D3D: Move some HLSL-specific code to a new folder.

BUILD.gn

@@ -319,6 +319,10 @@ static_library("libANGLE") {
     defines += [ "ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES={ " + "\"d3dcompiler_47.dll\", \"d3dcompiler_46.dll\", \"d3dcompiler_43.dll\" }" ]
   }
 
+  if (angle_enable_hlsl) {
+    sources += rebase_path(gles_gypi.libangle_d3d_hlsl_sources, ".", "src")
+  }
+
   if (angle_enable_d3d9) {
     sources += rebase_path(gles_gypi.libangle_d3d9_sources, ".", "src")
     libs += [ "d3d9.lib" ]

src/libANGLE/angletypes.h

@@ -336,6 +336,11 @@ inline GLenum FramebufferBindingToEnum(FramebufferBinding binding)
             return GL_NONE;
     }
 }
-}
+}  // namespace angle
+
+namespace gl
+{
+class ContextState;
+}  // namespace gl
 
 #endif // LIBANGLE_ANGLETYPES_H_

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -16,7 +16,7 @@
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
-#include "libANGLE/renderer/d3d/VaryingPacking.h"
+#include "libANGLE/renderer/d3d/hlsl/VaryingPacking.h"
 
 using namespace gl;
 
@@ -121,13 +121,6 @@ constexpr const char *VERTEX_ATTRIBUTE_STUB_STRING = "@@ VERTEX ATTRIBUTES @@";
 constexpr const char *PIXEL_OUTPUT_STUB_STRING     = "@@ PIXEL OUTPUT @@";
 }  // anonymous namespace
 
-std::string GetVaryingSemantic(int majorShaderModel, bool programUsesPointSize)
-{
-    // SM3 reserves the TEXCOORD semantic for point sprite texcoords (gl_PointCoord)
-    // In D3D11 we manually compute gl_PointCoord in the GS.
-    return ((programUsesPointSize && majorShaderModel < 4) ? "COLOR" : "TEXCOORD");
-}
-
 // DynamicHLSL implementation
 
 DynamicHLSL::DynamicHLSL(RendererD3D *const renderer) : mRenderer(renderer)

src/libANGLE/renderer/d3d/DynamicHLSL.h

@@ -97,7 +97,6 @@ class DynamicHLSL : angle::NonCopyable
                                                 const sh::ShaderVariable &shaderAttrib) const;
 };
 
-std::string GetVaryingSemantic(int majorShaderModel, bool programUsesPointSize);
 }
 
 #endif  // LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -21,8 +21,8 @@
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
 #include "libANGLE/renderer/d3d/ShaderExecutableD3D.h"
-#include "libANGLE/renderer/d3d/VaryingPacking.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
+#include "libANGLE/renderer/d3d/hlsl/VaryingPacking.h"
 
 using namespace angle;
 
@@ -473,6 +473,60 @@ const ShaderD3D *ProgramD3DMetadata::getFragmentShader() const
     return mFragmentShader;
 }
 
