"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.
function rebuildAllMaterials( obj )
{
if( obj === undefined )
{
for(var i in this.state.scenes)
{
rebuildAllMaterials.call( this, this.state.scenes[i].threeScene );
}
} else {
if(obj && obj.material)
{
obj.material.needsUpdate = true;
}
if(obj && obj.children)
{
for(var i in obj.children)
rebuildAllMaterials.call( this, obj.children[i] );
}
}
}
function matCpy( mat )
{
var ret = [];
for ( var i =0; i < mat.length; i++ )
ret.push( mat[i] );
// I don't think there is any reason we need to copy the return array
return ret;
// return ret.slice(0);
}
define( [ "module",
"vwf/model",
"vwf/utility",
"vwf/utility/color",
"jquery"
],
function( module, model, utility, Color, $ ) {
var self;
var checkLights = true;
var sceneCreated = false;
return model.load( module, {
// == Module Definition ====================================================================
// -- initialize ---------------------------------------------------------------------------
initialize: function() {
self = this;
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.kernel.kernel;
this.state.lights = {};
this.state.setMeshPropertyRecursively = function( threeObject, propertyName, value ) {
if ( !threeObject ) {
return;
}
threeObject[ propertyName ] = value;
var meshes = findAllMeshes( threeObject );
for ( var i = 0; i < meshes.length; i++ ) {
meshes[ i ][ propertyName ] = value;
}
}
this.state.setGeometryPropertyRecursively = function( threeObject, propertyName, value ) {
if ( !threeObject ) {
return;
}
threeObject[ propertyName ] = value;
var geoList = findAllGeometries( threeObject );
for ( var i = 0; i < geoList.length; i++ ) {
geoList[ i ][ propertyName ] = value;
}
}
// turns on logger debugger console messages
this.debug = {
"creation": false,
"initializing": false,
"parenting": false,
"deleting": false,
"properties": false,
"setting": false,
"getting": false,
"prototypes": false
};
},
// == Model API ============================================================================
// -- creatingNode ------------------------------------------------------------------------
creatingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
childSource, childType, childIndex, childName, callback ) {
self = this;
// If the parent nodeID is 0, this node is attached directly to the root and is therefore either
// the scene or a prototype. In either of those cases, save the uri of the new node
var childURI = ( nodeID === 0 ? childIndex : undefined );
var appID = this.kernel.application();
if ( this.debug.creation ) {
this.logger.infox( "creatingNode", nodeID, childID, childExtendsID, childImplementsIDs, childSource, childType, childName );
}
// If the node being created is a prototype, construct it and add it to the array of prototypes,
// and then return
var prototypeID = utility.ifPrototypeGetId( appID, this.state.prototypes, nodeID, childID );
if ( prototypeID !== undefined ) {
if ( this.debug.prototypes ) {
this.logger.infox( "prototype: ", prototypeID );
}
this.state.prototypes[ prototypeID ] = {
parentID: nodeID,
ID: childID,
extendsID: childExtendsID,
implementsID: childImplementsIDs,
source: childSource,
type: childType,
uri: childURI,
name: childName,
};
return;
}
var node = undefined;
var parentNode;
var threeChild;
var threeParent;
var waiting = false;
if ( nodeID )
{
parentNode = this.state.nodes[ nodeID ];
// If parent is not a node, see if it is a scene
if ( !parentNode )
parentNode = this.state.scenes[ nodeID ];
if ( parentNode )
{
threeParent = parentNode.threeObject ? parentNode.threeObject : parentNode.threeScene;
if ( threeParent && childName )
{
threeChild = FindChildByName.call( this,threeParent,childName,childExtendsID,false );
}
}
}
var kernel = this.kernel.kernel.kernel;
var protos = getPrototypes.call( this, kernel, childExtendsID );
if ( isSceneDefinition.call(this, protos) && childID == this.kernel.application() )
{
var sceneNode = CreateThreeJSSceneNode( nodeID, childID, childExtendsID );
this.state.scenes[ childID ] = sceneNode;
this.state.cameraInUse = sceneNode.camera.defaultCamera;
sceneCreated = true;
if ( childImplementsIDs && childImplementsIDs.length > 0 ) {
for ( var i = 0; i < childImplementsIDs.length; i++ ) {
switch ( childImplementsIDs[ i ] ) {
case "http://vwf.example.com/threejs/fogExp2.vwf":
sceneNode.threeScene.fog = new THREE.FogExp2( 0x000000 );
break;
case "http://vwf.example.com/threejs/fog.vwf":
sceneNode.threeScene.fog = new THREE.Fog( 0x000000 );
break;
}
}
}
}
if ( protos && isCameraDefinition.call( this, protos ) ) {
var sceneID = this.kernel.application();
var camName = this.kernel.name( childID );
var sceneNode = this.state.scenes[ sceneID ];
node = this.state.nodes[ childID ] = {
name: childName,
threeObject: threeChild,
ID: childID,
parentID: nodeID,
sceneID: this.kernel.application(),
threeScene: sceneNode ? sceneNode.threeScene : undefined,
type: childExtendsID,
sourceType: childType,
prototypes: protos
};
// if there was not a preexisting object, then you have to make a new camera
if ( node.threeObject === undefined ) {
if ( nodeID === sceneID && childName === "camera" ) {
node.threeObject = sceneNode.camera.defaultCamera;
if ( sceneNode.camera.ID !== undefined ) {
sceneNode.camera.ID = childID;
}
} else {
createCamera.call( this, nodeID, childID, childName );
}
}
} else if(protos && isLightDefinition.call( this, protos )) {
node = this.state.nodes[ childID ] = this.state.lights[ childID ] = {
name: childName,
threeObject: threeChild,
ID: childID,
parentID: nodeID,
type: childExtendsID,
sourceType: childType,
};
if ( !node.threeObject ) {
createLight.call( this, nodeID, childID, childExtendsID, childName );
} else {
if ( !( node.threeObject instanceof THREE.Light ) ) {
if ( node.threeObject.children ) {
var child = undefined;
var light = undefined;
for ( var j = 0; light === undefined &&
j < node.threeObject.children.length; j++ ) {
child = node.threeObject.children[ j ];
switch ( childExtendsID ) {
case "http://vwf.example.com/directionallight.vwf":
if ( child instanceof THREE.DirectionalLight ) {
light = child;
}
break;
case "http://vwf.example.com/spotlight.vwf":
if ( child instanceof THREE.SpotLight ) {
light = child;
}
break;
case "http://vwf.example.com/hemispherelight.vwf":
if ( child instanceof THREE.HemisphereLight ) {
light = child;
}
break;
case "http://vwf.example.com/pointlight.vwf":
default:
if ( child instanceof THREE.PointLight ) {
light = child;
}
break;
}
}
if ( light !== undefined ) {
node.threeObject = light;
}
}
}
}
} else if ( protos && isMaterialDefinition.call( this, protos ) ) {
var mat;
var matDef = undefined;
if ( parentNode && parentNode.threeObject ) {
mat = GetMaterial( parentNode.threeObject, childName );
}
node = this.state.nodes[childID] = {
name: childName,
threeObject: mat,
ID: childID,
parentID: nodeID,
type: childExtendsID,
sourceType: childType
};
if ( childType !== undefined ) {
if ( childType !== "material/definition" ) {
// define childType to be one of the material types
// then the uniform properties and be set in the
// uniforms component as a child of this component
matDef = { "type": childType };
}
} else if ( !node.threeObject ) {
matDef = { "type": "MeshPhongMaterial" };
}
if ( matDef !== undefined ) {
node.threeObject = createMaterial( matDef );
if ( node.threeObject ) {
if ( parentNode && parentNode.threeObject ) {
SetMaterial( parentNode.threeObject, node.threeObject, childName );
} else {
console.info( "unable to find: " + nodeID );
}
}
}
} else if ( protos && isShaderMaterialDefinition.call( this, protos ) ) {
node = this.state.nodes[ childID ] = {
name: childName,
//threeObject: GetMaterial( parentNode.threeObject, childName ),
threeObject: undefined,
ID: childID,
parentID: nodeID,
type: childExtendsID,
sourceType: childType
};
if ( childType !== undefined ) {
if ( childType !== "shader/definition" ) {
// define childType to be one of the preexisting shaderTypes
// then the uniform properties and be set in the
// uniforms component as a child of this component
node.threeObject = createMaterial( { "type": 'ShaderMaterial', "shaderType": childType } );
node.shaderType = childType;
}
} else {
node.threeObject = new THREE.ShaderMaterial();
}
if ( node.threeObject ) {
if ( parentNode && parentNode.threeObject ) {
SetMaterial( parentNode.threeObject, node.threeObject, childName );
}
}
} else if ( protos && isShaderUniformsDefinition.call( this, protos ) ) {
var mat = this.state.nodes[ nodeID ];
node = this.state.nodes[ childID ] = {
name: childName,
threeObject: undefined,
ID: childID,
parentID: nodeID,
type: childExtendsID,
sourceType: childType,
isUniformObject: true
};
if ( mat ) {
node.threeObject = mat.threeObject.uniforms;
}
} else if ( protos && isTextureDefinition.call( this, protos ) ) {
var mat = this.state.nodes[ nodeID ];
node = this.state.nodes[ childID ] = {
name: childName,
threeObject: undefined,
ID: childID,
parentID: nodeID,
type: childExtendsID,
sourceType: childType,
isUniformObject: true
};
if ( mat ) {
node.threeObject = mat.threeObject.map;
}
} else if ( protos && isParticleDefinition.call( this, protos ) ) {
node = this.state.nodes[childID] = {
name: childName,
threeObject: threeChild,
ID: childID,
parentID: nodeID,
type: childExtendsID,
sourceType: childType,
};
if(!node.threeObject)
{
CreateParticleSystem.call(this,nodeID,childID,childName);
}
} else if ( protos && isNodeDefinition.call( this, protos ) && childName !== undefined ) {
var sceneNode = this.state.scenes[ this.kernel.application() ];
if ( supportedFileType( childType ) ) {
// Most often this callback is used to suspend the queue until the load is complete
callback( false );
node = this.state.nodes[ childID ] = {
name: childName,
threeObject: threeChild,
source: utility.resolveURI( childSource, this.kernel.uri( childID, true ) ),
ID: childID,
parentID: nodeID,
sourceType: childType,
type: childExtendsID,
// Hang on to the callback and call it again in assetLoaded with ready=true
loadingCallback: callback,
sceneID: this.kernel.application()
};
loadAsset.call( this, parentNode, node, childType, notifyDriverOfPrototypeAndBehaviorProps );
}
else if ( childType == "mesh/definition" ) {
//callback( false );
node = this.state.nodes[ childID ] = {
name: childName,
source: utility.resolveURI( childSource, this.kernel.uri( childID, true ) ),
ID: childID,
parentID: nodeID,
sourceType: childType,
type: childExtendsID,
sceneID: this.kernel.application(),
prototypes: protos,
};
node.threeObject = new THREE.Object3D();
node.threeObject.name = childName;
if ( threeParent !== undefined ) {
threeParent.add( node.threeObject );
}
} else {
node = this.state.nodes[childID] = {
name: childName,
threeObject: threeChild,
source: utility.resolveURI( childSource, this.kernel.uri( childID, true ) ),
ID: childID,
parentID: nodeID,
sourceType: childType,
type: childExtendsID,
//no load callback, maybe don't need this?
//loadingCallback: callback,
sceneID: this.kernel.application(),
prototypes: protos,
};
if( !node.threeObject )
node.threeObject = findThreeObjectInParent.call(this,childName,nodeID);
//The parent three object did not have any childrent with the name matching the nodeID, so make a new group
if( !node.threeObject ) {
// doesn't this object need to be added to the parent node
node.threeObject = new THREE.Object3D();
node.threeObject.name = childName;
if ( threeParent !== undefined ) {
threeParent.add( node.threeObject );
}
}
}
if ( node && node.threeObject )
{
if ( !node.threeObject.vwfID )
node.threeObject.vwfID = childID;
if ( !node.threeObject.name )
node.threeObject.name = childName;
}
}
updateStoredTransform( node );
// 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 ( ! supportedFileType( childType ) ) {
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 GLGE 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 ) ) {
ptPropValue = kernel.getProperty( childExtendsID, propertyName );
if ( ptPropValue !== undefined && ptPropValue !== null && childID !== undefined && childID !== null) {
self.settingProperty( childID, propertyName, ptPropValue );
}
}
} );
childImplementsIDs.forEach( function( behaviorID ) {
for ( var propertyName in kernel.getProperties( behaviorID ) ) {
ptPropValue = kernel.getProperty( behaviorID, propertyName );
if ( ptPropValue !== undefined && ptPropValue !== null && childID !== undefined && childID !== null) {
self.settingProperty( childID, propertyName, ptPropValue );
}
}
} );
};
},
initializingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
childSource, childType, childIndex, childName ) {
var myNode = this.state.nodes[childID];
if ( this.debug.initializing ) {
this.logger.infox( "initializingNode", nodeID, childID, childExtendsID, childImplementsIDs, childSource, childType, childName );
}
if ( myNode && !( myNode.threeObject instanceof THREE.Material ) ) {
generateNodeMaterial.call( this, childID, myNode );//Potential node, need to do node things!
}
},
// -- deletingNode -------------------------------------------------------------------------
deletingNode: function( nodeID ) {
if ( this.debug.deleting ) {
this.logger.infox( "deletingNode", nodeID );
}
if(nodeID)
{
var childNode = this.state.nodes[nodeID];
if(childNode)
{
var threeObject = childNode.threeObject;
if(threeObject && threeObject.parent)
{
threeObject.parent.remove(threeObject);
}
delete this.state.nodes[childNode];
}
}
},
// -- addingChild ------------------------------------------------------------------------
addingChild: function( nodeID, childID, childName ) {
var threeObjParent = getThreeObject.call( this, nodeID );
var threeObjChild = getThreeObject.call( this, childID );
if ( threeObjParent && threeObjChild ) {
if ( threeObjParent instanceof THREE.Object3D ) {
if ( !( threeObjChild instanceof THREE.Material ) ) {
var childParent = threeObjChild.parent;
if ( childParent !== threeObjParent ) {
// what does vwf do here? add only if parent is currently undefined
if ( childParent ) {
childParent.remove( threeObjChild )
}
threeObjParent.add( threeObjChild );
}
} else {
// TODO
// this is adding of a material
}
}
}
},
// -- movingChild ------------------------------------------------------------------------
movingChild: function( nodeID, childID, childName ) {
var threeObjParent = getThreeObject.call( this, nodeID );
var threeObjChild = getThreeObject.call( this, childID );
if ( threeObjParent && threeObjChild && ( threeObjParent instanceof THREE.Object3D ) ){
var childParent = threeObjChild.parent;
// do we only move if there is currently a parent
if ( childParent && ( childParent !== threeObjParent ) ) {
childParent.remove( threeObjChild );
threeObjParent.add( threeObjChild );
}
}
},
// -- removingChild ------------------------------------------------------------------------
removingChild: function( nodeID, childID, childName ) {
var threeObjParent = getThreeObject.call( this, nodeID );
var threeObjChild = getThreeObject.call( this, childID );
if ( threeObjParent && threeObjChild && ( threeObjParent instanceof THREE.Object3D ) ){
var childParent = threeObjChild.parent;
if ( childParent === threeObjParent ) {
childParent.remove( threeObjChild )
}
}
},
// -- creatingProperty ---------------------------------------------------------------------
creatingProperty: function( nodeID, propertyName, propertyValue ) {
if ( this.debug.properties ) {
this.logger.infox( "C === creatingProperty ", nodeID, propertyName, propertyValue );
}
return this.initializingProperty( nodeID, propertyName, propertyValue );
},
// -- initializingProperty -----------------------------------------------------------------
initializingProperty: function( nodeID, propertyName, propertyValue ) {
var value = undefined;
if ( this.debug.properties ) {
this.logger.infox( " I === initializingProperty ", nodeID, propertyName, propertyValue );
}
if ( propertyValue !== undefined ) {
var node = this.state.nodes[ nodeID ];
if ( node === undefined ) node = this.state.scenes[ nodeID ];
if ( node !== undefined ) {
var objectType, objectDef;
switch ( propertyName ) {
case "meshDefinition":
createMesh.call( this, node, propertyValue, true );
value = propertyValue;
break;
case "shaderDefinition":
objectType = propertyValue.type || propertyValue.shaderType || propertyValue;
objectDef = { "type": 'ShaderMaterial', "shaderType": objectType };
if ( propertyValue instanceof Object ) {
for ( var prop in propertyValue ) {
switch ( prop ) {
case "type":
case "shaderType":
break;
default:
objectDef[ prop ] = propertyValue[ prop ];
break;
}
}
}
node.threeObject = createMaterial( objectDef );
value = propertyValue;
if ( node.threeObject ) {
var parentNode = this.state.nodes[ node.parentID ];
if ( parentNode && parentNode.threeObject ) {
SetMaterial( parentNode.threeObject, node.threeObject, node.name );
}
}
break;
case "materialDefinition":
objectType = propertyValue.type || propertyValue;
objectDef = { "type": objectType };
if ( propertyValue instanceof Object ) {
for ( var prop in propertyValue ) {
switch ( prop ) {
case "type":
break;
case "color":
case "specular":
case "emissive":
objectDef[ prop ] = new THREE.Color( propertyValue[ prop ] );
break;
case "shininess":
case "bumpScale":
case "reflectivity":
case "wireframeLinewidth":
case "refractionRatio":
case "opacity":
case "linewidth":
case "scale":
case "dashSize":
case "gapSize":
case "overdraw":
case "alphaTest":
case "polygonOffsetFactor":
case "polygonOffsetUnits":
case "size":
objectDef[ prop ] = parseFloat( propertyValue[ prop ] );
break;
case "map":
case "specularMap":
case "normalMap":
case "alphaMap":
case "bumpMap":
case "lightMap":
objectDef[ prop ] = loadTexture( undefined, propertyValue[ prop ] );
break;
case "envMap":
objectDef[ prop ] = THREE.ImageUtils.loadTextureCube( propertyValue[ prop ] );
break;
case "normalScale":
case "uvOffset":
case "uvScale":
objectDef[ prop ] = new THREE.Vector2( propertyValue[ prop ][ 0 ], propertyValue[ prop ][ 1 ] );
break;
case "wrapRGB":
objectDef[ prop ] = new THREE.Vector3( propertyValue[ prop ][ 0 ], propertyValue[ prop ][ 1 ], propertyValue[ prop ][ 2 ] );
break;
case "wrapAround":
case "metal":
case "fog":
case "skinning":
case "morphTargets":
case "morphNormals":
case "wireframe":
case "depthTest":
case "depthWrite":
case "transparent":
case "polygonOffset":
case "visible":
case "lights":
objectDef[ prop ] = Boolean( propertyValue[ prop ] );
break;
case "vertexColors":
switch ( propertyValue[ prop ] ) {
case "true":
objectDef[ prop ] = true;
break;
case "false":
objectDef[ prop ] = false;
break;
case 1:
case "1":
case "face":
objectDef[ prop ] = THREE.FaceColors;
break;
case 2:
case "2":
case "vertex":
objectDef[ prop ] = THREE.VertexColors;
break;
case 0:
case "0":
case "no":
default:
objectDef[ prop ] = THREE.NoColors;
break;
}
break;
case "blendSrc":
case "blendDst":
switch ( propertyValue[ prop ] ) {
case 200:
case "200":
case "zero":
objectDef[ prop ] = THREE.ZeroFactor;
break;
case 201:
case "201":
case "one":
objectDef[ prop ] = THREE.OneFactor;
break;
case 202:
case "202":
case "srcColor":
objectDef[ prop ] = THREE.SrcColorFactor;
break;
case 203:
case "203":
case "oneMinusSrcColor":
objectDef[ prop ] = THREE.OneMinusSrcColorFactor;
break;
case 204:
case "204":
case "srcAlpha":
objectDef[ prop ] = THREE.SrcAlphaFactor;
break;
case 205:
case "205":
case "oneMinusSrcAlpha":
objectDef[ prop ] = THREE.OneMinusSrcAlphaFactor;
break;
case 206:
case "206":
case "dstAlpha":
objectDef[ prop ] = THREE.DstAlphaFactor;
break;
case 207:
case "207":
case "oneMinusDstAlpha":
objectDef[ prop ] = THREE.OneMinusDstAlphaFactor;
break;
case 208:
case "208":
case "dstColor":
objectDef[ prop ] = THREE.DstColorFactor;
break;
case 209:
case "209":
case "oneMinusDstColor":
objectDef[ prop ] = THREE.OneMinusDstColorFactor;
break;
case 210:
case "210":
case "srcAlphaSaturate":
objectDef[ prop ] = THREE.SrcAlphaSaturateFactor;
break;
}
break;
case "blendEquation":
switch ( propertyValue[ prop ] ) {
case 100:
case "100":
case "add":
objectDef[ prop ] = THREE.AddEquation;
break;
case 101:
case "101":
case "sub":
case "subtract":
objectDef[ prop ] = THREE.SubtractEquation;
break;
case 102:
case "102":
case "revSub":
case "revSubtract":
objectDef[ prop ] = THREE.ReverseSubtractEquation;
break;
case 103:
case "103":
case "min":
objectDef[ prop ] = THREE.MinEquation;
break;
case 104:
case "104":
case "max":
objectDef[ prop ] = THREE.MaxEquation;
break;
}
break;
case "combine":
switch ( propertyValue[ prop ] ) {
case 1:
case "1":
case "mix":
objectDef[ prop ] = THREE.MixOperation;
break;
case 2:
case "2":
case "add":
objectDef[ prop ] = THREE.AddOperation;
break;
case 0:
case "0":
case "mult":
case "multiply":
default:
objectDef[ prop ] = THREE.MultiplyOperation;
break;
}
break;
case "shading":
switch ( propertyValue[ prop ] ) {
case 1:
case "1":
case "flat":
objectDef[ prop ] = THREE.FlatShading;
break;
case 2:
case "2":
case "smooth":
objectDef[ prop ] = THREE.SmoothShading;
break;
case 0:
case "0":
case "no":
default:
objectDef[ prop ] = THREE.NoShading;
break;
}
break;
case "blending":
switch ( propertyValue[ prop ] ) {
case 1:
case "1":
case "normal":
objectDef[ prop ] = THREE.NormalBlending;
break;
case 2:
case "2":
case "add":
case "additive":
objectDef[ prop ] = THREE.AdditiveBlending;
break;
case 3:
case "3":
case "sub":
case "subtractive":
objectDef[ prop ] = THREE.SubtractiveBlending;
break;
case 4:
case "4":
case "mult":
case "multiply":
objectDef[ prop ] = THREE.MultiplyBlending;
break;
case 5:
case "5":
case "custom":
objectDef[ prop ] = THREE.CustomBlending;
break;
case 0:
case "0":
case "no":
default:
objectDef[ prop ] = THREE.NoBlending;
break;
}
break;
case "side":
switch ( propertyValue[ prop ] ) {
case 2:
case "2":
case "double":
objectDef[ prop ] = THREE.DoubleSide;
break;
case 1:
case "1":
case "back":
objectDef[ prop ] = THREE.BackSide;
break;
case 0:
case "0":
case "front":
default:
objectDef[ prop ] = THREE.FrontSide;
break;
}
break;
case "linecap":
case "linejoin":
default:
objectDef[ prop ] = propertyValue[ prop ];
break;
}
}
}
node.threeObject = createMaterial( objectDef );
value = propertyValue;
if ( node.threeObject ) {
var parentNode = this.state.nodes[ node.parentID ];
if ( parentNode && parentNode.threeObject ) {
SetMaterial( parentNode.threeObject, node.threeObject, node.name );
}
}
break;
default:
value = this.settingProperty( nodeID, propertyName, propertyValue );
break;
}
}
}
return value;
},
// -- settingProperty ----------------------------------------------------------------------
settingProperty: function( nodeID, propertyName, propertyValue ) {
if ( this.debug.properties || this.debug.setting ) {
this.logger.infox( " S === settingProperty ", nodeID, propertyName, propertyValue );
}
var node = this.state.nodes[ nodeID ]; // { name: childName, glgeObject: undefined }
if( node === undefined ) node = this.state.scenes[ nodeID ]; // { name: childName, glgeObject: undefined }
var value = undefined;
//this driver has no representation of this node, so there is nothing to do.
if(!node) return;
var parentNode = this.state.nodes[ node.parentID ];
if ( parentNode === undefined ) {
parentNode = this.state.scenes[ node.parentID ];
}
var threeObject = node.threeObject;
if ( !threeObject )
threeObject = node.threeScene;
//There is not three object for this node, so there is nothing this driver can do. return
if(!threeObject) return value;
if ( propertyValue !== undefined )
{
self = this;
if ( threeObject instanceof THREE.Object3D )
{
// Function to make the object continuously look at a position or node
// (for use when setting 'transform' or 'lookAt')
// An almost identical function is copied in view/threejs.js, so if any modifications are made here, they
// should be made there, also
var lookAt = function( lookAtValue ) {
// Function to make the object look at a particular position
// (For use in the following conditional)
var lookAtWorldPosition = function( targetWorldPos ) {
// Get the eye position
var eye = new THREE.Vector3();
var worldTransform = getWorldTransform( node );
eye.setFromMatrixPosition( worldTransform );
var look = new THREE.Vector3();
look.subVectors( targetWorldPos, eye );
if ( look.length() > 0 ) {
look.normalize();
// Set the up vector to be z
var roughlyUp = new THREE.Vector3();
roughlyUp.set( 0, 0, 1 );
var right = new THREE.Vector3();
right.crossVectors( look, roughlyUp );
if ( right.length() == 0 ) {
look.x += 0.0001;
right.crossVectors( look, roughlyUp );
}
right.normalize();
var up = new THREE.Vector3();
up.crossVectors( right, look );
var worldTransformArray = worldTransform.elements;
worldTransformArray[ 0 ] = right.x;
worldTransformArray[ 1 ] = right.y;
worldTransformArray[ 2 ] = right.z;
worldTransformArray[ 4 ] = look.x;
worldTransformArray[ 5 ] = look.y;
worldTransformArray[ 6 ] = look.z;
worldTransformArray[ 8 ] = up.x;
worldTransformArray[ 9 ] = up.y;
worldTransformArray[ 10 ] = up.z;
setWorldTransform( node, worldTransform );
}
}
// The position for the object to look at - to be set in the following conditional
var targetWorldPos = new THREE.Vector3();
//Threejs does not currently support auto tracking the lookat,
//instead, we'll take the position of the node and look at that.
if ( utility.isString( lookAtValue ) ) {
// We use '' to denote that there is no object to look at.
// Therefore, we only care if it is something other than that.
if ( lookAtValue != '' ) {
var lookatNode = self.state.nodes[ lookAtValue ];
if ( lookatNode )
{
node.lookatval = lookAtValue;
var targetWorldTransform = getWorldTransform( lookatNode );
targetWorldPos.setFromMatrixPosition( targetWorldTransform );
lookAtWorldPosition( targetWorldPos );
} else {
self.logger.errorx( "Lookat node does not exist: '" + lookAtValue + "'" );
}
}
} else if ( lookAtValue instanceof Array ) {
node.lookatval = lookAtValue;
targetWorldPos.set( lookAtValue[0], lookAtValue[1], lookAtValue[2] );
lookAtWorldPosition( targetWorldPos );
} else if ( !lookAtValue ) {
node.lookatval = null;
} else {
self.logger.errorx( "Invalid lookat property value: '" + lookAtValue + "'" );
}
return node.lookatval;
}
// Begin handling properties
if ( propertyName == 'transform' && node.transform ) {
//console.info( "setting transform of: " + nodeID + " to " + Array.prototype.slice.call( propertyValue ) );
var transformMatrix = goog.vec.Mat4.createFromArray( propertyValue || [] );
if( threeObject instanceof THREE.PointCloud )
{
threeObject.updateTransform(propertyValue);
}
// Store the value locally
// It must be stored separately from the threeObject so the view can change the
// threeObject's transform to get ahead of the model state without polluting it
node.transform.elements = matCpy( transformMatrix );
value = propertyValue;
//because threejs does not do auto tracking of lookat, we must do it manually.
//after updating the matrix for an ojbect, if it's looking at something, update to lookat from
//the new position
if ( node.lookatval ) {
lookAt( node.lookatval );
}
setTransformsDirty( threeObject );
}
else if ( propertyName == 'lookAt' ) {
value = lookAt( propertyValue );
}
else if ( propertyName == 'visible' )
{
value = Boolean( propertyValue );
// this was the old style of recursively setting visible
// self.state.setMeshPropertyRecursively( threeObject, "visible", value );
SetVisible( threeObject, value );
// SetVisible will only set visible on the children
// that the driver has NOT binding to, bad/good, was the old way better?
}
else if ( propertyName == 'castShadows' )
{
value = Boolean( propertyValue );
// TODO: We should call setMeshPropertyRecursively here instead of repeating code
threeObject.castShadow = value;
var meshes = findAllMeshes.call( this, threeObject );
for(var i = 0, il = meshes.length; i < il; i++) {
meshes[i].castShadow = value;
}
}
else if ( propertyName == 'receiveShadows' )
{
value = Boolean( propertyValue );
// TODO: We should call setMeshPropertyRecursively here instead of repeating code
threeObject.receiveShadow = value;
var meshes = findAllMeshes.call( this, threeObject );
for(var i = 0, il = meshes.length; i < il; i++) {
meshes[i].receiveShadow = value;
}
}
//This can be a bit confusing, as the node has a material property, and a material child node.
//setting the property does this, but the code in the component is ambigious
else if ( propertyName == 'material' )
{
var material = GetMaterial(node.threeObject);
if(!material)
{
material = new THREE.MeshPhongMaterial();
SetMaterial(node.threeObject,material);
}
if(propertyValue == 'red')
material.color.setRGB(1,0,0);
if(propertyValue == 'green')
material.color.setRGB(0,1,0);
if(propertyValue == 'blue')
material.color.setRGB(0,0,1);
if(propertyValue == 'purple')
material.color.setRGB(1,0,1);
if(propertyValue == 'orange')
material.color.setRGB(1,.5,0);
if(propertyValue == 'yellow')
material.color.setRGB(1,1,0);
if(propertyValue == 'gray')
material.color.setRGB(.5,.5,.5);
if(propertyValue == 'white')
material.color.setRGB(1,1,1);
if(propertyValue == 'black')
material.color.setRGB(0,0,0);
material.ambient.setRGB( material.color.r,material.color.g,material.color.b);
value = propertyValue;
}
else if ( propertyName == "animationTimeUpdated" ) {
// Keyframe Animations
if ( node.threeObject.kfAnimations && node.threeObject.kfAnimations.length && propertyValue !== undefined ) {
for ( var i = 0; i < node.threeObject.kfAnimations.length; i++ ) {
node.threeObject.kfAnimations[i].stop()
node.threeObject.kfAnimations[i].play( false, 0 );
node.threeObject.kfAnimations[i].update( propertyValue );
}
}
// Both JSON and Collada models can be skinned mesh animations, but the Collada loader does not support bones
// therefore Collada models will fall in the Morph Target conditional if applicable.
// Skeletal Animations (takes precedence over Morph Target)
if ( node.threeObject.bones && node.threeObject.bones.length > 0 ) {
var animRate = this.state.kernel.getProperty( nodeID, "animationRate" ) || 1;
THREE.AnimationHandler.update(animRate);
}
// Morph Target Animations
else if ( node.threeObject.animatedMesh && node.threeObject.animatedMesh.length && propertyValue !== undefined ) {
var fps = this.state.kernel.getProperty( nodeID, "animationFPS" ) || 30;
for( var i = 0; i < node.threeObject.animatedMesh.length; i++ ) {
if ( node.threeObject.animatedMesh[i].morphTargetInfluences ) {
for( var j = 0; j < node.threeObject.animatedMesh[i].morphTargetInfluences.length; j++ ) {
node.threeObject.animatedMesh[i].morphTargetInfluences[j] = 0;
}
node.threeObject.animatedMesh[i].morphTargetInfluences[ Math.floor(propertyValue * fps) ] = 1;
}
}
}
// the transform is being stored locally which is probably the
// main source of the problem( animated transforms are incorrect while
// being animated ), I'm not sure why this has been done
//updateStoredTransform( node );
// calling updateStoredTransform here seemed to be
// too big of a performance hit, so setting a flag
// to be checked in the getter before getting the transform
// node.storedTransformDirty = true;
setTransformsDirty( node.threeObject );
}
else if ( propertyName == "animationDuration" ) {
if( node.threeObject.animatedMesh && node.threeObject.animatedMesh.length || node.threeObject.kfAnimations ) {
value = this.gettingProperty( nodeID, "animationDuration" );
}
}
else if ( propertyName == "animationFPS" ) {
if( node.threeObject.animatedMesh && node.threeObject.animatedMesh.length || node.threeObject.kfAnimations ) {
value = this.gettingProperty( nodeID, "animationFPS" );
}
}
}
if( threeObject instanceof THREE.PointCloud )
{
var ps = threeObject;
var particles = ps.geometry;
switch( propertyName ) {
case 'emitterSize':
case 'emitterType':
case 'gravity':
case 'gravityCenter':
case 'velocityMode':
case 'damping':
case 'maxRate':
ps[propertyName] = propertyValue;
if( ps.material == ps.shaderMaterial_analytic ) {
ps.rebuildParticles();
}
break;
case 'size':
ps[propertyName] = propertyValue;
for( var i = 0; i < ps.material.attributes.size.value.length; i++ ) {
ps.material.attributes.size.value[i] = propertyValue;
}
ps.material.attributes.size.needsUpdate = true;
break;
case 'particleCount':
ps.setParticleCount(propertyValue);
break;
case 'startSize':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.startSize.value = propertyValue;
// ps.material.uniforms.startSize.value = propertyValue;
break;
case 'endSize':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.endSize.value = propertyValue;
// ps.material.uniforms.endSize.value = propertyValue;
break;
case 'sizeRange':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.sizeRange.value = propertyValue;
// ps.material.uniforms.sizeRange.value = propertyValue;
break;
case 'maxSpin':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.maxSpin.value = propertyValue;
// ps.material.uniforms.maxSpin.value = propertyValue;
break;
case 'minSpin':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.minSpin.value = propertyValue;
// ps.material.uniforms.minSpin.value = propertyValue;
break;
case 'textureTiles':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.textureTiles.value = propertyValue;
// ps.material.uniforms.textureTiles.value = propertyValue;
break;
case 'maxOrientation':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.maxOrientation.value = propertyValue;
// ps.material.uniforms.maxOrientation.value = propertyValue;
break;
case 'minOrientation':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.minOrientation.value = propertyValue;
// ps.material.uniforms.minOrientation.value = propertyValue;
break;
case 'colorRange':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.colorRange.value.x = propertyValue[0];
ps.shaderMaterial_analytic.uniforms.colorRange.value.y = propertyValue[1];
ps.shaderMaterial_analytic.uniforms.colorRange.value.z = propertyValue[2];
ps.shaderMaterial_analytic.uniforms.colorRange.value.w = propertyValue[3];
break;
case 'startColor':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.startColor.value.x = propertyValue[0];
ps.shaderMaterial_analytic.uniforms.startColor.value.y = propertyValue[1];
ps.shaderMaterial_analytic.uniforms.startColor.value.z = propertyValue[2];
ps.shaderMaterial_analytic.uniforms.startColor.value.w = propertyValue[3];
break;
case 'endColor':
ps[propertyName] = propertyValue;
ps.shaderMaterial_analytic.uniforms.endColor.value.x = propertyValue[0];
ps.shaderMaterial_analytic.uniforms.endColor.value.y = propertyValue[1];
ps.shaderMaterial_analytic.uniforms.endColor.value.z = propertyValue[2];
ps.shaderMaterial_analytic.uniforms.endColor.value.w = propertyValue[3];
break;
case 'solver':
ps[propertyName] = propertyValue;
ps.setSolverType(propertyValue);
break;
case 'image':
ps[propertyName] = propertyValue;
ps.shaderMaterial_default.uniforms.texture.value = loadTexture( undefined, propertyValue );
ps.shaderMaterial_default.uniforms.useTexture.value = 1.0;
ps.shaderMaterial_analytic.uniforms.texture.value = loadTexture( undefined, propertyValue );
ps.shaderMaterial_analytic.uniforms.useTexture.value = 1.0;
break;
case 'additive':
ps[propertyName] = propertyValue;
if ( Boolean( propertyValue ) )
{
ps.shaderMaterial_default.blending = THREE.AdditiveBlending;
ps.shaderMaterial_default.transparent = true;
ps.shaderMaterial_analytic.blending = THREE.AdditiveBlending;
ps.shaderMaterial_analytic.transparent = true;
ps.shaderMaterial_interpolate.blending = THREE.AdditiveBlending;
ps.shaderMaterial_interpolate.transparent = true;
}
else
{
ps.shaderMaterial_default.blending = THREE.NormalBlending;
ps.shaderMaterial_default.transparent = true;
ps.shaderMaterial_analytic.blending = THREE.NormalBlending;
ps.shaderMaterial_analytic.transparent = true;
ps.shaderMaterial_interpolate.blending = THREE.NormalBlending;
ps.shaderMaterial_interpolate.transparent = true;
}
ps.shaderMaterial_default.needsUpdate = true;
ps.shaderMaterial_analytic.needsUpdate = true;
ps.shaderMaterial_interpolate.needsUpdate = true;
break;
case 'depthTest':
ps[propertyName] = propertyValue;
ps.shaderMaterial_default.depthTest = propertyValue;
ps.shaderMaterial_analytic.depthTest = propertyValue;
ps.shaderMaterial_interpolate.depthTest = propertyValue;
break;
case 'depthWrite':
ps[propertyName] = propertyValue;
ps.shaderMaterial_default.depthWrite = propertyValue;
ps.shaderMaterial_analytic.depthWrite = propertyValue;
ps.shaderMaterial_interpolate.depthWrite = propertyValue;
break;
case 'minAcceleration':
case 'maxAcceleration':
ps[propertyName] = propertyValue;
if(!ps.minAcceleration) ps.minAcceleration = [0,0,0];
if(!ps.maxAcceleration) ps.maxAcceleration = [0,0,0];
for(var i = 0; i < particles.vertices.length; i++)
{
particles.vertices[i].acceleration.x = ps.minAcceleration[0] + (ps.maxAcceleration[0] - ps.minAcceleration[0]) * Math.random();
particles.vertices[i].acceleration.y = ps.minAcceleration[1] + (ps.maxAcceleration[1] - ps.minAcceleration[1]) * Math.random();
particles.vertices[i].acceleration.z = ps.minAcceleration[2] + (ps.maxAcceleration[2] - ps.minAcceleration[2]) * Math.random();
}
if( ps.material == ps.shaderMaterial_analytic ) {
ps.rebuildParticles();
}
break;
case 'minVelocity':
case 'maxVelocity':
ps[propertyName] = propertyValue;
if(!ps.minVelocity) ps.minVelocity = [0,0,0];
if(!ps.maxVelocity) ps.maxVelocity = [0,0,0];
for(var i = 0; i < particles.vertices.length; i++)
{
particles.vertices[i].velocity.x = ps.minVelocity[0] + (ps.maxVelocity[0] - ps.minVelocity[0]) * Math.random();
particles.vertices[i].velocity.y = ps.minVelocity[1] + (ps.maxVelocity[1] - ps.minVelocity[1]) * Math.random();
particles.vertices[i].velocity.z = ps.minVelocity[2] + (ps.maxVelocity[2] - ps.minVelocity[2]) * Math.random();
}
if( ps.material == ps.shaderMaterial_analytic ) {
ps.rebuildParticles();
}
break;
case 'minLifeTime':
case 'maxLifeTime':
ps[propertyName] = propertyValue;
if(ps.minLifeTime === undefined) ps.minLifeTime = 0;
if(ps.maxLifeTime === undefined) ps.maxLifeTime = 1;
for(var i = 0; i < particles.vertices.length; i++)
{
particles.vertices[i].lifespan = ps.minLifeTime + (ps.maxLifeTime - ps.minLifeTime) * Math.random();
}
break;
}
}
if(threeObject instanceof THREE.Camera)
{
if(propertyName == "fovy")
{
if(propertyValue)
{
value = parseFloat(propertyValue);
threeObject.fov = value;
threeObject.updateProjectionMatrix();
}
}
if(propertyName == "near")
{
if(propertyValue)
{
value = parseFloat(propertyValue);
threeObject.near = value;
threeObject.updateProjectionMatrix();
}
}
if(propertyName == "aspect")
{
if(propertyValue)
{
value = parseFloat(propertyValue);
threeObject.aspect = value;
threeObject.updateProjectionMatrix();
}
}
if(propertyName == "far")
{
if(propertyValue)
{
value = parseFloat(propertyValue);
threeObject.far = value;
threeObject.updateProjectionMatrix();
}
}
if(propertyName == "cameraType")
{
if(propertyValue == 'perspective')
{
value = propertyValue;
var parent = threeObject.parent;
if(parent && threeObject && !(threeObject instanceof THREE.PerspectiveCamera))
{
var sceneNode = this.state.scenes[ this.kernel.application() ];
parent.remove(threeObject);
var cam = new THREE.PerspectiveCamera(35,$(document).width()/$(document).height() ,.01,10000);
cam.far = threeObject.far;
cam.near = threeObject.near;
cam.matrix.elements = matCpy(threeObject.matrix.elements);
cam.matrixAutoUpdate = false;
if ( threeObject.fov )
cam.fov = threeObject.fov;
if ( threeObject.aspect )
cam.aspect = threeObject.aspect;
// If the camera we are replacing, is the active camera,
// set the active camera
if ( this.state.cameraInUse == threeObject )
this.state.cameraInUse = cam;
threeObject.updateProjectionMatrix();
node.threeObject = cam;
parent.add(node.threeObject);
}
}
if(propertyValue == 'orthographic')
{
value = propertyValue;
var parent = threeObject.parent;
if(parent && threeObject && !(threeObject instanceof THREE.OrthographicCamera))
{
var sceneNode = this.state.scenes[ this.kernel.application() ];
parent.remove(threeObject);
var offset = threeObject.far * Math.cos(threeObject.fov/2 * 0.0174532925);
offset = offset/2;
var aspect = threeObject.aspect;
var cam = new THREE.OrthographicCamera(-offset,offset,offset/aspect,-offset/aspect,threeObject.near,threeObject.far);
cam.far = threeObject.far;
cam.near = threeObject.near;
cam.matrix = threeObject.matrix;
cam.matrixAutoUpdate = false;
if ( threeObject.fov )
cam.fov = threeObject.fov;
if ( threeObject.aspect )
cam.aspect = threeObject.aspect;
// If the camera we are replacing, is the active camera,
// set the active camera
if ( this.state.cameraInUse == threeObject )
this.state.cameraInUse = cam;
node.threeObject = cam;
parent.add(node.threeObject);
}
}
}
}
if ( threeObject instanceof THREE.Material ) {
value = setMaterialProperty( threeObject, propertyName, propertyValue );
if ( value !== undefined ) {
if ( this.state.nodes[ node.parentID ] && this.state.nodes[ node.parentID ].threeObject ) {
var obj3 = this.state.nodes[ node.parentID ].threeObject;
this.state.setGeometryPropertyRecursively( obj3, "uvsNeedUpdate", true );
}
}
}
if ( threeObject instanceof THREE.Texture ) {
value = setTextureProperty( threeObject, propertyName, propertyValue );
if ( value !== undefined ) {
if ( this.state.nodes[ node.parentID ] && this.state.nodes[ node.parentID ].threeObject ) {
var obj3 = this.state.nodes[ node.parentID ].threeObject;
this.state.setGeometryPropertyRecursively( obj3, "uvsNeedUpdate", true );
}
}
}
if ( threeObject instanceof THREE.ShaderMaterial ) {
if ( utility.validObject( propertyValue ) ) {
if ( propertyName === "uniforms" ) {
value = propertyValue;
threeObject.uniforms = value;
}
if ( propertyName === "vertexShader" ) {
value = propertyValue;
threeObject.vertexShader = value;
}
if ( propertyName === "fragmentShader" ) {
value = propertyValue;
threeObject.fragmentShader = value;
}
if ( propertyName === "updateFunction" ) {
value = propertyValue;
threeObject.updateFunction = value;
threeObject.update = function() {
eval( this.updateFunction );
}
}
}
}
if ( node.isUniformObject ) {
value = setUniformProperty( threeObject, propertyName, propertyValue.type, propertyValue.pValue );
}
if( threeObject instanceof THREE.Scene )
{
if(propertyName == 'activeCamera')
{
if ( this.state.nodes[ propertyValue ] !== undefined ) {
// Update the model's activeCamera
this.state.scenes[ this.kernel.application() ].camera.ID = propertyValue;
value = propertyValue;
}
}
if( propertyName == 'ambientColor' )
{
var lightsFound = 0;
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
for( var i = 0; i < threeObject.children.length; i++ )
{
if( threeObject.children[i] instanceof THREE.AmbientLight )
{
threeObject.children[i].color.setRGB( vwfColor.red()/255, vwfColor.green()/255, vwfColor.blue()/255 );
lightsFound++;
}
}
if ( lightsFound == 0 ) {
node.ambientlight = new THREE.AmbientLight( '#000000' );
node.ambientlight.color.setRGB( vwfColor.red()/255, vwfColor.green()/255, vwfColor.blue()/255 );
node.threeScene.add( node.ambientlight );
this.state.lights[ node.nodeID ] = node.ambientlight;
}
value = vwfColor.toString();
}
}
// backgroundColor, enableShadows, shadowMapCullFace and shadowMapType are dependent
// on the renderer object, but if they are set in a prototype,
// the renderer is not available yet, so store them until it is ready.
if ( propertyName == 'backgroundColor' )
{
if ( node && node.renderer ) {
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
node.renderer.setClearColor( vwfColor.getHex(), vwfColor.alpha() );
value = vwfColor.toString();
}
}
else if(node) {
node.rendererProperties["backgroundColor"] = propertyValue;
}
}
if(propertyName == 'enableShadows')
{
if ( node && node.renderer ) {
value = Boolean( propertyValue );
node.renderer.shadowMapEnabled = value;
}
else if(node) {
node.rendererProperties["enableShadows"] = propertyValue;
}
// Need to reset the viewport or you just get a blank screen
this.state.kernel.dispatchEvent( nodeID, "resetViewport" );
}
if ( propertyName == 'shadowMapCullFace') {
var shadowMapCullFace;
switch(propertyValue) {
case "none":
shadowMapCullFace = 0;
value = propertyValue;
break;
case "back":
shadowMapCullFace = 1;
value = propertyValue;
break;
case "front":
shadowMapCullFace = 2;
value = propertyValue;
break;
case "both":
shadowMapCullFace = 3;
value = propertyValue;
break;
}
if ( node && node.renderer ) {
node.renderer.shadowMapCullFace = shadowMapCullFace;
}
else if ( node ) {
node.rendererProperties["shadowMapCullFace"] = shadowMapCullFace;
}
}
if ( propertyName == 'shadowMapType') {
var shadowMapType;
switch(propertyValue) {
case "basic":
shadowMapType = 0;
value = propertyValue;
break;
case "PCF":
shadowMapType = 1;
value = propertyValue;
break;
case "PCFSoft":
shadowMapType = 2;
value = propertyValue;
break;
}
if ( node && node.renderer ) {
node.renderer.shadowMapType = shadowMapType;
}
else if ( node ) {
node.rendererProperties["shadowMapType"] = shadowMapType;
}
}
if ( propertyName === 'fogexp_color' ) {
if ( threeObject.fog && threeObject.fog instanceof THREE.FogExp2 ) {
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
threeObject.fog.color.setRGB( vwfColor.red()/255, vwfColor.green()/255, vwfColor.blue()/255 );
}
}
}
if ( propertyName === 'fogexp_density' ) {
if ( threeObject.fog && threeObject.fog instanceof THREE.FogExp2 ) {
threeObject.fog.density = parseFloat( propertyValue );
}
}
if ( propertyName === 'fog_color' ) {
if ( threeObject.fog && threeObject.fog instanceof THREE.Fog ) {
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
threeObject.fog.color.setRGB( vwfColor.red()/255, vwfColor.green()/255, vwfColor.blue()/255 );
}
}
}
if ( propertyName === 'fog_near' ) {
if ( threeObject.fog && threeObject.fog instanceof THREE.Fog ) {
threeObject.fog.fog_near = parseFloat( propertyValue );
}
}
if ( propertyName === 'fog_far' ) {
if ( threeObject.fog && threeObject.fog instanceof THREE.Fog ) {
threeObject.fog.fog_far = parseFloat( propertyValue );
}
}
}
if(threeObject instanceof THREE.PointLight || threeObject instanceof THREE.DirectionalLight
|| threeObject instanceof THREE.SpotLight || threeObject instanceof THREE.HemisphereLight )
{
if(propertyName == 'lightType')
{
var newlight;
var parent = threeObject.parent;
var currProps = {
"name": threeObject.name,
"distance": threeObject.distance,
"color": threeObject.color,
"groundColor": threeObject.groundColor,
"intensity": threeObject.intensity,
"castShadow": threeObject.castShadow,
"shadowCameraLeft": threeObject.shadowCameraLeft,
"shadowCameraRight": threeObject.shadowCameraRight,
"shadowCameraTop": threeObject.shadowCameraTop,
"shadowCameraBottom": threeObject.shadowCameraBottom,
"shadowCameraNear": threeObject.shadowCameraNear,
"shadowCameraFar": threeObject.shadowCameraFar,
"shadowDarkness": threeObject.shadowDarkness,
"shadowMapHeight": threeObject.shadowMapHeight,
"shadowMapWidth": threeObject.shadowMapWidth,
"shadowBias": threeObject.shadowBias,
"target": threeObject.target,
"position": threeObject.position,
"clone": function( newObj ) {
newObj.name = this.name;
newObj.distance = this.distance;
//console.info( "light.clone.color = " + JSON.stringify( this.color ) )
newObj.color.setRGB( this.color.r, this.color.g, this.color.b );
if (this.groundColor !== undefined) {
newObj.groundColor = new THREE.Color().setRGB( this.groundColor.r, this.groundColor.g, this.groundColor.b );
}
newObj.intensity = this.intensity;
newObj.castShadow = this.castShadow;
newObj.shadowCameraLeft = this.shadowCameraLeft;
newObj.shadowCameraRight = this.shadowCameraRight;
newObj.shadowCameraTop = this.shadowCameraTop;
newObj.shadowCameraBottom = this.shadowCameraBottom;
newObj.shadowCameraNear = this.shadowCameraNear;
newObj.shadowCameraFar = this.shadowCameraFar;
newObj.shadowDarkness = this.shadowDarkness;
newObj.shadowMapHeight = this.shadowMapHeight;
newObj.shadowMapWidth = this.shadowMapWidth;
newObj.shadowBias = this.shadowBias;
if ( this.target ) {
newObj.target = this.target;
}
newObj.position.set( this.position.x, this.position.y, this.position.z );
}
};
if(propertyValue == 'point' && !(threeObject instanceof THREE.PointLight))
{
newlight = new THREE.PointLight('FFFFFF',1,0);
currProps.clone( newlight );
//newlight.matrixAutoUpdate = false;
parent.remove( node.threeObject );
parent.add( newlight );
node.threeObject = newlight;
rebuildAllMaterials.call(this);
}
if(propertyValue == 'directional' && !(threeObject instanceof THREE.DirectionalLight))
{
newlight = new THREE.DirectionalLight( 'FFFFFF' );
currProps.clone( newlight );
//newlight.matrixAutoUpdate = false;
parent.remove( node.threeObject );
parent.add( newlight );
node.threeObject = newlight;
rebuildAllMaterials.call(this);
}
if(propertyValue == 'spot' && !(threeObject instanceof THREE.SpotLight))
{
newlight = new THREE.SpotLight('FFFFFF',1,0);
currProps.clone( newlight );
//newlight.matrixAutoUpdate = false;
parent.remove( node.threeObject );
parent.add( newlight );
node.threeObject = newlight;
rebuildAllMaterials.call(this);
}
if(propertyValue == 'hemisphere' && !(threeObject instanceof THREE.HemisphereLight))
{
newlight = new THREE.HemisphereLight('FFFFFF','FFFFFF',1);
currProps.clone( newlight );
//newlight.matrixAutoUpdate = false;
parent.remove( node.threeObject );
parent.add( newlight );
node.threeObject = newlight;
rebuildAllMaterials.call(this);
}
if ( propertyValue == 'point' || propertyValue == 'directional' || propertyValue == 'spot' || propertyValue == 'hemisphere' ) {
value = propertyValue;
}
}
//if(propertyName == 'diffuse')
//{
// threeObject.color.setRGB(propertyValue[0]/255,propertyValue[1]/255,propertyValue[2]/255);
//}
else if ( propertyName == 'enable' ) {
if ( parentNode !== undefined ) {
var threeParent = ( parentNode.threeObject !== undefined ) ? parentNode.threeObject : parentNode.threeScene;
if ( threeParent !== undefined ) {
if ( Boolean( propertyValue ) ) {
if ( threeObject.parent === undefined ) {
threeParent.add( threeObject );
}
} else {
if ( threeObject.parent !== undefined ) {
threeParent.remove( threeObject );
}
}
}
}
} else if ( propertyName == 'position' ) {
if ( threeObject.position !== null && propertyValue.length ) {
threeObject.position.set( propertyValue[0], propertyValue[1], propertyValue[2] );
}
}
else if ( propertyName == 'distance' ) {
value = Number( propertyValue );
threeObject.distance = value;
}
else if ( propertyName == 'color' ) {
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
threeObject.color.setRGB( vwfColor.red()/255, vwfColor.green()/255, vwfColor.blue()/255 );
}
value = vwfColor.toString();
}
else if ( propertyName == 'groundColor' ) {
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
threeObject.groundColor = new THREE.Color().setRGB( vwfColor.red()/255, vwfColor.green()/255, vwfColor.blue()/255 );
}
value = vwfColor.toString();
}
else if ( propertyName == 'intensity' ) {
value = parseFloat( propertyValue );
threeObject.intensity = value;
}
else if ( propertyName == 'castShadows' ) {
value = Boolean( propertyValue );
threeObject.castShadow = value;
}
else if ( propertyName == 'shadowCameraBottom' ) {
value = Number( propertyValue );
threeObject.shadowCameraBottom = value;
}
else if ( propertyName == 'shadowCameraLeft' ) {
value = Number( propertyValue );
threeObject.shadowCameraLeft = value;
}
else if ( propertyName == 'shadowCameraRight' ) {
value = Number( propertyValue );
threeObject.shadowCameraRight = value;
}
else if ( propertyName == 'shadowCameraTop' ) {
value = Number( propertyValue );
threeObject.shadowCameraTop = value;
}
else if ( propertyName == 'shadowCameraNear' ) {
value = Number( propertyValue );
threeObject.shadowCameraNear = value;
}
else if ( propertyName == 'shadowCameraFar' ) {
value = Number( propertyValue );
threeObject.shadowCameraFar = value;
}
else if ( propertyName == 'shadowDarkness' ) {
value = Number( propertyValue );
threeObject.shadowDarkness = value;
}
else if ( propertyName == 'shadowMapHeight' ) {
value = Number ( propertyValue );
threeObject.shadowMapHeight = value;
if(threeObject.shadowMapSize) {
threeObject.shadowMapSize.y = value;
}
if(threeObject.shadowMap) {
threeObject.shadowMap.height = value;
}
}
else if ( propertyName == 'shadowMapWidth' ) {
value = Number ( propertyValue );
threeObject.shadowMapWidth = value;
if(threeObject.shadowMapSize) {
threeObject.shadowMapSize.x = value;
}
if(threeObject.shadowMap) {
threeObject.shadowMap.width = value;
}
}
else if ( propertyName == 'shadowBias' ) {
value = Number ( propertyValue );
threeObject.shadowBias = value;
}
else if ( propertyName == "target" ) {
if ( propertyValue instanceof Array ) {
value = propertyValue;
if ( threeObject.target ) {
threeObject.target.position.set( value[ 0 ], value[ 1 ], value[ 2 ] );
}
} else if ( this.state.nodes[ propertyValue ] ) {
value = propertyValue;
threeObject.target = this.state.nodes[ value ].threeObject;
} else {
this.logger.warnx( "settingProperty", "Invalid target: " + propertyValue );
}
}
}
}
return value;
},
// -- gettingProperty ----------------------------------------------------------------------
gettingProperty: function( nodeID, propertyName ) {
if ( this.debug.properties || this.debug.getting ) {
this.logger.infox( " G === gettingProperty ", nodeID, propertyName );
}
var node = this.state.nodes[ nodeID ]; // { name: childName, glgeObject: undefined }
if(!node) node = this.state.scenes[ nodeID ]; // { name: childName, glgeObject: undefined }
var value = undefined;
//this driver has no representation of this node, so there is nothing to do.
if(!node) return;
var threeObject = node.threeObject;
if( !threeObject )
threeObject = node.threeScene;
//There is not three object for this node, so there is nothing this driver can do. return
if(!threeObject) return value;
if(threeObject instanceof THREE.Object3D)
{
if(propertyName == 'transform' && node.transform)
{
if ( node.storedTransformDirty ) {
updateStoredTransform( node );
}
value = matCpy( node.transform.elements );
return value;
}
if(propertyName =='lookAt')
{
value = node.lookatval;
return value;
}
if(propertyName == "boundingbox")
{
value = getBoundingBox.call( this, threeObject );
return value;
}
if ( propertyName == "centerOffset" )
{
value = getCenterOffset.call( this, threeObject );
return value;
}
if(propertyName == "meshData")
{
value = [];
var scale = this.gettingProperty( nodeID, "scale", [] );
scale = [1,1,1];
var meshList = findAllMeshes.call( this, threeObject );
for ( var i = 0; i < meshList.length; i++ ) {
value.push( { "vertices": getMeshVertices.call( this, meshList[i],threeObject ),
"vertexIndices": getMeshVertexIndices.call( this, meshList[i] ),
"scale": scale
} );
}
return value;
}
if(propertyName == "animationDuration") {
var animationDuration = 0;
if(node.threeObject.animations) {
for(var i=0, il = node.threeObject.animations.length; i < il; i++) {
if(node.threeObject.animations[i].length > animationDuration) {
animationDuration = node.threeObject.animations[i].length;
}
}
value = animationDuration;
}
else if ( node.threeObject.animatedMesh && node.threeObject.animatedMesh.length ) {
var fps = this.state.kernel.getProperty( nodeID, "animationFPS") || 30;
for(var i=0, il = node.threeObject.animatedMesh.length; i < il; i++) {
if (node.threeObject.animatedMesh[i].bones) {
// Skeletal animations take precedence over Morph Targets
animationDuration = node.threeObject.animatedMesh[i].bones.length;
}
else if( node.threeObject.animatedMesh[i].morphTargetInfluences.length > animationDuration ) {
animationDuration = node.threeObject.animatedMesh[i].morphTargetInfluences.length;
}
}
value = animationDuration / fps;
}
return value;
}
if(propertyName == "animationFPS") {
if(node.threeObject.animations) {
var animationDuration = 0;
var animationFrameCount = 0;
for(var i=0, il = node.threeObject.animations.length; i < il; i++) {
for(var i=0, il = node.threeObject.animations.length; i < il; i++) {
if(node.threeObject.animations[i].length > animationDuration) {
animationDuration = node.threeObject.animations[i].length;
}
if(node.threeObject.animations[i].hierarchy[0].keys.length > animationFrameCount) {
animationFrameCount = node.threeObject.animations[i].hierarchy[0].keys.length;
}
}
}
value = Math.floor(animationFrameCount / animationDuration);
}
return value;
}
if( propertyName == "visible" ) {
value = node.threeObject.visible;
return value;
}
if ( propertyName == "castShadows" ) {
value = node.threeObject.castShadow;
return value;
}
if ( propertyName == "receiveShadows" ) {
value = node.threeObject.receiveShadow;
return value;
}
}
if(threeObject instanceof THREE.Material)
{
if(propertyName == "texture")
{
if( threeObject.map && threeObject.map.image )
return threeObject.map.image.src;
}
if(propertyName == "color") {
var vwfColor = new utility.color( [ threeObject.color.r*255, threeObject.color.g*255, threeObject.color.b*255 ] );
value = vwfColor.toString();
return value;
}
if ( propertyName == "specColor" ) {
if ( threeObject.specular !== undefined ) {
var vwfColor = new utility.color( [ threeObject.specular.r*255, threeObject.specular.g*255, threeObject.specular.b*255 ] );
value = vwfColor.toString();
return value;
}
}
if ( propertyName == "reflect" ) {
value = threeObject.reflectivity;
return value;
}
if ( propertyName == "shininess" ) {
value = threeObject.shininess;
return value;
}
if ( propertyName == "emit" ) {
if ( threeObject.emissive ) {
var vwfColor = new utility.color( [ threeObject.emissive.r*255, threeObject.emissive.g*255, threeObject.emissive.b*255 ] );
value = vwfColor.toString();
return value;
}
}
if ( propertyName == "ambient" ) {
if ( threeObject.ambient ) {
var vwfColor = new utility.color( [ threeObject.ambient.r*255, threeObject.ambient.g*255, threeObject.ambient.b*255 ] );
value = vwfColor.toString();
return value;
}
}
if ( ( propertyName == "bumpScale" ) && ( threeObject.bumpMap ) ) {
value = threeObject.bumpScale;
return value;
}
if ( propertyName == "alphaTest" ) {
value = threeObject.alphaTest;
return value;
}
if ( propertyName == "transparent" ) {
value = threeObject.transparent;
return value;
}
if ( propertyName == "opacity" ) {
value = threeObject.opacity;
return value;
}
if ( propertyName === "side" ) {
switch ( threeObject.side ) {
case THREE.DoubleSide:
value = "double";
break;
case THREE.FrontSide:
value = "front";
break;
case THREE.BackSide:
value = "back";
break;
}
}
}
if ( threeObject instanceof THREE.ShaderMaterial ) {
if ( propertyName === "uniforms" ) {
value = {};
for ( var uni in threeObject.uniforms ) {
if ( threeObject.uniforms[ uni ].type === 't' ) {
if ( threeObject.uniforms[ uni ].value ) {
value[ uni ] = { "type": 't', "value": threeObject.uniforms[ uni ].value.sourceFile };
} else {
value[ uni ] = threeObject.uniforms[ uni ];
}
} else {
value[ uni ] = threeObject.uniforms[ uni ];
}
}
return value;
}
if ( propertyName === "vertexShader" ) {
value = threeObject.vertexShader;
return value;
}
if ( propertyName === "fragmentShader" ) {
value = threeObject.fragmentShader;
return value;
}
if ( propertyName === "updateFunction" ) {
value = threeObject.updateFunction;
return value;
}
}
if ( node.isUniformObject ) {
value = {};
for ( var prop in threeObject ) {
if ( ! utility.isFunction( threeObject[ prop ] ) ) {
if ( threeObject[ prop ].type !== 't' ) {
value[ prop ] = {
"type": threeObject[ prop ].type,
"pValue": threeObject[ prop ].value
};
} else {
value[ prop ] = {
"type": threeObject[ prop ].type,
"pValue": threeObject[ prop ].src
};
}
}
}
return value;
}
if ( threeObject instanceof THREE.Texture ) {
value = undefined;
switch ( propertyName ) {
case "url":
if( threeObject.image ) {
value = threeObject.image.src;
} else {
value = "";
}
break;
case "wrapT":
switch ( threeObject.wrapT ) {
case THREE.ClampToEdgeWrapping:
value = "clamp";
break;
case THREE.RepeatWrapping:
value = "repeat";
break;
case THREE.MirroredRepeatWrapping:
value = "mirror";
break;
}
break;
case "wrapS":
switch ( threeObject.wrapS ) {
case THREE.ClampToEdgeWrapping:
value = "clamp";
break;
case THREE.RepeatWrapping:
value = "repeat";
break;
case THREE.MirroredRepeatWrapping:
value = "mirror";
break;
}
break;
case "repeat":
if ( threeObject.repeat ) {
value = [ threeObject.repeat.x, threeObject.repeat.y ]
}
break;
case "offset":
if ( threeObject.offset ) {
value = [ threeObject.repeat.x, threeObject.offset.y ]
}
break;
case "magFilter":
switch ( threeObject.magFilter ) {
case THREE.NearestFilter:
value = "nearest";
break;
case THREE.NearestMipMapNearestFilter:
value = "nearestNearest";
break;
case THREE.NearestMipMapLinearFilter:
value = "nearestLinear";
break;
case THREE.LinearFilter:
value = "linear";
break;
case THREE.LinearMipMapNearestFilter:
value = "linearNearest";
break;
case THREE.LinearMipMapLinearFilter:
value = "linearLinear";
break;
}
break;
case "minFilter":
switch ( threeObject.minFilter ) {
case THREE.NearestFilter:
value = "nearest";
break;
case THREE.NearestMipMapNearestFilter:
value = "nearestNearest";
break;
case THREE.NearestMipMapLinearFilter:
value = "nearestLinear";
break;
case THREE.LinearFilter:
value = "linear";
break;
case THREE.LinearMipMapNearestFilter:
value = "linearNearest";
break;
case THREE.LinearMipMapLinearFilter:
value = "linearLinear";
break;
}
break;
case "anisotropy":
value = threeObject.anisotropy;
break;
}
if ( value !== undefined ) {
return value;
}
}
if( threeObject instanceof THREE.Camera ) {
switch ( propertyName ) {
case "fovy":
value = threeObject.fovy;
break;
case "near":
value = threeObject.near;
break;
case "aspect":
value = threeObject.aspect;
break;
case "far":
value = threeObject.far;
break;
case "cameraType":
if ( threeObject instanceof THREE.OrthographicCamera ) {
value = 'orthographic';
} else {
value = 'perspective';
}
break;
}
}
if( threeObject instanceof THREE.Scene ) {
var found = false;
var vwfColor, color;
switch ( propertyName ) {
case "ambientColor":
for( var i = 0; i < threeObject.children.length && !found; i++ ) {
if( threeObject.children[i] instanceof THREE.AmbientLight ) {
color = threeObject.children[i].color;
vwfColor = new utility.color( [ color.r*255, color.g*255, color.b*255 ] );
value = vwfColor.toString();
found = true;
}
}
break;
case "backgroundColor":
if ( node.renderer ) {
color = node.renderer.getClearColor();
var alpha = node.renderer.getClearAlpha();
if ( alpha !== undefined && alpha != 1 ){
vwfColor = new utility.color( [ color.r*255, color.g*255, color.b*255, alpha ] );
} else {
vwfColor = new utility.color( [ color.r*255, color.g*255, color.b*255 ] );
}
value = vwfColor.toString();
}
break;
case 'enableShadows':
if ( node.renderer ) {
value = node.renderer.shadowMapEnabled;
}
break;
case "activeCamera":
value = node.camera.ID;
break;
case "shadowMapCullFace":
if ( node.renderer ) {
value = node.renderer.shadowMapCullFace;
}
break;
case "shadowMapType":
if ( node.renderer ) {
value = node.renderer.shadowMapType;
}
break;
case "fogexp_color":
if ( threeObject.fog && threeObject.fog instanceof THREE.FogExp2 ) {
color = threeObject.fog.color;
vwfColor = new utility.color( [ color.r*255, color.g*255, color.b*255 ] );
value = vwfColor.toString();
}
break;
case "fogexp_density":
if ( threeObject.fog && threeObject.fog instanceof THREE.FogExp2 ) {
value = threeObject.fog.density;
}
break;
case "fog_color":
if ( threeObject.fog && threeObject.fog instanceof THREE.Fog ) {
color = threeObject.fog.color;
vwfColor = new utility.color( [ color.r*255, color.g*255, color.b*255 ] );
value = vwfColor.toString();
}
break;
case "fog_near":
if ( threeObject.fog && threeObject.fog instanceof THREE.Fog ) {
value = threeObject.fog.near;
}
break;
case "fog_far":
if ( threeObject.fog && threeObject.fog instanceof THREE.Fog ) {
value = threeObject.fog.far;
}
break;
}
}
if( threeObject instanceof THREE.Light ) {
switch ( propertyName ) {
case "lightType":
if ( threeObject instanceof THREE.DirectionalLight ){
value = 'directional';
} else if ( threeObject instanceof THREE.SpotLight ) {
value = 'spot';
} else if ( threeObject instanceof THREE.HemisphereLight ) {
value = 'hemisphere';
} else {
value = 'point';
}
break;
case "enable":
value = ( threeObject.parent !== undefined );
break;
case "position":
if ( threeObject.position !== null ) {
value = [ threeObject.position.x, threeObject.position.y, threeObject.position.z ];
}
break;
case "distance":
value = threeObject.distance;
break;
case "color":
var clr = new utility.color( [ threeObject.color.r * 255, threeObject.color.g * 255,
threeObject.color.b * 255 ] )
value = clr.toString();
break;
case "groundColor":
var clr = new utility.color( [ threeObject.groundColor.r * 255, threeObject.groundColor.g * 255,
threeObject.groundColor.b * 255 ] )
value = clr.toString();
break;
case "intensity":
value = threeObject.intensity;
break;
case "castShadows":
value = threeObject.castShadow;
break;
case "shadowCameraBottom":
value = threeObject.shadowCameraBottom;
break;
case "shadowCameraLeft":
value = threeObject.shadowCameraLeft;
break;
case "shadowCameraRight":
value = threeObject.shadowCameraRight;
break;
case "shadowCameraTop":
value = threeObject.shadowCameraTop;
break;
case "shadowCameraNear":
value = threeObject.shadowCameraNear;
break;
case "shadowCameraFar":
value = threeObject.shadowCameraFar;
break;
case "shadowDarkness":
value = threeObject.shadowDarkness;
break;
case "shadowMapHeight":
value = threeObject.shadowMapHeight;
break;
case "shadowMapWidth":
value = threeObject.shadowMapWidth;
break;
case "shadowBias":
value = threeObject.shadowBias;
break;
case "target":
// TODO: Return target node information if target is a node.
// The threeObjects of some nodes do not have a vwfID. This
// will incorrectly return a position in those cases. This
// needs to be fixed.
if ( threeObject.target !== undefined ) {
if ( threeObject.target.vwfID !== undefined ) {
value = threeObject.target.vwfID;
} else {
var targetPos = [ threeObject.target.position.x,
threeObject.target.position.y,
threeObject.target.position.z ];
value = targetPos;
}
}
break;
}
}
return value;
},
// TODO: deletingMethod
// -- callingMethod --------------------------------------------------------------------------
callingMethod: function( nodeID, methodName, parameters /* [, parameter1, parameter2, ... ] */ ) { // TODO: parameters
if ( methodName === "raycast" ) {
var origin, direction, near, far, recursive, objectIDs;
if ( parameters ) {
if ( parameters[0] instanceof THREE.Vector3 ) {
origin = parameters[0];
} else if ( parameters[0] instanceof Array && parameters[0].length === 3 ) {
var x, y, z;
x = isNaN( parameters[0][0] ) ? 0 : parameters[0][0];
y = isNaN( parameters[0][1] ) ? 0 : parameters[0][1];
z = isNaN( parameters[0][2] ) ? 0 : parameters[0][2];
origin = new THREE.Vector3( x, y, z );
} else {
origin = new THREE.Vector3();
}
if ( parameters[1] instanceof THREE.Vector3 ) {
direction = parameters[1];
} else if ( parameters[1] instanceof Array && parameters[1].length === 3 ) {
var x, y, z;
x = isNaN( parameters[1][0] ) ? 0 : parameters[1][0];
y = isNaN( parameters[1][1] ) ? 0 : parameters[1][1];
z = isNaN( parameters[1][2] ) ? 0 : parameters[1][2];
direction = new THREE.Vector3( x, y, z );
} else {
direction = new THREE.Vector3();
}
near = isNaN( parameters[2] ) ? 0 : parameters[2];
far = isNaN( parameters[3] ) ? Infinity : parameters[3];
recursive = typeof parameters[4] === "boolean" ? parameters[4] : false;
if ( parameters[5] instanceof Array ) {
objectIDs = parameters[5];
} else if ( utility.isString( parameters[5] ) ) {
objectIDs = new Array();
objectIDs.push( parameters[5] );
} else {
objectIDs = null;
}
} else {
origin = new THREE.Vector3();
direction = new THREE.Vector3();
near = 0;
far = Infinity;
recursive = false;
objectIDs = null;
}
var objects = new Array();
if ( objectIDs !== null ) {
for ( var i = 0; i < objectIDs.length; i++ ) {
var object = this.state.nodes[ objectIDs[i] ];
if ( object !== undefined && object.threeObject !== undefined ) {
objects.push( object.threeObject );
}
}
} else {
for ( nodeID in this.state.nodes ) {
var object = this.state.nodes[ nodeID ];
if ( object.threeObject !== undefined ) {
objects.push( object.threeObject );
}
}
}
var raycaster = new THREE.Raycaster( origin, direction, near, far );
var intersects = raycaster.intersectObjects( objects, recursive );
return intersects;
}
return undefined;
},
// TODO: creatingEvent, deltetingEvent, firingEvent
// -- executing ------------------------------------------------------------------------------
executing: function( nodeID, scriptText, scriptType ) {
return undefined;
},
// == ticking =============================================================================
ticking: function( vwfTime ) {
if ( checkLights && this.state.appInitialized && sceneCreated ) {
var lightsInScene = sceneLights.call( this );
createDefaultLighting.call( this, lightsInScene );
checkLights = false;
}
}
} );
// == PRIVATE ========================================================================================
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;
}
function getPrototypes( kernel, extendsID ) {
var prototypes = [];
var id = extendsID;
while ( id !== undefined ) {
prototypes.push( id );
id = kernel.prototype( id );
}
return prototypes;
}
function getThreeScene( id ) {
if ( id === undefined ) {
id = this.kernel.application();
}
if ( this.state.scenes[ id ] ) {
return this.state.scenes[ id ].threeScene;
}
return undefined;
}
function isSceneDefinition( prototypes ) {
var foundScene = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundScene; i++ ) {
foundScene = ( prototypes[i] == "http://vwf.example.com/navscene.vwf" || prototypes[i] == "http://vwf.example.com/scene.vwf" );
}
}
return foundScene;
}
function isMaterialDefinition( prototypes ) {
var foundMaterial = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundMaterial; i++ ) {
foundMaterial = ( prototypes[i] == "http://vwf.example.com/material.vwf" );
}
}
return foundMaterial;
}
function isShaderMaterialDefinition( prototypes ) {
var foundMaterial = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundMaterial; i++ ) {
foundMaterial = ( prototypes[i] == "http://vwf.example.com/shaderMaterial.vwf" );
}
}
return foundMaterial;
}
function isShaderUniformsDefinition( prototypes ) {
var found = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !found; i++ ) {
found = ( prototypes[i] == "http://vwf.example.com/threejs/uniforms.vwf" );
}
}
return found;
}
function isTextureDefinition( prototypes ) {
var found = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !found; i++ ) {
found = ( prototypes[i] == "http://vwf.example.com/texture.vwf" );
}
}
return found;
}
function isCameraDefinition( prototypes ) {
var foundCamera = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundCamera; i++ ) {
foundCamera = ( prototypes[i] == "http://vwf.example.com/camera.vwf" );
}
}
return foundCamera;
}
function isParticleDefinition( prototypes ) {
var foundSystem = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundSystem; i++ ) {
foundSystem = ( prototypes[i] == "http://vwf.example.com/particlesystem.vwf" );
}
}
return foundSystem;
}
function isNodeDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/node3.vwf" );
}
}
return foundNode;
}
function isStarFieldDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/threejs/starfield.vwf" );
}
}
return foundNode;
}
function isCubeDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/threejs/cube.vwf" );
}
}
return foundNode;
}
function isCircleDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/threejs/circle.vwf" );
}
}
return foundNode;
}
function isPlaneDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/threejs/plane.vwf" );
}
}
return foundNode;
}
function isSphereDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/threejs/sphere.vwf" );
}
}
return foundNode;
}
function isCylinderDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/threejs/cylinder.vwf" );
}
}
return foundNode;
}
function isTextDefinition( prototypes ) {
var foundNode = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundNode; i++ ) {
foundNode = ( prototypes[i] == "http://vwf.example.com/threejs/text.vwf" );
}
}
return foundNode;
}
function supportedFileType( type ) {
return ( type == "model/vnd.collada+xml" ||
type == "model/vnd.osgjs+json+compressed" ||
type == "model/x-threejs-morphanim+json" ||
type == "model/vnd.gltf+json" ||
type == "model/x-threejs-skinned+json" );
}
function CreateThreeJSSceneNode( parentID, thisID, extendsID )
{
var node = {};
node.name = "scene";
node.camera = {
"ID": undefined,
"defaultCamera": CreateThreeCamera()
};
node.ID = thisID;
node.parentID = parentID;
node.type = extendsID;
node.viewInited = false;
node.modelInited = false;
node.threeScene = new THREE.Scene();
node.threeScene.name = "scene";
node.pendingLoads = 0;
node.srcAssetObjects = [];
node.rendererProperties = {};
return node;
}
function nameTest( obj, name ) {
if ( obj.name == "" ) {
return ( obj.parent.name+"Child" == name );
} else {
return ( obj.name == name || obj.id == name || obj.vwfID == name );
}
}
// Changing this function significantly from the GLGE code
// Will search hierarchy down until encountering a matching child
// Will look into nodes that don't match.... this might not be desirable
function FindChildByName( obj, childName, childType, recursive ) {
var child = undefined;
if ( recursive ) {
// TODO: If the obj itself has the child name, the object will be returned by this function
// I don't think this this desirable.
if( nameTest.call( this, obj, childName ) ) {
child = obj;
} else if ( obj.children && obj.children.length > 0) {
for( var i = 0; i < obj.children.length && child === undefined; i++ ) {
child = FindChildByName( obj.children[i], childName, childType, true );
}
}
} else {
if ( obj.children ) {
for( var i = 0; i < obj.children.length && child === undefined; i++ ) {
if ( nameTest.call( this, obj.children[i], childName ) ) {
child = obj.children[i];
}
}
}
}
return child;
}
function findObject( objName, type ) {
//there is no global registry of threejs objects. return undefined;
return undefined;
}
function CreateThreeCamera()
{
var cam = new THREE.PerspectiveCamera( 35, $(document).width()/$(document).height() , 0.01, 10000 );
cam.matrixAutoUpdate = false;
cam.up = new THREE.Vector3( 0, 0, 1 );
cam.matrix.elements = [ 1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1 ];
cam.updateMatrixWorld( true );
return cam;
}
function createAmbientLight( threeScene, clr ){
var ambient = new THREE.AmbientLight();
if ( clr !== undefined && clr instanceof Array ) {
ambient.color.r = clr[0];
ambient.color.g = clr[1];
ambient.color.b = clr[2];
} else {
ambient.color.r = 0.5;
ambient.color.g = 0.5;
ambient.color.b = 0.5;
}
threeScene.add( ambient );
}
function createCamera( nodeID, childID, childName ) {
var sceneNode = this.state.scenes[ nodeID ];
var parent = sceneNode ? sceneNode : this.state.nodes[ nodeID ];
if ( !sceneNode ) sceneNode = this.state.scenes[ parent.sceneID ];
if ( sceneNode && parent ) {
var child = this.state.nodes[ childID ];
if ( child ) {
var cam = CreateThreeCamera.call( this );;
var threeParent = parent.threeObject;
if( !threeParent ) threeParent = parent.threeScene;
if ( threeParent && threeParent.add ) {
threeParent.add( cam );
}
child.name = childName;
child.threeObject = cam;
child.uid = child.threeObject.uid;
cam.name = childName;
}
}
}
function getThreeObject( ID ) {
var threeObject = undefined;
var node = this.state.nodes[ ID ]; // { name: childName, glgeObject: undefined }
if( node === undefined ) node = this.state.scenes[ ID ]; // { name: childName, glgeObject: undefined }
if( node ) {
threeObject = node.threeObject;
if( !threeObject )
threeObject = node.threeScene;
}
return threeObject;
}
function findAllGeometries( threeObject, list ) {
if( threeObject === undefined ) return;
if( list === undefined ) list = [];
if( threeObject instanceof THREE.Geometry )
list.push( threeObject );
if( threeObject.children ) {
for( var i = 0; i < threeObject.children.length; i++ ) {
findAllGeometries( threeObject.children[i], list );
}
}
return list;
}
function findAllMeshes(threeObject,list)
{
if(!threeObject) return;
if(!list) list = [];
if(threeObject instanceof THREE.Mesh)
list.push(threeObject);
if(threeObject.children)
{
for(var i = 0; i < threeObject.children.length; i++)
{
findAllMeshes(threeObject.children[i],list);
}
}
return list;
}
function createLightContainer() {
return {
"ambientLights": [],
"directionalLights": [],
"spotLights": [],
"pointLights": []
};
}
function findAllLights( threeObject, lights ) {
if( !threeObject )
return;
if ( threeObject instanceof THREE.DirectionalLight )
lights.directionalLights.push( threeObject );
else if ( threeObject instanceof THREE.SpotLight )
lights.spotLights.push( threeObject );
else if ( threeObject instanceof THREE.PointLight )
lights.pointLights.push( threeObject );
else if ( threeObject instanceof THREE.AmbientLight )
lights.ambientLights.push( threeObject );
if( threeObject.children ) {
for ( var i = 0; i < threeObject.children.length; i++) {
findAllLights( threeObject.children[ i ], lights );
}
}
return lights;
}
function getMeshVertexIndices(mesh)
{
var ret = [];
for(var i = 0; i < mesh.geometry.faces.length; i++)
{
var face = mesh.geometry.faces[i];
ret.push([face.a,face.b,face.c]);
}
return ret;
}
//Get all mesh verts. Transform via matrix stack up to threeObject. Thus, get all sub mesh verts relative to this object's transform
function getMeshVertices(mesh,threeObject )
{
var matrix = new THREE.Matrix4();
matrix.copy(mesh.matrix);
var parent = mesh.parent;
while(parent && parent != threeObject)
{
var mat = new THREE.Matrix4();
mat.copy(parent.matrix);
matrix = matrix.multiplyMatrices(mat,matrix);
parent = parent.parent;
}
var mat = new THREE.Matrix4();
mat.copy(threeObject.matrix);
matrix = matrix.multiplyMatrices(mat,matrix);
var ret = [];
for(var i = 0; i < mesh.geometry.vertices.length; i++)
{
var vert = new THREE.Vector3();
vert.copy(mesh.geometry.vertices[i]);
vert.applyMatrix4( matrix );
ret.push([vert.x,-vert.y,vert.z]);
}
return ret;
}
function GetAllMaterials( threeObject ) {
var result = [];
var resultUUID = [];
if ( !threeObject ) {
return result;
}
if ( threeObject && threeObject.material ) {
if ( ( threeObject.material instanceof THREE.Material ) && ( resultUUID.indexOf( threeObject.material.uuid ) < 0 ) ) {
result.push( threeObject.material );
resultUUID.push( threeObject.material.uuid );
}
else if ( threeObject.material instanceof THREE.MeshFaceMaterial ) {
if ( threeObject.material.materials ) {
for ( var index = 0; index < threeObject.material.materials.length; index++ ) {
if ( ( threeObject.material.materials[ index ] instanceof THREE.Material ) && ( resultUUID.indexOf( threeObject.material.materials[ index ].uuid ) < 0 ) ) {
result.push( threeObject.material.materials[ index ] );
resultUUID.push( threeObject.material.materials[ index ].uuid );
}
}
}
}
}
if ( threeObject && threeObject.children ) {
for ( var index = 0; index < threeObject.children.length; index++ ) {
var childrenMaterials = GetAllMaterials( threeObject.children[ index ] );
for ( var subindex = 0; subindex < childrenMaterials.length; subindex++ ) {
if ( resultUUID.indexOf( childrenMaterials[ subindex ].uuid ) < 0 ) {
result.push( childrenMaterials[ subindex ] );
resultUUID.push( childrenMaterials[ subindex ].uuid );
}
}
}
}
return result;
}
//do a depth first search of the children, return the first material
function GetMaterial(threeObject, optionalName)
{
//something must be pretty seriously wrong if no threeobject
if(!threeObject)
{
return null;
}
var allMaterialChildren = GetAllMaterials( threeObject );
if ( optionalName ) {
var regExResult = optionalName.match(/^material_\d+_/);
if ( regExResult ) {
var updatedName = optionalName.slice( regExResult[ 0 ].length );
var firstMatch = undefined;
var nameIndex = parseInt( optionalName.slice( 9, regExResult[ 0 ].length - 1 ) );
var foundIndex = 0;
for ( var index = 0; index < allMaterialChildren.length; index++ ) {
if ( allMaterialChildren[ index ].name == updatedName ) {
if ( ! firstMatch ) {
firstMatch = allMaterialChildren[ index ];
}
foundIndex++;
if ( foundIndex == nameIndex ) {
return allMaterialChildren[ index ];
}
}
}
if ( firstMatch ) {
return firstMatch;
}
}
for ( var index = 0; index < allMaterialChildren.length; index++ ) {
if ( allMaterialChildren[ index ].name == optionalName ) {
return allMaterialChildren[ index ];
}
}
}
if ( allMaterialChildren.length > 0 ) {
return allMaterialChildren[ 0 ];
}
return null;
}
function GetAllLeafMeshes(threeObject,list)
{
if(threeObject instanceof THREE.Mesh)
{
list.push(threeObject);
}
if(threeObject.children)
{
for(var i=0; i < threeObject.children.length; i++)
{
GetAllLeafMeshes(threeObject.children[i],list);
}
}
}
function fixMissingUVs(mesh)
{
if ( mesh.geometry instanceof THREE.BufferGeometry ) {
return;
}
var geometry = mesh.geometry;
if ( !geometry.faceVertexUvs[ 0 ] ) {
geometry.faceVertexUvs[ 0 ] = [];
}
if ( geometry.faceVertexUvs[ 0 ].length === 0 ) {
for ( var i = 0; i < geometry.faces.length; i++ ) {
var face = geometry.faces[ i ];
if ( face instanceof THREE.Face4 ) {
geometry.faceVertexUvs[0].push( [ new THREE.Vector2( 0, 1 ),
new THREE.Vector2( 0, 1 ),
new THREE.Vector2( 0, 1 ),
new THREE.Vector2( 0, 1 )
] );
} else if ( face instanceof THREE.Face3 ) {
geometry.faceVertexUvs[0].push( [ new THREE.Vector2( 0, 1 ),
new THREE.Vector2( 0, 1 ),
new THREE.Vector2( 0, 1 )
] );
}
}
}
geometry.computeCentroids && geometry.computeCentroids();
geometry.computeFaceNormals && geometry.computeFaceNormals();
geometry.computeVertexNormals && geometry.computeVertexNormals();
geometry.uvsNeedUpdate = true;
}
//set the material on all the sub meshes of an object.
//This could cause some strangeness in cases where an asset has multiple sub materials
//best to only specify the material sub-node where an asset is a mesh leaf
function SetMaterial( threeObject, material, materialname )
{
//something must be pretty seriously wrong if no threeobject
if(!threeObject)
return null;
var meshes =[];
GetAllLeafMeshes(threeObject,meshes);
//apply to all sub meshes
if(!materialname || materialname == 'material')
{
for(var i=0; i < meshes.length; i++)
{
meshes[i].material = material;
meshes[i].needsUpdate = true;
}
}else
{
var index = parseInt(materialname.substr(8));
if(meshes[index])
{
meshes[index].material = material;
meshes[index].needsUpdate = true;
window._dMesh =meshes[index];
}
}
}
function createShader( shaderDef ) {
var shaderMaterial = undefined;
if ( shaderDef && shaderDef.shaderType ) {
if ( THREE.ShaderLib[ shaderDef.shaderType ] !== undefined ) {
var shader = THREE.ShaderLib[ shaderDef.shaderType ];
var uniforms = THREE.UniformsUtils.clone( shader.uniforms );
var mergedShader = {
fragmentShader: shader.fragmentShader,
vertexShader: shader.vertexShader,
uniforms: uniforms
};
for ( var prop in shaderDef ) {
switch ( prop ) {
case "shaderType":
break;
case "uniforms":
for ( var uProp in shaderDef.uniforms ) {
var uniProp = shaderDef.uniforms[ uProp ];
setUniformProperty( mergedShader.uniforms, uProp, uniProp.type, uniProp.pValue );
}
break;
default:
mergedShader[ prop ] = shaderDef[ prop ];
break;
}
}
shaderMaterial = new THREE.ShaderMaterial( mergedShader );
} else {
shaderMaterial = new THREE.ShaderMaterial( shaderDef );
}
}
return shaderMaterial;
}
function createGeometry( node, meshDef, doubleSided ) {
var geo = undefined;
var i, face, sides;
if ( ( node && isCubeDefinition.call( this, node.prototypes ) ) || meshDef.type === "box" ) {
sides = meshDef.sides || { px: true, nx: true, py: true, ny: true, pz: true, nz: true };
geo = new THREE.BoxGeometry( meshDef.width || 10, meshDef.height || 10, meshDef.depth || 10,
meshDef.segmentsWidth || 1, meshDef.segmentsHeight || 1, meshDef.segmentsDepth || 1 );
} else if ( ( node && isPlaneDefinition.call( this, node.prototypes ) ) || meshDef.type === "plane" ) {
geo = new THREE.PlaneGeometry( meshDef.width || 1, meshDef.height || 1,
meshDef.segmentsWidth || 1, meshDef.segmentsHeight || 1 );
} else if ( ( node && isCircleDefinition.call( this, node.prototypes ) ) || meshDef.type === "circle" ) {
geo = new THREE.CircleGeometry( meshDef.radius || 10,
meshDef.segments || 8, meshDef.thetaStart || 0,
meshDef.thetaLength || Math.PI * 2 );
} else if ( ( node && isSphereDefinition.call( this, node.prototypes ) ) || meshDef.type === "sphere" ) {
geo = new THREE.SphereGeometry( meshDef.radius || 10, meshDef.segmentsWidth || 8,
meshDef.segmentsHeight || 6, meshDef.phiStart || 0,
meshDef.phiLength || Math.PI * 2, meshDef.thetaStart || 0,
meshDef.thetaLength || Math.PI );
} else if ( ( node && isCylinderDefinition.call( this, node.prototypes ) ) || meshDef.type === "cylinder" ) {
geo = new THREE.CylinderGeometry( meshDef.radiusTop || 10, meshDef.radiusBottom || 10,
meshDef.height || 10, meshDef.segmentsRadius || 8,
meshDef.segmentsHeight || 1, meshDef.openEnded );
} else if ( ( node && isTextDefinition.call( this, node.prototypes ) ) || meshDef.type === "text" ) {
if ( meshDef.text != "" ) {
var parms = meshDef.parameters || {};
geo = new THREE.TextGeometry( meshDef.text, { "size": parms.size || 100,
"curveSegments": parms.curveSegments || 4, "font": parms.font || "helvetiker",
"weight": parms.weight || "normal", "style": parms.style || "normal",
"amount": parms.amount || 50, "height": parms.height || 50,
"bevelThickness": parms.bevelThickness || 10, "bevelSize": parms.bevelSize || 8,
"bevelEnabled": Boolean( parms.bevelEnabled ),
} );
// geo = new THREE.TextGeometry( meshDef.text, {
// size: 80,
// height: 20,
// curveSegments: 2,
// font: "helvetiker"
// } );
}
} else {
geo = new THREE.Geometry();
for ( i = 0; geo.vertices && meshDef.positions && ((i*3) < meshDef.positions.length); i++ ) {
//console.info( " adding vertices: [" + (meshDef.positions[i*3]) + ", " + (meshDef.positions[i*3+1]) + ", "+ (meshDef.positions[i*3+2]) + " ]" )
geo.vertices.push( new THREE.Vector3( meshDef.positions[i*3], meshDef.positions[i*3+1],meshDef.positions[i*3+2] ) );
}
for ( i = 0; geo.faces && meshDef.faces && ( (i*3) < meshDef.faces.length ); i++ ) {
//console.info( " adding face: [" + (meshDef.faces[i*3]) + ", " + (meshDef.faces[i*3+1]) + ", "+ (meshDef.faces[i*3+2]) + " ]" );
face = new THREE.Face3( meshDef.faces[i*3], meshDef.faces[i*3+1],meshDef.faces[i*3+2] );
geo.faces.push( face );
if ( doubleSided ) {
//console.info( " adding face: [" + (meshDef.faces[i*3+2]) + ", " + (meshDef.faces[i*3+1]) + ", "+ (meshDef.faces[i*3]) + " ]" );
face = new THREE.Face3( meshDef.faces[i*3+2], meshDef.faces[i*3+1],meshDef.faces[i*3] );
geo.faces.push( face );
}
}
// TODO: needed doubleSided support for normals
for ( i = 0 ; geo.faces && meshDef.normals && i < geo.faces.length; i++ ) {
face = geo.faces[ i ];
//console.info( " adding face normal: [" + (meshDef.normals[i*3]) + ", " + (meshDef.normals[i*3+1]) + ", "+ (meshDef.normals[i*3+2]) + " ]" );
face.vertexNormals.push( new THREE.Vector3( meshDef.normals[i*3], meshDef.normals[i*3+1],meshDef.normals[i*3+2] ) );
}
for ( i = 0; geo.faceVertexUvs && meshDef.uv1 && i < meshDef.uv1.length; i++ ) {
//console.info( " adding face vertex uv: [" + (meshDef.uv1[i*2]) + ", " + (meshDef.uv1[i*2+1]) + " ]" );
geo.faceVertexUvs.push( new THREE.Vector2( meshDef.uv1[i*2], meshDef.uv1[i*2+1] ) );
}
}
return geo;
}
function createMesh( node, meshDef, doubleSided ) {
if ( node.threeObject && node.threeObject instanceof THREE.Object3D ) {
var vwfColor, colorValue = 0xFFFFFF;
if ( meshDef.color !== undefined ) {
vwfColor = new utility.color( meshDef.color );
if ( vwfColor ) {
colorValue = vwfColor._decimal;
}
}
var mat = new THREE.MeshLambertMaterial( { "color": colorValue, "ambient": colorValue, side: THREE.DoubleSide } );
var geo = createGeometry( node, meshDef, doubleSided );
if ( meshDef.children ) {
var childGeo = undefined;
var matrix = new THREE.Matrix4();
var trans = [];
for ( var child in meshDef.children ) {
childGeo = createGeometry( undefined, meshDef.children[ child ], doubleSided );
if ( childGeo ) {
trans[ 0 ] = meshDef.children[ child ].properties.translation[ 0 ] || 0;
trans[ 1 ] = meshDef.children[ child ].properties.translation[ 1 ] || 0;
trans[ 2 ] = meshDef.children[ child ].properties.translation[ 2 ] || 0;
geo.merge( childGeo, matrix.makeTranslation( trans[ 0 ], trans[ 1 ], trans[ 2 ] ) );
}
}
geo.computeBoundingBoxSphere && geo.computeBoundingBoxSphere();
}
if ( geo !== undefined ) {
//geo.computeTangents && geo.computeTangents();
var mesh = new THREE.Mesh( geo, mat );
// The child mesh is created after the properties have been initialized, so copy
// the values of cast and receive shadow so they match
mesh.castShadow = node.threeObject.castShadow;
mesh.receiveShadow = node.threeObject.receiveShadow;
node.threeObject.add( mesh );
node.threeObject.vwfID = node.ID;
node.threeObject.name = node.name;
mesh.vwfID = node.ID;
mesh.name = node.name;
//geo.computeCentroids();
geo.computeFaceNormals && geo.computeFaceNormals();
}
}
}
//walk the graph of an object, and set all materials to new material clones
function cloneMaterials( nodein ) {
//sort the materials in the model, and when cloneing, make the new model share the same material setup as the old.
var materialMap = {};
walkGraph( nodein, function( node ) {
if(node.material) {
if ( node.material instanceof THREE.Material ) {
if(!materialMap[node.material.uuid]) {
materialMap[node.material.uuid] = [];
}
materialMap[node.material.uuid].push( [ node, -1 ] );
}
else if ( node.material instanceof THREE.MeshFaceMaterial ) {
if ( node.material.materials ) {
for ( var index = 0; index < node.material.materials.length; index++ ) {
if ( node.material.materials[ index ] instanceof THREE.Material ) {
if(!materialMap[node.material.materials[ index ].uuid]) {
materialMap[node.material.materials[ index ].uuid] = [];
}
materialMap[node.material.materials[ index ].uuid].push( [ node, index ] );
}
}
}
}
}
});
for(var i in materialMap)
{
var newmat;
if ( materialMap[ i ][ 0 ][ 1 ] < 0 ) {
newmat = materialMap[ i ][ 0 ][ 0 ].material.clone( );
}
else {
newmat = materialMap[ i ][ 0 ][ 0 ].material.materials[ materialMap[ i ][ 0 ][ 1 ] ].clone( );
}
for ( var j =0; j < materialMap[i].length; j++ ) {
if ( materialMap[ i ][ j ][ 1 ] < 0 ) {
materialMap[ i ][ j ][ 0 ].material = newmat;
}
else {
materialMap[ i ][ j ][ 0 ].material.materials[ materialMap[ i ][ j ][ 1 ] ] = newmat;
}
}
}
}
function loadAsset( parentNode, node, childType, propertyNotifyCallback ) {
var nodeCopy = node;
var nodeID = node.ID;
var childName = node.name;
var threeModel = this;
var sceneNode = this.state.scenes[ this.kernel.application() ];
var parentObject3 = parentNode.threeObject ? parentNode.threeObject : parentNode.threeScene;
//console.info( "---- loadAsset( "+parentNode.name+", "+node.name+", "+childType+" )" );
node.assetLoaded = function( geometry , materials) {
//console.info( "++++ assetLoaded( "+parentNode.name+", "+node.name+", "+childType+" )" );
sceneNode.pendingLoads--;
var removed = false;
// THREE JSON model
if ( childType == "model/x-threejs-morphanim+json" || childType == "model/x-threejs-skinned+json" ) {
for ( var i = 0; i < materials.length; i++ ) {
var m = materials[ i ];
// Do we have Morph Target animations?
if ( geometry.morphTargets.length > 0 ) {
m.morphTargets = true;
}
// Do we have skeletal animations?
if ( geometry.animation ) {
m.skinning = true;
}
}
var meshMaterial;
if ( materials.length > 1 ) {
// THREE.MeshFaceMaterial for meshes that have multiple materials
meshMaterial = new THREE.MeshFaceMaterial( materials );
} else {
// This mesh has only one material
meshMaterial = materials[ 0 ];
}
if ( childType == "model/x-threejs-morphanim+json" ) {
var asset = new THREE.MorphAnimMesh( geometry, meshMaterial );
} else { // childType == "model/x-threejs-skinned+json"
// THREE.AnimationHandler had a couple of methods
// depricated, check THREE.UCSCharacter
// THREE.AnimationHandler.add( geometry.animation );
var asset = new THREE.SkinnedMesh( geometry, meshMaterial );
var skinnedAnimation = new THREE.Animation( asset, geometry.animation );
skinnedAnimation.play();
}
asset.updateMatrix();
} else { // Collada model
var asset = geometry;
}
var keyframeAnimations, animatedMesh;
if ( asset.animations && asset.animations.length > 0 ) {
keyframeAnimations = asset.animations;
}
if ( asset.scene ) {
asset = asset.scene;
}
var meshes = [];
GetAllLeafMeshes( asset, meshes );
for ( var i = 0; i < meshes.length; i++ ) {
if ( meshes[ i ].material.map != null ) {
fixMissingUVs( meshes[ i ] );
}
}
asset.updateMatrixWorld();
asset.matrix = new THREE.Matrix4();
asset.matrixAutoUpdate = false;
// Don't make a copy of the three object if there are keyframe or skeletal animations associated with it
// until we figure out a way to copy them successfully.
if ( keyframeAnimations || skinnedAnimation ) {
nodeCopy.threeObject = asset;
}
else {
nodeCopy.threeObject = asset.clone();
}
//make sure that the new object has a unique material
cloneMaterials( nodeCopy.threeObject );
//find and bind the animations
//NOTE: this would probably be better handled by walking and finding the animations and skins only on the
//property setter when needed.
animatedMesh = [];
walkGraph(nodeCopy.threeObject,function( node ){
if( node instanceof THREE.SkinnedMesh || node instanceof THREE.MorphAnimMesh ) {
animatedMesh.push( node );
}
});
nodeCopy.threeObject.animatedMesh = animatedMesh;
nodeCopy.threeObject.updateMatrixWorld();
removeAmbientLights.call( this, nodeCopy.threeObject );
parentObject3.add( nodeCopy.threeObject );
nodeCopy.threeObject.name = childName;
nodeCopy.threeObject.vwfID = nodeID;
nodeCopy.threeObject.matrixAutoUpdate = false;
if( keyframeAnimations ) {
//var animHandler = THREE.AnimationHandler;
nodeCopy.threeObject.kfAnimations = [];
nodeCopy.threeObject.animations = keyframeAnimations;
// Initialize the key frame animations
for ( var i = 0; i < keyframeAnimations.length; i++ ) {
var animation = keyframeAnimations[ i ];
if ( !animation.node ) {
continue;
}
// Save references to the animations on the node that is animated, so that it can play separately
if( animation.node.animations == undefined ) {
animation.node.animations = [];
}
if( animation.node.kfAnimations == undefined ) {
animation.node.kfAnimations = [];
}
animation.node.animations.push( animation );
// add has been depricated
//animHandler.add( animation );
//var kfAnimation = new THREE.KeyFrameAnimation( animation.node, animation.name );
var kfAnimation = new THREE.KeyFrameAnimation( animation );
kfAnimation.timeScale = 1;
nodeCopy.threeObject.kfAnimations.push( kfAnimation );
animation.node.kfAnimations.push( kfAnimation );
for ( var h = 0; h < kfAnimation.hierarchy.length; h++ ) {
var keys = kfAnimation.data.hierarchy[ h ].keys;
var sids = kfAnimation.data.hierarchy[ h ].sids;
var obj = kfAnimation.hierarchy[ h ];
if ( keys.length && sids ) {
for(var s = 0; s < sids.length; s++) {
var sid = sids[s];
var next = kfAnimation.getNextKeyWith(sid, h, 0);
if(next) next.apply(sid);
}
obj.matrixAutoUpdate = false;
kfAnimation.data.hierarchy[h].node.updateMatrix();
obj.matrixWorldNeedsUpdate = true;
}
}
kfAnimation.play(false, 0);
}
}
if(animatedMesh) {
nodeCopy.threeObject.animatedMesh = animatedMesh;
}
// remember that this was a loaded collada file
nodeCopy.threeObject.loadedColladaNode = true;
for ( var j = 0; j < sceneNode.srcAssetObjects.length; j++ ) {
if ( sceneNode.srcAssetObjects[j] == nodeCopy ){
sceneNode.srcAssetObjects.splice( j, 1 );
removed = true;
}
}
updateStoredTransform( node );
// 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
propertyNotifyCallback();
// let vwf know the asset is loaded
if ( nodeCopy.loadingCallback ) {
//console.info( "========= LOADED ========== "+node.name+" ========= LOADED ==========" );
nodeCopy.loadingCallback( true );
}
//get the entry from the asset registry
reg = threeModel.assetRegistry[nodeCopy.source];
// If there are animations, set loaded to false and don't store the asset
// in the registry, since the animations don't work with the copy process
if(keyframeAnimations) {
reg.pending = false;
reg.loaded = false;
}
else {
//it's not pending, and it is loaded
reg.pending = false;
reg.loaded = true;
//store this asset in the registry
reg.node = asset;
}
//if any callbacks were waiting on the asset, call those callbacks
for( var i = 0; i < reg.callbacks.length; i++ ) {
reg.callbacks[i]( asset );
}
//nothing should be waiting on callbacks now.
reg.callbacks = [];
}
node.name = childName;
//create an asset registry if one does not exist for this driver
if( !this.assetRegistry ) {
this.assetRegistry = {};
}
// if there is no entry in the registry, create one
if( !this.assetRegistry[node.source] ) {
//it's new, so not waiting, and not loaded
this.assetRegistry[node.source] = {};
this.assetRegistry[node.source].loaded = false;
this.assetRegistry[node.source].pending = false;
this.assetRegistry[node.source].callbacks = [];
}
//grab the registry entry for this asset
var reg = this.assetRegistry[node.source];
//if the asset entry is not loaded and not pending, you'll have to actually go download and parse it
if( reg.loaded == false && reg.pending == false ) {
//thus, it becomes pending
reg.pending = true;
sceneNode.srcAssetObjects.push( node.threeObject );
//node.threeObject.vwfID = nodeID;
sceneNode.pendingLoads++;
switch ( childType ) {
case "model/vnd.collada+xml":
node.parse = true;
node.loader = new THREE.ColladaLoader();
node.loader.options.convertUpAxis = true;
node.loader.options.upAxis = "Z";
node.loader.load(node.source,node.assetLoaded.bind( this ));
break;
case "model/vnd.osgjs+json+compressed":
node.loader = new UTF8JsonLoader( node,node.assetLoaded.bind( this ) );
break;
case "model/x-threejs-morphanim+json":
case "model/x-threejs-skinned+json":
node.loader = new THREE.JSONLoader()
node.loader.load( node.source, node.assetLoaded.bind( this ) );
break;
case "model/vnd.gltf+json":
//create a queue to hold requests to the loader, since the loader cannot be re-entered for parallel loads
if ( !THREE.glTFLoader.queue )
{
//task is an object that holds the info about what to load
//nextTask is supplied by async to trigger the next in the queue
THREE.glTFLoader.queue = new async.queue( function( task, nextTask ) {
var node = task.node;
var cb = task.cb;
//call the actual load function
//signature of callback dictated by loader
node.loader.load( node.source, function( geometry , materials ) {
//ok, this model loaded, we can start the next load
nextTask();
//do whatever it was (asset loaded) that this load was going to do when complete
cb( geometry , materials );
} );
}, 1 );
}
node.loader = new THREE.glTFLoader();
node.loader.useBufferGeometry = true;
//we need to queue up our entry to this module, since it cannot handle re-entry. This means that while it
//is an async function, it cannot be entered again before it completes
THREE.glTFLoader.queue.push( {
node: node,
cb: node.assetLoaded.bind( this )
} );
break;
default:
self.logger.warnx( "Unable to import " + node.source + ". Unsupported file type: " + childType );
break;
}
}
//if the asset registry entry is not pending and it is loaded, then just grab a copy,
//no download or parse necessary
else if( reg.loaded == true && reg.pending == false ) {
var asset = (reg.node.clone());
// make sure the materails are unique
cloneMaterials( asset );
var n = asset;
var skins = [];
walkGraph( n, function( node ) {
if( node instanceof THREE.SkinnedMesh || node instanceof THREE.MorphAnimMesh ) {
skins.push( node );
}
});
n.animatedMesh = skins;
nodeCopy.threeObject = asset;
nodeCopy.threeObject.matrix = new THREE.Matrix4();
nodeCopy.threeObject.matrixAutoUpdate = false;
parentObject3.add( nodeCopy.threeObject );
nodeCopy.threeObject.name = childName;
nodeCopy.threeObject.vwfID = nodeID;
nodeCopy.threeObject.matrixAutoUpdate = false;
nodeCopy.threeObject.updateMatrixWorld( true );
propertyNotifyCallback();
window.setTimeout( function() {
nodeCopy.loadingCallback( true );
}, 10);
}
//if it's pending but not done, register a callback so that when it is done, it can be attached.
else if( reg.loaded == false && reg.pending == true ) {
sceneNode.srcAssetObjects.push( node.threeObject );
//so, not necessary to do all the other VWF node goo stuff, as that will be handled by the node that requested
//the asset in teh first place
reg.callbacks.push( function( node ) {
//just clone the node and attach it.
//this should not clone the geometry, so much lower memory.
//seems to take near nothing to duplicated animated avatar
var n = node.clone();
cloneMaterials( n );
var skins = [];
walkGraph( n, function( node ) {
if( node instanceof THREE.SkinnedMesh || node instanceof THREE.MorphAnimMesh ) {
skins.push( node );
}
});
n.animatedMesh = skins;
nodeCopy.threeObject = n;
nodeCopy.threeObject.matrix = new THREE.Matrix4();
nodeCopy.threeObject.matrixAutoUpdate = false;
removeAmbientLights.call(this, nodeCopy.threeObject);
parentObject3.add( nodeCopy.threeObject );
nodeCopy.threeObject.name = childName;
nodeCopy.threeObject.vwfID = nodeID;
nodeCopy.threeObject.matrixAutoUpdate = false;
nodeCopy.threeObject.updateMatrixWorld( true );
propertyNotifyCallback();
nodeCopy.loadingCallback( true );
});
}
}
//walk the scenegraph from the given root, calling the given function on each node
function walkGraph( root, func ) {
if( root ) {
func( root );
}
for( var i =0; i < root.children.length; i++ ) {
walkGraph( root.children[i], func );
}
}
// Strips the imported scene's ambient lights
function removeAmbientLights( threeObject ) {
for( var i = threeObject.children.length -1; i >= 0; i-- )
{
if( threeObject.children[i] instanceof THREE.AmbientLight )
{
threeObject.remove( threeObject.children[i] );
}
}
}
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) );
}
$.each( this.state.nodes, function (nodeID, node) {
if ( node.threeObject == 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 isLightDefinition( prototypes ) {
var foundLight = false;
if ( prototypes ) {
for ( var i = 0; i < prototypes.length && !foundLight; i++ ) {
foundLight = ( prototypes[i] == "http://vwf.example.com/light.vwf" );
}
}
return foundLight;
}
function createLight( nodeID, childID, type, childName ) {
var child = this.state.nodes[childID];
if ( child ) {
switch( type ) {
case "http://vwf.example.com/directionallight.vwf":
child.threeObject = new THREE.DirectionalLight( 'FFFFFF' );
break;
case "http://vwf.example.com/spotlight.vwf":
child.threeObject = new THREE.SpotLight( 'FFFFFF' );
break;
case "http://vwf.example.com/hemispherelight.vwf":
child.threeObject = new THREE.HemisphereLight('FFFFFF','FFFFFF',1);
break;
case "http://vwf.example.com/pointlight.vwf":
default:
child.threeObject = new THREE.PointLight( 'FFFFFF', 1, 1000 );
break;
}
child.threeObject.name = childName;
child.name = childName;
addThreeChild.call( this, nodeID, childID );
}
}
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 CreateParticleSystem(nodeID, childID, childName )
{
var child = this.state.nodes[childID];
if ( child )
{
// create the particle variables
var particles = new THREE.Geometry();
//default material expects all computation done cpu side, just renders
// note that since the color, size, spin and orientation are just linear
// interpolations, they can be done in the shader
var vertShader_default =
"attribute float size; \n"+
"attribute vec4 vertexColor;\n"+
"varying vec4 vColor;\n"+
"attribute vec4 random;\n"+
"varying vec4 vRandom;\n"+
"uniform float sizeRange;\n"+
"uniform vec4 colorRange;\n"+
"void main() {\n"+
" vColor = vertexColor + (random -0.5) * colorRange;\n"+
" vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n"+
" float psize = size + (random.y -0.5) * sizeRange;\n"+
" gl_PointSize = psize * ( 1000.0/ length( mvPosition.xyz ) );\n"+
" gl_Position = projectionMatrix * mvPosition;\n"+
" vRandom = random;"+
"} \n";
var fragShader_default =
"uniform float useTexture;\n"+
"uniform sampler2D texture;\n"+
"varying vec4 vColor;\n"+
"varying vec4 vRandom;\n"+
"uniform float time;\n"+
"uniform float maxSpin;\n"+
"uniform float minSpin;\n"+
"uniform float maxOrientation;\n"+
"uniform float minOrientation;\n"+
"uniform float textureTiles;\n"+
"void main() {\n"+
" vec2 coord = vec2(0.0,0.0);"+
" vec2 orig_coord = vec2(gl_PointCoord.s,1.0-gl_PointCoord.t);"+
" float spin = mix(maxSpin,minSpin,vRandom.x);"+
" float orientation = mix(maxOrientation,minOrientation,vRandom.y);"+
" coord.s = (orig_coord.s-.5)*cos(time*spin+orientation)-(orig_coord.t-.5)*sin(time*spin+orientation);"+
" coord.t = (orig_coord.t-.5)*cos(time*spin+orientation)+(orig_coord.s-.5)*sin(time*spin+orientation);"+
" coord = coord + vec2(.5,.5);\n"+
" coord = coord/textureTiles;\n"+
" coord.x = clamp(coord.x,0.0,1.0/textureTiles);\n"+
" coord.y = clamp(coord.y,0.0,1.0/textureTiles);\n"+
" coord += vec2(floor(vRandom.x*textureTiles)/textureTiles,floor(vRandom.y*textureTiles)/textureTiles);\n"+
" vec4 outColor = (vColor * texture2D( texture, coord )) *useTexture + vColor * (1.0-useTexture);\n"+
" gl_FragColor = outColor;\n"+
"}\n";
//the default shader - the one used by the analytic solver, just has some simple stuff
//note that this could be changed to do just life and lifespan, and calculate the
//size and color from to uniforms. Im not going to bother
var attributes_default = {
size: { type: 'f', value: [] },
vertexColor: { type: 'v4', value: [] },
random: { type: 'v4', value: [] },
};
var uniforms_default = {
amplitude: { type: "f", value: 1.0 },
texture: { type: "t", value: new THREE.Texture( new Image() ) },
useTexture: { type: "f", value: 0.0 },
maxSpin: { type: "f", value: 0.0 },
minSpin: { type: "f", value: 0.0 },
maxOrientation: { type: "f", value: 0.0 },
minOrientation: { type: "f", value: 0.0 },
time: { type: "f", value: 0.0 },
fractime: { type: "f", value: 0.0 },
sizeRange: { type: "f", value: 0.0 },
textureTiles: { type: "f", value: 1.0 },
colorRange: { type: 'v4', value: new THREE.Vector4(0,0,0,0) },
startColor:{type: "v4", value:new THREE.Vector4()},
endColor:{type: "v4", value:new THREE.Vector4()},
startSize:{type:"f", value:1},
endSize:{type:"f", value:1},
};
uniforms_default.texture.value.wrapS = uniforms_default.texture.value.wrapT = THREE.RepeatWrapping;
var shaderMaterial_default = new THREE.ShaderMaterial( {
uniforms: uniforms_default,
attributes: attributes_default,
vertexShader: vertShader_default,
fragmentShader: fragShader_default
});
//the interpolate shader blends from one simulation step to the next on the shader
//this allows for a complex sim to run at a low framerate, but still have smooth motion
//this is very efficient, as it only requires sending data up to the gpu on each sim tick
//reuse the frag shader from the normal material
var vertShader_interpolate =
"attribute float age; \n"+
"attribute float lifespan; \n"+
"attribute vec3 previousPosition;\n"+
"varying vec4 vColor;\n"+
"attribute vec4 random;\n"+
"varying vec4 vRandom;\n"+
"uniform float sizeRange;\n"+
"uniform vec4 colorRange;\n"+
"uniform float fractime;\n"+
"uniform float startSize;\n"+
"uniform float endSize;\n"+
"uniform vec4 startColor;\n"+
"uniform vec4 endColor;\n"+
"void main() {\n"+
" vColor = mix(startColor,endColor,(age+fractime*3.33)/lifespan) + (random -0.5) * colorRange;\n"+
" vec4 mvPosition = modelViewMatrix * vec4(mix(previousPosition,position,fractime), 1.0 );\n"+
" float psize = mix(startSize,endSize,(age+fractime*3.33)/lifespan) + (random.y -0.5) * sizeRange;\n"+
" gl_PointSize = psize * ( 1000.0/ length( mvPosition.xyz ) );\n"+
" gl_Position = projectionMatrix * mvPosition;\n"+
" vRandom = random;"+
"} \n";
//the interpolation does need to remember the previous position
var attributes_interpolate = {
random: attributes_default.random,
previousPosition: { type: 'v3', value: [] },
age: { type: 'f', value: [] },
lifespan: { type: 'f', value: [] }
};
var shaderMaterial_interpolate = new THREE.ShaderMaterial( {
uniforms: uniforms_default,
attributes: attributes_interpolate,
vertexShader: vertShader_interpolate,
fragmentShader: fragShader_default
});
//analytic shader does entire simulation on GPU
//it cannot account for drag, gravity. nor can it generate new randomness. Each particle has it's randomness assigned and it
//just repeats the same motion over and over. Also, the other solvers can hold a particle until
//it can be reused based on the emitRate. This cannot, as the entire life of the particle must be
//computed from an equation given just time t. It does offset them in time to avoid all the particles
//being generated at once. Also, it does not account for emitter motion.
//upside : very very efficient. No CPU intervention required
var vertShader_analytic =
"attribute float size; \n"+
"attribute vec4 vertexColor;\n"+
"attribute vec3 acceleration;\n"+
"attribute vec3 velocity;\n"+
"attribute float lifespan;\n"+
"attribute vec4 random;\n"+
"uniform float time;\n"+
"uniform float startSize;\n"+
"uniform float endSize;\n"+
"uniform vec4 startColor;\n"+
"uniform vec4 endColor;\n"+
"varying vec4 vColor;\n"+
"varying vec4 vRandom;\n"+
"uniform float sizeRange;\n"+
"uniform vec4 colorRange;\n"+
"void main() {\n"+
//randomly offset in time
" float lifetime = mod( random.x * lifespan + time, lifespan );"+
//solve for position
" vec3 pos2 = position.xyz + velocity*lifetime + (acceleration*lifetime*lifetime)/2.0;"+ // ;
" vec4 mvPosition = modelViewMatrix * vec4( pos2.xyz, 1.0 );\n"+
//find random size based on randomness, start and end size, and size range
" float psize = mix(startSize,endSize,lifetime/lifespan) + (random.y -0.5) * sizeRange;\n"+
" gl_PointSize = psize * ( 1000.0/ length( mvPosition.xyz ) );\n"+
" gl_Position = projectionMatrix * mvPosition;\n"+
" vec4 nR = (random -0.5);\n"+
//find random color based on start and endcolor, time and colorRange
" vColor = mix(startColor,endColor,lifetime/lifespan) + nR * colorRange;\n"+
" vRandom = random;"+
"} \n";
var fragShader_analytic =
"uniform float useTexture;\n"+
"uniform sampler2D texture;\n"+
"uniform float time;\n"+
"uniform float maxSpin;\n"+
"uniform float minSpin;\n"+
"varying vec4 vColor;\n"+
"varying vec4 vRandom;\n"+
"uniform float maxOrientation;\n"+
"uniform float minOrientation;\n"+
"uniform float textureTiles;\n"+
"void main() {\n"+
//bit of drama for dividing into 4 or 9 'virtual' textures
//nice to be able to have different images on particles
" vec2 coord = vec2(0.0,0.0);"+
" vec2 orig_coord = vec2(gl_PointCoord.s,1.0-gl_PointCoord.t);"+
" float spin = mix(maxSpin,minSpin,vRandom.x);"+
" float orientation = mix(maxOrientation,minOrientation,vRandom.y);"+
" coord.s = (orig_coord.s-.5)*cos(time*spin+orientation)-(orig_coord.t-.5)*sin(time*spin+orientation);"+
" coord.t = (orig_coord.t-.5)*cos(time*spin+orientation)+(orig_coord.s-.5)*sin(time*spin+orientation);"+
" coord = coord + vec2(.5,.5);\n"+
" coord = coord/textureTiles;\n"+
" coord.x = clamp(coord.x,0.0,1.0/textureTiles);\n"+
" coord.y = clamp(coord.y,0.0,1.0/textureTiles);\n"+
" coord += vec2(floor(vRandom.x*textureTiles)/textureTiles,floor(vRandom.y*textureTiles)/textureTiles);\n"+
//get the color from the texture and blend with the vertexColor.
" vec4 outColor = (vColor * texture2D( texture, coord )) *useTexture + vColor * (1.0-useTexture);\n"+
" gl_FragColor = outColor;\n"+
"}\n";
var attributes_analytic = {
acceleration: { type: 'v3', value: [] },
velocity: { type: 'v3', value: [] },
lifespan: attributes_interpolate.lifespan,
random: attributes_default.random,
vertexColor : attributes_default.vertexColor,
size: attributes_default.size
};
var shaderMaterial_analytic = new THREE.ShaderMaterial( {
uniforms: uniforms_default,
attributes: attributes_analytic,
vertexShader: vertShader_analytic,
fragmentShader: fragShader_analytic
});
// create the particle system
var particleSystem = new THREE.PointCloud( particles, shaderMaterial_default );
//keep track of the shaders
particleSystem.shaderMaterial_analytic = shaderMaterial_analytic;
particleSystem.shaderMaterial_default = shaderMaterial_default;
particleSystem.shaderMaterial_interpolate = shaderMaterial_interpolate;
//setup all the default values
particleSystem.minVelocity = [0,0,0];
particleSystem.maxVelocity = [0,0,0];
particleSystem.maxAcceleration = [0,0,0];
particleSystem.minAcceleration = [0,0,0];
particleSystem.minLifeTime = 0;
particleSystem.maxLifeTime = 1;
particleSystem.emitterType = 'point';
particleSystem.emitterSize = [0,0,0];
particleSystem.startColor = [1,1,1,1];
particleSystem.endColor = [0,0,0,0];
particleSystem.regenParticles = [];
particleSystem.maxRate = 1000;
particleSystem.particleCount = 1000;
particleSystem.damping = 0;
particleSystem.startSize = 3;
particleSystem.endSize = 3;
particleSystem.gravity = 0;
particleSystem.gravityCenter = [0,0,0];
particleSystem.velocityMode = 'cartesian';
particleSystem.temp = new THREE.Vector3();
//create a new particle. create and store all the values for vertex attributes in each shader
particleSystem.createParticle = function(i)
{
var particle = new THREE.Vector3(0,0,0);
this.geometry.vertices.push(particle);
particle.i = i;
//the world space position
particle.world = new THREE.Vector3();
//the previous !tick! (not frame) position
particle.prevworld = new THREE.Vector3();
this.shaderMaterial_interpolate.attributes.previousPosition.value.push(particle.prevworld);
//the color
var color = new THREE.Vector4(1,1,1,1);
this.shaderMaterial_default.attributes.vertexColor.value.push(color);
//age
this.shaderMaterial_interpolate.attributes.age.value.push(1);
particle.color = color;
//the sise
this.shaderMaterial_default.attributes.size.value.push(1);
var self = this;
//set the size - stored per vertex
particle.setSize = function(s)
{
self.material.attributes.size.value[this.i] = s;
}
//set the age - stored per vertex
particle.setAge = function(a)
{
this.age = a;
self.shaderMaterial_interpolate.attributes.age.value[this.i] = this.age;
}
//the lifespan - stored per vertex
particle.setLifespan = function(a)
{
this.lifespan = a;
self.shaderMaterial_interpolate.attributes.lifespan.value[this.i] = this.a;
}
//This looks like it could be computed from the start and end plus random on the shader
//doing this saves computetime on the shader at expense of gpu mem
shaderMaterial_analytic.attributes.acceleration.value.push(new THREE.Vector3());
shaderMaterial_analytic.attributes.velocity.value.push(new THREE.Vector3());
shaderMaterial_analytic.attributes.lifespan.value.push(1);
shaderMaterial_analytic.attributes.random.value.push(new THREE.Vector4(Math.random(),Math.random(),Math.random(),Math.random()));
return particle;
}
//Generate a new point in space based on the emitter type and size
particleSystem.generatePoint = function()
{
//generate from a point
//TODO: specify point?
if(this.emitterType.toLowerCase() == 'point')
{
return new THREE.Vector3(0,0,0);
}
//Generate in a box
//assumes centered at 0,0,0
if(this.emitterType.toLowerCase() == 'box')
{
var x = this.emitterSize[0] * Math.random() - this.emitterSize[0]/2;
var y = this.emitterSize[1] * Math.random() - this.emitterSize[1]/2;
var z = this.emitterSize[2] * Math.random() - this.emitterSize[2]/2;
return new THREE.Vector3(x,y,z);
}
//Generate in a sphere
//assumes centered at 0,0,0
if(this.emitterType.toLowerCase() == 'sphere')
{
var u2 = Math.random();
u2 = Math.pow(u2,1/3);
var o = this.emitterSize[0] * Math.random() * Math.PI*2;
var u = this.emitterSize[1] * Math.random() * 2 - 1;
var r = this.emitterSize[2] * u2;
var x = Math.cos(o)*Math.sqrt(1-(u*u));
var y = Math.sin(o)*Math.sqrt(1-(u*u));
var z = u;
return new THREE.Vector3(x,y,z).setLength(r);
}
}
//setup the particles with new values
particleSystem.rebuildParticles = function()
{
for(var i = 0; i < this.geometry.vertices.length; i++)
{
this.setupParticle(this.geometry.vertices[i],this.matrix);
}
}
//set the particles initial values. Used when creating and resuing particles
particleSystem.setupParticle = function(particle,mat,inv)
{
particle.x = 0;
particle.y = 0;
particle.z = 0;
//generate a point in objects space, the move to world space
particle.world = this.generatePoint().applyMatrix4( mat );
//back up initial (needed by the analyticShader)
particle.initialx = particle.world.x;
particle.initialy = particle.world.y;
particle.initialz = particle.world.z;
//start at initial pos
particle.x = particle.initialx;
particle.y = particle.initialy;
particle.z = particle.initialz;
//start stoped, age 0
particle.age = 0;
particle.velocity = new THREE.Vector3(0,0,0);
particle.acceleration = new THREE.Vector3( 0,0,0);
particle.lifespan = 1;
//Generate the initial velocity
//In this mode, you specify a min and max x,y,z
if(this.velocityMode == 'cartesian')
{
particle.velocity.x = this.minVelocity[0] + (this.maxVelocity[0] - this.minVelocity[0]) * Math.random();
particle.velocity.y = this.minVelocity[1] + (this.maxVelocity[1] - this.minVelocity[1]) * Math.random();
particle.velocity.z = this.minVelocity[2] + (this.maxVelocity[2] - this.minVelocity[2]) * Math.random();
}
//In this mode, you give a pitch and yaw from 0,1, and a min and max length.
//This is easier to emit into a circle, or a cone section
if(this.velocityMode == 'spherical')
{
//random sphercial points concentrate at poles
/* var r = this.minVelocity[2] + (this.maxVelocity[2] - this.minVelocity[2]) * Math.random();
var t = this.minVelocity[1] + (this.maxVelocity[1] - this.minVelocity[1]) * Math.random() * Math.PI*2;
var w = this.minVelocity[0] + (this.maxVelocity[0] - this.minVelocity[0]) * Math.random() * Math.PI - Math.PI/2;
particle.velocity.x = r * Math.sin(t)*Math.cos(w);
particle.velocity.y = r * Math.sin(t)*Math.sin(w);
particle.velocity.z = r * Math.cos(t); */
//better distribution
var o = this.minVelocity[0] + (this.maxVelocity[0] - this.minVelocity[0]) * Math.random() * Math.PI*2;
var u = this.minVelocity[1] + (this.maxVelocity[1] - this.minVelocity[1]) * Math.random() * 2 - 1;
var u2 = Math.random();
u2 = Math.pow(u2,1/3);
var r = this.minVelocity[2] + (this.maxVelocity[2] - this.minVelocity[2]) * u2;
particle.velocity.x = Math.cos(o)*Math.sqrt(1-(u*u));
particle.velocity.y = Math.sin(o)*Math.sqrt(1-(u*u));
particle.velocity.z = u;
particle.velocity.setLength(r);
}
//The velocity should be in world space, but is generated in local space for
//ease of use
mat = mat.clone();
mat.elements[12] = 0;
mat.elements[13] = 0;
mat.elements[14] = 0;
particle.velocity.applyMatrix4( mat );
//accelerations are always world space, just min and max on each axis
particle.acceleration.x = this.minAcceleration[0] + (this.maxAcceleration[0] - this.minAcceleration[0]) * Math.random();
particle.acceleration.y = this.minAcceleration[1] + (this.maxAcceleration[1] - this.minAcceleration[1]) * Math.random();
particle.acceleration.z = this.minAcceleration[2] + (this.maxAcceleration[2] - this.minAcceleration[2]) * Math.random();
particle.setLifespan(this.minLifeTime + (this.maxLifeTime - this.minLifeTime) * Math.random());
//color is start color
particle.color.x = this.startColor[0];
particle.color.y = this.startColor[1];
particle.color.z = this.startColor[2];
particle.color.w = this.startColor[3];
//save the values into the attributes
shaderMaterial_analytic.attributes.acceleration.value[particle.i] = (particle.acceleration);
shaderMaterial_analytic.attributes.velocity.value[particle.i] = (particle.velocity);
shaderMaterial_analytic.attributes.lifespan.value[particle.i] = (particle.lifespan);
shaderMaterial_analytic.attributes.acceleration.needsUpdate = true;
shaderMaterial_analytic.attributes.velocity.needsUpdate = true;
shaderMaterial_analytic.attributes.lifespan.needsUpdate = true;
this.geometry.verticesNeedUpdate = true;
//randomly move the particle up to one step in time
particle.prevworld.x = particle.x;
particle.prevworld.y = particle.y;
particle.prevworld.z = particle.z;
}
//when updating in AnalyticShader mode, is very simple, just inform the shader of new time.
particleSystem.updateAnalyticShader = function(time)
{
particleSystem.material.uniforms.time.value += time/1000;
}
//In Analytic mode, run the equation for the position
particleSystem.updateAnalytic =function(time)
{
particleSystem.material.uniforms.time.value += time/3333.0;
var time_in_ticks = time/33.333;
var inv = this.matrix.clone();
inv = inv.getInverse(inv);
var particles = this.geometry;
//update each particle
var pCount = this.geometry.vertices.length;
while(pCount--)
{
var particle =particles.vertices[pCount];
this.updateParticleAnalytic(particle,this.matrix,inv,time_in_ticks);
}
//examples developed with faster tick - maxrate *33 is scale to make work
//with new timing
//Reuse up to maxRate particles, sliced for delta_time
//Once a particle reaches it's end of life, its available to be regenerated.
//We hold extras in limbo with alpha 0 until they can be regenerated
//Note the maxRate never creates or destroys particles, just manages when they will restart
//after dying
var len = Math.min(this.regenParticles.length,this.maxRate*15*time_in_ticks);
for(var i =0; i < len; i++)
{
//setup with new random values, and move randomly forward in time one step
var particle = this.regenParticles.shift();
this.setupParticle(particle,this.matrix,inv);
this.updateParticleAnalytic(particle,this.matrix,inv,Math.random()*3.33);
particle.waitForRegen = false;
}
//only these things change, other properties are in the shader as they are linear WRT time
this.geometry.verticesNeedUpdate = true;
this.geometry.colorsNeedUpdate = true;
this.material.attributes.vertexColor.needsUpdate = true;
this.material.attributes.size.needsUpdate = true;
}
particleSystem.counter = 0;
particleSystem.testtime = 0;
particleSystem.totaltime = 0;
//timesliced Euler integrator
//todo: switch to RK4
//This can do more complex sim, maybe even a cloth sim or such. It ticks 10 times a second, and blends tick with previous via a shader
particleSystem.updateEuler = function(time)
{
particleSystem.material.uniforms.time.value += time/3333.0;
var time_in_ticks = time/100.0;
if(this.lastTime === undefined) this.lastTime = 0;
this.lastTime += time_in_ticks;//ticks - Math.floor(ticks);
var inv = this.matrix.clone();
inv = inv.getInverse(inv);
var particles = this.geometry;
//timesliced tick give up after 5 steps - just cant go fast enough
if(Math.floor(this.lastTime) > 5)
this.lastTime = 1;
for(var i=0; i < Math.floor(this.lastTime) ; i++)
{
this.lastTime--;
var pCount = this.geometry.vertices.length;
while(pCount--)
{
var particle =particles.vertices[pCount];
this.updateParticleEuler(particle,this.matrix,inv,3.333);
}
//examples developed with faster tick - maxrate *33 is scale to make work
//with new timing
//Reuse up to maxRate particles, sliced for delta_time
//Once a particle reaches it's end of life, its available to be regenerated.
//We hold extras in limbo with alpha 0 until they can be regenerated
//Note the maxRate never creates or destroys particles, just manages when they will restart
//after dying
var len = Math.min(this.regenParticles.length,this.maxRate*333);
for(var i =0; i < len; i++)
{
particle.waitForRegen = false;
var particle = this.regenParticles.shift();
this.setupParticle(particle,this.matrix,inv);
this.updateParticleEuler(particle,this.matrix,inv,Math.random()*3.33);
this.material.attributes.lifespan.needsUpdate = true;
}
//only need to send up the age, position, and previous position. other props handled in the shader
this.geometry.verticesNeedUpdate = true;
this.material.attributes.previousPosition.needsUpdate = true;
this.material.attributes.age.needsUpdate = true;
}
//even if this is not a sim tick, we need to send the fractional time up to the shader for the interpolation
this.material.uniforms.fractime.value = this.lastTime;
}
//Update a particle from the Analytic solver
particleSystem.updateParticleAnalytic = function(particle,mat,inv,delta_time)
{
particle.age += delta_time;
//Make the particle dead. Hide it until it can be reused
if(particle.age >= particle.lifespan && !particle.waitForRegen)
{
this.regenParticles.push(particle);
particle.waitForRegen = true;
particle.x = 0;
particle.y = 0;
particle.z = 0;
particle.color.w = 0.0;
}else
{
//Run the formula to get position.
var percent = particle.age/particle.lifespan;
particle.world.x = particle.initialx + (particle.velocity.x * particle.age) + 0.5*(particle.acceleration.x * particle.age * particle.age)
particle.world.y = particle.initialy + (particle.velocity.y * particle.age) + 0.5*(particle.acceleration.y * particle.age * particle.age)
particle.world.z = particle.initialz + (particle.velocity.z * particle.age) + 0.5*(particle.acceleration.z * particle.age * particle.age)
this.temp.x = particle.world.x;
this.temp.y = particle.world.y;
this.temp.z = particle.world.z;
//need to specify in object space, event though comptued in local
this.temp.applyMatrix4( inv );
particle.x = this.temp.x;
particle.y = this.temp.y;
particle.z = this.temp.z;
//Should probably move this to the shader. Linear with time, no point in doing on CPU
particle.color.x = this.startColor[0] + (this.endColor[0] - this.startColor[0]) * percent;
particle.color.y = this.startColor[1] + (this.endColor[1] - this.startColor[1]) * percent;
particle.color.z = this.startColor[2] + (this.endColor[2] - this.startColor[2]) * percent;
particle.color.w = this.startColor[3] + (this.endColor[3] - this.startColor[3]) * percent;
particle.setSize(this.startSize + (this.endSize - this.startSize) * percent);
}
}
//updtae a partilce with the Euler solver
particleSystem.updateParticleEuler = function(particle,mat,inv,step_dist)
{
particle.prevage = particle.age;
particle.age += step_dist;
particle.setAge(particle.age + step_dist);
//If the particle is dead ,hide it unitl it can be reused
if(particle.age >= particle.lifespan && !particle.waitForRegen)
{
this.regenParticles.push(particle);
particle.waitForRegen = true;
particle.x = 0;
particle.y = 0;
particle.z = 0;
particle.world.x = 0;
particle.world.y = 0;
particle.world.z = 0;
particle.prevworld.x = 0;
particle.prevworld.y = 0;
particle.prevworld.z = 0;
particle.color.w = 1.0;
particle.size = 100;
}else
{
// and the position
particle.prevworld.x = particle.world.x;
particle.prevworld.y = particle.world.y;
particle.prevworld.z = particle.world.z;
//find direction to center for gravity
var gravityAccel = new THREE.Vector3(particle.world.x,particle.world.y,particle.world.z);
gravityAccel.x -= this.gravityCenter[0];
gravityAccel.y -= this.gravityCenter[1];
gravityAccel.z -= this.gravityCenter[2];
var len = gravityAccel.length()+.1;
gravityAccel.normalize();
gravityAccel.multiplyScalar(-Math.min(1/(len*len),100));
gravityAccel.multiplyScalar(this.gravity);
//update position
particle.world.x += particle.velocity.x * step_dist + (particle.acceleration.x + gravityAccel.x)* step_dist * step_dist;
particle.world.y += particle.velocity.y * step_dist + (particle.acceleration.y + gravityAccel.y )* step_dist * step_dist;;
particle.world.z += particle.velocity.z * step_dist + (particle.acceleration.z + gravityAccel.z )* step_dist * step_dist;;
//update velocity
particle.velocity.x += (particle.acceleration.x + gravityAccel.x) * step_dist * step_dist;
particle.velocity.y += (particle.acceleration.y + gravityAccel.y) * step_dist * step_dist;
particle.velocity.z += (particle.acceleration.z + gravityAccel.z) * step_dist * step_dist
var damping = 1-(this.damping * step_dist);
//drag
particle.velocity.x *= damping;
particle.velocity.y *= damping;
particle.velocity.z *= damping;
//move from world to local space
this.temp.x = particle.world.x ;
this.temp.y = particle.world.y ;
this.temp.z = particle.world.z;
this.temp.applyMatrix4( inv );
particle.x = this.temp.x;
particle.y = this.temp.y;
particle.z = this.temp.z;
//careful to have prev and current pos in same space!!!!
particle.prevworld.applyMatrix4( inv );
}
}
//Change the solver type for the system
particleSystem.setSolverType =function(type)
{
this.solver = type;
if(type == 'Euler')
{
particleSystem.update = particleSystem.updateEuler;
particleSystem.material = particleSystem.shaderMaterial_interpolate;
particleSystem.rebuildParticles();
}
if(type == 'Analytic')
{
particleSystem.update = particleSystem.updateAnalytic;
particleSystem.material = particleSystem.shaderMaterial_default;
particleSystem.rebuildParticles();
}
if(type == 'AnalyticShader')
{
particleSystem.update = particleSystem.updateAnalyticShader ;
particleSystem.material = particleSystem.shaderMaterial_analytic;
particleSystem.rebuildParticles();
}
}
//If you move a system, all the particles need to be recomputed to look like they stick in world space
//not that we pointedly dont do this for the AnalyticShader. We could, but that solver is ment to be very high performance, do we dont
particleSystem.updateTransform = function(newtransform)
{
//Get he current transform, and invert new one
var inv = new THREE.Matrix4();
var newt = new THREE.Matrix4();
inv.elements = matCpy(newtransform);
newt = newt.copy(this.matrix);
inv = inv.getInverse(inv);
//don't adjust for the high performance shader
if(particleSystem.solver == 'AnalyticShader')
{
return;
}
//Move all particles out of old space to world, then back into new space.
//this will make it seem like they stay at the correct position in the world, though
//acutally they change position
//note that it would actually be more efficient to leave the matrix as identity, and change the position of the
//emitters for this...... Could probably handle it in the model setter actually... would be much more efficient, but linking
//a system to a moving object would break.
for(var i =0; i < this.geometry.vertices.length; i++)
{
this.geometry.vertices[ i ].applyMatrix4( inv );
this.shaderMaterial_interpolate.attributes.previousPosition.value[ i ].applyMatrix4( inv );
this.geometry.vertices[ i ].applyMatrix4( newt );
this.shaderMaterial_interpolate.attributes.previousPosition.value[ i ].applyMatrix4( newt );
}
this.geometry.verticesNeedUpdate = true;
this.shaderMaterial_interpolate.attributes.previousPosition.needsUpdate = true;
}
//Change the system count. Note that this must be set before the first frame renders, cant be changed at runtime.
particleSystem.setParticleCount = function(newcount)
{
var inv = this.matrix.clone();
inv = inv.getInverse(inv);
var particles = this.geometry;
while(this.geometry.vertices.length > newcount)
{
this.geometry.vertices.pop();
}
while(this.geometry.vertices.length < newcount)
{
var particle = particleSystem.createParticle(this.geometry.vertices.length);
particleSystem.setupParticle(particle,particleSystem.matrix,inv);
particle.age = Infinity;
this.regenParticles.push(particle);
particle.waitForRegen = true;
}
this.geometry.verticesNeedUpdate = true;
this.geometry.colorsNeedUpdate = true;
this.shaderMaterial_default.attributes.vertexColor.needsUpdate = true;
this.particleCount = newcount;
}
//Setup some defaults
particleSystem.setParticleCount(1000);
particleSystem.setSolverType('AnalyticShader');
particleSystem.update(1);
child.threeObject = particleSystem;
child.threeObject.name = childName;
child.name = childName;
addThreeChild.call( this, nodeID, childID );
}
}
function addThreeChild( parentID, childID ) {
var threeParent;
var parent = this.state.nodes[ parentID ];
if ( !parent && this.state.scenes[ parentID ] ) {
parent = this.state.scenes[ parentID ];
threeParent = parent.threeScene;
} else {
threeParent = parent.threeObject;
}
if ( threeParent && this.state.nodes[ childID ]) {
var child = this.state.nodes[ childID ];
if ( child.threeObject ) {
threeParent.add( child.threeObject );
}
}
}
//search the threeObject of the parent sim node for the threeChild with the name of the sim child node
function findThreeObjectInParent(childID,parentID)
{
var parentThreeObject;
if(this.state.nodes[parentID])
parentThreeObject = this.state.nodes[parentID].threeObject;
if(!parentThreeObject && this.state.scenes[parentID])
parentThreeObject = this.state.scenes[parentID].threeScene;
//If there is no parent object render node, then there does not need to be a child node
if(!parentThreeObject) return null;
var threeChild = findChildThreeObject(parentThreeObject,childID);
return threeChild;
}
function findChildThreeObject(threeParent,childID)
{
var ret = null;
if(threeParent.name == childID)
ret = threeParent;
else if(threeParent.children)
{
for(var i = 0; i< threeParent.children.length; i++)
var child = findChildThreeObject(threeParent.children[i],childID);
if(child)
ret = child;
}
return ret;
}
function sceneLights() {
var scene = getThreeScene.call( this );
var lightList = createLightContainer.call( this );
if ( scene ) {
lightList = findAllLights( scene, lightList );
}
return lightList;
}
function createDefaultLighting( lights ) {
var sceneID = this.kernel.application();
var ambientCount = lights.ambientLights.length;
var lightCount = lights.spotLights.length + lights.directionalLights.length + lights.pointLights.length;
var scene = getThreeScene.call( this );
if ( lightCount == 0 ) {
var light1 = new THREE.DirectionalLight( '808080', 2 );
var light2 = new THREE.DirectionalLight( '808080', 2 );
light1.distance = light2.distance = 2000;
scene.add( light1 );
scene.add( light2 );
light1.position.set( 0.7, -0.7, 0.3 );
light2.position.set( -0.7, 0.7, 0.3 );
}
if ( ambientCount == 0 ) {
createAmbientLight.call( this, scene, [ 0.20, 0.20, 0.20 ] );
}
}
function findVwfChildren( threeObj, children ) {
if ( threeObj !== undefined ) {
if ( threeObj.vwfID !== undefined ) {
children.push( threeObj.vwfID );
}
if ( threeObj && threeObj.children ) {
for ( var i = 0; i < threeObj.children.length; i++ ) {
findVwfChildren( threeObj.children[ i ], children );
}
}
}
}
function SetVisible( node, state ) {
if ( node ) {
node.visible = state;
}
if ( node && node.children ) {
for( var i = 0; i < node.children.length; i++ ) {
var child = node.children[i];
if( !child.vwfID ) {
SetVisible( child, state );
}
}
}
}
function setTransformsDirty( threeObject ) {
var vwfChildren = [];
var childNode;
findVwfChildren( threeObject, vwfChildren );
for ( var i = 0; i < vwfChildren.length; i++ ) {
childNode = self.state.nodes[ vwfChildren[ i ] ];
if ( childNode && childNode.transform !== undefined ) {
childNode.storedTransformDirty = true;
}
}
}
function getWorldTransform( node ) {
var parent = self.state.nodes[ node.parentID ];
if ( parent === undefined ) {
parent = self.state.scenes[ node.parentID ];
}
if ( parent ) {
var worldTransform = new THREE.Matrix4();
if ( node.transform === undefined ) {
node.transform = new THREE.Matrix4();
}
return worldTransform.multiplyMatrices( getWorldTransform( parent ), node.transform );
} else {
return node.transform || new THREE.Matrix4();
}
}
function setWorldTransform( node, worldTransform ) {
if ( node.parent ) {
var parentInverse = goog.vec.Mat4.create();
if ( goog.vec.Mat4.invert( getWorldTransform( node.parent ), parentInverse ) ) {
node.transform = goog.vec.Mat4.multMat( parentInverse, worldTransform,
goog.vec.Mat4.create() );
} else {
self.logger.errorx( "Parent world transform is not invertible - did not set world transform " +
"on node '" + node.id + "'" );
}
} else {
node.transform = worldTransform;
}
}
function updateStoredTransform( node ) {
if ( node && node.threeObject && ( node.threeObject instanceof THREE.Object3D ) ) {
// Add a local model-side transform that can stay pure even if the view changes the
// transform on the threeObject - this already happened in creatingNode for those nodes that
// didn't need to load a model
node.transform = new THREE.Matrix4();
node.transform.elements = matCpy( node.threeObject.matrix.elements );
// If this threeObject is a camera, it has a 90-degree rotation on it to account for the
// different coordinate systems of VWF and three.js. We need to undo that rotation before
// setting the VWF property.
if ( node.threeObject instanceof THREE.Camera ) {
var transformArray = node.transform.elements;
// Get column y and z out of the matrix
var columny = goog.vec.Vec4.create();
goog.vec.Mat4.getColumn( transformArray, 1, columny );
var columnz = goog.vec.Vec4.create();
goog.vec.Mat4.getColumn( transformArray, 2, columnz );
// Swap the two columns, negating columny
goog.vec.Mat4.setColumn( transformArray, 1, goog.vec.Vec4.negate( columnz, columnz ) );
goog.vec.Mat4.setColumn( transformArray, 2, columny );
}
node.storedTransformDirty = false;
}
}
// -- getBoundingBox ------------------------------------------------------------------------------
function getBoundingBox( object3 ) {
var bBox = {
min: { x: Number.MAX_VALUE, y: Number.MAX_VALUE, z: Number.MAX_VALUE },
max: { x: -Number.MAX_VALUE, y: -Number.MAX_VALUE, z: -Number.MAX_VALUE }
};
if (object3 instanceof THREE.Object3D)
{
object3.traverse (function (mesh)
{
if (mesh instanceof THREE.Mesh)
{
mesh.geometry.computeBoundingBox ();
var meshBoundingBox = mesh.geometry.boundingBox;
// compute overall bbox
bBox.min.x = Math.min (bBox.min.x, meshBoundingBox.min.x);
bBox.min.y = Math.min (bBox.min.y, meshBoundingBox.min.y);
bBox.min.z = Math.min (bBox.min.z, meshBoundingBox.min.z);
bBox.max.x = Math.max (bBox.max.x, meshBoundingBox.max.x);
bBox.max.y = Math.max (bBox.max.y, meshBoundingBox.max.y);
bBox.max.z = Math.max (bBox.max.z, meshBoundingBox.max.z);
}
});
}
else if ( object3 && object3.geometry && object3.geometry.computeBoundingBox ) {
object3.geometry.computeBoundingBox();
var bx = object3.geometry.boundingBox;
bBox = {
min: { x: bx.min.x, y: bx.min.y, z: bx.min.z },
max: { x: bx.max.x, y: bx.max.y, z: bx.max.z }
};
}
return bBox;
}
function getCenterOffset( object3 ) {
var offset = [ 0, 0, 0 ];
if ( object3 ) {
var bBox = getBoundingBox.call( this, object3 );
offset[0] = ( bBox.max.x + bBox.min.x ) * 0.50;
offset[1] = ( bBox.max.y + bBox.min.y ) * 0.50;
offset[2] = ( bBox.max.z + bBox.min.z ) * 0.50;
}
return offset;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//UTF8 loader
function DecodeARRAY_BUFFER(str,range,inmin,stride,bits)
{
str = blobarray[str];
var attribs_out = [];//new Float32Array(str.length);
//min = min + 0.0;
var prev = [0,0,0];
var divisor = Math.pow(2,bits);
for (var i = 5; i < str.length-5; i+=stride) {
for(var j = 0; j< stride; j++)
{
var code = str.charCodeAt(i+j);
var dezigzag = (Number(code) >> 1) ^ (-(Number(code) & 1));
prev[j] += dezigzag;
var prev_attrib = ((prev[j]/divisor)*(range)) + Number(inmin) ;//(code >> 1) ^ (-(code & 1));
attribs_out.push(prev_attrib);
}
}
return attribs_out;
}
var debugarraytype = "";
function DecodeELEMENT_ARRAY_BUFFER(str,range)
{
str = blobarray[str];
var attribs_out = [];//new Uint16Array(str.length);
var prev = 0;
for (var i = 5; i < str.length-5; i++) {
var code = str.charCodeAt(i);
var dezigzag = (code >> 1) ^ (-(code & 1));;
prev += dezigzag;
// alert("char code " +code + " dezigzag " + dezigzag + " new value " + prev);
attribs_out.push(prev);
}
return attribs_out;
}
function DecodeArray(array,key)
{
var type = array.type;
var array2 =[];
var itemsize = array.itemSize;
if(type == "ELEMENT_ARRAY_BUFFER")
array2 = DecodeELEMENT_ARRAY_BUFFER(array.elements.values,array.elements.range);
if(type == "ARRAY_BUFFER")
array2 = DecodeARRAY_BUFFER(array.elements.values,array.elements.range,array.elements.min,itemsize,array.elements.bits);
return array2;
}
function UTF8JsonLoader(node,callback)
{
this.url = node.source;
this.callback = callback;
this.children=[];
this.jsonLoaded = function(e)
{
var test = 1+1;
var jsonData = JSON.parse(decompress(e));
var texture_load_callback = function(texturename)
{
var src = "";
if(this.url.toLowerCase().indexOf('3dr_federation') != -1)
src = this.url.substr(0,this.url.indexOf("Model/")) + "textures/NoRedirect/" + encodeURIComponent(texturename) +"?ID=00-00-00";
else
src = this.url.substr(0,this.url.indexOf("Model/")) + "textures/" + encodeURIComponent(texturename) +"?ID=00-00-00";
console.log(src);
src = src.replace("AnonymousUser:@","");
var tex = loadTexture( undefined, src );
return tex;
}
this.scene = ParseSceneGraph(jsonData,texture_load_callback.bind(this));
if(this.callback)
this.callback(this);
}.bind(this);
this.error = function(e)
{
alert(e.responseText);
}.bind(this);
$.ajax({
url: this.url,
data: {},
success: this.jsonLoaded,
error: this.error,
dataType:'text'
});
;
}
function BuildUTF8JsonNode(node,callback)
{
return new UTF8JsonLoader(node,callback);
}
function toColor(arr)
{
var color = new THREE.Color();
color.setRGB(arr[0],arr[1],arr[2],arr[3]);
return color;
}
function ApplyMaterial(newnode,newmaterial)
{
if(newnode instanceof THREE.Mesh)
newnode.material = newmaterial;
else if( newnode.children)
{
for(var i =0; i < newnode.children.length;i++)
ApplyMaterial(newnode.children[0],newmaterial);
}
}
function isIdentityMatrix( elements ) {
if ( ( elements.length == 16 ) || ( elements.length == 9 ) ) {
var modNumber = Math.sqrt( elements.length ) + 1;
for ( var index = 0; index < elements.length; index++ ) {
if ( ( index % modNumber ) == 0 ) {
if ( elements[ index ] != 1 ) {
return false;
}
}
else {
if ( elements[ index ] != 0 ) {
return false;
}
}
}
return true;
}
return false;
}
function ParseSceneGraph(node, texture_load_callback) {
var newnode;
//its geometry
if (node.primitives) {
//newnode = new THREE.Object3D();
var geo = new THREE.Geometry();
var mesh = newnode = new THREE.Mesh(geo);
mesh.geometry.normals = [];
mesh.geometry.UVS = [];
//vertex data
if (node.attributes) {
$.each(node.attributes, function(key, element) {
debugarraytype = key;
var attributeArray = node.attributes[key];
node.attributes[key] = DecodeArray(attributeArray,key);
if(key == "Vertex")
{
for(var i = 0; i < node.attributes[key].length-2; i+= 3)
{
var vert = new THREE.Vector3( node.attributes[ key ][ i ],
node.attributes[ key ][ i + 1 ],
node.attributes[ key ][ i + 2 ] );
mesh.geometry.vertices.push(vert);
}
}
if(key == "Normal")
{
for(var i = 0; i < node.attributes[key].length-2; i+= 3)
{
var norm = new THREE.Vector3( node.attributes[ key ][ i ],
node.attributes[ key ][ i + 1 ],
node.attributes[ key ][ i + 2 ] );
mesh.geometry.normals.push(norm);
}
}
if(key == "TexCoord0")
{
for(var i = 0; i < node.attributes[key].length-1; i+= 2)
{
var uv = new THREE.Vector2( node.attributes[ key ][ i ],
node.attributes[ key ][ i + 1 ] );
mesh.geometry.UVS.push(uv);
}
}
if(key == "VertexColor")
{
for(var i = 0; i < node.attributes[key].length-3; i+= 4)
{
var vert = new THREE.Vector3( node.attributes[ key ][ i ],
node.attributes[ key ][ i + 1 ],
node.attributes[ key ][ i + 2 ] );
mesh.geometry.colors.push(vert);
}
}
});
}
var i;
for (i in node.primitives) {
if (node.primitives[i].indices) {
var array = node.primitives[i].indices;
array = DecodeArray(array);
for(var j = 0; j < array.length-2; j+= 3)
{
var face = new THREE.Face3(array[j],array[j+1],array[j+2],new THREE.Vector3(0,1,0),new THREE.Color('#000000'),0);
face.vertexNormals.push(mesh.geometry.normals[face.a]);
face.vertexNormals.push(mesh.geometry.normals[face.b]);
face.vertexNormals.push(mesh.geometry.normals[face.c]);
mesh.geometry.faces.push(face);
mesh.geometry.faceVertexUvs[0].push([mesh.geometry.UVS[face.a],mesh.geometry.UVS[face.b],mesh.geometry.UVS[face.c]]);
}
} else {
mode = gl[mode];
var first = node.primitives[i].first;
var count = node.primitives[i].count;
if (count > 65535)
count = 32740;
//node.primitives[i] = new osg.DrawArrays(mode, first, count);
}
}
mesh.geometry.verticesNeedUpdate = true;
mesh.geometry.facesNeedUpdate = true;
}
var newmaterial = null;
if (node.stateset) {
newmaterial = new THREE.MeshPhongMaterial();
if (node.stateset.textures) {
var textures = node.stateset.textures;
for ( var t = 0, tl = textures.length; t < tl; t++) {
if (textures[t] === undefined) {
continue;
}
if (!textures[t].file) {
if (console !== undefined) {
console.log("no 'file' field for texture "
+ textures[t]);
}
}
var tex;
if ( texture_load_callback ) {
tex = texture_load_callback( textures[t].file );
} else {
tex = loadTexture( newmaterial, textures[t].file );
}
if (tex) {
tex.wrapS = THREE.RepeatWrapping;
tex.wrapT = THREE.RepeatWrapping;
newmaterial.map = tex;
newmaterial.needsUpdate = true;
}
}
}
if (node.stateset.material) {
newmaterial.ambient = (toColor(node.stateset.material.ambient));
newmaterial.color = (toColor(node.stateset.material.diffuse));
newmaterial.shininess = (node.stateset.material.shininess);
newmaterial.specular = (toColor(node.stateset.material.specular));
newmaterial.needsUpdate = true;
}
}
if (node.matrix) {
if(newnode == null)
newnode = new THREE.Object3D();
var matrix = [];
for(var i =0; i < node.matrix.length; i++)
matrix.push(node.matrix[i]);
var glmat = new THREE.Matrix4();
glmat.elements = matrix;
var flipmat = new THREE.Matrix4(1, 0,0,0,
0, 0,1,0,
0,-1,0,0,
0, 0,0,1);
glmat = glmat.multiplyMatrices(flipmat,glmat);
//glmat = glmat.transpose();
newnode.matrix.copy(glmat)
newnode.matrixAutoUpdate = false;
}
if (node.children) {
if(newnode == null)
newnode = new THREE.Object3D();
for ( var child = 0; child < node.children.length; child++) {
var childnode = ParseSceneGraph(node.children[child],texture_load_callback);
if(childnode)
newnode.add(childnode);
}
}
if(newnode && newmaterial)
ApplyMaterial(newnode,newmaterial);
if(node.name && newnode)
newnode.name = node.name;
if(newnode && newnode.children && newnode.children.length == 1 && isIdentityMatrix(newnode.matrix.elements))
return newnode.children[0];
return newnode;
}
var blobsfound = 0;
var blobarray = [];
function DecompressStrings(data, replace, find)
{
var reg = new RegExp(find,'g');
return data.replace(reg, replace);
}
function decompressJsonStrings(data)
{
data = DecompressStrings(data,"\"min\":","min:");
data = DecompressStrings(data,"\"max\":","max:");
data = DecompressStrings(data,"\"stateset\":","ss:");
data = DecompressStrings(data,"\"LINE_LOOP\"","\"LL\"");
data = DecompressStrings(data,"\"LINEAR\"","\"L\"");
data = DecompressStrings(data,"\"LINEAR_MIPMAP_LINEAR\"","\"LML\"");
data = DecompressStrings(data,"\"LINEAR_MIPMAP_NEAREST\"","\"LMN\"");
data = DecompressStrings(data,"\"NEAREST\"","\"NE\"");
data = DecompressStrings(data,"\"NEAREST_MIPMAP_LINEAR\"","\"NML\"");
data = DecompressStrings(data,"\"NEAREST_MIPMAP_NEAREST\"","\"NMN\"");
data = DecompressStrings(data,"\"mag_filter\":","maf:");
data = DecompressStrings(data,"\"min_filter\":","mif:");
data = DecompressStrings(data,"\"file\":","f:");
data = DecompressStrings(data,"\"name\":","n:");
data = DecompressStrings(data,"\"ambient\":","a:");
data = DecompressStrings(data,"\"diffuse\":","d:");
data = DecompressStrings(data,"\"specular\":","s:");
data = DecompressStrings(data,"\"emission\":","e:");
data = DecompressStrings(data,"\"shininess\":","sh:");
data = DecompressStrings(data,"\"textures\":","t:");
data = DecompressStrings(data,"\"material\":","m:");
data = DecompressStrings(data,"\"POINTS\"","\"P\"");
data = DecompressStrings(data,"\"LINES\"","\"LI\"");
data = DecompressStrings(data,"\"LINE_STRIP\"","\"LS\"");
data = DecompressStrings(data,"\"TRIANGLES\"","\"T\"");
data = DecompressStrings(data,"\"TRIANGLE_FAN\"","\"TF\"");
data = DecompressStrings(data,"\"TRIANGLE_STRIP\"","\"TS\"");
data = DecompressStrings(data,"\"first\":","fi:");
data = DecompressStrings(data,"\"count\":","co:");
data = DecompressStrings(data,"\"mode\":","mo:");
data = DecompressStrings(data,"\"undefined\":","u:");
data = DecompressStrings(data,"\"children\":","c:");
data = DecompressStrings(data,"\"range\":","r:");
data = DecompressStrings(data,"\"bits\":","b:");
data = DecompressStrings(data,"\"values\":","v:");
data = DecompressStrings(data,"\"elements\":","el:");
data = DecompressStrings(data,"\"itemSize\":","iS:");
data = DecompressStrings(data,"\"type\":","ty:");
data = DecompressStrings(data,"\"ARRAY_BUFFER\"","\"AB\"");
data = DecompressStrings(data,"\"ELEMENT_ARRAY_BUFFER\"","\"EAB\"");
data = DecompressStrings(data,"\"indices\":","i:");
data = DecompressStrings(data,"\"Vertex\":","V:");
data = DecompressStrings(data,"\"Normal\":","N:");
data = DecompressStrings(data,"\"TexCoord0\":","T0:");
data = DecompressStrings(data,"\"TexCoord1\":","T1:");
data = DecompressStrings(data,"\"TexCoord2\":","T2:");
data = DecompressStrings(data,"\"TexCoord3\":","T3:");
data = DecompressStrings(data,"\"TexCoord4\":","T4:");
data = DecompressStrings(data,"\"attributes\":","A:");
data = DecompressStrings(data,"\"primitives\":","p:");
data = DecompressStrings(data,"\"projection\":","pr:");
data = DecompressStrings(data,"\"matrix\":","M:");
return data;
}
function isUUIDinArray( value, arrayToCheck ) {
for ( var index = 0; index < arrayToCheck.length; index++ ) {
if ( value.uuid == arrayToCheck[ index ].uuid ) {
return true;
}
}
return false;
}
function threeMaterialsFromIDs( nodeIDs ) {
var result = [];
for ( var index = 0; index < nodeIDs.length; index++ ) {
var node = this.state.nodes[ nodeIDs[ index ] ];
if ( node && ( node.threeObject instanceof THREE.Material ) ) {
result.push( node.threeObject );
}
}
return result;
}
function createInheritedMaterial( parentID, threeObject, name ) {
var nodeName = "material";
if ( name ) {
nodeName = name;
}
else if ( threeObject.name.length > 0 ) {
nodeName = threeObject.name;
}
var newNode = {
"id": nodeName,
"uri": nodeName,
"extends": "http://vwf.example.com/material.vwf",
"properties": {
"private": null,
},
"methods": {
},
"scripts": []
};
vwf.createChild( parentID, nodeName, newNode);
}
function generateNodeMaterial( nodeID, node ) {
if ( false ) {
if ( node.threeObject instanceof THREE.Object3D ) {
var representedMaterialsVWF = vwf.find( nodeID, "./element(*,'http://vwf.example.com/material.vwf')" );
var representedMaterialsThreeJS = threeMaterialsFromIDs.call( this, representedMaterialsVWF );
var allChildrenMaterials = GetAllMaterials( node.threeObject );
var nameTallys = {};
for ( var index = 0; index < allChildrenMaterials.length; index ++ ) {
if ( nameTallys[ allChildrenMaterials[ index ].name ] ) {
nameTallys[ allChildrenMaterials[ index ].name ] = nameTallys[ allChildrenMaterials[ index ].name ] + 1;
}
else {
nameTallys[ allChildrenMaterials[ index ].name ] = 1;
}
if ( ! isUUIDinArray( allChildrenMaterials[ index ], representedMaterialsThreeJS ) ) {
var newName = "material_" + nameTallys[ allChildrenMaterials[ index ].name ] + "_" + allChildrenMaterials[ index ].name;
createInheritedMaterial.call( this, nodeID, allChildrenMaterials[ index ], newName );
}
}
}
}
}
function setUniformProperty( obj, prop, type, value ) {
//console.info( "setUniformProperty( obj, "+prop+", "+type+", "+value+" )" );
switch ( type ) {
case 'i':
obj[ prop ].value = Number( value );
break
case 'f':
obj[ prop ].value = parseFloat( value );
break;
case 'c':
obj[ prop ].value = new THREE.Color( value );
break;
case 'v2':
obj[ prop ].value = new THREE.Vector2( value[0], value[1] );
break;
case 'v3':
obj[ prop ].value = new THREE.Vector3( value[0], value[1], value[2] );
break;
case 'v4':
obj[ prop ].value = new THREE.Vector4( value[0], value[1], value[2], value[3] );
break;
case 't':
obj[ prop ].src = value;
obj[ prop ].value = loadTexture( undefined, value );
break;
}
}
function decompress(dataencoded)
{
blobsfound = 0;
blobarray = [];
var regex = new RegExp('\u7FFF\u7FFE\u7FFF\u7FFE\u7FFF[\\S\\s]*?\u7FFE\u7FFF\u7FFE\u7FFF\u7FFE','igm');
blobarray = dataencoded.match(regex);
var data = dataencoded.replace(regex,function(match) { return "\""+(blobsfound++)+"\"";});
data = decompressJsonStrings(data);
return data;
}
function loadTexture( mat, def ) {
var txt = undefined;
var url = undefined;
var mapping = undefined;
var onLoad = function( texture ) {
if ( mat ) {
mat.map = texture;
mat.needsUpdate = true;
}
};
function onError() {
self.logger.warnx( )
}
//console.log( [ "loadTexture: ", JSON.stringify( def ) ] );
if ( utility.isString( def ) ) {
url = def;
} else {
url = def.url;
mapping = def.mapping;
}
if ( mat === undefined ) {
if ( mapping === undefined ) {
txt = THREE.ImageUtils.loadTexture( url );
} else {
txt = THREE.ImageUtils.loadTexture( url, mapping );
}
} else {
txt = THREE.ImageUtils.loadTexture( url, mapping, onLoad, onError );
}
return txt;
}
function createMaterial( matDef ) {
var mat, text;
//console.log( [ "createMaterial: ", JSON.stringify( matDef ) ] );
if ( matDef.texture !== undefined ) {
text = loadTexture( undefined, matDef.texture );
if ( !utility.isString( matDef.texture ) ) {
for ( var prop in matDef.texture ) {
if ( prop !== 'url' && prop !== 'mapping' ) {
setTextureProperty( text, prop, matDef.texture[ prop ] );
}
}
}
}
if ( matDef.type !== undefined ) {
var matParameters = {};
for ( var prop in matDef ) {
switch ( prop ) {
case "type":
case "texture":
break;
default:
matParameters[ prop ] = matDef[ prop ];
break;
}
}
if ( text ) {
matParameters.map = text;
}
switch ( matDef.type ) {
case "MeshBasicMaterial":
mat = new THREE.MeshBasicMaterial( matParameters );
break;
case "MeshLambertMaterial":
mat = new THREE.MeshLambertMaterial( matParameters );
break;
case "MeshPhongMaterial":
mat = new THREE.MeshPhongMaterial( matParameters );
break;
case "MeshNormalMaterial":
mat = new THREE.MeshNormalMaterial( matParameters );
break;
case "MeshDepthMaterial":
mat = new THREE.MeshDepthMaterial( matParameters );
break;
case "ShaderMaterial":
mat = createShader( matParameters );
break;
case "SpriteMaterial":
mat = new THREE.SpriteMaterial( matParameters );
break;
case "LineBasicMaterial":
mat = new THREE.LineBasicMaterial( matParameters );
break;
case "LineDashedMaterial":
mat = new THREE.LineDashedMaterial( matParameters );
break;
case "MeshFaceMaterial":
mat = new THREE.MeshFaceMaterial( matParameters );
break;
case "PointCloudMaterial":
mat = new THREE.PointCloudMaterial( matParameters );
break;
case "RawShaderMaterial":
mat = new THREE.RawShaderMaterial( matParameters );
break;
}
//if ( mat ) {
// console.info( "Material created: " + matDef.type );
//}
} else {
mat = new THREE.MeshBasicMaterial( matDef );
}
return mat;
}
function setMaterialProperty( material, propertyName, propertyValue ) {
var value = propertyValue;
if ( material === undefined ) {
return undefined;
}
//console.log( [ "setMaterialProperty: ", propertyName, propertyValue ] );
switch ( propertyName ) {
case "texture":
if ( propertyValue !== "" && utility.validObject( propertyValue ) ) {
loadTexture( material, propertyValue );
} else {
material.map = null;
material.needsUpdate;
}
break;
case "color":
case "diffuse":
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
material.color.setRGB( vwfColor.red()/255, vwfColor.green()/255, vwfColor.blue()/255 );
}
if ( material.ambient !== undefined ) {
material.ambient.setRGB( material.color.r, material.color.g, material.color.b );
}
value = vwfColor.toString();
break;
case "specColor":
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
material.specular.setRGB( vwfColor.red() / 255, vwfColor.green() / 255, vwfColor.blue() / 255 );
value = vwfColor.toString();
}
break;
case "reflect":
value = Number( propertyValue );
material.reflectivity = value;
break;
case "shininess":
value = Number( propertyValue );
material.shininess = value;
break;
case "bumpScale":
value = Number( propertyValue );
material.bumpScale = value;
break;
case "alphaTest":
value = Number( propertyValue );
material.alphaTest = value;
break;
case "ambient":
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
material.ambient.setRGB( vwfColor.red( ) / 255, vwfColor.green( ) / 255, vwfColor.blue( ) / 255 );
value = vwfColor.toString();
}
break;
case "emit":
var vwfColor = new utility.color( propertyValue );
if ( vwfColor ) {
material.emissive.setRGB( vwfColor.red( ) / 255, vwfColor.green( ) / 255, vwfColor.blue( ) / 255 );
value = vwfColor.toString();
}
break;
case "transparent":
value = Boolean( propertyValue );
material.transparent = value;
break;
case "opacity":
value = Number( propertyValue );
material.opacity = value;
break;
case "side":
switch ( propertyValue ) {
case 2:
case "2":
case "double":
material.side = THREE.DoubleSide;
break;
case 0:
case "0":
case "front":
material.side = THREE.FrontSide;
break;
case 1:
case "1":
case "back":
material.side = THREE.BackSide;
break;
default:
value = undefined;
break;
}
break;
default:
value = undefined;
break;
}
if ( value !== undefined ) {
material.needsUpdate = true;
}
return value;
}
function setTextureProperty( texture, propertyName, propertyValue ) {
var value = propertyValue;
if ( texture === undefined ) {
return undefined;
}
//console.log( [ "setTextureProperty: ", propertyName, propertyValue ] );
switch ( propertyName ) {
case "wrapT":
switch ( propertyValue ) {
case 1001:
case "1001":
case "clamp":
texture.wrapT = THREE.ClampToEdgeWrapping;
break;
case 1000:
case "1000":
case "repeat":
texture.wrapT = THREE.RepeatWrapping;
break;
case 1002:
case "1002":
case "mirror":
texture.wrapT = THREE.MirroredRepeatWrapping;
break;
default:
value = undefined;
break;
}
break;
case "wrapS":
switch ( propertyValue ) {
case 1001:
case "1001":
case "clamp":
texture.wrapS = THREE.ClampToEdgeWrapping;
break;
case 1000:
case "1000":
case "repeat":
texture.wrapS = THREE.RepeatWrapping;
break;
case 1002:
case "1002":
case "mirror":
texture.wrapS = THREE.MirroredRepeatWrapping;
break;
default:
value = undefined;
break;
}
break;
case "repeat":
if ( propertyValue instanceof Array && propertyValue.length > 1 ) {
texture.repeat = new THREE.Vector2( propertyValue[0], propertyValue[1] );
} else {
value = undefined;
}
break;
case "offset":
if ( propertyValue instanceof Array && propertyValue.length > 1 ) {
texture.offset = new THREE.Vector2( propertyValue[0], propertyValue[1] );
} else {
value = undefined;
}
break
case "magFilter":
switch ( propertyValue ) {
case 1003:
case "1003":
case "nearest":
texture.magFilter = THREE.NearestFilter;
break;
case 1004:
case "1004":
case "nearestNearest":
texture.magFilter = THREE.NearestMipMapNearestFilter;
break;
case 1005:
case "1005":
case "nearestLinear":
texture.magFilter = THREE.NearestMipMapLinearFilter;
break;
case 1006:
case "1006":
case "linear":
texture.magFilter = THREE.LinearFilter;
break;
case 1007:
case "1007":
case "linearNearest":
texture.magFilter = THREE.LinearMipMapNearestFilter;
break;
case 1008:
case "1008":
case "linearLinear":
texture.magFilter = THREE.LinearMipMapLinearFilter;
break;
default:
value = undefined;
break;
}
break;
case "minFilter":
switch ( propertyValue ) {
case 1003:
case "1003":
case "nearest":
texture.minFilter = THREE.NearestFilter;
break;
case 1004:
case "1004":
case "nearestNearest":
texture.minFilter = THREE.NearestMipMapNearestFilter;
break;
case 1005:
case "1005":
case "nearestLinear":
texture.minFilter = THREE.NearestMipMapLinearFilter;
break;
case 1006:
case "1006":
case "linear":
texture.minFilter = THREE.LinearFilter;
break;
case 1007:
case "1007":
case "linearNearest":
texture.minFilter = THREE.LinearMipMapNearestFilter;
break;
case 1008:
case "1008":
case "linearLinear":
texture.minFilter = THREE.LinearMipMapLinearFilter;
break;
default:
value = undefined;
break;
}
break;
case "anisotropy":
texture.anisotropy = parseFloat( prop );
break;
default:
value = undefined;
break;
}
if ( value !== undefined ) {
texture.needsUpdate = true;
}
return value;
}
});