From 6321075d93044c6747682a8e7280b5996da7ec52 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Thu, 2 Feb 2012 11:57:58 -0800
Subject: added some additional shaders

---
 js/helper-classes/RDGE/Materials/DeformMaterial.js | 133 +++++++++++++++++++++
 js/helper-classes/RDGE/Materials/FlyMaterial.js    | 133 +++++++++++++++++++++
 .../RDGE/Materials/ReliefTunnelMaterial.js         | 133 +++++++++++++++++++++
 .../RDGE/Materials/SquareTunnelMaterial.js         | 133 +++++++++++++++++++++
 js/helper-classes/RDGE/Materials/StarMaterial.js   | 133 +++++++++++++++++++++
 js/helper-classes/RDGE/Materials/WaterMaterial.js  | 133 +++++++++++++++++++++
 .../RDGE/Materials/ZInvertMaterial.js              | 133 +++++++++++++++++++++
 js/helper-classes/RDGE/MaterialsLibrary.js         |  21 ++++
 8 files changed, 952 insertions(+)
 create mode 100644 js/helper-classes/RDGE/Materials/DeformMaterial.js
 create mode 100644 js/helper-classes/RDGE/Materials/FlyMaterial.js
 create mode 100644 js/helper-classes/RDGE/Materials/ReliefTunnelMaterial.js
 create mode 100644 js/helper-classes/RDGE/Materials/SquareTunnelMaterial.js
 create mode 100644 js/helper-classes/RDGE/Materials/StarMaterial.js
 create mode 100644 js/helper-classes/RDGE/Materials/WaterMaterial.js
 create mode 100644 js/helper-classes/RDGE/Materials/ZInvertMaterial.js

(limited to 'js/helper-classes')

