1 files changed, 185 insertions, 85 deletions

diff --git a/js/lib/rdge/materials/cloud-material.js b/js/lib/rdge/materials/cloud-material.js
index 126751c6..e2292c7a 100644
--- a/js/lib/rdge/materials/cloud-material.js
+++ b/js/lib/rdge/materials/cloud-material.js
@@ -8,6 +8,8 @@ var MaterialParser		= require("js/lib/rdge/materials/material-parser").MaterialP
 var Material                    = require("js/lib/rdge/materials/material").Material;
 var GLWorld                             = require("js/lib/drawing/world").World;
 var Texture                             = require("js/lib/rdge/texture").Texture;
+var ElementMediator             = require("js/mediators/element-mediator").ElementMediator;
+var TagTool                             = require("js/tools/TagTool").TagTool;
 
 ///////////////////////////////////////////////////////////////////////
 // Class GLMaterial
@@ -20,7 +22,9 @@ var CloudMaterial = function CloudMaterial() {
         this._name = "CloudMaterial";
         this._shaderName = "cloud";
 
-        this._texMap = 'assets/images/cloud10.png';
+        //this._texMap = 'assets/images/cloud10.png';
+        this._texMap = 'assets/images/us_flag.png';
+        //this._texMap = 'assets/images/cubelight.png';
         this._diffuseColor = [0.5, 0.5, 0.5, 0.5];
 
         // base size of cloud polygons.  Random adjustments made to each quad
@@ -31,7 +35,7 @@ var CloudMaterial = function CloudMaterial() {
 
         // parameter initial values
         this._time                      = 0.0;
-        this._surfaceAlpha      = 1.0;
+        this._surfaceAlpha      = 0.6;
         this._zmin                      = 0.1;
         this._zmax                      = 10.0;
 
@@ -111,80 +115,54 @@ var CloudMaterial = function CloudMaterial() {
 
                 // save the world
                 if (world)  this.setWorld( world );
-
-                // this variable declared above is inherited set to a smaller delta.
-                // the cloud material runs a little faster
-                this._dTime = 0.01;
+                var dstWorld = world;
 
                 // create a canvas to render into
-                var doc = world.getCanvas().ownerDocument;
+                var dstCanvas = this.getWorld().getCanvas();
+                var doc = this.getWorld().getCanvas().ownerDocument;
                 var canvasID = "__canvas__";
                 //this._srcCanvas = doc.createElement(canvasID);
                 this._srcCanvas = NJUtils.makeNJElement("canvas", canvasID, "shape", {"data-RDGE-id": NJUtils.generateRandom()}, true);
-                var dstCanvas = this.getWorld().getCanvas(),
-                        srcCanvas = this._srcCanvas;
+                srcCanvas = this._srcCanvas;
                 srcCanvas.width  = dstCanvas.width;
                 srcCanvas.height = dstCanvas.height;
 
-                // save the current RDGE context
-                var saveContext = g_Engine.getContext();        
-
-                // build a world to do the rendering
-                this._srcWorld = new GLWorld( this._srcCanvas, true, true );
-                var srcWorld = this._srcWorld;
-                this._srcCanvas.__GLWorld = srcWorld;
+                //////////////////////////////////////////////////////////////////////////////////
+                // IS THIS NECESSARY??
+        //var elementModel = TagTool.makeElement(~~srcCanvas.width, ~~srcCanvas.height,
+        //                                                                Matrix.I(4), [0,0,0], srcCanvas);
+        //ElementMediator.addElement(srcCanvas, elementModel.data, true);
+                //////////////////////////////////////////////////////////////////////////////////
 
-                // build the geometry
-                var prim = this.buildGeometry( srcWorld,  srcCanvas.width, srcCanvas.height );
+                // build the source.
+                // the source being the world/canvas/geometry of the clouds.
+                // the source is used to create a texture map that is then used by
+                // the destimation.
+                this.buildSource();
 
                 // set up the shader
                 this._shader = new jshader();
-                this._shader.def = cloudMaterialDef;
+                this._shader.def = cloudMapMaterialDef;
                 this._shader.init();
 
                 // set up the material node
-                this._materialNode = createMaterialNode("cloudMaterial" + "_" + world.generateUniqueNodeID());
+                this._materialNode = createMaterialNode("cloudMapMaterial" + "_" + world.generateUniqueNodeID());
                 this._materialNode.setShader(this._shader);
 
-                // initialize the shader uniforms
+                // initialize the time
                 this._time = 0;
-                if (this._shader && this._shader['default']) {
-                        var t = this._shader['default'];
-                        if (t)
-                        {
-                                t.u_time.set( [this._time] );
-                                t.u_surfaceAlpha.set( [this._surfaceAlpha] );
-                                t.u_zmin.set( [this._zmin] );
-                                t.u_zmax.set( [this._zmax] );
 
-                                var wrap = 'REPEAT',  mips = true;
-                                var texMapName = this._propValues[this._propNames[0]];
-                                var tex = srcWorld.renderer.getTextureByName(texMapName, wrap, mips );
-                                if (tex)
-                                        srcWorld.textureToLoad( tex );
-                        }
-        }
-
-                // add the nodes to the tree
-                var trNode = createTransformNode("objRootNode_" + this._srcWorld._nodeCounter++);
-                srcWorld._rootNode.insertAsChild( trNode );
-                trNode.attachMeshNode(srcWorld.renderer.id + "_prim_" + srcWorld._nodeCounter++, prim);
-        trNode.attachMaterial( this._materialNode );
-
-                // create the texture
+                // create the texture to map the source cloud generation world/canvas to the destination
                 var wrap = 'REPEAT',  mips = true;
-                this._srcWorld._hasAnimatedMaterials = true;    // hack to make the texture think this world is animated
                 this._glTex = new Texture( world, this._srcCanvas,  wrap, mips );
 
                 // set the shader values in the shader
                 this.updateTexture();
                 this.update( 0 );
-
-                // restore the previous RDGE context
-                g_Engine.setContext( saveContext.id );
         };
 
-        this.updateTexture = function() {
+        this.updateTexture = function()
+        {
                 var material = this._materialNode;
                 if (material) 
                 {
@@ -195,9 +173,7 @@ var CloudMaterial = function CloudMaterial() {
                         var technique = material.shaderProgram['default'];
                         var renderer = g_Engine.getContext().renderer;
                         if (renderer && technique) {
-                                var texMapName = this._propValues[this._propNames[0]];
                                 var wrap = 'REPEAT',  mips = true;
-                                //var tex = this.loadTexture( texMapName, wrap, mips );
                 if (this._glTex)
                 {
                     this._glTex.render();
@@ -205,9 +181,9 @@ var CloudMaterial = function CloudMaterial() {
                                         if (tex)
                                                 technique.u_tex0.set( tex );
                 }
-
                         }
 
+                        // restore the context
                         g_Engine.setContext( saveContext.id );
                 }
         };
@@ -226,29 +202,100 @@ var CloudMaterial = function CloudMaterial() {
 
         this.update = function( time )
         {
+                var technique, renderer, tex;
+                
+                // update the cloud map material
                 var material = this._materialNode;
                 if (material)
                 {
-                        if (this._srcWorld)  this._srcWorld.draw();
+                        technique = material.shaderProgram['default'];
+                        renderer = g_Engine.getContext().renderer;
+                        if (renderer && technique)
+                        {
+                                        if (this._glTex)
+                                        {
+                                                this._glTex.render();
+                                                tex = this._glTex.getTexture();
+                                                technique.u_tex0.set( tex );
+                                        }
+                }
+                        }
+                }
 
-                        var technique = material.shaderProgram['default'];
-                        var renderer = g_Engine.getContext().renderer;
-                        if (renderer && technique) {
+                // update the source material
+                material = this._srcMaterialNode;
+                if (material)
+                {
+                        technique = material.shaderProgram['default'];
+                        renderer = g_Engine.getContext().renderer;
+                        if (renderer && technique)
+                        {