From 00cd98e49c959906d7c44bb6adcdef1f3d5148ae Mon Sep 17 00:00:00 2001
From: hwc487
Date: Thu, 22 Mar 2012 13:52:09 -0700
Subject: Merge branch 'master' of github.com:Motorola-Mobility/ninja-internal
 into Texture

Conflicts:
	assets/shaders/plasma.frag.glsl
	js/helper-classes/RDGE/GLLine.js
	js/helper-classes/RDGE/MaterialsLibrary.js
	js/lib/drawing/world.js
	js/lib/geom/circle.js
	js/lib/geom/rectangle.js
	js/lib/rdge/materials/flat-material.js
	js/lib/rdge/materials/material.js
	js/panels/Materials/Materials.xml
	js/panels/Materials/materials-popup.reel/materials-popup.js
	js/preloader/Preloader.js
---
 js/lib/rdge/texture.js | 149 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 149 insertions(+)
 create mode 100644 js/lib/rdge/texture.js

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
new file mode 100644
index 00000000..f9b3d4c3
--- /dev/null
+++ b/js/lib/rdge/texture.js
@@ -0,0 +1,149 @@
+/* <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> */
+
+var Material = require("js/lib/rdge/materials/material").Material;
+
+///////////////////////////////////////////////////////////////////////
+// Class GLTexture
+//      GL representation of a texture.
+///////////////////////////////////////////////////////////////////////
+function Texture( dstWorld )
+{
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._texture;
+
+	// texture attributes
+	this._texMapName;
+	this._wrap;
+	this._mips;
+
+	this._srcCanvas;	// the canvas generating the texture map.
+	this._dstWorld;		// the world that will use the texture map
+	this._dstWorld = dstWorld;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+	this.getTexture		= function()	{  return this._texture;	}
+
+	this.setSrcWorld	= function(w)	{  this._srcWorld = w;		}
+	this.getSrcWorld	= function()	{  return this._srcWorld;	}
+
+	this.setDstWorld	= function(w)	{  this._dstWorld = w;		}
+	this.getDstWorld	= function()	{  return this._dstWorld;	}
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+
+	this.loadFromFile = function( texMapName,  wrap,  mips )
+	{
+		var tex = this._texture;
+		this._srcCanvas = null;
+
+		// only load if something has changed
+		if (this._texMapName !== texMapName)	// does RDGE allow us to change wrap or mips?
+		{
+			this._texMapName = texMapName.slice();
+			this._wrap = wrap;
+			this._mips = mips;
+
+			var dstWorld = this.getDstWorld();
+			if (dstWorld)
+			{
+				var renderer = dstWorld.getRenderer();
+				tex = renderer.getTextureByName(texMapName, wrap, mips );
+				this._texture = tex;
+				dstWorld.textureToLoad( tex );
+			}
+		}
+
+		return tex;
+	}
+
+	this.loadFromCanvas = function( srcCanvas,  wrap, mips )
+	{
+		this._texMapName = "GLTexture_" + this.texCounter;
+		this.texCounter++;
+
+		//if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
+		var world = this.getDstWorld();
+		var renderer = world.getRenderer();
+
+		var imageData;
+		var width = srcCanvas.width,  height = srcCanvas.height;
+		width = 128;  height = 64;	// some even power of 2 for now...
+
+		// create a canvas to be used as the image for the texture map
+		var doc = srcCanvas.ownerDocument;
+		var dstCanvas = doc.createElement("canvas");
+		dstCanvas.width = width;
+		dstCanvas.height = height;
+		var dstCtx = dstCanvas.getContext("2d");
+
+		var tex;
+		var srcCtx = srcCanvas.getContext("2d");
+		if (srcCtx)
+		{
+			tex = renderer.getTextureByName(this._texMapName, wrap, mips );
+			imageData = srcCtx.getImageData( 0, 0, width, height );
+		    dstCtx.putImageData( imageData, 0, 0 );
+		}
+		else
+		{
+			tex = renderer.getTextureByName(this._texMapName, wrap, mips );
+			//tex = world.getGLContext().createTexture();
+			tex.image = new Image;
+			tex.wrap = wrap;
+			tex.mips = mips;
+
+			srcCtx = srcCanvas.getContext("experimental-webgl");
+			if (srcCtx)
+			{
+//				var data = new Uint8Array(width * height * 4);
+//				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
+//				console.log( "pixel 0: " + data[width+0] + ", " + data[width+1] + ", " + data[width+2] + ", " + data[width+3] );
+//						
+//				//imageData.data = data;
+//				imageData = dstCtx.createImageData(width, height);
+//				var nBytes = width*height*4;
+//				for (var i=0;  i<nBytes;  i++)
+//					imageData.data[i] = data[i];
+//		        dstCtx.putImageData( imageData, 0, 0 );
+
+                dstCtx.drawImage(srcCanvas, 0, 0);
+			}
+		}
+
+
+		/////////////////
+		tex.image = dstCanvas;
+
+		this._texture = tex;
+		return tex;
+	}
+
+	this.findPreviousWorld = function()
+	{
+		var prevWorld;
+		for ( var w in _worldStack )
+		{
+			world = _worldStack[w];
+			if (world == this.getWorld())  return prevWorld;
+			prevWorld = world;
+		}
+	}
+
+	var texCounter = 0;
+}
+
+if (typeof exports === "object") {
+    exports.Texture = Texture;
+}
+
+
-- 
cgit v1.2.3


From 8fa51b9d8c37896dfd13a5b238cf990fcbdb0c96 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Fri, 23 Mar 2012 13:46:40 -0700
Subject: textures

---
 js/lib/rdge/texture.js | 153 +++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 142 insertions(+), 11 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index f9b3d4c3..28dc868a 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -66,18 +66,27 @@ function Texture( dstWorld )
 		return tex;
 	}
 
+    var __texCounter = 0;
+
+    /*
 	this.loadFromCanvas = function( srcCanvas,  wrap, mips )
 	{
-		this._texMapName = "GLTexture_" + this.texCounter;
-		this.texCounter++;
+		this._texMapName = "GLTexture_" + __texCounter;
+		__texCounter++;
 
 		//if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
 		var world = this.getDstWorld();
 		var renderer = world.getRenderer();
 
+		// set default values for wrap and mips
+        if (wrap === undefined)
+            wrap = "REPEAT";
+        if (mips === undefined)
+            mips = true;
+
 		var imageData;
 		var width = srcCanvas.width,  height = srcCanvas.height;
-		width = 128;  height = 64;	// some even power of 2 for now...
+		width = 64;  height = 64;	// some even power of 2 for now...
 
 		// create a canvas to be used as the image for the texture map
 		var doc = srcCanvas.ownerDocument;
@@ -116,6 +125,13 @@ function Texture( dstWorld )
 //					imageData.data[i] = data[i];
 //		        dstCtx.putImageData( imageData, 0, 0 );
 
+				var data = new Uint8Array(width * height * 4);
+				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
+                for (var i=1;  i<10;  i++)
+                {
+				    console.log( "row " + i + ": " + data[i*4*width] + ", " + data[i*4*width+1] + ", " + data[i*4*width+2] + ", " + data[i*4*width+3] );
+                }
+
                 dstCtx.drawImage(srcCanvas, 0, 0);
 			}
 		}
@@ -127,19 +143,134 @@ function Texture( dstWorld )
 		this._texture = tex;
 		return tex;
 	}
+    */
+
+    this.loadFromCanvas = function( srcCanvas,  wrap, mips )
+	{
+		this._srcCanvas = srcCanvas;
+
+		this._texMapName = "GLTexture_" + __texCounter;
+		__texCounter++;
+
+		// set default values for wrap and mips
+        if (wrap === undefined)
+            wrap = "REPEAT";
+        if (mips === undefined)
+            mips = true;
+
+		// we animate only if the source is an animated GLWorld
+		if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
+			this._isAnimated = srcCanvas.elementModel.shapeModel.GLWorld._hasAnimatedMaterials;
+
+		// create the texture
+		var world = this.getDstWorld();
+		tex = world.getGLContext().createTexture();
+		this._texture = tex;
+		tex.texparams = new _texparams(wrap, mips);	// defined in renderer.js
+		tex.image = new Image;
+
+		// create the canvas and context to render into
+		var doc = srcCanvas.ownerDocument;
+		this._renderCanvas = doc.createElement("canvas");
+
+		// cache whether this is a 2D canvas or 3D canvas
+		var srcCtx = srcCanvas.getContext("2d");
+		this._is3D = false;
+		if (!srcCtx)  this.is3D = true;
+
+		this.rerender();
+
+		return tex;
+	}
 
