Final merge from O3D Perforce tree.

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@17243 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 660 insertions, 64 deletions

diff --git a/o3d/plugin/idl/texture.idl b/o3d/plugin/idl/texture.idl
index 03dc49b..0f4614b 100644
--- a/o3d/plugin/idl/texture.idl
+++ b/o3d/plugin/idl/texture.idl
@@ -161,33 +161,67 @@ namespace o3d {
   [nocpp, userglue, include="core/cross/math_utilities.h"]
   void Set(int level, float[] values);
 
+  %[
+    Sets a rectangular area of values in a texture.
+
+    Does clipping. In other words if you pass in a 10x10 pixel array
+    and give it destination of (-5, -5) it will only use the bottom 5x5
+    pixels of the array you passed in to set to set the top 5x5 pixels of the
+    texture.
+
+    See o3d.Texture2D.set for details on formats.
+
+    \param level the mip level to update.
+    \param destination_x The x coordinate of the area in the texture to effect.
+    \param destination_y The y coordinate of the area in the texture to effect.
+    \param source_width The width of the area to effect. The height is
+        determined bythe size of the array passed in.
+    \param values Values to be stored in the buffer.
+    \see o3d.Texture2D.set
+  %]
+  [nocpp, userglue, include="core/cross/math_utilities.h"]
+  void SetRect(int level,
+               int destination_x,
+               int destination_y,
+               int source_width,
+               float[] values);
+
+
   [verbatim=cpp_glue] %{
-    void userglue_method_Set(o3d::Texture2D* self,
-                             int level,
-                             const std::vector<float>& values) {
+    void SetRectCheck(o3d::Texture2D* self,
+                      int level,
+                      int destination_x,
+                      int destination_y,
+                      int source_width,
+                      const std::vector<float>& values,
+                      bool check_needed) {
       if (level < 0 || level >= self->levels()) {
         O3D_ERROR(self->service_locator())
             << "level (" << level << " out of range";
         return;
       }
-      unsigned width = std::max(self->width() >> level, 1);
-      unsigned height = std::max(self->height() >> level, 1);
-      unsigned num_elements;
+      if (values.empty() || source_width <= 0) {
+        return;
+      }
+      unsigned num_values = values.size();
+      unsigned texture_width = std::max(self->width() >> level, 1);
+      unsigned texture_height = std::max(self->height() >> level, 1);
+      unsigned num_components;
       unsigned swizzle[4] = {2, 1, 0, 3};
       switch (self->format()) {
         case o3d::Texture::XRGB8:
-          num_elements = 3;
+          num_components = 3;
           break;
         case o3d::Texture::R32F:
           swizzle[0] = 0;
-          num_elements = 1;
+          num_components = 1;
           break;
         case o3d::Texture::ARGB8:
         case o3d::Texture::ABGR16F:
-          num_elements = 4;
+          num_components = 4;
           break;
         case o3d::Texture::ABGR32F: {
-          num_elements = 4;
+          num_components = 4;
           const o3d::Texture::RGBASwizzleIndices& indices =
              self->GetABGR32FSwizzleIndices();
           for (int ii = 0; ii < 4; ++ii) {
@@ -200,62 +234,128 @@ namespace o3d {
             << "Texture::Set not supported for this type of texture";
           return;
       }
-      unsigned needed = num_elements * width * height;
-      if (values.size() != needed) {
+      if (num_values % num_components != 0) {
         O3D_ERROR(self->service_locator())
-          << "needed " << needed << " values but " << values.size()
-          << " passed in.";
+          << "The number of elements passed in must be a multiple of "
+          << num_components;
+      }
+      unsigned num_elements = num_values / num_components;
+      if (num_elements % source_width != 0) {
+        O3D_ERROR(self->service_locator())
+          << "The number of elements passed in must be a multiple of the "
+          << "width";
+        return;
+      }
+      unsigned source_height = num_elements / source_width;
+      if (check_needed) {
+        unsigned needed = num_components * texture_width * texture_height;
+        if (num_values != needed) {
+          O3D_ERROR(self->service_locator())
+            << "needed " << needed << " values but " << num_values
+            << " passed in.";
+          return;
+        }
+      }
+
+      // clip
+      int source_x = 0;
+      int source_y = 0;
+      int copy_width = source_width;
+      int copy_height = source_height;
+
+      if (destination_x < 0) {
+        copy_width += destination_x;
+        source_x -= destination_x;
+        destination_x = 0;
+      }
+      if (destination_x + copy_width > texture_width) {
+        copy_width -= destination_x + copy_width - texture_width;
+      }
+
+      if (destination_y < 0) {
+        copy_height += destination_y;
+        source_y -= destination_y;
+        destination_y = 0;
+      }
+      if (destination_y + copy_height > texture_height) {
+        copy_height -= destination_y + copy_height - texture_height;
+      }
+
+      if (copy_width <= 0 || copy_height <= 0) {
         return;
       }
+
       void* data;
       if (!self->Lock(level, &data)) {
         O3D_ERROR(self->service_locator()) << "could not lock texture";
         return;
       }
+      const float* source =
+          &values[0] +
+          (source_y * source_width + source_x) * num_components;
+      unsigned source_stride = (source_width - copy_width) * num_components;
+      unsigned destination_stride =
+          (texture_width - copy_width) * num_components;
       switch (self->format()) {
         case o3d::Texture::ABGR16F: {
-          unsigned short* destination = static_cast<unsigned short*>(data);
-          unsigned short* end = destination + width * height * num_elements;
-          const float* source = &values[0];
-          while (destination < end) {
-            for (int element = 0; element < num_elements; ++element) {
-              destination[element] = Vectormath::Aos::FloatToHalf(
-                  source[swizzle[element]]);
+          unsigned short* destination =
+              static_cast<unsigned short*>(data) +
+              (destination_y * texture_width + destination_x) * num_components;
+          while (copy_height > 0) {
+            for (int xx = 0; xx < copy_width; ++xx) {
+              for (int element = 0; element < num_components; ++element) {
+                destination[element] = Vectormath::Aos::FloatToHalf(
+                    source[swizzle[element]]);
+              }
+              destination += num_components;
+              source += num_components;
             }
-            destination += num_elements;
-            source += num_elements;
+            destination += destination_stride;
+            source += source_stride;
+            --copy_height;
           }
           break;
         }
         case o3d::Texture::R32F:
         case o3d::Texture::ABGR32F: {
-          float* destination = static_cast<float*>(data);
-          float* end = destination + width * height * num_elements;
-          const float* source = &values[0];
-          while (destination < end) {
-            for (int element = 0; element < num_elements; ++element) {
-              destination[element] = source[swizzle[element]];
+          float* destination =
+            static_cast<float*>(data) +
+            (destination_y * texture_width + destination_x) * num_components;
+          while (copy_height > 0) {
+            for (int xx = 0; xx < copy_width; ++xx) {
+              for (int element = 0; element < num_components; ++element) {
+                destination[element] = source[swizzle[element]];
+              }
+              destination += num_components;
+              source += num_components;
             }
-            destination += num_elements;
-            source += num_elements;
+            destination += destination_stride;
+            source += source_stride;
+            --copy_height;
           }
           break;
         }
         default: {
-          unsigned char* destination = static_cast<unsigned char*>(data);
-          unsigned char* end = destination + width * height * 4;
-          const float* source = &values[0];
-          while (destination < end) {
-            destination[0] = static_cast<unsigned char>(
-                source[swizzle[0]] * 255.0f);
-            destination[1] = static_cast<unsigned char>(
-                source[swizzle[1]] * 255.0f);
-            destination[2] = static_cast<unsigned char>(
-                source[swizzle[2]] * 255.0f);
-            destination[3] = (num_elements == 4) ?
-                static_cast<unsigned char>(source[swizzle[3]] * 255.0f) : 255;
-            destination += 4;
-            source += num_elements;
+          destination_stride = (texture_width - copy_width) * 4;
+          uint8* destination =
+              static_cast<uint8*>(data) +
+             (destination_y * texture_width + destination_x) * 4;
+          while (copy_height > 0) {
+            for (int xx = 0; xx < copy_width; ++xx) {
+              destination[0] = static_cast<unsigned char>(
+                  source[swizzle[0]] * 255.0f);
+              destination[1] = static_cast<unsigned char>(
+                  source[swizzle[1]] * 255.0f);
+              destination[2] = static_cast<unsigned char>(
+                  source[swizzle[2]] * 255.0f);
+              destination[3] = (num_components == 4) ?
+                  static_cast<unsigned char>(source[swizzle[3]] * 255.0f) : 255;
+              destination += 4;
+              source += num_components;
+            }
+            destination += destination_stride;
+            source += source_stride;
+            --copy_height;
           }
           break;
         }
@@ -264,6 +364,25 @@ namespace o3d {
         O3D_ERROR(self->service_locator()) << "could not unlock texture";
       }
     }
+    void userglue_method_SetRect(o3d::Texture2D* self,
+                                 int level,
+                                 int destination_x,
+                                 int destination_y,
+                                 int source_width,
+                                 const std::vector<float>& values) {
+      SetRectCheck(self,
+                   level,
+                   destination_x,
+                   destination_y,
+                   source_width,
+                   values,
+                   false);
+    }
+    void userglue_method_Set(o3d::Texture2D* self,
+                             int level,
+                             const std::vector<float>& values) {
+      SetRectCheck(self, level, 0, 0, self->width(), values, true);
+    }
   %}
 };  // Texture2D
 
diff --git a/o3d/samples/o3djs/debug.js b/o3d/samples/o3djs/debug.js
index cc34b7a..8b1dc8d 100644
--- a/o3d/samples/o3djs/debug.js
+++ b/o3d/samples/o3djs/debug.js
@@ -387,7 +387,7 @@ o3djs.debug.createLineSphereVertices = function(radius,
                                                 subdivisionsHeight,
                                                 opt_matrix) {
   if (subdivisionsAxis <= 0 || subdivisionsHeight <= 0) {
-    throw RangeError('subdivisionAxis and subdivisionHeight must be > 0');
+    throw Error('subdivisionAxis and subdivisionHeight must be > 0');
   }
 
   // We are going to generate our sphere by iterating through its
@@ -474,8 +474,19 @@ o3djs.debug.createLineSphere = function(pack,
  *     this line belongs too.
  */
 o3djs.debug.DebugLine = function(debugLineGroup) {
+  /**
+   * The DebugLineGroup this DebugLine is managed by.
+   * @private
+   * @type {!o3djs.debug.DebugLineGroup}
+   */
   this.debugLineGroup_ = debugLineGroup;
   var pack = debugLineGroup.getPack();
+
+  /**
+   * The transform for this DebugLine.
+   * @private
+   * @type {!o3d.Transform}
+   */
   this.transform_ = pack.createObject('Transform');
   this.transform_.name = O3D_DEBUG_LINE_SHAPE_NAME;
   this.transform_.addShape(debugLineGroup.getLineShape());
diff --git a/o3d/samples/o3djs/primitives.js b/o3d/samples/o3djs/primitives.js
index d3df686..52621d5 100644
--- a/o3d/samples/o3djs/primitives.js
+++ b/o3d/samples/o3djs/primitives.js
@@ -703,7 +703,7 @@ o3djs.primitives.createSphereVertices = function(radius,
                                                  subdivisionsHeight,
                                                  opt_matrix) {
   if (subdivisionsAxis <= 0 || subdivisionsHeight <= 0) {
-    throw RangeError('subdivisionAxis and subdivisionHeight must be > 0');
+    throw Error('subdivisionAxis and subdivisionHeight must be > 0');
   }
 
   // We are going to generate our sphere by iterating through its
@@ -1016,7 +1016,7 @@ o3djs.primitives.createDiscVertices = function(radius,
                                                opt_stackPower,
                                                opt_matrix) {
   if (divisions < 3) {
-    throw RangeError('divisions must be at least 3');
+    throw Error('divisions must be at least 3');
   }
 
   var stacks = opt_stacks ? opt_stacks : 1;
@@ -1148,11 +1148,11 @@ o3djs.primitives.createCylinderVertices = function(radius,
                                                    verticalSubdivisions,
                                                    opt_matrix) {
   if (radialSubdivisions < 1) {
-    throw RangeError('radialSubdivisions must be 1 or greater');
+    throw Error('radialSubdivisions must be 1 or greater');
   }
 
   if (verticalSubdivisions < 1) {
-    throw RangeError('verticalSubdivisions must be 1 or greater');
+    throw Error('verticalSubdivisions must be 1 or greater');
   }
 
   var vertexInfo = o3djs.primitives.createVertexInfo();
@@ -1417,7 +1417,7 @@ o3djs.primitives.createPrismVertices = function(points,
                                                 depth,
                                                 opt_matrix) {
   if (points.length < 3) {
-    throw RangeError('there must be 3 or more points');
+    throw Error('there must be 3 or more points');
   }
 
   var backZ = -0.5 * depth;
@@ -1573,7 +1573,7 @@ o3djs.primitives.createPlaneVertices = function(width,
                                                 subdivisionsDepth,
                                                 opt_matrix) {
   if (subdivisionsWidth <= 0 || subdivisionsDepth <= 0) {
-    throw RangeError('subdivisionWidth and subdivisionDepth must be > 0');
+    throw Error('subdivisionWidth and subdivisionDepth must be > 0');
   }
 
   var vertexInfo = o3djs.primitives.createVertexInfo();
diff --git a/o3d/samples/o3djs/simple.js b/o3d/samples/o3djs/simple.js
index a02e84d..8bb729b 100644
--- a/o3d/samples/o3djs/simple.js
+++ b/o3d/samples/o3djs/simple.js
@@ -421,10 +421,12 @@ o3djs.simple.SimpleInfo.prototype.createSphere = function(radius,
  * Loads a scene from a URL.
  * TODO: Implement
  * @param {string} url Url of scene to load.
- * @return {!o3djs.simple.Scene} A Javascript object to manage th scene.
+ * @return {!o3djs.simple.Scene} A Javascript object to manage the scene.
  */
 o3djs.simple.SimpleInfo.prototype.loadScene = function(url) {
-  throw('not implemented');
+  if (true) {
+    throw('not implemented');
+  }
   return null;
 };
 
diff --git a/o3d/samples/o3djs/util.js b/o3d/samples/o3djs/util.js
index de283ba..b898a24 100644
--- a/o3d/samples/o3djs/util.js
+++ b/o3d/samples/o3djs/util.js
@@ -310,7 +310,7 @@ o3djs.util.requiredVersionAvailable = function(requiredVersion) {
   var haveParts = version.split('.');
   var requiredParts = requiredVersion.split('.');
   if (requiredParts.length > 4) {
-    throw RangeError('requiredVersion has more than 4 parts!');
+    throw Error('requiredVersion has more than 4 parts!');
   }
   for (var pp = 0; pp < requiredParts.length; ++pp) {
     var have = parseInt(haveParts[pp], 10);
@@ -511,7 +511,6 @@ o3djs.util.getElementContentById = function(id) {
       throw 'getElementContentById does not no how to get content from a ' +
           node.tagName + ' element';
   }
-  return node.value;
 };
 
 /**
diff --git a/o3d/tests/selenium/javascript_unit_test_list.txt b/o3d/tests/selenium/javascript_unit_test_list.txt
index 9cfa199..fc3f287 100644
--- a/o3d/tests/selenium/javascript_unit_test_list.txt
+++ b/o3d/tests/selenium/javascript_unit_test_list.txt
@@ -69,6 +69,7 @@ small   base-test
 small   util-test
 small   pixel-perfection      screenshot pdiff_threshold(2500) pdiff_threshold_mac(3000) except(*iexplore)
 medium  offscreen-test
+medium  texture-set-test      screenshot
 small   no-rendergraph        screenshot
 small   non-cachable-params   screenshot pdiff_threshold(1700)
 small   type-test
diff --git a/o3d/tests/selenium/sample_list.txt b/o3d/tests/selenium/sample_list.txt
index 699a888..136cd5a 100644
--- a/o3d/tests/selenium/sample_list.txt
+++ b/o3d/tests/selenium/sample_list.txt
@@ -59,28 +59,27 @@
 medium  2d                                screenshot pdiff_threshold(41200)
 medium  animation
 large   animated-scene                    screenshot timeout(45000) pdiff_threshold(200)
-large   beachdemo/beachdemo               screenshot timeout(120000) pdiff_threshold(15500) except(*iexplore)
+large   beachdemo/beachdemo               screenshot timeout(120000) pdiff_threshold(100) downsample(1) except(*iexplore)
 medium  canvas                            screenshot pdiff_threshold(4700) pdiff_threshold_mac(14600)
 medium  canvas-fonts                      screenshot pdiff_threshold(1100) pdiff_threshold_mac(21900)
 medium  canvas-texturedraw
 medium  checkers                          screenshot pdiff_threshold(1100)
 medium  convolution                       screenshot pdiff_threshold(200)
-medium  culling                           screenshot pdiff_threshold(3400)
+medium  culling                           screenshot pdiff_threshold(1000) downsample(1)
 medium  debugging                         screenshot pdiff_threshold(2000) pdiff_threshold_mac(3000)
 medium  displayfps
-small   generate-texture                  screenshot pdiff_threshold(30000)  except(*iexplore)
+small   generate-texture                  screenshot pdiff_threshold(30000) except(*iexplore)
 medium  hellocube                         screenshot pdiff_threshold(1000)
-medium  hellocube-colors                  screenshot pdiff_threshold(1000)
+medium  hellocube-colors                  screenshot pdiff_threshold(50) downsample(2)
 medium  helloworld                        screenshot pdiff_threshold(900)
 medium  hud-2d-overlay                    screenshot pdiff_threshold(11300) pdiff_threshold_win(39800)
 medium  instance-override                 screenshot pdiff_threshold(10500)
 medium  instancing                        screenshot pdiff_threshold(14300)
-medium  juggler                           screenshot
-# NOTE: temporarily disabled while we investigate failures
-# medium  julia                             screenshot
+medium  juggler                           screenshot downsample(1)
+medium  julia                             screenshot
 small   multiple-views                    screenshot pdiff_threshold(1900)
 medium  particles                         screenshot pdiff_threshold(35500)
-medium  primitives                        screenshot pdiff_threshold(17200) pdiff_threshold_mac(20000)
+medium  primitives                        screenshot pdiff_threshold(17200) pdiff_threshold_mac(20000) colorfactor(.7)
 medium  procedural-texture                screenshot pdiff_threshold(1300)
 medium  render-targets                    screenshot pdiff_threshold(1400)
 medium  scatter-chart                     screenshot pdiff_threshold(10100) pdiff_threshold_mac(10600)
diff --git a/o3d/tests/selenium/tests/texture-set-test.html b/o3d/tests/selenium/tests/texture-set-test.html
new file mode 100644
index 0000000..88f8619
--- /dev/null
+++ b/o3d/tests/selenium/tests/texture-set-test.html
@@ -0,0 +1,465 @@
+<!--
+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.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-->
+
+<!--
+Texture set test.
+-->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+<title>
+Texture Set Test.
+</title>
+<script type="text/javascript" src="../../../samples/o3djs/base.js"></script>
+<script type="text/javascript">
+o3djs.require('o3djs.util');
+o3djs.require('o3djs.math');
+o3djs.require('o3djs.rendergraph');
+o3djs.require('o3djs.primitives');
+o3djs.require('o3djs.effect');
+
+// global variables
+var g_o3d;
+var g_math;
+var g_client;
+var g_pack;
+var g_viewInfo;
+
+/**
+ * Creates the client area.
+ */
+function init() {
+  // Comment out the line below to run the sample in the browser
+  // JavaScript engine.  This may be helpful for debugging.
+  o3djs.util.setMainEngine(o3djs.util.Engine.V8);
+  o3djs.util.makeClients(initStep2, 'FloatingPointTextures,NotAntiAliased');
+}
+
+/**
+ * Initializes O3D, loads an effect, creates some textures
+ * and quads to display them.
+ * @param {Array} clientElements Array of o3d object elements.
+ */
+function initStep2(clientElements) {
+  // Initializes global variables and libraries.
+  var o3dElement = clientElements[0];
+  g_o3d = o3dElement.o3d;
+  g_math = o3djs.math;
+
+  // Set window.g_client as well.  Otherwise when the sample runs in
+  // V8, selenium won't be able to find this variable (it can only see
+  // the browser environment).
+  window.g_client = g_client = o3dElement.client;
+
+  // Create a pack to manage our resources/assets
+  g_pack = g_client.createPack();
+
+  // Create the render graph for a view.
+  g_viewInfo = o3djs.rendergraph.createBasicView(
+      g_pack,
+      g_client.root,
+      g_client.renderGraphRoot);
+
+  var clientWidth = g_client.width;
+  var clientHeight = g_client.height;
+  g_viewInfo.drawContext.projection = g_math.matrix4.orthographic(
+      -clientWidth * 0.5,
+      clientWidth * 0.5,
+      -clientHeight * 0.5,
+      clientHeight * 0.5,
+      0.001,
+      1000);
+  g_viewInfo.drawContext.view = g_math.matrix4.lookAt(
+      [0, 500, 0], // eye
+      [0, 0, 0],   // target
+      [0, 0, -1]); // up
+
+  // Create and load the effects.
+  var effectNames = [
+      'texture-only.shader',
+      'luminance_alpha_texture.shader'];
+
+  var effectInfos = {
+    texture_only: {name: 'texture_only'},
+    one_channel_texture: {name: 'one_channel_texture'}};
+  for (var key in effectInfos) {
+    var info = effectInfos[key];
+    var effect = g_pack.createObject('Effect');
+    effect.loadFromFXString(o3djs.util.getElementContentById(info.name));
+
+    // Create a Material for the effect.
+    var material = g_pack.createObject('Material');
+
+    // Set the material's drawList for transparent objects.
+    material.drawList = g_viewInfo.zOrderedDrawList;
+
+    // Apply the effect to this material.
+    material.effect = effect;
+
+    // Create the params that effect requires on the material.
+    effect.createUniformParameters(material);
+
+    // Create a quad.
+    var shape = o3djs.primitives.createPlane(g_pack,
+                                             material,
+                                             1,
+                                             1,
+                                             1,
+                                             1);
+    info.shape = shape;
+  }
+
+  // display our shape 5 times with 5 different textures
+  // by overriding the sampler on each instance.
+  for (var f = 0; f < 5; ++f) {
+    for (var s = 0; s < 5; ++s) {
+      // create a transform for an instance
+      var transform = g_pack.createObject('Transform');
+      var x = s;
+      var z = f;
+      transform.translate(-180 + 32 + s * 70, 0, -180 + 32 + f * 70);
+      transform.scale(64, 1, 64);
+      transform.parent = g_client.root;
+
+      // Create a ParamSampler on the transform with the same name as in
+      // the effect so this param will be used instead of the one on the
+      // material.
+      var samplerParam = transform.createParam('texSampler0', 'ParamSampler');
+
+      var sampler = g_pack.createObject('Sampler');
+      samplerParam.value = sampler;
+      sampler.magFilter = g_o3d.Sampler.NONE;
+      sampler.minFilter = g_o3d.Sampler.NONE;
+      sampler.mipFilter = g_o3d.Sampler.NONE;
+      sampler.addressModeU = g_o3d.Sampler.CLAMP;
+      sampler.addressModeV = g_o3d.Sampler.CLAMP;
+
+      // Create a texture.
+      {
+        var pixels = [];
+        var format;
+
+        switch (s) {
+          case 0: {  // XRGB8
+            transform.addShape(effectInfos.texture_only.shape);
+            format = g_o3d.Texture.XRGB8;
+            for (var y = 0; y < 32; ++y) {
+              for (var x = 0; x < 32; ++x) {
+                var offset = (y * 32 + x) * 3;  // rgb
+                var u = x / 32 * Math.PI * 0.5;
+                var v = y / 32 * Math.PI * 0.5;
+                pixels[offset + 0] = Math.cos(u);  // red
+                pixels[offset + 1] = Math.sin(v);  // green
+                pixels[offset + 2] = Math.sin(u);  // blue
+              }
+            }
+            break;
+          }
+          case 1: {  // ARGB8
+            transform.addShape(effectInfos.texture_only.shape);
+            format = g_o3d.Texture.ARGB8;
+            for (var y = 0; y < 32; ++y) {
+              for (var x = 0; x < 32; ++x) {
+                var offset = (y * 32 + x) * 4;  // rgba
+                var u = x / 32 * Math.PI * 0.5;
+                var v = y / 32 * Math.PI * 0.5;
+                pixels[offset + 0] = Math.floor(y / 4) % 2;  // red
+                pixels[offset + 1] = Math.sin(v);  // green
+                pixels[offset + 2] = Math.floor(x / 4) % 2;  // blue
+                pixels[offset + 3] = Math.abs(Math.sin(v * 4));  // alpha
+              }
+            }
+            break;
+          }
+          case 2: {  // ABGR16F
+            transform.addShape(effectInfos.texture_only.shape);
+            format = g_o3d.Texture.ABGR16F;
+            for (var y = 0; y < 32; ++y) {
+              for (var x = 0; x < 32; ++x) {
+                var offset = (y * 32 + x) * 4;  // rgba
+                var u = x / 32 * Math.PI * 0.5;
+                var v = y / 32 * Math.PI * 0.5;
+                pixels[offset + 0] = Math.cos(v);  // red
+                pixels[offset + 1] = Math.sin(u);  // green
+                pixels[offset + 2] = Math.sin(v);  // blue
+                pixels[offset + 3] = Math.abs(Math.sin(u * 8));  // alpha
+              }
+            }
+            break;
+          }
+          case 3: {  // ABGR32F
+            transform.addShape(effectInfos.texture_only.shape);
+            format = g_o3d.Texture.ABGR32F;
+            for (var y = 0; y < 32; ++y) {
+              for (var x = 0; x < 32; ++x) {
+                var offset = (y * 32 + x) * 4;  // rgba
+                var u = x / 32 * Math.PI * 0.5;
+                var v = y / 32 * Math.PI * 0.5;
+                pixels[offset + 0] = Math.cos(v);  // red
+                pixels[offset + 1] = Math.sin(u);  // green
+                pixels[offset + 2] = Math.sin(v);  // blue
+                pixels[offset + 3] = Math.abs(Math.sin(u * 8));  // alpha
+              }
+            }
+            break;
+          }
+          case 4: {  // R32F
+            /**
+             * NOTE: GL and D3D do NOT share compatible 1 channel texture
+             * formats.
+             *
+             * In D3D the sampler will return
+             *
+             * R = channel 0
+             * G = const 1
+             * B = const 1
+             * A = const 1
+             *
+             * In GL the sampler will return
+             *
+             * R = channel 0
+             * G = channel 0
+             * B = channel 0
+             * A = channel 0
+             *
+             * What that means is only R works across platforms. G, B and A are
+             * undefined and if you use them you'll get the wrong results.
+             */
+            transform.addShape(effectInfos.one_channel_texture.shape);
+            format = g_o3d.Texture.R32F;
+            for (var y = 0; y < 32; ++y) {
+              for (var x = 0; x < 32; ++x) {
+                var offset = (y * 32 + x);  // r
+                var u = x / 32 * Math.PI * 0.5;
+                var v = y / 32 * Math.PI * 0.5;
+                pixels[offset + 0] = Math.cos(v * 16);  // red
+              }
+            }
+            break;
+          }
+        }
+        var texture = g_pack.createTexture2D(32, 32, format, 1, false);
+        var tx = -16 + (f % 2) * 32;
+        var ty = -16 + Math.floor(f / 2) * 32;
+        if (f == 4) {
+          tx = 0;
+          ty = 0;
+        }
+        texture.setRect(0, tx, ty, 32, pixels);
+        sampler.texture = texture;
+      }
+    }
+  }
+  window.g_testResult = true;  // for selenium testing.
+}
+
+</script>
+</head>
+<body onload="init()">
+<h1>Texture Set Test</h1>
+<br/>
+
+<!-- Start of O3D plugin -->
+<div id="o3d" style="width: 400px; height: 400px;"></div>
+<!-- End of O3D plugin -->
+<script type="test/o3deffect" id="texture_only">
+/*
+ * 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.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+float4x4 worldViewProjection : WORLDVIEWPROJECTION;
+
+// The texture sampler is used to access the texture bitmap in the fragment
+// shader.
+sampler texSampler0;
+
+// input parameters for our vertex shader
+struct PixelShaderInput {
+  float4 position : POSITION;
+  float2 texcoord : TEXCOORD0;  // Texture coordinates
+};
+
+// input parameters for our pixel shader
+struct VertexShaderInput {
+  float4 position : POSITION;
+  float2 texcoord : TEXCOORD0;  // Texture coordinates
+};
+
+/**
+ * Our vertex shader
+ */
+PixelShaderInput vertexShaderFunction(VertexShaderInput input) {
+  PixelShaderInput output;
+  output.position = mul(input.position, worldViewProjection);
+  output.texcoord = input.texcoord;
+  return output;
+}
+
+/* Given the texture coordinates, our pixel shader grabs the corresponding
+ * color from the texture.
+ */
+float4 pixelShaderFunction(PixelShaderInput input): COLOR {
+  return tex2D(texSampler0, input.texcoord);
+}
+
+// Here we tell our effect file *which* functions are
+// our vertex and pixel shaders.
+// #o3d VertexShaderEntryPoint vertexShaderFunction
+// #o3d PixelShaderEntryPoint pixelShaderFunction
+// #o3d MatrixLoadOrder RowMajor
+</script>
+<script type="test/o3deffect" id="one_channel_texture">
+/*
+ * 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.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+float4x4 worldViewProjection : WORLDVIEWPROJECTION;
+
+// The texture sampler is used to access the texture bitmap in the fragment
+// shader.
+sampler texSampler0;
+
+// input parameters for our vertex shader
+struct PixelShaderInput {
+  float4 position : POSITION;
+  float2 texcoord : TEXCOORD0;  // Texture coordinates
+};
+
+// input parameters for our pixel shader
+struct VertexShaderInput {
+  float4 position : POSITION;
+  float2 texcoord : TEXCOORD0;  // Texture coordinates
+};
+
+/**
+ * Our vertex shader
+ */
+PixelShaderInput vertexShaderFunction(VertexShaderInput input) {
+  PixelShaderInput output;
+  output.position = mul(input.position, worldViewProjection);
+  output.texcoord = input.texcoord;
+  return output;
+}
+
+/**
+ * Given the texture coordinates, our pixel shader grabs the corresponding
+ * color from the texture.
+ *
+ * NOTE: GL and D3D do NOT share compatible 1 channel texture formats.
+ *
+ * In D3D the sampler will return
+ *
+ * R = channel 0
+ * G = const 1
+ * B = const 1
+ * A = const 1
+ *
+ * In GL the sampler will return
+ *
+ * R = channel 0
+ * G = channel 0
+ * B = channel 0
+ * A = channel 0
+ *
+ * What that means is only R works across platforms. G, B and A are undefined
+ * and if you use them you'll get the wrong results.
+ */
+float4 pixelShaderFunction(PixelShaderInput input): COLOR {
+  // ** Use only valid channels. ** ---------+
+  //                                         |
+  //                                         V
+  return tex2D(texSampler0, input.texcoord).rrrr;
+}
+
+// Here we tell our effect file *which* functions are
+// our vertex and pixel shaders.
+// #o3d VertexShaderEntryPoint vertexShaderFunction
+// #o3d PixelShaderEntryPoint pixelShaderFunction
+// #o3d MatrixLoadOrder RowMajor
+</script>
+</body>
+</html>