livecodingspace-app/support/client/lib/vwf/model/glge.js

"use strict";

// Copyright 2012 United States Government, as represented by the Secretary of Defense, Under
// Secretary of Defense (Personnel & Readiness).
// 
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
// 
//   http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software distributed under the License
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied. See the License for the specific language governing permissions and limitations under
// the License.

/// vwf/model/glge.js is an interface to the GLGE WebGL scene manager.
/// 
/// @module vwf/model/glge
/// @requires vwf/model
/// @requires vwf/utility

define( [ "module", "vwf/model", "vwf/utility" ], function( module, model, utility ) {

    // For historical reasons yet to be resolved, the GLGE model code currently resides in
    // vwf-model.glge.js intermixed with the view code. This driver is a gross hack to delegate model
    // calls to the appropriate parts of the GLGE view.

    return model.load( module, {

        // == Module Definition ====================================================================

        // -- initialize ---------------------------------------------------------------------------

        initialize: function() {
            checkCompatibility.call(this);
            this.state.scenes = {}; // id => { glgeDocument: new GLGE.Document(), glgeRenderer: new GLGE.Renderer(), glgeScene: new GLGE.Scene() }
            this.state.nodes = {}; // id => { name: string, glgeObject: GLGE.Object, GLGE.Collada, GLGE.Light, or other...? }
            this.state.prototypes = {}; 
            this.state.kernel = this.kernel;

        },


        // == Model API ============================================================================

        // -- creatingNode ------------------------------------------------------------------------
        
        creatingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
                                childSource, childType, childIndex, childName, callback ) {

            var childURI = nodeID === 0 ? childIndex : undefined;

            var self = this;

            //console.log(["creatingNode:",nodeID,childID,childName,childExtendsID,childType]);
            var prototypeID = isPrototype.call( this, nodeID, childID );
            if ( prototypeID !== undefined ) {
                //console.info( "FOUND prototype: " + prototypeID );
                this.state.prototypes[ prototypeID ] = {
                    parentID: nodeID,
                    ID: childID,
                    extendsID: childExtendsID,
                    implementsID: childImplementsIDs,
                    source: childSource, 
                    type: childType,
                    uri: childURI,
                    name: childName
                };
                return;                
            }
            if ( childExtendsID === undefined )
                return;

            //console.log("Create " + childID);

            var node, parentNode, glgeChild, glgeParent;
            var kernel = this.kernel;
            var prototypes = getPrototypes.call( this, kernel, childExtendsID );

//            this.logger.enabled = true;
//            this.logger.infox( "creatingNode", nodeID, childID, childExtendsID, childImplementsIDs,
//                                childSource, childType, childIndex, childName );
//            this.logger.enabled = false;

            // find the parent node
            if ( nodeID ) {
                if ( this.state.nodes[ nodeID ] )
                    parentNode = this.state.nodes[ nodeID ];
                else 
                    parentNode = this.state.scenes[ nodeID ];

                if ( parentNode ) {
                    glgeParent = parentNode.glgeObject ? parentNode.glgeObject : parentNode.glgeScene;
                    var recursive = false;
                    if ( glgeParent && childName ) {
                        recursive = ( glgeParent.constructor == GLGE.Collada );
                        glgeChild = glgeObjectChild.call( this, glgeParent, childName, childExtendsID, prototypes, recursive );
                    }
                }
            }

            if ( prototypes && isGlgeSceneDefinition.call( this, prototypes ) && childID == this.kernel.application() ) {

                this.state.sceneRootID = childID;

                var sceneNode = this.state.scenes[childID] = {
                    glgeDocument: new GLGE.Document(),
                    glgeRenderer: undefined,
                    glgeScene: new GLGE.Scene(),
                    ID: childID,
                    parentID: nodeID,
                    glgeKeys: new GLGE.KeyInput(),
                    type: childExtendsID,
                    camera: {
                        ID: undefined
                    },
                    xmlColladaObjects: [],
                    srcColladaObjects: [],
                    viewInited: false,
                    modelInited: false,
                    pendingLoads: 0,
                };
				
                if ( sceneNode.glgeScene.camera ) {
                    sceneNode.glgeScene.camera.name = "camera";
                    this.state.cameraInUse = sceneNode.glgeScene.camera;
                    initCamera.call( this, sceneNode.glgeScene.camera );
                }   

                var model = this;
                var xmlDocLoadedCallback = callback;
                sceneNode.glgeDocument.onLoad = function () {
                    sceneNode.pendingLoads--;
                    xmlDocLoadedCallback( true );
                };

                if ( childSource ) {
                    switch ( childType ) {
                        case "model/x-glge":
                            callback( false );
                            sceneNode.glgeDocument.load( utility.resolveURI( childSource, childURI ) );
                            sceneNode.pendingLoads++;
                            break;
                    }
                }
           
            } else if ( prototypes && isGlgeCameraDefinition.call( this, prototypes ) ) {
                if ( childName !== undefined ) {
                    var camName = this.kernel.name( childID );
                    var sceneNode = this.state.scenes[ this.state.sceneRootID ];
                    node = this.state.nodes[childID] = {
                        name: childName,
                        glgeObject: glgeChild,
                        ID: childID,
                        parentID: nodeID,
                        sceneID: this.state.sceneRootID,
                        glgeScene: sceneNode ? sceneNode.glgeScene : undefined,
                        type: childExtendsID,
                        sourceType: childType,
                    };

                    if ( nodeID === this.kernel.application() && childName === "camera" ) {

                    } else if ( node.glgeObject === undefined ){
                        createCamera.call( this, nodeID, childID, childName );
                    }
                }              
            } else if ( prototypes && isGlgeLightDefinition.call( this, prototypes ) ) {
                if ( childName !== undefined ) {
                    node = this.state.nodes[childID] = {
                        name: childName,
                        glgeObject: glgeChild,
                        ID: childID,
                        parentID: nodeID,
                        type: childExtendsID,
                        sourceType: childType,
                    };
                    if ( nodeID != 0 && !node.glgeObject ) {
                        createLight.call( this, nodeID, childID, childName );
                    }
                }
            } else if ( prototypes && isGlgeParticleSystemDefinition.call( this, prototypes ) ) {
                if ( childName !== undefined ) {
                    node = this.state.nodes[childID] = {
                        name: childName,
                        glgeObject: glgeChild,
                        ID: childID,
                        parentID: nodeID,
                        type: childExtendsID
                    };
                    if ( nodeID != 0 && !node.glgeObject ) {
                        createParticleSystem.call( this, nodeID, childID, childName );
                    }
                }
            } else if ( prototypes && isGlgeNodeDefinition.call( this, prototypes ) ) {

                if ( childName !== undefined ) {
                    var sceneNode = this.state.scenes[ this.state.sceneRootID ];
                    switch ( childType ) {
                        case "model/vnd.collada+xml":
                            callback( false );
                            node = this.state.nodes[childID] = {
                                name: childName,  
                                glgeObject: undefined,
                                source: utility.resolveURI( childSource, childURI ),
                                ID: childID,
                                parentID: nodeID,
                                sourceType: childType,
                                type: childExtendsID,
                                loadedCallback: callback,
                                glgeScene: sceneNode
                            };
                            loadCollada.call( this, parentNode, node, notifyDriverOfPrototypeAndBehaviorProps ); 
                            break;

                        case "text/xml":
                            node = this.state.nodes[childID] = {
                                name: childName,  
                                glgeObject: undefined,
                                source: childSource,
                                ID: childID,                                
                                parentID: nodeID,
                                type: childExtendsID,
                                sourceType: childType,
                                glgeScene: sceneNode 
                            };
                                
                            if ( sceneNode && sceneNode.glgeDocument ){
                                var meshDef = sceneNode.glgeDocument.getElement( node.source );
                                if ( meshDef ) {
                                    node.glgeObject = new GLGE.Object();
                                    node.glgeObject.setMesh( meshDef );
                                    if ( glgeParent ) {
                                        glgeParent.addObject( node.glgeObject );
                                    } else {
                                        if ( sceneNode.glgeScene ) {
                                            sceneNode.glgeScene.addObject( node.glgeObject );
                                        }
                                    }
                                }
                            }
                            break;
                            
                        case "definition/mesh": {
                                node = this.state.nodes[childID] = {
                                    name: childName,  
                                    glgeObject: undefined,
                                    glgeParent: glgeParent,
                                    source: childSource,
                                    ID: childID,                                
                                    parentID: nodeID,
                                    type: childExtendsID,
                                    sourceType: childType,
                                    glgeScene: sceneNode  
                                };
                                createMesh.call( this, node );
                            }
                            break;

                        default:
                            node = this.state.nodes[childID] = {
                                name: childName,  
                                glgeObject: glgeChild,
                                ID: childID,
                                parentID: nodeID,
                                type: childExtendsID,
                                sourceType: childType,
                                glgeScene: sceneNode  
                            };
                            if ( node.glgeObject ) {
                                if ( ( node.glgeObject.constructor == GLGE.Collada ) ) {
                                    callback( false );
                                    node.glgeObject.vwfID = childID;
                                    sceneNode.xmlColladaObjects.push( node.glgeObject );
                                    setColladaCallback.call( this, node.glgeObject, sceneNode );
                                    node.loadedCallback = callback;                                    
                                }
                            } else {
                                if ( nodeID != 0 ) {
                                    node.glgeObject = new GLGE.Group();
                                    if ( parentNode ) {
                                        if ( parentNode.glgeObject ) {
                                            parentNode.glgeObject.addObject( node.glgeObject );
                                        } else if ( parentNode.glgeScene ) {
                                            parentNode.glgeScene.addObject( node.glgeObject );
                                        }
                                    }
                            
                                    node.gui = node.glgeObject.uid;
                                    node.glgeObject.name = childName;  
                                }
                            }
                            break;
                    }  

                    this.settingProperty( childID, "playing", false );  // TODO: these are matching the defaults in node3; they should be sent through creatingProperty() so that we don't have to ask
                    this.settingProperty( childID, "looping", false );  // TODO: these are matching the defaults in node3; they should be sent through creatingProperty() so that we don't have to ask
                    this.settingProperty( childID, "speed", 1 );  // TODO: these are matching the defaults in node3; they should be sent through creatingProperty() so that we don't have to ask

                }
            } else if ( prototypes && isGlgeMaterialDefinition.call( this, prototypes ) ) {
                if ( childName !== undefined ) {
                    node = this.state.nodes[childID] = {
                        name: childName,
                        glgeObject: undefined,
                        glgeMaterial: true,
                        ID: childID,
                        parentID: nodeID,
                        type: childExtendsID,
                        sourceType: childType,
                    };
                    findMaterial.call( this, nodeID, childName, node );
                }
            } // end of else

            // If we do not have a load a model for this node, then we are almost done, so we can update all
            // the driver properties w/ the stop-gap function below.
            // Else, it will be called at the end of the assetLoaded callback
            if ( ! ( childType == "model/vnd.collada+xml" || 
                     childType == "model/vnd.osgjs+json+compressed" ) )
                notifyDriverOfPrototypeAndBehaviorProps();

            // Since prototypes are created before the object, it does not get "setProperty" updates for
            // its prototype (and behavior) properties.  Therefore, we cycle through those properties to
            // notify the drivers of the property values so they can react accordingly
            // TODO: Have the kernel send the "setProperty" updates itself so the driver need not
            // NOTE: Identical code exists in three.js driver, so if an change is necessary, it should be made
            //       there, too
            function notifyDriverOfPrototypeAndBehaviorProps() {
                var ptPropValue;
                var protos = getPrototypes.call( this, kernel, childExtendsID );
                protos.forEach( function( prototypeID ) {
                    for ( var propertyName in kernel.getProperties( prototypeID ) ) {
                        //console.info( " 1    getting "+propertyName+" of: " + childExtendsID  );
                        ptPropValue = kernel.getProperty( childExtendsID, propertyName );
                        if ( ptPropValue !== undefined && ptPropValue !== null && childID !== undefined && childID !== null) {
                            //console.info( " 1    setting "+propertyName+" of: " + nodeID + " to " + ptPropValue );
                            self.settingProperty( childID, propertyName, ptPropValue );
                        }
                    }
                } );
                childImplementsIDs.forEach( function( behaviorID ) {
                    for ( var propertyName in kernel.getProperties( behaviorID ) ) {
                        //console.info( "     2    getting "+propertyName+" of: " + behaviorID  );
                        ptPropValue = kernel.getProperty( behaviorID, propertyName );
                        if ( ptPropValue !== undefined && ptPropValue !== null && childID !== undefined && childID !== null) {
                            //console.info( "     2    setting "+propertyName+" of: " + nodeID + " to " + ptPropValue );
                            self.settingProperty( childID, propertyName, ptPropValue );
                        }
                    }
                } );
            }; 
        },
         
        // -- deletingNode -------------------------------------------------------------------------

        deletingNode: function( nodeID ) {

            if ( this.state.nodes[ nodeID ] ) {
                var node = this.state.nodes[ nodeID ];
                if ( node.glgeObject ) {
                    var obj = node.glgeObject;
                    var parent = obj.parent;
                    if ( parent ) {
                        if ( parent.removeChild ) parent.removeChild( obj );
                        node.glgeObject = undefined;
                        //delete obj;
                    }
                }
                delete this.state.nodes[ nodeID ];
            }
        },

        // -- addingChild ------------------------------------------------------------------------
        
        addingChild: function( nodeID, childID, childName ) {
            
            var parentGlgeObj = getGlgeObject.call( this, nodeID );
            var childGlgeObj = getGlgeObject.call( this, childID );

            if ( parentGlgeObj && childGlgeObj && parentGlgeObj instanceof GLGE.Group ) {

                var childParent = childGlgeObj.parent;
                // what does vwf do here?  add only if parent is currently undefined
                if ( childParent ) {
                    childParent.remove( childGlgeObj )   
                } 
                parentGlgeObj.add( childGlgeObj );   
            }
        },

        // -- movingChild ------------------------------------------------------------------------
        
        movingChild: function( nodeID, childID, childName ) {
            var parentGlgeObj = getGlgeObject.call( this, nodeID );
            var childGlgeObj = getGlgeObject.call( this, childID );

            if ( parentGlgeObj && childGlgeObj && parentGlgeObj instanceof GLGE.Group ) {

                var childParent = childGlgeObj.parent;
                
                if ( childParent ) {
                    childParent.remove( childGlgeObj ); 
                    parentGlgeObj.add( childGlgeObj );   
                } 
                  
            }
        },

        // -- removingChild ------------------------------------------------------------------------
        
        removingChild: function( nodeID, childID, childName ) {
            var parentGlgeObj = getGlgeObject.call( this, nodeID );
            var childGlgeObj = getGlgeObject.call( this, childID );

            if ( parentGlgeObj && childGlgeObj && parentGlgeObj instanceof GLGE.Group ) {

                var childParent = childGlgeObj.parent;
                if ( childParent === parentGlgeObj ) {
                    parentGlgeObj.remove( childGlgeObj )   
                } 
                  
            }
        },

        // -- creatingProperty ---------------------------------------------------------------------

        creatingProperty: function( nodeID, propertyName, propertyValue ) {

            return this.initializingProperty( nodeID, propertyName, propertyValue );
        },

        // -- initializingProperty -----------------------------------------------------------------

        initializingProperty: function( nodeID, propertyName, propertyValue ) {

            var value = undefined;

            if ( propertyValue !== undefined ) {
                var node = this.state.nodes[ nodeID ];
                if ( !node ) node = this.state.scenes[ nodeID ];
                if ( node ) {
                    switch ( propertyName ) {

                        case "meshDefinition":
                            defineMesh.call( this, propertyValue, node );
                            break;

                        default:
                            value = this.settingProperty( nodeID, propertyName, propertyValue );            
                            break;
                    }
                }
            }

            return value;
        },

        // -- settingProperty ----------------------------------------------------------------------

        settingProperty: function( nodeID, propertyName, propertyValue ) {

            var node = this.state.nodes[ nodeID ]; // { name: childName, glgeObject: undefined }
            var prototypes;
            var value = undefined;

            if ( node && node.glgeObject && propertyValue !== undefined ) {

                var validProperty = false;
                var glgeObject = node.glgeObject;
                var isAnimatable = glgeObject.animate; // implements GLGE.Animatable?
    isAnimatable = isAnimatable && glgeObject.animation || propertyName == "looping" && glgeObject.constructor == GLGE.ParticleSystem; // has an animation?
    isAnimatable = isAnimatable && node.name != "cityblock.dae"; // TODO: this is a hack to prevent disabling the animation that keeps the world upright


                value = propertyValue;

                if ( isAnimatable ) {

                    switch ( propertyName ) {

                        case "playing":

    if ( !Boolean( propertyValue ) && glgeObject.animFinished ) {  // TODO: GLGE finished doesn't flow back into node3's playing yet; assume playing is being toggled and interpret it as true if the animation has played and finished.
        propertyValue = true;
    }

//    if ( !node.initialized ) {  // TODO: this is a hack to set the animation to frame 0 during initialization
//        //if ( glgeObject.animFrames == 100 ) { glgeObject.setFrames( 50 ); } // hack to use only the opening half of the door animation
//        glgeObject.setStartFrame( 0, 0, glgeObject.getLoop() );
//        glgeObject.getInitialValues( glgeObject.animation, glgeObject.animationStart );
//    }

                            if ( Boolean( propertyValue ) ) {
                                if ( glgeObject.animFinished ) {
                                    glgeObject.setStartFrame( 0, 0, glgeObject.getLoop() );
                                } else if ( glgeObject.getPaused() ) {
                                    if ( glgeObject.animFrames == 100 ) {
                                        glgeObject.setFrames( 50 );
                                    }
                                    glgeObject.setPaused( GLGE.FALSE );
                                    value = false;
                                    validProperty = true;
                                }
                            } else {
                                glgeObject.setPaused( GLGE.TRUE );
                                value = true;
                                validProperty = true;
                            }

                            break;

                        case "looping":
                            value = Boolean( propertyValue ) ? GLGE.TRUE : GLGE.FALSE;
                            glgeObject.setLoop( value );
                            value = (value == GLGE.TRUE) ? true : false;
                            validProperty = true;
                            break;

                        case "speed":
                            value = Number( propertyValue ) * 30; // TODO: not safe to assume default speed is 30 fps
                            glgeObject.setFrameRate( value );
                            validProperty = true;
                            break;
                    }
                }

                var pv = propertyValue;
                switch ( propertyName ) {

                    case "transform":

                        //console.info( "setting transform of: " + nodeID + " to " + Array.prototype.slice.call( propertyValue ) );
                        var transform = goog.vec.Mat4.createFromArray( propertyValue || [] );

                        // Rotate 90 degress around X to convert from VWF Z-up to GLGE Y-up.
                        if ( glgeObject instanceof GLGE.Camera ) {
                            var columny = goog.vec.Vec4.create();
                            goog.vec.Mat4.getColumn( transform, 1, columny );
                            var columnz = goog.vec.Vec4.create();
                            goog.vec.Mat4.getColumn( transform, 2, columnz );
                            goog.vec.Mat4.setColumn( transform, 1, columnz );
                            goog.vec.Mat4.setColumn( transform, 2, goog.vec.Vec4.negate( columny, columny ) );
                        }

                        // Assign the transform. GLGE matrices are transposed compared to VWF.
                        // setStaticMatrix() doesn't propagate correctly for cameras, so we have to
                        // decompose camera assignments.

                        if ( glgeObject instanceof GLGE.Camera || glgeObject instanceof GLGE.Light || glgeObject instanceof GLGE.ParticleSystem ) { // setStaticMatrix doesn't work for cameras

                            var translation = goog.vec.Vec3.create();
                            goog.vec.Mat4.getColumn( transform, 3, translation );
                            goog.vec.Mat4.setColumnValues( transform, 3, 0, 0, 0, 1 );
                            goog.vec.Mat4.transpose( transform, transform );
                            glgeObject.setRotMatrix( transform );
                            glgeObject.setLoc( translation[0], translation[1], translation[2] );

                        } else {

                            // Set loc[XYZ] so that GLGE.Placeable.getPosition() will return correct
                            // values for lookAt. setLoc() clears the static matrix, so call it
                            // before setStaticMatrix().

                            var translation = goog.vec.Vec3.create();
                            goog.vec.Mat4.getColumn( transform, 3, translation );
                            glgeObject.setLoc( translation[0], translation[1], translation[2] );

                            // Set the full matrix.

                            glgeObject.setStaticMatrix(
                                goog.vec.Mat4.transpose( transform, goog.vec.Mat4.create() )
                            );
                        }

                        break;

                    case "material": {
                            var sceneNode = this.state.scenes[ this.state.sceneRootID ];
                            if ( sceneNode && node.glgeObject ) {
                                if ( propertyValue && propertyValue.constructor == Array ) propertyValue = propertyValue[(Math.random() * propertyValue.length) | 0];
                                if ( !propertyValue ) propertyValue = "grey";
                                var mat = sceneNode.glgeDocument.getElement( propertyValue );
                                if ( mat ) {
                                    node.glgeObject.setMaterial( mat ); 
                                }
                            } 
                        }                      
                        break;

                    case "lookAt": {
                            //console.info( "settingProperty( " + nodeID + ", " + propertyName + ", " + propertyValue + " )" );
                            if ( propertyValue == "activeCamera" ) {
                                if ( this.state.cameraInUse ) {
                                    glgeObject.setLookat( this.state.cameraInUse );
                                }
                            } else {
                                var lookAtNode = this.state.nodes[ propertyValue ];
                                if ( lookAtNode && lookAtNode.glgeObject ) {
                                    //console.info( "         settingProperty found lookat object" );
                                    glgeObject.setLookat( lookAtNode.glgeObject );
                                } else {
                                    if ( glgeObject.getLookat && glgeObject.getLookat() ) 
                                        glgeObject.setLookat( null );
                                }
                            }
                        }
                        break;

                    case "pickable":
                        if ( glgeObject.setPickable ){
                            glgeObject.setPickable( propertyValue );
                        }                            
                        break;

                    case "visible":
                        if ( glgeObject.setVisible ) {
                            glgeObject.setVisible( propertyValue );
                        }
                        break;

                    default:
                        prototypes = getPrototypes.call( this, this.kernel.kernel.kernel, node["type"] );
                        if ( isGlgeMaterialDefinition.call( this, prototypes ) ){
                            value = setMaterialProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeCameraDefinition.call( this, prototypes ) ) {
                            value = setCameraProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeLightDefinition.call( this, prototypes ) ) {
                            value = setLightProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeParticleSystemDefinition.call( this, prototypes ) ) {
                            value = setParticleSystemProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeSceneDefinition.call( this, prototypes ) ) {
                            value = setSceneProperty.call( this, nodeID, propertyName, propertyValue );
                        } else {
                            if ( !validProperty ) {
                                value = undefined;
                            }                          
                        }
                        break;
                }
            } else if ( this.state.scenes[nodeID] ) {
                value = setSceneProperty.call( this, nodeID, propertyName, propertyValue );
            } 

             return value;        
        },

        // -- gettingProperty ----------------------------------------------------------------------

        gettingProperty: function( nodeID, propertyName, propertyValue ) {

            var node = this.state.nodes[nodeID]; // { name: childName, glgeObject: undefined }
            var value = undefined;
            var glgeModel = this;
            var prototypes = undefined;
            var validProperty = false;

            if ( node && node.glgeObject ) {

                var glgeObject = node.glgeObject;
                var isAnimatable = glgeObject.animate; // implements GLGE.Animatable?
    isAnimatable = isAnimatable && glgeObject.animation || propertyName == "looping" && glgeObject.constructor == GLGE.ParticleSystem; // has an animation?
    isAnimatable = isAnimatable && node.name != "cityblock.dae"; // TODO: this is a hack to prevent disabling the animation that keeps the world upright

                if ( isAnimatable ) {

                    switch ( propertyName ) {

                        case "playing":
                            value = !Boolean( glgeObject.getPaused() );
                            validProperty = true;
                            break;

                        case "looping":
                            value = Boolean( glgeObject.getLoop() );
                            validProperty = true;
                            break;

                        case "speed":
                            value = glgeObject.getFrameRate() / 30; // TODO: not safe to assume default speed is 30 fps
                            validProperty = true;
                            break;
                    }
                }

                switch ( propertyName ) {

                    case "transform":

                        // We would use glgeObject.getLocalMatrix(), but glgeObject.localMatrix
                        // isn't always recalculated. So, we need to replicate the calculations from
                        // glgeObject.getModelMatrix(). VWF matrices are transposed compared to GLGE.

                        value = goog.vec.Mat4.transpose( glgeObject.staticMatrix ||
                            GLGE.mulMat4(
                                glgeObject.getTranslateMatrix(),
                                GLGE.mulMat4(
                                    glgeObject.getRotMatrix(),
                                    glgeObject.getScaleMatrix()
                                )
                            ),
                            goog.vec.Mat4.create()
                        );

                        // Rotate -90 degress around X to convert from GLGE Y-up to VWF Z-up.

                        if ( glgeObject instanceof GLGE.Camera ) {
                            var columny = goog.vec.Vec4.create();
                            goog.vec.Mat4.getColumn( value, 1, columny );
                            var columnz = goog.vec.Vec4.create();
                            goog.vec.Mat4.getColumn( value, 2, columnz );
                            goog.vec.Mat4.setColumn( value, 2, columny );
                            goog.vec.Mat4.setColumn( value, 1, goog.vec.Vec4.negate( columnz, columnz ) );
                        }

                        break;
                
                    case "boundingbox":
                        var bbox;
                        if ( glgeObject.getBoundingVolume ) {
                            bbox = glgeObject.getBoundingVolume( true );
                            value = { min: { x: bbox.limits[0], y: bbox.limits[2], z: bbox.limits[4] }, max: { x: bbox.limits[1], y: bbox.limits[3], z: bbox.limits[5] } };
                        } 
                        break;

                    case "centerOffset":
                        var centerOff = getCenterOffset.call( this, glgeObject );
                        var scale = this.kernel.getProperty( nodeID, "scale", undefined );
                        value = new Array;
                        value.push( centerOff[0] * scale[0], centerOff[1] * scale[1], centerOff[2] * scale[2] ); 
                        break;

                    case "vertices":
                        value = getMeshVertices.call( this, glgeObject );
                        break;

                    case "vertexIndices":
                        value = getMeshVertexIndices.call( this, glgeObject );
                        break;

                    case "meshData":
                        value = [];
                        var scale = this.gettingProperty( nodeID, "scale", [] ); 
                        var meshList = findAllMeshes.call( this, glgeObject );
                        for ( var i = 0; i < meshList.length; i++ ) {
                            value.push( {  "vertices": getMeshVertices.call( this, meshList[i] ),
                                           "vertexIndices": getMeshVertexIndices.call( this, meshList[i] ),
                                           "scale": scale 
                                        } );
                        }
                        break;
 
                    case "lookAt": {
                            value = "";
                            var lookAtObject = glgeObject.getLookat();
                            if ( lookAtObject ) {
                                value = getObjectID.call( glgeModel, lookAtObject, false, false );
                            }
                        }
                        break;

                    case "pickable":
                        if ( glgeObject.getPickable ){
                            value = glgeObject.getPickable();
                        }                            
                        break;

                    case "visible":
                        if ( glgeObject.getVisible ) {
                            value = glgeObject.getVisible();
                        }
                        break;

                    default:
                        // handle all of the other types
                        prototypes = getPrototypes.call( this, this.kernel.kernel.kernel, node["type"] );
                        if ( isGlgeMaterialDefinition.call( this, prototypes ) ){
                            value = getMaterialProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeCameraDefinition.call( this, prototypes ) ) {
                            value = getCameraProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeLightDefinition.call( this, prototypes ) ) {
                            value = getLightProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeParticleSystemDefinition.call( this, prototypes ) ) {
                            value = getParticleSystemProperty.call( this, nodeID, propertyName, propertyValue );
                        } else if ( isGlgeSceneDefinition.call( this, prototypes ) ) {
                            value = getSceneProperty.call( this, nodeID, propertyName, propertyValue );
                        } else {
                            if ( !validProperty ) {
                                value = undefined;
                            }   
                        }
                        break;    

                }
            } else if ( this.state.scenes[nodeID] ) {
                value = getSceneProperty.call( this, nodeID, propertyName, propertyValue );
            } 

//            if ( value && value instanceof Object && !( value instanceof Array ) && !( value instanceof Float32Array ) ){
//                console.info( "WARNING: gettingProperty( "+nodeID+", "+propertyName+" ) returning an OBJECT: " + value );
//            }

            return value;

        },


        // TODO: deletingMethod

        // -- callingMethod --------------------------------------------------------------------------

//        callingMethod: function( nodeID, methodName /* [, parameter1, parameter2, ... ] */ ) { // TODO: parameters
//            return undefined;
//        },


        // TODO: creatingEvent, deltetingEvent, firingEvent

        // -- executing ------------------------------------------------------------------------------

//        executing: function( nodeID, scriptText, scriptType ) {
//            return undefined;
//        },

        // == ticking =============================================================================

//        ticking: function( vwfTime ) {
//        },

    } );

    // == Private functions ==================================================================

    // -- checkCompatibility -------------------------------------------------------------

    function checkCompatibility() {
        this.compatibilityStatus = { compatible:true, errors:{} }
        var contextNames = ["webgl","experimental-webgl","moz-webgl","webkit-3d"];
        for(var i = 0; i < contextNames.length; i++){
            try{
                var canvas = document.createElement('canvas');
                var gl = canvas.getContext(contextNames[i]);
                if(gl){
                    return true;
                }
            }
            catch(e){}
        }
        this.compatibilityStatus.compatible = false;
        this.compatibilityStatus.errors["WGL"] = "This browser is not compatible. The vwf/view/threejs driver requires WebGL.";
        return false;
    }

    // -- initScene ------------------------------------------------------------------------

    function initScene( sceneNode ) {

        if ( sceneNode && !sceneNode.modelInited ) {
            sceneNode.modelInited = true;

            //findAllColladaObjs.call( this, sceneNode.glgeScene, sceneNode.ID );
        }
    } 

    // -- loadCollada ------------------------------------------------------------------------  
    
    function loadCollada( parentNode, node, propertyNotifyCallback ) {

        // Create new GLGE collada object
        node.glgeObject = new GLGE.Collada;

        // Set properties on new GLGE collada object
        var sceneNode = this.state.scenes[ this.state.sceneRootID ];
        var colladaLoadedCallback = setColladaCallback.call( this, node.glgeObject, sceneNode, 
                                                             propertyNotifyCallback );
        node.glgeObject.vwfID = node.ID;
        node.glgeObject.setDocument( node.source, window.location.href, colladaLoadedCallback );

        // Add the new GLGE collada object to the list of those that need to be loaded
        sceneNode.srcColladaObjects.push( node.glgeObject );
        
        // If the new node has a parent, attach its GLGE object to that of the parent
        // Else, attach it to the scene directly as a top-level object
        if ( parentNode && parentNode.glgeObject )
            parentNode.glgeObject.addCollada( node.glgeObject );
        else if ( sceneNode && sceneNode.glgeScene )
            sceneNode.glgeScene.addCollada( node.glgeObject );
    }


    // -- findCollada ------------------------------------------------------------------------

    function findCollada( grp, nodeID ) {

        if ( grp && grp.getChildren ) {
            var children = grp.getChildren();
            var sceneNode = this.state.scenes[ this.state.sceneRootID ];    

            for ( var i = 0; i < children.length; i++ ) {
                if ( children[i].constructor == GLGE.Collada ) {
                    var modelID = nodeID;
                    var glgeModel = this;

                    sceneNode.xmlColladaObjects.push( children[i] );
                    setColladaCallback.call( this, children[i], sceneNode );

                    children[i].loadedCallback = colladaLoaded;
                    sceneNode.pendingLoads++;
                }
                findCollada.call( this, children[i] ); 
            }
        }
    }


    // -- setColladaCallback ------------------------------------------------------------------------

    function setColladaCallback( glgeColladaObject, sceneNode, propertyNotifyCallback ) {

        var self = this;

        // Update the number of pending loads on the scene node
        // This information is just for our own knowledge; it is not used anywhere
        // (But double-check to make sure no one has added a reference before you do anything drastic)
        sceneNode.pendingLoads++;

        // Set the callback as defined below
        glgeColladaObject.loadedCallback = colladaLoaded;

        function colladaLoaded( colladaObject ) {

            // Undo default GLGE rotation applied in GLGE.Collada.initVisualScene that adjusts for +Y up
            colladaObject.setRot( 0, 0, 0 );

            // Update the number of pending loads on the scene node
            // This information is just for our own knowledge; it is not used anywhere
            // (But double-check to make sure no one has added a reference before you do anything drastic)
            sceneNode.pendingLoads--;

            // Now that this object has loaded, remove it from the list of objects to be loaded            
            var removedFromLoadList = false;
            for ( var i = 0; !removedFromLoadList && i < sceneNode.srcColladaObjects.length; i++ ) {
                if ( sceneNode.srcColladaObjects[ i ] == colladaObject ){
                    sceneNode.srcColladaObjects.splice( i, 1 );
                    removedFromLoadList = true;
                }
            }
            for ( var i = 0; !removedFromLoadList && i < sceneNode.xmlColladaObjects.length; i++ ) {
                if ( sceneNode.xmlColladaObjects[ i ] == colladaObject ){
                    sceneNode.xmlColladaObjects.splice( i, 1 );
                    removedFromLoadList = true;
                }
            }

            // Since prototypes are created before the object, it does not get "setProperty" updates for
            // its prototype (and behavior) properties.  Therefore, we cycle through those properties to
            // notify the drivers of the property values so they can react accordingly
            // TODO: Have the kernel send the "setProperty" updates itself so the driver need not
            if ( propertyNotifyCallback )
                propertyNotifyCallback();

            // If the VWF node for the newly loaded collada has a callback function, call it
            // TODO: Since the callback resumes the queue, maybe we should not call it if there are still
            //       objects to be loaded
            var id = colladaObject.vwfID || getObjectID.call( self, colladaObject, true, false );
            if ( id && ( id != "" ) ) {
                var colladaNode = self.state.nodes[ id ];
                if ( colladaNode && colladaNode.loadedCallback ) {
                    colladaNode.loadedCallback( true );                    
                }
            }
        }
        return colladaLoaded;
    }

    // -- findColladaParent ------------------------------------------------------------------------

    function findAllColladaObjs( glgeScene, nodeID ) {

        findCollada.call( this, glgeScene, nodeID );

    }

    // -- findColladaParent ------------------------------------------------------------------------

    function findColladaParent( glgeObject ) {
        var colladaObj = undefined;
        var currentObj;
        if ( glgeObject ) {
            currentObj = glgeObject;
            while ( !colladaObj && currentObj ) {
                if ( currentObj.constructor == GLGE.Collada )
                    colladaObj = currentObj;
                else
                    currentObj = currentObj.parent;
            } 
        }
        return colladaObj;    
    }


    // -- setSceneProperty ------------------------------------------------------------------------

    function setSceneProperty( nodeID, propertyName, propertyValue ) {

        var value = propertyValue;
        var sceneNode = this.state.scenes[ nodeID ];

        if ( sceneNode && sceneNode.glgeScene ) {
            switch ( propertyName ) {
                case "ambientColor":
                    if ( propertyValue )
                        sceneNode.glgeScene.setAmbientColor( propertyValue );
                    else
                        this.logger.warn( "Invalid ambient color");
                    break;
                case "activeCamera":
                        if ( this.state.nodes[ propertyValue ] ) {
                            setActiveCamera.call( this, sceneNode, propertyValue );
                        }
                    break;
                case "backgroundColor":
                    if ( propertyValue )
                        sceneNode.glgeScene.setBackgroundColor( propertyValue );
                    else
                        this.logger.warn( "Invalid background color");
                    break;

                default:
                    value = undefined;
                    break;
            }
        }
        return value;

    }

    // -- setParticleSystemProperty ------------------------------------------------------------------------

    function setParticleSystemProperty( nodeID, propertyName, propertyValue ) {

        var node = this.state.nodes[nodeID]; // { name: childName, glgeObject: undefined }
        var value = propertyValue;
        switch ( propertyName ) {
            case "numberParticles":
                node.glgeObject.setNumParticles( propertyValue );
                break;
            case "lifeTime":
                node.glgeObject.setLifeTime( propertyValue );
                break;
            case "maxLifeTime":
                node.glgeObject.setMaxLifeTime( propertyValue );
                break;
            case "minLifeTime":
                node.glgeObject.setMinLifeTime( propertyValue );
                break;
            case "startSize":
                node.glgeObject.setStartSize( propertyValue );
                break;
            case "endSize":
                node.glgeObject.setEndSize( propertyValue );
                break;
            case "loop":
                node.glgeObject.setLoop( propertyValue );
                break;
            case "velocity":
                if ( propertyValue )
                    node.glgeObject.setVelocity( propertyValue[0], propertyValue[1], propertyValue[2] );
                break;
            case "maxVelocity":
                if ( propertyValue )
                    node.glgeObject.setMaxVelocity( propertyValue[0], propertyValue[1], propertyValue[2] );
                break;            
            case "minVelocity":
                if ( propertyValue )
                    node.glgeObject.setMinVelocity( propertyValue[0], propertyValue[1], propertyValue[2] );
                break;    
            case "startAcceleration":
                if ( propertyValue )
                    node.glgeObject.setStartAccelertaion( propertyValue[0], propertyValue[1], 
                                                          propertyValue[2] );
                break;
            case "endAcceleration":
                if ( propertyValue )
                    node.glgeObject.setEndAccelertaion( propertyValue[0], propertyValue[1], propertyValue[2] );
                break;
            case "maxStartAcceleration":
                if ( propertyValue )
                    node.glgeObject.setMaxStartAccelertaion( propertyValue[0], propertyValue[1], 
                                                             propertyValue[2] );
                break;
            case "maxEndAcceleration":
                if ( propertyValue )
                    node.glgeObject.setMaxEndAccelertaion( propertyValue[0], propertyValue[1], 
                                                           propertyValue[2] );
                break;
            case "minStartAcceleration":
                if ( propertyValue )
                    node.glgeObject.setMinStartAccelertaion( propertyValue[0], propertyValue[1], 
                                                             propertyValue[2] );
                break;
            case "minEndAcceleration":
                if ( propertyValue )
                    node.glgeObject.setMinEndAccelertaion( propertyValue[0], propertyValue[1], 
                                                           propertyValue[2] );
                break;
            case "startColor":
                if ( propertyValue )
                    node.glgeObject.setStartColor( propertyValue );
                break;
            case "endColor":
                if ( propertyValue )
                    node.glgeObject.setEndColor( propertyValue );
                break;
            case "image":
                node.glgeObject.setImage( propertyValue );
                break;
            default:
                value = undefined;
                break;
        }
        return value;

    }

    // -- setCameraProperty ------------------------------------------------------------------------

    function setCameraProperty( nodeID, propertyName, propertyValue ) {

        var node = this.state.nodes[nodeID]; // { name: childName, glgeObject: undefined }
        var value = propertyValue;
        switch ( propertyName ) {
            case "cameraType":
                switch ( propertyValue ) {
                    case "perspective":
                        node.glgeObject.setType( GLGE.C_PERSPECTIVE );
                        break;
                    case "orthographic":
                        node.glgeObject.setType( GLGE.C_ORTHO );
                        break;
                    default:
                        value = undefined;
                        break;
                }
                break;
            case "far":
                node.glgeObject.setFar( Number( propertyValue ) );
                break;
            case "near":
                node.glgeObject.setNear( Number( propertyValue ) );
                break;
            case "fovy":
                node.glgeObject.setFovY( Number( propertyValue ) );
                break;            
            case "aspect":
                
                // If the propertyValue is real, set it
                // Else, it will be set to be the aspect ratio of the GLGE canvas
                if ( propertyValue )
                    node.glgeObject.setAspect( Number( propertyValue ) );
                break;            
//            case "orthoscale":
//                if ( propertyValue ) { 
//                    node.glgeObject.setOrthoScale( Number( propertyValue ) );
//                }
//                break;
            default:
                value = undefined;
                break;
        }
        return value;

    }

    // -- setMaterialProperty ------------------------------------------------------------------------

    function setMaterialProperty( nodeID, propertyName, propertyValue ) {

        var node = this.state.nodes[ nodeID ]; 
        var value = propertyValue;
        var txtr, mat, txtrPropValue;

        if ( propertyValue ) {
            if ( node.glgeMaterial && node.glgeMaterial.textures ) {
                mat = node.glgeMaterial;
                txtr = node.glgeMaterial.textures[0];
            } else if ( node.glgeObject && node.glgeObject.material ) {
                mat = node.glgeObject.material; 
                txtr = node.glgeObject.material.textures[0];
            }            
            switch ( propertyName ) {
                case "texture": {
                    
            // setting the texture back to the same value is causing a problem, need 
            // to find out why so this get and check can be removed
            txtrPropValue = getMaterialProperty.call( this, nodeID, propertyName );
                    //console.info( "txtrProp = " + txtrPropValue );
                    //console.info( "Setting the texture of: " + nodeID + " to " + propertyValue);    
                    if ( ( propertyValue !== undefined ) && ( propertyValue != "" ) && ( propertyValue != txtrPropValue ) ) {
                        var textureType = "image";
                        if ( propertyValue == "canvas" ) {
                            textureType = "canvas";
                        } else if ( propertyValue.indexOf( "canvas_" ) == 0 ) {
                            textureType = "canvas";   
                        } else if ( this.state.nodes[propertyValue] ) {
                            textureType = "camera";
                        } else if ( !isImageFileRef.call( this, propertyValue ) /* isVideoFileRef.call( this, propertyValue ) */ ) {
                            textureType = "video";
                        }

                        //console.info( "     mat: " + mat );
                        //console.info( "     txtr: " + txtr );                        
                        //console.info( "     textureType: " + textureType );

                        var isCorrectTexture = false;
                        if ( txtr ) {
                            switch ( textureType ){ 
                                case "image":
                                    isCorrectTexture = ( txtr instanceof GLGE.Texture );
                                    break;
                                case "canvas":
                                    isCorrectTexture = ( txtr instanceof GLGE.TextureCanvas );
                                    break;
                                case "camera":
                                    isCorrectTexture = ( txtr instanceof GLGE.TextureCamera );
                                    break;
                                case "video":
                                    isCorrectTexture = ( txtr instanceof GLGE.TextureVideo );
                                    break;                                    
                            }
                        }

                        //console.info( "     isCorrectTexture: " + isCorrectTexture );

                        if ( isCorrectTexture ) {
                            if ( textureType == "video" || textureType == "image" ){
                                txtr.setSrc( propertyValue );   
                            } else if ( "camera" ) {
                                var camNode = this.state.nodes[ propertyValue ];
                                var cam = findCamera.call( this, camNode );
                                if ( cam ) {
                                    txtr.setCamera( cam );
                                } 
                            } 
                        } else if ( mat ) {
                            var txt;
					        var ml = new GLGE.MaterialLayer;
					        ml.setMapto( GLGE.M_COLOR );
					        ml.setMapinput( GLGE.UV1 );
                            //console.info( "     new textureType: " + textureType );

                            switch ( textureType ) {
                                case "image":
                                    txt = new GLGE.Texture();
                                    txt.setSrc( propertyValue );
                                    break;
                                case "canvas":
                                    //console.info( "     GLGE.TextureCanvas with id = " + propertyValue );
                                    txt = new GLGE.TextureCanvas( undefined, "512", "512", propertyValue );
                                    break;
                                case "camera":
                                    txt = new GLGE.TextureCamera( undefined, "512", "512" );
                                    var camNode = this.state.nodes[ propertyValue ];
                                    var cam = findCamera.call( this, camNode );
                                    if ( cam ) {
                                        txt.setCamera( cam );
                                    }                                     
                                    break;
                                case "video":
                                    txt = new GLGE.TextureVideo( undefined, "1024", "512" );
                                    txt.setSrc( propertyValue );
                                    ml.setScaleX( -1 );
                                    ml.setScaleY( -1 );                                    
                                    break;                                  
                            }
                            //console.info( "     txt: " + txt );
                            mat.addTexture( txt );
					        ml.setTexture( txt );
					        mat.addMaterialLayer( ml );
                        }
                    }
                    }
                    break;

                case "color":
                    if ( mat ) { mat.setColor( propertyValue ); } 
                    break;                
                case "ambient":
                    if ( mat ) { mat.setAmbient( propertyValue ); } 
                    break;
                case "specColor":
                    if ( mat ) { mat.setSpecularColor( propertyValue ); } 
                    break;
                case "shininess":
                    if ( mat ) { mat.setShininess( propertyValue ); } 
                    break;  
                case "reflect":
                    if ( mat ) { mat.setReflectivity( propertyValue ); } 
                    break;
                case "specular":
                    if ( mat ) { mat.setSpecular( propertyValue ); } 
                    break;
                case "emit":
                    if ( mat ) { mat.setEmit( propertyValue ); } 
                    break; 
                case "alpha":
                    if ( mat ) { mat.setAlpha( propertyValue ); } 
                    break;                    
                case "binaryAlpha":
                    if ( mat ) { mat.setBinaryAlpha( propertyValue ); } 
                    break; 

                default:
                    value = undefined;
                    break;
            }
        }

        return value;
    }


    // -- setLightProperty ------------------------------------------------------------------------

    function setLightProperty( nodeID, propertyName, propertyValue ) {

        if ( propertyValue === undefined ) return;

        var node = this.state.nodes[nodeID]; // { name: childName, glgeObject: undefined }
        var value = propertyValue;

        switch ( propertyName ) {
            case "lightType":
                switch ( propertyValue ) {
                    case "point":
                        node.glgeObject.setType( GLGE.L_POINT );
                        break;
                    case "directional":
                        node.glgeObject.setType( GLGE.L_DIR );
                        break;
                    case "spot":
                        node.glgeObject.setType( GLGE.L_SPOT );
                        break;
                    default:
                        value = undefined;
                        break;
                }
                break;
            case "enable":
                if ( propertyValue && propertyValue != "false" ) {
                    node.glgeObject.enableLight();
                } else {
                    node.glgeObject.disableLight();
                }
                break;

            case "glge-constantAttenuation":
                node.glgeObject.setAttenuationConstant( propertyValue );
                break;

            case "glge-linearAttenuation":
                node.glgeObject.setAttenuationLinear( propertyValue );
                break;

            case "glge-quadraticAttenuation":
                node.glgeObject.setAttenuationQuadratic( propertyValue );
                break;

            case "glge-spotCosCutOff":
                node.glgeObject.setSpotCosCutOff( propertyValue );
                break;

            case "glge-spotCutOff":
                node.glgeObject.setSpotCutOff( propertyValue );
                break;

            case "glge-spotExponent":
                node.glgeObject.setSpotExponent( propertyValue );
                break;

            case "color":
                node.glgeObject.setColor( propertyValue );
                break;

            case "diffuse":
                node.glgeObject.setColor(propertyValue); // no setDiffuse() in GLGE 0.7
                break;

            case "specular":
            case "glge-specular":
                node.glgeObject.specular = propertyValue; // no setSpecular() in GLGE 0.7
                break;

            case "glge-samples":
                node.glgeObject.setShadowSamples( propertyValue );
                break;

            case "glge-softness":
                node.glgeObject.setShadowSoftness( propertyValue );
                break;

            case "glge-bufferHeight":
                node.glgeObject.setBufferHeight( propertyValue );
                break;

            case "glge-bufferWidth":
                node.glgeObject.setBufferWidth( propertyValue );
                break;

            case "glge-shadowBias":
                node.glgeObject.setShadowBias( propertyValue );
                break;

            case "distance":
                node.glgeObject.setDistance( propertyValue );
                break;

            case "castShadows":
                node.glgeObject.setCastShadows( propertyValue );
                break;

            case "glge-spotSoftness":
                node.glgeObject.setSpotSoftness( propertyValue );
                break;

            case "glge-spotSoftnessDistance":
                node.glgeObject.setSpotSoftDistance( propertyValue );
                break;

            case "glge-cascadeLevels":
                node.glgeObject.setCascadeLevels( propertyValue );
                break;

            default:
                value = undefined;
                break;
        }
        return value;

    }

    // -- getSceneProperty ------------------------------------------------------------------------------

    function getSceneProperty( nodeID, propertyName, propertyValue ) {

        var color = undefined, tempClr;
        var sceneNode = this.state.scenes[nodeID] // { name: childName, glgeObject: undefined }
        var value = undefined;
        switch ( propertyName ) {
              case "ambientColor":
                color = vwfColor.call( this, sceneNode.glgeScene.getAmbientColor() );
                value = color.toString();
                break;
            case "activeCamera":
                if ( sceneNode.glgeScene.camera ) {
                    value = getObjectID.call( this, sceneNode.glgeScene.camera, false, false );
                }
                break;

            case "backgroundColor":
                tempClr = sceneNode.glgeScene.getBackgroundColor();
                if ( tempClr ) {
                    if ( tempClr.r && isNaN( tempClr.r ) ) tempClr.r = 0;
                    if ( tempClr.g && isNaN( tempClr.g ) ) tempClr.g = 0;
                    if ( tempClr.b && isNaN( tempClr.b ) ) tempClr.b = 0;
                    if ( tempClr.a && isNaN( tempClr.a ) ) tempClr.a = 0;
                    color = vwfColor.call( this, tempClr );
                    value = color.toString();
                }
                break;
            
            default:
                value = undefined;
                break;

        }
        return value;

    }

    // -- getParticleSystemProperty ------------------------------------------------------------------------------

    function getParticleSystemProperty( nodeID, propertyName, propertyValue ) {

        var value = undefined;
        var obj, color;
        var node = this.state.nodes[nodeID];
        if ( node && node.glgeObject ) {
            var ps = node.glgeObject;
            switch ( propertyName ) {
                case "numberParticles":
                    if ( ps.getNumParticles )
                        value = ps.getNumParticles();
                    break;
                case "maxLifeTime":
                    if ( ps.getMaxLifeTime )
                        value = ps.getMaxLifeTime();
                    break;
                case "minLifeTime":
                    if ( ps.getMinLifeTime )
                    value = ps.getMinLifeTime();
                    break;
                case "startSize":
                    if ( ps.getStartSize )
                        value = ps.getStartSize();
                    break;
                case "endSize":
                    if ( ps.getEndSize )
                        value = ps.getEndSize();
                    break;
                case "loop":
                    if ( ps.getLoop )
                        value = ps.getLoop();
                    break;
                case "maxVelocity":
                    if ( ps.getMaxVelocity ) {
                        obj = ps.getMaxVelocity();    
                        value = [ obj.x, obj.y, obj.z ]; 
                    }
                    break;            
                case "minVelocity":
                    if ( ps.getMinVelocity ) {
                        obj = ps.getMinVelocity();
                        value = [ obj.x, obj.y, obj.z ];
                    }
                    break;    
                case "maxStartAcceleration":
                    if ( ps.getMaxStartAccelertaion ) {
                        obj = ps.getMaxStartAccelertaion();
                        value = [ obj.x, obj.y, obj.z ];
                    }
                    break;
                case "maxEndAcceleration":
                    if ( ps.getMaxEndAccelertaion ) {
                       obj = ps.getMaxEndAccelertaion();
                       value = [ obj.x, obj.y, obj.z ];
                    }
                    break;
                case "minStartAcceleration":
                    if ( ps.getMinStartAccelertaion ) {
                        obj = ps.getMinStartAccelertaion();
                        value = [ obj.x, obj.y, obj.z ];
                    }
                    break;
                case "minEndAcceleration":
                    if ( ps.getMinEndAccelertaion )
                        obj = ps.getMinEndAccelertaion();
                        value = [ obj.x, obj.y, obj.z ]; 
                    break;
                case "startColor":
                    if ( ps.getStartColor ) {
                        color = vwfColor.call( this, ps.getStartColor() );
                        value = color.toString();
                    } else { value = undefined; }
                    break;
                case "endColor":
                    if ( ps.getEndColor ){
                        color = vwfColor.call( this, ps.getEndColor() );
                        value = color.toString();
                    } else { value = undefined; }
                    break;
                case "image":
                    if ( ps.getImage )
                        value = ps.getImage();
                    break;
                default:
                    value = undefined;
                    break;
            }
        }
        return value;

    }

    // -- getObjectProperty ------------------------------------------------------------------------------

    function getObjectProperty( nodeID, propertyName, propertyValue ) {

        var node = this.state.nodes[ nodeID ]; 
        var value = undefined;
        var txtr, mat;

        switch ( propertyName ) {
            case "mesh": {
                    if ( node.glgeObject && node.glgeObject && node.glgeObject.getMesh ) {
                        value = node.glgeObject.getMesh();
                    }
                }
                break;
        }

        return value;
    }

    // -- getMaterialProperty ------------------------------------------------------------------------------

    function getMaterialProperty( nodeID, propertyName, propertyValue ) {
        var node = this.state.nodes[ nodeID ]; 
        var value = undefined;
        var txtr, mat, obj, color;

        if ( node.glgeMaterial && node.glgeMaterial.textures ) {
            mat = node.glgeMaterial;
            txtr = node.glgeMaterial.textures[0];
        } else if ( node.glgeObject && node.glgeObject.material ) {
            mat = node.glgeObject.material; 
            txtr = node.glgeObject.material.textures[0];
        }   

        switch ( propertyName ) {
            case "texture": 
                if ( txtr ) {
                    if ( txtr instanceof GLGE.TextureCanvas ) {
                        var cv = txtr.getCanvas();
                        value = "canvas";
                        if ( cv ) {
                            value = cv.getAttribute( 'id' );
                        }  
                    } else if ( txtr instanceof GLGE.TextureCamera ) {
                        var cam = txtr.getCamera();
                        if ( cam === this.state.cameraInUse ) {
                            value = "activeCamera"; 
                        } else {
                            value = getObjectID.call( this, cam, false, false );
                        }
                    } else {
                        if ( txtr.getSrc ) {
                            value = txtr.getSrc();
                        }
                    }
                }
                break;

            case "color":
                if ( mat ) { 
                    color = vwfColor.call( this, mat.getColor() );
                    value = color.toString();
                } else { value = undefined; }
                break;
                
            case "ambient":
                if ( mat ) { 
                    color = vwfColor.call( this, mat.getAmbient() );
                    value = color.toString();               
                } else { value = undefined; }
                break;
            case "specColor":
                if ( mat ) { 
                    color = vwfColor.call( this, mat.getSpecularColor() );
                    value = color.toString();  
                } else { value = undefined; }
                break;
            case "shininess":
                if ( mat ) { value = mat.getShininess(); } 
                break;  
            case "reflect":
                if ( mat ) { value = mat.getReflectivity(); } 
                break;
            case "specular":
                if ( mat ) { value = mat.getSpecular(); } 
                break;
            case "emit":
                if ( mat ) { value = mat.getEmit(); } 
                break; 
            case "alpha":
                if ( mat ) { value = mat.getAlpha(); } 
                break;                    
            case "binaryAlpha":
                if ( mat ) { value = mat.getBinaryAlpha(); } 
                break;  
        }

        return value;
    }

    // -- getLightProperty ------------------------------------------------------------------------------

    function getLightProperty( nodeID, propertyName, propertyValue ) {

        var value = undefined;
        var node = this.state.nodes[ nodeID ];
        var temp, color;

        switch( propertyName ) {

            case "lightType":
                switch ( node.glgeObject.getType() ) {
                    case GLGE.L_POINT:
                        value = "point";
                        break;
                    case GLGE.L_DIR:
                        value = "directional";
                        break;
                    case GLGE.L_SPOT:
                        value = "spot";
                        break;
                }
                break;

            case "glge-constantAttenuation":
                temp = node.glgeObject.getAttenuation();
                value = temp.constant;
                break;

            case "glge-linearAttenuation":
                temp = node.glgeObject.getAttenuation();
                value = temp.linear;
                break;

            case "glge-quadraticAttenuation":
                temp = node.glgeObject.getAttenuation();
                value = temp.quadratic;
                break;

            case "glge-spotCosCutOff":
                value = node.glgeObject.getSpotCosCutOff();
                break;

            case "glge-spotCutOff":
                node.glgeObject.getSpotCutOff( propertyValue );
                break;

            case "spotExponent":
                value = node.glgeObject.getSpotExponent();
                break;

            case "color":
                color = vwfColor.call( this, node.glgeObject.getColor() );
                value = color.toString();  
                break;

            case "diffuse":
                value = node.glgeObject.diffuse; // no getDiffuse() in GLGE 0.7
                break;

            case "glge-specular":
                value = node.glgeObject.specular; // no getSpecular() in GLGE 0.7
                break;

            case "glge-samples":
                value = node.glgeObject.getShadowSamples();
                break;

            case "glge-softness":
                value = node.glgeObject.getShadowSoftness();
                break;

            case "glge-bufferHeight":
                value = node.glgeObject.getBufferHeight();
                break;

            case "glge-bufferWidth":
                value = node.glgeObject.getBufferWidth();
                break;

            case "glge-shadowBias":
                value = node.glgeObject.getShadowBias();
                break;

            case "distance":
                value = node.glgeObject.getDistance();
                break;

            case "castShadows":
                value = node.glgeObject.getCastShadows();
                break;

            case "glge-spotSoftness":
                value = node.glgeObject.getSpotSoftness();
                break;
                
            case "glge-spotSoftnessDistance":
                value = node.glgeObject.getSpotSoftDistance();
                break;                

            case "glge-cascadeLevels":
                value = node.glgeObject.getCascadeLevels();
                break;

            default:
                value = undefined;
                break;
        }
        return value;    
    
    }

    // -- getCameraProperty ------------------------------------------------------------------------------

    function getCameraProperty(nodeID, propertyName, propertyValue) {

        var node = this.state.nodes[nodeID];
        var value = undefined;
        switch( propertyName ) {
            case "cameraType":
                switch ( node.glgeObject.getType() ) {
                    case GLGE.C_PERSPECTIVE:
                        value = "perspective";
                        break;
                    case GLGE.C_ORTHO:
                        value = "orthographic";
                        break;
                }
                break;
            case "far":
                value = node.glgeObject.getFar();
                break;
            case "near":
                value = node.glgeObject.getNear();
                break;
            case "fovy":
                value = node.glgeObject.getFovY();
                break;            
            case "aspect":
                value = node.glgeObject.getAspect();
                break;            
            case "orthoscale":
                value = node.glgeObject.getOrthoScale();
                break;
            default:
                value = undefined;
                break;
        }
        return value;

    }

    // -- findGlgeObject ------------------------------------------------------------------------------

    function findGlgeObject( objName, type, prototypes ) {

        var obj = undefined;
        var assetObj = undefined;
        var glgeObjName = "";

        for ( var key in GLGE.Assets.assets ) {
            assetObj = GLGE.Assets.assets[key];
            if ( assetObj ) {
                glgeObjName = name( assetObj );
                if ( glgeObjName == objName ) {
                    switch ( type ) {
                        case "http://vwf.example.com/mesh.vwf":
                            if ( assetObj.constructor == GLGE.Object )
                                obj = assetObj;
                            break;
                        case "http://vwf.example.com/node3.vwf":
                            if ( ( assetObj.constructor == GLGE.Group ) || ( assetObj.constructor == GLGE.Object ) )
                                obj = assetObj;
                            break;
                        case "http://vwf.example.com/light.vwf":
                            if ( assetObj.constructor == GLGE.Light )
                                obj = assetObj;
                            break;
                        case "http://vwf.example.com/camera.vwf":
                            if ( assetObj.constructor == GLGE.Camera )
                                obj = assetObj;
                            break;
                        case "http://vwf.example.com/scene.vwf":
                            if ( assetObj.constructor == GLGE.Scene )
                                obj = assetObj;
                            break;
                        case "http://vwf.example.com/particleSystem.vwf":
                            if ( assetObj.constructor == GLGE.ParticleSystem )
                                obj = assetObj;
                            break;
                    }
                    if ( obj ) break;
                }
            }
        }

        return obj;

    }

    // -- setActiveCamera ------------------------------------------------------------------------------

    function setActiveCamera( sceneNode, nodeID ) {

        if ( this.state.nodes[ nodeID ] ) {
            var glgeCamera = this.state.nodes[ nodeID ].glgeObject;
            if ( glgeCamera ) {
                setAspect.call( this, nodeID );
                this.state.cameraInUse = glgeCamera;
                sceneNode.glgeScene.setCamera( glgeCamera );
            }
        }

    }

    // -- setAspect ------------------------------------------------------------------------------

    function setAspect( nodeID ) {

        if ( this.state.nodes[ nodeID ] ) {
            var glgeCamera = this.state.nodes[ nodeID ].glgeObject;
            if ( glgeCamera ) {
                var canvas = document.getElementById( this.state.sceneRootID );
                glgeCamera.setAspect( canvas.width / canvas.height );
            }
        }
    }


    // -- createLight ------------------------------------------------------------------------------

    function createLight( nodeID, childID, childName ) {

        var child = this.state.nodes[childID];
        if ( child ) {
            child.glgeObject = new GLGE.Light();
            child.glgeObject.name = childName;
            child.name = childName;
            child.uid = child.glgeObject.uid;
            addGlgeChild.call( this, nodeID, childID );
        } 
               
    }

   // -- createCamera ------------------------------------------------------------------------------

    function createCamera( nodeID, childID, childName ) {

        var sceneNode = this.state.scenes[nodeID]
        var parent = sceneNode ? sceneNode : this.state.nodes[nodeID]
        if ( !sceneNode ) sceneNode = parent.glgeScene;
        if ( sceneNode && parent ) {
            var child = this.state.nodes[childID];
            if ( child ) {
                var cam = new GLGE.Camera();;
                initCamera.call( this, cam );
                var glgeParent = parent.glgeObject;
                if ( glgeParent && ( glgeParent instanceof GLGE.Scene || glgeParent instanceof GLGE.Group )) {
                    glgeParent.addObject( cam );
                }

                child.name = childName;
                child.glgeObject = cam;
                child.uid = child.glgeObject.uid;
                cam.name = childName;
            }
        }  

    }

   // -- createParticleSystem ------------------------------------------------------------------------------

    function createParticleSystem( nodeID, childID, childName ) {
        var glgeParent = undefined;
        var parentNode = this.state.nodes[ nodeID ];
        if ( parentNode && parentNode.glgeObject && parentNode.glgeObject.getChildren ) {
            glgeParent = parentNode.glgeObject;   
        }
        if ( !glgeParent ) {
            parentNode = this.state.scenes[ this.state.sceneRootID ];
            glgeParent = parentNode.glgeScene; 
        }
        if ( glgeParent ) {
            var ps = new GLGE.ParticleSystem();
            this.state.nodes[ childID ].glgeObject = ps; 
            glgeParent.addObject( ps );
        }
    }

   // -- initCamera ------------------------------------------------------------------------------

    function initCamera( glgeCamera ) {

        if ( glgeCamera ) {
            glgeCamera.setLoc( 0, 0, 0 );
            glgeCamera.setRot( Math.PI/2, 0, 0 ); // rotate to look at +Y, VWF's default orientation
            glgeCamera.setType( GLGE.C_PERSPECTIVE );
            glgeCamera.setRotOrder( GLGE.ROT_XZY );
        }
                
    }

   // -- getLocalBoundingBox ------------------------------------------------------------------------------

    function getLocalBoundingBox( glgeObject ) {

        var bBox = { xMin: Number.MAX_VALUE, xMax: -Number.MAX_VALUE,
                     yMin: Number.MAX_VALUE, yMax: -Number.MAX_VALUE,
                     zMin: Number.MAX_VALUE, zMax: -Number.MAX_VALUE };

        var glgeObjectList = [];
        findAllGlgeObjects.call( this, glgeObject, glgeObjectList );

        for ( var j = 0; j < glgeObjectList.length; j++ ) {
            var vertices = getMeshVertices.call( this, glgeObjectList[j] );
            for ( var i = 0; i < vertices.length; i++ ) {
                if ( vertices[i][0] < bBox.xMin )
                    bBox.xMin = vertices[i][0];
                if ( vertices[i][0] > bBox.xMax )
                    bBox.xMax = vertices[i][0];
                if ( vertices[i][1] < bBox.yMin )
                    bBox.yMin = vertices[i][1];
                if ( vertices[i][1] > bBox.yMax )
                    bBox.yMax = vertices[i][1];
                if ( vertices[i][2] < bBox.zMin )
                    bBox.zMin = vertices[i][2];
                if ( vertices[i][2] > bBox.zMax )
                    bBox.zMax = vertices[i][2];
            }
        }

        return bBox; 
           
    }

   // -- getCenterOffset ------------------------------------------------------------------------------

    function getCenterOffset( glgeObject ) {

        var offset = [ 0, 0, 0 ];
        if ( glgeObject ) {
            var bBox = getLocalBoundingBox.call( this, glgeObject )
            offset[0] = ( bBox.xMax + bBox.xMin ) * 0.50;
            offset[1] = ( bBox.yMax + bBox.yMin ) * 0.50;
            offset[2] = ( bBox.zMax + bBox.zMin ) * 0.50;
        }
        return offset;

    }

   // -- getNodeVertices ------------------------------------------------------------------------------

    function getNodeVertices( nodeID ) {

        if ( this.state.nodes[nodeID] ) {
            return getMeshVertices.call( this, this.state.nodes[nodeID] );
        }
        return undefined;

    }

   // -- getMeshVertices ------------------------------------------------------------------------------

    function getMeshVertices( glgeObject ) {

        var vertices = [];
        var glgeMesh;
        if ( glgeObject ) {
            if ( glgeObject.getChildren && !glgeObject.getMesh ) {
                var objects = []; 
                findAllGlgeObjects.call( this, glgeObject, objects );
                for ( var j = 0; j < objects.length; j++ ) {
                    if ( objects[j].getMesh ) {
                        var pos = objects[j].getMesh().positions;
                        if ( pos ) {
                            for ( var i = 0; i < pos.length; i = i + 3 ) {
                                vertices.push([pos[i], pos[i + 1], pos[i + 2]]);
                            }
                        }
                    }                    
                }
            } else if ( glgeObject.getMesh && glgeObject.getMesh() ) {
                glgeMesh = glgeObject.getMesh();
            } else if ( glgeObject.constructor == GLGE.Mesh ) {
                glgeMesh = glgeObject;
            }

            if ( glgeMesh ) {
                var pos = glgeMesh.positions;
                if ( pos ) {
                    for ( var i = 0; i < pos.length; i = i + 3 ) {
                        vertices.push( [pos[i], pos[i + 1], pos[i + 2]] );
                    }
                }            
            }
        }    
        return vertices;

    }

   // -- getNodeVertexIndices ------------------------------------------------------------------------------

    function getNodeVertexIndices( nodeID ) {

        if ( this.state.nodes[nodeID] ) {
            return getMeshVertexIndices.call( this, this.state.nodes[nodeID] );
        }
        return undefined;

    }

   // -- findAllGlgeObjects ------------------------------------------------------------------------------

    function findAllGlgeObjects( glgeNode, objList ) {

        if ( glgeNode ) {
            if ( glgeNode.constructor == GLGE.Object )
                objList.push( glgeNode );

            if ( glgeNode.getChildren ) {
                var nodeChildren = glgeNode.getChildren();
                for (var i = 0; i < nodeChildren.length; i++) {
                    findAllGlgeObjects.call( this, nodeChildren[i], objList );
                }
            }
        }

    }

   // -- findAllMeshes ------------------------------------------------------------------------------

    function findAllMeshes( glgeNode ) {

        var meshes = [];
        var objs = [];
        findAllGlgeObjects.call( this, glgeNode, objs );
        for ( var i = 0; i < objs.length; i++ ){
            if ( objs[i].getMesh && objs[i].getMesh() ) {
                meshes.push( objs[i].getMesh() );
            }       
        }
        return meshes;

    }

   // -- getGlgeObject ------------------------------------------------------------------------------

    function getGlgeObject( id ) {
        var glgeObj = undefined;
        var node = this.state.nodes[ id ];
        if ( !node && this.state.scenes[ id ] ) {
            node = this.state.scenes[ id ];
        }
        if ( node ) {
            glgeObj = node.glgeObject;
            if ( !glgeObj && node.glgeScene ) {
                glgeObj = node.glgeScene;
            }
        }
        return glgeObj;
    }

   // -- getObjectID ------------------------------------------------------------------------------

    function getObjectID( objectToLookFor, bubbleUp, debug ) {

        var objectIDFound = -1;
            
        while (objectIDFound == -1 && objectToLookFor) {
            if ( debug ) {
                this.logger.info("====>>>  vwf.model-glge.mousePick: searching for: " + path(objectToLookFor) );
            }
            jQuery.each( this.state.nodes, function (nodeID, node) {
                if ( node.glgeObject == objectToLookFor && !node.glgeMaterial ) {
                    if ( debug ) { this.logger.info("pick object name: " + name(objectToLookFor) + " with id = " + nodeID ); }
                    objectIDFound = nodeID;
                }
            });
            if ( bubbleUp ) {
                objectToLookFor = objectToLookFor.parent;
            } else {
                objectToLookFor = undefined;
            }
        }
        if (objectIDFound != -1)
            return objectIDFound;

        return undefined;
    }

    function nameGlge(obj) {
        return obj.colladaName || obj.colladaId || obj.name || obj.id || obj.uid || "";
    }

    function name(obj) {
        return obj.colladaName || obj.colladaId || obj.name || obj.id || "";
    }

    function path(obj) {
        var sOut = "";
        var sName = "";

        while (obj && obj.parent) {
            if (sOut == "")
                sOut = name(obj);
            else
                sOut = name(obj) + "." + sOut;
            obj = obj.parent;
        }
        return sOut;
    }

    function vwfColor( color ) {
        var vwfColor = {};
        vwfColor['r'] = color['r']*255;
        vwfColor['g'] = color['g']*255;
        vwfColor['b'] = color['b']*255;                                
        if ( color['a'] !== undefined && color['a'] != 1 ) {
            vwfColor['a'] = color['a'];
            vwfColor = new utility.color( "rgba("+vwfColor['r']+","+vwfColor['g']+","+vwfColor['b']+","+vwfColor['a']+")" );
        } else {
            vwfColor = new utility.color( "rgb("+vwfColor['r']+","+vwfColor['g']+","+vwfColor['b']+")" );
        }
        return vwfColor;        
    }

    function getMeshVertexIndices( glgeObject ) {
        var vertexIndices = [];
        var mesh;
        if ( glgeObject ) {
            if ( glgeObject.getMesh && glgeObject.getMesh() ) {
                mesh = glgeObject.getMesh();
            } else if ( glgeObject.constructor == GLGE.Mesh ) {
                mesh = glgeObject;
            }

            if ( mesh && mesh.faces ) {
                var faces = mesh.faces.data;
                if ( faces ) {
                    for (var i = 0; i < faces.length; i = i + 3) {
                        vertexIndices.push( [faces[i], faces[i + 1], faces[i + 2]] );
                    }
                }
            }
        }

        return vertexIndices;
    }

    // get the list of types this ID extends

    function getPrototypes( kernel, extendsID ) {
        var prototypes = [];
        var id = extendsID;

        while ( id !== undefined ) {
            prototypes.push( id );
            id = kernel.prototype( id );
        }
                
        return prototypes;
    }

    function isPrototype( nodeID, childID ) {
        var ptID;
        if ( ( nodeID == 0 && childID != this.kernel.application() ) || this.state.prototypes[ nodeID ] !== undefined ) {
            if ( nodeID != 0 || childID != this.kernel.application() ) {
                ptID = nodeID ? nodeID : childID;
                if ( this.state.prototypes[ ptID ] !== undefined ) {
                    ptID = childID;
                }
                return ptID;
            } 
        }
        return undefined;
    }


    function isGlgeSceneDefinition( prototypes ) {
        var foundGlge = false;
        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundGlge; i++ ) {
                foundGlge = ( prototypes[i] == "http://vwf.example.com/navscene.vwf" || prototypes[i] == "http://vwf.example.com/scene.vwf" );
            }
        }

        return foundGlge;
    }

    function isGlgeNodeDefinition( prototypes ) {
        var foundGlge = false;
        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundGlge; i++ ) {
                foundGlge = ( prototypes[i] == "http://vwf.example.com/node3.vwf" );
            }
        }

        return foundGlge;
    }

    function isGlgeCameraDefinition( prototypes ) {
        var foundGlge = false;
        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundGlge; i++ ) {
                foundGlge = ( prototypes[i] == "http://vwf.example.com/camera.vwf" );
            }
        }

        return foundGlge;
    }

    function isGlgeLightDefinition( prototypes ) {
        var foundGlge = false;
        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundGlge; i++ ) {
                foundGlge = ( prototypes[i] == "http://vwf.example.com/light.vwf" );
            }
        }

        return foundGlge;
    }

    function isGlgeParticleSystemDefinition( prototypes ) {
        var foundGlge = false;
        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundGlge; i++ ) {
                foundGlge = ( prototypes[i] == "http://vwf.example.com/particlesystem.vwf" );
            }
        }

        return foundGlge;
    }

    function isGlgeMaterialDefinition( prototypes ) {
        var foundGlge = false;
        if ( prototypes ) {
            for ( var i = 0; i < prototypes.length && !foundGlge; i++ ) {
                foundGlge = ( prototypes[i] == "http://vwf.example.com/material.vwf" );
            }
        }

        return foundGlge;
    }
    // Search a GLGE.Scene for a child with the given name.

    function glgeSceneChild(glgeScene, childName) {

        var childToReturn = jQuery.grep(glgeScene.children || [], function (glgeChild) {
            return (glgeChild.name || glgeChild.id || glgeChild.sourceURL || "") == childName;
        }).shift();

        //this.logger.info("      glgeSceneChild( " + childName + " ) returns " + childToReturn);
        return childToReturn;

    }

    // Search a GLGE.Object, GLGE.Collada, GLGE.Light for a child with the given name.  TODO: really, it's anything with children[]; could be the same as glgeSceneChild().

    function glgeObjectChild( glgeObject, childName, childType, prototypes, recursive ) {
        
        var childToReturn = jQuery.grep( glgeObject.children || [], function ( glgeChild ) {
            return (glgeChild.colladaName || glgeChild.colladaId || glgeChild.name || glgeChild.id || "") == childName;
        }).shift();

        // to slow, and may bind to the incorrect object
        if ( recursive && childToReturn === undefined ) {
            if ( glgeObject.children ) {
            for ( var i = 0; i < glgeObject.children.length && childToReturn === undefined; i++ )
                childToReturn = glgeObjectChild.call( this, glgeObject.children[i], childName, childType, prototypes, recursive );
            }
        }
        return childToReturn;

    }

    function findMaterial( parentID, materialName, materialNode ) {

        var materialStringIndex, materialIndex;
        var parentNode = this.state.nodes[ parentID ];

        // the material name is a combination of the following information
        // groupParentName + 'Material' + indexOfTheMultiMaterial

        if ( parentNode ) {
            if ( parentNode.glgeObject ) {
                if ( parentNode.glgeObject.constructor == GLGE.Object ) {
                    if ( materialName == "material" ) {
                        materialNode.glgeObject = parentNode.glgeObject;
                        materialNode.glgeMaterial = materialNode.glgeObject.getMaterial();
                    }
                } else {
                    var index = materialName.substr( 8 );
                    var glgeObjs = [];
                    if ( index == "" ) index = 0;

                    findAllGlgeObjects.call( this, parentNode.glgeObject, glgeObjs );

                    for ( var i = 1; i < glgeObjs.length; i++ ) {
                        console.info( "WARNING:  passing other materials .......harding to index to 0 " );
                    }

                    if ( glgeObjs && glgeObjs.length && index < glgeObjs.length ) {
                        materialNode.glgeObject = glgeObjs[index];
                        materialNode.glgeMaterial = glgeObjs[index].getMaterial();
                    }
                }
            }
        }

    }

    function findMesh( parentID, meshName, meshNode ) {

        var materialStringIndex, materialIndex, childName;
        var parentNode = this.state.nodes[ parentID ];

        // the material name is a combination of the following information
        // groupParentName + 'Material' + indexOfTheMultiMaterial

        if ( parentNode ) {
            materialStringIndex = materialName.lastIndexOf( "Material" );
            materialIndex = Number( materialName.substr( materialStringIndex + 8 ) ) - 1;
            childName = materialName.substr( 0, materialStringIndex );

            if ( parentNode.glgeObject ) {
                var glgeObjs = [];
                var found = false;

                findAllGlgeObjects.call( this, parentNode.glgeObject, glgeObjs );

                if ( glgeObjs && glgeObjs.length ) {
                    for ( var i = 0; i < glgeObjs.length && !found; i++ ) {
                        if ( name( glgeObjs[i].parent ) == childName ) {
                            materialNode.glgeObject = glgeObjs[i];
                            materialNode.glgeMaterial = glgeObjs[i].getMaterial( materialIndex );
                            found = true;                        
                        }                   
                    }
                } else if ( parentNode.glgeObject.children.length == 1 && parentNode.glgeObject.children[0].constructor == GLGE.Object ) {

                    var glgeChild = parentNode.glgeObject.children[0];
                    materialNode.glgeObject = glgeChild;
                    materialNode.glgeMaterial = glgeChild.getMaterial( materialIndex );
                
                    if ( !( materialNode.glgeMaterial ) && ( childNode.glgeObject ) ) {
                        materialNode.glgeMaterial = childNode.glgeObject.getMaterial();
                    }
                }
            }
        }

    }

    function createMesh( node ) {
        if ( !node.glgeParent ) {
            node.glgeParent = this.state.nodes[ node.parentID ];    
        }
        
        if ( node.glgeParent ) {
            node.glgeObject = new GLGE.Group();
            node.glgeParent.addObject( node.glgeObject );
            var obj = new GLGE.Object();
            obj.setMaterial( new GLGE.Material() );
            obj.setMesh( new GLGE.Mesh() );
            node.glgeObject.addObject( obj );
        }        
    }

    function defineMesh( def, node ) {
        if ( node.glgeObject ) {
            var obj = new GLGE.Object();
            var mat = new GLGE.Material();
            var mesh = new GLGE.Mesh();

            if ( def.color ) {
                mat.setColor( def.color );
            }
            obj.setMaterial( mat );

            if ( def.positions )
                mesh.setPositions( def.positions );
            if ( def.normals )
                mesh.setNormals( def.normals );
            if ( def.uv1 )
                mesh.setUV( def.uv1 );
            if ( def.faces )
                mesh.setFaces( def.faces );

            obj.setMesh( mesh );
            node.glgeObject.addObject( obj );
        }        
    }
			
	function BuildBox(size,offset,color)
	{
		
		var hx = size[0]/2;
		var hy = size[1]/2;
		var hz = size[2]/2;
		
		var ox = offset[0];
		var oy = offset[1];
		var oz = offset[2];
		
		var planemesh = new GLGE.Mesh();
		var planeobj = new GLGE.Object();
		planeobj.setMesh(planemesh);
		
		var positions = [
		hx + ox,hy + oy,hz + oz, 
		hx + ox,hy + oy,-hz + oz, 
		hx + ox,-hy + oy,hz + oz, 
		hx + ox,-hy + oy,-hz + oz,
		-hx + ox,hy + oy,hz + oz,
		-hx + ox,hy + oy,-hz + oz, 
		-hx + ox,-hy + oy,hz + oz, 
		-hx + ox,-hy + oy,-hz + oz
		];
		
		var colors = [];
		for(var i = 0; i < (positions.length/3); i++)
		{	colors.push(color[0]);
			colors.push(color[1]);
			colors.push(color[2]);
			colors.push(color[3]);
		}
		
		var indexes = [0,2,6,6,4,0,1,3,7,7,5,1,0,1,3,3,2,0,4,5,7,7,6,4,0,1,5,5,4,0,2,3,7,7,6,2];
		
		planemesh.setPositions(positions);
		planemesh.setVertexColors(colors);
		planemesh.setFaces(indexes);
		
		var mat = new GLGE.Material();
		
		planeobj.setPickable(true);
		planeobj.setMaterial(mat);
		mat.setVertexColorMode(GLGE.VC_MUL);
		//mat.setColor(color);
		//mat.setEmit(color);
		//mat.setShadeless(true);
		//mat.setAmbient([.5,.5,.5,1]);
		return planeobj;
	}
	function BuildAxis()
	{	
		var red = [1,.55,.55,1];
		var green = [.55,1,.55,1];
		var blue = [.55,.55,1,1];
		
		var MoveGizmo = new GLGE.Group();
		MoveGizmo.addChild(BuildBox([1,.030,.030],[.5,0,0],red));               //move x
		MoveGizmo.addChild(BuildBox([.030,1,.030],[0,.5,0],green));//move y
		MoveGizmo.addChild(BuildBox([.030,.030,1],[0,0,.5],blue));//move z
		return MoveGizmo;
	}
    function addGlgeChild( parentID, childID ) {
        
        var glgeParent;
        var parent = this.state.nodes[ parentID ];
        if ( !parent && this.state.scenes[ parentID ] ) {
            parent = this.state.scenes[ parentID ];
            glgeParent = parent.glgeScene;
        } else {
            glgeParent = parent.glgeObject;
        }
            
        if ( glgeParent && this.state.nodes[ childID ]) {
            var child = this.state.nodes[ childID ];

            if ( child.glgeObject ) {
                glgeParent.addChild( child.glgeObject );
            }
        }
    }

    function isMovieFileRef( fileName ) {
        var isMovieFile = false;
        if ( fileName && fileName != "" ){
            var fileSplit = fileName.split( "." );
            var fileSLen = fileSplit ? fileSplit.length : 0;
            if ( fileSLen > 0 ) {
                switch ( fileSplit[ fileSLen-1 ] ) {
                    case "ogv":
                        isMovieFile = true;
                        break;
                }
            }             
        }
        return isMovieFile;
    }

    function isImageFileRef( fileName ) {
        var isImageFile = false;
        if ( fileName && fileName != "" ){
            var fileSplit = fileName.split( "." );
            var fileSLen = fileSplit ? fileSplit.length : 0;
            if ( fileSLen > 0 ) {
                switch ( fileSplit[ fileSLen-1 ] ) {
                    case "png":
                    case "jpeg":
                    case "bmp":
                    case "gif":
                    case "tif":
                    case "tiff":
                    case "jpg":
                    case "tga":
                        isImageFile = true;
                        break;
                }
            }             
        }
        return isImageFile;
    }
    function isVideoFileRef( fileName ) {
        var isVideoFile = false;
        if ( fileName && fileName != "" ){
            var fileSplit = fileName.split( "." );
            var fileSLen = fileSplit ? fileSplit.length : 0;
            if ( fileSLen > 0 ) {
                switch ( fileSplit[ fileSLen-1 ] ) {
                    case "ogg":
                    case "mjeg":
                    case "mpeg1":
                    case "mpeg":
                    case "avi":
                    case "mpg":
                    case "mp2":
                    case "m1v":
                        isVideoFile = true;
                        break;
                }
            }             
        }
        return isVideoFile;
    }  

    function findCamera( camNode ) {
        var cam = undefined;
        if ( camNode ) {
            if ( camNode.glgeObject && camNode.glgeObject instanceof GLGE.Camera ){
                cam = camNode.glgeObject;
            } else if ( camNode.glgeObject instanceof GLGE.Group ) {
                cam = new GLGE.Camera();
                camNode.glgeObject.addObject( cam );
            }
        }
        return cam;  
    }

} );