-	this.findPreviousWorld = function()
+	this.rerender = function()
 	{
-		var prevWorld;
-		for ( var w in _worldStack )
+		if (!this._srcCanvas)
 		{
-			world = _worldStack[w];
-			if (world == this.getWorld())  return prevWorld;
-			prevWorld = world;
+			console.log( " no source canvas in GLTexture.rerender" );
+			return;
+		}
+		var srcCanvas = this._srcCanvas;
+
+		var world = this.getDstWorld();
+		if (!world)
+		{
+			console.log( "no world in GLTexture.rerender" );
+			return;
+		}
+		var renderer = world.getRenderer();
+
+		var imageData;
+		var width = srcCanvas.width,  height = srcCanvas.height;
+		if (!this.isPowerOfTwo(width) || !this.isPowerOfTwo(height))
+		{
+			width = this.nextHighestPowerOfTwo( width );
+			height = this.nextHighestPowerOfTwo( height );
 		}
-	}
 
-	var texCounter = 0;
+		// create a canvas to be used as the image for the texture map
+		var doc = srcCanvas.ownerDocument;
+		var renderCanvas = this._renderCanvas;
+		if (!renderCanvas)
+		{
+			console.log( "no render canvas in GLTexture.rerender" );
+			return;
+		}
+		renderCanvas.width = width;
+		renderCanvas.height = height;
+		var renderCtx = renderCanvas.getContext("2d");
+
+		// create the texture
+		var tex = this._texture;
+		if (!tex)
+		{
+			console.log( "no texture in GLTexture.rerender" );
+			return;
+		}
+
+		var srcCtx;
+		if (!this.is3D)
+		{
+			srcCtx = srcCanvas.getContext("2d");
+			imageData = srcCtx.getImageData( 0, 0, width, height );
+		}
+		else
+		{
+			srcCtx = srcCanvas.getContext("experimental-webgl");
+			if (srcCtx)
+			{
+				var data = new Uint8Array(width * height * 4);
+				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
+						
+				imageData = renderCtx.createImageData(width, height);
+				var nBytes = width*height*4;
+				for (var i=0;  i<nBytes;  i++)
+					imageData.data[i] = data[i];
+			}
+		}
+		renderCtx.putImageData( imageData, 0, 0 );
+
+		/////////////////
+		tex.image = renderCanvas;
+		renderer.commitTexture( tex );
+
+		return tex;
+    }
+
+ 
+	this.isPowerOfTwo = function(x)
+	{
+		return (x & (x - 1)) == 0;
+	}
+ 
+	this.nextHighestPowerOfTwo = function(x)
+	{
+		--x;
+		for (var i = 1; i < 32; i <<= 1) {
+			x = x | x >> i;
+		}
+		return x + 1;
+	}
 }
 
 if (typeof exports === "object") {
-- 
cgit v1.2.3


From 62f4327f9b83760e52a1f6bf1e689b1e0a780fbb Mon Sep 17 00:00:00 2001
From: hwc487
Date: Fri, 23 Mar 2012 17:15:28 -0700
Subject: textures

---
 js/lib/rdge/texture.js | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index 28dc868a..c72864b8 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -207,6 +207,7 @@ function Texture( dstWorld )
 			width = this.nextHighestPowerOfTwo( width );
 			height = this.nextHighestPowerOfTwo( height );
 		}
+        width = 64;  height = 64;
 
 		// create a canvas to be used as the image for the texture map
 		var doc = srcCanvas.ownerDocument;
@@ -246,6 +247,10 @@ function Texture( dstWorld )
 				var nBytes = width*height*4;
 				for (var i=0;  i<nBytes;  i++)
 					imageData.data[i] = data[i];
+                var nPrint = nBytes;
+                if (nPrint > 1000)  nPrint = 1000;
+                for (var i=0; i<nPrint;  i++)
+                    console.log( " " + data[i] );
 			}
 		}
 		renderCtx.putImageData( imageData, 0, 0 );
-- 
cgit v1.2.3


From 2f66a9ab38f761b7796800bb37f8146f140db40b Mon Sep 17 00:00:00 2001
From: hwc487
Date: Mon, 26 Mar 2012 11:31:23 -0700
Subject: WebGL & Canvas as data for texture maps.

---
 js/lib/rdge/texture.js | 377 +++++++++++++++++++------------------------------
 1 file changed, 149 insertions(+), 228 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index c72864b8..b349ee62 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -15,267 +15,188 @@ function Texture( dstWorld )
     ///////////////////////////////////////////////////////////////////////
     // Instance variables
     ///////////////////////////////////////////////////////////////////////
-	this._texture;
+    this._texture;
 
-	// texture attributes
-	this._texMapName;
-	this._wrap;
-	this._mips;
+    // texture attributes
+    this._texMapName;
+    this._wrap;
+    this._mips;
 
-	this._srcCanvas;	// the canvas generating the texture map.
-	this._dstWorld;		// the world that will use the texture map
-	this._dstWorld = dstWorld;
+    this._srcCanvas;	// the canvas generating the texture map.
+    this._dstWorld;		// the world that will use the texture map
+    this._dstWorld = dstWorld;
 
     ///////////////////////////////////////////////////////////////////////
     // Property Accessors
     ///////////////////////////////////////////////////////////////////////
-	this.getTexture		= function()	{  return this._texture;	}
+    this.getTexture		= function()	{  return this._texture;	}
 
-	this.setSrcWorld	= function(w)	{  this._srcWorld = w;		}
-	this.getSrcWorld	= function()	{  return this._srcWorld;	}
+    this.setSrcWorld	= function(w)	{  this._srcWorld = w;		}
+    this.getSrcWorld	= function()	{  return this._srcWorld;	}
 
-	this.setDstWorld	= function(w)	{  this._dstWorld = w;		}
-	this.getDstWorld	= function()	{  return this._dstWorld;	}
+    this.setDstWorld	= function(w)	{  this._dstWorld = w;		}
+    this.getDstWorld	= function()	{  return this._dstWorld;	}
+
+    this.isAnimated     = function()    {  return this._isAnimated; }
 
     ///////////////////////////////////////////////////////////////////////
     // Methods
     ///////////////////////////////////////////////////////////////////////
 
-	this.loadFromFile = function( texMapName,  wrap,  mips )
-	{
-		var tex = this._texture;
-		this._srcCanvas = null;
-
-		// only load if something has changed
-		if (this._texMapName !== texMapName)	// does RDGE allow us to change wrap or mips?
-		{
-			this._texMapName = texMapName.slice();
-			this._wrap = wrap;
-			this._mips = mips;
-
-			var dstWorld = this.getDstWorld();
-			if (dstWorld)
-			{
-				var renderer = dstWorld.getRenderer();
-				tex = renderer.getTextureByName(texMapName, wrap, mips );
-				this._texture = tex;
-				dstWorld.textureToLoad( tex );
-			}
-		}
-
-		return tex;
-	}
+    this.loadFromFile = function( texMapName,  wrap,  mips )
+    {
+        var tex = this._texture;
+        this._srcCanvas = null;
+
+        // only load if something has changed
+        if (this._texMapName !== texMapName)	// does RDGE allow us to change wrap or mips?
+        {
+            this._texMapName = texMapName.slice();
+            this._wrap = wrap;
+            this._mips = mips;
+
+            var dstWorld = this.getDstWorld();
+            if (dstWorld)
+            {
+                var renderer = dstWorld.getRenderer();
+                tex = renderer.getTextureByName(texMapName, wrap, mips );
+                this._texture = tex;
+                dstWorld.textureToLoad( tex );
+            }
+        }
+
+        return tex;
+    }
 
     var __texCounter = 0;
