commit 55def58323c359f5ab26c62757edcbe516259ada
author Jamie Madill <jmadill@chromium.org> Mon May 04 11:24:57 2015 -0400
committer Jamie Madill <jmadill@chromium.org> Mon May 04 17:21:28 2015 +0000
tree ffcf9455bb30701621d40364532922f0568eee90
parent 931c78cb7f310fad8e42af1faa47a0df1b30b570

translator: Fix variable collection for gl_DepthRange.

*re-land with Linux fixes, and fix for locations*

This built-in uniform wasn't being collected in VariableInfo.cpp.
Also remove the existing workaround for D3D gl_DepthRange
collection.

BUG=angleproject:991
BUG=478570

Change-Id: Iba84651bfc58f82fd4ce039421874f561f83c348
Reviewed-on: https://chromium-review.googlesource.com/268840
Tested-by: Jamie Madill <jmadill@chromium.org>
Reviewed-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 15cd8fb..71e9dc7 100644
--- a/src/libANGLE/renderer/d3d/ProgramD3D.cpp
+++ b/src/libANGLE/renderer/d3d/ProgramD3D.cpp
@@ -1375,7 +1375,9 @@
 
         if (uniform.staticUse)
         {
-            defineUniformBase(vertexShaderD3D, uniform, vertexShaderD3D->getUniformRegister(uniform.name));
+            unsigned int registerBase = uniform.isBuiltIn() ? GL_INVALID_INDEX :
+                vertexShaderD3D->getUniformRegister(uniform.name);
+            defineUniformBase(vertexShaderD3D, uniform, registerBase);
         }
     }
 
@@ -1385,7 +1387,9 @@
 
         if (uniform.staticUse)
         {
-            defineUniformBase(fragmentShaderD3D, uniform, fragmentShaderD3D->getUniformRegister(uniform.name));
+            unsigned int registerBase = uniform.isBuiltIn() ? GL_INVALID_INDEX :
+                fragmentShaderD3D->getUniformRegister(uniform.name);
+            defineUniformBase(fragmentShaderD3D, uniform, registerBase);
         }
     }
 
@@ -1396,21 +1400,17 @@
 
     initializeUniformStorage();
 
-    // special case for gl_DepthRange, the only built-in uniform (also a struct)
-    if (vertexShaderD3D->usesDepthRange() || fragmentShaderD3D->usesDepthRange())
-    {
-        const sh::BlockMemberInfo &defaultInfo = sh::BlockMemberInfo::getDefaultBlockInfo();
-
-        mUniforms.push_back(new gl::LinkedUniform(GL_FLOAT, GL_HIGH_FLOAT, "gl_DepthRange.near", 0, -1, defaultInfo));
-        mUniforms.push_back(new gl::LinkedUniform(GL_FLOAT, GL_HIGH_FLOAT, "gl_DepthRange.far", 0, -1, defaultInfo));
-        mUniforms.push_back(new gl::LinkedUniform(GL_FLOAT, GL_HIGH_FLOAT, "gl_DepthRange.diff", 0, -1, defaultInfo));
-    }
-
     return true;
 }
 
 void ProgramD3D::defineUniformBase(const ShaderD3D *shader, const sh::Uniform &uniform, unsigned int uniformRegister)
 {
+    if (uniformRegister == GL_INVALID_INDEX)
+    {
+        defineUniform(shader, uniform, uniform.name, nullptr);
+        return;
+    }
+
     ShShaderOutput outputType = shader->getCompilerOutputType();
     sh::HLSLBlockEncoder encoder(sh::HLSLBlockEncoder::GetStrategyFor(outputType));
     encoder.skipRegisters(uniformRegister);
@@ -1427,7 +1427,8 @@
         {
             const std::string &elementString = (uniform.isArray() ? ArrayString(elementIndex) : "");
 
-            encoder->enterAggregateType();
+            if (encoder)
+                encoder->enterAggregateType();
 
             for (size_t fieldIndex = 0; fieldIndex < uniform.fields.size(); fieldIndex++)
             {
@@ -1437,13 +1438,14 @@
                 defineUniform(shader, field, fieldFullName, encoder);
             }
 
-            encoder->exitAggregateType();
+            if (encoder)
+                encoder->exitAggregateType();
         }
     }
     else // Not a struct
     {
         // Arrays are treated as aggregate types
-        if (uniform.isArray())
+        if (uniform.isArray() && encoder)
         {
             encoder->enterAggregateType();
         }
@@ -1451,29 +1453,36 @@
         gl::LinkedUniform *linkedUniform = getUniformByName(fullName);
 
         // Advance the uniform offset, to track registers allocation for structs
-        sh::BlockMemberInfo blockInfo = encoder->encodeType(uniform.type, uniform.arraySize, false);
+        sh::BlockMemberInfo blockInfo = encoder ?
+            encoder->encodeType(uniform.type, uniform.arraySize, false) :
+            sh::BlockMemberInfo::getDefaultBlockInfo();
 
         if (!linkedUniform)
         {
             linkedUniform = new gl::LinkedUniform(uniform.type, uniform.precision, fullName, uniform.arraySize,
                                                   -1, sh::BlockMemberInfo::getDefaultBlockInfo());
             ASSERT(linkedUniform);
-            linkedUniform->registerElement = sh::HLSLBlockEncoder::getBlockRegisterElement(blockInfo);
+
+            if (encoder)
+                linkedUniform->registerElement = sh::HLSLBlockEncoder::getBlockRegisterElement(blockInfo);
             mUniforms.push_back(linkedUniform);
         }
 
-        if (shader->getShaderType() == GL_FRAGMENT_SHADER)
+        if (encoder)
         {
-            linkedUniform->psRegisterIndex = sh::HLSLBlockEncoder::getBlockRegister(blockInfo);
+            if (shader->getShaderType() == GL_FRAGMENT_SHADER)
+            {
+                linkedUniform->psRegisterIndex = sh::HLSLBlockEncoder::getBlockRegister(blockInfo);
+            }
+            else if (shader->getShaderType() == GL_VERTEX_SHADER)
+            {
+                linkedUniform->vsRegisterIndex = sh::HLSLBlockEncoder::getBlockRegister(blockInfo);
+            }
+            else UNREACHABLE();
         }
-        else if (shader->getShaderType() == GL_VERTEX_SHADER)
-        {
-            linkedUniform->vsRegisterIndex = sh::HLSLBlockEncoder::getBlockRegister(blockInfo);
-        }
-        else UNREACHABLE();
 
         // Arrays are treated as aggregate types
-        if (uniform.isArray())
+        if (uniform.isArray() && encoder)
         {
             encoder->exitAggregateType();
         }
@@ -1934,9 +1943,12 @@
             }
         }
 
-        for (unsigned int arrayElementIndex = 0; arrayElementIndex < uniform.elementCount(); arrayElementIndex++)
+        for (unsigned int arrayIndex = 0; arrayIndex < uniform.elementCount(); arrayIndex++)
         {
-            mUniformIndex.push_back(gl::VariableLocation(uniform.name, arrayElementIndex, uniformIndex));
+            if (!uniform.isBuiltIn())
+            {
+                mUniformIndex.push_back(gl::VariableLocation(uniform.name, arrayIndex, uniformIndex));
+            }
         }
     }