o3djs: Multiple simple lights, and a new demo.

o3djs/effect.js

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 448 matching lines @@
       p.VARYING_DECLARATION_PREFIX + 'position' +
       p.semanticSuffix('POSITION') + ';\n' +
       p.buildTexCoords(material, true) +
       p.buildBumpOutputCoords(bumpSampler);
   if (diffuse || specular) {
     str += p.VARYING + p.FLOAT3 + ' ' +
         p.VARYING_DECLARATION_PREFIX + 'normal' +
         p.semanticSuffix('TEXCOORD' +
            p.interpolant_++ + '') + ';\n' +
         p.VARYING + p.FLOAT3 + ' ' +
-        p.VARYING_DECLARATION_PREFIX + 'surfaceToLight' +
+        p.VARYING_DECLARATION_PREFIX + 'surfacePosition' +
         p.semanticSuffix(
             'TEXCOORD' + p.interpolant_++ + '') + ';\n';
   }
   if (specular) {
     str += p.VARYING + p.FLOAT3 + ' ' +
         p.VARYING_DECLARATION_PREFIX + 'surfaceToView' +
         p.semanticSuffix(
             'TEXCOORD' + p.interpolant_++ + '') + ';\n';
   }
   str += p.END_STRUCT;
@@ skipping 349 matching lines @@
     effect.name = url;
   }
   return effect;
 };
 
 /**
  * Builds a shader string for a given standard COLLADA material type.
  *
  * @param {!o3d.Material} material Material for which to build the shader.
  * @param {string} effectType Type of effect to create ('phong', 'lambert',
- *     'constant').
+ *     'constant', 'blinn').
+ * @param {Object} opt_options Parameters to customize shader code generation.
+       See o3djs.effect.getStandardShader for details on the possible values.
  * @return {{description: string, shader: string}} A description and the shader
  *     string.
  */
 o3djs.effect.buildStandardShaderString = function(material,
-                                                  effectType) {
+                                                  effectType,
+                                                  opt_options) {
+  if (!opt_options) {
+    opt_options = {};
+  }
+  var numLights = 0;
+  var currentLightWorldPos = 'lightWorldPos';
+  if (opt_options.lights) {
+    numLights = opt_options.lights;
+    currentLightWorldPos = 'lightWorldPosList[i]';
+  }
   var p = o3djs.effect;
   var bumpSampler = material.getParam('bumpSampler');
   var bumpUVInterpolant;
   var skinning;
 
   var maxSkinInfluences = 4;
 
   // Hardcode reasonable maximum for number of skinning uniforms.
   // glsl: Table 6.19: minimum MAX_VERTEX_UNIFORM_VECTORS is 128.
   // (DX9 requires a minimum of 256, so not a problem in o3d).
@@ skipping 39 matching lines @@
       return getTextureType(textureParam);
     else
       return '2D';
   };
 
   /**
    * Builds uniform variables common to all standard lighting types.
    * @return {string} The effect code for the common shader uniforms.
    */
   var buildCommonVertexUniforms = function() {
+    //var size = numLights ? '['+numLights+']' : '';
     return 'uniform ' + p.MATRIX4 + ' worldViewProjection' +
-        p.semanticSuffix('WORLDVIEWPROJECTION') + ';\n' +
-        'uniform ' + p.FLOAT3 + ' lightWorldPos;\n';
+        p.semanticSuffix('WORLDVIEWPROJECTION') + ';\n';
   };
 
   /**
    * Builds uniform variables common to all standard lighting types.
    * @return {string} The effect code for the common shader uniforms.
    */
   var buildCommonPixelUniforms = function() {
-    return 'uniform ' + p.FLOAT4 + ' lightColor;\n';
+    if (numLights > 0) {
+      return 'uniform ' + p.FLOAT4 + ' lightColorList[' + numLights + '];\n' +
+          'uniform ' + p.FLOAT3 + ' lightWorldPosList[' + numLights + '];\n';
+    } else {
+      return 'uniform ' + p.FLOAT4 + ' lightColor;\n' +
+          'uniform ' + p.FLOAT3 + ' lightWorldPos' + ';\n';
+    }
   };
 
   /**
    * Builds uniform variables common to lambert, phong and blinn lighting types.
    * @return {string} The effect code for the common shader uniforms.
    */
   var buildLightingUniforms = function() {
     return 'uniform ' + p.MATRIX4 + ' world' +
         p.semanticSuffix('WORLD') + ';\n' +
         'uniform ' + p.MATRIX4 +
@@ skipping 59 matching lines @@
       var type = getSamplerType(samplerParam);
       return '  ' + p.FLOAT4 + ' ' + name + ' = ' + p.TEXTURE + type +
              '(' + name + 'Sampler, ' +
              p.PIXEL_VARYING_PREFIX + name + 'UV);\n'
     } else {
       return '';
     }
   };
 
   /**
+   * Begins a section of code which is to be run once for each light.
+   * @return {string} The effect code for the for loop, or the empty string if
+   *                  not using multiple lights.
+   */
+  var beginLightLoop = function() {
+    if (numLights) {
+      return '  ' + p.FLOAT4 + ' lightColorDiffuse = ' + p.FLOAT4 + '(0);\n' +
+          '  for (int i = 0; i < ' + numLights + '; i++) {\n';
+    } else {
+      return '';
+    }
+  };
+
+  /**
+   * Ends the block of code which is to be run for each light. Adds the current
+   * light's color times (diffuseExpression) into lightColorDiffuse.
+   * @param {string} diffuseExpression Expression to multiply by light color.
+   * @return {string} The effect code to set lightColorDiffuse.
+   */
+  var endLightLoop = function(diffuseExpression) {
+    if (numLights) {
+      return '    lightColorDiffuse += ' +
+          'lightColorList[i] * ( ' + diffuseExpression + ');\n' +
+          '  }\n';
+    } else {
+      return '  ' + p.FLOAT4 + ' lightColorDiffuse = ' +
+          'lightColor * (' + diffuseExpression + ');';
+    }
+  };
+
+  /**
    * Builds vertex and fragment shader string for the Constant lighting type.
    * @param {!o3d.Material} material The material for which to build
    *     shaders.
    * @param {!Array.<string>} descriptions Array to add descriptions too.
    * @return {string} The effect code for the shader, ready to be parsed.
    */
   var buildConstantShaderString = function(material, descriptions) {
     descriptions.push('constant');
     return buildCommonVertexUniforms() +
            buildSkinningUniforms() +
@@ skipping 23 matching lines @@
   var buildLambertShaderString = function(material, descriptions) {
     descriptions.push('lambert');
     return buildCommonVertexUniforms() +
            buildLightingUniforms() +
            buildSkinningUniforms() +
            buildVertexDecls(material, true, false) +
            p.beginVertexShaderMain() +
            p.buildUVPassthroughs(material) +
            positionVertexShaderCode() +
            normalVertexShaderCode() +
-           surfaceToLightVertexShaderCode() +
+           surfacePositionVertexShaderCode() +
            bumpVertexShaderCode() +
            p.endVertexShaderMain() +
            p.pixelShaderHeader(material, true, false) +
            buildCommonPixelUniforms() +
            p.repeatVaryingDecls() +
            buildColorParam(material, descriptions, 'emissive') +
            buildColorParam(material, descriptions, 'ambient') +
            buildColorParam(material, descriptions, 'diffuse') +
            buildColorParam(material, descriptions, 'bump', false) +
            p.utilityFunctions() +
            p.beginPixelShaderMain() +
            getColorParam(material, 'emissive') +
            getColorParam(material, 'ambient') +
            getColorParam(material, 'diffuse') +
            getNormalShaderCode() +
-           '  ' + p.FLOAT3 + ' surfaceToLight = normalize(' +
-           p.PIXEL_VARYING_PREFIX + 'surfaceToLight);\n' +
-           '  ' + p.FLOAT4 +
-           ' litR = lit(dot(normal, surfaceToLight), 0.0, 0.0);\n' +
+           beginLightLoop() +
+           '    ' + p.FLOAT3 + ' surfaceToLight = normalize(' +
+           currentLightWorldPos + ' - ' +
+           p.PIXEL_VARYING_PREFIX + 'surfacePosition);\n' +
+           '    ' + p.FLOAT4 +
+           '    litR = lit(dot(normal, surfaceToLight), 0.0, 0.0);\n' +
+           endLightLoop('ambient * diffuse + diffuse * litR.y') +
            p.endPixelShaderMain(p.FLOAT4 +
            '((emissive +\n' +
-           '      lightColor *' +
-           ' (ambient * diffuse + diffuse * litR.y)).rgb,\n' +
+           '      lightColorDiffuse).rgb,\n' +
            '          diffuse.a)') +
            p.entryPoints() +
            p.matrixLoadOrder();
   };
 
   /**
    * Builds vertex and fragment shader string for the Blinn lighting type.
    * @param {!o3d.Material} material The material for which to build
    *     shaders.
    * @param {!Array.<string>} descriptions Array to add descriptions too.
    * @return {string} The effect code for the shader, ready to be parsed.
    * TODO: This is actually just a copy of the Phong code.
    *     Change to Blinn.
    */
   var buildBlinnShaderString = function(material, descriptions) {
     descriptions.push('phong');
     return buildCommonVertexUniforms() +
         buildLightingUniforms() +
         buildSkinningUniforms() +
         buildVertexDecls(material, true, true) +
         p.beginVertexShaderMain() +
         p.buildUVPassthroughs(material) +
         positionVertexShaderCode() +
         normalVertexShaderCode() +
-        surfaceToLightVertexShaderCode() +
+        surfacePositionVertexShaderCode() +
         surfaceToViewVertexShaderCode() +
         bumpVertexShaderCode() +
         p.endVertexShaderMain() +
         p.pixelShaderHeader(material, true, true) +
         buildCommonPixelUniforms() +
         p.repeatVaryingDecls() +
         buildColorParam(material, descriptions, 'emissive') +
         buildColorParam(material, descriptions, 'ambient') +
         buildColorParam(material, descriptions, 'diffuse') +
         buildColorParam(material, descriptions, 'specular') +
         buildColorParam(material, descriptions, 'bump', false) +
         'uniform float shininess;\n' +
         'uniform float specularFactor;\n' +
         p.utilityFunctions() +
         p.beginPixelShaderMain() +
         getColorParam(material, 'emissive') +
         getColorParam(material, 'ambient') +
         getColorParam(material, 'diffuse') +
         getColorParam(material, 'specular') +
         getNormalShaderCode() +
-        '  ' + p.FLOAT3 + ' surfaceToLight = normalize(' +
-        p.PIXEL_VARYING_PREFIX + 'surfaceToLight);\n' +
         '  ' + p.FLOAT3 + ' surfaceToView = normalize(' +
         p.PIXEL_VARYING_PREFIX + 'surfaceToView);\n' +
-        '  ' + p.FLOAT3 +
-        ' halfVector = normalize(surfaceToLight + ' +
-        p.PIXEL_VARYING_PREFIX + 'surfaceToView);\n' +
-        '  ' + p.FLOAT4 +
+        beginLightLoop() +
+        '    ' + p.FLOAT3 + ' surfaceToLight = normalize(' +
+        currentLightWorldPos + ' - ' +
+        p.PIXEL_VARYING_PREFIX + 'surfacePosition);\n' +
+        '    ' + p.FLOAT3 +
+        ' halfVector = normalize(surfaceToLight + surfaceToView);\n' +
+        '    ' + p.FLOAT4 +
         ' litR = lit(dot(normal, surfaceToLight), \n' +
         '                    dot(normal, halfVector), shininess);\n' +
+        endLightLoop('ambient * diffuse + diffuse * litR.y\n' +
+        '                  + specular * litR.z * specularFactor') +
         p.endPixelShaderMain( p.FLOAT4 +
-        '((emissive +\n' +
-        '  lightColor *' +
-        ' (ambient * diffuse + diffuse * litR.y +\n' +
-        '                        + specular * litR.z *' +
-        ' specularFactor)).rgb,\n' +
+        '((emissive + lightColorDiffuse).rgb,\n' +
         '      diffuse.a)') +
         p.entryPoints() +
         p.matrixLoadOrder();
   };
 
   /**
    * Builds vertex and fragment shader string for the Phong lighting type.
    * @param {!o3d.Material} material The material for which to build
    *     shaders.
    * @param {!Array.<string>} descriptions Array to add descriptions too.
    * @return {string} The effect code for the shader, ready to be parsed.
    */
   var buildPhongShaderString = function(material, descriptions) {
     descriptions.push('phong');
     return buildCommonVertexUniforms() +
         buildLightingUniforms() +
         buildSkinningUniforms() +
         buildVertexDecls(material, true, true) +
         p.beginVertexShaderMain() +
         p.buildUVPassthroughs(material) +
         positionVertexShaderCode() +
         normalVertexShaderCode() +
-        surfaceToLightVertexShaderCode() +
+        surfacePositionVertexShaderCode() +
         surfaceToViewVertexShaderCode() +
         bumpVertexShaderCode() +
         p.endVertexShaderMain() +
         p.pixelShaderHeader(material, true, true) +
         buildCommonPixelUniforms() +
         p.repeatVaryingDecls() +
         buildColorParam(material, descriptions, 'emissive') +
         buildColorParam(material, descriptions, 'ambient') +
         buildColorParam(material, descriptions, 'diffuse') +
         buildColorParam(material, descriptions, 'specular') +
         buildColorParam(material, descriptions, 'bump', false) +
         'uniform float shininess;\n' +
         'uniform float specularFactor;\n' +
         p.utilityFunctions() +
         p.beginPixelShaderMain() +
         getColorParam(material, 'emissive') +
         getColorParam(material, 'ambient') +
         getColorParam(material, 'diffuse') +
         getColorParam(material, 'specular') +
         getNormalShaderCode() +
-        '  ' + p.FLOAT3 + ' surfaceToLight = normalize(' +
-        p.PIXEL_VARYING_PREFIX + 'surfaceToLight);\n' +
         '  ' + p.FLOAT3 + ' surfaceToView = normalize(' +
         p.PIXEL_VARYING_PREFIX + 'surfaceToView);\n' +
-        '  ' + p.FLOAT3 +
+        beginLightLoop() +
+        '    ' + p.FLOAT3 + ' surfaceToLight = normalize(' +
+        currentLightWorldPos + ' - ' +
+        p.PIXEL_VARYING_PREFIX + 'surfacePosition);\n' +
+        '    ' + p.FLOAT3 +
         ' halfVector = normalize(surfaceToLight + surfaceToView);\n' +
-        '  ' + p.FLOAT4 +
+        '    ' + p.FLOAT4 +
         ' litR = lit(dot(normal, surfaceToLight), \n' +
         '                    dot(normal, halfVector), shininess);\n' +
+        endLightLoop('ambient * diffuse + diffuse * litR.y +\n' +
+        '                  + specular * litR.z * specularFactor') +
         p.endPixelShaderMain(p.FLOAT4 +
-        '((emissive +\n' +
-        '  lightColor * (ambient * diffuse + diffuse * litR.y +\n' +
-        '                        + specular * litR.z *' +
-        ' specularFactor)).rgb,\n' +
+        '((emissive + lightColorDiffuse).rgb,\n' +
         '      diffuse.a)') +
         p.entryPoints() +
         p.matrixLoadOrder();
   };
 
   /**
    * Builds the position code for the vertex shader.
    * @return {string} The code for the vertex shader.
    */
   var positionVertexShaderCode = function() {
@@ skipping 44 matching lines @@
                 'worldInverseTranspose') + '.xyz;\n';
     } else {
       return '  ' + p.VERTEX_VARYING_PREFIX + 'normal = ' +
           p.mul(p.FLOAT4 + '(' +
           attribute_normal + ', 0)', 'worldInverseTranspose') +
           '.xyz;\n';
     }
   };
 
   /**
-   * Builds the surface to light code for the vertex shader.
+   * Builds the surface position code for the vertex shader. To support
+   * multiple lights, the dot product with each light should then be
+   * computed in the fragment shader.
    * @return {string} The code for the vertex shader.
    */
