o3djs: Recommit effect.js for skinning shader....

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 391 matching lines @@
 };
 
 
 /**
  * Builds the vertex attribute declarations for a given material.
  * @param {!o3d.Material} material The material to inspect.
  * @param {boolean} diffuse Whether to include stuff for diffuse calculations.
  * @param {boolean} specular Whether to include stuff for diffuse
  *     calculations.
  * @param {boolean} bumpSampler Whether there is a bump sampler.
+ * @param {boolean} skinning Whether this mesh has a skin.
  * @return {string} The code for the declarations.
  */
 o3djs.effect.buildAttributeDecls =
-    function(material, diffuse, specular, bumpSampler) {
+    function(material, diffuse, specular, bumpSampler, skinning) {
   var str = o3djs.effect.BEGIN_IN_STRUCT +
             o3djs.effect.ATTRIBUTE + o3djs.effect.FLOAT4 + ' ' + 'position' +
             o3djs.effect.semanticSuffix('POSITION') + ';\n';
   if (diffuse || specular) {
     str += o3djs.effect.ATTRIBUTE + o3djs.effect.FLOAT3 + ' ' + 'normal' +
     o3djs.effect.semanticSuffix('NORMAL') + ';\n';
   }
+  if (skinning) {
+    str += o3djs.effect.ATTRIBUTE + o3djs.effect.FLOAT4 + ' influenceWeights' +
+        o3djs.effect.semanticSuffix('BLENDWEIGHT') + ';\n';
+    str += o3djs.effect.ATTRIBUTE + o3djs.effect.FLOAT4 + ' influenceIndices' +
+        o3djs.effect.semanticSuffix('BLENDINDICES') + ';\n';
+  }
   str += o3djs.effect.buildTexCoords(material, false) +
          o3djs.effect.buildBumpInputCoords(bumpSampler) +
          o3djs.effect.END_STRUCT;
   return str;
 };
 
 
 /**
  * Caches the varying parameter declarations to be repeated in the case that
  * we're in glsl and need to declare the varying parameters in both shaders.
@@ skipping 398 matching lines @@
  * @param {string} effectType Type of effect to create ('phong', 'lambert',
  *     'constant').
  * @return {{description: string, shader: string}} A description and the shader
  *     string.
  */
 o3djs.effect.buildStandardShaderString = function(material,
                                                   effectType) {
   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).
+  var maxSkinUniforms = 36 * 3;
+  if (o3djs.base.o3d && o3djs.base.o3d.SkinEval &&
+      o3djs.base.o3d.SkinEval.getMaxNumBones) {
+    maxSkinUniforms = o3d.SkinEval.getMaxNumBones(material) * 3;
+    skinning = true;
+  } else {
+    skinning = false;
+  }
 
   /**
    * Extracts the texture type from a texture param.
    * @param {!o3d.ParamTexture} textureParam The texture parameter to
    *     inspect.
    * @return {string} The texture type (1D, 2D, 3D or CUBE).
    */
   var getTextureType = function(textureParam) {
     var texture = textureParam.value;
     if (!texture) return '2D';  // No texture value, have to make a guess.
@@ skipping 48 matching lines @@
   var buildLightingUniforms = function() {
     return 'uniform ' + p.MATRIX4 + ' world' +
         p.semanticSuffix('WORLD') + ';\n' +
         'uniform ' + p.MATRIX4 +
         ' viewInverse' + p.semanticSuffix('VIEWINVERSE') + ';\n' +
         'uniform ' + p.MATRIX4 + ' worldInverseTranspose' +
         p.semanticSuffix('WORLDINVERSETRANSPOSE') + ';\n';
   };
 
   /**
+   * If skinning is enabled, builds the bone matrix uniform variables needed
+   * for skinning. Otherwise, returns the empty string.
+   * @return {string} The effect code for skinning uniforms.
+   */
+  var buildSkinningUniforms = function() {
+    return skinning ? 'uniform ' + p.FLOAT4 + ' boneToWorld3x4' +
+        '[' + maxSkinUniforms + '];\n' +
+        'uniform float usingSkinShader;\n' : '';
+  };
+
+  /**
    * Builds uniform parameters for a given color input.  If the material
    * has a sampler parameter, a sampler uniform is created, otherwise a
    * float4 color value is created.
    * @param {!o3d.Material} material The material to inspect.
    * @param {!Array.<string>} descriptions Array to add descriptions too.
    * @param {string} name The name of the parameter to look for.  Usually
    *     emissive, ambient, diffuse or specular.
    * @param {boolean} opt_addColorParam Whether to add a color param if no
    *     sampler exists. Default = true.
    * @return {string} The effect code for the uniform parameter.
@@ skipping 41 matching lines @@
   /**
    * 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() +
            buildVertexDecls(material, false, false) +
            p.beginVertexShaderMain() +
            positionVertexShaderCode() +
            p.buildUVPassthroughs(material) +
            p.endVertexShaderMain() +
            p.pixelShaderHeader(material, false, false, bumpSampler) +
            buildCommonPixelUniforms() +
            p.repeatVaryingDecls() +
            buildColorParam(material, descriptions, 'emissive') +
            p.beginPixelShaderMain() +
            getColorParam(material, 'emissive') +
            p.endPixelShaderMain('emissive') +
            p.entryPoints() +
            p.matrixLoadOrder();
   };
 
   /**
    * Builds vertex and fragment shader string for the Lambert 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 buildLambertShaderString = function(material, descriptions) {
     descriptions.push('lambert');
     return buildCommonVertexUniforms() +
            buildLightingUniforms() +
+           buildSkinningUniforms() +
            buildVertexDecls(material, true, false) +
            p.beginVertexShaderMain() +
            p.buildUVPassthroughs(material) +
            positionVertexShaderCode() +
            normalVertexShaderCode() +
            surfaceToLightVertexShaderCode() +
            bumpVertexShaderCode() +
            p.endVertexShaderMain() +
            p.pixelShaderHeader(material, true, false) +
            buildCommonPixelUniforms() +
@@ skipping 27 matching lines @@
    *     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() +
         surfaceToViewVertexShaderCode() +
         bumpVertexShaderCode() +
         p.endVertexShaderMain() +
         p.pixelShaderHeader(material, true, true) +
@@ skipping 38 matching lines @@
    * 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() +
         surfaceToViewVertexShaderCode() +
         bumpVertexShaderCode() +
         p.endVertexShaderMain() +
         p.pixelShaderHeader(material, true, true) +
@@ skipping 30 matching lines @@
         '      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() {
-    return '  ' + p.VERTEX_VARYING_PREFIX + 'position = ' +
-        p.mul(p.ATTRIBUTE_PREFIX +
-        'position', 'worldViewProjection') + ';\n';
+    var attribute_position = p.ATTRIBUTE_PREFIX + 'position';
+    if (skinning) {
+      return '  ' + p.FLOAT4 + ' weightedpos = ' + attribute_position + ';\n' +
+          '  for (int i = 0; i < ' + maxSkinInfluences + '; i++) {\n' +
+          '    ' + p.FLOAT4 + ' temp = ' + p.FLOAT4 + '(' +
+          'dot(boneToWorld3x4[int(influenceIndices[i] * 3.0)], ' +
+          attribute_position + '),\n' +
+          '    dot(boneToWorld3x4[int(influenceIndices[i] * 3.0 + 1.0)], ' +
+          attribute_position + '),\n' +
+          '    dot(boneToWorld3x4[int(influenceIndices[i] * 3.0 + 2.0)], ' +
+          attribute_position + '),\n' +
+          '    1.0);\n' +
+          '    weightedpos += usingSkinShader * influenceWeights[i] * ' +
+          '(temp - ' + attribute_position + ');\n' +
+          '  }\n' +
+          '  ' + p.VERTEX_VARYING_PREFIX + 'position = ' +
+          p.mul('weightedpos', 'worldViewProjection') + ';\n';
+    } else {
+      return '  ' + p.VERTEX_VARYING_PREFIX + 'position = ' +
+          p.mul(attribute_position, 'worldViewProjection') + ';\n';
+    }
   };
 
   /**
    * Builds the normal code for the vertex shader.
    * @return {string} The code for the vertex shader.
    */
   var normalVertexShaderCode = function() {
-    return '  ' + p.VERTEX_VARYING_PREFIX + 'normal = ' +
-        p.mul(p.FLOAT4 + '(' +
-        p.ATTRIBUTE_PREFIX +
-        'normal, 0)', 'worldInverseTranspose') + '.xyz;\n';
+    var attribute_normal = p.ATTRIBUTE_PREFIX + 'normal';
+    if (skinning) {
+      return '  ' + p.FLOAT3 + ' weightednorm = ' + attribute_normal + ';\n' +
+          '  for (int i = 0; i < ' + maxSkinInfluences + '; i++) {\n' +
+          '    ' + p.FLOAT3 + ' temp = ' + p.FLOAT3 + '(' +
+          'dot(boneToWorld3x4[int(influenceIndices[i] * 3.0)].xyz, ' +
+          attribute_normal + '),\n' +
+          '    dot(boneToWorld3x4[int(influenceIndices[i] * 3.0 + 1.0)].xyz, ' +
+          attribute_normal + '),\n' +
+          '    dot(boneToWorld3x4[int(influenceIndices[i] * 3.0 + 2.0)].xyz, ' +
+          attribute_normal + '));\n' +
+          '    weightednorm += usingSkinShader * influenceWeights[i] * ' +
+          '(temp - ' + attribute_normal + ');\n' +
+          '  }\n' +
+          '  ' + p.VERTEX_VARYING_PREFIX + 'normal = ' +
+          p.mul(p.FLOAT4 + '(' + 'weightednorm' + ', 0)',
+                '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.
    * @return {string} The code for the vertex shader.
    */
   var surfaceToLightVertexShaderCode = function() {
     return '  ' + p.VERTEX_VARYING_PREFIX +
         'surfaceToLight = lightWorldPos - \n' +
            '                          ' +
@@ skipping 55 matching lines @@
    * Builds the vertex declarations for a given material.
    * @param {!o3d.Material} material The material to inspect.
    * @param {boolean} diffuse Whether to include stuff for diffuse
    *     calculations.
    * @param {boolean} specular Whether to include stuff for diffuse
    *     calculations.
    * @return {string} The code for the vertex declarations.
    */
   var buildVertexDecls = function(material, diffuse, specular) {
     return p.buildAttributeDecls(
-        material, diffuse, specular, bumpSampler) +
+        material, diffuse, specular, bumpSampler, skinning) +
         p.buildVaryingDecls(
             material, diffuse, specular, bumpSampler);
   };
 
 
   // Create a shader string of the appropriate type, based on the
   // effectType.
   var str;
   var descriptions = [];
   if (effectType == 'phong') {
@@ skipping 139 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');