o3d-webgl: convolution shader and error texture.

samples/o3d-webgl/client.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 634 matching lines @@
   gl.hack_canvas = canvas;
   this.gl = gl;
   this.root.gl = gl;
   this.renderGraphRoot.gl = gl;
 
   gl.client = this;
   gl.displayInfo = {width: canvas.width,
                     height: canvas.height};
   o3d.State.createDefaultState_(gl).push_();
 
+  // Create the default error texture.
+  var defaultTexture = new o3d.Texture2D();
+  defaultTexture.gl = this.gl;
+  defaultTexture.init_(8, 8, o3d.Texture.ARGB8, 1, false);
+  var r = [1, 0, 0, 1];
+  var Y = [1, 1, 0, 1];
+  var error = [r, r, r, r, r, r, r, r,
+               r, r, Y, Y, Y, Y, r, r,
+               r, Y, r, r, r, Y, Y, r,
+               r, Y, r, r, Y, r, Y, r,
+               r, Y, r, Y, r, r, Y, r,
+               r, Y, Y, r, r, r, Y, r,
+               r, r, Y, Y, Y, Y, r, r,
+               r, r, r, r, r, r, r, r];
+  var pixels = [];
+  for (var i = 0; i < error.length; i++) {
+    for (var j = 0; j < 4; j++) {
+      pixels[i * 4 + j] = error[i][j];
+    }
+  }
+  defaultTexture.set(0, pixels);
+  defaultTexture.name = 'DefaultTexture';
+  this.fallback_error_texture_ = defaultTexture;
+  this.error_texture_ = defaultTexture;
+
   return true;
 };
 
 
 /**
  * Sets the per frame render callback.
  *
  * Note: The callback will not be called recursively. When your callback is
  * called if you somehow manage to cause the client to render more frames
  * before you've returned from the callback you will not be called for those
@@ skipping 245 matching lines @@
  * you get any errors using Client.setErrorCallback or Client.lastError.
  *
  * var t = g_pack.createTexture2D('', 1, 1, g_o3d.Texture.XRGB8, 1);
  * t.set(0, [0, 0, 0]);
  * g_client.setErrorTexture(t);
  *
  * @param {o3d.Texture} texture texture to use for missing textures or null.
  */
 o3d.Client.prototype.setErrorTexture =
     function(texture) {
-  o3d.notImplemented();
+  this.error_texture_ = texture;
 };
 
 
 /**
  * Sets a callback for when the client ticks. The client processes some things
  * like animation timers at up to 100hz.  This callback will get called before
  * each of those process ticks.
  *
  * NOTE: The client takes ownership of the TickCallback you
  * pass in. It will be deleted if you call SetTickCallback a
@@ skipping 40 matching lines @@
  * an alert everytime the client tries to render which is every time you close
  * the current alert which means you'll be in an infinite loop of alerts.
  *
  * @param {o3d.ErrorCallback} error_callback ErrorCallback to call when the
  *     Client gets an error.
  */
 o3d.Client.prototype.setErrorCallback =
     function(error_callback) {
   // Other code expects to not see a null error callback.
   if (error_callback) {
-    this.error_callback = error_callback;
+    this.error_callback = this.wrapErrorCallback_(error_callback);
   } else {
-    this.error_callback = function(string) {};
+    this.error_callback = function(string) {
+      this.last_error_ = string;
+    };
   }
 };
 
 
 /**
+ * Wraps a callback function, saving the error string so that the
+ * lastError variable can access it.
+ *
+ * @param {function} error_callback User-defined error callback.
+ * @return {function} Wrapped error callback.
+ * @private
+ */
+o3d.Client.prototype.wrapErrorCallback_ = function(error_callback) {
+  return function(string) {
+    this.last_error_ = string;
+    error_callback(string);
+  }
+}
+
+
+/**
  * Clears the Error callback
  *
  * NOTE: The client takes ownership of the ErrorCallback you
  * pass in. It will be deleted if you call SetErrorCallback a second
  * time or if you call ClearErrorCallback.
  */
 o3d.Client.prototype.clearErrorCallback = function() {
   this.setErrorCallback(null);
 };
 
@@ skipping 96 matching lines @@
  * Returns the status of initializing the renderer so we can display the
  * appropriate message. We require a certain minimum set of graphics
  * capabilities. If the user's computer does not have his minimum
  * set this will be GPU_NOT_UP_TO_SPEC. If the user is out of graphics
  * resources this will be OUT_OF_RESOURCES. If some other error happened this
  * will be INITIALIZATION_ERROR. Otherwise it will be SUCCESS.
  */
 o3d.Client.prototype.renderer_init_status = 0;
 
 
-
 /**
  * Gets / Sets the cursor's shape.
  *
  * @type {o3d.Cursor}
  */
 o3d.Client.prototype.cursor = null;
 
 
 /**
+ * The current error texture.
+ *
+ * @type {o3d.Texture}
+ * @private
+ */
+o3d.Client.prototype.error_texture_ = null;
+
+
+/**
+ * The fallback error texture. Should only be initialized once per client and
+ * is read-only.
+ *
+ * @type {!o3d.Texture}
+ * @private
+ */
+o3d.Client.prototype.fallback_error_texture_ = null;
+
+
+/**
  * The last error reported by the plugin.
  *
  * @type {string}
+ * @private
  */
 o3d.Client.prototype.last_error_ = '';
+o3d.Client.prototype.__defineGetter__('lastError',
+    function() {
+      return this.last_error_;
+    }
+);
 
+/**
+ * Returns true if missing textures, samplers or ParamSamplers should be
+ * reported by calling the error callback. We assume that if the user
+ * explicitly sets the error texture to null, then they want such errors to
+ * trigger the error callback.
+ *
+ * @return {boolean}
+ * @private
+ */
+o3d.Client.prototype.reportErrors_ = function() {
+  return (this.error_texture_ == null);
+}
 
 
 /**
  * All the objects managed by this client.
  *
  * Each access to this field gets the entire list so it is best to get it
  * just once. For example:
  *
  * var objects = client.objects;
  * for (var i = 0; i < objects.length; i++) {
  *   var object = objects[i];
  * }
  *
  *
  * Note that modifications to this array [e.g. push()] will not affect
  * the underlying Client, while modifications to the array's members
  * will affect them.
  *
  * @type {!Array.<!o3d.ObjectBase>}
  */
 o3d.Client.prototype.objects = [];
 
 
 
 /**
  * Clears the error returned in lastError.
  */
 o3d.Client.prototype.clearLastError = function () {
-  o3d.notImplemented();
+  this.last_error_ = '';
 };
 
 
 
 /**
  * Resets the profiling information.
  */
 o3d.Client.prototype.profileReset = function() {
   o3d.notImplemented();
 };
@@ skipping 23 matching lines @@
  * Gets info about the client.
  */
 o3d.Client.prototype.clientInfo = null;
 
 
 /**
  * The canvas associated with this client.
  * @type {Element}
  */
 o3d.Client.prototype.canvas = null;
-
-