+    this.loadFromCanvas = function( srcCanvas,  wrap, mips )
+    {
+        this._srcCanvas = srcCanvas;
 
-    /*
-	this.loadFromCanvas = function( srcCanvas,  wrap, mips )
-	{
-		this._texMapName = "GLTexture_" + __texCounter;
-		__texCounter++;
-
-		//if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
-		var world = this.getDstWorld();
-		var renderer = world.getRenderer();
+        this._texMapName = "GLTexture_" + __texCounter;
+        __texCounter++;
 
-		// set default values for wrap and mips
+        // set default values for wrap and mips
         if (wrap === undefined)
             wrap = "REPEAT";
         if (mips === undefined)
             mips = true;
 
-		var imageData;
-		var width = srcCanvas.width,  height = srcCanvas.height;
-		width = 64;  height = 64;	// some even power of 2 for now...
-
-		// create a canvas to be used as the image for the texture map
-		var doc = srcCanvas.ownerDocument;
-		var dstCanvas = doc.createElement("canvas");
-		dstCanvas.width = width;
-		dstCanvas.height = height;
-		var dstCtx = dstCanvas.getContext("2d");
-
-		var tex;
-		var srcCtx = srcCanvas.getContext("2d");
-		if (srcCtx)
-		{
-			tex = renderer.getTextureByName(this._texMapName, wrap, mips );
-			imageData = srcCtx.getImageData( 0, 0, width, height );
-		    dstCtx.putImageData( imageData, 0, 0 );
-		}
-		else
-		{
-			tex = renderer.getTextureByName(this._texMapName, wrap, mips );
-			//tex = world.getGLContext().createTexture();
-			tex.image = new Image;
-			tex.wrap = wrap;
-			tex.mips = mips;
-
-			srcCtx = srcCanvas.getContext("experimental-webgl");
-			if (srcCtx)
-			{
-//				var data = new Uint8Array(width * height * 4);
-//				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
-//				console.log( "pixel 0: " + data[width+0] + ", " + data[width+1] + ", " + data[width+2] + ", " + data[width+3] );
-//						
-//				//imageData.data = data;
-//				imageData = dstCtx.createImageData(width, height);
-//				var nBytes = width*height*4;
-//				for (var i=0;  i<nBytes;  i++)
-//					imageData.data[i] = data[i];
-//		        dstCtx.putImageData( imageData, 0, 0 );
-
-				var data = new Uint8Array(width * height * 4);
-				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
-                for (var i=1;  i<10;  i++)
-                {
-				    console.log( "row " + i + ": " + data[i*4*width] + ", " + data[i*4*width+1] + ", " + data[i*4*width+2] + ", " + data[i*4*width+3] );
-                }
+        // we animate only if the source is an animated GLWorld
+        if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
+            this._isAnimated = srcCanvas.elementModel.shapeModel.GLWorld._hasAnimatedMaterials;
 
-                dstCtx.drawImage(srcCanvas, 0, 0);
-			}
-		}
+        // create the texture
+        var world = this.getDstWorld();
+        tex = world.getGLContext().createTexture();
+        this._texture = tex;
+        tex.texparams = new _texparams(wrap, mips);	// defined in renderer.js
+        tex.image = new Image;
 
+        // create the canvas and context to render into
+        var doc = srcCanvas.ownerDocument;
+        this._renderCanvas = doc.createElement("canvas");
 
-		/////////////////
-		tex.image = dstCanvas;
+        // cache whether this is a 2D canvas or 3D canvas
+        var srcCtx = srcCanvas.getContext("2d");
+        this._is3D = false;
+        if (!srcCtx)  this._is3D = true;
 
-		this._texture = tex;
-		return tex;
-	}
-    */
+        this.rerender();
 
-    this.loadFromCanvas = function( srcCanvas,  wrap, mips )
-	{
-		this._srcCanvas = srcCanvas;
+        return tex;
+    }
 
-		this._texMapName = "GLTexture_" + __texCounter;
-		__texCounter++;
+    this.rerender = function()
+    {
+        if (!this._srcCanvas)
+        {
+            console.log( " no source canvas in GLTexture.rerender" );
+            return;
+        }
+        var srcCanvas = this._srcCanvas;
+
+        var world = this.getDstWorld();
+        if (!world)
+        {
+            console.log( "no world in GLTexture.rerender" );
+            return;
+        }
+        var renderer = world.getRenderer();
+
+        var imageData;
+        var width = srcCanvas.width,  height = srcCanvas.height;
+        if (!this.isPowerOfTwo(width) || !this.isPowerOfTwo(height))
+        {
+            width = this.nextHighestPowerOfTwo( width );
+            height = this.nextHighestPowerOfTwo( height );
+            //width = 64;  height = 64;
+        }
+
+        // create a canvas to be used as the image for the texture map
+        var doc = srcCanvas.ownerDocument;
+        var renderCanvas = this._renderCanvas;
+        if (!renderCanvas)
+        {
+            console.log( "no render canvas in GLTexture.rerender" );
+            return;
+        }
+        renderCanvas.width = width;
+        renderCanvas.height = height;
+        var renderCtx = renderCanvas.getContext("2d");
+
+        // create the texture
+        var tex = this._texture;
+        if (!tex)
+        {
+            console.log( "no texture in GLTexture.rerender" );
+            return;
+        }
+
+        var srcCtx;
+        if (!this._is3D)
+        {
+            srcCtx = srcCanvas.getContext("2d");
+            imageData = srcCtx.getImageData( 0, 0, width, height );
+            renderCtx.putImageData( imageData, 0, 0 );
+        }
+        else
+        {
+            srcCtx = srcCanvas.getContext("experimental-webgl");
+            if (srcCtx)
+            {
+                renderCtx.drawImage(srcCanvas, 0, 0);
+//				var data = new Uint8Array(width * height * 4);
+//				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
+//				imageData = renderCtx.createImageData(width, height);
+//				var nBytes = width*height*4;
+//				for (var i=0;  i<nBytes;  i++)
+//					imageData.data[i] = data[i];
+//		        renderCtx.putImageData( imageData, 0, 0 );
 
-		// set default values for wrap and mips
-        if (wrap === undefined)
-            wrap = "REPEAT";
-        if (mips === undefined)
-            mips = true;
+            }
+        }
 
-		// we animate only if the source is an animated GLWorld
-		if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
-			this._isAnimated = srcCanvas.elementModel.shapeModel.GLWorld._hasAnimatedMaterials;
-
-		// create the texture
-		var world = this.getDstWorld();
-		tex = world.getGLContext().createTexture();
-		this._texture = tex;
-		tex.texparams = new _texparams(wrap, mips);	// defined in renderer.js
-		tex.image = new Image;
-
-		// create the canvas and context to render into
-		var doc = srcCanvas.ownerDocument;
-		this._renderCanvas = doc.createElement("canvas");
-
-		// cache whether this is a 2D canvas or 3D canvas
-		var srcCtx = srcCanvas.getContext("2d");
-		this._is3D = false;
-		if (!srcCtx)  this.is3D = true;
-
-		this.rerender();
-
-		return tex;
-	}
-
-	this.rerender = function()
-	{
-		if (!this._srcCanvas)
-		{
-			console.log( " no source canvas in GLTexture.rerender" );
-			return;
-		}
-		var srcCanvas = this._srcCanvas;
-
-		var world = this.getDstWorld();
-		if (!world)
-		{
-			console.log( "no world in GLTexture.rerender" );
-			return;
-		}
-		var renderer = world.getRenderer();
-
-		var imageData;
-		var width = srcCanvas.width,  height = srcCanvas.height;
-		if (!this.isPowerOfTwo(width) || !this.isPowerOfTwo(height))
-		{
-			width = this.nextHighestPowerOfTwo( width );
-			height = this.nextHighestPowerOfTwo( height );
-		}
-        width = 64;  height = 64;
-
-		// create a canvas to be used as the image for the texture map
-		var doc = srcCanvas.ownerDocument;
-		var renderCanvas = this._renderCanvas;
-		if (!renderCanvas)
-		{
-			console.log( "no render canvas in GLTexture.rerender" );
-			return;
-		}
-		renderCanvas.width = width;
-		renderCanvas.height = height;
-		var renderCtx = renderCanvas.getContext("2d");
-
-		// create the texture
-		var tex = this._texture;
-		if (!tex)
-		{
-			console.log( "no texture in GLTexture.rerender" );
-			return;
-		}
-
-		var srcCtx;
-		if (!this.is3D)
-		{
-			srcCtx = srcCanvas.getContext("2d");
-			imageData = srcCtx.getImageData( 0, 0, width, height );
-		}
-		else
-		{
-			srcCtx = srcCanvas.getContext("experimental-webgl");
-			if (srcCtx)
-			{
-				var data = new Uint8Array(width * height * 4);
-				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
-						
-				imageData = renderCtx.createImageData(width, height);
-				var nBytes = width*height*4;
-				for (var i=0;  i<nBytes;  i++)
-					imageData.data[i] = data[i];
-                var nPrint = nBytes;
-                if (nPrint > 1000)  nPrint = 1000;
-                for (var i=0; i<nPrint;  i++)
-                    console.log( " " + data[i] );
-			}
-		}
-		renderCtx.putImageData( imageData, 0, 0 );
-
-		/////////////////
-		tex.image = renderCanvas;
-		renderer.commitTexture( tex );
-
-		return tex;
-    }
+        /////////////////
+        tex.image = renderCanvas;
+        renderer.commitTexture( tex );
 
+        return tex;
+}
  