diff --git a/js/helper-classes/RDGE/Materials/DeformMaterial.js b/js/helper-classes/RDGE/Materials/DeformMaterial.js
new file mode 100644
index 00000000..ddc97383
--- /dev/null
+++ b/js/helper-classes/RDGE/Materials/DeformMaterial.js
@@ -0,0 +1,133 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+
+
+///////////////////////////////////////////////////////////////////////
+// Class GLMaterial
+//      RDGE representation of a material.
+///////////////////////////////////////////////////////////////////////
+function DeformMaterial()
+{
+    // initialize the inherited members
+    this.inheritedFrom = PulseMaterial;
+    this.inheritedFrom();
+   
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._name = "DeformMaterial";
+	this._shaderName = "deform";
+
+	this._texMap = 'assets/images/rocky-normal.jpg';
+
+	this._time = 0.0;
+	this._dTime = 0.01;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Properties
+    ///////////////////////////////////////////////////////////////////////
+	// all defined in parent PulseMaterial.js
+	// load the local default value
+	this._propValues[ this._propNames[0] ] = this._texMap.slice(0);
+
+    ///////////////////////////////////////////////////////////////////////
+    // Material Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+	// duplcate method requirde
+	this.dup = function( world )
+	{
+		// allocate a new uber material
+		var newMat = new DeformMaterial();
+
+		// copy over the current values;
+		var propNames = [],  propValues = [],  propTypes = [],  propLabels = [];
+		this.getAllProperties( propNames,  propValues,  propTypes,  propLabels);
+		var n = propNames.length;
+		for (var i=0;  i<n;  i++)
+			newMat.setProperty( propNames[i], propValues[i] );
+
+		return newMat;
+	} 
+
+	this.init = function( world )
+	{
+		// save the world
+		if (world)  this.setWorld( world );
+
+		// set up the shader
+		this._shader = new jshader();
+		this._shader.def = deformMaterialDef;
+		this._shader.init();
+
+		// set up the material node
+		this._materialNode = createMaterialNode("deformMaterial");
+		this._materialNode.setShader(this._shader);
+
+		this._time = 0;
+		if (this._shader && this._shader.default)
+			this._shader.default.u_time.set( [this._time] );
+
+		// set the shader values in the shader
+		this.updateTexture();
+		this.setResolution( [world.getViewportWidth(),world.getViewportHeight()] );
+		this.update( 0 );
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// RDGE shader
+ 
+// shader spec (can also be loaded from a .JSON file, or constructed at runtime)
+var deformMaterialDef =
+{'shaders': 
+	{
+		'defaultVShader':"assets/shaders/Basic.vert.glsl",
+		'defaultFShader':"assets/shaders/Deform.frag.glsl"
+	},
+	'techniques':
+	{ 
+		'default':
+		[
+			{
+				'vshader' : 'defaultVShader',
+				'fshader' : 'defaultFShader',
+				// attributes
+				'attributes' :
+				{
+					'vert'  :   { 'type' : 'vec3' },
+					'normal' :  { 'type' : 'vec3' },
+					'texcoord'  :   { 'type' : 'vec2' }
+				},
+				// parameters
+				'params' : 
+				{
+					'u_tex0': { 'type' : 'tex2d' },
+					'u_time' : { 'type' : 'float' },
+					'u_resolution'  :   { 'type' : 'vec2' },
+				},
+
+				// render states
+				'states' : 
+				{
+					'depthEnable' : true,
+					'offset':[1.0, 0.1]
+				},
+			},
+		]
+	}
+};
+
+
+
+
diff --git a/js/helper-classes/RDGE/Materials/FlyMaterial.js b/js/helper-classes/RDGE/Materials/FlyMaterial.js
new file mode 100644
index 00000000..ca07ce85
--- /dev/null
+++ b/js/helper-classes/RDGE/Materials/FlyMaterial.js
@@ -0,0 +1,133 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+
+
+///////////////////////////////////////////////////////////////////////
+// Class GLMaterial
+//      RDGE representation of a material.
+///////////////////////////////////////////////////////////////////////
+function FlyMaterial()
+{
+    // initialize the inherited members
+    this.inheritedFrom = PulseMaterial;
+    this.inheritedFrom();
+   
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._name = "FlyMaterial";
+	this._shaderName = "tunnel";
+
+	this._texMap = 'assets/images/rocky-normal.jpg';
+
+	this._time = 0.0;
+	this._dTime = 0.01;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Properties
+    ///////////////////////////////////////////////////////////////////////
+	// all defined in parent PulseMaterial.js
+	// load the local default value
+	this._propValues[ this._propNames[0] ] = this._texMap.slice(0);
+
+    ///////////////////////////////////////////////////////////////////////
+    // Material Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+	// duplcate method requirde
+	this.dup = function( world )
+	{
+		// allocate a new uber material
+		var newMat = new FlyMaterial();
+
+		// copy over the current values;
+		var propNames = [],  propValues = [],  propTypes = [],  propLabels = [];
+		this.getAllProperties( propNames,  propValues,  propTypes,  propLabels);
+		var n = propNames.length;
+		for (var i=0;  i<n;  i++)
+			newMat.setProperty( propNames[i], propValues[i] );
+
+		return newMat;
+	} 
+
+	this.init = function( world )
+	{
+		// save the world
+		if (world)  this.setWorld( world );
+
+		// set up the shader
+		this._shader = new jshader();
+		this._shader.def = flyMaterialDef;
+		this._shader.init();
+
+		// set up the material node
+		this._materialNode = createMaterialNode("flyMaterial");
+		this._materialNode.setShader(this._shader);
+
+		this._time = 0;
+		if (this._shader && this._shader.default)
+			this._shader.default.u_time.set( [this._time] );
+
+		// set the shader values in the shader
+		this.updateTexture();
+		this.setResolution( [world.getViewportWidth(),world.getViewportHeight()] );
+		this.update( 0 );
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// RDGE shader
+ 
+// shader spec (can also be loaded from a .JSON file, or constructed at runtime)
+var flyMaterialDef =
+{'shaders': 
+	{
+		'defaultVShader':"assets/shaders/Basic.vert.glsl",
+		'defaultFShader':"assets/shaders/Fly.frag.glsl"
+	},
+	'techniques':
+	{ 
+		'default':
+		[
+			{
+				'vshader' : 'defaultVShader',
+				'fshader' : 'defaultFShader',
+				// attributes
+				'attributes' :
+				{
+					'vert'  :   { 'type' : 'vec3' },
+					'normal' :  { 'type' : 'vec3' },
+					'texcoord'  :   { 'type' : 'vec2' }
+				},
+				// parameters
+				'params' : 
+				{
+					'u_tex0': { 'type' : 'tex2d' },
+					'u_time' : { 'type' : 'float' },
+					'u_resolution'  :   { 'type' : 'vec2' },
+				},
+
+				// render states
+				'states' : 
+				{
+					'depthEnable' : true,
+					'offset':[1.0, 0.1]
+				},
+			},
+		]
+	}
+};
+
+
+
+
diff --git a/js/helper-classes/RDGE/Materials/ReliefTunnelMaterial.js b/js/helper-classes/RDGE/Materials/ReliefTunnelMaterial.js
new file mode 100644
index 00000000..c5c0b9a7
--- /dev/null
+++ b/js/helper-classes/RDGE/Materials/ReliefTunnelMaterial.js
@@ -0,0 +1,133 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+
+
+///////////////////////////////////////////////////////////////////////
+// Class GLMaterial
+//      RDGE representation of a material.
+///////////////////////////////////////////////////////////////////////
+function ReliefTunnelMaterial()
+{
+    // initialize the inherited members
+    this.inheritedFrom = PulseMaterial;
+    this.inheritedFrom();
+   
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._name = "ReliefTunnelMaterial";
+	this._shaderName = "tunnel";
+
+	this._texMap = 'assets/images/rocky-normal.jpg';
+
+	this._time = 0.0;
+	this._dTime = 0.01;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Properties
+    ///////////////////////////////////////////////////////////////////////
+	// all defined in parent PulseMaterial.js
+	// load the local default value
+	this._propValues[ this._propNames[0] ] = this._texMap.slice(0);
+
+    ///////////////////////////////////////////////////////////////////////
+    // Material Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+	// duplcate method requirde
+	this.dup = function( world )
+	{
+		// allocate a new uber material
+		var newMat = new ReliefTunnelMaterial();
+
+		// copy over the current values;
+		var propNames = [],  propValues = [],  propTypes = [],  propLabels = [];
+		this.getAllProperties( propNames,  propValues,  propTypes,  propLabels);
+		var n = propNames.length;
+		for (var i=0;  i<n;  i++)
+			newMat.setProperty( propNames[i], propValues[i] );
+
+		return newMat;
+	} 
+
+	this.init = function( world )
+	{
+		// save the world
+		if (world)  this.setWorld( world );
+
+		// set up the shader
+		this._shader = new jshader();
+		this._shader.def = reliefTunnelMaterialDef;
+		this._shader.init();
+
+		// set up the material node
+		this._materialNode = createMaterialNode("reliefTunnelMaterial");
+		this._materialNode.setShader(this._shader);
+
+		this._time = 0;
+		if (this._shader && this._shader.default)
+			this._shader.default.u_time.set( [this._time] );
+
+		// set the shader values in the shader
+		this.updateTexture();
+		this.setResolution( [world.getViewportWidth(),world.getViewportHeight()] );
+		this.update( 0 );
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// RDGE shader
+ 
+// shader spec (can also be loaded from a .JSON file, or constructed at runtime)
+var reliefTunnelMaterialDef =
+{'shaders': 
+	{
+		'defaultVShader':"assets/shaders/Basic.vert.glsl",
+		'defaultFShader':"assets/shaders/ReliefTunnel.frag.glsl"
+	},
+	'techniques':
+	{ 
+		'default':
+		[
+			{
+				'vshader' : 'defaultVShader',
+				'fshader' : 'defaultFShader',
+				// attributes
+				'attributes' :
+				{
+					'vert'  :   { 'type' : 'vec3' },
+					'normal' :  { 'type' : 'vec3' },
+					'texcoord'  :   { 'type' : 'vec2' }
+				},
+				// parameters
+				'params' : 
+				{
+					'u_tex0': { 'type' : 'tex2d' },
+					'u_time' : { 'type' : 'float' },
+					'u_resolution'  :   { 'type' : 'vec2' },
+				},
+
+				// render states
+				'states' : 
+				{
+					'depthEnable' : true,
+					'offset':[1.0, 0.1]
+				},
+			},
+		]
+	}
+};
+
+
+
+
diff --git a/js/helper-classes/RDGE/Materials/SquareTunnelMaterial.js b/js/helper-classes/RDGE/Materials/SquareTunnelMaterial.js
new file mode 100644
index 00000000..41a46429
--- /dev/null
+++ b/js/helper-classes/RDGE/Materials/SquareTunnelMaterial.js
@@ -0,0 +1,133 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+
+
+///////////////////////////////////////////////////////////////////////
+// Class GLMaterial
+//      RDGE representation of a material.
+///////////////////////////////////////////////////////////////////////
+function SquareTunnelMaterial()
+{
+    // initialize the inherited members
+    this.inheritedFrom = PulseMaterial;
+    this.inheritedFrom();
+   
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._name = "SquareTunnelMaterial";
+	this._shaderName = "tunnel";
+
+	this._texMap = 'assets/images/rocky-normal.jpg';
+
+	this._time = 0.0;
+	this._dTime = 0.01;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Properties
+    ///////////////////////////////////////////////////////////////////////
+	// all defined in parent PulseMaterial.js
+	// load the local default value
+	this._propValues[ this._propNames[0] ] = this._texMap.slice(0);
+
+    ///////////////////////////////////////////////////////////////////////
+    // Material Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+	// duplcate method requirde
+	this.dup = function( world )
+	{
+		// allocate a new uber material
+		var newMat = new SquareTunnelMaterial();
+
+		// copy over the current values;
+		var propNames = [],  propValues = [],  propTypes = [],  propLabels = [];
+		this.getAllProperties( propNames,  propValues,  propTypes,  propLabels);
+		var n = propNames.length;
+		for (var i=0;  i<n;  i++)
+			newMat.setProperty( propNames[i], propValues[i] );
+
+		return newMat;
+	} 
+
+	this.init = function( world )
+	{
+		// save the world
+		if (world)  this.setWorld( world );
+
+		// set up the shader
+		this._shader = new jshader();
+		this._shader.def = squareTunnelMaterialDef;
+		this._shader.init();
+
+		// set up the material node
+		this._materialNode = createMaterialNode("squareTunnelMaterial");
+		this._materialNode.setShader(this._shader);
+
+		this._time = 0;
+		if (this._shader && this._shader.default)
+			this._shader.default.u_time.set( [this._time] );
+
+		// set the shader values in the shader
+		this.updateTexture();
+		this.setResolution( [world.getViewportWidth(),world.getViewportHeight()] );
+		this.update( 0 );
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// RDGE shader
+ 
+// shader spec (can also be loaded from a .JSON file, or constructed at runtime)
+var squareTunnelMaterialDef =
+{'shaders': 
+	{
+		'defaultVShader':"assets/shaders/Basic.vert.glsl",
+		'defaultFShader':"assets/shaders/SquareTunnel.frag.glsl"
+	},
+	'techniques':
+	{ 
+		'default':
+		[
+			{
+				'vshader' : 'defaultVShader',
+				'fshader' : 'defaultFShader',
+				// attributes
+				'attributes' :
+				{
+					'vert'  :   { 'type' : 'vec3' },
+					'normal' :  { 'type' : 'vec3' },
+					'texcoord'  :   { 'type' : 'vec2' }
+				},
+				// parameters
+				'params' : 
+				{
+					'u_tex0': { 'type' : 'tex2d' },
+					'u_time' : { 'type' : 'float' },
+					'u_resolution'  :   { 'type' : 'vec2' },
+				},
+
+				// render states
+				'states' : 
+				{
+					'depthEnable' : true,
+					'offset':[1.0, 0.1]
+				},
+			},
+		]
+	}
+};
+
+
+
+
diff --git a/js/helper-classes/RDGE/Materials/StarMaterial.js b/js/helper-classes/RDGE/Materials/StarMaterial.js
new file mode 100644
index 00000000..a5f188a1
--- /dev/null
+++ b/js/helper-classes/RDGE/Materials/StarMaterial.js
@@ -0,0 +1,133 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+
+
+///////////////////////////////////////////////////////////////////////
+// Class GLMaterial
+//      RDGE representation of a material.
+///////////////////////////////////////////////////////////////////////
+function StarMaterial()
+{
+    // initialize the inherited members
+    this.inheritedFrom = PulseMaterial;
+    this.inheritedFrom();
+   
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._name = "StarMaterial";
+	this._shaderName = "star";
+
+	this._texMap = 'assets/images/rocky-normal.jpg';
+
+	this._time = 0.0;
+	this._dTime = 0.01;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Properties
+    ///////////////////////////////////////////////////////////////////////
+	// all defined in parent PulseMaterial.js
+	// load the local default value
+	this._propValues[ this._propNames[0] ] = this._texMap.slice(0);
+
+    ///////////////////////////////////////////////////////////////////////
+    // Material Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+	// duplcate method requirde
+	this.dup = function( world )
+	{
+		// allocate a new uber material
+		var newMat = new StarMaterial();
+
+		// copy over the current values;
+		var propNames = [],  propValues = [],  propTypes = [],  propLabels = [];
+		this.getAllProperties( propNames,  propValues,  propTypes,  propLabels);
+		var n = propNames.length;
+		for (var i=0;  i<n;  i++)
+			newMat.setProperty( propNames[i], propValues[i] );
+
+		return newMat;
+	} 
+
+	this.init = function( world )
+	{
+		// save the world
+		if (world)  this.setWorld( world );
+
+		// set up the shader
+		this._shader = new jshader();
+		this._shader.def = starMaterialDef;
+		this._shader.init();
+
+		// set up the material node
+		this._materialNode = createMaterialNode("starMaterial");
+		this._materialNode.setShader(this._shader);
+
+		this._time = 0;
+		if (this._shader && this._shader.default)
+			this._shader.default.u_time.set( [this._time] );
+
+		// set the shader values in the shader
+		this.updateTexture();
+		this.setResolution( [world.getViewportWidth(),world.getViewportHeight()] );
+		this.update( 0 );
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// RDGE shader
+ 
+// shader spec (can also be loaded from a .JSON file, or constructed at runtime)
+var starMaterialDef =
+{'shaders': 
+	{
+		'defaultVShader':"assets/shaders/Basic.vert.glsl",
+		'defaultFShader':"assets/shaders/Star.frag.glsl"
+	},
+	'techniques':
+	{ 
+		'default':
+		[
+			{
+				'vshader' : 'defaultVShader',
+				'fshader' : 'defaultFShader',
+				// attributes
+				'attributes' :
+				{
+					'vert'  :   { 'type' : 'vec3' },
+					'normal' :  { 'type' : 'vec3' },
+					'texcoord'  :   { 'type' : 'vec2' }
+				},
+				// parameters
+				'params' : 
+				{
+					'u_tex0': { 'type' : 'tex2d' },
+					'u_time' : { 'type' : 'float' },
+					'u_resolution'  :   { 'type' : 'vec2' },
+				},
+
+				// render states
+				'states' : 
+				{
+					'depthEnable' : true,
+					'offset':[1.0, 0.1]
+				},
+			},
+		]
+	}
+};
+
+
+
+
diff --git a/js/helper-classes/RDGE/Materials/WaterMaterial.js b/js/helper-classes/RDGE/Materials/WaterMaterial.js
new file mode 100644
index 00000000..e6b9a8c7
--- /dev/null
+++ b/js/helper-classes/RDGE/Materials/WaterMaterial.js
@@ -0,0 +1,133 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+
+
+///////////////////////////////////////////////////////////////////////
+// Class GLMaterial
+//      RDGE representation of a material.
+///////////////////////////////////////////////////////////////////////
+function WaterMaterial()
+{
+    // initialize the inherited members
+    this.inheritedFrom = PulseMaterial;
+    this.inheritedFrom();
+   
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._name = "WaterMaterial";
+	this._shaderName = "water";
+
+	this._texMap = 'assets/images/rocky-normal.jpg';
+
+	this._time = 0.0;
+	this._dTime = 0.01;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Properties
+    ///////////////////////////////////////////////////////////////////////
+	// all defined in parent PulseMaterial.js
+	// load the local default value
+	this._propValues[ this._propNames[0] ] = this._texMap.slice(0);
+
+    ///////////////////////////////////////////////////////////////////////
+    // Material Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+	// duplcate method requirde
+	this.dup = function( world )
+	{
+		// allocate a new uber material
+		var newMat = new WaterMaterial();
+
+		// copy over the current values;
+		var propNames = [],  propValues = [],  propTypes = [],  propLabels = [];
+		this.getAllProperties( propNames,  propValues,  propTypes,  propLabels);
+		var n = propNames.length;
+		for (var i=0;  i<n;  i++)
+			newMat.setProperty( propNames[i], propValues[i] );
+
+		return newMat;
+	} 
+
+	this.init = function( world )
+	{
+		// save the world
+		if (world)  this.setWorld( world );
+
+		// set up the shader
+		this._shader = new jshader();
+		this._shader.def = waterMaterialDef;
+		this._shader.init();
+
+		// set up the material node
+		this._materialNode = createMaterialNode("waterMaterial");
+		this._materialNode.setShader(this._shader);
+
+		this._time = 0;
+		if (this._shader && this._shader.default)
+			this._shader.default.u_time.set( [this._time] );
+
+		// set the shader values in the shader
+		this.updateTexture();
+		this.setResolution( [world.getViewportWidth(),world.getViewportHeight()] );
+		this.update( 0 );
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// RDGE shader
+ 
+// shader spec (can also be loaded from a .JSON file, or constructed at runtime)
+var waterMaterialDef =
+{'shaders': 
+	{
+		'defaultVShader':"assets/shaders/Basic.vert.glsl",
+		'defaultFShader':"assets/shaders/Water.frag.glsl"
+	},
+	'techniques':
+	{ 
+		'default':
+		[
+			{
+				'vshader' : 'defaultVShader',
+				'fshader' : 'defaultFShader',
+				// attributes
+				'attributes' :
+				{
+					'vert'  :   { 'type' : 'vec3' },
+					'normal' :  { 'type' : 'vec3' },
+					'texcoord'  :   { 'type' : 'vec2' }
+				},
+				// parameters
+				'params' : 
+				{
+					'u_tex0': { 'type' : 'tex2d' },
+					'u_time' : { 'type' : 'float' },
+					'u_resolution'  :   { 'type' : 'vec2' },
+				},
+
+				// render states
+				'states' : 
+				{
+					'depthEnable' : true,
+					'offset':[1.0, 0.1]
+				},
+			},
+		]
+	}
+};
+
+
+
+
diff --git a/js/helper-classes/RDGE/Materials/ZInvertMaterial.js b/js/helper-classes/RDGE/Materials/ZInvertMaterial.js
new file mode 100644
index 00000000..2ac8920f
--- /dev/null
+++ b/js/helper-classes/RDGE/Materials/ZInvertMaterial.js
@@ -0,0 +1,133 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+
+
+///////////////////////////////////////////////////////////////////////
+// Class GLMaterial
+//      RDGE representation of a material.
+///////////////////////////////////////////////////////////////////////
+function ZInvertMaterial()
+{
+    // initialize the inherited members
+    this.inheritedFrom = PulseMaterial;
+    this.inheritedFrom();
+   
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._name = "ZInvertMaterial";
+	this._shaderName = "zinvert";
+
+	this._texMap = 'assets/images/rocky-normal.jpg';
+
+	this._time = 0.0;
+	this._dTime = 0.01;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Properties
+    ///////////////////////////////////////////////////////////////////////
+	// all defined in parent PulseMaterial.js
+	// load the local default value
+	this._propValues[ this._propNames[0] ] = this._texMap.slice(0);
+
+    ///////////////////////////////////////////////////////////////////////
+    // Material Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+	// duplcate method requirde
+	this.dup = function( world )
+	{
+		// allocate a new uber material
+		var newMat = new ZInvertMaterial();
+
+		// copy over the current values;
+		var propNames = [],  propValues = [],  propTypes = [],  propLabels = [];
+		this.getAllProperties( propNames,  propValues,  propTypes,  propLabels);
+		var n = propNames.length;
+		for (var i=0;  i<n;  i++)
+			newMat.setProperty( propNames[i], propValues[i] );
+
+		return newMat;
+	} 
+
+	this.init = function( world )
+	{
+		// save the world
+		if (world)  this.setWorld( world );
+
+		// set up the shader
+		this._shader = new jshader();
+		this._shader.def = zInvertMaterialDef;
+		this._shader.init();
+
+		// set up the material node
+		this._materialNode = createMaterialNode("zInvertMaterial");
+		this._materialNode.setShader(this._shader);
+
+		this._time = 0;
+		if (this._shader && this._shader.default)
+			this._shader.default.u_time.set( [this._time] );
+
+		// set the shader values in the shader
+		this.updateTexture();
+		this.setResolution( [world.getViewportWidth(),world.getViewportHeight()] );
+		this.update( 0 );
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+// RDGE shader
+ 
+// shader spec (can also be loaded from a .JSON file, or constructed at runtime)
+var zInvertMaterialDef =
+{'shaders': 
+	{
+		'defaultVShader':"assets/shaders/Basic.vert.glsl",
+		'defaultFShader':"assets/shaders/ZInvert.frag.glsl"
+	},
+	'techniques':
+	{ 
+		'default':
+		[
+			{
+				'vshader' : 'defaultVShader',
+				'fshader' : 'defaultFShader',
+				// attributes
+				'attributes' :
+				{
+					'vert'  :   { 'type' : 'vec3' },
+					'normal' :  { 'type' : 'vec3' },
+					'texcoord'  :   { 'type' : 'vec2' }
+				},
+				// parameters
+				'params' : 
+				{
+					'u_tex0': { 'type' : 'tex2d' },
+					'u_time' : { 'type' : 'float' },
+					'u_resolution'  :   { 'type' : 'vec2' },
+				},
+
+				// render states
+				'states' : 
+				{
+					'depthEnable' : true,
+					'offset':[1.0, 0.1]
+				},
+			},
+		]
+	}
+};
+
+
+
+
diff --git a/js/helper-classes/RDGE/MaterialsLibrary.js b/js/helper-classes/RDGE/MaterialsLibrary.js
index 5f82a996..19204470 100644
--- a/js/helper-classes/RDGE/MaterialsLibrary.js
+++ b/js/helper-classes/RDGE/MaterialsLibrary.js
@@ -136,6 +136,13 @@ var MaterialsLibrary = Object.create(Object.prototype, {
 					case "radialBlur":			mat = new RadiaBlurMaterial();			break;
 					case "pulse":				mat = new PulseMaterial();				break;
 					case "tunnel":				mat = new TunnelMaterial();				break;
+					case "reliefTunnel":		mat = new ReliefTunnelMaterial();		break;
+					case "squareTunnel":		mat = new SquareTunnelMaterial();		break;
+					case "fly":					mat = new FlyMaterial();				break;
+					case "water":				mat = new WaterMaterial();				break;
+					case "zInvert":				mat = new ZInvertMaterial();			break;
+					case "deform":				mat = new DeformMaterial();				break;
+					case "star":				mat = new StarMaterial();				break;
 					case "twist":				mat = new TwistMaterial();				break;
 					case "keleidoscope":		mat = new KeleidoscopeMaterial();		break;
 					case "julia":				mat = new JuliaMaterial();				break;
@@ -175,6 +182,13 @@ var radialGradientMaterial		= new RadialGradientMaterial();
 var radialBlurMaterial			= new RadialBlurMaterial();
 var pulseMaterial				= new PulseMaterial();
 var tunnelMaterial				= new TunnelMaterial();
+var reliefTunnelMaterial		= new ReliefTunnelMaterial();
+var squareTunnelMaterial		= new SquareTunnelMaterial();
+var flyMaterial					= new FlyMaterial();
+var waterMaterial				= new WaterMaterial();
+var zInvertMaterial				= new ZInvertMaterial();
+var deformMaterial				= new DeformMaterial();
+var starMaterial				= new StarMaterial();
 var twistMaterial				= new TwistMaterial();
 var keleidoscopeMaterial		= new KeleidoscopeMaterial();
 var juliaMaterial				= new JuliaMaterial();
@@ -187,6 +201,13 @@ MaterialsLibrary.addMaterial(radialGradientMaterial);
 MaterialsLibrary.addMaterial(radialBlurMaterial);
 MaterialsLibrary.addMaterial(pulseMaterial);
 MaterialsLibrary.addMaterial(tunnelMaterial);
+MaterialsLibrary.addMaterial(reliefTunnelMaterial);
+MaterialsLibrary.addMaterial(squareTunnelMaterial);
+MaterialsLibrary.addMaterial(flyMaterial);
+MaterialsLibrary.addMaterial(waterMaterial);
+MaterialsLibrary.addMaterial(zInvertMaterial);
+MaterialsLibrary.addMaterial(deformMaterial);
+MaterialsLibrary.addMaterial(starMaterial);
 MaterialsLibrary.addMaterial(twistMaterial);
 MaterialsLibrary.addMaterial(keleidoscopeMaterial);
 MaterialsLibrary.addMaterial(juliaMaterial);
-- 
cgit v1.2.3


From 4ebae7378608750192f8d3bb392a54222ca0ec2f Mon Sep 17 00:00:00 2001
From: hwc487
Date: Thu, 2 Feb 2012 13:56:25 -0800
Subject: Added the 'animate' flag to the pulse material

---
 js/helper-classes/RDGE/Materials/RadialBlurMaterial.js | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'js/helper-classes')

diff --git a/js/helper-classes/RDGE/Materials/RadialBlurMaterial.js b/js/helper-classes/RDGE/Materials/RadialBlurMaterial.js
index 9acb4213..732800cf 100644
--- a/js/helper-classes/RDGE/Materials/RadialBlurMaterial.js
+++ b/js/helper-classes/RDGE/Materials/RadialBlurMaterial.js
@@ -37,6 +37,8 @@ function RadialBlurMaterial()
 	this.getTextureMap			= function()		{  return this._texMap.slice(0);	}
 	this.setTextureMap			= function(m)		{  this._propValues[this._propNames[0]] = m.slice(0);  this.updateTexture();  	}	
 
+	this.isAnimated				= function()		{  return true;		}
+
     ///////////////////////////////////////////////////////////////////////
     // Material Property Accessors
     ///////////////////////////////////////////////////////////////////////
-- 
cgit v1.2.3


From 3d5b5f7c5efb25b5e605d5d120b57f2dde33fd23 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Fri, 3 Feb 2012 15:18:45 -0800
Subject: Added a counter to the renderer that tracks the number of unloaded
 texture maps.

Started vertex deformations.
---
 js/helper-classes/RDGE/GLMaterial.js               |  11 ++
 js/helper-classes/RDGE/GLRectangle.js              | 148 +++++++++++++++++++--
 js/helper-classes/RDGE/GLWorld.js                  |  25 ++--
 js/helper-classes/RDGE/Materials/FlatMaterial.js   |   1 +
 .../RDGE/Materials/LinearGradientMaterial.js       |   4 +-
 js/helper-classes/RDGE/src/core/script/renderer.js |  13 ++
 6 files changed, 178 insertions(+), 24 deletions(-)

(limited to 'js/helper-classes')

diff --git a/js/helper-classes/RDGE/GLMaterial.js b/js/helper-classes/RDGE/GLMaterial.js
index c633f679..07a98ab5 100644
--- a/js/helper-classes/RDGE/GLMaterial.js
+++ b/js/helper-classes/RDGE/GLMaterial.js
@@ -31,6 +31,11 @@ function GLMaterial( world )
 
 	this._texture;
 
+	// vertex deformation variables
+	this._hasVertexDeformation = false;
+	this._vertexDeformationRange = [0, 0, 1, 1];	// (xMin, yMin, xMax, yMax)
+	this._vertexDeformationTolerance = 0.05;
+
 	// RDGE variables
 	this._shader;
 	this._materialNode;
@@ -66,6 +71,12 @@ function GLMaterial( world )
 	// Any material needing continuous rendering should override this method
 	this.isAnimated			= function()			{  return false;					}
 
+	// the vertex shader can apply deformations requiring refinement in
+	// certain areas.
+	this.hasVertexDeformation			= function()	{  return this._hasVertexDeformation;			}
+	this.getVertexDeformationRange		= function()	{  return this._vertexDeformationRange.slice();			}	
+	this.getVertexDeformationTolerance	= function()	{  return this._vertexDeformationTolerance;		}
+
 
     ///////////////////////////////////////////////////////////////////////
     // Common Material Methods
diff --git a/js/helper-classes/RDGE/GLRectangle.js b/js/helper-classes/RDGE/GLRectangle.js
index 1bb4bcac..e72b4488 100644
--- a/js/helper-classes/RDGE/GLRectangle.js
+++ b/js/helper-classes/RDGE/GLRectangle.js
@@ -280,7 +280,7 @@ function GLRectangle()
 
 		// stroke
 		var strokeMaterial = this.makeStrokeMaterial();
-		prim = this.createStroke([x,y],  2*xFill,  2*yFill,  strokeSize,  tlRadius, blRadius, brRadius, trRadius, strokeMaterial)
+		prim = this.createStroke([x,y],  2*xFill,  2*yFill,  strokeSize,  tlRadius, blRadius, brRadius, trRadius);
         this._primArray.push( prim );
 		this._materialNodeArray.push( strokeMaterial.getMaterialNode() );
 
@@ -486,7 +486,7 @@ function GLRectangle()
 	this.createStroke = function(ctr,  width,  height,  strokeWidth,  tlRad, blRad, brRad, trRad, material)
 	{
 		// create the geometry
-		var prim = RectangleStroke.create( ctr,  width, height, strokeWidth,  tlRad, blRad,  brRad, trRad)
+		var prim = RectangleStroke.create( ctr,  width, height, strokeWidth,  tlRad, blRad,  brRad, trRad, material)
 		return prim;
 	}
 
@@ -496,9 +496,9 @@ function GLRectangle()
 		// special the (common) case of no rounded corners
 		var prim
 		if ((tlRad <= 0) && (blRad <= 0) && (brRad <= 0) && (trRad <= 0))
-			prim = RectangleGeometry.create( ctr, width, height );
+			prim = RectangleGeometry.create( ctr, width, height, material );
 		else
-			prim = RectangleFill.create( ctr,  width, height,  tlRad, blRad,  brRad, trRad);
+			prim = RectangleFill.create( ctr,  width, height,  tlRad, blRad,  brRad, trRad, material);
 
 		return prim;
 	}
@@ -747,7 +747,7 @@ function GLRectangle()
  }
 
 RectangleFill = {};
-RectangleFill.create = function( rectCtr,  width, height, tlRad, blRad,  brRad, trRad)
+RectangleFill.create = function( rectCtr,  width, height, tlRad, blRad,  brRad, trRad,  material)
 {
 	var x = rectCtr[0],  y = rectCtr[1],  z = 0.0;
 	var	hw = 0.5*width,  hh = 0.5*height;
@@ -834,6 +834,17 @@ RectangleFill.create = function( rectCtr,  width, height, tlRad, blRad,  brRad,
 		j++;
 	}
 
+	//refine the mesh for vertex deformations
+	if (material)
+	{
+		if (material.hasVertexDeformation())
+		{
+			var paramRange = material.getVertexDeformationRange();
+			var tolerance = material.getVertexDeformationTolerance();
+			nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
+		}
+	}
+
 	// create the RDGE primitive
 	var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.TRIANGLES, nVertices);
 	return prim;
@@ -906,7 +917,7 @@ RectangleFill.getRoundedCorner = function(ctr, startPt,  vertices)
 
 
 RectangleStroke = {};
-RectangleStroke.create = function( rectCtr,  width, height, strokeWidth,  tlRad, blRad,  brRad, trRad)
+RectangleStroke.create = function( rectCtr,  width, height, strokeWidth,  tlRad, blRad,  brRad, trRad, material)
 {
 	var x = rectCtr[0],  y = rectCtr[1],  z = 0.0;
 	var	hw = 0.5*width,  hh = 0.5*height,  sw = strokeWidth;
@@ -1097,6 +1108,17 @@ RectangleStroke.create = function( rectCtr,  width, height, strokeWidth,  tlRad,
 		k++;
 	}
 
+	//refine the mesh for vertex deformations
+	if (material)
+	{
+		if (material.hasVertexDeformation())
+		{
+			var paramRange = material.getVertexDeformationRange();
+			var tolerance = material.getVertexDeformationTolerance();
+			nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
+		}
+	}
+
 	// create the RDGE primitive
 	var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.TRIANGLES, nVertices);
 	return prim;
@@ -1141,7 +1163,7 @@ RectangleStroke.getUV		= RectangleFill.getUV;
 
 // Helper function for generating Three.js geometry
 RectangleGeometry = {};
-RectangleGeometry.create = function( ctr,  width, height )
+RectangleGeometry.create = function( ctr,  width, height, material )
 {
 	var x = ctr[0],  y = ctr[1],  z = 0.0;
 	var	hw = 0.5*width,  hh = 0.5*height;
@@ -1179,6 +1201,17 @@ RectangleGeometry.create = function( ctr,  width, height )
 	RectangleGeometry.pushIndices( 2, 1, 0 );
 	RectangleGeometry.pushIndices( 0, 3, 2 );
 
+	//refine the mesh for vertex deformations
+	if (material)
+	{
+		if (material.hasVertexDeformation())
+		{
+			var paramRange = material.getVertexDeformationRange();
+			var tolerance = material.getVertexDeformationTolerance();
+			nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
+		}
+	}
+
 	// create the RDGE primitive
 	var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.TRIANGLES, nVertices);
 	return prim;
@@ -1249,4 +1282,103 @@ ShapePrimitive.create = function(coords,  normals,  uvs,  indices, primType, ver
 	renderer.createPrimitive(prim, vertexCount);
 
 	return prim;
-}
\ No newline at end of file
+}
+
+
+ShapePrimitive.refineMesh = function( verts, norms, uvs, indices, nVertices,  paramRange,  tolerance )
+{
+	// get the param range
+	var pUMin = paramRange[0],  pVMin = paramRange[1],
+		pUMax = paramRange[2],  pVMax = paramRange[3];
+	var iTriangle = 0;
+	var nTriangles = indices.length/3;
+	var index = 0;
+	while (iTriangle < nTriangles)
+	{
+		// get the indices of the 3 vertices
+		var i0 = indices[index],
+			i1 = indices[index+1],
+			i2 = indices[index+2];
+
+		// get the uv values
+		var vrtIndex = 3*iTriangle;
+		var iuv0 = 2 * i0,
+			iuv1 = 2 * i1,
+			iuv2 = 2 * i2;
+		var u0 = uvs[iuv0],  v0 = uvs[iuv0+1],
+			u1 = uvs[iuv1],  v1 = uvs[iuv1+1],
+			u2 = uvs[iuv2],  v2 = uvs[iuv2+1];
+
+		// find the u and v range
+		var uMin = u0,  vMin = v0;
+		if (u1 < uMin)  uMin = u1;  if (v1 < vMin)  vMin = v1;
+		if (u2 < uMin)  uMin = u2;  if (v2 < vMin)  vMin = v2;
+		var uMax = u0,  vMax = v0;
+		if (u1 > uMax)  uMax = u1;  if (v1 > vMax)  vMax = v1;
+		if (u2 > uMax)  uMax = u2;  if (v2 > vMax)  vMax = v2;
+
+		// if the parameter range of the triangle is outside the
+		// desired parameter range, advance to the next polygon and continue
+		if ((uMin > pUMax) || (uMax < pUMin) || (vMin > pVMax) || (vMax < pVMin))
+		{
+			// go to the next triangle
+			iTriangle++;
+			index += 3;
+		}
+		else
+		{
+			// check thesize of the triangle in uv space.  If small enough, advance
+			// to the next triangle.  If not small enough, split the triangle into 3;
+			var du = uMax - uMin,  dv = vMax - vMin;
+			if ((du < tolerance) && (dv < tolerance))
+			{
+				iTriangle++;
+				index += 3;
+			}
+			else	// split the triangle
+			{
+				//calculate the position of the new vertex
+				var iPt0 = 3 * i0,
+					iPt1 = 3 * i1,
+					iPt2 = 3 * i2;
+				var x0 = verts[iPt0],  y0 = verts[iPt0+1],  z0 = verts[iPt0+2],
+					x1 = verts[iPt1],  y1 = verts[iPt1+1],  z1 = verts[iPt1+2],
+					x2 = verts[iPt2],  y2 = verts[iPt2+1],  z2 = verts[iPt2+2];
+				var xMid = (x0 + x1 + x2)/3.0,
+					yMid = (y0 + y1 + y2)/3.0,
+					zMid = (z0 + z1 + z2)/3.0;
+
+				// calculate the uv value of the new coordinate
+				var uMid = (u0 + u1 + u2)/3.0,
+					vMid = (v0 + v1 + v2)/3.0;
+
+				// calculate the normal for the new coordinate
+				var nx0 = norms[iPt0],  ny0 = norms[iPt0+1],  nz0 = norms[iPt0+2],
+					nx1 = norms[iPt1],  ny1 = norms[iPt1+1],  nz1 = norms[iPt1+2],
+					nx2 = norms[iPt2],  ny2 = norms[iPt2+1],  nz2 = norms[iPt2+2];
+				var nxMid = (nx0 + nx1 + nx2),
+					nyMid = (ny0 + ny1 + ny2),
+					nzMid = (nz0 + nz1 + nz2);
+				var nrm = VecUtils.vecNormalize(3, [nxMid, nyMid, nzMid], 1.0 );
+
+				// push the new vertex
+				verts.push(nrm[0]);  verts.push(nrm[1]);  verts.push(nrm[2]);
+				uvs.push(uMid),  uvs.push(vMid);
+				norms.push(nrm[0]);  norms.push(nrm[1]);  norms.push(nrm[2]);
+				var iMidVrt = nVertices;
+				nVertices++;
+
+				// split the current triangle into 3
+				indices[index+2] = iMidVrt;
+				indices.push(i1);  indices.push(i2);  indices.push(iMidVrt);  nTriangles++;
+				indices.push(i2);  indices.push(i0);  indices.push(iMidVrt);  nTriangles++;
+
+				// by not advancing 'index', we examine the first of the 3 triangles generated above
+			}
+		}
+	}
+	return nVertices;
+}
+
+
+
diff --git a/js/helper-classes/RDGE/GLWorld.js b/js/helper-classes/RDGE/GLWorld.js
index 819f89db..c97e29d4 100644
--- a/js/helper-classes/RDGE/GLWorld.js
+++ b/js/helper-classes/RDGE/GLWorld.js
@@ -225,19 +225,15 @@ function GLWorld( canvas, use3D )
     {
 		if (this._useWebGL)
 		{
-			if (this._allMapsLoaded)
+			var ctx = g_Engine.getContext();
+			var ctx1 = g_Engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle);
+			if (ctx1 != ctx)  console.log( "***** different contexts (2) *****" );
+			var aRenderer = ctx1.renderer;
+			var renderer = ctx.renderer;
+			if (renderer != aRenderer)  console.log( "***** DIFFERENT RENDERERS *****" );
+				
+			if (renderer.unloadedTextureCount <= 0)
 			{
-				var ctx = g_Engine.getContext();
-				//console.log( "RDGE state: " + ctx.ctxStateManager.currentState().name);
-
-				/////////////////////////////
-				var ctx1 = g_Engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle);
-				if (ctx1 != ctx)  console.log( "***** different contexts (2) *****" );
-				var aRenderer = ctx1.renderer;
-				//////////////////////////////////////////
-
-				var renderer = ctx.renderer;
-				if (renderer != aRenderer)  console.log( "***** DIFFERENT RENDERERS *****" );
 				renderer.disableCulling();
 				this.myScene.render();
 				//console.log( "render" );
@@ -249,8 +245,8 @@ function GLWorld( canvas, use3D )
 					if (!this.hasAnimatedMaterials())
 					{
 						//this.myScene.render();
-						//this._canvas.task.stop();
-						this._renderCount = 10;
+						this._canvas.task.stop();
+						//this._renderCount = 10;
 					}
 				}
 				else if (this._renderCount >= 0)
@@ -259,7 +255,6 @@ function GLWorld( canvas, use3D )
 					if (this._renderCount <= 0)
 						this._canvas.task.stop();
 				}
-
 			}
 		}
 		else
diff --git a/js/helper-classes/RDGE/Materials/FlatMaterial.js b/js/helper-classes/RDGE/Materials/FlatMaterial.js
index 3e3ae25e..c8eb3b6c 100644
--- a/js/helper-classes/RDGE/Materials/FlatMaterial.js
+++ b/js/helper-classes/RDGE/Materials/FlatMaterial.js
@@ -121,6 +121,7 @@ function FlatMaterial()
 flatShaderDef  = 
 {
     'shaders':  { // shader files
+		//'defaultVShader':"assets/shaders/Taper.vert.glsl",
 		'defaultVShader':"assets/shaders/Basic.vert.glsl",
 		'defaultFShader':"assets/shaders/Basic.frag.glsl",
         },
diff --git a/js/helper-classes/RDGE/Materials/LinearGradientMaterial.js b/js/helper-classes/RDGE/Materials/LinearGradientMaterial.js
index ce965296..8b23d77e 100644
--- a/js/helper-classes/RDGE/Materials/LinearGradientMaterial.js
+++ b/js/helper-classes/RDGE/Materials/LinearGradientMaterial.js
@@ -135,8 +135,10 @@ function LinearGradientMaterial()
 	// duplcate method requirde
 	this.dup = function()	{  return new LinearGradientMaterial();	} 
 
-	this.init = function()
+	this.init = function( world )
 	{
+		this.setWorld( world );
+
 		// set up the shader
 		this._shader = new jshader();
 		this._shader.def = linearGradientMaterialDef;
diff --git a/js/helper-classes/RDGE/src/core/script/renderer.js b/js/helper-classes/RDGE/src/core/script/renderer.js
index 517947df..04cb36a7 100644
--- a/js/helper-classes/RDGE/src/core/script/renderer.js
+++ b/js/helper-classes/RDGE/src/core/script/renderer.js
@@ -359,9 +359,11 @@ _renderer = function(canvas) {
     *	@param wrap - optional "CLAMP or "REPEAT", default is clamp
     *	@param mips - optional true/false value to create mipmaps, the default is true
     */
+	this.unloadedTextureCount = 0;
     _texparams = function(wrap, mips) { this.wrap = wrap, this.mips = mips };
     this.createTexture = function(url, wrap, mips) {
         var texture = this.ctx.createTexture();
+		this.unloadedTextureCount++;
 
         if (wrap === undefined)
             wrap = "CLAMP";
@@ -379,7 +381,18 @@ _renderer = function(canvas) {
                 stateMan.RDGEInitState.loadTexture(texture);
 				//console.log( "loaded texture: " + texture.lookUpName );
 				if (texture.callback)  texture.callback( texture );
+				this.context.renderer.unloadedTextureCount--;
+				if (this.context.renderer.unloadedTextureCount < 0)
+					console.log( "more textures loaded then created..." );
             };
+			texture.image.onerror = function() {
+				this.context.renderer.unloadedTextureCount--;
+				if (texture.callback)  texture.callback( texture );
+				console.log( "Error loading texture: " + texture.image.src );
+				if (this.context.renderer.unloadedTextureCount < 0)
+					console.log( "more textures loaded then created..." );
+			}
+				
         }
         return texture;
     }
-- 
cgit v1.2.3


From 465636cc0676d7fb83939d6fdb9204e474d47d46 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Mon, 6 Feb 2012 13:08:26 -0800
Subject: Removed an unnecessary (and incorrect) snapping calculation.

---
 js/helper-classes/3D/snap-manager.js | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

(limited to 'js/helper-classes')

diff --git a/js/helper-classes/3D/snap-manager.js b/js/helper-classes/3D/snap-manager.js
index 8819f637..7e1260bf 100644
--- a/js/helper-classes/3D/snap-manager.js
+++ b/js/helper-classes/3D/snap-manager.js
@@ -977,7 +977,7 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
 			viewUtils.setViewportObj( stage );
 
 			MathUtils.makeDimension3( screenPt );
-			this.hSnapToElements( stage,  screenPt, hitRecs, 0, screenPt );
+			this.hSnapToElements( stage,  hitRecs, 0, screenPt );
 
 			return;
 		}
@@ -985,7 +985,7 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
 
 	hSnapToElements : 
 	{
-		value: function( elt, parentPt, hitRecs, depth, globalScrPt )
+		value: function( elt, hitRecs, depth, globalScrPt )
 		{
 			// hit test the current object
 			var hit;
@@ -994,8 +994,7 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
 				// if the element is in the 2D cache snapping is done there
 				if (elt.elementModel && !elt.elementModel.isIn2DSnapCache)
 				{
-					var scrPt = viewUtils.parentToChild( parentPt, elt, false );
-					hit = this.snapToElement( elt, scrPt, globalScrPt );
+					hit = this.snapToElement( elt, globalScrPt );
 					if (hit)
 					{
 						//hitRecs.push( hit );
@@ -1017,14 +1016,14 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
             }
 			// test the rest of the tree
 			var n = elt.childElementCount;
-			var eltPt = viewUtils.parentToChild( parentPt, elt, true );
+			//var eltPt = viewUtils.parentToChild( parentPt, elt, true );
 			if (n > 0)
 			{
 				for (var i=0;  i<n;  i++)
 				{
 					var child = elt.children[i];
 					//var childPt = viewUtils.parentToChild( scrPt, child );
-					hit = this.hSnapToElements( child,  eltPt, hitRecs, (depth+1), globalScrPt );
+					hit = this.hSnapToElements( child,  hitRecs, (depth+1), globalScrPt );
 					if (hit)
 					{
 						//hitRecs.push( hit );
@@ -1044,7 +1043,7 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
 
 	snapToElement : 
 	{
-		value: function( elt, scrPt, globalScrPt ) 
+		value: function( elt, globalScrPt ) 
 		{
 			if (this.isAvoidedElement(elt) )  return null;
 
-- 
cgit v1.2.3


From 9d122c5f1632b1225a543049913c36b9a030110c Mon Sep 17 00:00:00 2001
From: hwc487
Date: Mon, 6 Feb 2012 15:50:07 -0800
Subject: Enhanced the overlap test for the selection tool marquee select.

---
 js/helper-classes/3D/math-utils.js   | 97 +++++++++++++++++++++++++++++++++++-
 js/helper-classes/3D/snap-manager.js |  6 ---
 2 files changed, 96 insertions(+), 7 deletions(-)

(limited to 'js/helper-classes')

diff --git a/js/helper-classes/3D/math-utils.js b/js/helper-classes/3D/math-utils.js
index 71ed62a0..58f0680a 100644
--- a/js/helper-classes/3D/math-utils.js
+++ b/js/helper-classes/3D/math-utils.js
@@ -8,7 +8,9 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 // Class Utils
 //      Math Utility functions
 ///////////////////////////////////////////////////////////////////////
-var VecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
+var VecUtils = require("js/helper-classes/3D/vec-utils").VecUtils,
+	ViewUtils = require("js/helper-classes/3D/view-utils").ViewUtils,
+	Rectangle = require("js/helper-classes/3D/rectangle").Rectangle;
 
 var MathUtilsClass = exports.MathUtilsClass = Object.create(Object.prototype, {
     ///////////////////////////////////////////////////////////////////////
@@ -536,6 +538,99 @@ var MathUtilsClass = exports.MathUtilsClass = Object.create(Object.prototype, {
         }
     },
 
+	rectsOverlap:
+	{
+		value: function( pt, width, height,  elt )
+		{
+			// only consider rectangles with non-zero area
+			if ((width == 0) || (height == 0))  return false;
+
+			// get the mins/maxs of the onput rectangle
+			var xMin, xMax, yMin, yMax;
+			if (width > 0)  {  xMin = pt[0];   xMax = pt[0] + width;  }
+			else  {  xMax = pt[0];  xMin = pt[0] + width;  }
+			if (height > 0)  {  yMin = pt[1];   yMax = pt[1] + height;  }
+			else  {  yMax = pt[1];  yMin = pt[1] + height;  }
+
+			// get the bounds of the element in global screen space
+			var bounds = ViewUtils.getElementViewBounds3D( elt );
+			var bounds3D = [];
+			for (var i=0;  i<4;  i++)
+				bounds3D[i] = ViewUtils.localToGlobal( bounds[i],  elt );
+
+			// get the min/maxs for the element
+			var xMinElt = bounds3D[0][0],  xMaxElt = bounds3D[0][0],
+				yMinElt = bounds3D[0][1],  yMaxElt = bounds3D[0][1];
+			for (var i=1;  i<4;  i++)
+			{
+				if (bounds3D[i][0] < xMinElt)  xMinElt = bounds3D[i][0];
+				else if  (bounds3D[i][0] > xMaxElt)  xMaxElt = bounds3D[i][0];
+				if (bounds3D[i][1] < yMinElt)  yMinElt = bounds3D[i][1];
+				else if  (bounds3D[i][1] > yMaxElt)  yMaxElt = bounds3D[i][1];
+			}
+
+			// test 1.  Overall bounding box test
+			if ((xMaxElt < xMin) || (xMinElt > xMax) || (yMaxElt < yMin) || (yMinElt > yMax))
+				return false;
+			
+			// test 2.  See if any of the corners of the element are contained in the rectangle
+			var rect = Object.create(Rectangle, {});
+			rect.set( pt[0], pt[1], width, height );
+			for (var i=0;  i<4;  i++)
+			{
+				if (rect.contains( bounds3D[i][0], bounds3D[i][1] ))  return true;
+			}
+
+			// test 3.  Bounding box tests on individual edges of the element
+			for (var i=0;  i<4;  i++)
+			{
+				var pt0 = bounds3D[i],
+					pt1 = bounds3D[(i+1)%4];
+
+				// get the extremes of the edge
+				if (pt0[0] < pt1[0])  {  xMinElt = pt0[0];  xMaxElt = pt1[0];  }
+				else {  xMaxElt = pt0[0];  xMinElt = pt1[0]; }
+				if (pt0[1] < pt1[1])  {  yMinElt = pt0[1];  yMaxElt = pt1[1];  }
+				else {  yMaxElt = pt0[1];  yMinElt = pt1[1]; }
+
+				if ((xMaxElt < xMin) || (xMinElt > xMax) || (yMaxElt < yMin) || (yMinElt > yMax))
+					continue;
+				else
+				{
+					// intersect the element edge with the 4 sides of the rectangle
+					// vertical edges
+					var xRect = xMin;
+					for (var j=0;  j<2;  j++)
+					{
+						if ((xMinElt < xRect) && (xMaxElt > xRect))
+						{
+							var t = (xRect - pt0[0])/(pt1[0] - pt0[0]);
+							var y = pt0[1] + t*(pt1[1] - pt0[1]);
+							if ((y >= yMin) && (y <= yMax))  return true;
+						}
+						xRect = xMax;
+					}
+
+					// horizontal edges
+					var yRect = yMin;
+					for (var j=0;  j<2;  j++)
+					{
+						if ((yMinElt < yRect) && (yMaxElt > yRect))
+						{
+							var t = (yRect - pt0[1])/(pt1[1] - pt0[1]);
+							var x = pt0[0] + t*(pt1[0] - pt0[0]);
+							if ((x >= xMin) && (x <= xMax))  return true;
+						}
+						yRect = yMax;
+					}
+				}
+			}
+
+			// if we get here there is no overlap
+			return false;
+		}
+	},
+
     ///////////////////////////////////////////////////////////////////////
     // Bezier Methods
     ///////////////////////////////////////////////////////////////////////
diff --git a/js/helper-classes/3D/snap-manager.js b/js/helper-classes/3D/snap-manager.js
index 7e1260bf..f3e8b823 100644
--- a/js/helper-classes/3D/snap-manager.js
+++ b/js/helper-classes/3D/snap-manager.js
@@ -971,7 +971,6 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
 		value: function( screenPt,  hitRecs ) {
 			// start at the stage.
 			var stage = this.getStage();
-			//var stagePt = viewUtils.parentToChild( screenPt, stage );
 
 			// the root should be the 'view' canvas, so the first matrix is the camera
 			viewUtils.setViewportObj( stage );
@@ -997,7 +996,6 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
 					hit = this.snapToElement( elt, globalScrPt );
 					if (hit)
 					{
-						//hitRecs.push( hit );
 						if (!hit.checkType())
 						{
 							console.log( "invalid hit record: " + hit.getTypeString() );
@@ -1016,17 +1014,14 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
             }
 			// test the rest of the tree
 			var n = elt.childElementCount;
-			//var eltPt = viewUtils.parentToChild( parentPt, elt, true );
 			if (n > 0)
 			{
 				for (var i=0;  i<n;  i++)
 				{
 					var child = elt.children[i];
-					//var childPt = viewUtils.parentToChild( scrPt, child );
 					hit = this.hSnapToElements( child,  hitRecs, (depth+1), globalScrPt );
 					if (hit)
 					{
-						//hitRecs.push( hit );
 						if (!hit.checkType())
 						{
 							console.log( "invalid hit record: " + hit.getTypeString() );
@@ -1034,7 +1029,6 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
 						}
 						else
 							hitRecs.push( hit );
-
 					}
 				}
 			}
-- 
cgit v1.2.3


From 2d4da18a778471b02e188ad668752e331ee76127 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Tue, 7 Feb 2012 14:35:55 -0800
Subject: test code for deformation shader

---
 js/helper-classes/RDGE/GLMaterial.js             |  4 +-
 js/helper-classes/RDGE/GLRectangle.js            | 64 ++++++++++++++----------
 js/helper-classes/RDGE/GLWorld.js                |  6 ++-
 js/helper-classes/RDGE/Materials/FlatMaterial.js | 11 ++--
 4 files changed, 52 insertions(+), 33 deletions(-)

(limited to 'js/helper-classes')

diff --git a/js/helper-classes/RDGE/GLMaterial.js b/js/helper-classes/RDGE/GLMaterial.js
index 07a98ab5..a74a74e4 100644
--- a/js/helper-classes/RDGE/GLMaterial.js
+++ b/js/helper-classes/RDGE/GLMaterial.js
@@ -34,7 +34,7 @@ function GLMaterial( world )
 	// vertex deformation variables
 	this._hasVertexDeformation = false;
 	this._vertexDeformationRange = [0, 0, 1, 1];	// (xMin, yMin, xMax, yMax)
-	this._vertexDeformationTolerance = 0.05;
+	this._vertexDeformationTolerance = 0.1;
 
 	// RDGE variables
 	this._shader;
@@ -74,7 +74,7 @@ function GLMaterial( world )
 	// the vertex shader can apply deformations requiring refinement in
 	// certain areas.
 	this.hasVertexDeformation			= function()	{  return this._hasVertexDeformation;			}
-	this.getVertexDeformationRange		= function()	{  return this._vertexDeformationRange.slice();			}	
+	this.getVertexDeformationRange		= function()	{  return this._vertexDeformationRange.slice();	}	
 	this.getVertexDeformationTolerance	= function()	{  return this._vertexDeformationTolerance;		}
 
 
diff --git a/js/helper-classes/RDGE/GLRectangle.js b/js/helper-classes/RDGE/GLRectangle.js
index e72b4488..7fe03022 100644
--- a/js/helper-classes/RDGE/GLRectangle.js
+++ b/js/helper-classes/RDGE/GLRectangle.js
@@ -1121,6 +1121,7 @@ RectangleStroke.create = function( rectCtr,  width, height, strokeWidth,  tlRad,
 
 	// create the RDGE primitive
 	var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.TRIANGLES, nVertices);
+	//var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.LINES, nVertices);
 	return prim;
 }
 
@@ -1214,6 +1215,7 @@ RectangleGeometry.create = function( ctr,  width, height, material )
 
 	// create the RDGE primitive
 	var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.TRIANGLES, nVertices);
+	//var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.LINES, nVertices);
 	return prim;
 }
 
@@ -1301,7 +1303,7 @@ ShapePrimitive.refineMesh = function( verts, norms, uvs, indices, nVertices,  pa
 			i2 = indices[index+2];
 
 		// get the uv values
-		var vrtIndex = 3*iTriangle;
+		//var vrtIndex = 3*iTriangle;
 		var iuv0 = 2 * i0,
 			iuv1 = 2 * i1,
 			iuv2 = 2 * i2;
@@ -1335,7 +1337,7 @@ ShapePrimitive.refineMesh = function( verts, norms, uvs, indices, nVertices,  pa
 				iTriangle++;
 				index += 3;
 			}
-			else	// split the triangle
+			else	// split the triangle into 4 parts
 			{
 				//calculate the position of the new vertex
 				var iPt0 = 3 * i0,
@@ -1344,34 +1346,42 @@ ShapePrimitive.refineMesh = function( verts, norms, uvs, indices, nVertices,  pa
 				var x0 = verts[iPt0],  y0 = verts[iPt0+1],  z0 = verts[iPt0+2],
 					x1 = verts[iPt1],  y1 = verts[iPt1+1],  z1 = verts[iPt1+2],
 					x2 = verts[iPt2],  y2 = verts[iPt2+1],  z2 = verts[iPt2+2];
-				var xMid = (x0 + x1 + x2)/3.0,
-					yMid = (y0 + y1 + y2)/3.0,
-					zMid = (z0 + z1 + z2)/3.0;
-
-				// calculate the uv value of the new coordinate
-				var uMid = (u0 + u1 + u2)/3.0,
-					vMid = (v0 + v1 + v2)/3.0;
-
-				// calculate the normal for the new coordinate
+				
+				// calculate the midpoints of the edges
+				var xA = (x0 + x1)/2.0,  yA = (y0 + y1)/2.0,  zA = (z0 + z1)/2.0,
+					xB = (x1 + x2)/2.0,  yB = (y1 + y2)/2.0,  zB = (z1 + z2)/2.0,
+					xC = (x2 + x0)/2.0,  yC = (y2 + y0)/2.0,  zC = (z2 + z0)/2.0;
+
+				// calculate the uv values of the new coordinates
+				var uA = (u0 + u1)/2.0,  vA = (v0 + v1)/2.0,
+					uB = (u1 + u2)/2.0,  vB = (v1 + v2)/2.0,
+					uC = (u2 + u0)/2.0,  vC = (v2 + v0)/2.0;
+
+				// calculate the normals for the new points
 				var nx0 = norms[iPt0],  ny0 = norms[iPt0+1],  nz0 = norms[iPt0+2],
 					nx1 = norms[iPt1],  ny1 = norms[iPt1+1],  nz1 = norms[iPt1+2],
 					nx2 = norms[iPt2],  ny2 = norms[iPt2+1],  nz2 = norms[iPt2+2];
-				var nxMid = (nx0 + nx1 + nx2),
-					nyMid = (ny0 + ny1 + ny2),
-					nzMid = (nz0 + nz1 + nz2);
-				var nrm = VecUtils.vecNormalize(3, [nxMid, nyMid, nzMid], 1.0 );
-
-				// push the new vertex
-				verts.push(nrm[0]);  verts.push(nrm[1]);  verts.push(nrm[2]);
-				uvs.push(uMid),  uvs.push(vMid);
-				norms.push(nrm[0]);  norms.push(nrm[1]);  norms.push(nrm[2]);
-				var iMidVrt = nVertices;
-				nVertices++;
-
-				// split the current triangle into 3
-				indices[index+2] = iMidVrt;
-				indices.push(i1);  indices.push(i2);  indices.push(iMidVrt);  nTriangles++;
-				indices.push(i2);  indices.push(i0);  indices.push(iMidVrt);  nTriangles++;
+				var nxA = (nx0 + nx1),  nyA = (ny0 + ny1),  nzA = (nz0 + nz1);  var nrmA = VecUtils.vecNormalize(3, [nxA, nyA, nzA], 1.0 ),
+					nxB = (nx1 + nx2),  nyB = (ny1 + ny2),  nzB = (nz1 + nz2);  var nrmB = VecUtils.vecNormalize(3, [nxB, nyB, nzB], 1.0 ),
+					nxC = (nx2 + nx0),  nyC = (ny2 + ny0),  nzC = (nz2 + nz0);  var nrmC = VecUtils.vecNormalize(3, [nxC, nyC, nzC], 1.0 );
+
+				// push everything
+				verts.push(xA);  verts.push(yA);  verts.push(zA);
+				verts.push(xB);  verts.push(yB);  verts.push(zB);
+				verts.push(xC);  verts.push(yC);  verts.push(zC);
+				uvs.push(uA),  uvs.push(vA);
+				uvs.push(uB),  uvs.push(vB);
+				uvs.push(uC),  uvs.push(vC);
+				norms.push(nrmA[0]);  norms.push(nrmA[1]);  norms.push(nrmA[2]);
+				norms.push(nrmB[0]);  norms.push(nrmB[1]);  norms.push(nrmB[2]);
+				norms.push(nrmC[0]);  norms.push(nrmC[1]);  norms.push(nrmC[2]);
+
+				// split the current triangle into 4
+				indices[index+1] = nVertices;  indices[index+2] = nVertices+2;
+				indices.push(nVertices);    indices.push(i1);           indices.push(nVertices+1);  nTriangles++;
+				indices.push(nVertices+1);  indices.push(i2);           indices.push(nVertices+2);  nTriangles++;
+				indices.push(nVertices);    indices.push(nVertices+1);  indices.push(nVertices+2);  nTriangles++;
+				nVertices += 3;
 
 				// by not advancing 'index', we examine the first of the 3 triangles generated above
 			}
diff --git a/js/helper-classes/RDGE/GLWorld.js b/js/helper-classes/RDGE/GLWorld.js
index c97e29d4..83ed717d 100644
--- a/js/helper-classes/RDGE/GLWorld.js
+++ b/js/helper-classes/RDGE/GLWorld.js
@@ -14,6 +14,7 @@ var fragmentShaderSource = "";
 var rdgeStarted = false;
 
 var nodeCounter = 0;
+var worldCounter = 0;
 
 
 ///////////////////////////////////////////////////////////////////////
@@ -70,6 +71,9 @@ function GLWorld( canvas, use3D )
 	// no animated materials
 	this._firstRender = true;
 
+	this._worldCount = worldCounter;
+	worldCounter++;
+
     ///////////////////////////////////////////////////////////////////////
     // Property accessors
     ///////////////////////////////////////////////////////////////////////
@@ -236,7 +240,7 @@ function GLWorld( canvas, use3D )
 			{
 				renderer.disableCulling();
 				this.myScene.render();
-				//console.log( "render" );
+				console.log( "render" );
 
 				if (this._firstRender)
 				{
diff --git a/js/helper-classes/RDGE/Materials/FlatMaterial.js b/js/helper-classes/RDGE/Materials/FlatMaterial.js
index c8eb3b6c..de039231 100644
--- a/js/helper-classes/RDGE/Materials/FlatMaterial.js
+++ b/js/helper-classes/RDGE/Materials/FlatMaterial.js
@@ -26,10 +26,13 @@ function Fla