+void ProgramD3DMetadata::updatePackingBuiltins(ShaderType shaderType, VaryingPacking *packing)
+{
+    const std::string &userSemantic =
+        GetVaryingSemantic(mRendererMajorShaderModel, usesSystemValuePointSize());
+
+    unsigned int reservedSemanticIndex = packing->getMaxSemanticIndex();
+
+    VaryingPacking::BuiltinInfo *builtins = &packing->builtins(shaderType);
+
+    if (mRendererMajorShaderModel >= 4)
+    {
+        builtins->dxPosition.enableSystem("SV_Position");
+    }
+    else if (shaderType == SHADER_PIXEL)
+    {
+        builtins->dxPosition.enableSystem("VPOS");
+    }
+    else
+    {
+        builtins->dxPosition.enableSystem("POSITION");
+    }
+
+    if (usesTransformFeedbackGLPosition())
+    {
+        builtins->glPosition.enable(userSemantic, reservedSemanticIndex++);
+    }
+
+    if (usesFragCoord())
+    {
+        builtins->glFragCoord.enable(userSemantic, reservedSemanticIndex++);
+    }
+
+    if (shaderType == SHADER_VERTEX ? addsPointCoordToVertexShader() : usesPointCoord())
+    {
+        // SM3 reserves the TEXCOORD semantic for point sprite texcoords (gl_PointCoord)
+        // In D3D11 we manually compute gl_PointCoord in the GS.
+        if (mRendererMajorShaderModel >= 4)
+        {
+            builtins->glPointCoord.enable(userSemantic, reservedSemanticIndex++);
+        }
+        else
+        {
+            builtins->glPointCoord.enable("TEXCOORD", 0);
+        }
+    }
+
+    // Special case: do not include PSIZE semantic in HLSL 3 pixel shaders
+    if (usesSystemValuePointSize() &&
+        (shaderType != SHADER_PIXEL || mRendererMajorShaderModel >= 4))
+    {
+        builtins->glPointSize.enableSystem("PSIZE");
+    }
+}
+
 // ProgramD3D Implementation
 
 ProgramD3D::VertexExecutable::VertexExecutable(const gl::InputLayout &inputLayout,
@@ -1444,8 +1498,8 @@ LinkResult ProgramD3D::link(const gl::ContextState &data, gl::InfoLog &infoLog)
 
     ProgramD3DMetadata metadata(mRenderer, vertexShaderD3D, fragmentShaderD3D);
 
-    varyingPacking.enableBuiltins(SHADER_VERTEX, metadata);
-    varyingPacking.enableBuiltins(SHADER_PIXEL, metadata);
+    metadata.updatePackingBuiltins(SHADER_VERTEX, &varyingPacking);
+    metadata.updatePackingBuiltins(SHADER_PIXEL, &varyingPacking);
 
     if (static_cast<GLuint>(varyingPacking.getRegisterCount()) > data.getCaps().maxVaryingVectors)
     {
@@ -1486,7 +1540,7 @@ LinkResult ProgramD3D::link(const gl::ContextState &data, gl::InfoLog &infoLog)
 
     if (mRenderer->getMajorShaderModel() >= 4)
     {
-        varyingPacking.enableBuiltins(SHADER_GEOMETRY, metadata);
+        metadata.updatePackingBuiltins(SHADER_GEOMETRY, &varyingPacking);
         mGeometryShaderPreamble = mDynamicHLSL->generateGeometryShaderPreamble(varyingPacking);
     }
 

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -119,6 +119,9 @@ class ProgramD3DMetadata final : angle::NonCopyable
     GLint getMajorShaderVersion() const;
     const ShaderD3D *getFragmentShader() const;
 
+    // Applies the metadata structure to the varying packing.
+    void updatePackingBuiltins(ShaderType shaderType, VaryingPacking *packing);
+
   private:
     const int mRendererMajorShaderModel;
     const std::string mShaderModelSuffix;

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -9,20 +9,20 @@
 #ifndef LIBANGLE_RENDERER_D3D_RENDERERD3D_H_
 #define LIBANGLE_RENDERER_D3D_RENDERERD3D_H_
 
+#include <array>
+
 #include "common/debug.h"
 #include "common/MemoryBuffer.h"
 #include "libANGLE/ContextState.h"
 #include "libANGLE/Device.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
-#include "libANGLE/renderer/d3d/formatutilsD3D.h"
 #include "libANGLE/renderer/d3d/WorkaroundsD3D.h"
+#include "libANGLE/renderer/d3d/hlsl/hlsl_utils.h"
+#include "libANGLE/renderer/d3d/formatutilsD3D.h"
 #include "libANGLE/Version.h"
 #include "libANGLE/WorkerThread.h"
 
-//FIXME(jmadill): std::array is currently prohibited by Chromium style guide
-#include <array>
-
 namespace egl
 {
 class ConfigSet;
@@ -56,14 +56,6 @@ struct TranslatedIndexData;
 class UniformStorageD3D;
 class VertexBuffer;
 
-enum ShaderType
-{
-    SHADER_VERTEX,
-    SHADER_PIXEL,
-    SHADER_GEOMETRY,
-    SHADER_TYPE_MAX
-};
-
 struct DeviceIdentifier
 {
     UINT VendorId;

src/libANGLE/renderer/d3d/VaryingPacking.cpp → src/libANGLE/renderer/d3d/hlsl/VaryingPacking.cpp

@@ -8,12 +8,11 @@
 //   for linking between shader stages.
 //
 
-#include "libANGLE/renderer/d3d/VaryingPacking.h"
+#include "libANGLE/renderer/d3d/hlsl/VaryingPacking.h"
 
 #include "common/utilities.h"
 #include "compiler/translator/blocklayoutHLSL.h"
-#include "libANGLE/renderer/d3d/DynamicHLSL.h"
-#include "libANGLE/renderer/d3d/ProgramD3D.h"
+#include "libANGLE/Program.h"
 
 namespace rx
 {
@@ -158,7 +157,7 @@ bool VaryingPacking::packVarying(const PackedVarying &packedVarying)
                     registerInfo.registerRow       = row + arrayIndex;
                     registerInfo.registerColumn    = bestColumn;
                     registerInfo.varyingArrayIndex = arrayIndex;
-                    registerInfo.varyingRowIndex = 0;
+                    registerInfo.varyingRowIndex   = 0;
                     mRegisterList.push_back(registerInfo);
                     mRegisterMap[row + arrayIndex][bestColumn] = true;
                 }
@@ -213,8 +212,8 @@ void VaryingPacking::insert(unsigned int registerRow,
     {
         for (unsigned int varyingRow = 0; varyingRow < varyingRows; ++varyingRow)
         {
-            registerInfo.registerRow       = registerRow + (arrayElement * varyingRows) + varyingRow;
-            registerInfo.varyingRowIndex   = varyingRow;
+            registerInfo.registerRow     = registerRow + (arrayElement * varyingRows) + varyingRow;
+            registerInfo.varyingRowIndex = varyingRow;
             registerInfo.varyingArrayIndex = arrayElement;
             mRegisterList.push_back(registerInfo);
 
@@ -338,64 +337,4 @@ unsigned int VaryingPacking::getRegisterCount() const
     return count;
 }
 
-void VaryingPacking::enableBuiltins(ShaderType shaderType,
-                                    const ProgramD3DMetadata &programMetadata)
-{
-    int majorShaderModel = programMetadata.getRendererMajorShaderModel();
-    bool position        = programMetadata.usesTransformFeedbackGLPosition();
-    bool fragCoord       = programMetadata.usesFragCoord();
-    bool pointCoord = shaderType == SHADER_VERTEX ? programMetadata.addsPointCoordToVertexShader()
-                                                  : programMetadata.usesPointCoord();
-    bool pointSize                  = programMetadata.usesSystemValuePointSize();
-    bool hlsl4                      = (majorShaderModel >= 4);
-    const std::string &userSemantic = GetVaryingSemantic(majorShaderModel, pointSize);
-
-    unsigned int reservedSemanticIndex = getMaxSemanticIndex();
-
-    BuiltinInfo *builtins = &mBuiltinInfo[shaderType];
-
-    if (hlsl4)
-    {
-        builtins->dxPosition.enableSystem("SV_Position");
-    }
-    else if (shaderType == SHADER_PIXEL)
-    {
-        builtins->dxPosition.enableSystem("VPOS");
-    }
-    else
-    {
-        builtins->dxPosition.enableSystem("POSITION");
-    }
-
-    if (position)
-    {
-        builtins->glPosition.enable(userSemantic, reservedSemanticIndex++);
-    }
-
-    if (fragCoord)
-    {
-        builtins->glFragCoord.enable(userSemantic, reservedSemanticIndex++);
-    }
-
-    if (pointCoord)
-    {
-        // SM3 reserves the TEXCOORD semantic for point sprite texcoords (gl_PointCoord)
-        // In D3D11 we manually compute gl_PointCoord in the GS.
-        if (hlsl4)
-        {
-            builtins->glPointCoord.enable(userSemantic, reservedSemanticIndex++);
-        }
-        else
-        {
-            builtins->glPointCoord.enable("TEXCOORD", 0);
-        }
-    }
-
-    // Special case: do not include PSIZE semantic in HLSL 3 pixel shaders
-    if (pointSize && (shaderType != SHADER_PIXEL || hlsl4))
-    {
-        builtins->glPointSize.enableSystem("PSIZE");
-    }
-}
-
 }  // namespace rx

src/libANGLE/renderer/d3d/VaryingPacking.h → src/libANGLE/renderer/d3d/hlsl/VaryingPacking.h

@@ -8,15 +8,22 @@
 //   for linking between shader stages.
 //
 
-#ifndef LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_
-#define LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_
+#ifndef LIBANGLE_RENDERER_D3D_HLSL_VARYINGPACKING_H_
+#define LIBANGLE_RENDERER_D3D_HLSL_VARYINGPACKING_H_
 
-#include "libANGLE/renderer/d3d/RendererD3D.h"
+#include <GLSLANG/ShaderVars.h>
 
-namespace rx
+#include "angle_gl.h"
+#include "common/angleutils.h"
+#include "libANGLE/renderer/d3d/hlsl/hlsl_utils.h"
+
+namespace gl
 {
-class ProgramD3DMetadata;
+class InfoLog;
+}
 
+namespace rx
+{
 struct PackedVarying
 {
     PackedVarying(const sh::ShaderVariable &varyingIn, sh::InterpolationType interpolationIn)
@@ -125,8 +132,6 @@ class VaryingPacking final : angle::NonCopyable
     }
     unsigned int getRegisterCount() const;
 
-    void enableBuiltins(ShaderType shaderType, const ProgramD3DMetadata &programMetadata);
-
     struct BuiltinVarying final : angle::NonCopyable
     {
         BuiltinVarying();
@@ -151,6 +156,7 @@ class VaryingPacking final : angle::NonCopyable
     };
 
     const BuiltinInfo &builtins(ShaderType shaderType) const { return mBuiltinInfo[shaderType]; }
+    BuiltinInfo &builtins(ShaderType shaderType) { return mBuiltinInfo[shaderType]; }
 
     bool usesPointSize() const { return mBuiltinInfo[SHADER_VERTEX].glPointSize.enabled; }
 
@@ -172,4 +178,4 @@ class VaryingPacking final : angle::NonCopyable
 
 }  // namespace rx
 
-#endif  // LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_
+#endif  // LIBANGLE_RENDERER_D3D_HLSL_VARYINGPACKING_H_

src/libANGLE/renderer/d3d/hlsl/hlsl_utils.h

+//
+// Copyright 2015 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.
+//
+// hlsl_utils: Helper functions for HLSL.
+
+#ifndef LIBANGLE_RENDERER_D3D_HLSL_HLSL_UTILS_H_
+#define LIBANGLE_RENDERER_D3D_HLSL_HLSL_UTILS_H_
+
+#include <string>
+
+namespace rx
+{
+
+enum ShaderType
+{
+    SHADER_VERTEX,
+    SHADER_PIXEL,
+    SHADER_GEOMETRY,
+    SHADER_TYPE_MAX
+};
+
+inline std::string GetVaryingSemantic(int majorShaderModel, bool programUsesPointSize)
+{
+    // SM3 reserves the TEXCOORD semantic for point sprite texcoords (gl_PointCoord)
+    // In D3D11 we manually compute gl_PointCoord in the GS.
+    return ((programUsesPointSize && majorShaderModel < 4) ? "COLOR" : "TEXCOORD");
+}
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_D3D_HLSL_HLSL_UTILS_H_

src/libGLESv2.gypi

@@ -265,14 +265,18 @@
             'libANGLE/renderer/d3d/TextureD3D.cpp',
             'libANGLE/renderer/d3d/TextureD3D.h',
             'libANGLE/renderer/d3d/TextureStorage.h',
-            'libANGLE/renderer/d3d/VaryingPacking.cpp',
-            'libANGLE/renderer/d3d/VaryingPacking.h',
             'libANGLE/renderer/d3d/VertexBuffer.cpp',
             'libANGLE/renderer/d3d/VertexBuffer.h',
             'libANGLE/renderer/d3d/VertexDataManager.cpp',
             'libANGLE/renderer/d3d/VertexDataManager.h',
             'libANGLE/renderer/d3d/WorkaroundsD3D.h',
         ],
+        'libangle_d3d_hlsl_sources':
+        [
+            'libANGLE/renderer/d3d/hlsl/VaryingPacking.cpp',
+            'libANGLE/renderer/d3d/hlsl/VaryingPacking.h',
+            'libANGLE/renderer/d3d/hlsl/hlsl_utils.h',
+        ],
         'libangle_d3d9_sources':
         [
             'libANGLE/renderer/d3d/d3d9/Blit9.cpp',
@@ -826,6 +830,7 @@
                 {
                     'sources':
                     [
+                        '<@(libangle_d3d_hlsl_sources)',
                         '<@(libangle_d3d_shared_sources)',
                     ],
                 }],