o3d-webgl: convolution shader and error texture.

samples/o3d-webgl/effect.js

 /*
  * Copyright 2010, 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 44 matching lines @@
 
   /**
    * The number of elements.  Non-zero for array types, zero for non-array
    * types.
    * @type {number}
    */
   this.numElements = numElements || 0;
 
   /**
    * The semantic of the parameter. This is always in UPPERCASE.
-   * @type {o3d.Stream.Semantic}
+   * @type {string}
    */
-  this.semantic = semantic || o3d.Stream.UNKNOWN_SEMANTIC;
+  this.semantic = semantic || '';
 
   /**
    * If this is a standard parameter (SAS) this will be the name of the type
    * of Param needed. Otherwise it will be the empty string.
    *
    * Standard Parameters are generally handled automatically by o3d but you
    * can supply your own if you have a unique situation.
    *
    * @type {string}
    */
@@ skipping 181 matching lines @@
  */
 o3d.Effect.prototype.loadFromFXString =
     function(shaderString) {
   var splitIndex = shaderString.indexOf('// #o3d SplitMarker');
   return this.loadVertexShaderFromString(shaderString.substr(0, splitIndex)) &&
       this.loadPixelShaderFromString(shaderString.substr(splitIndex));
 };
 
 
 /**
+ * Generates an array of indexed strings. For example, given 'arr' and a size
+ * of 10, generates 'arr[0]', 'arr[1]', 'arr[2]' up to 'arr[9]'.
+ *
+ * @param {string} base The name of the array.
+ * @param {number} size The number of elements in the array.
+ * @return {!Array.<string>}
+ * @private
+ */
+o3d.Effect.prototype.getParamArrayNames_ = function(base, size) {
+  var names = [];
+  for (var i = 0; i < size; i++) {
+    names[i] = base + '[' + i + ']';
+  }
+  return names;
+}
+
+
+/**
  * Iterates through the active uniforms of the program and gets the
  * location of each one and stores them by name in the uniforms
  * object.
  * @private
  */
 o3d.Effect.prototype.getUniforms_ =
     function() {
   this.uniforms_ = {};
   var numUniforms = this.gl.getProgramParameter(
       this.program_, this.gl.ACTIVE_UNIFORMS);
   for (var i = 0; i < numUniforms; ++i) {
     var info = this.gl.getActiveUniform(this.program_, i);
-    this.uniforms_[info.name] = {info: info,
-        location: this.gl.getUniformLocation(this.program_, info.name)};
+    if (info.name.indexOf('[') != -1) {
+      // This is an array param and we need to individually query each item in
+      // the array to get its location.
+      var baseName = info.name.substring(0, info.name.indexOf('['));
+      var names = this.getParamArrayNames_(baseName, info.size);
+      var locations = [];
+      for (var j = 0; j < names.length; j++) {
+        locations[j] = this.gl.getUniformLocation(this.program_, names[j]);
+      }
+      this.uniforms_[baseName] = {
+          info: {name: baseName, size: info.size, type: info.type},
+          kind: o3d.Effect.ARRAY,
+          locations: locations /* mind the s */
+      };
+    } else {
+      // Not an array param.
+      this.uniforms_[info.name] = {
+          info: info,
+          kind: o3d.Effect.ELEMENT,
+          location: this.gl.getUniformLocation(this.program_, info.name)
+      };
+    }
   }
 };
 
 
 /**
  * Iterates through the active attributes of the program and gets the
  * location of each one and stores them by name in the attributes
  * object.
  * @private
  */
@@ skipping 34 matching lines @@
     o3d.Effect.paramTypes_[gl.INT] = 'ParamInteger';
     o3d.Effect.paramTypes_[gl.BOOL] = 'ParamBoolean';
     o3d.Effect.paramTypes_[gl.FLOAT_MAT4] = 'ParamMatrix4';
     o3d.Effect.paramTypes_[gl.SAMPLER_2D] = 'ParamSampler';
     o3d.Effect.paramTypes_[gl.SAMPLER_CUBE] = 'ParamSampler';
   }
 
   return o3d.Effect.paramTypes_;
 }
 
