commit 91445bce0e27b389d3be0f72f7cac5e48a7ba83e
author Jamie Madill <jmadill@chromium.org> Wed Sep 23 16:47:53 2015 -0400
committer Jamie Madill <jmadill@chromium.org> Thu Sep 24 18:34:28 2015 +0000
tree 51f4f35b49fbe6818b5d1446be5f3c31902b7125
parent 046e53e3706b1b43c04bc2c6af8676bb4c740832

Make a shader Shader::Data state structure.

This design follows the similar designs for Program, Framebuffer, etc.
Because of the current design, share a mutable pointer with the Impl
so the patch becomes a bit smaller and easier to review. In a follow-
up patch we can move the shared code into the GL layer.

BUG=angleproject:1159

Change-Id: Ib243e74779f23be51cdca80f1b5c6e5f3e36059d
Reviewed-on: https://chromium-review.googlesource.com/299876
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>

src/libANGLE/renderer/d3d/ProgramD3D.cpp

diff --git a/src/libANGLE/renderer/d3d/ProgramD3D.cpp b/src/libANGLE/renderer/d3d/ProgramD3D.cpp
index 4819ca0..9011f86 100644
--- a/src/libANGLE/renderer/d3d/ProgramD3D.cpp
+++ b/src/libANGLE/renderer/d3d/ProgramD3D.cpp
@@ -1002,11 +1002,11 @@
     mSamplersVS.resize(data.caps->maxVertexTextureImageUnits);
     mSamplersPS.resize(data.caps->maxTextureImageUnits);
 
-    mVertexHLSL = vertexShaderD3D->getTranslatedSource();
+    mVertexHLSL = vertexShader->getTranslatedSource();
     vertexShaderD3D->generateWorkarounds(&mVertexWorkarounds);
-    mShaderVersion = vertexShaderD3D->getShaderVersion();
+    mShaderVersion = vertexShader->getShaderVersion();
 
-    mPixelHLSL = fragmentShaderD3D->getTranslatedSource();
+    mPixelHLSL = fragmentShader->getTranslatedSource();
     fragmentShaderD3D->generateWorkarounds(&mPixelWorkarounds);
 
     if (mRenderer->getRendererLimitations().noFrontFacingSupport)
@@ -1346,28 +1346,23 @@
 
 void ProgramD3D::defineUniformsAndAssignRegisters()
 {
-    const gl::Shader *vertexShader   = mData.getAttachedVertexShader();
-    const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(vertexShader);
-
     D3DUniformMap uniformMap;
-
+    const gl::Shader *vertexShader   = mData.getAttachedVertexShader();
     for (const sh::Uniform &vertexUniform : vertexShader->getUniforms())
 
     {
         if (vertexUniform.staticUse)
         {
-            defineUniformBase(vertexShaderD3D, vertexUniform, &uniformMap);
+            defineUniformBase(vertexShader, vertexUniform, &uniformMap);
         }
     }
 
     const gl::Shader *fragmentShader   = mData.getAttachedFragmentShader();
-    const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(fragmentShader);
-
     for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms())
     {
         if (fragmentUniform.staticUse)
         {
-            defineUniformBase(fragmentShaderD3D, fragmentUniform, &uniformMap);
+            defineUniformBase(fragmentShader, fragmentUniform, &uniformMap);
         }
     }
 
@@ -1386,22 +1381,24 @@
     initializeUniformStorage();
 }
 
-void ProgramD3D::defineUniformBase(const ShaderD3D *shader,
+void ProgramD3D::defineUniformBase(const gl::Shader *shader,
                                    const sh::Uniform &uniform,
                                    D3DUniformMap *uniformMap)
 {
     if (uniform.isBuiltIn())
     {
-        defineUniform(shader, uniform, uniform.name, nullptr, uniformMap);
+        defineUniform(shader->getType(), uniform, uniform.name, nullptr, uniformMap);
         return;
     }
 
-    unsigned int startRegister = shader->getUniformRegister(uniform.name);
-    ShShaderOutput outputType = shader->getCompilerOutputType();
+    const ShaderD3D *shaderD3D = GetImplAs<ShaderD3D>(shader);
+
+    unsigned int startRegister = shaderD3D->getUniformRegister(uniform.name);
+    ShShaderOutput outputType = shaderD3D->getCompilerOutputType();
     sh::HLSLBlockEncoder encoder(sh::HLSLBlockEncoder::GetStrategyFor(outputType));
     encoder.skipRegisters(startRegister);
 
-    defineUniform(shader, uniform, uniform.name, &encoder, uniformMap);
+    defineUniform(shader->getType(), uniform, uniform.name, &encoder, uniformMap);
 }
 
 D3DUniform *ProgramD3D::getD3DUniformByName(const std::string &name)
@@ -1417,7 +1414,7 @@
     return nullptr;
 }
 
-void ProgramD3D::defineUniform(const ShaderD3D *shader,
+void ProgramD3D::defineUniform(GLenum shaderType,
                                const sh::ShaderVariable &uniform,
                                const std::string &fullName,
                                sh::HLSLBlockEncoder *encoder,
@@ -1437,7 +1434,7 @@
                 const sh::ShaderVariable &field = uniform.fields[fieldIndex];
                 const std::string &fieldFullName = (fullName + elementString + "." + field.name);
 
-                defineUniform(shader, field, fieldFullName, encoder, uniformMap);
+                defineUniform(shaderType, field, fieldFullName, encoder, uniformMap);
             }
 
             if (encoder)
@@ -1476,16 +1473,15 @@
             static_cast<unsigned int>(sh::HLSLBlockEncoder::getBlockRegisterElement(blockInfo));
         unsigned int reg =
             static_cast<unsigned int>(sh::HLSLBlockEncoder::getBlockRegister(blockInfo));
-        if (shader->getShaderType() == GL_FRAGMENT_SHADER)
+        if (shaderType == GL_FRAGMENT_SHADER)
         {
             d3dUniform->psRegisterIndex = reg;
         }
-        else if (shader->getShaderType() == GL_VERTEX_SHADER)
+        else
         {
+            ASSERT(shaderType == GL_VERTEX_SHADER);
             d3dUniform->vsRegisterIndex = reg;
         }
-        else
-            UNREACHABLE();
 
         // Arrays are treated as aggregate types
         if (uniform.isArray())