Handle uniform precision mismatches

Source/Renderer/Context.js

@@ -263,6 +263,9 @@ define([
         ContextLimits._maximumViewportWidth = maximumViewportDimensions[0];
         ContextLimits._maximumViewportHeight = maximumViewportDimensions[1];
 
+        var highp = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT);
+        ContextLimits._highpSupported = highp.precision !== 0;
+
         this._antialias = gl.getContextAttributes().antialias;
 
         // Query and initialize extensions

Source/Renderer/ContextLimits.js

@@ -27,7 +27,8 @@ define([
         _maximumViewportHeight : 0,
         _maximumTextureFilterAnisotropy : 0,
         _maximumDrawBuffers : 0,
-        _maximumColorAttachments : 0
+        _maximumColorAttachments : 0,
+        _highpSupported : false
     };
 
     defineProperties(ContextLimits, {
@@ -264,7 +265,19 @@ define([
             get: function () {
                 return ContextLimits._maximumColorAttachments;
             }
+        },
+
+        /**
+         * High precision supported (<code>highp</code>) in fragment shaders.
+         * @memberof ContextLimits
+         * @type {Boolean}
+         */
+        highpSupported : {
+            get: function () {
+                return ContextLimits._highpSupported;
+            }
         }
+
     });
 
     return ContextLimits;

Source/Renderer/ShaderProgram.js

@@ -7,6 +7,7 @@ define([
         '../Core/DeveloperError',
         '../Core/RuntimeError',
         './AutomaticUniforms',
+        './ContextLimits',
         './createUniform',
         './createUniformArray'
     ], function(
@@ -17,6 +18,7 @@ define([
         DeveloperError,
         RuntimeError,
         AutomaticUniforms,
+        ContextLimits,
         createUniform,
         createUniformArray) {
     "use strict";
@@ -27,7 +29,51 @@ define([
     /**
      * @private
      */
+
+    function extractUniforms(shaderText) {
+        // TODO: regex doesn't work for inline structs
+        var uniformNames = [];
+        var uniformLines = shaderText.match(/uniform[\w\s]*(?=[=\[;])/g);
+        if (uniformLines) {
+            for (var i = 0; i < uniformLines.length; i++) {
+                var line = uniformLines[i].trim();
+                var name = line.slice(line.lastIndexOf(' ') + 1);
+                uniformNames.push(name);
+            }
+        }
+        return uniformNames;
+    }
+
     var ShaderProgram = function(options) {
+        // If a uniform exists in both the vertex and fragment shader but with different precision qualifiers,
+        // give the fragment shader uniform a different name. This fixes shader compilation errors on devices
+        // that only support mediump in the fragment shader.
+        var vertexShaderText = options.vertexShaderText;
+        var fragmentShaderText = options.fragmentShaderText;
+        var duplicateUniformNames = {};
+
+        if (!ContextLimits.highpSupported) {
+            var vertexShaderUniforms = extractUniforms(vertexShaderText);
+            var fragmentShaderUniforms = extractUniforms(fragmentShaderText);
+
+            // Find uniforms used in both
+            var i, j;
+            var uniformName;
+            var duplicateName;
+            for (i = 0; i < vertexShaderUniforms.length; i++) {
+                for (j = 0; j < fragmentShaderUniforms.length; j++) {
+                    if (vertexShaderUniforms[i] === fragmentShaderUniforms[j]) {
+                        uniformName = vertexShaderUniforms[i];
+                        duplicateName = uniformName + "_f";
+                        // Update fragmentShaderText with renamed uniforms
+                        var re = new RegExp(uniformName + "\\b", "g");
+                        fragmentShaderText = fragmentShaderText.replace(re, duplicateName);
+                        duplicateUniformNames[duplicateName] = uniformName;
+                    }
+                }
+            }
+        }
+
         this._gl = options.gl;
         this._logShaderCompilation = options.logShaderCompilation;
         this._debugShaders = options.debugShaders;
@@ -40,6 +86,7 @@ define([
         this._uniforms = undefined;
         this._automaticUniforms = undefined;
         this._manualUniforms = undefined;
+        this._duplicateUniformNames = duplicateUniformNames;
         this._cachedShader = undefined; // Used by ShaderCache
 
         /**
@@ -48,9 +95,9 @@ define([
         this.maximumTextureUnitIndex = undefined;
 
         this._vertexShaderSource = options.vertexShaderSource;
-        this._vertexShaderText = options.vertexShaderText;
+        this._vertexShaderText = vertexShaderText;
         this._fragmentShaderSource = options.fragmentShaderSource;
-        this._fragmentShaderText = options.fragmentShaderText;
+        this._fragmentShaderText = fragmentShaderText;
 
         /**
          * @private
@@ -346,20 +393,28 @@ define([
         };
     }
 
-    function partitionUniforms(uniforms) {
+    function partitionUniforms(shader, uniforms) {
         var automaticUniforms = [];
         var manualUniforms = [];
 
-        for ( var uniform in uniforms) {
+        for (var uniform in uniforms) {
             if (uniforms.hasOwnProperty(uniform)) {
-                var automaticUniform = AutomaticUniforms[uniform];
+                var uniformObject = uniforms[uniform];
+                var uniformName = uniform;
+                // if it's a duplicate uniform, use its original name so it is updated correctly
+                var duplicateUniform = shader._duplicateUniformNames[uniformName];
+                if (duplicateUniform) {
+                    uniformObject.name = duplicateUniform;
+                    uniformName = duplicateUniform;
+                }
+                var automaticUniform = AutomaticUniforms[uniformName];
                 if (automaticUniform) {
                     automaticUniforms.push({
-                        uniform : uniforms[uniform],
+                        uniform : uniformObject,
                         automaticUniform : automaticUniform
                     });
                 } else {
-                    manualUniforms.push(uniforms[uniform]);
+                    manualUniforms.push(uniformObject);
                 }
             }
         }
@@ -393,7 +448,7 @@ define([
         var program = createAndLinkProgram(gl, shader, shader._debugShaders);
         var numberOfVertexAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
         var uniforms = findUniforms(gl, program);
-        var partitionedUniforms = partitionUniforms(uniforms.uniformsByName);
+        var partitionedUniforms = partitionUniforms(shader, uniforms.uniformsByName);
 
         shader._program = program;
         shader._numberOfVertexAttributes = numberOfVertexAttributes;

Source/Renderer/ShaderSource.js

@@ -14,6 +14,9 @@ define([
     "use strict";
 
     function removeComments(source) {
+        // remove inline comments
+        source = source.replace(/\/\/.*/g, '');
+        // remove multiline comment block
         return source.replace(/\/\*\*[\s\S]*?\*\//gm, function(match) {
             // preserve the number of lines in the comment block so the line numbers will be correct when debugging shaders
             var numberOfLines = match.match(/\n/gm).length;

Specs/Renderer/ShaderProgramSpec.js

@@ -12,6 +12,7 @@ defineSuite([
         'Renderer/Buffer',
         'Renderer/BufferUsage',
         'Renderer/ClearCommand',
+        'Renderer/ContextLimits',
         'Renderer/DrawCommand',
         'Renderer/ShaderSource',
         'Renderer/VertexArray',
@@ -29,6 +30,7 @@ defineSuite([
         Buffer,
         BufferUsage,
         ClearCommand,
+        ContextLimits,
         DrawCommand,
         ShaderSource,
         VertexArray,
@@ -77,7 +79,7 @@ defineSuite([
         }
     });
 
-    function renderFragment(context, shaderProgram) {
+    function renderFragment(context, shaderProgram, uniformMap) {
         va = new VertexArray({
             context : context,
             attributes : [{
@@ -97,7 +99,8 @@ defineSuite([
         var command = new DrawCommand({
             primitiveType : PrimitiveType.POINTS,
             shaderProgram : shaderProgram,
-            vertexArray : va
+            vertexArray : va,
+            uniformMap : uniformMap
         });
         command.execute(context);
 
@@ -355,6 +358,27 @@ defineSuite([
         expect(renderFragment(context, sp)).toEqual([255, 255, 255, 255]);
     });
 
+    it('creates duplicate uniforms if precision of uniforms in vertex and fragment shader do not match', function() {
+        var highpSupported = ContextLimits.highpSupported;
+        ContextLimits._highpSupported = false;
+        var vs = 'attribute vec4 position; uniform float u_value; varying float v_value; void main() { gl_PointSize = 1.0; v_value = u_value + czm_viewport.z*0.2; gl_Position = position; }';
+        var fs = 'uniform float u_value; varying float v_value; void main() { gl_FragColor = vec4(u_value + v_value + czm_viewport.z*0.2); }';
+        sp = ShaderProgram.fromCache({
+            context : context,
+            vertexShaderSource : vs,
+            fragmentShaderSource : fs
+        });
+        var uniformMap = {
+            u_value : function() {
+                return 0.2;
+            }
+        };
+        expect(sp.allUniforms.u_value).toBeDefined();
+        expect(sp.allUniforms.u_value_f).toBeDefined();
+        expect(renderFragment(context, sp, uniformMap)).toEqual([204, 204, 204, 204]);
+        ContextLimits._highpSupported = highpSupported;
+    });
+
     it('1 level function dependency', function() {
         var vs = 'attribute vec4 position; void main() { gl_PointSize = 1.0; gl_Position = position; }';
         var fs =