src/third_party/angle/src/libGLESv2/renderer/d3d/d3d11/InputLayoutCache.cpp

   1 //
   2 // Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 // InputLayoutCache.cpp: Defines InputLayoutCache, a class that builds and caches
   8 // D3D11 input layouts.
   9
  10 #include "libGLESv2/renderer/d3d/d3d11/InputLayoutCache.h"
  11 #include "libGLESv2/renderer/d3d/d3d11/VertexBuffer11.h"
  12 #include "libGLESv2/renderer/d3d/d3d11/Buffer11.h"
  13 #include "libGLESv2/renderer/d3d/d3d11/ShaderExecutable11.h"
  14 #include "libGLESv2/renderer/d3d/d3d11/formatutils11.h"
  15 #include "libGLESv2/renderer/d3d/VertexDataManager.h"
  16 #include "libGLESv2/ProgramBinary.h"
  17 #include "libGLESv2/VertexAttribute.h"
  18
  19 #include "third_party/murmurhash/MurmurHash3.h"
  20
  21 namespace rx
  22 {
  23
  24 static void GetInputLayout(const TranslatedAttribute translatedAttributes[gl::MAX_VERTEX_ATTRIBS],
  25                            gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS])
  26 {
  27     for (unsigned int attributeIndex = 0; attributeIndex < gl::MAX_VERTEX_ATTRIBS; attributeIndex++)
  28     {
  29         const TranslatedAttribute &translatedAttribute = translatedAttributes[attributeIndex];
  30
  31         if (translatedAttributes[attributeIndex].active)
  32         {
  33             inputLayout[attributeIndex] = gl::VertexFormat(*translatedAttribute.attribute,
  34                                                            translatedAttribute.currentValueType);
  35         }
  36     }
  37 }
  38
  39 const unsigned int InputLayoutCache::kMaxInputLayouts = 1024;
  40
  41 InputLayoutCache::InputLayoutCache() : mInputLayoutMap(kMaxInputLayouts, hashInputLayout, compareInputLayouts)
  42 {
  43     mCounter = 0;
  44     mDevice = NULL;
  45     mDeviceContext = NULL;
  46     mCurrentIL = NULL;
  47     for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
  48     {
  49         mCurrentBuffers[i] = NULL;
  50         mCurrentVertexStrides[i] = -1;
  51         mCurrentVertexOffsets[i] = -1;
  52     }
  53 }
  54
  55 InputLayoutCache::~InputLayoutCache()
  56 {
  57     clear();
  58 }
  59
  60 void InputLayoutCache::initialize(ID3D11Device *device, ID3D11DeviceContext *context)
  61 {
  62     clear();
  63     mDevice = device;
  64     mDeviceContext = context;
  65 }
  66
  67 void InputLayoutCache::clear()
  68 {
  69     for (InputLayoutMap::iterator i = mInputLayoutMap.begin(); i != mInputLayoutMap.end(); i++)
  70     {
  71         SafeRelease(i->second.inputLayout);
  72     }
  73     mInputLayoutMap.clear();
  74     markDirty();
  75 }
  76
  77 void InputLayoutCache::markDirty()
  78 {
  79     mCurrentIL = NULL;
  80     for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
  81     {
  82         mCurrentBuffers[i] = NULL;
  83         mCurrentVertexStrides[i] = -1;
  84         mCurrentVertexOffsets[i] = -1;
  85     }
  86 }
  87
  88 gl::Error InputLayoutCache::applyVertexBuffers(TranslatedAttribute attributes[gl::MAX_VERTEX_ATTRIBS],
  89                                                gl::ProgramBinary *programBinary)
  90 {
  91     int sortedSemanticIndices[gl::MAX_VERTEX_ATTRIBS];
  92     programBinary->sortAttributesByLayout(attributes, sortedSemanticIndices);
  93
  94     if (!mDevice || !mDeviceContext)
  95     {
  96         return gl::Error(GL_OUT_OF_MEMORY, "Internal input layout cache is not initialized.");
  97     }
  98
  99     InputLayoutKey ilKey = { 0 };
 100
 101     static const char* semanticName = "TEXCOORD";
 102
 103     for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
 104     {
 105         if (attributes[i].active)
 106         {
 107             D3D11_INPUT_CLASSIFICATION inputClass = attributes[i].divisor > 0 ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA;
 108
 109             gl::VertexFormat vertexFormat(*attributes[i].attribute, attributes[i].currentValueType);
 110             const d3d11::VertexFormat &vertexFormatInfo = d3d11::GetVertexFormatInfo(vertexFormat);
 111
 112             // Record the type of the associated vertex shader vector in our key
 113             // This will prevent mismatched vertex shaders from using the same input layout
 114             GLint attributeSize;
 115             programBinary->getActiveAttribute(ilKey.elementCount, 0, NULL, &attributeSize, &ilKey.elements[ilKey.elementCount].glslElementType, NULL);
 116
 117             ilKey.elements[ilKey.elementCount].desc.SemanticName = semanticName;
 118             ilKey.elements[ilKey.elementCount].desc.SemanticIndex = sortedSemanticIndices[i];
 119             ilKey.elements[ilKey.elementCount].desc.Format = vertexFormatInfo.nativeFormat;
 120             ilKey.elements[ilKey.elementCount].desc.InputSlot = i;
 121             ilKey.elements[ilKey.elementCount].desc.AlignedByteOffset = 0;
 122             ilKey.elements[ilKey.elementCount].desc.InputSlotClass = inputClass;
 123             ilKey.elements[ilKey.elementCount].desc.InstanceDataStepRate = attributes[i].divisor;
 124             ilKey.elementCount++;
 125         }
 126     }
 127
 128     ID3D11InputLayout *inputLayout = NULL;
 129
 130     InputLayoutMap::iterator keyIter = mInputLayoutMap.find(ilKey);
 131     if (keyIter != mInputLayoutMap.end())
 132     {
 133         inputLayout = keyIter->second.inputLayout;
 134         keyIter->second.lastUsedTime = mCounter++;
 135     }
 136     else
 137     {
 138         gl::VertexFormat shaderInputLayout[gl::MAX_VERTEX_ATTRIBS];
 139         GetInputLayout(attributes, shaderInputLayout);
 140         ShaderExecutable11 *shader = ShaderExecutable11::makeShaderExecutable11(programBinary->getVertexExecutableForInputLayout(shaderInputLayout));
 141
 142         D3D11_INPUT_ELEMENT_DESC descs[gl::MAX_VERTEX_ATTRIBS];
 143         for (unsigned int j = 0; j < ilKey.elementCount; ++j)
 144         {
 145             descs[j] = ilKey.elements[j].desc;
 146         }
 147
 148         HRESULT result = mDevice->CreateInputLayout(descs, ilKey.elementCount, shader->getFunction(), shader->getLength(), &inputLayout);
 149         if (FAILED(result))
 150         {
 151             return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal input layout, HRESULT: 0x%08x", result);
 152         }
 153
 154         if (mInputLayoutMap.size() >= kMaxInputLayouts)
 155         {
 156             TRACE("Overflowed the limit of %u input layouts, removing the least recently used "
 157                   "to make room.", kMaxInputLayouts);
 158
 159             InputLayoutMap::iterator leastRecentlyUsed = mInputLayoutMap.begin();
 160             for (InputLayoutMap::iterator i = mInputLayoutMap.begin(); i != mInputLayoutMap.end(); i++)
 161             {
 162                 if (i->second.lastUsedTime < leastRecentlyUsed->second.lastUsedTime)
 163                 {
 164                     leastRecentlyUsed = i;
 165                 }
 166             }
 167             SafeRelease(leastRecentlyUsed->second.inputLayout);
 168             mInputLayoutMap.erase(leastRecentlyUsed);
 169         }
 170
 171         InputLayoutCounterPair inputCounterPair;
 172         inputCounterPair.inputLayout = inputLayout;
 173         inputCounterPair.lastUsedTime = mCounter++;
 174
 175         mInputLayoutMap.insert(std::make_pair(ilKey, inputCounterPair));
 176     }
 177
 178     if (inputLayout != mCurrentIL)
 179     {
 180         mDeviceContext->IASetInputLayout(inputLayout);
 181         mCurrentIL = inputLayout;
 182     }
 183
 184     bool dirtyBuffers = false;
 185     size_t minDiff = gl::MAX_VERTEX_ATTRIBS;
 186     size_t maxDiff = 0;
 187     for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
 188     {
 189         ID3D11Buffer *buffer = NULL;
 190
 191         if (attributes[i].active)
 192         {
 193             VertexBuffer11 *vertexBuffer = VertexBuffer11::makeVertexBuffer11(attributes[i].vertexBuffer);
 194             Buffer11 *bufferStorage = attributes[i].storage ? Buffer11::makeBuffer11(attributes[i].storage) : NULL;
 195
 196             buffer = bufferStorage ? bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK)
 197                                    : vertexBuffer->getBuffer();
 198         }
 199
 200         UINT vertexStride = attributes[i].stride;
 201         UINT vertexOffset = attributes[i].offset;
 202
 203         if (buffer != mCurrentBuffers[i] || vertexStride != mCurrentVertexStrides[i] ||
 204             vertexOffset != mCurrentVertexOffsets[i])
 205         {
 206             dirtyBuffers = true;
 207             minDiff = std::min(minDiff, static_cast<size_t>(i));
 208             maxDiff = std::max(maxDiff, static_cast<size_t>(i));
 209
 210             mCurrentBuffers[i] = buffer;
 211             mCurrentVertexStrides[i] = vertexStride;
 212             mCurrentVertexOffsets[i] = vertexOffset;
 213         }
 214     }
 215
 216     if (dirtyBuffers)
 217     {
 218         ASSERT(minDiff <= maxDiff && maxDiff < gl::MAX_VERTEX_ATTRIBS);
 219         mDeviceContext->IASetVertexBuffers(minDiff, maxDiff - minDiff + 1, mCurrentBuffers + minDiff,
 220                                            mCurrentVertexStrides + minDiff, mCurrentVertexOffsets + minDiff);
 221     }
 222
 223     return gl::Error(GL_NO_ERROR);
 224 }
 225
 226 std::size_t InputLayoutCache::hashInputLayout(const InputLayoutKey &inputLayout)
 227 {
 228     static const unsigned int seed = 0xDEADBEEF;
 229
 230     std::size_t hash = 0;
 231     MurmurHash3_x86_32(inputLayout.begin(), inputLayout.end() - inputLayout.begin(), seed, &hash);
 232     return hash;
 233 }
 234
 235 bool InputLayoutCache::compareInputLayouts(const InputLayoutKey &a, const InputLayoutKey &b)
 236 {
 237     if (a.elementCount != b.elementCount)
 238     {
 239         return false;
 240     }
 241
 242     return std::equal(a.begin(), a.end(), b.begin());
 243 }
 244
 245 }