Add LazyInputLayout to defer loading input layouts.

src/libANGLE/renderer/d3d/d3d11/Blit11.h

@@ -83,8 +83,6 @@ class Blit11 : angle::NonCopyable
         BLITSHADER_3D_LUMAALPHA,
     };
 
-    static BlitShaderType GetBlitShaderType(GLenum destinationFormat, bool isSigned, bool is3D);
-
     enum SwizzleShaderType
     {
         SWIZZLESHADER_INVALID,
@@ -102,47 +100,48 @@ class Blit11 : angle::NonCopyable
         SWIZZLESHADER_ARRAY_INT,
     };
 
-    static SwizzleShaderType GetSwizzleShaderType(GLenum type, D3D11_SRV_DIMENSION dimensionality);
-
-    gl::Error copyDepthStencil(ID3D11Resource *source, unsigned int sourceSubresource, const gl::Box &sourceArea, const gl::Extents &sourceSize,
-                               ID3D11Resource *dest, unsigned int destSubresource, const gl::Box &destArea, const gl::Extents &destSize,
-                               const gl::Rectangle *scissor, bool stencilOnly);
-
     typedef void (*WriteVertexFunction)(const gl::Box &sourceArea, const gl::Extents &sourceSize,
                                         const gl::Box &destArea, const gl::Extents &destSize,
                                         void *outVertices, unsigned int *outStride, unsigned int *outVertexCount,
                                         D3D11_PRIMITIVE_TOPOLOGY *outTopology);
 
+    enum ShaderDimension
+    {
+        SHADER_2D,
+        SHADER_3D,
+    };
+
     struct Shader
     {
-        WriteVertexFunction mVertexWriteFunction;
-        ID3D11InputLayout *mInputLayout;
-        ID3D11VertexShader *mVertexShader;
-        ID3D11GeometryShader *mGeometryShader;
-        ID3D11PixelShader *mPixelShader;
+        ShaderDimension dimension;
+        ID3D11PixelShader *pixelShader;
     };
 
-    struct CommonShaders
+    struct ShaderSupport
     {
-        ID3D11VertexShader *vertexShader2D;
-        ID3D11VertexShader *vertexShader3D;
-        ID3D11GeometryShader *geometryShader3D;
+        ID3D11InputLayout *inputLayout;
+        ID3D11VertexShader *vertexShader;
+        ID3D11GeometryShader *geometryShader;
+        WriteVertexFunction vertexWriteFunction;
     };
 
-    void add2DBlitShaderToMap(BlitShaderType blitShaderType, const CommonShaders &commonShaders, ID3D11PixelShader *ps);
-    void add3DBlitShaderToMap(BlitShaderType blitShaderType, const CommonShaders &commonShaders, ID3D11PixelShader *ps);
+    ShaderSupport getShaderSupport(const Shader &shader);
 
-    gl::Error getBlitShader(GLenum destFormat, bool isSigned, bool is3D, const Shader **shaderOut);
-    gl::Error getSwizzleShader(GLenum type, D3D11_SRV_DIMENSION viewDimension, const Shader **shaderOut);
+    static BlitShaderType GetBlitShaderType(GLenum destinationFormat, bool isSigned, ShaderDimension dimension);
+    static SwizzleShaderType GetSwizzleShaderType(GLenum type, D3D11_SRV_DIMENSION dimensionality);
 
-    void addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType, bool is2D, const CommonShaders &commonShaders, ID3D11PixelShader *ps);
+    gl::Error copyDepthStencil(ID3D11Resource *source, unsigned int sourceSubresource, const gl::Box &sourceArea, const gl::Extents &sourceSize,
+                               ID3D11Resource *dest, unsigned int destSubresource, const gl::Box &destArea, const gl::Extents &destSize,
+                               const gl::Rectangle *scissor, bool stencilOnly);
 
-    void clearShaderMap();
+    void addBlitShaderToMap(BlitShaderType blitShaderType, ShaderDimension dimension, ID3D11PixelShader *ps);
+
+    gl::Error getBlitShader(GLenum destFormat, bool isSigned, ShaderDimension dimension, const Shader **shaderOut);
+    gl::Error getSwizzleShader(GLenum type, D3D11_SRV_DIMENSION viewDimension, const Shader **shaderOut);
 
-    gl::Error getCommonShaders(CommonShaders *commonShadersOut, bool get3D);
+    void addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType, ShaderDimension dimension, ID3D11PixelShader *ps);
 
-    ID3D11InputLayout *getQuad2DIL();
-    ID3D11InputLayout *getQuad3DIL();
+    void clearShaderMap();
 
     Renderer11 *mRenderer;
 
@@ -156,11 +155,11 @@ class Blit11 : angle::NonCopyable
     ID3D11RasterizerState *mScissorDisabledRasterizerState;
     ID3D11DepthStencilState *mDepthStencilState;
 
-    ID3D11InputLayout *mQuad2DIL;
+    d3d11::LazyInputLayout mQuad2DIL;
     d3d11::LazyShader<ID3D11VertexShader> mQuad2DVS;
     d3d11::LazyShader<ID3D11PixelShader> mDepthPS;
 
-    ID3D11InputLayout *mQuad3DIL;
+    d3d11::LazyInputLayout mQuad3DIL;
     d3d11::LazyShader<ID3D11VertexShader> mQuad3DVS;
     d3d11::LazyShader<ID3D11GeometryShader> mQuad3DGS;
 

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h

@@ -192,8 +192,32 @@ ID3D11PixelShader *CompilePS(ID3D11Device *device, const BYTE (&byteCode)[N], co
     return CompilePS(device, byteCode, N, name);
 }
 
