Added culling sample.

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 79 matching lines @@
  */
 o3d.Renderer.clients_ = [];
 
 
 /**
  * Renders all clients associated with this renderer.
  */
 o3d.Renderer.renderClients = function() {
   for (var i = 0; i < o3d.Renderer.clients_.length; ++i) {
     var client = o3d.Renderer.clients_[i];
-    var renderEvent = new o3d.RenderEvent;
-    var now = (new Date()).getTime() * 0.001;
-    if(client.then_ == 0.0)
-      renderEvent.elapsedTime = 0.0;
-    else
-      renderEvent.elapsedTime = now - client.then_;
-    client.updateDisplayInfo_();
-    if (client.render_callback) {
-      client.render_callback(renderEvent);
-    }
-    client.then_ = now;
-    client.renderTree(client.renderGraphRoot);
+
+    client.render();
   }
 };
 
 
 /**
  * Sets a timer to traverse the rendergraph every sixtieth of a second.
  */
 o3d.Renderer.installRenderInterval = function() {
   o3d.Renderer.render_callback_interval_ = setInterval(
       "o3d.Renderer.renderClients()", 1000.0 / 60.0);
@@ skipping 84 matching lines @@
  * The Client class is the main point of entry to O3D.  It defines methods
  * for creating and deleting packs. Each new object created by the Client is
  * assigned a unique ID.
  *
  * The Client has a root transform for the transform graph and a root render
  * node for the render graph.
  * @constructor
  */
 o3d.Client = function() {
   o3d.NamedObject.call(this);
-  this.root = new o3d.Transform;
-  this.renderGraphRoot = new o3d.RenderNode;
-  this.root = new o3d.Transform;
+
+  var tempPack = this.createPack();
+  this.root = tempPack.createObject('Transform');
+  this.renderGraphRoot = tempPack.createObject('RenderNode');
   this.clientId = o3d.Client.nextId++;
+  this.packs_ = [tempPack];
 
   if (o3d.Renderer.clients_.length == 0)
     o3d.Renderer.installRenderInterval();
 
   o3d.Renderer.clients_.push(this);
 };
 o3d.inherit('Client', 'NamedObject');
 
 /**
  * @type {function(!o3d.RenderEvent): void}
@@ skipping 32 matching lines @@
 
 
 /**
  * The transform graph root.
  * @type {o3d.Transform}
  */
 o3d.Client.prototype.root = null;
 
 
 /**
+ * A list of all packs for this client.
+ * @type {!Array.<!o3d.Pack>}
+ */
+o3d.Client.prototype.packs_ = [];
+
+
+/**
  * Function that gets called when the client encounters an error.
  */
 o3d.Client.prototype.error_callback = function(error_message) {
   alert(error_message);
 };
 
 
 /**
  * Function that gets called right before the client renders.
  */
@@ skipping 24 matching lines @@
 
 
 /**
  * Creates a pack object.
  *   A pack object.
  * @return {!o3d.Pack} A new pack object.
  */
 o3d.Client.prototype.createPack =
     function() {
   var pack = new o3d.Pack;
+  pack.client = this;
   pack.gl = this.gl;
+  this.packs_.push(pack);
   return pack;
 };
 
 
 /**
+ * Creates a pack object.
+ *   A pack object.
+ * @param {!o3d.Pack} pack The pack to remove.
+ */
+o3d.Client.prototype.destroyPack =
+    function(pack) {
+  o3d.removeFromArray(this.packs_, pack);
+};
+
+
+
+/**
  * Searches the Client for an object matching the given id.
  *
  * @param {number} id The id of the object to look for.
  * @return {o3d.ObjectBase}  The object or null if a object
  *     with the given id is not found.
  */
 o3d.Client.prototype.getObjectById =
     function(id) {
   o3d.notImplemented();
 };
 
 
 /**
  * Searches the Client for objects of a particular name and type.
  * @param {string} name name of object to look for.
  * @param {string} class_name name of class to look for.
  * @return {!Array.<!o3d.ObjectBase>}  Array of objects found.
  */
 o3d.Client.prototype.getObjects =
     function(name, class_name) {
-  o3d.notImplemented();
-  return [];
+  var objects = [];
+
+  for (var i = 0; i < this.packs_.length; ++i) {
+    var pack = this.packs_[i];
+    objects = objects.concat(pack.getObjects(name, class_name));
+  }
+
+  return objects;
 };
 
 
 /**
  * Searches the Client for objects of a particular type.
  * @param {string} class_name name of class to look for.
  * @return {!Array.<!Object>}  Array of objects found.
  */
 o3d.Client.prototype.getObjectsByClassName =
     function(class_name) {
-  o3d.notImplemented();
-  return [];
+  var objects = [];
+
+  for (var i = 0; i < this.packs_.length; ++i) {
+    var pack = this.packs_[i];
+    objects = objects.concat(pack.getObjectsByClassName(class_name));
+  }
+
+  return objects;
 };
 
 
 /**
  * @type {number}
  */
 o3d.Client.RenderMode = goog.typedef;
 
 /**
  *  RENDERMODE_CONTINUOUS,  Draw as often as possible up to refresh rate.
@@ skipping 14 matching lines @@
  */
 o3d.Client.prototype.renderMode = o3d.Client.RENDERMODE_CONTINUOUS;
 
 
 
 /**
  * Forces a render of the current scene if the current render mode is
  * RENDERMODE_ON_DEMAND.
  */
 o3d.Client.prototype.render = function() {
-  this.renderTree();
+  // Synthesize a render event.
+  var render_event = new o3d.RenderEvent;
+
+  var now = (new Date()).getTime() * 0.001;
+  if(this.then_ == 0.0)
+    render_event.elapsedTime = 0.0;
+  else
+    render_event.elapsedTime = now - this.then_;
+
+  if (this.render_callback) {
+    for (var stat in this.render_stats_) {
+      render_event[stat] = this.render_stats_[stat];
+    }
+    this.render_callback(render_event);
+  }
+  this.then_ = now;
+  this.renderTree(this.renderGraphRoot);
 };
 
 
+/**
+ * An object for various statistics that are gather during the render tree
+ * tranversal.
+ *
+ * @type {Object}
+ */
+o3d.Client.prototype.render_stats = {}
+
 
 /**
  * Renders a render graph.
  *
  * Normally the client calls this function automatically for you effectively
  * doing a client.renderTree(client.renderGraphRoot) but there are cases
  * where it is beneficial to be able to call this yourself and pass it
  * different roots when you need to manipulate something between calls.
  *
  * This function can only be called from inside a render callback. If you call
  * it the client will not do its default call as mentioned above.
  *
  * @param {!o3d.RenderNode} render_node root RenderNode to start rendering from.
  */
 o3d.Client.prototype.renderTree =
     function(render_node) {
+
+  this.render_stats_ = {
+    drawElementsCulled: 0,
+    drawElementsProcessed: 0,
+    drawElementsRendered: 0,
+    primitivesRendered: 0,
+    transformsCulled: 0,
+    transformsProcessed: 0
+  };
+
   render_node.render();
 };
 
 
 /**
  * Returns an array of DisplayModes which are available for use in full-screen
  * mode.
  *  An array of DisplayModes.
  * @type {!Array.<!o3d.Client.DispalyMode>}
  */
 o3d.Client.prototype.getDisplayModes = [];
 
 
-
 /**
  * Makes a region of the plugin area that will invoke full-screen mode if
  * clicked.  The developer is responsible for communicating this to the user,
  * as this region has no visible marker.  The developer is also responsible for
  * updating this region if the plugin gets resized, as we don't know whether or
  * how to scale it.  There can be only one full-screen click region at a time;
  * calling this again will override any previous call.
  *
  * @param {number} x x position in pixels.
  * @param {number} y y position in pixels.
  * @param {number} width width in pixels.
  * @param {number} height height in pixels.
  * @param {number} mode_id Id of mode to use.
  */
 o3d.Client.prototype.setFullscreenClickRegion =
     function(x, y, width, height, mode_id) {
-
+  o3d.notImplemented();
 };
 
 
 /**
  * Deactivates the plugin click region that was previously created with
  * SetFullscreenClickRegion().
  */
 o3d.Client.prototype.clearFullscreenClickRegion = function() {
   o3d.notImplemented();
 };
@@ skipping 79 matching lines @@
 
   try {gl = canvas.getContext("experimental-webgl", standard_attributes) } catch(e) { }
   if (!gl)
       try {gl = canvas.getContext("moz-webgl") } catch(e) { }
   if (!gl) {
       alert("No WebGL context found");
       return null;
   }
 
   this.gl = gl;
+  this.root.gl = gl;
+  this.renderGraphRoot.gl = gl;
 
   gl.client = this;
-  this.updateDisplayInfo_();
+  gl.displayInfo = {width: canvas.width,
+                    height: canvas.height};
 };
 
 
 /**
  * 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
  * frames.
@@ skipping 330 matching lines @@
 
 
 
 /**
  * The canvas associated with this client.
  * @type {Element}
  */
 o3d.Client.prototype.canvas = null;
 
 
-/**
- * Updates the display information attached to the GL.
- * @private
- */
-o3d.Client.prototype.updateDisplayInfo_ = function() {
-  this.gl.displayInfo = {width: this.width,
-                         height: this.height};
-};