+
 /**
  * A map linking names of certain attributes in the shader to the corresponding
  * semantic and semantic index.
  * @private
  */
 o3d.Effect.semanticMap_ = {
   'position': {semantic: o3d.Stream.POSITION, index: 0, gl_index: 0},
   'normal': {semantic: o3d.Stream.NORMAL, index: 0, gl_index: 1},
   'tangent': {semantic: o3d.Stream.TANGENT, index: 0, gl_index: 2},
   'binormal': {semantic: o3d.Stream.BINORMAL, index: 0, gl_index: 3},
@@ skipping 21 matching lines @@
  * depending on your application it may be more appropriate to pass in a
  * Transform, Effect, Element or DrawElement.
  *
  * @param {!o3d.ParamObject} param_object The param object on which the
  *     new paramters will be created.
  */
 o3d.Effect.prototype.createUniformParameters =
     function(param_object) {
   var sasTypes = o3d.Param.sasTypes_;
   var paramTypes = o3d.Effect.getParamTypes_(this.gl);
-
   for (var name in this.uniforms_) {
-    var info = this.uniforms_[name].info;
+    var uniformData = this.uniforms_[name];
     if (!sasTypes[name]) {
-      param_object.createParam(info.name, paramTypes[info.type]);
+      switch (uniformData.kind) {
+        case o3d.Effect.ARRAY:
+          param_object.createParam(name, 'ParamParamArray');
+          break;
+        case o3d.Effect.STRUCT:
+          o3d.notImplemented();
+          break;
+        case o3d.Effect.ELEMENT:
+        default:
+          param_object.createParam(name, paramTypes[uniformData.info.type]);
+          break;
+      }
     }
   }
 };
 
 
 /**
  * For each of the effect's uniform parameters, if it is a SAS parameter
  * creates corresponding StandardParamMatrix4 parameters on the given
  * ParamObject.  Note that SAS parameters are handled automatically by the
  * rendering system. so except in some rare cases there is no reason to call
@@ skipping 22 matching lines @@
 
 
 /**
  * Gets info about the parameters this effect needs.
  * @return {!Array.<!o3d.EffectParameterInfo>} an array of
  *     EffectParameterInfo objects.
  */
 o3d.Effect.prototype.getParameterInfo = function() {
   var infoArray = [];
   var sasTypes = o3d.Param.sasTypes_;
+  var semanticMap = o3d.Effect.semanticMap_;
   var paramTypes = o3d.Effect.getParamTypes_(this.gl);
-  var semanticMap = o3d.Effect.semanticMap_;
 
   for (var name in this.uniforms_) {
-    var info = this.uniforms_[name].info;
-    var sasTypeName = sasTypes[name] || '';
-    var className = paramTypes[info.type] || '';
-    var numElements = 0;  // TODO(petersont): Add array support.
-    var semantic = (semanticMap[name] && semanticMap[name].semantic) ?
-        semanticMap[name].semantic : o3d.Stream.UNKNOWN_SEMANTIC;
-
+    var uniformData = this.uniforms_[name];
+    var sasClassName = sasTypes[name] || '';
+    var dataType = paramTypes[uniformData.info.type] || '';
+    var numElements = (uniformData.kind == o3d.Effect.ARRAY) ?
+        uniformData.info.size : 0; // 0 if a non-array type.
+    var semantic = semanticMap[name] ? name : '';
     infoArray.push(new o3d.EffectParameterInfo(
-      name, className, numElements, semantic, sasTypeName));
+      name, dataType, numElements, semantic.toUpperCase(), sasClassName));
   }
 
   return infoArray;
 };
 
 
 /**
  * Gets info about the streams this effect needs.
  * @return {!Array.<!o3d.EffectStreamInfo>} an array of
  *     EffectStreamInfo objects.
  */
 o3d.Effect.prototype.getStreamInfo = function() {
   var infoList = [];
 
   for (var name in this.attributes_) {
     var semantic_index_pair = o3d.Effect.semanticMap_[name];
     infoList.push(new o3d.EffectStreamInfo(
         semantic_index_pair.semantic, semantic_index_pair.index));
   }
   return infoList;
 };
 
 
 /**
  * Searches the objects in the given list for parameters to apply to the
  * uniforms defined on this effects program, and applies them, favoring
- * the objects nearer the begining of the list.
+ * the objects nearer the beginning of the list.
  *
  * @param {!Array.<!o3d.ParamObject>} object_list The param objects to search.
  * @private
  */
 o3d.Effect.prototype.searchForParams_ = function(object_list) {
   var filled_map = {};
   for (var name in this.uniforms_) {
     filled_map[name] = false;
   }
   this.gl.useProgram(this.program_);
   o3d.Param.texture_index_ = 0;
   for (var i = 0; i < object_list.length; ++i) {
     var obj = object_list[i];
     for (var name in this.uniforms_) {
       var uniformInfo = this.uniforms_[name];
       if (filled_map[name]) {
         continue;
       }
       var param = obj.getParam(name);
       if (param) {
-        param.applyToLocation(this.gl, uniformInfo.location);
+        if (uniformInfo.kind == o3d.Effect.ARRAY) {
+          param.applyToLocations(this.gl, uniformInfo.locations);
+        } else {
+          param.applyToLocation(this.gl, uniformInfo.location);
+        }
         filled_map[name] = true;
       }
     }
   }
 
   this.updateHelperConstants_(this.gl.displayInfo.width,
                               this.gl.displayInfo.height);
   filled_map[o3d.Effect.HELPER_CONSTANT_NAME] = true;
-
   for (var name in this.uniforms_) {
     if (!filled_map[name]) {
-      throw ('Uniform param not filled: "'+ name + '"');
+      if (this.uniforms_[name].info.type == this.gl.SAMPLER_2D) {
+        if (this.gl.client.reportErrors_()) {
+          this.gl.client.error_callback("Missing ParamSampler");
+        }
+        var defaultParamSampler = o3d.ParamSampler.defaultParamSampler_;
+        defaultParamSampler.gl = this.gl;
+        defaultParamSampler.applyToLocation(this.gl,
+            this.uniforms_[name].location);
+      } else {
+        throw ('Uniform param not filled: "'+ name + '"');
+      }
     }
   }
 };
 
 
 /**
  * Updates certain parameters used to make the GLSL shaders have the
  * same clipping semantics as D3D's.
  * @param {number} width width of the viewport in pixels
  * @param {number} height height of the viewport in pixels
@@ skipping 28 matching lines @@
  *  MatrixLoadOrder,
  *  ROW_MAJOR,  Matrix parameters are loaded in row-major order (DX-style).
  *  COLUMN_MAJOR,   Matrix parameters are loaded in column-major order
  *     (OpenGL-style).
  */
 o3d.Effect.ROW_MAJOR = 0;
 o3d.Effect.COLUMN_MAJOR = 1;
 
 
 /**
+ * UniformType,
+ * ELEMENT,   the param is a single gl.* element
+ * ARRAY,   the param is an array of same-typed elements
+ * STRUCT,   not implemented
+ */
+o3d.Effect.ELEMENT = 0;
+o3d.Effect.ARRAY = 1;
+o3d.Effect.STRUCT = 2;
+
+
+/**
  * The order in which matrix data is loaded to the GPU.
  * @type {o3d.Effect.MatrixLoadOrder}
  */
 o3d.Effect.prototype.matrix_load_order_ = o3d.Effect.ROW_MAJOR;
 
 
 /**
  * The source for the shaders on this Effect.
  * @type {string}
  */
 o3d.Effect.prototype.source_ = '';
-
-