gl::ErrorOrResult<const std::vector<ID3D11Buffer *> *> TransformFeedback11::getSOBuffers( const gl::Context *context) { for (size_t bindingIdx = 0; bindingIdx < mBuffers.size(); bindingIdx++) { const auto &binding = mState.getIndexedBuffer(bindingIdx); if (binding.get() != nullptr) { Buffer11 *storage = GetImplAs<Buffer11>(binding.get()); ANGLE_TRY_RESULT(storage->getBuffer(context, BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK), mBuffers[bindingIdx]); } } return &mBuffers; }
gl::Error Framebuffer11::readPixels(const gl::Rectangle &area, GLenum format, GLenum type, size_t outputPitch, const gl::PixelPackState &pack, uint8_t *pixels) const { ID3D11Texture2D *colorBufferTexture = NULL; unsigned int subresourceIndex = 0; const gl::FramebufferAttachment *colorbuffer = getReadAttachment(); ASSERT(colorbuffer); gl::Error error = getRenderTargetResource(colorbuffer, &subresourceIndex, &colorBufferTexture); if (error.isError()) { return error; } gl::Buffer *packBuffer = pack.pixelBuffer.get(); if (packBuffer != NULL) { Buffer11 *packBufferStorage = Buffer11::makeBuffer11(packBuffer->getImplementation()); PackPixelsParams packParams(area, format, type, outputPitch, pack, reinterpret_cast<ptrdiff_t>(pixels)); error = packBufferStorage->packPixels(colorBufferTexture, subresourceIndex, packParams); if (error.isError()) { SafeRelease(colorBufferTexture); return error; } packBuffer->getIndexRangeCache()->clear(); } else { error = mRenderer->readTextureData(colorBufferTexture, subresourceIndex, area, format, type, outputPitch, pack, pixels); if (error.isError()) { SafeRelease(colorBufferTexture); return error; } } SafeRelease(colorBufferTexture); return gl::Error(GL_NO_ERROR); }
gl::Error Framebuffer11::readPixelsImpl(const gl::Rectangle &area, GLenum format, GLenum type, size_t outputPitch, const gl::PixelPackState &pack, uint8_t *pixels) const { const gl::FramebufferAttachment *readAttachment = mState.getReadAttachment(); ASSERT(readAttachment); gl::Buffer *packBuffer = pack.pixelBuffer.get(); if (packBuffer != nullptr) { Buffer11 *packBufferStorage = GetImplAs<Buffer11>(packBuffer); PackPixelsParams packParams(area, format, type, static_cast<GLuint>(outputPitch), pack, reinterpret_cast<ptrdiff_t>(pixels)); return packBufferStorage->packPixels(*readAttachment, packParams); } return mRenderer->readFromAttachment(*readAttachment, area, format, type, static_cast<GLuint>(outputPitch), pack, pixels); }
gl::Error InputLayoutCache::applyVertexBuffers( const std::vector<TranslatedAttribute> &unsortedAttributes, GLenum mode, gl::Program *program, TranslatedIndexData *indexInfo, GLsizei numIndicesPerInstance) { ASSERT(mDevice && mDeviceContext); ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); bool programUsesInstancedPointSprites = programD3D->usesPointSize() && programD3D->usesInstancedPointSpriteEmulation(); bool instancedPointSpritesActive = programUsesInstancedPointSprites && (mode == GL_POINTS); SortedIndexArray sortedSemanticIndices; mSortedAttributes.fill(nullptr); mUnsortedAttributesCount = unsortedAttributes.size(); programD3D->sortAttributesByLayout(unsortedAttributes, sortedSemanticIndices.data(), mSortedAttributes.data()); // If we are using FL 9_3, make sure the first attribute is not instanced if (mFeatureLevel <= D3D_FEATURE_LEVEL_9_3 && !unsortedAttributes.empty()) { if (mSortedAttributes[0]->divisor > 0) { Optional<size_t> firstNonInstancedIndex = FindFirstNonInstanced(mSortedAttributes, unsortedAttributes.size()); if (firstNonInstancedIndex.valid()) { size_t index = firstNonInstancedIndex.value(); std::swap(mSortedAttributes[0], mSortedAttributes[index]); std::swap(sortedSemanticIndices[0], sortedSemanticIndices[index]); } } } gl::Error error = updateInputLayout(program, mode, mSortedAttributes, sortedSemanticIndices, unsortedAttributes.size(), numIndicesPerInstance); if (error.isError()) { return error; } bool dirtyBuffers = false; size_t minDiff = gl::MAX_VERTEX_ATTRIBS; size_t maxDiff = 0; // Note that if we use instance emulation, we reserve the first buffer slot. size_t reservedBuffers = GetReservedBufferCount(programUsesInstancedPointSprites); for (size_t attribIndex = 0; attribIndex < (gl::MAX_VERTEX_ATTRIBS - reservedBuffers); ++attribIndex) { ID3D11Buffer *buffer = NULL; UINT vertexStride = 0; UINT vertexOffset = 0; const auto &attrib = *mSortedAttributes[attribIndex]; if (attribIndex < unsortedAttributes.size() && attrib.active) { VertexBuffer11 *vertexBuffer = GetAs<VertexBuffer11>(attrib.vertexBuffer); Buffer11 *bufferStorage = attrib.storage ? GetAs<Buffer11>(attrib.storage) : nullptr; // If indexed pointsprite emulation is active, then we need to take a less efficent code path. // Emulated indexed pointsprite rendering requires that the vertex buffers match exactly to // the indices passed by the caller. This could expand or shrink the vertex buffer depending // on the number of points indicated by the index list or how many duplicates are found on the index list. if (bufferStorage == nullptr) { buffer = vertexBuffer->getBuffer(); } else if (instancedPointSpritesActive && (indexInfo != nullptr)) { if (indexInfo->srcIndexData.srcBuffer != nullptr) { const uint8_t *bufferData = nullptr; error = indexInfo->srcIndexData.srcBuffer->getData(&bufferData); if (error.isError()) { return error; } ASSERT(bufferData != nullptr); ptrdiff_t offset = reinterpret_cast<ptrdiff_t>(indexInfo->srcIndexData.srcIndices); indexInfo->srcIndexData.srcBuffer = nullptr; indexInfo->srcIndexData.srcIndices = bufferData + offset; } buffer = bufferStorage->getEmulatedIndexedBuffer(&indexInfo->srcIndexData, &attrib); } else { buffer = bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK); } vertexStride = attrib.stride; vertexOffset = attrib.offset; } size_t bufferIndex = reservedBuffers + attribIndex; if (buffer != mCurrentBuffers[bufferIndex] || vertexStride != mCurrentVertexStrides[bufferIndex] || vertexOffset != mCurrentVertexOffsets[bufferIndex]) { dirtyBuffers = true; minDiff = std::min(minDiff, bufferIndex); maxDiff = std::max(maxDiff, bufferIndex); mCurrentBuffers[bufferIndex] = buffer; mCurrentVertexStrides[bufferIndex] = vertexStride; mCurrentVertexOffsets[bufferIndex] = vertexOffset; } } // Instanced PointSprite emulation requires two additional ID3D11Buffers. A vertex buffer needs // to be created and added to the list of current buffers, strides and offsets collections. // This buffer contains the vertices for a single PointSprite quad. // An index buffer also needs to be created and applied because rendering instanced data on // D3D11 FL9_3 requires DrawIndexedInstanced() to be used. Shaders that contain gl_PointSize and // used without the GL_POINTS rendering mode require a vertex buffer because some drivers cannot // handle missing vertex data and will TDR the system. if (programUsesInstancedPointSprites) { HRESULT result = S_OK; const UINT pointSpriteVertexStride = sizeof(float) * 5; if (!mPointSpriteVertexBuffer) { static const float pointSpriteVertices[] = { // Position // TexCoord -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, }; D3D11_SUBRESOURCE_DATA vertexBufferData = { pointSpriteVertices, 0, 0 }; D3D11_BUFFER_DESC vertexBufferDesc; vertexBufferDesc.ByteWidth = sizeof(pointSpriteVertices); vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE; vertexBufferDesc.CPUAccessFlags = 0; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; result = mDevice->CreateBuffer(&vertexBufferDesc, &vertexBufferData, &mPointSpriteVertexBuffer); if (FAILED(result)) { return gl::Error(GL_OUT_OF_MEMORY, "Failed to create instanced pointsprite emulation vertex buffer, HRESULT: 0x%08x", result); } } mCurrentBuffers[0] = mPointSpriteVertexBuffer; // Set the stride to 0 if GL_POINTS mode is not being used to instruct the driver to avoid // indexing into the vertex buffer. mCurrentVertexStrides[0] = instancedPointSpritesActive ? pointSpriteVertexStride : 0; mCurrentVertexOffsets[0] = 0; // Update maxDiff to include the additional point sprite vertex buffer // to ensure that IASetVertexBuffers uses the correct buffer count. minDiff = 0; maxDiff = std::max(maxDiff, static_cast<size_t>(0)); if (!mPointSpriteIndexBuffer) { // Create an index buffer and set it for pointsprite rendering static const unsigned short pointSpriteIndices[] = { 0, 1, 2, 3, 4, 5, }; D3D11_SUBRESOURCE_DATA indexBufferData = { pointSpriteIndices, 0, 0 }; D3D11_BUFFER_DESC indexBufferDesc; indexBufferDesc.ByteWidth = sizeof(pointSpriteIndices); indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE; indexBufferDesc.CPUAccessFlags = 0; indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; result = mDevice->CreateBuffer(&indexBufferDesc, &indexBufferData, &mPointSpriteIndexBuffer); if (FAILED(result)) { SafeRelease(mPointSpriteVertexBuffer); return gl::Error(GL_OUT_OF_MEMORY, "Failed to create instanced pointsprite emulation index buffer, HRESULT: 0x%08x", result); } } if (instancedPointSpritesActive) { // The index buffer is applied here because Instanced PointSprite emulation uses the a // non-indexed rendering path in ANGLE (DrawArrays). This means that applyIndexBuffer() // on the renderer will not be called and setting this buffer here ensures that the // rendering path will contain the correct index buffers. mDeviceContext->IASetIndexBuffer(mPointSpriteIndexBuffer, DXGI_FORMAT_R16_UINT, 0); } } if (dirtyBuffers) { ASSERT(minDiff <= maxDiff && maxDiff < gl::MAX_VERTEX_ATTRIBS); mDeviceContext->IASetVertexBuffers( static_cast<UINT>(minDiff), static_cast<UINT>(maxDiff - minDiff + 1), mCurrentBuffers + minDiff, mCurrentVertexStrides + minDiff, mCurrentVertexOffsets + minDiff); } return gl::Error(GL_NO_ERROR); }
gl::Error InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl::MAX_VERTEX_ATTRIBS], GLenum mode, gl::Program *program) { ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); int sortedSemanticIndices[gl::MAX_VERTEX_ATTRIBS]; programD3D->sortAttributesByLayout(attributes, sortedSemanticIndices); bool programUsesInstancedPointSprites = programD3D->usesPointSize() && programD3D->usesInstancedPointSpriteEmulation(); bool instancedPointSpritesActive = programUsesInstancedPointSprites && (mode == GL_POINTS); if (!mDevice || !mDeviceContext) { return gl::Error(GL_OUT_OF_MEMORY, "Internal input layout cache is not initialized."); } InputLayoutKey ilKey = { 0 }; static const char* semanticName = "TEXCOORD"; unsigned int firstIndexedElement = gl::MAX_VERTEX_ATTRIBS; unsigned int firstInstancedElement = gl::MAX_VERTEX_ATTRIBS; unsigned int nextAvailableInputSlot = 0; for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) { if (attributes[i].active) { D3D11_INPUT_CLASSIFICATION inputClass = attributes[i].divisor > 0 ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA; // If rendering points and instanced pointsprite emulation is being used, the inputClass is required to be configured as per instance data inputClass = instancedPointSpritesActive ? D3D11_INPUT_PER_INSTANCE_DATA : inputClass; gl::VertexFormat vertexFormat(*attributes[i].attribute, attributes[i].currentValueType); const d3d11::VertexFormat &vertexFormatInfo = d3d11::GetVertexFormatInfo(vertexFormat, mFeatureLevel); // Record the type of the associated vertex shader vector in our key // This will prevent mismatched vertex shaders from using the same input layout GLint attributeSize; program->getActiveAttribute(ilKey.elementCount, 0, NULL, &attributeSize, &ilKey.elements[ilKey.elementCount].glslElementType, NULL); ilKey.elements[ilKey.elementCount].desc.SemanticName = semanticName; ilKey.elements[ilKey.elementCount].desc.SemanticIndex = sortedSemanticIndices[i]; ilKey.elements[ilKey.elementCount].desc.Format = vertexFormatInfo.nativeFormat; ilKey.elements[ilKey.elementCount].desc.InputSlot = i; ilKey.elements[ilKey.elementCount].desc.AlignedByteOffset = 0; ilKey.elements[ilKey.elementCount].desc.InputSlotClass = inputClass; ilKey.elements[ilKey.elementCount].desc.InstanceDataStepRate = instancedPointSpritesActive ? 1 : attributes[i].divisor; if (inputClass == D3D11_INPUT_PER_VERTEX_DATA && firstIndexedElement == gl::MAX_VERTEX_ATTRIBS) { firstIndexedElement = ilKey.elementCount; } else if (inputClass == D3D11_INPUT_PER_INSTANCE_DATA && firstInstancedElement == gl::MAX_VERTEX_ATTRIBS) { firstInstancedElement = ilKey.elementCount; } ilKey.elementCount++; nextAvailableInputSlot = i + 1; } } // Instanced PointSprite emulation requires additional entries in the // inputlayout to support the vertices that make up the pointsprite quad. // We do this even if mode != GL_POINTS, since the shader signature has these inputs, and the input layout must match the shader if (programUsesInstancedPointSprites) { ilKey.elements[ilKey.elementCount].desc.SemanticName = "SPRITEPOSITION"; ilKey.elements[ilKey.elementCount].desc.SemanticIndex = 0; ilKey.elements[ilKey.elementCount].desc.Format = DXGI_FORMAT_R32G32B32_FLOAT; ilKey.elements[ilKey.elementCount].desc.InputSlot = nextAvailableInputSlot; ilKey.elements[ilKey.elementCount].desc.AlignedByteOffset = 0; ilKey.elements[ilKey.elementCount].desc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; ilKey.elements[ilKey.elementCount].desc.InstanceDataStepRate = 0; // The new elements are D3D11_INPUT_PER_VERTEX_DATA data so the indexed element // tracking must be applied. This ensures that the instancing specific // buffer swapping logic continues to work. if (firstIndexedElement == gl::MAX_VERTEX_ATTRIBS) { firstIndexedElement = ilKey.elementCount; } ilKey.elementCount++; ilKey.elements[ilKey.elementCount].desc.SemanticName = "SPRITETEXCOORD"; ilKey.elements[ilKey.elementCount].desc.SemanticIndex = 0; ilKey.elements[ilKey.elementCount].desc.Format = DXGI_FORMAT_R32G32_FLOAT; ilKey.elements[ilKey.elementCount].desc.InputSlot = nextAvailableInputSlot; ilKey.elements[ilKey.elementCount].desc.AlignedByteOffset = sizeof(float) * 3; ilKey.elements[ilKey.elementCount].desc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; ilKey.elements[ilKey.elementCount].desc.InstanceDataStepRate = 0; ilKey.elementCount++; } // On 9_3, we must ensure that slot 0 contains non-instanced data. // If slot 0 currently contains instanced data then we swap it with a non-instanced element. // Note that instancing is only available on 9_3 via ANGLE_instanced_arrays, since 9_3 doesn't support OpenGL ES 3.0. // As per the spec for ANGLE_instanced_arrays, not all attributes can be instanced simultaneously, so a non-instanced element must exist. ASSERT(!(mFeatureLevel <= D3D_FEATURE_LEVEL_9_3 && firstIndexedElement == gl::MAX_VERTEX_ATTRIBS)); bool moveFirstIndexedIntoSlotZero = mFeatureLevel <= D3D_FEATURE_LEVEL_9_3 && firstInstancedElement == 0 && firstIndexedElement != gl::MAX_VERTEX_ATTRIBS; if (moveFirstIndexedIntoSlotZero) { ilKey.elements[firstInstancedElement].desc.InputSlot = ilKey.elements[firstIndexedElement].desc.InputSlot; ilKey.elements[firstIndexedElement].desc.InputSlot = 0; // Instanced PointSprite emulation uses multiple layout entries across a single vertex buffer. // If an index swap is performed, we need to ensure that all elements get the proper InputSlot. if (programUsesInstancedPointSprites) { ilKey.elements[firstIndexedElement + 1].desc.InputSlot = 0; } } ID3D11InputLayout *inputLayout = NULL; InputLayoutMap::iterator keyIter = mInputLayoutMap.find(ilKey); if (keyIter != mInputLayoutMap.end()) { inputLayout = keyIter->second.inputLayout; keyIter->second.lastUsedTime = mCounter++; } else { gl::VertexFormat shaderInputLayout[gl::MAX_VERTEX_ATTRIBS]; GetInputLayout(attributes, shaderInputLayout); ShaderExecutableD3D *shader = NULL; gl::Error error = programD3D->getVertexExecutableForInputLayout(shaderInputLayout, &shader, nullptr); if (error.isError()) { return error; } ShaderExecutableD3D *shader11 = ShaderExecutable11::makeShaderExecutable11(shader); D3D11_INPUT_ELEMENT_DESC descs[gl::MAX_VERTEX_ATTRIBS]; for (unsigned int j = 0; j < ilKey.elementCount; ++j) { descs[j] = ilKey.elements[j].desc; } HRESULT result = mDevice->CreateInputLayout(descs, ilKey.elementCount, shader11->getFunction(), shader11->getLength(), &inputLayout); if (FAILED(result)) { return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal input layout, HRESULT: 0x%08x", result); } if (mInputLayoutMap.size() >= kMaxInputLayouts) { TRACE("Overflowed the limit of %u input layouts, removing the least recently used " "to make room.", kMaxInputLayouts); InputLayoutMap::iterator leastRecentlyUsed = mInputLayoutMap.begin(); for (InputLayoutMap::iterator i = mInputLayoutMap.begin(); i != mInputLayoutMap.end(); i++) { if (i->second.lastUsedTime < leastRecentlyUsed->second.lastUsedTime) { leastRecentlyUsed = i; } } SafeRelease(leastRecentlyUsed->second.inputLayout); mInputLayoutMap.erase(leastRecentlyUsed); } InputLayoutCounterPair inputCounterPair; inputCounterPair.inputLayout = inputLayout; inputCounterPair.lastUsedTime = mCounter++; mInputLayoutMap.insert(std::make_pair(ilKey, inputCounterPair)); } if (inputLayout != mCurrentIL) { mDeviceContext->IASetInputLayout(inputLayout); mCurrentIL = inputLayout; } bool dirtyBuffers = false; size_t minDiff = gl::MAX_VERTEX_ATTRIBS; size_t maxDiff = 0; unsigned int nextAvailableIndex = 0; for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) { ID3D11Buffer *buffer = NULL; if (attributes[i].active) { VertexBuffer11 *vertexBuffer = VertexBuffer11::makeVertexBuffer11(attributes[i].vertexBuffer); Buffer11 *bufferStorage = attributes[i].storage ? Buffer11::makeBuffer11(attributes[i].storage) : NULL; buffer = bufferStorage ? bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK) : vertexBuffer->getBuffer(); } UINT vertexStride = attributes[i].stride; UINT vertexOffset = attributes[i].offset; if (buffer != mCurrentBuffers[i] || vertexStride != mCurrentVertexStrides[i] || vertexOffset != mCurrentVertexOffsets[i]) { dirtyBuffers = true; minDiff = std::min(minDiff, static_cast<size_t>(i)); maxDiff = std::max(maxDiff, static_cast<size_t>(i)); mCurrentBuffers[i] = buffer; mCurrentVertexStrides[i] = vertexStride; mCurrentVertexOffsets[i] = vertexOffset; // If a non null ID3D11Buffer is being assigned to mCurrentBuffers, // then the next available index needs to be tracked to ensure // that any instanced pointsprite emulation buffers will be properly packed. if (buffer) { nextAvailableIndex = i + 1; } } } // Instanced PointSprite emulation requires two additional ID3D11Buffers. // A vertex buffer needs to be created and added to the list of current buffers, // strides and offsets collections. This buffer contains the vertices for a single // PointSprite quad. // An index buffer also needs to be created and applied because rendering instanced // data on D3D11 FL9_3 requires DrawIndexedInstanced() to be used. if (instancedPointSpritesActive) { HRESULT result = S_OK; const UINT pointSpriteVertexStride = sizeof(float) * 5; if (!mPointSpriteVertexBuffer) { static const float pointSpriteVertices[] = { // Position // TexCoord -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, }; D3D11_SUBRESOURCE_DATA vertexBufferData = { pointSpriteVertices, 0, 0 }; D3D11_BUFFER_DESC vertexBufferDesc; vertexBufferDesc.ByteWidth = sizeof(pointSpriteVertices); vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE; vertexBufferDesc.CPUAccessFlags = 0; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; result = mDevice->CreateBuffer(&vertexBufferDesc, &vertexBufferData, &mPointSpriteVertexBuffer); if (FAILED(result)) { return gl::Error(GL_OUT_OF_MEMORY, "Failed to create instanced pointsprite emulation vertex buffer, HRESULT: 0x%08x", result); } } mCurrentBuffers[nextAvailableIndex] = mPointSpriteVertexBuffer; mCurrentVertexStrides[nextAvailableIndex] = pointSpriteVertexStride; mCurrentVertexOffsets[nextAvailableIndex] = 0; if (!mPointSpriteIndexBuffer) { // Create an index buffer and set it for pointsprite rendering static const unsigned short pointSpriteIndices[] = { 0, 1, 2, 3, 4, 5, }; D3D11_SUBRESOURCE_DATA indexBufferData = { pointSpriteIndices, 0, 0 }; D3D11_BUFFER_DESC indexBufferDesc; indexBufferDesc.ByteWidth = sizeof(pointSpriteIndices); indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE; indexBufferDesc.CPUAccessFlags = 0; indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; result = mDevice->CreateBuffer(&indexBufferDesc, &indexBufferData, &mPointSpriteIndexBuffer); if (FAILED(result)) { SafeRelease(mPointSpriteVertexBuffer); return gl::Error(GL_OUT_OF_MEMORY, "Failed to create instanced pointsprite emulation index buffer, HRESULT: 0x%08x", result); } } // The index buffer is applied here because Instanced PointSprite emulation uses // the a non-indexed rendering path in ANGLE (DrawArrays). This means that applyIndexBuffer() // on the renderer will not be called and setting this buffer here ensures that the rendering // path will contain the correct index buffers. mDeviceContext->IASetIndexBuffer(mPointSpriteIndexBuffer, DXGI_FORMAT_R16_UINT, 0); } if (moveFirstIndexedIntoSlotZero) { // In this case, we swapped the slots of the first instanced element and the first indexed element, to ensure // that the first slot contains non-instanced data (required by Feature Level 9_3). // We must also swap the corresponding buffers sent to IASetVertexBuffers so that the correct data is sent to each slot. std::swap(mCurrentBuffers[firstIndexedElement], mCurrentBuffers[firstInstancedElement]); std::swap(mCurrentVertexStrides[firstIndexedElement], mCurrentVertexStrides[firstInstancedElement]); std::swap(mCurrentVertexOffsets[firstIndexedElement], mCurrentVertexOffsets[firstInstancedElement]); } if (dirtyBuffers) { ASSERT(minDiff <= maxDiff && maxDiff < gl::MAX_VERTEX_ATTRIBS); mDeviceContext->IASetVertexBuffers(minDiff, maxDiff - minDiff + 1, mCurrentBuffers + minDiff, mCurrentVertexStrides + minDiff, mCurrentVertexOffsets + minDiff); } return gl::Error(GL_NO_ERROR); }
gl::Error InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl::MAX_VERTEX_ATTRIBS], gl::ProgramBinary *programBinary) { int sortedSemanticIndices[gl::MAX_VERTEX_ATTRIBS]; programBinary->sortAttributesByLayout(attributes, sortedSemanticIndices); if (!mDevice || !mDeviceContext) { return gl::Error(GL_OUT_OF_MEMORY, "Internal input layout cache is not initialized."); } InputLayoutKey ilKey = { 0 }; static const char* semanticName = "TEXCOORD"; for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) { if (attributes[i].active) { D3D11_INPUT_CLASSIFICATION inputClass = attributes[i].divisor > 0 ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA; gl::VertexFormat vertexFormat(*attributes[i].attribute, attributes[i].currentValueType); const d3d11::VertexFormat &vertexFormatInfo = d3d11::GetVertexFormatInfo(vertexFormat); // Record the type of the associated vertex shader vector in our key // This will prevent mismatched vertex shaders from using the same input layout GLint attributeSize; programBinary->getActiveAttribute(sortedSemanticIndices[i], 0, NULL, &attributeSize, &ilKey.elements[ilKey.elementCount].glslElementType, NULL); ilKey.elements[ilKey.elementCount].desc.SemanticName = semanticName; ilKey.elements[ilKey.elementCount].desc.SemanticIndex = i; ilKey.elements[ilKey.elementCount].desc.Format = vertexFormatInfo.nativeFormat; ilKey.elements[ilKey.elementCount].desc.InputSlot = i; ilKey.elements[ilKey.elementCount].desc.AlignedByteOffset = 0; ilKey.elements[ilKey.elementCount].desc.InputSlotClass = inputClass; ilKey.elements[ilKey.elementCount].desc.InstanceDataStepRate = attributes[i].divisor; ilKey.elementCount++; } } ID3D11InputLayout *inputLayout = NULL; InputLayoutMap::iterator keyIter = mInputLayoutMap.find(ilKey); if (keyIter != mInputLayoutMap.end()) { inputLayout = keyIter->second.inputLayout; keyIter->second.lastUsedTime = mCounter++; } else { gl::VertexFormat shaderInputLayout[gl::MAX_VERTEX_ATTRIBS]; GetInputLayout(attributes, shaderInputLayout); ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(programBinary->getImplementation()); ShaderExecutable *shader = NULL; gl::Error error = programD3D->getVertexExecutableForInputLayout(shaderInputLayout, &shader); if (error.isError()) { return error; } ShaderExecutable *shader11 = ShaderExecutable11::makeShaderExecutable11(shader); D3D11_INPUT_ELEMENT_DESC descs[gl::MAX_VERTEX_ATTRIBS]; for (unsigned int j = 0; j < ilKey.elementCount; ++j) { descs[j] = ilKey.elements[j].desc; } HRESULT result = mDevice->CreateInputLayout(descs, ilKey.elementCount, shader11->getFunction(), shader11->getLength(), &inputLayout); if (FAILED(result)) { return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal input layout, HRESULT: 0x%08x", result); } if (mInputLayoutMap.size() >= kMaxInputLayouts) { TRACE("Overflowed the limit of %u input layouts, removing the least recently used " "to make room.", kMaxInputLayouts); InputLayoutMap::iterator leastRecentlyUsed = mInputLayoutMap.begin(); for (InputLayoutMap::iterator i = mInputLayoutMap.begin(); i != mInputLayoutMap.end(); i++) { if (i->second.lastUsedTime < leastRecentlyUsed->second.lastUsedTime) { leastRecentlyUsed = i; } } SafeRelease(leastRecentlyUsed->second.inputLayout); mInputLayoutMap.erase(leastRecentlyUsed); } InputLayoutCounterPair inputCounterPair; inputCounterPair.inputLayout = inputLayout; inputCounterPair.lastUsedTime = mCounter++; mInputLayoutMap.insert(std::make_pair(ilKey, inputCounterPair)); } if (inputLayout != mCurrentIL) { mDeviceContext->IASetInputLayout(inputLayout); mCurrentIL = inputLayout; } bool dirtyBuffers = false; size_t minDiff = gl::MAX_VERTEX_ATTRIBS; size_t maxDiff = 0; for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++) { ID3D11Buffer *buffer = NULL; if (attributes[i].active) { VertexBuffer11 *vertexBuffer = VertexBuffer11::makeVertexBuffer11(attributes[i].vertexBuffer); Buffer11 *bufferStorage = attributes[i].storage ? Buffer11::makeBuffer11(attributes[i].storage) : NULL; buffer = bufferStorage ? bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK) : vertexBuffer->getBuffer(); } UINT vertexStride = attributes[i].stride; UINT vertexOffset = attributes[i].offset; if (buffer != mCurrentBuffers[i] || vertexStride != mCurrentVertexStrides[i] || vertexOffset != mCurrentVertexOffsets[i]) { dirtyBuffers = true; minDiff = std::min(minDiff, static_cast<size_t>(i)); maxDiff = std::max(maxDiff, static_cast<size_t>(i)); mCurrentBuffers[i] = buffer; mCurrentVertexStrides[i] = vertexStride; mCurrentVertexOffsets[i] = vertexOffset; } } if (dirtyBuffers) { ASSERT(minDiff <= maxDiff && maxDiff < gl::MAX_VERTEX_ATTRIBS); mDeviceContext->IASetVertexBuffers(minDiff, maxDiff - minDiff + 1, mCurrentBuffers + minDiff, mCurrentVertexStrides + minDiff, mCurrentVertexOffsets + minDiff); } return gl::Error(GL_NO_ERROR); }