-	this.isPowerOfTwo = function(x)
-	{
-		return (x & (x - 1)) == 0;
-	}
+    this.isPowerOfTwo = function(x)
+    {
+        return (x & (x - 1)) == 0;
+    }
  
-	this.nextHighestPowerOfTwo = function(x)
-	{
-		--x;
-		for (var i = 1; i < 32; i <<= 1) {
-			x = x | x >> i;
-		}
-		return x + 1;
-	}
+    this.nextHighestPowerOfTwo = function(x)
+    {
+        --x;
+        for (var i = 1; i < 32; i <<= 1) {
+            x = x | x >> i;
+        }
+        return x + 1;
+    }
 }
 
 if (typeof exports === "object") {
-- 
cgit v1.2.3


From d7269673dc1f5caf6df3765c6b669d3d1a93bdb1 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Tue, 27 Mar 2012 04:53:27 -0700
Subject: Integrated texture wrapper into pulse and bump-metal materials.

---
 js/lib/rdge/texture.js | 134 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 107 insertions(+), 27 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index b349ee62..41c9a54a 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -10,7 +10,7 @@ var Material = require("js/lib/rdge/materials/material").Material;
 // Class GLTexture
 //      GL representation of a texture.
 ///////////////////////////////////////////////////////////////////////
-function Texture( dstWorld )
+function Texture( dstWorld, texMapName,  wrap, mips )
 {
     ///////////////////////////////////////////////////////////////////////
     // Instance variables
@@ -18,12 +18,24 @@ function Texture( dstWorld )
     this._texture;
 
     // texture attributes
-    this._texMapName;
-    this._wrap;
-    this._mips;
-
-    this._srcCanvas;	// the canvas generating the texture map.
-    this._dstWorld;		// the world that will use the texture map
+    this._texMapName = texMapName.slice();
+
+    // set default values for wrap and mips
+    if (wrap === undefined)
+        wrap = "REPEAT";
+    if (mips === undefined)
+        mips = true;
+    this._wrap = wrap;
+    this._mips = mips;
+
+   // the canvas generating the texture map (if there is one)
+    this._srcCanvas;	
+    this._srcWorld;
+
+    // cache whether or not the source is animated
+    this._isAnimated = false;
+    
+    // the destination world that will use the texture map
     this._dstWorld = dstWorld;
 
     ///////////////////////////////////////////////////////////////////////
@@ -43,7 +55,35 @@ function Texture( dstWorld )
     // Methods
     ///////////////////////////////////////////////////////////////////////
 
-    this.loadFromFile = function( texMapName,  wrap,  mips )
+    this.init = function()
+    {
+        // determine if the source is a canvas or an image file
+        var viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
+        var root = viewUtils.application.ninja.currentDocument.documentRoot;
+        var srcCanvas = this.findCanvas( this._texMapName, root );
+        if (srcCanvas)
+        {
+            this._srcCanvas = srcCanvas;
+            if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel && srcCanvas.elementModel.shapeModel.GLWorld)
+            {
+                this._srcWorld = srcCanvas.elementModel.shapeModel.GLWorld;
+
+                // check if the source is animated
+                if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
+                    this._isAnimated = this._srcWorld._hasAnimatedMaterials;
+            }
+
+            this.loadFromCanvas();
+        }
+        else
+        {
+            this.loadFromFile();  
+        }
+
+
+    }
+
+    this.loadFromFile = function()
     {
         var tex = this._texture;
         this._srcCanvas = null;
@@ -51,9 +91,9 @@ function Texture( dstWorld )
         // only load if something has changed
         if (this._texMapName !== texMapName)	// does RDGE allow us to change wrap or mips?
         {
-            this._texMapName = texMapName.slice();
-            this._wrap = wrap;
-            this._mips = mips;
+            var texMapName = this._texMapName;
+            var wrap = this._wrap;
+            var mips = this._mips;
 
             var dstWorld = this.getDstWorld();
             if (dstWorld)
@@ -69,23 +109,15 @@ function Texture( dstWorld )
     }
 
     var __texCounter = 0;
-    this.loadFromCanvas = function( srcCanvas,  wrap, mips )
+    this.loadFromCanvas = function()
     {
-        this._srcCanvas = srcCanvas;
+        var srcCanvas = this._srcCanvas;
+        var wrap = this._wrap;
+        var mips = this._mips;
 
         this._texMapName = "GLTexture_" + __texCounter;
         __texCounter++;
 
-        // set default values for wrap and mips
-        if (wrap === undefined)
-            wrap = "REPEAT";
-        if (mips === undefined)
-            mips = true;
-
-        // we animate only if the source is an animated GLWorld
-        if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
-            this._isAnimated = srcCanvas.elementModel.shapeModel.GLWorld._hasAnimatedMaterials;
-
         // create the texture
         var world = this.getDstWorld();
         tex = world.getGLContext().createTexture();
@@ -128,13 +160,11 @@ function Texture( dstWorld )
         var width = srcCanvas.width,  height = srcCanvas.height;
         if (!this.isPowerOfTwo(width) || !this.isPowerOfTwo(height))
         {
-            width = this.nextHighestPowerOfTwo( width );
-            height = this.nextHighestPowerOfTwo( height );
-            //width = 64;  height = 64;
+            width = this.nextLowerPowerOfTwo( width );
+            height = this.nextLowerPowerOfTwo( height );
         }
 
         // create a canvas to be used as the image for the texture map
-        var doc = srcCanvas.ownerDocument;
         var renderCanvas = this._renderCanvas;
         if (!renderCanvas)
         {
@@ -197,6 +227,56 @@ function Texture( dstWorld )
         }
         return x + 1;
     }
+ 
+    this.nextLowerPowerOfTwo = function(x)
+    {
+        return this.nextHighestPowerOfTwo(x) >> 1;
+    }
+
+    this.findCanvas = function( id,  elt )
+    {
+        if (elt.id && elt.id === id)
+            return elt;
+ 
+		if (elt.children)
+		{
+			var nKids = elt.children.length;
+			for (var i=0;  i<nKids;  i++)
+			{
+				var child = elt.children[i];
+				var canvas = this.findCanvas( id, child );
+                if (canvas)  return canvas;
+			}
+		}
+   }
+
+    /*
+    this.findWorld = function( id,  elt )
+    {
+        if (elt.id && elt.id === id)
+        {
+            if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
+            {
+                var world = elt.elementModel.shapeModel.GLWorld;
+                return world;
+            }
+        }
+ 
+		if (elt.children)
+		{
+			var nKids = elt.children.length;
+			for (var i=0;  i<nKids;  i++)
+			{
+				var child = elt.children[i];
+				var world = this.findWorld( id, child );
+                if (world)  return world;
+			}
+		}
+   }
+   */
+
+   // initialize the object
+   this.init();
 }
 
 if (typeof exports === "object") {
-- 
cgit v1.2.3


From 2ab7fbef0df37f0c2bb6a4447f03993b9d50b5d0 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Thu, 29 Mar 2012 07:27:49 -0700
Subject: linked textures

---
 js/lib/rdge/texture.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index 41c9a54a..d67c65d2 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -68,6 +68,9 @@ function Texture( dstWorld, texMapName,  wrap, mips )
             {
                 this._srcWorld = srcCanvas.elementModel.shapeModel.GLWorld;
 
+                // add a notifier to the world
+                this._srcWorld.addListener( this,  this.worldCallback,  { myObj: 'anything' } );
+
                 // check if the source is animated
                 if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
                     this._isAnimated = this._srcWorld._hasAnimatedMaterials;
@@ -79,8 +82,11 @@ function Texture( dstWorld, texMapName,  wrap, mips )
         {
             this.loadFromFile();  
         }
+    }
 
-
+    this.worldCallback = function( type, callbackObj,  calleeData,  callerData )
+    {
+        console.log( "texture callback, type: " + type );
     }
 
     this.loadFromFile = function()
-- 
cgit v1.2.3


From 679a0746bedab9c5871a83a5fea6a06ac6a4f41c Mon Sep 17 00:00:00 2001
From: hwc487
Date: Mon, 2 Apr 2012 10:17:48 -0700
Subject: texture abstraction

---
 js/lib/rdge/texture.js | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index d67c65d2..83509f80 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -69,7 +69,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
                 this._srcWorld = srcCanvas.elementModel.shapeModel.GLWorld;
 
                 // add a notifier to the world
-                this._srcWorld.addListener( this,  this.worldCallback,  { myObj: 'anything' } );
+                this._srcWorld.addListener( this,  this.worldCallback,  { srcWorld: this._srcWorld } );
 
                 // check if the source is animated
                 if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
@@ -87,6 +87,33 @@ function Texture( dstWorld, texMapName,  wrap, mips )
     this.worldCallback = function( type, callbackObj,  calleeData,  callerData )
     {
         console.log( "texture callback, type: " + type );
+        if (calleeData.srcWorld)
+        {
+            var srcWorld = calleeData.srcWorld;
+            var notifier = srcWorld._notifier;
+            var texture = this.callbackObj;
+            if (texture)
+            {
+                switch (type)
+                {
+                    case notifier.OBJECT_DELETE:
+                        break;
+
+                    case notifier.OBJECT_REINSTANTIATE:
+                        break;
+
+                    case notifier.OBJECT_CHANGE:
+                        if (!texture.isAnimated())
+                            texture.rerender();
+                            texture.getDstWorld().restartRenderLoop();
+                        break;
+
+                    default:
+                        throw new Exception( "unrecognized texture callback type: " + type );
+                        break;
+                }
+           }
+        }
     }
 
     this.loadFromFile = function()
-- 
cgit v1.2.3


From 0f31002ca696c1ef303d2926a504afd27305e94f Mon Sep 17 00:00:00 2001
From: hwc487
Date: Wed, 4 Apr 2012 05:52:54 -0700
Subject: Added Flag material

---
 js/lib/rdge/texture.js | 527 ++++++++++++++++++++++++-------------------------
 1 file changed, 261 insertions(+), 266 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index 83509f80..2e76f2c0 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -12,264 +12,259 @@ var Material = require("js/lib/rdge/materials/material").Material;
 ///////////////////////////////////////////////////////////////////////
 function Texture( dstWorld, texMapName,  wrap, mips )
 {
-    ///////////////////////////////////////////////////////////////////////
-    // Instance variables
-    ///////////////////////////////////////////////////////////////////////
-    this._texture;
-
-    // texture attributes
-    this._texMapName = texMapName.slice();
-
-    // set default values for wrap and mips
-    if (wrap === undefined)
-        wrap = "REPEAT";
-    if (mips === undefined)
-        mips = true;
-    this._wrap = wrap;
-    this._mips = mips;
+	///////////////////////////////////////////////////////////////////////
+	// Instance variables
+	///////////////////////////////////////////////////////////////////////
+	this._texture;
+
+	// texture attributes
+	this._texMapName = texMapName.slice();
+
+	// set default values for wrap and mips
+	if (wrap === undefined)
+		wrap = "REPEAT";
+	if (mips === undefined)
+		mips = true;
+	this._wrap = wrap;
+	this._mips = mips;
 
    // the canvas generating the texture map (if there is one)
-    this._srcCanvas;	
-    this._srcWorld;
-
-    // cache whether or not the source is animated
-    this._isAnimated = false;
-    
-    // the destination world that will use the texture map
-    this._dstWorld = dstWorld;
-
-    ///////////////////////////////////////////////////////////////////////
-    // Property Accessors
-    ///////////////////////////////////////////////////////////////////////
-    this.getTexture		= function()	{  return this._texture;	}
-
-    this.setSrcWorld	= function(w)	{  this._srcWorld = w;		}
-    this.getSrcWorld	= function()	{  return this._srcWorld;	}
-
-    this.setDstWorld	= function(w)	{  this._dstWorld = w;		}
-    this.getDstWorld	= function()	{  return this._dstWorld;	}
-
-    this.isAnimated     = function()    {  return this._isAnimated; }
-
-    ///////////////////////////////////////////////////////////////////////
-    // Methods
-    ///////////////////////////////////////////////////////////////////////
-
-    this.init = function()
-    {
-        // determine if the source is a canvas or an image file
-        var viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
-        var root = viewUtils.application.ninja.currentDocument.documentRoot;
-        var srcCanvas = this.findCanvas( this._texMapName, root );
-        if (srcCanvas)
-        {
-            this._srcCanvas = srcCanvas;
-            if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel && srcCanvas.elementModel.shapeModel.GLWorld)
-            {
-                this._srcWorld = srcCanvas.elementModel.shapeModel.GLWorld;
-
-                // add a notifier to the world
-                this._srcWorld.addListener( this,  this.worldCallback,  { srcWorld: this._srcWorld } );
-
-                // check if the source is animated
-                if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
-                    this._isAnimated = this._srcWorld._hasAnimatedMaterials;
-            }
-
-            this.loadFromCanvas();
-        }
-        else
-        {
-            this.loadFromFile();  
-        }
-    }
-
-    this.worldCallback = function( type, callbackObj,  calleeData,  callerData )
-    {
-        console.log( "texture callback, type: " + type );
-        if (calleeData.srcWorld)
-        {
-            var srcWorld = calleeData.srcWorld;
-            var notifier = srcWorld._notifier;
-            var texture = this.callbackObj;
-            if (texture)
-            {
-                switch (type)
-                {
-                    case notifier.OBJECT_DELETE:
-                        break;
-
-                    case notifier.OBJECT_REINSTANTIATE:
-                        break;
-
-                    case notifier.OBJECT_CHANGE:
-                        if (!texture.isAnimated())
-                            texture.rerender();
-                            texture.getDstWorld().restartRenderLoop();
-                        break;
-
-                    default:
-                        throw new Exception( "unrecognized texture callback type: " + type );
-                        break;
-                }
-           }
-        }
-    }
-
-    this.loadFromFile = function()
-    {
-        var tex = this._texture;
-        this._srcCanvas = null;
-
-        // only load if something has changed
-        if (this._texMapName !== texMapName)	// does RDGE allow us to change wrap or mips?
-        {
-            var texMapName = this._texMapName;
-            var wrap = this._wrap;
-            var mips = this._mips;
-
-            var dstWorld = this.getDstWorld();
-            if (dstWorld)
-            {
-                var renderer = dstWorld.getRenderer();
-                tex = renderer.getTextureByName(texMapName, wrap, mips );
-                this._texture = tex;
-                dstWorld.textureToLoad( tex );
-            }
-        }
-
-        return tex;
-    }
-
-    var __texCounter = 0;
-    this.loadFromCanvas = function()
-    {
-        var srcCanvas = this._srcCanvas;
-        var wrap = this._wrap;
-        var mips = this._mips;
-
-        this._texMapName = "GLTexture_" + __texCounter;
-        __texCounter++;
-
-        // create the texture
-        var world = this.getDstWorld();
-        tex = world.getGLContext().createTexture();
-        this._texture = tex;
-        tex.texparams = new _texparams(wrap, mips);	// defined in renderer.js
-        tex.image = new Image;
-
-        // create the canvas and context to render into
-        var doc = srcCanvas.ownerDocument;
-        this._renderCanvas = doc.createElement("canvas");
-
-        // cache whether this is a 2D canvas or 3D canvas
-        var srcCtx = srcCanvas.getContext("2d");
-        this._is3D = false;
-        if (!srcCtx)  this._is3D = true;
-
-        this.rerender();
-
-        return tex;
-    }
-
-    this.rerender = function()
-    {
-        if (!this._srcCanvas)
-        {
-            console.log( " no source canvas in GLTexture.rerender" );
-            return;
-        }
-        var srcCanvas = this._srcCanvas;
-
-        var world = this.getDstWorld();
-        if (!world)
-        {
-            console.log( "no world in GLTexture.rerender" );
-            return;
-        }
-        var renderer = world.getRenderer();
-
-        var imageData;
-        var width = srcCanvas.width,  height = srcCanvas.height;
-        if (!this.isPowerOfTwo(width) || !this.isPowerOfTwo(height))
-        {
-            width = this.nextLowerPowerOfTwo( width );
-            height = this.nextLowerPowerOfTwo( height );
-        }
-
-        // create a canvas to be used as the image for the texture map
-        var renderCanvas = this._renderCanvas;
-        if (!renderCanvas)
-        {
-            console.log( "no render canvas in GLTexture.rerender" );
-            return;
-        }
-        renderCanvas.width = width;
-        renderCanvas.height = height;
-        var renderCtx = renderCanvas.getContext("2d");
-
-        // create the texture
-        var tex = this._texture;
-        if (!tex)
-        {
-            console.log( "no texture in GLTexture.rerender" );
-            return;
-        }
-
-        var srcCtx;
-        if (!this._is3D)
-        {
-            srcCtx = srcCanvas.getContext("2d");
-            imageData = srcCtx.getImageData( 0, 0, width, height );
-            renderCtx.putImageData( imageData, 0, 0 );
-        }
-        else
-        {
-            srcCtx = srcCanvas.getContext("experimental-webgl");
-            if (srcCtx)
-            {
-                renderCtx.drawImage(srcCanvas, 0, 0);
-//				var data = new Uint8Array(width * height * 4);
-//				srcCtx.readPixels(0, 0, width, height, srcCtx.RGBA, srcCtx.UNSIGNED_BYTE, data);
-//				imageData = renderCtx.createImageData(width, height);
-//				var nBytes = width*height*4;
-//				for (var i=0;  i<nBytes;  i++)
-//					imageData.data[i] = data[i];
-//		        renderCtx.putImageData( imageData, 0, 0 );
-
-            }
-        }
-
-        /////////////////
-        tex.image = renderCanvas;
-        renderer.commitTexture( tex );
-
-        return tex;
+	this._srcCanvas;	
+	this._srcWorld;
+
+	// cache whether or not the source is animated
+	this._isAnimated = false;
+	
+	// the destination world that will use the texture map
+	this._dstWorld = dstWorld;
+
+	///////////////////////////////////////////////////////////////////////
+	// Property Accessors
+	///////////////////////////////////////////////////////////////////////
+	this.getTexture		= function()	{  return this._texture;	}
+
+	this.setSrcWorld	= function(w)	{  this._srcWorld = w;		}
+	this.getSrcWorld	= function()	{  return this._srcWorld;	}
+
+	this.setDstWorld	= function(w)	{  this._dstWorld = w;		}
+	this.getDstWorld	= function()	{  return this._dstWorld;	}
+
+	this.isAnimated     = function()    {  return this._isAnimated; }
+
+	///////////////////////////////////////////////////////////////////////
+	// Methods
+	///////////////////////////////////////////////////////////////////////
+
+	this.init = function()
+	{
+		// determine if the source is a canvas or an image file
+		var viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
+		var root = viewUtils.application.ninja.currentDocument.documentRoot;
+		var srcCanvas = this.findCanvas( this._texMapName, root );
+		if (srcCanvas)
+		{
+			this._srcCanvas = srcCanvas;
+			if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel && srcCanvas.elementModel.shapeModel.GLWorld)
+			{
+				this._srcWorld = srcCanvas.elementModel.shapeModel.GLWorld;
+
+				// add a notifier to the world
+				this._srcWorld.addListener( this,  this.worldCallback,  { srcWorld: this._srcWorld } );
+
+				// check if the source is animated
+				if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
+					this._isAnimated = this._srcWorld._hasAnimatedMaterials;
+			}
+
+			this.loadFromCanvas();
+		}
+		else
+		{
+			this.loadFromFile();  
+		}
+	}
+
+	this.worldCallback = function( type, callbackObj,  calleeData,  callerData )
+	{
+		console.log( "texture callback, type: " + type );
+		if (calleeData.srcWorld)
+		{
+			var srcWorld = calleeData.srcWorld;
+			var notifier = srcWorld._notifier;
+			var texture = this.callbackObj;
+			if (texture)
+			{
+				switch (type)
+				{
+					case notifier.OBJECT_DELETE:
+						break;
+
+					case notifier.OBJECT_REINSTANTIATE:
+						break;
+
+					case notifier.OBJECT_CHANGE:
+						if (!texture.isAnimated())
+							texture.rerender();
+							texture.getDstWorld().restartRenderLoop();
+						break;
+
+					default:
+						throw new Exception( "unrecognized texture callback type: " + type );
+						break;
+				}
+		   }
+		}
+	}
+
+	this.loadFromFile = function()
+	{
+		var tex = this._texture;
+		this._srcCanvas = null;
+
+		// only load if something has changed
+		if (this._texMapName !== texMapName)	// does RDGE allow us to change wrap or mips?
+		{
+			var texMapName = this._texMapName;
+			var wrap = this._wrap;
+			var mips = this._mips;
+
+			var dstWorld = this.getDstWorld();
+			if (dstWorld)
+			{
+				var renderer = dstWorld.getRenderer();
+				tex = renderer.getTextureByName(texMapName, wrap, mips );
+				this._texture = tex;
+				dstWorld.textureToLoad( tex );
+			}
+		}
+
+		return tex;
+	}
+
+	var __texCounter = 0;
+	this.loadFromCanvas = function()
+	{
+		var srcCanvas = this._srcCanvas;
+		var wrap = this._wrap;
+		var mips = this._mips;
+
+		this._texMapName = "GLTexture_" + __texCounter;
+		__texCounter++;
+
+		// create the texture
+		var world = this.getDstWorld();
+		tex = world.getGLContext().createTexture();
+		this._texture = tex;
+		tex.texparams = new _texparams(wrap, mips);	// defined in renderer.js
+		tex.image = new Image;
+
+		// create the canvas and context to render into
+		var doc = srcCanvas.ownerDocument;
+		this._renderCanvas = doc.createElement("canvas");
+
+		// cache whether this is a 2D canvas or 3D canvas
+//		var srcCtx = srcCanvas.getContext("2d");
+//		this._is3D = false;
+//		if (!srcCtx)  this._is3D = true;
+
+		this.rerender();
+
+		return tex;
+	}
+
+	this.rerender = function()
+	{
+		if (!this._srcCanvas)
+		{
+			console.log( " no source canvas in GLTexture.rerender" );
+			return;
+		}
+		var srcCanvas = this._srcCanvas;
+
+		var world = this.getDstWorld();
+		if (!world)
+		{
+			console.log( "no world in GLTexture.rerender" );
+			return;
+		}
+		var renderer = world.getRenderer();
+
+		var imageData;
+		var width = srcCanvas.width,  height = srcCanvas.height;
+		if (!this.isPowerOfTwo(width) || !this.isPowerOfTwo(height))
+		{
+			width = this.nextLowerPowerOfTwo( width );
+			height = this.nextLowerPowerOfTwo( height );
+		}
+
+		// create a canvas to be used as the image for the texture map
+		var renderCanvas = this._renderCanvas;
+		if (!renderCanvas)
+		{
+			console.log( "no render canvas in GLTexture.rerender" );
+			return;
+		}
+		renderCanvas.width = width;
+		renderCanvas.height = height;
+		var renderCtx = renderCanvas.getContext("2d");
+
+		// create the texture
+		var tex = this._texture;
+		if (!tex)
+		{
+			console.log( "no texture in GLTexture.rerender" );
+			return;
+		}
+
+		/*
+		var srcCtx;
+		if (!this._is3D)
+		{
+			srcCtx = srcCanvas.getContext("2d");
+			imageData = srcCtx.getImageData( 0, 0, width, height );
+			renderCtx.putImageData( imageData, 0, 0 );
+		}
+		else
+		{
+			srcCtx = srcCanvas.getContext("experimental-webgl");
+			if (srcCtx)
+			{
+				renderCtx.drawImage(srcCanvas, 0, 0);
+			}
+		}
+		*/
+		renderCtx.drawImage(srcCanvas, 0, 0);
+
+		/////////////////
+		tex.image = renderCanvas;
+		renderer.commitTexture( tex );
+
+		return tex;
 }
  
-    this.isPowerOfTwo = function(x)
-    {
-        return (x & (x - 1)) == 0;
-    }
+	this.isPowerOfTwo = function(x)
+	{
+		return (x & (x - 1)) == 0;
+	}
  
-    this.nextHighestPowerOfTwo = function(x)
-    {
-        --x;
-        for (var i = 1; i < 32; i <<= 1) {
-            x = x | x >> i;
-        }
-        return x + 1;
-    }
+	this.nextHighestPowerOfTwo = function(x)
+	{
+		--x;
+		for (var i = 1; i < 32; i <<= 1) {
+			x = x | x >> i;
+		}
+		return x + 1;
+	}
  
-    this.nextLowerPowerOfTwo = function(x)
-    {
-        return this.nextHighestPowerOfTwo(x) >> 1;
-    }
-
-    this.findCanvas = function( id,  elt )
-    {
-        if (elt.id && elt.id === id)
-            return elt;
+	this.nextLowerPowerOfTwo = function(x)
+	{
+		return this.nextHighestPowerOfTwo(x) >> 1;
+	}
+
+	this.findCanvas = function( id,  elt )
+	{
+		if (elt.id && elt.id === id)
+			return elt;
  
 		if (elt.children)
 		{
@@ -278,22 +273,22 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 			{
 				var child = elt.children[i];
 				var canvas = this.findCanvas( id, child );
-                if (canvas)  return canvas;
+				if (canvas)  return canvas;
 			}
 		}
    }
 
-    /*
-    this.findWorld = function( id,  elt )
-    {
-        if (elt.id && elt.id === id)
-        {
-            if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
-            {
-                var world = elt.elementModel.shapeModel.GLWorld;
-                return world;
-            }
-        }
+	/*
+	this.findWorld = function( id,  elt )
+	{
+		if (elt.id && elt.id === id)
+		{
+			if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
+			{
+				var world = elt.elementModel.shapeModel.GLWorld;
+				return world;
+			}
+		}
  
 		if (elt.children)
 		{
@@ -302,7 +297,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 			{
 				var child = elt.children[i];
 				var world = this.findWorld( id, child );
-                if (world)  return world;
+				if (world)  return world;
 			}
 		}
    }
@@ -313,7 +308,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 }
 
 if (typeof exports === "object") {
-    exports.Texture = Texture;
+	exports.Texture = Texture;
 }
 
 
-- 
cgit v1.2.3


From b6a8f72f670a8edee35554a4ca3a0618c526d651 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Thu, 5 Apr 2012 05:30:55 -0700
Subject: Re-added taper and twist-vert materials.

---
 js/lib/rdge/texture.js | 45 ++-------------------------------------------
 1 file changed, 2 insertions(+), 43 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index 2e76f2c0..d2f66efa 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -216,23 +216,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 			return;
 		}
 
-		/*
-		var srcCtx;
-		if (!this._is3D)
-		{
-			srcCtx = srcCanvas.getContext("2d");
-			imageData = srcCtx.getImageData( 0, 0, width, height );
-			renderCtx.putImageData( imageData, 0, 0 );
-		}
-		else
-		{
-			srcCtx = srcCanvas.getContext("experimental-webgl");
-			if (srcCtx)
-			{
-				renderCtx.drawImage(srcCanvas, 0, 0);
-			}
-		}
-		*/
+		// copy the source canvas to the context to be used in the texture
 		renderCtx.drawImage(srcCanvas, 0, 0);
 
 		/////////////////
@@ -240,7 +224,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		renderer.commitTexture( tex );
 
 		return tex;
-}
+	}
  
 	this.isPowerOfTwo = function(x)
 	{
@@ -278,31 +262,6 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		}
    }
 