-  var surfaceToLightVertexShaderCode = function() {
+  var surfacePositionVertexShaderCode = function() {
     return '  ' + p.VERTEX_VARYING_PREFIX +
-        'surfaceToLight = lightWorldPos - \n' +
-           '                          ' +
+        'surfacePosition =  \n' +
            p.mul(p.ATTRIBUTE_PREFIX + 'position',
               'world') + '.xyz;\n';
   };
 
   /**
    * Builds the surface to view code for the vertex shader.
    * @return {string} The code for the vertex shader.
    */
   var surfaceToViewVertexShaderCode = function() {
     return '  ' + p.VERTEX_VARYING_PREFIX +
@@ skipping 79 matching lines @@
 
 /**
  * Gets or builds a shader for given standard COLLADA material type.
  *
  * Looks at the material passed in and assigns it an Effect that matches its
  * Params. If a suitable Effect already exists in pack it will use that Effect.
  *
  * @param {!o3d.Pack} pack Pack in which to create the new Effect.
  * @param {!o3d.Material} material Material for which to build the shader.
  * @param {string} effectType Type of effect to create ('phong', 'lambert',
- *     'constant').
+ *     'constant', 'blinn').
+ * @param {{lights: number}} opt_options Extra options.
+ *     If 'lights' is non-zero, creates an array of light params; otherwise
+ *     only a single light is supported.
  * @return {o3d.Effect} The created effect.
  */
 o3djs.effect.getStandardShader = function(pack,
                                           material,
-                                          effectType) {
+                                          effectType,
+                                          opt_options) {
   var record = o3djs.effect.buildStandardShaderString(material,
-                                                      effectType);
+                                                      effectType,
+                                                      opt_options);
   var effects = pack.getObjectsByClassName('o3d.Effect');
   for (var ii = 0; ii < effects.length; ++ii) {
     if (effects[ii].name == record.description &&
         effects[ii].source == record.shader) {
       return effects[ii];
     }
   }
   var effect = pack.createObject('Effect');
   if (effect) {
     effect.name = record.description;
     if (effect.loadFromFXString(record.shader)) {
       return effect;
     }
     pack.removeObject(effect);
   }
   return null;
 };
 
 /**
  * Attaches a shader for a given standard COLLADA material type to the
  * material.
  *
  * Looks at the material passed in and assigns it an Effect that matches its
  * Params. If a suitable Effect already exists in pack it will use that Effect.
  *
  * @param {!o3d.Pack} pack Pack in which to create the new Effect.
  * @param {!o3d.Material} material Material for which to build the shader.
  * @param {!o3djs.math.Vector3} lightPos Position of the default light.
  * @param {string} effectType Type of effect to create ('phong', 'lambert',
- *     'constant').
+ *     'constant', 'blinn').
+ * @param {Object} opt_options Extra options for effect.getStandardShader
  * @return {boolean} True on success.
  */
 o3djs.effect.attachStandardShader = function(pack,
                                              material,
                                              lightPos,
-                                             effectType) {
+                                             effectType,
+                                             opt_options) {
   var effect = o3djs.effect.getStandardShader(pack,
                                               material,
-                                              effectType);
+                                              effectType,
+                                              opt_options);
   if (effect) {
     material.effect = effect;
     effect.createUniformParameters(material);
 
     // Set a couple of the default parameters in the hopes that this will
     // help the user get something on the screen. We check to make sure they
     // are not connected to something otherwise we'll get an error.
     var param = material.getParam('lightWorldPos');
     if (param && !param.inputConnection) {
       param.value = lightPos;
@@ skipping 59 matching lines @@
   effect.name = o3djs.effect.TWO_COLOR_CHECKER_EFFECT_NAME;
   return effect;
 };
 
 
 // For compatability with o3d code, the default language is o3d shading
 // language.
 o3djs.effect.setLanguage('o3d');