blob: 5056bcb8c78061f9b3c0609950f4c4eb4f2c9e5b [file] [log] [blame]
shannon.woods@transgaming.combdf2d802013-02-28 23:16:20 +00001#include "precompiled.h"
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +00002//
daniel@transgaming.comf6549452012-01-27 15:39:08 +00003// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +00004// Use of this source code is governed by a BSD-style license that can be
5// found in the LICENSE file.
6//
7
daniel@transgaming.com8fd34bd2011-02-18 02:52:14 +00008// IndexDataManager.cpp: Defines the IndexDataManager, a class that
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +00009// runs the Buffer translation process for index buffers.
10
daniel@transgaming.com50aadb02012-11-28 21:06:11 +000011#include "libGLESv2/renderer/IndexDataManager.h"
shannon.woods@transgaming.comd2811d62013-02-28 23:11:19 +000012#include "libGLESv2/renderer/BufferStorage.h"
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000013
daniel@transgaming.combbf56f72010-04-20 18:52:13 +000014#include "libGLESv2/Buffer.h"
daniel@transgaming.com37b141e2011-01-08 05:46:13 +000015#include "libGLESv2/main.h"
Geoff Langf23eb282013-07-22 10:52:19 -040016#include "libGLESv2/formatutils.h"
shannon.woods@transgaming.com486d9e92013-02-28 23:15:41 +000017#include "libGLESv2/renderer/IndexBuffer.h"
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000018
daniel@transgaming.com31240482012-11-28 21:06:41 +000019namespace rx
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000020{
21
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000022IndexDataManager::IndexDataManager(Renderer *renderer) : mRenderer(renderer)
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000023{
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000024 mStreamingBufferShort = new StreamingIndexBufferInterface(mRenderer);
25 if (!mStreamingBufferShort->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_SHORT))
daniel@transgaming.com3e4c6002010-05-05 18:50:13 +000026 {
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000027 delete mStreamingBufferShort;
28 mStreamingBufferShort = NULL;
daniel@transgaming.com3e4c6002010-05-05 18:50:13 +000029 }
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000030
31 mStreamingBufferInt = new StreamingIndexBufferInterface(mRenderer);
32 if (!mStreamingBufferInt->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT))
daniel@transgaming.com3e4c6002010-05-05 18:50:13 +000033 {
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000034 delete mStreamingBufferInt;
daniel@transgaming.com83921382011-01-08 05:46:00 +000035 mStreamingBufferInt = NULL;
daniel@transgaming.com3e4c6002010-05-05 18:50:13 +000036 }
daniel@transgaming.com72b9e182011-04-13 14:58:33 +000037
38 if (!mStreamingBufferShort)
39 {
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000040 // Make sure both buffers are deleted.
41 delete mStreamingBufferInt;
42 mStreamingBufferInt = NULL;
43
daniel@transgaming.com72b9e182011-04-13 14:58:33 +000044 ERR("Failed to allocate the streaming index buffer(s).");
45 }
daniel@transgaming.comf6549452012-01-27 15:39:08 +000046
47 mCountingBuffer = NULL;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000048}
49
50IndexDataManager::~IndexDataManager()
51{
daniel@transgaming.com83921382011-01-08 05:46:00 +000052 delete mStreamingBufferShort;
53 delete mStreamingBufferInt;
daniel@transgaming.comf6549452012-01-27 15:39:08 +000054 delete mCountingBuffer;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000055}
56
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000057static void convertIndices(GLenum type, const void *input, GLsizei count, void *output)
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000058{
daniel@transgaming.com83921382011-01-08 05:46:00 +000059 if (type == GL_UNSIGNED_BYTE)
60 {
61 const GLubyte *in = static_cast<const GLubyte*>(input);
62 GLushort *out = static_cast<GLushort*>(output);
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000063
daniel@transgaming.com83921382011-01-08 05:46:00 +000064 for (GLsizei i = 0; i < count; i++)
65 {
66 out[i] = in[i];
67 }
68 }
69 else if (type == GL_UNSIGNED_INT)
70 {
71 memcpy(output, input, count * sizeof(GLuint));
72 }
73 else if (type == GL_UNSIGNED_SHORT)
74 {
75 memcpy(output, input, count * sizeof(GLushort));
76 }
77 else UNREACHABLE();
78}
79
80template <class IndexType>
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000081static void computeRange(const IndexType *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex)
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000082{
daniel@transgaming.com83921382011-01-08 05:46:00 +000083 *minIndex = indices[0];
84 *maxIndex = indices[0];
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000085
86 for (GLsizei i = 0; i < count; i++)
87 {
daniel@transgaming.com83921382011-01-08 05:46:00 +000088 if (*minIndex > indices[i]) *minIndex = indices[i];
89 if (*maxIndex < indices[i]) *maxIndex = indices[i];
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000090 }
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000091}
92
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +000093static void computeRange(GLenum type, const GLvoid *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex)
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +000094{
daniel@transgaming.com83921382011-01-08 05:46:00 +000095 if (type == GL_UNSIGNED_BYTE)
daniel@transgaming.com41d8dd82010-05-12 03:45:03 +000096 {
daniel@transgaming.com83921382011-01-08 05:46:00 +000097 computeRange(static_cast<const GLubyte*>(indices), count, minIndex, maxIndex);
98 }
99 else if (type == GL_UNSIGNED_INT)
100 {
101 computeRange(static_cast<const GLuint*>(indices), count, minIndex, maxIndex);
102 }
103 else if (type == GL_UNSIGNED_SHORT)
104 {
105 computeRange(static_cast<const GLushort*>(indices), count, minIndex, maxIndex);
106 }
107 else UNREACHABLE();
108}
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000109
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000110GLenum IndexDataManager::prepareIndexData(GLenum type, GLsizei count, gl::Buffer *buffer, const GLvoid *indices, TranslatedIndexData *translated)
daniel@transgaming.com83921382011-01-08 05:46:00 +0000111{
daniel@transgaming.com72b9e182011-04-13 14:58:33 +0000112 if (!mStreamingBufferShort)
113 {
114 return GL_OUT_OF_MEMORY;
115 }
116
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000117 GLenum destinationIndexType = (type == GL_UNSIGNED_INT) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
daniel@transgaming.com83921382011-01-08 05:46:00 +0000118 intptr_t offset = reinterpret_cast<intptr_t>(indices);
119 bool alignedOffset = false;
120
shannon.woods@transgaming.coma1229a32013-02-28 23:08:40 +0000121 BufferStorage *storage = NULL;
122
daniel@transgaming.com83921382011-01-08 05:46:00 +0000123 if (buffer != NULL)
124 {
shannon.woods@transgaming.coma1229a32013-02-28 23:08:40 +0000125 storage = buffer->getStorage();
shannon.woods@transgaming.com76655412013-02-28 23:08:09 +0000126
daniel@transgaming.com83921382011-01-08 05:46:00 +0000127 switch (type)
128 {
129 case GL_UNSIGNED_BYTE: alignedOffset = (offset % sizeof(GLubyte) == 0); break;
130 case GL_UNSIGNED_SHORT: alignedOffset = (offset % sizeof(GLushort) == 0); break;
131 case GL_UNSIGNED_INT: alignedOffset = (offset % sizeof(GLuint) == 0); break;
132 default: UNREACHABLE(); alignedOffset = false;
133 }
134
Geoff Langf23eb282013-07-22 10:52:19 -0400135 if (gl::GetTypeBytes(type) * count + offset > storage->getSize())
daniel@transgaming.com41d8dd82010-05-12 03:45:03 +0000136 {
137 return GL_INVALID_OPERATION;
138 }
139
shannon.woods@transgaming.com76655412013-02-28 23:08:09 +0000140 indices = static_cast<const GLubyte*>(storage->getData()) + offset;
daniel@transgaming.com41d8dd82010-05-12 03:45:03 +0000141 }
142
daniel@transgaming.com50cc7252012-12-20 21:09:23 +0000143 StreamingIndexBufferInterface *streamingBuffer = (type == GL_UNSIGNED_INT) ? mStreamingBufferInt : mStreamingBufferShort;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000144
daniel@transgaming.com50cc7252012-12-20 21:09:23 +0000145 StaticIndexBufferInterface *staticBuffer = buffer ? buffer->getStaticIndexBuffer() : NULL;
146 IndexBufferInterface *indexBuffer = streamingBuffer;
shannon.woods@transgaming.coma1229a32013-02-28 23:08:40 +0000147 bool directStorage = alignedOffset && storage && storage->supportsDirectBinding() &&
148 destinationIndexType == type;
daniel@transgaming.com83921382011-01-08 05:46:00 +0000149 UINT streamOffset = 0;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000150
shannon.woods@transgaming.coma1229a32013-02-28 23:08:40 +0000151 if (directStorage)
152 {
153 indexBuffer = streamingBuffer;
154 streamOffset = offset;
Geoff Langf23eb282013-07-22 10:52:19 -0400155
156 if (!buffer->getIndexRangeCache()->findRange(type, offset, count, &translated->minIndex,
157 &translated->maxIndex, NULL))
158 {
159 computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex);
160 buffer->getIndexRangeCache()->addRange(type, offset, count, translated->minIndex,
161 translated->maxIndex, offset);
162 }
shannon.woods@transgaming.coma1229a32013-02-28 23:08:40 +0000163 }
shannon.woods@transgaming.com38e87882013-02-28 23:18:32 +0000164 else if (staticBuffer && staticBuffer->getBufferSize() != 0 && staticBuffer->getIndexType() == type && alignedOffset)
apatrick@chromium.orgf99fbb72010-11-16 01:57:05 +0000165 {
daniel@transgaming.com83921382011-01-08 05:46:00 +0000166 indexBuffer = staticBuffer;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000167
Geoff Langf23eb282013-07-22 10:52:19 -0400168 if (!staticBuffer->getIndexRangeCache()->findRange(type, offset, count, &translated->minIndex,
169 &translated->maxIndex, &streamOffset))
daniel@transgaming.com3e4c6002010-05-05 18:50:13 +0000170 {
Geoff Langf23eb282013-07-22 10:52:19 -0400171 streamOffset = (offset / gl::GetTypeBytes(type)) * gl::GetTypeBytes(destinationIndexType);
daniel@transgaming.com83921382011-01-08 05:46:00 +0000172 computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex);
Geoff Langf23eb282013-07-22 10:52:19 -0400173 staticBuffer->getIndexRangeCache()->addRange(type, offset, count, translated->minIndex,
174 translated->maxIndex, streamOffset);
daniel@transgaming.com3e4c6002010-05-05 18:50:13 +0000175 }
176 }
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000177 else
178 {
daniel@transgaming.com83921382011-01-08 05:46:00 +0000179 int convertCount = count;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000180
daniel@transgaming.com83921382011-01-08 05:46:00 +0000181 if (staticBuffer)
182 {
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000183 if (staticBuffer->getBufferSize() == 0 && alignedOffset)
daniel@transgaming.com83921382011-01-08 05:46:00 +0000184 {
185 indexBuffer = staticBuffer;
Geoff Langf23eb282013-07-22 10:52:19 -0400186 convertCount = storage->getSize() / gl::GetTypeBytes(type);
daniel@transgaming.com83921382011-01-08 05:46:00 +0000187 }
188 else
189 {
190 buffer->invalidateStaticData();
191 staticBuffer = NULL;
192 }
193 }
194
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000195 if (!indexBuffer)
daniel@transgaming.com5ee2ad02011-01-08 05:46:20 +0000196 {
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000197 ERR("No valid index buffer.");
198 return GL_INVALID_OPERATION;
daniel@transgaming.com5ee2ad02011-01-08 05:46:20 +0000199 }
daniel@transgaming.com50aadb02012-11-28 21:06:11 +0000200
Geoff Langf23eb282013-07-22 10:52:19 -0400201 unsigned int bufferSizeRequired = convertCount * gl::GetTypeBytes(destinationIndexType);
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000202 indexBuffer->reserveBufferSpace(bufferSizeRequired, type);
203
204 void* output = NULL;
205 streamOffset = indexBuffer->mapBuffer(bufferSizeRequired, &output);
206 if (streamOffset == -1 || output == NULL)
daniel@transgaming.com83921382011-01-08 05:46:00 +0000207 {
208 ERR("Failed to map index buffer.");
209 return GL_OUT_OF_MEMORY;
210 }
211
shannon.woods@transgaming.com76655412013-02-28 23:08:09 +0000212 convertIndices(type, staticBuffer ? storage->getData() : indices, convertCount, output);
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000213
214 if (!indexBuffer->unmapBuffer())
215 {
216 ERR("Failed to unmap index buffer.");
217 return GL_OUT_OF_MEMORY;
218 }
daniel@transgaming.com83921382011-01-08 05:46:00 +0000219
220 computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex);
221
222 if (staticBuffer)
223 {
Geoff Langf23eb282013-07-22 10:52:19 -0400224 streamOffset = (offset / gl::GetTypeBytes(type)) * gl::GetTypeBytes(destinationIndexType);
225 staticBuffer->getIndexRangeCache()->addRange(type, offset, count, translated->minIndex,
226 translated->maxIndex, streamOffset);
daniel@transgaming.com83921382011-01-08 05:46:00 +0000227 }
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000228 }
229
shannon.woods@transgaming.coma1229a32013-02-28 23:08:40 +0000230 translated->storage = directStorage ? storage : NULL;
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000231 translated->indexBuffer = indexBuffer->getIndexBuffer();
shannon.woods@transgaming.coma1229a32013-02-28 23:08:40 +0000232 translated->serial = directStorage ? storage->getSerial() : indexBuffer->getSerial();
Geoff Langf23eb282013-07-22 10:52:19 -0400233 translated->startIndex = streamOffset / gl::GetTypeBytes(destinationIndexType);
daniel@transgaming.com22ada2c2013-01-11 04:07:12 +0000234 translated->startOffset = streamOffset;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000235
daniel@transgaming.com78624ca2011-04-22 04:17:57 +0000236 if (buffer)
237 {
Geoff Langf23eb282013-07-22 10:52:19 -0400238 buffer->promoteStaticUsage(count * gl::GetTypeBytes(type));
daniel@transgaming.com78624ca2011-04-22 04:17:57 +0000239 }
240
daniel@transgaming.com41d8dd82010-05-12 03:45:03 +0000241 return GL_NO_ERROR;
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000242}
243
daniel@transgaming.com50cc7252012-12-20 21:09:23 +0000244StaticIndexBufferInterface *IndexDataManager::getCountingIndices(GLsizei count)
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000245{
daniel@transgaming.com0f328a72012-03-05 15:07:50 +0000246 if (count <= 65536) // 16-bit indices
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000247 {
248 const unsigned int spaceNeeded = count * sizeof(unsigned short);
249
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000250 if (!mCountingBuffer || mCountingBuffer->getBufferSize() < spaceNeeded)
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000251 {
252 delete mCountingBuffer;
daniel@transgaming.com50cc7252012-12-20 21:09:23 +0000253 mCountingBuffer = new StaticIndexBufferInterface(mRenderer);
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000254 mCountingBuffer->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_SHORT);
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000255
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000256 void* mappedMemory = NULL;
257 if (mCountingBuffer->mapBuffer(spaceNeeded, &mappedMemory) == -1 || mappedMemory == NULL)
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000258 {
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000259 ERR("Failed to map counting buffer.");
260 return NULL;
261 }
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000262
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000263 unsigned short *data = reinterpret_cast<unsigned short*>(mappedMemory);
264 for(int i = 0; i < count; i++)
265 {
266 data[i] = i;
267 }
268
269 if (!mCountingBuffer->unmapBuffer())
270 {
271 ERR("Failed to unmap counting buffer.");
272 return NULL;
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000273 }
274 }
275 }
276 else if (mStreamingBufferInt) // 32-bit indices supported
277 {
278 const unsigned int spaceNeeded = count * sizeof(unsigned int);
279
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000280 if (!mCountingBuffer || mCountingBuffer->getBufferSize() < spaceNeeded)
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000281 {
282 delete mCountingBuffer;
daniel@transgaming.com50cc7252012-12-20 21:09:23 +0000283 mCountingBuffer = new StaticIndexBufferInterface(mRenderer);
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000284 mCountingBuffer->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT);
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000285
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000286 void* mappedMemory = NULL;
287 if (mCountingBuffer->mapBuffer(spaceNeeded, &mappedMemory) == -1 || mappedMemory == NULL)
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000288 {
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000289 ERR("Failed to map counting buffer.");
290 return NULL;
291 }
daniel@transgaming.com50aadb02012-11-28 21:06:11 +0000292
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000293 unsigned int *data = reinterpret_cast<unsigned int*>(mappedMemory);
294 for(int i = 0; i < count; i++)
295 {
296 data[i] = i;
297 }
298
299 if (!mCountingBuffer->unmapBuffer())
300 {
301 ERR("Failed to unmap counting buffer.");
302 return NULL;
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000303 }
304 }
305 }
daniel@transgaming.com1e3a8042012-12-20 21:09:55 +0000306 else
307 {
308 return NULL;
309 }
daniel@transgaming.com50aadb02012-11-28 21:06:11 +0000310
daniel@transgaming.comf6549452012-01-27 15:39:08 +0000311 return mCountingBuffer;
312}
313
daniel@transgaming.comf8b58a02010-03-26 04:08:45 +0000314}