-	/*
-	this.findWorld = function( id,  elt )
-	{
-		if (elt.id && elt.id === id)
-		{
-			if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
-			{
-				var world = elt.elementModel.shapeModel.GLWorld;
-				return world;
-			}
-		}
- 
-		if (elt.children)
-		{
-			var nKids = elt.children.length;
-			for (var i=0;  i<nKids;  i++)
-			{
-				var child = elt.children[i];
-				var world = this.findWorld( id, child );
-				if (world)  return world;
-			}
-		}
-   }
-   */
-
    // initialize the object
    this.init();
 }
-- 
cgit v1.2.3


From 416ce9d4954e0a7f4ee7b9afe43bf691fdb276f4 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Fri, 6 Apr 2012 05:18:48 -0700
Subject: texture notifications

---
 js/lib/rdge/texture.js | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index d2f66efa..f1448195 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -6,6 +6,8 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 
 var Material = require("js/lib/rdge/materials/material").Material;
 
+var __textureCounter = 0;
+
 ///////////////////////////////////////////////////////////////////////
 // Class GLTexture
 //      GL representation of a texture.
@@ -38,6 +40,9 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 	// the destination world that will use the texture map
 	this._dstWorld = dstWorld;
 
+	this._texCount = __textureCounter;
+	__textureCounter++;
+
 	///////////////////////////////////////////////////////////////////////
 	// Property Accessors
 	///////////////////////////////////////////////////////////////////////
