void VertexArrayGL::computeStreamingAttributeSizes(const gl::AttributesMask &activeAttributesMask, GLsizei instanceCount, const gl::IndexRange &indexRange, size_t *outStreamingDataSize, size_t *outMaxAttributeDataSize) const { *outStreamingDataSize = 0; *outMaxAttributeDataSize = 0; ASSERT(mAttributesNeedStreaming.any()); const auto &attribs = mData.getVertexAttributes(); for (unsigned int idx : angle::IterateBitSet(mAttributesNeedStreaming & activeAttributesMask)) { const auto &attrib = attribs[idx]; ASSERT(AttributeNeedsStreaming(attrib)); // If streaming is going to be required, compute the size of the required buffer // and how much slack space at the beginning of the buffer will be required by determining // the attribute with the largest data size. size_t typeSize = ComputeVertexAttributeTypeSize(attrib); *outStreamingDataSize += typeSize * ComputeVertexAttributeElementCount( attrib, indexRange.vertexCount(), instanceCount); *outMaxAttributeDataSize = std::max(*outMaxAttributeDataSize, typeSize); } }
gl::Error VertexDataManager::reserveSpaceForAttrib(const TranslatedAttribute &translatedAttrib, GLsizei count, GLsizei instances) const { const gl::VertexAttribute &attrib = *translatedAttrib.attribute; gl::Buffer *buffer = attrib.buffer.get(); BufferD3D *bufferImpl = buffer ? GetImplAs<BufferD3D>(buffer) : NULL; StaticVertexBufferInterface *staticBuffer = bufferImpl ? bufferImpl->getStaticVertexBuffer(attrib) : NULL; VertexBufferInterface *vertexBuffer = staticBuffer ? staticBuffer : static_cast<VertexBufferInterface*>(mStreamingBuffer); if (!vertexBuffer->directStoragePossible(attrib, translatedAttrib.currentValueType)) { if (staticBuffer) { if (staticBuffer->getBufferSize() == 0) { int totalCount = ElementsInBuffer(attrib, static_cast<unsigned int>(bufferImpl->getSize())); gl::Error error = staticBuffer->reserveVertexSpace(attrib, totalCount, 0); if (error.isError()) { return error; } } } else { size_t totalCount = ComputeVertexAttributeElementCount(attrib, count, instances); ASSERT(!bufferImpl || ElementsInBuffer(attrib, static_cast<unsigned int>(bufferImpl->getSize())) >= static_cast<int>(totalCount)); gl::Error error = mStreamingBuffer->reserveVertexSpace( attrib, static_cast<GLsizei>(totalCount), instances); if (error.isError()) { return error; } } } return gl::Error(GL_NO_ERROR); }
gl::Error VertexDataManager::reserveSpaceForAttrib(const TranslatedAttribute &translatedAttrib, GLsizei count, GLsizei instances) const { const gl::VertexAttribute &attrib = *translatedAttrib.attribute; ASSERT(!DirectStoragePossible(attrib)); gl::Buffer *buffer = attrib.buffer.get(); BufferD3D *bufferD3D = buffer ? GetImplAs<BufferD3D>(buffer) : nullptr; ASSERT(!bufferD3D || bufferD3D->getStaticVertexBuffer(attrib) == nullptr); UNUSED_ASSERTION_VARIABLE(bufferD3D); size_t totalCount = ComputeVertexAttributeElementCount(attrib, count, instances); ASSERT(!bufferD3D || ElementsInBuffer(attrib, static_cast<unsigned int>(bufferD3D->getSize())) >= static_cast<int>(totalCount)); return mStreamingBuffer->reserveVertexSpace(attrib, static_cast<GLsizei>(totalCount), instances); }
gl::Error VertexDataManager::storeAttribute(TranslatedAttribute *translated, GLint start, GLsizei count, GLsizei instances) { const gl::VertexAttribute &attrib = *translated->attribute; gl::Buffer *buffer = attrib.buffer.get(); ASSERT(buffer || attrib.pointer); ASSERT(attrib.enabled); BufferD3D *storage = buffer ? GetImplAs<BufferD3D>(buffer) : NULL; StaticVertexBufferInterface *staticBuffer = storage ? storage->getStaticVertexBuffer(attrib) : NULL; VertexBufferInterface *vertexBuffer = staticBuffer ? staticBuffer : static_cast<VertexBufferInterface*>(mStreamingBuffer); bool directStorage = vertexBuffer->directStoragePossible(attrib, translated->currentValueType); // Instanced vertices do not apply the 'start' offset GLint firstVertexIndex = (instances > 0 && attrib.divisor > 0 ? 0 : start); translated->vertexBuffer = vertexBuffer->getVertexBuffer(); if (directStorage) { translated->storage = storage; translated->serial = storage->getSerial(); translated->stride = static_cast<unsigned int>(ComputeVertexAttributeStride(attrib)); translated->offset = static_cast<unsigned int>(attrib.offset + translated->stride * firstVertexIndex); return gl::Error(GL_NO_ERROR); } // Compute source data pointer const uint8_t *sourceData = nullptr; if (buffer) { gl::Error error = storage->getData(&sourceData); if (error.isError()) { return error; } sourceData += static_cast<int>(attrib.offset); } else { sourceData = static_cast<const uint8_t*>(attrib.pointer); } unsigned int streamOffset = 0; unsigned int outputElementSize = 0; if (staticBuffer) { gl::Error error = staticBuffer->getVertexBuffer()->getSpaceRequired(attrib, 1, 0, &outputElementSize); if (error.isError()) { return error; } if (!staticBuffer->lookupAttribute(attrib, &streamOffset)) { // Convert the entire buffer int totalCount = ElementsInBuffer(attrib, static_cast<unsigned int>(storage->getSize())); int startIndex = static_cast<int>(attrib.offset) / static_cast<int>(ComputeVertexAttributeStride(attrib)); error = staticBuffer->storeVertexAttributes(attrib, translated->currentValueType, -startIndex, totalCount, 0, &streamOffset, sourceData); if (error.isError()) { return error; } } unsigned int firstElementOffset = (static_cast<unsigned int>(attrib.offset) / static_cast<unsigned int>(ComputeVertexAttributeStride(attrib))) * outputElementSize; unsigned int startOffset = (instances == 0 || attrib.divisor == 0) ? firstVertexIndex * outputElementSize : 0; if (streamOffset + firstElementOffset + startOffset < streamOffset) { return gl::Error(GL_OUT_OF_MEMORY); } streamOffset += firstElementOffset + startOffset; } else { size_t totalCount = ComputeVertexAttributeElementCount(attrib, count, instances); gl::Error error = mStreamingBuffer->getVertexBuffer()->getSpaceRequired(attrib, 1, 0, &outputElementSize); if (error.isError()) { return error; } error = mStreamingBuffer->storeVertexAttributes( attrib, translated->currentValueType, firstVertexIndex, static_cast<GLsizei>(totalCount), instances, &streamOffset, sourceData); if (error.isError()) { return error; } } translated->storage = nullptr; translated->serial = vertexBuffer->getSerial(); translated->stride = outputElementSize; translated->offset = streamOffset; return gl::Error(GL_NO_ERROR); }
gl::Error VertexDataManager::storeDynamicAttrib(TranslatedAttribute *translated, GLint start, GLsizei count, GLsizei instances) { const gl::VertexAttribute &attrib = *translated->attribute; gl::Buffer *buffer = attrib.buffer.get(); ASSERT(buffer || attrib.pointer); ASSERT(attrib.enabled); BufferD3D *storage = buffer ? GetImplAs<BufferD3D>(buffer) : nullptr; // Instanced vertices do not apply the 'start' offset GLint firstVertexIndex = (attrib.divisor > 0 ? 0 : start); // Compute source data pointer const uint8_t *sourceData = nullptr; if (buffer) { gl::Error error = storage->getData(&sourceData); if (error.isError()) { return error; } sourceData += static_cast<int>(attrib.offset); } else { sourceData = static_cast<const uint8_t*>(attrib.pointer); } unsigned int streamOffset = 0; auto errorOrOutputElementSize = mFactory->getVertexSpaceRequired(attrib, 1, 0); if (errorOrOutputElementSize.isError()) { return errorOrOutputElementSize.getError(); } translated->storage = nullptr; translated->stride = errorOrOutputElementSize.getResult(); size_t totalCount = ComputeVertexAttributeElementCount(attrib, count, instances); gl::Error error = mStreamingBuffer->storeDynamicAttribute( attrib, translated->currentValueType, firstVertexIndex, static_cast<GLsizei>(totalCount), instances, &streamOffset, sourceData); if (error.isError()) { return error; } VertexBuffer *vertexBuffer = mStreamingBuffer->getVertexBuffer(); translated->vertexBuffer.set(vertexBuffer); translated->serial = vertexBuffer->getSerial(); translated->offset = streamOffset; return gl::Error(GL_NO_ERROR); }
gl::Error VertexArrayGL::streamAttributes(const gl::AttributesMask &activeAttributesMask, GLsizei instanceCount, const gl::IndexRange &indexRange) const { // Sync the vertex attribute state and track what data needs to be streamed size_t streamingDataSize = 0; size_t maxAttributeDataSize = 0; computeStreamingAttributeSizes(activeAttributesMask, instanceCount, indexRange, &streamingDataSize, &maxAttributeDataSize); if (streamingDataSize == 0) { return gl::Error(GL_NO_ERROR); } if (mStreamingArrayBuffer == 0) { mFunctions->genBuffers(1, &mStreamingArrayBuffer); mStreamingArrayBufferSize = 0; } // If first is greater than zero, a slack space needs to be left at the beginning of the buffer so that // the same 'first' argument can be passed into the draw call. const size_t bufferEmptySpace = maxAttributeDataSize * indexRange.start; const size_t requiredBufferSize = streamingDataSize + bufferEmptySpace; mStateManager->bindBuffer(GL_ARRAY_BUFFER, mStreamingArrayBuffer); if (requiredBufferSize > mStreamingArrayBufferSize) { mFunctions->bufferData(GL_ARRAY_BUFFER, requiredBufferSize, nullptr, GL_DYNAMIC_DRAW); mStreamingArrayBufferSize = requiredBufferSize; } // Unmapping a buffer can return GL_FALSE to indicate that the system has corrupted the data // somehow (such as by a screen change), retry writing the data a few times and return OUT_OF_MEMORY // if that fails. GLboolean unmapResult = GL_FALSE; size_t unmapRetryAttempts = 5; while (unmapResult != GL_TRUE && --unmapRetryAttempts > 0) { uint8_t *bufferPointer = reinterpret_cast<uint8_t*>(mFunctions->mapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY)); size_t curBufferOffset = bufferEmptySpace; const auto &attribs = mData.getVertexAttributes(); for (unsigned int idx : angle::IterateBitSet(mAttributesNeedStreaming & activeAttributesMask)) { const auto &attrib = attribs[idx]; ASSERT(AttributeNeedsStreaming(attrib)); const size_t streamedVertexCount = ComputeVertexAttributeElementCount(attrib, indexRange.vertexCount(), instanceCount); const size_t sourceStride = ComputeVertexAttributeStride(attrib); const size_t destStride = ComputeVertexAttributeTypeSize(attrib); const uint8_t *inputPointer = reinterpret_cast<const uint8_t *>(attrib.pointer); // Pack the data when copying it, user could have supplied a very large stride that // would cause the buffer to be much larger than needed. if (destStride == sourceStride) { // Can copy in one go, the data is packed memcpy(bufferPointer + curBufferOffset, inputPointer + (sourceStride * indexRange.start), destStride * streamedVertexCount); } else { // Copy each vertex individually for (size_t vertexIdx = 0; vertexIdx < streamedVertexCount; vertexIdx++) { uint8_t *out = bufferPointer + curBufferOffset + (destStride * vertexIdx); const uint8_t *in = inputPointer + sourceStride * (vertexIdx + indexRange.start); memcpy(out, in, destStride); } } // Compute where the 0-index vertex would be. const size_t vertexStartOffset = curBufferOffset - (indexRange.start * destStride); if (attrib.pureInteger) { ASSERT(!attrib.normalized); mFunctions->vertexAttribIPointer( idx, attrib.size, attrib.type, static_cast<GLsizei>(destStride), reinterpret_cast<const GLvoid *>(vertexStartOffset)); } else { mFunctions->vertexAttribPointer( idx, attrib.size, attrib.type, attrib.normalized, static_cast<GLsizei>(destStride), reinterpret_cast<const GLvoid *>(vertexStartOffset)); } curBufferOffset += destStride * streamedVertexCount; // Mark the applied attribute as dirty by setting an invalid size so that if it doesn't // need to be streamed later, there is no chance that the caching will skip it. mAppliedAttributes[idx].size = static_cast<GLuint>(-1); } unmapResult = mFunctions->unmapBuffer(GL_ARRAY_BUFFER); } if (unmapResult != GL_TRUE) { return Error(GL_OUT_OF_MEMORY, "Failed to unmap the client data streaming buffer."); } return Error(GL_NO_ERROR); }