+template <typename ResourceType>
+class LazyResource : public angle::NonCopyable
+{
+  public:
+    LazyResource() : mResource(nullptr), mAssociatedDevice(nullptr) {}
+    virtual ~LazyResource() { release(); }
+
+    virtual ResourceType *resolve(ID3D11Device *device) = 0;
+    void release() { SafeRelease(mResource); }
+
+  protected:
+    void checkAssociatedDevice(ID3D11Device *device);
+
+    ResourceType *mResource;
+    ID3D11Device *mAssociatedDevice;
+};
+
+template <typename ResourceType>
+void LazyResource<ResourceType>::checkAssociatedDevice(ID3D11Device *device)
+{
+    ASSERT(mAssociatedDevice == nullptr || device == mAssociatedDevice);
+    mAssociatedDevice = device;
+}
+
 template <typename D3D11ShaderType>
-class LazyShader final : public angle::NonCopyable
+class LazyShader final : public LazyResource<D3D11ShaderType>
 {
   public:
     // All parameters must be constexpr. Not supported in VS2013.
@@ -202,65 +226,97 @@ class LazyShader final : public angle::NonCopyable
                const char *name)
         : mByteCode(byteCode),
           mByteCodeSize(byteCodeSize),
-          mName(name),
-          mShader(nullptr),
-          mAssociatedDevice(nullptr)
+          mName(name)
     {
     }
 
-    ~LazyShader() { release(); }
-
-    D3D11ShaderType *resolve(ID3D11Device *device);
-    void release() { SafeRelease(mShader); }
+    D3D11ShaderType *resolve(ID3D11Device *device) override;
 
   private:
-    void checkAssociatedDevice(ID3D11Device *device);
-
     const BYTE *mByteCode;
     size_t mByteCodeSize;
     const char *mName;
-    D3D11ShaderType *mShader;
-    ID3D11Device *mAssociatedDevice;
 };
 
-template <typename D3D11ShaderType>
-void LazyShader<D3D11ShaderType>::checkAssociatedDevice(ID3D11Device *device)
-{
-    ASSERT(mAssociatedDevice == nullptr || device == mAssociatedDevice);
-    mAssociatedDevice = device;
-}
-
 template <>
 inline ID3D11VertexShader *LazyShader<ID3D11VertexShader>::resolve(ID3D11Device *device)
 {
     checkAssociatedDevice(device);
-    if (mShader == nullptr)
+    if (mResource == nullptr)
     {
-        mShader = CompileVS(device, mByteCode, mByteCodeSize, mName);
+        mResource = CompileVS(device, mByteCode, mByteCodeSize, mName);
     }
-    return mShader;
+    return mResource;
 }
 
 template <>
 inline ID3D11GeometryShader *LazyShader<ID3D11GeometryShader>::resolve(ID3D11Device *device)
 {
     checkAssociatedDevice(device);
-    if (mShader == nullptr)
+    if (mResource == nullptr)
     {
-        mShader = CompileGS(device, mByteCode, mByteCodeSize, mName);
+        mResource = CompileGS(device, mByteCode, mByteCodeSize, mName);
     }
-    return mShader;
+    return mResource;
 }
 
 template <>
 inline ID3D11PixelShader *LazyShader<ID3D11PixelShader>::resolve(ID3D11Device *device)
 {
     checkAssociatedDevice(device);
-    if (mShader == nullptr)
+    if (mResource == nullptr)
     {
-        mShader = CompilePS(device, mByteCode, mByteCodeSize, mName);
+        mResource = CompilePS(device, mByteCode, mByteCodeSize, mName);
     }
-    return mShader;
+    return mResource;
+}
+
+class LazyInputLayout final : public LazyResource<ID3D11InputLayout>
+{
+  public:
+    LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
+                    size_t inputDescLen,
+                    const BYTE *byteCode,
+                    size_t byteCodeLen,
+                    const char *debugName);
+
+    ID3D11InputLayout *resolve(ID3D11Device *device) override;
+
+  private:
+    std::vector<D3D11_INPUT_ELEMENT_DESC> mInputDesc;
+    size_t mByteCodeLen;
+    const BYTE *mByteCode;
+    const char *mDebugName;
+};
+
+inline LazyInputLayout::LazyInputLayout(
+    const D3D11_INPUT_ELEMENT_DESC *inputDesc,
+    size_t inputDescLen,
+    const BYTE *byteCode,
+    size_t byteCodeLen,
+    const char *debugName)
+    : mInputDesc(inputDescLen),
+      mByteCodeLen(byteCodeLen),
+      mByteCode(byteCode),
+      mDebugName(debugName)
+{
+    memcpy(&mInputDesc[0], inputDesc, sizeof(D3D11_INPUT_ELEMENT_DESC) * inputDescLen);
+}
+
+inline ID3D11InputLayout *LazyInputLayout::resolve(ID3D11Device *device)
+{
+    checkAssociatedDevice(device);
+
+    if (mResource == nullptr)
+    {
+        HRESULT result = device->CreateInputLayout(
+            &mInputDesc[0], static_cast<UINT>(mInputDesc.size()), mByteCode, mByteCodeLen, &mResource);
+        ASSERT(SUCCEEDED(result));
+        UNUSED_ASSERTION_VARIABLE(result);
+        d3d11::SetDebugName(mResource, mDebugName);
+    }
+
+    return mResource;
 }
 
 // Copy data to small D3D11 buffers, such as for small constant buffers, which use one struct to