@@ -89,7 +94,8 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		console.log( "texture callback, type: " + type );
 		if (calleeData.srcWorld)
 		{
-			var srcWorld = calleeData.srcWorld;
+			var srcWorld = callbackObj.getSrcWorld();
+			var dstWorld = callbackObj.getDstWorld();
 			var notifier = srcWorld._notifier;
 			var texture = this.callbackObj;
 			if (texture)
@@ -103,9 +109,20 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 						break;
 
 					case notifier.OBJECT_CHANGE:
-						if (!texture.isAnimated())
-							texture.rerender();
-							texture.getDstWorld().restartRenderLoop();
+//						this._isAnimated = srcWorld._hasAnimatedMaterials;
+//						if (!srcWorld.hasAnimatedMaterials())
+//							srcWorld.restartRenderLoop();
+//						else if (!dstWorld.hasAnimatedMaterials())
+//						{
+//							dstWorld.refreshTextures();
+//							dstWorld.restartRenderLoop();
+//						}
+						break;
+
+					case notifier.FIRST_RENDER:
+						texture._isAnimated = srcWorld.hasAnimatedMaterials();
+						dstWorld.refreshTextures();
+						dstWorld.restartRenderLoop();
 						break;
 
 					default:
-- 
cgit v1.2.3


From 5b878fdfaa696c1a01afa191c1d65c0ccb006b65 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Sun, 8 Apr 2012 05:26:08 -0700
Subject: Clouds

---
 js/lib/rdge/texture.js | 25 ++++++-------------------
 1 file changed, 6 insertions(+), 19 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index f1448195..94147852 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -109,14 +109,6 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 						break;
 
 					case notifier.OBJECT_CHANGE:
-//						this._isAnimated = srcWorld._hasAnimatedMaterials;
-//						if (!srcWorld.hasAnimatedMaterials())
-//							srcWorld.restartRenderLoop();
-//						else if (!dstWorld.hasAnimatedMaterials())
-//						{
-//							dstWorld.refreshTextures();
-//							dstWorld.restartRenderLoop();
-//						}
 						break;
 
 					case notifier.FIRST_RENDER:
@@ -179,21 +171,16 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		var doc = srcCanvas.ownerDocument;
 		this._renderCanvas = doc.createElement("canvas");
 
-		// cache whether this is a 2D canvas or 3D canvas
-//		var srcCtx = srcCanvas.getContext("2d");
-//		this._is3D = false;
-//		if (!srcCtx)  this._is3D = true;
-
-		this.rerender();
+		this.render();
 
 		return tex;
 	}
 
