Redesign the code that uses block layouts to use a generic base class.

src/build_angle.gypi

@@ -65,6 +65,8 @@
       ],
       'sources': [
         'compiler/BaseTypes.h',
+        'compiler/BlockLayoutEncoder.cpp',
+        'compiler/BlockLayoutEncoder.h',
         'compiler/BuiltInFunctionEmulator.cpp',
         'compiler/BuiltInFunctionEmulator.h',
         'compiler/Common.h',
@@ -206,6 +208,8 @@
             'compiler/DetectDiscontinuity.cpp',
             'compiler/DetectDiscontinuity.h',
             'compiler/CodeGenHLSL.cpp',
+            'compiler/HLSLLayoutEncoder.cpp',
+            'compiler/HLSLLayoutEncoder.h',
             'compiler/OutputHLSL.cpp',
             'compiler/OutputHLSL.h',
             'compiler/TranslatorHLSL.cpp',

src/compiler/BlockLayoutEncoder.cpp

+//
+// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#include "compiler/BlockLayoutEncoder.h"
+#include "compiler/Uniform.h"
+#include "common/mathutil.h"
+#include "common/utilities.h"
+
+namespace sh
+{
+
+BlockLayoutEncoder::BlockLayoutEncoder(std::vector<BlockMemberInfo> *blockInfoOut)
+    : mCurrentOffset(0),
+      mBlockInfoOut(blockInfoOut)
+{
+}
+
+void BlockLayoutEncoder::encodeFields(const std::vector<Uniform> &fields)
+{
+    for (unsigned int fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++)
+    {
+        const Uniform &uniform = fields[fieldIndex];
+
+        if (uniform.fields.size() > 0)
+        {
+            const unsigned int elementCount = std::max(1u, uniform.arraySize);
+
+            for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
+            {
+                enterAggregateType();
+                encodeFields(uniform.fields);
+                exitAggregateType();
+            }
+        }
+        else
+        {
+            encodeType(uniform);
+        }
+    }
+}
+
+void BlockLayoutEncoder::encodeType(const Uniform &uniform)
+{
+    int arrayStride;
+    int matrixStride;
+
+    getBlockLayoutInfo(uniform, &arrayStride, &matrixStride);
+
+    const BlockMemberInfo memberInfo(mCurrentOffset * ComponentSize, arrayStride * ComponentSize, matrixStride * ComponentSize, uniform.isRowMajorMatrix);
+    mBlockInfoOut->push_back(memberInfo);
+
+    advanceOffset(uniform, arrayStride, matrixStride);
+}
+
+void BlockLayoutEncoder::nextRegister()
+{
+    mCurrentOffset = rx::roundUp(mCurrentOffset, RegisterSize);
+}
+
+Std140BlockEncoder::Std140BlockEncoder(std::vector<BlockMemberInfo> *blockInfoOut)
+    : BlockLayoutEncoder(blockInfoOut)
+{
+}
+
+void Std140BlockEncoder::enterAggregateType()
+{
+    nextRegister();
+}
+
+void Std140BlockEncoder::exitAggregateType()
+{
+    nextRegister();
+}
+
+void Std140BlockEncoder::getBlockLayoutInfo(const Uniform &uniform, int *arrayStrideOut, int *matrixStrideOut)
+{
+    ASSERT(uniform.fields.empty());
+
+    // We assume we are only dealing with 4 byte components (no doubles or half-words currently)
+    ASSERT(gl::UniformComponentSize(gl::UniformComponentType(uniform.type)) == ComponentSize);
+
+    int numComponents = gl::UniformComponentCount(uniform.type);
+    size_t baseAlignment = (numComponents == 3 ? 4u : static_cast<size_t>(numComponents));
+    int matrixStride = 0;
+    int arrayStride = 0;
+
+    if (gl::IsMatrixType(uniform.type))
+    {
+        numComponents = gl::MatrixComponentCount(uniform.type, uniform.isRowMajorMatrix);
+        baseAlignment = rx::roundUp(baseAlignment, RegisterSize);
+        matrixStride = baseAlignment;
+
+        if (uniform.arraySize > 0)
+        {
+            const int numRegisters = gl::MatrixRegisterCount(uniform.type, uniform.isRowMajorMatrix);
+            arrayStride = matrixStride * numRegisters;
+        }
+    }
+    else if (uniform.arraySize > 0)
+    {
+        baseAlignment = rx::roundUp(baseAlignment, RegisterSize);
+        arrayStride = baseAlignment;
+    }
+
+    mCurrentOffset = rx::roundUp(mCurrentOffset, baseAlignment);
+
+    *matrixStrideOut = matrixStride;
+    *arrayStrideOut = arrayStride;
+}
+
+void Std140BlockEncoder::advanceOffset(const Uniform &uniform, int arrayStride, int matrixStride)
+{
+    if (uniform.arraySize > 0)
+    {
+        mCurrentOffset += arrayStride * uniform.arraySize;
+    }
+    else if (gl::IsMatrixType(uniform.type))
+    {
+        ASSERT(matrixStride == RegisterSize);
+        const int numRegisters = gl::MatrixRegisterCount(uniform.type, uniform.isRowMajorMatrix);
+        mCurrentOffset += RegisterSize * numRegisters;
+    }
+    else
+    {
+        mCurrentOffset += gl::UniformComponentCount(uniform.type);
+    }
+}
+
+}

src/compiler/BlockLayoutEncoder.h

+//
+// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#ifndef TRANSLATOR_COMMON_BLOCKLAYOUTENCODER_H_
+#define TRANSLATOR_COMMON_BLOCKLAYOUTENCODER_H_
+
+#include <vector>
+
+namespace sh
+{
+
+struct Uniform;
+struct BlockMemberInfo;
+
+class BlockLayoutEncoder
+{
+  public:
+    BlockLayoutEncoder(std::vector<BlockMemberInfo> *blockInfoOut);
+
+    void encodeFields(const std::vector<Uniform> &fields);
+    void encodeType(const Uniform &uniform);
+    size_t getBlockSize() { return mCurrentOffset * ComponentSize; }
+
+    static const size_t ComponentSize = 4u;
+    static const unsigned int RegisterSize = 4u;
+
+  protected:
+    size_t mCurrentOffset;
+
+    void nextRegister();
+
+    virtual void enterAggregateType() = 0;
+    virtual void exitAggregateType() = 0;
+    virtual void getBlockLayoutInfo(const Uniform &uniform, int *arrayStrideOut, int *matrixStrideOut) = 0;
+    virtual void advanceOffset(const Uniform &uniform, int arrayStride, int matrixStride) = 0;
+
+  private:
+    std::vector<BlockMemberInfo> *mBlockInfoOut;
+};
+
+// Block layout according to the std140 block layout
+// See "Standard Uniform Block Layout" in Section 2.11.6 of the OpenGL ES 3.0 specification
+
+class Std140BlockEncoder : public BlockLayoutEncoder
+{
+  public:
+    Std140BlockEncoder(std::vector<BlockMemberInfo> *blockInfoOut);
+
+  protected:
+    virtual void enterAggregateType();
+    virtual void exitAggregateType();
+    virtual void getBlockLayoutInfo(const Uniform &uniform, int *arrayStrideOut, int *matrixStrideOut);
+    virtual void advanceOffset(const Uniform &uniform, int arrayStride, int matrixStride);
+};
+
+}
+
+#endif // TRANSLATOR_COMMON_BLOCKLAYOUTENCODER_H_

src/compiler/HLSLLayoutEncoder.cpp

+//
+// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#include "compiler/HLSLLayoutEncoder.h"
+#include "compiler/Uniform.h"
+#include "common/mathutil.h"
+#include "common/utilities.h"
+
+namespace sh
+{
+
+HLSLBlockEncoder::HLSLBlockEncoder(std::vector<BlockMemberInfo> *blockInfoOut)
+    : BlockLayoutEncoder(blockInfoOut)
+{
+}
+
+void HLSLBlockEncoder::enterAggregateType()
+{
+    nextRegister();
+}
+
+void HLSLBlockEncoder::exitAggregateType()
+{
+}
+
+void HLSLBlockEncoder::getBlockLayoutInfo(const sh::Uniform &uniform, int *arrayStrideOut, int *matrixStrideOut)
+{
+    ASSERT(uniform.fields.empty());
+
+    // We assume we are only dealing with 4 byte components (no doubles or half-words currently)
+    ASSERT(gl::UniformComponentSize(gl::UniformComponentType(uniform.type)) == ComponentSize);
+
+    int matrixStride = 0;
+    int arrayStride = 0;
+
+    if (gl::IsMatrixType(uniform.type))
+    {
+        nextRegister();
+        matrixStride = RegisterSize;
+
+        if (uniform.arraySize > 0)
+        {
+            const int numRegisters = gl::MatrixRegisterCount(uniform.type, uniform.isRowMajorMatrix);
+            arrayStride = RegisterSize * numRegisters;
+        }
+    }
+    else if (uniform.arraySize > 0)
+    {
+        nextRegister();
+        arrayStride = RegisterSize;
+    }
+    else
+    {
+        int numComponents = gl::UniformComponentCount(uniform.type);
+        if ((numComponents + (mCurrentOffset % RegisterSize)) > RegisterSize)
+        {
+            nextRegister();
+        }
+    }
+
+    *matrixStrideOut = matrixStride;
+    *arrayStrideOut = arrayStride;
+}
+
+void HLSLBlockEncoder::advanceOffset(const sh::Uniform &uniform, int arrayStride, int matrixStride)
+{
+    if (uniform.arraySize > 0)
+    {
+        mCurrentOffset += arrayStride * (uniform.arraySize - 1);
+    }
+
+    if (gl::IsMatrixType(uniform.type))
+    {
+        ASSERT(matrixStride == RegisterSize);
+        const int numRegisters = gl::MatrixRegisterCount(uniform.type, uniform.isRowMajorMatrix);
+        const int numComponents = gl::MatrixComponentCount(uniform.type, uniform.isRowMajorMatrix);
+        mCurrentOffset += RegisterSize * (numRegisters - 1);
+        mCurrentOffset += numComponents;
+    }
+    else
+    {
+        mCurrentOffset += gl::UniformComponentCount(uniform.type);
+    }
+}
+
+}

src/compiler/HLSLLayoutEncoder.h

+//
+// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#ifndef TRANSLATOR_HLSL_HLSLLAYOUTENCODER_H_
+#define TRANSLATOR_HLSL_HLSLLAYOUTENCODER_H_
+
+#include "compiler/BlockLayoutEncoder.h"
+
+namespace sh
+{
+
+// Block layout packed according to the default D3D11 register packing rules
+// See http://msdn.microsoft.com/en-us/library/windows/desktop/bb509632(v=vs.85).aspx
+
+class HLSLBlockEncoder : public BlockLayoutEncoder
+{
+  public:
+    HLSLBlockEncoder(std::vector<BlockMemberInfo> *blockInfoOut);
+
+  protected:
+    virtual void enterAggregateType();
+    virtual void exitAggregateType();
+    virtual void getBlockLayoutInfo(const sh::Uniform &uniform, int *arrayStrideOut, int *matrixStrideOut);
+    virtual void advanceOffset(const sh::Uniform &uniform, int arrayStride, int matrixStride);
+};
+
+}
+
+#endif // TRANSLATOR_HLSL_HLSLLAYOUTENCODER_H_
\ No newline at end of file

src/compiler/OutputHLSL.cpp

@@ -13,6 +13,7 @@
 #include "compiler/InfoSink.h"
 #include "compiler/SearchSymbol.h"
 #include "compiler/UnfoldShortCircuit.h"
+#include "compiler/HLSLLayoutEncoder.h"
 
 #include <algorithm>
 #include <cfloat>
@@ -284,6 +285,37 @@ TString OutputHLSL::interfaceBlockString(const TType &interfaceBlockType, unsign
     return hlsl;
 }
 
+// Use the same layout for packed and shared
+void setBlockLayout(InterfaceBlock *interfaceBlock, BlockLayoutType newLayout)
+{
+    interfaceBlock->layout = newLayout;
+    interfaceBlock->blockInfo.clear();
+
+    switch (newLayout)
+    {
+      case BLOCKLAYOUT_SHARED:
+      case BLOCKLAYOUT_PACKED:
+        {
+            HLSLBlockEncoder hlslEncoder(&interfaceBlock->blockInfo);
+            hlslEncoder.encodeFields(interfaceBlock->activeUniforms);
+            interfaceBlock->dataSize = hlslEncoder.getBlockSize();
+        }
+        break;
+
+      case BLOCKLAYOUT_STANDARD:
+        {
+            Std140BlockEncoder stdEncoder(&interfaceBlock->blockInfo);
+            stdEncoder.encodeFields(interfaceBlock->activeUniforms);
+            interfaceBlock->dataSize = stdEncoder.getBlockSize();
+        }
+        break;
+
+      default:
+        UNREACHABLE();
+        break;
+    }
+}
+
 void OutputHLSL::header()
 {
     ShShaderType shaderType = mContext.shaderType;
@@ -335,7 +367,7 @@ void OutputHLSL::header()
         mInterfaceBlockRegister += std::max(1u, interfaceBlock.arraySize);
 
         // TODO: handle other block layouts
-        interfaceBlock.setBlockLayout(BLOCKLAYOUT_SHARED);
+        setBlockLayout(&interfaceBlock, BLOCKLAYOUT_SHARED);
         mActiveInterfaceBlocks.push_back(interfaceBlock);
 
         if (interfaceBlockType.hasInstanceName())

src/compiler/Uniform.cpp

@@ -5,8 +5,6 @@
 //
 
 #include "compiler/Uniform.h"
-#include "common/mathutil.h"
-#include "common/utilities.h"
 
 namespace sh
 {
@@ -56,170 +54,4 @@ InterfaceBlock::InterfaceBlock(const char *name, unsigned int arraySize, unsigne
 {
 }
 
-// Use the same layout for packed and shared
-void InterfaceBlock::setBlockLayout(BlockLayoutType newLayout)
-{
-    layout = newLayout;
-
-    const size_t componentSize = 4;
-    unsigned int currentOffset = 0;
-
-    blockInfo.clear();
-    getBlockLayoutInfo(activeUniforms, &currentOffset);
-
-    dataSize = currentOffset * componentSize;
-}
-
-void InterfaceBlock::getBlockLayoutInfo(const sh::ActiveUniforms &fields, unsigned int *currentOffset)
-{
-    const size_t componentSize = 4;
-
-    for (unsigned int fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++)
-    {
-        int arrayStride;
-        int matrixStride;
-
-        const sh::Uniform &uniform = fields[fieldIndex];
-
-        if (getBlockLayoutInfo(uniform, currentOffset, &arrayStride, &matrixStride))
-        {
-            const BlockMemberInfo memberInfo(*currentOffset * componentSize, arrayStride * componentSize, matrixStride * componentSize, uniform.isRowMajorMatrix);
-            blockInfo.push_back(memberInfo);
-
-            if (uniform.arraySize > 0)
-            {
-                *currentOffset += arrayStride * (uniform.arraySize - 1);
-            }
-
-            if (gl::IsMatrixType(uniform.type))
-            {
-                const int componentGroups = (uniform.isRowMajorMatrix ? gl::VariableRowCount(uniform.type) : gl::VariableColumnCount(uniform.type));
-                const int numComponents = (uniform.isRowMajorMatrix ? gl::VariableColumnCount(uniform.type) : gl::VariableRowCount(uniform.type));
-                *currentOffset += matrixStride * (componentGroups - 1);
-                *currentOffset += numComponents;
-            }
-            else
-            {
-                *currentOffset += gl::UniformComponentCount(uniform.type);
-            }
-        }
-    }
-}
-
-bool InterfaceBlock::getBlockLayoutInfo(const sh::Uniform &uniform, unsigned int *currentOffset, int *arrayStrideOut, int *matrixStrideOut)
-{
-    if (!uniform.fields.empty())
-    {
-        const unsigned int elementCount = std::max(1u, uniform.arraySize);
-
-        for (unsigned int elementIndex = 0; elementIndex < elementCount; elementIndex++)
-        {
-            // align struct to register size
-            *currentOffset = rx::roundUp(*currentOffset, 4u);
-            getBlockLayoutInfo(uniform.fields, currentOffset);
-        }
-
-        return false;
-    }
-
-    switch (layout)
-    {
-      case BLOCKLAYOUT_SHARED:
-      case BLOCKLAYOUT_PACKED:
-        getD3DLayoutInfo(uniform, currentOffset, arrayStrideOut, matrixStrideOut);
-        return true;
-
-      case BLOCKLAYOUT_STANDARD:
-        getStandardLayoutInfo(uniform, currentOffset, arrayStrideOut, matrixStrideOut);
-        return true;
-
-      default:
-        UNREACHABLE();
-        return false;
-    }
-}
-
-// Block layout packed according to the default D3D11 register packing rules
-// See http://msdn.microsoft.com/en-us/library/windows/desktop/bb509632(v=vs.85).aspx
-void InterfaceBlock::getD3DLayoutInfo(const sh::Uniform &uniform, unsigned int *currentOffset, int *arrayStrideOut, int *matrixStrideOut)
-{
-    ASSERT(uniform.fields.empty());
-
-    const unsigned int registerSize = 4;
-    const size_t componentSize = 4;
-
-    // We assume we are only dealing with 4 byte components (no doubles or half-words currently)
-    ASSERT(gl::UniformComponentSize(gl::UniformComponentType(uniform.type)) == componentSize);
-    int matrixStride = 0;
-    int arrayStride = 0;
-
-    if (gl::IsMatrixType(uniform.type))
-    {
-        *currentOffset = rx::roundUp(*currentOffset, 4u);
-        matrixStride = registerSize;
-
-        if (uniform.arraySize > 0)
-        {
-            const int componentGroups = (uniform.isRowMajorMatrix ? gl::VariableRowCount(uniform.type) : gl::VariableColumnCount(uniform.type));
-            arrayStride = matrixStride * componentGroups;
-        }
-    }
-    else if (uniform.arraySize > 0)
-    {
-        *currentOffset = rx::roundUp(*currentOffset, registerSize);
-        arrayStride = registerSize;
-    }
-    else
-    {
-        int numComponents = gl::UniformComponentCount(uniform.type);
-        if ((numComponents + (*currentOffset % registerSize)) > registerSize)
-        {
-            *currentOffset = rx::roundUp(*currentOffset, registerSize);
-        }
-    }
-
-    *matrixStrideOut = matrixStride;
-    *arrayStrideOut = arrayStride;
-}
-
-// Block layout according to the std140 block layout
-// See "Standard Uniform Block Layout" in Section 2.11.6 of the OpenGL ES 3.0 specification
-void InterfaceBlock::getStandardLayoutInfo(const sh::Uniform &uniform, unsigned int *currentOffset, int *arrayStrideOut, int *matrixStrideOut)
-{
-    ASSERT(uniform.fields.empty());
-
-    const size_t componentSize = 4;
-
-    // We assume we are only dealing with 4 byte components (no doubles or half-words currently)
-    ASSERT(gl::UniformComponentSize(gl::UniformComponentType(uniform.type)) == componentSize);
-
-    int numComponents = gl::UniformComponentCount(uniform.type);
-    size_t baseAlignment = static_cast<size_t>(numComponents == 3 ? 4 : numComponents);
-    int matrixStride = 0;
-    int arrayStride = 0;
-
-    if (gl::IsMatrixType(uniform.type))
-    {
-        numComponents = (uniform.isRowMajorMatrix ? gl::VariableColumnCount(uniform.type) : gl::VariableRowCount(uniform.type));
-        baseAlignment = rx::roundUp(baseAlignment, 4u);
-        matrixStride = baseAlignment;
-
-        if (uniform.arraySize > 0)
-        {
-            const int componentGroups = (uniform.isRowMajorMatrix ? gl::VariableRowCount(uniform.type) : gl::VariableColumnCount(uniform.type));
-            arrayStride = matrixStride * componentGroups;
-        }
-    }
-    else if (uniform.arraySize > 0)
-    {
-        baseAlignment = rx::roundUp(baseAlignment, 4u);
-        arrayStride = baseAlignment;
-    }
-
-    *currentOffset = rx::roundUp(*currentOffset, baseAlignment);
-
-    *matrixStrideOut = matrixStride;
-    *arrayStrideOut = arrayStride;
-}
-
 }

src/compiler/Uniform.h

@@ -81,14 +81,6 @@ struct InterfaceBlock
     BlockLayoutType layout;
 
     unsigned int registerIndex;
-
-    void setBlockLayout(BlockLayoutType newLayout);
-
-  private:
-    void getBlockLayoutInfo(const sh::ActiveUniforms &fields, unsigned int *currentOffset);
-    bool getBlockLayoutInfo(const sh::Uniform &uniform, unsigned int *currentOffset, int *arrayStrideOut, int *matrixStrideOut);
-    void getD3DLayoutInfo(const sh::Uniform &uniform, unsigned int *currentOffset, int *arrayStrideOut, int *matrixStrideOut);
-    void getStandardLayoutInfo(const sh::Uniform &uniform, unsigned int *currentOffset, int *arrayStrideOut, int *matrixStrideOut);
 };
 
 typedef std::vector<InterfaceBlock> ActiveInterfaceBlocks;

src/compiler/translator_common.vcxproj

@@ -139,6 +139,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="..\common\utilities.cpp" />
+    <ClCompile Include="BlockLayoutEncoder.cpp" />
     <ClCompile Include="BuiltInFunctionEmulator.cpp" />
     <ClCompile Include="Compiler.cpp" />
     <ClCompile Include="debug.cpp" />
@@ -229,6 +230,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BaseTypes.h" />
+    <ClInclude Include="BlockLayoutEncoder.h" />
     <ClInclude Include="BuiltInFunctionEmulator.h" />
     <ClInclude Include="Common.h" />
     <ClInclude Include="ConstantUnion.h" />

src/compiler/translator_common.vcxproj.filters

@@ -143,6 +143,9 @@
     <ClCompile Include="ValidateOutputs.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="BlockLayoutEncoder.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BaseTypes.h">
@@ -268,6 +271,9 @@
     <ClInclude Include="ValidateOutputs.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="BlockLayoutEncoder.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="glslang.l">

src/compiler/translator_hlsl.vcxproj

@@ -144,6 +144,7 @@
   <ItemGroup>
     <ClCompile Include="CodeGenHLSL.cpp" />
     <ClCompile Include="DetectDiscontinuity.cpp" />
+    <ClCompile Include="HLSLLayoutEncoder.cpp" />
     <ClCompile Include="OutputHLSL.cpp" />
     <ClCompile Include="SearchSymbol.cpp" />
     <ClCompile Include="TranslatorHLSL.cpp" />
@@ -152,6 +153,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DetectDiscontinuity.h" />
+    <ClInclude Include="HLSLLayoutEncoder.h" />
     <ClInclude Include="OutputHLSL.h" />
     <ClInclude Include="SearchSymbol.h" />
     <ClInclude Include="TranslatorHLSL.h" />

src/compiler/translator_hlsl.vcxproj.filters

@@ -32,6 +32,9 @@
     <ClCompile Include="Uniform.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="HLSLLayoutEncoder.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DetectDiscontinuity.h">
@@ -52,5 +55,8 @@
     <ClInclude Include="Uniform.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="HLSLLayoutEncoder.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file