-	this.rerender = function()
+	this.render = function()
 	{
 		if (!this._srcCanvas)
 		{
-			console.log( " no source canvas in GLTexture.rerender" );
+			console.log( " no source canvas in GLTexture.render" );
 			return;
 		}
 		var srcCanvas = this._srcCanvas;
@@ -201,7 +188,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		var world = this.getDstWorld();
 		if (!world)
 		{
-			console.log( "no world in GLTexture.rerender" );
+			console.log( "no world in GLTexture.render" );
 			return;
 		}
 		var renderer = world.getRenderer();
@@ -218,7 +205,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		var renderCanvas = this._renderCanvas;
 		if (!renderCanvas)
 		{
-			console.log( "no render canvas in GLTexture.rerender" );
+			console.log( "no render canvas in GLTexture.render" );
 			return;
 		}
 		renderCanvas.width = width;
@@ -229,7 +216,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		var tex = this._texture;
 		if (!tex)
 		{
-			console.log( "no texture in GLTexture.rerender" );
+			console.log( "no texture in GLTexture.render" );
 			return;
 		}
 
-- 
cgit v1.2.3


From 1b7592f81c9b47c2b42d78efe385cd979d54d3ca Mon Sep 17 00:00:00 2001
From: hwc487
Date: Wed, 11 Apr 2012 06:24:05 -0700
Subject: Cloud material

---
 js/lib/rdge/texture.js | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index 94147852..345effd6 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -19,8 +19,16 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 	///////////////////////////////////////////////////////////////////////
 	this._texture;
 
+   // the canvas generating the texture map (if there is one)
+	this._srcCanvas;	
+	this._srcWorld;
+
 	// texture attributes
-	this._texMapName = texMapName.slice();
+	if (typeof texMapName === "string")
+		this._texMapName = texMapName.slice();
+	else
+		this._srcCanvas = texMapName;
+		
 
 	// set default values for wrap and mips
 	if (wrap === undefined)
@@ -30,10 +38,6 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 	this._wrap = wrap;
 	this._mips = mips;
 
-   // the canvas generating the texture map (if there is one)
-	this._srcCanvas;	
-	this._srcWorld;
-
 	// cache whether or not the source is animated
 	this._isAnimated = false;
 	
@@ -65,7 +69,9 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		// determine if the source is a canvas or an image file
 		var viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
 		var root = viewUtils.application.ninja.currentDocument.documentRoot;
-		var srcCanvas = this.findCanvas( this._texMapName, root );
+		var srcCanvas = this._srcCanvas;
+		if (!srcCanvas)
+			srcCanvas = this.findCanvas( this._texMapName, root );
 		if (srcCanvas)
 		{
 			this._srcCanvas = srcCanvas;
@@ -169,7 +175,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 
 		// create the canvas and context to render into
 		var doc = srcCanvas.ownerDocument;
-		this._renderCanvas = doc.createElement("canvas");
+		this._renderCanvas = doc.createElement("texture_canvas");
 
 		this.render();
 
-- 
cgit v1.2.3


From b5aa082842f798d1eec582428468a322bd5a017f Mon Sep 17 00:00:00 2001
From: hwc487
Date: Wed, 11 Apr 2012 17:11:43 -0700
Subject: Cloud material

---
 js/lib/rdge/texture.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index 345effd6..569bc364 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -159,6 +159,8 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 	var __texCounter = 0;
 	this.loadFromCanvas = function()
 	{
+		var NJUtils = require("js/lib/NJUtils").NJUtils;
+		
 		var srcCanvas = this._srcCanvas;
 		var wrap = this._wrap;
 		var mips = this._mips;
@@ -175,7 +177,8 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 
 		// create the canvas and context to render into
 		var doc = srcCanvas.ownerDocument;
-		this._renderCanvas = doc.createElement("texture_canvas");
+		//this._renderCanvas = doc.createElement("texture_canvas");
+		this._renderCanvas = NJUtils.makeNJElement("canvas", "texture_canvas", "shape", {"data-RDGE-id": NJUtils.generateRandom()}, true);
 
 		this.render();
 
-- 
cgit v1.2.3


From 1fa8516bcd0fb0277c13a7081b5a51ce041d3496 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Thu, 12 Apr 2012 06:24:46 -0700
Subject: Cloud material

---
 js/lib/rdge/texture.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index 569bc364..b85ee076 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -75,16 +75,19 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		if (srcCanvas)
 		{
 			this._srcCanvas = srcCanvas;
-			if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel && srcCanvas.elementModel.shapeModel.GLWorld)
+			var srcWorld
+			if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
+			 srcWorld = srcCanvas.elementModel.shapeModel.GLWorld;
+			if (!srcWorld)  srcWorld = srcCanvas.__GLWorld;
+			if (srcWorld)
 			{
-				this._srcWorld = srcCanvas.elementModel.shapeModel.GLWorld;
+				this._srcWorld = srcWorld;
 
 				// add a notifier to the world
-				this._srcWorld.addListener( this,  this.worldCallback,  { srcWorld: this._srcWorld } );
+				srcWorld.addListener( this,  this.worldCallback,  { srcWorld: this._srcWorld } );
 
 				// check if the source is animated
-				if (srcCanvas.elementModel && srcCanvas.elementModel.shapeModel  && srcCanvas.elementModel.shapeModel.GLWorld)
-					this._isAnimated = this._srcWorld._hasAnimatedMaterials;
+				this._isAnimated = srcWorld._hasAnimatedMaterials;
 			}
 
 			this.loadFromCanvas();
-- 
cgit v1.2.3


From 8992d9baf542135e910bb59328a592d9e330703a Mon Sep 17 00:00:00 2001
From: hwc487
Date: Sun, 15 Apr 2012 05:16:34 -0700
Subject: Cloud Material

---
 js/lib/rdge/texture.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'js/lib/rdge/texture.js')

diff --git a/js/lib/rdge/texture.js b/js/lib/rdge/texture.js
index b85ee076..15f786ea 100644
--- a/js/lib/rdge/texture.js
+++ b/js/lib/rdge/texture.js
@@ -233,7 +233,7 @@ function Texture( dstWorld, texMapName,  wrap, mips )
 		}
 
 		// copy the source canvas to the context to be used in the texture
-		renderCtx.drawImage(srcCanvas, 0, 0);
+		renderCtx.drawImage(srcCanvas, 0, 0, width, height);
 
 		/////////////////
 		tex.image = renderCanvas;
-- 
cgit v1.2.3


From c0aa5e88890fbf74124d019df96c33215da99f17 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Mon, 16 Apr 2012 05:59:01 -0700
Subject: Cloud material

---
 js/lib/rdge/texture.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(l