diff --git a/gulpfile.js b/gulpfile.js new file mode 100644 index 000000000..18d6dbe86 --- /dev/null +++ b/gulpfile.js @@ -0,0 +1,136 @@ +//var gulp = require('gulp'); +//var browserify = require('browserify'); +//var source = require('vinyl-source-stream'); +// + + +//var gulp = require('gulp'); +//var glob = require('glob'); +//var browserify = require('browserify'); +//var source = require('vinyl-source-stream'); +// +//gulp.task('browserify', function(){ +// var testFiles = glob.sync('./build/away/**/*.js'); +// return browserify({ +// debug: true, +// entries: testFiles, +// paths: ['./build/away'] +// }) +// .bundle() +// .pipe(source('away.js')) +// .pipe(gulp.dest('./build')); +//}); +// +//gulp.task('default', ['browserify']); + +var concat = require('gulp-concat'); +var gulp = require('gulp'); +var changed = require('gulp-changed'); +var glob = require('glob'); +var path = require('path'); +var browserify = require('browserify'); +var source = require('vinyl-source-stream'); +var map = require('vinyl-map'); +var exorcist = require('exorcist'); +var sourcemaps = require('gulp-sourcemaps'); + +var typescript = require('gulp-typescript'); + +//var project = { +// declaration: true, +// sourcemap: true, +// noResolve: false, +// target: 'ES5', +// module: 'commonjs' +//}; +// +//gulp.task('compile', function() { +// return gulp.src(['./lib/**/*.ts']) +// //.pipe(changed('./out/', {extension:'.js', hasChanged: changed.compareLastModifiedTime})) +// .pipe(tsc(project)) +// .pipe(gulp.dest('out/')); +//}); +// +//gulp.task('watch', ['scripts'], function() { +// gulp.watch('lib/**/*.ts', ['scripts']); +//}); + +gulp.task('compile', function() { + var tsProject = typescript.createProject({ + declarationFiles: true, + noExternalResolve: true, + target: 'ES5', + module: 'commonjs' + }); + + var ambientWrap = map(function(code, filename) { + code = code.toString(); + code = 'declare module "' + path.relative('../', filename.slice(0,-5)) + '" {\n\t' + + code.split('declare ').join('').split('\n').join('\n\t') + "\n" + + '}'; + return code; + }); + + var tsResult = gulp.src(['./lib/**/*.ts', './node_modules/awayjs-**/build/*.d.ts']) + .pipe(sourcemaps.init()) + .pipe(typescript(tsProject)); + + tsResult.dts + .pipe(ambientWrap) + .pipe(concat('awayjs-renderergl.d.ts')) + .pipe(gulp.dest('./build')); + + return tsResult.js + .pipe(sourcemaps.write()) + .pipe(gulp.dest('./lib')); +}); + +gulp.task('watch', ['package'], function() { + gulp.watch('./lib/**/*.ts', ['package']); +}); + +gulp.task('package', ['compile'], function(callback){ + var b = browserify({ + debug: true, + paths: ['../'] + }); + + glob('./node_modules/awayjs-**/lib/**/*.js', {}, function (error, files) { + files.forEach(function (file) { + b.external(file); + }); + }); + + glob('./lib/**/*.js', {}, function (error, files) { + + files.forEach(function (file) { + b.require(file, {expose:path.relative('../', file.slice(0,-3))}); + }); + + b.bundle() + .pipe(exorcist('./build/awayjs-renderergl.js.map')) + .pipe(source('awayjs-renderergl.js')) + .pipe(gulp.dest('./build')) + .on('end', callback); + }); +}); + + +gulp.task('tests', function () { + + var tsProject = typescript.createProject({ + declarationFiles: true, + noExternalResolve: true, + target: 'ES5', + module: 'commonjs' + }); + + var tsResult = gulp.src(['./tests/**/*.ts', './node_modules/awayjs-**/build/*.d.ts', './build/awayjs-renderergl.d.ts']) + //.pipe(changed('./tests', {extension:'.js', hasChanged: changed.compareLastModifiedTime})) + .pipe(sourcemaps.init()) + .pipe(typescript(tsProject)); + + return tsResult.js + .pipe(sourcemaps.write()) + .pipe(gulp.dest('./tests')); +}); \ No newline at end of file diff --git a/lib/animators/ParticleAnimationSet.js b/lib/animators/ParticleAnimationSet.js new file mode 100755 index 000000000..1a9d0484f --- /dev/null +++ b/lib/animators/ParticleAnimationSet.js @@ -0,0 +1,301 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationSetBase = require("awayjs-stagegl/lib/animators/AnimationSetBase"); +var AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +var AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +var ParticleAnimationData = require("awayjs-renderergl/lib/animators/data/ParticleAnimationData"); +var ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleTimeNode = require("awayjs-renderergl/lib/animators/nodes/ParticleTimeNode"); +/** + * The animation data set used by particle-based animators, containing particle animation data. + * + * @see away.animators.ParticleAnimator + */ +var ParticleAnimationSet = (function (_super) { + __extends(ParticleAnimationSet, _super); + /** + * Creates a new ParticleAnimationSet + * + * @param [optional] usesDuration Defines whether the animation set uses the duration data in its static properties to determine how long a particle is visible for. Defaults to false. + * @param [optional] usesLooping Defines whether the animation set uses a looping timeframe for each particle determined by the startTime, duration and delay data in its static properties function. Defaults to false. Requires usesDuration to be true. + * @param [optional] usesDelay Defines whether the animation set uses the delay data in its static properties to determine how long a particle is hidden for. Defaults to false. Requires usesLooping to be true. + */ + function ParticleAnimationSet(usesDuration, usesLooping, usesDelay) { + if (usesDuration === void 0) { usesDuration = false; } + if (usesLooping === void 0) { usesLooping = false; } + if (usesDelay === void 0) { usesDelay = false; } + _super.call(this); + this._animationSubGeometries = new Object(); + this._particleNodes = new Array(); + this._localDynamicNodes = new Array(); + this._localStaticNodes = new Array(); + this._totalLenOfOneVertex = 0; + //automatically add a particle time node to the set + this.addAnimation(this._timeNode = new ParticleTimeNode(usesDuration, usesLooping, usesDelay)); + } + Object.defineProperty(ParticleAnimationSet.prototype, "particleNodes", { + /** + * Returns a vector of the particle animation nodes contained within the set. + */ + get: function () { + return this._particleNodes; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.addAnimation = function (node) { + var i /*int*/; + var n = node; + n._iProcessAnimationSetting(this); + if (n.mode == ParticlePropertiesMode.LOCAL_STATIC) { + n._iDataOffset = this._totalLenOfOneVertex; + this._totalLenOfOneVertex += n.dataLength; + this._localStaticNodes.push(n); + } + else if (n.mode == ParticlePropertiesMode.LOCAL_DYNAMIC) + this._localDynamicNodes.push(n); + for (i = this._particleNodes.length - 1; i >= 0; i--) { + if (this._particleNodes[i].priority <= n.priority) + break; + } + this._particleNodes.splice(i + 1, 0, n); + _super.prototype.addAnimation.call(this, node); + }; + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.activate = function (shaderObject, stage) { + // this._iAnimationRegisterCache = pass.animationRegisterCache; + }; + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.deactivate = function (shaderObject, stage) { + // var context:IContextStageGL = stage.context; + // var offset:number /*int*/ = this._iAnimationRegisterCache.vertexAttributesOffset; + // var used:number /*int*/ = this._iAnimationRegisterCache.numUsedStreams; + // for (var i:number /*int*/ = offset; i < used; i++) + // context.setVertexBufferAt(i, null); + }; + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.getAGALVertexCode = function (shaderObject) { + //grab animationRegisterCache from the materialpassbase or create a new one if the first time + this._iAnimationRegisterCache = shaderObject.animationRegisterCache; + if (this._iAnimationRegisterCache == null) + this._iAnimationRegisterCache = shaderObject.animationRegisterCache = new AnimationRegisterCache(shaderObject.profile); + //reset animationRegisterCache + this._iAnimationRegisterCache.vertexConstantOffset = shaderObject.numUsedVertexConstants; + this._iAnimationRegisterCache.vertexAttributesOffset = shaderObject.numUsedStreams; + this._iAnimationRegisterCache.varyingsOffset = shaderObject.numUsedVaryings; + this._iAnimationRegisterCache.fragmentConstantOffset = shaderObject.numUsedFragmentConstants; + this._iAnimationRegisterCache.hasUVNode = this.hasUVNode; + this._iAnimationRegisterCache.needVelocity = this.needVelocity; + this._iAnimationRegisterCache.hasBillboard = this.hasBillboard; + this._iAnimationRegisterCache.sourceRegisters = shaderObject.animatableAttributes; + this._iAnimationRegisterCache.targetRegisters = shaderObject.animationTargetRegisters; + this._iAnimationRegisterCache.needFragmentAnimation = shaderObject.usesFragmentAnimation; + this._iAnimationRegisterCache.needUVAnimation = !shaderObject.usesUVTransform; + this._iAnimationRegisterCache.hasColorAddNode = this.hasColorAddNode; + this._iAnimationRegisterCache.hasColorMulNode = this.hasColorMulNode; + this._iAnimationRegisterCache.reset(); + var code = ""; + code += this._iAnimationRegisterCache.getInitCode(); + var node; + var i /*int*/; + for (i = 0; i < this._particleNodes.length; i++) { + node = this._particleNodes[i]; + if (node.priority < ParticleAnimationSet.POST_PRIORITY) + code += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache); + } + code += this._iAnimationRegisterCache.getCombinationCode(); + for (i = 0; i < this._particleNodes.length; i++) { + node = this._particleNodes[i]; + if (node.priority >= ParticleAnimationSet.POST_PRIORITY && node.priority < ParticleAnimationSet.COLOR_PRIORITY) + code += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache); + } + code += this._iAnimationRegisterCache.initColorRegisters(); + for (i = 0; i < this._particleNodes.length; i++) { + node = this._particleNodes[i]; + if (node.priority >= ParticleAnimationSet.COLOR_PRIORITY) + code += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache); + } + code += this._iAnimationRegisterCache.getColorPassCode(); + return code; + }; + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.getAGALUVCode = function (shaderObject) { + var code = ""; + if (this.hasUVNode) { + this._iAnimationRegisterCache.setUVSourceAndTarget(shaderObject.uvSource, shaderObject.uvTarget); + code += "mov " + this._iAnimationRegisterCache.uvTarget + ".xy," + this._iAnimationRegisterCache.uvAttribute.toString() + "\n"; + var node; + for (var i = 0; i < this._particleNodes.length; i++) + node = this._particleNodes[i]; + code += node.getAGALUVCode(shaderObject, this._iAnimationRegisterCache); + code += "mov " + this._iAnimationRegisterCache.uvVar.toString() + "," + this._iAnimationRegisterCache.uvTarget + ".xy\n"; + } + else + code += "mov " + shaderObject.uvTarget + "," + shaderObject.uvSource + "\n"; + return code; + }; + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.getAGALFragmentCode = function (shaderObject, shadedTarget) { + return this._iAnimationRegisterCache.getColorCombinationCode(shadedTarget); + }; + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.doneAGALCode = function (shaderObject) { + this._iAnimationRegisterCache.setDataLength(); + //set vertexZeroConst,vertexOneConst,vertexTwoConst + this._iAnimationRegisterCache.setVertexConst(this._iAnimationRegisterCache.vertexZeroConst.index, 0, 1, 2, 0); + }; + Object.defineProperty(ParticleAnimationSet.prototype, "usesCPU", { + /** + * @inheritDoc + */ + get: function () { + return false; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleAnimationSet.prototype.cancelGPUCompatibility = function () { + }; + ParticleAnimationSet.prototype.dispose = function () { + for (var key in this._animationSubGeometries) + this._animationSubGeometries[key].dispose(); + _super.prototype.dispose.call(this); + }; + ParticleAnimationSet.prototype.getAnimationSubGeometry = function (subMesh) { + var mesh = subMesh.parentMesh; + var animationSubGeometry = (mesh.shareAnimationGeometry) ? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id]; + if (animationSubGeometry) + return animationSubGeometry; + this._iGenerateAnimationSubGeometries(mesh); + return (mesh.shareAnimationGeometry) ? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id]; + }; + /** @private */ + ParticleAnimationSet.prototype._iGenerateAnimationSubGeometries = function (mesh) { + if (this.initParticleFunc == null) + throw (new Error("no initParticleFunc set")); + var geometry = mesh.geometry; + if (!geometry) + throw (new Error("Particle animation can only be performed on a ParticleGeometry object")); + var i /*int*/, j /*int*/, k /*int*/; + var animationSubGeometry; + var newAnimationSubGeometry = false; + var subGeometry; + var subMesh; + var localNode; + for (i = 0; i < mesh.subMeshes.length; i++) { + subMesh = mesh.subMeshes[i]; + subGeometry = subMesh.subGeometry; + if (mesh.shareAnimationGeometry) { + animationSubGeometry = this._animationSubGeometries[subGeometry.id]; + if (animationSubGeometry) + continue; + } + animationSubGeometry = new AnimationSubGeometry(); + if (mesh.shareAnimationGeometry) + this._animationSubGeometries[subGeometry.id] = animationSubGeometry; + else + this._animationSubGeometries[subMesh.id] = animationSubGeometry; + newAnimationSubGeometry = true; + //create the vertexData vector that will be used for local node data + animationSubGeometry.createVertexData(subGeometry.numVertices, this._totalLenOfOneVertex); + } + if (!newAnimationSubGeometry) + return; + var particles = geometry.particles; + var particlesLength = particles.length; + var numParticles = geometry.numParticles; + var particleProperties = new ParticleProperties(); + var particle; + var oneDataLen /*int*/; + var oneDataOffset /*int*/; + var counterForVertex /*int*/; + var counterForOneData /*int*/; + var oneData; + var numVertices /*uint*/; + var vertexData; + var vertexLength /*uint*/; + var startingOffset /*uint*/; + var vertexOffset /*uint*/; + //default values for particle param + particleProperties.total = numParticles; + particleProperties.startTime = 0; + particleProperties.duration = 1000; + particleProperties.delay = 0.1; + i = 0; + j = 0; + while (i < numParticles) { + particleProperties.index = i; + //call the init on the particle parameters + this.initParticleFunc.call(this.initParticleScope, particleProperties); + for (k = 0; k < this._localStaticNodes.length; k++) + this._localStaticNodes[k]._iGeneratePropertyOfOneParticle(particleProperties); + while (j < particlesLength && (particle = particles[j]).particleIndex == i) { + for (k = 0; k < mesh.subMeshes.length; k++) { + subMesh = mesh.subMeshes[k]; + if (subMesh.subGeometry == particle.subGeometry) { + animationSubGeometry = (mesh.shareAnimationGeometry) ? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id]; + break; + } + } + numVertices = particle.numVertices; + vertexData = animationSubGeometry.vertexData; + vertexLength = numVertices * this._totalLenOfOneVertex; + startingOffset = animationSubGeometry.numProcessedVertices * this._totalLenOfOneVertex; + for (k = 0; k < this._localStaticNodes.length; k++) { + localNode = this._localStaticNodes[k]; + oneData = localNode.oneData; + oneDataLen = localNode.dataLength; + oneDataOffset = startingOffset + localNode._iDataOffset; + for (counterForVertex = 0; counterForVertex < vertexLength; counterForVertex += this._totalLenOfOneVertex) { + vertexOffset = oneDataOffset + counterForVertex; + for (counterForOneData = 0; counterForOneData < oneDataLen; counterForOneData++) + vertexData[vertexOffset + counterForOneData] = oneData[counterForOneData]; + } + } + //store particle properties if they need to be retreived for dynamic local nodes + if (this._localDynamicNodes.length) + animationSubGeometry.animationParticles.push(new ParticleAnimationData(i, particleProperties.startTime, particleProperties.duration, particleProperties.delay, particle)); + animationSubGeometry.numProcessedVertices += numVertices; + //next index + j++; + } + //next particle + i++; + } + }; + /** + * Property used by particle nodes that require compilation at the end of the shader + */ + ParticleAnimationSet.POST_PRIORITY = 9; + /** + * Property used by particle nodes that require color compilation + */ + ParticleAnimationSet.COLOR_PRIORITY = 18; + return ParticleAnimationSet; +})(AnimationSetBase); +module.exports = ParticleAnimationSet; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/particleanimationset.ts"],"names":["ParticleAnimationSet","ParticleAnimationSet.constructor","ParticleAnimationSet.particleNodes","ParticleAnimationSet.addAnimation","ParticleAnimationSet.activate","ParticleAnimationSet.deactivate","ParticleAnimationSet.getAGALVertexCode","ParticleAnimationSet.getAGALUVCode","ParticleAnimationSet.getAGALFragmentCode","ParticleAnimationSet.doneAGALCode","ParticleAnimationSet.usesCPU","ParticleAnimationSet.cancelGPUCompatibility","ParticleAnimationSet.dispose","ParticleAnimationSet.getAnimationSubGeometry","ParticleAnimationSet._iGenerateAnimationSubGeometries"],"mappings":"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","file":"animators/ParticleAnimationSet.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import IAnimationSet\t\t\t\t\t= require(\"awayjs-core/lib/animators/IAnimationSet\");\nimport AnimationNodeBase\t\t\t\t= require(\"awayjs-core/lib/animators/nodes/AnimationNodeBase\");\nimport ISubMesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/ISubMesh\");\nimport SubGeometryBase\t\t\t\t\t= require(\"awayjs-core/lib/core/base/SubGeometryBase\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\n\nimport AnimationSetBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimationSetBase\");\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\n\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticleAnimationData\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleAnimationData\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleData\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleData\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleTimeNode\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleTimeNode\");\nimport ParticleGeometry\t\t\t\t\t= require(\"awayjs-renderergl/lib/core/base/ParticleGeometry\");\n\n/**\n * The animation data set used by particle-based animators, containing particle animation data.\n *\n * @see away.animators.ParticleAnimator\n */\nclass ParticleAnimationSet extends AnimationSetBase implements IAnimationSet\n{\n\t/** @private */\n\tpublic _iAnimationRegisterCache:AnimationRegisterCache;\n\n\t//all other nodes dependent on it\n\tprivate _timeNode:ParticleTimeNode;\n\n\t/**\n\t * Property used by particle nodes that require compilation at the end of the shader\n\t */\n\tpublic static POST_PRIORITY:number /*int*/ = 9;\n\n\t/**\n\t * Property used by particle nodes that require color compilation\n\t */\n\tpublic static COLOR_PRIORITY:number /*int*/ = 18;\n\n\tprivate _animationSubGeometries:Object = new Object();\n\tprivate _particleNodes:Array<ParticleNodeBase> = new Array<ParticleNodeBase>();\n\tprivate _localDynamicNodes:Array<ParticleNodeBase> = new Array<ParticleNodeBase>();\n\tprivate _localStaticNodes:Array<ParticleNodeBase> = new Array<ParticleNodeBase>();\n\tprivate _totalLenOfOneVertex:number /*int*/ = 0;\n\n\t//set true if has an node which will change UV\n\tpublic hasUVNode:boolean;\n\t//set if the other nodes need to access the velocity\n\tpublic needVelocity:boolean;\n\t//set if has a billboard node.\n\tpublic hasBillboard:boolean;\n\t//set if has an node which will apply color multiple operation\n\tpublic hasColorMulNode:boolean;\n\t//set if has an node which will apply color add operation\n\tpublic hasColorAddNode:boolean;\n\n\t/**\n\t * Initialiser function for static particle properties. Needs to reference a with the following format\n\t *\n\t * <code>\n\t * initParticleFunc(prop:ParticleProperties)\n\t * {\n\t * \t\t//code for settings local properties\n\t * }\n\t * </code>\n\t *\n\t * Aside from setting any properties required in particle animation nodes using local static properties, the initParticleFunc function\n\t * is required to time node requirements as they may be needed. These properties on the ParticleProperties object can include\n\t * <code>startTime</code>, <code>duration</code> and <code>delay</code>. The use of these properties is determined by the setting\n\t * arguments passed in the constructor of the particle animation set. By default, only the <code>startTime</code> property is required.\n\t */\n\tpublic initParticleFunc:Function;\n\n\t/**\n\t * Initialiser function scope for static particle properties\n\t */\n\tpublic initParticleScope:Object;\n\n\t/**\n\t * Creates a new <code>ParticleAnimationSet</code>\n\t *\n\t * @param    [optional] usesDuration    Defines whether the animation set uses the <code>duration</code> data in its static properties to determine how long a particle is visible for. Defaults to false.\n\t * @param    [optional] usesLooping     Defines whether the animation set uses a looping timeframe for each particle determined by the <code>startTime</code>, <code>duration</code> and <code>delay</code> data in its static properties function. Defaults to false. Requires <code>usesDuration</code> to be true.\n\t * @param    [optional] usesDelay       Defines whether the animation set uses the <code>delay</code> data in its static properties to determine how long a particle is hidden for. Defaults to false. Requires <code>usesLooping</code> to be true.\n\t */\n\tconstructor(usesDuration:boolean = false, usesLooping:boolean = false, usesDelay:boolean = false)\n\t{\n\t\tsuper();\n\n\t\t//automatically add a particle time node to the set\n\t\tthis.addAnimation(this._timeNode = new ParticleTimeNode(usesDuration, usesLooping, usesDelay));\n\t}\n\n\t/**\n\t * Returns a vector of the particle animation nodes contained within the set.\n\t */\n\tpublic get particleNodes():Array<ParticleNodeBase>\n\t{\n\t\treturn this._particleNodes;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic addAnimation(node:AnimationNodeBase)\n\t{\n\t\tvar i:number /*int*/;\n\t\tvar n:ParticleNodeBase = <ParticleNodeBase> node;\n\t\tn._iProcessAnimationSetting(this);\n\t\tif (n.mode == ParticlePropertiesMode.LOCAL_STATIC) {\n\t\t\tn._iDataOffset = this._totalLenOfOneVertex;\n\t\t\tthis._totalLenOfOneVertex += n.dataLength;\n\t\t\tthis._localStaticNodes.push(n);\n\t\t} else if (n.mode == ParticlePropertiesMode.LOCAL_DYNAMIC)\n\t\t\tthis._localDynamicNodes.push(n);\n\n\t\tfor (i = this._particleNodes.length - 1; i >= 0; i--) {\n\t\t\tif (this._particleNodes[i].priority <= n.priority)\n\t\t\t\tbreak;\n\t\t}\n\n\t\tthis._particleNodes.splice(i + 1, 0, n);\n\n\t\tsuper.addAnimation(node);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic activate(shaderObject:ShaderObjectBase, stage:Stage)\n\t{\n//\t\t\tthis._iAnimationRegisterCache = pass.animationRegisterCache;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic deactivate(shaderObject:ShaderObjectBase, stage:Stage)\n\t{\n//\t\t\tvar context:IContextStageGL = <IContextStageGL> stage.context;\n//\t\t\tvar offset:number /*int*/ = this._iAnimationRegisterCache.vertexAttributesOffset;\n//\t\t\tvar used:number /*int*/ = this._iAnimationRegisterCache.numUsedStreams;\n//\t\t\tfor (var i:number /*int*/ = offset; i < used; i++)\n//\t\t\t\tcontext.setVertexBufferAt(i, null);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\t//grab animationRegisterCache from the materialpassbase or create a new one if the first time\n\t\tthis._iAnimationRegisterCache = shaderObject.animationRegisterCache;\n\n\t\tif (this._iAnimationRegisterCache == null)\n\t\t\tthis._iAnimationRegisterCache = shaderObject.animationRegisterCache = new AnimationRegisterCache(shaderObject.profile);\n\n\t\t//reset animationRegisterCache\n\t\tthis._iAnimationRegisterCache.vertexConstantOffset = shaderObject.numUsedVertexConstants;\n\t\tthis._iAnimationRegisterCache.vertexAttributesOffset = shaderObject.numUsedStreams;\n\t\tthis._iAnimationRegisterCache.varyingsOffset = shaderObject.numUsedVaryings;\n\t\tthis._iAnimationRegisterCache.fragmentConstantOffset = shaderObject.numUsedFragmentConstants;\n\t\tthis._iAnimationRegisterCache.hasUVNode = this.hasUVNode;\n\t\tthis._iAnimationRegisterCache.needVelocity = this.needVelocity;\n\t\tthis._iAnimationRegisterCache.hasBillboard = this.hasBillboard;\n\t\tthis._iAnimationRegisterCache.sourceRegisters = shaderObject.animatableAttributes;\n\t\tthis._iAnimationRegisterCache.targetRegisters = shaderObject.animationTargetRegisters;\n\t\tthis._iAnimationRegisterCache.needFragmentAnimation = shaderObject.usesFragmentAnimation;\n\t\tthis._iAnimationRegisterCache.needUVAnimation = !shaderObject.usesUVTransform;\n\t\tthis._iAnimationRegisterCache.hasColorAddNode = this.hasColorAddNode;\n\t\tthis._iAnimationRegisterCache.hasColorMulNode = this.hasColorMulNode;\n\t\tthis._iAnimationRegisterCache.reset();\n\n\t\tvar code:string = \"\";\n\n\t\tcode += this._iAnimationRegisterCache.getInitCode();\n\n\t\tvar node:ParticleNodeBase;\n\t\tvar i:number /*int*/;\n\n\t\tfor (i = 0; i < this._particleNodes.length; i++) {\n\t\t\tnode = this._particleNodes[i];\n\t\t\tif (node.priority < ParticleAnimationSet.POST_PRIORITY)\n\t\t\t\tcode += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache);\n\t\t}\n\n\t\tcode += this._iAnimationRegisterCache.getCombinationCode();\n\n\t\tfor (i = 0; i < this._particleNodes.length; i++) {\n\t\t\tnode = this._particleNodes[i];\n\t\t\tif (node.priority >= ParticleAnimationSet.POST_PRIORITY && node.priority < ParticleAnimationSet.COLOR_PRIORITY)\n\t\t\t\tcode += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache);\n\t\t}\n\n\t\tcode += this._iAnimationRegisterCache.initColorRegisters();\n\n\t\tfor (i = 0; i < this._particleNodes.length; i++) {\n\t\t\tnode = this._particleNodes[i];\n\t\t\tif (node.priority >= ParticleAnimationSet.COLOR_PRIORITY)\n\t\t\t\tcode += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache);\n\t\t}\n\t\tcode += this._iAnimationRegisterCache.getColorPassCode();\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALUVCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\tvar code:string = \"\";\n\t\tif (this.hasUVNode) {\n\t\t\tthis._iAnimationRegisterCache.setUVSourceAndTarget(shaderObject.uvSource, shaderObject.uvTarget);\n\t\t\tcode += \"mov \" + this._iAnimationRegisterCache.uvTarget + \".xy,\" + this._iAnimationRegisterCache.uvAttribute.toString() + \"\\n\";\n\t\t\tvar node:ParticleNodeBase;\n\t\t\tfor (var i:number /*uint*/ = 0; i < this._particleNodes.length; i++)\n\t\t\t\tnode = this._particleNodes[i];\n\t\t\t\tcode += node.getAGALUVCode(shaderObject, this._iAnimationRegisterCache);\n\t\t\tcode += \"mov \" + this._iAnimationRegisterCache.uvVar.toString() + \",\" + this._iAnimationRegisterCache.uvTarget + \".xy\\n\";\n\t\t} else\n\t\t\tcode += \"mov \" + shaderObject.uvTarget + \",\" + shaderObject.uvSource + \"\\n\";\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALFragmentCode(shaderObject:ShaderObjectBase, shadedTarget:string):string\n\t{\n\t\treturn this._iAnimationRegisterCache.getColorCombinationCode(shadedTarget);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic doneAGALCode(shaderObject:ShaderObjectBase)\n\t{\n\t\tthis._iAnimationRegisterCache.setDataLength();\n\n\t\t//set vertexZeroConst,vertexOneConst,vertexTwoConst\n\t\tthis._iAnimationRegisterCache.setVertexConst(this._iAnimationRegisterCache.vertexZeroConst.index, 0, 1, 2, 0);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get usesCPU():boolean\n\t{\n\t\treturn false;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic cancelGPUCompatibility()\n\t{\n\n\t}\n\n\tpublic dispose()\n\t{\n\t\tfor (var key in this._animationSubGeometries)\n\t\t\t(<AnimationSubGeometry> this._animationSubGeometries[key]).dispose();\n\n\t\tsuper.dispose();\n\t}\n\n\tpublic getAnimationSubGeometry(subMesh:ISubMesh)\n\t{\n\t\tvar mesh:Mesh = subMesh.parentMesh;\n\t\tvar animationSubGeometry:AnimationSubGeometry = (mesh.shareAnimationGeometry)? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id];\n\n\t\tif (animationSubGeometry)\n\t\t\treturn animationSubGeometry;\n\n\t\tthis._iGenerateAnimationSubGeometries(mesh);\n\n\t\treturn (mesh.shareAnimationGeometry)? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id];\n\t}\n\n\n\t/** @private */\n\tpublic _iGenerateAnimationSubGeometries(mesh:Mesh)\n\t{\n\t\tif (this.initParticleFunc == null)\n\t\t\tthrow(new Error(\"no initParticleFunc set\"));\n\n\t\tvar geometry:ParticleGeometry = <ParticleGeometry> mesh.geometry;\n\n\t\tif (!geometry)\n\t\t\tthrow(new Error(\"Particle animation can only be performed on a ParticleGeometry object\"));\n\n\t\tvar i:number /*int*/, j:number /*int*/, k:number /*int*/;\n\t\tvar animationSubGeometry:AnimationSubGeometry;\n\t\tvar newAnimationSubGeometry:boolean = false;\n\t\tvar subGeometry:SubGeometryBase;\n\t\tvar subMesh:ISubMesh;\n\t\tvar localNode:ParticleNodeBase;\n\n\t\tfor (i = 0; i < mesh.subMeshes.length; i++) {\n\t\t\tsubMesh = mesh.subMeshes[i];\n\t\t\tsubGeometry = subMesh.subGeometry;\n\t\t\tif (mesh.shareAnimationGeometry) {\n\t\t\t\tanimationSubGeometry = this._animationSubGeometries[subGeometry.id];\n\n\t\t\t\tif (animationSubGeometry)\n\t\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tanimationSubGeometry = new AnimationSubGeometry();\n\n\t\t\tif (mesh.shareAnimationGeometry)\n\t\t\t\tthis._animationSubGeometries[subGeometry.id] = animationSubGeometry;\n\t\t\telse\n\t\t\t\tthis._animationSubGeometries[subMesh.id] = animationSubGeometry;\n\n\t\t\tnewAnimationSubGeometry = true;\n\n\t\t\t//create the vertexData vector that will be used for local node data\n\t\t\tanimationSubGeometry.createVertexData(subGeometry.numVertices, this._totalLenOfOneVertex);\n\t\t}\n\n\t\tif (!newAnimationSubGeometry)\n\t\t\treturn;\n\n\t\tvar particles:Array<ParticleData> = geometry.particles;\n\t\tvar particlesLength:number /*uint*/ = particles.length;\n\t\tvar numParticles:number /*uint*/ = geometry.numParticles;\n\t\tvar particleProperties:ParticleProperties = new ParticleProperties();\n\t\tvar particle:ParticleData;\n\n\t\tvar oneDataLen:number /*int*/;\n\t\tvar oneDataOffset:number /*int*/;\n\t\tvar counterForVertex:number /*int*/;\n\t\tvar counterForOneData:number /*int*/;\n\t\tvar oneData:Array<number>;\n\t\tvar numVertices:number /*uint*/;\n\t\tvar vertexData:Array<number>;\n\t\tvar vertexLength:number /*uint*/;\n\t\tvar startingOffset:number /*uint*/;\n\t\tvar vertexOffset:number /*uint*/;\n\n\t\t//default values for particle param\n\t\tparticleProperties.total = numParticles;\n\t\tparticleProperties.startTime = 0;\n\t\tparticleProperties.duration = 1000;\n\t\tparticleProperties.delay = 0.1;\n\n\t\ti = 0;\n\t\tj = 0;\n\t\twhile (i < numParticles) {\n\t\t\tparticleProperties.index = i;\n\n\t\t\t//call the init on the particle parameters\n\t\t\tthis.initParticleFunc.call(this.initParticleScope, particleProperties);\n\n\t\t\t//create the next set of node properties for the particle\n\t\t\tfor (k = 0; k < this._localStaticNodes.length; k++)\n\t\t\t\tthis._localStaticNodes[k]._iGeneratePropertyOfOneParticle(particleProperties);\n\n\t\t\t//loop through all particle data for the curent particle\n\t\t\twhile (j < particlesLength && (particle = particles[j]).particleIndex == i) {\n\t\t\t\t//find the target animationSubGeometry\n\t\t\t\tfor (k = 0; k < mesh.subMeshes.length; k++) {\n\t\t\t\t\tsubMesh = mesh.subMeshes[k];\n\t\t\t\t\tif (subMesh.subGeometry == particle.subGeometry) {\n\t\t\t\t\t\tanimationSubGeometry = (mesh.shareAnimationGeometry)? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tnumVertices = particle.numVertices;\n\t\t\t\tvertexData = animationSubGeometry.vertexData;\n\t\t\t\tvertexLength = numVertices*this._totalLenOfOneVertex;\n\t\t\t\tstartingOffset = animationSubGeometry.numProcessedVertices*this._totalLenOfOneVertex;\n\n\t\t\t\t//loop through each static local node in the animation set\n\t\t\t\tfor (k = 0; k < this._localStaticNodes.length; k++) {\n\t\t\t\t\tlocalNode = this._localStaticNodes[k];\n\t\t\t\t\toneData = localNode.oneData;\n\t\t\t\t\toneDataLen = localNode.dataLength;\n\t\t\t\t\toneDataOffset = startingOffset + localNode._iDataOffset;\n\n\t\t\t\t\t//loop through each vertex set in the vertex data\n\t\t\t\t\tfor (counterForVertex = 0; counterForVertex < vertexLength; counterForVertex += this._totalLenOfOneVertex) {\n\t\t\t\t\t\tvertexOffset = oneDataOffset + counterForVertex;\n\n\t\t\t\t\t\t//add the data for the local node to the vertex data\n\t\t\t\t\t\tfor (counterForOneData = 0; counterForOneData < oneDataLen; counterForOneData++)\n\t\t\t\t\t\t\tvertexData[vertexOffset + counterForOneData] = oneData[counterForOneData];\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\t//store particle properties if they need to be retreived for dynamic local nodes\n\t\t\t\tif (this._localDynamicNodes.length)\n\t\t\t\t\tanimationSubGeometry.animationParticles.push(new ParticleAnimationData(i, particleProperties.startTime, particleProperties.duration, particleProperties.delay, particle));\n\n\t\t\t\tanimationSubGeometry.numProcessedVertices += numVertices;\n\n\t\t\t\t//next index\n\t\t\t\tj++;\n\t\t\t}\n\n\t\t\t//next particle\n\t\t\ti++;\n\t\t}\n\t}\n}\n\nexport = ParticleAnimationSet;"]} \ No newline at end of file diff --git a/lib/animators/ParticleAnimationSet.ts b/lib/animators/ParticleAnimationSet.ts new file mode 100644 index 000000000..d4d51f476 --- /dev/null +++ b/lib/animators/ParticleAnimationSet.ts @@ -0,0 +1,415 @@ +import IAnimationSet = require("awayjs-core/lib/animators/IAnimationSet"); +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +import ISubMesh = require("awayjs-core/lib/core/base/ISubMesh"); +import SubGeometryBase = require("awayjs-core/lib/core/base/SubGeometryBase"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); + +import AnimationSetBase = require("awayjs-stagegl/lib/animators/AnimationSetBase"); +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); + +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticleAnimationData = require("awayjs-renderergl/lib/animators/data/ParticleAnimationData"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleData = require("awayjs-renderergl/lib/animators/data/ParticleData"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleTimeNode = require("awayjs-renderergl/lib/animators/nodes/ParticleTimeNode"); +import ParticleGeometry = require("awayjs-renderergl/lib/core/base/ParticleGeometry"); + +/** + * The animation data set used by particle-based animators, containing particle animation data. + * + * @see away.animators.ParticleAnimator + */ +class ParticleAnimationSet extends AnimationSetBase implements IAnimationSet +{ + /** @private */ + public _iAnimationRegisterCache:AnimationRegisterCache; + + //all other nodes dependent on it + private _timeNode:ParticleTimeNode; + + /** + * Property used by particle nodes that require compilation at the end of the shader + */ + public static POST_PRIORITY:number /*int*/ = 9; + + /** + * Property used by particle nodes that require color compilation + */ + public static COLOR_PRIORITY:number /*int*/ = 18; + + private _animationSubGeometries:Object = new Object(); + private _particleNodes:Array = new Array(); + private _localDynamicNodes:Array = new Array(); + private _localStaticNodes:Array = new Array(); + private _totalLenOfOneVertex:number /*int*/ = 0; + + //set true if has an node which will change UV + public hasUVNode:boolean; + //set if the other nodes need to access the velocity + public needVelocity:boolean; + //set if has a billboard node. + public hasBillboard:boolean; + //set if has an node which will apply color multiple operation + public hasColorMulNode:boolean; + //set if has an node which will apply color add operation + public hasColorAddNode:boolean; + + /** + * Initialiser function for static particle properties. Needs to reference a with the following format + * + * + * initParticleFunc(prop:ParticleProperties) + * { + * //code for settings local properties + * } + * + * + * Aside from setting any properties required in particle animation nodes using local static properties, the initParticleFunc function + * is required to time node requirements as they may be needed. These properties on the ParticleProperties object can include + * startTime, duration and delay. The use of these properties is determined by the setting + * arguments passed in the constructor of the particle animation set. By default, only the startTime property is required. + */ + public initParticleFunc:Function; + + /** + * Initialiser function scope for static particle properties + */ + public initParticleScope:Object; + + /** + * Creates a new ParticleAnimationSet + * + * @param [optional] usesDuration Defines whether the animation set uses the duration data in its static properties to determine how long a particle is visible for. Defaults to false. + * @param [optional] usesLooping Defines whether the animation set uses a looping timeframe for each particle determined by the startTime, duration and delay data in its static properties function. Defaults to false. Requires usesDuration to be true. + * @param [optional] usesDelay Defines whether the animation set uses the delay data in its static properties to determine how long a particle is hidden for. Defaults to false. Requires usesLooping to be true. + */ + constructor(usesDuration:boolean = false, usesLooping:boolean = false, usesDelay:boolean = false) + { + super(); + + //automatically add a particle time node to the set + this.addAnimation(this._timeNode = new ParticleTimeNode(usesDuration, usesLooping, usesDelay)); + } + + /** + * Returns a vector of the particle animation nodes contained within the set. + */ + public get particleNodes():Array + { + return this._particleNodes; + } + + /** + * @inheritDoc + */ + public addAnimation(node:AnimationNodeBase) + { + var i:number /*int*/; + var n:ParticleNodeBase = node; + n._iProcessAnimationSetting(this); + if (n.mode == ParticlePropertiesMode.LOCAL_STATIC) { + n._iDataOffset = this._totalLenOfOneVertex; + this._totalLenOfOneVertex += n.dataLength; + this._localStaticNodes.push(n); + } else if (n.mode == ParticlePropertiesMode.LOCAL_DYNAMIC) + this._localDynamicNodes.push(n); + + for (i = this._particleNodes.length - 1; i >= 0; i--) { + if (this._particleNodes[i].priority <= n.priority) + break; + } + + this._particleNodes.splice(i + 1, 0, n); + + super.addAnimation(node); + } + + /** + * @inheritDoc + */ + public activate(shaderObject:ShaderObjectBase, stage:Stage) + { +// this._iAnimationRegisterCache = pass.animationRegisterCache; + } + + /** + * @inheritDoc + */ + public deactivate(shaderObject:ShaderObjectBase, stage:Stage) + { +// var context:IContextStageGL = stage.context; +// var offset:number /*int*/ = this._iAnimationRegisterCache.vertexAttributesOffset; +// var used:number /*int*/ = this._iAnimationRegisterCache.numUsedStreams; +// for (var i:number /*int*/ = offset; i < used; i++) +// context.setVertexBufferAt(i, null); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase):string + { + //grab animationRegisterCache from the materialpassbase or create a new one if the first time + this._iAnimationRegisterCache = shaderObject.animationRegisterCache; + + if (this._iAnimationRegisterCache == null) + this._iAnimationRegisterCache = shaderObject.animationRegisterCache = new AnimationRegisterCache(shaderObject.profile); + + //reset animationRegisterCache + this._iAnimationRegisterCache.vertexConstantOffset = shaderObject.numUsedVertexConstants; + this._iAnimationRegisterCache.vertexAttributesOffset = shaderObject.numUsedStreams; + this._iAnimationRegisterCache.varyingsOffset = shaderObject.numUsedVaryings; + this._iAnimationRegisterCache.fragmentConstantOffset = shaderObject.numUsedFragmentConstants; + this._iAnimationRegisterCache.hasUVNode = this.hasUVNode; + this._iAnimationRegisterCache.needVelocity = this.needVelocity; + this._iAnimationRegisterCache.hasBillboard = this.hasBillboard; + this._iAnimationRegisterCache.sourceRegisters = shaderObject.animatableAttributes; + this._iAnimationRegisterCache.targetRegisters = shaderObject.animationTargetRegisters; + this._iAnimationRegisterCache.needFragmentAnimation = shaderObject.usesFragmentAnimation; + this._iAnimationRegisterCache.needUVAnimation = !shaderObject.usesUVTransform; + this._iAnimationRegisterCache.hasColorAddNode = this.hasColorAddNode; + this._iAnimationRegisterCache.hasColorMulNode = this.hasColorMulNode; + this._iAnimationRegisterCache.reset(); + + var code:string = ""; + + code += this._iAnimationRegisterCache.getInitCode(); + + var node:ParticleNodeBase; + var i:number /*int*/; + + for (i = 0; i < this._particleNodes.length; i++) { + node = this._particleNodes[i]; + if (node.priority < ParticleAnimationSet.POST_PRIORITY) + code += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache); + } + + code += this._iAnimationRegisterCache.getCombinationCode(); + + for (i = 0; i < this._particleNodes.length; i++) { + node = this._particleNodes[i]; + if (node.priority >= ParticleAnimationSet.POST_PRIORITY && node.priority < ParticleAnimationSet.COLOR_PRIORITY) + code += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache); + } + + code += this._iAnimationRegisterCache.initColorRegisters(); + + for (i = 0; i < this._particleNodes.length; i++) { + node = this._particleNodes[i]; + if (node.priority >= ParticleAnimationSet.COLOR_PRIORITY) + code += node.getAGALVertexCode(shaderObject, this._iAnimationRegisterCache); + } + code += this._iAnimationRegisterCache.getColorPassCode(); + return code; + } + + /** + * @inheritDoc + */ + public getAGALUVCode(shaderObject:ShaderObjectBase):string + { + var code:string = ""; + if (this.hasUVNode) { + this._iAnimationRegisterCache.setUVSourceAndTarget(shaderObject.uvSource, shaderObject.uvTarget); + code += "mov " + this._iAnimationRegisterCache.uvTarget + ".xy," + this._iAnimationRegisterCache.uvAttribute.toString() + "\n"; + var node:ParticleNodeBase; + for (var i:number /*uint*/ = 0; i < this._particleNodes.length; i++) + node = this._particleNodes[i]; + code += node.getAGALUVCode(shaderObject, this._iAnimationRegisterCache); + code += "mov " + this._iAnimationRegisterCache.uvVar.toString() + "," + this._iAnimationRegisterCache.uvTarget + ".xy\n"; + } else + code += "mov " + shaderObject.uvTarget + "," + shaderObject.uvSource + "\n"; + return code; + } + + /** + * @inheritDoc + */ + public getAGALFragmentCode(shaderObject:ShaderObjectBase, shadedTarget:string):string + { + return this._iAnimationRegisterCache.getColorCombinationCode(shadedTarget); + } + + /** + * @inheritDoc + */ + public doneAGALCode(shaderObject:ShaderObjectBase) + { + this._iAnimationRegisterCache.setDataLength(); + + //set vertexZeroConst,vertexOneConst,vertexTwoConst + this._iAnimationRegisterCache.setVertexConst(this._iAnimationRegisterCache.vertexZeroConst.index, 0, 1, 2, 0); + } + + /** + * @inheritDoc + */ + public get usesCPU():boolean + { + return false; + } + + /** + * @inheritDoc + */ + public cancelGPUCompatibility() + { + + } + + public dispose() + { + for (var key in this._animationSubGeometries) + ( this._animationSubGeometries[key]).dispose(); + + super.dispose(); + } + + public getAnimationSubGeometry(subMesh:ISubMesh) + { + var mesh:Mesh = subMesh.parentMesh; + var animationSubGeometry:AnimationSubGeometry = (mesh.shareAnimationGeometry)? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id]; + + if (animationSubGeometry) + return animationSubGeometry; + + this._iGenerateAnimationSubGeometries(mesh); + + return (mesh.shareAnimationGeometry)? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id]; + } + + + /** @private */ + public _iGenerateAnimationSubGeometries(mesh:Mesh) + { + if (this.initParticleFunc == null) + throw(new Error("no initParticleFunc set")); + + var geometry:ParticleGeometry = mesh.geometry; + + if (!geometry) + throw(new Error("Particle animation can only be performed on a ParticleGeometry object")); + + var i:number /*int*/, j:number /*int*/, k:number /*int*/; + var animationSubGeometry:AnimationSubGeometry; + var newAnimationSubGeometry:boolean = false; + var subGeometry:SubGeometryBase; + var subMesh:ISubMesh; + var localNode:ParticleNodeBase; + + for (i = 0; i < mesh.subMeshes.length; i++) { + subMesh = mesh.subMeshes[i]; + subGeometry = subMesh.subGeometry; + if (mesh.shareAnimationGeometry) { + animationSubGeometry = this._animationSubGeometries[subGeometry.id]; + + if (animationSubGeometry) + continue; + } + + animationSubGeometry = new AnimationSubGeometry(); + + if (mesh.shareAnimationGeometry) + this._animationSubGeometries[subGeometry.id] = animationSubGeometry; + else + this._animationSubGeometries[subMesh.id] = animationSubGeometry; + + newAnimationSubGeometry = true; + + //create the vertexData vector that will be used for local node data + animationSubGeometry.createVertexData(subGeometry.numVertices, this._totalLenOfOneVertex); + } + + if (!newAnimationSubGeometry) + return; + + var particles:Array = geometry.particles; + var particlesLength:number /*uint*/ = particles.length; + var numParticles:number /*uint*/ = geometry.numParticles; + var particleProperties:ParticleProperties = new ParticleProperties(); + var particle:ParticleData; + + var oneDataLen:number /*int*/; + var oneDataOffset:number /*int*/; + var counterForVertex:number /*int*/; + var counterForOneData:number /*int*/; + var oneData:Array; + var numVertices:number /*uint*/; + var vertexData:Array; + var vertexLength:number /*uint*/; + var startingOffset:number /*uint*/; + var vertexOffset:number /*uint*/; + + //default values for particle param + particleProperties.total = numParticles; + particleProperties.startTime = 0; + particleProperties.duration = 1000; + particleProperties.delay = 0.1; + + i = 0; + j = 0; + while (i < numParticles) { + particleProperties.index = i; + + //call the init on the particle parameters + this.initParticleFunc.call(this.initParticleScope, particleProperties); + + //create the next set of node properties for the particle + for (k = 0; k < this._localStaticNodes.length; k++) + this._localStaticNodes[k]._iGeneratePropertyOfOneParticle(particleProperties); + + //loop through all particle data for the curent particle + while (j < particlesLength && (particle = particles[j]).particleIndex == i) { + //find the target animationSubGeometry + for (k = 0; k < mesh.subMeshes.length; k++) { + subMesh = mesh.subMeshes[k]; + if (subMesh.subGeometry == particle.subGeometry) { + animationSubGeometry = (mesh.shareAnimationGeometry)? this._animationSubGeometries[subMesh.subGeometry.id] : this._animationSubGeometries[subMesh.id]; + break; + } + } + numVertices = particle.numVertices; + vertexData = animationSubGeometry.vertexData; + vertexLength = numVertices*this._totalLenOfOneVertex; + startingOffset = animationSubGeometry.numProcessedVertices*this._totalLenOfOneVertex; + + //loop through each static local node in the animation set + for (k = 0; k < this._localStaticNodes.length; k++) { + localNode = this._localStaticNodes[k]; + oneData = localNode.oneData; + oneDataLen = localNode.dataLength; + oneDataOffset = startingOffset + localNode._iDataOffset; + + //loop through each vertex set in the vertex data + for (counterForVertex = 0; counterForVertex < vertexLength; counterForVertex += this._totalLenOfOneVertex) { + vertexOffset = oneDataOffset + counterForVertex; + + //add the data for the local node to the vertex data + for (counterForOneData = 0; counterForOneData < oneDataLen; counterForOneData++) + vertexData[vertexOffset + counterForOneData] = oneData[counterForOneData]; + } + + } + + //store particle properties if they need to be retreived for dynamic local nodes + if (this._localDynamicNodes.length) + animationSubGeometry.animationParticles.push(new ParticleAnimationData(i, particleProperties.startTime, particleProperties.duration, particleProperties.delay, particle)); + + animationSubGeometry.numProcessedVertices += numVertices; + + //next index + j++; + } + + //next particle + i++; + } + } +} + +export = ParticleAnimationSet; \ No newline at end of file diff --git a/lib/animators/ParticleAnimator.js b/lib/animators/ParticleAnimator.js new file mode 100755 index 000000000..dc03af739 --- /dev/null +++ b/lib/animators/ParticleAnimator.js @@ -0,0 +1,128 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +var ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +var AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +/** + * Provides an interface for assigning paricle-based animation data sets to mesh-based entity objects + * and controlling the various available states of animation through an interative playhead that can be + * automatically updated or manually triggered. + * + * Requires that the containing geometry of the parent mesh is particle geometry + * + * @see away.base.ParticleGeometry + */ +var ParticleAnimator = (function (_super) { + __extends(ParticleAnimator, _super); + /** + * Creates a new ParticleAnimator object. + * + * @param particleAnimationSet The animation data set containing the particle animations used by the animator. + */ + function ParticleAnimator(particleAnimationSet) { + _super.call(this, particleAnimationSet); + this._animationParticleStates = new Array(); + this._animatorParticleStates = new Array(); + this._timeParticleStates = new Array(); + this._totalLenOfOneVertex = 0; + this._animatorSubGeometries = new Object(); + this._particleAnimationSet = particleAnimationSet; + var state; + var node; + for (var i = 0; i < this._particleAnimationSet.particleNodes.length; i++) { + node = this._particleAnimationSet.particleNodes[i]; + state = this.getAnimationState(node); + if (node.mode == ParticlePropertiesMode.LOCAL_DYNAMIC) { + this._animatorParticleStates.push(state); + node._iDataOffset = this._totalLenOfOneVertex; + this._totalLenOfOneVertex += node.dataLength; + } + else { + this._animationParticleStates.push(state); + } + if (state.needUpdateTime) + this._timeParticleStates.push(state); + } + } + /** + * @inheritDoc + */ + ParticleAnimator.prototype.clone = function () { + return new ParticleAnimator(this._particleAnimationSet); + }; + /** + * @inheritDoc + */ + ParticleAnimator.prototype.setRenderState = function (shaderObject, renderable, stage, camera, vertexConstantOffset /*int*/, vertexStreamOffset /*int*/) { + var animationRegisterCache = this._particleAnimationSet._iAnimationRegisterCache; + var subMesh = renderable.subMesh; + var state; + var i; + if (!subMesh) + throw (new Error("Must be subMesh")); + //process animation sub geometries + var animationSubGeometry = this._particleAnimationSet.getAnimationSubGeometry(subMesh); + for (i = 0; i < this._animationParticleStates.length; i++) + this._animationParticleStates[i].setRenderState(stage, renderable, animationSubGeometry, animationRegisterCache, camera); + //process animator subgeometries + var animatorSubGeometry = this.getAnimatorSubGeometry(subMesh); + for (i = 0; i < this._animatorParticleStates.length; i++) + this._animatorParticleStates[i].setRenderState(stage, renderable, animatorSubGeometry, animationRegisterCache, camera); + stage.context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, animationRegisterCache.vertexConstantOffset, animationRegisterCache.vertexConstantData, animationRegisterCache.numVertexConstant); + if (animationRegisterCache.numFragmentConstant > 0) + stage.context.setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, animationRegisterCache.fragmentConstantOffset, animationRegisterCache.fragmentConstantData, animationRegisterCache.numFragmentConstant); + }; + /** + * @inheritDoc + */ + ParticleAnimator.prototype.testGPUCompatibility = function (shaderObject) { + }; + /** + * @inheritDoc + */ + ParticleAnimator.prototype.start = function () { + _super.prototype.start.call(this); + for (var i = 0; i < this._timeParticleStates.length; i++) + this._timeParticleStates[i].offset(this._pAbsoluteTime); + }; + /** + * @inheritDoc + */ + ParticleAnimator.prototype._pUpdateDeltaTime = function (dt) { + this._pAbsoluteTime += dt; + for (var i = 0; i < this._timeParticleStates.length; i++) + this._timeParticleStates[i].update(this._pAbsoluteTime); + }; + /** + * @inheritDoc + */ + ParticleAnimator.prototype.resetTime = function (offset) { + if (offset === void 0) { offset = 0; } + for (var i = 0; i < this._timeParticleStates.length; i++) + this._timeParticleStates[i].offset(this._pAbsoluteTime + offset); + this.update(this.time); + }; + ParticleAnimator.prototype.dispose = function () { + for (var key in this._animatorSubGeometries) + this._animatorSubGeometries[key].dispose(); + }; + ParticleAnimator.prototype.getAnimatorSubGeometry = function (subMesh) { + if (!this._animatorParticleStates.length) + return; + var subGeometry = subMesh.subGeometry; + var animatorSubGeometry = this._animatorSubGeometries[subGeometry.id] = new AnimationSubGeometry(); + //create the vertexData vector that will be used for local state data + animatorSubGeometry.createVertexData(subGeometry.numVertices, this._totalLenOfOneVertex); + //pass the particles data to the animator subGeometry + animatorSubGeometry.animationParticles = this._particleAnimationSet.getAnimationSubGeometry(subMesh).animationParticles; + }; + return ParticleAnimator; +})(AnimatorBase); +module.exports = ParticleAnimator; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/particleanimator.ts"],"names":["ParticleAnimator","ParticleAnimator.constructor","ParticleAnimator.clone","ParticleAnimator.setRenderState","ParticleAnimator.testGPUCompatibility","ParticleAnimator.start","ParticleAnimator._pUpdateDeltaTime","ParticleAnimator.resetTime","ParticleAnimator.dispose","ParticleAnimator.getAnimatorSubGeometry"],"mappings":"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","file":"animators/ParticleAnimator.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ISubMesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/ISubMesh\");\nimport SubGeometryBase\t\t\t\t\t= require(\"awayjs-core/lib/core/base/SubGeometryBase\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport TriangleSubMeshRenderable\t\t= require(\"awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable\");\nimport ContextGLProgramType\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLProgramType\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticleAnimationData\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleAnimationData\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * Provides an interface for assigning paricle-based animation data sets to mesh-based entity objects\n * and controlling the various available states of animation through an interative playhead that can be\n * automatically updated or manually triggered.\n *\n * Requires that the containing geometry of the parent mesh is particle geometry\n *\n * @see away.base.ParticleGeometry\n */\nclass ParticleAnimator extends AnimatorBase\n{\n\n\tprivate _particleAnimationSet:ParticleAnimationSet;\n\tprivate _animationParticleStates:Array<ParticleStateBase> = new Array<ParticleStateBase>();\n\tprivate _animatorParticleStates:Array<ParticleStateBase> = new Array<ParticleStateBase>();\n\tprivate _timeParticleStates:Array<ParticleStateBase> = new Array<ParticleStateBase>();\n\tprivate _totalLenOfOneVertex:number /*uint*/ = 0;\n\tprivate _animatorSubGeometries:Object = new Object();\n\n\t/**\n\t * Creates a new <code>ParticleAnimator</code> object.\n\t *\n\t * @param particleAnimationSet The animation data set containing the particle animations used by the animator.\n\t */\n\tconstructor(particleAnimationSet:ParticleAnimationSet)\n\t{\n\t\tsuper(particleAnimationSet);\n\t\tthis._particleAnimationSet = particleAnimationSet;\n\n\t\tvar state:ParticleStateBase;\n\t\tvar node:ParticleNodeBase;\n\n\t\tfor (var i:number = 0; i < this._particleAnimationSet.particleNodes.length; i++) {\n\t\t\tnode = this._particleAnimationSet.particleNodes[i];\n\t\t\tstate = <ParticleStateBase> this.getAnimationState(node);\n\t\t\tif (node.mode == ParticlePropertiesMode.LOCAL_DYNAMIC) {\n\t\t\t\tthis._animatorParticleStates.push(state);\n\t\t\t\tnode._iDataOffset = this._totalLenOfOneVertex;\n\t\t\t\tthis._totalLenOfOneVertex += node.dataLength;\n\t\t\t} else {\n\t\t\t\tthis._animationParticleStates.push(state);\n\t\t\t}\n\t\t\tif (state.needUpdateTime)\n\t\t\t\tthis._timeParticleStates.push(state);\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic clone():AnimatorBase\n\t{\n\t\treturn new ParticleAnimator(this._particleAnimationSet);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setRenderState(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, camera:Camera, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/)\n\t{\n\t\tvar animationRegisterCache:AnimationRegisterCache = this._particleAnimationSet._iAnimationRegisterCache;\n\n\t\tvar subMesh:ISubMesh = (<TriangleSubMeshRenderable> renderable).subMesh;\n\t\tvar state:ParticleStateBase;\n\t\tvar i:number;\n\n\t\tif (!subMesh)\n\t\t\tthrow(new Error(\"Must be subMesh\"));\n\n\t\t//process animation sub geometries\n\t\tvar animationSubGeometry:AnimationSubGeometry = this._particleAnimationSet.getAnimationSubGeometry(subMesh);\n\n\t\tfor (i = 0; i < this._animationParticleStates.length; i++)\n\t\t\tthis._animationParticleStates[i].setRenderState(stage, renderable, animationSubGeometry, animationRegisterCache, camera);\n\n\t\t//process animator subgeometries\n\t\tvar animatorSubGeometry:AnimationSubGeometry = this.getAnimatorSubGeometry(subMesh);\n\n\t\tfor (i = 0; i < this._animatorParticleStates.length; i++)\n\t\t\tthis._animatorParticleStates[i].setRenderState(stage, renderable, animatorSubGeometry, animationRegisterCache, camera);\n\n\t\t(<IContextStageGL> stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, animationRegisterCache.vertexConstantOffset, animationRegisterCache.vertexConstantData, animationRegisterCache.numVertexConstant);\n\n\t\tif (animationRegisterCache.numFragmentConstant > 0)\n\t\t\t(<IContextStageGL> stage.context).setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, animationRegisterCache.fragmentConstantOffset, animationRegisterCache.fragmentConstantData, animationRegisterCache.numFragmentConstant);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic testGPUCompatibility(shaderObject:ShaderObjectBase)\n\t{\n\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic start()\n\t{\n\t\tsuper.start();\n\n\t\tfor (var i:number = 0; i < this._timeParticleStates.length; i++)\n\t\t\tthis._timeParticleStates[i].offset(this._pAbsoluteTime);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdateDeltaTime(dt:number)\n\t{\n\t\tthis._pAbsoluteTime += dt;\n\n\t\tfor (var i:number = 0; i < this._timeParticleStates.length; i++)\n\t\t\tthis._timeParticleStates[i].update(this._pAbsoluteTime);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic resetTime(offset:number /*int*/ = 0)\n\t{\n\t\tfor (var i:number = 0; i < this._timeParticleStates.length; i++)\n\t\t\tthis._timeParticleStates[i].offset(this._pAbsoluteTime + offset);\n\t\tthis.update(this.time);\n\t}\n\n\tpublic dispose()\n\t{\n\t\tfor (var key in this._animatorSubGeometries)\n\t\t\t(<AnimationSubGeometry> this._animatorSubGeometries[key]).dispose();\n\t}\n\n\tprivate getAnimatorSubGeometry(subMesh:ISubMesh):AnimationSubGeometry\n\t{\n\t\tif (!this._animatorParticleStates.length)\n\t\t\treturn;\n\n\t\tvar subGeometry:SubGeometryBase = subMesh.subGeometry;\n\t\tvar animatorSubGeometry:AnimationSubGeometry = this._animatorSubGeometries[subGeometry.id] = new AnimationSubGeometry();\n\n\t\t//create the vertexData vector that will be used for local state data\n\t\tanimatorSubGeometry.createVertexData(subGeometry.numVertices, this._totalLenOfOneVertex);\n\n\t\t//pass the particles data to the animator subGeometry\n\t\tanimatorSubGeometry.animationParticles = this._particleAnimationSet.getAnimationSubGeometry(subMesh).animationParticles;\n\t}\n}\n\nexport = ParticleAnimator;"]} \ No newline at end of file diff --git a/lib/animators/ParticleAnimator.ts b/lib/animators/ParticleAnimator.ts new file mode 100644 index 000000000..25e389fbc --- /dev/null +++ b/lib/animators/ParticleAnimator.ts @@ -0,0 +1,170 @@ +import ISubMesh = require("awayjs-core/lib/core/base/ISubMesh"); +import SubGeometryBase = require("awayjs-core/lib/core/base/SubGeometryBase"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import TriangleSubMeshRenderable = require("awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable"); +import ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticleAnimationData = require("awayjs-renderergl/lib/animators/data/ParticleAnimationData"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * Provides an interface for assigning paricle-based animation data sets to mesh-based entity objects + * and controlling the various available states of animation through an interative playhead that can be + * automatically updated or manually triggered. + * + * Requires that the containing geometry of the parent mesh is particle geometry + * + * @see away.base.ParticleGeometry + */ +class ParticleAnimator extends AnimatorBase +{ + + private _particleAnimationSet:ParticleAnimationSet; + private _animationParticleStates:Array = new Array(); + private _animatorParticleStates:Array = new Array(); + private _timeParticleStates:Array = new Array(); + private _totalLenOfOneVertex:number /*uint*/ = 0; + private _animatorSubGeometries:Object = new Object(); + + /** + * Creates a new ParticleAnimator object. + * + * @param particleAnimationSet The animation data set containing the particle animations used by the animator. + */ + constructor(particleAnimationSet:ParticleAnimationSet) + { + super(particleAnimationSet); + this._particleAnimationSet = particleAnimationSet; + + var state:ParticleStateBase; + var node:ParticleNodeBase; + + for (var i:number = 0; i < this._particleAnimationSet.particleNodes.length; i++) { + node = this._particleAnimationSet.particleNodes[i]; + state = this.getAnimationState(node); + if (node.mode == ParticlePropertiesMode.LOCAL_DYNAMIC) { + this._animatorParticleStates.push(state); + node._iDataOffset = this._totalLenOfOneVertex; + this._totalLenOfOneVertex += node.dataLength; + } else { + this._animationParticleStates.push(state); + } + if (state.needUpdateTime) + this._timeParticleStates.push(state); + } + } + + /** + * @inheritDoc + */ + public clone():AnimatorBase + { + return new ParticleAnimator(this._particleAnimationSet); + } + + /** + * @inheritDoc + */ + public setRenderState(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, camera:Camera, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/) + { + var animationRegisterCache:AnimationRegisterCache = this._particleAnimationSet._iAnimationRegisterCache; + + var subMesh:ISubMesh = ( renderable).subMesh; + var state:ParticleStateBase; + var i:number; + + if (!subMesh) + throw(new Error("Must be subMesh")); + + //process animation sub geometries + var animationSubGeometry:AnimationSubGeometry = this._particleAnimationSet.getAnimationSubGeometry(subMesh); + + for (i = 0; i < this._animationParticleStates.length; i++) + this._animationParticleStates[i].setRenderState(stage, renderable, animationSubGeometry, animationRegisterCache, camera); + + //process animator subgeometries + var animatorSubGeometry:AnimationSubGeometry = this.getAnimatorSubGeometry(subMesh); + + for (i = 0; i < this._animatorParticleStates.length; i++) + this._animatorParticleStates[i].setRenderState(stage, renderable, animatorSubGeometry, animationRegisterCache, camera); + + ( stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, animationRegisterCache.vertexConstantOffset, animationRegisterCache.vertexConstantData, animationRegisterCache.numVertexConstant); + + if (animationRegisterCache.numFragmentConstant > 0) + ( stage.context).setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, animationRegisterCache.fragmentConstantOffset, animationRegisterCache.fragmentConstantData, animationRegisterCache.numFragmentConstant); + } + + /** + * @inheritDoc + */ + public testGPUCompatibility(shaderObject:ShaderObjectBase) + { + + } + + /** + * @inheritDoc + */ + public start() + { + super.start(); + + for (var i:number = 0; i < this._timeParticleStates.length; i++) + this._timeParticleStates[i].offset(this._pAbsoluteTime); + } + + /** + * @inheritDoc + */ + public _pUpdateDeltaTime(dt:number) + { + this._pAbsoluteTime += dt; + + for (var i:number = 0; i < this._timeParticleStates.length; i++) + this._timeParticleStates[i].update(this._pAbsoluteTime); + } + + /** + * @inheritDoc + */ + public resetTime(offset:number /*int*/ = 0) + { + for (var i:number = 0; i < this._timeParticleStates.length; i++) + this._timeParticleStates[i].offset(this._pAbsoluteTime + offset); + this.update(this.time); + } + + public dispose() + { + for (var key in this._animatorSubGeometries) + ( this._animatorSubGeometries[key]).dispose(); + } + + private getAnimatorSubGeometry(subMesh:ISubMesh):AnimationSubGeometry + { + if (!this._animatorParticleStates.length) + return; + + var subGeometry:SubGeometryBase = subMesh.subGeometry; + var animatorSubGeometry:AnimationSubGeometry = this._animatorSubGeometries[subGeometry.id] = new AnimationSubGeometry(); + + //create the vertexData vector that will be used for local state data + animatorSubGeometry.createVertexData(subGeometry.numVertices, this._totalLenOfOneVertex); + + //pass the particles data to the animator subGeometry + animatorSubGeometry.animationParticles = this._particleAnimationSet.getAnimationSubGeometry(subMesh).animationParticles; + } +} + +export = ParticleAnimator; \ No newline at end of file diff --git a/lib/animators/SkeletonAnimationSet.js b/lib/animators/SkeletonAnimationSet.js new file mode 100755 index 000000000..e780a1a9f --- /dev/null +++ b/lib/animators/SkeletonAnimationSet.js @@ -0,0 +1,103 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationSetBase = require("awayjs-stagegl/lib/animators/AnimationSetBase"); +/** + * The animation data set used by skeleton-based animators, containing skeleton animation data. + * + * @see away.animators.SkeletonAnimator + */ +var SkeletonAnimationSet = (function (_super) { + __extends(SkeletonAnimationSet, _super); + /** + * Creates a new SkeletonAnimationSet object. + * + * @param jointsPerVertex Sets the amount of skeleton joints that can be linked to a single vertex via skinned weight values. For GPU-base animation, the maximum allowed value is 4. Defaults to 4. + */ + function SkeletonAnimationSet(jointsPerVertex) { + if (jointsPerVertex === void 0) { jointsPerVertex = 4; } + _super.call(this); + this._jointsPerVertex = jointsPerVertex; + } + Object.defineProperty(SkeletonAnimationSet.prototype, "jointsPerVertex", { + /** + * Returns the amount of skeleton joints that can be linked to a single vertex via skinned weight values. For GPU-base animation, the + * maximum allowed value is 4. + */ + get: function () { + return this._jointsPerVertex; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SkeletonAnimationSet.prototype.getAGALVertexCode = function (shaderObject) { + var len = shaderObject.animatableAttributes.length; + var indexOffset0 = shaderObject.numUsedVertexConstants; + var indexOffset1 = indexOffset0 + 1; + var indexOffset2 = indexOffset0 + 2; + var indexStream = "va" + shaderObject.numUsedStreams; + var weightStream = "va" + (shaderObject.numUsedStreams + 1); + var indices = [indexStream + ".x", indexStream + ".y", indexStream + ".z", indexStream + ".w"]; + var weights = [weightStream + ".x", weightStream + ".y", weightStream + ".z", weightStream + ".w"]; + var temp1 = this._pFindTempReg(shaderObject.animationTargetRegisters); + var temp2 = this._pFindTempReg(shaderObject.animationTargetRegisters, temp1); + var dot = "dp4"; + var code = ""; + for (var i = 0; i < len; ++i) { + var src = shaderObject.animatableAttributes[i]; + for (var j = 0; j < this._jointsPerVertex; ++j) { + code += dot + " " + temp1 + ".x, " + src + ", vc[" + indices[j] + "+" + indexOffset0 + "]\n" + dot + " " + temp1 + ".y, " + src + ", vc[" + indices[j] + "+" + indexOffset1 + "]\n" + dot + " " + temp1 + ".z, " + src + ", vc[" + indices[j] + "+" + indexOffset2 + "]\n" + "mov " + temp1 + ".w, " + src + ".w\n" + "mul " + temp1 + ", " + temp1 + ", " + weights[j] + "\n"; // apply weight + // add or mov to target. Need to write to a temp reg first, because an output can be a target + if (j == 0) + code += "mov " + temp2 + ", " + temp1 + "\n"; + else + code += "add " + temp2 + ", " + temp2 + ", " + temp1 + "\n"; + } + // switch to dp3 once positions have been transformed, from now on, it should only be vectors instead of points + dot = "dp3"; + code += "mov " + shaderObject.animationTargetRegisters[i] + ", " + temp2 + "\n"; + } + return code; + }; + /** + * @inheritDoc + */ + SkeletonAnimationSet.prototype.activate = function (shaderObject, stage) { + }; + /** + * @inheritDoc + */ + SkeletonAnimationSet.prototype.deactivate = function (shaderObject, stage) { + // var streamOffset:number /*uint*/ = pass.numUsedStreams; + // var context:IContextStageGL = stage.context; + // context.setVertexBufferAt(streamOffset, null); + // context.setVertexBufferAt(streamOffset + 1, null); + }; + /** + * @inheritDoc + */ + SkeletonAnimationSet.prototype.getAGALFragmentCode = function (shaderObject, shadedTarget) { + return ""; + }; + /** + * @inheritDoc + */ + SkeletonAnimationSet.prototype.getAGALUVCode = function (shaderObject) { + return "mov " + shaderObject.uvTarget + "," + shaderObject.uvSource + "\n"; + }; + /** + * @inheritDoc + */ + SkeletonAnimationSet.prototype.doneAGALCode = function (shaderObject) { + }; + return SkeletonAnimationSet; +})(AnimationSetBase); +module.exports = SkeletonAnimationSet; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/skeletonanimationset.ts"],"names":["SkeletonAnimationSet","SkeletonAnimationSet.constructor","SkeletonAnimationSet.jointsPerVertex","SkeletonAnimationSet.getAGALVertexCode","SkeletonAnimationSet.activate","SkeletonAnimationSet.deactivate","SkeletonAnimationSet.getAGALFragmentCode","SkeletonAnimationSet.getAGALUVCode","SkeletonAnimationSet.doneAGALCode"],"mappings":"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","file":"animators/SkeletonAnimationSet.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import IAnimationSet\t\t\t\t\t= require(\"awayjs-core/lib/animators/IAnimationSet\");\n\nimport AnimationSetBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimationSetBase\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\n\n/**\n * The animation data set used by skeleton-based animators, containing skeleton animation data.\n *\n * @see away.animators.SkeletonAnimator\n */\nclass SkeletonAnimationSet extends AnimationSetBase implements IAnimationSet\n{\n\tprivate _jointsPerVertex:number /*uint*/;\n\n\t/**\n\t * Returns the amount of skeleton joints that can be linked to a single vertex via skinned weight values. For GPU-base animation, the\n\t * maximum allowed value is 4.\n\t */\n\tpublic get jointsPerVertex():number /*uint*/\n\t{\n\t\treturn this._jointsPerVertex;\n\t}\n\n\t/**\n\t * Creates a new <code>SkeletonAnimationSet</code> object.\n\t *\n\t * @param jointsPerVertex Sets the amount of skeleton joints that can be linked to a single vertex via skinned weight values. For GPU-base animation, the maximum allowed value is 4. Defaults to 4.\n\t */\n\tconstructor(jointsPerVertex:number /*uint*/ = 4)\n\t{\n\t\tsuper();\n\n\t\tthis._jointsPerVertex = jointsPerVertex;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\tvar len:number /*uint*/ = shaderObject.animatableAttributes.length;\n\n\t\tvar indexOffset0:number /*uint*/ = shaderObject.numUsedVertexConstants;\n\t\tvar indexOffset1:number /*uint*/ = indexOffset0 + 1;\n\t\tvar indexOffset2:number /*uint*/ = indexOffset0 + 2;\n\t\tvar indexStream:string = \"va\" + shaderObject.numUsedStreams;\n\t\tvar weightStream:string = \"va\" + (shaderObject.numUsedStreams + 1);\n\t\tvar indices:Array<string> = [ indexStream + \".x\", indexStream + \".y\", indexStream + \".z\", indexStream + \".w\" ];\n\t\tvar weights:Array<string> = [ weightStream + \".x\", weightStream + \".y\", weightStream + \".z\", weightStream + \".w\" ];\n\t\tvar temp1:string = this._pFindTempReg(shaderObject.animationTargetRegisters);\n\t\tvar temp2:string = this._pFindTempReg(shaderObject.animationTargetRegisters, temp1);\n\t\tvar dot:string = \"dp4\";\n\t\tvar code:string = \"\";\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; ++i) {\n\n\t\t\tvar src:string = shaderObject.animatableAttributes[i];\n\n\t\t\tfor (var j:number /*uint*/ = 0; j < this._jointsPerVertex; ++j) {\n\t\t\t\tcode += dot + \" \" + temp1 + \".x, \" + src + \", vc[\" + indices[j] + \"+\" + indexOffset0 + \"]\\n\" +\n\t\t\t\t\tdot + \" \" + temp1 + \".y, \" + src + \", vc[\" + indices[j] + \"+\" + indexOffset1 + \"]\\n\" +\n\t\t\t\t\tdot + \" \" + temp1 + \".z, \" + src + \", vc[\" + indices[j] + \"+\" + indexOffset2 + \"]\\n\" +\n\t\t\t\t\t\"mov \" + temp1 + \".w, \" + src + \".w\\n\" +\n\t\t\t\t\t\"mul \" + temp1 + \", \" + temp1 + \", \" + weights[j] + \"\\n\"; // apply weight\n\n\t\t\t\t// add or mov to target. Need to write to a temp reg first, because an output can be a target\n\t\t\t\tif (j == 0)\n\t\t\t\t\tcode += \"mov \" + temp2 + \", \" + temp1 + \"\\n\"; else\n\t\t\t\t\tcode += \"add \" + temp2 + \", \" + temp2 + \", \" + temp1 + \"\\n\";\n\t\t\t}\n\t\t\t// switch to dp3 once positions have been transformed, from now on, it should only be vectors instead of points\n\t\t\tdot = \"dp3\";\n\t\t\tcode += \"mov \" + shaderObject.animationTargetRegisters[i] + \", \" + temp2 + \"\\n\";\n\t\t}\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic activate(shaderObject:ShaderObjectBase, stage:Stage)\n\t{\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic deactivate(shaderObject:ShaderObjectBase, stage:Stage)\n\t{\n//\t\t\tvar streamOffset:number /*uint*/ = pass.numUsedStreams;\n//\t\t\tvar context:IContextStageGL = <IContextStageGL> stage.context;\n//\t\t\tcontext.setVertexBufferAt(streamOffset, null);\n//\t\t\tcontext.setVertexBufferAt(streamOffset + 1, null);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALFragmentCode(shaderObject:ShaderObjectBase, shadedTarget:string):string\n\t{\n\t\treturn \"\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALUVCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\treturn \"mov \" + shaderObject.uvTarget + \",\" + shaderObject.uvSource + \"\\n\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic doneAGALCode(shaderObject:ShaderObjectBase)\n\t{\n\n\t}\n}\n\nexport = SkeletonAnimationSet;"]} \ No newline at end of file diff --git a/lib/animators/SkeletonAnimationSet.ts b/lib/animators/SkeletonAnimationSet.ts new file mode 100644 index 000000000..c14fd07cd --- /dev/null +++ b/lib/animators/SkeletonAnimationSet.ts @@ -0,0 +1,123 @@ +import IAnimationSet = require("awayjs-core/lib/animators/IAnimationSet"); + +import AnimationSetBase = require("awayjs-stagegl/lib/animators/AnimationSetBase"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); + +/** + * The animation data set used by skeleton-based animators, containing skeleton animation data. + * + * @see away.animators.SkeletonAnimator + */ +class SkeletonAnimationSet extends AnimationSetBase implements IAnimationSet +{ + private _jointsPerVertex:number /*uint*/; + + /** + * Returns the amount of skeleton joints that can be linked to a single vertex via skinned weight values. For GPU-base animation, the + * maximum allowed value is 4. + */ + public get jointsPerVertex():number /*uint*/ + { + return this._jointsPerVertex; + } + + /** + * Creates a new SkeletonAnimationSet object. + * + * @param jointsPerVertex Sets the amount of skeleton joints that can be linked to a single vertex via skinned weight values. For GPU-base animation, the maximum allowed value is 4. Defaults to 4. + */ + constructor(jointsPerVertex:number /*uint*/ = 4) + { + super(); + + this._jointsPerVertex = jointsPerVertex; + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase):string + { + var len:number /*uint*/ = shaderObject.animatableAttributes.length; + + var indexOffset0:number /*uint*/ = shaderObject.numUsedVertexConstants; + var indexOffset1:number /*uint*/ = indexOffset0 + 1; + var indexOffset2:number /*uint*/ = indexOffset0 + 2; + var indexStream:string = "va" + shaderObject.numUsedStreams; + var weightStream:string = "va" + (shaderObject.numUsedStreams + 1); + var indices:Array = [ indexStream + ".x", indexStream + ".y", indexStream + ".z", indexStream + ".w" ]; + var weights:Array = [ weightStream + ".x", weightStream + ".y", weightStream + ".z", weightStream + ".w" ]; + var temp1:string = this._pFindTempReg(shaderObject.animationTargetRegisters); + var temp2:string = this._pFindTempReg(shaderObject.animationTargetRegisters, temp1); + var dot:string = "dp4"; + var code:string = ""; + + for (var i:number /*uint*/ = 0; i < len; ++i) { + + var src:string = shaderObject.animatableAttributes[i]; + + for (var j:number /*uint*/ = 0; j < this._jointsPerVertex; ++j) { + code += dot + " " + temp1 + ".x, " + src + ", vc[" + indices[j] + "+" + indexOffset0 + "]\n" + + dot + " " + temp1 + ".y, " + src + ", vc[" + indices[j] + "+" + indexOffset1 + "]\n" + + dot + " " + temp1 + ".z, " + src + ", vc[" + indices[j] + "+" + indexOffset2 + "]\n" + + "mov " + temp1 + ".w, " + src + ".w\n" + + "mul " + temp1 + ", " + temp1 + ", " + weights[j] + "\n"; // apply weight + + // add or mov to target. Need to write to a temp reg first, because an output can be a target + if (j == 0) + code += "mov " + temp2 + ", " + temp1 + "\n"; else + code += "add " + temp2 + ", " + temp2 + ", " + temp1 + "\n"; + } + // switch to dp3 once positions have been transformed, from now on, it should only be vectors instead of points + dot = "dp3"; + code += "mov " + shaderObject.animationTargetRegisters[i] + ", " + temp2 + "\n"; + } + + return code; + } + + /** + * @inheritDoc + */ + public activate(shaderObject:ShaderObjectBase, stage:Stage) + { + } + + /** + * @inheritDoc + */ + public deactivate(shaderObject:ShaderObjectBase, stage:Stage) + { +// var streamOffset:number /*uint*/ = pass.numUsedStreams; +// var context:IContextStageGL = stage.context; +// context.setVertexBufferAt(streamOffset, null); +// context.setVertexBufferAt(streamOffset + 1, null); + } + + /** + * @inheritDoc + */ + public getAGALFragmentCode(shaderObject:ShaderObjectBase, shadedTarget:string):string + { + return ""; + } + + /** + * @inheritDoc + */ + public getAGALUVCode(shaderObject:ShaderObjectBase):string + { + return "mov " + shaderObject.uvTarget + "," + shaderObject.uvSource + "\n"; + } + + /** + * @inheritDoc + */ + public doneAGALCode(shaderObject:ShaderObjectBase) + { + + } +} + +export = SkeletonAnimationSet; \ No newline at end of file diff --git a/lib/animators/SkeletonAnimator.js b/lib/animators/SkeletonAnimator.js new file mode 100755 index 000000000..6b1010575 --- /dev/null +++ b/lib/animators/SkeletonAnimator.js @@ -0,0 +1,533 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var SubGeometryEvent = require("awayjs-core/lib/events/SubGeometryEvent"); +var AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +var ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var AnimationStateEvent = require("awayjs-renderergl/lib/events/AnimationStateEvent"); +/** + * Provides an interface for assigning skeleton-based animation data sets to mesh-based entity objects + * and controlling the various available states of animation through an interative playhead that can be + * automatically updated or manually triggered. + */ +var SkeletonAnimator = (function (_super) { + __extends(SkeletonAnimator, _super); + /** + * Creates a new SkeletonAnimator object. + * + * @param skeletonAnimationSet The animation data set containing the skeleton animations used by the animator. + * @param skeleton The skeleton object used for calculating the resulting global matrices for transforming skinned mesh data. + * @param forceCPU Optional value that only allows the animator to perform calculation on the CPU. Defaults to false. + */ + function SkeletonAnimator(animationSet, skeleton, forceCPU) { + var _this = this; + if (forceCPU === void 0) { forceCPU = false; } + _super.call(this, animationSet); + this._globalPose = new SkeletonPose(); + this._morphedSubGeometry = new Object(); + this._morphedSubGeometryDirty = new Object(); + this._skeleton = skeleton; + this._forceCPU = forceCPU; + this._jointsPerVertex = animationSet.jointsPerVertex; + this._numJoints = this._skeleton.numJoints; + this._globalMatrices = new Array(this._numJoints * 12); + var j = 0; + for (var i = 0; i < this._numJoints; ++i) { + this._globalMatrices[j++] = 1; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 1; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 1; + this._globalMatrices[j++] = 0; + } + this._onTransitionCompleteDelegate = function (event) { return _this.onTransitionComplete(event); }; + this._onIndicesUpdateDelegate = function (event) { return _this.onIndicesUpdate(event); }; + this._onVerticesUpdateDelegate = function (event) { return _this.onVerticesUpdate(event); }; + } + Object.defineProperty(SkeletonAnimator.prototype, "globalMatrices", { + /** + * returns the calculated global matrices of the current skeleton pose. + * + * @see #globalPose + */ + get: function () { + if (this._globalPropertiesDirty) + this.updateGlobalProperties(); + return this._globalMatrices; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SkeletonAnimator.prototype, "globalPose", { + /** + * returns the current skeleton pose output from the animator. + * + * @see away.animators.data.SkeletonPose + */ + get: function () { + if (this._globalPropertiesDirty) + this.updateGlobalProperties(); + return this._globalPose; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SkeletonAnimator.prototype, "skeleton", { + /** + * Returns the skeleton object in use by the animator - this defines the number and heirarchy of joints used by the + * skinned geoemtry to which skeleon animator is applied. + */ + get: function () { + return this._skeleton; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SkeletonAnimator.prototype, "forceCPU", { + /** + * Indicates whether the skeleton animator is disabled by default for GPU rendering, something that allows the animator to perform calculation on the GPU. + * Defaults to false. + */ + get: function () { + return this._forceCPU; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SkeletonAnimator.prototype, "useCondensedIndices", { + /** + * Offers the option of enabling GPU accelerated animation on skeletons larger than 32 joints + * by condensing the number of joint index values required per mesh. Only applicable to + * skeleton animations that utilise more than one mesh object. Defaults to false. + */ + get: function () { + return this._useCondensedIndices; + }, + set: function (value) { + this._useCondensedIndices = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SkeletonAnimator.prototype.clone = function () { + /* The cast to SkeletonAnimationSet should never fail, as _animationSet can only be set + through the constructor, which will only accept a SkeletonAnimationSet. */ + return new SkeletonAnimator(this._pAnimationSet, this._skeleton, this._forceCPU); + }; + /** + * Plays an animation state registered with the given name in the animation data set. + * + * @param name The data set name of the animation state to be played. + * @param transition An optional transition object that determines how the animator will transition from the currently active animation state. + * @param offset An option offset time (in milliseconds) that resets the state's internal clock to the absolute time of the animator plus the offset value. Required for non-looping animation states. + */ + SkeletonAnimator.prototype.play = function (name, transition, offset) { + if (transition === void 0) { transition = null; } + if (offset === void 0) { offset = NaN; } + if (this._pActiveAnimationName == name) + return; + this._pActiveAnimationName = name; + if (!this._pAnimationSet.hasAnimation(name)) + throw new Error("Animation root node " + name + " not found!"); + if (transition && this._pActiveNode) { + //setup the transition + this._pActiveNode = transition.getAnimationNode(this, this._pActiveNode, this._pAnimationSet.getAnimation(name), this._pAbsoluteTime); + this._pActiveNode.addEventListener(AnimationStateEvent.TRANSITION_COMPLETE, this._onTransitionCompleteDelegate); + } + else + this._pActiveNode = this._pAnimationSet.getAnimation(name); + this._pActiveState = this.getAnimationState(this._pActiveNode); + if (this.updatePosition) { + //update straight away to reset position deltas + this._pActiveState.update(this._pAbsoluteTime); + this._pActiveState.positionDelta; + } + this._activeSkeletonState = this._pActiveState; + this.start(); + //apply a time offset if specified + if (!isNaN(offset)) + this.reset(name, offset); + }; + /** + * @inheritDoc + */ + SkeletonAnimator.prototype.setRenderState = function (shaderObject, renderable, stage, camera, vertexConstantOffset /*int*/, vertexStreamOffset /*int*/) { + // do on request of globalProperties + if (this._globalPropertiesDirty) + this.updateGlobalProperties(); + var subGeometry = renderable.subMesh.subGeometry; + subGeometry.useCondensedIndices = this._useCondensedIndices; + if (this._useCondensedIndices) { + // using a condensed data set + this.updateCondensedMatrices(subGeometry.condensedIndexLookUp, subGeometry.numCondensedJoints); + stage.context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._condensedMatrices, subGeometry.numCondensedJoints * 3); + } + else { + if (this._pAnimationSet.usesCPU) { + if (this._morphedSubGeometryDirty[subGeometry.id]) + this.morphSubGeometry(renderable, subGeometry); + return; + } + stage.context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._globalMatrices, this._numJoints * 3); + } + stage.context.activateBuffer(vertexStreamOffset, renderable.getVertexData(TriangleSubGeometry.JOINT_INDEX_DATA), renderable.getVertexOffset(TriangleSubGeometry.JOINT_INDEX_DATA), renderable.JOINT_INDEX_FORMAT); + stage.context.activateBuffer(vertexStreamOffset + 1, renderable.getVertexData(TriangleSubGeometry.JOINT_WEIGHT_DATA), renderable.getVertexOffset(TriangleSubGeometry.JOINT_WEIGHT_DATA), renderable.JOINT_WEIGHT_FORMAT); + }; + /** + * @inheritDoc + */ + SkeletonAnimator.prototype.testGPUCompatibility = function (shaderObject) { + if (!this._useCondensedIndices && (this._forceCPU || this._jointsPerVertex > 4 || shaderObject.numUsedVertexConstants + this._numJoints * 3 > 128)) + this._pAnimationSet.cancelGPUCompatibility(); + }; + /** + * Applies the calculated time delta to the active animation state node or state transition object. + */ + SkeletonAnimator.prototype._pUpdateDeltaTime = function (dt) { + _super.prototype._pUpdateDeltaTime.call(this, dt); + //invalidate pose matrices + this._globalPropertiesDirty = true; + //trigger geometry invalidation if using CPU animation + if (this._pAnimationSet.usesCPU) + for (var key in this._morphedSubGeometryDirty) + this._morphedSubGeometryDirty[key] = true; + }; + SkeletonAnimator.prototype.updateCondensedMatrices = function (condensedIndexLookUp /*uint*/, numJoints /*uint*/) { + var i = 0, j = 0; + var len /*uint*/; + var srcIndex /*uint*/; + this._condensedMatrices = new Array(); + do { + srcIndex = condensedIndexLookUp[i] * 4; + len = srcIndex + 12; + while (srcIndex < len) + this._condensedMatrices[j++] = this._globalMatrices[srcIndex++]; + } while (++i < numJoints); + }; + SkeletonAnimator.prototype.updateGlobalProperties = function () { + this._globalPropertiesDirty = false; + //get global pose + this.localToGlobalPose(this._activeSkeletonState.getSkeletonPose(this._skeleton), this._globalPose, this._skeleton); + // convert pose to matrix + var mtxOffset = 0; + var globalPoses = this._globalPose.jointPoses; + var raw; + var ox, oy, oz, ow; + var xy2, xz2, xw2; + var yz2, yw2, zw2; + var n11, n12, n13; + var n21, n22, n23; + var n31, n32, n33; + var m11, m12, m13, m14; + var m21, m22, m23, m24; + var m31, m32, m33, m34; + var joints = this._skeleton.joints; + var pose; + var quat; + var vec; + var t; + for (var i = 0; i < this._numJoints; ++i) { + pose = globalPoses[i]; + quat = pose.orientation; + vec = pose.translation; + ox = quat.x; + oy = quat.y; + oz = quat.z; + ow = quat.w; + xy2 = (t = 2.0 * ox) * oy; + xz2 = t * oz; + xw2 = t * ow; + yz2 = (t = 2.0 * oy) * oz; + yw2 = t * ow; + zw2 = 2.0 * oz * ow; + yz2 = 2.0 * oy * oz; + yw2 = 2.0 * oy * ow; + zw2 = 2.0 * oz * ow; + ox *= ox; + oy *= oy; + oz *= oz; + ow *= ow; + n11 = (t = ox - oy) - oz + ow; + n12 = xy2 - zw2; + n13 = xz2 + yw2; + n21 = xy2 + zw2; + n22 = -t - oz + ow; + n23 = yz2 - xw2; + n31 = xz2 - yw2; + n32 = yz2 + xw2; + n33 = -ox - oy + oz + ow; + // prepend inverse bind pose + raw = joints[i].inverseBindPose; + m11 = raw[0]; + m12 = raw[4]; + m13 = raw[8]; + m14 = raw[12]; + m21 = raw[1]; + m22 = raw[5]; + m23 = raw[9]; + m24 = raw[13]; + m31 = raw[2]; + m32 = raw[6]; + m33 = raw[10]; + m34 = raw[14]; + this._globalMatrices[mtxOffset] = n11 * m11 + n12 * m21 + n13 * m31; + this._globalMatrices[mtxOffset + 1] = n11 * m12 + n12 * m22 + n13 * m32; + this._globalMatrices[mtxOffset + 2] = n11 * m13 + n12 * m23 + n13 * m33; + this._globalMatrices[mtxOffset + 3] = n11 * m14 + n12 * m24 + n13 * m34 + vec.x; + this._globalMatrices[mtxOffset + 4] = n21 * m11 + n22 * m21 + n23 * m31; + this._globalMatrices[mtxOffset + 5] = n21 * m12 + n22 * m22 + n23 * m32; + this._globalMatrices[mtxOffset + 6] = n21 * m13 + n22 * m23 + n23 * m33; + this._globalMatrices[mtxOffset + 7] = n21 * m14 + n22 * m24 + n23 * m34 + vec.y; + this._globalMatrices[mtxOffset + 8] = n31 * m11 + n32 * m21 + n33 * m31; + this._globalMatrices[mtxOffset + 9] = n31 * m12 + n32 * m22 + n33 * m32; + this._globalMatrices[mtxOffset + 10] = n31 * m13 + n32 * m23 + n33 * m33; + this._globalMatrices[mtxOffset + 11] = n31 * m14 + n32 * m24 + n33 * m34 + vec.z; + mtxOffset = mtxOffset + 12; + } + }; + SkeletonAnimator.prototype.getRenderableSubGeometry = function (renderable, sourceSubGeometry) { + this._morphedSubGeometryDirty[sourceSubGeometry.id] = true; + //early out for GPU animations + if (!this._pAnimationSet.usesCPU) + return sourceSubGeometry; + var targetSubGeometry; + if (!(targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id])) { + //not yet stored + targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id] = sourceSubGeometry.clone(); + //turn off auto calculations on the morphed geometry + targetSubGeometry.autoDeriveNormals = false; + targetSubGeometry.autoDeriveTangents = false; + targetSubGeometry.autoDeriveUVs = false; + //add event listeners for any changes in UV values on the source geometry + sourceSubGeometry.addEventListener(SubGeometryEvent.INDICES_UPDATED, this._onIndicesUpdateDelegate); + sourceSubGeometry.addEventListener(SubGeometryEvent.VERTICES_UPDATED, this._onVerticesUpdateDelegate); + } + return targetSubGeometry; + }; + /** + * If the animation can't be performed on GPU, transform vertices manually + * @param subGeom The subgeometry containing the weights and joint index data per vertex. + * @param pass The material pass for which we need to transform the vertices + */ + SkeletonAnimator.prototype.morphSubGeometry = function (renderable, sourceSubGeometry) { + this._morphedSubGeometryDirty[sourceSubGeometry.id] = false; + var sourcePositions = sourceSubGeometry.positions; + var sourceNormals = sourceSubGeometry.vertexNormals; + var sourceTangents = sourceSubGeometry.vertexTangents; + var jointIndices = sourceSubGeometry.jointIndices; + var jointWeights = sourceSubGeometry.jointWeights; + var targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id]; + var targetPositions = targetSubGeometry.positions; + var targetNormals = targetSubGeometry.vertexNormals; + var targetTangents = targetSubGeometry.vertexTangents; + var index = 0; + var j = 0; + var k /*uint*/; + var vx, vy, vz; + var nx, ny, nz; + var tx, ty, tz; + var len = sourcePositions.length; + var weight; + var vertX, vertY, vertZ; + var normX, normY, normZ; + var tangX, tangY, tangZ; + var m11, m12, m13, m14; + var m21, m22, m23, m24; + var m31, m32, m33, m34; + while (index < len) { + vertX = sourcePositions[index]; + vertY = sourcePositions[index + 1]; + vertZ = sourcePositions[index + 2]; + normX = sourceNormals[index]; + normY = sourceNormals[index + 1]; + normZ = sourceNormals[index + 2]; + tangX = sourceTangents[index]; + tangY = sourceTangents[index + 1]; + tangZ = sourceTangents[index + 2]; + vx = 0; + vy = 0; + vz = 0; + nx = 0; + ny = 0; + nz = 0; + tx = 0; + ty = 0; + tz = 0; + k = 0; + while (k < this._jointsPerVertex) { + weight = jointWeights[j]; + if (weight > 0) { + // implicit /3*12 (/3 because indices are multiplied by 3 for gpu matrix access, *12 because it's the matrix size) + var mtxOffset = jointIndices[j++] << 2; + m11 = this._globalMatrices[mtxOffset]; + m12 = this._globalMatrices[mtxOffset + 1]; + m13 = this._globalMatrices[mtxOffset + 2]; + m14 = this._globalMatrices[mtxOffset + 3]; + m21 = this._globalMatrices[mtxOffset + 4]; + m22 = this._globalMatrices[mtxOffset + 5]; + m23 = this._globalMatrices[mtxOffset + 6]; + m24 = this._globalMatrices[mtxOffset + 7]; + m31 = this._globalMatrices[mtxOffset + 8]; + m32 = this._globalMatrices[mtxOffset + 9]; + m33 = this._globalMatrices[mtxOffset + 10]; + m34 = this._globalMatrices[mtxOffset + 11]; + vx += weight * (m11 * vertX + m12 * vertY + m13 * vertZ + m14); + vy += weight * (m21 * vertX + m22 * vertY + m23 * vertZ + m24); + vz += weight * (m31 * vertX + m32 * vertY + m33 * vertZ + m34); + nx += weight * (m11 * normX + m12 * normY + m13 * normZ); + ny += weight * (m21 * normX + m22 * normY + m23 * normZ); + nz += weight * (m31 * normX + m32 * normY + m33 * normZ); + tx += weight * (m11 * tangX + m12 * tangY + m13 * tangZ); + ty += weight * (m21 * tangX + m22 * tangY + m23 * tangZ); + tz += weight * (m31 * tangX + m32 * tangY + m33 * tangZ); + ++k; + } + else { + j += (this._jointsPerVertex - k); + k = this._jointsPerVertex; + } + } + targetPositions[index] = vx; + targetPositions[index + 1] = vy; + targetPositions[index + 2] = vz; + targetNormals[index] = nx; + targetNormals[index + 1] = ny; + targetNormals[index + 2] = nz; + targetTangents[index] = tx; + targetTangents[index + 1] = ty; + targetTangents[index + 2] = tz; + index += 3; + } + targetSubGeometry.updatePositions(targetPositions); + targetSubGeometry.updateVertexNormals(targetNormals); + targetSubGeometry.updateVertexTangents(targetTangents); + }; + /** + * Converts a local hierarchical skeleton pose to a global pose + * @param targetPose The SkeletonPose object that will contain the global pose. + * @param skeleton The skeleton containing the joints, and as such, the hierarchical data to transform to global poses. + */ + SkeletonAnimator.prototype.localToGlobalPose = function (sourcePose, targetPose, skeleton) { + var globalPoses = targetPose.jointPoses; + var globalJointPose; + var joints = skeleton.joints; + var len = sourcePose.numJointPoses; + var jointPoses = sourcePose.jointPoses; + var parentIndex /*int*/; + var joint; + var parentPose; + var pose; + var or; + var tr; + var t; + var q; + var x1, y1, z1, w1; + var x2, y2, z2, w2; + var x3, y3, z3; + // :s + if (globalPoses.length != len) + globalPoses.length = len; + for (var i = 0; i < len; ++i) { + globalJointPose = globalPoses[i]; + if (globalJointPose == null) + globalJointPose = globalPoses[i] = new JointPose(); + joint = joints[i]; + parentIndex = joint.parentIndex; + pose = jointPoses[i]; + q = globalJointPose.orientation; + t = globalJointPose.translation; + if (parentIndex < 0) { + tr = pose.translation; + or = pose.orientation; + q.x = or.x; + q.y = or.y; + q.z = or.z; + q.w = or.w; + t.x = tr.x; + t.y = tr.y; + t.z = tr.z; + } + else { + // append parent pose + parentPose = globalPoses[parentIndex]; + // rotate point + or = parentPose.orientation; + tr = pose.translation; + x2 = or.x; + y2 = or.y; + z2 = or.z; + w2 = or.w; + x3 = tr.x; + y3 = tr.y; + z3 = tr.z; + w1 = -x2 * x3 - y2 * y3 - z2 * z3; + x1 = w2 * x3 + y2 * z3 - z2 * y3; + y1 = w2 * y3 - x2 * z3 + z2 * x3; + z1 = w2 * z3 + x2 * y3 - y2 * x3; + // append parent translation + tr = parentPose.translation; + t.x = -w1 * x2 + x1 * w2 - y1 * z2 + z1 * y2 + tr.x; + t.y = -w1 * y2 + x1 * z2 + y1 * w2 - z1 * x2 + tr.y; + t.z = -w1 * z2 - x1 * y2 + y1 * x2 + z1 * w2 + tr.z; + // append parent orientation + x1 = or.x; + y1 = or.y; + z1 = or.z; + w1 = or.w; + or = pose.orientation; + x2 = or.x; + y2 = or.y; + z2 = or.z; + w2 = or.w; + q.w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2; + q.x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2; + q.y = w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2; + q.z = w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2; + } + } + }; + SkeletonAnimator.prototype.onTransitionComplete = function (event) { + if (event.type == AnimationStateEvent.TRANSITION_COMPLETE) { + event.animationNode.removeEventListener(AnimationStateEvent.TRANSITION_COMPLETE, this._onTransitionCompleteDelegate); + //if this is the current active state transition, revert control to the active node + if (this._pActiveState == event.animationState) { + this._pActiveNode = this._pAnimationSet.getAnimation(this._pActiveAnimationName); + this._pActiveState = this.getAnimationState(this._pActiveNode); + this._activeSkeletonState = this._pActiveState; + } + } + }; + SkeletonAnimator.prototype.onIndicesUpdate = function (event) { + var subGeometry = event.target; + this._morphedSubGeometry[subGeometry.id].updateIndices(subGeometry.indices); + }; + SkeletonAnimator.prototype.onVerticesUpdate = function (event) { + var subGeometry = event.target; + var morphGeometry = this._morphedSubGeometry[subGeometry.id]; + switch (event.dataType) { + case TriangleSubGeometry.UV_DATA: + morphGeometry.updateUVs(subGeometry.uvs); + case TriangleSubGeometry.SECONDARY_UV_DATA: + morphGeometry.updateUVs(subGeometry.secondaryUVs); + } + }; + return SkeletonAnimator; +})(AnimatorBase); +module.exports = SkeletonAnimator; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/skeletonanimator.ts"],"names":["SkeletonAnimator","SkeletonAnimator.constructor","SkeletonAnimator.globalMatrices","SkeletonAnimator.globalPose","SkeletonAnimator.skeleton","SkeletonAnimator.forceCPU","SkeletonAnimator.useCondensedIndices","SkeletonAnimator.clone","SkeletonAnimator.play","SkeletonAnimator.setRenderState","SkeletonAnimator.testGPUCompatibility","SkeletonAnimator._pUpdateDeltaTime","SkeletonAnimator.updateCondensedMatrices","SkeletonAnimator.updateGlobalProperties","SkeletonAnimator.getRenderableSubGeometry","SkeletonAnimator.morphSubGeometry","SkeletonAnimator.localToGlobalPose","SkeletonAnimator.onTransitionComplete","SkeletonAnimator.onIndicesUpdate","SkeletonAnimator.onVerticesUpdate"],"mappings":";;;;;;AACA,IAAO,mBAAmB,WAAc,+CAA+C,CAAC,CAAC;AAKzF,IAAO,gBAAgB,WAAe,yCAAyC,CAAC,CAAC;AAEjF,IAAO,YAAY,WAAgB,2CAA2C,CAAC,CAAC;AAIhF,IAAO,oBAAoB,WAAc,sDAAsD,CAAC,CAAC;AAKjG,IAAO,SAAS,WAAgB,gDAAgD,CAAC,CAAC;AAGlF,IAAO,YAAY,WAAgB,mDAAmD,CAAC,CAAC;AAGxF,IAAO,mBAAmB,WAAc,kDAAkD,CAAC,CAAC;AAE5F,AAKA;;;;GADG;IACG,gBAAgB;IAASA,UAAzBA,gBAAgBA,UAAqBA;IA+E1CA;;;;;;OAMGA;IACHA,SAtFKA,gBAAgBA,CAsFTA,YAAiCA,EAAEA,QAAiBA,EAAEA,QAAwBA;QAtF3FC,iBAqlBCA;QA/fkEA,wBAAwBA,GAAxBA,gBAAwBA;QAEzFA,kBAAMA,YAAYA,CAACA,CAACA;QArFbA,gBAAWA,GAAgBA,IAAIA,YAAYA,EAAEA,CAACA;QAG9CA,wBAAmBA,GAAUA,IAAIA,MAAMA,EAAEA,CAACA;QAC1CA,6BAAwBA,GAAUA,IAAIA,MAAMA,EAAEA,CAACA;QAmFtDA,IAAIA,CAACA,SAASA,GAAGA,QAAQA,CAACA;QAC1BA,IAAIA,CAACA,SAASA,GAAGA,QAAQA,CAACA;QAC1BA,IAAIA,CAACA,gBAAgBA,GAAGA,YAAYA,CAACA,eAAeA,CAACA;QAErDA,IAAIA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,CAACA;QAC3CA,IAAIA,CAACA,eAAeA,GAAGA,IAAIA,KAAKA,CAASA,IAAIA,CAACA,UAAUA,GAACA,EAAEA,CAACA,CAACA;QAE7DA,IAAIA,CAACA,GAAkBA,CAACA,CAACA;QACzBA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YAC1DA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAC9BA,IAAIA,CAACA,eAAeA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;QAC/BA,CAACA;QAEDA,IAAIA,CAACA,6BAA6BA,GAAGA,UAACA,KAAyBA,IAAKA,OAAAA,KAAIA,CAACA,oBAAoBA,CAACA,KAAKA,CAACA,EAAhCA,CAAgCA,CAACA;QACrGA,IAAIA,CAACA,wBAAwBA,GAAGA,UAACA,KAAsBA,IAAKA,OAAAA,KAAIA,CAACA,eAAeA,CAACA,KAAKA,CAACA,EAA3BA,CAA2BA,CAACA;QACxFA,IAAIA,CAACA,yBAAyBA,GAAGA,UAACA,KAAsBA,IAAKA,OAAAA,KAAIA,CAACA,gBAAgBA,CAACA,KAAKA,CAACA,EAA5BA,CAA4BA,CAACA;IAC3FA,CAACA;IA3FDD,sBAAWA,4CAAcA;QALzBA;;;;WAIGA;aACHA;YAECE,EAAEA,CAACA,CAACA,IAAIA,CAACA,sBAAsBA,CAACA;gBAC/BA,IAAIA,CAACA,sBAAsBA,EAAEA,CAACA;YAE/BA,MAAMA,CAACA,IAAIA,CAACA,eAAeA,CAACA;QAC7BA,CAACA;;;OAAAF;IAODA,sBAAWA,wCAAUA;QALrBA;;;;WAIGA;aACHA;YAECG,EAAEA,CAACA,CAACA,IAAIA,CAACA,sBAAsBA,CAACA;gBAC/BA,IAAIA,CAACA,sBAAsBA,EAAEA,CAACA;YAE/BA,MAAMA,CAACA,IAAIA,CAACA,WAAWA,CAACA;QACzBA,CAACA;;;OAAAH;IAMDA,sBAAWA,sCAAQA;QAJnBA;;;WAGGA;aACHA;YAECI,MAAMA,CAACA,IAAIA,CAACA,SAASA,CAACA;QACvBA,CAACA;;;OAAAJ;IAMDA,sBAAWA,sCAAQA;QAJnBA;;;WAGGA;aACHA;YAECK,MAAMA,CAACA,IAAIA,CAACA,SAASA,CAACA;QACvBA,CAACA;;;OAAAL;IAODA,sBAAWA,iDAAmBA;QAL9BA;;;;WAIGA;aACHA;YAECM,MAAMA,CAACA,IAAIA,CAACA,oBAAoBA,CAACA;QAClCA,CAACA;aAEDN,UAA+BA,KAAaA;YAE3CM,IAAIA,CAACA,oBAAoBA,GAAGA,KAAKA,CAACA;QACnCA,CAACA;;;OALAN;IA8CDA;;OAEGA;IACIA,gCAAKA,GAAZA;QAECO,AAEAA;mFAD2EA;QAC3EA,MAAMA,CAACA,IAAIA,gBAAgBA,CAAwBA,IAAIA,CAACA,cAAcA,EAAEA,IAAIA,CAACA,SAASA,EAAEA,IAAIA,CAACA,SAASA,CAACA,CAACA;IACzGA,CAACA;IAEDP;;;;;;OAMGA;IACIA,+BAAIA,GAAXA,UAAYA,IAAWA,EAAEA,UAAsCA,EAAEA,MAAmBA;QAA3DQ,0BAAsCA,GAAtCA,iBAAsCA;QAAEA,sBAAmBA,GAAnBA,YAAmBA;QAEnFA,EAAEA,CAACA,CAACA,IAAIA,CAACA,qBAAqBA,IAAIA,IAAIA,CAACA;YACtCA,MAAMA,CAACA;QAERA,IAAIA,CAACA,qBAAqBA,GAAGA,IAAIA,CAACA;QAElCA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,YAAYA,CAACA,IAAIA,CAACA,CAACA;YAC3CA,MAAMA,IAAIA,KAAKA,CAACA,sBAAsBA,GAAGA,IAAIA,GAAGA,aAAaA,CAACA,CAACA;QAEhEA,EAAEA,CAACA,CAACA,UAAUA,IAAIA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;YACrCA,AACAA,sBADsBA;YACtBA,IAAIA,CAACA,YAAYA,GAAGA,UAAUA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,IAAIA,CAACA,YAAYA,EAAEA,IAAIA,CAACA,cAAcA,CAACA,YAAYA,CAACA,IAAIA,CAACA,EAAEA,IAAIA,CAACA,cAAcA,CAACA,CAACA;YACtIA,IAAIA,CAACA,YAAYA,CAACA,gBAAgBA,CAACA,mBAAmBA,CAACA,mBAAmBA,EAAEA,IAAIA,CAACA,6BAA6BA,CAACA,CAACA;QACjHA,CAACA;QAACA,IAAIA;YACLA,IAAIA,CAACA,YAAYA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,YAAYA,CAACA,IAAIA,CAACA,CAACA;QAE5DA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,CAACA,iBAAiBA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA;QAE/DA,EAAEA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA;YACzBA,AACAA,+CAD+CA;YAC/CA,IAAIA,CAACA,aAAaA,CAACA,MAAMA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA;YAC/CA,IAAIA,CAACA,aAAaA,CAACA,aAAaA,CAACA;QAClCA,CAACA;QAEDA,IAAIA,CAACA,oBAAoBA,GAA6BA,IAAIA,CAACA,aAAaA,CAACA;QAEzEA,IAAIA,CAACA,KAAKA,EAAEA,CAACA;QAEbA,AACAA,kCADkCA;QAClCA,EAAEA,CAACA,CAACA,CAACA,KAAKA,CAACA,MAAMA,CAACA,CAACA;YAClBA,IAAIA,CAACA,KAAKA,CAACA,IAAIA,EAAEA,MAAMA,CAACA,CAACA;IAC3BA,CAACA;IAEDR;;OAEGA;IACIA,yCAAcA,GAArBA,UAAsBA,YAA6BA,EAAEA,UAAyBA,EAAEA,KAAWA,EAAEA,MAAaA,EAAEA,oBAAoBA,CAAQA,OAADA,AAAQA,EAAEA,kBAAkBA,CAAQA,OAADA,AAAQA;QAEjLS,AACAA,oCADoCA;QACpCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,sBAAsBA,CAACA;YAC/BA,IAAIA,CAACA,sBAAsBA,EAAEA,CAACA;QAE/BA,IAAIA,WAAWA,GAA6FA,UAAWA,CAACA,OAAQA,CAACA,WAAWA,CAACA;QAE7IA,WAAWA,CAACA,mBAAmBA,GAAGA,IAAIA,CAACA,oBAAoBA,CAACA;QAE5DA,EAAEA,CAACA,CAACA,IAAIA,CAACA,oBAAoBA,CAACA,CAACA,CAACA;YAC/BA,AACAA,6BAD6BA;YAC7BA,IAAIA,CAACA,uBAAuBA,CAACA,WAAWA,CAACA,oBAAoBA,EAAEA,WAAWA,CAACA,kBAAkBA,CAACA,CAACA;YAC5EA,KAAKA,CAACA,OAAQA,CAACA,4BAA4BA,CAACA,oBAAoBA,CAACA,MAAMA,EAAEA,oBAAoBA,EAAEA,IAAIA,CAACA,kBAAkBA,EAAEA,WAAWA,CAACA,kBAAkBA,GAACA,CAACA,CAACA,CAACA;QAC9KA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,EAAEA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,OAAOA,CAACA,CAACA,CAACA;gBACjCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,wBAAwBA,CAACA,WAAWA,CAACA,EAAEA,CAACA,CAACA;oBACjDA,IAAIA,CAACA,gBAAgBA,CAA6BA,UAAUA,EAAEA,WAAWA,CAACA,CAACA;gBAE5EA,MAAMA,CAAAA;YACPA,CAACA;YACkBA,KAAKA,CAACA,OAAQA,CAACA,4BAA4BA,CAACA,oBAAoBA,CAACA,MAAMA,EAAEA,oBAAoBA,EAAEA,IAAIA,CAACA,eAAeA,EAAEA,IAAIA,CAACA,UAAUA,GAACA,CAACA,CAACA,CAACA;QAC5JA,CAACA;QAEkBA,KAAKA,CAACA,OAAQA,CAACA,cAAcA,CAACA,kBAAkBA,EAAEA,UAAUA,CAACA,aAAaA,CAACA,mBAAmBA,CAACA,gBAAgBA,CAACA,EAAEA,UAAUA,CAACA,eAAeA,CAACA,mBAAmBA,CAACA,gBAAgBA,CAACA,EAAEA,UAAUA,CAACA,kBAAkBA,CAACA,CAACA;QACnNA,KAAKA,CAACA,OAAQA,CAACA,cAAcA,CAACA,kBAAkBA,GAAGA,CAACA,EAAEA,UAAUA,CAACA,aAAaA,CAACA,mBAAmBA,CAACA,iBAAiBA,CAACA,EAAEA,UAAUA,CAACA,eAAeA,CAACA,mBAAmBA,CAACA,iBAAiBA,CAACA,EAAEA,UAAUA,CAACA,mBAAmBA,CAACA,CAACA;IAC9OA,CAACA;IAEDT;;OAEGA;IACIA,+CAAoBA,GAA3BA,UAA4BA,YAA6BA;QAExDU,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,oBAAoBA,IAAIA,CAACA,IAAIA,CAACA,SAASA,IAAIA,IAAIA,CAACA,gBAAgBA,GAAGA,CAACA,IAAIA,YAAYA,CAACA,sBAAsBA,GAAGA,IAAIA,CAACA,UAAUA,GAACA,CAACA,GAAGA,GAAGA,CAACA,CAACA;YAChJA,IAAIA,CAACA,cAAcA,CAACA,sBAAsBA,EAAEA,CAACA;IAC/CA,CAACA;IAEDV;;OAEGA;IACIA,4CAAiBA,GAAxBA,UAAyBA,EAASA;QAEjCW,gBAAKA,CAACA,iBAAiBA,YAACA,EAAEA,CAACA,CAACA;QAE5BA,AACAA,0BAD0BA;QAC1BA,IAAIA,CAACA,sBAAsBA,GAAGA,IAAIA,CAACA;QAEnCA,AACAA,sDADsDA;QACtDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,OAAOA,CAACA;YAC/BA,GAAGA,CAACA,CAACA,GAAGA,CAACA,GAAGA,IAAIA,IAAIA,CAACA,wBAAwBA,CAACA;gBAC7CA,IAAIA,CAACA,wBAAwBA,CAACA,GAAGA,CAACA,GAAGA,IAAIA,CAACA;IAC7CA,CAACA;IAEOX,kDAAuBA,GAA/BA,UAAgCA,oBAAoBA,CAAeA,QAADA,AAASA,EAAEA,SAASA,CAAQA,QAADA,AAASA;QAErGY,IAAIA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAmBA,CAACA,CAACA;QACjDA,IAAIA,GAAGA,CAAQA,QAADA,AAASA,CAACA;QACxBA,IAAIA,QAAQA,CAAQA,QAADA,AAASA,CAACA;QAE7BA,IAAIA,CAACA,kBAAkBA,GAAGA,IAAIA,KAAKA,EAAUA,CAACA;QAE9CA,GAAGA,CAACA;YACHA,QAAQA,GAAGA,oBAAoBA,CAACA,CAACA,CAACA,GAACA,CAACA,CAACA;YACrCA,GAAGA,GAAGA,QAAQA,GAAGA,EAAEA,CAACA;YAEpBA,OAAOA,QAAQA,GAAGA,GAAGA;gBACpBA,IAAIA,CAACA,kBAAkBA,CAACA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,QAAQA,EAAEA,CAACA,CAACA;QAClEA,CAACA,QAAQA,EAAEA,CAACA,GAAGA,SAASA,EAAEA;IAC3BA,CAACA;IAEOZ,iDAAsBA,GAA9BA;QAECa,IAAIA,CAACA,sBAAsBA,GAAGA,KAAKA,CAACA;QAEpCA,AACAA,iBADiBA;QACjBA,IAAIA,CAACA,iBAAiBA,CAACA,IAAIA,CAACA,oBAAoBA,CAACA,eAAeA,CAACA,IAAIA,CAACA,SAASA,CAACA,EAAEA,IAAIA,CAACA,WAAWA,EAAEA,IAAIA,CAACA,SAASA,CAACA,CAACA;QAEpHA,AACAA,yBADyBA;YACrBA,SAASA,GAAmBA,CAACA,CAACA;QAClCA,IAAIA,WAAWA,GAAoBA,IAAIA,CAACA,WAAWA,CAACA,UAAUA,CAACA;QAC/DA,IAAIA,GAAiBA,CAACA;QACtBA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QAC/CA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACnDA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACnDA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACnDA,IAAIA,MAAMA,GAAwBA,IAAIA,CAACA,SAASA,CAACA,MAAMA,CAACA;QACxDA,IAAIA,IAAcA,CAACA;QACnBA,IAAIA,IAAeA,CAACA;QACpBA,IAAIA,GAAYA,CAACA;QACjBA,IAAIA,CAAQA,CAACA;QAEbA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YAC1DA,IAAIA,GAAGA,WAAWA,CAACA,CAACA,CAACA,CAACA;YACtBA,IAAIA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;YACxBA,GAAGA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;YACvBA,EAAEA,GAAGA,IAAIA,CAACA,CAACA,CAACA;YACZA,EAAEA,GAAGA,IAAIA,CAACA,CAACA,CAACA;YACZA,EAAEA,GAAGA,IAAIA,CAACA,CAACA,CAACA;YACZA,EAAEA,GAAGA,IAAIA,CAACA,CAACA,CAACA;YAEZA,GAAGA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,EAAEA,CAACA,GAACA,EAAEA,CAACA;YACtBA,GAAGA,GAAGA,CAACA,GAACA,EAAEA,CAACA;YACXA,GAAGA,GAAGA,CAACA,GAACA,EAAEA,CAACA;YACXA,GAAGA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,EAAEA,CAACA,GAACA,EAAEA,CAACA;YACtBA,GAAGA,GAAGA,CAACA,GAACA,EAAEA,CAACA;YACXA,GAAGA,GAAGA,GAAGA,GAACA,EAAEA,GAACA,EAAEA,CAACA;YAEhBA,GAAGA,GAAGA,GAAGA,GAACA,EAAEA,GAACA,EAAEA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAACA,EAAEA,GAACA,EAAEA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAACA,EAAEA,GAACA,EAAEA,CAACA;YAChBA,EAAEA,IAAIA,EAAEA,CAACA;YACTA,EAAEA,IAAIA,EAAEA,CAACA;YACTA,EAAEA,IAAIA,EAAEA,CAACA;YACTA,EAAEA,IAAIA,EAAEA,CAACA;YAETA,GAAGA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,GAAGA,EAAEA,CAACA,GAAGA,EAAEA,GAAGA,EAAEA,CAACA;YAC9BA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,GAAGA,EAAEA,CAACA;YACnBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,CAACA,EAAEA,GAAGA,EAAEA,GAAGA,EAAEA,GAAGA,EAAEA,CAACA;YAEzBA,AACAA,4BAD4BA;YAC5BA,GAAGA,GAAGA,MAAMA,CAACA,CAACA,CAACA,CAACA,eAAeA,CAACA;YAChCA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,EAAEA,CAACA,CAACA;YACdA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,EAAEA,CAACA,CAACA;YACdA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACbA,GAAGA,GAAGA,GAAGA,CAACA,EAAEA,CAACA,CAACA;YACdA,GAAGA,GAAGA,GAAGA,CAACA,EAAEA,CAACA,CAACA;YAEdA,IAAIA,CAACA,eAAeA,CAACA,SAASA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAC9DA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAClEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAClEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA;YAC1EA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAClEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAClEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAClEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA;YAC1EA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAClEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YAClEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,EAAEA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YACnEA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,EAAEA,CAACA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,CAACA,CAACA,CAACA;YAE3EA,SAASA,GAAGA,SAASA,GAAGA,EAAEA,CAACA;QAC5BA,CAACA;IACFA,CAACA;IAGMb,mDAAwBA,GAA/BA,UAAgCA,UAAoCA,EAAEA,iBAAqCA;QAE1Gc,IAAIA,CAACA,wBAAwBA,CAACA,iBAAiBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA;QAE3DA,AACAA,8BAD8BA;QAC9BA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,OAAOA,CAACA;YAChCA,MAAMA,CAACA,iBAAiBA,CAACA;QAE1BA,IAAIA,iBAAqCA,CAACA;QAE1CA,EAAEA,CAACA,CAACA,CAACA,CAACA,iBAAiBA,GAAGA,IAAIA,CAACA,mBAAmBA,CAACA,iBAAiBA,CAACA,EAAEA,CAACA,CAACA,CAACA,CAACA,CAACA;YAC3EA,AACAA,gBADgBA;YAChBA,iBAAiBA,GAAGA,IAAIA,CAACA,mBAAmBA,CAACA,iBAAiBA,CAACA,EAAEA,CAACA,GAAGA,iBAAiBA,CAACA,KAAKA,EAAEA,CAACA;YAC/FA,AACAA,oDADoDA;YACpDA,iBAAiBA,CAACA,iBAAiBA,GAAGA,KAAKA,CAACA;YAC5CA,iBAAiBA,CAACA,kBAAkBA,GAAGA,KAAKA,CAACA;YAC7CA,iBAAiBA,CAACA,aAAaA,GAAGA,KAAKA,CAACA;YACxCA,AACAA,yEADyEA;YACzEA,iBAAiBA,CAACA,gBAAgBA,CAACA,gBAAgBA,CAACA,eAAeA,EAAEA,IAAIA,CAACA,wBAAwBA,CAACA,CAACA;YACpGA,iBAAiBA,CAACA,gBAAgBA,CAACA,gBAAgBA,CAACA,gBAAgBA,EAAEA,IAAIA,CAACA,yBAAyBA,CAACA,CAACA;QACvGA,CAACA;QAEDA,MAAMA,CAACA,iBAAiBA,CAACA;IAC1BA,CAACA;IAEDd;;;;OAIGA;IACIA,2CAAgBA,GAAvBA,UAAwBA,UAAoCA,EAAEA,iBAAqCA;QAElGe,IAAIA,CAACA,wBAAwBA,CAACA,iBAAiBA,CAACA,EAAEA,CAACA,GAAGA,KAAKA,CAACA;QAE5DA,IAAIA,eAAeA,GAAiBA,iBAAiBA,CAACA,SAASA,CAACA;QAChEA,IAAIA,aAAaA,GAAiBA,iBAAiBA,CAACA,aAAaA,CAACA;QAClEA,IAAIA,cAAcA,GAAiBA,iBAAiBA,CAACA,cAAcA,CAACA;QAEpEA,IAAIA,YAAYA,GAAiBA,iBAAiBA,CAACA,YAAYA,CAACA;QAChEA,IAAIA,YAAYA,GAAiBA,iBAAiBA,CAACA,YAAYA,CAACA;QAEhEA,IAAIA,iBAAiBA,GAAGA,IAAIA,CAACA,mBAAmBA,CAACA,iBAAiBA,CAACA,EAAEA,CAACA,CAACA;QAEvEA,IAAIA,eAAeA,GAAiBA,iBAAiBA,CAACA,SAASA,CAACA;QAChEA,IAAIA,aAAaA,GAAiBA,iBAAiBA,CAACA,aAAaA,CAACA;QAClEA,IAAIA,cAAcA,GAAiBA,iBAAiBA,CAACA,cAAcA,CAACA;QAEpEA,IAAIA,KAAKA,GAAmBA,CAACA,CAACA;QAC9BA,IAAIA,CAACA,GAAmBA,CAACA,CAACA;QAC1BA,IAAIA,CAACA,CAAQA,QAADA,AAASA,CAACA;QACtBA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,GAAGA,GAAkBA,eAAeA,CAACA,MAAMA,CAACA;QAChDA,IAAIA,MAAaA,CAACA;QAClBA,IAAIA,KAAYA,EAAEA,KAAYA,EAAEA,KAAYA,CAACA;QAC7CA,IAAIA,KAAYA,EAAEA,KAAYA,EAAEA,KAAYA,CAACA;QAC7CA,IAAIA,KAAYA,EAAEA,KAAYA,EAAEA,KAAYA,CAACA;QAC7CA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACnDA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACnDA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QAEnDA,OAAOA,KAAKA,GAAGA,GAAGA,EAAEA,CAACA;YACpBA,KAAKA,GAAGA,eAAeA,CAACA,KAAKA,CAACA,CAACA;YAC/BA,KAAKA,GAAGA,eAAeA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAACA;YACnCA,KAAKA,GAAGA,eAAeA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAACA;YACnCA,KAAKA,GAAGA,aAAaA,CAACA,KAAKA,CAACA,CAACA;YAC7BA,KAAKA,GAAGA,aAAaA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAACA;YACjCA,KAAKA,GAAGA,aAAaA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAACA;YACjCA,KAAKA,GAAGA,cAAcA,CAACA,KAAKA,CAACA,CAACA;YAC9BA,KAAKA,GAAGA,cAAcA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAACA;YAClCA,KAAKA,GAAGA,cAAcA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAACA;YAClCA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,EAAEA,GAAGA,CAACA,CAACA;YACPA,CAACA,GAAGA,CAACA,CAACA;YACNA,OAAOA,CAACA,GAAGA,IAAIA,CAACA,gBAAgBA,EAAEA,CAACA;gBAClCA,MAAMA,GAAGA,YAAYA,CAACA,CAACA,CAACA,CAACA;gBACzBA,EAAEA,CAACA,CAACA,MAAMA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBAChBA,AACAA,kHADkHA;wBAC9GA,SAASA,GAAmBA,YAAYA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,CAACA;oBACvDA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,CAACA,CAACA;oBACtCA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,CAACA,CAACA,CAACA;oBAC1CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,EAAEA,CAACA,CAACA;oBAC3CA,GAAGA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,SAASA,GAAGA,EAAEA,CAACA,CAACA;oBAC3CA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,CAACA,CAACA;oBACvDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,CAACA,CAACA;oBACvDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,CAACA,CAACA;oBACvDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,CAACA,CAACA;oBACjDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,CAACA,CAACA;oBACjDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,CAACA,CAACA;oBACjDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,CAACA,CAACA;oBACjDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,CAACA,CAACA;oBACjDA,EAAEA,IAAIA,MAAMA,GAACA,CAACA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,GAAGA,GAAGA,GAACA,KAAKA,CAACA,CAACA;oBACjDA,EAAEA,CAACA,CAACA;gBACLA,CAACA;gBAACA,IAAIA,CAACA,CAACA;oBACPA,CAACA,IAAIA,CAACA,IAAIA,CAACA,gBAAgBA,GAAGA,CAACA,CAACA,CAACA;oBACjCA,CAACA,GAAGA,IAAIA,CAACA,gBAAgBA,CAACA;gBAC3BA,CAACA;YACFA,CAACA;YAEDA,eAAeA,CAACA,KAAKA,CAACA,GAAGA,EAAEA,CAACA;YAC5BA,eAAeA,CAACA,KAAKA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,CAACA;YAChCA,eAAeA,CAACA,KAAKA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,CAACA;YAChCA,aAAaA,CAACA,KAAKA,CAACA,GAAGA,EAAEA,CAACA;YAC1BA,aAAaA,CAACA,KAAKA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,CAACA;YAC9BA,aAAaA,CAACA,KAAKA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,CAACA;YAC9BA,cAAcA,CAACA,KAAKA,CAACA,GAAGA,EAAEA,CAACA;YAC3BA,cAAcA,CAACA,KAAKA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,CAACA;YAC/BA,cAAcA,CAACA,KAAKA,GAAGA,CAACA,CAACA,GAAGA,EAAEA,CAACA;YAE/BA,KAAKA,IAAIA,CAACA,CAACA;QACZA,CAACA;QAEDA,iBAAiBA,CAACA,eAAeA,CAACA,eAAeA,CAACA,CAACA;QACnDA,iBAAiBA,CAACA,mBAAmBA,CAACA,aAAaA,CAACA,CAACA;QACrDA,iBAAiBA,CAACA,oBAAoBA,CAACA,cAAcA,CAACA,CAACA;IACxDA,CAACA;IAEDf;;;;OAIGA;IACKA,4CAAiBA,GAAzBA,UAA0BA,UAAuBA,EAAEA,UAAuBA,EAAEA,QAAiBA;QAE5FgB,IAAIA,WAAWA,GAAoBA,UAAUA,CAACA,UAAUA,CAACA;QACzDA,IAAIA,eAAyBA,CAACA;QAC9BA,IAAIA,MAAMA,GAAwBA,QAAQA,CAACA,MAAMA,CAACA;QAClDA,IAAIA,GAAGA,GAAmBA,UAAUA,CAACA,aAAaA,CAACA;QACnDA,IAAIA,UAAUA,GAAoBA,UAAUA,CAACA,UAAUA,CAACA;QACxDA,IAAIA,WAAWA,CAAQA,OAADA,AAAQA,CAACA;QAC/BA,IAAIA,KAAmBA,CAACA;QACxBA,IAAIA,UAAoBA,CAACA;QACzBA,IAAIA,IAAcA,CAACA;QACnBA,IAAIA,EAAaA,CAACA;QAClBA,IAAIA,EAAWA,CAACA;QAChBA,IAAIA,CAAUA,CAACA;QACfA,IAAIA,CAAYA,CAACA;QAEjBA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QAC/CA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QAC/CA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QAEpCA,AACAA,KADKA;QACLA,EAAEA,CAACA,CAACA,WAAWA,CAACA,MAAMA,IAAIA,GAAGA,CAACA;YAC7BA,WAAWA,CAACA,MAAMA,GAAGA,GAAGA,CAACA;QAE1BA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YAC9CA,eAAeA,GAAGA,WAAWA,CAACA,CAACA,CAACA,CAACA;YAEjCA,EAAEA,CAACA,CAACA,eAAeA,IAAIA,IAAIA,CAACA;gBAC3BA,eAAeA,GAAGA,WAAWA,CAACA,CAACA,CAACA,GAAGA,IAAIA,SAASA,EAAEA,CAACA;YAEpDA,KAAKA,GAAGA,MAAMA,CAACA,CAACA,CAACA,CAACA;YAClBA,WAAWA,GAAGA,KAAKA,CAACA,WAAWA,CAACA;YAChCA,IAAIA,GAAGA,UAAUA,CAACA,CAACA,CAACA,CAACA;YAErBA,CAACA,GAAGA,eAAeA,CAACA,WAAWA,CAACA;YAChCA,CAACA,GAAGA,eAAeA,CAACA,WAAWA,CAACA;YAEhCA,EAAEA,CAACA,CAACA,WAAWA,GAAGA,CAACA,CAACA,CAACA,CAACA;gBACrBA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;gBACtBA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;gBACtBA,CAACA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACXA,CAACA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACXA,CAACA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACXA,CAACA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACXA,CAACA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACXA,CAACA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACXA,CAACA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;YACZA,CAACA;YAACA,IAAIA,CAACA,CAACA;gBACPA,AACAA,qBADqBA;gBACrBA,UAAUA,GAAGA,WAAWA,CAACA,WAAWA,CAACA,CAACA;gBAEtCA,AACAA,eADeA;gBACfA,EAAEA,GAAGA,UAAUA,CAACA,WAAWA,CAACA;gBAC5BA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;gBACtBA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBAEVA,EAAEA,GAAGA,CAACA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;gBAC5BA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;gBAC3BA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;gBAC3BA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;gBAE3BA,AACAA,4BAD4BA;gBAC5BA,EAAEA,GAAGA,UAAUA,CAACA,WAAWA,CAACA;gBAC5BA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBAC5CA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBAC5CA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBAE5CA,AACAA,4BAD4BA;gBAC5BA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;gBACtBA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACVA,EAAEA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBAEVA,CAACA,CAACA,CAACA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;gBACpCA,CAACA,CAACA,CAACA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;gBACpCA,CAACA,CAACA,CAACA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;gBACpCA,CAACA,CAACA,CAACA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA;YACrCA,CAACA;QACFA,CAACA;IACFA,CAACA;IAEOhB,+CAAoBA,GAA5BA,UAA6BA,KAAyBA;QAErDiB,EAAEA,CAACA,CAACA,KAAKA,CAACA,IAAIA,IAAIA,mBAAmBA,CAACA,mBAAmBA,CAACA,CAACA,CAACA;YAC3DA,KAAKA,CAACA,aAAaA,CAACA,mBAAmBA,CAACA,mBAAmBA,CAACA,mBAAmBA,EAAEA,IAAIA,CAACA,6BAA6BA,CAACA,CAACA;YACrHA,AACAA,mFADmFA;YACnFA,EAAEA,CAACA,CAACA,IAAIA,CAACA,aAAaA,IAAIA,KAAKA,CAACA,cAAcA,CAACA,CAACA,CAACA;gBAChDA,IAAIA,CAACA,YAAYA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,YAAYA,CAACA,IAAIA,CAACA,qBAAqBA,CAACA,CAACA;gBACjFA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,CAACA,iBAAiBA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA;gBAC/DA,IAAIA,CAACA,oBAAoBA,GAA6BA,IAAIA,CAACA,aAAaA,CAACA;YAC1EA,CAACA;QACFA,CAACA;IACFA,CAACA;IAEOjB,0CAAeA,GAAvBA,UAAwBA,KAAsBA;QAE7CkB,IAAIA,WAAWA,GAA6CA,KAAKA,CAACA,MAAMA,CAACA;QAElDA,IAAIA,CAACA,mBAAmBA,CAACA,WAAWA,CAACA,EAAEA,CAAEA,CAACA,aAAaA,CAACA,WAAWA,CAACA,OAAOA,CAACA,CAACA;IACrGA,CAACA;IAEOlB,2CAAgBA,GAAxBA,UAAyBA,KAAsBA;QAE9CmB,IAAIA,WAAWA,GAA6CA,KAAKA,CAACA,MAAMA,CAACA;QACzEA,IAAIA,aAAaA,GAA6CA,IAAIA,CAACA,mBAAmBA,CAACA,WAAWA,CAACA,EAAEA,CAACA,CAACA;QAEvGA,MAAMA,CAAAA,CAACA,KAAKA,CAACA,QAAQA,CAACA,CAACA,CAACA;YACvBA,KAAKA,mBAAmBA,CAACA,OAAOA;gBAC/BA,aAAaA,CAACA,SAASA,CAACA,WAAWA,CAACA,GAAGA,CAACA,CAACA;YAC1CA,KAAKA,mBAAmBA,CAACA,iBAAiBA;gBACzCA,aAAaA,CAACA,SAASA,CAACA,WAAWA,CAACA,YAAYA,CAACA,CAACA;QACpDA,CAACA;IACFA,CAACA;IACFnB,uBAACA;AAADA,CArlBA,AAqlBCA,EArlB8B,YAAY,EAqlB1C;AAED,AAA0B,iBAAjB,gBAAgB,CAAC","file":"animators/SkeletonAnimator.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ISubMesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/ISubMesh\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport TriangleSubMesh\t\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubMesh\");\nimport Quaternion\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Quaternion\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport SubGeometryEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/SubGeometryEvent\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport TriangleSubMeshRenderable\t\t= require(\"awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable\");\nimport ContextGLProgramType\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLProgramType\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\n\nimport SkeletonAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/SkeletonAnimationSet\");\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonJoint\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonJoint\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport ISkeletonAnimationState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ISkeletonAnimationState\");\nimport IAnimationTransition\t\t\t\t= require(\"awayjs-renderergl/lib/animators/transitions/IAnimationTransition\");\nimport AnimationStateEvent\t\t\t\t= require(\"awayjs-renderergl/lib/events/AnimationStateEvent\");\n\n/**\n * Provides an interface for assigning skeleton-based animation data sets to mesh-based entity objects\n * and controlling the various available states of animation through an interative playhead that can be\n * automatically updated or manually triggered.\n */\nclass SkeletonAnimator extends AnimatorBase\n{\n\tprivate _globalMatrices:Array<number>;\n\tprivate _globalPose:SkeletonPose = new SkeletonPose();\n\tprivate _globalPropertiesDirty:boolean;\n\tprivate _numJoints:number /*uint*/;\n\tprivate _morphedSubGeometry:Object = new Object();\n\tprivate _morphedSubGeometryDirty:Object = new Object();\n\tprivate _condensedMatrices:Array<number>;\n\n\tprivate _skeleton:Skeleton;\n\tprivate _forceCPU:boolean;\n\tprivate _useCondensedIndices:boolean;\n\tprivate _jointsPerVertex:number /*uint*/;\n\tprivate _activeSkeletonState:ISkeletonAnimationState;\n\tprivate _onTransitionCompleteDelegate:(event:AnimationStateEvent) => void;\n\n\tprivate _onIndicesUpdateDelegate:(event:SubGeometryEvent) => void;\n\tprivate _onVerticesUpdateDelegate:(event:SubGeometryEvent) => void;\n\n\t/**\n\t * returns the calculated global matrices of the current skeleton pose.\n\t *\n\t * @see #globalPose\n\t */\n\tpublic get globalMatrices():Array<number>\n\t{\n\t\tif (this._globalPropertiesDirty)\n\t\t\tthis.updateGlobalProperties();\n\n\t\treturn this._globalMatrices;\n\t}\n\n\t/**\n\t * returns the current skeleton pose output from the animator.\n\t *\n\t * @see away.animators.data.SkeletonPose\n\t */\n\tpublic get globalPose():SkeletonPose\n\t{\n\t\tif (this._globalPropertiesDirty)\n\t\t\tthis.updateGlobalProperties();\n\n\t\treturn this._globalPose;\n\t}\n\n\t/**\n\t * Returns the skeleton object in use by the animator - this defines the number and heirarchy of joints used by the\n\t * skinned geoemtry to which skeleon animator is applied.\n\t */\n\tpublic get skeleton():Skeleton\n\t{\n\t\treturn this._skeleton;\n\t}\n\n\t/**\n\t * Indicates whether the skeleton animator is disabled by default for GPU rendering, something that allows the animator to perform calculation on the GPU.\n\t * Defaults to false.\n\t */\n\tpublic get forceCPU():boolean\n\t{\n\t\treturn this._forceCPU;\n\t}\n\n\t/**\n\t * Offers the option of enabling GPU accelerated animation on skeletons larger than 32 joints\n\t * by condensing the number of joint index values required per mesh. Only applicable to\n\t * skeleton animations that utilise more than one mesh object. Defaults to false.\n\t */\n\tpublic get useCondensedIndices():boolean\n\t{\n\t\treturn this._useCondensedIndices;\n\t}\n\n\tpublic set useCondensedIndices(value:boolean)\n\t{\n\t\tthis._useCondensedIndices = value;\n\t}\n\n\t/**\n\t * Creates a new <code>SkeletonAnimator</code> object.\n\t *\n\t * @param skeletonAnimationSet The animation data set containing the skeleton animations used by the animator.\n\t * @param skeleton The skeleton object used for calculating the resulting global matrices for transforming skinned mesh data.\n\t * @param forceCPU Optional value that only allows the animator to perform calculation on the CPU. Defaults to false.\n\t */\n\tconstructor(animationSet:SkeletonAnimationSet, skeleton:Skeleton, forceCPU:boolean = false)\n\t{\n\t\tsuper(animationSet);\n\n\t\tthis._skeleton = skeleton;\n\t\tthis._forceCPU = forceCPU;\n\t\tthis._jointsPerVertex = animationSet.jointsPerVertex;\n\n\t\tthis._numJoints = this._skeleton.numJoints;\n\t\tthis._globalMatrices = new Array<number>(this._numJoints*12);\n\n\t\tvar j:number /*int*/ = 0;\n\t\tfor (var i:number /*uint*/ = 0; i < this._numJoints; ++i) {\n\t\t\tthis._globalMatrices[j++] = 1;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 1;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t\tthis._globalMatrices[j++] = 1;\n\t\t\tthis._globalMatrices[j++] = 0;\n\t\t}\n\n\t\tthis._onTransitionCompleteDelegate = (event:AnimationStateEvent) => this.onTransitionComplete(event);\n\t\tthis._onIndicesUpdateDelegate = (event:SubGeometryEvent) => this.onIndicesUpdate(event);\n\t\tthis._onVerticesUpdateDelegate = (event:SubGeometryEvent) => this.onVerticesUpdate(event);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic clone():AnimatorBase\n\t{\n\t\t/* The cast to SkeletonAnimationSet should never fail, as _animationSet can only be set\n\t\t through the constructor, which will only accept a SkeletonAnimationSet. */\n\t\treturn new SkeletonAnimator(<SkeletonAnimationSet> this._pAnimationSet, this._skeleton, this._forceCPU);\n\t}\n\n\t/**\n\t * Plays an animation state registered with the given name in the animation data set.\n\t *\n\t * @param name The data set name of the animation state to be played.\n\t * @param transition An optional transition object that determines how the animator will transition from the currently active animation state.\n\t * @param offset An option offset time (in milliseconds) that resets the state's internal clock to the absolute time of the animator plus the offset value. Required for non-looping animation states.\n\t */\n\tpublic play(name:string, transition:IAnimationTransition = null, offset:number = NaN)\n\t{\n\t\tif (this._pActiveAnimationName == name)\n\t\t\treturn;\n\n\t\tthis._pActiveAnimationName = name;\n\n\t\tif (!this._pAnimationSet.hasAnimation(name))\n\t\t\tthrow new Error(\"Animation root node \" + name + \" not found!\");\n\n\t\tif (transition && this._pActiveNode) {\n\t\t\t//setup the transition\n\t\t\tthis._pActiveNode = transition.getAnimationNode(this, this._pActiveNode, this._pAnimationSet.getAnimation(name), this._pAbsoluteTime);\n\t\t\tthis._pActiveNode.addEventListener(AnimationStateEvent.TRANSITION_COMPLETE, this._onTransitionCompleteDelegate);\n\t\t} else\n\t\t\tthis._pActiveNode = this._pAnimationSet.getAnimation(name);\n\n\t\tthis._pActiveState = this.getAnimationState(this._pActiveNode);\n\n\t\tif (this.updatePosition) {\n\t\t\t//update straight away to reset position deltas\n\t\t\tthis._pActiveState.update(this._pAbsoluteTime);\n\t\t\tthis._pActiveState.positionDelta;\n\t\t}\n\n\t\tthis._activeSkeletonState = <ISkeletonAnimationState> this._pActiveState;\n\n\t\tthis.start();\n\n\t\t//apply a time offset if specified\n\t\tif (!isNaN(offset))\n\t\t\tthis.reset(name, offset);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setRenderState(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, camera:Camera, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/)\n\t{\n\t\t// do on request of globalProperties\n\t\tif (this._globalPropertiesDirty)\n\t\t\tthis.updateGlobalProperties();\n\n\t\tvar subGeometry:TriangleSubGeometry = <TriangleSubGeometry> (<TriangleSubMesh> (<TriangleSubMeshRenderable> renderable).subMesh).subGeometry;\n\n\t\tsubGeometry.useCondensedIndices = this._useCondensedIndices;\n\n\t\tif (this._useCondensedIndices) {\n\t\t\t// using a condensed data set\n\t\t\tthis.updateCondensedMatrices(subGeometry.condensedIndexLookUp, subGeometry.numCondensedJoints);\n\t\t\t(<IContextStageGL> stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._condensedMatrices, subGeometry.numCondensedJoints*3);\n\t\t} else {\n\t\t\tif (this._pAnimationSet.usesCPU) {\n\t\t\t\tif (this._morphedSubGeometryDirty[subGeometry.id])\n\t\t\t\t\tthis.morphSubGeometry(<TriangleSubMeshRenderable> renderable, subGeometry);\n\n\t\t\t\treturn\n\t\t\t}\n\t\t\t(<IContextStageGL> stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._globalMatrices, this._numJoints*3);\n\t\t}\n\n\t\t(<IContextStageGL> stage.context).activateBuffer(vertexStreamOffset, renderable.getVertexData(TriangleSubGeometry.JOINT_INDEX_DATA), renderable.getVertexOffset(TriangleSubGeometry.JOINT_INDEX_DATA), renderable.JOINT_INDEX_FORMAT);\n\t\t(<IContextStageGL> stage.context).activateBuffer(vertexStreamOffset + 1, renderable.getVertexData(TriangleSubGeometry.JOINT_WEIGHT_DATA), renderable.getVertexOffset(TriangleSubGeometry.JOINT_WEIGHT_DATA), renderable.JOINT_WEIGHT_FORMAT);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic testGPUCompatibility(shaderObject:ShaderObjectBase)\n\t{\n\t\tif (!this._useCondensedIndices && (this._forceCPU || this._jointsPerVertex > 4 || shaderObject.numUsedVertexConstants + this._numJoints*3 > 128))\n\t\t\tthis._pAnimationSet.cancelGPUCompatibility();\n\t}\n\n\t/**\n\t * Applies the calculated time delta to the active animation state node or state transition object.\n\t */\n\tpublic _pUpdateDeltaTime(dt:number)\n\t{\n\t\tsuper._pUpdateDeltaTime(dt);\n\n\t\t//invalidate pose matrices\n\t\tthis._globalPropertiesDirty = true;\n\n\t\t//trigger geometry invalidation if using CPU animation\n\t\tif (this._pAnimationSet.usesCPU)\n\t\t\tfor (var key in this._morphedSubGeometryDirty)\n\t\t\t\tthis._morphedSubGeometryDirty[key] = true;\n\t}\n\n\tprivate updateCondensedMatrices(condensedIndexLookUp:Array<number> /*uint*/, numJoints:number /*uint*/)\n\t{\n\t\tvar i:number /*uint*/ = 0, j:number /*uint*/ = 0;\n\t\tvar len:number /*uint*/;\n\t\tvar srcIndex:number /*uint*/;\n\n\t\tthis._condensedMatrices = new Array<number>();\n\n\t\tdo {\n\t\t\tsrcIndex = condensedIndexLookUp[i]*4;\n\t\t\tlen = srcIndex + 12;\n\t\t\t// copy into condensed\n\t\t\twhile (srcIndex < len)\n\t\t\t\tthis._condensedMatrices[j++] = this._globalMatrices[srcIndex++];\n\t\t} while (++i < numJoints);\n\t}\n\n\tprivate updateGlobalProperties()\n\t{\n\t\tthis._globalPropertiesDirty = false;\n\n\t\t//get global pose\n\t\tthis.localToGlobalPose(this._activeSkeletonState.getSkeletonPose(this._skeleton), this._globalPose, this._skeleton);\n\n\t\t// convert pose to matrix\n\t\tvar mtxOffset:number /*uint*/ = 0;\n\t\tvar globalPoses:Array<JointPose> = this._globalPose.jointPoses;\n\t\tvar raw:Array<number>;\n\t\tvar ox:number, oy:number, oz:number, ow:number;\n\t\tvar xy2:number, xz2:number, xw2:number;\n\t\tvar yz2:number, yw2:number, zw2:number;\n\t\tvar n11:number, n12:number, n13:number;\n\t\tvar n21:number, n22:number, n23:number;\n\t\tvar n31:number, n32:number, n33:number;\n\t\tvar m11:number, m12:number, m13:number, m14:number;\n\t\tvar m21:number, m22:number, m23:number, m24:number;\n\t\tvar m31:number, m32:number, m33:number, m34:number;\n\t\tvar joints:Array<SkeletonJoint> = this._skeleton.joints;\n\t\tvar pose:JointPose;\n\t\tvar quat:Quaternion;\n\t\tvar vec:Vector3D;\n\t\tvar t:number;\n\n\t\tfor (var i:number /*uint*/ = 0; i < this._numJoints; ++i) {\n\t\t\tpose = globalPoses[i];\n\t\t\tquat = pose.orientation;\n\t\t\tvec = pose.translation;\n\t\t\tox = quat.x;\n\t\t\toy = quat.y;\n\t\t\toz = quat.z;\n\t\t\tow = quat.w;\n\n\t\t\txy2 = (t = 2.0*ox)*oy;\n\t\t\txz2 = t*oz;\n\t\t\txw2 = t*ow;\n\t\t\tyz2 = (t = 2.0*oy)*oz;\n\t\t\tyw2 = t*ow;\n\t\t\tzw2 = 2.0*oz*ow;\n\n\t\t\tyz2 = 2.0*oy*oz;\n\t\t\tyw2 = 2.0*oy*ow;\n\t\t\tzw2 = 2.0*oz*ow;\n\t\t\tox *= ox;\n\t\t\toy *= oy;\n\t\t\toz *= oz;\n\t\t\tow *= ow;\n\n\t\t\tn11 = (t = ox - oy) - oz + ow;\n\t\t\tn12 = xy2 - zw2;\n\t\t\tn13 = xz2 + yw2;\n\t\t\tn21 = xy2 + zw2;\n\t\t\tn22 = -t - oz + ow;\n\t\t\tn23 = yz2 - xw2;\n\t\t\tn31 = xz2 - yw2;\n\t\t\tn32 = yz2 + xw2;\n\t\t\tn33 = -ox - oy + oz + ow;\n\n\t\t\t// prepend inverse bind pose\n\t\t\traw = joints[i].inverseBindPose;\n\t\t\tm11 = raw[0];\n\t\t\tm12 = raw[4];\n\t\t\tm13 = raw[8];\n\t\t\tm14 = raw[12];\n\t\t\tm21 = raw[1];\n\t\t\tm22 = raw[5];\n\t\t\tm23 = raw[9];\n\t\t\tm24 = raw[13];\n\t\t\tm31 = raw[2];\n\t\t\tm32 = raw[6];\n\t\t\tm33 = raw[10];\n\t\t\tm34 = raw[14];\n\n\t\t\tthis._globalMatrices[mtxOffset] = n11*m11 + n12*m21 + n13*m31;\n\t\t\tthis._globalMatrices[mtxOffset + 1] = n11*m12 + n12*m22 + n13*m32;\n\t\t\tthis._globalMatrices[mtxOffset + 2] = n11*m13 + n12*m23 + n13*m33;\n\t\t\tthis._globalMatrices[mtxOffset + 3] = n11*m14 + n12*m24 + n13*m34 + vec.x;\n\t\t\tthis._globalMatrices[mtxOffset + 4] = n21*m11 + n22*m21 + n23*m31;\n\t\t\tthis._globalMatrices[mtxOffset + 5] = n21*m12 + n22*m22 + n23*m32;\n\t\t\tthis._globalMatrices[mtxOffset + 6] = n21*m13 + n22*m23 + n23*m33;\n\t\t\tthis._globalMatrices[mtxOffset + 7] = n21*m14 + n22*m24 + n23*m34 + vec.y;\n\t\t\tthis._globalMatrices[mtxOffset + 8] = n31*m11 + n32*m21 + n33*m31;\n\t\t\tthis._globalMatrices[mtxOffset + 9] = n31*m12 + n32*m22 + n33*m32;\n\t\t\tthis._globalMatrices[mtxOffset + 10] = n31*m13 + n32*m23 + n33*m33;\n\t\t\tthis._globalMatrices[mtxOffset + 11] = n31*m14 + n32*m24 + n33*m34 + vec.z;\n\n\t\t\tmtxOffset = mtxOffset + 12;\n\t\t}\n\t}\n\n\n\tpublic getRenderableSubGeometry(renderable:TriangleSubMeshRenderable, sourceSubGeometry:TriangleSubGeometry):TriangleSubGeometry\n\t{\n\t\tthis._morphedSubGeometryDirty[sourceSubGeometry.id] = true;\n\n\t\t//early out for GPU animations\n\t\tif (!this._pAnimationSet.usesCPU)\n\t\t\treturn sourceSubGeometry;\n\n\t\tvar targetSubGeometry:TriangleSubGeometry;\n\n\t\tif (!(targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id])) {\n\t\t\t//not yet stored\n\t\t\ttargetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id] = sourceSubGeometry.clone();\n\t\t\t//turn off auto calculations on the morphed geometry\n\t\t\ttargetSubGeometry.autoDeriveNormals = false;\n\t\t\ttargetSubGeometry.autoDeriveTangents = false;\n\t\t\ttargetSubGeometry.autoDeriveUVs = false;\n\t\t\t//add event listeners for any changes in UV values on the source geometry\n\t\t\tsourceSubGeometry.addEventListener(SubGeometryEvent.INDICES_UPDATED, this._onIndicesUpdateDelegate);\n\t\t\tsourceSubGeometry.addEventListener(SubGeometryEvent.VERTICES_UPDATED, this._onVerticesUpdateDelegate);\n\t\t}\n\n\t\treturn targetSubGeometry;\n\t}\n\n\t/**\n\t * If the animation can't be performed on GPU, transform vertices manually\n\t * @param subGeom The subgeometry containing the weights and joint index data per vertex.\n\t * @param pass The material pass for which we need to transform the vertices\n\t */\n\tpublic morphSubGeometry(renderable:TriangleSubMeshRenderable, sourceSubGeometry:TriangleSubGeometry)\n\t{\n\t\tthis._morphedSubGeometryDirty[sourceSubGeometry.id] = false;\n\n\t\tvar sourcePositions:Array<number> = sourceSubGeometry.positions;\n\t\tvar sourceNormals:Array<number> = sourceSubGeometry.vertexNormals;\n\t\tvar sourceTangents:Array<number> = sourceSubGeometry.vertexTangents;\n\n\t\tvar jointIndices:Array<number> = sourceSubGeometry.jointIndices;\n\t\tvar jointWeights:Array<number> = sourceSubGeometry.jointWeights;\n\n\t\tvar targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id];\n\n\t\tvar targetPositions:Array<number> = targetSubGeometry.positions;\n\t\tvar targetNormals:Array<number> = targetSubGeometry.vertexNormals;\n\t\tvar targetTangents:Array<number> = targetSubGeometry.vertexTangents;\n\n\t\tvar index:number /*uint*/ = 0;\n\t\tvar j:number /*uint*/ = 0;\n\t\tvar k:number /*uint*/;\n\t\tvar vx:number, vy:number, vz:number;\n\t\tvar nx:number, ny:number, nz:number;\n\t\tvar tx:number, ty:number, tz:number;\n\t\tvar len:number /*int*/ = sourcePositions.length;\n\t\tvar weight:number;\n\t\tvar vertX:number, vertY:number, vertZ:number;\n\t\tvar normX:number, normY:number, normZ:number;\n\t\tvar tangX:number, tangY:number, tangZ:number;\n\t\tvar m11:number, m12:number, m13:number, m14:number;\n\t\tvar m21:number, m22:number, m23:number, m24:number;\n\t\tvar m31:number, m32:number, m33:number, m34:number;\n\n\t\twhile (index < len) {\n\t\t\tvertX = sourcePositions[index];\n\t\t\tvertY = sourcePositions[index + 1];\n\t\t\tvertZ = sourcePositions[index + 2];\n\t\t\tnormX = sourceNormals[index];\n\t\t\tnormY = sourceNormals[index + 1];\n\t\t\tnormZ = sourceNormals[index + 2];\n\t\t\ttangX = sourceTangents[index];\n\t\t\ttangY = sourceTangents[index + 1];\n\t\t\ttangZ = sourceTangents[index + 2];\n\t\t\tvx = 0;\n\t\t\tvy = 0;\n\t\t\tvz = 0;\n\t\t\tnx = 0;\n\t\t\tny = 0;\n\t\t\tnz = 0;\n\t\t\ttx = 0;\n\t\t\tty = 0;\n\t\t\ttz = 0;\n\t\t\tk = 0;\n\t\t\twhile (k < this._jointsPerVertex) {\n\t\t\t\tweight = jointWeights[j];\n\t\t\t\tif (weight > 0) {\n\t\t\t\t\t// implicit /3*12 (/3 because indices are multiplied by 3 for gpu matrix access, *12 because it's the matrix size)\n\t\t\t\t\tvar mtxOffset:number /*uint*/ = jointIndices[j++] << 2;\n\t\t\t\t\tm11 = this._globalMatrices[mtxOffset];\n\t\t\t\t\tm12 = this._globalMatrices[mtxOffset + 1];\n\t\t\t\t\tm13 = this._globalMatrices[mtxOffset + 2];\n\t\t\t\t\tm14 = this._globalMatrices[mtxOffset + 3];\n\t\t\t\t\tm21 = this._globalMatrices[mtxOffset + 4];\n\t\t\t\t\tm22 = this._globalMatrices[mtxOffset + 5];\n\t\t\t\t\tm23 = this._globalMatrices[mtxOffset + 6];\n\t\t\t\t\tm24 = this._globalMatrices[mtxOffset + 7];\n\t\t\t\t\tm31 = this._globalMatrices[mtxOffset + 8];\n\t\t\t\t\tm32 = this._globalMatrices[mtxOffset + 9];\n\t\t\t\t\tm33 = this._globalMatrices[mtxOffset + 10];\n\t\t\t\t\tm34 = this._globalMatrices[mtxOffset + 11];\n\t\t\t\t\tvx += weight*(m11*vertX + m12*vertY + m13*vertZ + m14);\n\t\t\t\t\tvy += weight*(m21*vertX + m22*vertY + m23*vertZ + m24);\n\t\t\t\t\tvz += weight*(m31*vertX + m32*vertY + m33*vertZ + m34);\n\t\t\t\t\tnx += weight*(m11*normX + m12*normY + m13*normZ);\n\t\t\t\t\tny += weight*(m21*normX + m22*normY + m23*normZ);\n\t\t\t\t\tnz += weight*(m31*normX + m32*normY + m33*normZ);\n\t\t\t\t\ttx += weight*(m11*tangX + m12*tangY + m13*tangZ);\n\t\t\t\t\tty += weight*(m21*tangX + m22*tangY + m23*tangZ);\n\t\t\t\t\ttz += weight*(m31*tangX + m32*tangY + m33*tangZ);\n\t\t\t\t\t++k;\n\t\t\t\t} else {\n\t\t\t\t\tj += (this._jointsPerVertex - k);\n\t\t\t\t\tk = this._jointsPerVertex;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ttargetPositions[index] = vx;\n\t\t\ttargetPositions[index + 1] = vy;\n\t\t\ttargetPositions[index + 2] = vz;\n\t\t\ttargetNormals[index] = nx;\n\t\t\ttargetNormals[index + 1] = ny;\n\t\t\ttargetNormals[index + 2] = nz;\n\t\t\ttargetTangents[index] = tx;\n\t\t\ttargetTangents[index + 1] = ty;\n\t\t\ttargetTangents[index + 2] = tz;\n\n\t\t\tindex += 3;\n\t\t}\n\n\t\ttargetSubGeometry.updatePositions(targetPositions);\n\t\ttargetSubGeometry.updateVertexNormals(targetNormals);\n\t\ttargetSubGeometry.updateVertexTangents(targetTangents);\n\t}\n\n\t/**\n\t * Converts a local hierarchical skeleton pose to a global pose\n\t * @param targetPose The SkeletonPose object that will contain the global pose.\n\t * @param skeleton The skeleton containing the joints, and as such, the hierarchical data to transform to global poses.\n\t */\n\tprivate localToGlobalPose(sourcePose:SkeletonPose, targetPose:SkeletonPose, skeleton:Skeleton)\n\t{\n\t\tvar globalPoses:Array<JointPose> = targetPose.jointPoses;\n\t\tvar globalJointPose:JointPose;\n\t\tvar joints:Array<SkeletonJoint> = skeleton.joints;\n\t\tvar len:number /*uint*/ = sourcePose.numJointPoses;\n\t\tvar jointPoses:Array<JointPose> = sourcePose.jointPoses;\n\t\tvar parentIndex:number /*int*/;\n\t\tvar joint:SkeletonJoint;\n\t\tvar parentPose:JointPose;\n\t\tvar pose:JointPose;\n\t\tvar or:Quaternion;\n\t\tvar tr:Vector3D;\n\t\tvar t:Vector3D;\n\t\tvar q:Quaternion;\n\n\t\tvar x1:number, y1:number, z1:number, w1:number;\n\t\tvar x2:number, y2:number, z2:number, w2:number;\n\t\tvar x3:number, y3:number, z3:number;\n\n\t\t// :s\n\t\tif (globalPoses.length != len)\n\t\t\tglobalPoses.length = len;\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; ++i) {\n\t\t\tglobalJointPose = globalPoses[i];\n\n\t\t\tif (globalJointPose == null)\n\t\t\t\tglobalJointPose = globalPoses[i] = new JointPose();\n\n\t\t\tjoint = joints[i];\n\t\t\tparentIndex = joint.parentIndex;\n\t\t\tpose = jointPoses[i];\n\n\t\t\tq = globalJointPose.orientation;\n\t\t\tt = globalJointPose.translation;\n\n\t\t\tif (parentIndex < 0) {\n\t\t\t\ttr = pose.translation;\n\t\t\t\tor = pose.orientation;\n\t\t\t\tq.x = or.x;\n\t\t\t\tq.y = or.y;\n\t\t\t\tq.z = or.z;\n\t\t\t\tq.w = or.w;\n\t\t\t\tt.x = tr.x;\n\t\t\t\tt.y = tr.y;\n\t\t\t\tt.z = tr.z;\n\t\t\t} else {\n\t\t\t\t// append parent pose\n\t\t\t\tparentPose = globalPoses[parentIndex];\n\n\t\t\t\t// rotate point\n\t\t\t\tor = parentPose.orientation;\n\t\t\t\ttr = pose.translation;\n\t\t\t\tx2 = or.x;\n\t\t\t\ty2 = or.y;\n\t\t\t\tz2 = or.z;\n\t\t\t\tw2 = or.w;\n\t\t\t\tx3 = tr.x;\n\t\t\t\ty3 = tr.y;\n\t\t\t\tz3 = tr.z;\n\n\t\t\t\tw1 = -x2*x3 - y2*y3 - z2*z3;\n\t\t\t\tx1 = w2*x3 + y2*z3 - z2*y3;\n\t\t\t\ty1 = w2*y3 - x2*z3 + z2*x3;\n\t\t\t\tz1 = w2*z3 + x2*y3 - y2*x3;\n\n\t\t\t\t// append parent translation\n\t\t\t\ttr = parentPose.translation;\n\t\t\t\tt.x = -w1*x2 + x1*w2 - y1*z2 + z1*y2 + tr.x;\n\t\t\t\tt.y = -w1*y2 + x1*z2 + y1*w2 - z1*x2 + tr.y;\n\t\t\t\tt.z = -w1*z2 - x1*y2 + y1*x2 + z1*w2 + tr.z;\n\n\t\t\t\t// append parent orientation\n\t\t\t\tx1 = or.x;\n\t\t\t\ty1 = or.y;\n\t\t\t\tz1 = or.z;\n\t\t\t\tw1 = or.w;\n\t\t\t\tor = pose.orientation;\n\t\t\t\tx2 = or.x;\n\t\t\t\ty2 = or.y;\n\t\t\t\tz2 = or.z;\n\t\t\t\tw2 = or.w;\n\n\t\t\t\tq.w = w1*w2 - x1*x2 - y1*y2 - z1*z2;\n\t\t\t\tq.x = w1*x2 + x1*w2 + y1*z2 - z1*y2;\n\t\t\t\tq.y = w1*y2 - x1*z2 + y1*w2 + z1*x2;\n\t\t\t\tq.z = w1*z2 + x1*y2 - y1*x2 + z1*w2;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate onTransitionComplete(event:AnimationStateEvent)\n\t{\n\t\tif (event.type == AnimationStateEvent.TRANSITION_COMPLETE) {\n\t\t\tevent.animationNode.removeEventListener(AnimationStateEvent.TRANSITION_COMPLETE, this._onTransitionCompleteDelegate);\n\t\t\t//if this is the current active state transition, revert control to the active node\n\t\t\tif (this._pActiveState == event.animationState) {\n\t\t\t\tthis._pActiveNode = this._pAnimationSet.getAnimation(this._pActiveAnimationName);\n\t\t\t\tthis._pActiveState = this.getAnimationState(this._pActiveNode);\n\t\t\t\tthis._activeSkeletonState = <ISkeletonAnimationState> this._pActiveState;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate onIndicesUpdate(event:SubGeometryEvent)\n\t{\n\t\tvar subGeometry:TriangleSubGeometry = <TriangleSubGeometry> event.target;\n\n\t\t(<TriangleSubGeometry> this._morphedSubGeometry[subGeometry.id]).updateIndices(subGeometry.indices);\n\t}\n\n\tprivate onVerticesUpdate(event:SubGeometryEvent)\n\t{\n\t\tvar subGeometry:TriangleSubGeometry = <TriangleSubGeometry> event.target;\n\t\tvar morphGeometry:TriangleSubGeometry = <TriangleSubGeometry> this._morphedSubGeometry[subGeometry.id];\n\n\t\tswitch(event.dataType) {\n\t\t\tcase TriangleSubGeometry.UV_DATA:\n\t\t\t\tmorphGeometry.updateUVs(subGeometry.uvs);\n\t\t\tcase TriangleSubGeometry.SECONDARY_UV_DATA:\n\t\t\t\tmorphGeometry.updateUVs(subGeometry.secondaryUVs);\n\t\t}\n\t}\n}\n\nexport = SkeletonAnimator;"]} \ No newline at end of file diff --git a/lib/animators/SkeletonAnimator.ts b/lib/animators/SkeletonAnimator.ts new file mode 100644 index 000000000..00e827b8d --- /dev/null +++ b/lib/animators/SkeletonAnimator.ts @@ -0,0 +1,630 @@ +import ISubMesh = require("awayjs-core/lib/core/base/ISubMesh"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import TriangleSubMesh = require("awayjs-core/lib/core/base/TriangleSubMesh"); +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); +import SubGeometryEvent = require("awayjs-core/lib/events/SubGeometryEvent"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import TriangleSubMeshRenderable = require("awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable"); +import ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); + +import SkeletonAnimationSet = require("awayjs-renderergl/lib/animators/SkeletonAnimationSet"); +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonJoint = require("awayjs-renderergl/lib/animators/data/SkeletonJoint"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import ISkeletonAnimationState = require("awayjs-renderergl/lib/animators/states/ISkeletonAnimationState"); +import IAnimationTransition = require("awayjs-renderergl/lib/animators/transitions/IAnimationTransition"); +import AnimationStateEvent = require("awayjs-renderergl/lib/events/AnimationStateEvent"); + +/** + * Provides an interface for assigning skeleton-based animation data sets to mesh-based entity objects + * and controlling the various available states of animation through an interative playhead that can be + * automatically updated or manually triggered. + */ +class SkeletonAnimator extends AnimatorBase +{ + private _globalMatrices:Array; + private _globalPose:SkeletonPose = new SkeletonPose(); + private _globalPropertiesDirty:boolean; + private _numJoints:number /*uint*/; + private _morphedSubGeometry:Object = new Object(); + private _morphedSubGeometryDirty:Object = new Object(); + private _condensedMatrices:Array; + + private _skeleton:Skeleton; + private _forceCPU:boolean; + private _useCondensedIndices:boolean; + private _jointsPerVertex:number /*uint*/; + private _activeSkeletonState:ISkeletonAnimationState; + private _onTransitionCompleteDelegate:(event:AnimationStateEvent) => void; + + private _onIndicesUpdateDelegate:(event:SubGeometryEvent) => void; + private _onVerticesUpdateDelegate:(event:SubGeometryEvent) => void; + + /** + * returns the calculated global matrices of the current skeleton pose. + * + * @see #globalPose + */ + public get globalMatrices():Array + { + if (this._globalPropertiesDirty) + this.updateGlobalProperties(); + + return this._globalMatrices; + } + + /** + * returns the current skeleton pose output from the animator. + * + * @see away.animators.data.SkeletonPose + */ + public get globalPose():SkeletonPose + { + if (this._globalPropertiesDirty) + this.updateGlobalProperties(); + + return this._globalPose; + } + + /** + * Returns the skeleton object in use by the animator - this defines the number and heirarchy of joints used by the + * skinned geoemtry to which skeleon animator is applied. + */ + public get skeleton():Skeleton + { + return this._skeleton; + } + + /** + * Indicates whether the skeleton animator is disabled by default for GPU rendering, something that allows the animator to perform calculation on the GPU. + * Defaults to false. + */ + public get forceCPU():boolean + { + return this._forceCPU; + } + + /** + * Offers the option of enabling GPU accelerated animation on skeletons larger than 32 joints + * by condensing the number of joint index values required per mesh. Only applicable to + * skeleton animations that utilise more than one mesh object. Defaults to false. + */ + public get useCondensedIndices():boolean + { + return this._useCondensedIndices; + } + + public set useCondensedIndices(value:boolean) + { + this._useCondensedIndices = value; + } + + /** + * Creates a new SkeletonAnimator object. + * + * @param skeletonAnimationSet The animation data set containing the skeleton animations used by the animator. + * @param skeleton The skeleton object used for calculating the resulting global matrices for transforming skinned mesh data. + * @param forceCPU Optional value that only allows the animator to perform calculation on the CPU. Defaults to false. + */ + constructor(animationSet:SkeletonAnimationSet, skeleton:Skeleton, forceCPU:boolean = false) + { + super(animationSet); + + this._skeleton = skeleton; + this._forceCPU = forceCPU; + this._jointsPerVertex = animationSet.jointsPerVertex; + + this._numJoints = this._skeleton.numJoints; + this._globalMatrices = new Array(this._numJoints*12); + + var j:number /*int*/ = 0; + for (var i:number /*uint*/ = 0; i < this._numJoints; ++i) { + this._globalMatrices[j++] = 1; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 1; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 0; + this._globalMatrices[j++] = 1; + this._globalMatrices[j++] = 0; + } + + this._onTransitionCompleteDelegate = (event:AnimationStateEvent) => this.onTransitionComplete(event); + this._onIndicesUpdateDelegate = (event:SubGeometryEvent) => this.onIndicesUpdate(event); + this._onVerticesUpdateDelegate = (event:SubGeometryEvent) => this.onVerticesUpdate(event); + } + + /** + * @inheritDoc + */ + public clone():AnimatorBase + { + /* The cast to SkeletonAnimationSet should never fail, as _animationSet can only be set + through the constructor, which will only accept a SkeletonAnimationSet. */ + return new SkeletonAnimator( this._pAnimationSet, this._skeleton, this._forceCPU); + } + + /** + * Plays an animation state registered with the given name in the animation data set. + * + * @param name The data set name of the animation state to be played. + * @param transition An optional transition object that determines how the animator will transition from the currently active animation state. + * @param offset An option offset time (in milliseconds) that resets the state's internal clock to the absolute time of the animator plus the offset value. Required for non-looping animation states. + */ + public play(name:string, transition:IAnimationTransition = null, offset:number = NaN) + { + if (this._pActiveAnimationName == name) + return; + + this._pActiveAnimationName = name; + + if (!this._pAnimationSet.hasAnimation(name)) + throw new Error("Animation root node " + name + " not found!"); + + if (transition && this._pActiveNode) { + //setup the transition + this._pActiveNode = transition.getAnimationNode(this, this._pActiveNode, this._pAnimationSet.getAnimation(name), this._pAbsoluteTime); + this._pActiveNode.addEventListener(AnimationStateEvent.TRANSITION_COMPLETE, this._onTransitionCompleteDelegate); + } else + this._pActiveNode = this._pAnimationSet.getAnimation(name); + + this._pActiveState = this.getAnimationState(this._pActiveNode); + + if (this.updatePosition) { + //update straight away to reset position deltas + this._pActiveState.update(this._pAbsoluteTime); + this._pActiveState.positionDelta; + } + + this._activeSkeletonState = this._pActiveState; + + this.start(); + + //apply a time offset if specified + if (!isNaN(offset)) + this.reset(name, offset); + } + + /** + * @inheritDoc + */ + public setRenderState(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, camera:Camera, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/) + { + // do on request of globalProperties + if (this._globalPropertiesDirty) + this.updateGlobalProperties(); + + var subGeometry:TriangleSubGeometry = ( ( renderable).subMesh).subGeometry; + + subGeometry.useCondensedIndices = this._useCondensedIndices; + + if (this._useCondensedIndices) { + // using a condensed data set + this.updateCondensedMatrices(subGeometry.condensedIndexLookUp, subGeometry.numCondensedJoints); + ( stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._condensedMatrices, subGeometry.numCondensedJoints*3); + } else { + if (this._pAnimationSet.usesCPU) { + if (this._morphedSubGeometryDirty[subGeometry.id]) + this.morphSubGeometry( renderable, subGeometry); + + return + } + ( stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._globalMatrices, this._numJoints*3); + } + + ( stage.context).activateBuffer(vertexStreamOffset, renderable.getVertexData(TriangleSubGeometry.JOINT_INDEX_DATA), renderable.getVertexOffset(TriangleSubGeometry.JOINT_INDEX_DATA), renderable.JOINT_INDEX_FORMAT); + ( stage.context).activateBuffer(vertexStreamOffset + 1, renderable.getVertexData(TriangleSubGeometry.JOINT_WEIGHT_DATA), renderable.getVertexOffset(TriangleSubGeometry.JOINT_WEIGHT_DATA), renderable.JOINT_WEIGHT_FORMAT); + } + + /** + * @inheritDoc + */ + public testGPUCompatibility(shaderObject:ShaderObjectBase) + { + if (!this._useCondensedIndices && (this._forceCPU || this._jointsPerVertex > 4 || shaderObject.numUsedVertexConstants + this._numJoints*3 > 128)) + this._pAnimationSet.cancelGPUCompatibility(); + } + + /** + * Applies the calculated time delta to the active animation state node or state transition object. + */ + public _pUpdateDeltaTime(dt:number) + { + super._pUpdateDeltaTime(dt); + + //invalidate pose matrices + this._globalPropertiesDirty = true; + + //trigger geometry invalidation if using CPU animation + if (this._pAnimationSet.usesCPU) + for (var key in this._morphedSubGeometryDirty) + this._morphedSubGeometryDirty[key] = true; + } + + private updateCondensedMatrices(condensedIndexLookUp:Array /*uint*/, numJoints:number /*uint*/) + { + var i:number /*uint*/ = 0, j:number /*uint*/ = 0; + var len:number /*uint*/; + var srcIndex:number /*uint*/; + + this._condensedMatrices = new Array(); + + do { + srcIndex = condensedIndexLookUp[i]*4; + len = srcIndex + 12; + // copy into condensed + while (srcIndex < len) + this._condensedMatrices[j++] = this._globalMatrices[srcIndex++]; + } while (++i < numJoints); + } + + private updateGlobalProperties() + { + this._globalPropertiesDirty = false; + + //get global pose + this.localToGlobalPose(this._activeSkeletonState.getSkeletonPose(this._skeleton), this._globalPose, this._skeleton); + + // convert pose to matrix + var mtxOffset:number /*uint*/ = 0; + var globalPoses:Array = this._globalPose.jointPoses; + var raw:Array; + var ox:number, oy:number, oz:number, ow:number; + var xy2:number, xz2:number, xw2:number; + var yz2:number, yw2:number, zw2:number; + var n11:number, n12:number, n13:number; + var n21:number, n22:number, n23:number; + var n31:number, n32:number, n33:number; + var m11:number, m12:number, m13:number, m14:number; + var m21:number, m22:number, m23:number, m24:number; + var m31:number, m32:number, m33:number, m34:number; + var joints:Array = this._skeleton.joints; + var pose:JointPose; + var quat:Quaternion; + var vec:Vector3D; + var t:number; + + for (var i:number /*uint*/ = 0; i < this._numJoints; ++i) { + pose = globalPoses[i]; + quat = pose.orientation; + vec = pose.translation; + ox = quat.x; + oy = quat.y; + oz = quat.z; + ow = quat.w; + + xy2 = (t = 2.0*ox)*oy; + xz2 = t*oz; + xw2 = t*ow; + yz2 = (t = 2.0*oy)*oz; + yw2 = t*ow; + zw2 = 2.0*oz*ow; + + yz2 = 2.0*oy*oz; + yw2 = 2.0*oy*ow; + zw2 = 2.0*oz*ow; + ox *= ox; + oy *= oy; + oz *= oz; + ow *= ow; + + n11 = (t = ox - oy) - oz + ow; + n12 = xy2 - zw2; + n13 = xz2 + yw2; + n21 = xy2 + zw2; + n22 = -t - oz + ow; + n23 = yz2 - xw2; + n31 = xz2 - yw2; + n32 = yz2 + xw2; + n33 = -ox - oy + oz + ow; + + // prepend inverse bind pose + raw = joints[i].inverseBindPose; + m11 = raw[0]; + m12 = raw[4]; + m13 = raw[8]; + m14 = raw[12]; + m21 = raw[1]; + m22 = raw[5]; + m23 = raw[9]; + m24 = raw[13]; + m31 = raw[2]; + m32 = raw[6]; + m33 = raw[10]; + m34 = raw[14]; + + this._globalMatrices[mtxOffset] = n11*m11 + n12*m21 + n13*m31; + this._globalMatrices[mtxOffset + 1] = n11*m12 + n12*m22 + n13*m32; + this._globalMatrices[mtxOffset + 2] = n11*m13 + n12*m23 + n13*m33; + this._globalMatrices[mtxOffset + 3] = n11*m14 + n12*m24 + n13*m34 + vec.x; + this._globalMatrices[mtxOffset + 4] = n21*m11 + n22*m21 + n23*m31; + this._globalMatrices[mtxOffset + 5] = n21*m12 + n22*m22 + n23*m32; + this._globalMatrices[mtxOffset + 6] = n21*m13 + n22*m23 + n23*m33; + this._globalMatrices[mtxOffset + 7] = n21*m14 + n22*m24 + n23*m34 + vec.y; + this._globalMatrices[mtxOffset + 8] = n31*m11 + n32*m21 + n33*m31; + this._globalMatrices[mtxOffset + 9] = n31*m12 + n32*m22 + n33*m32; + this._globalMatrices[mtxOffset + 10] = n31*m13 + n32*m23 + n33*m33; + this._globalMatrices[mtxOffset + 11] = n31*m14 + n32*m24 + n33*m34 + vec.z; + + mtxOffset = mtxOffset + 12; + } + } + + + public getRenderableSubGeometry(renderable:TriangleSubMeshRenderable, sourceSubGeometry:TriangleSubGeometry):TriangleSubGeometry + { + this._morphedSubGeometryDirty[sourceSubGeometry.id] = true; + + //early out for GPU animations + if (!this._pAnimationSet.usesCPU) + return sourceSubGeometry; + + var targetSubGeometry:TriangleSubGeometry; + + if (!(targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id])) { + //not yet stored + targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id] = sourceSubGeometry.clone(); + //turn off auto calculations on the morphed geometry + targetSubGeometry.autoDeriveNormals = false; + targetSubGeometry.autoDeriveTangents = false; + targetSubGeometry.autoDeriveUVs = false; + //add event listeners for any changes in UV values on the source geometry + sourceSubGeometry.addEventListener(SubGeometryEvent.INDICES_UPDATED, this._onIndicesUpdateDelegate); + sourceSubGeometry.addEventListener(SubGeometryEvent.VERTICES_UPDATED, this._onVerticesUpdateDelegate); + } + + return targetSubGeometry; + } + + /** + * If the animation can't be performed on GPU, transform vertices manually + * @param subGeom The subgeometry containing the weights and joint index data per vertex. + * @param pass The material pass for which we need to transform the vertices + */ + public morphSubGeometry(renderable:TriangleSubMeshRenderable, sourceSubGeometry:TriangleSubGeometry) + { + this._morphedSubGeometryDirty[sourceSubGeometry.id] = false; + + var sourcePositions:Array = sourceSubGeometry.positions; + var sourceNormals:Array = sourceSubGeometry.vertexNormals; + var sourceTangents:Array = sourceSubGeometry.vertexTangents; + + var jointIndices:Array = sourceSubGeometry.jointIndices; + var jointWeights:Array = sourceSubGeometry.jointWeights; + + var targetSubGeometry = this._morphedSubGeometry[sourceSubGeometry.id]; + + var targetPositions:Array = targetSubGeometry.positions; + var targetNormals:Array = targetSubGeometry.vertexNormals; + var targetTangents:Array = targetSubGeometry.vertexTangents; + + var index:number /*uint*/ = 0; + var j:number /*uint*/ = 0; + var k:number /*uint*/; + var vx:number, vy:number, vz:number; + var nx:number, ny:number, nz:number; + var tx:number, ty:number, tz:number; + var len:number /*int*/ = sourcePositions.length; + var weight:number; + var vertX:number, vertY:number, vertZ:number; + var normX:number, normY:number, normZ:number; + var tangX:number, tangY:number, tangZ:number; + var m11:number, m12:number, m13:number, m14:number; + var m21:number, m22:number, m23:number, m24:number; + var m31:number, m32:number, m33:number, m34:number; + + while (index < len) { + vertX = sourcePositions[index]; + vertY = sourcePositions[index + 1]; + vertZ = sourcePositions[index + 2]; + normX = sourceNormals[index]; + normY = sourceNormals[index + 1]; + normZ = sourceNormals[index + 2]; + tangX = sourceTangents[index]; + tangY = sourceTangents[index + 1]; + tangZ = sourceTangents[index + 2]; + vx = 0; + vy = 0; + vz = 0; + nx = 0; + ny = 0; + nz = 0; + tx = 0; + ty = 0; + tz = 0; + k = 0; + while (k < this._jointsPerVertex) { + weight = jointWeights[j]; + if (weight > 0) { + // implicit /3*12 (/3 because indices are multiplied by 3 for gpu matrix access, *12 because it's the matrix size) + var mtxOffset:number /*uint*/ = jointIndices[j++] << 2; + m11 = this._globalMatrices[mtxOffset]; + m12 = this._globalMatrices[mtxOffset + 1]; + m13 = this._globalMatrices[mtxOffset + 2]; + m14 = this._globalMatrices[mtxOffset + 3]; + m21 = this._globalMatrices[mtxOffset + 4]; + m22 = this._globalMatrices[mtxOffset + 5]; + m23 = this._globalMatrices[mtxOffset + 6]; + m24 = this._globalMatrices[mtxOffset + 7]; + m31 = this._globalMatrices[mtxOffset + 8]; + m32 = this._globalMatrices[mtxOffset + 9]; + m33 = this._globalMatrices[mtxOffset + 10]; + m34 = this._globalMatrices[mtxOffset + 11]; + vx += weight*(m11*vertX + m12*vertY + m13*vertZ + m14); + vy += weight*(m21*vertX + m22*vertY + m23*vertZ + m24); + vz += weight*(m31*vertX + m32*vertY + m33*vertZ + m34); + nx += weight*(m11*normX + m12*normY + m13*normZ); + ny += weight*(m21*normX + m22*normY + m23*normZ); + nz += weight*(m31*normX + m32*normY + m33*normZ); + tx += weight*(m11*tangX + m12*tangY + m13*tangZ); + ty += weight*(m21*tangX + m22*tangY + m23*tangZ); + tz += weight*(m31*tangX + m32*tangY + m33*tangZ); + ++k; + } else { + j += (this._jointsPerVertex - k); + k = this._jointsPerVertex; + } + } + + targetPositions[index] = vx; + targetPositions[index + 1] = vy; + targetPositions[index + 2] = vz; + targetNormals[index] = nx; + targetNormals[index + 1] = ny; + targetNormals[index + 2] = nz; + targetTangents[index] = tx; + targetTangents[index + 1] = ty; + targetTangents[index + 2] = tz; + + index += 3; + } + + targetSubGeometry.updatePositions(targetPositions); + targetSubGeometry.updateVertexNormals(targetNormals); + targetSubGeometry.updateVertexTangents(targetTangents); + } + + /** + * Converts a local hierarchical skeleton pose to a global pose + * @param targetPose The SkeletonPose object that will contain the global pose. + * @param skeleton The skeleton containing the joints, and as such, the hierarchical data to transform to global poses. + */ + private localToGlobalPose(sourcePose:SkeletonPose, targetPose:SkeletonPose, skeleton:Skeleton) + { + var globalPoses:Array = targetPose.jointPoses; + var globalJointPose:JointPose; + var joints:Array = skeleton.joints; + var len:number /*uint*/ = sourcePose.numJointPoses; + var jointPoses:Array = sourcePose.jointPoses; + var parentIndex:number /*int*/; + var joint:SkeletonJoint; + var parentPose:JointPose; + var pose:JointPose; + var or:Quaternion; + var tr:Vector3D; + var t:Vector3D; + var q:Quaternion; + + var x1:number, y1:number, z1:number, w1:number; + var x2:number, y2:number, z2:number, w2:number; + var x3:number, y3:number, z3:number; + + // :s + if (globalPoses.length != len) + globalPoses.length = len; + + for (var i:number /*uint*/ = 0; i < len; ++i) { + globalJointPose = globalPoses[i]; + + if (globalJointPose == null) + globalJointPose = globalPoses[i] = new JointPose(); + + joint = joints[i]; + parentIndex = joint.parentIndex; + pose = jointPoses[i]; + + q = globalJointPose.orientation; + t = globalJointPose.translation; + + if (parentIndex < 0) { + tr = pose.translation; + or = pose.orientation; + q.x = or.x; + q.y = or.y; + q.z = or.z; + q.w = or.w; + t.x = tr.x; + t.y = tr.y; + t.z = tr.z; + } else { + // append parent pose + parentPose = globalPoses[parentIndex]; + + // rotate point + or = parentPose.orientation; + tr = pose.translation; + x2 = or.x; + y2 = or.y; + z2 = or.z; + w2 = or.w; + x3 = tr.x; + y3 = tr.y; + z3 = tr.z; + + w1 = -x2*x3 - y2*y3 - z2*z3; + x1 = w2*x3 + y2*z3 - z2*y3; + y1 = w2*y3 - x2*z3 + z2*x3; + z1 = w2*z3 + x2*y3 - y2*x3; + + // append parent translation + tr = parentPose.translation; + t.x = -w1*x2 + x1*w2 - y1*z2 + z1*y2 + tr.x; + t.y = -w1*y2 + x1*z2 + y1*w2 - z1*x2 + tr.y; + t.z = -w1*z2 - x1*y2 + y1*x2 + z1*w2 + tr.z; + + // append parent orientation + x1 = or.x; + y1 = or.y; + z1 = or.z; + w1 = or.w; + or = pose.orientation; + x2 = or.x; + y2 = or.y; + z2 = or.z; + w2 = or.w; + + q.w = w1*w2 - x1*x2 - y1*y2 - z1*z2; + q.x = w1*x2 + x1*w2 + y1*z2 - z1*y2; + q.y = w1*y2 - x1*z2 + y1*w2 + z1*x2; + q.z = w1*z2 + x1*y2 - y1*x2 + z1*w2; + } + } + } + + private onTransitionComplete(event:AnimationStateEvent) + { + if (event.type == AnimationStateEvent.TRANSITION_COMPLETE) { + event.animationNode.removeEventListener(AnimationStateEvent.TRANSITION_COMPLETE, this._onTransitionCompleteDelegate); + //if this is the current active state transition, revert control to the active node + if (this._pActiveState == event.animationState) { + this._pActiveNode = this._pAnimationSet.getAnimation(this._pActiveAnimationName); + this._pActiveState = this.getAnimationState(this._pActiveNode); + this._activeSkeletonState = this._pActiveState; + } + } + } + + private onIndicesUpdate(event:SubGeometryEvent) + { + var subGeometry:TriangleSubGeometry = event.target; + + ( this._morphedSubGeometry[subGeometry.id]).updateIndices(subGeometry.indices); + } + + private onVerticesUpdate(event:SubGeometryEvent) + { + var subGeometry:TriangleSubGeometry = event.target; + var morphGeometry:TriangleSubGeometry = this._morphedSubGeometry[subGeometry.id]; + + switch(event.dataType) { + case TriangleSubGeometry.UV_DATA: + morphGeometry.updateUVs(subGeometry.uvs); + case TriangleSubGeometry.SECONDARY_UV_DATA: + morphGeometry.updateUVs(subGeometry.secondaryUVs); + } + } +} + +export = SkeletonAnimator; \ No newline at end of file diff --git a/lib/animators/VertexAnimationSet.js b/lib/animators/VertexAnimationSet.js new file mode 100755 index 000000000..9b4d340c6 --- /dev/null +++ b/lib/animators/VertexAnimationSet.js @@ -0,0 +1,164 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationSetBase = require("awayjs-stagegl/lib/animators/AnimationSetBase"); +var VertexAnimationMode = require("awayjs-renderergl/lib/animators/data/VertexAnimationMode"); +/** + * The animation data set used by vertex-based animators, containing vertex animation state data. + * + * @see VertexAnimator + */ +var VertexAnimationSet = (function (_super) { + __extends(VertexAnimationSet, _super); + /** + * Returns whether or not normal data is used in last set GPU pass of the vertex shader. + */ + // public get useNormals():boolean + // { + // return this._uploadNormals; + // } + /** + * Creates a new VertexAnimationSet object. + * + * @param numPoses The number of poses made available at once to the GPU animation code. + * @param blendMode Optional value for setting the animation mode of the vertex animator object. + * + * @see away3d.animators.data.VertexAnimationMode + */ + function VertexAnimationSet(numPoses, blendMode) { + if (numPoses === void 0) { numPoses = 2; } + if (blendMode === void 0) { blendMode = "absolute"; } + _super.call(this); + this._numPoses = numPoses; + this._blendMode = blendMode; + } + Object.defineProperty(VertexAnimationSet.prototype, "numPoses", { + /** + * Returns the number of poses made available at once to the GPU animation code. + */ + get: function () { + return this._numPoses; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(VertexAnimationSet.prototype, "blendMode", { + /** + * Returns the active blend mode of the vertex animator object. + */ + get: function () { + return this._blendMode; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + VertexAnimationSet.prototype.getAGALVertexCode = function (shaderObject) { + if (this._blendMode == VertexAnimationMode.ABSOLUTE) + return this.getAbsoluteAGALCode(shaderObject); + else + return this.getAdditiveAGALCode(shaderObject); + }; + /** + * @inheritDoc + */ + VertexAnimationSet.prototype.activate = function (shaderObject, stage) { + // var uID:number = pass._iUniqueId; + // this._uploadNormals = this._useNormals[uID]; + // this._uploadTangents = this._useTangents[uID]; + }; + /** + * @inheritDoc + */ + VertexAnimationSet.prototype.deactivate = function (shaderObject, stage) { + // var uID:number = pass._iUniqueId; + // var index:number /*uint*/ = this._streamIndices[uID]; + // var context:IContextStageGL = stage.context; + // context.setVertexBufferAt(index, null); + // if (this._uploadNormals) + // context.setVertexBufferAt(index + 1, null); + // if (this._uploadTangents) + // context.setVertexBufferAt(index + 2, null); + }; + /** + * @inheritDoc + */ + VertexAnimationSet.prototype.getAGALFragmentCode = function (shaderObject, shadedTarget) { + return ""; + }; + /** + * @inheritDoc + */ + VertexAnimationSet.prototype.getAGALUVCode = function (shaderObject) { + return "mov " + shaderObject.uvTarget + "," + shaderObject.uvSource + "\n"; + }; + /** + * @inheritDoc + */ + VertexAnimationSet.prototype.doneAGALCode = function (shaderObject) { + }; + /** + * Generates the vertex AGAL code for absolute blending. + */ + VertexAnimationSet.prototype.getAbsoluteAGALCode = function (shaderObject) { + var code = ""; + var temp1 = this._pFindTempReg(shaderObject.animationTargetRegisters); + var temp2 = this._pFindTempReg(shaderObject.animationTargetRegisters, temp1); + var regs = new Array("x", "y", "z", "w"); + var len = shaderObject.animatableAttributes.length; + var constantReg = "vc" + shaderObject.numUsedVertexConstants; + if (len > 2) + len = 2; + var streamIndex = shaderObject.numUsedStreams; + for (var i = 0; i < len; ++i) { + code += "mul " + temp1 + ", " + shaderObject.animatableAttributes[i] + ", " + constantReg + "." + regs[0] + "\n"; + for (var j = 1; j < this._numPoses; ++j) { + code += "mul " + temp2 + ", va" + streamIndex + ", " + constantReg + "." + regs[j] + "\n"; + if (j < this._numPoses - 1) + code += "add " + temp1 + ", " + temp1 + ", " + temp2 + "\n"; + ++streamIndex; + } + code += "add " + shaderObject.animationTargetRegisters[i] + ", " + temp1 + ", " + temp2 + "\n"; + } + // add code for bitangents if tangents are used + if (shaderObject.tangentDependencies > 0 || shaderObject.outputsNormals) { + code += "dp3 " + temp1 + ".x, " + shaderObject.animatableAttributes[2] + ", " + shaderObject.animationTargetRegisters[1] + "\n" + "mul " + temp1 + ", " + shaderObject.animationTargetRegisters[1] + ", " + temp1 + ".x\n" + "sub " + shaderObject.animationTargetRegisters[2] + ", " + shaderObject.animationTargetRegisters[2] + ", " + temp1 + "\n"; + } + return code; + }; + /** + * Generates the vertex AGAL code for additive blending. + */ + VertexAnimationSet.prototype.getAdditiveAGALCode = function (shaderObject) { + var code = ""; + var len = shaderObject.animatableAttributes.length; + var regs = ["x", "y", "z", "w"]; + var temp1 = this._pFindTempReg(shaderObject.animationTargetRegisters); + var k /*uint*/; + var streamIndex = shaderObject.numUsedStreams; + if (len > 2) + len = 2; + code += "mov " + shaderObject.animationTargetRegisters[0] + ", " + shaderObject.animatableAttributes[0] + "\n"; + if (shaderObject.normalDependencies > 0) + code += "mov " + shaderObject.animationTargetRegisters[1] + ", " + shaderObject.animatableAttributes[1] + "\n"; + for (var i = 0; i < len; ++i) { + for (var j = 0; j < this._numPoses; ++j) { + code += "mul " + temp1 + ", va" + (streamIndex + k) + ", vc" + shaderObject.numUsedVertexConstants + "." + regs[j] + "\n" + "add " + shaderObject.animationTargetRegisters[i] + ", " + shaderObject.animationTargetRegisters[i] + ", " + temp1 + "\n"; + k++; + } + } + if (shaderObject.tangentDependencies > 0 || shaderObject.outputsNormals) { + code += "dp3 " + temp1 + ".x, " + shaderObject.animatableAttributes[2] + ", " + shaderObject.animationTargetRegisters[1] + "\n" + "mul " + temp1 + ", " + shaderObject.animationTargetRegisters[1] + ", " + temp1 + ".x\n" + "sub " + shaderObject.animationTargetRegisters[2] + ", " + shaderObject.animatableAttributes[2] + ", " + temp1 + "\n"; + } + return code; + }; + return VertexAnimationSet; +})(AnimationSetBase); +module.exports = VertexAnimationSet; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/vertexanimationset.ts"],"names":["VertexAnimationSet","VertexAnimationSet.constructor","VertexAnimationSet.numPoses","VertexAnimationSet.blendMode","VertexAnimationSet.getAGALVertexCode","VertexAnimationSet.activate","VertexAnimationSet.deactivate","VertexAnimationSet.getAGALFragmentCode","VertexAnimationSet.getAGALUVCode","VertexAnimationSet.doneAGALCode","VertexAnimationSet.getAbsoluteAGALCode","VertexAnimationSet.getAdditiveAGALCode"],"mappings":";;;;;;AAEA,IAAO,gBAAgB,WAAe,+CAA+C,CAAC,CAAC;AAIvF,IAAO,mBAAmB,WAAc,0DAA0D,CAAC,CAAC;AAEpG,AAKA;;;;GADG;IACG,kBAAkB;IAASA,UAA3BA,kBAAkBA,UAAyBA;IAqBhDA;;OAEGA;IACJA,mCAAmCA;IACnCA,KAAKA;IACLA,gCAAgCA;IAChCA,KAAKA;IAEJA;;;;;;;OAOGA;IACHA,SArCKA,kBAAkBA,CAqCXA,QAA4BA,EAAEA,SAA6BA;QAA3DC,wBAA4BA,GAA5BA,YAA4BA;QAAEA,yBAA6BA,GAA7BA,sBAA6BA;QAEtEA,iBAAOA,CAACA;QACRA,IAAIA,CAACA,SAASA,GAAGA,QAAQA,CAACA;QAC1BA,IAAIA,CAACA,UAAUA,GAAGA,SAASA,CAACA;IAE7BA,CAACA;IAnCDD,sBAAWA,wCAAQA;QAHnBA;;WAEGA;aACHA;YAECE,MAAMA,CAACA,IAAIA,CAACA,SAASA,CAACA;QACvBA,CAACA;;;OAAAF;IAKDA,sBAAWA,yCAASA;QAHpBA;;WAEGA;aACHA;YAECG,MAAMA,CAACA,IAAIA,CAACA,UAAUA,CAACA;QACxBA,CAACA;;;OAAAH;IA0BDA;;OAEGA;IACIA,8CAAiBA,GAAxBA,UAAyBA,YAA6BA;QAErDI,EAAEA,CAACA,CAACA,IAAIA,CAACA,UAAUA,IAAIA,mBAAmBA,CAACA,QAAQA,CAACA;YACnDA,MAAMA,CAACA,IAAIA,CAACA,mBAAmBA,CAACA,YAAYA,CAACA,CAACA;QAC/CA,IAAIA;YACHA,MAAMA,CAACA,IAAIA,CAACA,mBAAmBA,CAACA,YAAYA,CAACA,CAACA;IAChDA,CAACA;IAEDJ;;OAEGA;IACIA,qCAAQA,GAAfA,UAAgBA,YAA6BA,EAAEA,KAAWA;QAE3DK,sCAAsCA;QACtCA,2DAA2DA;QAC3DA,6DAA6DA;IAC5DA,CAACA;IAEDL;;OAEGA;IACIA,uCAAUA,GAAjBA,UAAkBA,YAA6BA,EAAEA,KAAWA;QAE7DM,sCAAsCA;QACtCA,0DAA0DA;QAC1DA,mEAAmEA;QACnEA,4CAA4CA;QAC5CA,6BAA6BA;QAC7BA,iDAAiDA;QACjDA,8BAA8BA;QAC9BA,iDAAiDA;IAChDA,CAACA;IAEDN;;OAEGA;IACIA,gDAAmBA,GAA1BA,UAA2BA,YAA6BA,EAAEA,YAAmBA;QAE5EO,MAAMA,CAACA,EAAEA,CAACA;IACXA,CAACA;IAEDP;;OAEGA;IACIA,0CAAaA,GAApBA,UAAqBA,YAA6BA;QAEjDQ,MAAMA,CAACA,MAAMA,GAAGA,YAAYA,CAACA,QAAQA,GAAGA,GAAGA,GAAGA,YAAYA,CAACA,QAAQA,GAAGA,IAAIA,CAACA;IAC5EA,CAACA;IAEDR;;OAEGA;IACIA,yCAAYA,GAAnBA,UAAoBA,YAA6BA;IAGjDS,CAACA;IAEDT;;OAEGA;IACKA,gDAAmBA,GAA3BA,UAA4BA,YAA6BA;QAExDU,IAAIA,IAAIA,GAAUA,EAAEA,CAACA;QACrBA,IAAIA,KAAKA,GAAUA,IAAIA,CAACA,aAAaA,CAACA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA;QAC7EA,IAAIA,KAAKA,GAAUA,IAAIA,CAACA,aAAaA,CAACA,YAAYA,CAACA,wBAAwBA,EAAEA,KAAKA,CAACA,CAACA;QACpFA,IAAIA,IAAIA,GAAiBA,IAAIA,KAAKA,CAASA,GAAGA,EAAEA,GAAGA,EAAEA,GAAGA,EAAEA,GAAGA,CAACA,CAACA;QAC/DA,IAAIA,GAAGA,GAAmBA,YAAYA,CAACA,oBAAoBA,CAACA,MAAMA,CAACA;QACnEA,IAAIA,WAAWA,GAAUA,IAAIA,GAAGA,YAAYA,CAACA,sBAAsBA,CAACA;QAEpEA,EAAEA,CAACA,CAACA,GAAGA,GAAGA,CAACA,CAACA;YACXA,GAAGA,GAAGA,CAACA,CAACA;QACTA,IAAIA,WAAWA,GAAmBA,YAAYA,CAACA,cAAcA,CAACA;QAE9DA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YAC9CA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,oBAAoBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,WAAWA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA;YAEjHA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,SAASA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;gBACzDA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,MAAMA,GAAGA,WAAWA,GAAGA,IAAIA,GAAGA,WAAWA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA;gBAE1FA,EAAEA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,SAASA,GAAGA,CAACA,CAACA;oBAC1BA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,IAAIA,CAACA;gBAE7DA,EAAEA,WAAWA,CAACA;YACfA,CAACA;YAEDA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,IAAIA,CAACA;QAChGA,CAACA;QAEDA,AACAA,+CAD+CA;QAC/CA,EAAEA,CAACA,CAACA,YAAYA,CAACA,mBAAmBA,GAAGA,CAACA,IAAIA,YAAYA,CAACA,cAAcA,CAACA,CAACA,CAACA;YACzEA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,MAAMA,GAAGA,YAAYA,CAACA,oBAAoBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAC9HA,MAAMA,GAAGA,KAAKA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,MAAMA,GACxFA,MAAMA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,IAAIA,CAACA;QAC5HA,CAACA;QACDA,MAAMA,CAACA,IAAIA,CAACA;IACbA,CAACA;IAEDV;;OAEGA;IACKA,gDAAmBA,GAA3BA,UAA4BA,YAA6BA;QAExDW,IAAIA,IAAIA,GAAUA,EAAEA,CAACA;QACrBA,IAAIA,GAAGA,GAAmBA,YAAYA,CAACA,oBAAoBA,CAACA,MAAMA,CAACA;QACnEA,IAAIA,IAAIA,GAAiBA,CAACA,GAAGA,EAAEA,GAAGA,EAAEA,GAAGA,EAAEA,GAAGA,CAACA,CAACA;QAC9CA,IAAIA,KAAKA,GAAUA,IAAIA,CAACA,aAAaA,CAACA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA;QAC7EA,IAAIA,CAACA,CAAQA,QAADA,AAASA,CAACA;QAEtBA,IAAIA,WAAWA,GAAmBA,YAAYA,CAACA,cAAcA,CAACA;QAE9DA,EAAEA,CAACA,CAACA,GAAGA,GAAGA,CAACA,CAACA;YACXA,GAAGA,GAAGA,CAACA,CAACA;QAETA,IAAIA,IAAIA,OAAOA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,oBAAoBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA;QAChHA,EAAEA,CAACA,CAACA,YAAYA,CAACA,kBAAkBA,GAAGA,CAACA,CAACA;YACvCA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,oBAAoBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA;QAEhHA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YAC9CA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,SAASA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;gBACzDA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,MAAMA,GAAGA,CAACA,WAAWA,GAAGA,CAACA,CAACA,GAAGA,MAAMA,GAAGA,YAAYA,CAACA,sBAAsBA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GACxHA,MAAMA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,IAAIA,CAACA;gBAC3HA,CAACA,EAAEA,CAACA;YACLA,CAACA;QACFA,CAACA;QAEDA,EAAEA,CAACA,CAACA,YAAYA,CAACA,mBAAmBA,GAAGA,CAACA,IAAIA,YAAYA,CAACA,cAAcA,CAACA,CAACA,CAACA;YACzEA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,MAAMA,GAAGA,YAAYA,CAACA,oBAAoBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAC9HA,MAAMA,GAAGA,KAAKA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,MAAMA,GACxFA,MAAMA,GAAGA,YAAYA,CAACA,wBAAwBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,YAAYA,CAACA,oBAAoBA,CAACA,CAACA,CAACA,GAAGA,IAAIA,GAAGA,KAAKA,GAAGA,IAAIA,CAACA;QACxHA,CAACA;QAEDA,MAAMA,CAACA,IAAIA,CAACA;IACbA,CAACA;IACFX,yBAACA;AAADA,CArLA,AAqLCA,EArLgC,gBAAgB,EAqLhD;AAED,AAA4B,iBAAnB,kBAAkB,CAAC","file":"animators/VertexAnimationSet.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import IAnimationSet\t\t\t\t\t= require(\"awayjs-core/lib/animators/IAnimationSet\");\n\nimport AnimationSetBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimationSetBase\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\n\nimport VertexAnimationMode\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/VertexAnimationMode\");\n\n/**\n * The animation data set used by vertex-based animators, containing vertex animation state data.\n *\n * @see VertexAnimator\n */\nclass VertexAnimationSet extends AnimationSetBase implements IAnimationSet\n{\n\tprivate _numPoses:number /*uint*/;\n\tprivate _blendMode:string;\n\n\t/**\n\t * Returns the number of poses made available at once to the GPU animation code.\n\t */\n\tpublic get numPoses():number /*uint*/\n\t{\n\t\treturn this._numPoses;\n\t}\n\n\t/**\n\t * Returns the active blend mode of the vertex animator object.\n\t */\n\tpublic get blendMode():string\n\t{\n\t\treturn this._blendMode;\n\t}\n\n\t/**\n\t * Returns whether or not normal data is used in last set GPU pass of the vertex shader.\n\t */\n//\t\tpublic get useNormals():boolean\n//\t\t{\n//\t\t\treturn this._uploadNormals;\n//\t\t}\n\n\t/**\n\t * Creates a new <code>VertexAnimationSet</code> object.\n\t *\n\t * @param numPoses The number of poses made available at once to the GPU animation code.\n\t * @param blendMode Optional value for setting the animation mode of the vertex animator object.\n\t *\n\t * @see away3d.animators.data.VertexAnimationMode\n\t */\n\tconstructor(numPoses:number /*uint*/ = 2, blendMode:string = \"absolute\")\n\t{\n\t\tsuper();\n\t\tthis._numPoses = numPoses;\n\t\tthis._blendMode = blendMode;\n\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\tif (this._blendMode == VertexAnimationMode.ABSOLUTE)\n\t\t\treturn this.getAbsoluteAGALCode(shaderObject);\n\t\telse\n\t\t\treturn this.getAdditiveAGALCode(shaderObject);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic activate(shaderObject:ShaderObjectBase, stage:Stage)\n\t{\n//\t\t\tvar uID:number = pass._iUniqueId;\n//\t\t\tthis._uploadNormals = <boolean> this._useNormals[uID];\n//\t\t\tthis._uploadTangents = <boolean> this._useTangents[uID];\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic deactivate(shaderObject:ShaderObjectBase, stage:Stage)\n\t{\n//\t\t\tvar uID:number = pass._iUniqueId;\n//\t\t\tvar index:number /*uint*/ = this._streamIndices[uID];\n//\t\t\tvar context:IContextStageGL = <IContextStageGL> stage.context;\n//\t\t\tcontext.setVertexBufferAt(index, null);\n//\t\t\tif (this._uploadNormals)\n//\t\t\t\tcontext.setVertexBufferAt(index + 1, null);\n//\t\t\tif (this._uploadTangents)\n//\t\t\t\tcontext.setVertexBufferAt(index + 2, null);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALFragmentCode(shaderObject:ShaderObjectBase, shadedTarget:string):string\n\t{\n\t\treturn \"\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALUVCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\treturn \"mov \" + shaderObject.uvTarget + \",\" + shaderObject.uvSource + \"\\n\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic doneAGALCode(shaderObject:ShaderObjectBase)\n\t{\n\n\t}\n\n\t/**\n\t * Generates the vertex AGAL code for absolute blending.\n\t */\n\tprivate getAbsoluteAGALCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar temp1:string = this._pFindTempReg(shaderObject.animationTargetRegisters);\n\t\tvar temp2:string = this._pFindTempReg(shaderObject.animationTargetRegisters, temp1);\n\t\tvar regs:Array<string> = new Array<string>(\"x\", \"y\", \"z\", \"w\");\n\t\tvar len:number /*uint*/ = shaderObject.animatableAttributes.length;\n\t\tvar constantReg:string = \"vc\" + shaderObject.numUsedVertexConstants;\n\n\t\tif (len > 2)\n\t\t\tlen = 2;\n\t\tvar streamIndex:number /*uint*/ = shaderObject.numUsedStreams;\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; ++i) {\n\t\t\tcode += \"mul \" + temp1 + \", \" + shaderObject.animatableAttributes[i] + \", \" + constantReg + \".\" + regs[0] + \"\\n\";\n\n\t\t\tfor (var j:number /*uint*/ = 1; j < this._numPoses; ++j) {\n\t\t\t\tcode += \"mul \" + temp2 + \", va\" + streamIndex + \", \" + constantReg + \".\" + regs[j] + \"\\n\";\n\n\t\t\t\tif (j < this._numPoses - 1)\n\t\t\t\t\tcode += \"add \" + temp1 + \", \" + temp1 + \", \" + temp2 + \"\\n\";\n\n\t\t\t\t++streamIndex;\n\t\t\t}\n\n\t\t\tcode += \"add \" + shaderObject.animationTargetRegisters[i] + \", \" + temp1 + \", \" + temp2 + \"\\n\";\n\t\t}\n\n\t\t// add code for bitangents if tangents are used\n\t\tif (shaderObject.tangentDependencies > 0 || shaderObject.outputsNormals) {\n\t\t\tcode += \"dp3 \" + temp1 + \".x, \" + shaderObject.animatableAttributes[2] + \", \" + shaderObject.animationTargetRegisters[1] + \"\\n\" +\n\t\t\t\t\"mul \" + temp1 + \", \" + shaderObject.animationTargetRegisters[1] + \", \" + temp1 + \".x\\n\" +\n\t\t\t\t\"sub \" + shaderObject.animationTargetRegisters[2] + \", \" + shaderObject.animationTargetRegisters[2] + \", \" + temp1 + \"\\n\";\n\t\t}\n\t\treturn code;\n\t}\n\n\t/**\n\t * Generates the vertex AGAL code for additive blending.\n\t */\n\tprivate getAdditiveAGALCode(shaderObject:ShaderObjectBase):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar len:number /*uint*/ = shaderObject.animatableAttributes.length;\n\t\tvar regs:Array<string> = [\"x\", \"y\", \"z\", \"w\"];\n\t\tvar temp1:string = this._pFindTempReg(shaderObject.animationTargetRegisters);\n\t\tvar k:number /*uint*/;\n\n\t\tvar streamIndex:number /*uint*/ = shaderObject.numUsedStreams;\n\n\t\tif (len > 2)\n\t\t\tlen = 2;\n\n\t\tcode += \"mov  \" + shaderObject.animationTargetRegisters[0] + \", \" + shaderObject.animatableAttributes[0] + \"\\n\";\n\t\tif (shaderObject.normalDependencies > 0)\n\t\t\tcode += \"mov \" + shaderObject.animationTargetRegisters[1] + \", \" + shaderObject.animatableAttributes[1] + \"\\n\";\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; ++i) {\n\t\t\tfor (var j:number /*uint*/ = 0; j < this._numPoses; ++j) {\n\t\t\t\tcode += \"mul \" + temp1 + \", va\" + (streamIndex + k) + \", vc\" + shaderObject.numUsedVertexConstants + \".\" + regs[j] + \"\\n\" +\n\t\t\t\t\t\"add \" + shaderObject.animationTargetRegisters[i] + \", \" + shaderObject.animationTargetRegisters[i] + \", \" + temp1 + \"\\n\";\n\t\t\t\tk++;\n\t\t\t}\n\t\t}\n\n\t\tif (shaderObject.tangentDependencies > 0 || shaderObject.outputsNormals) {\n\t\t\tcode += \"dp3 \" + temp1 + \".x, \" + shaderObject.animatableAttributes[2] + \", \" + shaderObject.animationTargetRegisters[1] + \"\\n\" +\n\t\t\t\t\"mul \" + temp1 + \", \" + shaderObject.animationTargetRegisters[1] + \", \" + temp1 + \".x\\n\" +\n\t\t\t\t\"sub \" + shaderObject.animationTargetRegisters[2] + \", \" + shaderObject.animatableAttributes[2] + \", \" + temp1 + \"\\n\";\n\t\t}\n\n\t\treturn code;\n\t}\n}\n\nexport = VertexAnimationSet;"]} \ No newline at end of file diff --git a/lib/animators/VertexAnimationSet.ts b/lib/animators/VertexAnimationSet.ts new file mode 100644 index 000000000..ed8d8385c --- /dev/null +++ b/lib/animators/VertexAnimationSet.ts @@ -0,0 +1,197 @@ +import IAnimationSet = require("awayjs-core/lib/animators/IAnimationSet"); + +import AnimationSetBase = require("awayjs-stagegl/lib/animators/AnimationSetBase"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); + +import VertexAnimationMode = require("awayjs-renderergl/lib/animators/data/VertexAnimationMode"); + +/** + * The animation data set used by vertex-based animators, containing vertex animation state data. + * + * @see VertexAnimator + */ +class VertexAnimationSet extends AnimationSetBase implements IAnimationSet +{ + private _numPoses:number /*uint*/; + private _blendMode:string; + + /** + * Returns the number of poses made available at once to the GPU animation code. + */ + public get numPoses():number /*uint*/ + { + return this._numPoses; + } + + /** + * Returns the active blend mode of the vertex animator object. + */ + public get blendMode():string + { + return this._blendMode; + } + + /** + * Returns whether or not normal data is used in last set GPU pass of the vertex shader. + */ +// public get useNormals():boolean +// { +// return this._uploadNormals; +// } + + /** + * Creates a new VertexAnimationSet object. + * + * @param numPoses The number of poses made available at once to the GPU animation code. + * @param blendMode Optional value for setting the animation mode of the vertex animator object. + * + * @see away3d.animators.data.VertexAnimationMode + */ + constructor(numPoses:number /*uint*/ = 2, blendMode:string = "absolute") + { + super(); + this._numPoses = numPoses; + this._blendMode = blendMode; + + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase):string + { + if (this._blendMode == VertexAnimationMode.ABSOLUTE) + return this.getAbsoluteAGALCode(shaderObject); + else + return this.getAdditiveAGALCode(shaderObject); + } + + /** + * @inheritDoc + */ + public activate(shaderObject:ShaderObjectBase, stage:Stage) + { +// var uID:number = pass._iUniqueId; +// this._uploadNormals = this._useNormals[uID]; +// this._uploadTangents = this._useTangents[uID]; + } + + /** + * @inheritDoc + */ + public deactivate(shaderObject:ShaderObjectBase, stage:Stage) + { +// var uID:number = pass._iUniqueId; +// var index:number /*uint*/ = this._streamIndices[uID]; +// var context:IContextStageGL = stage.context; +// context.setVertexBufferAt(index, null); +// if (this._uploadNormals) +// context.setVertexBufferAt(index + 1, null); +// if (this._uploadTangents) +// context.setVertexBufferAt(index + 2, null); + } + + /** + * @inheritDoc + */ + public getAGALFragmentCode(shaderObject:ShaderObjectBase, shadedTarget:string):string + { + return ""; + } + + /** + * @inheritDoc + */ + public getAGALUVCode(shaderObject:ShaderObjectBase):string + { + return "mov " + shaderObject.uvTarget + "," + shaderObject.uvSource + "\n"; + } + + /** + * @inheritDoc + */ + public doneAGALCode(shaderObject:ShaderObjectBase) + { + + } + + /** + * Generates the vertex AGAL code for absolute blending. + */ + private getAbsoluteAGALCode(shaderObject:ShaderObjectBase):string + { + var code:string = ""; + var temp1:string = this._pFindTempReg(shaderObject.animationTargetRegisters); + var temp2:string = this._pFindTempReg(shaderObject.animationTargetRegisters, temp1); + var regs:Array = new Array("x", "y", "z", "w"); + var len:number /*uint*/ = shaderObject.animatableAttributes.length; + var constantReg:string = "vc" + shaderObject.numUsedVertexConstants; + + if (len > 2) + len = 2; + var streamIndex:number /*uint*/ = shaderObject.numUsedStreams; + + for (var i:number /*uint*/ = 0; i < len; ++i) { + code += "mul " + temp1 + ", " + shaderObject.animatableAttributes[i] + ", " + constantReg + "." + regs[0] + "\n"; + + for (var j:number /*uint*/ = 1; j < this._numPoses; ++j) { + code += "mul " + temp2 + ", va" + streamIndex + ", " + constantReg + "." + regs[j] + "\n"; + + if (j < this._numPoses - 1) + code += "add " + temp1 + ", " + temp1 + ", " + temp2 + "\n"; + + ++streamIndex; + } + + code += "add " + shaderObject.animationTargetRegisters[i] + ", " + temp1 + ", " + temp2 + "\n"; + } + + // add code for bitangents if tangents are used + if (shaderObject.tangentDependencies > 0 || shaderObject.outputsNormals) { + code += "dp3 " + temp1 + ".x, " + shaderObject.animatableAttributes[2] + ", " + shaderObject.animationTargetRegisters[1] + "\n" + + "mul " + temp1 + ", " + shaderObject.animationTargetRegisters[1] + ", " + temp1 + ".x\n" + + "sub " + shaderObject.animationTargetRegisters[2] + ", " + shaderObject.animationTargetRegisters[2] + ", " + temp1 + "\n"; + } + return code; + } + + /** + * Generates the vertex AGAL code for additive blending. + */ + private getAdditiveAGALCode(shaderObject:ShaderObjectBase):string + { + var code:string = ""; + var len:number /*uint*/ = shaderObject.animatableAttributes.length; + var regs:Array = ["x", "y", "z", "w"]; + var temp1:string = this._pFindTempReg(shaderObject.animationTargetRegisters); + var k:number /*uint*/; + + var streamIndex:number /*uint*/ = shaderObject.numUsedStreams; + + if (len > 2) + len = 2; + + code += "mov " + shaderObject.animationTargetRegisters[0] + ", " + shaderObject.animatableAttributes[0] + "\n"; + if (shaderObject.normalDependencies > 0) + code += "mov " + shaderObject.animationTargetRegisters[1] + ", " + shaderObject.animatableAttributes[1] + "\n"; + + for (var i:number /*uint*/ = 0; i < len; ++i) { + for (var j:number /*uint*/ = 0; j < this._numPoses; ++j) { + code += "mul " + temp1 + ", va" + (streamIndex + k) + ", vc" + shaderObject.numUsedVertexConstants + "." + regs[j] + "\n" + + "add " + shaderObject.animationTargetRegisters[i] + ", " + shaderObject.animationTargetRegisters[i] + ", " + temp1 + "\n"; + k++; + } + } + + if (shaderObject.tangentDependencies > 0 || shaderObject.outputsNormals) { + code += "dp3 " + temp1 + ".x, " + shaderObject.animatableAttributes[2] + ", " + shaderObject.animationTargetRegisters[1] + "\n" + + "mul " + temp1 + ", " + shaderObject.animationTargetRegisters[1] + ", " + temp1 + ".x\n" + + "sub " + shaderObject.animationTargetRegisters[2] + ", " + shaderObject.animatableAttributes[2] + ", " + temp1 + "\n"; + } + + return code; + } +} + +export = VertexAnimationSet; \ No newline at end of file diff --git a/lib/animators/VertexAnimator.js b/lib/animators/VertexAnimator.js new file mode 100755 index 000000000..3d7573ded --- /dev/null +++ b/lib/animators/VertexAnimator.js @@ -0,0 +1,144 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +var VertexDataPool = require("awayjs-stagegl/lib/core/pool/VertexDataPool"); +var ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +var VertexAnimationMode = require("awayjs-renderergl/lib/animators/data/VertexAnimationMode"); +/** + * Provides an interface for assigning vertex-based animation data sets to mesh-based entity objects + * and controlling the various available states of animation through an interative playhead that can be + * automatically updated or manually triggered. + */ +var VertexAnimator = (function (_super) { + __extends(VertexAnimator, _super); + /** + * Creates a new VertexAnimator object. + * + * @param vertexAnimationSet The animation data set containing the vertex animations used by the animator. + */ + function VertexAnimator(vertexAnimationSet) { + _super.call(this, vertexAnimationSet); + this._poses = new Array(); + this._weights = Array(1, 0, 0, 0); + this._vertexAnimationSet = vertexAnimationSet; + this._numPoses = vertexAnimationSet.numPoses; + this._blendMode = vertexAnimationSet.blendMode; + } + /** + * @inheritDoc + */ + VertexAnimator.prototype.clone = function () { + return new VertexAnimator(this._vertexAnimationSet); + }; + /** + * Plays a sequence with a given name. If the sequence is not found, it may not be loaded yet, and it will retry every frame. + * @param sequenceName The name of the clip to be played. + */ + VertexAnimator.prototype.play = function (name, transition, offset) { + if (transition === void 0) { transition = null; } + if (offset === void 0) { offset = NaN; } + if (this._pActiveAnimationName == name) + return; + this._pActiveAnimationName = name; + //TODO: implement transitions in vertex animator + if (!this._pAnimationSet.hasAnimation(name)) + throw new Error("Animation root node " + name + " not found!"); + this._pActiveNode = this._pAnimationSet.getAnimation(name); + this._pActiveState = this.getAnimationState(this._pActiveNode); + if (this.updatePosition) { + //update straight away to reset position deltas + this._pActiveState.update(this._pAbsoluteTime); + this._pActiveState.positionDelta; + } + this._activeVertexState = this._pActiveState; + this.start(); + //apply a time offset if specified + if (!isNaN(offset)) + this.reset(name, offset); + }; + /** + * @inheritDoc + */ + VertexAnimator.prototype._pUpdateDeltaTime = function (dt) { + _super.prototype._pUpdateDeltaTime.call(this, dt); + var geometryFlag = false; + if (this._poses[0] != this._activeVertexState.currentGeometry) { + this._poses[0] = this._activeVertexState.currentGeometry; + geometryFlag = true; + } + if (this._poses[1] != this._activeVertexState.nextGeometry) { + this._poses[1] = this._activeVertexState.nextGeometry; + geometryFlag = true; + } + this._weights[0] = 1 - (this._weights[1] = this._activeVertexState.blendWeight); + if (geometryFlag) { + //invalidate meshes + var mesh; + var len = this._pOwners.length; + for (var i = 0; i < len; i++) { + mesh = this._pOwners[i]; + mesh._iInvalidateRenderableGeometries(); + } + } + }; + /** + * @inheritDoc + */ + VertexAnimator.prototype.setRenderState = function (shaderObject, renderable, stage, camera, vertexConstantOffset /*int*/, vertexStreamOffset /*int*/) { + // todo: add code for when running on cpu + // if no poses defined, set temp data + if (!this._poses.length) { + this.setNullPose(shaderObject, renderable, stage, vertexConstantOffset, vertexStreamOffset); + return; + } + // this type of animation can only be SubMesh + var subMesh = renderable.subMesh; + var subGeom; + var i /*uint*/; + var len = this._numPoses; + stage.context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._weights, 1); + if (this._blendMode == VertexAnimationMode.ABSOLUTE) + i = 1; + else + i = 0; + for (; i < len; ++i) { + subGeom = this._poses[i].subGeometries[subMesh._iIndex] || subMesh.subGeometry; + stage.context.activateBuffer(vertexStreamOffset++, VertexDataPool.getItem(subGeom, renderable.getIndexData(), TriangleSubGeometry.POSITION_DATA), subGeom.getOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + if (shaderObject.normalDependencies > 0) + stage.context.activateBuffer(vertexStreamOffset++, VertexDataPool.getItem(subGeom, renderable.getIndexData(), TriangleSubGeometry.NORMAL_DATA), subGeom.getOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT); + } + }; + VertexAnimator.prototype.setNullPose = function (shaderObject, renderable, stage, vertexConstantOffset /*int*/, vertexStreamOffset /*int*/) { + stage.context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._weights, 1); + if (this._blendMode == VertexAnimationMode.ABSOLUTE) { + var len = this._numPoses; + for (var i = 1; i < len; ++i) { + stage.context.activateBuffer(vertexStreamOffset++, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + if (shaderObject.normalDependencies > 0) + stage.context.activateBuffer(vertexStreamOffset++, renderable.getVertexData(TriangleSubGeometry.NORMAL_DATA), renderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT); + } + } + // todo: set temp data for additive? + }; + /** + * Verifies if the animation will be used on cpu. Needs to be true for all passes for a material to be able to use it on gpu. + * Needs to be called if gpu code is potentially required. + */ + VertexAnimator.prototype.testGPUCompatibility = function (shaderObject) { + }; + VertexAnimator.prototype.getRenderableSubGeometry = function (renderable, sourceSubGeometry) { + if (this._blendMode == VertexAnimationMode.ABSOLUTE && this._poses.length) + return this._poses[0].subGeometries[renderable.subMesh._iIndex] || sourceSubGeometry; + //nothing to do here + return sourceSubGeometry; + }; + return VertexAnimator; +})(AnimatorBase); +module.exports = VertexAnimator; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/vertexanimator.ts"],"names":["VertexAnimator","VertexAnimator.constructor","VertexAnimator.clone","VertexAnimator.play","VertexAnimator._pUpdateDeltaTime","VertexAnimator.setRenderState","VertexAnimator.setNullPose","VertexAnimator.testGPUCompatibility","VertexAnimator.getRenderableSubGeometry"],"mappings":"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","file":"animators/VertexAnimator.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport SubGeometryBase\t\t\t\t\t= require(\"awayjs-core/lib/core/base/SubGeometryBase\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport TriangleSubMesh\t\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubMesh\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport TriangleSubMeshRenderable\t\t= require(\"awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport VertexDataPool\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/VertexDataPool\");\nimport ContextGLProgramType\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLProgramType\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\n\nimport VertexAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/VertexAnimationSet\");\nimport VertexAnimationMode\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/VertexAnimationMode\");\nimport IVertexAnimationState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/IVertexAnimationState\");\nimport IAnimationTransition\t\t\t\t= require(\"awayjs-renderergl/lib/animators/transitions/IAnimationTransition\");\n\n/**\n * Provides an interface for assigning vertex-based animation data sets to mesh-based entity objects\n * and controlling the various available states of animation through an interative playhead that can be\n * automatically updated or manually triggered.\n */\nclass VertexAnimator extends AnimatorBase\n{\n\tprivate _vertexAnimationSet:VertexAnimationSet;\n\tprivate _poses:Array<Geometry> = new Array<Geometry>();\n\tprivate _weights:Array<number> = Array<number>(1, 0, 0, 0);\n\tprivate _numPoses:number /*uint*/;\n\tprivate _blendMode:string;\n\tprivate _activeVertexState:IVertexAnimationState;\n\n\t/**\n\t * Creates a new <code>VertexAnimator</code> object.\n\t *\n\t * @param vertexAnimationSet The animation data set containing the vertex animations used by the animator.\n\t */\n\tconstructor(vertexAnimationSet:VertexAnimationSet)\n\t{\n\t\tsuper(vertexAnimationSet);\n\n\t\tthis._vertexAnimationSet = vertexAnimationSet;\n\t\tthis._numPoses = vertexAnimationSet.numPoses;\n\t\tthis._blendMode = vertexAnimationSet.blendMode;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic clone():AnimatorBase\n\t{\n\t\treturn new VertexAnimator(this._vertexAnimationSet);\n\t}\n\n\t/**\n\t * Plays a sequence with a given name. If the sequence is not found, it may not be loaded yet, and it will retry every frame.\n\t * @param sequenceName The name of the clip to be played.\n\t */\n\tpublic play(name:string, transition:IAnimationTransition = null, offset:number = NaN)\n\t{\n\t\tif (this._pActiveAnimationName == name)\n\t\t\treturn;\n\n\t\tthis._pActiveAnimationName = name;\n\n\t\t//TODO: implement transitions in vertex animator\n\n\t\tif (!this._pAnimationSet.hasAnimation(name))\n\t\t\tthrow new Error(\"Animation root node \" + name + \" not found!\");\n\n\t\tthis._pActiveNode = this._pAnimationSet.getAnimation(name);\n\n\t\tthis._pActiveState = this.getAnimationState(this._pActiveNode);\n\n\t\tif (this.updatePosition) {\n\t\t\t//update straight away to reset position deltas\n\t\t\tthis._pActiveState.update(this._pAbsoluteTime);\n\t\t\tthis._pActiveState.positionDelta;\n\t\t}\n\n\t\tthis._activeVertexState = <IVertexAnimationState> this._pActiveState;\n\n\t\tthis.start();\n\n\t\t//apply a time offset if specified\n\t\tif (!isNaN(offset))\n\t\t\tthis.reset(name, offset);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdateDeltaTime(dt:number)\n\t{\n\t\tsuper._pUpdateDeltaTime(dt);\n\n\t\tvar geometryFlag:boolean = false;\n\n\t\tif (this._poses[0] != this._activeVertexState.currentGeometry) {\n\t\t\tthis._poses[0] = this._activeVertexState.currentGeometry;\n\t\t\tgeometryFlag = true;\n\t\t}\n\n\t\tif (this._poses[1] != this._activeVertexState.nextGeometry) {\n\t\t\tthis._poses[1] = this._activeVertexState.nextGeometry;\n\t\t\tgeometryFlag = true;\n\t\t}\n\n\t\tthis._weights[0] = 1 - (this._weights[1] = this._activeVertexState.blendWeight);\n\n\t\tif (geometryFlag) {\n\t\t\t//invalidate meshes\n\t\t\tvar mesh:Mesh;\n\t\t\tvar len:number = this._pOwners.length;\n\t\t\tfor (var i:number = 0; i < len; i++) {\n\t\t\t\tmesh = this._pOwners[i];\n\t\t\t\tmesh._iInvalidateRenderableGeometries();\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setRenderState(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, camera:Camera, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/)\n\t{\n\t\t// todo: add code for when running on cpu\n\n\t\t// if no poses defined, set temp data\n\t\tif (!this._poses.length) {\n\t\t\tthis.setNullPose(shaderObject, renderable, stage, vertexConstantOffset, vertexStreamOffset);\n\t\t\treturn;\n\t\t}\n\n\t\t// this type of animation can only be SubMesh\n\t\tvar subMesh:TriangleSubMesh = <TriangleSubMesh> (<TriangleSubMeshRenderable> renderable).subMesh;\n\t\tvar subGeom:SubGeometryBase;\n\t\tvar i:number /*uint*/;\n\t\tvar len:number /*uint*/ = this._numPoses;\n\n\t\t(<IContextStageGL> stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._weights, 1);\n\n\t\tif (this._blendMode == VertexAnimationMode.ABSOLUTE)\n\t\t\ti = 1;\n\t\telse\n\t\t\ti = 0;\n\n\t\tfor (; i < len; ++i) {\n\t\t\tsubGeom = this._poses[i].subGeometries[subMesh._iIndex] || subMesh.subGeometry;\n\n\t\t\t(<IContextStageGL> stage.context).activateBuffer(vertexStreamOffset++, VertexDataPool.getItem(subGeom, renderable.getIndexData(), TriangleSubGeometry.POSITION_DATA), subGeom.getOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT);\n\n\t\t\tif (shaderObject.normalDependencies > 0)\n\t\t\t\t(<IContextStageGL> stage.context).activateBuffer(vertexStreamOffset++, VertexDataPool.getItem(subGeom, renderable.getIndexData(), TriangleSubGeometry.NORMAL_DATA), subGeom.getOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT);\n\t\t}\n\t}\n\n\tprivate setNullPose(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/)\n\t{\n\t\t(<IContextStageGL> stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._weights, 1);\n\n\t\tif (this._blendMode == VertexAnimationMode.ABSOLUTE) {\n\t\t\tvar len:number /*uint*/ = this._numPoses;\n\t\t\tfor (var i:number /*uint*/ = 1; i < len; ++i) {\n\t\t\t\t(<IContextStageGL> stage.context).activateBuffer(vertexStreamOffset++, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT);\n\n\t\t\t\tif (shaderObject.normalDependencies > 0)\n\t\t\t\t\t(<IContextStageGL> stage.context).activateBuffer(vertexStreamOffset++, renderable.getVertexData(TriangleSubGeometry.NORMAL_DATA), renderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT);\n\t\t\t}\n\t\t}\n\t\t// todo: set temp data for additive?\n\t}\n\n\t/**\n\t * Verifies if the animation will be used on cpu. Needs to be true for all passes for a material to be able to use it on gpu.\n\t * Needs to be called if gpu code is potentially required.\n\t */\n\tpublic testGPUCompatibility(shaderObject:ShaderObjectBase)\n\t{\n\t}\n\n\tpublic getRenderableSubGeometry(renderable:TriangleSubMeshRenderable, sourceSubGeometry:TriangleSubGeometry):TriangleSubGeometry\n\t{\n\t\tif (this._blendMode == VertexAnimationMode.ABSOLUTE && this._poses.length)\n\t\t\treturn <TriangleSubGeometry> this._poses[0].subGeometries[renderable.subMesh._iIndex] || sourceSubGeometry;\n\n\t\t//nothing to do here\n\t\treturn sourceSubGeometry;\n\t}\n}\n\nexport = VertexAnimator;"]} \ No newline at end of file diff --git a/lib/animators/VertexAnimator.ts b/lib/animators/VertexAnimator.ts new file mode 100644 index 000000000..e713fa7b7 --- /dev/null +++ b/lib/animators/VertexAnimator.ts @@ -0,0 +1,195 @@ +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import SubGeometryBase = require("awayjs-core/lib/core/base/SubGeometryBase"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import TriangleSubMesh = require("awayjs-core/lib/core/base/TriangleSubMesh"); +import Camera = require("awayjs-core/lib/entities/Camera"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import TriangleSubMeshRenderable = require("awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import VertexDataPool = require("awayjs-stagegl/lib/core/pool/VertexDataPool"); +import ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); + +import VertexAnimationSet = require("awayjs-renderergl/lib/animators/VertexAnimationSet"); +import VertexAnimationMode = require("awayjs-renderergl/lib/animators/data/VertexAnimationMode"); +import IVertexAnimationState = require("awayjs-renderergl/lib/animators/states/IVertexAnimationState"); +import IAnimationTransition = require("awayjs-renderergl/lib/animators/transitions/IAnimationTransition"); + +/** + * Provides an interface for assigning vertex-based animation data sets to mesh-based entity objects + * and controlling the various available states of animation through an interative playhead that can be + * automatically updated or manually triggered. + */ +class VertexAnimator extends AnimatorBase +{ + private _vertexAnimationSet:VertexAnimationSet; + private _poses:Array = new Array(); + private _weights:Array = Array(1, 0, 0, 0); + private _numPoses:number /*uint*/; + private _blendMode:string; + private _activeVertexState:IVertexAnimationState; + + /** + * Creates a new VertexAnimator object. + * + * @param vertexAnimationSet The animation data set containing the vertex animations used by the animator. + */ + constructor(vertexAnimationSet:VertexAnimationSet) + { + super(vertexAnimationSet); + + this._vertexAnimationSet = vertexAnimationSet; + this._numPoses = vertexAnimationSet.numPoses; + this._blendMode = vertexAnimationSet.blendMode; + } + + /** + * @inheritDoc + */ + public clone():AnimatorBase + { + return new VertexAnimator(this._vertexAnimationSet); + } + + /** + * Plays a sequence with a given name. If the sequence is not found, it may not be loaded yet, and it will retry every frame. + * @param sequenceName The name of the clip to be played. + */ + public play(name:string, transition:IAnimationTransition = null, offset:number = NaN) + { + if (this._pActiveAnimationName == name) + return; + + this._pActiveAnimationName = name; + + //TODO: implement transitions in vertex animator + + if (!this._pAnimationSet.hasAnimation(name)) + throw new Error("Animation root node " + name + " not found!"); + + this._pActiveNode = this._pAnimationSet.getAnimation(name); + + this._pActiveState = this.getAnimationState(this._pActiveNode); + + if (this.updatePosition) { + //update straight away to reset position deltas + this._pActiveState.update(this._pAbsoluteTime); + this._pActiveState.positionDelta; + } + + this._activeVertexState = this._pActiveState; + + this.start(); + + //apply a time offset if specified + if (!isNaN(offset)) + this.reset(name, offset); + } + + /** + * @inheritDoc + */ + public _pUpdateDeltaTime(dt:number) + { + super._pUpdateDeltaTime(dt); + + var geometryFlag:boolean = false; + + if (this._poses[0] != this._activeVertexState.currentGeometry) { + this._poses[0] = this._activeVertexState.currentGeometry; + geometryFlag = true; + } + + if (this._poses[1] != this._activeVertexState.nextGeometry) { + this._poses[1] = this._activeVertexState.nextGeometry; + geometryFlag = true; + } + + this._weights[0] = 1 - (this._weights[1] = this._activeVertexState.blendWeight); + + if (geometryFlag) { + //invalidate meshes + var mesh:Mesh; + var len:number = this._pOwners.length; + for (var i:number = 0; i < len; i++) { + mesh = this._pOwners[i]; + mesh._iInvalidateRenderableGeometries(); + } + } + } + + /** + * @inheritDoc + */ + public setRenderState(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, camera:Camera, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/) + { + // todo: add code for when running on cpu + + // if no poses defined, set temp data + if (!this._poses.length) { + this.setNullPose(shaderObject, renderable, stage, vertexConstantOffset, vertexStreamOffset); + return; + } + + // this type of animation can only be SubMesh + var subMesh:TriangleSubMesh = ( renderable).subMesh; + var subGeom:SubGeometryBase; + var i:number /*uint*/; + var len:number /*uint*/ = this._numPoses; + + ( stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._weights, 1); + + if (this._blendMode == VertexAnimationMode.ABSOLUTE) + i = 1; + else + i = 0; + + for (; i < len; ++i) { + subGeom = this._poses[i].subGeometries[subMesh._iIndex] || subMesh.subGeometry; + + ( stage.context).activateBuffer(vertexStreamOffset++, VertexDataPool.getItem(subGeom, renderable.getIndexData(), TriangleSubGeometry.POSITION_DATA), subGeom.getOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + + if (shaderObject.normalDependencies > 0) + ( stage.context).activateBuffer(vertexStreamOffset++, VertexDataPool.getItem(subGeom, renderable.getIndexData(), TriangleSubGeometry.NORMAL_DATA), subGeom.getOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT); + } + } + + private setNullPose(shaderObject:ShaderObjectBase, renderable:RenderableBase, stage:Stage, vertexConstantOffset:number /*int*/, vertexStreamOffset:number /*int*/) + { + ( stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, vertexConstantOffset, this._weights, 1); + + if (this._blendMode == VertexAnimationMode.ABSOLUTE) { + var len:number /*uint*/ = this._numPoses; + for (var i:number /*uint*/ = 1; i < len; ++i) { + ( stage.context).activateBuffer(vertexStreamOffset++, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + + if (shaderObject.normalDependencies > 0) + ( stage.context).activateBuffer(vertexStreamOffset++, renderable.getVertexData(TriangleSubGeometry.NORMAL_DATA), renderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT); + } + } + // todo: set temp data for additive? + } + + /** + * Verifies if the animation will be used on cpu. Needs to be true for all passes for a material to be able to use it on gpu. + * Needs to be called if gpu code is potentially required. + */ + public testGPUCompatibility(shaderObject:ShaderObjectBase) + { + } + + public getRenderableSubGeometry(renderable:TriangleSubMeshRenderable, sourceSubGeometry:TriangleSubGeometry):TriangleSubGeometry + { + if (this._blendMode == VertexAnimationMode.ABSOLUTE && this._poses.length) + return this._poses[0].subGeometries[renderable.subMesh._iIndex] || sourceSubGeometry; + + //nothing to do here + return sourceSubGeometry; + } +} + +export = VertexAnimator; \ No newline at end of file diff --git a/lib/animators/data/AnimationSubGeometry.js b/lib/animators/data/AnimationSubGeometry.js new file mode 100755 index 000000000..8ed4d8fd5 --- /dev/null +++ b/lib/animators/data/AnimationSubGeometry.js @@ -0,0 +1,73 @@ +/** + * ... + */ +var AnimationSubGeometry = (function () { + function AnimationSubGeometry() { + this._pVertexBuffer = new Array(8); + this._pBufferContext = new Array(8); + this._pBufferDirty = new Array(8); + this.numProcessedVertices = 0; + this.previousTime = Number.NEGATIVE_INFINITY; + this.animationParticles = new Array(); + for (var i = 0; i < 8; i++) + this._pBufferDirty[i] = true; + this._iUniqueId = AnimationSubGeometry.SUBGEOM_ID_COUNT++; + } + AnimationSubGeometry.prototype.createVertexData = function (numVertices /*uint*/, totalLenOfOneVertex /*uint*/) { + this._numVertices = numVertices; + this._totalLenOfOneVertex = totalLenOfOneVertex; + this._pVertexData = new Array(numVertices * totalLenOfOneVertex); + }; + AnimationSubGeometry.prototype.activateVertexBuffer = function (index /*int*/, bufferOffset /*int*/, stage, format) { + var contextIndex = stage.stageIndex; + var context = stage.context; + var buffer = this._pVertexBuffer[contextIndex]; + if (!buffer || this._pBufferContext[contextIndex] != context) { + buffer = this._pVertexBuffer[contextIndex] = context.createVertexBuffer(this._numVertices, this._totalLenOfOneVertex); + this._pBufferContext[contextIndex] = context; + this._pBufferDirty[contextIndex] = true; + } + if (this._pBufferDirty[contextIndex]) { + buffer.uploadFromArray(this._pVertexData, 0, this._numVertices); + this._pBufferDirty[contextIndex] = false; + } + context.setVertexBufferAt(index, buffer, bufferOffset, format); + }; + AnimationSubGeometry.prototype.dispose = function () { + while (this._pVertexBuffer.length) { + var vertexBuffer = this._pVertexBuffer.pop(); + if (vertexBuffer) + vertexBuffer.dispose(); + } + }; + AnimationSubGeometry.prototype.invalidateBuffer = function () { + for (var i = 0; i < 8; i++) + this._pBufferDirty[i] = true; + }; + Object.defineProperty(AnimationSubGeometry.prototype, "vertexData", { + get: function () { + return this._pVertexData; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationSubGeometry.prototype, "numVertices", { + get: function () { + return this._numVertices; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationSubGeometry.prototype, "totalLenOfOneVertex", { + get: function () { + return this._totalLenOfOneVertex; + }, + enumerable: true, + configurable: true + }); + AnimationSubGeometry.SUBGEOM_ID_COUNT = 0; + return AnimationSubGeometry; +})(); +module.exports = AnimationSubGeometry; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/data/animationsubgeometry.ts"],"names":["AnimationSubGeometry","AnimationSubGeometry.constructor","AnimationSubGeometry.createVertexData","AnimationSubGeometry.activateVertexBuffer","AnimationSubGeometry.dispose","AnimationSubGeometry.invalidateBuffer","AnimationSubGeometry.vertexData","AnimationSubGeometry.numVertices","AnimationSubGeometry.totalLenOfOneVertex"],"mappings":"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","file":"animators/data/AnimationSubGeometry.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport IVertexBuffer\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IVertexBuffer\");\n\nimport ParticleAnimationData\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleAnimationData\");\n\n/**\n * ...\n */\nclass AnimationSubGeometry\n{\n\tpublic static SUBGEOM_ID_COUNT:number = 0;\n\n\tpublic _pVertexData:Array<number>;\n\n\tpublic _pVertexBuffer:Array<IVertexBuffer> = new Array<IVertexBuffer>(8);\n\tpublic _pBufferContext:Array<IContextStageGL> = new Array<IContextStageGL>(8);\n\tpublic _pBufferDirty:Array<boolean> = new Array<boolean>(8);\n\n\tprivate _numVertices:number /*uint*/;\n\n\tprivate _totalLenOfOneVertex:number /*uint*/;\n\n\tpublic numProcessedVertices:number /*int*/ = 0;\n\n\tpublic previousTime:number = Number.NEGATIVE_INFINITY;\n\n\tpublic animationParticles:Array<ParticleAnimationData> = new Array<ParticleAnimationData>();\n\n\t/**\n\t * An id for this animation subgeometry, used to identify animation subgeometries when using animation sets.\n\t *\n\t * @private\n\t */\n\tpublic _iUniqueId:number;//Arcane\n\n\tconstructor()\n\t{\n\t\tfor (var i:number /*int*/ = 0; i < 8; i++)\n\t\t\tthis._pBufferDirty[i] = true;\n\n\t\tthis._iUniqueId = AnimationSubGeometry.SUBGEOM_ID_COUNT++;\n\t}\n\n\tpublic createVertexData(numVertices:number /*uint*/, totalLenOfOneVertex:number /*uint*/)\n\t{\n\t\tthis._numVertices = numVertices;\n\t\tthis._totalLenOfOneVertex = totalLenOfOneVertex;\n\t\tthis._pVertexData = new Array<number>(numVertices*totalLenOfOneVertex);\n\t}\n\n\tpublic activateVertexBuffer(index:number /*int*/, bufferOffset:number /*int*/, stage:Stage, format:string)\n\t{\n\t\tvar contextIndex:number /*int*/ = stage.stageIndex;\n\t\tvar context:IContextStageGL = <IContextStageGL> stage.context;\n\n\t\tvar buffer:IVertexBuffer = this._pVertexBuffer[contextIndex];\n\t\tif (!buffer || this._pBufferContext[contextIndex] != context) {\n\t\t\tbuffer = this._pVertexBuffer[contextIndex] = context.createVertexBuffer(this._numVertices, this._totalLenOfOneVertex);\n\t\t\tthis._pBufferContext[contextIndex] = context;\n\t\t\tthis._pBufferDirty[contextIndex] = true;\n\t\t}\n\t\tif (this._pBufferDirty[contextIndex]) {\n\t\t\tbuffer.uploadFromArray(this._pVertexData, 0, this._numVertices);\n\t\t\tthis._pBufferDirty[contextIndex] = false;\n\t\t}\n\t\tcontext.setVertexBufferAt(index, buffer, bufferOffset, format);\n\t}\n\n\tpublic dispose()\n\t{\n\t\twhile (this._pVertexBuffer.length) {\n\t\t\tvar vertexBuffer:IVertexBuffer = this._pVertexBuffer.pop()\n\n\t\t\tif (vertexBuffer)\n\t\t\t\tvertexBuffer.dispose();\n\t\t}\n\t}\n\n\tpublic invalidateBuffer()\n\t{\n\t\tfor (var i:number /*int*/ = 0; i < 8; i++)\n\t\t\tthis._pBufferDirty[i] = true;\n\t}\n\n\tpublic get vertexData():Array<number>\n\t{\n\t\treturn this._pVertexData;\n\t}\n\n\tpublic get numVertices():number /*uint*/\n\t{\n\t\treturn this._numVertices;\n\t}\n\n\tpublic get totalLenOfOneVertex():number /*uint*/\n\t{\n\t\treturn this._totalLenOfOneVertex;\n\t}\n}\n\nexport = AnimationSubGeometry;"]} \ No newline at end of file diff --git a/lib/animators/data/AnimationSubGeometry.ts b/lib/animators/data/AnimationSubGeometry.ts new file mode 100644 index 000000000..76b6c7e7e --- /dev/null +++ b/lib/animators/data/AnimationSubGeometry.ts @@ -0,0 +1,102 @@ +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import IVertexBuffer = require("awayjs-stagegl/lib/core/stagegl/IVertexBuffer"); + +import ParticleAnimationData = require("awayjs-renderergl/lib/animators/data/ParticleAnimationData"); + +/** + * ... + */ +class AnimationSubGeometry +{ + public static SUBGEOM_ID_COUNT:number = 0; + + public _pVertexData:Array; + + public _pVertexBuffer:Array = new Array(8); + public _pBufferContext:Array = new Array(8); + public _pBufferDirty:Array = new Array(8); + + private _numVertices:number /*uint*/; + + private _totalLenOfOneVertex:number /*uint*/; + + public numProcessedVertices:number /*int*/ = 0; + + public previousTime:number = Number.NEGATIVE_INFINITY; + + public animationParticles:Array = new Array(); + + /** + * An id for this animation subgeometry, used to identify animation subgeometries when using animation sets. + * + * @private + */ + public _iUniqueId:number;//Arcane + + constructor() + { + for (var i:number /*int*/ = 0; i < 8; i++) + this._pBufferDirty[i] = true; + + this._iUniqueId = AnimationSubGeometry.SUBGEOM_ID_COUNT++; + } + + public createVertexData(numVertices:number /*uint*/, totalLenOfOneVertex:number /*uint*/) + { + this._numVertices = numVertices; + this._totalLenOfOneVertex = totalLenOfOneVertex; + this._pVertexData = new Array(numVertices*totalLenOfOneVertex); + } + + public activateVertexBuffer(index:number /*int*/, bufferOffset:number /*int*/, stage:Stage, format:string) + { + var contextIndex:number /*int*/ = stage.stageIndex; + var context:IContextStageGL = stage.context; + + var buffer:IVertexBuffer = this._pVertexBuffer[contextIndex]; + if (!buffer || this._pBufferContext[contextIndex] != context) { + buffer = this._pVertexBuffer[contextIndex] = context.createVertexBuffer(this._numVertices, this._totalLenOfOneVertex); + this._pBufferContext[contextIndex] = context; + this._pBufferDirty[contextIndex] = true; + } + if (this._pBufferDirty[contextIndex]) { + buffer.uploadFromArray(this._pVertexData, 0, this._numVertices); + this._pBufferDirty[contextIndex] = false; + } + context.setVertexBufferAt(index, buffer, bufferOffset, format); + } + + public dispose() + { + while (this._pVertexBuffer.length) { + var vertexBuffer:IVertexBuffer = this._pVertexBuffer.pop() + + if (vertexBuffer) + vertexBuffer.dispose(); + } + } + + public invalidateBuffer() + { + for (var i:number /*int*/ = 0; i < 8; i++) + this._pBufferDirty[i] = true; + } + + public get vertexData():Array + { + return this._pVertexData; + } + + public get numVertices():number /*uint*/ + { + return this._numVertices; + } + + public get totalLenOfOneVertex():number /*uint*/ + { + return this._totalLenOfOneVertex; + } +} + +export = AnimationSubGeometry; \ No newline at end of file diff --git a/lib/animators/data/ColorSegmentPoint.js b/lib/animators/data/ColorSegmentPoint.js new file mode 100755 index 000000000..33f0b70cd --- /dev/null +++ b/lib/animators/data/ColorSegmentPoint.js @@ -0,0 +1,27 @@ +var ColorSegmentPoint = (function () { + function ColorSegmentPoint(life, color) { + //0= 1) + throw (new Error("life exceeds range (0,1)")); + this._life = life; + this._color = color; + } + Object.defineProperty(ColorSegmentPoint.prototype, "color", { + get: function () { + return this._color; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ColorSegmentPoint.prototype, "life", { + get: function () { + return this._life; + }, + enumerable: true, + configurable: true + }); + return ColorSegmentPoint; +})(); +module.exports = ColorSegmentPoint; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9kYXRhL2NvbG9yc2VnbWVudHBvaW50LnRzIl0sIm5hbWVzIjpbIkNvbG9yU2VnbWVudFBvaW50IiwiQ29sb3JTZWdtZW50UG9pbnQuY29uc3RydWN0b3IiLCJDb2xvclNlZ21lbnRQb2ludC5jb2xvciIsIkNvbG9yU2VnbWVudFBvaW50LmxpZmUiXSwibWFwcGluZ3MiOiJBQUVBLElBQU0saUJBQWlCO0lBS3RCQSxTQUxLQSxpQkFBaUJBLENBS1ZBLElBQVdBLEVBQUVBLEtBQW9CQTtRQUU1Q0MsQUFDQUEsVUFEVUE7UUFDVkEsRUFBRUEsQ0FBQ0EsQ0FBQ0EsSUFBSUEsSUFBSUEsQ0FBQ0EsSUFBSUEsSUFBSUEsSUFBSUEsQ0FBQ0EsQ0FBQ0E7WUFDMUJBLE1BQUtBLENBQUNBLElBQUlBLEtBQUtBLENBQUNBLDBCQUEwQkEsQ0FBQ0EsQ0FBQ0EsQ0FBQ0E7UUFDOUNBLElBQUlBLENBQUNBLEtBQUtBLEdBQUdBLElBQUlBLENBQUNBO1FBQ2xCQSxJQUFJQSxDQUFDQSxNQUFNQSxHQUFHQSxLQUFLQSxDQUFDQTtJQUNyQkEsQ0FBQ0E7SUFFREQsc0JBQVdBLG9DQUFLQTthQUFoQkE7WUFFQ0UsTUFBTUEsQ0FBQ0EsSUFBSUEsQ0FBQ0EsTUFBTUEsQ0FBQ0E7UUFDcEJBLENBQUNBOzs7T0FBQUY7SUFFREEsc0JBQVdBLG1DQUFJQTthQUFmQTtZQUVDRyxNQUFNQSxDQUFDQSxJQUFJQSxDQUFDQSxLQUFLQSxDQUFDQTtRQUNuQkEsQ0FBQ0E7OztPQUFBSDtJQUVGQSx3QkFBQ0E7QUFBREEsQ0F4QkEsQUF3QkNBLElBQUE7QUFFRCxBQUEyQixpQkFBbEIsaUJBQWlCLENBQUMiLCJmaWxlIjoiYW5pbWF0b3JzL2RhdGEvQ29sb3JTZWdtZW50UG9pbnQuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgQ29sb3JUcmFuc2Zvcm1cdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLWNvcmUvbGliL2NvcmUvZ2VvbS9Db2xvclRyYW5zZm9ybVwiKTtcblxuY2xhc3MgQ29sb3JTZWdtZW50UG9pbnRcbntcblx0cHJpdmF0ZSBfY29sb3I6Q29sb3JUcmFuc2Zvcm07XG5cdHByaXZhdGUgX2xpZmU6bnVtYmVyO1xuXG5cdGNvbnN0cnVjdG9yKGxpZmU6bnVtYmVyLCBjb2xvcjpDb2xvclRyYW5zZm9ybSlcblx0e1xuXHRcdC8vMDxsaWZlPDFcblx0XHRpZiAobGlmZSA8PSAwIHx8IGxpZmUgPj0gMSlcblx0XHRcdHRocm93KG5ldyBFcnJvcihcImxpZmUgZXhjZWVkcyByYW5nZSAoMCwxKVwiKSk7XG5cdFx0dGhpcy5fbGlmZSA9IGxpZmU7XG5cdFx0dGhpcy5fY29sb3IgPSBjb2xvcjtcblx0fVxuXG5cdHB1YmxpYyBnZXQgY29sb3IoKTpDb2xvclRyYW5zZm9ybVxuXHR7XG5cdFx0cmV0dXJuIHRoaXMuX2NvbG9yO1xuXHR9XG5cblx0cHVibGljIGdldCBsaWZlKCk6bnVtYmVyXG5cdHtcblx0XHRyZXR1cm4gdGhpcy5fbGlmZTtcblx0fVxuXG59XG5cbmV4cG9ydCA9IENvbG9yU2VnbWVudFBvaW50OyJdfQ== \ No newline at end of file diff --git a/lib/animators/data/ColorSegmentPoint.ts b/lib/animators/data/ColorSegmentPoint.ts new file mode 100644 index 000000000..025641855 --- /dev/null +++ b/lib/animators/data/ColorSegmentPoint.ts @@ -0,0 +1,29 @@ +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); + +class ColorSegmentPoint +{ + private _color:ColorTransform; + private _life:number; + + constructor(life:number, color:ColorTransform) + { + //0= 1) + throw(new Error("life exceeds range (0,1)")); + this._life = life; + this._color = color; + } + + public get color():ColorTransform + { + return this._color; + } + + public get life():number + { + return this._life; + } + +} + +export = ColorSegmentPoint; \ No newline at end of file diff --git a/lib/animators/data/JointPose.js b/lib/animators/data/JointPose.js new file mode 100755 index 000000000..aca5b0415 --- /dev/null +++ b/lib/animators/data/JointPose.js @@ -0,0 +1,57 @@ +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +/** + * Contains transformation data for a skeleton joint, used for skeleton animation. + * + * @see away.animation.Skeleton + * @see away.animation.SkeletonJoint + * + * todo: support (uniform) scale + */ +var JointPose = (function () { + function JointPose() { + /** + * The rotation of the pose stored as a quaternion + */ + this.orientation = new Quaternion(); + /** + * The translation of the pose + */ + this.translation = new Vector3D(); + } + /** + * Converts the transformation to a Matrix3D representation. + * + * @param target An optional target matrix to store the transformation. If not provided, it will create a new instance. + * @return The transformation matrix of the pose. + */ + JointPose.prototype.toMatrix3D = function (target) { + if (target === void 0) { target = null; } + if (target == null) + target = new Matrix3D(); + this.orientation.toMatrix3D(target); + target.appendTranslation(this.translation.x, this.translation.y, this.translation.z); + return target; + }; + /** + * Copies the transformation data from a source pose object into the existing pose object. + * + * @param pose The source pose to copy from. + */ + JointPose.prototype.copyFrom = function (pose) { + var or = pose.orientation; + var tr = pose.translation; + this.orientation.x = or.x; + this.orientation.y = or.y; + this.orientation.z = or.z; + this.orientation.w = or.w; + this.translation.x = tr.x; + this.translation.y = tr.y; + this.translation.z = tr.z; + }; + return JointPose; +})(); +module.exports = JointPose; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/data/JointPose.ts b/lib/animators/data/JointPose.ts new file mode 100644 index 000000000..2d25bf3e1 --- /dev/null +++ b/lib/animators/data/JointPose.ts @@ -0,0 +1,70 @@ +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +/** + * Contains transformation data for a skeleton joint, used for skeleton animation. + * + * @see away.animation.Skeleton + * @see away.animation.SkeletonJoint + * + * todo: support (uniform) scale + */ +class JointPose +{ + /** + * The name of the joint to which the pose is associated + */ + public name:string; // intention is that this should be used only at load time, not in the main loop + + /** + * The rotation of the pose stored as a quaternion + */ + public orientation:Quaternion = new Quaternion(); + + /** + * The translation of the pose + */ + public translation:Vector3D = new Vector3D(); + + constructor() + { + + } + + /** + * Converts the transformation to a Matrix3D representation. + * + * @param target An optional target matrix to store the transformation. If not provided, it will create a new instance. + * @return The transformation matrix of the pose. + */ + public toMatrix3D(target:Matrix3D = null):Matrix3D + { + if (target == null) + target = new Matrix3D(); + + this.orientation.toMatrix3D(target); + target.appendTranslation(this.translation.x, this.translation.y, this.translation.z); + return target; + } + + /** + * Copies the transformation data from a source pose object into the existing pose object. + * + * @param pose The source pose to copy from. + */ + public copyFrom(pose:JointPose) + { + var or:Quaternion = pose.orientation; + var tr:Vector3D = pose.translation; + this.orientation.x = or.x; + this.orientation.y = or.y; + this.orientation.z = or.z; + this.orientation.w = or.w; + this.translation.x = tr.x; + this.translation.y = tr.y; + this.translation.z = tr.z; + } +} + +export = JointPose; \ No newline at end of file diff --git a/lib/animators/data/ParticleAnimationData.js b/lib/animators/data/ParticleAnimationData.js new file mode 100755 index 000000000..cceceeab9 --- /dev/null +++ b/lib/animators/data/ParticleAnimationData.js @@ -0,0 +1,18 @@ +/** + * ... + */ +var ParticleAnimationData = (function () { + function ParticleAnimationData(index /*uint*/, startTime, duration, delay, particle) { + this.index = index; + this.startTime = startTime; + this.totalTime = duration + delay; + this.duration = duration; + this.delay = delay; + this.startVertexIndex = particle.startVertexIndex; + this.numVertices = particle.numVertices; + } + return ParticleAnimationData; +})(); +module.exports = ParticleAnimationData; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/data/ParticleAnimationData.ts b/lib/animators/data/ParticleAnimationData.ts new file mode 100644 index 000000000..c18940adb --- /dev/null +++ b/lib/animators/data/ParticleAnimationData.ts @@ -0,0 +1,28 @@ +import ParticleData = require("awayjs-renderergl/lib/animators/data/ParticleData"); + +/** + * ... + */ +class ParticleAnimationData +{ + public index:number /*uint*/; + public startTime:number; + public totalTime:number; + public duration:number; + public delay:number; + public startVertexIndex:number /*uint*/; + public numVertices:number /*uint*/; + + constructor(index:number /*uint*/, startTime:number, duration:number, delay:number, particle:ParticleData) + { + this.index = index; + this.startTime = startTime; + this.totalTime = duration + delay; + this.duration = duration; + this.delay = delay; + this.startVertexIndex = particle.startVertexIndex; + this.numVertices = particle.numVertices; + } +} + +export = ParticleAnimationData; \ No newline at end of file diff --git a/lib/animators/data/ParticleData.js b/lib/animators/data/ParticleData.js new file mode 100755 index 000000000..c4eee1032 --- /dev/null +++ b/lib/animators/data/ParticleData.js @@ -0,0 +1,8 @@ +var ParticleData = (function () { + function ParticleData() { + } + return ParticleData; +})(); +module.exports = ParticleData; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9kYXRhL3BhcnRpY2xlZGF0YS50cyJdLCJuYW1lcyI6WyJQYXJ0aWNsZURhdGEiLCJQYXJ0aWNsZURhdGEuY29uc3RydWN0b3IiXSwibWFwcGluZ3MiOiJBQUVBLElBQU0sWUFBWTtJQUFsQkEsU0FBTUEsWUFBWUE7SUFNbEJDLENBQUNBO0lBQURELG1CQUFDQTtBQUFEQSxDQU5BLEFBTUNBLElBQUE7QUFFRCxBQUFxQixpQkFBWixZQUFZLENBQUEiLCJmaWxlIjoiYW5pbWF0b3JzL2RhdGEvUGFydGljbGVEYXRhLmpzIiwic291cmNlUm9vdCI6Ii9Vc2Vycy9yb2JiYXRlbWFuL1dlYnN0b3JtUHJvamVjdHMvYXdheWpzLXJlbmRlcmVyZ2wvIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFRyaWFuZ2xlU3ViR2VvbWV0cnlcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1jb3JlL2xpYi9jb3JlL2Jhc2UvVHJpYW5nbGVTdWJHZW9tZXRyeVwiKTtcblxuY2xhc3MgUGFydGljbGVEYXRhXG57XG5cdHB1YmxpYyBwYXJ0aWNsZUluZGV4Om51bWJlciAvKnVpbnQqLztcblx0cHVibGljIG51bVZlcnRpY2VzOm51bWJlciAvKnVpbnQqLztcblx0cHVibGljIHN0YXJ0VmVydGV4SW5kZXg6bnVtYmVyIC8qdWludCovO1xuXHRwdWJsaWMgc3ViR2VvbWV0cnk6VHJpYW5nbGVTdWJHZW9tZXRyeTtcbn1cblxuZXhwb3J0ID0gUGFydGljbGVEYXRhIl19 \ No newline at end of file diff --git a/lib/animators/data/ParticleData.ts b/lib/animators/data/ParticleData.ts new file mode 100644 index 000000000..5ec3c84b1 --- /dev/null +++ b/lib/animators/data/ParticleData.ts @@ -0,0 +1,11 @@ +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); + +class ParticleData +{ + public particleIndex:number /*uint*/; + public numVertices:number /*uint*/; + public startVertexIndex:number /*uint*/; + public subGeometry:TriangleSubGeometry; +} + +export = ParticleData \ No newline at end of file diff --git a/lib/animators/data/ParticleProperties.js b/lib/animators/data/ParticleProperties.js new file mode 100755 index 000000000..8a516840a --- /dev/null +++ b/lib/animators/data/ParticleProperties.js @@ -0,0 +1,12 @@ +/** + * Dynamic class for holding the local properties of a particle, used for processing the static properties + * of particles in the particle animation set before beginning upload to the GPU. + */ +var ParticleProperties = (function () { + function ParticleProperties() { + } + return ParticleProperties; +})(); +module.exports = ParticleProperties; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/data/ParticleProperties.ts b/lib/animators/data/ParticleProperties.ts new file mode 100644 index 000000000..3da259b93 --- /dev/null +++ b/lib/animators/data/ParticleProperties.ts @@ -0,0 +1,37 @@ +/** + * Dynamic class for holding the local properties of a particle, used for processing the static properties + * of particles in the particle animation set before beginning upload to the GPU. + */ +class ParticleProperties +{ + /** + * The index of the current particle being set. + */ + public index:number /*uint*/; + + /** + * The total number of particles being processed by the particle animation set. + */ + public total:number /*uint*/; + + /** + * The start time of the particle. + */ + public startTime:number; + + /** + * The duration of the particle, an optional value used when the particle aniamtion set settings for useDuration are enabled in the constructor. + * + * @see away.animators.ParticleAnimationSet + */ + public duration:number; + + /** + * The delay between cycles of the particle, an optional value used when the particle aniamtion set settings for useLooping and useDelay are enabled in the constructor. + * + * @see away.animators.ParticleAnimationSet + */ + public delay:number; +} + +export = ParticleProperties; \ No newline at end of file diff --git a/lib/animators/data/ParticlePropertiesMode.js b/lib/animators/data/ParticlePropertiesMode.js new file mode 100755 index 000000000..dba8dcbdd --- /dev/null +++ b/lib/animators/data/ParticlePropertiesMode.js @@ -0,0 +1,23 @@ +/** + * Options for setting the properties mode of a particle animation node. + */ +var ParticlePropertiesMode = (function () { + function ParticlePropertiesMode() { + } + /** + * Mode that defines the particle node as acting on global properties (ie. the properties set in the node constructor or the corresponding animation state). + */ + ParticlePropertiesMode.GLOBAL = 0; + /** + * Mode that defines the particle node as acting on local static properties (ie. the properties of particles set in the initialising on the animation set). + */ + ParticlePropertiesMode.LOCAL_STATIC = 1; + /** + * Mode that defines the particle node as acting on local dynamic properties (ie. the properties of the particles set in the corresponding animation state). + */ + ParticlePropertiesMode.LOCAL_DYNAMIC = 2; + return ParticlePropertiesMode; +})(); +module.exports = ParticlePropertiesMode; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9kYXRhL3BhcnRpY2xlcHJvcGVydGllc21vZGUudHMiXSwibmFtZXMiOlsiUGFydGljbGVQcm9wZXJ0aWVzTW9kZSIsIlBhcnRpY2xlUHJvcGVydGllc01vZGUuY29uc3RydWN0b3IiXSwibWFwcGluZ3MiOiJBQUFBLEFBR0E7O0dBREc7SUFDRyxzQkFBc0I7SUFBNUJBLFNBQU1BLHNCQUFzQkE7SUFnQjVCQyxDQUFDQTtJQWRBRDs7T0FFR0E7SUFDV0EsNkJBQU1BLEdBQW1CQSxDQUFDQSxDQUFDQTtJQUV6Q0E7O09BRUdBO0lBQ1dBLG1DQUFZQSxHQUFtQkEsQ0FBQ0EsQ0FBQ0E7SUFFL0NBOztPQUVHQTtJQUNXQSxvQ0FBYUEsR0FBbUJBLENBQUNBLENBQUNBO0lBQ2pEQSw2QkFBQ0E7QUFBREEsQ0FoQkEsQUFnQkNBLElBQUE7QUFFRCxBQUFnQyxpQkFBdkIsc0JBQXNCLENBQUMiLCJmaWxlIjoiYW5pbWF0b3JzL2RhdGEvUGFydGljbGVQcm9wZXJ0aWVzTW9kZS5qcyIsInNvdXJjZVJvb3QiOiIvVXNlcnMvcm9iYmF0ZW1hbi9XZWJzdG9ybVByb2plY3RzL2F3YXlqcy1yZW5kZXJlcmdsLyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogT3B0aW9ucyBmb3Igc2V0dGluZyB0aGUgcHJvcGVydGllcyBtb2RlIG9mIGEgcGFydGljbGUgYW5pbWF0aW9uIG5vZGUuXG4gKi9cbmNsYXNzIFBhcnRpY2xlUHJvcGVydGllc01vZGVcbntcblx0LyoqXG5cdCAqIE1vZGUgdGhhdCBkZWZpbmVzIHRoZSBwYXJ0aWNsZSBub2RlIGFzIGFjdGluZyBvbiBnbG9iYWwgcHJvcGVydGllcyAoaWUuIHRoZSBwcm9wZXJ0aWVzIHNldCBpbiB0aGUgbm9kZSBjb25zdHJ1Y3RvciBvciB0aGUgY29ycmVzcG9uZGluZyBhbmltYXRpb24gc3RhdGUpLlxuXHQgKi9cblx0cHVibGljIHN0YXRpYyBHTE9CQUw6bnVtYmVyIC8qdWludCovID0gMDtcblxuXHQvKipcblx0ICogTW9kZSB0aGF0IGRlZmluZXMgdGhlIHBhcnRpY2xlIG5vZGUgYXMgYWN0aW5nIG9uIGxvY2FsIHN0YXRpYyBwcm9wZXJ0aWVzIChpZS4gdGhlIHByb3BlcnRpZXMgb2YgcGFydGljbGVzIHNldCBpbiB0aGUgaW5pdGlhbGlzaW5nIG9uIHRoZSBhbmltYXRpb24gc2V0KS5cblx0ICovXG5cdHB1YmxpYyBzdGF0aWMgTE9DQUxfU1RBVElDOm51bWJlciAvKnVpbnQqLyA9IDE7XG5cblx0LyoqXG5cdCAqIE1vZGUgdGhhdCBkZWZpbmVzIHRoZSBwYXJ0aWNsZSBub2RlIGFzIGFjdGluZyBvbiBsb2NhbCBkeW5hbWljIHByb3BlcnRpZXMgKGllLiB0aGUgcHJvcGVydGllcyBvZiB0aGUgcGFydGljbGVzIHNldCBpbiB0aGUgY29ycmVzcG9uZGluZyBhbmltYXRpb24gc3RhdGUpLlxuXHQgKi9cblx0cHVibGljIHN0YXRpYyBMT0NBTF9EWU5BTUlDOm51bWJlciAvKnVpbnQqLyA9IDI7XG59XG5cbmV4cG9ydCA9IFBhcnRpY2xlUHJvcGVydGllc01vZGU7Il19 \ No newline at end of file diff --git a/lib/animators/data/ParticlePropertiesMode.ts b/lib/animators/data/ParticlePropertiesMode.ts new file mode 100644 index 000000000..a623bc964 --- /dev/null +++ b/lib/animators/data/ParticlePropertiesMode.ts @@ -0,0 +1,22 @@ +/** + * Options for setting the properties mode of a particle animation node. + */ +class ParticlePropertiesMode +{ + /** + * Mode that defines the particle node as acting on global properties (ie. the properties set in the node constructor or the corresponding animation state). + */ + public static GLOBAL:number /*uint*/ = 0; + + /** + * Mode that defines the particle node as acting on local static properties (ie. the properties of particles set in the initialising on the animation set). + */ + public static LOCAL_STATIC:number /*uint*/ = 1; + + /** + * Mode that defines the particle node as acting on local dynamic properties (ie. the properties of the particles set in the corresponding animation state). + */ + public static LOCAL_DYNAMIC:number /*uint*/ = 2; +} + +export = ParticlePropertiesMode; \ No newline at end of file diff --git a/lib/animators/data/Skeleton.js b/lib/animators/data/Skeleton.js new file mode 100755 index 000000000..e56e1d692 --- /dev/null +++ b/lib/animators/data/Skeleton.js @@ -0,0 +1,94 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var NamedAssetBase = require("awayjs-core/lib/core/library/NamedAssetBase"); +/** + * A Skeleton object is a hierarchical grouping of joint objects that can be used for skeletal animation. + * + * @see away.animators.SkeletonJoint + */ +var Skeleton = (function (_super) { + __extends(Skeleton, _super); + /** + * Creates a new Skeleton object + */ + function Skeleton() { + _super.call(this); + // in the long run, it might be a better idea to not store Joint objects, but keep all data in Vectors, that we can upload easily? + this.joints = new Array(); + } + Object.defineProperty(Skeleton.prototype, "numJoints", { + /** + * The total number of joints in the skeleton. + */ + get: function () { + return this.joints.length; + }, + enumerable: true, + configurable: true + }); + /** + * Returns the joint object in the skeleton with the given name, otherwise returns a null object. + * + * @param jointName The name of the joint object to be found. + * @return The joint object with the given name. + * + * @see #joints + */ + Skeleton.prototype.jointFromName = function (jointName) { + var jointIndex = this.jointIndexFromName(jointName); + if (jointIndex != -1) + return this.joints[jointIndex]; + else + return null; + }; + /** + * Returns the joint index, given the joint name. -1 is returned if the joint name is not found. + * + * @param jointName The name of the joint object to be found. + * @return The index of the joint object in the joints Array + * + * @see #joints + */ + Skeleton.prototype.jointIndexFromName = function (jointName) { + // this is implemented as a linear search, rather than a possibly + // more optimal method (Dictionary lookup, for example) because: + // a) it is assumed that it will be called once for each joint + // b) it is assumed that it will be called only during load, and not during main loop + // c) maintaining a dictionary (for safety) would dictate an interface to access SkeletonJoints, + // rather than direct array access. this would be sub-optimal. + var jointIndex /*int*/; + var joint; + for (var i /*int*/; i < this.joints.length; i++) { + joint = this.joints[i]; + if (joint.name == jointName) + return jointIndex; + jointIndex++; + } + return -1; + }; + /** + * @inheritDoc + */ + Skeleton.prototype.dispose = function () { + this.joints.length = 0; + }; + Object.defineProperty(Skeleton.prototype, "assetType", { + /** + * @inheritDoc + */ + get: function () { + return AssetType.SKELETON; + }, + enumerable: true, + configurable: true + }); + return Skeleton; +})(NamedAssetBase); +module.exports = Skeleton; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/data/Skeleton.ts b/lib/animators/data/Skeleton.ts new file mode 100644 index 000000000..61bcfff38 --- /dev/null +++ b/lib/animators/data/Skeleton.ts @@ -0,0 +1,101 @@ +import SkeletonJoint = require("awayjs-renderergl/lib/animators/data/SkeletonJoint"); + +import AssetType = require("awayjs-core/lib/core/library/AssetType"); +import IAsset = require("awayjs-core/lib/core/library/IAsset"); +import NamedAssetBase = require("awayjs-core/lib/core/library/NamedAssetBase"); + +/** + * A Skeleton object is a hierarchical grouping of joint objects that can be used for skeletal animation. + * + * @see away.animators.SkeletonJoint + */ +class Skeleton extends NamedAssetBase implements IAsset +{ + /** + * A flat list of joint objects that comprise the skeleton. Every joint except for the root has a parentIndex + * property that is an index into this list. + * A child joint should always have a higher index than its parent. + */ + public joints:Array; + + /** + * The total number of joints in the skeleton. + */ + public get numJoints():number /*uint*/ + { + return this.joints.length; + } + + /** + * Creates a new Skeleton object + */ + constructor() + { + super(); + + // in the long run, it might be a better idea to not store Joint objects, but keep all data in Vectors, that we can upload easily? + this.joints = new Array(); + } + + /** + * Returns the joint object in the skeleton with the given name, otherwise returns a null object. + * + * @param jointName The name of the joint object to be found. + * @return The joint object with the given name. + * + * @see #joints + */ + public jointFromName(jointName:string):SkeletonJoint + { + var jointIndex:number /*int*/ = this.jointIndexFromName(jointName); + if (jointIndex != -1) + return this.joints[jointIndex]; else + return null; + } + + /** + * Returns the joint index, given the joint name. -1 is returned if the joint name is not found. + * + * @param jointName The name of the joint object to be found. + * @return The index of the joint object in the joints Array + * + * @see #joints + */ + public jointIndexFromName(jointName:string):number /*int*/ + { + // this is implemented as a linear search, rather than a possibly + // more optimal method (Dictionary lookup, for example) because: + // a) it is assumed that it will be called once for each joint + // b) it is assumed that it will be called only during load, and not during main loop + // c) maintaining a dictionary (for safety) would dictate an interface to access SkeletonJoints, + // rather than direct array access. this would be sub-optimal. + var jointIndex:number /*int*/; + var joint:SkeletonJoint; + for (var i:number /*int*/; i < this.joints.length; i++) { + joint = this.joints[i]; + if (joint.name == jointName) + return jointIndex; + jointIndex++; + } + + return -1; + } + + /** + * @inheritDoc + */ + public dispose() + { + this.joints.length = 0; + } + + /** + * @inheritDoc + */ + public get assetType():string + { + return AssetType.SKELETON; + } +} + +export = Skeleton; \ No newline at end of file diff --git a/lib/animators/data/SkeletonJoint.js b/lib/animators/data/SkeletonJoint.js new file mode 100755 index 000000000..8e0c24473 --- /dev/null +++ b/lib/animators/data/SkeletonJoint.js @@ -0,0 +1,22 @@ +/** + * A value obect representing a single joint in a skeleton object. + * + * @see away.animators.Skeleton + */ +var SkeletonJoint = (function () { + /** + * Creates a new SkeletonJoint object + */ + function SkeletonJoint() { + /** + * The index of the parent joint in the skeleton's joints vector. + * + * @see away.animators.Skeleton#joints + */ + this.parentIndex = -1; + } + return SkeletonJoint; +})(); +module.exports = SkeletonJoint; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9kYXRhL3NrZWxldG9uam9pbnQudHMiXSwibmFtZXMiOlsiU2tlbGV0b25Kb2ludCIsIlNrZWxldG9uSm9pbnQuY29uc3RydWN0b3IiXSwibWFwcGluZ3MiOiJBQUFBLEFBS0E7Ozs7R0FERztJQUNHLGFBQWE7SUFtQmxCQTs7T0FFR0E7SUFDSEEsU0F0QktBLGFBQWFBO1FBRWxCQzs7OztXQUlHQTtRQUNJQSxnQkFBV0EsR0FBa0JBLENBQUNBLENBQUNBLENBQUNBO0lBaUJ2Q0EsQ0FBQ0E7SUFDRkQsb0JBQUNBO0FBQURBLENBekJBLEFBeUJDQSxJQUFBO0FBRUQsQUFBdUIsaUJBQWQsYUFBYSxDQUFDIiwiZmlsZSI6ImFuaW1hdG9ycy9kYXRhL1NrZWxldG9uSm9pbnQuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgdmFsdWUgb2JlY3QgcmVwcmVzZW50aW5nIGEgc2luZ2xlIGpvaW50IGluIGEgc2tlbGV0b24gb2JqZWN0LlxuICpcbiAqIEBzZWUgYXdheS5hbmltYXRvcnMuU2tlbGV0b25cbiAqL1xuY2xhc3MgU2tlbGV0b25Kb2ludFxue1xuXHQvKipcblx0ICogVGhlIGluZGV4IG9mIHRoZSBwYXJlbnQgam9pbnQgaW4gdGhlIHNrZWxldG9uJ3Mgam9pbnRzIHZlY3Rvci5cblx0ICpcblx0ICogQHNlZSBhd2F5LmFuaW1hdG9ycy5Ta2VsZXRvbiNqb2ludHNcblx0ICovXG5cdHB1YmxpYyBwYXJlbnRJbmRleDpudW1iZXIgLyppbnQqLyA9IC0xO1xuXG5cdC8qKlxuXHQgKiBUaGUgbmFtZSBvZiB0aGUgam9pbnRcblx0ICovXG5cdHB1YmxpYyBuYW1lOnN0cmluZzsgLy8gaW50ZW50aW9uIGlzIHRoYXQgdGhpcyBzaG91bGQgYmUgdXNlZCBvbmx5IGF0IGxvYWQgdGltZSwgbm90IGluIHRoZSBtYWluIGxvb3BcblxuXHQvKipcblx0ICogVGhlIGludmVyc2UgYmluZCBwb3NlIG1hdHJpeCwgYXMgcmF3IGRhdGEsIHVzZWQgdG8gdHJhbnNmb3JtIHZlcnRpY2VzIHRvIGJpbmQgam9pbnQgc3BhY2UgaW4gcHJlcGFyYXRpb24gZm9yIHRyYW5zZm9ybWF0aW9uIHVzaW5nIHRoZSBqb2ludCBtYXRyaXguXG5cdCAqL1xuXHRwdWJsaWMgaW52ZXJzZUJpbmRQb3NlOkFycmF5PG51bWJlcj47XG5cblx0LyoqXG5cdCAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+U2tlbGV0b25Kb2ludDwvY29kZT4gb2JqZWN0XG5cdCAqL1xuXHRjb25zdHJ1Y3RvcigpXG5cdHtcblx0fVxufVxuXG5leHBvcnQgPSBTa2VsZXRvbkpvaW50OyJdfQ== \ No newline at end of file diff --git a/lib/animators/data/SkeletonJoint.ts b/lib/animators/data/SkeletonJoint.ts new file mode 100644 index 000000000..a02a3dc8c --- /dev/null +++ b/lib/animators/data/SkeletonJoint.ts @@ -0,0 +1,33 @@ +/** + * A value obect representing a single joint in a skeleton object. + * + * @see away.animators.Skeleton + */ +class SkeletonJoint +{ + /** + * The index of the parent joint in the skeleton's joints vector. + * + * @see away.animators.Skeleton#joints + */ + public parentIndex:number /*int*/ = -1; + + /** + * The name of the joint + */ + public name:string; // intention is that this should be used only at load time, not in the main loop + + /** + * The inverse bind pose matrix, as raw data, used to transform vertices to bind joint space in preparation for transformation using the joint matrix. + */ + public inverseBindPose:Array; + + /** + * Creates a new SkeletonJoint object + */ + constructor() + { + } +} + +export = SkeletonJoint; \ No newline at end of file diff --git a/lib/animators/data/SkeletonPose.js b/lib/animators/data/SkeletonPose.js new file mode 100755 index 000000000..73f924129 --- /dev/null +++ b/lib/animators/data/SkeletonPose.js @@ -0,0 +1,113 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var NamedAssetBase = require("awayjs-core/lib/core/library/NamedAssetBase"); +/** + * A collection of pose objects, determining the pose for an entire skeleton. + * The jointPoses vector object corresponds to a skeleton's joints vector object, however, there is no + * reference to a skeleton's instance, since several skeletons can be influenced by the same pose (eg: animation + * clips are added to any animator with a valid skeleton) + * + * @see away.animators.Skeleton + * @see away.animators.JointPose + */ +var SkeletonPose = (function (_super) { + __extends(SkeletonPose, _super); + /** + * Creates a new SkeletonPose object. + */ + function SkeletonPose() { + _super.call(this); + this.jointPoses = new Array(); + } + Object.defineProperty(SkeletonPose.prototype, "numJointPoses", { + /** + * The total number of joint poses in the skeleton pose. + */ + get: function () { + return this.jointPoses.length; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SkeletonPose.prototype, "assetType", { + /** + * @inheritDoc + */ + get: function () { + return AssetType.SKELETON_POSE; + }, + enumerable: true, + configurable: true + }); + /** + * Returns the joint pose object with the given joint name, otherwise returns a null object. + * + * @param jointName The name of the joint object whose pose is to be found. + * @return The pose object with the given joint name. + */ + SkeletonPose.prototype.jointPoseFromName = function (jointName) { + var jointPoseIndex = this.jointPoseIndexFromName(jointName); + if (jointPoseIndex != -1) + return this.jointPoses[jointPoseIndex]; + else + return null; + }; + /** + * Returns the pose index, given the joint name. -1 is returned if the joint name is not found in the pose. + * + * @param The name of the joint object whose pose is to be found. + * @return The index of the pose object in the jointPoses Array + * + * @see #jointPoses + */ + SkeletonPose.prototype.jointPoseIndexFromName = function (jointName) { + // this is implemented as a linear search, rather than a possibly + // more optimal method (Dictionary lookup, for example) because: + // a) it is assumed that it will be called once for each joint + // b) it is assumed that it will be called only during load, and not during main loop + // c) maintaining a dictionary (for safety) would dictate an interface to access JointPoses, + // rather than direct array access. this would be sub-optimal. + var jointPoseIndex /*int*/; + var jointPose; + for (var i /*uint*/; i < this.jointPoses.length; i++) { + jointPose = this.jointPoses[i]; + if (jointPose.name == jointName) + return jointPoseIndex; + jointPoseIndex++; + } + return -1; + }; + /** + * Creates a copy of the SkeletonPose object, with a dulpicate of its component joint poses. + * + * @return SkeletonPose + */ + SkeletonPose.prototype.clone = function () { + var clone = new SkeletonPose(); + var numJointPoses = this.jointPoses.length; + for (var i = 0; i < numJointPoses; i++) { + var cloneJointPose = new JointPose(); + var thisJointPose = this.jointPoses[i]; + cloneJointPose.name = thisJointPose.name; + cloneJointPose.copyFrom(thisJointPose); + clone.jointPoses[i] = cloneJointPose; + } + return clone; + }; + /** + * @inheritDoc + */ + SkeletonPose.prototype.dispose = function () { + this.jointPoses.length = 0; + }; + return SkeletonPose; +})(NamedAssetBase); +module.exports = SkeletonPose; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/data/skeletonpose.ts"],"names":["SkeletonPose","SkeletonPose.constructor","SkeletonPose.numJointPoses","SkeletonPose.assetType","SkeletonPose.jointPoseFromName","SkeletonPose.jointPoseIndexFromName","SkeletonPose.clone","SkeletonPose.dispose"],"mappings":"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","file":"animators/data/SkeletonPose.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\n\nimport AssetType\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport NamedAssetBase\t\t\t\t\t= require(\"awayjs-core/lib/core/library/NamedAssetBase\");\n\n/**\n * A collection of pose objects, determining the pose for an entire skeleton.\n * The <code>jointPoses</code> vector object corresponds to a skeleton's <code>joints</code> vector object, however, there is no\n * reference to a skeleton's instance, since several skeletons can be influenced by the same pose (eg: animation\n * clips are added to any animator with a valid skeleton)\n *\n * @see away.animators.Skeleton\n * @see away.animators.JointPose\n */\nclass SkeletonPose extends NamedAssetBase implements IAsset\n{\n\t/**\n\t * A flat list of pose objects that comprise the skeleton pose. The pose indices correspond to the target skeleton's joint indices.\n\t *\n\t * @see away.animators.Skeleton#joints\n\t */\n\tpublic jointPoses:Array<JointPose>;\n\n\t/**\n\t * The total number of joint poses in the skeleton pose.\n\t */\n\tpublic get numJointPoses():number /*uint*/\n\t{\n\t\treturn this.jointPoses.length;\n\t}\n\n\t/**\n\t * Creates a new <code>SkeletonPose</code> object.\n\t */\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis.jointPoses = new Array<JointPose>();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get assetType():string\n\t{\n\t\treturn AssetType.SKELETON_POSE;\n\t}\n\n\t/**\n\t * Returns the joint pose object with the given joint name, otherwise returns a null object.\n\t *\n\t * @param jointName The name of the joint object whose pose is to be found.\n\t * @return The pose object with the given joint name.\n\t */\n\tpublic jointPoseFromName(jointName:string):JointPose\n\t{\n\t\tvar jointPoseIndex:number /*int*/ = this.jointPoseIndexFromName(jointName);\n\t\tif (jointPoseIndex != -1)\n\t\t\treturn this.jointPoses[jointPoseIndex]; else\n\t\t\treturn null;\n\t}\n\n\t/**\n\t * Returns the pose index, given the joint name. -1 is returned if the joint name is not found in the pose.\n\t *\n\t * @param The name of the joint object whose pose is to be found.\n\t * @return The index of the pose object in the jointPoses Array\n\t *\n\t * @see #jointPoses\n\t */\n\tpublic jointPoseIndexFromName(jointName:string):number /*int*/\n\t{\n\t\t// this is implemented as a linear search, rather than a possibly\n\t\t// more optimal method (Dictionary lookup, for example) because:\n\t\t// a) it is assumed that it will be called once for each joint\n\t\t// b) it is assumed that it will be called only during load, and not during main loop\n\t\t// c) maintaining a dictionary (for safety) would dictate an interface to access JointPoses,\n\t\t//    rather than direct array access.  this would be sub-optimal.\n\t\tvar jointPoseIndex:number /*int*/;\n\t\tvar jointPose:JointPose;\n\t\tfor (var i:number /*uint*/; i < this.jointPoses.length; i++) {\n\t\t\tjointPose = this.jointPoses[i];\n\t\t\tif (jointPose.name == jointName)\n\t\t\t\treturn jointPoseIndex;\n\t\t\tjointPoseIndex++;\n\t\t}\n\n\t\treturn -1;\n\t}\n\n\t/**\n\t * Creates a copy of the <code>SkeletonPose</code> object, with a dulpicate of its component joint poses.\n\t *\n\t * @return SkeletonPose\n\t */\n\tpublic clone():SkeletonPose\n\t{\n\t\tvar clone:SkeletonPose = new SkeletonPose();\n\t\tvar numJointPoses:number /*uint*/ = this.jointPoses.length;\n\t\tfor (var i:number /*uint*/ = 0; i < numJointPoses; i++) {\n\t\t\tvar cloneJointPose:JointPose = new JointPose();\n\t\t\tvar thisJointPose:JointPose = this.jointPoses[i];\n\t\t\tcloneJointPose.name = thisJointPose.name;\n\t\t\tcloneJointPose.copyFrom(thisJointPose);\n\t\t\tclone.jointPoses[i] = cloneJointPose;\n\t\t}\n\t\treturn clone;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t\tthis.jointPoses.length = 0;\n\t}\n}\n\nexport = SkeletonPose;"]} \ No newline at end of file diff --git a/lib/animators/data/SkeletonPose.ts b/lib/animators/data/SkeletonPose.ts new file mode 100644 index 000000000..3223a3d31 --- /dev/null +++ b/lib/animators/data/SkeletonPose.ts @@ -0,0 +1,121 @@ +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); + +import AssetType = require("awayjs-core/lib/core/library/AssetType"); +import IAsset = require("awayjs-core/lib/core/library/IAsset"); +import NamedAssetBase = require("awayjs-core/lib/core/library/NamedAssetBase"); + +/** + * A collection of pose objects, determining the pose for an entire skeleton. + * The jointPoses vector object corresponds to a skeleton's joints vector object, however, there is no + * reference to a skeleton's instance, since several skeletons can be influenced by the same pose (eg: animation + * clips are added to any animator with a valid skeleton) + * + * @see away.animators.Skeleton + * @see away.animators.JointPose + */ +class SkeletonPose extends NamedAssetBase implements IAsset +{ + /** + * A flat list of pose objects that comprise the skeleton pose. The pose indices correspond to the target skeleton's joint indices. + * + * @see away.animators.Skeleton#joints + */ + public jointPoses:Array; + + /** + * The total number of joint poses in the skeleton pose. + */ + public get numJointPoses():number /*uint*/ + { + return this.jointPoses.length; + } + + /** + * Creates a new SkeletonPose object. + */ + constructor() + { + super(); + + this.jointPoses = new Array(); + } + + /** + * @inheritDoc + */ + public get assetType():string + { + return AssetType.SKELETON_POSE; + } + + /** + * Returns the joint pose object with the given joint name, otherwise returns a null object. + * + * @param jointName The name of the joint object whose pose is to be found. + * @return The pose object with the given joint name. + */ + public jointPoseFromName(jointName:string):JointPose + { + var jointPoseIndex:number /*int*/ = this.jointPoseIndexFromName(jointName); + if (jointPoseIndex != -1) + return this.jointPoses[jointPoseIndex]; else + return null; + } + + /** + * Returns the pose index, given the joint name. -1 is returned if the joint name is not found in the pose. + * + * @param The name of the joint object whose pose is to be found. + * @return The index of the pose object in the jointPoses Array + * + * @see #jointPoses + */ + public jointPoseIndexFromName(jointName:string):number /*int*/ + { + // this is implemented as a linear search, rather than a possibly + // more optimal method (Dictionary lookup, for example) because: + // a) it is assumed that it will be called once for each joint + // b) it is assumed that it will be called only during load, and not during main loop + // c) maintaining a dictionary (for safety) would dictate an interface to access JointPoses, + // rather than direct array access. this would be sub-optimal. + var jointPoseIndex:number /*int*/; + var jointPose:JointPose; + for (var i:number /*uint*/; i < this.jointPoses.length; i++) { + jointPose = this.jointPoses[i]; + if (jointPose.name == jointName) + return jointPoseIndex; + jointPoseIndex++; + } + + return -1; + } + + /** + * Creates a copy of the SkeletonPose object, with a dulpicate of its component joint poses. + * + * @return SkeletonPose + */ + public clone():SkeletonPose + { + var clone:SkeletonPose = new SkeletonPose(); + var numJointPoses:number /*uint*/ = this.jointPoses.length; + for (var i:number /*uint*/ = 0; i < numJointPoses; i++) { + var cloneJointPose:JointPose = new JointPose(); + var thisJointPose:JointPose = this.jointPoses[i]; + cloneJointPose.name = thisJointPose.name; + cloneJointPose.copyFrom(thisJointPose); + clone.jointPoses[i] = cloneJointPose; + } + return clone; + } + + /** + * @inheritDoc + */ + public dispose() + { + this.jointPoses.length = 0; + } +} + +export = SkeletonPose; \ No newline at end of file diff --git a/lib/animators/data/VertexAnimationMode.js b/lib/animators/data/VertexAnimationMode.js new file mode 100755 index 000000000..c83fbda70 --- /dev/null +++ b/lib/animators/data/VertexAnimationMode.js @@ -0,0 +1,21 @@ +/** + * Options for setting the animation mode of a vertex animator object. + * + * @see away.animators.VertexAnimator + */ +var VertexAnimationMode = (function () { + function VertexAnimationMode() { + } + /** + * Animation mode that adds all outputs from active vertex animation state to form the current vertex animation pose. + */ + VertexAnimationMode.ADDITIVE = "additive"; + /** + * Animation mode that picks the output from a single vertex animation state to form the current vertex animation pose. + */ + VertexAnimationMode.ABSOLUTE = "absolute"; + return VertexAnimationMode; +})(); +module.exports = VertexAnimationMode; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9kYXRhL3ZlcnRleGFuaW1hdGlvbm1vZGUudHMiXSwibmFtZXMiOlsiVmVydGV4QW5pbWF0aW9uTW9kZSIsIlZlcnRleEFuaW1hdGlvbk1vZGUuY29uc3RydWN0b3IiXSwibWFwcGluZ3MiOiJBQUFBLEFBS0E7Ozs7R0FERztJQUNHLG1CQUFtQjtJQUF6QkEsU0FBTUEsbUJBQW1CQTtJQVd6QkMsQ0FBQ0E7SUFUQUQ7O09BRUdBO0lBQ1dBLDRCQUFRQSxHQUFVQSxVQUFVQSxDQUFDQTtJQUUzQ0E7O09BRUdBO0lBQ1dBLDRCQUFRQSxHQUFVQSxVQUFVQSxDQUFDQTtJQUM1Q0EsMEJBQUNBO0FBQURBLENBWEEsQUFXQ0EsSUFBQTtBQUVELEFBQTZCLGlCQUFwQixtQkFBbUIsQ0FBQyIsImZpbGUiOiJhbmltYXRvcnMvZGF0YS9WZXJ0ZXhBbmltYXRpb25Nb2RlLmpzIiwic291cmNlUm9vdCI6Ii9Vc2Vycy9yb2JiYXRlbWFuL1dlYnN0b3JtUHJvamVjdHMvYXdheWpzLXJlbmRlcmVyZ2wvIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBPcHRpb25zIGZvciBzZXR0aW5nIHRoZSBhbmltYXRpb24gbW9kZSBvZiBhIHZlcnRleCBhbmltYXRvciBvYmplY3QuXG4gKlxuICogQHNlZSBhd2F5LmFuaW1hdG9ycy5WZXJ0ZXhBbmltYXRvclxuICovXG5jbGFzcyBWZXJ0ZXhBbmltYXRpb25Nb2RlXG57XG5cdC8qKlxuXHQgKiBBbmltYXRpb24gbW9kZSB0aGF0IGFkZHMgYWxsIG91dHB1dHMgZnJvbSBhY3RpdmUgdmVydGV4IGFuaW1hdGlvbiBzdGF0ZSB0byBmb3JtIHRoZSBjdXJyZW50IHZlcnRleCBhbmltYXRpb24gcG9zZS5cblx0ICovXG5cdHB1YmxpYyBzdGF0aWMgQURESVRJVkU6c3RyaW5nID0gXCJhZGRpdGl2ZVwiO1xuXG5cdC8qKlxuXHQgKiBBbmltYXRpb24gbW9kZSB0aGF0IHBpY2tzIHRoZSBvdXRwdXQgZnJvbSBhIHNpbmdsZSB2ZXJ0ZXggYW5pbWF0aW9uIHN0YXRlIHRvIGZvcm0gdGhlIGN1cnJlbnQgdmVydGV4IGFuaW1hdGlvbiBwb3NlLlxuXHQgKi9cblx0cHVibGljIHN0YXRpYyBBQlNPTFVURTpzdHJpbmcgPSBcImFic29sdXRlXCI7XG59XG5cbmV4cG9ydCA9IFZlcnRleEFuaW1hdGlvbk1vZGU7Il19 \ No newline at end of file diff --git a/lib/animators/data/VertexAnimationMode.ts b/lib/animators/data/VertexAnimationMode.ts new file mode 100644 index 000000000..c188e10a3 --- /dev/null +++ b/lib/animators/data/VertexAnimationMode.ts @@ -0,0 +1,19 @@ +/** + * Options for setting the animation mode of a vertex animator object. + * + * @see away.animators.VertexAnimator + */ +class VertexAnimationMode +{ + /** + * Animation mode that adds all outputs from active vertex animation state to form the current vertex animation pose. + */ + public static ADDITIVE:string = "additive"; + + /** + * Animation mode that picks the output from a single vertex animation state to form the current vertex animation pose. + */ + public static ABSOLUTE:string = "absolute"; +} + +export = VertexAnimationMode; \ No newline at end of file diff --git a/lib/animators/nodes/AnimationClipNodeBase.js b/lib/animators/nodes/AnimationClipNodeBase.js new file mode 100755 index 000000000..279920229 --- /dev/null +++ b/lib/animators/nodes/AnimationClipNodeBase.js @@ -0,0 +1,116 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +/** + * Provides an abstract base class for nodes with time-based animation data in an animation blend tree. + */ +var AnimationClipNodeBase = (function (_super) { + __extends(AnimationClipNodeBase, _super); + /** + * Creates a new AnimationClipNodeBase object. + */ + function AnimationClipNodeBase() { + _super.call(this); + this._pLooping = true; + this._pTotalDuration = 0; + this._pStitchDirty = true; + this._pStitchFinalFrame = false; + this._pNumFrames = 0; + this._pDurations = new Array(); + /*uint*/ + this._pTotalDelta = new Vector3D(); + this.fixedFrameRate = true; + } + Object.defineProperty(AnimationClipNodeBase.prototype, "looping", { + /** + * Determines whether the contents of the animation node have looping characteristics enabled. + */ + get: function () { + return this._pLooping; + }, + set: function (value) { + if (this._pLooping == value) + return; + this._pLooping = value; + this._pStitchDirty = true; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationClipNodeBase.prototype, "stitchFinalFrame", { + /** + * Defines if looping content blends the final frame of animation data with the first (true) or works on the + * assumption that both first and last frames are identical (false). Defaults to false. + */ + get: function () { + return this._pStitchFinalFrame; + }, + set: function (value) { + if (this._pStitchFinalFrame == value) + return; + this._pStitchFinalFrame = value; + this._pStitchDirty = true; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationClipNodeBase.prototype, "totalDuration", { + get: function () { + if (this._pStitchDirty) + this._pUpdateStitch(); + return this._pTotalDuration; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationClipNodeBase.prototype, "totalDelta", { + get: function () { + if (this._pStitchDirty) + this._pUpdateStitch(); + return this._pTotalDelta; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationClipNodeBase.prototype, "lastFrame", { + get: function () { + if (this._pStitchDirty) + this._pUpdateStitch(); + return this._pLastFrame; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationClipNodeBase.prototype, "durations", { + /** + * Returns a vector of time values representing the duration (in milliseconds) of each animation frame in the clip. + */ + get: function () { + return this._pDurations; + }, + enumerable: true, + configurable: true + }); + /** + * Updates the node's final frame stitch state. + * + * @see #stitchFinalFrame + */ + AnimationClipNodeBase.prototype._pUpdateStitch = function () { + this._pStitchDirty = false; + this._pLastFrame = (this._pStitchFinalFrame) ? this._pNumFrames : this._pNumFrames - 1; + this._pTotalDuration = 0; + this._pTotalDelta.x = 0; + this._pTotalDelta.y = 0; + this._pTotalDelta.z = 0; + }; + return AnimationClipNodeBase; +})(AnimationNodeBase); +module.exports = AnimationClipNodeBase; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/AnimationClipNodeBase.ts b/lib/animators/nodes/AnimationClipNodeBase.ts new file mode 100644 index 000000000..a6933746a --- /dev/null +++ b/lib/animators/nodes/AnimationClipNodeBase.ts @@ -0,0 +1,118 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +/** + * Provides an abstract base class for nodes with time-based animation data in an animation blend tree. + */ +class AnimationClipNodeBase extends AnimationNodeBase +{ + public _pLooping:boolean = true; + public _pTotalDuration:number /*uint*/ = 0; + public _pLastFrame:number /*uint*/; + + public _pStitchDirty:boolean = true; + public _pStitchFinalFrame:boolean = false; + public _pNumFrames:number /*uint*/ = 0; + + public _pDurations:Array = new Array(); + /*uint*/ + public _pTotalDelta:Vector3D = new Vector3D(); + + public fixedFrameRate:boolean = true; + + /** + * Determines whether the contents of the animation node have looping characteristics enabled. + */ + public get looping():boolean + { + return this._pLooping; + } + + public set looping(value:boolean) + { + if (this._pLooping == value) + return; + + this._pLooping = value; + + this._pStitchDirty = true; + } + + /** + * Defines if looping content blends the final frame of animation data with the first (true) or works on the + * assumption that both first and last frames are identical (false). Defaults to false. + */ + public get stitchFinalFrame():boolean + { + return this._pStitchFinalFrame; + } + + public set stitchFinalFrame(value:boolean) + { + if (this._pStitchFinalFrame == value) + return; + + this._pStitchFinalFrame = value; + + this._pStitchDirty = true; + } + + public get totalDuration():number /*uint*/ + { + if (this._pStitchDirty) + this._pUpdateStitch(); + + return this._pTotalDuration; + } + + public get totalDelta():Vector3D + { + if (this._pStitchDirty) + this._pUpdateStitch(); + + return this._pTotalDelta; + } + + public get lastFrame():number /*uint*/ + { + if (this._pStitchDirty) + this._pUpdateStitch(); + + return this._pLastFrame; + } + + /** + * Returns a vector of time values representing the duration (in milliseconds) of each animation frame in the clip. + */ + public get durations():Array /*uint*/ + { + return this._pDurations; + } + + /** + * Creates a new AnimationClipNodeBase object. + */ + constructor() + { + super(); + } + + /** + * Updates the node's final frame stitch state. + * + * @see #stitchFinalFrame + */ + public _pUpdateStitch() + { + this._pStitchDirty = false; + + this._pLastFrame = (this._pStitchFinalFrame)? this._pNumFrames : this._pNumFrames - 1; + + this._pTotalDuration = 0; + this._pTotalDelta.x = 0; + this._pTotalDelta.y = 0; + this._pTotalDelta.z = 0; + } +} + +export = AnimationClipNodeBase; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleAccelerationNode.js b/lib/animators/nodes/ParticleAccelerationNode.js new file mode 100755 index 000000000..5b4c1adfd --- /dev/null +++ b/lib/animators/nodes/ParticleAccelerationNode.js @@ -0,0 +1,73 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleAccelerationState = require("awayjs-renderergl/lib/animators/states/ParticleAccelerationState"); +/** + * A particle animation node used to apply a constant acceleration vector to the motion of a particle. + */ +var ParticleAccelerationNode = (function (_super) { + __extends(ParticleAccelerationNode, _super); + /** + * Creates a new ParticleAccelerationNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] acceleration Defines the default acceleration vector of the node, used when in global mode. + */ + function ParticleAccelerationNode(mode /*uint*/, acceleration) { + if (acceleration === void 0) { acceleration = null; } + _super.call(this, "ParticleAcceleration", mode, 3); + this._pStateClass = ParticleAccelerationState; + this._acceleration = acceleration || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticleAccelerationNode.prototype.pGetAGALVertexCode = function (shaderObject, animationRegisterCache) { + var accelerationValue = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleAccelerationState.ACCELERATION_INDEX, accelerationValue.index); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp, 1); + var code = "mul " + temp + "," + animationRegisterCache.vertexTime + "," + accelerationValue + "\n"; + if (animationRegisterCache.needVelocity) { + var temp2 = animationRegisterCache.getFreeVertexVectorTemp(); + code += "mul " + temp2 + "," + temp + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + temp2 + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + } + animationRegisterCache.removeVertexTempUsage(temp); + code += "mul " + temp + "," + temp + "," + animationRegisterCache.vertexTime + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + temp + "," + animationRegisterCache.positionTarget + ".xyz\n"; + return code; + }; + /** + * @inheritDoc + */ + ParticleAccelerationNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleAccelerationNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var tempAcceleration = param[ParticleAccelerationNode.ACCELERATION_VECTOR3D]; + if (!tempAcceleration) + throw new Error("there is no " + ParticleAccelerationNode.ACCELERATION_VECTOR3D + " in param!"); + this._pOneData[0] = tempAcceleration.x / 2; + this._pOneData[1] = tempAcceleration.y / 2; + this._pOneData[2] = tempAcceleration.z / 2; + }; + /** + * Reference for acceleration node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the direction of acceleration on the particle. + */ + ParticleAccelerationNode.ACCELERATION_VECTOR3D = "AccelerationVector3D"; + return ParticleAccelerationNode; +})(ParticleNodeBase); +module.exports = ParticleAccelerationNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particleaccelerationnode.ts"],"names":["ParticleAccelerationNode","ParticleAccelerationNode.constructor","ParticleAccelerationNode.pGetAGALVertexCode","ParticleAccelerationNode.getAnimationState","ParticleAccelerationNode._iGeneratePropertyOfOneParticle"],"mappings":";;;;;;AAAA,IAAO,QAAQ,WAAiB,oCAAoC,CAAC,CAAC;AAQtE,IAAO,sBAAsB,WAAa,6DAA6D,CAAC,CAAC;AACzG,IAAO,gBAAgB,WAAe,wDAAwD,CAAC,CAAC;AAChG,IAAO,yBAAyB,WAAY,kEAAkE,CAAC,CAAC;AAEhH,AAGA;;GADG;IACG,wBAAwB;IAASA,UAAjCA,wBAAwBA,UAAyBA;IAWtDA;;;;;OAKGA;IACHA,SAjBKA,wBAAwBA,CAiBjBA,IAAIA,CAAQA,QAADA,AAASA,EAAEA,YAA4BA;QAA5BC,4BAA4BA,GAA5BA,mBAA4BA;QAE7DA,kBAAMA,sBAAsBA,EAAEA,IAAIA,EAAEA,CAACA,CAACA,CAACA;QAEvCA,IAAIA,CAACA,YAAYA,GAAGA,yBAAyBA,CAACA;QAE9CA,IAAIA,CAACA,aAAaA,GAAGA,YAAYA,IAAIA,IAAIA,QAAQA,EAAEA,CAACA;IACrDA,CAACA;IAEDD;;OAEGA;IACIA,qDAAkBA,GAAzBA,UAA0BA,YAA6BA,EAAEA,sBAA6CA;QAErGE,IAAIA,iBAAiBA,GAAyBA,CAACA,IAAIA,CAACA,MAAMA,IAAIA,sBAAsBA,CAACA,MAAMA,CAACA,GAAEA,sBAAsBA,CAACA,qBAAqBA,EAAEA,GAAGA,sBAAsBA,CAACA,sBAAsBA,EAAEA,CAACA;QAC/LA,sBAAsBA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,yBAAyBA,CAACA,kBAAkBA,EAAEA,iBAAiBA,CAACA,KAAKA,CAACA,CAACA;QAErHA,IAAIA,IAAIA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;QAClFA,sBAAsBA,CAACA,mBAAmBA,CAACA,IAAIA,EAAEA,CAACA,CAACA,CAACA;QAEpDA,IAAIA,IAAIA,GAAUA,MAAMA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,UAAUA,GAAGA,GAAGA,GAAGA,iBAAiBA,GAAGA,IAAIA,CAACA;QAE3GA,EAAEA,CAACA,CAACA,sBAAsBA,CAACA,YAAYA,CAACA,CAACA,CAACA;YACzCA,IAAIA,KAAKA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;YACnFA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,IAAIA,CAACA;YACzFA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,OAAOA,GAAGA,KAAKA,GAAGA,OAAOA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,QAAQA,CAACA;QACvIA,CAACA;QACDA,sBAAsBA,CAACA,qBAAqBA,CAACA,IAAIA,CAACA,CAACA;QAEnDA,IAAIA,IAAIA,MAAMA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,UAAUA,GAAGA,IAAIA,CAACA;QACpFA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,OAAOA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,QAAQA,CAACA;QACjIA,MAAMA,CAACA,IAAIA,CAACA;IACbA,CAACA;IAEDF;;OAEGA;IACIA,oDAAiBA,GAAxBA,UAAyBA,QAAqBA;QAE7CG,MAAMA,CAA6BA,QAAQA,CAACA,iBAAiBA,CAACA,IAAIA,CAACA,CAACA;IACrEA,CAACA;IAEDH;;OAEGA;IACIA,kEAA+BA,GAAtCA,UAAuCA,KAAwBA;QAE9DI,IAAIA,gBAAgBA,GAAYA,KAAKA,CAACA,wBAAwBA,CAACA,qBAAqBA,CAACA,CAACA;QACtFA,EAAEA,CAACA,CAACA,CAACA,gBAAgBA,CAACA;YACrBA,MAAMA,IAAIA,KAAKA,CAACA,cAAcA,GAAGA,wBAAwBA,CAACA,qBAAqBA,GAAGA,YAAYA,CAACA,CAACA;QAEjGA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,gBAAgBA,CAACA,CAACA,GAACA,CAACA,CAACA;QACzCA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,gBAAgBA,CAACA,CAACA,GAACA,CAACA,CAACA;QACzCA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,gBAAgBA,CAACA,CAACA,GAACA,CAACA,CAACA;IAC1CA,CAACA;IAlEDJ;;;OAGGA;IACWA,8CAAqBA,GAAUA,sBAAsBA,CAACA;IA+DrEA,+BAACA;AAADA,CAxEA,AAwECA,EAxEsC,gBAAgB,EAwEtD;AAED,AAAkC,iBAAzB,wBAAwB,CAAC","file":"animators/nodes/ParticleAccelerationNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleAccelerationState\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleAccelerationState\");\n\n/**\n * A particle animation node used to apply a constant acceleration vector to the motion of a particle.\n */\nclass ParticleAccelerationNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _acceleration:Vector3D;\n\n\t/**\n\t * Reference for acceleration node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the direction of acceleration on the particle.\n\t */\n\tpublic static ACCELERATION_VECTOR3D:string = \"AccelerationVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleAccelerationNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] acceleration    Defines the default acceleration vector of the node, used when in global mode.\n\t */\n\tconstructor(mode:number /*uint*/, acceleration:Vector3D = null)\n\t{\n\t\tsuper(\"ParticleAcceleration\", mode, 3);\n\n\t\tthis._pStateClass = ParticleAccelerationState;\n\n\t\tthis._acceleration = acceleration || new Vector3D();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic pGetAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar accelerationValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleAccelerationState.ACCELERATION_INDEX, accelerationValue.index);\n\n\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tanimationRegisterCache.addVertexTempUsages(temp, 1);\n\n\t\tvar code:string = \"mul \" + temp + \",\" + animationRegisterCache.vertexTime + \",\" + accelerationValue + \"\\n\";\n\n\t\tif (animationRegisterCache.needVelocity) {\n\t\t\tvar temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tcode += \"mul \" + temp2 + \",\" + temp + \",\" + animationRegisterCache.vertexTwoConst + \"\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.velocityTarget + \".xyz,\" + temp2 + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz\\n\";\n\t\t}\n\t\tanimationRegisterCache.removeVertexTempUsage(temp);\n\n\t\tcode += \"mul \" + temp + \",\" + temp + \",\" + animationRegisterCache.vertexTime + \"\\n\";\n\t\tcode += \"add \" + animationRegisterCache.positionTarget + \".xyz,\" + temp + \",\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleAccelerationState\n\t{\n\t\treturn <ParticleAccelerationState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tvar tempAcceleration:Vector3D = param[ParticleAccelerationNode.ACCELERATION_VECTOR3D];\n\t\tif (!tempAcceleration)\n\t\t\tthrow new Error(\"there is no \" + ParticleAccelerationNode.ACCELERATION_VECTOR3D + \" in param!\");\n\n\t\tthis._pOneData[0] = tempAcceleration.x/2;\n\t\tthis._pOneData[1] = tempAcceleration.y/2;\n\t\tthis._pOneData[2] = tempAcceleration.z/2;\n\t}\n}\n\nexport = ParticleAccelerationNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleAccelerationNode.ts b/lib/animators/nodes/ParticleAccelerationNode.ts new file mode 100644 index 000000000..06894ea4f --- /dev/null +++ b/lib/animators/nodes/ParticleAccelerationNode.ts @@ -0,0 +1,90 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleAccelerationState = require("awayjs-renderergl/lib/animators/states/ParticleAccelerationState"); + +/** + * A particle animation node used to apply a constant acceleration vector to the motion of a particle. + */ +class ParticleAccelerationNode extends ParticleNodeBase +{ + /** @private */ + public _acceleration:Vector3D; + + /** + * Reference for acceleration node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the direction of acceleration on the particle. + */ + public static ACCELERATION_VECTOR3D:string = "AccelerationVector3D"; + + /** + * Creates a new ParticleAccelerationNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] acceleration Defines the default acceleration vector of the node, used when in global mode. + */ + constructor(mode:number /*uint*/, acceleration:Vector3D = null) + { + super("ParticleAcceleration", mode, 3); + + this._pStateClass = ParticleAccelerationState; + + this._acceleration = acceleration || new Vector3D(); + } + + /** + * @inheritDoc + */ + public pGetAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var accelerationValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleAccelerationState.ACCELERATION_INDEX, accelerationValue.index); + + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp, 1); + + var code:string = "mul " + temp + "," + animationRegisterCache.vertexTime + "," + accelerationValue + "\n"; + + if (animationRegisterCache.needVelocity) { + var temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + code += "mul " + temp2 + "," + temp + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + temp2 + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + } + animationRegisterCache.removeVertexTempUsage(temp); + + code += "mul " + temp + "," + temp + "," + animationRegisterCache.vertexTime + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + temp + "," + animationRegisterCache.positionTarget + ".xyz\n"; + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleAccelerationState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var tempAcceleration:Vector3D = param[ParticleAccelerationNode.ACCELERATION_VECTOR3D]; + if (!tempAcceleration) + throw new Error("there is no " + ParticleAccelerationNode.ACCELERATION_VECTOR3D + " in param!"); + + this._pOneData[0] = tempAcceleration.x/2; + this._pOneData[1] = tempAcceleration.y/2; + this._pOneData[2] = tempAcceleration.z/2; + } +} + +export = ParticleAccelerationNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleBezierCurveNode.js b/lib/animators/nodes/ParticleBezierCurveNode.js new file mode 100755 index 000000000..5600fb9f9 --- /dev/null +++ b/lib/animators/nodes/ParticleBezierCurveNode.js @@ -0,0 +1,105 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleBezierCurveState = require("awayjs-renderergl/lib/animators/states/ParticleBezierCurveState"); +/** + * A particle animation node used to control the position of a particle over time along a bezier curve. + */ +var ParticleBezierCurveNode = (function (_super) { + __extends(ParticleBezierCurveNode, _super); + /** + * Creates a new ParticleBezierCurveNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] controlPoint Defines the default control point of the node, used when in global mode. + * @param [optional] endPoint Defines the default end point of the node, used when in global mode. + */ + function ParticleBezierCurveNode(mode /*uint*/, controlPoint, endPoint) { + if (controlPoint === void 0) { controlPoint = null; } + if (endPoint === void 0) { endPoint = null; } + _super.call(this, "ParticleBezierCurve", mode, 6); + this._pStateClass = ParticleBezierCurveState; + this._iControlPoint = controlPoint || new Vector3D(); + this._iEndPoint = endPoint || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticleBezierCurveNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var controlValue = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleBezierCurveState.BEZIER_CONTROL_INDEX, controlValue.index); + var endValue = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleBezierCurveState.BEZIER_END_INDEX, endValue.index); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + var rev_time = new ShaderRegisterElement(temp.regName, temp.index, 0); + var time_2 = new ShaderRegisterElement(temp.regName, temp.index, 1); + var time_temp = new ShaderRegisterElement(temp.regName, temp.index, 2); + animationRegisterCache.addVertexTempUsages(temp, 1); + var temp2 = animationRegisterCache.getFreeVertexVectorTemp(); + var distance = new ShaderRegisterElement(temp2.regName, temp2.index); + animationRegisterCache.removeVertexTempUsage(temp); + var code = ""; + code += "sub " + rev_time + "," + animationRegisterCache.vertexOneConst + "," + animationRegisterCache.vertexLife + "\n"; + code += "mul " + time_2 + "," + animationRegisterCache.vertexLife + "," + animationRegisterCache.vertexLife + "\n"; + code += "mul " + time_temp + "," + animationRegisterCache.vertexLife + "," + rev_time + "\n"; + code += "mul " + time_temp + "," + time_temp + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "mul " + distance + ".xyz," + time_temp + "," + controlValue + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "mul " + distance + ".xyz," + time_2 + "," + endValue + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + if (animationRegisterCache.needVelocity) { + code += "mul " + time_2 + "," + animationRegisterCache.vertexLife + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sub " + time_temp + "," + animationRegisterCache.vertexOneConst + "," + time_2 + "\n"; + code += "mul " + time_temp + "," + animationRegisterCache.vertexTwoConst + "," + time_temp + "\n"; + code += "mul " + distance + ".xyz," + controlValue + "," + time_temp + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + code += "mul " + distance + ".xyz," + endValue + "," + time_2 + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + } + return code; + }; + /** + * @inheritDoc + */ + ParticleBezierCurveNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleBezierCurveNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var bezierControl = param[ParticleBezierCurveNode.BEZIER_CONTROL_VECTOR3D]; + if (!bezierControl) + throw new Error("there is no " + ParticleBezierCurveNode.BEZIER_CONTROL_VECTOR3D + " in param!"); + var bezierEnd = param[ParticleBezierCurveNode.BEZIER_END_VECTOR3D]; + if (!bezierEnd) + throw new Error("there is no " + ParticleBezierCurveNode.BEZIER_END_VECTOR3D + " in param!"); + this._pOneData[0] = bezierControl.x; + this._pOneData[1] = bezierControl.y; + this._pOneData[2] = bezierControl.z; + this._pOneData[3] = bezierEnd.x; + this._pOneData[4] = bezierEnd.y; + this._pOneData[5] = bezierEnd.z; + }; + /** + * Reference for bezier curve node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the control point position (0, 1, 2) of the curve. + */ + ParticleBezierCurveNode.BEZIER_CONTROL_VECTOR3D = "BezierControlVector3D"; + /** + * Reference for bezier curve node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the end point position (0, 1, 2) of the curve. + */ + ParticleBezierCurveNode.BEZIER_END_VECTOR3D = "BezierEndVector3D"; + return ParticleBezierCurveNode; +})(ParticleNodeBase); +module.exports = ParticleBezierCurveNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlebeziercurvenode.ts"],"names":["ParticleBezierCurveNode","ParticleBezierCurveNode.constructor","ParticleBezierCurveNode.getAGALVertexCode","ParticleBezierCurveNode.getAnimationState","ParticleBezierCurveNode._iGeneratePropertyOfOneParticle"],"mappings":"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","file":"animators/nodes/ParticleBezierCurveNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleBezierCurveState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleBezierCurveState\");\n\n/**\n * A particle animation node used to control the position of a particle over time along a bezier curve.\n */\nclass ParticleBezierCurveNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iControlPoint:Vector3D;\n\t/** @private */\n\tpublic _iEndPoint:Vector3D;\n\n\t/**\n\t * Reference for bezier curve node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the control point position (0, 1, 2) of the curve.\n\t */\n\tpublic static BEZIER_CONTROL_VECTOR3D:string = \"BezierControlVector3D\";\n\n\t/**\n\t * Reference for bezier curve node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the end point position (0, 1, 2) of the curve.\n\t */\n\tpublic static BEZIER_END_VECTOR3D:string = \"BezierEndVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleBezierCurveNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] controlPoint    Defines the default control point of the node, used when in global mode.\n\t * @param    [optional] endPoint        Defines the default end point of the node, used when in global mode.\n\t */\n\tconstructor(mode:number /*uint*/, controlPoint:Vector3D = null, endPoint:Vector3D = null)\n\t{\n\t\tsuper(\"ParticleBezierCurve\", mode, 6);\n\n\t\tthis._pStateClass = ParticleBezierCurveState;\n\n\t\tthis._iControlPoint = controlPoint || new Vector3D();\n\t\tthis._iEndPoint = endPoint || new Vector3D();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar controlValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleBezierCurveState.BEZIER_CONTROL_INDEX, controlValue.index);\n\n\t\tvar endValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleBezierCurveState.BEZIER_END_INDEX, endValue.index);\n\n\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tvar rev_time:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0);\n\t\tvar time_2:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1);\n\t\tvar time_temp:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 2);\n\t\tanimationRegisterCache.addVertexTempUsages(temp, 1);\n\t\tvar temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tvar distance:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index);\n\t\tanimationRegisterCache.removeVertexTempUsage(temp);\n\n\t\tvar code:string = \"\";\n\t\tcode += \"sub \" + rev_time + \",\" + animationRegisterCache.vertexOneConst + \",\" + animationRegisterCache.vertexLife + \"\\n\";\n\t\tcode += \"mul \" + time_2 + \",\" + animationRegisterCache.vertexLife + \",\" + animationRegisterCache.vertexLife + \"\\n\";\n\n\t\tcode += \"mul \" + time_temp + \",\" + animationRegisterCache.vertexLife + \",\" + rev_time + \"\\n\";\n\t\tcode += \"mul \" + time_temp + \",\" + time_temp + \",\" + animationRegisterCache.vertexTwoConst + \"\\n\";\n\t\tcode += \"mul \" + distance + \".xyz,\" + time_temp + \",\" + controlValue + \"\\n\";\n\t\tcode += \"add \" + animationRegisterCache.positionTarget + \".xyz,\" + distance + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\t\tcode += \"mul \" + distance + \".xyz,\" + time_2 + \",\" + endValue + \"\\n\";\n\t\tcode += \"add \" + animationRegisterCache.positionTarget + \".xyz,\" + distance + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\n\t\tif (animationRegisterCache.needVelocity) {\n\t\t\tcode += \"mul \" + time_2 + \",\" + animationRegisterCache.vertexLife + \",\" + animationRegisterCache.vertexTwoConst + \"\\n\";\n\t\t\tcode += \"sub \" + time_temp + \",\" + animationRegisterCache.vertexOneConst + \",\" + time_2 + \"\\n\";\n\t\t\tcode += \"mul \" + time_temp + \",\" + animationRegisterCache.vertexTwoConst + \",\" + time_temp + \"\\n\";\n\t\t\tcode += \"mul \" + distance + \".xyz,\" + controlValue + \",\" + time_temp + \"\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.velocityTarget + \".xyz,\" + distance + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz\\n\";\n\t\t\tcode += \"mul \" + distance + \".xyz,\" + endValue + \",\" + time_2 + \"\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.velocityTarget + \".xyz,\" + distance + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz\\n\";\n\t\t}\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleBezierCurveState\n\t{\n\t\treturn <ParticleBezierCurveState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tvar bezierControl:Vector3D = param[ParticleBezierCurveNode.BEZIER_CONTROL_VECTOR3D];\n\t\tif (!bezierControl)\n\t\t\tthrow new Error(\"there is no \" + ParticleBezierCurveNode.BEZIER_CONTROL_VECTOR3D + \" in param!\");\n\n\t\tvar bezierEnd:Vector3D = param[ParticleBezierCurveNode.BEZIER_END_VECTOR3D];\n\t\tif (!bezierEnd)\n\t\t\tthrow new Error(\"there is no \" + ParticleBezierCurveNode.BEZIER_END_VECTOR3D + \" in param!\");\n\n\t\tthis._pOneData[0] = bezierControl.x;\n\t\tthis._pOneData[1] = bezierControl.y;\n\t\tthis._pOneData[2] = bezierControl.z;\n\t\tthis._pOneData[3] = bezierEnd.x;\n\t\tthis._pOneData[4] = bezierEnd.y;\n\t\tthis._pOneData[5] = bezierEnd.z;\n\t}\n}\n\nexport = ParticleBezierCurveNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleBezierCurveNode.ts b/lib/animators/nodes/ParticleBezierCurveNode.ts new file mode 100644 index 000000000..fffadb4ba --- /dev/null +++ b/lib/animators/nodes/ParticleBezierCurveNode.ts @@ -0,0 +1,126 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleBezierCurveState = require("awayjs-renderergl/lib/animators/states/ParticleBezierCurveState"); + +/** + * A particle animation node used to control the position of a particle over time along a bezier curve. + */ +class ParticleBezierCurveNode extends ParticleNodeBase +{ + /** @private */ + public _iControlPoint:Vector3D; + /** @private */ + public _iEndPoint:Vector3D; + + /** + * Reference for bezier curve node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the control point position (0, 1, 2) of the curve. + */ + public static BEZIER_CONTROL_VECTOR3D:string = "BezierControlVector3D"; + + /** + * Reference for bezier curve node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the end point position (0, 1, 2) of the curve. + */ + public static BEZIER_END_VECTOR3D:string = "BezierEndVector3D"; + + /** + * Creates a new ParticleBezierCurveNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] controlPoint Defines the default control point of the node, used when in global mode. + * @param [optional] endPoint Defines the default end point of the node, used when in global mode. + */ + constructor(mode:number /*uint*/, controlPoint:Vector3D = null, endPoint:Vector3D = null) + { + super("ParticleBezierCurve", mode, 6); + + this._pStateClass = ParticleBezierCurveState; + + this._iControlPoint = controlPoint || new Vector3D(); + this._iEndPoint = endPoint || new Vector3D(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var controlValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleBezierCurveState.BEZIER_CONTROL_INDEX, controlValue.index); + + var endValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleBezierCurveState.BEZIER_END_INDEX, endValue.index); + + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var rev_time:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0); + var time_2:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1); + var time_temp:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 2); + animationRegisterCache.addVertexTempUsages(temp, 1); + var temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var distance:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index); + animationRegisterCache.removeVertexTempUsage(temp); + + var code:string = ""; + code += "sub " + rev_time + "," + animationRegisterCache.vertexOneConst + "," + animationRegisterCache.vertexLife + "\n"; + code += "mul " + time_2 + "," + animationRegisterCache.vertexLife + "," + animationRegisterCache.vertexLife + "\n"; + + code += "mul " + time_temp + "," + animationRegisterCache.vertexLife + "," + rev_time + "\n"; + code += "mul " + time_temp + "," + time_temp + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "mul " + distance + ".xyz," + time_temp + "," + controlValue + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "mul " + distance + ".xyz," + time_2 + "," + endValue + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + + if (animationRegisterCache.needVelocity) { + code += "mul " + time_2 + "," + animationRegisterCache.vertexLife + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sub " + time_temp + "," + animationRegisterCache.vertexOneConst + "," + time_2 + "\n"; + code += "mul " + time_temp + "," + animationRegisterCache.vertexTwoConst + "," + time_temp + "\n"; + code += "mul " + distance + ".xyz," + controlValue + "," + time_temp + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + code += "mul " + distance + ".xyz," + endValue + "," + time_2 + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + } + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleBezierCurveState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var bezierControl:Vector3D = param[ParticleBezierCurveNode.BEZIER_CONTROL_VECTOR3D]; + if (!bezierControl) + throw new Error("there is no " + ParticleBezierCurveNode.BEZIER_CONTROL_VECTOR3D + " in param!"); + + var bezierEnd:Vector3D = param[ParticleBezierCurveNode.BEZIER_END_VECTOR3D]; + if (!bezierEnd) + throw new Error("there is no " + ParticleBezierCurveNode.BEZIER_END_VECTOR3D + " in param!"); + + this._pOneData[0] = bezierControl.x; + this._pOneData[1] = bezierControl.y; + this._pOneData[2] = bezierControl.z; + this._pOneData[3] = bezierEnd.x; + this._pOneData[4] = bezierEnd.y; + this._pOneData[5] = bezierEnd.z; + } +} + +export = ParticleBezierCurveNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleBillboardNode.js b/lib/animators/nodes/ParticleBillboardNode.js new file mode 100755 index 000000000..4042e0be2 --- /dev/null +++ b/lib/animators/nodes/ParticleBillboardNode.js @@ -0,0 +1,58 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleBillboardState = require("awayjs-renderergl/lib/animators/states/ParticleBillboardState"); +/** + * A particle animation node that controls the rotation of a particle to always face the camera. + */ +var ParticleBillboardNode = (function (_super) { + __extends(ParticleBillboardNode, _super); + /** + * Creates a new ParticleBillboardNode + */ + function ParticleBillboardNode(billboardAxis) { + if (billboardAxis === void 0) { billboardAxis = null; } + _super.call(this, "ParticleBillboard", ParticlePropertiesMode.GLOBAL, 0, 4); + this._pStateClass = ParticleBillboardState; + this._iBillboardAxis = billboardAxis; + } + /** + * @inheritDoc + */ + ParticleBillboardNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var rotationMatrixRegister = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleBillboardState.MATRIX_INDEX, rotationMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + var code = "m33 " + temp + ".xyz," + animationRegisterCache.scaleAndRotateTarget + "," + rotationMatrixRegister + "\n" + "mov " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp + "\n"; + var shaderRegisterElement; + for (var i = 0; i < animationRegisterCache.rotationRegisters.length; i++) { + shaderRegisterElement = animationRegisterCache.rotationRegisters[i]; + code += "m33 " + temp + ".xyz," + shaderRegisterElement + "," + rotationMatrixRegister + "\n" + "mov " + shaderRegisterElement + ".xyz," + shaderRegisterElement + "\n"; + } + return code; + }; + /** + * @inheritDoc + */ + ParticleBillboardNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleBillboardNode.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + particleAnimationSet.hasBillboard = true; + }; + return ParticleBillboardNode; +})(ParticleNodeBase); +module.exports = ParticleBillboardNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/ParticleBillboardNode.ts b/lib/animators/nodes/ParticleBillboardNode.ts new file mode 100644 index 000000000..b8db77ea3 --- /dev/null +++ b/lib/animators/nodes/ParticleBillboardNode.ts @@ -0,0 +1,77 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleBillboardState = require("awayjs-renderergl/lib/animators/states/ParticleBillboardState"); + +/** + * A particle animation node that controls the rotation of a particle to always face the camera. + */ +class ParticleBillboardNode extends ParticleNodeBase +{ + /** @private */ + public _iBillboardAxis:Vector3D; + + /** + * Creates a new ParticleBillboardNode + */ + constructor(billboardAxis:Vector3D = null) + { + super("ParticleBillboard", ParticlePropertiesMode.GLOBAL, 0, 4); + + this._pStateClass = ParticleBillboardState; + + this._iBillboardAxis = billboardAxis; + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var rotationMatrixRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleBillboardState.MATRIX_INDEX, rotationMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + + var code:string = "m33 " + temp + ".xyz," + animationRegisterCache.scaleAndRotateTarget + "," + rotationMatrixRegister + "\n" + + "mov " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp + "\n"; + + var shaderRegisterElement:ShaderRegisterElement; + for (var i:number /*uint*/ = 0; i < animationRegisterCache.rotationRegisters.length; i++) { + shaderRegisterElement = animationRegisterCache.rotationRegisters[i]; + code += "m33 " + temp + ".xyz," + shaderRegisterElement + "," + rotationMatrixRegister + "\n" + + "mov " + shaderRegisterElement + ".xyz," + shaderRegisterElement + "\n"; + } + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleBillboardState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + particleAnimationSet.hasBillboard = true; + } +} + +export = ParticleBillboardNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleColorNode.js b/lib/animators/nodes/ParticleColorNode.js new file mode 100755 index 000000000..e667d1d3d --- /dev/null +++ b/lib/animators/nodes/ParticleColorNode.js @@ -0,0 +1,178 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +var ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleColorState = require("awayjs-renderergl/lib/animators/states/ParticleColorState"); +/** + * A particle animation node used to control the color variation of a particle over time. + */ +var ParticleColorNode = (function (_super) { + __extends(ParticleColorNode, _super); + /** + * Creates a new ParticleColorNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] usesMultiplier Defines whether the node uses multiplier data in the shader for its color transformations. Defaults to true. + * @param [optional] usesOffset Defines whether the node uses offset data in the shader for its color transformations. Defaults to true. + * @param [optional] usesCycle Defines whether the node uses the cycleDuration property in the shader to calculate the period of the animation independent of particle duration. Defaults to false. + * @param [optional] usesPhase Defines whether the node uses the cyclePhase property in the shader to calculate a starting offset to the cycle rotation of the particle. Defaults to false. + * @param [optional] startColor Defines the default start color transform of the node, when in global mode. + * @param [optional] endColor Defines the default end color transform of the node, when in global mode. + * @param [optional] cycleDuration Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + function ParticleColorNode(mode /*uint*/, usesMultiplier, usesOffset, usesCycle, usesPhase, startColor, endColor, cycleDuration, cyclePhase) { + if (usesMultiplier === void 0) { usesMultiplier = true; } + if (usesOffset === void 0) { usesOffset = true; } + if (usesCycle === void 0) { usesCycle = false; } + if (usesPhase === void 0) { usesPhase = false; } + if (startColor === void 0) { startColor = null; } + if (endColor === void 0) { endColor = null; } + if (cycleDuration === void 0) { cycleDuration = 1; } + if (cyclePhase === void 0) { cyclePhase = 0; } + _super.call(this, "ParticleColor", mode, (usesMultiplier && usesOffset) ? 16 : 8, ParticleAnimationSet.COLOR_PRIORITY); + this._pStateClass = ParticleColorState; + this._iUsesMultiplier = usesMultiplier; + this._iUsesOffset = usesOffset; + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + this._iStartColor = startColor || new ColorTransform(); + this._iEndColor = endColor || new ColorTransform(); + this._iCycleDuration = cycleDuration; + this._iCyclePhase = cyclePhase; + } + /** + * @inheritDoc + */ + ParticleColorNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var code = ""; + if (animationRegisterCache.needFragmentAnimation) { + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + if (this._iUsesCycle) { + var cycleConst = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.CYCLE_INDEX, cycleConst.index); + animationRegisterCache.addVertexTempUsages(temp, 1); + var sin = animationRegisterCache.getFreeVertexSingleTemp(); + animationRegisterCache.removeVertexTempUsage(temp); + code += "mul " + sin + "," + animationRegisterCache.vertexTime + "," + cycleConst + ".x\n"; + if (this._iUsesPhase) + code += "add " + sin + "," + sin + "," + cycleConst + ".y\n"; + code += "sin " + sin + "," + sin + "\n"; + } + if (this._iUsesMultiplier) { + var startMultiplierValue = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + var deltaMultiplierValue = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.START_MULTIPLIER_INDEX, startMultiplierValue.index); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.DELTA_MULTIPLIER_INDEX, deltaMultiplierValue.index); + code += "mul " + temp + "," + deltaMultiplierValue + "," + (this._iUsesCycle ? sin : animationRegisterCache.vertexLife) + "\n"; + code += "add " + temp + "," + temp + "," + startMultiplierValue + "\n"; + code += "mul " + animationRegisterCache.colorMulTarget + "," + temp + "," + animationRegisterCache.colorMulTarget + "\n"; + } + if (this._iUsesOffset) { + var startOffsetValue = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC) ? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant(); + var deltaOffsetValue = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC) ? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.START_OFFSET_INDEX, startOffsetValue.index); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.DELTA_OFFSET_INDEX, deltaOffsetValue.index); + code += "mul " + temp + "," + deltaOffsetValue + "," + (this._iUsesCycle ? sin : animationRegisterCache.vertexLife) + "\n"; + code += "add " + temp + "," + temp + "," + startOffsetValue + "\n"; + code += "add " + animationRegisterCache.colorAddTarget + "," + temp + "," + animationRegisterCache.colorAddTarget + "\n"; + } + } + return code; + }; + /** + * @inheritDoc + */ + ParticleColorNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleColorNode.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + if (this._iUsesMultiplier) + particleAnimationSet.hasColorMulNode = true; + if (this._iUsesOffset) + particleAnimationSet.hasColorAddNode = true; + }; + /** + * @inheritDoc + */ + ParticleColorNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var startColor = param[ParticleColorNode.COLOR_START_COLORTRANSFORM]; + if (!startColor) + throw (new Error("there is no " + ParticleColorNode.COLOR_START_COLORTRANSFORM + " in param!")); + var endColor = param[ParticleColorNode.COLOR_END_COLORTRANSFORM]; + if (!endColor) + throw (new Error("there is no " + ParticleColorNode.COLOR_END_COLORTRANSFORM + " in param!")); + var i = 0; + if (!this._iUsesCycle) { + //multiplier + if (this._iUsesMultiplier) { + this._pOneData[i++] = startColor.redMultiplier; + this._pOneData[i++] = startColor.greenMultiplier; + this._pOneData[i++] = startColor.blueMultiplier; + this._pOneData[i++] = startColor.alphaMultiplier; + this._pOneData[i++] = endColor.redMultiplier - startColor.redMultiplier; + this._pOneData[i++] = endColor.greenMultiplier - startColor.greenMultiplier; + this._pOneData[i++] = endColor.blueMultiplier - startColor.blueMultiplier; + this._pOneData[i++] = endColor.alphaMultiplier - startColor.alphaMultiplier; + } + //offset + if (this._iUsesOffset) { + this._pOneData[i++] = startColor.redOffset / 255; + this._pOneData[i++] = startColor.greenOffset / 255; + this._pOneData[i++] = startColor.blueOffset / 255; + this._pOneData[i++] = startColor.alphaOffset / 255; + this._pOneData[i++] = (endColor.redOffset - startColor.redOffset) / 255; + this._pOneData[i++] = (endColor.greenOffset - startColor.greenOffset) / 255; + this._pOneData[i++] = (endColor.blueOffset - startColor.blueOffset) / 255; + this._pOneData[i++] = (endColor.alphaOffset - startColor.alphaOffset) / 255; + } + } + else { + //multiplier + if (this._iUsesMultiplier) { + this._pOneData[i++] = (startColor.redMultiplier + endColor.redMultiplier) / 2; + this._pOneData[i++] = (startColor.greenMultiplier + endColor.greenMultiplier) / 2; + this._pOneData[i++] = (startColor.blueMultiplier + endColor.blueMultiplier) / 2; + this._pOneData[i++] = (startColor.alphaMultiplier + endColor.alphaMultiplier) / 2; + this._pOneData[i++] = (startColor.redMultiplier - endColor.redMultiplier) / 2; + this._pOneData[i++] = (startColor.greenMultiplier - endColor.greenMultiplier) / 2; + this._pOneData[i++] = (startColor.blueMultiplier - endColor.blueMultiplier) / 2; + this._pOneData[i++] = (startColor.alphaMultiplier - endColor.alphaMultiplier) / 2; + } + //offset + if (this._iUsesOffset) { + this._pOneData[i++] = (startColor.redOffset + endColor.redOffset) / (255 * 2); + this._pOneData[i++] = (startColor.greenOffset + endColor.greenOffset) / (255 * 2); + this._pOneData[i++] = (startColor.blueOffset + endColor.blueOffset) / (255 * 2); + this._pOneData[i++] = (startColor.alphaOffset + endColor.alphaOffset) / (255 * 2); + this._pOneData[i++] = (startColor.redOffset - endColor.redOffset) / (255 * 2); + this._pOneData[i++] = (startColor.greenOffset - endColor.greenOffset) / (255 * 2); + this._pOneData[i++] = (startColor.blueOffset - endColor.blueOffset) / (255 * 2); + this._pOneData[i++] = (startColor.alphaOffset - endColor.alphaOffset) / (255 * 2); + } + } + }; + /** + * Reference for color node properties on a single particle (when in local property mode). + * Expects a ColorTransform object representing the start color transform applied to the particle. + */ + ParticleColorNode.COLOR_START_COLORTRANSFORM = "ColorStartColorTransform"; + /** + * Reference for color node properties on a single particle (when in local property mode). + * Expects a ColorTransform object representing the end color transform applied to the particle. + */ + ParticleColorNode.COLOR_END_COLORTRANSFORM = "ColorEndColorTransform"; + return ParticleColorNode; +})(ParticleNodeBase); +module.exports = ParticleColorNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlecolornode.ts"],"names":["ParticleColorNode","ParticleColorNode.constructor","ParticleColorNode.getAGALVertexCode","ParticleColorNode.getAnimationState","ParticleColorNode._iProcessAnimationSetting","ParticleColorNode._iGeneratePropertyOfOneParticle"],"mappings":"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AACA;gBAC1EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,CAACA,eAAeA,GAAGA,UAAUA,CAACA,eAAeA,CAACA;YAC7EA,CAACA;YAEDA,AACAA,QADQA;YACRA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;gBACvBA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,UAAUA,CAACA,SAASA,GAACA,GAAGA,CAACA;gBAC/CA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,UAAUA,CAACA,WAAWA,GAACA,GAAGA,CAACA;gBACjDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,UAAUA,CAACA,UAAUA,GAACA,GAAGA,CAACA;gBAChDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,UAAUA,CAACA,WAAWA,GAACA,GAAGA,CAACA;gBACjDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,QAAQA,CAACA,SAASA,GAAGA,UAAUA,CAACA,SAASA,CAACA,GAACA,GAAGA,CAACA;gBACtEA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,QAAQA,CAACA,WAAWA,GAAGA,UAAUA,CAACA,WAAWA,CAACA,GAACA,GAAGA,CAACA;gBAC1EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,QAAQA,CAACA,UAAUA,GAAGA,UAAUA,CAACA,UAAUA,CAACA,GAACA,GAAGA,CAACA;gBACxEA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,QAAQA,CAACA,WAAWA,GAAGA,UAAUA,CAACA,WAAWA,CAACA,GAACA,GAAGA,CAACA;YAC3EA,CAACA;QACFA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,AACAA,YADYA;YACZA,EAAEA,CAACA,CAACA,IAAIA,CAACA,gBAAgBA,CAACA,CAACA,CAACA;gBAC3BA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,aAAaA,GAAGA,QAAQA,CAACA,aAAaA,CAACA,GAACA,CAACA,CAACA;gBAC5EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,eAAeA,GAAGA,QAAQA,CAACA,eAAeA,CAACA,GAACA,CAACA,CAACA;gBAChFA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,cAAcA,GAAGA,QAAQA,CAACA,cAAcA,CAACA,GAACA,CAACA,CAACA;gBAC9EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,eAAeA,GAAGA,QAAQA,CAACA,eAAeA,CAACA,GAACA,CAACA,CAACA;gBAChFA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,aAAaA,GAAGA,QAAQA,CAACA,aAAaA,CAACA,GAACA,CAACA,CAACA;gBAC5EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,eAAeA,GAAGA,QAAQA,CAACA,eAAeA,CAACA,GAACA,CAACA,CAACA;gBAChFA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,cAAcA,GAAGA,QAAQA,CAACA,cAAcA,CAACA,GAACA,CAACA,CAACA;gBAC9EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,eAAeA,GAAGA,QAAQA,CAACA,eAAeA,CAACA,GAACA,CAACA,CAACA;YACjFA,CAACA;YAEDA,AACAA,QADQA;YACRA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;gBACvBA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,SAASA,GAAGA,QAAQA,CAACA,SAASA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;gBAC1EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,WAAWA,GAAGA,QAAQA,CAACA,WAAWA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;gBAC9EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,UAAUA,GAAGA,QAAQA,CAACA,UAAUA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;gBAC5EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,WAAWA,GAAGA,QAAQA,CAACA,WAAWA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;gBAC9EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,SAASA,GAAGA,QAAQA,CAACA,SAASA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;gBAC1EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,WAAWA,GAAGA,QAAQA,CAACA,WAAWA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;gBAC9EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,UAAUA,GAAGA,QAAQA,CAACA,UAAUA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;gBAC5EA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,UAAUA,CAACA,WAAWA,GAAGA,QAAQA,CAACA,WAAWA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA;YAC/EA,CAACA;QACFA,CAACA;IAEFA,CAACA;IAnLDL;;;OAGGA;IACWA,4CAA0BA,GAAUA,0BAA0BA,CAACA;IAE7EA;;;OAGGA;IACWA,0CAAwBA,GAAUA,wBAAwBA,CAACA;IA0K1EA,wBAACA;AAADA,CAxMA,AAwMCA,EAxM+B,gBAAgB,EAwM/C;AAED,AAA2B,iBAAlB,iBAAiB,CAAC","file":"animators/nodes/ParticleColorNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ColorTransform\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/ColorTransform\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleColorState\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleColorState\");\n\n/**\n * A particle animation node used to control the color variation of a particle over time.\n */\nclass ParticleColorNode extends ParticleNodeBase\n{\n\t//default values used when creating states\n\t/** @private */\n\tpublic _iUsesMultiplier:boolean;\n\t/** @private */\n\tpublic _iUsesOffset:boolean;\n\t/** @private */\n\tpublic _iUsesCycle:boolean;\n\t/** @private */\n\tpublic _iUsesPhase:boolean;\n\t/** @private */\n\tpublic _iStartColor:ColorTransform;\n\t/** @private */\n\tpublic _iEndColor:ColorTransform;\n\t/** @private */\n\tpublic _iCycleDuration:number;\n\t/** @private */\n\tpublic _iCyclePhase:number;\n\n\t/**\n\t * Reference for color node properties on a single particle (when in local property mode).\n\t * Expects a <code>ColorTransform</code> object representing the start color transform applied to the particle.\n\t */\n\tpublic static COLOR_START_COLORTRANSFORM:string = \"ColorStartColorTransform\";\n\n\t/**\n\t * Reference for color node properties on a single particle (when in local property mode).\n\t * Expects a <code>ColorTransform</code> object representing the end color transform applied to the particle.\n\t */\n\tpublic static COLOR_END_COLORTRANSFORM:string = \"ColorEndColorTransform\";\n\n\t/**\n\t * Creates a new <code>ParticleColorNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] usesMultiplier  Defines whether the node uses multiplier data in the shader for its color transformations. Defaults to true.\n\t * @param    [optional] usesOffset      Defines whether the node uses offset data in the shader for its color transformations. Defaults to true.\n\t * @param    [optional] usesCycle       Defines whether the node uses the <code>cycleDuration</code> property in the shader to calculate the period of the animation independent of particle duration. Defaults to false.\n\t * @param    [optional] usesPhase       Defines whether the node uses the <code>cyclePhase</code> property in the shader to calculate a starting offset to the cycle rotation of the particle. Defaults to false.\n\t * @param    [optional] startColor      Defines the default start color transform of the node, when in global mode.\n\t * @param    [optional] endColor        Defines the default end color transform of the node, when in global mode.\n\t * @param    [optional] cycleDuration   Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1.\n\t * @param    [optional] cyclePhase      Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0.\n\t */\n\tconstructor(mode:number /*uint*/, usesMultiplier:boolean = true, usesOffset:boolean = true, usesCycle:boolean = false, usesPhase:boolean = false, startColor:ColorTransform = null, endColor:ColorTransform = null, cycleDuration:number = 1, cyclePhase:number = 0)\n\t{\n\t\tsuper(\"ParticleColor\", mode, (usesMultiplier && usesOffset)? 16 : 8, ParticleAnimationSet.COLOR_PRIORITY);\n\n\t\tthis._pStateClass = ParticleColorState;\n\n\t\tthis._iUsesMultiplier = usesMultiplier;\n\t\tthis._iUsesOffset = usesOffset;\n\t\tthis._iUsesCycle = usesCycle;\n\t\tthis._iUsesPhase = usesPhase;\n\n\t\tthis._iStartColor = startColor || new ColorTransform();\n\t\tthis._iEndColor = endColor || new ColorTransform();\n\t\tthis._iCycleDuration = cycleDuration;\n\t\tthis._iCyclePhase = cyclePhase;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar code:string = \"\";\n\t\tif (animationRegisterCache.needFragmentAnimation) {\n\t\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\n\t\t\tif (this._iUsesCycle) {\n\t\t\t\tvar cycleConst:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleColorState.CYCLE_INDEX, cycleConst.index);\n\n\t\t\t\tanimationRegisterCache.addVertexTempUsages(temp, 1);\n\t\t\t\tvar sin:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp();\n\t\t\t\tanimationRegisterCache.removeVertexTempUsage(temp);\n\n\t\t\t\tcode += \"mul \" + sin + \",\" + animationRegisterCache.vertexTime + \",\" + cycleConst + \".x\\n\";\n\n\t\t\t\tif (this._iUsesPhase)\n\t\t\t\t\tcode += \"add \" + sin + \",\" + sin + \",\" + cycleConst + \".y\\n\";\n\n\t\t\t\tcode += \"sin \" + sin + \",\" + sin + \"\\n\";\n\t\t\t}\n\n\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\tvar startMultiplierValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\t\t\tvar deltaMultiplierValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleColorState.START_MULTIPLIER_INDEX, startMultiplierValue.index);\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleColorState.DELTA_MULTIPLIER_INDEX, deltaMultiplierValue.index);\n\n\t\t\t\tcode += \"mul \" + temp + \",\" + deltaMultiplierValue + \",\" + (this._iUsesCycle? sin : animationRegisterCache.vertexLife) + \"\\n\";\n\t\t\t\tcode += \"add \" + temp + \",\" + temp + \",\" + startMultiplierValue + \"\\n\";\n\t\t\t\tcode += \"mul \" + animationRegisterCache.colorMulTarget + \",\" + temp + \",\" + animationRegisterCache.colorMulTarget + \"\\n\";\n\t\t\t}\n\n\t\t\tif (this._iUsesOffset) {\n\t\t\t\tvar startOffsetValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC)? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant();\n\t\t\t\tvar deltaOffsetValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC)? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant();\n\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleColorState.START_OFFSET_INDEX, startOffsetValue.index);\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleColorState.DELTA_OFFSET_INDEX, deltaOffsetValue.index);\n\n\t\t\t\tcode += \"mul \" + temp + \",\" + deltaOffsetValue + \",\" + (this._iUsesCycle? sin : animationRegisterCache.vertexLife) + \"\\n\";\n\t\t\t\tcode += \"add \" + temp + \",\" + temp + \",\" + startOffsetValue + \"\\n\";\n\t\t\t\tcode += \"add \" + animationRegisterCache.colorAddTarget + \",\" + temp + \",\" + animationRegisterCache.colorAddTarget + \"\\n\";\n\t\t\t}\n\t\t}\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleColorState\n\t{\n\t\treturn <ParticleColorState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet)\n\t{\n\t\tif (this._iUsesMultiplier)\n\t\t\tparticleAnimationSet.hasColorMulNode = true;\n\t\tif (this._iUsesOffset)\n\t\t\tparticleAnimationSet.hasColorAddNode = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tvar startColor:ColorTransform = param[ParticleColorNode.COLOR_START_COLORTRANSFORM];\n\t\tif (!startColor)\n\t\t\tthrow(new Error(\"there is no \" + ParticleColorNode.COLOR_START_COLORTRANSFORM + \" in param!\"));\n\n\t\tvar endColor:ColorTransform = param[ParticleColorNode.COLOR_END_COLORTRANSFORM];\n\t\tif (!endColor)\n\t\t\tthrow(new Error(\"there is no \" + ParticleColorNode.COLOR_END_COLORTRANSFORM + \" in param!\"));\n\n\t\tvar i:number /*uint*/ = 0;\n\n\t\tif (!this._iUsesCycle) {\n\t\t\t//multiplier\n\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\tthis._pOneData[i++] = startColor.redMultiplier;\n\t\t\t\tthis._pOneData[i++] = startColor.greenMultiplier;\n\t\t\t\tthis._pOneData[i++] = startColor.blueMultiplier;\n\t\t\t\tthis._pOneData[i++] = startColor.alphaMultiplier;\n\t\t\t\tthis._pOneData[i++] = endColor.redMultiplier - startColor.redMultiplier;\n\t\t\t\tthis._pOneData[i++] = endColor.greenMultiplier - startColor.greenMultiplier;\n\t\t\t\tthis._pOneData[i++] = endColor.blueMultiplier - startColor.blueMultiplier;\n\t\t\t\tthis._pOneData[i++] = endColor.alphaMultiplier - startColor.alphaMultiplier;\n\t\t\t}\n\n\t\t\t//offset\n\t\t\tif (this._iUsesOffset) {\n\t\t\t\tthis._pOneData[i++] = startColor.redOffset/255;\n\t\t\t\tthis._pOneData[i++] = startColor.greenOffset/255;\n\t\t\t\tthis._pOneData[i++] = startColor.blueOffset/255;\n\t\t\t\tthis._pOneData[i++] = startColor.alphaOffset/255;\n\t\t\t\tthis._pOneData[i++] = (endColor.redOffset - startColor.redOffset)/255;\n\t\t\t\tthis._pOneData[i++] = (endColor.greenOffset - startColor.greenOffset)/255;\n\t\t\t\tthis._pOneData[i++] = (endColor.blueOffset - startColor.blueOffset)/255;\n\t\t\t\tthis._pOneData[i++] = (endColor.alphaOffset - startColor.alphaOffset)/255;\n\t\t\t}\n\t\t} else {\n\t\t\t//multiplier\n\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\tthis._pOneData[i++] = (startColor.redMultiplier + endColor.redMultiplier)/2;\n\t\t\t\tthis._pOneData[i++] = (startColor.greenMultiplier + endColor.greenMultiplier)/2;\n\t\t\t\tthis._pOneData[i++] = (startColor.blueMultiplier + endColor.blueMultiplier)/2;\n\t\t\t\tthis._pOneData[i++] = (startColor.alphaMultiplier + endColor.alphaMultiplier)/2;\n\t\t\t\tthis._pOneData[i++] = (startColor.redMultiplier - endColor.redMultiplier)/2;\n\t\t\t\tthis._pOneData[i++] = (startColor.greenMultiplier - endColor.greenMultiplier)/2;\n\t\t\t\tthis._pOneData[i++] = (startColor.blueMultiplier - endColor.blueMultiplier)/2;\n\t\t\t\tthis._pOneData[i++] = (startColor.alphaMultiplier - endColor.alphaMultiplier)/2;\n\t\t\t}\n\n\t\t\t//offset\n\t\t\tif (this._iUsesOffset) {\n\t\t\t\tthis._pOneData[i++] = (startColor.redOffset + endColor.redOffset)/(255*2);\n\t\t\t\tthis._pOneData[i++] = (startColor.greenOffset + endColor.greenOffset)/(255*2);\n\t\t\t\tthis._pOneData[i++] = (startColor.blueOffset + endColor.blueOffset)/(255*2);\n\t\t\t\tthis._pOneData[i++] = (startColor.alphaOffset + endColor.alphaOffset)/(255*2);\n\t\t\t\tthis._pOneData[i++] = (startColor.redOffset - endColor.redOffset)/(255*2);\n\t\t\t\tthis._pOneData[i++] = (startColor.greenOffset - endColor.greenOffset)/(255*2);\n\t\t\t\tthis._pOneData[i++] = (startColor.blueOffset - endColor.blueOffset)/(255*2);\n\t\t\t\tthis._pOneData[i++] = (startColor.alphaOffset - endColor.alphaOffset)/(255*2);\n\t\t\t}\n\t\t}\n\n\t}\n}\n\nexport = ParticleColorNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleColorNode.ts b/lib/animators/nodes/ParticleColorNode.ts new file mode 100644 index 000000000..eb792beec --- /dev/null +++ b/lib/animators/nodes/ParticleColorNode.ts @@ -0,0 +1,220 @@ +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleColorState = require("awayjs-renderergl/lib/animators/states/ParticleColorState"); + +/** + * A particle animation node used to control the color variation of a particle over time. + */ +class ParticleColorNode extends ParticleNodeBase +{ + //default values used when creating states + /** @private */ + public _iUsesMultiplier:boolean; + /** @private */ + public _iUsesOffset:boolean; + /** @private */ + public _iUsesCycle:boolean; + /** @private */ + public _iUsesPhase:boolean; + /** @private */ + public _iStartColor:ColorTransform; + /** @private */ + public _iEndColor:ColorTransform; + /** @private */ + public _iCycleDuration:number; + /** @private */ + public _iCyclePhase:number; + + /** + * Reference for color node properties on a single particle (when in local property mode). + * Expects a ColorTransform object representing the start color transform applied to the particle. + */ + public static COLOR_START_COLORTRANSFORM:string = "ColorStartColorTransform"; + + /** + * Reference for color node properties on a single particle (when in local property mode). + * Expects a ColorTransform object representing the end color transform applied to the particle. + */ + public static COLOR_END_COLORTRANSFORM:string = "ColorEndColorTransform"; + + /** + * Creates a new ParticleColorNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] usesMultiplier Defines whether the node uses multiplier data in the shader for its color transformations. Defaults to true. + * @param [optional] usesOffset Defines whether the node uses offset data in the shader for its color transformations. Defaults to true. + * @param [optional] usesCycle Defines whether the node uses the cycleDuration property in the shader to calculate the period of the animation independent of particle duration. Defaults to false. + * @param [optional] usesPhase Defines whether the node uses the cyclePhase property in the shader to calculate a starting offset to the cycle rotation of the particle. Defaults to false. + * @param [optional] startColor Defines the default start color transform of the node, when in global mode. + * @param [optional] endColor Defines the default end color transform of the node, when in global mode. + * @param [optional] cycleDuration Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + constructor(mode:number /*uint*/, usesMultiplier:boolean = true, usesOffset:boolean = true, usesCycle:boolean = false, usesPhase:boolean = false, startColor:ColorTransform = null, endColor:ColorTransform = null, cycleDuration:number = 1, cyclePhase:number = 0) + { + super("ParticleColor", mode, (usesMultiplier && usesOffset)? 16 : 8, ParticleAnimationSet.COLOR_PRIORITY); + + this._pStateClass = ParticleColorState; + + this._iUsesMultiplier = usesMultiplier; + this._iUsesOffset = usesOffset; + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + + this._iStartColor = startColor || new ColorTransform(); + this._iEndColor = endColor || new ColorTransform(); + this._iCycleDuration = cycleDuration; + this._iCyclePhase = cyclePhase; + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var code:string = ""; + if (animationRegisterCache.needFragmentAnimation) { + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + + if (this._iUsesCycle) { + var cycleConst:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.CYCLE_INDEX, cycleConst.index); + + animationRegisterCache.addVertexTempUsages(temp, 1); + var sin:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp(); + animationRegisterCache.removeVertexTempUsage(temp); + + code += "mul " + sin + "," + animationRegisterCache.vertexTime + "," + cycleConst + ".x\n"; + + if (this._iUsesPhase) + code += "add " + sin + "," + sin + "," + cycleConst + ".y\n"; + + code += "sin " + sin + "," + sin + "\n"; + } + + if (this._iUsesMultiplier) { + var startMultiplierValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + var deltaMultiplierValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + + animationRegisterCache.setRegisterIndex(this, ParticleColorState.START_MULTIPLIER_INDEX, startMultiplierValue.index); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.DELTA_MULTIPLIER_INDEX, deltaMultiplierValue.index); + + code += "mul " + temp + "," + deltaMultiplierValue + "," + (this._iUsesCycle? sin : animationRegisterCache.vertexLife) + "\n"; + code += "add " + temp + "," + temp + "," + startMultiplierValue + "\n"; + code += "mul " + animationRegisterCache.colorMulTarget + "," + temp + "," + animationRegisterCache.colorMulTarget + "\n"; + } + + if (this._iUsesOffset) { + var startOffsetValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC)? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant(); + var deltaOffsetValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC)? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant(); + + animationRegisterCache.setRegisterIndex(this, ParticleColorState.START_OFFSET_INDEX, startOffsetValue.index); + animationRegisterCache.setRegisterIndex(this, ParticleColorState.DELTA_OFFSET_INDEX, deltaOffsetValue.index); + + code += "mul " + temp + "," + deltaOffsetValue + "," + (this._iUsesCycle? sin : animationRegisterCache.vertexLife) + "\n"; + code += "add " + temp + "," + temp + "," + startOffsetValue + "\n"; + code += "add " + animationRegisterCache.colorAddTarget + "," + temp + "," + animationRegisterCache.colorAddTarget + "\n"; + } + } + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleColorState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + if (this._iUsesMultiplier) + particleAnimationSet.hasColorMulNode = true; + if (this._iUsesOffset) + particleAnimationSet.hasColorAddNode = true; + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var startColor:ColorTransform = param[ParticleColorNode.COLOR_START_COLORTRANSFORM]; + if (!startColor) + throw(new Error("there is no " + ParticleColorNode.COLOR_START_COLORTRANSFORM + " in param!")); + + var endColor:ColorTransform = param[ParticleColorNode.COLOR_END_COLORTRANSFORM]; + if (!endColor) + throw(new Error("there is no " + ParticleColorNode.COLOR_END_COLORTRANSFORM + " in param!")); + + var i:number /*uint*/ = 0; + + if (!this._iUsesCycle) { + //multiplier + if (this._iUsesMultiplier) { + this._pOneData[i++] = startColor.redMultiplier; + this._pOneData[i++] = startColor.greenMultiplier; + this._pOneData[i++] = startColor.blueMultiplier; + this._pOneData[i++] = startColor.alphaMultiplier; + this._pOneData[i++] = endColor.redMultiplier - startColor.redMultiplier; + this._pOneData[i++] = endColor.greenMultiplier - startColor.greenMultiplier; + this._pOneData[i++] = endColor.blueMultiplier - startColor.blueMultiplier; + this._pOneData[i++] = endColor.alphaMultiplier - startColor.alphaMultiplier; + } + + //offset + if (this._iUsesOffset) { + this._pOneData[i++] = startColor.redOffset/255; + this._pOneData[i++] = startColor.greenOffset/255; + this._pOneData[i++] = startColor.blueOffset/255; + this._pOneData[i++] = startColor.alphaOffset/255; + this._pOneData[i++] = (endColor.redOffset - startColor.redOffset)/255; + this._pOneData[i++] = (endColor.greenOffset - startColor.greenOffset)/255; + this._pOneData[i++] = (endColor.blueOffset - startColor.blueOffset)/255; + this._pOneData[i++] = (endColor.alphaOffset - startColor.alphaOffset)/255; + } + } else { + //multiplier + if (this._iUsesMultiplier) { + this._pOneData[i++] = (startColor.redMultiplier + endColor.redMultiplier)/2; + this._pOneData[i++] = (startColor.greenMultiplier + endColor.greenMultiplier)/2; + this._pOneData[i++] = (startColor.blueMultiplier + endColor.blueMultiplier)/2; + this._pOneData[i++] = (startColor.alphaMultiplier + endColor.alphaMultiplier)/2; + this._pOneData[i++] = (startColor.redMultiplier - endColor.redMultiplier)/2; + this._pOneData[i++] = (startColor.greenMultiplier - endColor.greenMultiplier)/2; + this._pOneData[i++] = (startColor.blueMultiplier - endColor.blueMultiplier)/2; + this._pOneData[i++] = (startColor.alphaMultiplier - endColor.alphaMultiplier)/2; + } + + //offset + if (this._iUsesOffset) { + this._pOneData[i++] = (startColor.redOffset + endColor.redOffset)/(255*2); + this._pOneData[i++] = (startColor.greenOffset + endColor.greenOffset)/(255*2); + this._pOneData[i++] = (startColor.blueOffset + endColor.blueOffset)/(255*2); + this._pOneData[i++] = (startColor.alphaOffset + endColor.alphaOffset)/(255*2); + this._pOneData[i++] = (startColor.redOffset - endColor.redOffset)/(255*2); + this._pOneData[i++] = (startColor.greenOffset - endColor.greenOffset)/(255*2); + this._pOneData[i++] = (startColor.blueOffset - endColor.blueOffset)/(255*2); + this._pOneData[i++] = (startColor.alphaOffset - endColor.alphaOffset)/(255*2); + } + } + + } +} + +export = ParticleColorNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleFollowNode.js b/lib/animators/nodes/ParticleFollowNode.js new file mode 100755 index 000000000..ad964cac1 --- /dev/null +++ b/lib/animators/nodes/ParticleFollowNode.js @@ -0,0 +1,127 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleFollowState = require("awayjs-renderergl/lib/animators/states/ParticleFollowState"); +/** + * A particle animation node used to create a follow behaviour on a particle system. + */ +var ParticleFollowNode = (function (_super) { + __extends(ParticleFollowNode, _super); + /** + * Creates a new ParticleFollowNode + * + * @param [optional] usesPosition Defines wehether the individual particle reacts to the position of the target. + * @param [optional] usesRotation Defines wehether the individual particle reacts to the rotation of the target. + * @param [optional] smooth Defines wehether the state calculate the interpolated value. + */ + function ParticleFollowNode(usesPosition, usesRotation, smooth) { + if (usesPosition === void 0) { usesPosition = true; } + if (usesRotation === void 0) { usesRotation = true; } + if (smooth === void 0) { smooth = false; } + _super.call(this, "ParticleFollow", ParticlePropertiesMode.LOCAL_DYNAMIC, (usesPosition && usesRotation) ? 6 : 3, ParticleAnimationSet.POST_PRIORITY); + this._pStateClass = ParticleFollowState; + this._iUsesPosition = usesPosition; + this._iUsesRotation = usesRotation; + this._iSmooth = smooth; + } + /** + * @inheritDoc + */ + ParticleFollowNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + //TODO: use Quaternion to implement this function + var code = ""; + if (this._iUsesRotation) { + var rotationAttribute = animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleFollowState.FOLLOW_ROTATION_INDEX, rotationAttribute.index); + var temp1 = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var temp2 = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp2, 1); + var temp3 = animationRegisterCache.getFreeVertexVectorTemp(); + var temp4; + if (animationRegisterCache.hasBillboard) { + animationRegisterCache.addVertexTempUsages(temp3, 1); + temp4 = animationRegisterCache.getFreeVertexVectorTemp(); + } + animationRegisterCache.removeVertexTempUsage(temp1); + animationRegisterCache.removeVertexTempUsage(temp2); + if (animationRegisterCache.hasBillboard) + animationRegisterCache.removeVertexTempUsage(temp3); + var len = animationRegisterCache.rotationRegisters.length; + var i /*int*/; + //x axis + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "sin " + temp3 + ".y," + rotationAttribute + ".x\n"; + code += "cos " + temp3 + ".z," + rotationAttribute + ".x\n"; + code += "mov " + temp2 + ".x," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".y," + temp3 + ".z\n"; + code += "neg " + temp2 + ".z," + temp3 + ".y\n"; + if (animationRegisterCache.hasBillboard) + code += "m33 " + temp4 + ".xyz," + animationRegisterCache.positionTarget + ".xyz," + temp1 + "\n"; + else { + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + //y axis + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "cos " + temp1 + ".x," + rotationAttribute + ".y\n"; + code += "sin " + temp1 + ".z," + rotationAttribute + ".y\n"; + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".y," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "neg " + temp3 + ".x," + temp1 + ".z\n"; + code += "mov " + temp3 + ".z," + temp1 + ".x\n"; + if (animationRegisterCache.hasBillboard) + code += "m33 " + temp4 + ".xyz," + temp4 + ".xyz," + temp1 + "\n"; + else { + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + //z axis + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "sin " + temp2 + ".x," + rotationAttribute + ".z\n"; + code += "cos " + temp2 + ".y," + rotationAttribute + ".z\n"; + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + temp2 + ".y\n"; + code += "neg " + temp1 + ".y," + temp2 + ".x\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".z," + animationRegisterCache.vertexOneConst + "\n"; + if (animationRegisterCache.hasBillboard) { + code += "m33 " + temp4 + ".xyz," + temp4 + ".xyz," + temp1 + "\n"; + code += "sub " + temp4 + ".xyz," + temp4 + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp4 + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + } + else { + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + } + if (this._iUsesPosition) { + var positionAttribute = animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleFollowState.FOLLOW_POSITION_INDEX, positionAttribute.index); + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + positionAttribute + "," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + } + return code; + }; + /** + * @inheritDoc + */ + ParticleFollowNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + return ParticleFollowNode; +})(ParticleNodeBase); +module.exports = ParticleFollowNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlefollownode.ts"],"names":["ParticleFollowNode","ParticleFollowNode.constructor","ParticleFollowNode.getAGALVertexCode","ParticleFollowNode.getAnimationState"],"mappings":"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","file":"animators/nodes/ParticleFollowNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleFollowState\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleFollowState\");\n\n/**\n * A particle animation node used to create a follow behaviour on a particle system.\n */\nclass ParticleFollowNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iUsesPosition:boolean;\n\n\t/** @private */\n\tpublic _iUsesRotation:boolean;\n\n\t/** @private */\n\tpublic _iSmooth:boolean;\n\n\t/**\n\t * Creates a new <code>ParticleFollowNode</code>\n\t *\n\t * @param    [optional] usesPosition     Defines wehether the individual particle reacts to the position of the target.\n\t * @param    [optional] usesRotation     Defines wehether the individual particle reacts to the rotation of the target.\n\t * @param    [optional] smooth     Defines wehether the state calculate the interpolated value.\n\t */\n\tconstructor(usesPosition:boolean = true, usesRotation:boolean = true, smooth:boolean = false)\n\t{\n\t\tsuper(\"ParticleFollow\", ParticlePropertiesMode.LOCAL_DYNAMIC, (usesPosition && usesRotation)? 6 : 3, ParticleAnimationSet.POST_PRIORITY);\n\n\t\tthis._pStateClass = ParticleFollowState;\n\n\t\tthis._iUsesPosition = usesPosition;\n\t\tthis._iUsesRotation = usesRotation;\n\t\tthis._iSmooth = smooth;\n\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\t//TODO: use Quaternion to implement this function\n\t\tvar code:string = \"\";\n\t\tif (this._iUsesRotation) {\n\t\t\tvar rotationAttribute:ShaderRegisterElement = animationRegisterCache.getFreeVertexAttribute();\n\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleFollowState.FOLLOW_ROTATION_INDEX, rotationAttribute.index);\n\n\t\t\tvar temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(temp1, 1);\n\t\t\tvar temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(temp2, 1);\n\t\t\tvar temp3:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\n\t\t\tvar temp4:ShaderRegisterElement;\n\t\t\tif (animationRegisterCache.hasBillboard) {\n\t\t\t\tanimationRegisterCache.addVertexTempUsages(temp3, 1);\n\t\t\t\ttemp4 = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\t}\n\n\t\t\tanimationRegisterCache.removeVertexTempUsage(temp1);\n\t\t\tanimationRegisterCache.removeVertexTempUsage(temp2);\n\t\t\tif (animationRegisterCache.hasBillboard)\n\t\t\t\tanimationRegisterCache.removeVertexTempUsage(temp3);\n\n\t\t\tvar len:number /*int*/ = animationRegisterCache.rotationRegisters.length;\n\t\t\tvar i:number /*int*/;\n\n\t\t\t//x axis\n\t\t\tcode += \"mov \" + temp1 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp1 + \".x,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp3 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"sin \" + temp3 + \".y,\" + rotationAttribute + \".x\\n\";\n\t\t\tcode += \"cos \" + temp3 + \".z,\" + rotationAttribute + \".x\\n\";\n\t\t\tcode += \"mov \" + temp2 + \".x,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp2 + \".y,\" + temp3 + \".z\\n\";\n\t\t\tcode += \"neg \" + temp2 + \".z,\" + temp3 + \".y\\n\";\n\n\t\t\tif (animationRegisterCache.hasBillboard)\n\t\t\t\tcode += \"m33 \" + temp4 + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz,\" + temp1 + \"\\n\";\n\t\t\telse {\n\t\t\t\tcode += \"m33 \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp1 + \"\\n\";\n\t\t\t\tfor (i = 0; i < len; i++)\n\t\t\t\t\tcode += \"m33 \" + animationRegisterCache.rotationRegisters[i] + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \",\" + temp1 + \"\\n\";\n\t\t\t}\n\n\t\t\t//y axis\n\t\t\tcode += \"mov \" + temp1 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"cos \" + temp1 + \".x,\" + rotationAttribute + \".y\\n\";\n\t\t\tcode += \"sin \" + temp1 + \".z,\" + rotationAttribute + \".y\\n\";\n\t\t\tcode += \"mov \" + temp2 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp2 + \".y,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp3 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"neg \" + temp3 + \".x,\" + temp1 + \".z\\n\";\n\t\t\tcode += \"mov \" + temp3 + \".z,\" + temp1 + \".x\\n\";\n\n\t\t\tif (animationRegisterCache.hasBillboard)\n\t\t\t\tcode += \"m33 \" + temp4 + \".xyz,\" + temp4 + \".xyz,\" + temp1 + \"\\n\";\n\t\t\telse {\n\t\t\t\tcode += \"m33 \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp1 + \"\\n\";\n\t\t\t\tfor (i = 0; i < len; i++)\n\t\t\t\t\tcode += \"m33 \" + animationRegisterCache.rotationRegisters[i] + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \",\" + temp1 + \"\\n\";\n\t\t\t}\n\n\t\t\t//z axis\n\t\t\tcode += \"mov \" + temp2 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"sin \" + temp2 + \".x,\" + rotationAttribute + \".z\\n\";\n\t\t\tcode += \"cos \" + temp2 + \".y,\" + rotationAttribute + \".z\\n\";\n\t\t\tcode += \"mov \" + temp1 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp1 + \".x,\" + temp2 + \".y\\n\";\n\t\t\tcode += \"neg \" + temp1 + \".y,\" + temp2 + \".x\\n\";\n\t\t\tcode += \"mov \" + temp3 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp3 + \".z,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\n\t\t\tif (animationRegisterCache.hasBillboard) {\n\t\t\t\tcode += \"m33 \" + temp4 + \".xyz,\" + temp4 + \".xyz,\" + temp1 + \"\\n\";\n\t\t\t\tcode += \"sub \" + temp4 + \".xyz,\" + temp4 + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\t\t\t\tcode += \"add \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp4 + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\t\t\t} else {\n\t\t\t\tcode += \"m33 \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp1 + \"\\n\";\n\t\t\t\tfor (i = 0; i < len; i++)\n\t\t\t\t\tcode += \"m33 \" + animationRegisterCache.rotationRegisters[i] + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \",\" + temp1 + \"\\n\";\n\t\t\t}\n\n\t\t}\n\n\t\tif (this._iUsesPosition) {\n\t\t\tvar positionAttribute:ShaderRegisterElement = animationRegisterCache.getFreeVertexAttribute();\n\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleFollowState.FOLLOW_POSITION_INDEX, positionAttribute.index);\n\t\t\tcode += \"add \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + positionAttribute + \",\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\t\t}\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleFollowState\n\t{\n\t\treturn <ParticleFollowState> animator.getAnimationState(this);\n\t}\n}\n\nexport = ParticleFollowNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleFollowNode.ts b/lib/animators/nodes/ParticleFollowNode.ts new file mode 100644 index 000000000..c4cb793e8 --- /dev/null +++ b/lib/animators/nodes/ParticleFollowNode.ts @@ -0,0 +1,154 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleFollowState = require("awayjs-renderergl/lib/animators/states/ParticleFollowState"); + +/** + * A particle animation node used to create a follow behaviour on a particle system. + */ +class ParticleFollowNode extends ParticleNodeBase +{ + /** @private */ + public _iUsesPosition:boolean; + + /** @private */ + public _iUsesRotation:boolean; + + /** @private */ + public _iSmooth:boolean; + + /** + * Creates a new ParticleFollowNode + * + * @param [optional] usesPosition Defines wehether the individual particle reacts to the position of the target. + * @param [optional] usesRotation Defines wehether the individual particle reacts to the rotation of the target. + * @param [optional] smooth Defines wehether the state calculate the interpolated value. + */ + constructor(usesPosition:boolean = true, usesRotation:boolean = true, smooth:boolean = false) + { + super("ParticleFollow", ParticlePropertiesMode.LOCAL_DYNAMIC, (usesPosition && usesRotation)? 6 : 3, ParticleAnimationSet.POST_PRIORITY); + + this._pStateClass = ParticleFollowState; + + this._iUsesPosition = usesPosition; + this._iUsesRotation = usesRotation; + this._iSmooth = smooth; + + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + //TODO: use Quaternion to implement this function + var code:string = ""; + if (this._iUsesRotation) { + var rotationAttribute:ShaderRegisterElement = animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleFollowState.FOLLOW_ROTATION_INDEX, rotationAttribute.index); + + var temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp2, 1); + var temp3:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + + var temp4:ShaderRegisterElement; + if (animationRegisterCache.hasBillboard) { + animationRegisterCache.addVertexTempUsages(temp3, 1); + temp4 = animationRegisterCache.getFreeVertexVectorTemp(); + } + + animationRegisterCache.removeVertexTempUsage(temp1); + animationRegisterCache.removeVertexTempUsage(temp2); + if (animationRegisterCache.hasBillboard) + animationRegisterCache.removeVertexTempUsage(temp3); + + var len:number /*int*/ = animationRegisterCache.rotationRegisters.length; + var i:number /*int*/; + + //x axis + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "sin " + temp3 + ".y," + rotationAttribute + ".x\n"; + code += "cos " + temp3 + ".z," + rotationAttribute + ".x\n"; + code += "mov " + temp2 + ".x," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".y," + temp3 + ".z\n"; + code += "neg " + temp2 + ".z," + temp3 + ".y\n"; + + if (animationRegisterCache.hasBillboard) + code += "m33 " + temp4 + ".xyz," + animationRegisterCache.positionTarget + ".xyz," + temp1 + "\n"; + else { + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + + //y axis + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "cos " + temp1 + ".x," + rotationAttribute + ".y\n"; + code += "sin " + temp1 + ".z," + rotationAttribute + ".y\n"; + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".y," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "neg " + temp3 + ".x," + temp1 + ".z\n"; + code += "mov " + temp3 + ".z," + temp1 + ".x\n"; + + if (animationRegisterCache.hasBillboard) + code += "m33 " + temp4 + ".xyz," + temp4 + ".xyz," + temp1 + "\n"; + else { + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + + //z axis + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "sin " + temp2 + ".x," + rotationAttribute + ".z\n"; + code += "cos " + temp2 + ".y," + rotationAttribute + ".z\n"; + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + temp2 + ".y\n"; + code += "neg " + temp1 + ".y," + temp2 + ".x\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".z," + animationRegisterCache.vertexOneConst + "\n"; + + if (animationRegisterCache.hasBillboard) { + code += "m33 " + temp4 + ".xyz," + temp4 + ".xyz," + temp1 + "\n"; + code += "sub " + temp4 + ".xyz," + temp4 + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp4 + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + } else { + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + + } + + if (this._iUsesPosition) { + var positionAttribute:ShaderRegisterElement = animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleFollowState.FOLLOW_POSITION_INDEX, positionAttribute.index); + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + positionAttribute + "," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + } + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleFollowState + { + return animator.getAnimationState(this); + } +} + +export = ParticleFollowNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleInitialColorNode.js b/lib/animators/nodes/ParticleInitialColorNode.js new file mode 100755 index 000000000..fd68cbe37 --- /dev/null +++ b/lib/animators/nodes/ParticleInitialColorNode.js @@ -0,0 +1,87 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +var ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleInitialColorState = require("awayjs-renderergl/lib/animators/states/ParticleInitialColorState"); +/** + * + */ +var ParticleInitialColorNode = (function (_super) { + __extends(ParticleInitialColorNode, _super); + function ParticleInitialColorNode(mode /*uint*/, usesMultiplier, usesOffset, initialColor) { + if (usesMultiplier === void 0) { usesMultiplier = true; } + if (usesOffset === void 0) { usesOffset = false; } + if (initialColor === void 0) { initialColor = null; } + _super.call(this, "ParticleInitialColor", mode, (usesMultiplier && usesOffset) ? 8 : 4, ParticleAnimationSet.COLOR_PRIORITY); + this._pStateClass = ParticleInitialColorState; + this._iUsesMultiplier = usesMultiplier; + this._iUsesOffset = usesOffset; + this._iInitialColor = initialColor || new ColorTransform(); + } + /** + * @inheritDoc + */ + ParticleInitialColorNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var code = ""; + if (animationRegisterCache.needFragmentAnimation) { + if (this._iUsesMultiplier) { + var multiplierValue = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleInitialColorState.MULTIPLIER_INDEX, multiplierValue.index); + code += "mul " + animationRegisterCache.colorMulTarget + "," + multiplierValue + "," + animationRegisterCache.colorMulTarget + "\n"; + } + if (this._iUsesOffset) { + var offsetValue = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC) ? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleInitialColorState.OFFSET_INDEX, offsetValue.index); + code += "add " + animationRegisterCache.colorAddTarget + "," + offsetValue + "," + animationRegisterCache.colorAddTarget + "\n"; + } + } + return code; + }; + /** + * @inheritDoc + */ + ParticleInitialColorNode.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + if (this._iUsesMultiplier) + particleAnimationSet.hasColorMulNode = true; + if (this._iUsesOffset) + particleAnimationSet.hasColorAddNode = true; + }; + /** + * @inheritDoc + */ + ParticleInitialColorNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var initialColor = param[ParticleInitialColorNode.COLOR_INITIAL_COLORTRANSFORM]; + if (!initialColor) + throw (new Error("there is no " + ParticleInitialColorNode.COLOR_INITIAL_COLORTRANSFORM + " in param!")); + var i = 0; + //multiplier + if (this._iUsesMultiplier) { + this._pOneData[i++] = initialColor.redMultiplier; + this._pOneData[i++] = initialColor.greenMultiplier; + this._pOneData[i++] = initialColor.blueMultiplier; + this._pOneData[i++] = initialColor.alphaMultiplier; + } + //offset + if (this._iUsesOffset) { + this._pOneData[i++] = initialColor.redOffset / 255; + this._pOneData[i++] = initialColor.greenOffset / 255; + this._pOneData[i++] = initialColor.blueOffset / 255; + this._pOneData[i++] = initialColor.alphaOffset / 255; + } + }; + /** + * Reference for color node properties on a single particle (when in local property mode). + * Expects a ColorTransform object representing the color transform applied to the particle. + */ + ParticleInitialColorNode.COLOR_INITIAL_COLORTRANSFORM = "ColorInitialColorTransform"; + return ParticleInitialColorNode; +})(ParticleNodeBase); +module.exports = ParticleInitialColorNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particleinitialcolornode.ts"],"names":["ParticleInitialColorNode","ParticleInitialColorNode.constructor","ParticleInitialColorNode.getAGALVertexCode","ParticleInitialColorNode._iProcessAnimationSetting","ParticleInitialColorNode._iGeneratePropertyOfOneParticle"],"mappings":";;;;;;AAAA,IAAO,cAAc,WAAe,0CAA0C,CAAC,CAAC;AAQhF,IAAO,oBAAoB,WAAc,sDAAsD,CAAC,CAAC;AAEjG,IAAO,sBAAsB,WAAa,6DAA6D,CAAC,CAAC;AACzG,IAAO,gBAAgB,WAAe,wDAAwD,CAAC,CAAC;AAChG,IAAO,yBAAyB,WAAY,kEAAkE,CAAC,CAAC;AAEhH,AAGA;;GADG;IACG,wBAAwB;IAASA,UAAjCA,wBAAwBA,UAAyBA;IAgBtDA,SAhBKA,wBAAwBA,CAgBjBA,IAAIA,CAAQA,QAADA,AAASA,EAAEA,cAA6BA,EAAEA,UAA0BA,EAAEA,YAAkCA;QAA7FC,8BAA6BA,GAA7BA,qBAA6BA;QAAEA,0BAA0BA,GAA1BA,kBAA0BA;QAAEA,4BAAkCA,GAAlCA,mBAAkCA;QAE9HA,kBAAMA,sBAAsBA,EAAEA,IAAIA,EAAEA,CAACA,cAAcA,IAAIA,UAAUA,CAACA,GAAEA,CAACA,GAAGA,CAACA,EAAEA,oBAAoBA,CAACA,cAAcA,CAACA,CAACA;QAEhHA,IAAIA,CAACA,YAAYA,GAAGA,yBAAyBA,CAACA;QAE9CA,IAAIA,CAACA,gBAAgBA,GAAGA,cAAcA,CAACA;QACvCA,IAAIA,CAACA,YAAYA,GAAGA,UAAUA,CAACA;QAC/BA,IAAIA,CAACA,cAAcA,GAAGA,YAAYA,IAAIA,IAAIA,cAAcA,EAAEA,CAACA;IAC5DA,CAACA;IAEDD;;OAEGA;IACIA,oDAAiBA,GAAxBA,UAAyBA,YAA6BA,EAAEA,sBAA6CA;QAEpGE,IAAIA,IAAIA,GAAUA,EAAEA,CAACA;QACrBA,EAAEA,CAACA,CAACA,sBAAsBA,CAACA,qBAAqBA,CAACA,CAACA,CAACA;YAElDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,gBAAgBA,CAACA,CAACA,CAACA;gBAC3BA,IAAIA,eAAeA,GAAyBA,CAACA,IAAIA,CAACA,MAAMA,IAAIA,sBAAsBA,CAACA,MAAMA,CAACA,GAAEA,sBAAsBA,CAACA,qBAAqBA,EAAEA,GAAGA,sBAAsBA,CAACA,sBAAsBA,EAAEA,CAACA;gBAC7LA,sBAAsBA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,yBAAyBA,CAACA,gBAAgBA,EAAEA,eAAeA,CAACA,KAAKA,CAACA,CAACA;gBAEjHA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,eAAeA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,IAAIA,CAACA;YACrIA,CAACA;YAEDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;gBACvBA,IAAIA,WAAWA,GAAyBA,CAACA,IAAIA,CAACA,MAAMA,IAAIA,sBAAsBA,CAACA,YAAYA,CAACA,GAAEA,sBAAsBA,CAACA,sBAAsBA,EAAEA,GAAGA,sBAAsBA,CAACA,qBAAqBA,EAAEA,CAACA;gBAC/LA,sBAAsBA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,yBAAyBA,CAACA,YAAYA,EAAEA,WAAWA,CAACA,KAAKA,CAACA,CAACA;gBAEzGA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,WAAWA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,IAAIA,CAACA;YACjIA,CAACA;QACFA,CAACA;QAEDA,MAAMA,CAACA,IAAIA,CAACA;IACbA,CAACA;IAEDF;;OAEGA;IACIA,4DAAyBA,GAAhCA,UAAiCA,oBAAyCA;QAEzEG,EAAEA,CAACA,CAACA,IAAIA,CAACA,gBAAgBA,CAACA;YACzBA,oBAAoBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;QAC7CA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA;YACrBA,oBAAoBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;IAC9CA,CAACA;IAEDH;;OAEGA;IACIA,kEAA+BA,GAAtCA,UAAuCA,KAAwBA;QAE9DI,IAAIA,YAAYA,GAAkBA,KAAKA,CAACA,wBAAwBA,CAACA,4BAA4BA,CAACA,CAACA;QAC/FA,EAAEA,CAACA,CAACA,CAACA,YAAYA,CAACA;YACjBA,MAAKA,CAACA,IAAIA,KAAKA,CAACA,cAAcA,GAAGA,wBAAwBA,CAACA,4BAA4BA,GAAGA,YAAYA,CAACA,CAACA,CAACA;QAEzGA,IAAIA,CAACA,GAAmBA,CAACA,CAACA;QAE1BA,AACAA,YADYA;QACZA,EAAEA,CAACA,CAACA,IAAIA,CAACA,gBAAgBA,CAACA,CAACA,CAACA;YAC3BA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,aAAaA,CAACA;YACjDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,eAAeA,CAACA;YACnDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,cAAcA,CAACA;YAClDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,eAAeA,CAACA;QACpDA,CAACA;QACDA,AACAA,QADQA;QACRA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;YACvBA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,SAASA,GAACA,GAAGA,CAACA;YACjDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,WAAWA,GAACA,GAAGA,CAACA;YACnDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,UAAUA,GAACA,GAAGA,CAACA;YAClDA,IAAIA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,YAAYA,CAACA,WAAWA,GAACA,GAAGA,CAACA;QACpDA,CAACA;IAEFA,CAACA;IAhFDJ;;;OAGGA;IACWA,qDAA4BA,GAAUA,4BAA4BA,CAACA;IA8ElFA,+BAACA;AAADA,CA5FA,AA4FCA,EA5FsC,gBAAgB,EA4FtD;AAED,AAAkC,iBAAzB,wBAAwB,CAAC","file":"animators/nodes/ParticleInitialColorNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ColorTransform\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/ColorTransform\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleInitialColorState\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleInitialColorState\");\n\n/**\n *\n */\nclass ParticleInitialColorNode extends ParticleNodeBase\n{\n\t//default values used when creating states\n\t/** @private */\n\tpublic _iUsesMultiplier:boolean;\n\t/** @private */\n\tpublic _iUsesOffset:boolean;\n\t/** @private */\n\tpublic _iInitialColor:ColorTransform;\n\n\t/**\n\t * Reference for color node properties on a single particle (when in local property mode).\n\t * Expects a <code>ColorTransform</code> object representing the color transform applied to the particle.\n\t */\n\tpublic static COLOR_INITIAL_COLORTRANSFORM:string = \"ColorInitialColorTransform\";\n\n\tconstructor(mode:number /*uint*/, usesMultiplier:boolean = true, usesOffset:boolean = false, initialColor:ColorTransform = null)\n\t{\n\t\tsuper(\"ParticleInitialColor\", mode, (usesMultiplier && usesOffset)? 8 : 4, ParticleAnimationSet.COLOR_PRIORITY);\n\n\t\tthis._pStateClass = ParticleInitialColorState;\n\n\t\tthis._iUsesMultiplier = usesMultiplier;\n\t\tthis._iUsesOffset = usesOffset;\n\t\tthis._iInitialColor = initialColor || new ColorTransform();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar code:string = \"\";\n\t\tif (animationRegisterCache.needFragmentAnimation) {\n\n\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\tvar multiplierValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleInitialColorState.MULTIPLIER_INDEX, multiplierValue.index);\n\n\t\t\t\tcode += \"mul \" + animationRegisterCache.colorMulTarget + \",\" + multiplierValue + \",\" + animationRegisterCache.colorMulTarget + \"\\n\";\n\t\t\t}\n\n\t\t\tif (this._iUsesOffset) {\n\t\t\t\tvar offsetValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC)? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant();\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleInitialColorState.OFFSET_INDEX, offsetValue.index);\n\n\t\t\t\tcode += \"add \" + animationRegisterCache.colorAddTarget + \",\" + offsetValue + \",\" + animationRegisterCache.colorAddTarget + \"\\n\";\n\t\t\t}\n\t\t}\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet)\n\t{\n\t\tif (this._iUsesMultiplier)\n\t\t\tparticleAnimationSet.hasColorMulNode = true;\n\t\tif (this._iUsesOffset)\n\t\t\tparticleAnimationSet.hasColorAddNode = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tvar initialColor:ColorTransform = param[ParticleInitialColorNode.COLOR_INITIAL_COLORTRANSFORM];\n\t\tif (!initialColor)\n\t\t\tthrow(new Error(\"there is no \" + ParticleInitialColorNode.COLOR_INITIAL_COLORTRANSFORM + \" in param!\"));\n\n\t\tvar i:number /*uint*/ = 0;\n\n\t\t//multiplier\n\t\tif (this._iUsesMultiplier) {\n\t\t\tthis._pOneData[i++] = initialColor.redMultiplier;\n\t\t\tthis._pOneData[i++] = initialColor.greenMultiplier;\n\t\t\tthis._pOneData[i++] = initialColor.blueMultiplier;\n\t\t\tthis._pOneData[i++] = initialColor.alphaMultiplier;\n\t\t}\n\t\t//offset\n\t\tif (this._iUsesOffset) {\n\t\t\tthis._pOneData[i++] = initialColor.redOffset/255;\n\t\t\tthis._pOneData[i++] = initialColor.greenOffset/255;\n\t\t\tthis._pOneData[i++] = initialColor.blueOffset/255;\n\t\t\tthis._pOneData[i++] = initialColor.alphaOffset/255;\n\t\t}\n\n\t}\n\n}\n\nexport = ParticleInitialColorNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleInitialColorNode.ts b/lib/animators/nodes/ParticleInitialColorNode.ts new file mode 100644 index 000000000..2f480d5ef --- /dev/null +++ b/lib/animators/nodes/ParticleInitialColorNode.ts @@ -0,0 +1,112 @@ +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleInitialColorState = require("awayjs-renderergl/lib/animators/states/ParticleInitialColorState"); + +/** + * + */ +class ParticleInitialColorNode extends ParticleNodeBase +{ + //default values used when creating states + /** @private */ + public _iUsesMultiplier:boolean; + /** @private */ + public _iUsesOffset:boolean; + /** @private */ + public _iInitialColor:ColorTransform; + + /** + * Reference for color node properties on a single particle (when in local property mode). + * Expects a ColorTransform object representing the color transform applied to the particle. + */ + public static COLOR_INITIAL_COLORTRANSFORM:string = "ColorInitialColorTransform"; + + constructor(mode:number /*uint*/, usesMultiplier:boolean = true, usesOffset:boolean = false, initialColor:ColorTransform = null) + { + super("ParticleInitialColor", mode, (usesMultiplier && usesOffset)? 8 : 4, ParticleAnimationSet.COLOR_PRIORITY); + + this._pStateClass = ParticleInitialColorState; + + this._iUsesMultiplier = usesMultiplier; + this._iUsesOffset = usesOffset; + this._iInitialColor = initialColor || new ColorTransform(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var code:string = ""; + if (animationRegisterCache.needFragmentAnimation) { + + if (this._iUsesMultiplier) { + var multiplierValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleInitialColorState.MULTIPLIER_INDEX, multiplierValue.index); + + code += "mul " + animationRegisterCache.colorMulTarget + "," + multiplierValue + "," + animationRegisterCache.colorMulTarget + "\n"; + } + + if (this._iUsesOffset) { + var offsetValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.LOCAL_STATIC)? animationRegisterCache.getFreeVertexAttribute() : animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleInitialColorState.OFFSET_INDEX, offsetValue.index); + + code += "add " + animationRegisterCache.colorAddTarget + "," + offsetValue + "," + animationRegisterCache.colorAddTarget + "\n"; + } + } + + return code; + } + + /** + * @inheritDoc + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + if (this._iUsesMultiplier) + particleAnimationSet.hasColorMulNode = true; + if (this._iUsesOffset) + particleAnimationSet.hasColorAddNode = true; + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var initialColor:ColorTransform = param[ParticleInitialColorNode.COLOR_INITIAL_COLORTRANSFORM]; + if (!initialColor) + throw(new Error("there is no " + ParticleInitialColorNode.COLOR_INITIAL_COLORTRANSFORM + " in param!")); + + var i:number /*uint*/ = 0; + + //multiplier + if (this._iUsesMultiplier) { + this._pOneData[i++] = initialColor.redMultiplier; + this._pOneData[i++] = initialColor.greenMultiplier; + this._pOneData[i++] = initialColor.blueMultiplier; + this._pOneData[i++] = initialColor.alphaMultiplier; + } + //offset + if (this._iUsesOffset) { + this._pOneData[i++] = initialColor.redOffset/255; + this._pOneData[i++] = initialColor.greenOffset/255; + this._pOneData[i++] = initialColor.blueOffset/255; + this._pOneData[i++] = initialColor.alphaOffset/255; + } + + } + +} + +export = ParticleInitialColorNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleNodeBase.js b/lib/animators/nodes/ParticleNodeBase.js new file mode 100755 index 000000000..da6d7d6ff --- /dev/null +++ b/lib/animators/nodes/ParticleNodeBase.js @@ -0,0 +1,127 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +/** + * Provides an abstract base class for particle animation nodes. + */ +var ParticleNodeBase = (function (_super) { + __extends(ParticleNodeBase, _super); + /** + * Creates a new ParticleNodeBase object. + * + * @param name Defines the generic name of the particle animation node. + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param dataLength Defines the length of the data used by the node when in LOCAL_STATIC mode. + * @param [optional] priority the priority of the particle animation node, used to order the agal generated in a particle animation set. Defaults to 1. + */ + function ParticleNodeBase(name, mode /*uint*/, dataLength /*uint*/, priority) { + if (priority === void 0) { priority = 1; } + _super.call(this); + this._pDataLength = 3; + name = name + ParticleNodeBase.MODES[mode]; + this.name = name; + this._pMode = mode; + this._priority = priority; + this._pDataLength = dataLength; + this._pOneData = new Array(this._pDataLength); + } + Object.defineProperty(ParticleNodeBase.prototype, "mode", { + /** + * Returns the property mode of the particle animation node. Typically set in the node constructor + * + * @see away.animators.ParticlePropertiesMode + */ + get: function () { + return this._pMode; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleNodeBase.prototype, "priority", { + /** + * Returns the priority of the particle animation node, used to order the agal generated in a particle animation set. Set automatically on instantiation. + * + * @see away.animators.ParticleAnimationSet + * @see #getAGALVertexCode + */ + get: function () { + return this._priority; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleNodeBase.prototype, "dataLength", { + /** + * Returns the length of the data used by the node when in LOCAL_STATIC mode. Used to generate the local static data of the particle animation set. + * + * @see away.animators.ParticleAnimationSet + * @see #getAGALVertexCode + */ + get: function () { + return this._pDataLength; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleNodeBase.prototype, "oneData", { + /** + * Returns the generated data vector of the node after one particle pass during the generation of all local static data of the particle animation set. + * + * @see away.animators.ParticleAnimationSet + * @see #generatePropertyOfOneParticle + */ + get: function () { + return this._pOneData; + }, + enumerable: true, + configurable: true + }); + /** + * Returns the AGAL code of the particle animation node for use in the vertex shader. + */ + ParticleNodeBase.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + return ""; + }; + /** + * Returns the AGAL code of the particle animation node for use in the fragment shader. + */ + ParticleNodeBase.prototype.getAGALFragmentCode = function (shaderObject, animationRegisterCache) { + return ""; + }; + /** + * Returns the AGAL code of the particle animation node for use in the fragment shader when UV coordinates are required. + */ + ParticleNodeBase.prototype.getAGALUVCode = function (shaderObject, animationRegisterCache) { + return ""; + }; + /** + * Called internally by the particle animation set when assigning the set of static properties originally defined by the initParticleFunc of the set. + * + * @see away.animators.ParticleAnimationSet#initParticleFunc + */ + ParticleNodeBase.prototype._iGeneratePropertyOfOneParticle = function (param) { + }; + /** + * Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. + */ + ParticleNodeBase.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + }; + //modes alias + ParticleNodeBase.GLOBAL = 'Global'; + ParticleNodeBase.LOCAL_STATIC = 'LocalStatic'; + ParticleNodeBase.LOCAL_DYNAMIC = 'LocalDynamic'; + //modes list + ParticleNodeBase.MODES = { + 0: ParticleNodeBase.GLOBAL, + 1: ParticleNodeBase.LOCAL_STATIC, + 2: ParticleNodeBase.LOCAL_DYNAMIC + }; + return ParticleNodeBase; +})(AnimationNodeBase); +module.exports = ParticleNodeBase; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlenodebase.ts"],"names":["ParticleNodeBase","ParticleNodeBase.constructor","ParticleNodeBase.mode","ParticleNodeBase.priority","ParticleNodeBase.dataLength","ParticleNodeBase.oneData","ParticleNodeBase.getAGALVertexCode","ParticleNodeBase.getAGALFragmentCode","ParticleNodeBase.getAGALUVCode","ParticleNodeBase._iGeneratePropertyOfOneParticle","ParticleNodeBase._iProcessAnimationSetting"],"mappings":";;;;;;AAAA,IAAO,iBAAiB,WAAc,mDAAmD,CAAC,CAAC;AAQ3F,AAGA;;GADG;IACG,gBAAgB;IAASA,UAAzBA,gBAAgBA,UAA0BA;IAkE/CA;;;;;;;OAOGA;IACHA,SA1EKA,gBAAgBA,CA0ETA,IAAWA,EAAEA,IAAIA,CAAQA,QAADA,AAASA,EAAEA,UAAUA,CAAQA,QAADA,AAASA,EAAEA,QAA2BA;QAA3BC,wBAA2BA,GAA3BA,YAA2BA;QAErGA,iBAAOA,CAACA;QAvEFA,iBAAYA,GAAmBA,CAACA,CAACA;QAyEvCA,IAAIA,GAAGA,IAAIA,GAAGA,gBAAgBA,CAACA,KAAKA,CAACA,IAAIA,CAACA,CAACA;QAE3CA,IAAIA,CAACA,IAAIA,GAAGA,IAAIA,CAACA;QACjBA,IAAIA,CAACA,MAAMA,GAAGA,IAAIA,CAACA;QACnBA,IAAIA,CAACA,SAASA,GAAGA,QAAQA,CAACA;QAC1BA,IAAIA,CAACA,YAAYA,GAAGA,UAAUA,CAACA;QAE/BA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,KAAKA,CAASA,IAAIA,CAACA,YAAYA,CAACA,CAACA;IACvDA,CAACA;IA1DDD,sBAAWA,kCAAIA;QALfA;;;;WAIGA;aACHA;YAECE,MAAMA,CAACA,IAAIA,CAACA,MAAMA,CAACA;QACpBA,CAACA;;;OAAAF;IAQDA,sBAAWA,sCAAQA;QANnBA;;;;;WAKGA;aACHA;YAECG,MAAMA,CAACA,IAAIA,CAACA,SAASA,CAACA;QACvBA,CAACA;;;OAAAH;IAQDA,sBAAWA,wCAAUA;QANrBA;;;;;WAKGA;aACHA;YAECI,MAAMA,CAACA,IAAIA,CAACA,YAAYA,CAACA;QAC1BA,CAACA;;;OAAAJ;IAQDA,sBAAWA,qCAAOA;QANlBA;;;;;WAKGA;aACHA;YAECK,MAAMA,CAACA,IAAIA,CAACA,SAASA,CAACA;QACvBA,CAACA;;;OAAAL;IAwBDA;;OAEGA;IACIA,4CAAiBA,GAAxBA,UAAyBA,YAA6BA,EAAEA,sBAA6CA;QAEpGM,MAAMA,CAACA,EAAEA,CAACA;IACXA,CAACA;IAEDN;;OAEGA;IACIA,8CAAmBA,GAA1BA,UAA2BA,YAA6BA,EAAEA,sBAA6CA;QAEtGO,MAAMA,CAACA,EAAEA,CAACA;IACXA,CAACA;IAEDP;;OAEGA;IACIA,wCAAaA,GAApBA,UAAqBA,YAA6BA,EAAEA,sBAA6CA;QAEhGQ,MAAMA,CAACA,EAAEA,CAACA;IACXA,CAACA;IAEDR;;;;OAIGA;IACIA,0DAA+BA,GAAtCA,UAAuCA,KAAwBA;IAG/DS,CAACA;IAEDT;;OAEGA;IACIA,oDAAyBA,GAAhCA,UAAiCA,oBAAyCA;IAG1EU,CAACA;IAtHDV,aAAaA;IACEA,uBAAMA,GAAUA,QAAQA,CAACA;IACzBA,6BAAYA,GAAUA,aAAaA,CAACA;IACpCA,8BAAaA,GAAUA,cAAcA,CAACA;IAErDA,YAAYA;IACGA,sBAAKA,GACpBA;QACCA,CAACA,EAACA,gBAAgBA,CAACA,MAAMA;QACzBA,CAACA,EAACA,gBAAgBA,CAACA,YAAYA;QAC/BA,CAACA,EAACA,gBAAgBA,CAACA,aAAaA;KAChCA,CAACA;IA4GHA,uBAACA;AAADA,CAjIA,AAiICA,EAjI8B,iBAAiB,EAiI/C;AAED,AAA0B,iBAAjB,gBAAgB,CAAC","file":"animators/nodes/ParticleNodeBase.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import AnimationNodeBase\t\t\t\t= require(\"awayjs-core/lib/animators/nodes/AnimationNodeBase\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\n\n/**\n * Provides an abstract base class for particle animation nodes.\n */\nclass ParticleNodeBase extends AnimationNodeBase\n{\n\tprivate _priority:number /*int*/;\n\n\tpublic _pMode:number /*uint*/;\n\tpublic _pDataLength:number /*uint*/ = 3;\n\tpublic _pOneData:Array<number>;\n\n\tpublic _iDataOffset:number /*uint*/;\n\n\t//modes alias\n\tprivate static GLOBAL:string = 'Global';\n\tprivate static LOCAL_STATIC:string = 'LocalStatic';\n\tprivate static LOCAL_DYNAMIC:string = 'LocalDynamic';\n\n\t//modes list\n\tprivate static MODES:Object =\n\t{\n\t\t0:ParticleNodeBase.GLOBAL,\n\t\t1:ParticleNodeBase.LOCAL_STATIC,\n\t\t2:ParticleNodeBase.LOCAL_DYNAMIC\n\t};\n\n\t/**\n\t * Returns the property mode of the particle animation node. Typically set in the node constructor\n\t *\n\t * @see away.animators.ParticlePropertiesMode\n\t */\n\tpublic get mode():number /*uint*/\n\t{\n\t\treturn this._pMode;\n\t}\n\n\t/**\n\t * Returns the priority of the particle animation node, used to order the agal generated in a particle animation set. Set automatically on instantiation.\n\t *\n\t * @see away.animators.ParticleAnimationSet\n\t * @see #getAGALVertexCode\n\t */\n\tpublic get priority():number /*int*/\n\t{\n\t\treturn this._priority;\n\t}\n\n\t/**\n\t * Returns the length of the data used by the node when in <code>LOCAL_STATIC</code> mode. Used to generate the local static data of the particle animation set.\n\t *\n\t * @see away.animators.ParticleAnimationSet\n\t * @see #getAGALVertexCode\n\t */\n\tpublic get dataLength():number /*int*/\n\t{\n\t\treturn this._pDataLength;\n\t}\n\n\t/**\n\t * Returns the generated data vector of the node after one particle pass during the generation of all local static data of the particle animation set.\n\t *\n\t * @see away.animators.ParticleAnimationSet\n\t * @see #generatePropertyOfOneParticle\n\t */\n\tpublic get oneData():Array<number>\n\t{\n\t\treturn this._pOneData;\n\t}\n\n\t/**\n\t * Creates a new <code>ParticleNodeBase</code> object.\n\t *\n\t * @param               name            Defines the generic name of the particle animation node.\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param               dataLength      Defines the length of the data used by the node when in <code>LOCAL_STATIC</code> mode.\n\t * @param    [optional] priority        the priority of the particle animation node, used to order the agal generated in a particle animation set. Defaults to 1.\n\t */\n\tconstructor(name:string, mode:number /*uint*/, dataLength:number /*uint*/, priority:number /*int*/ = 1)\n\t{\n\t\tsuper();\n\n\t\tname = name + ParticleNodeBase.MODES[mode];\n\n\t\tthis.name = name;\n\t\tthis._pMode = mode;\n\t\tthis._priority = priority;\n\t\tthis._pDataLength = dataLength;\n\n\t\tthis._pOneData = new Array<number>(this._pDataLength);\n\t}\n\n\t/**\n\t * Returns the AGAL code of the particle animation node for use in the vertex shader.\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\treturn \"\";\n\t}\n\n\t/**\n\t * Returns the AGAL code of the particle animation node for use in the fragment shader.\n\t */\n\tpublic getAGALFragmentCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\treturn \"\";\n\t}\n\n\t/**\n\t * Returns the AGAL code of the particle animation node for use in the fragment shader when UV coordinates are required.\n\t */\n\tpublic getAGALUVCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\treturn \"\";\n\t}\n\n\t/**\n\t * Called internally by the particle animation set when assigning the set of static properties originally defined by the initParticleFunc of the set.\n\t *\n\t * @see away.animators.ParticleAnimationSet#initParticleFunc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\n\t}\n\n\t/**\n\t * Called internally by the particle animation set when determining the requirements of the particle animation node AGAL.\n\t */\n\tpublic _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet)\n\t{\n\n\t}\n}\n\nexport = ParticleNodeBase;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleNodeBase.ts b/lib/animators/nodes/ParticleNodeBase.ts new file mode 100644 index 000000000..4bdf0a66c --- /dev/null +++ b/lib/animators/nodes/ParticleNodeBase.ts @@ -0,0 +1,143 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); + +/** + * Provides an abstract base class for particle animation nodes. + */ +class ParticleNodeBase extends AnimationNodeBase +{ + private _priority:number /*int*/; + + public _pMode:number /*uint*/; + public _pDataLength:number /*uint*/ = 3; + public _pOneData:Array; + + public _iDataOffset:number /*uint*/; + + //modes alias + private static GLOBAL:string = 'Global'; + private static LOCAL_STATIC:string = 'LocalStatic'; + private static LOCAL_DYNAMIC:string = 'LocalDynamic'; + + //modes list + private static MODES:Object = + { + 0:ParticleNodeBase.GLOBAL, + 1:ParticleNodeBase.LOCAL_STATIC, + 2:ParticleNodeBase.LOCAL_DYNAMIC + }; + + /** + * Returns the property mode of the particle animation node. Typically set in the node constructor + * + * @see away.animators.ParticlePropertiesMode + */ + public get mode():number /*uint*/ + { + return this._pMode; + } + + /** + * Returns the priority of the particle animation node, used to order the agal generated in a particle animation set. Set automatically on instantiation. + * + * @see away.animators.ParticleAnimationSet + * @see #getAGALVertexCode + */ + public get priority():number /*int*/ + { + return this._priority; + } + + /** + * Returns the length of the data used by the node when in LOCAL_STATIC mode. Used to generate the local static data of the particle animation set. + * + * @see away.animators.ParticleAnimationSet + * @see #getAGALVertexCode + */ + public get dataLength():number /*int*/ + { + return this._pDataLength; + } + + /** + * Returns the generated data vector of the node after one particle pass during the generation of all local static data of the particle animation set. + * + * @see away.animators.ParticleAnimationSet + * @see #generatePropertyOfOneParticle + */ + public get oneData():Array + { + return this._pOneData; + } + + /** + * Creates a new ParticleNodeBase object. + * + * @param name Defines the generic name of the particle animation node. + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param dataLength Defines the length of the data used by the node when in LOCAL_STATIC mode. + * @param [optional] priority the priority of the particle animation node, used to order the agal generated in a particle animation set. Defaults to 1. + */ + constructor(name:string, mode:number /*uint*/, dataLength:number /*uint*/, priority:number /*int*/ = 1) + { + super(); + + name = name + ParticleNodeBase.MODES[mode]; + + this.name = name; + this._pMode = mode; + this._priority = priority; + this._pDataLength = dataLength; + + this._pOneData = new Array(this._pDataLength); + } + + /** + * Returns the AGAL code of the particle animation node for use in the vertex shader. + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + return ""; + } + + /** + * Returns the AGAL code of the particle animation node for use in the fragment shader. + */ + public getAGALFragmentCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + return ""; + } + + /** + * Returns the AGAL code of the particle animation node for use in the fragment shader when UV coordinates are required. + */ + public getAGALUVCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + return ""; + } + + /** + * Called internally by the particle animation set when assigning the set of static properties originally defined by the initParticleFunc of the set. + * + * @see away.animators.ParticleAnimationSet#initParticleFunc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + + } + + /** + * Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + + } +} + +export = ParticleNodeBase; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleOrbitNode.js b/lib/animators/nodes/ParticleOrbitNode.js new file mode 100755 index 000000000..09530b120 --- /dev/null +++ b/lib/animators/nodes/ParticleOrbitNode.js @@ -0,0 +1,130 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleOrbitState = require("awayjs-renderergl/lib/animators/states/ParticleOrbitState"); +/** + * A particle animation node used to control the position of a particle over time around a circular orbit. + */ +var ParticleOrbitNode = (function (_super) { + __extends(ParticleOrbitNode, _super); + /** + * Creates a new ParticleOrbitNode object. + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] usesEulers Defines whether the node uses the eulers property in the shader to calculate a rotation on the orbit. Defaults to true. + * @param [optional] usesCycle Defines whether the node uses the cycleDuration property in the shader to calculate the period of the orbit independent of particle duration. Defaults to false. + * @param [optional] usesPhase Defines whether the node uses the cyclePhase property in the shader to calculate a starting offset to the cycle rotation of the particle. Defaults to false. + * @param [optional] radius Defines the radius of the orbit when in global mode. Defaults to 100. + * @param [optional] cycleDuration Defines the duration of the orbit in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the phase of the orbit in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + * @param [optional] eulers Defines the euler rotation in degrees, applied to the orientation of the orbit when in global mode. + */ + function ParticleOrbitNode(mode /*uint*/, usesEulers, usesCycle, usesPhase, radius, cycleDuration, cyclePhase, eulers) { + if (usesEulers === void 0) { usesEulers = true; } + if (usesCycle === void 0) { usesCycle = false; } + if (usesPhase === void 0) { usesPhase = false; } + if (radius === void 0) { radius = 100; } + if (cycleDuration === void 0) { cycleDuration = 1; } + if (cyclePhase === void 0) { cyclePhase = 0; } + if (eulers === void 0) { eulers = null; } + var len = 3; + if (usesPhase) + len++; + _super.call(this, "ParticleOrbit", mode, len); + this._pStateClass = ParticleOrbitState; + this._iUsesEulers = usesEulers; + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + this._iRadius = radius; + this._iCycleDuration = cycleDuration; + this._iCyclePhase = cyclePhase; + this._iEulers = eulers || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticleOrbitNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var orbitRegister = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleOrbitState.ORBIT_INDEX, orbitRegister.index); + var eulersMatrixRegister = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleOrbitState.EULERS_INDEX, eulersMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + var temp1 = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var distance = new ShaderRegisterElement(temp1.regName, temp1.index); + var temp2 = animationRegisterCache.getFreeVertexVectorTemp(); + var cos = new ShaderRegisterElement(temp2.regName, temp2.index, 0); + var sin = new ShaderRegisterElement(temp2.regName, temp2.index, 1); + var degree = new ShaderRegisterElement(temp2.regName, temp2.index, 2); + animationRegisterCache.removeVertexTempUsage(temp1); + var code = ""; + if (this._iUsesCycle) { + code += "mul " + degree + "," + animationRegisterCache.vertexTime + "," + orbitRegister + ".y\n"; + if (this._iUsesPhase) + code += "add " + degree + "," + degree + "," + orbitRegister + ".w\n"; + } + else + code += "mul " + degree + "," + animationRegisterCache.vertexLife + "," + orbitRegister + ".y\n"; + code += "cos " + cos + "," + degree + "\n"; + code += "sin " + sin + "," + degree + "\n"; + code += "mul " + distance + ".x," + cos + "," + orbitRegister + ".x\n"; + code += "mul " + distance + ".y," + sin + "," + orbitRegister + ".x\n"; + code += "mov " + distance + ".wz" + animationRegisterCache.vertexZeroConst + "\n"; + if (this._iUsesEulers) + code += "m44 " + distance + "," + distance + "," + eulersMatrixRegister + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + if (animationRegisterCache.needVelocity) { + code += "neg " + distance + ".x," + sin + "\n"; + code += "mov " + distance + ".y," + cos + "\n"; + code += "mov " + distance + ".zw," + animationRegisterCache.vertexZeroConst + "\n"; + if (this._iUsesEulers) + code += "m44 " + distance + "," + distance + "," + eulersMatrixRegister + "\n"; + code += "mul " + distance + "," + distance + "," + orbitRegister + ".z\n"; + code += "div " + distance + "," + distance + "," + orbitRegister + ".y\n"; + if (!this._iUsesCycle) + code += "div " + distance + "," + distance + "," + animationRegisterCache.vertexLife + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz\n"; + } + return code; + }; + /** + * @inheritDoc + */ + ParticleOrbitNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleOrbitNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + //Vector3D.x is radius, Vector3D.y is cycle duration, Vector3D.z is phase + var orbit = param[ParticleOrbitNode.ORBIT_VECTOR3D]; + if (!orbit) + throw new Error("there is no " + ParticleOrbitNode.ORBIT_VECTOR3D + " in param!"); + this._pOneData[0] = orbit.x; + if (this._iUsesCycle && orbit.y <= 0) + throw (new Error("the cycle duration must be greater than zero")); + this._pOneData[1] = Math.PI * 2 / (!this._iUsesCycle ? 1 : orbit.y); + this._pOneData[2] = orbit.x * Math.PI * 2; + if (this._iUsesPhase) + this._pOneData[3] = orbit.z * Math.PI / 180; + }; + /** + * Reference for orbit node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the radius (x), cycle speed (y) and cycle phase (z) of the motion on the particle. + */ + ParticleOrbitNode.ORBIT_VECTOR3D = "OrbitVector3D"; + return ParticleOrbitNode; +})(ParticleNodeBase); +module.exports = ParticleOrbitNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particleorbitnode.ts"],"names":["ParticleOrbitNode","ParticleOrbitNode.constructor","ParticleOrbitNode.getAGALVertexCode","ParticleOrbitNode.getAnimationState","ParticleOrbitNode._iGeneratePropertyOfOneParticle"],"mappings":"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","file":"animators/nodes/ParticleOrbitNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleOrbitState\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleOrbitState\");\n\n/**\n * A particle animation node used to control the position of a particle over time around a circular orbit.\n */\nclass ParticleOrbitNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iUsesEulers:boolean;\n\n\t/** @private */\n\tpublic _iUsesCycle:boolean;\n\n\t/** @private */\n\tpublic _iUsesPhase:boolean;\n\n\t/** @private */\n\tpublic _iRadius:number;\n\t/** @private */\n\tpublic _iCycleDuration:number;\n\t/** @private */\n\tpublic _iCyclePhase:number;\n\t/** @private */\n\tpublic _iEulers:Vector3D;\n\n\t/**\n\t * Reference for orbit node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the radius (x), cycle speed (y) and cycle phase (z) of the motion on the particle.\n\t */\n\tpublic static ORBIT_VECTOR3D:string = \"OrbitVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleOrbitNode</code> object.\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] usesEulers      Defines whether the node uses the <code>eulers</code> property in the shader to calculate a rotation on the orbit. Defaults to true.\n\t * @param    [optional] usesCycle       Defines whether the node uses the <code>cycleDuration</code> property in the shader to calculate the period of the orbit independent of particle duration. Defaults to false.\n\t * @param    [optional] usesPhase       Defines whether the node uses the <code>cyclePhase</code> property in the shader to calculate a starting offset to the cycle rotation of the particle. Defaults to false.\n\t * @param    [optional] radius          Defines the radius of the orbit when in global mode. Defaults to 100.\n\t * @param    [optional] cycleDuration   Defines the duration of the orbit in seconds, used as a period independent of particle duration when in global mode. Defaults to 1.\n\t * @param    [optional] cyclePhase      Defines the phase of the orbit in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0.\n\t * @param    [optional] eulers          Defines the euler rotation in degrees, applied to the orientation of the orbit when in global mode.\n\t */\n\tconstructor(mode:number /*uint*/, usesEulers:boolean = true, usesCycle:boolean = false, usesPhase:boolean = false, radius:number = 100, cycleDuration:number = 1, cyclePhase:number = 0, eulers:Vector3D = null)\n\t{\n\t\tvar len:number /*int*/ = 3;\n\t\tif (usesPhase)\n\t\t\tlen++;\n\t\tsuper(\"ParticleOrbit\", mode, len);\n\n\t\tthis._pStateClass = ParticleOrbitState;\n\n\t\tthis._iUsesEulers = usesEulers;\n\t\tthis._iUsesCycle = usesCycle;\n\t\tthis._iUsesPhase = usesPhase;\n\n\t\tthis._iRadius = radius;\n\t\tthis._iCycleDuration = cycleDuration;\n\t\tthis._iCyclePhase = cyclePhase;\n\t\tthis._iEulers = eulers || new Vector3D();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar orbitRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleOrbitState.ORBIT_INDEX, orbitRegister.index);\n\n\t\tvar eulersMatrixRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleOrbitState.EULERS_INDEX, eulersMatrixRegister.index);\n\t\tanimationRegisterCache.getFreeVertexConstant();\n\t\tanimationRegisterCache.getFreeVertexConstant();\n\t\tanimationRegisterCache.getFreeVertexConstant();\n\n\t\tvar temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tanimationRegisterCache.addVertexTempUsages(temp1, 1);\n\t\tvar distance:ShaderRegisterElement = new ShaderRegisterElement(temp1.regName, temp1.index);\n\n\t\tvar temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tvar cos:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index, 0);\n\t\tvar sin:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index, 1);\n\t\tvar degree:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index, 2);\n\t\tanimationRegisterCache.removeVertexTempUsage(temp1);\n\n\t\tvar code:string = \"\";\n\n\t\tif (this._iUsesCycle) {\n\t\t\tcode += \"mul \" + degree + \",\" + animationRegisterCache.vertexTime + \",\" + orbitRegister + \".y\\n\";\n\n\t\t\tif (this._iUsesPhase)\n\t\t\t\tcode += \"add \" + degree + \",\" + degree + \",\" + orbitRegister + \".w\\n\";\n\t\t} else\n\t\t\tcode += \"mul \" + degree + \",\" + animationRegisterCache.vertexLife + \",\" + orbitRegister + \".y\\n\";\n\n\t\tcode += \"cos \" + cos + \",\" + degree + \"\\n\";\n\t\tcode += \"sin \" + sin + \",\" + degree + \"\\n\";\n\t\tcode += \"mul \" + distance + \".x,\" + cos + \",\" + orbitRegister + \".x\\n\";\n\t\tcode += \"mul \" + distance + \".y,\" + sin + \",\" + orbitRegister + \".x\\n\";\n\t\tcode += \"mov \" + distance + \".wz\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\tif (this._iUsesEulers)\n\t\t\tcode += \"m44 \" + distance + \",\" + distance + \",\" + eulersMatrixRegister + \"\\n\";\n\t\tcode += \"add \" + animationRegisterCache.positionTarget + \".xyz,\" + distance + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\n\t\tif (animationRegisterCache.needVelocity) {\n\t\t\tcode += \"neg \" + distance + \".x,\" + sin + \"\\n\";\n\t\t\tcode += \"mov \" + distance + \".y,\" + cos + \"\\n\";\n\t\t\tcode += \"mov \" + distance + \".zw,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tif (this._iUsesEulers)\n\t\t\t\tcode += \"m44 \" + distance + \",\" + distance + \",\" + eulersMatrixRegister + \"\\n\";\n\t\t\tcode += \"mul \" + distance + \",\" + distance + \",\" + orbitRegister + \".z\\n\";\n\t\t\tcode += \"div \" + distance + \",\" + distance + \",\" + orbitRegister + \".y\\n\";\n\t\t\tif (!this._iUsesCycle)\n\t\t\t\tcode += \"div \" + distance + \",\" + distance + \",\" + animationRegisterCache.vertexLife + \"\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.velocityTarget + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz,\" + distance + \".xyz\\n\";\n\t\t}\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleOrbitState\n\t{\n\t\treturn <ParticleOrbitState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\t//Vector3D.x is radius, Vector3D.y is cycle duration, Vector3D.z is phase\n\t\tvar orbit:Vector3D = param[ParticleOrbitNode.ORBIT_VECTOR3D];\n\t\tif (!orbit)\n\t\t\tthrow new Error(\"there is no \" + ParticleOrbitNode.ORBIT_VECTOR3D + \" in param!\");\n\n\t\tthis._pOneData[0] = orbit.x;\n\t\tif (this._iUsesCycle && orbit.y <= 0)\n\t\t\tthrow(new Error(\"the cycle duration must be greater than zero\"));\n\t\tthis._pOneData[1] = Math.PI*2/(!this._iUsesCycle? 1 : orbit.y);\n\t\tthis._pOneData[2] = orbit.x*Math.PI*2;\n\t\tif (this._iUsesPhase)\n\t\t\tthis._pOneData[3] = orbit.z*Math.PI/180;\n\t}\n}\n\nexport = ParticleOrbitNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleOrbitNode.ts b/lib/animators/nodes/ParticleOrbitNode.ts new file mode 100644 index 000000000..f56e8c6cc --- /dev/null +++ b/lib/animators/nodes/ParticleOrbitNode.ts @@ -0,0 +1,159 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleOrbitState = require("awayjs-renderergl/lib/animators/states/ParticleOrbitState"); + +/** + * A particle animation node used to control the position of a particle over time around a circular orbit. + */ +class ParticleOrbitNode extends ParticleNodeBase +{ + /** @private */ + public _iUsesEulers:boolean; + + /** @private */ + public _iUsesCycle:boolean; + + /** @private */ + public _iUsesPhase:boolean; + + /** @private */ + public _iRadius:number; + /** @private */ + public _iCycleDuration:number; + /** @private */ + public _iCyclePhase:number; + /** @private */ + public _iEulers:Vector3D; + + /** + * Reference for orbit node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the radius (x), cycle speed (y) and cycle phase (z) of the motion on the particle. + */ + public static ORBIT_VECTOR3D:string = "OrbitVector3D"; + + /** + * Creates a new ParticleOrbitNode object. + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] usesEulers Defines whether the node uses the eulers property in the shader to calculate a rotation on the orbit. Defaults to true. + * @param [optional] usesCycle Defines whether the node uses the cycleDuration property in the shader to calculate the period of the orbit independent of particle duration. Defaults to false. + * @param [optional] usesPhase Defines whether the node uses the cyclePhase property in the shader to calculate a starting offset to the cycle rotation of the particle. Defaults to false. + * @param [optional] radius Defines the radius of the orbit when in global mode. Defaults to 100. + * @param [optional] cycleDuration Defines the duration of the orbit in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the phase of the orbit in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + * @param [optional] eulers Defines the euler rotation in degrees, applied to the orientation of the orbit when in global mode. + */ + constructor(mode:number /*uint*/, usesEulers:boolean = true, usesCycle:boolean = false, usesPhase:boolean = false, radius:number = 100, cycleDuration:number = 1, cyclePhase:number = 0, eulers:Vector3D = null) + { + var len:number /*int*/ = 3; + if (usesPhase) + len++; + super("ParticleOrbit", mode, len); + + this._pStateClass = ParticleOrbitState; + + this._iUsesEulers = usesEulers; + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + + this._iRadius = radius; + this._iCycleDuration = cycleDuration; + this._iCyclePhase = cyclePhase; + this._iEulers = eulers || new Vector3D(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var orbitRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleOrbitState.ORBIT_INDEX, orbitRegister.index); + + var eulersMatrixRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleOrbitState.EULERS_INDEX, eulersMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + + var temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var distance:ShaderRegisterElement = new ShaderRegisterElement(temp1.regName, temp1.index); + + var temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var cos:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index, 0); + var sin:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index, 1); + var degree:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index, 2); + animationRegisterCache.removeVertexTempUsage(temp1); + + var code:string = ""; + + if (this._iUsesCycle) { + code += "mul " + degree + "," + animationRegisterCache.vertexTime + "," + orbitRegister + ".y\n"; + + if (this._iUsesPhase) + code += "add " + degree + "," + degree + "," + orbitRegister + ".w\n"; + } else + code += "mul " + degree + "," + animationRegisterCache.vertexLife + "," + orbitRegister + ".y\n"; + + code += "cos " + cos + "," + degree + "\n"; + code += "sin " + sin + "," + degree + "\n"; + code += "mul " + distance + ".x," + cos + "," + orbitRegister + ".x\n"; + code += "mul " + distance + ".y," + sin + "," + orbitRegister + ".x\n"; + code += "mov " + distance + ".wz" + animationRegisterCache.vertexZeroConst + "\n"; + if (this._iUsesEulers) + code += "m44 " + distance + "," + distance + "," + eulersMatrixRegister + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + + if (animationRegisterCache.needVelocity) { + code += "neg " + distance + ".x," + sin + "\n"; + code += "mov " + distance + ".y," + cos + "\n"; + code += "mov " + distance + ".zw," + animationRegisterCache.vertexZeroConst + "\n"; + if (this._iUsesEulers) + code += "m44 " + distance + "," + distance + "," + eulersMatrixRegister + "\n"; + code += "mul " + distance + "," + distance + "," + orbitRegister + ".z\n"; + code += "div " + distance + "," + distance + "," + orbitRegister + ".y\n"; + if (!this._iUsesCycle) + code += "div " + distance + "," + distance + "," + animationRegisterCache.vertexLife + "\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz\n"; + } + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleOrbitState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + //Vector3D.x is radius, Vector3D.y is cycle duration, Vector3D.z is phase + var orbit:Vector3D = param[ParticleOrbitNode.ORBIT_VECTOR3D]; + if (!orbit) + throw new Error("there is no " + ParticleOrbitNode.ORBIT_VECTOR3D + " in param!"); + + this._pOneData[0] = orbit.x; + if (this._iUsesCycle && orbit.y <= 0) + throw(new Error("the cycle duration must be greater than zero")); + this._pOneData[1] = Math.PI*2/(!this._iUsesCycle? 1 : orbit.y); + this._pOneData[2] = orbit.x*Math.PI*2; + if (this._iUsesPhase) + this._pOneData[3] = orbit.z*Math.PI/180; + } +} + +export = ParticleOrbitNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleOscillatorNode.js b/lib/animators/nodes/ParticleOscillatorNode.js new file mode 100755 index 000000000..e67ce1a21 --- /dev/null +++ b/lib/animators/nodes/ParticleOscillatorNode.js @@ -0,0 +1,85 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleOscillatorState = require("awayjs-renderergl/lib/animators/states/ParticleOscillatorState"); +/** + * A particle animation node used to control the position of a particle over time using simple harmonic motion. + */ +var ParticleOscillatorNode = (function (_super) { + __extends(ParticleOscillatorNode, _super); + /** + * Creates a new ParticleOscillatorNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] oscillator Defines the default oscillator axis (x, y, z) and cycleDuration (w) of the node, used when in global mode. + */ + function ParticleOscillatorNode(mode /*uint*/, oscillator) { + if (oscillator === void 0) { oscillator = null; } + _super.call(this, "ParticleOscillator", mode, 4); + this._pStateClass = ParticleOscillatorState; + this._iOscillator = oscillator || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticleOscillatorNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var oscillatorRegister = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleOscillatorState.OSCILLATOR_INDEX, oscillatorRegister.index); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + var dgree = new ShaderRegisterElement(temp.regName, temp.index, 0); + var sin = new ShaderRegisterElement(temp.regName, temp.index, 1); + var cos = new ShaderRegisterElement(temp.regName, temp.index, 2); + animationRegisterCache.addVertexTempUsages(temp, 1); + var temp2 = animationRegisterCache.getFreeVertexVectorTemp(); + var distance = new ShaderRegisterElement(temp2.regName, temp2.index); + animationRegisterCache.removeVertexTempUsage(temp); + var code = ""; + code += "mul " + dgree + "," + animationRegisterCache.vertexTime + "," + oscillatorRegister + ".w\n"; + code += "sin " + sin + "," + dgree + "\n"; + code += "mul " + distance + ".xyz," + sin + "," + oscillatorRegister + ".xyz\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + if (animationRegisterCache.needVelocity) { + code += "cos " + cos + "," + dgree + "\n"; + code += "mul " + distance + ".xyz," + cos + "," + oscillatorRegister + ".xyz\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + } + return code; + }; + /** + * @inheritDoc + */ + ParticleOscillatorNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleOscillatorNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + //(Vector3D.x,Vector3D.y,Vector3D.z) is oscillator axis, Vector3D.w is oscillator cycle duration + var drift = param[ParticleOscillatorNode.OSCILLATOR_VECTOR3D]; + if (!drift) + throw (new Error("there is no " + ParticleOscillatorNode.OSCILLATOR_VECTOR3D + " in param!")); + this._pOneData[0] = drift.x; + this._pOneData[1] = drift.y; + this._pOneData[2] = drift.z; + if (drift.w <= 0) + throw (new Error("the cycle duration must greater than zero")); + this._pOneData[3] = Math.PI * 2 / drift.w; + }; + /** + * Reference for ocsillator node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the axis (x,y,z) and cycle speed (w) of the motion on the particle. + */ + ParticleOscillatorNode.OSCILLATOR_VECTOR3D = "OscillatorVector3D"; + return ParticleOscillatorNode; +})(ParticleNodeBase); +module.exports = ParticleOscillatorNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particleoscillatornode.ts"],"names":["ParticleOscillatorNode","ParticleOscillatorNode.constructor","ParticleOscillatorNode.getAGALVertexCode","ParticleOscillatorNode.getAnimationState","ParticleOscillatorNode._iGeneratePropertyOfOneParticle"],"mappings":"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","file":"animators/nodes/ParticleOscillatorNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleOscillatorState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleOscillatorState\");\n\n/**\n * A particle animation node used to control the position of a particle over time using simple harmonic motion.\n */\nclass ParticleOscillatorNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iOscillator:Vector3D;\n\n\t/**\n\t * Reference for ocsillator node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the axis (x,y,z) and cycle speed (w) of the motion on the particle.\n\t */\n\tpublic static OSCILLATOR_VECTOR3D:string = \"OscillatorVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleOscillatorNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] oscillator      Defines the default oscillator axis (x, y, z) and cycleDuration (w) of the node, used when in global mode.\n\t */\n\tconstructor(mode:number /*uint*/, oscillator:Vector3D = null)\n\t{\n\t\tsuper(\"ParticleOscillator\", mode, 4);\n\n\t\tthis._pStateClass = ParticleOscillatorState;\n\n\t\tthis._iOscillator = oscillator || new Vector3D();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar oscillatorRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleOscillatorState.OSCILLATOR_INDEX, oscillatorRegister.index);\n\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tvar dgree:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0);\n\t\tvar sin:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1);\n\t\tvar cos:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 2);\n\t\tanimationRegisterCache.addVertexTempUsages(temp, 1);\n\t\tvar temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tvar distance:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index);\n\t\tanimationRegisterCache.removeVertexTempUsage(temp);\n\n\t\tvar code:string = \"\";\n\t\tcode += \"mul \" + dgree + \",\" + animationRegisterCache.vertexTime + \",\" + oscillatorRegister + \".w\\n\";\n\t\tcode += \"sin \" + sin + \",\" + dgree + \"\\n\";\n\t\tcode += \"mul \" + distance + \".xyz,\" + sin + \",\" + oscillatorRegister + \".xyz\\n\";\n\t\tcode += \"add \" + animationRegisterCache.positionTarget + \".xyz,\" + distance + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\n\t\tif (animationRegisterCache.needVelocity) {\n\t\t\tcode += \"cos \" + cos + \",\" + dgree + \"\\n\";\n\t\t\tcode += \"mul \" + distance + \".xyz,\" + cos + \",\" + oscillatorRegister + \".xyz\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.velocityTarget + \".xyz,\" + distance + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz\\n\";\n\t\t}\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleOscillatorState\n\t{\n\t\treturn <ParticleOscillatorState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\t//(Vector3D.x,Vector3D.y,Vector3D.z) is oscillator axis, Vector3D.w is oscillator cycle duration\n\t\tvar drift:Vector3D = param[ParticleOscillatorNode.OSCILLATOR_VECTOR3D];\n\t\tif (!drift)\n\t\t\tthrow(new Error(\"there is no \" + ParticleOscillatorNode.OSCILLATOR_VECTOR3D + \" in param!\"));\n\n\t\tthis._pOneData[0] = drift.x;\n\t\tthis._pOneData[1] = drift.y;\n\t\tthis._pOneData[2] = drift.z;\n\t\tif (drift.w <= 0)\n\t\t\tthrow(new Error(\"the cycle duration must greater than zero\"));\n\t\tthis._pOneData[3] = Math.PI*2/drift.w;\n\t}\n}\n\nexport = ParticleOscillatorNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleOscillatorNode.ts b/lib/animators/nodes/ParticleOscillatorNode.ts new file mode 100644 index 000000000..f6fb73a2b --- /dev/null +++ b/lib/animators/nodes/ParticleOscillatorNode.ts @@ -0,0 +1,100 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleOscillatorState = require("awayjs-renderergl/lib/animators/states/ParticleOscillatorState"); + +/** + * A particle animation node used to control the position of a particle over time using simple harmonic motion. + */ +class ParticleOscillatorNode extends ParticleNodeBase +{ + /** @private */ + public _iOscillator:Vector3D; + + /** + * Reference for ocsillator node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the axis (x,y,z) and cycle speed (w) of the motion on the particle. + */ + public static OSCILLATOR_VECTOR3D:string = "OscillatorVector3D"; + + /** + * Creates a new ParticleOscillatorNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] oscillator Defines the default oscillator axis (x, y, z) and cycleDuration (w) of the node, used when in global mode. + */ + constructor(mode:number /*uint*/, oscillator:Vector3D = null) + { + super("ParticleOscillator", mode, 4); + + this._pStateClass = ParticleOscillatorState; + + this._iOscillator = oscillator || new Vector3D(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var oscillatorRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleOscillatorState.OSCILLATOR_INDEX, oscillatorRegister.index); + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var dgree:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0); + var sin:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1); + var cos:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 2); + animationRegisterCache.addVertexTempUsages(temp, 1); + var temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var distance:ShaderRegisterElement = new ShaderRegisterElement(temp2.regName, temp2.index); + animationRegisterCache.removeVertexTempUsage(temp); + + var code:string = ""; + code += "mul " + dgree + "," + animationRegisterCache.vertexTime + "," + oscillatorRegister + ".w\n"; + code += "sin " + sin + "," + dgree + "\n"; + code += "mul " + distance + ".xyz," + sin + "," + oscillatorRegister + ".xyz\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + + if (animationRegisterCache.needVelocity) { + code += "cos " + cos + "," + dgree + "\n"; + code += "mul " + distance + ".xyz," + cos + "," + oscillatorRegister + ".xyz\n"; + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + distance + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + } + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleOscillatorState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + //(Vector3D.x,Vector3D.y,Vector3D.z) is oscillator axis, Vector3D.w is oscillator cycle duration + var drift:Vector3D = param[ParticleOscillatorNode.OSCILLATOR_VECTOR3D]; + if (!drift) + throw(new Error("there is no " + ParticleOscillatorNode.OSCILLATOR_VECTOR3D + " in param!")); + + this._pOneData[0] = drift.x; + this._pOneData[1] = drift.y; + this._pOneData[2] = drift.z; + if (drift.w <= 0) + throw(new Error("the cycle duration must greater than zero")); + this._pOneData[3] = Math.PI*2/drift.w; + } +} + +export = ParticleOscillatorNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticlePositionNode.js b/lib/animators/nodes/ParticlePositionNode.js new file mode 100755 index 000000000..1c99e8232 --- /dev/null +++ b/lib/animators/nodes/ParticlePositionNode.js @@ -0,0 +1,62 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticlePositionState = require("awayjs-renderergl/lib/animators/states/ParticlePositionState"); +/** + * A particle animation node used to set the starting position of a particle. + */ +var ParticlePositionNode = (function (_super) { + __extends(ParticlePositionNode, _super); + /** + * Creates a new ParticlePositionNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] position Defines the default position of the particle when in global mode. Defaults to 0,0,0. + */ + function ParticlePositionNode(mode /*uint*/, position) { + if (position === void 0) { position = null; } + _super.call(this, "ParticlePosition", mode, 3); + this._pStateClass = ParticlePositionState; + this._iPosition = position || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticlePositionNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var positionAttribute = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticlePositionState.POSITION_INDEX, positionAttribute.index); + return "add " + animationRegisterCache.positionTarget + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + }; + /** + * @inheritDoc + */ + ParticlePositionNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticlePositionNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var offset = param[ParticlePositionNode.POSITION_VECTOR3D]; + if (!offset) + throw (new Error("there is no " + ParticlePositionNode.POSITION_VECTOR3D + " in param!")); + this._pOneData[0] = offset.x; + this._pOneData[1] = offset.y; + this._pOneData[2] = offset.z; + }; + /** + * Reference for position node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing position of the particle. + */ + ParticlePositionNode.POSITION_VECTOR3D = "PositionVector3D"; + return ParticlePositionNode; +})(ParticleNodeBase); +module.exports = ParticlePositionNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/ParticlePositionNode.ts b/lib/animators/nodes/ParticlePositionNode.ts new file mode 100644 index 000000000..e811771a6 --- /dev/null +++ b/lib/animators/nodes/ParticlePositionNode.ts @@ -0,0 +1,76 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticlePositionState = require("awayjs-renderergl/lib/animators/states/ParticlePositionState"); + +/** + * A particle animation node used to set the starting position of a particle. + */ +class ParticlePositionNode extends ParticleNodeBase +{ + /** @private */ + public _iPosition:Vector3D; + + /** + * Reference for position node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing position of the particle. + */ + public static POSITION_VECTOR3D:string = "PositionVector3D"; + + /** + * Creates a new ParticlePositionNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] position Defines the default position of the particle when in global mode. Defaults to 0,0,0. + */ + constructor(mode:number /*uint*/, position:Vector3D = null) + { + super("ParticlePosition", mode, 3); + + this._pStateClass = ParticlePositionState; + + this._iPosition = position || new Vector3D(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var positionAttribute:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticlePositionState.POSITION_INDEX, positionAttribute.index); + + return "add " + animationRegisterCache.positionTarget + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticlePositionState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var offset:Vector3D = param[ParticlePositionNode.POSITION_VECTOR3D]; + if (!offset) + throw(new Error("there is no " + ParticlePositionNode.POSITION_VECTOR3D + " in param!")); + + this._pOneData[0] = offset.x; + this._pOneData[1] = offset.y; + this._pOneData[2] = offset.z; + } +} + +export = ParticlePositionNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleRotateToHeadingNode.js b/lib/animators/nodes/ParticleRotateToHeadingNode.js new file mode 100755 index 000000000..dd7a1619c --- /dev/null +++ b/lib/animators/nodes/ParticleRotateToHeadingNode.js @@ -0,0 +1,163 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleRotateToHeadingState = require("awayjs-renderergl/lib/animators/states/ParticleRotateToHeadingState"); +/** + * A particle animation node used to control the rotation of a particle to match its heading vector. + */ +var ParticleRotateToHeadingNode = (function (_super) { + __extends(ParticleRotateToHeadingNode, _super); + /** + * Creates a new ParticleBillboardNode + */ + function ParticleRotateToHeadingNode() { + _super.call(this, "ParticleRotateToHeading", ParticlePropertiesMode.GLOBAL, 0, 3); + this._pStateClass = ParticleRotateToHeadingState; + } + /** + * @inheritDoc + */ + ParticleRotateToHeadingNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var code = ""; + var len = animationRegisterCache.rotationRegisters.length; + var i /*int*/; + if (animationRegisterCache.hasBillboard) { + var temp1 = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var temp2 = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp2, 1); + var temp3 = animationRegisterCache.getFreeVertexVectorTemp(); + var rotationMatrixRegister = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleRotateToHeadingState.MATRIX_INDEX, rotationMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.removeVertexTempUsage(temp1); + animationRegisterCache.removeVertexTempUsage(temp2); + //process the velocity + code += "m33 " + temp1 + ".xyz," + animationRegisterCache.velocityTarget + ".xyz," + rotationMatrixRegister + "\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".xy," + temp1 + ".xy\n"; + code += "nrm " + temp3 + ".xyz," + temp3 + ".xyz\n"; + //temp3.x=cos,temp3.y=sin + //only process z axis + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".x," + temp3 + ".y\n"; + code += "mov " + temp2 + ".y," + temp3 + ".x\n"; + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + temp3 + ".x\n"; + code += "neg " + temp1 + ".y," + temp3 + ".y\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".z," + animationRegisterCache.vertexOneConst + "\n"; + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + else { + var nrmVel = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(nrmVel, 1); + var xAxis = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(xAxis, 1); + var R = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(R, 1); + var R_rev = animationRegisterCache.getFreeVertexVectorTemp(); + var cos = new ShaderRegisterElement(R.regName, R.index, 3); + var sin = new ShaderRegisterElement(R_rev.regName, R_rev.index, 3); + var cos2 = new ShaderRegisterElement(nrmVel.regName, nrmVel.index, 3); + var tempSingle = sin; + animationRegisterCache.removeVertexTempUsage(nrmVel); + animationRegisterCache.removeVertexTempUsage(xAxis); + animationRegisterCache.removeVertexTempUsage(R); + code += "mov " + xAxis + ".x," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + xAxis + ".yz," + animationRegisterCache.vertexZeroConst + "\n"; + code += "nrm " + nrmVel + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + code += "dp3 " + cos2 + "," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + xAxis + ".xyz," + nrmVel + ".xyz\n"; + code += "nrm " + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + //use R as temp to judge if nrm is (0,0,0). + //if nrm is (0,0,0) ,change it to (0,0,1). + code += "dp3 " + R + ".x," + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + code += "sge " + R + ".x," + animationRegisterCache.vertexZeroConst + "," + R + ".x\n"; + code += "add " + nrmVel + ".z," + R + ".x," + nrmVel + ".z\n"; + code += "add " + tempSingle + "," + cos2 + "," + animationRegisterCache.vertexOneConst + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + cos + "," + tempSingle + "\n"; + code += "sub " + tempSingle + "," + animationRegisterCache.vertexOneConst + "," + cos2 + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + sin + "," + tempSingle + "\n"; + code += "mul " + R + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + //use cos as R.w + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + //use cos as R_rev.w + //nrmVel and xAxis are used as temp register + code += "crs " + nrmVel + ".xyz," + R + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + //use cos as R.w + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + R + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + code += "crs " + R + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + //code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," +R_rev + ".w\n"; + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + R + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + for (i = 0; i < len; i++) { + //just repeat the calculate above + //because of the limited registers, no need to optimise + code += "mov " + xAxis + ".x," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + xAxis + ".yz," + animationRegisterCache.vertexZeroConst + "\n"; + code += "nrm " + nrmVel + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + code += "dp3 " + cos2 + "," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + xAxis + ".xyz," + nrmVel + ".xyz\n"; + code += "nrm " + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + code += "dp3 " + R + ".x," + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + code += "sge " + R + ".x," + animationRegisterCache.vertexZeroConst + "," + R + ".x\n"; + code += "add " + nrmVel + ".z," + R + ".x," + nrmVel + ".z\n"; + code += "add " + tempSingle + "," + cos2 + "," + animationRegisterCache.vertexOneConst + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + cos + "," + tempSingle + "\n"; + code += "sub " + tempSingle + "," + animationRegisterCache.vertexOneConst + "," + cos2 + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + sin + "," + tempSingle + "\n"; + code += "mul " + R + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + R + ".xyz," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + R + ".xyz," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + code += "crs " + R + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + R + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + } + } + return code; + }; + /** + * @inheritDoc + */ + ParticleRotateToHeadingNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleRotateToHeadingNode.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + particleAnimationSet.needVelocity = true; + }; + return ParticleRotateToHeadingNode; +})(ParticleNodeBase); +module.exports = ParticleRotateToHeadingNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlerotatetoheadingnode.ts"],"names":["ParticleRotateToHeadingNode","ParticleRotateToHeadingNode.constructor","ParticleRotateToHeadingNode.getAGALVertexCode","ParticleRotateToHeadingNode.getAnimationState","ParticleRotateToHeadingNode._iProcessAnimationSetting"],"mappings":"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","file":"animators/nodes/ParticleRotateToHeadingNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleRotateToHeadingState\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleRotateToHeadingState\");\n\n/**\n * A particle animation node used to control the rotation of a particle to match its heading vector.\n */\nclass ParticleRotateToHeadingNode extends ParticleNodeBase\n{\n\t/**\n\t * Creates a new <code>ParticleBillboardNode</code>\n\t */\n\tconstructor()\n\t{\n\t\tsuper(\"ParticleRotateToHeading\", ParticlePropertiesMode.GLOBAL, 0, 3);\n\n\t\tthis._pStateClass = ParticleRotateToHeadingState;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar len:number /*int*/ = animationRegisterCache.rotationRegisters.length;\n\t\tvar i:number /*int*/;\n\t\tif (animationRegisterCache.hasBillboard) {\n\t\t\tvar temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(temp1, 1);\n\t\t\tvar temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(temp2, 1);\n\t\t\tvar temp3:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\n\t\t\tvar rotationMatrixRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleRotateToHeadingState.MATRIX_INDEX, rotationMatrixRegister.index);\n\t\t\tanimationRegisterCache.getFreeVertexConstant();\n\t\t\tanimationRegisterCache.getFreeVertexConstant();\n\t\t\tanimationRegisterCache.getFreeVertexConstant();\n\n\t\t\tanimationRegisterCache.removeVertexTempUsage(temp1);\n\t\t\tanimationRegisterCache.removeVertexTempUsage(temp2);\n\n\t\t\t//process the velocity\n\t\t\tcode += \"m33 \" + temp1 + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz,\" + rotationMatrixRegister + \"\\n\";\n\n\t\t\tcode += \"mov \" + temp3 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp3 + \".xy,\" + temp1 + \".xy\\n\";\n\t\t\tcode += \"nrm \" + temp3 + \".xyz,\" + temp3 + \".xyz\\n\";\n\n\t\t\t//temp3.x=cos,temp3.y=sin\n\t\t\t//only process z axis\n\t\t\tcode += \"mov \" + temp2 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp2 + \".x,\" + temp3 + \".y\\n\";\n\t\t\tcode += \"mov \" + temp2 + \".y,\" + temp3 + \".x\\n\";\n\t\t\tcode += \"mov \" + temp1 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp1 + \".x,\" + temp3 + \".x\\n\";\n\t\t\tcode += \"neg \" + temp1 + \".y,\" + temp3 + \".y\\n\";\n\t\t\tcode += \"mov \" + temp3 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp3 + \".z,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\tcode += \"m33 \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp1 + \"\\n\";\n\t\t\tfor (i = 0; i < len; i++)\n\t\t\t\tcode += \"m33 \" + animationRegisterCache.rotationRegisters[i] + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \",\" + temp1 + \"\\n\";\n\t\t} else {\n\t\t\tvar nrmVel:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(nrmVel, 1);\n\n\t\t\tvar xAxis:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(xAxis, 1);\n\n\t\t\tvar R:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(R, 1);\n\t\t\tvar R_rev:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tvar cos:ShaderRegisterElement = new ShaderRegisterElement(R.regName, R.index, 3);\n\t\t\tvar sin:ShaderRegisterElement = new ShaderRegisterElement(R_rev.regName, R_rev.index, 3);\n\t\t\tvar cos2:ShaderRegisterElement = new ShaderRegisterElement(nrmVel.regName, nrmVel.index, 3);\n\t\t\tvar tempSingle:ShaderRegisterElement = sin;\n\n\t\t\tanimationRegisterCache.removeVertexTempUsage(nrmVel);\n\t\t\tanimationRegisterCache.removeVertexTempUsage(xAxis);\n\t\t\tanimationRegisterCache.removeVertexTempUsage(R);\n\n\t\t\tcode += \"mov \" + xAxis + \".x,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\tcode += \"mov \" + xAxis + \".yz,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\n\t\t\tcode += \"nrm \" + nrmVel + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz\\n\";\n\t\t\tcode += \"dp3 \" + cos2 + \",\" + nrmVel + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\tcode += \"crs \" + nrmVel + \".xyz,\" + xAxis + \".xyz,\" + nrmVel + \".xyz\\n\";\n\t\t\tcode += \"nrm \" + nrmVel + \".xyz,\" + nrmVel + \".xyz\\n\";\n\t\t\t//use R as temp to judge if nrm is (0,0,0).\n\t\t\t//if nrm is (0,0,0) ,change it to (0,0,1).\n\t\t\tcode += \"dp3 \" + R + \".x,\" + nrmVel + \".xyz,\" + nrmVel + \".xyz\\n\";\n\t\t\tcode += \"sge \" + R + \".x,\" + animationRegisterCache.vertexZeroConst + \",\" + R + \".x\\n\";\n\t\t\tcode += \"add \" + nrmVel + \".z,\" + R + \".x,\" + nrmVel + \".z\\n\";\n\n\t\t\tcode += \"add \" + tempSingle + \",\" + cos2 + \",\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\tcode += \"div \" + tempSingle + \",\" + tempSingle + \",\" + animationRegisterCache.vertexTwoConst + \"\\n\";\n\t\t\tcode += \"sqt \" + cos + \",\" + tempSingle + \"\\n\";\n\n\t\t\tcode += \"sub \" + tempSingle + \",\" + animationRegisterCache.vertexOneConst + \",\" + cos2 + \"\\n\";\n\t\t\tcode += \"div \" + tempSingle + \",\" + tempSingle + \",\" + animationRegisterCache.vertexTwoConst + \"\\n\";\n\t\t\tcode += \"sqt \" + sin + \",\" + tempSingle + \"\\n\";\n\n\t\t\tcode += \"mul \" + R + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\n\t\t\t//use cos as R.w\n\n\t\t\tcode += \"mul \" + R_rev + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\t\t\tcode += \"neg \" + R_rev + \".xyz,\" + R_rev + \".xyz\\n\";\n\n\t\t\t//use cos as R_rev.w\n\n\t\t\t//nrmVel and xAxis are used as temp register\n\t\t\tcode += \"crs \" + nrmVel + \".xyz,\" + R + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\n\t\t\t//use cos as R.w\n\t\t\tcode += \"mul \" + xAxis + \".xyz,\" + cos + \",\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\t\t\tcode += \"add \" + nrmVel + \".xyz,\" + nrmVel + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\tcode += \"dp3 \" + xAxis + \".w,\" + R + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\t\t\tcode += \"neg \" + nrmVel + \".w,\" + xAxis + \".w\\n\";\n\n\t\t\tcode += \"crs \" + R + \".xyz,\" + nrmVel + \".xyz,\" + R_rev + \".xyz\\n\";\n\t\t\t//code += \"mul \" + xAxis + \".xyzw,\" + nrmVel + \".xyzw,\" +R_rev + \".w\\n\";\n\t\t\tcode += \"mul \" + xAxis + \".xyzw,\" + nrmVel + \".xyzw,\" + cos + \"\\n\";\n\t\t\tcode += \"add \" + R + \".xyz,\" + R + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\tcode += \"mul \" + xAxis + \".xyz,\" + nrmVel + \".w,\" + R_rev + \".xyz\\n\";\n\n\t\t\tcode += \"add \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + R + \".xyz,\" + xAxis + \".xyz\\n\";\n\n\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\t//just repeat the calculate above\n\t\t\t\t//because of the limited registers, no need to optimise\n\t\t\t\tcode += \"mov \" + xAxis + \".x,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\t\tcode += \"mov \" + xAxis + \".yz,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\t\tcode += \"nrm \" + nrmVel + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz\\n\";\n\t\t\t\tcode += \"dp3 \" + cos2 + \",\" + nrmVel + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\t\tcode += \"crs \" + nrmVel + \".xyz,\" + xAxis + \".xyz,\" + nrmVel + \".xyz\\n\";\n\t\t\t\tcode += \"nrm \" + nrmVel + \".xyz,\" + nrmVel + \".xyz\\n\";\n\t\t\t\tcode += \"dp3 \" + R + \".x,\" + nrmVel + \".xyz,\" + nrmVel + \".xyz\\n\";\n\t\t\t\tcode += \"sge \" + R + \".x,\" + animationRegisterCache.vertexZeroConst + \",\" + R + \".x\\n\";\n\t\t\t\tcode += \"add \" + nrmVel + \".z,\" + R + \".x,\" + nrmVel + \".z\\n\";\n\t\t\t\tcode += \"add \" + tempSingle + \",\" + cos2 + \",\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\t\tcode += \"div \" + tempSingle + \",\" + tempSingle + \",\" + animationRegisterCache.vertexTwoConst + \"\\n\";\n\t\t\t\tcode += \"sqt \" + cos + \",\" + tempSingle + \"\\n\";\n\t\t\t\tcode += \"sub \" + tempSingle + \",\" + animationRegisterCache.vertexOneConst + \",\" + cos2 + \"\\n\";\n\t\t\t\tcode += \"div \" + tempSingle + \",\" + tempSingle + \",\" + animationRegisterCache.vertexTwoConst + \"\\n\";\n\t\t\t\tcode += \"sqt \" + sin + \",\" + tempSingle + \"\\n\";\n\t\t\t\tcode += \"mul \" + R + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\t\t\t\tcode += \"mul \" + R_rev + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\t\t\t\tcode += \"neg \" + R_rev + \".xyz,\" + R_rev + \".xyz\\n\";\n\t\t\t\tcode += \"crs \" + nrmVel + \".xyz,\" + R + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \".xyz\\n\";\n\t\t\t\tcode += \"mul \" + xAxis + \".xyz,\" + cos + \",\" + animationRegisterCache.rotationRegisters[i] + \".xyz\\n\";\n\t\t\t\tcode += \"add \" + nrmVel + \".xyz,\" + nrmVel + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\t\tcode += \"dp3 \" + xAxis + \".w,\" + R + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \".xyz\\n\";\n\t\t\t\tcode += \"neg \" + nrmVel + \".w,\" + xAxis + \".w\\n\";\n\t\t\t\tcode += \"crs \" + R + \".xyz,\" + nrmVel + \".xyz,\" + R_rev + \".xyz\\n\";\n\t\t\t\tcode += \"mul \" + xAxis + \".xyzw,\" + nrmVel + \".xyzw,\" + cos + \"\\n\";\n\t\t\t\tcode += \"add \" + R + \".xyz,\" + R + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\t\tcode += \"mul \" + xAxis + \".xyz,\" + nrmVel + \".w,\" + R_rev + \".xyz\\n\";\n\t\t\t\tcode += \"add \" + animationRegisterCache.rotationRegisters[i] + \".xyz,\" + R + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\t}\n\n\t\t}\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleRotateToHeadingState\n\t{\n\t\treturn <ParticleRotateToHeadingState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet)\n\t{\n\t\tparticleAnimationSet.needVelocity = true;\n\t}\n}\n\nexport = ParticleRotateToHeadingNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleRotateToHeadingNode.ts b/lib/animators/nodes/ParticleRotateToHeadingNode.ts new file mode 100644 index 000000000..f9ee42d93 --- /dev/null +++ b/lib/animators/nodes/ParticleRotateToHeadingNode.ts @@ -0,0 +1,193 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleRotateToHeadingState = require("awayjs-renderergl/lib/animators/states/ParticleRotateToHeadingState"); + +/** + * A particle animation node used to control the rotation of a particle to match its heading vector. + */ +class ParticleRotateToHeadingNode extends ParticleNodeBase +{ + /** + * Creates a new ParticleBillboardNode + */ + constructor() + { + super("ParticleRotateToHeading", ParticlePropertiesMode.GLOBAL, 0, 3); + + this._pStateClass = ParticleRotateToHeadingState; + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var code:string = ""; + var len:number /*int*/ = animationRegisterCache.rotationRegisters.length; + var i:number /*int*/; + if (animationRegisterCache.hasBillboard) { + var temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp2, 1); + var temp3:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + + var rotationMatrixRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleRotateToHeadingState.MATRIX_INDEX, rotationMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + + animationRegisterCache.removeVertexTempUsage(temp1); + animationRegisterCache.removeVertexTempUsage(temp2); + + //process the velocity + code += "m33 " + temp1 + ".xyz," + animationRegisterCache.velocityTarget + ".xyz," + rotationMatrixRegister + "\n"; + + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".xy," + temp1 + ".xy\n"; + code += "nrm " + temp3 + ".xyz," + temp3 + ".xyz\n"; + + //temp3.x=cos,temp3.y=sin + //only process z axis + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".x," + temp3 + ".y\n"; + code += "mov " + temp2 + ".y," + temp3 + ".x\n"; + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + temp3 + ".x\n"; + code += "neg " + temp1 + ".y," + temp3 + ".y\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".z," + animationRegisterCache.vertexOneConst + "\n"; + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } else { + var nrmVel:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(nrmVel, 1); + + var xAxis:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(xAxis, 1); + + var R:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(R, 1); + var R_rev:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var cos:ShaderRegisterElement = new ShaderRegisterElement(R.regName, R.index, 3); + var sin:ShaderRegisterElement = new ShaderRegisterElement(R_rev.regName, R_rev.index, 3); + var cos2:ShaderRegisterElement = new ShaderRegisterElement(nrmVel.regName, nrmVel.index, 3); + var tempSingle:ShaderRegisterElement = sin; + + animationRegisterCache.removeVertexTempUsage(nrmVel); + animationRegisterCache.removeVertexTempUsage(xAxis); + animationRegisterCache.removeVertexTempUsage(R); + + code += "mov " + xAxis + ".x," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + xAxis + ".yz," + animationRegisterCache.vertexZeroConst + "\n"; + + code += "nrm " + nrmVel + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + code += "dp3 " + cos2 + "," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + xAxis + ".xyz," + nrmVel + ".xyz\n"; + code += "nrm " + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + //use R as temp to judge if nrm is (0,0,0). + //if nrm is (0,0,0) ,change it to (0,0,1). + code += "dp3 " + R + ".x," + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + code += "sge " + R + ".x," + animationRegisterCache.vertexZeroConst + "," + R + ".x\n"; + code += "add " + nrmVel + ".z," + R + ".x," + nrmVel + ".z\n"; + + code += "add " + tempSingle + "," + cos2 + "," + animationRegisterCache.vertexOneConst + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + cos + "," + tempSingle + "\n"; + + code += "sub " + tempSingle + "," + animationRegisterCache.vertexOneConst + "," + cos2 + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + sin + "," + tempSingle + "\n"; + + code += "mul " + R + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + + //use cos as R.w + + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + + //use cos as R_rev.w + + //nrmVel and xAxis are used as temp register + code += "crs " + nrmVel + ".xyz," + R + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + + //use cos as R.w + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + R + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + + code += "crs " + R + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + //code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," +R_rev + ".w\n"; + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + R + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + + for (i = 0; i < len; i++) { + //just repeat the calculate above + //because of the limited registers, no need to optimise + code += "mov " + xAxis + ".x," + animationRegisterCache.vertexOneConst + "\n"; + code += "mov " + xAxis + ".yz," + animationRegisterCache.vertexZeroConst + "\n"; + code += "nrm " + nrmVel + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + code += "dp3 " + cos2 + "," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + xAxis + ".xyz," + nrmVel + ".xyz\n"; + code += "nrm " + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + code += "dp3 " + R + ".x," + nrmVel + ".xyz," + nrmVel + ".xyz\n"; + code += "sge " + R + ".x," + animationRegisterCache.vertexZeroConst + "," + R + ".x\n"; + code += "add " + nrmVel + ".z," + R + ".x," + nrmVel + ".z\n"; + code += "add " + tempSingle + "," + cos2 + "," + animationRegisterCache.vertexOneConst + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + cos + "," + tempSingle + "\n"; + code += "sub " + tempSingle + "," + animationRegisterCache.vertexOneConst + "," + cos2 + "\n"; + code += "div " + tempSingle + "," + tempSingle + "," + animationRegisterCache.vertexTwoConst + "\n"; + code += "sqt " + sin + "," + tempSingle + "\n"; + code += "mul " + R + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + R + ".xyz," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + R + ".xyz," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + code += "crs " + R + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + R + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + ".xyz," + R + ".xyz," + xAxis + ".xyz\n"; + } + + } + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleRotateToHeadingState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + particleAnimationSet.needVelocity = true; + } +} + +export = ParticleRotateToHeadingNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleRotateToPositionNode.js b/lib/animators/nodes/ParticleRotateToPositionNode.js new file mode 100755 index 000000000..5773a1764 --- /dev/null +++ b/lib/animators/nodes/ParticleRotateToPositionNode.js @@ -0,0 +1,182 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleRotateToPositionState = require("awayjs-renderergl/lib/animators/states/ParticleRotateToPositionState"); +/** + * A particle animation node used to control the rotation of a particle to face to a position + */ +var ParticleRotateToPositionNode = (function (_super) { + __extends(ParticleRotateToPositionNode, _super); + /** + * Creates a new ParticleRotateToPositionNode + */ + function ParticleRotateToPositionNode(mode /*uint*/, position) { + if (position === void 0) { position = null; } + _super.call(this, "ParticleRotateToPosition", mode, 3, 3); + this._pStateClass = ParticleRotateToPositionState; + this._iPosition = position || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticleRotateToPositionNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var positionAttribute = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleRotateToPositionState.POSITION_INDEX, positionAttribute.index); + var code = ""; + var len = animationRegisterCache.rotationRegisters.length; + var i /*int*/; + if (animationRegisterCache.hasBillboard) { + var temp1 = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var temp2 = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp2, 1); + var temp3 = animationRegisterCache.getFreeVertexVectorTemp(); + var rotationMatrixRegister = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleRotateToPositionState.MATRIX_INDEX, rotationMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.removeVertexTempUsage(temp1); + animationRegisterCache.removeVertexTempUsage(temp2); + //process the position + code += "sub " + temp1 + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "m33 " + temp1 + ".xyz," + temp1 + ".xyz," + rotationMatrixRegister + "\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".xy," + temp1 + ".xy\n"; + code += "nrm " + temp3 + ".xyz," + temp3 + ".xyz\n"; + //temp3.x=cos,temp3.y=sin + //only process z axis + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".x," + temp3 + ".y\n"; + code += "mov " + temp2 + ".y," + temp3 + ".x\n"; + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + temp3 + ".x\n"; + code += "neg " + temp1 + ".y," + temp3 + ".y\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".z," + animationRegisterCache.vertexOneConst + "\n"; + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } + else { + var nrmDirection = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(nrmDirection, 1); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp, 1); + var cos = new ShaderRegisterElement(temp.regName, temp.index, 0); + var sin = new ShaderRegisterElement(temp.regName, temp.index, 1); + var o_temp = new ShaderRegisterElement(temp.regName, temp.index, 2); + var tempSingle = new ShaderRegisterElement(temp.regName, temp.index, 3); + var R = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(R, 1); + animationRegisterCache.removeVertexTempUsage(nrmDirection); + animationRegisterCache.removeVertexTempUsage(temp); + animationRegisterCache.removeVertexTempUsage(R); + code += "sub " + nrmDirection + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "mov " + sin + "," + nrmDirection + ".y\n"; + code += "mul " + cos + "," + sin + "," + sin + "\n"; + code += "sub " + cos + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "sqt " + cos + "," + cos + "\n"; + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".y\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".y\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + code += "sub " + animationRegisterCache.scaleAndRotateTarget + ".y," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".z," + R + ".z," + R + ".w\n"; + code += "abs " + R + ".y," + nrmDirection + ".y\n"; + code += "sge " + R + ".z," + R + ".y," + animationRegisterCache.vertexOneConst + "\n"; + code += "mul " + R + ".x," + R + ".y," + nrmDirection + ".y\n"; + //judgu if nrmDirection=(0,1,0); + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "dp3 " + sin + "," + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "sge " + tempSingle + "," + animationRegisterCache.vertexZeroConst + "," + sin + "\n"; + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "sub " + sin + "," + animationRegisterCache.vertexOneConst + "," + tempSingle + "\n"; + code += "mul " + sin + "," + sin + "," + nrmDirection + ".x\n"; + code += "mov " + cos + "," + nrmDirection + ".z\n"; + code += "neg " + cos + "," + cos + "\n"; + code += "sub " + o_temp + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "mul " + o_temp + "," + R + ".x," + tempSingle + "\n"; + code += "add " + cos + "," + cos + "," + o_temp + "\n"; + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".x\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".x\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + code += "sub " + animationRegisterCache.scaleAndRotateTarget + ".x," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".z," + R + ".z," + R + ".w\n"; + for (i = 0; i < len; i++) { + //just repeat the calculate above + //because of the limited registers, no need to optimise + code += "sub " + nrmDirection + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "mov " + sin + "," + nrmDirection + ".y\n"; + code += "mul " + cos + "," + sin + "," + sin + "\n"; + code += "sub " + cos + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "sqt " + cos + "," + cos + "\n"; + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".y\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".y\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "sub " + animationRegisterCache.rotationRegisters[i] + ".y," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + ".z," + R + ".z," + R + ".w\n"; + code += "abs " + R + ".y," + nrmDirection + ".y\n"; + code += "sge " + R + ".z," + R + ".y," + animationRegisterCache.vertexOneConst + "\n"; + code += "mul " + R + ".x," + R + ".y," + nrmDirection + ".y\n"; + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "dp3 " + sin + "," + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "sge " + tempSingle + "," + animationRegisterCache.vertexZeroConst + "," + sin + "\n"; + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "sub " + sin + "," + animationRegisterCache.vertexOneConst + "," + tempSingle + "\n"; + code += "mul " + sin + "," + sin + "," + nrmDirection + ".x\n"; + code += "mov " + cos + "," + nrmDirection + ".z\n"; + code += "neg " + cos + "," + cos + "\n"; + code += "sub " + o_temp + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "mul " + o_temp + "," + R + ".x," + tempSingle + "\n"; + code += "add " + cos + "," + cos + "," + o_temp + "\n"; + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".x\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".x\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "sub " + animationRegisterCache.rotationRegisters[i] + ".x," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + ".z," + R + ".z," + R + ".w\n"; + } + } + return code; + }; + /** + * @inheritDoc + */ + ParticleRotateToPositionNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleRotateToPositionNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var offset = param[ParticleRotateToPositionNode.POSITION_VECTOR3D]; + if (!offset) + throw (new Error("there is no " + ParticleRotateToPositionNode.POSITION_VECTOR3D + " in param!")); + this._pOneData[0] = offset.x; + this._pOneData[1] = offset.y; + this._pOneData[2] = offset.z; + }; + /** + * Reference for the position the particle will rotate to face for a single particle (when in local property mode). + * Expects a Vector3D object representing the position that the particle must face. + */ + ParticleRotateToPositionNode.POSITION_VECTOR3D = "RotateToPositionVector3D"; + return ParticleRotateToPositionNode; +})(ParticleNodeBase); +module.exports = ParticleRotateToPositionNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlerotatetopositionnode.ts"],"names":["ParticleRotateToPositionNode","ParticleRotateToPositionNode.constructor","ParticleRotateToPositionNode.getAGALVertexCode","ParticleRotateToPositionNode.getAnimationState","ParticleRotateToPositionNode._iGeneratePropertyOfOneParticle"],"mappings":";;;;;;AAAA,IAAO,QAAQ,WAAiB,oCAAoC,CAAC,CAAC;AAKtE,IAAO,qBAAqB,WAAa,gEAAgE,CAAC,CAAC;AAG3G,IAAO,sBAAsB,WAAa,6DAA6D,CAAC,CAAC;AACzG,IAAO,gBAAgB,WAAe,wDAAwD,CAAC,CAAC;AAChG,IAAO,6BAA6B,WAAW,sEAAsE,CAAC,CAAC;AAEvH,AAGA;;GADG;IACG,4BAA4B;IAASA,UAArCA,4BAA4BA,UAAyBA;IAW1DA;;OAEGA;IACHA,SAdKA,4BAA4BA,CAcrBA,IAAIA,CAAQA,QAADA,AAASA,EAAEA,QAAwBA;QAAxBC,wBAAwBA,GAAxBA,eAAwBA;QAEzDA,kBAAMA,0BAA0BA,EAAEA,IAAIA,EAAEA,CAACA,EAAEA,CAACA,CAACA,CAACA;QAE9CA,IAAIA,CAACA,YAAYA,GAAGA,6BAA6BA,CAACA;QAElDA,IAAIA,CAACA,UAAUA,GAAGA,QAAQA,IAAIA,IAAIA,QAAQA,EAAEA,CAACA;IAC9CA,CAACA;IAEDD;;OAEGA;IACIA,wDAAiBA,GAAxBA,UAAyBA,YAA6BA,EAAEA,sBAA6CA;QAEpGE,IAAIA,iBAAiBA,GAAyBA,CAACA,IAAIA,CAACA,MAAMA,IAAIA,sBAAsBA,CAACA,MAAMA,CAACA,GAAEA,sBAAsBA,CAACA,qBAAqBA,EAAEA,GAAGA,sBAAsBA,CAACA,sBAAsBA,EAAEA,CAACA;QAC/LA,sBAAsBA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,6BAA6BA,CAACA,cAAcA,EAAEA,iBAAiBA,CAACA,KAAKA,CAACA,CAACA;QAErHA,IAAIA,IAAIA,GAAUA,EAAEA,CAACA;QACrBA,IAAIA,GAAGA,GAAkBA,sBAAsBA,CAACA,iBAAiBA,CAACA,MAAMA,CAACA;QACzEA,IAAIA,CAACA,CAAQA,OAADA,AAAQA,CAACA;QACrBA,EAAEA,CAACA,CAACA,sBAAsBA,CAACA,YAAYA,CAACA,CAACA,CAACA;YACzCA,IAAIA,KAAKA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;YACnFA,sBAAsBA,CAACA,mBAAmBA,CAACA,KAAKA,EAAEA,CAACA,CAACA,CAACA;YACrDA,IAAIA,KAAKA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;YACnFA,sBAAsBA,CAACA,mBAAmBA,CAACA,KAAKA,EAAEA,CAACA,CAACA,CAACA;YACrDA,IAAIA,KAAKA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;YAEnFA,IAAIA,sBAAsBA,GAAyBA,sBAAsBA,CAACA,qBAAqBA,EAAEA,CAACA;YAClGA,sBAAsBA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,6BAA6BA,CAACA,YAAYA,EAAEA,sBAAsBA,CAACA,KAAKA,CAACA,CAACA;YACxHA,sBAAsBA,CAACA,qBAAqBA,EAAEA,CAACA;YAC/CA,sBAAsBA,CAACA,qBAAqBA,EAAEA,CAACA;YAC/CA,sBAAsBA,CAACA,qBAAqBA,EAAEA,CAACA;YAE/CA,sBAAsBA,CAACA,qBAAqBA,CAACA,KAAKA,CAACA,CAACA;YACpDA,sBAAsBA,CAACA,qBAAqBA,CAACA,KAAKA,CAACA,CAACA;YAEpDA,AACAA,sBADsBA;YACtBA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,OAAOA,GAAGA,iBAAiBA,GAAGA,OAAOA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,QAAQA,CAACA;YAClHA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,OAAOA,GAAGA,KAAKA,GAAGA,OAAOA,GAAGA,sBAAsBA,GAAGA,IAAIA,CAACA;YAEnFA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;YAC7EA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,MAAMA,GAAGA,KAAKA,GAAGA,OAAOA,CAACA;YAClDA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,OAAOA,GAAGA,KAAKA,GAAGA,QAAQA,CAACA;YAEpDA,AAEAA,yBAFyBA;YACzBA,qBAAqBA;YACrBA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;YAC7EA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,MAAMA,CAACA;YAChDA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,MAAMA,CAACA;YAChDA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;YAC7EA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,MAAMA,CAACA;YAChDA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,MAAMA,CAACA;YAChDA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;YAC7EA,IAAIA,IAAIA,MAAMA,GAAGA,KAAKA,GAAGA,KAAKA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,IAAIA,CAACA;YAC9EA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,OAAOA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,OAAOA,GAAGA,KAAKA,GAAGA,IAAIA,CAACA;YAC9IA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,CAACA,EAAEA;gBACvBA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,OAAOA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,GAAGA,GAAGA,KAAKA,GAAGA,IAAIA,CAACA;QAC5IA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,IAAIA,YAAYA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;YAC1FA,sBAAsBA,CAACA,mBAAmBA,CAACA,YAAYA,EAAEA,CAACA,CAACA,CAACA;YAE5DA,IAAIA,IAAIA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;YAClFA,sBAAsBA,CAACA,mBAAmBA,CAACA,IAAIA,EAAEA,CAACA,CAACA,CAACA;YACpDA,IAAIA,GAAGA,GAAyBA,IAAIA,qBAAqBA,CAACA,IAAIA,CAACA,OAAOA,EAAEA,IAAIA,CAACA,KAAKA,EAAEA,CAACA,CAACA,CAACA;YACvFA,IAAIA,GAAGA,GAAyBA,IAAIA,qBAAqBA,CAACA,IAAIA,CAACA,OAAOA,EAAEA,IAAIA,CAACA,KAAKA,EAAEA,CAACA,CAACA,CAACA;YACvFA,IAAIA,MAAMA,GAAyBA,IAAIA,qBAAqBA,CAACA,IAAIA,CAACA,OAAOA,EAAEA,IAAIA,CAACA,KAAKA,EAAEA,CAACA,CAACA,CAACA;YAC1FA,IAAIA,UAAUA,GAAyBA,IAAIA,qBAAqBA,CAACA,IAAIA,CAACA,OAAOA,EAAEA,IAAIA,CAACA,KAAKA,EAAEA,CAACA,CAACA,CAACA;YAE9FA,IAAIA,CAACA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;YAC/EA,sBAAsBA,CAACA,mBAAmBA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;YAEjDA,sBAAsBA,CAACA,qBAAqBA,CAACA,YAAYA,CAACA,CAACA;YAC3DA,sBAAsBA,CAACA,qBAAqBA,CAACA,IAAIA,CAACA,CAACA;YACnDA,sBAAsBA,CAACA,qBAAqBA,CAACA,CAACA,CAACA,CAACA;YAEhDA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,iBAAiBA,GAAGA,OAAOA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,QAAQA,CAACA;YACzHA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,YAAYA,GAAGA,QAAQA,CAACA;YAElEA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;YACnDA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;YACpDA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;YACtFA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;YAExCA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAE9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;YAE9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;YACnDA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,IAAIA,CAACA;YACtFA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;YAE/DA,AACAA,gCADgCA;YAChCA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,KAAKA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;YACtFA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,YAAYA,GAAGA,QAAQA,CAACA;YAC9EA,IAAIA,IAAIA,MAAMA,GAAGA,UAAUA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;YAE9FA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,KAAKA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;YACtFA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,YAAYA,GAAGA,QAAQA,CAACA;YAElEA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,UAAUA,GAAGA,IAAIA,CAACA;YAC7FA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;YAE/DA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;YACnDA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;YACxCA,IAAIA,IAAIA,MAAMA,GAAGA,MAAMA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;YACzFA,IAAIA,IAAIA,MAAMA,GAAGA,MAAMA,GAAGA,GAAGA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,UAAUA,GAAGA,IAAIA,CAACA;YAC9DA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,MAAMA,GAAGA,IAAIA,CAACA;YAEvDA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,MAAMA,CAACA;YAE9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;YAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;YAE9FA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBAC1BA,AAEAA,iCAFiCA;gBACjCA,uDAAuDA;gBACvDA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,iBAAiBA,GAAGA,OAAOA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,QAAQA,CAACA;gBACzHA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,YAAYA,GAAGA,QAAQA,CAACA;gBAClEA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;gBACnDA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;gBACpDA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;gBACtFA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;gBACxCA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;gBACnDA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,IAAIA,CAACA;gBACtFA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;gBAC/DA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,KAAKA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;gBACtFA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,YAAYA,GAAGA,QAAQA,CAACA;gBAC9EA,IAAIA,IAAIA,MAAMA,GAAGA,UAAUA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,KAAKA,GAAGA,sBAAsBA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;gBACtFA,IAAIA,IAAIA,MAAMA,GAAGA,YAAYA,GAAGA,OAAOA,GAAGA,YAAYA,GAAGA,QAAQA,CAACA;gBAClEA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,UAAUA,GAAGA,IAAIA,CAACA;gBAC7FA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;gBAC/DA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,YAAYA,GAAGA,MAAMA,CAACA;gBACnDA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;gBACxCA,IAAIA,IAAIA,MAAMA,GAAGA,MAAMA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,cAAcA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA;gBACzFA,IAAIA,IAAIA,MAAMA,GAAGA,MAAMA,GAAGA,GAAGA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,UAAUA,GAAGA,IAAIA,CAACA;gBAC9DA,IAAIA,IAAIA,MAAMA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,MAAMA,GAAGA,IAAIA,CAACA;gBACvDA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;gBAC9FA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,iBAAiBA,CAACA,CAACA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,KAAKA,GAAGA,CAACA,GAAGA,MAAMA,CAACA;YAC/FA,CAACA;QACFA,CAACA;QACDA,MAAMA,CAACA,IAAIA,CAACA;IACbA,CAACA;IAEDF;;OAEGA;IACIA,wDAAiBA,GAAxBA,UAAyBA,QAAqBA;QAE7CG,MAAMA,CAAiCA,QAAQA,CAACA,iBAAiBA,CAACA,IAAIA,CAACA,CAACA;IACzEA,CAACA;IAEDH;;OAEGA;IACIA,sEAA+BA,GAAtCA,UAAuCA,KAAwBA;QAE9DI,IAAIA,MAAMA,GAAYA,KAAKA,CAACA,4BAA4BA,CAACA,iBAAiBA,CAACA,CAACA;QAC5EA,EAAEA,CAACA,CAACA,CAACA,MAAMA,CAACA;YACXA,MAAKA,CAACA,IAAIA,KAAKA,CAACA,cAAcA,GAAGA,4BAA4BA,CAACA,iBAAiBA,GAAGA,YAAYA,CAACA,CAACA,CAACA;QAElGA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA,CAACA,CAACA;QAC7BA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA,CAACA,CAACA;QAC7BA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA,CAACA,CAACA;IAC9BA,CAACA;IA9LDJ;;;OAGGA;IACWA,8CAAiBA,GAAUA,0BAA0BA,CAACA;IA2LrEA,mCAACA;AAADA,CApMA,AAoMCA,EApM0C,gBAAgB,EAoM1D;AAED,AAAsC,iBAA7B,4BAA4B,CAAC","file":"animators/nodes/ParticleRotateToPositionNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleRotateToPositionState\t= require(\"awayjs-renderergl/lib/animators/states/ParticleRotateToPositionState\");\n\n/**\n * A particle animation node used to control the rotation of a particle to face to a position\n */\nclass ParticleRotateToPositionNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iPosition:Vector3D;\n\n\t/**\n\t * Reference for the position the particle will rotate to face for a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the position that the particle must face.\n\t */\n\tpublic static POSITION_VECTOR3D:string = \"RotateToPositionVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleRotateToPositionNode</code>\n\t */\n\tconstructor(mode:number /*uint*/, position:Vector3D = null)\n\t{\n\t\tsuper(\"ParticleRotateToPosition\", mode, 3, 3);\n\n\t\tthis._pStateClass = ParticleRotateToPositionState;\n\n\t\tthis._iPosition = position || new Vector3D();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar positionAttribute:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleRotateToPositionState.POSITION_INDEX, positionAttribute.index);\n\n\t\tvar code:string = \"\";\n\t\tvar len:number /*int*/ = animationRegisterCache.rotationRegisters.length;\n\t\tvar i:number /*int*/;\n\t\tif (animationRegisterCache.hasBillboard) {\n\t\t\tvar temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(temp1, 1);\n\t\t\tvar temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(temp2, 1);\n\t\t\tvar temp3:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\n\t\t\tvar rotationMatrixRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleRotateToPositionState.MATRIX_INDEX, rotationMatrixRegister.index);\n\t\t\tanimationRegisterCache.getFreeVertexConstant();\n\t\t\tanimationRegisterCache.getFreeVertexConstant();\n\t\t\tanimationRegisterCache.getFreeVertexConstant();\n\n\t\t\tanimationRegisterCache.removeVertexTempUsage(temp1);\n\t\t\tanimationRegisterCache.removeVertexTempUsage(temp2);\n\n\t\t\t//process the position\n\t\t\tcode += \"sub \" + temp1 + \".xyz,\" + positionAttribute + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\t\t\tcode += \"m33 \" + temp1 + \".xyz,\" + temp1 + \".xyz,\" + rotationMatrixRegister + \"\\n\";\n\n\t\t\tcode += \"mov \" + temp3 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp3 + \".xy,\" + temp1 + \".xy\\n\";\n\t\t\tcode += \"nrm \" + temp3 + \".xyz,\" + temp3 + \".xyz\\n\";\n\n\t\t\t//temp3.x=cos,temp3.y=sin\n\t\t\t//only process z axis\n\t\t\tcode += \"mov \" + temp2 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp2 + \".x,\" + temp3 + \".y\\n\";\n\t\t\tcode += \"mov \" + temp2 + \".y,\" + temp3 + \".x\\n\";\n\t\t\tcode += \"mov \" + temp1 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp1 + \".x,\" + temp3 + \".x\\n\";\n\t\t\tcode += \"neg \" + temp1 + \".y,\" + temp3 + \".y\\n\";\n\t\t\tcode += \"mov \" + temp3 + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mov \" + temp3 + \".z,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\tcode += \"m33 \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp1 + \"\\n\";\n\t\t\tfor (i = 0; i < len; i++)\n\t\t\t\tcode += \"m33 \" + animationRegisterCache.rotationRegisters[i] + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \",\" + temp1 + \"\\n\";\n\t\t} else {\n\t\t\tvar nrmDirection:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(nrmDirection, 1);\n\n\t\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(temp, 1);\n\t\t\tvar cos:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0);\n\t\t\tvar sin:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1);\n\t\t\tvar o_temp:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 2);\n\t\t\tvar tempSingle:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 3);\n\n\t\t\tvar R:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(R, 1);\n\n\t\t\tanimationRegisterCache.removeVertexTempUsage(nrmDirection);\n\t\t\tanimationRegisterCache.removeVertexTempUsage(temp);\n\t\t\tanimationRegisterCache.removeVertexTempUsage(R);\n\n\t\t\tcode += \"sub \" + nrmDirection + \".xyz,\" + positionAttribute + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\t\t\tcode += \"nrm \" + nrmDirection + \".xyz,\" + nrmDirection + \".xyz\\n\";\n\n\t\t\tcode += \"mov \" + sin + \",\" + nrmDirection + \".y\\n\";\n\t\t\tcode += \"mul \" + cos + \",\" + sin + \",\" + sin + \"\\n\";\n\t\t\tcode += \"sub \" + cos + \",\" + animationRegisterCache.vertexOneConst + \",\" + cos + \"\\n\";\n\t\t\tcode += \"sqt \" + cos + \",\" + cos + \"\\n\";\n\n\t\t\tcode += \"mul \" + R + \".x,\" + cos + \",\" + animationRegisterCache.scaleAndRotateTarget + \".y\\n\";\n\t\t\tcode += \"mul \" + R + \".y,\" + sin + \",\" + animationRegisterCache.scaleAndRotateTarget + \".z\\n\";\n\t\t\tcode += \"mul \" + R + \".z,\" + sin + \",\" + animationRegisterCache.scaleAndRotateTarget + \".y\\n\";\n\t\t\tcode += \"mul \" + R + \".w,\" + cos + \",\" + animationRegisterCache.scaleAndRotateTarget + \".z\\n\";\n\n\t\t\tcode += \"sub \" + animationRegisterCache.scaleAndRotateTarget + \".y,\" + R + \".x,\" + R + \".y\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.scaleAndRotateTarget + \".z,\" + R + \".z,\" + R + \".w\\n\";\n\n\t\t\tcode += \"abs \" + R + \".y,\" + nrmDirection + \".y\\n\";\n\t\t\tcode += \"sge \" + R + \".z,\" + R + \".y,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\tcode += \"mul \" + R + \".x,\" + R + \".y,\" + nrmDirection + \".y\\n\";\n\n\t\t\t//judgu if nrmDirection=(0,1,0);\n\t\t\tcode += \"mov \" + nrmDirection + \".y,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"dp3 \" + sin + \",\" + nrmDirection + \".xyz,\" + nrmDirection + \".xyz\\n\";\n\t\t\tcode += \"sge \" + tempSingle + \",\" + animationRegisterCache.vertexZeroConst + \",\" + sin + \"\\n\";\n\n\t\t\tcode += \"mov \" + nrmDirection + \".y,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"nrm \" + nrmDirection + \".xyz,\" + nrmDirection + \".xyz\\n\";\n\n\t\t\tcode += \"sub \" + sin + \",\" + animationRegisterCache.vertexOneConst + \",\" + tempSingle + \"\\n\";\n\t\t\tcode += \"mul \" + sin + \",\" + sin + \",\" + nrmDirection + \".x\\n\";\n\n\t\t\tcode += \"mov \" + cos + \",\" + nrmDirection + \".z\\n\";\n\t\t\tcode += \"neg \" + cos + \",\" + cos + \"\\n\";\n\t\t\tcode += \"sub \" + o_temp + \",\" + animationRegisterCache.vertexOneConst + \",\" + cos + \"\\n\";\n\t\t\tcode += \"mul \" + o_temp + \",\" + R + \".x,\" + tempSingle + \"\\n\";\n\t\t\tcode += \"add \" + cos + \",\" + cos + \",\" + o_temp + \"\\n\";\n\n\t\t\tcode += \"mul \" + R + \".x,\" + cos + \",\" + animationRegisterCache.scaleAndRotateTarget + \".x\\n\";\n\t\t\tcode += \"mul \" + R + \".y,\" + sin + \",\" + animationRegisterCache.scaleAndRotateTarget + \".z\\n\";\n\t\t\tcode += \"mul \" + R + \".z,\" + sin + \",\" + animationRegisterCache.scaleAndRotateTarget + \".x\\n\";\n\t\t\tcode += \"mul \" + R + \".w,\" + cos + \",\" + animationRegisterCache.scaleAndRotateTarget + \".z\\n\";\n\n\t\t\tcode += \"sub \" + animationRegisterCache.scaleAndRotateTarget + \".x,\" + R + \".x,\" + R + \".y\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.scaleAndRotateTarget + \".z,\" + R + \".z,\" + R + \".w\\n\";\n\n\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\t//just repeat the calculate above\n\t\t\t\t//because of the limited registers, no need to optimise\n\t\t\t\tcode += \"sub \" + nrmDirection + \".xyz,\" + positionAttribute + \".xyz,\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\t\t\t\tcode += \"nrm \" + nrmDirection + \".xyz,\" + nrmDirection + \".xyz\\n\";\n\t\t\t\tcode += \"mov \" + sin + \",\" + nrmDirection + \".y\\n\";\n\t\t\t\tcode += \"mul \" + cos + \",\" + sin + \",\" + sin + \"\\n\";\n\t\t\t\tcode += \"sub \" + cos + \",\" + animationRegisterCache.vertexOneConst + \",\" + cos + \"\\n\";\n\t\t\t\tcode += \"sqt \" + cos + \",\" + cos + \"\\n\";\n\t\t\t\tcode += \"mul \" + R + \".x,\" + cos + \",\" + animationRegisterCache.rotationRegisters[i] + \".y\\n\";\n\t\t\t\tcode += \"mul \" + R + \".y,\" + sin + \",\" + animationRegisterCache.rotationRegisters[i] + \".z\\n\";\n\t\t\t\tcode += \"mul \" + R + \".z,\" + sin + \",\" + animationRegisterCache.rotationRegisters[i] + \".y\\n\";\n\t\t\t\tcode += \"mul \" + R + \".w,\" + cos + \",\" + animationRegisterCache.rotationRegisters[i] + \".z\\n\";\n\t\t\t\tcode += \"sub \" + animationRegisterCache.rotationRegisters[i] + \".y,\" + R + \".x,\" + R + \".y\\n\";\n\t\t\t\tcode += \"add \" + animationRegisterCache.rotationRegisters[i] + \".z,\" + R + \".z,\" + R + \".w\\n\";\n\t\t\t\tcode += \"abs \" + R + \".y,\" + nrmDirection + \".y\\n\";\n\t\t\t\tcode += \"sge \" + R + \".z,\" + R + \".y,\" + animationRegisterCache.vertexOneConst + \"\\n\";\n\t\t\t\tcode += \"mul \" + R + \".x,\" + R + \".y,\" + nrmDirection + \".y\\n\";\n\t\t\t\tcode += \"mov \" + nrmDirection + \".y,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\t\tcode += \"dp3 \" + sin + \",\" + nrmDirection + \".xyz,\" + nrmDirection + \".xyz\\n\";\n\t\t\t\tcode += \"sge \" + tempSingle + \",\" + animationRegisterCache.vertexZeroConst + \",\" + sin + \"\\n\";\n\t\t\t\tcode += \"mov \" + nrmDirection + \".y,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\t\tcode += \"nrm \" + nrmDirection + \".xyz,\" + nrmDirection + \".xyz\\n\";\n\t\t\t\tcode += \"sub \" + sin + \",\" + animationRegisterCache.vertexOneConst + \",\" + tempSingle + \"\\n\";\n\t\t\t\tcode += \"mul \" + sin + \",\" + sin + \",\" + nrmDirection + \".x\\n\";\n\t\t\t\tcode += \"mov \" + cos + \",\" + nrmDirection + \".z\\n\";\n\t\t\t\tcode += \"neg \" + cos + \",\" + cos + \"\\n\";\n\t\t\t\tcode += \"sub \" + o_temp + \",\" + animationRegisterCache.vertexOneConst + \",\" + cos + \"\\n\";\n\t\t\t\tcode += \"mul \" + o_temp + \",\" + R + \".x,\" + tempSingle + \"\\n\";\n\t\t\t\tcode += \"add \" + cos + \",\" + cos + \",\" + o_temp + \"\\n\";\n\t\t\t\tcode += \"mul \" + R + \".x,\" + cos + \",\" + animationRegisterCache.rotationRegisters[i] + \".x\\n\";\n\t\t\t\tcode += \"mul \" + R + \".y,\" + sin + \",\" + animationRegisterCache.rotationRegisters[i] + \".z\\n\";\n\t\t\t\tcode += \"mul \" + R + \".z,\" + sin + \",\" + animationRegisterCache.rotationRegisters[i] + \".x\\n\";\n\t\t\t\tcode += \"mul \" + R + \".w,\" + cos + \",\" + animationRegisterCache.rotationRegisters[i] + \".z\\n\";\n\t\t\t\tcode += \"sub \" + animationRegisterCache.rotationRegisters[i] + \".x,\" + R + \".x,\" + R + \".y\\n\";\n\t\t\t\tcode += \"add \" + animationRegisterCache.rotationRegisters[i] + \".z,\" + R + \".z,\" + R + \".w\\n\";\n\t\t\t}\n\t\t}\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleRotateToPositionState\n\t{\n\t\treturn <ParticleRotateToPositionState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tvar offset:Vector3D = param[ParticleRotateToPositionNode.POSITION_VECTOR3D];\n\t\tif (!offset)\n\t\t\tthrow(new Error(\"there is no \" + ParticleRotateToPositionNode.POSITION_VECTOR3D + \" in param!\"));\n\n\t\tthis._pOneData[0] = offset.x;\n\t\tthis._pOneData[1] = offset.y;\n\t\tthis._pOneData[2] = offset.z;\n\t}\n}\n\nexport = ParticleRotateToPositionNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleRotateToPositionNode.ts b/lib/animators/nodes/ParticleRotateToPositionNode.ts new file mode 100644 index 000000000..a897510c8 --- /dev/null +++ b/lib/animators/nodes/ParticleRotateToPositionNode.ts @@ -0,0 +1,214 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleRotateToPositionState = require("awayjs-renderergl/lib/animators/states/ParticleRotateToPositionState"); + +/** + * A particle animation node used to control the rotation of a particle to face to a position + */ +class ParticleRotateToPositionNode extends ParticleNodeBase +{ + /** @private */ + public _iPosition:Vector3D; + + /** + * Reference for the position the particle will rotate to face for a single particle (when in local property mode). + * Expects a Vector3D object representing the position that the particle must face. + */ + public static POSITION_VECTOR3D:string = "RotateToPositionVector3D"; + + /** + * Creates a new ParticleRotateToPositionNode + */ + constructor(mode:number /*uint*/, position:Vector3D = null) + { + super("ParticleRotateToPosition", mode, 3, 3); + + this._pStateClass = ParticleRotateToPositionState; + + this._iPosition = position || new Vector3D(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var positionAttribute:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleRotateToPositionState.POSITION_INDEX, positionAttribute.index); + + var code:string = ""; + var len:number /*int*/ = animationRegisterCache.rotationRegisters.length; + var i:number /*int*/; + if (animationRegisterCache.hasBillboard) { + var temp1:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp1, 1); + var temp2:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp2, 1); + var temp3:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + + var rotationMatrixRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleRotateToPositionState.MATRIX_INDEX, rotationMatrixRegister.index); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.getFreeVertexConstant(); + + animationRegisterCache.removeVertexTempUsage(temp1); + animationRegisterCache.removeVertexTempUsage(temp2); + + //process the position + code += "sub " + temp1 + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "m33 " + temp1 + ".xyz," + temp1 + ".xyz," + rotationMatrixRegister + "\n"; + + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".xy," + temp1 + ".xy\n"; + code += "nrm " + temp3 + ".xyz," + temp3 + ".xyz\n"; + + //temp3.x=cos,temp3.y=sin + //only process z axis + code += "mov " + temp2 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp2 + ".x," + temp3 + ".y\n"; + code += "mov " + temp2 + ".y," + temp3 + ".x\n"; + code += "mov " + temp1 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp1 + ".x," + temp3 + ".x\n"; + code += "neg " + temp1 + ".y," + temp3 + ".y\n"; + code += "mov " + temp3 + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mov " + temp3 + ".z," + animationRegisterCache.vertexOneConst + "\n"; + code += "m33 " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp1 + "\n"; + for (i = 0; i < len; i++) + code += "m33 " + animationRegisterCache.rotationRegisters[i] + ".xyz," + animationRegisterCache.rotationRegisters[i] + "," + temp1 + "\n"; + } else { + var nrmDirection:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(nrmDirection, 1); + + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp, 1); + var cos:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0); + var sin:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1); + var o_temp:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 2); + var tempSingle:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 3); + + var R:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(R, 1); + + animationRegisterCache.removeVertexTempUsage(nrmDirection); + animationRegisterCache.removeVertexTempUsage(temp); + animationRegisterCache.removeVertexTempUsage(R); + + code += "sub " + nrmDirection + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + + code += "mov " + sin + "," + nrmDirection + ".y\n"; + code += "mul " + cos + "," + sin + "," + sin + "\n"; + code += "sub " + cos + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "sqt " + cos + "," + cos + "\n"; + + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".y\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".y\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + + code += "sub " + animationRegisterCache.scaleAndRotateTarget + ".y," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".z," + R + ".z," + R + ".w\n"; + + code += "abs " + R + ".y," + nrmDirection + ".y\n"; + code += "sge " + R + ".z," + R + ".y," + animationRegisterCache.vertexOneConst + "\n"; + code += "mul " + R + ".x," + R + ".y," + nrmDirection + ".y\n"; + + //judgu if nrmDirection=(0,1,0); + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "dp3 " + sin + "," + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "sge " + tempSingle + "," + animationRegisterCache.vertexZeroConst + "," + sin + "\n"; + + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + + code += "sub " + sin + "," + animationRegisterCache.vertexOneConst + "," + tempSingle + "\n"; + code += "mul " + sin + "," + sin + "," + nrmDirection + ".x\n"; + + code += "mov " + cos + "," + nrmDirection + ".z\n"; + code += "neg " + cos + "," + cos + "\n"; + code += "sub " + o_temp + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "mul " + o_temp + "," + R + ".x," + tempSingle + "\n"; + code += "add " + cos + "," + cos + "," + o_temp + "\n"; + + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".x\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.scaleAndRotateTarget + ".x\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".z\n"; + + code += "sub " + animationRegisterCache.scaleAndRotateTarget + ".x," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".z," + R + ".z," + R + ".w\n"; + + for (i = 0; i < len; i++) { + //just repeat the calculate above + //because of the limited registers, no need to optimise + code += "sub " + nrmDirection + ".xyz," + positionAttribute + ".xyz," + animationRegisterCache.positionTarget + ".xyz\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "mov " + sin + "," + nrmDirection + ".y\n"; + code += "mul " + cos + "," + sin + "," + sin + "\n"; + code += "sub " + cos + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "sqt " + cos + "," + cos + "\n"; + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".y\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".y\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "sub " + animationRegisterCache.rotationRegisters[i] + ".y," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + ".z," + R + ".z," + R + ".w\n"; + code += "abs " + R + ".y," + nrmDirection + ".y\n"; + code += "sge " + R + ".z," + R + ".y," + animationRegisterCache.vertexOneConst + "\n"; + code += "mul " + R + ".x," + R + ".y," + nrmDirection + ".y\n"; + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "dp3 " + sin + "," + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "sge " + tempSingle + "," + animationRegisterCache.vertexZeroConst + "," + sin + "\n"; + code += "mov " + nrmDirection + ".y," + animationRegisterCache.vertexZeroConst + "\n"; + code += "nrm " + nrmDirection + ".xyz," + nrmDirection + ".xyz\n"; + code += "sub " + sin + "," + animationRegisterCache.vertexOneConst + "," + tempSingle + "\n"; + code += "mul " + sin + "," + sin + "," + nrmDirection + ".x\n"; + code += "mov " + cos + "," + nrmDirection + ".z\n"; + code += "neg " + cos + "," + cos + "\n"; + code += "sub " + o_temp + "," + animationRegisterCache.vertexOneConst + "," + cos + "\n"; + code += "mul " + o_temp + "," + R + ".x," + tempSingle + "\n"; + code += "add " + cos + "," + cos + "," + o_temp + "\n"; + code += "mul " + R + ".x," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".x\n"; + code += "mul " + R + ".y," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "mul " + R + ".z," + sin + "," + animationRegisterCache.rotationRegisters[i] + ".x\n"; + code += "mul " + R + ".w," + cos + "," + animationRegisterCache.rotationRegisters[i] + ".z\n"; + code += "sub " + animationRegisterCache.rotationRegisters[i] + ".x," + R + ".x," + R + ".y\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + ".z," + R + ".z," + R + ".w\n"; + } + } + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleRotateToPositionState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var offset:Vector3D = param[ParticleRotateToPositionNode.POSITION_VECTOR3D]; + if (!offset) + throw(new Error("there is no " + ParticleRotateToPositionNode.POSITION_VECTOR3D + " in param!")); + + this._pOneData[0] = offset.x; + this._pOneData[1] = offset.y; + this._pOneData[2] = offset.z; + } +} + +export = ParticleRotateToPositionNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleRotationalVelocityNode.js b/lib/animators/nodes/ParticleRotationalVelocityNode.js new file mode 100755 index 000000000..12e3f615d --- /dev/null +++ b/lib/animators/nodes/ParticleRotationalVelocityNode.js @@ -0,0 +1,127 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleRotationalVelocityState = require("awayjs-renderergl/lib/animators/states/ParticleRotationalVelocityState"); +/** + * A particle animation node used to set the starting rotational velocity of a particle. + */ +var ParticleRotationalVelocityNode = (function (_super) { + __extends(ParticleRotationalVelocityNode, _super); + /** + * Creates a new ParticleRotationalVelocityNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + */ + function ParticleRotationalVelocityNode(mode /*uint*/, rotationalVelocity) { + if (rotationalVelocity === void 0) { rotationalVelocity = null; } + _super.call(this, "ParticleRotationalVelocity", mode, 4); + this._pStateClass = ParticleRotationalVelocityState; + this._iRotationalVelocity = rotationalVelocity || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticleRotationalVelocityNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var rotationRegister = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleRotationalVelocityState.ROTATIONALVELOCITY_INDEX, rotationRegister.index); + var nrmVel = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(nrmVel, 1); + var xAxis = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(xAxis, 1); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp, 1); + var Rtemp = new ShaderRegisterElement(temp.regName, temp.index); + var R_rev = animationRegisterCache.getFreeVertexVectorTemp(); + R_rev = new ShaderRegisterElement(R_rev.regName, R_rev.index); + var cos = new ShaderRegisterElement(Rtemp.regName, Rtemp.index, 3); + var sin = new ShaderRegisterElement(R_rev.regName, R_rev.index, 3); + animationRegisterCache.removeVertexTempUsage(nrmVel); + animationRegisterCache.removeVertexTempUsage(xAxis); + animationRegisterCache.removeVertexTempUsage(temp); + var code = ""; + code += "mov " + nrmVel + ".xyz," + rotationRegister + ".xyz\n"; + code += "mov " + nrmVel + ".w," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mul " + cos + "," + animationRegisterCache.vertexTime + "," + rotationRegister + ".w\n"; + code += "sin " + sin + "," + cos + "\n"; + code += "cos " + cos + "," + cos + "\n"; + code += "mul " + Rtemp + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + //nrmVel and xAxis are used as temp register + code += "crs " + nrmVel + ".xyz," + Rtemp + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + Rtemp + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + code += "crs " + Rtemp + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + //use cos as R_rev.w + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + Rtemp + ".xyz," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + var len = animationRegisterCache.rotationRegisters.length; + for (var i = 0; i < len; i++) { + code += "mov " + nrmVel + ".xyz," + rotationRegister + ".xyz\n"; + code += "mov " + nrmVel + ".w," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mul " + cos + "," + animationRegisterCache.vertexTime + "," + rotationRegister + ".w\n"; + code += "sin " + sin + "," + cos + "\n"; + code += "cos " + cos + "," + cos + "\n"; + code += "mul " + Rtemp + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + Rtemp + ".xyz," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.rotationRegisters[i] + "\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + Rtemp + ".xyz," + animationRegisterCache.rotationRegisters[i] + "\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + code += "crs " + Rtemp + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + Rtemp + ".xyz," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + "," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + } + return code; + }; + /** + * @inheritDoc + */ + ParticleRotationalVelocityNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleRotationalVelocityNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + //(Vector3d.x,Vector3d.y,Vector3d.z) is rotation axis,Vector3d.w is cycle duration + var rotate = param[ParticleRotationalVelocityNode.ROTATIONALVELOCITY_VECTOR3D]; + if (!rotate) + throw (new Error("there is no " + ParticleRotationalVelocityNode.ROTATIONALVELOCITY_VECTOR3D + " in param!")); + if (rotate.length <= 0) + rotate.z = 1; //set the default direction + else + rotate.normalize(); + this._pOneData[0] = rotate.x; + this._pOneData[1] = rotate.y; + this._pOneData[2] = rotate.z; + if (rotate.w <= 0) + throw (new Error("the cycle duration must greater than zero")); + // it's used as angle/2 in agal + this._pOneData[3] = Math.PI / rotate.w; + }; + /** + * Reference for rotational velocity node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the rotational velocity around an axis of the particle. + */ + ParticleRotationalVelocityNode.ROTATIONALVELOCITY_VECTOR3D = "RotationalVelocityVector3D"; + return ParticleRotationalVelocityNode; +})(ParticleNodeBase); +module.exports = ParticleRotationalVelocityNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlerotationalvelocitynode.ts"],"names":["ParticleRotationalVelocityNode","ParticleRotationalVelocityNode.constructor","ParticleRotationalVelocityNode.getAGALVertexCode","ParticleRotationalVelocityNode.getAnimationState","ParticleRotationalVelocityNode._iGeneratePropertyOfOneParticle"],"mappings":"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","file":"animators/nodes/ParticleRotationalVelocityNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleRotationalVelocityState\t= require(\"awayjs-renderergl/lib/animators/states/ParticleRotationalVelocityState\");\n\n/**\n * A particle animation node used to set the starting rotational velocity of a particle.\n */\nclass ParticleRotationalVelocityNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iRotationalVelocity:Vector3D;\n\n\t/**\n\t * Reference for rotational velocity node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the rotational velocity around an axis of the particle.\n\t */\n\tpublic static ROTATIONALVELOCITY_VECTOR3D:string = \"RotationalVelocityVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleRotationalVelocityNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t */\n\tconstructor(mode:number /*uint*/, rotationalVelocity:Vector3D = null)\n\t{\n\t\tsuper(\"ParticleRotationalVelocity\", mode, 4);\n\n\t\tthis._pStateClass = ParticleRotationalVelocityState;\n\n\t\tthis._iRotationalVelocity = rotationalVelocity || new Vector3D();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar rotationRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleRotationalVelocityState.ROTATIONALVELOCITY_INDEX, rotationRegister.index);\n\n\t\tvar nrmVel:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tanimationRegisterCache.addVertexTempUsages(nrmVel, 1);\n\n\t\tvar xAxis:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tanimationRegisterCache.addVertexTempUsages(xAxis, 1);\n\n\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tanimationRegisterCache.addVertexTempUsages(temp, 1);\n\t\tvar Rtemp:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index);\n\t\tvar R_rev:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tR_rev = new ShaderRegisterElement(R_rev.regName, R_rev.index);\n\n\t\tvar cos:ShaderRegisterElement = new ShaderRegisterElement(Rtemp.regName, Rtemp.index, 3);\n\t\tvar sin:ShaderRegisterElement = new ShaderRegisterElement(R_rev.regName, R_rev.index, 3);\n\n\t\tanimationRegisterCache.removeVertexTempUsage(nrmVel);\n\t\tanimationRegisterCache.removeVertexTempUsage(xAxis);\n\t\tanimationRegisterCache.removeVertexTempUsage(temp);\n\n\t\tvar code:string = \"\";\n\t\tcode += \"mov \" + nrmVel + \".xyz,\" + rotationRegister + \".xyz\\n\";\n\t\tcode += \"mov \" + nrmVel + \".w,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\n\t\tcode += \"mul \" + cos + \",\" + animationRegisterCache.vertexTime + \",\" + rotationRegister + \".w\\n\";\n\n\t\tcode += \"sin \" + sin + \",\" + cos + \"\\n\";\n\t\tcode += \"cos \" + cos + \",\" + cos + \"\\n\";\n\n\t\tcode += \"mul \" + Rtemp + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\n\t\tcode += \"mul \" + R_rev + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\t\tcode += \"neg \" + R_rev + \".xyz,\" + R_rev + \".xyz\\n\";\n\n\t\t//nrmVel and xAxis are used as temp register\n\t\tcode += \"crs \" + nrmVel + \".xyz,\" + Rtemp + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\n\t\tcode += \"mul \" + xAxis + \".xyz,\" + cos + \",\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\t\tcode += \"add \" + nrmVel + \".xyz,\" + nrmVel + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\tcode += \"dp3 \" + xAxis + \".w,\" + Rtemp + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz\\n\";\n\t\tcode += \"neg \" + nrmVel + \".w,\" + xAxis + \".w\\n\";\n\n\t\tcode += \"crs \" + Rtemp + \".xyz,\" + nrmVel + \".xyz,\" + R_rev + \".xyz\\n\";\n\n\t\t//use cos as R_rev.w\n\t\tcode += \"mul \" + xAxis + \".xyzw,\" + nrmVel + \".xyzw,\" + cos + \"\\n\";\n\t\tcode += \"add \" + Rtemp + \".xyz,\" + Rtemp + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\tcode += \"mul \" + xAxis + \".xyz,\" + nrmVel + \".w,\" + R_rev + \".xyz\\n\";\n\n\t\tcode += \"add \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + Rtemp + \".xyz,\" + xAxis + \".xyz\\n\";\n\n\t\tvar len:number /*int*/ = animationRegisterCache.rotationRegisters.length;\n\t\tfor (var i:number /*int*/ = 0; i < len; i++) {\n\t\t\tcode += \"mov \" + nrmVel + \".xyz,\" + rotationRegister + \".xyz\\n\";\n\t\t\tcode += \"mov \" + nrmVel + \".w,\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\tcode += \"mul \" + cos + \",\" + animationRegisterCache.vertexTime + \",\" + rotationRegister + \".w\\n\";\n\t\t\tcode += \"sin \" + sin + \",\" + cos + \"\\n\";\n\t\t\tcode += \"cos \" + cos + \",\" + cos + \"\\n\";\n\t\t\tcode += \"mul \" + Rtemp + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\t\t\tcode += \"mul \" + R_rev + \".xyz,\" + sin + \",\" + nrmVel + \".xyz\\n\";\n\t\t\tcode += \"neg \" + R_rev + \".xyz,\" + R_rev + \".xyz\\n\";\n\t\t\tcode += \"crs \" + nrmVel + \".xyz,\" + Rtemp + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \".xyz\\n\";\n\t\t\tcode += \"mul \" + xAxis + \".xyz,\" + cos + \",\" + animationRegisterCache.rotationRegisters[i] + \"\\n\";\n\t\t\tcode += \"add \" + nrmVel + \".xyz,\" + nrmVel + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\tcode += \"dp3 \" + xAxis + \".w,\" + Rtemp + \".xyz,\" + animationRegisterCache.rotationRegisters[i] + \"\\n\";\n\t\t\tcode += \"neg \" + nrmVel + \".w,\" + xAxis + \".w\\n\";\n\t\t\tcode += \"crs \" + Rtemp + \".xyz,\" + nrmVel + \".xyz,\" + R_rev + \".xyz\\n\";\n\t\t\tcode += \"mul \" + xAxis + \".xyzw,\" + nrmVel + \".xyzw,\" + cos + \"\\n\";\n\t\t\tcode += \"add \" + Rtemp + \".xyz,\" + Rtemp + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t\tcode += \"mul \" + xAxis + \".xyz,\" + nrmVel + \".w,\" + R_rev + \".xyz\\n\";\n\t\t\tcode += \"add \" + animationRegisterCache.rotationRegisters[i] + \",\" + Rtemp + \".xyz,\" + xAxis + \".xyz\\n\";\n\t\t}\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleRotationalVelocityState\n\t{\n\t\treturn <ParticleRotationalVelocityState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\t//(Vector3d.x,Vector3d.y,Vector3d.z) is rotation axis,Vector3d.w is cycle duration\n\t\tvar rotate:Vector3D = param[ParticleRotationalVelocityNode.ROTATIONALVELOCITY_VECTOR3D];\n\t\tif (!rotate)\n\t\t\tthrow(new Error(\"there is no \" + ParticleRotationalVelocityNode.ROTATIONALVELOCITY_VECTOR3D + \" in param!\"));\n\n\t\tif (rotate.length <= 0)\n\t\t\trotate.z = 1; //set the default direction\n\t\telse\n\t\t\trotate.normalize();\n\n\t\tthis._pOneData[0] = rotate.x;\n\t\tthis._pOneData[1] = rotate.y;\n\t\tthis._pOneData[2] = rotate.z;\n\t\tif (rotate.w <= 0)\n\t\t\tthrow(new Error(\"the cycle duration must greater than zero\"));\n\t\t// it's used as angle/2 in agal\n\t\tthis._pOneData[3] = Math.PI/rotate.w;\n\t}\n}\n\nexport = ParticleRotationalVelocityNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleRotationalVelocityNode.ts b/lib/animators/nodes/ParticleRotationalVelocityNode.ts new file mode 100644 index 000000000..551851617 --- /dev/null +++ b/lib/animators/nodes/ParticleRotationalVelocityNode.ts @@ -0,0 +1,156 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleRotationalVelocityState = require("awayjs-renderergl/lib/animators/states/ParticleRotationalVelocityState"); + +/** + * A particle animation node used to set the starting rotational velocity of a particle. + */ +class ParticleRotationalVelocityNode extends ParticleNodeBase +{ + /** @private */ + public _iRotationalVelocity:Vector3D; + + /** + * Reference for rotational velocity node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the rotational velocity around an axis of the particle. + */ + public static ROTATIONALVELOCITY_VECTOR3D:string = "RotationalVelocityVector3D"; + + /** + * Creates a new ParticleRotationalVelocityNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + */ + constructor(mode:number /*uint*/, rotationalVelocity:Vector3D = null) + { + super("ParticleRotationalVelocity", mode, 4); + + this._pStateClass = ParticleRotationalVelocityState; + + this._iRotationalVelocity = rotationalVelocity || new Vector3D(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var rotationRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleRotationalVelocityState.ROTATIONALVELOCITY_INDEX, rotationRegister.index); + + var nrmVel:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(nrmVel, 1); + + var xAxis:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(xAxis, 1); + + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(temp, 1); + var Rtemp:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index); + var R_rev:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + R_rev = new ShaderRegisterElement(R_rev.regName, R_rev.index); + + var cos:ShaderRegisterElement = new ShaderRegisterElement(Rtemp.regName, Rtemp.index, 3); + var sin:ShaderRegisterElement = new ShaderRegisterElement(R_rev.regName, R_rev.index, 3); + + animationRegisterCache.removeVertexTempUsage(nrmVel); + animationRegisterCache.removeVertexTempUsage(xAxis); + animationRegisterCache.removeVertexTempUsage(temp); + + var code:string = ""; + code += "mov " + nrmVel + ".xyz," + rotationRegister + ".xyz\n"; + code += "mov " + nrmVel + ".w," + animationRegisterCache.vertexZeroConst + "\n"; + + code += "mul " + cos + "," + animationRegisterCache.vertexTime + "," + rotationRegister + ".w\n"; + + code += "sin " + sin + "," + cos + "\n"; + code += "cos " + cos + "," + cos + "\n"; + + code += "mul " + Rtemp + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + + //nrmVel and xAxis are used as temp register + code += "crs " + nrmVel + ".xyz," + Rtemp + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + Rtemp + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + + code += "crs " + Rtemp + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + + //use cos as R_rev.w + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + Rtemp + ".xyz," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + + code += "add " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + + var len:number /*int*/ = animationRegisterCache.rotationRegisters.length; + for (var i:number /*int*/ = 0; i < len; i++) { + code += "mov " + nrmVel + ".xyz," + rotationRegister + ".xyz\n"; + code += "mov " + nrmVel + ".w," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mul " + cos + "," + animationRegisterCache.vertexTime + "," + rotationRegister + ".w\n"; + code += "sin " + sin + "," + cos + "\n"; + code += "cos " + cos + "," + cos + "\n"; + code += "mul " + Rtemp + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "mul " + R_rev + ".xyz," + sin + "," + nrmVel + ".xyz\n"; + code += "neg " + R_rev + ".xyz," + R_rev + ".xyz\n"; + code += "crs " + nrmVel + ".xyz," + Rtemp + ".xyz," + animationRegisterCache.rotationRegisters[i] + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + cos + "," + animationRegisterCache.rotationRegisters[i] + "\n"; + code += "add " + nrmVel + ".xyz," + nrmVel + ".xyz," + xAxis + ".xyz\n"; + code += "dp3 " + xAxis + ".w," + Rtemp + ".xyz," + animationRegisterCache.rotationRegisters[i] + "\n"; + code += "neg " + nrmVel + ".w," + xAxis + ".w\n"; + code += "crs " + Rtemp + ".xyz," + nrmVel + ".xyz," + R_rev + ".xyz\n"; + code += "mul " + xAxis + ".xyzw," + nrmVel + ".xyzw," + cos + "\n"; + code += "add " + Rtemp + ".xyz," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + code += "mul " + xAxis + ".xyz," + nrmVel + ".w," + R_rev + ".xyz\n"; + code += "add " + animationRegisterCache.rotationRegisters[i] + "," + Rtemp + ".xyz," + xAxis + ".xyz\n"; + } + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleRotationalVelocityState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + //(Vector3d.x,Vector3d.y,Vector3d.z) is rotation axis,Vector3d.w is cycle duration + var rotate:Vector3D = param[ParticleRotationalVelocityNode.ROTATIONALVELOCITY_VECTOR3D]; + if (!rotate) + throw(new Error("there is no " + ParticleRotationalVelocityNode.ROTATIONALVELOCITY_VECTOR3D + " in param!")); + + if (rotate.length <= 0) + rotate.z = 1; //set the default direction + else + rotate.normalize(); + + this._pOneData[0] = rotate.x; + this._pOneData[1] = rotate.y; + this._pOneData[2] = rotate.z; + if (rotate.w <= 0) + throw(new Error("the cycle duration must greater than zero")); + // it's used as angle/2 in agal + this._pOneData[3] = Math.PI/rotate.w; + } +} + +export = ParticleRotationalVelocityNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleScaleNode.js b/lib/animators/nodes/ParticleScaleNode.js new file mode 100755 index 000000000..e2c40f83e --- /dev/null +++ b/lib/animators/nodes/ParticleScaleNode.js @@ -0,0 +1,95 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleScaleState = require("awayjs-renderergl/lib/animators/states/ParticleScaleState"); +/** + * A particle animation node used to control the scale variation of a particle over time. + */ +var ParticleScaleNode = (function (_super) { + __extends(ParticleScaleNode, _super); + /** + * Creates a new ParticleScaleNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] usesCycle Defines whether the node uses the cycleDuration property in the shader to calculate the period of animation independent of particle duration. Defaults to false. + * @param [optional] usesPhase Defines whether the node uses the cyclePhase property in the shader to calculate a starting offset to the animation cycle. Defaults to false. + * @param [optional] minScale Defines the default min scale transform of the node, when in global mode. Defaults to 1. + * @param [optional] maxScale Defines the default max color transform of the node, when in global mode. Defaults to 1. + * @param [optional] cycleDuration Defines the default duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the default phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + function ParticleScaleNode(mode /*uint*/, usesCycle, usesPhase, minScale, maxScale, cycleDuration, cyclePhase) { + if (minScale === void 0) { minScale = 1; } + if (maxScale === void 0) { maxScale = 1; } + if (cycleDuration === void 0) { cycleDuration = 1; } + if (cyclePhase === void 0) { cyclePhase = 0; } + _super.call(this, "ParticleScale", mode, (usesCycle && usesPhase) ? 4 : ((usesCycle || usesPhase) ? 3 : 2), 3); + this._pStateClass = ParticleScaleState; + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + this._iMinScale = minScale; + this._iMaxScale = maxScale; + this._iCycleDuration = cycleDuration; + this._iCyclePhase = cyclePhase; + } + /** + * @inheritDoc + */ + ParticleScaleNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var code = ""; + var temp = animationRegisterCache.getFreeVertexSingleTemp(); + var scaleRegister = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleScaleState.SCALE_INDEX, scaleRegister.index); + if (this._iUsesCycle) { + code += "mul " + temp + "," + animationRegisterCache.vertexTime + "," + scaleRegister + ".z\n"; + if (this._iUsesPhase) + code += "add " + temp + "," + temp + "," + scaleRegister + ".w\n"; + code += "sin " + temp + "," + temp + "\n"; + } + code += "mul " + temp + "," + scaleRegister + ".y," + ((this._iUsesCycle) ? temp : animationRegisterCache.vertexLife) + "\n"; + code += "add " + temp + "," + scaleRegister + ".x," + temp + "\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp + "\n"; + return code; + }; + /** + * @inheritDoc + */ + ParticleScaleNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleScaleNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var scale = param[ParticleScaleNode.SCALE_VECTOR3D]; + if (!scale) + throw (new Error("there is no " + ParticleScaleNode.SCALE_VECTOR3D + " in param!")); + if (this._iUsesCycle) { + this._pOneData[0] = (scale.x + scale.y) / 2; + this._pOneData[1] = Math.abs(scale.x - scale.y) / 2; + if (scale.z <= 0) + throw (new Error("the cycle duration must be greater than zero")); + this._pOneData[2] = Math.PI * 2 / scale.z; + if (this._iUsesPhase) + this._pOneData[3] = scale.w * Math.PI / 180; + } + else { + this._pOneData[0] = scale.x; + this._pOneData[1] = scale.y - scale.x; + } + }; + /** + * Reference for scale node properties on a single particle (when in local property mode). + * Expects a Vector3D representing the min scale (x), max scale(y), optional cycle speed (z) and phase offset (w) applied to the particle. + */ + ParticleScaleNode.SCALE_VECTOR3D = "ScaleVector3D"; + return ParticleScaleNode; +})(ParticleNodeBase); +module.exports = ParticleScaleNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlescalenode.ts"],"names":["ParticleScaleNode","ParticleScaleNode.constructor","ParticleScaleNode.getAGALVertexCode","ParticleScaleNode.getAnimationState","ParticleScaleNode._iGeneratePropertyOfOneParticle"],"mappings":";;;;;;AAQA,IAAO,sBAAsB,WAAa,6DAA6D,CAAC,CAAC;AACzG,IAAO,gBAAgB,WAAe,wDAAwD,CAAC,CAAC;AAChG,IAAO,kBAAkB,WAAc,2DAA2D,CAAC,CAAC;AAEpG,AAGA;;GADG;IACG,iBAAiB;IAASA,UAA1BA,iBAAiBA,UAAyBA;IAuB/CA;;;;;;;;;;OAUGA;IACHA,SAlCKA,iBAAiBA,CAkCVA,IAAIA,CAAQA,QAADA,AAASA,EAAEA,SAAiBA,EAAEA,SAAiBA,EAAEA,QAAmBA,EAAEA,QAAmBA,EAAEA,aAAwBA,EAAEA,UAAqBA;QAAzFC,wBAAmBA,GAAnBA,YAAmBA;QAAEA,wBAAmBA,GAAnBA,YAAmBA;QAAEA,6BAAwBA,GAAxBA,iBAAwBA;QAAEA,0BAAqBA,GAArBA,cAAqBA;QAEhKA,kBAAMA,eAAeA,EAAEA,IAAIA,EAAEA,CAACA,SAASA,IAAIA,SAASA,CAACA,GAAEA,CAACA,GAAGA,CAACA,CAACA,SAASA,IAAIA,SAASA,CAACA,GAAEA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;QAEjGA,IAAIA,CAACA,YAAYA,GAAGA,kBAAkBA,CAACA;QAEvCA,IAAIA,CAACA,WAAWA,GAAGA,SAASA,CAACA;QAC7BA,IAAIA,CAACA,WAAWA,GAAGA,SAASA,CAACA;QAE7BA,IAAIA,CAACA,UAAUA,GAAGA,QAAQA,CAACA;QAC3BA,IAAIA,CAACA,UAAUA,GAAGA,QAAQA,CAACA;QAC3BA,IAAIA,CAACA,eAAeA,GAAGA,aAAaA,CAACA;QACrCA,IAAIA,CAACA,YAAYA,GAAGA,UAAUA,CAACA;IAChCA,CAACA;IAEDD;;OAEGA;IACIA,6CAAiBA,GAAxBA,UAAyBA,YAA6BA,EAAEA,sBAA6CA;QAEpGE,IAAIA,IAAIA,GAAUA,EAAEA,CAACA;QACrBA,IAAIA,IAAIA,GAAyBA,sBAAsBA,CAACA,uBAAuBA,EAAEA,CAACA;QAElFA,IAAIA,aAAaA,GAAyBA,CAACA,IAAIA,CAACA,MAAMA,IAAIA,sBAAsBA,CAACA,MAAMA,CAACA,GAAEA,sBAAsBA,CAACA,qBAAqBA,EAAEA,GAAGA,sBAAsBA,CAACA,sBAAsBA,EAAEA,CAACA;QAC3LA,sBAAsBA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,kBAAkBA,CAACA,WAAWA,EAAEA,aAAaA,CAACA,KAAKA,CAACA,CAACA;QAEnGA,EAAEA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,CAACA;YACtBA,IAAIA,IAAIA,MAAMA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,sBAAsBA,CAACA,UAAUA,GAAGA,GAAGA,GAAGA,aAAaA,GAAGA,MAAMA,CAACA;YAE/FA,EAAEA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA;gBACpBA,IAAIA,IAAIA,MAAMA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,aAAaA,GAAGA,MAAMA,CAACA;YAEnEA,IAAIA,IAAIA,MAAMA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,IAAIA,GAAGA,IAAIA,CAACA;QAC3CA,CAACA;QAEDA,IAAIA,IAAIA,MAAMA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,aAAaA,GAAGA,KAAKA,GAAGA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA,GAAEA,IAAIA,GAAGA,sBAAsBA,CAACA,UAAUA,CAACA,GAAGA,IAAIA,CAACA;QAC5HA,IAAIA,IAAIA,MAAMA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,aAAaA,GAAGA,KAAKA,GAAGA,IAAIA,GAAGA,IAAIA,CAACA;QAClEA,IAAIA,IAAIA,MAAMA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,OAAOA,GAAGA,sBAAsBA,CAACA,oBAAoBA,GAAGA,OAAOA,GAAGA,IAAIA,GAAGA,IAAIA,CAACA;QAE7IA,MAAMA,CAACA,IAAIA,CAACA;IACbA,CAACA;IAEDF;;OAEGA;IACIA,6CAAiBA,GAAxBA,UAAyBA,QAAqBA;QAE7CG,MAAMA,CAAsBA,QAAQA,CAACA,iBAAiBA,CAACA,IAAIA,CAACA,CAACA;IAC9DA,CAACA;IAEDH;;OAEGA;IACIA,2DAA+BA,GAAtCA,UAAuCA,KAAwBA;QAE9DI,IAAIA,KAAKA,GAAYA,KAAKA,CAACA,iBAAiBA,CAACA,cAAcA,CAACA,CAACA;QAC7DA,EAAEA,CAACA,CAACA,CAACA,KAAKA,CAACA;YACVA,MAAKA,CAACA,IAAIA,KAAKA,CAACA,cAAcA,GAAGA,iBAAiBA,CAACA,cAAcA,GAAGA,YAAYA,CAACA,CAACA,CAACA;QAEpFA,EAAEA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,CAACA;YACtBA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,CAACA,KAAKA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,CAACA,CAACA;YAC1CA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,GAAGA,CAACA,KAAKA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,CAACA,CAACA;YAClDA,EAAEA,CAACA,CAACA,KAAKA,CAACA,CAACA,IAAIA,CAACA,CAACA;gBAChBA,MAAKA,CAACA,IAAIA,KAAKA,CAACA,8CAA8CA,CAACA,CAACA,CAACA;YAClEA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,EAAEA,GAACA,CAACA,GAACA,KAAKA,CAACA,CAACA,CAACA;YACtCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA;gBACpBA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,GAACA,IAAIA,CAACA,EAAEA,GAACA,GAAGA,CAACA;QAC1CA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA;YAC5BA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA;QACvCA,CAACA;IACFA,CAACA;IAxFDJ;;;OAGGA;IACWA,gCAAcA,GAAUA,eAAeA,CAACA;IAqFvDA,wBAACA;AAADA,CA1GA,AA0GCA,EA1G+B,gBAAgB,EA0G/C;AAED,AAA2B,iBAAlB,iBAAiB,CAAC","file":"animators/nodes/ParticleScaleNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleScaleState\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleScaleState\");\n\n/**\n * A particle animation node used to control the scale variation of a particle over time.\n */\nclass ParticleScaleNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iUsesCycle:boolean;\n\n\t/** @private */\n\tpublic _iUsesPhase:boolean;\n\n\t/** @private */\n\tpublic _iMinScale:number;\n\t/** @private */\n\tpublic _iMaxScale:number;\n\t/** @private */\n\tpublic _iCycleDuration:number;\n\t/** @private */\n\tpublic _iCyclePhase:number;\n\n\t/**\n\t * Reference for scale node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> representing the min scale (x), max scale(y), optional cycle speed (z) and phase offset (w) applied to the particle.\n\t */\n\tpublic static SCALE_VECTOR3D:string = \"ScaleVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleScaleNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] usesCycle       Defines whether the node uses the <code>cycleDuration</code> property in the shader to calculate the period of animation independent of particle duration. Defaults to false.\n\t * @param    [optional] usesPhase       Defines whether the node uses the <code>cyclePhase</code> property in the shader to calculate a starting offset to the animation cycle. Defaults to false.\n\t * @param    [optional] minScale        Defines the default min scale transform of the node, when in global mode. Defaults to 1.\n\t * @param    [optional] maxScale        Defines the default max color transform of the node, when in global mode. Defaults to 1.\n\t * @param    [optional] cycleDuration   Defines the default duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1.\n\t * @param    [optional] cyclePhase      Defines the default phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0.\n\t */\n\tconstructor(mode:number /*uint*/, usesCycle:boolean, usesPhase:boolean, minScale:number = 1, maxScale:number = 1, cycleDuration:number = 1, cyclePhase:number = 0)\n\t{\n\t\tsuper(\"ParticleScale\", mode, (usesCycle && usesPhase)? 4 : ((usesCycle || usesPhase)? 3 : 2), 3);\n\n\t\tthis._pStateClass = ParticleScaleState;\n\n\t\tthis._iUsesCycle = usesCycle;\n\t\tthis._iUsesPhase = usesPhase;\n\n\t\tthis._iMinScale = minScale;\n\t\tthis._iMaxScale = maxScale;\n\t\tthis._iCycleDuration = cycleDuration;\n\t\tthis._iCyclePhase = cyclePhase;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp();\n\n\t\tvar scaleRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleScaleState.SCALE_INDEX, scaleRegister.index);\n\n\t\tif (this._iUsesCycle) {\n\t\t\tcode += \"mul \" + temp + \",\" + animationRegisterCache.vertexTime + \",\" + scaleRegister + \".z\\n\";\n\n\t\t\tif (this._iUsesPhase)\n\t\t\t\tcode += \"add \" + temp + \",\" + temp + \",\" + scaleRegister + \".w\\n\";\n\n\t\t\tcode += \"sin \" + temp + \",\" + temp + \"\\n\";\n\t\t}\n\n\t\tcode += \"mul \" + temp + \",\" + scaleRegister + \".y,\" + ((this._iUsesCycle)? temp : animationRegisterCache.vertexLife) + \"\\n\";\n\t\tcode += \"add \" + temp + \",\" + scaleRegister + \".x,\" + temp + \"\\n\";\n\t\tcode += \"mul \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp + \"\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleScaleState\n\t{\n\t\treturn <ParticleScaleState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tvar scale:Vector3D = param[ParticleScaleNode.SCALE_VECTOR3D];\n\t\tif (!scale)\n\t\t\tthrow(new Error(\"there is no \" + ParticleScaleNode.SCALE_VECTOR3D + \" in param!\"));\n\n\t\tif (this._iUsesCycle) {\n\t\t\tthis._pOneData[0] = (scale.x + scale.y)/2;\n\t\t\tthis._pOneData[1] = Math.abs(scale.x - scale.y)/2;\n\t\t\tif (scale.z <= 0)\n\t\t\t\tthrow(new Error(\"the cycle duration must be greater than zero\"));\n\t\t\tthis._pOneData[2] = Math.PI*2/scale.z;\n\t\t\tif (this._iUsesPhase)\n\t\t\t\tthis._pOneData[3] = scale.w*Math.PI/180;\n\t\t} else {\n\t\t\tthis._pOneData[0] = scale.x;\n\t\t\tthis._pOneData[1] = scale.y - scale.x;\n\t\t}\n\t}\n}\n\nexport = ParticleScaleNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleScaleNode.ts b/lib/animators/nodes/ParticleScaleNode.ts new file mode 100644 index 000000000..f150cef24 --- /dev/null +++ b/lib/animators/nodes/ParticleScaleNode.ts @@ -0,0 +1,124 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleScaleState = require("awayjs-renderergl/lib/animators/states/ParticleScaleState"); + +/** + * A particle animation node used to control the scale variation of a particle over time. + */ +class ParticleScaleNode extends ParticleNodeBase +{ + /** @private */ + public _iUsesCycle:boolean; + + /** @private */ + public _iUsesPhase:boolean; + + /** @private */ + public _iMinScale:number; + /** @private */ + public _iMaxScale:number; + /** @private */ + public _iCycleDuration:number; + /** @private */ + public _iCyclePhase:number; + + /** + * Reference for scale node properties on a single particle (when in local property mode). + * Expects a Vector3D representing the min scale (x), max scale(y), optional cycle speed (z) and phase offset (w) applied to the particle. + */ + public static SCALE_VECTOR3D:string = "ScaleVector3D"; + + /** + * Creates a new ParticleScaleNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] usesCycle Defines whether the node uses the cycleDuration property in the shader to calculate the period of animation independent of particle duration. Defaults to false. + * @param [optional] usesPhase Defines whether the node uses the cyclePhase property in the shader to calculate a starting offset to the animation cycle. Defaults to false. + * @param [optional] minScale Defines the default min scale transform of the node, when in global mode. Defaults to 1. + * @param [optional] maxScale Defines the default max color transform of the node, when in global mode. Defaults to 1. + * @param [optional] cycleDuration Defines the default duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the default phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + constructor(mode:number /*uint*/, usesCycle:boolean, usesPhase:boolean, minScale:number = 1, maxScale:number = 1, cycleDuration:number = 1, cyclePhase:number = 0) + { + super("ParticleScale", mode, (usesCycle && usesPhase)? 4 : ((usesCycle || usesPhase)? 3 : 2), 3); + + this._pStateClass = ParticleScaleState; + + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + + this._iMinScale = minScale; + this._iMaxScale = maxScale; + this._iCycleDuration = cycleDuration; + this._iCyclePhase = cyclePhase; + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var code:string = ""; + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp(); + + var scaleRegister:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleScaleState.SCALE_INDEX, scaleRegister.index); + + if (this._iUsesCycle) { + code += "mul " + temp + "," + animationRegisterCache.vertexTime + "," + scaleRegister + ".z\n"; + + if (this._iUsesPhase) + code += "add " + temp + "," + temp + "," + scaleRegister + ".w\n"; + + code += "sin " + temp + "," + temp + "\n"; + } + + code += "mul " + temp + "," + scaleRegister + ".y," + ((this._iUsesCycle)? temp : animationRegisterCache.vertexLife) + "\n"; + code += "add " + temp + "," + scaleRegister + ".x," + temp + "\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp + "\n"; + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleScaleState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var scale:Vector3D = param[ParticleScaleNode.SCALE_VECTOR3D]; + if (!scale) + throw(new Error("there is no " + ParticleScaleNode.SCALE_VECTOR3D + " in param!")); + + if (this._iUsesCycle) { + this._pOneData[0] = (scale.x + scale.y)/2; + this._pOneData[1] = Math.abs(scale.x - scale.y)/2; + if (scale.z <= 0) + throw(new Error("the cycle duration must be greater than zero")); + this._pOneData[2] = Math.PI*2/scale.z; + if (this._iUsesPhase) + this._pOneData[3] = scale.w*Math.PI/180; + } else { + this._pOneData[0] = scale.x; + this._pOneData[1] = scale.y - scale.x; + } + } +} + +export = ParticleScaleNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleSegmentedColorNode.js b/lib/animators/nodes/ParticleSegmentedColorNode.js new file mode 100755 index 000000000..edfa4092e --- /dev/null +++ b/lib/animators/nodes/ParticleSegmentedColorNode.js @@ -0,0 +1,151 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleSegmentedColorState = require("awayjs-renderergl/lib/animators/states/ParticleSegmentedColorState"); +/** + * + */ +var ParticleSegmentedColorNode = (function (_super) { + __extends(ParticleSegmentedColorNode, _super); + function ParticleSegmentedColorNode(usesMultiplier, usesOffset, numSegmentPoint /*int*/, startColor, endColor, segmentPoints) { + //because of the stage3d register limitation, it only support the global mode + _super.call(this, "ParticleSegmentedColor", ParticlePropertiesMode.GLOBAL, 0, ParticleAnimationSet.COLOR_PRIORITY); + this._pStateClass = ParticleSegmentedColorState; + if (numSegmentPoint > 4) + throw (new Error("the numSegmentPoint must be less or equal 4")); + this._iUsesMultiplier = usesMultiplier; + this._iUsesOffset = usesOffset; + this._iNumSegmentPoint = numSegmentPoint; + this._iStartColor = startColor; + this._iEndColor = endColor; + this._iSegmentPoints = segmentPoints; + } + /** + * @inheritDoc + */ + ParticleSegmentedColorNode.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + if (this._iUsesMultiplier) + particleAnimationSet.hasColorMulNode = true; + if (this._iUsesOffset) + particleAnimationSet.hasColorAddNode = true; + }; + /** + * @inheritDoc + */ + ParticleSegmentedColorNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var code = ""; + if (animationRegisterCache.needFragmentAnimation) { + var accMultiplierColor; + //var accOffsetColor:ShaderRegisterElement; + if (this._iUsesMultiplier) { + accMultiplierColor = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(accMultiplierColor, 1); + } + var tempColor = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(tempColor, 1); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + var accTime = new ShaderRegisterElement(temp.regName, temp.index, 0); + var tempTime = new ShaderRegisterElement(temp.regName, temp.index, 1); + if (this._iUsesMultiplier) + animationRegisterCache.removeVertexTempUsage(accMultiplierColor); + animationRegisterCache.removeVertexTempUsage(tempColor); + //for saving all the life values (at most 4) + var lifeTimeRegister = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.TIME_DATA_INDEX, lifeTimeRegister.index); + var i /*int*/; + var startMulValue; + var deltaMulValues; + if (this._iUsesMultiplier) { + startMulValue = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.START_MULTIPLIER_INDEX, startMulValue.index); + deltaMulValues = new Array(); + for (i = 0; i < this._iNumSegmentPoint + 1; i++) + deltaMulValues.push(animationRegisterCache.getFreeVertexConstant()); + } + var startOffsetValue; + var deltaOffsetValues; + if (this._iUsesOffset) { + startOffsetValue = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.START_OFFSET_INDEX, startOffsetValue.index); + deltaOffsetValues = new Array(); + for (i = 0; i < this._iNumSegmentPoint + 1; i++) + deltaOffsetValues.push(animationRegisterCache.getFreeVertexConstant()); + } + if (this._iUsesMultiplier) + code += "mov " + accMultiplierColor + "," + startMulValue + "\n"; + if (this._iUsesOffset) + code += "add " + animationRegisterCache.colorAddTarget + "," + animationRegisterCache.colorAddTarget + "," + startOffsetValue + "\n"; + for (i = 0; i < this._iNumSegmentPoint; i++) { + switch (i) { + case 0: + code += "min " + tempTime + "," + animationRegisterCache.vertexLife + "," + lifeTimeRegister + ".x\n"; + break; + case 1: + code += "sub " + accTime + "," + animationRegisterCache.vertexLife + "," + lifeTimeRegister + ".x\n"; + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "min " + tempTime + "," + tempTime + "," + lifeTimeRegister + ".y\n"; + break; + case 2: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".y\n"; + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "min " + tempTime + "," + tempTime + "," + lifeTimeRegister + ".z\n"; + break; + case 3: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".z\n"; + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "min " + tempTime + "," + tempTime + "," + lifeTimeRegister + ".w\n"; + break; + } + if (this._iUsesMultiplier) { + code += "mul " + tempColor + "," + tempTime + "," + deltaMulValues[i] + "\n"; + code += "add " + accMultiplierColor + "," + accMultiplierColor + "," + tempColor + "\n"; + } + if (this._iUsesOffset) { + code += "mul " + tempColor + "," + tempTime + "," + deltaOffsetValues[i] + "\n"; + code += "add " + animationRegisterCache.colorAddTarget + "," + animationRegisterCache.colorAddTarget + "," + tempColor + "\n"; + } + } + //for the last segment: + if (this._iNumSegmentPoint == 0) + tempTime = animationRegisterCache.vertexLife; + else { + switch (this._iNumSegmentPoint) { + case 1: + code += "sub " + accTime + "," + animationRegisterCache.vertexLife + "," + lifeTimeRegister + ".x\n"; + break; + case 2: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".y\n"; + break; + case 3: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".z\n"; + break; + case 4: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".w\n"; + break; + } + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + } + if (this._iUsesMultiplier) { + code += "mul " + tempColor + "," + tempTime + "," + deltaMulValues[this._iNumSegmentPoint] + "\n"; + code += "add " + accMultiplierColor + "," + accMultiplierColor + "," + tempColor + "\n"; + code += "mul " + animationRegisterCache.colorMulTarget + "," + animationRegisterCache.colorMulTarget + "," + accMultiplierColor + "\n"; + } + if (this._iUsesOffset) { + code += "mul " + tempColor + "," + tempTime + "," + deltaOffsetValues[this._iNumSegmentPoint] + "\n"; + code += "add " + animationRegisterCache.colorAddTarget + "," + animationRegisterCache.colorAddTarget + "," + tempColor + "\n"; + } + } + return code; + }; + return ParticleSegmentedColorNode; +})(ParticleNodeBase); +module.exports = ParticleSegmentedColorNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlesegmentedcolornode.ts"],"names":["ParticleSegmentedColorNode","ParticleSegmentedColorNode.constructor","ParticleSegmentedColorNode._iProcessAnimationSetting","ParticleSegmentedColorNode.getAGALVertexCode"],"mappings":"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","file":"animators/nodes/ParticleSegmentedColorNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ColorTransform\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/ColorTransform\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ColorSegmentPoint\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ColorSegmentPoint\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleSegmentedColorState\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleSegmentedColorState\");\n\n/**\n *\n */\nclass ParticleSegmentedColorNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iUsesMultiplier:boolean;\n\t/** @private */\n\tpublic _iUsesOffset:boolean;\n\t/** @private */\n\tpublic _iStartColor:ColorTransform;\n\t/** @private */\n\tpublic _iEndColor:ColorTransform;\n\t/** @private */\n\tpublic _iNumSegmentPoint:number /*int*/;\n\t/** @private */\n\tpublic _iSegmentPoints:Array<ColorSegmentPoint>;\n\n\tconstructor(usesMultiplier:boolean, usesOffset:boolean, numSegmentPoint:number /*int*/, startColor:ColorTransform, endColor:ColorTransform, segmentPoints:Array<ColorSegmentPoint>)\n\t{\n\t\t//because of the stage3d register limitation, it only support the global mode\n\t\tsuper(\"ParticleSegmentedColor\", ParticlePropertiesMode.GLOBAL, 0, ParticleAnimationSet.COLOR_PRIORITY);\n\n\t\tthis._pStateClass = ParticleSegmentedColorState;\n\n\t\tif (numSegmentPoint > 4)\n\t\t\tthrow(new Error(\"the numSegmentPoint must be less or equal 4\"));\n\t\tthis._iUsesMultiplier = usesMultiplier;\n\t\tthis._iUsesOffset = usesOffset;\n\t\tthis._iNumSegmentPoint = numSegmentPoint;\n\t\tthis._iStartColor = startColor;\n\t\tthis._iEndColor = endColor;\n\t\tthis._iSegmentPoints = segmentPoints;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet)\n\t{\n\t\tif (this._iUsesMultiplier)\n\t\t\tparticleAnimationSet.hasColorMulNode = true;\n\t\tif (this._iUsesOffset)\n\t\t\tparticleAnimationSet.hasColorAddNode = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar code:string = \"\";\n\t\tif (animationRegisterCache.needFragmentAnimation) {\n\t\t\tvar accMultiplierColor:ShaderRegisterElement;\n\t\t\t//var accOffsetColor:ShaderRegisterElement;\n\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\taccMultiplierColor = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\t\tanimationRegisterCache.addVertexTempUsages(accMultiplierColor, 1);\n\t\t\t}\n\n\t\t\tvar tempColor:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tanimationRegisterCache.addVertexTempUsages(tempColor, 1);\n\n\t\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\t\tvar accTime:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0);\n\t\t\tvar tempTime:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1);\n\n\t\t\tif (this._iUsesMultiplier)\n\t\t\t\tanimationRegisterCache.removeVertexTempUsage(accMultiplierColor);\n\n\t\t\tanimationRegisterCache.removeVertexTempUsage(tempColor);\n\n\t\t\t//for saving all the life values (at most 4)\n\t\t\tvar lifeTimeRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.TIME_DATA_INDEX, lifeTimeRegister.index);\n\n\t\t\tvar i:number /*int*/;\n\n\t\t\tvar startMulValue:ShaderRegisterElement;\n\t\t\tvar deltaMulValues:Array<ShaderRegisterElement>;\n\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\tstartMulValue = animationRegisterCache.getFreeVertexConstant();\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.START_MULTIPLIER_INDEX, startMulValue.index);\n\t\t\t\tdeltaMulValues = new Array<ShaderRegisterElement>();\n\t\t\t\tfor (i = 0; i < this._iNumSegmentPoint + 1; i++)\n\t\t\t\t\tdeltaMulValues.push(animationRegisterCache.getFreeVertexConstant());\n\t\t\t}\n\n\t\t\tvar startOffsetValue:ShaderRegisterElement;\n\t\t\tvar deltaOffsetValues:Array<ShaderRegisterElement>;\n\t\t\tif (this._iUsesOffset) {\n\t\t\t\tstartOffsetValue = animationRegisterCache.getFreeVertexConstant();\n\t\t\t\tanimationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.START_OFFSET_INDEX, startOffsetValue.index);\n\t\t\t\tdeltaOffsetValues = new Array<ShaderRegisterElement>();\n\t\t\t\tfor (i = 0; i < this._iNumSegmentPoint + 1; i++)\n\t\t\t\t\tdeltaOffsetValues.push(animationRegisterCache.getFreeVertexConstant());\n\t\t\t}\n\n\t\t\tif (this._iUsesMultiplier)\n\t\t\t\tcode += \"mov \" + accMultiplierColor + \",\" + startMulValue + \"\\n\";\n\t\t\tif (this._iUsesOffset)\n\t\t\t\tcode += \"add \" + animationRegisterCache.colorAddTarget + \",\" + animationRegisterCache.colorAddTarget + \",\" + startOffsetValue + \"\\n\";\n\n\t\t\tfor (i = 0; i < this._iNumSegmentPoint; i++) {\n\t\t\t\tswitch (i) {\n\t\t\t\t\tcase 0:\n\t\t\t\t\t\tcode += \"min \" + tempTime + \",\" + animationRegisterCache.vertexLife + \",\" + lifeTimeRegister + \".x\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 1:\n\t\t\t\t\t\tcode += \"sub \" + accTime + \",\" + animationRegisterCache.vertexLife + \",\" + lifeTimeRegister + \".x\\n\";\n\t\t\t\t\t\tcode += \"max \" + tempTime + \",\" + accTime + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\t\t\t\tcode += \"min \" + tempTime + \",\" + tempTime + \",\" + lifeTimeRegister + \".y\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 2:\n\t\t\t\t\t\tcode += \"sub \" + accTime + \",\" + accTime + \",\" + lifeTimeRegister + \".y\\n\";\n\t\t\t\t\t\tcode += \"max \" + tempTime + \",\" + accTime + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\t\t\t\tcode += \"min \" + tempTime + \",\" + tempTime + \",\" + lifeTimeRegister + \".z\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 3:\n\t\t\t\t\t\tcode += \"sub \" + accTime + \",\" + accTime + \",\" + lifeTimeRegister + \".z\\n\";\n\t\t\t\t\t\tcode += \"max \" + tempTime + \",\" + accTime + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\t\t\t\tcode += \"min \" + tempTime + \",\" + tempTime + \",\" + lifeTimeRegister + \".w\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\t\tcode += \"mul \" + tempColor + \",\" + tempTime + \",\" + deltaMulValues[i] + \"\\n\";\n\t\t\t\t\tcode += \"add \" + accMultiplierColor + \",\" + accMultiplierColor + \",\" + tempColor + \"\\n\";\n\t\t\t\t}\n\t\t\t\tif (this._iUsesOffset) {\n\t\t\t\t\tcode += \"mul \" + tempColor + \",\" + tempTime + \",\" + deltaOffsetValues[i] + \"\\n\";\n\t\t\t\t\tcode += \"add \" + animationRegisterCache.colorAddTarget + \",\" + animationRegisterCache.colorAddTarget + \",\" + tempColor + \"\\n\";\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t//for the last segment:\n\t\t\tif (this._iNumSegmentPoint == 0)\n\t\t\t\ttempTime = animationRegisterCache.vertexLife;\n\t\t\telse {\n\t\t\t\tswitch (this._iNumSegmentPoint) {\n\t\t\t\t\tcase 1:\n\t\t\t\t\t\tcode += \"sub \" + accTime + \",\" + animationRegisterCache.vertexLife + \",\" + lifeTimeRegister + \".x\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 2:\n\t\t\t\t\t\tcode += \"sub \" + accTime + \",\" + accTime + \",\" + lifeTimeRegister + \".y\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 3:\n\t\t\t\t\t\tcode += \"sub \" + accTime + \",\" + accTime + \",\" + lifeTimeRegister + \".z\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 4:\n\t\t\t\t\t\tcode += \"sub \" + accTime + \",\" + accTime + \",\" + lifeTimeRegister + \".w\\n\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tcode += \"max \" + tempTime + \",\" + accTime + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\t\t}\n\t\t\tif (this._iUsesMultiplier) {\n\t\t\t\tcode += \"mul \" + tempColor + \",\" + tempTime + \",\" + deltaMulValues[this._iNumSegmentPoint] + \"\\n\";\n\t\t\t\tcode += \"add \" + accMultiplierColor + \",\" + accMultiplierColor + \",\" + tempColor + \"\\n\";\n\t\t\t\tcode += \"mul \" + animationRegisterCache.colorMulTarget + \",\" + animationRegisterCache.colorMulTarget + \",\" + accMultiplierColor + \"\\n\";\n\t\t\t}\n\t\t\tif (this._iUsesOffset) {\n\t\t\t\tcode += \"mul \" + tempColor + \",\" + tempTime + \",\" + deltaOffsetValues[this._iNumSegmentPoint] + \"\\n\";\n\t\t\t\tcode += \"add \" + animationRegisterCache.colorAddTarget + \",\" + animationRegisterCache.colorAddTarget + \",\" + tempColor + \"\\n\";\n\t\t\t}\n\n\t\t}\n\t\treturn code;\n\t}\n\n}\n\nexport = ParticleSegmentedColorNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleSegmentedColorNode.ts b/lib/animators/nodes/ParticleSegmentedColorNode.ts new file mode 100644 index 000000000..edee40270 --- /dev/null +++ b/lib/animators/nodes/ParticleSegmentedColorNode.ts @@ -0,0 +1,186 @@ +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ColorSegmentPoint = require("awayjs-renderergl/lib/animators/data/ColorSegmentPoint"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleSegmentedColorState = require("awayjs-renderergl/lib/animators/states/ParticleSegmentedColorState"); + +/** + * + */ +class ParticleSegmentedColorNode extends ParticleNodeBase +{ + /** @private */ + public _iUsesMultiplier:boolean; + /** @private */ + public _iUsesOffset:boolean; + /** @private */ + public _iStartColor:ColorTransform; + /** @private */ + public _iEndColor:ColorTransform; + /** @private */ + public _iNumSegmentPoint:number /*int*/; + /** @private */ + public _iSegmentPoints:Array; + + constructor(usesMultiplier:boolean, usesOffset:boolean, numSegmentPoint:number /*int*/, startColor:ColorTransform, endColor:ColorTransform, segmentPoints:Array) + { + //because of the stage3d register limitation, it only support the global mode + super("ParticleSegmentedColor", ParticlePropertiesMode.GLOBAL, 0, ParticleAnimationSet.COLOR_PRIORITY); + + this._pStateClass = ParticleSegmentedColorState; + + if (numSegmentPoint > 4) + throw(new Error("the numSegmentPoint must be less or equal 4")); + this._iUsesMultiplier = usesMultiplier; + this._iUsesOffset = usesOffset; + this._iNumSegmentPoint = numSegmentPoint; + this._iStartColor = startColor; + this._iEndColor = endColor; + this._iSegmentPoints = segmentPoints; + } + + /** + * @inheritDoc + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + if (this._iUsesMultiplier) + particleAnimationSet.hasColorMulNode = true; + if (this._iUsesOffset) + particleAnimationSet.hasColorAddNode = true; + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var code:string = ""; + if (animationRegisterCache.needFragmentAnimation) { + var accMultiplierColor:ShaderRegisterElement; + //var accOffsetColor:ShaderRegisterElement; + if (this._iUsesMultiplier) { + accMultiplierColor = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(accMultiplierColor, 1); + } + + var tempColor:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + animationRegisterCache.addVertexTempUsages(tempColor, 1); + + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var accTime:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0); + var tempTime:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1); + + if (this._iUsesMultiplier) + animationRegisterCache.removeVertexTempUsage(accMultiplierColor); + + animationRegisterCache.removeVertexTempUsage(tempColor); + + //for saving all the life values (at most 4) + var lifeTimeRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.TIME_DATA_INDEX, lifeTimeRegister.index); + + var i:number /*int*/; + + var startMulValue:ShaderRegisterElement; + var deltaMulValues:Array; + if (this._iUsesMultiplier) { + startMulValue = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.START_MULTIPLIER_INDEX, startMulValue.index); + deltaMulValues = new Array(); + for (i = 0; i < this._iNumSegmentPoint + 1; i++) + deltaMulValues.push(animationRegisterCache.getFreeVertexConstant()); + } + + var startOffsetValue:ShaderRegisterElement; + var deltaOffsetValues:Array; + if (this._iUsesOffset) { + startOffsetValue = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleSegmentedColorState.START_OFFSET_INDEX, startOffsetValue.index); + deltaOffsetValues = new Array(); + for (i = 0; i < this._iNumSegmentPoint + 1; i++) + deltaOffsetValues.push(animationRegisterCache.getFreeVertexConstant()); + } + + if (this._iUsesMultiplier) + code += "mov " + accMultiplierColor + "," + startMulValue + "\n"; + if (this._iUsesOffset) + code += "add " + animationRegisterCache.colorAddTarget + "," + animationRegisterCache.colorAddTarget + "," + startOffsetValue + "\n"; + + for (i = 0; i < this._iNumSegmentPoint; i++) { + switch (i) { + case 0: + code += "min " + tempTime + "," + animationRegisterCache.vertexLife + "," + lifeTimeRegister + ".x\n"; + break; + case 1: + code += "sub " + accTime + "," + animationRegisterCache.vertexLife + "," + lifeTimeRegister + ".x\n"; + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "min " + tempTime + "," + tempTime + "," + lifeTimeRegister + ".y\n"; + break; + case 2: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".y\n"; + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "min " + tempTime + "," + tempTime + "," + lifeTimeRegister + ".z\n"; + break; + case 3: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".z\n"; + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "min " + tempTime + "," + tempTime + "," + lifeTimeRegister + ".w\n"; + break; + } + if (this._iUsesMultiplier) { + code += "mul " + tempColor + "," + tempTime + "," + deltaMulValues[i] + "\n"; + code += "add " + accMultiplierColor + "," + accMultiplierColor + "," + tempColor + "\n"; + } + if (this._iUsesOffset) { + code += "mul " + tempColor + "," + tempTime + "," + deltaOffsetValues[i] + "\n"; + code += "add " + animationRegisterCache.colorAddTarget + "," + animationRegisterCache.colorAddTarget + "," + tempColor + "\n"; + } + } + + //for the last segment: + if (this._iNumSegmentPoint == 0) + tempTime = animationRegisterCache.vertexLife; + else { + switch (this._iNumSegmentPoint) { + case 1: + code += "sub " + accTime + "," + animationRegisterCache.vertexLife + "," + lifeTimeRegister + ".x\n"; + break; + case 2: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".y\n"; + break; + case 3: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".z\n"; + break; + case 4: + code += "sub " + accTime + "," + accTime + "," + lifeTimeRegister + ".w\n"; + break; + } + code += "max " + tempTime + "," + accTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + } + if (this._iUsesMultiplier) { + code += "mul " + tempColor + "," + tempTime + "," + deltaMulValues[this._iNumSegmentPoint] + "\n"; + code += "add " + accMultiplierColor + "," + accMultiplierColor + "," + tempColor + "\n"; + code += "mul " + animationRegisterCache.colorMulTarget + "," + animationRegisterCache.colorMulTarget + "," + accMultiplierColor + "\n"; + } + if (this._iUsesOffset) { + code += "mul " + tempColor + "," + tempTime + "," + deltaOffsetValues[this._iNumSegmentPoint] + "\n"; + code += "add " + animationRegisterCache.colorAddTarget + "," + animationRegisterCache.colorAddTarget + "," + tempColor + "\n"; + } + + } + return code; + } + +} + +export = ParticleSegmentedColorNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleSpriteSheetNode.js b/lib/animators/nodes/ParticleSpriteSheetNode.js new file mode 100755 index 000000000..be805ce67 --- /dev/null +++ b/lib/animators/nodes/ParticleSpriteSheetNode.js @@ -0,0 +1,167 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleSpriteSheetState = require("awayjs-renderergl/lib/animators/states/ParticleSpriteSheetState"); +/** + * A particle animation node used when a spritesheet texture is required to animate the particle. + * NB: to enable use of this node, the repeat property on the material has to be set to true. + */ +var ParticleSpriteSheetNode = (function (_super) { + __extends(ParticleSpriteSheetNode, _super); + /** + * Creates a new ParticleSpriteSheetNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] numColumns Defines the number of columns in the spritesheet, when in global mode. Defaults to 1. + * @param [optional] numRows Defines the number of rows in the spritesheet, when in global mode. Defaults to 1. + * @param [optional] cycleDuration Defines the default cycle duration in seconds, when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the default cycle phase, when in global mode. Defaults to 0. + * @param [optional] totalFrames Defines the total number of frames used by the spritesheet, when in global mode. Defaults to the number defined by numColumns and numRows. + * @param [optional] looping Defines whether the spritesheet animation is set to loop indefinitely. Defaults to true. + */ + function ParticleSpriteSheetNode(mode /*uint*/, usesCycle, usesPhase, numColumns, numRows, cycleDuration, cyclePhase, totalFrames) { + if (numColumns === void 0) { numColumns = 1; } + if (numRows === void 0) { numRows = 1; } + if (cycleDuration === void 0) { cycleDuration = 1; } + if (cyclePhase === void 0) { cyclePhase = 0; } + if (totalFrames === void 0) { totalFrames = Number.MAX_VALUE; } + _super.call(this, "ParticleSpriteSheet", mode, usesCycle ? (usesPhase ? 3 : 2) : 1, ParticleAnimationSet.POST_PRIORITY + 1); + this._pStateClass = ParticleSpriteSheetState; + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + this._iNumColumns = numColumns; + this._iNumRows = numRows; + this._iCyclePhase = cyclePhase; + this._iCycleDuration = cycleDuration; + this._iTotalFrames = Math.min(totalFrames, numColumns * numRows); + } + Object.defineProperty(ParticleSpriteSheetNode.prototype, "numColumns", { + /** + * Defines the number of columns in the spritesheet, when in global mode. Defaults to 1. Read only. + */ + get: function () { + return this._iNumColumns; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSpriteSheetNode.prototype, "numRows", { + /** + * Defines the number of rows in the spritesheet, when in global mode. Defaults to 1. Read only. + */ + get: function () { + return this._iNumRows; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSpriteSheetNode.prototype, "totalFrames", { + /** + * Defines the total number of frames used by the spritesheet, when in global mode. Defaults to the number defined by numColumns and numRows. Read only. + */ + get: function () { + return this._iTotalFrames; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleSpriteSheetNode.prototype.getAGALUVCode = function (shaderObject, animationRegisterCache) { + //get 2 vc + var uvParamConst1 = animationRegisterCache.getFreeVertexConstant(); + var uvParamConst2 = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleSpriteSheetState.UV_INDEX_0, uvParamConst1.index); + animationRegisterCache.setRegisterIndex(this, ParticleSpriteSheetState.UV_INDEX_1, uvParamConst2.index); + var uTotal = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 0); + var uStep = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 1); + var vStep = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 2); + var uSpeed = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 0); + var cycle = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 1); + var phaseTime = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 2); + var temp = animationRegisterCache.getFreeVertexVectorTemp(); + var time = new ShaderRegisterElement(temp.regName, temp.index, 0); + var vOffset = new ShaderRegisterElement(temp.regName, temp.index, 1); + temp = new ShaderRegisterElement(temp.regName, temp.index, 2); + var temp2 = new ShaderRegisterElement(temp.regName, temp.index, 3); + var u = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, 0); + var v = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, 1); + var code = ""; + //scale uv + code += "mul " + u + "," + u + "," + uStep + "\n"; + if (this._iNumRows > 1) + code += "mul " + v + "," + v + "," + vStep + "\n"; + if (this._iUsesCycle) { + if (this._iUsesPhase) + code += "add " + time + "," + animationRegisterCache.vertexTime + "," + phaseTime + "\n"; + else + code += "mov " + time + "," + animationRegisterCache.vertexTime + "\n"; + code += "div " + time + "," + time + "," + cycle + "\n"; + code += "frc " + time + "," + time + "\n"; + code += "mul " + time + "," + time + "," + cycle + "\n"; + code += "mul " + temp + "," + time + "," + uSpeed + "\n"; + } + else + code += "mul " + temp.toString() + "," + animationRegisterCache.vertexLife + "," + uTotal + "\n"; + if (this._iNumRows > 1) { + code += "frc " + temp2 + "," + temp + "\n"; + code += "sub " + vOffset + "," + temp + "," + temp2 + "\n"; + code += "mul " + vOffset + "," + vOffset + "," + vStep + "\n"; + code += "add " + v + "," + v + "," + vOffset + "\n"; + } + code += "div " + temp2 + "," + temp + "," + uStep + "\n"; + code += "frc " + temp + "," + temp2 + "\n"; + code += "sub " + temp2 + "," + temp2 + "," + temp + "\n"; + code += "mul " + temp + "," + temp2 + "," + uStep + "\n"; + if (this._iNumRows > 1) + code += "frc " + temp + "," + temp + "\n"; + code += "add " + u + "," + u + "," + temp + "\n"; + return code; + }; + /** + * @inheritDoc + */ + ParticleSpriteSheetNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleSpriteSheetNode.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + particleAnimationSet.hasUVNode = true; + }; + /** + * @inheritDoc + */ + ParticleSpriteSheetNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + if (this._iUsesCycle) { + var uvCycle = param[ParticleSpriteSheetNode.UV_VECTOR3D]; + if (!uvCycle) + throw (new Error("there is no " + ParticleSpriteSheetNode.UV_VECTOR3D + " in param!")); + if (uvCycle.x <= 0) + throw (new Error("the cycle duration must be greater than zero")); + var uTotal = this._iTotalFrames / this._iNumColumns; + this._pOneData[0] = uTotal / uvCycle.x; + this._pOneData[1] = uvCycle.x; + if (this._iUsesPhase) + this._pOneData[2] = uvCycle.y; + } + }; + /** + * Reference for spritesheet node properties on a single particle (when in local property mode). + * Expects a Vector3D representing the cycleDuration (x), optional phaseTime (y). + */ + ParticleSpriteSheetNode.UV_VECTOR3D = "UVVector3D"; + return ParticleSpriteSheetNode; +})(ParticleNodeBase); +module.exports = ParticleSpriteSheetNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlespritesheetnode.ts"],"names":["ParticleSpriteSheetNode","ParticleSpriteSheetNode.constructor","ParticleSpriteSheetNode.numColumns","ParticleSpriteSheetNode.numRows","ParticleSpriteSheetNode.totalFrames","ParticleSpriteSheetNode.getAGALUVCode","ParticleSpriteSheetNode.getAnimationState","ParticleSpriteSheetNode._iProcessAnimationSetting","ParticleSpriteSheetNode._iGeneratePropertyOfOneParticle"],"mappings":"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","file":"animators/nodes/ParticleSpriteSheetNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleSpriteSheetState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleSpriteSheetState\");\n\n/**\n * A particle animation node used when a spritesheet texture is required to animate the particle.\n * NB: to enable use of this node, the <code>repeat</code> property on the material has to be set to true.\n */\nclass ParticleSpriteSheetNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iUsesCycle:boolean;\n\n\t/** @private */\n\tpublic _iUsesPhase:boolean;\n\n\t/** @private */\n\tpublic _iTotalFrames:number /*int*/;\n\t/** @private */\n\tpublic _iNumColumns:number /*int*/;\n\t/** @private */\n\tpublic _iNumRows:number /*int*/;\n\t/** @private */\n\tpublic _iCycleDuration:number;\n\t/** @private */\n\tpublic _iCyclePhase:number;\n\n\t/**\n\t * Reference for spritesheet node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> representing the cycleDuration (x), optional phaseTime (y).\n\t */\n\tpublic static UV_VECTOR3D:string = \"UVVector3D\";\n\n\t/**\n\t * Defines the number of columns in the spritesheet, when in global mode. Defaults to 1. Read only.\n\t */\n\tpublic get numColumns():number\n\t{\n\t\treturn this._iNumColumns;\n\t}\n\n\t/**\n\t * Defines the number of rows in the spritesheet, when in global mode. Defaults to 1. Read only.\n\t */\n\tpublic get numRows():number\n\t{\n\t\treturn this._iNumRows;\n\t}\n\n\t/**\n\t * Defines the total number of frames used by the spritesheet, when in global mode. Defaults to the number defined by numColumns and numRows. Read only.\n\t */\n\tpublic get totalFrames():number\n\t{\n\t\treturn this._iTotalFrames;\n\t}\n\n\t/**\n\t * Creates a new <code>ParticleSpriteSheetNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] numColumns      Defines the number of columns in the spritesheet, when in global mode. Defaults to 1.\n\t * @param    [optional] numRows         Defines the number of rows in the spritesheet, when in global mode. Defaults to 1.\n\t * @param    [optional] cycleDuration   Defines the default cycle duration in seconds, when in global mode. Defaults to 1.\n\t * @param    [optional] cyclePhase      Defines the default cycle phase, when in global mode. Defaults to 0.\n\t * @param    [optional] totalFrames     Defines the total number of frames used by the spritesheet, when in global mode. Defaults to the number defined by numColumns and numRows.\n\t * @param    [optional] looping         Defines whether the spritesheet animation is set to loop indefinitely. Defaults to true.\n\t */\n\tconstructor(mode:number /*uint*/, usesCycle:boolean, usesPhase:boolean, numColumns:number /*int*/ = 1, numRows:number /*uint*/ = 1, cycleDuration:number = 1, cyclePhase:number = 0, totalFrames:number /*uint*/ = Number.MAX_VALUE)\n\t{\n\t\tsuper(\"ParticleSpriteSheet\", mode, usesCycle? (usesPhase? 3 : 2) : 1, ParticleAnimationSet.POST_PRIORITY + 1);\n\n\t\tthis._pStateClass = ParticleSpriteSheetState;\n\n\t\tthis._iUsesCycle = usesCycle;\n\t\tthis._iUsesPhase = usesPhase;\n\n\t\tthis._iNumColumns = numColumns;\n\t\tthis._iNumRows = numRows;\n\t\tthis._iCyclePhase = cyclePhase;\n\t\tthis._iCycleDuration = cycleDuration;\n\t\tthis._iTotalFrames = Math.min(totalFrames, numColumns*numRows);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALUVCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\t//get 2 vc\n\t\tvar uvParamConst1:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\tvar uvParamConst2:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleSpriteSheetState.UV_INDEX_0, uvParamConst1.index);\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleSpriteSheetState.UV_INDEX_1, uvParamConst2.index);\n\n\t\tvar uTotal:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 0);\n\t\tvar uStep:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 1);\n\t\tvar vStep:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 2);\n\n\t\tvar uSpeed:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 0);\n\t\tvar cycle:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 1);\n\t\tvar phaseTime:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 2);\n\n\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tvar time:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0);\n\t\tvar vOffset:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1);\n\t\ttemp = new ShaderRegisterElement(temp.regName, temp.index, 2);\n\t\tvar temp2:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 3);\n\n\t\tvar u:ShaderRegisterElement = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, 0);\n\t\tvar v:ShaderRegisterElement = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, 1);\n\n\t\tvar code:string = \"\";\n\t\t//scale uv\n\t\tcode += \"mul \" + u + \",\" + u + \",\" + uStep + \"\\n\";\n\t\tif (this._iNumRows > 1)\n\t\t\tcode += \"mul \" + v + \",\" + v + \",\" + vStep + \"\\n\";\n\n\t\tif (this._iUsesCycle) {\n\t\t\tif (this._iUsesPhase)\n\t\t\t\tcode += \"add \" + time + \",\" + animationRegisterCache.vertexTime + \",\" + phaseTime + \"\\n\";\n\t\t\telse\n\t\t\t\tcode += \"mov \" + time + \",\" + animationRegisterCache.vertexTime + \"\\n\";\n\t\t\tcode += \"div \" + time + \",\" + time + \",\" + cycle + \"\\n\";\n\t\t\tcode += \"frc \" + time + \",\" + time + \"\\n\";\n\t\t\tcode += \"mul \" + time + \",\" + time + \",\" + cycle + \"\\n\";\n\t\t\tcode += \"mul \" + temp + \",\" + time + \",\" + uSpeed + \"\\n\";\n\t\t} else\n\t\t\tcode += \"mul \" + temp.toString() + \",\" + animationRegisterCache.vertexLife + \",\" + uTotal + \"\\n\";\n\n\t\tif (this._iNumRows > 1) {\n\t\t\tcode += \"frc \" + temp2 + \",\" + temp + \"\\n\";\n\t\t\tcode += \"sub \" + vOffset + \",\" + temp + \",\" + temp2 + \"\\n\";\n\t\t\tcode += \"mul \" + vOffset + \",\" + vOffset + \",\" + vStep + \"\\n\";\n\t\t\tcode += \"add \" + v + \",\" + v + \",\" + vOffset + \"\\n\";\n\t\t}\n\n\t\tcode += \"div \" + temp2 + \",\" + temp + \",\" + uStep + \"\\n\";\n\t\tcode += \"frc \" + temp + \",\" + temp2 + \"\\n\";\n\t\tcode += \"sub \" + temp2 + \",\" + temp2 + \",\" + temp + \"\\n\";\n\t\tcode += \"mul \" + temp + \",\" + temp2 + \",\" + uStep + \"\\n\";\n\n\t\tif (this._iNumRows > 1)\n\t\t\tcode += \"frc \" + temp + \",\" + temp + \"\\n\";\n\t\tcode += \"add \" + u + \",\" + u + \",\" + temp + \"\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleSpriteSheetState\n\t{\n\t\treturn <ParticleSpriteSheetState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet)\n\t{\n\t\tparticleAnimationSet.hasUVNode = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tif (this._iUsesCycle) {\n\t\t\tvar uvCycle:Vector3D = param[ParticleSpriteSheetNode.UV_VECTOR3D];\n\t\t\tif (!uvCycle)\n\t\t\t\tthrow(new Error(\"there is no \" + ParticleSpriteSheetNode.UV_VECTOR3D + \" in param!\"));\n\t\t\tif (uvCycle.x <= 0)\n\t\t\t\tthrow(new Error(\"the cycle duration must be greater than zero\"));\n\t\t\tvar uTotal:number = this._iTotalFrames/this._iNumColumns;\n\t\t\tthis._pOneData[0] = uTotal/uvCycle.x;\n\t\t\tthis._pOneData[1] = uvCycle.x;\n\t\t\tif (this._iUsesPhase)\n\t\t\t\tthis._pOneData[2] = uvCycle.y;\n\t\t}\n\t}\n}\n\nexport = ParticleSpriteSheetNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleSpriteSheetNode.ts b/lib/animators/nodes/ParticleSpriteSheetNode.ts new file mode 100644 index 000000000..d5b17daaf --- /dev/null +++ b/lib/animators/nodes/ParticleSpriteSheetNode.ts @@ -0,0 +1,195 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleSpriteSheetState = require("awayjs-renderergl/lib/animators/states/ParticleSpriteSheetState"); + +/** + * A particle animation node used when a spritesheet texture is required to animate the particle. + * NB: to enable use of this node, the repeat property on the material has to be set to true. + */ +class ParticleSpriteSheetNode extends ParticleNodeBase +{ + /** @private */ + public _iUsesCycle:boolean; + + /** @private */ + public _iUsesPhase:boolean; + + /** @private */ + public _iTotalFrames:number /*int*/; + /** @private */ + public _iNumColumns:number /*int*/; + /** @private */ + public _iNumRows:number /*int*/; + /** @private */ + public _iCycleDuration:number; + /** @private */ + public _iCyclePhase:number; + + /** + * Reference for spritesheet node properties on a single particle (when in local property mode). + * Expects a Vector3D representing the cycleDuration (x), optional phaseTime (y). + */ + public static UV_VECTOR3D:string = "UVVector3D"; + + /** + * Defines the number of columns in the spritesheet, when in global mode. Defaults to 1. Read only. + */ + public get numColumns():number + { + return this._iNumColumns; + } + + /** + * Defines the number of rows in the spritesheet, when in global mode. Defaults to 1. Read only. + */ + public get numRows():number + { + return this._iNumRows; + } + + /** + * Defines the total number of frames used by the spritesheet, when in global mode. Defaults to the number defined by numColumns and numRows. Read only. + */ + public get totalFrames():number + { + return this._iTotalFrames; + } + + /** + * Creates a new ParticleSpriteSheetNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] numColumns Defines the number of columns in the spritesheet, when in global mode. Defaults to 1. + * @param [optional] numRows Defines the number of rows in the spritesheet, when in global mode. Defaults to 1. + * @param [optional] cycleDuration Defines the default cycle duration in seconds, when in global mode. Defaults to 1. + * @param [optional] cyclePhase Defines the default cycle phase, when in global mode. Defaults to 0. + * @param [optional] totalFrames Defines the total number of frames used by the spritesheet, when in global mode. Defaults to the number defined by numColumns and numRows. + * @param [optional] looping Defines whether the spritesheet animation is set to loop indefinitely. Defaults to true. + */ + constructor(mode:number /*uint*/, usesCycle:boolean, usesPhase:boolean, numColumns:number /*int*/ = 1, numRows:number /*uint*/ = 1, cycleDuration:number = 1, cyclePhase:number = 0, totalFrames:number /*uint*/ = Number.MAX_VALUE) + { + super("ParticleSpriteSheet", mode, usesCycle? (usesPhase? 3 : 2) : 1, ParticleAnimationSet.POST_PRIORITY + 1); + + this._pStateClass = ParticleSpriteSheetState; + + this._iUsesCycle = usesCycle; + this._iUsesPhase = usesPhase; + + this._iNumColumns = numColumns; + this._iNumRows = numRows; + this._iCyclePhase = cyclePhase; + this._iCycleDuration = cycleDuration; + this._iTotalFrames = Math.min(totalFrames, numColumns*numRows); + } + + /** + * @inheritDoc + */ + public getAGALUVCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + //get 2 vc + var uvParamConst1:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + var uvParamConst2:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleSpriteSheetState.UV_INDEX_0, uvParamConst1.index); + animationRegisterCache.setRegisterIndex(this, ParticleSpriteSheetState.UV_INDEX_1, uvParamConst2.index); + + var uTotal:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 0); + var uStep:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 1); + var vStep:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst1.regName, uvParamConst1.index, 2); + + var uSpeed:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 0); + var cycle:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 1); + var phaseTime:ShaderRegisterElement = new ShaderRegisterElement(uvParamConst2.regName, uvParamConst2.index, 2); + + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var time:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 0); + var vOffset:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 1); + temp = new ShaderRegisterElement(temp.regName, temp.index, 2); + var temp2:ShaderRegisterElement = new ShaderRegisterElement(temp.regName, temp.index, 3); + + var u:ShaderRegisterElement = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, 0); + var v:ShaderRegisterElement = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, 1); + + var code:string = ""; + //scale uv + code += "mul " + u + "," + u + "," + uStep + "\n"; + if (this._iNumRows > 1) + code += "mul " + v + "," + v + "," + vStep + "\n"; + + if (this._iUsesCycle) { + if (this._iUsesPhase) + code += "add " + time + "," + animationRegisterCache.vertexTime + "," + phaseTime + "\n"; + else + code += "mov " + time + "," + animationRegisterCache.vertexTime + "\n"; + code += "div " + time + "," + time + "," + cycle + "\n"; + code += "frc " + time + "," + time + "\n"; + code += "mul " + time + "," + time + "," + cycle + "\n"; + code += "mul " + temp + "," + time + "," + uSpeed + "\n"; + } else + code += "mul " + temp.toString() + "," + animationRegisterCache.vertexLife + "," + uTotal + "\n"; + + if (this._iNumRows > 1) { + code += "frc " + temp2 + "," + temp + "\n"; + code += "sub " + vOffset + "," + temp + "," + temp2 + "\n"; + code += "mul " + vOffset + "," + vOffset + "," + vStep + "\n"; + code += "add " + v + "," + v + "," + vOffset + "\n"; + } + + code += "div " + temp2 + "," + temp + "," + uStep + "\n"; + code += "frc " + temp + "," + temp2 + "\n"; + code += "sub " + temp2 + "," + temp2 + "," + temp + "\n"; + code += "mul " + temp + "," + temp2 + "," + uStep + "\n"; + + if (this._iNumRows > 1) + code += "frc " + temp + "," + temp + "\n"; + code += "add " + u + "," + u + "," + temp + "\n"; + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleSpriteSheetState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + particleAnimationSet.hasUVNode = true; + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + if (this._iUsesCycle) { + var uvCycle:Vector3D = param[ParticleSpriteSheetNode.UV_VECTOR3D]; + if (!uvCycle) + throw(new Error("there is no " + ParticleSpriteSheetNode.UV_VECTOR3D + " in param!")); + if (uvCycle.x <= 0) + throw(new Error("the cycle duration must be greater than zero")); + var uTotal:number = this._iTotalFrames/this._iNumColumns; + this._pOneData[0] = uTotal/uvCycle.x; + this._pOneData[1] = uvCycle.x; + if (this._iUsesPhase) + this._pOneData[2] = uvCycle.y; + } + } +} + +export = ParticleSpriteSheetNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleTimeNode.js b/lib/animators/nodes/ParticleTimeNode.js new file mode 100755 index 000000000..f19efe244 --- /dev/null +++ b/lib/animators/nodes/ParticleTimeNode.js @@ -0,0 +1,90 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleTimeState = require("awayjs-renderergl/lib/animators/states/ParticleTimeState"); +/** + * A particle animation node used as the base node for timekeeping inside a particle. Automatically added to a particle animation set on instatiation. + */ +var ParticleTimeNode = (function (_super) { + __extends(ParticleTimeNode, _super); + /** + * Creates a new ParticleTimeNode + * + * @param [optional] usesDuration Defines whether the node uses the duration data in the static properties to determine how long a particle is visible for. Defaults to false. + * @param [optional] usesDelay Defines whether the node uses the delay data in the static properties to determine how long a particle is hidden for. Defaults to false. Requires usesDuration to be true. + * @param [optional] usesLooping Defines whether the node creates a looping timeframe for each particle determined by the startTime, duration and delay data in the static properties function. Defaults to false. Requires usesLooping to be true. + */ + function ParticleTimeNode(usesDuration, usesLooping, usesDelay) { + if (usesDuration === void 0) { usesDuration = false; } + if (usesLooping === void 0) { usesLooping = false; } + if (usesDelay === void 0) { usesDelay = false; } + this._pStateClass = ParticleTimeState; + this._iUsesDuration = usesDuration; + this._iUsesLooping = usesLooping; + this._iUsesDelay = usesDelay; + _super.call(this, "ParticleTime", ParticlePropertiesMode.LOCAL_STATIC, 4, 0); + } + /** + * @inheritDoc + */ + ParticleTimeNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var timeStreamRegister = animationRegisterCache.getFreeVertexAttribute(); //timeStreamRegister.x is start，timeStreamRegister.y is during time + animationRegisterCache.setRegisterIndex(this, ParticleTimeState.TIME_STREAM_INDEX, timeStreamRegister.index); + var timeConst = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleTimeState.TIME_CONSTANT_INDEX, timeConst.index); + var code = ""; + code += "sub " + animationRegisterCache.vertexTime + "," + timeConst + "," + timeStreamRegister + ".x\n"; + //if time=0,set the position to zero. + var temp = animationRegisterCache.getFreeVertexSingleTemp(); + code += "sge " + temp + "," + animationRegisterCache.vertexTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp + "\n"; + if (this._iUsesDuration) { + if (this._iUsesLooping) { + var div = animationRegisterCache.getFreeVertexSingleTemp(); + if (this._iUsesDelay) { + code += "div " + div + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".z\n"; + code += "frc " + div + "," + div + "\n"; + code += "mul " + animationRegisterCache.vertexTime + "," + div + "," + timeStreamRegister + ".z\n"; + code += "slt " + div + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".y\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + div + "\n"; + } + else { + code += "mul " + div + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".w\n"; + code += "frc " + div + "," + div + "\n"; + code += "mul " + animationRegisterCache.vertexTime + "," + div + "," + timeStreamRegister + ".y\n"; + } + } + else { + var sge = animationRegisterCache.getFreeVertexSingleTemp(); + code += "sge " + sge + "," + timeStreamRegister + ".y," + animationRegisterCache.vertexTime + "\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + sge + "\n"; + } + } + code += "mul " + animationRegisterCache.vertexLife + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".w\n"; + return code; + }; + /** + * @inheritDoc + */ + ParticleTimeNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleTimeNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + this._pOneData[0] = param.startTime; + this._pOneData[1] = param.duration; + this._pOneData[2] = param.delay + param.duration; + this._pOneData[3] = 1 / param.duration; + }; + return ParticleTimeNode; +})(ParticleNodeBase); +module.exports = ParticleTimeNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particletimenode.ts"],"names":["ParticleTimeNode","ParticleTimeNode.constructor","ParticleTimeNode.getAGALVertexCode","ParticleTimeNode.getAnimationState","ParticleTimeNode._iGeneratePropertyOfOneParticle"],"mappings":"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","file":"animators/nodes/ParticleTimeNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleTimeState\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleTimeState\");\n\n/**\n * A particle animation node used as the base node for timekeeping inside a particle. Automatically added to a particle animation set on instatiation.\n */\nclass ParticleTimeNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iUsesDuration:boolean;\n\t/** @private */\n\tpublic _iUsesDelay:boolean;\n\t/** @private */\n\tpublic _iUsesLooping:boolean;\n\n\t/**\n\t * Creates a new <code>ParticleTimeNode</code>\n\t *\n\t * @param    [optional] usesDuration    Defines whether the node uses the <code>duration</code> data in the static properties to determine how long a particle is visible for. Defaults to false.\n\t * @param    [optional] usesDelay       Defines whether the node uses the <code>delay</code> data in the static properties to determine how long a particle is hidden for. Defaults to false. Requires <code>usesDuration</code> to be true.\n\t * @param    [optional] usesLooping     Defines whether the node creates a looping timeframe for each particle determined by the <code>startTime</code>, <code>duration</code> and <code>delay</code> data in the static properties function. Defaults to false. Requires <code>usesLooping</code> to be true.\n\t */\n\tconstructor(usesDuration:boolean = false, usesLooping:boolean = false, usesDelay:boolean = false)\n\t{\n\t\tthis._pStateClass = ParticleTimeState;\n\n\t\tthis._iUsesDuration = usesDuration;\n\t\tthis._iUsesLooping = usesLooping;\n\t\tthis._iUsesDelay = usesDelay;\n\n\t\tsuper(\"ParticleTime\", ParticlePropertiesMode.LOCAL_STATIC, 4, 0);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar timeStreamRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexAttribute(); //timeStreamRegister.x is start，timeStreamRegister.y is during time\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleTimeState.TIME_STREAM_INDEX, timeStreamRegister.index);\n\t\tvar timeConst:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleTimeState.TIME_CONSTANT_INDEX, timeConst.index);\n\n\t\tvar code:string = \"\";\n\t\tcode += \"sub \" + animationRegisterCache.vertexTime + \",\" + timeConst + \",\" + timeStreamRegister + \".x\\n\";\n\t\t//if time=0,set the position to zero.\n\t\tvar temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp();\n\t\tcode += \"sge \" + temp + \",\" + animationRegisterCache.vertexTime + \",\" + animationRegisterCache.vertexZeroConst + \"\\n\";\n\t\tcode += \"mul \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + temp + \"\\n\";\n\t\tif (this._iUsesDuration) {\n\t\t\tif (this._iUsesLooping) {\n\t\t\t\tvar div:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp();\n\t\t\t\tif (this._iUsesDelay) {\n\t\t\t\t\tcode += \"div \" + div + \",\" + animationRegisterCache.vertexTime + \",\" + timeStreamRegister + \".z\\n\";\n\t\t\t\t\tcode += \"frc \" + div + \",\" + div + \"\\n\";\n\t\t\t\t\tcode += \"mul \" + animationRegisterCache.vertexTime + \",\" + div + \",\" + timeStreamRegister + \".z\\n\";\n\t\t\t\t\tcode += \"slt \" + div + \",\" + animationRegisterCache.vertexTime + \",\" + timeStreamRegister + \".y\\n\";\n\t\t\t\t\tcode += \"mul \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + div + \"\\n\";\n\t\t\t\t} else {\n\t\t\t\t\tcode += \"mul \" + div + \",\" + animationRegisterCache.vertexTime + \",\" + timeStreamRegister + \".w\\n\";\n\t\t\t\t\tcode += \"frc \" + div + \",\" + div + \"\\n\";\n\t\t\t\t\tcode += \"mul \" + animationRegisterCache.vertexTime + \",\" + div + \",\" + timeStreamRegister + \".y\\n\";\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tvar sge:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp();\n\t\t\t\tcode += \"sge \" + sge + \",\" + timeStreamRegister + \".y,\" + animationRegisterCache.vertexTime + \"\\n\";\n\t\t\t\tcode += \"mul \" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + animationRegisterCache.scaleAndRotateTarget + \".xyz,\" + sge + \"\\n\";\n\t\t\t}\n\t\t}\n\t\tcode += \"mul \" + animationRegisterCache.vertexLife + \",\" + animationRegisterCache.vertexTime + \",\" + timeStreamRegister + \".w\\n\";\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleTimeState\n\t{\n\t\treturn <ParticleTimeState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tthis._pOneData[0] = param.startTime;\n\t\tthis._pOneData[1] = param.duration;\n\t\tthis._pOneData[2] = param.delay + param.duration;\n\t\tthis._pOneData[3] = 1/param.duration;\n\n\t}\n}\n\nexport = ParticleTimeNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleTimeNode.ts b/lib/animators/nodes/ParticleTimeNode.ts new file mode 100644 index 000000000..2a63b1f06 --- /dev/null +++ b/lib/animators/nodes/ParticleTimeNode.ts @@ -0,0 +1,104 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleTimeState = require("awayjs-renderergl/lib/animators/states/ParticleTimeState"); + +/** + * A particle animation node used as the base node for timekeeping inside a particle. Automatically added to a particle animation set on instatiation. + */ +class ParticleTimeNode extends ParticleNodeBase +{ + /** @private */ + public _iUsesDuration:boolean; + /** @private */ + public _iUsesDelay:boolean; + /** @private */ + public _iUsesLooping:boolean; + + /** + * Creates a new ParticleTimeNode + * + * @param [optional] usesDuration Defines whether the node uses the duration data in the static properties to determine how long a particle is visible for. Defaults to false. + * @param [optional] usesDelay Defines whether the node uses the delay data in the static properties to determine how long a particle is hidden for. Defaults to false. Requires usesDuration to be true. + * @param [optional] usesLooping Defines whether the node creates a looping timeframe for each particle determined by the startTime, duration and delay data in the static properties function. Defaults to false. Requires usesLooping to be true. + */ + constructor(usesDuration:boolean = false, usesLooping:boolean = false, usesDelay:boolean = false) + { + this._pStateClass = ParticleTimeState; + + this._iUsesDuration = usesDuration; + this._iUsesLooping = usesLooping; + this._iUsesDelay = usesDelay; + + super("ParticleTime", ParticlePropertiesMode.LOCAL_STATIC, 4, 0); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var timeStreamRegister:ShaderRegisterElement = animationRegisterCache.getFreeVertexAttribute(); //timeStreamRegister.x is start，timeStreamRegister.y is during time + animationRegisterCache.setRegisterIndex(this, ParticleTimeState.TIME_STREAM_INDEX, timeStreamRegister.index); + var timeConst:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleTimeState.TIME_CONSTANT_INDEX, timeConst.index); + + var code:string = ""; + code += "sub " + animationRegisterCache.vertexTime + "," + timeConst + "," + timeStreamRegister + ".x\n"; + //if time=0,set the position to zero. + var temp:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp(); + code += "sge " + temp + "," + animationRegisterCache.vertexTime + "," + animationRegisterCache.vertexZeroConst + "\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + temp + "\n"; + if (this._iUsesDuration) { + if (this._iUsesLooping) { + var div:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp(); + if (this._iUsesDelay) { + code += "div " + div + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".z\n"; + code += "frc " + div + "," + div + "\n"; + code += "mul " + animationRegisterCache.vertexTime + "," + div + "," + timeStreamRegister + ".z\n"; + code += "slt " + div + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".y\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + div + "\n"; + } else { + code += "mul " + div + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".w\n"; + code += "frc " + div + "," + div + "\n"; + code += "mul " + animationRegisterCache.vertexTime + "," + div + "," + timeStreamRegister + ".y\n"; + } + } else { + var sge:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp(); + code += "sge " + sge + "," + timeStreamRegister + ".y," + animationRegisterCache.vertexTime + "\n"; + code += "mul " + animationRegisterCache.scaleAndRotateTarget + ".xyz," + animationRegisterCache.scaleAndRotateTarget + ".xyz," + sge + "\n"; + } + } + code += "mul " + animationRegisterCache.vertexLife + "," + animationRegisterCache.vertexTime + "," + timeStreamRegister + ".w\n"; + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleTimeState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + this._pOneData[0] = param.startTime; + this._pOneData[1] = param.duration; + this._pOneData[2] = param.delay + param.duration; + this._pOneData[3] = 1/param.duration; + + } +} + +export = ParticleTimeNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleUVNode.js b/lib/animators/nodes/ParticleUVNode.js new file mode 100755 index 000000000..681c1a2c2 --- /dev/null +++ b/lib/animators/nodes/ParticleUVNode.js @@ -0,0 +1,123 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +var ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleUVState = require("awayjs-renderergl/lib/animators/states/ParticleUVState"); +/** + * A particle animation node used to control the UV offset and scale of a particle over time. + */ +var ParticleUVNode = (function (_super) { + __extends(ParticleUVNode, _super); + /** + * Creates a new ParticleTimeNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] cycle Defines whether the time track is in loop mode. Defaults to false. + * @param [optional] scale Defines whether the time track is in loop mode. Defaults to false. + * @param [optional] axis Defines whether the time track is in loop mode. Defaults to false. + */ + function ParticleUVNode(mode /*uint*/, cycle, scale, axis) { + if (cycle === void 0) { cycle = 1; } + if (scale === void 0) { scale = 1; } + if (axis === void 0) { axis = "x"; } + //because of the stage3d register limitation, it only support the global mode + _super.call(this, "ParticleUV", ParticlePropertiesMode.GLOBAL, 4, ParticleAnimationSet.POST_PRIORITY + 1); + this._pStateClass = ParticleUVState; + this._cycle = cycle; + this._scale = scale; + this._axis = axis; + this.updateUVData(); + } + Object.defineProperty(ParticleUVNode.prototype, "cycle", { + /** + * + */ + get: function () { + return this._cycle; + }, + set: function (value) { + this._cycle = value; + this.updateUVData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleUVNode.prototype, "scale", { + /** + * + */ + get: function () { + return this._scale; + }, + set: function (value) { + this._scale = value; + this.updateUVData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleUVNode.prototype, "axis", { + /** + * + */ + get: function () { + return this._axis; + }, + set: function (value) { + this._axis = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleUVNode.prototype.getAGALUVCode = function (shaderObject, animationRegisterCache) { + var code = ""; + var uvConst = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleUVState.UV_INDEX, uvConst.index); + var axisIndex = this._axis == "x" ? 0 : (this._axis == "y" ? 1 : 2); + var target = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, axisIndex); + var sin = animationRegisterCache.getFreeVertexSingleTemp(); + if (this._scale != 1) + code += "mul " + target + "," + target + "," + uvConst + ".y\n"; + code += "mul " + sin + "," + animationRegisterCache.vertexTime + "," + uvConst + ".x\n"; + code += "sin " + sin + "," + sin + "\n"; + code += "add " + target + "," + target + "," + sin + "\n"; + return code; + }; + /** + * @inheritDoc + */ + ParticleUVNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + ParticleUVNode.prototype.updateUVData = function () { + this._iUvData = new Vector3D(Math.PI * 2 / this._cycle, this._scale, 0, 0); + }; + /** + * @inheritDoc + */ + ParticleUVNode.prototype._iProcessAnimationSetting = function (particleAnimationSet) { + particleAnimationSet.hasUVNode = true; + }; + /** + * + */ + ParticleUVNode.U_AXIS = "x"; + /** + * + */ + ParticleUVNode.V_AXIS = "y"; + return ParticleUVNode; +})(ParticleNodeBase); +module.exports = ParticleUVNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particleuvnode.ts"],"names":["ParticleUVNode","ParticleUVNode.constructor","ParticleUVNode.cycle","ParticleUVNode.scale","ParticleUVNode.axis","ParticleUVNode.getAGALUVCode","ParticleUVNode.getAnimationState","ParticleUVNode.updateUVData","ParticleUVNode._iProcessAnimationSetting"],"mappings":"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","file":"animators/nodes/ParticleUVNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimationSet\");\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleUVState\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleUVState\");\n\n/**\n * A particle animation node used to control the UV offset and scale of a particle over time.\n */\nclass ParticleUVNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iUvData:Vector3D;\n\n\t/**\n\t *\n\t */\n\tpublic static U_AXIS:string = \"x\";\n\n\t/**\n\t *\n\t */\n\tpublic static V_AXIS:string = \"y\";\n\n\tprivate _cycle:number;\n\tprivate _scale:number;\n\tprivate _axis:string;\n\n\t/**\n\t * Creates a new <code>ParticleTimeNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] cycle           Defines whether the time track is in loop mode. Defaults to false.\n\t * @param    [optional] scale           Defines whether the time track is in loop mode. Defaults to false.\n\t * @param    [optional] axis            Defines whether the time track is in loop mode. Defaults to false.\n\t */\n\tconstructor(mode:number /*uint*/, cycle:number = 1, scale:number = 1, axis:string = \"x\")\n\t{\n\t\t//because of the stage3d register limitation, it only support the global mode\n\t\tsuper(\"ParticleUV\", ParticlePropertiesMode.GLOBAL, 4, ParticleAnimationSet.POST_PRIORITY + 1);\n\n\t\tthis._pStateClass = ParticleUVState;\n\n\t\tthis._cycle = cycle;\n\t\tthis._scale = scale;\n\t\tthis._axis = axis;\n\n\t\tthis.updateUVData();\n\t}\n\n\t/**\n\t *\n\t */\n\tpublic get cycle():number\n\t{\n\t\treturn this._cycle;\n\t}\n\n\tpublic set cycle(value:number)\n\t{\n\t\tthis._cycle = value;\n\n\t\tthis.updateUVData();\n\t}\n\n\t/**\n\t *\n\t */\n\tpublic get scale():number\n\t{\n\t\treturn this._scale;\n\t}\n\n\tpublic set scale(value:number)\n\t{\n\t\tthis._scale = value;\n\n\t\tthis.updateUVData();\n\t}\n\n\t/**\n\t *\n\t */\n\tpublic get axis():string\n\t{\n\t\treturn this._axis;\n\t}\n\n\tpublic set axis(value:string)\n\t{\n\t\tthis._axis = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALUVCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar code:string = \"\";\n\n\t\tvar uvConst:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleUVState.UV_INDEX, uvConst.index);\n\n\t\tvar axisIndex:number = this._axis == \"x\"? 0 : (this._axis == \"y\"? 1 : 2);\n\n\t\tvar target:ShaderRegisterElement = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, axisIndex);\n\n\t\tvar sin:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp();\n\n\t\tif (this._scale != 1)\n\t\t\tcode += \"mul \" + target + \",\" + target + \",\" + uvConst + \".y\\n\";\n\n\t\tcode += \"mul \" + sin + \",\" + animationRegisterCache.vertexTime + \",\" + uvConst + \".x\\n\";\n\t\tcode += \"sin \" + sin + \",\" + sin + \"\\n\";\n\t\tcode += \"add \" + target + \",\" + target + \",\" + sin + \"\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleUVState\n\t{\n\t\treturn <ParticleUVState> animator.getAnimationState(this);\n\t}\n\n\tprivate updateUVData()\n\t{\n\t\tthis._iUvData = new Vector3D(Math.PI*2/this._cycle, this._scale, 0, 0);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet)\n\t{\n\t\tparticleAnimationSet.hasUVNode = true;\n\t}\n}\n\nexport = ParticleUVNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleUVNode.ts b/lib/animators/nodes/ParticleUVNode.ts new file mode 100644 index 000000000..46064b972 --- /dev/null +++ b/lib/animators/nodes/ParticleUVNode.ts @@ -0,0 +1,149 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleAnimationSet = require("awayjs-renderergl/lib/animators/ParticleAnimationSet"); +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleUVState = require("awayjs-renderergl/lib/animators/states/ParticleUVState"); + +/** + * A particle animation node used to control the UV offset and scale of a particle over time. + */ +class ParticleUVNode extends ParticleNodeBase +{ + /** @private */ + public _iUvData:Vector3D; + + /** + * + */ + public static U_AXIS:string = "x"; + + /** + * + */ + public static V_AXIS:string = "y"; + + private _cycle:number; + private _scale:number; + private _axis:string; + + /** + * Creates a new ParticleTimeNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] cycle Defines whether the time track is in loop mode. Defaults to false. + * @param [optional] scale Defines whether the time track is in loop mode. Defaults to false. + * @param [optional] axis Defines whether the time track is in loop mode. Defaults to false. + */ + constructor(mode:number /*uint*/, cycle:number = 1, scale:number = 1, axis:string = "x") + { + //because of the stage3d register limitation, it only support the global mode + super("ParticleUV", ParticlePropertiesMode.GLOBAL, 4, ParticleAnimationSet.POST_PRIORITY + 1); + + this._pStateClass = ParticleUVState; + + this._cycle = cycle; + this._scale = scale; + this._axis = axis; + + this.updateUVData(); + } + + /** + * + */ + public get cycle():number + { + return this._cycle; + } + + public set cycle(value:number) + { + this._cycle = value; + + this.updateUVData(); + } + + /** + * + */ + public get scale():number + { + return this._scale; + } + + public set scale(value:number) + { + this._scale = value; + + this.updateUVData(); + } + + /** + * + */ + public get axis():string + { + return this._axis; + } + + public set axis(value:string) + { + this._axis = value; + } + + /** + * @inheritDoc + */ + public getAGALUVCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var code:string = ""; + + var uvConst:ShaderRegisterElement = animationRegisterCache.getFreeVertexConstant(); + animationRegisterCache.setRegisterIndex(this, ParticleUVState.UV_INDEX, uvConst.index); + + var axisIndex:number = this._axis == "x"? 0 : (this._axis == "y"? 1 : 2); + + var target:ShaderRegisterElement = new ShaderRegisterElement(animationRegisterCache.uvTarget.regName, animationRegisterCache.uvTarget.index, axisIndex); + + var sin:ShaderRegisterElement = animationRegisterCache.getFreeVertexSingleTemp(); + + if (this._scale != 1) + code += "mul " + target + "," + target + "," + uvConst + ".y\n"; + + code += "mul " + sin + "," + animationRegisterCache.vertexTime + "," + uvConst + ".x\n"; + code += "sin " + sin + "," + sin + "\n"; + code += "add " + target + "," + target + "," + sin + "\n"; + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleUVState + { + return animator.getAnimationState(this); + } + + private updateUVData() + { + this._iUvData = new Vector3D(Math.PI*2/this._cycle, this._scale, 0, 0); + } + + /** + * @inheritDoc + */ + public _iProcessAnimationSetting(particleAnimationSet:ParticleAnimationSet) + { + particleAnimationSet.hasUVNode = true; + } +} + +export = ParticleUVNode; \ No newline at end of file diff --git a/lib/animators/nodes/ParticleVelocityNode.js b/lib/animators/nodes/ParticleVelocityNode.js new file mode 100755 index 000000000..68ae3dad7 --- /dev/null +++ b/lib/animators/nodes/ParticleVelocityNode.js @@ -0,0 +1,68 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +var ParticleVelocityState = require("awayjs-renderergl/lib/animators/states/ParticleVelocityState"); +/** + * A particle animation node used to set the starting velocity of a particle. + */ +var ParticleVelocityNode = (function (_super) { + __extends(ParticleVelocityNode, _super); + /** + * Creates a new ParticleVelocityNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] velocity Defines the default velocity vector of the node, used when in global mode. + */ + function ParticleVelocityNode(mode /*uint*/, velocity) { + if (velocity === void 0) { velocity = null; } + _super.call(this, "ParticleVelocity", mode, 3); + this._pStateClass = ParticleVelocityState; + this._iVelocity = velocity || new Vector3D(); + } + /** + * @inheritDoc + */ + ParticleVelocityNode.prototype.getAGALVertexCode = function (shaderObject, animationRegisterCache) { + var velocityValue = (this._pMode == ParticlePropertiesMode.GLOBAL) ? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleVelocityState.VELOCITY_INDEX, velocityValue.index); + var distance = animationRegisterCache.getFreeVertexVectorTemp(); + var code = ""; + code += "mul " + distance + "," + animationRegisterCache.vertexTime + "," + velocityValue + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + "," + animationRegisterCache.positionTarget + ".xyz\n"; + if (animationRegisterCache.needVelocity) + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + velocityValue + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + return code; + }; + /** + * @inheritDoc + */ + ParticleVelocityNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + ParticleVelocityNode.prototype._iGeneratePropertyOfOneParticle = function (param) { + var _tempVelocity = param[ParticleVelocityNode.VELOCITY_VECTOR3D]; + if (!_tempVelocity) + throw new Error("there is no " + ParticleVelocityNode.VELOCITY_VECTOR3D + " in param!"); + this._pOneData[0] = _tempVelocity.x; + this._pOneData[1] = _tempVelocity.y; + this._pOneData[2] = _tempVelocity.z; + }; + /** + * Reference for velocity node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the direction of movement on the particle. + */ + ParticleVelocityNode.VELOCITY_VECTOR3D = "VelocityVector3D"; + return ParticleVelocityNode; +})(ParticleNodeBase); +module.exports = ParticleVelocityNode; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/nodes/particlevelocitynode.ts"],"names":["ParticleVelocityNode","ParticleVelocityNode.constructor","ParticleVelocityNode.getAGALVertexCode","ParticleVelocityNode.getAnimationState","ParticleVelocityNode._iGeneratePropertyOfOneParticle"],"mappings":"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","file":"animators/nodes/ParticleVelocityNode.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\n\nimport ParticleProperties\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleProperties\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport ParticleVelocityState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleVelocityState\");\n\n/**\n * A particle animation node used to set the starting velocity of a particle.\n */\nclass ParticleVelocityNode extends ParticleNodeBase\n{\n\t/** @private */\n\tpublic _iVelocity:Vector3D;\n\n\t/**\n\t * Reference for velocity node properties on a single particle (when in local property mode).\n\t * Expects a <code>Vector3D</code> object representing the direction of movement on the particle.\n\t */\n\tpublic static VELOCITY_VECTOR3D:string = \"VelocityVector3D\";\n\n\t/**\n\t * Creates a new <code>ParticleVelocityNode</code>\n\t *\n\t * @param               mode            Defines whether the mode of operation acts on local properties of a particle or global properties of the node.\n\t * @param    [optional] velocity        Defines the default velocity vector of the node, used when in global mode.\n\t */\n\tconstructor(mode:number /*uint*/, velocity:Vector3D = null)\n\t{\n\t\tsuper(\"ParticleVelocity\", mode, 3);\n\n\t\tthis._pStateClass = ParticleVelocityState;\n\n\t\tthis._iVelocity = velocity || new Vector3D();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string\n\t{\n\t\tvar velocityValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute();\n\t\tanimationRegisterCache.setRegisterIndex(this, ParticleVelocityState.VELOCITY_INDEX, velocityValue.index);\n\n\t\tvar distance:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp();\n\t\tvar code:string = \"\";\n\t\tcode += \"mul \" + distance + \",\" + animationRegisterCache.vertexTime + \",\" + velocityValue + \"\\n\";\n\t\tcode += \"add \" + animationRegisterCache.positionTarget + \".xyz,\" + distance + \",\" + animationRegisterCache.positionTarget + \".xyz\\n\";\n\n\t\tif (animationRegisterCache.needVelocity)\n\t\t\tcode += \"add \" + animationRegisterCache.velocityTarget + \".xyz,\" + velocityValue + \".xyz,\" + animationRegisterCache.velocityTarget + \".xyz\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getAnimationState(animator:AnimatorBase):ParticleVelocityState\n\t{\n\t\treturn <ParticleVelocityState> animator.getAnimationState(this);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGeneratePropertyOfOneParticle(param:ParticleProperties)\n\t{\n\t\tvar _tempVelocity:Vector3D = param[ParticleVelocityNode.VELOCITY_VECTOR3D];\n\t\tif (!_tempVelocity)\n\t\t\tthrow new Error(\"there is no \" + ParticleVelocityNode.VELOCITY_VECTOR3D + \" in param!\");\n\n\t\tthis._pOneData[0] = _tempVelocity.x;\n\t\tthis._pOneData[1] = _tempVelocity.y;\n\t\tthis._pOneData[2] = _tempVelocity.z;\n\t}\n}\n\nexport = ParticleVelocityNode;"]} \ No newline at end of file diff --git a/lib/animators/nodes/ParticleVelocityNode.ts b/lib/animators/nodes/ParticleVelocityNode.ts new file mode 100644 index 000000000..3bdaf33fc --- /dev/null +++ b/lib/animators/nodes/ParticleVelocityNode.ts @@ -0,0 +1,84 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); + +import ParticleProperties = require("awayjs-renderergl/lib/animators/data/ParticleProperties"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleVelocityState = require("awayjs-renderergl/lib/animators/states/ParticleVelocityState"); + +/** + * A particle animation node used to set the starting velocity of a particle. + */ +class ParticleVelocityNode extends ParticleNodeBase +{ + /** @private */ + public _iVelocity:Vector3D; + + /** + * Reference for velocity node properties on a single particle (when in local property mode). + * Expects a Vector3D object representing the direction of movement on the particle. + */ + public static VELOCITY_VECTOR3D:string = "VelocityVector3D"; + + /** + * Creates a new ParticleVelocityNode + * + * @param mode Defines whether the mode of operation acts on local properties of a particle or global properties of the node. + * @param [optional] velocity Defines the default velocity vector of the node, used when in global mode. + */ + constructor(mode:number /*uint*/, velocity:Vector3D = null) + { + super("ParticleVelocity", mode, 3); + + this._pStateClass = ParticleVelocityState; + + this._iVelocity = velocity || new Vector3D(); + } + + /** + * @inheritDoc + */ + public getAGALVertexCode(shaderObject:ShaderObjectBase, animationRegisterCache:AnimationRegisterCache):string + { + var velocityValue:ShaderRegisterElement = (this._pMode == ParticlePropertiesMode.GLOBAL)? animationRegisterCache.getFreeVertexConstant() : animationRegisterCache.getFreeVertexAttribute(); + animationRegisterCache.setRegisterIndex(this, ParticleVelocityState.VELOCITY_INDEX, velocityValue.index); + + var distance:ShaderRegisterElement = animationRegisterCache.getFreeVertexVectorTemp(); + var code:string = ""; + code += "mul " + distance + "," + animationRegisterCache.vertexTime + "," + velocityValue + "\n"; + code += "add " + animationRegisterCache.positionTarget + ".xyz," + distance + "," + animationRegisterCache.positionTarget + ".xyz\n"; + + if (animationRegisterCache.needVelocity) + code += "add " + animationRegisterCache.velocityTarget + ".xyz," + velocityValue + ".xyz," + animationRegisterCache.velocityTarget + ".xyz\n"; + + return code; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):ParticleVelocityState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _iGeneratePropertyOfOneParticle(param:ParticleProperties) + { + var _tempVelocity:Vector3D = param[ParticleVelocityNode.VELOCITY_VECTOR3D]; + if (!_tempVelocity) + throw new Error("there is no " + ParticleVelocityNode.VELOCITY_VECTOR3D + " in param!"); + + this._pOneData[0] = _tempVelocity.x; + this._pOneData[1] = _tempVelocity.y; + this._pOneData[2] = _tempVelocity.z; + } +} + +export = ParticleVelocityNode; \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonBinaryLERPNode.js b/lib/animators/nodes/SkeletonBinaryLERPNode.js new file mode 100755 index 000000000..ab9ae20ca --- /dev/null +++ b/lib/animators/nodes/SkeletonBinaryLERPNode.js @@ -0,0 +1,31 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +var SkeletonBinaryLERPState = require("awayjs-renderergl/lib/animators/states/SkeletonBinaryLERPState"); +/** + * A skeleton animation node that uses two animation node inputs to blend a lineraly interpolated output of a skeleton pose. + */ +var SkeletonBinaryLERPNode = (function (_super) { + __extends(SkeletonBinaryLERPNode, _super); + /** + * Creates a new SkeletonBinaryLERPNode object. + */ + function SkeletonBinaryLERPNode() { + _super.call(this); + this._pStateClass = SkeletonBinaryLERPState; + } + /** + * @inheritDoc + */ + SkeletonBinaryLERPNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + return SkeletonBinaryLERPNode; +})(AnimationNodeBase); +module.exports = SkeletonBinaryLERPNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonBinaryLERPNode.ts b/lib/animators/nodes/SkeletonBinaryLERPNode.ts new file mode 100644 index 000000000..c32d30f4a --- /dev/null +++ b/lib/animators/nodes/SkeletonBinaryLERPNode.ts @@ -0,0 +1,42 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import SkeletonBinaryLERPState = require("awayjs-renderergl/lib/animators/states/SkeletonBinaryLERPState"); + +/** + * A skeleton animation node that uses two animation node inputs to blend a lineraly interpolated output of a skeleton pose. + */ +class SkeletonBinaryLERPNode extends AnimationNodeBase +{ + /** + * Defines input node A to use for the blended output. + */ + public inputA:AnimationNodeBase; + + /** + * Defines input node B to use for the blended output. + */ + public inputB:AnimationNodeBase; + + /** + * Creates a new SkeletonBinaryLERPNode object. + */ + constructor() + { + super(); + + this._pStateClass = SkeletonBinaryLERPState; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):SkeletonBinaryLERPState + { + return animator.getAnimationState(this); + } +} + +export = SkeletonBinaryLERPNode; \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonClipNode.js b/lib/animators/nodes/SkeletonClipNode.js new file mode 100755 index 000000000..abe097500 --- /dev/null +++ b/lib/animators/nodes/SkeletonClipNode.js @@ -0,0 +1,85 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationClipNodeBase = require("awayjs-renderergl/lib/animators/nodes/AnimationClipNodeBase"); +var SkeletonClipState = require("awayjs-renderergl/lib/animators/states/SkeletonClipState"); +/** + * A skeleton animation node containing time-based animation data as individual skeleton poses. + */ +var SkeletonClipNode = (function (_super) { + __extends(SkeletonClipNode, _super); + /** + * Creates a new SkeletonClipNode object. + */ + function SkeletonClipNode() { + _super.call(this); + this._frames = new Array(); + /** + * Determines whether to use SLERP equations (true) or LERP equations (false) in the calculation + * of the output skeleton pose. Defaults to false. + */ + this.highQuality = false; + this._pStateClass = SkeletonClipState; + } + Object.defineProperty(SkeletonClipNode.prototype, "frames", { + /** + * Returns a vector of skeleton poses representing the pose of each animation frame in the clip. + */ + get: function () { + return this._frames; + }, + enumerable: true, + configurable: true + }); + /** + * Adds a skeleton pose frame to the internal timeline of the animation node. + * + * @param skeletonPose The skeleton pose object to add to the timeline of the node. + * @param duration The specified duration of the frame in milliseconds. + */ + SkeletonClipNode.prototype.addFrame = function (skeletonPose, duration /*number /*uint*/) { + this._frames.push(skeletonPose); + this._pDurations.push(duration); + this._pNumFrames = this._pDurations.length; + this._pStitchDirty = true; + }; + /** + * @inheritDoc + */ + SkeletonClipNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + /** + * @inheritDoc + */ + SkeletonClipNode.prototype._pUpdateStitch = function () { + _super.prototype._pUpdateStitch.call(this); + var i = this._pNumFrames - 1; + var p1, p2, delta; + while (i--) { + this._pTotalDuration += this._pDurations[i]; + p1 = this._frames[i].jointPoses[0].translation; + p2 = this._frames[i + 1].jointPoses[0].translation; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + if (this._pStitchFinalFrame || !this._pLooping) { + this._pTotalDuration += this._pDurations[this._pNumFrames - 1]; + p1 = this._frames[0].jointPoses[0].translation; + p2 = this._frames[1].jointPoses[0].translation; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + }; + return SkeletonClipNode; +})(AnimationClipNodeBase); +module.exports = SkeletonClipNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonClipNode.ts b/lib/animators/nodes/SkeletonClipNode.ts new file mode 100644 index 000000000..daee39fdd --- /dev/null +++ b/lib/animators/nodes/SkeletonClipNode.ts @@ -0,0 +1,95 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import AnimationClipNodeBase = require("awayjs-renderergl/lib/animators/nodes/AnimationClipNodeBase"); +import SkeletonClipState = require("awayjs-renderergl/lib/animators/states/SkeletonClipState"); + +/** + * A skeleton animation node containing time-based animation data as individual skeleton poses. + */ +class SkeletonClipNode extends AnimationClipNodeBase +{ + private _frames:Array = new Array(); + + /** + * Determines whether to use SLERP equations (true) or LERP equations (false) in the calculation + * of the output skeleton pose. Defaults to false. + */ + public highQuality:boolean = false; + + /** + * Returns a vector of skeleton poses representing the pose of each animation frame in the clip. + */ + public get frames():Array + { + return this._frames; + } + + /** + * Creates a new SkeletonClipNode object. + */ + constructor() + { + super(); + + this._pStateClass = SkeletonClipState; + } + + /** + * Adds a skeleton pose frame to the internal timeline of the animation node. + * + * @param skeletonPose The skeleton pose object to add to the timeline of the node. + * @param duration The specified duration of the frame in milliseconds. + */ + public addFrame(skeletonPose:SkeletonPose, duration:number /*number /*uint*/) + { + this._frames.push(skeletonPose); + this._pDurations.push(duration); + + this._pNumFrames = this._pDurations.length; + + this._pStitchDirty = true; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):SkeletonClipState + { + return animator.getAnimationState(this); + } + + /** + * @inheritDoc + */ + public _pUpdateStitch() + { + super._pUpdateStitch(); + + var i:number /*uint*/ = this._pNumFrames - 1; + var p1:Vector3D, p2:Vector3D, delta:Vector3D; + while (i--) { + this._pTotalDuration += this._pDurations[i]; + p1 = this._frames[i].jointPoses[0].translation; + p2 = this._frames[i + 1].jointPoses[0].translation; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + + if (this._pStitchFinalFrame || !this._pLooping) { + this._pTotalDuration += this._pDurations[this._pNumFrames - 1]; + p1 = this._frames[0].jointPoses[0].translation; + p2 = this._frames[1].jointPoses[0].translation; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + } +} + +export = SkeletonClipNode; \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonDifferenceNode.js b/lib/animators/nodes/SkeletonDifferenceNode.js new file mode 100755 index 000000000..46c8fd398 --- /dev/null +++ b/lib/animators/nodes/SkeletonDifferenceNode.js @@ -0,0 +1,31 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +var SkeletonDifferenceState = require("awayjs-renderergl/lib/animators/states/SkeletonDifferenceState"); +/** + * A skeleton animation node that uses a difference input pose with a base input pose to blend a linearly interpolated output of a skeleton pose. + */ +var SkeletonDifferenceNode = (function (_super) { + __extends(SkeletonDifferenceNode, _super); + /** + * Creates a new SkeletonAdditiveNode object. + */ + function SkeletonDifferenceNode() { + _super.call(this); + this._pStateClass = SkeletonDifferenceState; + } + /** + * @inheritDoc + */ + SkeletonDifferenceNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + return SkeletonDifferenceNode; +})(AnimationNodeBase); +module.exports = SkeletonDifferenceNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonDifferenceNode.ts b/lib/animators/nodes/SkeletonDifferenceNode.ts new file mode 100644 index 000000000..474430003 --- /dev/null +++ b/lib/animators/nodes/SkeletonDifferenceNode.ts @@ -0,0 +1,41 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import SkeletonDifferenceState = require("awayjs-renderergl/lib/animators/states/SkeletonDifferenceState"); + +/** + * A skeleton animation node that uses a difference input pose with a base input pose to blend a linearly interpolated output of a skeleton pose. + */ +class SkeletonDifferenceNode extends AnimationNodeBase +{ + /** + * Defines a base input node to use for the blended output. + */ + public baseInput:AnimationNodeBase; + + /** + * Defines a difference input node to use for the blended output. + */ + public differenceInput:AnimationNodeBase; + + /** + * Creates a new SkeletonAdditiveNode object. + */ + constructor() + { + super(); + + this._pStateClass = SkeletonDifferenceState; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):SkeletonDifferenceState + { + return animator.getAnimationState(this); + } +} + +export = SkeletonDifferenceNode \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonDirectionalNode.js b/lib/animators/nodes/SkeletonDirectionalNode.js new file mode 100755 index 000000000..cb5105d92 --- /dev/null +++ b/lib/animators/nodes/SkeletonDirectionalNode.js @@ -0,0 +1,28 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +var SkeletonDirectionalState = require("awayjs-renderergl/lib/animators/states/SkeletonDirectionalState"); +/** + * A skeleton animation node that uses four directional input poses with an input direction to blend a linearly interpolated output of a skeleton pose. + */ +var SkeletonDirectionalNode = (function (_super) { + __extends(SkeletonDirectionalNode, _super); + function SkeletonDirectionalNode() { + _super.call(this); + this._pStateClass = SkeletonDirectionalState; + } + /** + * @inheritDoc + */ + SkeletonDirectionalNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + return SkeletonDirectionalNode; +})(AnimationNodeBase); +module.exports = SkeletonDirectionalNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonDirectionalNode.ts b/lib/animators/nodes/SkeletonDirectionalNode.ts new file mode 100644 index 000000000..a9bc8ced9 --- /dev/null +++ b/lib/animators/nodes/SkeletonDirectionalNode.ts @@ -0,0 +1,49 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import SkeletonDirectionalState = require("awayjs-renderergl/lib/animators/states/SkeletonDirectionalState"); + +/** + * A skeleton animation node that uses four directional input poses with an input direction to blend a linearly interpolated output of a skeleton pose. + */ +class SkeletonDirectionalNode extends AnimationNodeBase +{ + /** + * Defines the forward configured input node to use for the blended output. + */ + public forward:AnimationNodeBase; + + /** + * Defines the backwards configured input node to use for the blended output. + */ + public backward:AnimationNodeBase; + + /** + * Defines the left configured input node to use for the blended output. + */ + public left:AnimationNodeBase; + + /** + * Defines the right configured input node to use for the blended output. + */ + public right:AnimationNodeBase; + + constructor() + { + super(); + + this._pStateClass = SkeletonDirectionalState; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):SkeletonDirectionalState + { + return animator.getAnimationState(this); + } + +} + +export = SkeletonDirectionalNode; \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonNaryLERPNode.js b/lib/animators/nodes/SkeletonNaryLERPNode.js new file mode 100755 index 000000000..ddb8604d0 --- /dev/null +++ b/lib/animators/nodes/SkeletonNaryLERPNode.js @@ -0,0 +1,61 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +var SkeletonNaryLERPState = require("awayjs-renderergl/lib/animators/states/SkeletonNaryLERPState"); +/** + * A skeleton animation node that uses an n-dimensional array of animation node inputs to blend a lineraly interpolated output of a skeleton pose. + */ +var SkeletonNaryLERPNode = (function (_super) { + __extends(SkeletonNaryLERPNode, _super); + /** + * Creates a new SkeletonNaryLERPNode object. + */ + function SkeletonNaryLERPNode() { + _super.call(this); + this._iInputs = new Array(); + this._pStateClass = SkeletonNaryLERPState; + } + Object.defineProperty(SkeletonNaryLERPNode.prototype, "numInputs", { + get: function () { + return this._numInputs; + }, + enumerable: true, + configurable: true + }); + /** + * Returns an integer representing the input index of the given skeleton animation node. + * + * @param input The skeleton animation node for with the input index is requested. + */ + SkeletonNaryLERPNode.prototype.getInputIndex = function (input) { + return this._iInputs.indexOf(input); + }; + /** + * Returns the skeleton animation node object that resides at the given input index. + * + * @param index The input index for which the skeleton animation node is requested. + */ + SkeletonNaryLERPNode.prototype.getInputAt = function (index /*uint*/) { + return this._iInputs[index]; + }; + /** + * Adds a new skeleton animation node input to the animation node. + */ + SkeletonNaryLERPNode.prototype.addInput = function (input) { + this._iInputs[this._numInputs++] = input; + }; + /** + * @inheritDoc + */ + SkeletonNaryLERPNode.prototype.getAnimationState = function (animator) { + return animator.getAnimationState(this); + }; + return SkeletonNaryLERPNode; +})(AnimationNodeBase); +module.exports = SkeletonNaryLERPNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/SkeletonNaryLERPNode.ts b/lib/animators/nodes/SkeletonNaryLERPNode.ts new file mode 100644 index 000000000..4117de7fb --- /dev/null +++ b/lib/animators/nodes/SkeletonNaryLERPNode.ts @@ -0,0 +1,68 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import SkeletonNaryLERPState = require("awayjs-renderergl/lib/animators/states/SkeletonNaryLERPState"); + +/** + * A skeleton animation node that uses an n-dimensional array of animation node inputs to blend a lineraly interpolated output of a skeleton pose. + */ +class SkeletonNaryLERPNode extends AnimationNodeBase +{ + public _iInputs:Array = new Array(); + + private _numInputs:number /*uint*/; + + public get numInputs():number /*uint*/ + { + return this._numInputs; + } + + /** + * Creates a new SkeletonNaryLERPNode object. + */ + constructor() + { + super(); + + this._pStateClass = SkeletonNaryLERPState; + } + + /** + * Returns an integer representing the input index of the given skeleton animation node. + * + * @param input The skeleton animation node for with the input index is requested. + */ + public getInputIndex(input:AnimationNodeBase):number /*int*/ + { + return this._iInputs.indexOf(input); + } + + /** + * Returns the skeleton animation node object that resides at the given input index. + * + * @param index The input index for which the skeleton animation node is requested. + */ + public getInputAt(index:number /*uint*/):AnimationNodeBase + { + return this._iInputs[index]; + } + + /** + * Adds a new skeleton animation node input to the animation node. + */ + public addInput(input:AnimationNodeBase) + { + this._iInputs[this._numInputs++] = input; + } + + /** + * @inheritDoc + */ + public getAnimationState(animator:AnimatorBase):SkeletonNaryLERPState + { + return animator.getAnimationState(this); + } +} + +export = SkeletonNaryLERPNode \ No newline at end of file diff --git a/lib/animators/nodes/VertexClipNode.js b/lib/animators/nodes/VertexClipNode.js new file mode 100755 index 000000000..9a67e5a5c --- /dev/null +++ b/lib/animators/nodes/VertexClipNode.js @@ -0,0 +1,79 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AnimationClipNodeBase = require("awayjs-renderergl/lib/animators/nodes/AnimationClipNodeBase"); +var VertexClipState = require("awayjs-renderergl/lib/animators/states/VertexClipState"); +/** + * A vertex animation node containing time-based animation data as individual geometry obejcts. + */ +var VertexClipNode = (function (_super) { + __extends(VertexClipNode, _super); + /** + * Creates a new VertexClipNode object. + */ + function VertexClipNode() { + _super.call(this); + this._frames = new Array(); + this._translations = new Array(); + this._pStateClass = VertexClipState; + } + Object.defineProperty(VertexClipNode.prototype, "frames", { + /** + * Returns a vector of geometry frames representing the vertex values of each animation frame in the clip. + */ + get: function () { + return this._frames; + }, + enumerable: true, + configurable: true + }); + /** + * Adds a geometry object to the internal timeline of the animation node. + * + * @param geometry The geometry object to add to the timeline of the node. + * @param duration The specified duration of the frame in milliseconds. + * @param translation The absolute translation of the frame, used in root delta calculations for mesh movement. + */ + VertexClipNode.prototype.addFrame = function (geometry, duration /*uint*/, translation) { + if (translation === void 0) { translation = null; } + this._frames.push(geometry); + this._pDurations.push(duration); + this._translations.push(translation || new Vector3D()); + this._pNumFrames = this._pDurations.length; + this._pStitchDirty = true; + }; + /** + * @inheritDoc + */ + VertexClipNode.prototype._pUpdateStitch = function () { + _super.prototype._pUpdateStitch.call(this); + var i = this._pNumFrames - 1; + var p1, p2, delta; + while (i--) { + this._pTotalDuration += this._pDurations[i]; + p1 = this._translations[i]; + p2 = this._translations[i + 1]; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + if (this._pNumFrames > 1 && (this._pStitchFinalFrame || !this._pLooping)) { + this._pTotalDuration += this._pDurations[this._pNumFrames - 1]; + p1 = this._translations[0]; + p2 = this._translations[1]; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + }; + return VertexClipNode; +})(AnimationClipNodeBase); +module.exports = VertexClipNode; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/nodes/VertexClipNode.ts b/lib/animators/nodes/VertexClipNode.ts new file mode 100644 index 000000000..655a77e9d --- /dev/null +++ b/lib/animators/nodes/VertexClipNode.ts @@ -0,0 +1,84 @@ +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import AnimationClipNodeBase = require("awayjs-renderergl/lib/animators/nodes/AnimationClipNodeBase"); +import VertexClipState = require("awayjs-renderergl/lib/animators/states/VertexClipState"); + +/** + * A vertex animation node containing time-based animation data as individual geometry obejcts. + */ +class VertexClipNode extends AnimationClipNodeBase +{ + private _frames:Array = new Array(); + private _translations:Array = new Array(); + + /** + * Returns a vector of geometry frames representing the vertex values of each animation frame in the clip. + */ + public get frames():Array + { + return this._frames; + } + + /** + * Creates a new VertexClipNode object. + */ + constructor() + { + super(); + + this._pStateClass = VertexClipState; + } + + /** + * Adds a geometry object to the internal timeline of the animation node. + * + * @param geometry The geometry object to add to the timeline of the node. + * @param duration The specified duration of the frame in milliseconds. + * @param translation The absolute translation of the frame, used in root delta calculations for mesh movement. + */ + public addFrame(geometry:Geometry, duration:number /*uint*/, translation:Vector3D = null) + { + this._frames.push(geometry); + this._pDurations.push(duration); + this._translations.push(translation || new Vector3D()); + + this._pNumFrames = this._pDurations.length; + + this._pStitchDirty = true; + } + + /** + * @inheritDoc + */ + public _pUpdateStitch() + { + super._pUpdateStitch(); + + var i:number /*uint*/ = this._pNumFrames - 1; + var p1:Vector3D, p2:Vector3D, delta:Vector3D; + while (i--) { + this._pTotalDuration += this._pDurations[i]; + p1 = this._translations[i]; + p2 = this._translations[i + 1]; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + + if (this._pNumFrames > 1 && (this._pStitchFinalFrame || !this._pLooping)) { + this._pTotalDuration += this._pDurations[this._pNumFrames - 1]; + p1 = this._translations[0]; + p2 = this._translations[1]; + delta = p2.subtract(p1); + this._pTotalDelta.x += delta.x; + this._pTotalDelta.y += delta.y; + this._pTotalDelta.z += delta.z; + } + } +} + +export = VertexClipNode; \ No newline at end of file diff --git a/lib/animators/states/AnimationClipState.js b/lib/animators/states/AnimationClipState.js new file mode 100755 index 000000000..2ce335d40 --- /dev/null +++ b/lib/animators/states/AnimationClipState.js @@ -0,0 +1,152 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +var AnimationStateEvent = require("awayjs-renderergl/lib/events/AnimationStateEvent"); +/** + * + */ +var AnimationClipState = (function (_super) { + __extends(AnimationClipState, _super); + function AnimationClipState(animator, animationClipNode) { + _super.call(this, animator, animationClipNode); + this._pFramesDirty = true; + this._animationClipNode = animationClipNode; + } + Object.defineProperty(AnimationClipState.prototype, "blendWeight", { + /** + * Returns a fractional value between 0 and 1 representing the blending ratio of the current playhead position + * between the current frame (0) and next frame (1) of the animation. + * + * @see #currentFrame + * @see #nextFrame + */ + get: function () { + if (this._pFramesDirty) + this._pUpdateFrames(); + return this._pBlendWeight; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationClipState.prototype, "currentFrame", { + /** + * Returns the current frame of animation in the clip based on the internal playhead position. + */ + get: function () { + if (this._pFramesDirty) + this._pUpdateFrames(); + return this._pCurrentFrame; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationClipState.prototype, "nextFrame", { + /** + * Returns the next frame of animation in the clip based on the internal playhead position. + */ + get: function () { + if (this._pFramesDirty) + this._pUpdateFrames(); + return this._pNextFrame; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + AnimationClipState.prototype.update = function (time /*int*/) { + if (!this._animationClipNode.looping) { + if (time > this._pStartTime + this._animationClipNode.totalDuration) + time = this._pStartTime + this._animationClipNode.totalDuration; + else if (time < this._pStartTime) + time = this._pStartTime; + } + if (this._pTime == time - this._pStartTime) + return; + this._pUpdateTime(time); + }; + /** + * @inheritDoc + */ + AnimationClipState.prototype.phase = function (value) { + var time = value * this._animationClipNode.totalDuration + this._pStartTime; + if (this._pTime == time - this._pStartTime) + return; + this._pUpdateTime(time); + }; + /** + * @inheritDoc + */ + AnimationClipState.prototype._pUpdateTime = function (time /*int*/) { + this._pFramesDirty = true; + this._pTimeDir = (time - this._pStartTime > this._pTime) ? 1 : -1; + _super.prototype._pUpdateTime.call(this, time); + }; + /** + * Updates the nodes internal playhead to determine the current and next animation frame, and the blendWeight between the two. + * + * @see #currentFrame + * @see #nextFrame + * @see #blendWeight + */ + AnimationClipState.prototype._pUpdateFrames = function () { + this._pFramesDirty = false; + var looping = this._animationClipNode.looping; + var totalDuration = this._animationClipNode.totalDuration; + var lastFrame = this._animationClipNode.lastFrame; + var time = this._pTime; + //trace("time", time, totalDuration) + if (looping && (time >= totalDuration || time < 0)) { + time %= totalDuration; + if (time < 0) + time += totalDuration; + } + if (!looping && time >= totalDuration) { + this.notifyPlaybackComplete(); + this._pCurrentFrame = lastFrame; + this._pNextFrame = lastFrame; + this._pBlendWeight = 0; + } + else if (!looping && time <= 0) { + this._pCurrentFrame = 0; + this._pNextFrame = 0; + this._pBlendWeight = 0; + } + else if (this._animationClipNode.fixedFrameRate) { + var t = time / totalDuration * lastFrame; + this._pCurrentFrame = Math.floor(t); + this._pBlendWeight = t - this._pCurrentFrame; + this._pNextFrame = this._pCurrentFrame + 1; + } + else { + this._pCurrentFrame = 0; + this._pNextFrame = 0; + var dur = 0, frameTime /*uint*/; + var durations = this._animationClipNode.durations; + do { + frameTime = dur; + dur += durations[this._pNextFrame]; + this._pCurrentFrame = this._pNextFrame++; + } while (time > dur); + if (this._pCurrentFrame == lastFrame) { + this._pCurrentFrame = 0; + this._pNextFrame = 1; + } + this._pBlendWeight = (time - frameTime) / durations[this._pCurrentFrame]; + } + }; + AnimationClipState.prototype.notifyPlaybackComplete = function () { + if (this._animationStatePlaybackComplete == null) + this._animationStatePlaybackComplete = new AnimationStateEvent(AnimationStateEvent.PLAYBACK_COMPLETE, this._pAnimator, this, this._animationClipNode); + this._animationClipNode.dispatchEvent(this._animationStatePlaybackComplete); + }; + return AnimationClipState; +})(AnimationStateBase); +module.exports = AnimationClipState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/animationclipstate.ts"],"names":["AnimationClipState","AnimationClipState.constructor","AnimationClipState.blendWeight","AnimationClipState.currentFrame","AnimationClipState.nextFrame","AnimationClipState.update","AnimationClipState.phase","AnimationClipState._pUpdateTime","AnimationClipState._pUpdateFrames","AnimationClipState.notifyPlaybackComplete"],"mappings":"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","file":"animators/states/AnimationClipState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\n\nimport AnimationClipNodeBase\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/AnimationClipNodeBase\");\nimport AnimationStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/AnimationStateBase\");\nimport AnimationStateEvent\t\t\t\t= require(\"awayjs-renderergl/lib/events/AnimationStateEvent\");\n\n/**\n *\n */\nclass AnimationClipState extends AnimationStateBase\n{\n\tprivate _animationClipNode:AnimationClipNodeBase;\n\tprivate _animationStatePlaybackComplete:AnimationStateEvent;\n\tpublic _pBlendWeight:number;\n\tpublic _pCurrentFrame:number /*uint*/;\n\tpublic _pNextFrame:number /*uint*/;\n\n\tpublic _pOldFrame:number /*uint*/;\n\tpublic _pTimeDir:number /*int*/;\n\tpublic _pFramesDirty:boolean = true;\n\n\t/**\n\t * Returns a fractional value between 0 and 1 representing the blending ratio of the current playhead position\n\t * between the current frame (0) and next frame (1) of the animation.\n\t *\n\t * @see #currentFrame\n\t * @see #nextFrame\n\t */\n\tpublic get blendWeight():number\n\t{\n\t\tif (this._pFramesDirty)\n\t\t\tthis._pUpdateFrames();\n\n\t\treturn this._pBlendWeight;\n\t}\n\n\t/**\n\t * Returns the current frame of animation in the clip based on the internal playhead position.\n\t */\n\tpublic get currentFrame():number /*uint*/\n\t{\n\t\tif (this._pFramesDirty)\n\t\t\tthis._pUpdateFrames();\n\n\t\treturn this._pCurrentFrame;\n\t}\n\n\t/**\n\t * Returns the next frame of animation in the clip based on the internal playhead position.\n\t */\n\tpublic get nextFrame():number /*uint*/\n\t{\n\t\tif (this._pFramesDirty)\n\t\t\tthis._pUpdateFrames();\n\n\t\treturn this._pNextFrame;\n\t}\n\n\tconstructor(animator:AnimatorBase, animationClipNode:AnimationClipNodeBase)\n\t{\n\t\tsuper(animator, animationClipNode);\n\n\t\tthis._animationClipNode = animationClipNode;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic update(time:number /*int*/)\n\t{\n\t\tif (!this._animationClipNode.looping) {\n\t\t\tif (time > this._pStartTime + this._animationClipNode.totalDuration)\n\t\t\t\ttime = this._pStartTime + this._animationClipNode.totalDuration; else if (time < this._pStartTime)\n\t\t\t\ttime = this._pStartTime;\n\t\t}\n\n\t\tif (this._pTime == time - this._pStartTime)\n\t\t\treturn;\n\n\t\tthis._pUpdateTime(time);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic phase(value:number)\n\t{\n\t\tvar time:number /*int*/ = value*this._animationClipNode.totalDuration + this._pStartTime;\n\n\t\tif (this._pTime == time - this._pStartTime)\n\t\t\treturn;\n\n\t\tthis._pUpdateTime(time);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdateTime(time:number /*int*/)\n\t{\n\t\tthis._pFramesDirty = true;\n\n\t\tthis._pTimeDir = (time - this._pStartTime > this._pTime)? 1 : -1;\n\n\t\tsuper._pUpdateTime(time);\n\t}\n\n\t/**\n\t * Updates the nodes internal playhead to determine the current and next animation frame, and the blendWeight between the two.\n\t *\n\t * @see #currentFrame\n\t * @see #nextFrame\n\t * @see #blendWeight\n\t */\n\tpublic _pUpdateFrames()\n\t{\n\t\tthis._pFramesDirty = false;\n\n\t\tvar looping:boolean = this._animationClipNode.looping;\n\t\tvar totalDuration:number /*uint*/ = this._animationClipNode.totalDuration;\n\t\tvar lastFrame:number /*uint*/ = this._animationClipNode.lastFrame;\n\t\tvar time:number /*int*/ = this._pTime;\n\n\t\t//trace(\"time\", time, totalDuration)\n\t\tif (looping && (time >= totalDuration || time < 0)) {\n\t\t\ttime %= totalDuration;\n\t\t\tif (time < 0)\n\t\t\t\ttime += totalDuration;\n\t\t}\n\n\t\tif (!looping && time >= totalDuration) {\n\t\t\tthis.notifyPlaybackComplete();\n\t\t\tthis._pCurrentFrame = lastFrame;\n\t\t\tthis._pNextFrame = lastFrame;\n\t\t\tthis._pBlendWeight = 0;\n\t\t} else if (!looping && time <= 0) {\n\t\t\tthis._pCurrentFrame = 0;\n\t\t\tthis._pNextFrame = 0;\n\t\t\tthis._pBlendWeight = 0;\n\t\t} else if (this._animationClipNode.fixedFrameRate) {\n\t\t\tvar t:number = time/totalDuration*lastFrame;\n\t\t\tthis._pCurrentFrame = Math.floor(t);\n\t\t\tthis._pBlendWeight = t - this._pCurrentFrame;\n\t\t\tthis._pNextFrame = this._pCurrentFrame + 1;\n\t\t} else {\n\t\t\tthis._pCurrentFrame = 0;\n\t\t\tthis._pNextFrame = 0;\n\n\t\t\tvar dur:number /*uint*/ = 0, frameTime:number /*uint*/;\n\t\t\tvar durations:Array<number> /*uint*/ = this._animationClipNode.durations;\n\n\t\t\tdo {\n\t\t\t\tframeTime = dur;\n\t\t\t\tdur += durations[this._pNextFrame];\n\t\t\t\tthis._pCurrentFrame = this._pNextFrame++;\n\t\t\t} while (time > dur);\n\n\t\t\tif (this._pCurrentFrame == lastFrame) {\n\t\t\t\tthis._pCurrentFrame = 0;\n\t\t\t\tthis._pNextFrame = 1;\n\t\t\t}\n\n\t\t\tthis._pBlendWeight = (time - frameTime)/durations[this._pCurrentFrame];\n\t\t}\n\t}\n\n\tprivate notifyPlaybackComplete()\n\t{\n\t\tif (this._animationStatePlaybackComplete == null)\n\t\t\tthis._animationStatePlaybackComplete = new AnimationStateEvent(AnimationStateEvent.PLAYBACK_COMPLETE, this._pAnimator, this, this._animationClipNode);\n\n\t\tthis._animationClipNode.dispatchEvent(this._animationStatePlaybackComplete);\n\t}\n}\n\nexport = AnimationClipState;"]} \ No newline at end of file diff --git a/lib/animators/states/AnimationClipState.ts b/lib/animators/states/AnimationClipState.ts new file mode 100644 index 000000000..0b08e02cf --- /dev/null +++ b/lib/animators/states/AnimationClipState.ts @@ -0,0 +1,176 @@ +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import AnimationClipNodeBase = require("awayjs-renderergl/lib/animators/nodes/AnimationClipNodeBase"); +import AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +import AnimationStateEvent = require("awayjs-renderergl/lib/events/AnimationStateEvent"); + +/** + * + */ +class AnimationClipState extends AnimationStateBase +{ + private _animationClipNode:AnimationClipNodeBase; + private _animationStatePlaybackComplete:AnimationStateEvent; + public _pBlendWeight:number; + public _pCurrentFrame:number /*uint*/; + public _pNextFrame:number /*uint*/; + + public _pOldFrame:number /*uint*/; + public _pTimeDir:number /*int*/; + public _pFramesDirty:boolean = true; + + /** + * Returns a fractional value between 0 and 1 representing the blending ratio of the current playhead position + * between the current frame (0) and next frame (1) of the animation. + * + * @see #currentFrame + * @see #nextFrame + */ + public get blendWeight():number + { + if (this._pFramesDirty) + this._pUpdateFrames(); + + return this._pBlendWeight; + } + + /** + * Returns the current frame of animation in the clip based on the internal playhead position. + */ + public get currentFrame():number /*uint*/ + { + if (this._pFramesDirty) + this._pUpdateFrames(); + + return this._pCurrentFrame; + } + + /** + * Returns the next frame of animation in the clip based on the internal playhead position. + */ + public get nextFrame():number /*uint*/ + { + if (this._pFramesDirty) + this._pUpdateFrames(); + + return this._pNextFrame; + } + + constructor(animator:AnimatorBase, animationClipNode:AnimationClipNodeBase) + { + super(animator, animationClipNode); + + this._animationClipNode = animationClipNode; + } + + /** + * @inheritDoc + */ + public update(time:number /*int*/) + { + if (!this._animationClipNode.looping) { + if (time > this._pStartTime + this._animationClipNode.totalDuration) + time = this._pStartTime + this._animationClipNode.totalDuration; else if (time < this._pStartTime) + time = this._pStartTime; + } + + if (this._pTime == time - this._pStartTime) + return; + + this._pUpdateTime(time); + } + + /** + * @inheritDoc + */ + public phase(value:number) + { + var time:number /*int*/ = value*this._animationClipNode.totalDuration + this._pStartTime; + + if (this._pTime == time - this._pStartTime) + return; + + this._pUpdateTime(time); + } + + /** + * @inheritDoc + */ + public _pUpdateTime(time:number /*int*/) + { + this._pFramesDirty = true; + + this._pTimeDir = (time - this._pStartTime > this._pTime)? 1 : -1; + + super._pUpdateTime(time); + } + + /** + * Updates the nodes internal playhead to determine the current and next animation frame, and the blendWeight between the two. + * + * @see #currentFrame + * @see #nextFrame + * @see #blendWeight + */ + public _pUpdateFrames() + { + this._pFramesDirty = false; + + var looping:boolean = this._animationClipNode.looping; + var totalDuration:number /*uint*/ = this._animationClipNode.totalDuration; + var lastFrame:number /*uint*/ = this._animationClipNode.lastFrame; + var time:number /*int*/ = this._pTime; + + //trace("time", time, totalDuration) + if (looping && (time >= totalDuration || time < 0)) { + time %= totalDuration; + if (time < 0) + time += totalDuration; + } + + if (!looping && time >= totalDuration) { + this.notifyPlaybackComplete(); + this._pCurrentFrame = lastFrame; + this._pNextFrame = lastFrame; + this._pBlendWeight = 0; + } else if (!looping && time <= 0) { + this._pCurrentFrame = 0; + this._pNextFrame = 0; + this._pBlendWeight = 0; + } else if (this._animationClipNode.fixedFrameRate) { + var t:number = time/totalDuration*lastFrame; + this._pCurrentFrame = Math.floor(t); + this._pBlendWeight = t - this._pCurrentFrame; + this._pNextFrame = this._pCurrentFrame + 1; + } else { + this._pCurrentFrame = 0; + this._pNextFrame = 0; + + var dur:number /*uint*/ = 0, frameTime:number /*uint*/; + var durations:Array /*uint*/ = this._animationClipNode.durations; + + do { + frameTime = dur; + dur += durations[this._pNextFrame]; + this._pCurrentFrame = this._pNextFrame++; + } while (time > dur); + + if (this._pCurrentFrame == lastFrame) { + this._pCurrentFrame = 0; + this._pNextFrame = 1; + } + + this._pBlendWeight = (time - frameTime)/durations[this._pCurrentFrame]; + } + } + + private notifyPlaybackComplete() + { + if (this._animationStatePlaybackComplete == null) + this._animationStatePlaybackComplete = new AnimationStateEvent(AnimationStateEvent.PLAYBACK_COMPLETE, this._pAnimator, this, this._animationClipNode); + + this._animationClipNode.dispatchEvent(this._animationStatePlaybackComplete); + } +} + +export = AnimationClipState; \ No newline at end of file diff --git a/lib/animators/states/AnimationStateBase.js b/lib/animators/states/AnimationStateBase.js new file mode 100755 index 000000000..48b269e10 --- /dev/null +++ b/lib/animators/states/AnimationStateBase.js @@ -0,0 +1,73 @@ +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +/** + * + */ +var AnimationStateBase = (function () { + function AnimationStateBase(animator, animationNode) { + this._pRootDelta = new Vector3D(); + this._pPositionDeltaDirty = true; + this._pStartTime = 0; + this._pAnimator = animator; + this._pAnimationNode = animationNode; + } + Object.defineProperty(AnimationStateBase.prototype, "positionDelta", { + /** + * Returns a 3d vector representing the translation delta of the animating entity for the current timestep of animation + */ + get: function () { + if (this._pPositionDeltaDirty) { + this._pUpdatePositionDelta(); + } + return this._pRootDelta; + }, + enumerable: true, + configurable: true + }); + /** + * Resets the start time of the node to a new value. + * + * @param startTime The absolute start time (in milliseconds) of the node's starting time. + */ + AnimationStateBase.prototype.offset = function (startTime) { + this._pStartTime = startTime; + this._pPositionDeltaDirty = true; + }; + /** + * Updates the configuration of the node to its current state. + * + * @param time The absolute time (in milliseconds) of the animator's play head position. + * + * @see AnimatorBase#update() + */ + AnimationStateBase.prototype.update = function (time) { + if (this._pTime == time - this._pStartTime) { + return; + } + this._pUpdateTime(time); + }; + /** + * Sets the animation phase of the node. + * + * @param value The phase value to use. 0 represents the beginning of an animation clip, 1 represents the end. + */ + AnimationStateBase.prototype.phase = function (value) { + }; + /** + * Updates the node's internal playhead position. + * + * @param time The local time (in milliseconds) of the node's playhead position. + */ + AnimationStateBase.prototype._pUpdateTime = function (time) { + this._pTime = time - this._pStartTime; + this._pPositionDeltaDirty = true; + }; + /** + * Updates the node's root delta position + */ + AnimationStateBase.prototype._pUpdatePositionDelta = function () { + }; + return AnimationStateBase; +})(); +module.exports = AnimationStateBase; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/AnimationStateBase.ts b/lib/animators/states/AnimationStateBase.ts new file mode 100644 index 000000000..f20f4b0f7 --- /dev/null +++ b/lib/animators/states/AnimationStateBase.ts @@ -0,0 +1,103 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import IAnimationState = require("awayjs-stagegl/lib/animators/states/IAnimationState"); + +import AnimationStateEvent = require("awayjs-renderergl/lib/events/AnimationStateEvent"); + +/** + * + */ +class AnimationStateBase implements IAnimationState +{ + public _pAnimationNode:AnimationNodeBase; + public _pRootDelta:Vector3D = new Vector3D(); + public _pPositionDeltaDirty:boolean = true; + + public _pTime:number; + public _pStartTime:number = 0; + public _pAnimator:AnimatorBase; + + /** + * Returns a 3d vector representing the translation delta of the animating entity for the current timestep of animation + */ + public get positionDelta():Vector3D + { + if (this._pPositionDeltaDirty) { + + this._pUpdatePositionDelta(); + } + + return this._pRootDelta; + + } + + constructor(animator:AnimatorBase, animationNode:AnimationNodeBase) + { + this._pAnimator = animator; + this._pAnimationNode = animationNode; + } + + /** + * Resets the start time of the node to a new value. + * + * @param startTime The absolute start time (in milliseconds) of the node's starting time. + */ + public offset(startTime:number) + { + this._pStartTime = startTime; + + this._pPositionDeltaDirty = true; + } + + /** + * Updates the configuration of the node to its current state. + * + * @param time The absolute time (in milliseconds) of the animator's play head position. + * + * @see AnimatorBase#update() + */ + public update(time:number) + { + if (this._pTime == time - this._pStartTime) { + + return; + + } + + this._pUpdateTime(time); + + } + + /** + * Sets the animation phase of the node. + * + * @param value The phase value to use. 0 represents the beginning of an animation clip, 1 represents the end. + */ + public phase(value:number) + { + + } + + /** + * Updates the node's internal playhead position. + * + * @param time The local time (in milliseconds) of the node's playhead position. + */ + public _pUpdateTime(time:number) + { + this._pTime = time - this._pStartTime; + + this._pPositionDeltaDirty = true; + } + + /** + * Updates the node's root delta position + */ + public _pUpdatePositionDelta() + { + } +} + +export = AnimationStateBase; \ No newline at end of file diff --git a/lib/animators/states/ISkeletonAnimationState.js b/lib/animators/states/ISkeletonAnimationState.js new file mode 100755 index 000000000..62ef01306 --- /dev/null +++ b/lib/animators/states/ISkeletonAnimationState.js @@ -0,0 +1,3 @@ + + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9zdGF0ZXMvaXNrZWxldG9uYW5pbWF0aW9uc3RhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBYWlDIiwiZmlsZSI6ImFuaW1hdG9ycy9zdGF0ZXMvSVNrZWxldG9uQW5pbWF0aW9uU3RhdGUuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgSUFuaW1hdGlvblN0YXRlXHRcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1zdGFnZWdsL2xpYi9hbmltYXRvcnMvc3RhdGVzL0lBbmltYXRpb25TdGF0ZVwiKTtcblxuaW1wb3J0IFNrZWxldG9uXHRcdFx0XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL2RhdGEvU2tlbGV0b25cIik7XG5pbXBvcnQgU2tlbGV0b25Qb3NlXHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXJlbmRlcmVyZ2wvbGliL2FuaW1hdG9ycy9kYXRhL1NrZWxldG9uUG9zZVwiKTtcblxuaW50ZXJmYWNlIElTa2VsZXRvbkFuaW1hdGlvblN0YXRlIGV4dGVuZHMgSUFuaW1hdGlvblN0YXRlXG57XG5cdC8qKlxuXHQgKiBSZXR1cm5zIHRoZSBvdXRwdXQgc2tlbGV0b24gcG9zZSBvZiB0aGUgYW5pbWF0aW9uIG5vZGUuXG5cdCAqL1xuXHRnZXRTa2VsZXRvblBvc2Uoc2tlbGV0b246U2tlbGV0b24pOlNrZWxldG9uUG9zZTtcbn1cblxuZXhwb3J0ID0gSVNrZWxldG9uQW5pbWF0aW9uU3RhdGU7Il19 \ No newline at end of file diff --git a/lib/animators/states/ISkeletonAnimationState.ts b/lib/animators/states/ISkeletonAnimationState.ts new file mode 100644 index 000000000..82040f79e --- /dev/null +++ b/lib/animators/states/ISkeletonAnimationState.ts @@ -0,0 +1,14 @@ +import IAnimationState = require("awayjs-stagegl/lib/animators/states/IAnimationState"); + +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); + +interface ISkeletonAnimationState extends IAnimationState +{ + /** + * Returns the output skeleton pose of the animation node. + */ + getSkeletonPose(skeleton:Skeleton):SkeletonPose; +} + +export = ISkeletonAnimationState; \ No newline at end of file diff --git a/lib/animators/states/IVertexAnimationState.js b/lib/animators/states/IVertexAnimationState.js new file mode 100755 index 000000000..49d48fa42 --- /dev/null +++ b/lib/animators/states/IVertexAnimationState.js @@ -0,0 +1,3 @@ + + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9zdGF0ZXMvaXZlcnRleGFuaW1hdGlvbnN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTRCK0IiLCJmaWxlIjoiYW5pbWF0b3JzL3N0YXRlcy9JVmVydGV4QW5pbWF0aW9uU3RhdGUuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgR2VvbWV0cnlcdFx0XHRcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1jb3JlL2xpYi9jb3JlL2Jhc2UvR2VvbWV0cnlcIik7XG5cbmltcG9ydCBJQW5pbWF0aW9uU3RhdGVcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXN0YWdlZ2wvbGliL2FuaW1hdG9ycy9zdGF0ZXMvSUFuaW1hdGlvblN0YXRlXCIpO1xuXG4vKipcbiAqIFByb3ZpZGVzIGFuIGludGVyZmFjZSBmb3IgYW5pbWF0aW9uIG5vZGUgY2xhc3NlcyB0aGF0IGhvbGQgYW5pbWF0aW9uIGRhdGEgZm9yIHVzZSBpbiB0aGUgVmVydGV4IGFuaW1hdG9yIGNsYXNzLlxuICpcbiAqIEBzZWUgYXdheS5hbmltYXRvcnMuVmVydGV4QW5pbWF0b3JcbiAqL1xuaW50ZXJmYWNlIElWZXJ0ZXhBbmltYXRpb25TdGF0ZSBleHRlbmRzIElBbmltYXRpb25TdGF0ZVxue1xuXHQvKipcblx0ICogUmV0dXJucyB0aGUgY3VycmVudCBnZW9tZXRyeSBmcmFtZSBvZiBhbmltYXRpb24gaW4gdGhlIGNsaXAgYmFzZWQgb24gdGhlIGludGVybmFsIHBsYXloZWFkIHBvc2l0aW9uLlxuXHQgKi9cblx0Y3VycmVudEdlb21ldHJ5Okdlb21ldHJ5OyAvL0dFVFxuXG5cdC8qKlxuXHQgKiBSZXR1cm5zIHRoZSBjdXJyZW50IGdlb21ldHJ5IGZyYW1lIG9mIGFuaW1hdGlvbiBpbiB0aGUgY2xpcCBiYXNlZCBvbiB0aGUgaW50ZXJuYWwgcGxheWhlYWQgcG9zaXRpb24uXG5cdCAqL1xuXHRuZXh0R2VvbWV0cnk6R2VvbWV0cnk7IC8vR0VUXG5cblx0LyoqXG5cdCAqIFJldHVybnMgYSBmcmFjdGlvbmFsIHZhbHVlIGJldHdlZW4gMCBhbmQgMSByZXByZXNlbnRpbmcgdGhlIGJsZW5kaW5nIHJhdGlvIG9mIHRoZSBjdXJyZW50IHBsYXloZWFkIHBvc2l0aW9uXG5cdCAqIGJldHdlZW4gdGhlIGN1cnJlbnQgZ2VvbWV0cnkgZnJhbWUgKDApIGFuZCBuZXh0IGdlb21ldHJ5IGZyYW1lICgxKSBvZiB0aGUgYW5pbWF0aW9uLlxuXHQgKi9cblx0YmxlbmRXZWlnaHQ6bnVtYmVyOyAvL0dFVFxufVxuXG5leHBvcnQgPSBJVmVydGV4QW5pbWF0aW9uU3RhdGU7Il19 \ No newline at end of file diff --git a/lib/animators/states/IVertexAnimationState.ts b/lib/animators/states/IVertexAnimationState.ts new file mode 100644 index 000000000..d4fa66351 --- /dev/null +++ b/lib/animators/states/IVertexAnimationState.ts @@ -0,0 +1,29 @@ +import Geometry = require("awayjs-core/lib/core/base/Geometry"); + +import IAnimationState = require("awayjs-stagegl/lib/animators/states/IAnimationState"); + +/** + * Provides an interface for animation node classes that hold animation data for use in the Vertex animator class. + * + * @see away.animators.VertexAnimator + */ +interface IVertexAnimationState extends IAnimationState +{ + /** + * Returns the current geometry frame of animation in the clip based on the internal playhead position. + */ + currentGeometry:Geometry; //GET + + /** + * Returns the current geometry frame of animation in the clip based on the internal playhead position. + */ + nextGeometry:Geometry; //GET + + /** + * Returns a fractional value between 0 and 1 representing the blending ratio of the current playhead position + * between the current geometry frame (0) and next geometry frame (1) of the animation. + */ + blendWeight:number; //GET +} + +export = IVertexAnimationState; \ No newline at end of file diff --git a/lib/animators/states/ParticleAccelerationState.js b/lib/animators/states/ParticleAccelerationState.js new file mode 100755 index 000000000..af38bdd47 --- /dev/null +++ b/lib/animators/states/ParticleAccelerationState.js @@ -0,0 +1,58 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleAccelerationState = (function (_super) { + __extends(ParticleAccelerationState, _super); + function ParticleAccelerationState(animator, particleAccelerationNode) { + _super.call(this, animator, particleAccelerationNode); + this._particleAccelerationNode = particleAccelerationNode; + this._acceleration = this._particleAccelerationNode._acceleration; + this.updateAccelerationData(); + } + Object.defineProperty(ParticleAccelerationState.prototype, "acceleration", { + /** + * Defines the acceleration vector of the state, used when in global mode. + */ + get: function () { + return this._acceleration; + }, + set: function (value) { + this._acceleration.x = value.x; + this._acceleration.y = value.y; + this._acceleration.z = value.z; + this.updateAccelerationData(); + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleAccelerationState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleAccelerationState.ACCELERATION_INDEX); + if (this._particleAccelerationNode.mode == ParticlePropertiesMode.LOCAL_STATIC) + animationSubGeometry.activateVertexBuffer(index, this._particleAccelerationNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + else + animationRegisterCache.setVertexConst(index, this._halfAcceleration.x, this._halfAcceleration.y, this._halfAcceleration.z); + }; + ParticleAccelerationState.prototype.updateAccelerationData = function () { + if (this._particleAccelerationNode.mode == ParticlePropertiesMode.GLOBAL) + this._halfAcceleration = new Vector3D(this._acceleration.x / 2, this._acceleration.y / 2, this._acceleration.z / 2); + }; + /** @private */ + ParticleAccelerationState.ACCELERATION_INDEX = 0; + return ParticleAccelerationState; +})(ParticleStateBase); +module.exports = ParticleAccelerationState; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9zdGF0ZXMvcGFydGljbGVhY2NlbGVyYXRpb25zdGF0ZS50cyJdLCJuYW1lcyI6WyJQYXJ0aWNsZUFjY2VsZXJhdGlvblN0YXRlIiwiUGFydGljbGVBY2NlbGVyYXRpb25TdGF0ZS5jb25zdHJ1Y3RvciIsIlBhcnRpY2xlQWNjZWxlcmF0aW9uU3RhdGUuYWNjZWxlcmF0aW9uIiwiUGFydGljbGVBY2NlbGVyYXRpb25TdGF0ZS5zZXRSZW5kZXJTdGF0ZSIsIlBhcnRpY2xlQWNjZWxlcmF0aW9uU3RhdGUudXBkYXRlQWNjZWxlcmF0aW9uRGF0YSJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsSUFBTyxRQUFRLFdBQWlCLG9DQUFvQyxDQUFDLENBQUM7QUFNdEUsSUFBTywyQkFBMkIsV0FBWSw2REFBNkQsQ0FBQyxDQUFDO0FBSTdHLElBQU8sc0JBQXNCLFdBQWEsNkRBQTZELENBQUMsQ0FBQztBQUV6RyxJQUFPLGlCQUFpQixXQUFjLDBEQUEwRCxDQUFDLENBQUM7QUFFbEcsQUFHQTs7R0FERztJQUNHLHlCQUF5QjtJQUFTQSxVQUFsQ0EseUJBQXlCQSxVQUEwQkE7SUEwQnhEQSxTQTFCS0EseUJBQXlCQSxDQTBCbEJBLFFBQXlCQSxFQUFFQSx3QkFBaURBO1FBRXZGQyxrQkFBTUEsUUFBUUEsRUFBRUEsd0JBQXdCQSxDQUFDQSxDQUFDQTtRQUUxQ0EsSUFBSUEsQ0FBQ0EseUJBQXlCQSxHQUFHQSx3QkFBd0JBLENBQUNBO1FBQzFEQSxJQUFJQSxDQUFDQSxhQUFhQSxHQUFHQSxJQUFJQSxDQUFDQSx5QkFBeUJBLENBQUNBLGFBQWFBLENBQUNBO1FBRWxFQSxJQUFJQSxDQUFDQSxzQkFBc0JBLEVBQUVBLENBQUNBO0lBQy9CQSxDQUFDQTtJQXRCREQsc0JBQVdBLG1EQUFZQTtRQUh2QkE7O1dBRUdBO2FBQ0hBO1lBRUNFLE1BQU1BLENBQUNBLElBQUlBLENBQUNBLGFBQWFBLENBQUNBO1FBQzNCQSxDQUFDQTthQUVERixVQUF3QkEsS0FBY0E7WUFFckNFLElBQUlBLENBQUNBLGFBQWFBLENBQUNBLENBQUNBLEdBQUdBLEtBQUtBLENBQUNBLENBQUNBLENBQUNBO1lBQy9CQSxJQUFJQSxDQUFDQSxhQUFhQSxDQUFDQSxDQUFDQSxHQUFHQSxLQUFLQSxDQUFDQSxDQUFDQSxDQUFDQTtZQUMvQkEsSUFBSUEsQ0FBQ0EsYUFBYUEsQ0FBQ0EsQ0FBQ0EsR0FBR0EsS0FBS0EsQ0FBQ0EsQ0FBQ0EsQ0FBQ0E7WUFFL0JBLElBQUlBLENBQUNBLHNCQUFzQkEsRUFBRUEsQ0FBQ0E7UUFDL0JBLENBQUNBOzs7T0FUQUY7SUFxQkRBOztPQUVHQTtJQUNJQSxrREFBY0EsR0FBckJBLFVBQXNCQSxLQUFXQSxFQUFFQSxVQUF5QkEsRUFBRUEsb0JBQXlDQSxFQUFFQSxzQkFBNkNBLEVBQUVBLE1BQWFBO1FBRXBLRyxJQUFJQSxLQUFLQSxHQUFrQkEsc0JBQXNCQSxDQUFDQSxnQkFBZ0JBLENBQUNBLElBQUlBLENBQUNBLGVBQWVBLEVBQUVBLHlCQUF5QkEsQ0FBQ0Esa0JBQWtCQSxDQUFDQSxDQUFDQTtRQUV2SUEsRUFBRUEsQ0FBQ0EsQ0FBQ0EsSUFBSUEsQ0FBQ0EseUJBQXlCQSxDQUFDQSxJQUFJQSxJQUFJQSxzQkFBc0JBLENBQUNBLFlBQVlBLENBQUNBO1lBQzlFQSxvQkFBb0JBLENBQUNBLG9CQUFvQkEsQ0FBQ0EsS0FBS0EsRUFBRUEsSUFBSUEsQ0FBQ0EseUJBQXlCQSxDQUFDQSxZQUFZQSxFQUFFQSxLQUFLQSxFQUFFQSwyQkFBMkJBLENBQUNBLE9BQU9BLENBQUNBLENBQUNBO1FBQzNJQSxJQUFJQTtZQUNIQSxzQkFBc0JBLENBQUNBLGNBQWNBLENBQUNBLEtBQUtBLEVBQUVBLElBQUlBLENBQUNBLGlCQUFpQkEsQ0FBQ0EsQ0FBQ0EsRUFBRUEsSUFBSUEsQ0FBQ0EsaUJBQWlCQSxDQUFDQSxDQUFDQSxFQUFFQSxJQUFJQSxDQUFDQSxpQkFBaUJBLENBQUNBLENBQUNBLENBQUNBLENBQUNBO0lBQzdIQSxDQUFDQTtJQUVPSCwwREFBc0JBLEdBQTlCQTtRQUVDSSxFQUFFQSxDQUFDQSxDQUFDQSxJQUFJQSxDQUFDQSx5QkFBeUJBLENBQUNBLElBQUlBLElBQUlBLHNCQUFzQkEsQ0FBQ0EsTUFBTUEsQ0FBQ0E7WUFDeEVBLElBQUlBLENBQUNBLGlCQUFpQkEsR0FBR0EsSUFBSUEsUUFBUUEsQ0FBQ0EsSUFBSUEsQ0FBQ0EsYUFBYUEsQ0FBQ0EsQ0FBQ0EsR0FBQ0EsQ0FBQ0EsRUFBRUEsSUFBSUEsQ0FBQ0EsYUFBYUEsQ0FBQ0EsQ0FBQ0EsR0FBQ0EsQ0FBQ0EsRUFBRUEsSUFBSUEsQ0FBQ0EsYUFBYUEsQ0FBQ0EsQ0FBQ0EsR0FBQ0EsQ0FBQ0EsQ0FBQ0EsQ0FBQ0E7SUFDaEhBLENBQUNBO0lBbkRESixlQUFlQTtJQUNEQSw0Q0FBa0JBLEdBQWtCQSxDQUFDQSxDQUFDQTtJQW1EckRBLGdDQUFDQTtBQUFEQSxDQXREQSxBQXNEQ0EsRUF0RHVDLGlCQUFpQixFQXNEeEQ7QUFFRCxBQUFtQyxpQkFBMUIseUJBQXlCLENBQUMiLCJmaWxlIjoiYW5pbWF0b3JzL3N0YXRlcy9QYXJ0aWNsZUFjY2VsZXJhdGlvblN0YXRlLmpzIiwic291cmNlUm9vdCI6Ii9Vc2Vycy9yb2JiYXRlbWFuL1dlYnN0b3JtUHJvamVjdHMvYXdheWpzLXJlbmRlcmVyZ2wvIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFZlY3RvcjNEXHRcdFx0XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtY29yZS9saWIvY29yZS9nZW9tL1ZlY3RvcjNEXCIpO1xuaW1wb3J0IENhbWVyYVx0XHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLWNvcmUvbGliL2VudGl0aWVzL0NhbWVyYVwiKTtcblxuaW1wb3J0IEFuaW1hdGlvblJlZ2lzdGVyQ2FjaGVcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtc3RhZ2VnbC9saWIvYW5pbWF0b3JzL2RhdGEvQW5pbWF0aW9uUmVnaXN0ZXJDYWNoZVwiKTtcbmltcG9ydCBTdGFnZVx0XHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXN0YWdlZ2wvbGliL2NvcmUvYmFzZS9TdGFnZVwiKTtcbmltcG9ydCBSZW5kZXJhYmxlQmFzZVx0XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtc3RhZ2VnbC9saWIvY29yZS9wb29sL1JlbmRlcmFibGVCYXNlXCIpO1xuaW1wb3J0IENvbnRleHRHTFZlcnRleEJ1ZmZlckZvcm1hdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtc3RhZ2VnbC9saWIvY29yZS9zdGFnZWdsL0NvbnRleHRHTFZlcnRleEJ1ZmZlckZvcm1hdFwiKTtcblxuaW1wb3J0IFBhcnRpY2xlQW5pbWF0b3JcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXJlbmRlcmVyZ2wvbGliL2FuaW1hdG9ycy9QYXJ0aWNsZUFuaW1hdG9yXCIpO1xuaW1wb3J0IEFuaW1hdGlvblN1Ykdlb21ldHJ5XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL2RhdGEvQW5pbWF0aW9uU3ViR2VvbWV0cnlcIik7XG5pbXBvcnQgUGFydGljbGVQcm9wZXJ0aWVzTW9kZVx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1yZW5kZXJlcmdsL2xpYi9hbmltYXRvcnMvZGF0YS9QYXJ0aWNsZVByb3BlcnRpZXNNb2RlXCIpO1xuaW1wb3J0IFBhcnRpY2xlQWNjZWxlcmF0aW9uTm9kZVx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1yZW5kZXJlcmdsL2xpYi9hbmltYXRvcnMvbm9kZXMvUGFydGljbGVBY2NlbGVyYXRpb25Ob2RlXCIpO1xuaW1wb3J0IFBhcnRpY2xlU3RhdGVCYXNlXHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL3N0YXRlcy9QYXJ0aWNsZVN0YXRlQmFzZVwiKTtcblxuLyoqXG4gKiAuLi5cbiAqL1xuY2xhc3MgUGFydGljbGVBY2NlbGVyYXRpb25TdGF0ZSBleHRlbmRzIFBhcnRpY2xlU3RhdGVCYXNlXG57XG5cdC8qKiBAcHJpdmF0ZSAqL1xuXHRwdWJsaWMgc3RhdGljIEFDQ0VMRVJBVElPTl9JTkRFWDpudW1iZXIgLyppbnQqLyA9IDA7XG5cblx0cHJpdmF0ZSBfcGFydGljbGVBY2NlbGVyYXRpb25Ob2RlOlBhcnRpY2xlQWNjZWxlcmF0aW9uTm9kZTtcblx0cHJpdmF0ZSBfYWNjZWxlcmF0aW9uOlZlY3RvcjNEO1xuXHRwcml2YXRlIF9oYWxmQWNjZWxlcmF0aW9uOlZlY3RvcjNEO1xuXHRcblx0LyoqXG5cdCAqIERlZmluZXMgdGhlIGFjY2VsZXJhdGlvbiB2ZWN0b3Igb2YgdGhlIHN0YXRlLCB1c2VkIHdoZW4gaW4gZ2xvYmFsIG1vZGUuXG5cdCAqL1xuXHRwdWJsaWMgZ2V0IGFjY2VsZXJhdGlvbigpOlZlY3RvcjNEXG5cdHtcblx0XHRyZXR1cm4gdGhpcy5fYWNjZWxlcmF0aW9uO1xuXHR9XG5cdFxuXHRwdWJsaWMgc2V0IGFjY2VsZXJhdGlvbih2YWx1ZTpWZWN0b3IzRClcblx0e1xuXHRcdHRoaXMuX2FjY2VsZXJhdGlvbi54ID0gdmFsdWUueDtcblx0XHR0aGlzLl9hY2NlbGVyYXRpb24ueSA9IHZhbHVlLnk7XG5cdFx0dGhpcy5fYWNjZWxlcmF0aW9uLnogPSB2YWx1ZS56O1xuXG5cdFx0dGhpcy51cGRhdGVBY2NlbGVyYXRpb25EYXRhKCk7XG5cdH1cblx0XG5cdGNvbnN0cnVjdG9yKGFuaW1hdG9yOlBhcnRpY2xlQW5pbWF0b3IsIHBhcnRpY2xlQWNjZWxlcmF0aW9uTm9kZTpQYXJ0aWNsZUFjY2VsZXJhdGlvbk5vZGUpXG5cdHtcblx0XHRzdXBlcihhbmltYXRvciwgcGFydGljbGVBY2NlbGVyYXRpb25Ob2RlKTtcblxuXHRcdHRoaXMuX3BhcnRpY2xlQWNjZWxlcmF0aW9uTm9kZSA9IHBhcnRpY2xlQWNjZWxlcmF0aW9uTm9kZTtcblx0XHR0aGlzLl9hY2NlbGVyYXRpb24gPSB0aGlzLl9wYXJ0aWNsZUFjY2VsZXJhdGlvbk5vZGUuX2FjY2VsZXJhdGlvbjtcblxuXHRcdHRoaXMudXBkYXRlQWNjZWxlcmF0aW9uRGF0YSgpO1xuXHR9XG5cdFxuXHQvKipcblx0ICogQGluaGVyaXREb2Ncblx0ICovXG5cdHB1YmxpYyBzZXRSZW5kZXJTdGF0ZShzdGFnZTpTdGFnZSwgcmVuZGVyYWJsZTpSZW5kZXJhYmxlQmFzZSwgYW5pbWF0aW9uU3ViR2VvbWV0cnk6QW5pbWF0aW9uU3ViR2VvbWV0cnksIGFuaW1hdGlvblJlZ2lzdGVyQ2FjaGU6QW5pbWF0aW9uUmVnaXN0ZXJDYWNoZSwgY2FtZXJhOkNhbWVyYSlcblx0e1xuXHRcdHZhciBpbmRleDpudW1iZXIgLyppbnQqLyA9IGFuaW1hdGlvblJlZ2lzdGVyQ2FjaGUuZ2V0UmVnaXN0ZXJJbmRleCh0aGlzLl9wQW5pbWF0aW9uTm9kZSwgUGFydGljbGVBY2NlbGVyYXRpb25TdGF0ZS5BQ0NFTEVSQVRJT05fSU5ERVgpO1xuXHRcdFxuXHRcdGlmICh0aGlzLl9wYXJ0aWNsZUFjY2VsZXJhdGlvbk5vZGUubW9kZSA9PSBQYXJ0aWNsZVByb3BlcnRpZXNNb2RlLkxPQ0FMX1NUQVRJQylcblx0XHRcdGFuaW1hdGlvblN1Ykdlb21ldHJ5LmFjdGl2YXRlVmVydGV4QnVmZmVyKGluZGV4LCB0aGlzLl9wYXJ0aWNsZUFjY2VsZXJhdGlvbk5vZGUuX2lEYXRhT2Zmc2V0LCBzdGFnZSwgQ29udGV4dEdMVmVydGV4QnVmZmVyRm9ybWF0LkZMT0FUXzMpO1xuXHRcdGVsc2Vcblx0XHRcdGFuaW1hdGlvblJlZ2lzdGVyQ2FjaGUuc2V0VmVydGV4Q29uc3QoaW5kZXgsIHRoaXMuX2hhbGZBY2NlbGVyYXRpb24ueCwgdGhpcy5faGFsZkFjY2VsZXJhdGlvbi55LCB0aGlzLl9oYWxmQWNjZWxlcmF0aW9uLnopO1xuXHR9XG5cdFxuXHRwcml2YXRlIHVwZGF0ZUFjY2VsZXJhdGlvbkRhdGEoKVxuXHR7XG5cdFx0aWYgKHRoaXMuX3BhcnRpY2xlQWNjZWxlcmF0aW9uTm9kZS5tb2RlID09IFBhcnRpY2xlUHJvcGVydGllc01vZGUuR0xPQkFMKVxuXHRcdFx0dGhpcy5faGFsZkFjY2VsZXJhdGlvbiA9IG5ldyBWZWN0b3IzRCh0aGlzLl9hY2NlbGVyYXRpb24ueC8yLCB0aGlzLl9hY2NlbGVyYXRpb24ueS8yLCB0aGlzLl9hY2NlbGVyYXRpb24uei8yKTtcblx0fVxufVxuXG5leHBvcnQgPSBQYXJ0aWNsZUFjY2VsZXJhdGlvblN0YXRlOyJdfQ== \ No newline at end of file diff --git a/lib/animators/states/ParticleAccelerationState.ts b/lib/animators/states/ParticleAccelerationState.ts new file mode 100644 index 000000000..7a6a22516 --- /dev/null +++ b/lib/animators/states/ParticleAccelerationState.ts @@ -0,0 +1,74 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleAccelerationNode = require("awayjs-renderergl/lib/animators/nodes/ParticleAccelerationNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleAccelerationState extends ParticleStateBase +{ + /** @private */ + public static ACCELERATION_INDEX:number /*int*/ = 0; + + private _particleAccelerationNode:ParticleAccelerationNode; + private _acceleration:Vector3D; + private _halfAcceleration:Vector3D; + + /** + * Defines the acceleration vector of the state, used when in global mode. + */ + public get acceleration():Vector3D + { + return this._acceleration; + } + + public set acceleration(value:Vector3D) + { + this._acceleration.x = value.x; + this._acceleration.y = value.y; + this._acceleration.z = value.z; + + this.updateAccelerationData(); + } + + constructor(animator:ParticleAnimator, particleAccelerationNode:ParticleAccelerationNode) + { + super(animator, particleAccelerationNode); + + this._particleAccelerationNode = particleAccelerationNode; + this._acceleration = this._particleAccelerationNode._acceleration; + + this.updateAccelerationData(); + } + + /** + * @inheritDoc + */ + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleAccelerationState.ACCELERATION_INDEX); + + if (this._particleAccelerationNode.mode == ParticlePropertiesMode.LOCAL_STATIC) + animationSubGeometry.activateVertexBuffer(index, this._particleAccelerationNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + else + animationRegisterCache.setVertexConst(index, this._halfAcceleration.x, this._halfAcceleration.y, this._halfAcceleration.z); + } + + private updateAccelerationData() + { + if (this._particleAccelerationNode.mode == ParticlePropertiesMode.GLOBAL) + this._halfAcceleration = new Vector3D(this._acceleration.x/2, this._acceleration.y/2, this._acceleration.z/2); + } +} + +export = ParticleAccelerationState; \ No newline at end of file diff --git a/lib/animators/states/ParticleBezierCurveState.js b/lib/animators/states/ParticleBezierCurveState.js new file mode 100755 index 000000000..05490c2c2 --- /dev/null +++ b/lib/animators/states/ParticleBezierCurveState.js @@ -0,0 +1,67 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleBezierCurveState = (function (_super) { + __extends(ParticleBezierCurveState, _super); + function ParticleBezierCurveState(animator, particleBezierCurveNode) { + _super.call(this, animator, particleBezierCurveNode); + this._particleBezierCurveNode = particleBezierCurveNode; + this._controlPoint = this._particleBezierCurveNode._iControlPoint; + this._endPoint = this._particleBezierCurveNode._iEndPoint; + } + Object.defineProperty(ParticleBezierCurveState.prototype, "controlPoint", { + /** + * Defines the default control point of the node, used when in global mode. + */ + get: function () { + return this._controlPoint; + }, + set: function (value) { + this._controlPoint = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleBezierCurveState.prototype, "endPoint", { + /** + * Defines the default end point of the node, used when in global mode. + */ + get: function () { + return this._endPoint; + }, + set: function (value) { + this._endPoint = value; + }, + enumerable: true, + configurable: true + }); + ParticleBezierCurveState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + var controlIndex = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleBezierCurveState.BEZIER_CONTROL_INDEX); + var endIndex = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleBezierCurveState.BEZIER_END_INDEX); + if (this._particleBezierCurveNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + animationSubGeometry.activateVertexBuffer(controlIndex, this._particleBezierCurveNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + animationSubGeometry.activateVertexBuffer(endIndex, this._particleBezierCurveNode._iDataOffset + 3, stage, ContextGLVertexBufferFormat.FLOAT_3); + } + else { + animationRegisterCache.setVertexConst(controlIndex, this._controlPoint.x, this._controlPoint.y, this._controlPoint.z); + animationRegisterCache.setVertexConst(endIndex, this._endPoint.x, this._endPoint.y, this._endPoint.z); + } + }; + /** @private */ + ParticleBezierCurveState.BEZIER_CONTROL_INDEX = 0; + /** @private */ + ParticleBezierCurveState.BEZIER_END_INDEX = 1; + return ParticleBezierCurveState; +})(ParticleStateBase); +module.exports = ParticleBezierCurveState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/ParticleBezierCurveState.ts b/lib/animators/states/ParticleBezierCurveState.ts new file mode 100644 index 000000000..9dbb47880 --- /dev/null +++ b/lib/animators/states/ParticleBezierCurveState.ts @@ -0,0 +1,80 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleBezierCurveNode = require("awayjs-renderergl/lib/animators/nodes/ParticleBezierCurveNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleBezierCurveState extends ParticleStateBase +{ + /** @private */ + public static BEZIER_CONTROL_INDEX:number /*int*/ = 0; + + /** @private */ + public static BEZIER_END_INDEX:number /*int*/ = 1; + + private _particleBezierCurveNode:ParticleBezierCurveNode; + private _controlPoint:Vector3D; + private _endPoint:Vector3D; + + /** + * Defines the default control point of the node, used when in global mode. + */ + public get controlPoint():Vector3D + { + return this._controlPoint; + } + + public set controlPoint(value:Vector3D) + { + this._controlPoint = value; + } + + /** + * Defines the default end point of the node, used when in global mode. + */ + public get endPoint():Vector3D + { + return this._endPoint; + } + + public set endPoint(value:Vector3D) + { + this._endPoint = value; + } + + constructor(animator:ParticleAnimator, particleBezierCurveNode:ParticleBezierCurveNode) + { + super(animator, particleBezierCurveNode); + + this._particleBezierCurveNode = particleBezierCurveNode; + this._controlPoint = this._particleBezierCurveNode._iControlPoint; + this._endPoint = this._particleBezierCurveNode._iEndPoint; + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + var controlIndex:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleBezierCurveState.BEZIER_CONTROL_INDEX); + var endIndex:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleBezierCurveState.BEZIER_END_INDEX); + + if (this._particleBezierCurveNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + animationSubGeometry.activateVertexBuffer(controlIndex, this._particleBezierCurveNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + animationSubGeometry.activateVertexBuffer(endIndex, this._particleBezierCurveNode._iDataOffset + 3, stage, ContextGLVertexBufferFormat.FLOAT_3); + } else { + animationRegisterCache.setVertexConst(controlIndex, this._controlPoint.x, this._controlPoint.y, this._controlPoint.z); + animationRegisterCache.setVertexConst(endIndex, this._endPoint.x, this._endPoint.y, this._endPoint.z); + } + } +} + +export = ParticleBezierCurveState; \ No newline at end of file diff --git a/lib/animators/states/ParticleBillboardState.js b/lib/animators/states/ParticleBillboardState.js new file mode 100755 index 000000000..58d8af9cc --- /dev/null +++ b/lib/animators/states/ParticleBillboardState.js @@ -0,0 +1,76 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var MathConsts = require("awayjs-core/lib/core/geom/MathConsts"); +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var Orientation3D = require("awayjs-core/lib/core/geom/Orientation3D"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleBillboardState = (function (_super) { + __extends(ParticleBillboardState, _super); + /** + * + */ + function ParticleBillboardState(animator, particleNode) { + _super.call(this, animator, particleNode); + this._matrix = new Matrix3D; + this._billboardAxis = particleNode._iBillboardAxis; + } + ParticleBillboardState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + var comps; + if (this._billboardAxis) { + var pos = renderable.sourceEntity.sceneTransform.position; + var look = camera.sceneTransform.position.subtract(pos); + var right = look.crossProduct(this._billboardAxis); + right.normalize(); + look = this.billboardAxis.crossProduct(right); + look.normalize(); + //create a quick inverse projection matrix + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + comps = this._matrix.decompose(Orientation3D.AXIS_ANGLE); + this._matrix.copyColumnFrom(0, right); + this._matrix.copyColumnFrom(1, this.billboardAxis); + this._matrix.copyColumnFrom(2, look); + this._matrix.copyColumnFrom(3, pos); + this._matrix.appendRotation(-comps[1].w * MathConsts.RADIANS_TO_DEGREES, comps[1]); + } + else { + //create a quick inverse projection matrix + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + this._matrix.append(camera.inverseSceneTransform); + //decompose using axis angle rotations + comps = this._matrix.decompose(Orientation3D.AXIS_ANGLE); + //recreate the matrix with just the rotation data + this._matrix.identity(); + this._matrix.appendRotation(-comps[1].w * MathConsts.RADIANS_TO_DEGREES, comps[1]); + } + //set a new matrix transform constant + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleBillboardState.MATRIX_INDEX), this._matrix); + }; + Object.defineProperty(ParticleBillboardState.prototype, "billboardAxis", { + /** + * Defines the billboard axis. + */ + get: function () { + return this.billboardAxis; + }, + set: function (value) { + this.billboardAxis = value ? value.clone() : null; + if (this.billboardAxis) + this.billboardAxis.normalize(); + }, + enumerable: true, + configurable: true + }); + /** @private */ + ParticleBillboardState.MATRIX_INDEX = 0; + return ParticleBillboardState; +})(ParticleStateBase); +module.exports = ParticleBillboardState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlebillboardstate.ts"],"names":["ParticleBillboardState","ParticleBillboardState.constructor","ParticleBillboardState.setRenderState","ParticleBillboardState.billboardAxis"],"mappings":"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","file":"animators/states/ParticleBillboardState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import MathConsts\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/MathConsts\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Orientation3D\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Orientation3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticleBillboardNode\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleBillboardNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n */\nclass ParticleBillboardState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static MATRIX_INDEX:number /*int*/ = 0;\n\n\tprivate _matrix:Matrix3D = new Matrix3D;\n\n\tprivate _billboardAxis:Vector3D;\n\n\t/**\n\t *\n\t */\n\tconstructor(animator:ParticleAnimator, particleNode:ParticleBillboardNode)\n\t{\n\t\tsuper(animator, particleNode);\n\n\t\tthis._billboardAxis = particleNode._iBillboardAxis;\n\t}\n\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tvar comps:Array<Vector3D>;\n\t\tif (this._billboardAxis) {\n\t\t\tvar pos:Vector3D = renderable.sourceEntity.sceneTransform.position;\n\t\t\tvar look:Vector3D = camera.sceneTransform.position.subtract(pos);\n\t\t\tvar right:Vector3D = look.crossProduct(this._billboardAxis);\n\t\t\tright.normalize();\n\t\t\tlook = this.billboardAxis.crossProduct(right);\n\t\t\tlook.normalize();\n\n\t\t\t//create a quick inverse projection matrix\n\t\t\tthis._matrix.copyFrom(renderable.sourceEntity.sceneTransform);\n\t\t\tcomps = this._matrix.decompose(Orientation3D.AXIS_ANGLE);\n\t\t\tthis._matrix.copyColumnFrom(0, right);\n\t\t\tthis._matrix.copyColumnFrom(1, this.billboardAxis);\n\t\t\tthis._matrix.copyColumnFrom(2, look);\n\t\t\tthis._matrix.copyColumnFrom(3, pos);\n\t\t\tthis._matrix.appendRotation(-comps[1].w*MathConsts.RADIANS_TO_DEGREES, comps[1]);\n\t\t} else {\n\t\t\t//create a quick inverse projection matrix\n\t\t\tthis._matrix.copyFrom(renderable.sourceEntity.sceneTransform);\n\t\t\tthis._matrix.append(camera.inverseSceneTransform);\n\n\t\t\t//decompose using axis angle rotations\n\t\t\tcomps = this._matrix.decompose(Orientation3D.AXIS_ANGLE);\n\n\t\t\t//recreate the matrix with just the rotation data\n\t\t\tthis._matrix.identity();\n\t\t\tthis._matrix.appendRotation(-comps[1].w*MathConsts.RADIANS_TO_DEGREES, comps[1]);\n\t\t}\n\n\t\t//set a new matrix transform constant\n\t\tanimationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleBillboardState.MATRIX_INDEX), this._matrix);\n\t}\n\n\t/**\n\t * Defines the billboard axis.\n\t */\n\tpublic get billboardAxis():Vector3D\n\t{\n\t\treturn this.billboardAxis;\n\t}\n\n\tpublic set billboardAxis(value:Vector3D)\n\t{\n\t\tthis.billboardAxis = value? value.clone() : null;\n\t\tif (this.billboardAxis)\n\t\t\tthis.billboardAxis.normalize();\n\t}\n\n}\n\nexport = ParticleBillboardState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleBillboardState.ts b/lib/animators/states/ParticleBillboardState.ts new file mode 100644 index 000000000..12532272f --- /dev/null +++ b/lib/animators/states/ParticleBillboardState.ts @@ -0,0 +1,92 @@ +import MathConsts = require("awayjs-core/lib/core/geom/MathConsts"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Orientation3D = require("awayjs-core/lib/core/geom/Orientation3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticleBillboardNode = require("awayjs-renderergl/lib/animators/nodes/ParticleBillboardNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleBillboardState extends ParticleStateBase +{ + /** @private */ + public static MATRIX_INDEX:number /*int*/ = 0; + + private _matrix:Matrix3D = new Matrix3D; + + private _billboardAxis:Vector3D; + + /** + * + */ + constructor(animator:ParticleAnimator, particleNode:ParticleBillboardNode) + { + super(animator, particleNode); + + this._billboardAxis = particleNode._iBillboardAxis; + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + var comps:Array; + if (this._billboardAxis) { + var pos:Vector3D = renderable.sourceEntity.sceneTransform.position; + var look:Vector3D = camera.sceneTransform.position.subtract(pos); + var right:Vector3D = look.crossProduct(this._billboardAxis); + right.normalize(); + look = this.billboardAxis.crossProduct(right); + look.normalize(); + + //create a quick inverse projection matrix + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + comps = this._matrix.decompose(Orientation3D.AXIS_ANGLE); + this._matrix.copyColumnFrom(0, right); + this._matrix.copyColumnFrom(1, this.billboardAxis); + this._matrix.copyColumnFrom(2, look); + this._matrix.copyColumnFrom(3, pos); + this._matrix.appendRotation(-comps[1].w*MathConsts.RADIANS_TO_DEGREES, comps[1]); + } else { + //create a quick inverse projection matrix + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + this._matrix.append(camera.inverseSceneTransform); + + //decompose using axis angle rotations + comps = this._matrix.decompose(Orientation3D.AXIS_ANGLE); + + //recreate the matrix with just the rotation data + this._matrix.identity(); + this._matrix.appendRotation(-comps[1].w*MathConsts.RADIANS_TO_DEGREES, comps[1]); + } + + //set a new matrix transform constant + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleBillboardState.MATRIX_INDEX), this._matrix); + } + + /** + * Defines the billboard axis. + */ + public get billboardAxis():Vector3D + { + return this.billboardAxis; + } + + public set billboardAxis(value:Vector3D) + { + this.billboardAxis = value? value.clone() : null; + if (this.billboardAxis) + this.billboardAxis.normalize(); + } + +} + +export = ParticleBillboardState; \ No newline at end of file diff --git a/lib/animators/states/ParticleColorState.js b/lib/animators/states/ParticleColorState.js new file mode 100755 index 000000000..ca0e7cac3 --- /dev/null +++ b/lib/animators/states/ParticleColorState.js @@ -0,0 +1,160 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + * @author ... + */ +var ParticleColorState = (function (_super) { + __extends(ParticleColorState, _super); + function ParticleColorState(animator, particleColorNode) { + _super.call(this, animator, particleColorNode); + this._particleColorNode = particleColorNode; + this._usesMultiplier = this._particleColorNode._iUsesMultiplier; + this._usesOffset = this._particleColorNode._iUsesOffset; + this._usesCycle = this._particleColorNode._iUsesCycle; + this._usesPhase = this._particleColorNode._iUsesPhase; + this._startColor = this._particleColorNode._iStartColor; + this._endColor = this._particleColorNode._iEndColor; + this._cycleDuration = this._particleColorNode._iCycleDuration; + this._cyclePhase = this._particleColorNode._iCyclePhase; + this.updateColorData(); + } + Object.defineProperty(ParticleColorState.prototype, "startColor", { + /** + * Defines the start color transform of the state, when in global mode. + */ + get: function () { + return this._startColor; + }, + set: function (value) { + this._startColor = value; + this.updateColorData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleColorState.prototype, "endColor", { + /** + * Defines the end color transform of the state, when in global mode. + */ + get: function () { + return this._endColor; + }, + set: function (value) { + this._endColor = value; + this.updateColorData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleColorState.prototype, "cycleDuration", { + /** + * Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + */ + get: function () { + return this._cycleDuration; + }, + set: function (value) { + this._cycleDuration = value; + this.updateColorData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleColorState.prototype, "cyclePhase", { + /** + * Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + get: function () { + return this._cyclePhase; + }, + set: function (value) { + this._cyclePhase = value; + this.updateColorData(); + }, + enumerable: true, + configurable: true + }); + ParticleColorState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (animationRegisterCache.needFragmentAnimation) { + var dataOffset = this._particleColorNode._iDataOffset; + if (this._usesCycle) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.CYCLE_INDEX), this._cycleData.x, this._cycleData.y, this._cycleData.z, this._cycleData.w); + if (this._usesMultiplier) { + if (this._particleColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + } + else { + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_MULTIPLIER_INDEX), this._startMultiplierData.x, this._startMultiplierData.y, this._startMultiplierData.z, this._startMultiplierData.w); + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_MULTIPLIER_INDEX), this._deltaMultiplierData.x, this._deltaMultiplierData.y, this._deltaMultiplierData.z, this._deltaMultiplierData.w); + } + } + if (this._usesOffset) { + if (this._particleColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + } + else { + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_OFFSET_INDEX), this._startOffsetData.x, this._startOffsetData.y, this._startOffsetData.z, this._startOffsetData.w); + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_OFFSET_INDEX), this._deltaOffsetData.x, this._deltaOffsetData.y, this._deltaOffsetData.z, this._deltaOffsetData.w); + } + } + } + }; + ParticleColorState.prototype.updateColorData = function () { + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw (new Error("the cycle duration must be greater than zero")); + this._cycleData = new Vector3D(Math.PI * 2 / this._cycleDuration, this._cyclePhase * Math.PI / 180, 0, 0); + } + if (this._particleColorNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._usesCycle) { + if (this._usesMultiplier) { + this._startMultiplierData = new Vector3D((this._startColor.redMultiplier + this._endColor.redMultiplier) / 2, (this._startColor.greenMultiplier + this._endColor.greenMultiplier) / 2, (this._startColor.blueMultiplier + this._endColor.blueMultiplier) / 2, (this._startColor.alphaMultiplier + this._endColor.alphaMultiplier) / 2); + this._deltaMultiplierData = new Vector3D((this._endColor.redMultiplier - this._startColor.redMultiplier) / 2, (this._endColor.greenMultiplier - this._startColor.greenMultiplier) / 2, (this._endColor.blueMultiplier - this._startColor.blueMultiplier) / 2, (this._endColor.alphaMultiplier - this._startColor.alphaMultiplier) / 2); + } + if (this._usesOffset) { + this._startOffsetData = new Vector3D((this._startColor.redOffset + this._endColor.redOffset) / (255 * 2), (this._startColor.greenOffset + this._endColor.greenOffset) / (255 * 2), (this._startColor.blueOffset + this._endColor.blueOffset) / (255 * 2), (this._startColor.alphaOffset + this._endColor.alphaOffset) / (255 * 2)); + this._deltaOffsetData = new Vector3D((this._endColor.redOffset - this._startColor.redOffset) / (255 * 2), (this._endColor.greenOffset - this._startColor.greenOffset) / (255 * 2), (this._endColor.blueOffset - this._startColor.blueOffset) / (255 * 2), (this._endColor.alphaOffset - this._startColor.alphaOffset) / (255 * 2)); + } + } + else { + if (this._usesMultiplier) { + this._startMultiplierData = new Vector3D(this._startColor.redMultiplier, this._startColor.greenMultiplier, this._startColor.blueMultiplier, this._startColor.alphaMultiplier); + this._deltaMultiplierData = new Vector3D((this._endColor.redMultiplier - this._startColor.redMultiplier), (this._endColor.greenMultiplier - this._startColor.greenMultiplier), (this._endColor.blueMultiplier - this._startColor.blueMultiplier), (this._endColor.alphaMultiplier - this._startColor.alphaMultiplier)); + } + if (this._usesOffset) { + this._startOffsetData = new Vector3D(this._startColor.redOffset / 255, this._startColor.greenOffset / 255, this._startColor.blueOffset / 255, this._startColor.alphaOffset / 255); + this._deltaOffsetData = new Vector3D((this._endColor.redOffset - this._startColor.redOffset) / 255, (this._endColor.greenOffset - this._startColor.greenOffset) / 255, (this._endColor.blueOffset - this._startColor.blueOffset) / 255, (this._endColor.alphaOffset - this._startColor.alphaOffset) / 255); + } + } + } + }; + /** @private */ + ParticleColorState.START_MULTIPLIER_INDEX = 0; + /** @private */ + ParticleColorState.DELTA_MULTIPLIER_INDEX = 1; + /** @private */ + ParticleColorState.START_OFFSET_INDEX = 2; + /** @private */ + ParticleColorState.DELTA_OFFSET_INDEX = 3; + /** @private */ + ParticleColorState.CYCLE_INDEX = 4; + return ParticleColorState; +})(ParticleStateBase); +module.exports = ParticleColorState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlecolorstate.ts"],"names":["ParticleColorState","ParticleColorState.constructor","ParticleColorState.startColor","ParticleColorState.endColor","ParticleColorState.cycleDuration","ParticleColorState.cyclePhase","ParticleColorState.setRenderState","ParticleColorState.updateColorData"],"mappings":"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,CAACA,GAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,eAAeA,CAACA,GAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,cAAcA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,cAAcA,CAACA,GAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,eAAeA,CAACA,GAACA,CAACA,CAACA,CAACA;gBAChUA,CAACA;gBAEDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,CAACA;oBACtBA,IAAIA,CAACA,gBAAgBA,GAAGA,IAAIA,QAAQA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA,SAASA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,SAASA,CAACA,WAAWA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,WAAWA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,SAASA,CAACA,UAAUA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,SAASA,CAACA,WAAWA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,CAACA,CAACA;oBACnTA,IAAIA,CAACA,gBAAgBA,GAAGA,IAAIA,QAAQA,CAACA,CAACA,IAAIA,CAACA,SAASA,CAACA,SAASA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,SAASA,CAACA,GAACA,CAACA,GAAGA,GAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,CAACA,GAACA,CAACA,GAAGA,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","file":"animators/states/ParticleColorState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ColorTransform\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/ColorTransform\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleColorNode\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleColorNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n * @author ...\n */\nclass ParticleColorState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static START_MULTIPLIER_INDEX:number /*uint*/ = 0;\n\n\t/** @private */\n\tpublic static DELTA_MULTIPLIER_INDEX:number /*uint*/ = 1;\n\n\t/** @private */\n\tpublic static START_OFFSET_INDEX:number /*uint*/ = 2;\n\n\t/** @private */\n\tpublic static DELTA_OFFSET_INDEX:number /*uint*/ = 3;\n\n\t/** @private */\n\tpublic static CYCLE_INDEX:number /*uint*/ = 4;\n\n\tprivate _particleColorNode:ParticleColorNode;\n\tprivate _usesMultiplier:boolean;\n\tprivate _usesOffset:boolean;\n\tprivate _usesCycle:boolean;\n\tprivate _usesPhase:boolean;\n\tprivate _startColor:ColorTransform;\n\tprivate _endColor:ColorTransform;\n\tprivate _cycleDuration:number;\n\tprivate _cyclePhase:number;\n\tprivate _cycleData:Vector3D;\n\tprivate _startMultiplierData:Vector3D;\n\tprivate _deltaMultiplierData:Vector3D;\n\tprivate _startOffsetData:Vector3D;\n\tprivate _deltaOffsetData:Vector3D;\n\n\t/**\n\t * Defines the start color transform of the state, when in global mode.\n\t */\n\tpublic get startColor():ColorTransform\n\t{\n\t\treturn this._startColor;\n\t}\n\n\tpublic set startColor(value:ColorTransform)\n\t{\n\t\tthis._startColor = value;\n\n\t\tthis.updateColorData();\n\t}\n\n\t/**\n\t * Defines the end color transform of the state, when in global mode.\n\t */\n\tpublic get endColor():ColorTransform\n\t{\n\t\treturn this._endColor;\n\t}\n\n\tpublic set endColor(value:ColorTransform)\n\t{\n\t\tthis._endColor = value;\n\n\t\tthis.updateColorData();\n\t}\n\n\t/**\n\t * Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1.\n\t */\n\tpublic get cycleDuration():number\n\t{\n\t\treturn this._cycleDuration;\n\t}\n\n\tpublic set cycleDuration(value:number)\n\t{\n\t\tthis._cycleDuration = value;\n\n\t\tthis.updateColorData();\n\t}\n\n\t/**\n\t * Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0.\n\t */\n\tpublic get cyclePhase():number\n\t{\n\t\treturn this._cyclePhase;\n\t}\n\n\tpublic set cyclePhase(value:number)\n\t{\n\t\tthis._cyclePhase = value;\n\n\t\tthis.updateColorData();\n\t}\n\n\tconstructor(animator:ParticleAnimator, particleColorNode:ParticleColorNode)\n\t{\n\t\tsuper(animator, particleColorNode);\n\n\t\tthis._particleColorNode = particleColorNode;\n\t\tthis._usesMultiplier = this._particleColorNode._iUsesMultiplier;\n\t\tthis._usesOffset = this._particleColorNode._iUsesOffset;\n\t\tthis._usesCycle = this._particleColorNode._iUsesCycle;\n\t\tthis._usesPhase = this._particleColorNode._iUsesPhase;\n\t\tthis._startColor = this._particleColorNode._iStartColor;\n\t\tthis._endColor = this._particleColorNode._iEndColor;\n\t\tthis._cycleDuration = this._particleColorNode._iCycleDuration;\n\t\tthis._cyclePhase = this._particleColorNode._iCyclePhase;\n\n\t\tthis.updateColorData();\n\t}\n\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tif (animationRegisterCache.needFragmentAnimation) {\n\t\t\tvar dataOffset:number /*uint*/ = this._particleColorNode._iDataOffset;\n\t\t\tif (this._usesCycle)\n\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.CYCLE_INDEX), this._cycleData.x, this._cycleData.y, this._cycleData.z, this._cycleData.w);\n\n\t\t\tif (this._usesMultiplier) {\n\t\t\t\tif (this._particleColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) {\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\t\t\tdataOffset += 4;\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\t\t\tdataOffset += 4;\n\t\t\t\t} else {\n\t\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_MULTIPLIER_INDEX), this._startMultiplierData.x, this._startMultiplierData.y, this._startMultiplierData.z, this._startMultiplierData.w);\n\t\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_MULTIPLIER_INDEX), this._deltaMultiplierData.x, this._deltaMultiplierData.y, this._deltaMultiplierData.z, this._deltaMultiplierData.w);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this._usesOffset) {\n\t\t\t\tif (this._particleColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) {\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\t\t\tdataOffset += 4;\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\t\t\tdataOffset += 4;\n\t\t\t\t} else {\n\t\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_OFFSET_INDEX), this._startOffsetData.x, this._startOffsetData.y, this._startOffsetData.z, this._startOffsetData.w);\n\t\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_OFFSET_INDEX), this._deltaOffsetData.x, this._deltaOffsetData.y, this._deltaOffsetData.z, this._deltaOffsetData.w);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate updateColorData()\n\t{\n\t\tif (this._usesCycle) {\n\t\t\tif (this._cycleDuration <= 0)\n\t\t\t\tthrow(new Error(\"the cycle duration must be greater than zero\"));\n\t\t\tthis._cycleData = new Vector3D(Math.PI*2/this._cycleDuration, this._cyclePhase*Math.PI/180, 0, 0);\n\t\t}\n\t\tif (this._particleColorNode.mode == ParticlePropertiesMode.GLOBAL) {\n\t\t\tif (this._usesCycle) {\n\t\t\t\tif (this._usesMultiplier) {\n\t\t\t\t\tthis._startMultiplierData = new Vector3D((this._startColor.redMultiplier + this._endColor.redMultiplier)/2, (this._startColor.greenMultiplier + this._endColor.greenMultiplier)/2, (this._startColor.blueMultiplier + this._endColor.blueMultiplier)/2, (this._startColor.alphaMultiplier + this._endColor.alphaMultiplier)/2);\n\t\t\t\t\tthis._deltaMultiplierData = new Vector3D((this._endColor.redMultiplier - this._startColor.redMultiplier)/2, (this._endColor.greenMultiplier - this._startColor.greenMultiplier)/2, (this._endColor.blueMultiplier - this._startColor.blueMultiplier)/2, (this._endColor.alphaMultiplier - this._startColor.alphaMultiplier)/2);\n\t\t\t\t}\n\n\t\t\t\tif (this._usesOffset) {\n\t\t\t\t\tthis._startOffsetData = new Vector3D((this._startColor.redOffset + this._endColor.redOffset)/(255*2), (this._startColor.greenOffset + this._endColor.greenOffset)/(255*2), (this._startColor.blueOffset + this._endColor.blueOffset)/(255*2), (this._startColor.alphaOffset + this._endColor.alphaOffset)/(255*2));\n\t\t\t\t\tthis._deltaOffsetData = new Vector3D((this._endColor.redOffset - this._startColor.redOffset)/(255*2), (this._endColor.greenOffset - this._startColor.greenOffset)/(255*2), (this._endColor.blueOffset - this._startColor.blueOffset)/(255*2), (this._endColor.alphaOffset - this._startColor.alphaOffset)/(255*2));\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (this._usesMultiplier) {\n\t\t\t\t\tthis._startMultiplierData = new Vector3D(this._startColor.redMultiplier, this._startColor.greenMultiplier, this._startColor.blueMultiplier, this._startColor.alphaMultiplier);\n\t\t\t\t\tthis._deltaMultiplierData = new Vector3D((this._endColor.redMultiplier - this._startColor.redMultiplier), (this._endColor.greenMultiplier - this._startColor.greenMultiplier), (this._endColor.blueMultiplier - this._startColor.blueMultiplier), (this._endColor.alphaMultiplier - this._startColor.alphaMultiplier));\n\t\t\t\t}\n\n\t\t\t\tif (this._usesOffset) {\n\t\t\t\t\tthis._startOffsetData = new Vector3D(this._startColor.redOffset/255, this._startColor.greenOffset/255, this._startColor.blueOffset/255, this._startColor.alphaOffset/255);\n\t\t\t\t\tthis._deltaOffsetData = new Vector3D((this._endColor.redOffset - this._startColor.redOffset)/255, (this._endColor.greenOffset - this._startColor.greenOffset)/255, (this._endColor.blueOffset - this._startColor.blueOffset )/255, (this._endColor.alphaOffset - this._startColor.alphaOffset)/255);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport = ParticleColorState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleColorState.ts b/lib/animators/states/ParticleColorState.ts new file mode 100644 index 000000000..6e9fc2110 --- /dev/null +++ b/lib/animators/states/ParticleColorState.ts @@ -0,0 +1,194 @@ +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleColorNode = require("awayjs-renderergl/lib/animators/nodes/ParticleColorNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + * @author ... + */ +class ParticleColorState extends ParticleStateBase +{ + /** @private */ + public static START_MULTIPLIER_INDEX:number /*uint*/ = 0; + + /** @private */ + public static DELTA_MULTIPLIER_INDEX:number /*uint*/ = 1; + + /** @private */ + public static START_OFFSET_INDEX:number /*uint*/ = 2; + + /** @private */ + public static DELTA_OFFSET_INDEX:number /*uint*/ = 3; + + /** @private */ + public static CYCLE_INDEX:number /*uint*/ = 4; + + private _particleColorNode:ParticleColorNode; + private _usesMultiplier:boolean; + private _usesOffset:boolean; + private _usesCycle:boolean; + private _usesPhase:boolean; + private _startColor:ColorTransform; + private _endColor:ColorTransform; + private _cycleDuration:number; + private _cyclePhase:number; + private _cycleData:Vector3D; + private _startMultiplierData:Vector3D; + private _deltaMultiplierData:Vector3D; + private _startOffsetData:Vector3D; + private _deltaOffsetData:Vector3D; + + /** + * Defines the start color transform of the state, when in global mode. + */ + public get startColor():ColorTransform + { + return this._startColor; + } + + public set startColor(value:ColorTransform) + { + this._startColor = value; + + this.updateColorData(); + } + + /** + * Defines the end color transform of the state, when in global mode. + */ + public get endColor():ColorTransform + { + return this._endColor; + } + + public set endColor(value:ColorTransform) + { + this._endColor = value; + + this.updateColorData(); + } + + /** + * Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + */ + public get cycleDuration():number + { + return this._cycleDuration; + } + + public set cycleDuration(value:number) + { + this._cycleDuration = value; + + this.updateColorData(); + } + + /** + * Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + public get cyclePhase():number + { + return this._cyclePhase; + } + + public set cyclePhase(value:number) + { + this._cyclePhase = value; + + this.updateColorData(); + } + + constructor(animator:ParticleAnimator, particleColorNode:ParticleColorNode) + { + super(animator, particleColorNode); + + this._particleColorNode = particleColorNode; + this._usesMultiplier = this._particleColorNode._iUsesMultiplier; + this._usesOffset = this._particleColorNode._iUsesOffset; + this._usesCycle = this._particleColorNode._iUsesCycle; + this._usesPhase = this._particleColorNode._iUsesPhase; + this._startColor = this._particleColorNode._iStartColor; + this._endColor = this._particleColorNode._iEndColor; + this._cycleDuration = this._particleColorNode._iCycleDuration; + this._cyclePhase = this._particleColorNode._iCyclePhase; + + this.updateColorData(); + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (animationRegisterCache.needFragmentAnimation) { + var dataOffset:number /*uint*/ = this._particleColorNode._iDataOffset; + if (this._usesCycle) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.CYCLE_INDEX), this._cycleData.x, this._cycleData.y, this._cycleData.z, this._cycleData.w); + + if (this._usesMultiplier) { + if (this._particleColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + } else { + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_MULTIPLIER_INDEX), this._startMultiplierData.x, this._startMultiplierData.y, this._startMultiplierData.z, this._startMultiplierData.w); + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_MULTIPLIER_INDEX), this._deltaMultiplierData.x, this._deltaMultiplierData.y, this._deltaMultiplierData.z, this._deltaMultiplierData.w); + } + } + if (this._usesOffset) { + if (this._particleColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + } else { + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.START_OFFSET_INDEX), this._startOffsetData.x, this._startOffsetData.y, this._startOffsetData.z, this._startOffsetData.w); + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleColorState.DELTA_OFFSET_INDEX), this._deltaOffsetData.x, this._deltaOffsetData.y, this._deltaOffsetData.z, this._deltaOffsetData.w); + } + } + } + } + + private updateColorData() + { + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw(new Error("the cycle duration must be greater than zero")); + this._cycleData = new Vector3D(Math.PI*2/this._cycleDuration, this._cyclePhase*Math.PI/180, 0, 0); + } + if (this._particleColorNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._usesCycle) { + if (this._usesMultiplier) { + this._startMultiplierData = new Vector3D((this._startColor.redMultiplier + this._endColor.redMultiplier)/2, (this._startColor.greenMultiplier + this._endColor.greenMultiplier)/2, (this._startColor.blueMultiplier + this._endColor.blueMultiplier)/2, (this._startColor.alphaMultiplier + this._endColor.alphaMultiplier)/2); + this._deltaMultiplierData = new Vector3D((this._endColor.redMultiplier - this._startColor.redMultiplier)/2, (this._endColor.greenMultiplier - this._startColor.greenMultiplier)/2, (this._endColor.blueMultiplier - this._startColor.blueMultiplier)/2, (this._endColor.alphaMultiplier - this._startColor.alphaMultiplier)/2); + } + + if (this._usesOffset) { + this._startOffsetData = new Vector3D((this._startColor.redOffset + this._endColor.redOffset)/(255*2), (this._startColor.greenOffset + this._endColor.greenOffset)/(255*2), (this._startColor.blueOffset + this._endColor.blueOffset)/(255*2), (this._startColor.alphaOffset + this._endColor.alphaOffset)/(255*2)); + this._deltaOffsetData = new Vector3D((this._endColor.redOffset - this._startColor.redOffset)/(255*2), (this._endColor.greenOffset - this._startColor.greenOffset)/(255*2), (this._endColor.blueOffset - this._startColor.blueOffset)/(255*2), (this._endColor.alphaOffset - this._startColor.alphaOffset)/(255*2)); + } + } else { + if (this._usesMultiplier) { + this._startMultiplierData = new Vector3D(this._startColor.redMultiplier, this._startColor.greenMultiplier, this._startColor.blueMultiplier, this._startColor.alphaMultiplier); + this._deltaMultiplierData = new Vector3D((this._endColor.redMultiplier - this._startColor.redMultiplier), (this._endColor.greenMultiplier - this._startColor.greenMultiplier), (this._endColor.blueMultiplier - this._startColor.blueMultiplier), (this._endColor.alphaMultiplier - this._startColor.alphaMultiplier)); + } + + if (this._usesOffset) { + this._startOffsetData = new Vector3D(this._startColor.redOffset/255, this._startColor.greenOffset/255, this._startColor.blueOffset/255, this._startColor.alphaOffset/255); + this._deltaOffsetData = new Vector3D((this._endColor.redOffset - this._startColor.redOffset)/255, (this._endColor.greenOffset - this._startColor.greenOffset)/255, (this._endColor.blueOffset - this._startColor.blueOffset )/255, (this._endColor.alphaOffset - this._startColor.alphaOffset)/255); + } + } + } + } +} + +export = ParticleColorState; \ No newline at end of file diff --git a/lib/animators/states/ParticleFollowState.js b/lib/animators/states/ParticleFollowState.js new file mode 100755 index 000000000..239e227f8 --- /dev/null +++ b/lib/animators/states/ParticleFollowState.js @@ -0,0 +1,219 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var MathConsts = require("awayjs-core/lib/core/geom/MathConsts"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleFollowState = (function (_super) { + __extends(ParticleFollowState, _super); + function ParticleFollowState(animator, particleFollowNode) { + _super.call(this, animator, particleFollowNode, true); + this._targetPos = new Vector3D(); + this._targetEuler = new Vector3D(); + //temporary vector3D for calculation + this._temp = new Vector3D(); + this._particleFollowNode = particleFollowNode; + this._smooth = particleFollowNode._iSmooth; + } + Object.defineProperty(ParticleFollowState.prototype, "followTarget", { + get: function () { + return this._followTarget; + }, + set: function (value) { + this._followTarget = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleFollowState.prototype, "smooth", { + get: function () { + return this._smooth; + }, + set: function (value) { + this._smooth = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleFollowState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (this._followTarget) { + if (this._particleFollowNode._iUsesPosition) { + this._targetPos.x = this._followTarget.transform.position.x / renderable.sourceEntity.scaleX; + this._targetPos.y = this._followTarget.transform.position.y / renderable.sourceEntity.scaleY; + this._targetPos.z = this._followTarget.transform.position.z / renderable.sourceEntity.scaleZ; + } + if (this._particleFollowNode._iUsesRotation) { + this._targetEuler.x = this._followTarget.rotationX; + this._targetEuler.y = this._followTarget.rotationY; + this._targetEuler.z = this._followTarget.rotationZ; + this._targetEuler.scaleBy(MathConsts.DEGREES_TO_RADIANS); + } + } + //initialization + if (!this._prePos) + this._prePos = this._targetPos.clone(); + if (!this._preEuler) + this._preEuler = this._targetEuler.clone(); + var currentTime = this._pTime / 1000; + var previousTime = animationSubGeometry.previousTime; + var deltaTime = currentTime - previousTime; + var needProcess = previousTime != currentTime; + if (this._particleFollowNode._iUsesPosition && this._particleFollowNode._iUsesRotation) { + if (needProcess) + this.processPositionAndRotation(currentTime, deltaTime, animationSubGeometry); + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_POSITION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_ROTATION_INDEX), this._particleFollowNode._iDataOffset + 3, stage, ContextGLVertexBufferFormat.FLOAT_3); + } + else if (this._particleFollowNode._iUsesPosition) { + if (needProcess) + this.processPosition(currentTime, deltaTime, animationSubGeometry); + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_POSITION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } + else if (this._particleFollowNode._iUsesRotation) { + if (needProcess) + this.precessRotation(currentTime, deltaTime, animationSubGeometry); + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_ROTATION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } + this._prePos.copyFrom(this._targetPos); + this._targetEuler.copyFrom(this._targetEuler); + animationSubGeometry.previousTime = currentTime; + }; + ParticleFollowState.prototype.processPosition = function (currentTime, deltaTime, animationSubGeometry) { + var data = animationSubGeometry.animationParticles; + var vertexData = animationSubGeometry.vertexData; + var changed = false; + var len = data.length; + var interpolatedPos; + var posVelocity; + if (this._smooth) { + posVelocity = this._prePos.subtract(this._targetPos); + posVelocity.scaleBy(1 / deltaTime); + } + else + interpolatedPos = this._targetPos; + for (var i = 0; i < len; i++) { + var k = (currentTime - data[i].startTime) / data[i].totalTime; + var t = (k - Math.floor(k)) * data[i].totalTime; + if (t - deltaTime <= 0) { + var inc = data[i].startVertexIndex * animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset; + if (this._smooth) { + this._temp.copyFrom(posVelocity); + this._temp.scaleBy(t); + interpolatedPos = this._targetPos.add(this._temp); + } + if (vertexData[inc] != interpolatedPos.x || vertexData[inc + 1] != interpolatedPos.y || vertexData[inc + 2] != interpolatedPos.z) { + changed = true; + for (var j = 0; j < data[i].numVertices; j++) { + vertexData[inc++] = interpolatedPos.x; + vertexData[inc++] = interpolatedPos.y; + vertexData[inc++] = interpolatedPos.z; + } + } + } + } + if (changed) + animationSubGeometry.invalidateBuffer(); + }; + ParticleFollowState.prototype.precessRotation = function (currentTime, deltaTime, animationSubGeometry) { + var data = animationSubGeometry.animationParticles; + var vertexData = animationSubGeometry.vertexData; + var changed = false; + var len = data.length; + var interpolatedRotation; + var rotationVelocity; + if (this._smooth) { + rotationVelocity = this._preEuler.subtract(this._targetEuler); + rotationVelocity.scaleBy(1 / deltaTime); + } + else + interpolatedRotation = this._targetEuler; + for (var i = 0; i < len; i++) { + var k = (currentTime - data[i].startTime) / data[i].totalTime; + var t = (k - Math.floor(k)) * data[i].totalTime; + if (t - deltaTime <= 0) { + var inc = data[i].startVertexIndex * animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset; + if (this._smooth) { + this._temp.copyFrom(rotationVelocity); + this._temp.scaleBy(t); + interpolatedRotation = this._targetEuler.add(this._temp); + } + if (vertexData[inc] != interpolatedRotation.x || vertexData[inc + 1] != interpolatedRotation.y || vertexData[inc + 2] != interpolatedRotation.z) { + changed = true; + for (var j = 0; j < data[i].numVertices; j++) { + vertexData[inc++] = interpolatedRotation.x; + vertexData[inc++] = interpolatedRotation.y; + vertexData[inc++] = interpolatedRotation.z; + } + } + } + } + if (changed) + animationSubGeometry.invalidateBuffer(); + }; + ParticleFollowState.prototype.processPositionAndRotation = function (currentTime, deltaTime, animationSubGeometry) { + var data = animationSubGeometry.animationParticles; + var vertexData = animationSubGeometry.vertexData; + var changed = false; + var len = data.length; + var interpolatedPos; + var interpolatedRotation; + var posVelocity; + var rotationVelocity; + if (this._smooth) { + posVelocity = this._prePos.subtract(this._targetPos); + posVelocity.scaleBy(1 / deltaTime); + rotationVelocity = this._preEuler.subtract(this._targetEuler); + rotationVelocity.scaleBy(1 / deltaTime); + } + else { + interpolatedPos = this._targetPos; + interpolatedRotation = this._targetEuler; + } + for (var i = 0; i < len; i++) { + var k = (currentTime - data[i].startTime) / data[i].totalTime; + var t = (k - Math.floor(k)) * data[i].totalTime; + if (t - deltaTime <= 0) { + var inc = data[i].startVertexIndex * animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset; + if (this._smooth) { + this._temp.copyFrom(posVelocity); + this._temp.scaleBy(t); + interpolatedPos = this._targetPos.add(this._temp); + this._temp.copyFrom(rotationVelocity); + this._temp.scaleBy(t); + interpolatedRotation = this._targetEuler.add(this._temp); + } + if (vertexData[inc] != interpolatedPos.x || vertexData[inc + 1] != interpolatedPos.y || vertexData[inc + 2] != interpolatedPos.z || vertexData[inc + 3] != interpolatedRotation.x || vertexData[inc + 4] != interpolatedRotation.y || vertexData[inc + 5] != interpolatedRotation.z) { + changed = true; + for (var j = 0; j < data[i].numVertices; j++) { + vertexData[inc++] = interpolatedPos.x; + vertexData[inc++] = interpolatedPos.y; + vertexData[inc++] = interpolatedPos.z; + vertexData[inc++] = interpolatedRotation.x; + vertexData[inc++] = interpolatedRotation.y; + vertexData[inc++] = interpolatedRotation.z; + } + } + } + } + if (changed) + animationSubGeometry.invalidateBuffer(); + }; + /** @private */ + ParticleFollowState.FOLLOW_POSITION_INDEX = 0; + /** @private */ + ParticleFollowState.FOLLOW_ROTATION_INDEX = 1; + return ParticleFollowState; +})(ParticleStateBase); +module.exports = ParticleFollowState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlefollowstate.ts"],"names":["ParticleFollowState","ParticleFollowState.constructor","ParticleFollowState.followTarget","ParticleFollowState.smooth","ParticleFollowState.setRenderState","ParticleFollowState.processPosition","ParticleFollowState.precessRotation","ParticleFollowState.processPositionAndRotation"],"mappings":";;;;;;AACA,IAAO,UAAU,WAAgB,sCAAsC,CAAC,CAAC;AACzE,IAAO,QAAQ,WAAiB,oCAAoC,CAAC,CAAC;AAMtE,IAAO,2BAA2B,WAAY,6DAA6D,CAAC,CAAC;AAM7G,IAAO,iBAAiB,WAAc,0DAA0D,CAAC,CAAC;AAElG,AAGA;;GADG;IACG,mBAAmB;IAASA,UAA5BA,mBAAmBA,UAA0BA;IAoBlDA,SApBKA,mBAAmBA,CAoBZA,QAAyBA,EAAEA,kBAAqCA;QAE3EC,kBAAMA,QAAQA,EAAEA,kBAAkBA,EAAEA,IAAIA,CAACA,CAACA;QAXnCA,eAAUA,GAAYA,IAAIA,QAAQA,EAAEA,CAACA;QACrCA,iBAAYA,GAAYA,IAAIA,QAAQA,EAAEA,CAACA;QAK/CA,oCAAoCA;QAC5BA,UAAKA,GAAYA,IAAIA,QAAQA,EAAEA,CAACA;QAMvCA,IAAIA,CAACA,mBAAmBA,GAAGA,kBAAkBA,CAACA;QAC9CA,IAAIA,CAACA,OAAOA,GAAGA,kBAAkBA,CAACA,QAAQA,CAACA;IAC5CA,CAACA;IAEDD,sBAAWA,6CAAYA;aAAvBA;YAECE,MAAMA,CAACA,IAAIA,CAACA,aAAaA,CAACA;QAC3BA,CAACA;aAEDF,UAAwBA,KAAmBA;YAE1CE,IAAIA,CAACA,aAAaA,GAAGA,KAAKA,CAACA;QAC5BA,CAACA;;;OALAF;IAODA,sBAAWA,uCAAMA;aAAjBA;YAECG,MAAMA,CAACA,IAAIA,CAACA,OAAOA,CAACA;QACrBA,CAACA;aAEDH,UAAkBA,KAAaA;YAE9BG,IAAIA,CAACA,OAAOA,GAAGA,KAAKA,CAACA;QACtBA,CAACA;;;OALAH;IAODA;;OAEGA;IACIA,4CAAcA,GAArBA,UAAsBA,KAAWA,EAAEA,UAAyBA,EAAEA,oBAAyCA,EAAEA,sBAA6CA,EAAEA,MAAaA;QAEpKI,EAAEA,CAACA,CAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA;YACxBA,EAAEA,CAACA,CAACA,IAAIA,CAACA,mBAAmBA,CAACA,cAAcA,CAACA,CAACA,CAACA;gBAC7CA,IAAIA,CAACA,UAAUA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,SAASA,CAACA,QAAQA,CAACA,CAACA,GAACA,UAAUA,CAACA,YAAYA,CAACA,MAAMA,CAACA;gBAC3FA,IAAIA,CAACA,UAAUA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,SAASA,CAACA,QAAQA,CAACA,CAACA,GAACA,UAAUA,CAACA,YAAYA,CAACA,MAAMA,CAACA;gBAC3FA,IAAIA,CAACA,UAAUA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,SAASA,CAACA,QAAQA,CAACA,CAACA,GAACA,UAAUA,CAACA,YAAYA,CAACA,MAAMA,CAACA;YAC5FA,CAACA;YACDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,mBAAmBA,CAACA,cAAcA,CAACA,CAACA,CAACA;gBAC7CA,IAAIA,CAACA,YAAYA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,SAASA,CAACA;gBACnDA,IAAIA,CAACA,YAAYA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,SAASA,CAACA;gBACnDA,IAAIA,CAACA,YAAYA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,SAASA,CAACA;gBACnDA,IAAIA,CAACA,YAAYA,CAACA,OAAOA,CAACA,UAAUA,CAACA,kBAAkBA,CAACA,CAACA;YAC1DA,CAACA;QACFA,CAACA;QACDA,AACAA,gBADgBA;QAChBA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,OAAOA,CAACA;YACjBA,IAAIA,CAACA,OAAOA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,KAAKA,EAAEA,CAACA;QACxCA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,SAASA,CAACA;YACnBA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,CAACA,YAAYA,CAACA,KAAKA,EAAEA,CAACA;QAE5CA,IAAIA,WAAWA,GAAUA,IAAIA,CAACA,MAAMA,GAACA,IAAIA,CAACA;QAC1CA,IAAIA,YAAYA,GAAUA,oBAAoBA,CAACA,YAAYA,CAACA;QAC5DA,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CA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;YAC9CA,IAAIA,CAACA,GAAUA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,CAACA,CAACA,CAACA,SAASA,CAACA,GAACA,IAAIA,CAACA,CAACA,CAACA,CAACA,SAASA,CAACA;YACnEA,IAAIA,CAACA,GAAUA,CAACA,CAACA,GAAGA,IAAIA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,GAACA,IAAIA,CAACA,CAACA,CAACA,CAACA,SAASA,CAACA;YACrDA,EAAEA,CAACA,CAACA,CAACA,GAAGA,SAASA,IAAIA,CAACA,CAACA,CAACA,CAACA;gBACxBA,IAAIA,GAAGA,GAAkBA,IAAIA,CAACA,CAACA,CAACA,CAACA,gBAAgBA,GAACA,oBAAoBA,CAACA,mBAAmBA,GAAGA,IAAIA,CAACA,mBAAmBA,CAACA,YAAYA,CAACA;gBAEnIA,EAAEA,CAACA,CAACA,IAAIA,CAACA,OAAOA,CAACA,CAACA,CAACA;oBAClBA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,WAAWA,CAACA,CAACA;oBACjCA,IAAIA,CAACA,KAAKA,CAACA,OAAOA,CAACA,CAACA,CAACA,CAACA;oBACtBA,eAAeA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,GAAGA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;gBACnDA,CAACA;gBAEDA,EAAEA,CAACA,CAACA,UAAUA,CAACA,GAAGA,CAACA,IAAIA,eAAeA,CAACA,CAACA,IAAIA,UAAUA,CAACA,GAAGA,GAAGA,CAACA,CAACA,IAAIA,eAAeA,CAACA,CAACA,IAAIA,UAAUA,CAACA,GAAGA,GAAGA,CAACA,CAACA,IAAIA,eAAeA,CAACA,CAACA,CAACA,CAACA,CAACA;oBAClIA,OAAOA,GAAGA,IAAIA,CAACA;oBACfA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,CAACA,CAACA,CAACA,WAAWA,EAA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AACA,CAACA,CAACA,CAACA,SAASA,CAACA,GAACA,IAAIA,CAACA,CAACA,CAACA,CAACA,SAASA,CAACA;YACnEA,IAAIA,CAACA,GAAUA,CAACA,CAACA,GAAGA,IAAIA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,GAACA,IAAIA,CAACA,CAACA,CAACA,CAACA,SAASA,CAACA;YACrDA,EAAEA,CAACA,CAACA,CAACA,GAAGA,SAASA,IAAIA,CAACA,CAACA,CAACA,CAACA;gBACxBA,IAAIA,GAAGA,GAAkBA,IAAIA,CAACA,CAACA,CAACA,CAACA,gBAAgBA,GAACA,oBAAoBA,CAACA,mBAAmBA,GAAGA,IAAIA,CAACA,mBAAmBA,CAACA,YAAYA,CAACA;gBACnIA,EAAEA,CAACA,CAACA,IAAIA,CAACA,OAAOA,CAACA,CAACA,CAACA;oBAClBA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,WAAWA,CAACA,CAACA;oBACjCA,IAAIA,CAACA,KAAKA,CAACA,OAAOA,CAACA,CAACA,CAACA,CAACA;oBACtBA,eAAeA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,GAAGA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;oBAElDA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,gBAAgBA,CAACA,CAACA;oBACtCA,IAAIA,CAACA,KAAKA,CAACA,OAAOA,CAACA,CAACA,CAACA,CAACA;oBACtBA,oBAAoBA,GAAGA,IAAIA,CAACA,YAAYA,CAACA,GAAGA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;gBAC1DA,CAACA;gBAEDA,EAAEA,CAACA,CAACA,UAAUA,CAACA,GAAGA,CAACA,IAAIA,eAAeA,CAACA,CAACA,IAAIA,UAAUA,CAACA,GAAGA,GAAGA,CAACA,CAACA,IAAIA,eAAeA,CAACA,CAACA,IAAIA,UAAUA,CAACA,GAAGA,GAAGA,CAACA,CAACA,IAAIA,eAAeA,CAACA,CAACA,IAAIA,UAAUA,CAACA,GAAGA,GAAGA,CAACA,CAACA,IAAIA,oBAAoBA,CAACA,CAACA,IAAIA,UAAUA,CAACA,GAAGA,GAAGA,CAACA,CAACA,IAAIA,oBAAoBA,CAACA,CAACA,IAAIA,UAAUA,CAACA,GAAGA,GAAGA,CAACA,CAACA,IAAIA,oBAAoBA,CAACA,CAACA,CAACA,CAACA,CAACA;oBACrRA,OAAOA,GAAGA,IAAIA,CAACA;oBACfA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,CAACA,CAACA,CAACA,WAAWA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;wBAC9DA,UAAUA,CAACA,GAAGA,EAAEA,CAACA,GAAGA,eAAeA,CAACA,CAACA,CAACA;wBACtCA,UAAUA,CAACA,GAAGA,EAAEA,CAACA,GAAGA,eAAeA,CAACA,CAACA,CAACA;wBACtCA,UAAUA,CAACA,GAAGA,EAAEA,CAACA,GAAGA,eAAeA,CAACA,CAACA,CAACA;wBACtCA,UAAUA,CAACA,GAAGA,EAAEA,CAACA,GAAGA,oBAAoBA,CAACA,CAACA,CAACA;wBAC3CA,UAAUA,CAACA,GAAGA,EAAEA,CAACA,GAAGA,oBAAoBA,CAACA,CAACA,CAACA;wBAC3CA,UAAUA,CAACA,GAAGA,EAAEA,CAACA,GAAGA,oBAAoBA,CAACA,CAACA,CAACA;oBAC5CA,CAACA;gBACFA,CAACA;YACFA,CAACA;QACFA,CAACA;QACDA,EAAEA,CAACA,CAACA,OAAOA,CAACA;YACXA,oBAAoBA,CAACA,gBAAgBA,EAAEA,CAACA;IAC1CA,CAACA;IA7ODP,eAAeA;IACDA,yCAAqBA,GAAmBA,CAACA,CAACA;IAExDA,eAAeA;IACDA,yCAAqBA,GAAmBA,CAACA,CAACA;IA2OzDA,0BAACA;AAADA,CAjPA,AAiPCA,EAjPiC,iBAAiB,EAiPlD;AAED,AAA6B,iBAApB,mBAAmB,CAAC","file":"animators/states/ParticleFollowState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObject\t\t\t\t\t= require(\"awayjs-core/lib/core/base/DisplayObject\");\nimport MathConsts\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/MathConsts\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticleAnimationData\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleAnimationData\");\nimport ParticleFollowNode\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleFollowNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n */\nclass ParticleFollowState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static FOLLOW_POSITION_INDEX:number /*uint*/ = 0;\n\n\t/** @private */\n\tpublic static FOLLOW_ROTATION_INDEX:number /*uint*/ = 1;\n\n\tprivate _particleFollowNode:ParticleFollowNode;\n\tprivate _followTarget:DisplayObject;\n\n\tprivate _targetPos:Vector3D = new Vector3D();\n\tprivate _targetEuler:Vector3D = new Vector3D();\n\tprivate _prePos:Vector3D;\n\tprivate _preEuler:Vector3D;\n\tprivate _smooth:boolean;\n\n\t//temporary vector3D for calculation\n\tprivate _temp:Vector3D = new Vector3D();\n\n\tconstructor(animator:ParticleAnimator, particleFollowNode:ParticleFollowNode)\n\t{\n\t\tsuper(animator, particleFollowNode, true);\n\n\t\tthis._particleFollowNode = particleFollowNode;\n\t\tthis._smooth = particleFollowNode._iSmooth;\n\t}\n\n\tpublic get followTarget():DisplayObject\n\t{\n\t\treturn this._followTarget;\n\t}\n\n\tpublic set followTarget(value:DisplayObject)\n\t{\n\t\tthis._followTarget = value;\n\t}\n\n\tpublic get smooth():boolean\n\t{\n\t\treturn this._smooth;\n\t}\n\n\tpublic set smooth(value:boolean)\n\t{\n\t\tthis._smooth = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tif (this._followTarget) {\n\t\t\tif (this._particleFollowNode._iUsesPosition) {\n\t\t\t\tthis._targetPos.x = this._followTarget.transform.position.x/renderable.sourceEntity.scaleX;\n\t\t\t\tthis._targetPos.y = this._followTarget.transform.position.y/renderable.sourceEntity.scaleY;\n\t\t\t\tthis._targetPos.z = this._followTarget.transform.position.z/renderable.sourceEntity.scaleZ;\n\t\t\t}\n\t\t\tif (this._particleFollowNode._iUsesRotation) {\n\t\t\t\tthis._targetEuler.x = this._followTarget.rotationX;\n\t\t\t\tthis._targetEuler.y = this._followTarget.rotationY;\n\t\t\t\tthis._targetEuler.z = this._followTarget.rotationZ;\n\t\t\t\tthis._targetEuler.scaleBy(MathConsts.DEGREES_TO_RADIANS);\n\t\t\t}\n\t\t}\n\t\t//initialization\n\t\tif (!this._prePos)\n\t\t\tthis._prePos = this._targetPos.clone();\n\t\tif (!this._preEuler)\n\t\t\tthis._preEuler = this._targetEuler.clone();\n\n\t\tvar currentTime:number = this._pTime/1000;\n\t\tvar previousTime:number = animationSubGeometry.previousTime;\n\t\tvar deltaTime:number = currentTime - previousTime;\n\n\t\tvar needProcess:boolean = previousTime != currentTime;\n\n\t\tif (this._particleFollowNode._iUsesPosition && this._particleFollowNode._iUsesRotation) {\n\t\t\tif (needProcess)\n\t\t\t\tthis.processPositionAndRotation(currentTime, deltaTime, animationSubGeometry);\n\n\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_POSITION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3);\n\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_ROTATION_INDEX), this._particleFollowNode._iDataOffset + 3, stage, ContextGLVertexBufferFormat.FLOAT_3);\n\t\t} else if (this._particleFollowNode._iUsesPosition) {\n\t\t\tif (needProcess)\n\t\t\t\tthis.processPosition(currentTime, deltaTime, animationSubGeometry);\n\n\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_POSITION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3);\n\t\t} else if (this._particleFollowNode._iUsesRotation) {\n\t\t\tif (needProcess)\n\t\t\t\tthis.precessRotation(currentTime, deltaTime, animationSubGeometry);\n\n\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_ROTATION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3);\n\t\t}\n\n\t\tthis._prePos.copyFrom(this._targetPos);\n\t\tthis._targetEuler.copyFrom(this._targetEuler);\n\t\tanimationSubGeometry.previousTime = currentTime;\n\t}\n\n\tprivate processPosition(currentTime:number, deltaTime:number, animationSubGeometry:AnimationSubGeometry)\n\t{\n\t\tvar data:Array<ParticleAnimationData> = animationSubGeometry.animationParticles;\n\t\tvar vertexData:Array<number> = animationSubGeometry.vertexData;\n\n\t\tvar changed:boolean = false;\n\t\tvar len:number /*uint*/ = data.length;\n\t\tvar interpolatedPos:Vector3D;\n\t\tvar posVelocity:Vector3D;\n\t\tif (this._smooth) {\n\t\t\tposVelocity = this._prePos.subtract(this._targetPos);\n\t\t\tposVelocity.scaleBy(1/deltaTime);\n\t\t} else\n\t\t\tinterpolatedPos = this._targetPos;\n\t\tfor (var i:number /*uint*/ = 0; i < len; i++) {\n\t\t\tvar k:number = (currentTime - data[i].startTime)/data[i].totalTime;\n\t\t\tvar t:number = (k - Math.floor(k))*data[i].totalTime;\n\t\t\tif (t - deltaTime <= 0) {\n\t\t\t\tvar inc:number /*int*/ = data[i].startVertexIndex*animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset;\n\n\t\t\t\tif (this._smooth) {\n\t\t\t\t\tthis._temp.copyFrom(posVelocity);\n\t\t\t\t\tthis._temp.scaleBy(t);\n\t\t\t\t\tinterpolatedPos = this._targetPos.add(this._temp);\n\t\t\t\t}\n\n\t\t\t\tif (vertexData[inc] != interpolatedPos.x || vertexData[inc + 1] != interpolatedPos.y || vertexData[inc + 2] != interpolatedPos.z) {\n\t\t\t\t\tchanged = true;\n\t\t\t\t\tfor (var j:number /*uint*/ = 0; j < data[i].numVertices; j++) {\n\t\t\t\t\t\tvertexData[inc++] = interpolatedPos.x;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedPos.y;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedPos.z;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (changed)\n\t\t\tanimationSubGeometry.invalidateBuffer();\n\n\t}\n\n\tprivate precessRotation(currentTime:number, deltaTime:number, animationSubGeometry:AnimationSubGeometry)\n\t{\n\t\tvar data:Array<ParticleAnimationData> = animationSubGeometry.animationParticles;\n\t\tvar vertexData:Array<number> = animationSubGeometry.vertexData;\n\n\t\tvar changed:boolean = false;\n\t\tvar len:number /*uint*/ = data.length;\n\n\t\tvar interpolatedRotation:Vector3D;\n\t\tvar rotationVelocity:Vector3D;\n\n\t\tif (this._smooth) {\n\t\t\trotationVelocity = this._preEuler.subtract(this._targetEuler);\n\t\t\trotationVelocity.scaleBy(1/deltaTime);\n\t\t} else\n\t\t\tinterpolatedRotation = this._targetEuler;\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; i++) {\n\t\t\tvar k:number = (currentTime - data[i].startTime)/data[i].totalTime;\n\t\t\tvar t:number = (k - Math.floor(k))*data[i].totalTime;\n\t\t\tif (t - deltaTime <= 0) {\n\t\t\t\tvar inc:number /*int*/ = data[i].startVertexIndex*animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset;\n\n\t\t\t\tif (this._smooth) {\n\t\t\t\t\tthis._temp.copyFrom(rotationVelocity);\n\t\t\t\t\tthis._temp.scaleBy(t);\n\t\t\t\t\tinterpolatedRotation = this._targetEuler.add(this._temp);\n\t\t\t\t}\n\n\t\t\t\tif (vertexData[inc] != interpolatedRotation.x || vertexData[inc + 1] != interpolatedRotation.y || vertexData[inc + 2] != interpolatedRotation.z) {\n\t\t\t\t\tchanged = true;\n\t\t\t\t\tfor (var j:number /*uint*/ = 0; j < data[i].numVertices; j++) {\n\t\t\t\t\t\tvertexData[inc++] = interpolatedRotation.x;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedRotation.y;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedRotation.z;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (changed)\n\t\t\tanimationSubGeometry.invalidateBuffer();\n\n\t}\n\n\tprivate processPositionAndRotation(currentTime:number, deltaTime:number, animationSubGeometry:AnimationSubGeometry)\n\t{\n\t\tvar data:Array<ParticleAnimationData> = animationSubGeometry.animationParticles;\n\t\tvar vertexData:Array<number> = animationSubGeometry.vertexData;\n\n\t\tvar changed:boolean = false;\n\t\tvar len:number /*uint*/ = data.length;\n\n\t\tvar interpolatedPos:Vector3D;\n\t\tvar interpolatedRotation:Vector3D;\n\n\t\tvar posVelocity:Vector3D;\n\t\tvar rotationVelocity:Vector3D;\n\t\tif (this._smooth) {\n\t\t\tposVelocity = this._prePos.subtract(this._targetPos);\n\t\t\tposVelocity.scaleBy(1/deltaTime);\n\t\t\trotationVelocity = this._preEuler.subtract(this._targetEuler);\n\t\t\trotationVelocity.scaleBy(1/deltaTime);\n\t\t} else {\n\t\t\tinterpolatedPos = this._targetPos;\n\t\t\tinterpolatedRotation = this._targetEuler;\n\t\t}\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; i++) {\n\t\t\tvar k:number = (currentTime - data[i].startTime)/data[i].totalTime;\n\t\t\tvar t:number = (k - Math.floor(k))*data[i].totalTime;\n\t\t\tif (t - deltaTime <= 0) {\n\t\t\t\tvar inc:number /*int*/ = data[i].startVertexIndex*animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset;\n\t\t\t\tif (this._smooth) {\n\t\t\t\t\tthis._temp.copyFrom(posVelocity);\n\t\t\t\t\tthis._temp.scaleBy(t);\n\t\t\t\t\tinterpolatedPos = this._targetPos.add(this._temp);\n\n\t\t\t\t\tthis._temp.copyFrom(rotationVelocity);\n\t\t\t\t\tthis._temp.scaleBy(t);\n\t\t\t\t\tinterpolatedRotation = this._targetEuler.add(this._temp);\n\t\t\t\t}\n\n\t\t\t\tif (vertexData[inc] != interpolatedPos.x || vertexData[inc + 1] != interpolatedPos.y || vertexData[inc + 2] != interpolatedPos.z || vertexData[inc + 3] != interpolatedRotation.x || vertexData[inc + 4] != interpolatedRotation.y || vertexData[inc + 5] != interpolatedRotation.z) {\n\t\t\t\t\tchanged = true;\n\t\t\t\t\tfor (var j:number /*uint*/ = 0; j < data[i].numVertices; j++) {\n\t\t\t\t\t\tvertexData[inc++] = interpolatedPos.x;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedPos.y;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedPos.z;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedRotation.x;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedRotation.y;\n\t\t\t\t\t\tvertexData[inc++] = interpolatedRotation.z;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (changed)\n\t\t\tanimationSubGeometry.invalidateBuffer();\n\t}\n\n}\n\nexport = ParticleFollowState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleFollowState.ts b/lib/animators/states/ParticleFollowState.ts new file mode 100644 index 000000000..64accfd26 --- /dev/null +++ b/lib/animators/states/ParticleFollowState.ts @@ -0,0 +1,263 @@ +import DisplayObject = require("awayjs-core/lib/core/base/DisplayObject"); +import MathConsts = require("awayjs-core/lib/core/geom/MathConsts"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticleAnimationData = require("awayjs-renderergl/lib/animators/data/ParticleAnimationData"); +import ParticleFollowNode = require("awayjs-renderergl/lib/animators/nodes/ParticleFollowNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleFollowState extends ParticleStateBase +{ + /** @private */ + public static FOLLOW_POSITION_INDEX:number /*uint*/ = 0; + + /** @private */ + public static FOLLOW_ROTATION_INDEX:number /*uint*/ = 1; + + private _particleFollowNode:ParticleFollowNode; + private _followTarget:DisplayObject; + + private _targetPos:Vector3D = new Vector3D(); + private _targetEuler:Vector3D = new Vector3D(); + private _prePos:Vector3D; + private _preEuler:Vector3D; + private _smooth:boolean; + + //temporary vector3D for calculation + private _temp:Vector3D = new Vector3D(); + + constructor(animator:ParticleAnimator, particleFollowNode:ParticleFollowNode) + { + super(animator, particleFollowNode, true); + + this._particleFollowNode = particleFollowNode; + this._smooth = particleFollowNode._iSmooth; + } + + public get followTarget():DisplayObject + { + return this._followTarget; + } + + public set followTarget(value:DisplayObject) + { + this._followTarget = value; + } + + public get smooth():boolean + { + return this._smooth; + } + + public set smooth(value:boolean) + { + this._smooth = value; + } + + /** + * @inheritDoc + */ + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (this._followTarget) { + if (this._particleFollowNode._iUsesPosition) { + this._targetPos.x = this._followTarget.transform.position.x/renderable.sourceEntity.scaleX; + this._targetPos.y = this._followTarget.transform.position.y/renderable.sourceEntity.scaleY; + this._targetPos.z = this._followTarget.transform.position.z/renderable.sourceEntity.scaleZ; + } + if (this._particleFollowNode._iUsesRotation) { + this._targetEuler.x = this._followTarget.rotationX; + this._targetEuler.y = this._followTarget.rotationY; + this._targetEuler.z = this._followTarget.rotationZ; + this._targetEuler.scaleBy(MathConsts.DEGREES_TO_RADIANS); + } + } + //initialization + if (!this._prePos) + this._prePos = this._targetPos.clone(); + if (!this._preEuler) + this._preEuler = this._targetEuler.clone(); + + var currentTime:number = this._pTime/1000; + var previousTime:number = animationSubGeometry.previousTime; + var deltaTime:number = currentTime - previousTime; + + var needProcess:boolean = previousTime != currentTime; + + if (this._particleFollowNode._iUsesPosition && this._particleFollowNode._iUsesRotation) { + if (needProcess) + this.processPositionAndRotation(currentTime, deltaTime, animationSubGeometry); + + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_POSITION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_ROTATION_INDEX), this._particleFollowNode._iDataOffset + 3, stage, ContextGLVertexBufferFormat.FLOAT_3); + } else if (this._particleFollowNode._iUsesPosition) { + if (needProcess) + this.processPosition(currentTime, deltaTime, animationSubGeometry); + + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_POSITION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } else if (this._particleFollowNode._iUsesRotation) { + if (needProcess) + this.precessRotation(currentTime, deltaTime, animationSubGeometry); + + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleFollowState.FOLLOW_ROTATION_INDEX), this._particleFollowNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } + + this._prePos.copyFrom(this._targetPos); + this._targetEuler.copyFrom(this._targetEuler); + animationSubGeometry.previousTime = currentTime; + } + + private processPosition(currentTime:number, deltaTime:number, animationSubGeometry:AnimationSubGeometry) + { + var data:Array = animationSubGeometry.animationParticles; + var vertexData:Array = animationSubGeometry.vertexData; + + var changed:boolean = false; + var len:number /*uint*/ = data.length; + var interpolatedPos:Vector3D; + var posVelocity:Vector3D; + if (this._smooth) { + posVelocity = this._prePos.subtract(this._targetPos); + posVelocity.scaleBy(1/deltaTime); + } else + interpolatedPos = this._targetPos; + for (var i:number /*uint*/ = 0; i < len; i++) { + var k:number = (currentTime - data[i].startTime)/data[i].totalTime; + var t:number = (k - Math.floor(k))*data[i].totalTime; + if (t - deltaTime <= 0) { + var inc:number /*int*/ = data[i].startVertexIndex*animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset; + + if (this._smooth) { + this._temp.copyFrom(posVelocity); + this._temp.scaleBy(t); + interpolatedPos = this._targetPos.add(this._temp); + } + + if (vertexData[inc] != interpolatedPos.x || vertexData[inc + 1] != interpolatedPos.y || vertexData[inc + 2] != interpolatedPos.z) { + changed = true; + for (var j:number /*uint*/ = 0; j < data[i].numVertices; j++) { + vertexData[inc++] = interpolatedPos.x; + vertexData[inc++] = interpolatedPos.y; + vertexData[inc++] = interpolatedPos.z; + } + } + } + } + if (changed) + animationSubGeometry.invalidateBuffer(); + + } + + private precessRotation(currentTime:number, deltaTime:number, animationSubGeometry:AnimationSubGeometry) + { + var data:Array = animationSubGeometry.animationParticles; + var vertexData:Array = animationSubGeometry.vertexData; + + var changed:boolean = false; + var len:number /*uint*/ = data.length; + + var interpolatedRotation:Vector3D; + var rotationVelocity:Vector3D; + + if (this._smooth) { + rotationVelocity = this._preEuler.subtract(this._targetEuler); + rotationVelocity.scaleBy(1/deltaTime); + } else + interpolatedRotation = this._targetEuler; + + for (var i:number /*uint*/ = 0; i < len; i++) { + var k:number = (currentTime - data[i].startTime)/data[i].totalTime; + var t:number = (k - Math.floor(k))*data[i].totalTime; + if (t - deltaTime <= 0) { + var inc:number /*int*/ = data[i].startVertexIndex*animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset; + + if (this._smooth) { + this._temp.copyFrom(rotationVelocity); + this._temp.scaleBy(t); + interpolatedRotation = this._targetEuler.add(this._temp); + } + + if (vertexData[inc] != interpolatedRotation.x || vertexData[inc + 1] != interpolatedRotation.y || vertexData[inc + 2] != interpolatedRotation.z) { + changed = true; + for (var j:number /*uint*/ = 0; j < data[i].numVertices; j++) { + vertexData[inc++] = interpolatedRotation.x; + vertexData[inc++] = interpolatedRotation.y; + vertexData[inc++] = interpolatedRotation.z; + } + } + } + } + if (changed) + animationSubGeometry.invalidateBuffer(); + + } + + private processPositionAndRotation(currentTime:number, deltaTime:number, animationSubGeometry:AnimationSubGeometry) + { + var data:Array = animationSubGeometry.animationParticles; + var vertexData:Array = animationSubGeometry.vertexData; + + var changed:boolean = false; + var len:number /*uint*/ = data.length; + + var interpolatedPos:Vector3D; + var interpolatedRotation:Vector3D; + + var posVelocity:Vector3D; + var rotationVelocity:Vector3D; + if (this._smooth) { + posVelocity = this._prePos.subtract(this._targetPos); + posVelocity.scaleBy(1/deltaTime); + rotationVelocity = this._preEuler.subtract(this._targetEuler); + rotationVelocity.scaleBy(1/deltaTime); + } else { + interpolatedPos = this._targetPos; + interpolatedRotation = this._targetEuler; + } + + for (var i:number /*uint*/ = 0; i < len; i++) { + var k:number = (currentTime - data[i].startTime)/data[i].totalTime; + var t:number = (k - Math.floor(k))*data[i].totalTime; + if (t - deltaTime <= 0) { + var inc:number /*int*/ = data[i].startVertexIndex*animationSubGeometry.totalLenOfOneVertex + this._particleFollowNode._iDataOffset; + if (this._smooth) { + this._temp.copyFrom(posVelocity); + this._temp.scaleBy(t); + interpolatedPos = this._targetPos.add(this._temp); + + this._temp.copyFrom(rotationVelocity); + this._temp.scaleBy(t); + interpolatedRotation = this._targetEuler.add(this._temp); + } + + if (vertexData[inc] != interpolatedPos.x || vertexData[inc + 1] != interpolatedPos.y || vertexData[inc + 2] != interpolatedPos.z || vertexData[inc + 3] != interpolatedRotation.x || vertexData[inc + 4] != interpolatedRotation.y || vertexData[inc + 5] != interpolatedRotation.z) { + changed = true; + for (var j:number /*uint*/ = 0; j < data[i].numVertices; j++) { + vertexData[inc++] = interpolatedPos.x; + vertexData[inc++] = interpolatedPos.y; + vertexData[inc++] = interpolatedPos.z; + vertexData[inc++] = interpolatedRotation.x; + vertexData[inc++] = interpolatedRotation.y; + vertexData[inc++] = interpolatedRotation.z; + } + } + } + } + if (changed) + animationSubGeometry.invalidateBuffer(); + } + +} + +export = ParticleFollowState; \ No newline at end of file diff --git a/lib/animators/states/ParticleInitialColorState.js b/lib/animators/states/ParticleInitialColorState.js new file mode 100755 index 000000000..ed230d146 --- /dev/null +++ b/lib/animators/states/ParticleInitialColorState.js @@ -0,0 +1,78 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** +* +*/ +var ParticleInitialColorState = (function (_super) { + __extends(ParticleInitialColorState, _super); + function ParticleInitialColorState(animator, particleInitialColorNode) { + _super.call(this, animator, particleInitialColorNode); + this._particleInitialColorNode = particleInitialColorNode; + this._usesMultiplier = particleInitialColorNode._iUsesMultiplier; + this._usesOffset = particleInitialColorNode._iUsesOffset; + this._initialColor = particleInitialColorNode._iInitialColor; + this.updateColorData(); + } + Object.defineProperty(ParticleInitialColorState.prototype, "initialColor", { + /** + * Defines the initial color transform of the state, when in global mode. + */ + get: function () { + return this._initialColor; + }, + set: function (value) { + this._initialColor = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleInitialColorState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + // TODO: not used + renderable = renderable; + camera = camera; + if (animationRegisterCache.needFragmentAnimation) { + if (this._particleInitialColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + var dataOffset = this._particleInitialColorNode._iDataOffset; + if (this._usesMultiplier) { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + } + if (this._usesOffset) + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + } + else { + if (this._usesMultiplier) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.MULTIPLIER_INDEX), this._multiplierData.x, this._multiplierData.y, this._multiplierData.z, this._multiplierData.w); + if (this._usesOffset) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.OFFSET_INDEX), this._offsetData.x, this._offsetData.y, this._offsetData.z, this._offsetData.w); + } + } + }; + ParticleInitialColorState.prototype.updateColorData = function () { + if (this._particleInitialColorNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._usesMultiplier) + this._multiplierData = new Vector3D(this._initialColor.redMultiplier, this._initialColor.greenMultiplier, this._initialColor.blueMultiplier, this._initialColor.alphaMultiplier); + if (this._usesOffset) + this._offsetData = new Vector3D(this._initialColor.redOffset / 255, this._initialColor.greenOffset / 255, this._initialColor.blueOffset / 255, this._initialColor.alphaOffset / 255); + } + }; + /** @private */ + ParticleInitialColorState.MULTIPLIER_INDEX = 0; + /** @private */ + ParticleInitialColorState.OFFSET_INDEX = 1; + return ParticleInitialColorState; +})(ParticleStateBase); +module.exports = ParticleInitialColorState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particleinitialcolorstate.ts"],"names":["ParticleInitialColorState","ParticleInitialColorState.constructor","ParticleInitialColorState.initialColor","ParticleInitialColorState.setRenderState","ParticleInitialColorState.updateColorData"],"mappings":"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","file":"animators/states/ParticleInitialColorState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ColorTransform\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/ColorTransform\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleInitialColorNode\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleInitialColorNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n*\n*/\nclass ParticleInitialColorState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static MULTIPLIER_INDEX:number /*uint*/ = 0;\n\t/** @private */\n\tpublic static OFFSET_INDEX:number /*uint*/ = 1;\n\n\tprivate _particleInitialColorNode:ParticleInitialColorNode;\n\tprivate _usesMultiplier:boolean;\n\tprivate _usesOffset:boolean;\n\tprivate _initialColor:ColorTransform;\n\tprivate _multiplierData:Vector3D;\n\tprivate _offsetData:Vector3D;\n\n\tconstructor(animator:ParticleAnimator, particleInitialColorNode:ParticleInitialColorNode)\n\t{\n\t\tsuper(animator, particleInitialColorNode);\n\n\t\tthis._particleInitialColorNode = particleInitialColorNode;\n\t\tthis._usesMultiplier = particleInitialColorNode._iUsesMultiplier;\n\t\tthis._usesOffset = particleInitialColorNode._iUsesOffset;\n\t\tthis._initialColor = particleInitialColorNode._iInitialColor;\n\n\t\tthis.updateColorData();\n\t}\n\n\t/**\n\t * Defines the initial color transform of the state, when in global mode.\n\t */\n\tpublic get initialColor():ColorTransform\n\t{\n\t\treturn this._initialColor;\n\t}\n\n\tpublic set initialColor(value:ColorTransform)\n\t{\n\t\tthis._initialColor = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\t// TODO: not used\n\t\trenderable = renderable;\n\t\tcamera = camera;\n\n\t\tif (animationRegisterCache.needFragmentAnimation) {\n\t\t\tif (this._particleInitialColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) {\n\t\t\t\tvar dataOffset:number /*uint*/ = this._particleInitialColorNode._iDataOffset;\n\t\t\t\tif (this._usesMultiplier) {\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\t\t\tdataOffset += 4;\n\t\t\t\t}\n\t\t\t\tif (this._usesOffset)\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\t} else {\n\t\t\t\tif (this._usesMultiplier)\n\t\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.MULTIPLIER_INDEX), this._multiplierData.x, this._multiplierData.y, this._multiplierData.z, this._multiplierData.w);\n\t\t\t\tif (this._usesOffset)\n\t\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.OFFSET_INDEX), this._offsetData.x, this._offsetData.y, this._offsetData.z, this._offsetData.w);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate updateColorData()\n\t{\n\t\tif (this._particleInitialColorNode.mode == ParticlePropertiesMode.GLOBAL) {\n\t\t\tif (this._usesMultiplier)\n\t\t\t\tthis._multiplierData = new Vector3D(this._initialColor.redMultiplier, this._initialColor.greenMultiplier, this._initialColor.blueMultiplier, this._initialColor.alphaMultiplier);\n\t\t\tif (this._usesOffset)\n\t\t\t\tthis._offsetData = new Vector3D(this._initialColor.redOffset/255, this._initialColor.greenOffset/255, this._initialColor.blueOffset/255, this._initialColor.alphaOffset/255);\n\t\t}\n\t}\n\n}\n\nexport = ParticleInitialColorState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleInitialColorState.ts b/lib/animators/states/ParticleInitialColorState.ts new file mode 100644 index 000000000..55964ce92 --- /dev/null +++ b/lib/animators/states/ParticleInitialColorState.ts @@ -0,0 +1,97 @@ +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleInitialColorNode = require("awayjs-renderergl/lib/animators/nodes/ParticleInitialColorNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** +* +*/ +class ParticleInitialColorState extends ParticleStateBase +{ + /** @private */ + public static MULTIPLIER_INDEX:number /*uint*/ = 0; + /** @private */ + public static OFFSET_INDEX:number /*uint*/ = 1; + + private _particleInitialColorNode:ParticleInitialColorNode; + private _usesMultiplier:boolean; + private _usesOffset:boolean; + private _initialColor:ColorTransform; + private _multiplierData:Vector3D; + private _offsetData:Vector3D; + + constructor(animator:ParticleAnimator, particleInitialColorNode:ParticleInitialColorNode) + { + super(animator, particleInitialColorNode); + + this._particleInitialColorNode = particleInitialColorNode; + this._usesMultiplier = particleInitialColorNode._iUsesMultiplier; + this._usesOffset = particleInitialColorNode._iUsesOffset; + this._initialColor = particleInitialColorNode._iInitialColor; + + this.updateColorData(); + } + + /** + * Defines the initial color transform of the state, when in global mode. + */ + public get initialColor():ColorTransform + { + return this._initialColor; + } + + public set initialColor(value:ColorTransform) + { + this._initialColor = value; + } + + /** + * @inheritDoc + */ + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + // TODO: not used + renderable = renderable; + camera = camera; + + if (animationRegisterCache.needFragmentAnimation) { + if (this._particleInitialColorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + var dataOffset:number /*uint*/ = this._particleInitialColorNode._iDataOffset; + if (this._usesMultiplier) { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.MULTIPLIER_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + dataOffset += 4; + } + if (this._usesOffset) + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.OFFSET_INDEX), dataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + } else { + if (this._usesMultiplier) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.MULTIPLIER_INDEX), this._multiplierData.x, this._multiplierData.y, this._multiplierData.z, this._multiplierData.w); + if (this._usesOffset) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleInitialColorState.OFFSET_INDEX), this._offsetData.x, this._offsetData.y, this._offsetData.z, this._offsetData.w); + } + } + } + + private updateColorData() + { + if (this._particleInitialColorNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._usesMultiplier) + this._multiplierData = new Vector3D(this._initialColor.redMultiplier, this._initialColor.greenMultiplier, this._initialColor.blueMultiplier, this._initialColor.alphaMultiplier); + if (this._usesOffset) + this._offsetData = new Vector3D(this._initialColor.redOffset/255, this._initialColor.greenOffset/255, this._initialColor.blueOffset/255, this._initialColor.alphaOffset/255); + } + } + +} + +export = ParticleInitialColorState; \ No newline at end of file diff --git a/lib/animators/states/ParticleOrbitState.js b/lib/animators/states/ParticleOrbitState.js new file mode 100755 index 000000000..2386c8702 --- /dev/null +++ b/lib/animators/states/ParticleOrbitState.js @@ -0,0 +1,124 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleOrbitState = (function (_super) { + __extends(ParticleOrbitState, _super); + function ParticleOrbitState(animator, particleOrbitNode) { + _super.call(this, animator, particleOrbitNode); + this._particleOrbitNode = particleOrbitNode; + this._usesEulers = this._particleOrbitNode._iUsesEulers; + this._usesCycle = this._particleOrbitNode._iUsesCycle; + this._usesPhase = this._particleOrbitNode._iUsesPhase; + this._eulers = this._particleOrbitNode._iEulers; + this._radius = this._particleOrbitNode._iRadius; + this._cycleDuration = this._particleOrbitNode._iCycleDuration; + this._cyclePhase = this._particleOrbitNode._iCyclePhase; + this.updateOrbitData(); + } + Object.defineProperty(ParticleOrbitState.prototype, "radius", { + /** + * Defines the radius of the orbit when in global mode. Defaults to 100. + */ + get: function () { + return this._radius; + }, + set: function (value) { + this._radius = value; + this.updateOrbitData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleOrbitState.prototype, "cycleDuration", { + /** + * Defines the duration of the orbit in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + */ + get: function () { + return this._cycleDuration; + }, + set: function (value) { + this._cycleDuration = value; + this.updateOrbitData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleOrbitState.prototype, "cyclePhase", { + /** + * Defines the phase of the orbit in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + get: function () { + return this._cyclePhase; + }, + set: function (value) { + this._cyclePhase = value; + this.updateOrbitData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleOrbitState.prototype, "eulers", { + /** + * Defines the euler rotation in degrees, applied to the orientation of the orbit when in global mode. + */ + get: function () { + return this._eulers; + }, + set: function (value) { + this._eulers = value; + this.updateOrbitData(); + }, + enumerable: true, + configurable: true + }); + ParticleOrbitState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOrbitState.ORBIT_INDEX); + if (this._particleOrbitNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + if (this._usesPhase) + animationSubGeometry.activateVertexBuffer(index, this._particleOrbitNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + else + animationSubGeometry.activateVertexBuffer(index, this._particleOrbitNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } + else + animationRegisterCache.setVertexConst(index, this._orbitData.x, this._orbitData.y, this._orbitData.z, this._orbitData.w); + if (this._usesEulers) + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOrbitState.EULERS_INDEX), this._eulersMatrix); + }; + ParticleOrbitState.prototype.updateOrbitData = function () { + if (this._usesEulers) { + this._eulersMatrix = new Matrix3D(); + this._eulersMatrix.appendRotation(this._eulers.x, Vector3D.X_AXIS); + this._eulersMatrix.appendRotation(this._eulers.y, Vector3D.Y_AXIS); + this._eulersMatrix.appendRotation(this._eulers.z, Vector3D.Z_AXIS); + } + if (this._particleOrbitNode.mode == ParticlePropertiesMode.GLOBAL) { + this._orbitData = new Vector3D(this._radius, 0, this._radius * Math.PI * 2, this._cyclePhase * Math.PI / 180); + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw (new Error("the cycle duration must be greater than zero")); + this._orbitData.y = Math.PI * 2 / this._cycleDuration; + } + else + this._orbitData.y = Math.PI * 2; + } + }; + /** @private */ + ParticleOrbitState.ORBIT_INDEX = 0; + /** @private */ + ParticleOrbitState.EULERS_INDEX = 1; + return ParticleOrbitState; +})(ParticleStateBase); +module.exports = ParticleOrbitState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particleorbitstate.ts"],"names":["ParticleOrbitState","ParticleOrbitState.constructor","ParticleOrbitState.radius","ParticleOrbitState.cycleDuration","ParticleOrbitState.cyclePhase","ParticleOrbitState.eulers","ParticleOrbitState.setRenderState","ParticleOrbitState.updateOrbitData"],"mappings":"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","file":"animators/states/ParticleOrbitState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleOrbitNode\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleOrbitNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n */\nclass ParticleOrbitState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static ORBIT_INDEX:number /*uint*/ = 0;\n\n\t/** @private */\n\tpublic static EULERS_INDEX:number /*uint*/ = 1;\n\n\tprivate _particleOrbitNode:ParticleOrbitNode;\n\tprivate _usesEulers:boolean;\n\tprivate _usesCycle:boolean;\n\tprivate _usesPhase:boolean;\n\tprivate _radius:number;\n\tprivate _cycleDuration:number;\n\tprivate _cyclePhase:number;\n\tprivate _eulers:Vector3D;\n\tprivate _orbitData:Vector3D;\n\tprivate _eulersMatrix:Matrix3D;\n\n\t/**\n\t * Defines the radius of the orbit when in global mode. Defaults to 100.\n\t */\n\tpublic get radius():number\n\t{\n\t\treturn this._radius;\n\t}\n\n\tpublic set radius(value:number)\n\t{\n\t\tthis._radius = value;\n\n\t\tthis.updateOrbitData();\n\t}\n\n\t/**\n\t * Defines the duration of the orbit in seconds, used as a period independent of particle duration when in global mode. Defaults to 1.\n\t */\n\tpublic get cycleDuration():number\n\t{\n\t\treturn this._cycleDuration;\n\t}\n\n\tpublic set cycleDuration(value:number)\n\t{\n\t\tthis._cycleDuration = value;\n\n\t\tthis.updateOrbitData();\n\t}\n\n\t/**\n\t * Defines the phase of the orbit in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0.\n\t */\n\tpublic get cyclePhase():number\n\t{\n\t\treturn this._cyclePhase;\n\t}\n\n\tpublic set cyclePhase(value:number)\n\t{\n\t\tthis._cyclePhase = value;\n\n\t\tthis.updateOrbitData();\n\t}\n\n\t/**\n\t * Defines the euler rotation in degrees, applied to the orientation of the orbit when in global mode.\n\t */\n\tpublic get eulers():Vector3D\n\t{\n\t\treturn this._eulers;\n\t}\n\n\tpublic set eulers(value:Vector3D)\n\t{\n\t\tthis._eulers = value;\n\n\t\tthis.updateOrbitData();\n\n\t}\n\n\tconstructor(animator:ParticleAnimator, particleOrbitNode:ParticleOrbitNode)\n\t{\n\t\tsuper(animator, particleOrbitNode);\n\n\t\tthis._particleOrbitNode = particleOrbitNode;\n\t\tthis._usesEulers = this._particleOrbitNode._iUsesEulers;\n\t\tthis._usesCycle = this._particleOrbitNode._iUsesCycle;\n\t\tthis._usesPhase = this._particleOrbitNode._iUsesPhase;\n\t\tthis._eulers = this._particleOrbitNode._iEulers;\n\t\tthis._radius = this._particleOrbitNode._iRadius;\n\t\tthis._cycleDuration = this._particleOrbitNode._iCycleDuration;\n\t\tthis._cyclePhase = this._particleOrbitNode._iCyclePhase;\n\t\tthis.updateOrbitData();\n\t}\n\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tvar index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOrbitState.ORBIT_INDEX);\n\n\t\tif (this._particleOrbitNode.mode == ParticlePropertiesMode.LOCAL_STATIC) {\n\t\t\tif (this._usesPhase)\n\t\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleOrbitNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\telse\n\t\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleOrbitNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3);\n\t\t} else\n\t\t\tanimationRegisterCache.setVertexConst(index, this._orbitData.x, this._orbitData.y, this._orbitData.z, this._orbitData.w);\n\n\t\tif (this._usesEulers)\n\t\t\tanimationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOrbitState.EULERS_INDEX), this._eulersMatrix);\n\t}\n\n\tprivate updateOrbitData()\n\t{\n\t\tif (this._usesEulers) {\n\t\t\tthis._eulersMatrix = new Matrix3D();\n\t\t\tthis._eulersMatrix.appendRotation(this._eulers.x, Vector3D.X_AXIS);\n\t\t\tthis._eulersMatrix.appendRotation(this._eulers.y, Vector3D.Y_AXIS);\n\t\t\tthis._eulersMatrix.appendRotation(this._eulers.z, Vector3D.Z_AXIS);\n\t\t}\n\t\tif (this._particleOrbitNode.mode == ParticlePropertiesMode.GLOBAL) {\n\t\t\tthis._orbitData = new Vector3D(this._radius, 0, this._radius*Math.PI*2, this._cyclePhase*Math.PI/180);\n\t\t\tif (this._usesCycle) {\n\t\t\t\tif (this._cycleDuration <= 0)\n\t\t\t\t\tthrow(new Error(\"the cycle duration must be greater than zero\"));\n\t\t\t\tthis._orbitData.y = Math.PI*2/this._cycleDuration;\n\t\t\t} else\n\t\t\t\tthis._orbitData.y = Math.PI*2;\n\t\t}\n\t}\n}\n\nexport = ParticleOrbitState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleOrbitState.ts b/lib/animators/states/ParticleOrbitState.ts new file mode 100644 index 000000000..2153843f0 --- /dev/null +++ b/lib/animators/states/ParticleOrbitState.ts @@ -0,0 +1,150 @@ +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleOrbitNode = require("awayjs-renderergl/lib/animators/nodes/ParticleOrbitNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleOrbitState extends ParticleStateBase +{ + /** @private */ + public static ORBIT_INDEX:number /*uint*/ = 0; + + /** @private */ + public static EULERS_INDEX:number /*uint*/ = 1; + + private _particleOrbitNode:ParticleOrbitNode; + private _usesEulers:boolean; + private _usesCycle:boolean; + private _usesPhase:boolean; + private _radius:number; + private _cycleDuration:number; + private _cyclePhase:number; + private _eulers:Vector3D; + private _orbitData:Vector3D; + private _eulersMatrix:Matrix3D; + + /** + * Defines the radius of the orbit when in global mode. Defaults to 100. + */ + public get radius():number + { + return this._radius; + } + + public set radius(value:number) + { + this._radius = value; + + this.updateOrbitData(); + } + + /** + * Defines the duration of the orbit in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + */ + public get cycleDuration():number + { + return this._cycleDuration; + } + + public set cycleDuration(value:number) + { + this._cycleDuration = value; + + this.updateOrbitData(); + } + + /** + * Defines the phase of the orbit in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + public get cyclePhase():number + { + return this._cyclePhase; + } + + public set cyclePhase(value:number) + { + this._cyclePhase = value; + + this.updateOrbitData(); + } + + /** + * Defines the euler rotation in degrees, applied to the orientation of the orbit when in global mode. + */ + public get eulers():Vector3D + { + return this._eulers; + } + + public set eulers(value:Vector3D) + { + this._eulers = value; + + this.updateOrbitData(); + + } + + constructor(animator:ParticleAnimator, particleOrbitNode:ParticleOrbitNode) + { + super(animator, particleOrbitNode); + + this._particleOrbitNode = particleOrbitNode; + this._usesEulers = this._particleOrbitNode._iUsesEulers; + this._usesCycle = this._particleOrbitNode._iUsesCycle; + this._usesPhase = this._particleOrbitNode._iUsesPhase; + this._eulers = this._particleOrbitNode._iEulers; + this._radius = this._particleOrbitNode._iRadius; + this._cycleDuration = this._particleOrbitNode._iCycleDuration; + this._cyclePhase = this._particleOrbitNode._iCyclePhase; + this.updateOrbitData(); + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOrbitState.ORBIT_INDEX); + + if (this._particleOrbitNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + if (this._usesPhase) + animationSubGeometry.activateVertexBuffer(index, this._particleOrbitNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + else + animationSubGeometry.activateVertexBuffer(index, this._particleOrbitNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } else + animationRegisterCache.setVertexConst(index, this._orbitData.x, this._orbitData.y, this._orbitData.z, this._orbitData.w); + + if (this._usesEulers) + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOrbitState.EULERS_INDEX), this._eulersMatrix); + } + + private updateOrbitData() + { + if (this._usesEulers) { + this._eulersMatrix = new Matrix3D(); + this._eulersMatrix.appendRotation(this._eulers.x, Vector3D.X_AXIS); + this._eulersMatrix.appendRotation(this._eulers.y, Vector3D.Y_AXIS); + this._eulersMatrix.appendRotation(this._eulers.z, Vector3D.Z_AXIS); + } + if (this._particleOrbitNode.mode == ParticlePropertiesMode.GLOBAL) { + this._orbitData = new Vector3D(this._radius, 0, this._radius*Math.PI*2, this._cyclePhase*Math.PI/180); + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw(new Error("the cycle duration must be greater than zero")); + this._orbitData.y = Math.PI*2/this._cycleDuration; + } else + this._orbitData.y = Math.PI*2; + } + } +} + +export = ParticleOrbitState; \ No newline at end of file diff --git a/lib/animators/states/ParticleOscillatorState.js b/lib/animators/states/ParticleOscillatorState.js new file mode 100755 index 000000000..987c0662e --- /dev/null +++ b/lib/animators/states/ParticleOscillatorState.js @@ -0,0 +1,64 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleOscillatorState = (function (_super) { + __extends(ParticleOscillatorState, _super); + function ParticleOscillatorState(animator, particleOscillatorNode) { + _super.call(this, animator, particleOscillatorNode); + this._particleOscillatorNode = particleOscillatorNode; + this._oscillator = this._particleOscillatorNode._iOscillator; + this.updateOscillatorData(); + } + Object.defineProperty(ParticleOscillatorState.prototype, "oscillator", { + /** + * Defines the default oscillator axis (x, y, z) and cycleDuration (w) of the state, used when in global mode. + */ + get: function () { + return this._oscillator; + }, + set: function (value) { + this._oscillator = value; + this.updateOscillatorData(); + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ParticleOscillatorState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOscillatorState.OSCILLATOR_INDEX); + if (this._particleOscillatorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) + animationSubGeometry.activateVertexBuffer(index, this._particleOscillatorNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + else + animationRegisterCache.setVertexConst(index, this._oscillatorData.x, this._oscillatorData.y, this._oscillatorData.z, this._oscillatorData.w); + }; + ParticleOscillatorState.prototype.updateOscillatorData = function () { + if (this._particleOscillatorNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._oscillator.w <= 0) + throw (new Error("the cycle duration must greater than zero")); + if (this._oscillatorData == null) + this._oscillatorData = new Vector3D(); + this._oscillatorData.x = this._oscillator.x; + this._oscillatorData.y = this._oscillator.y; + this._oscillatorData.z = this._oscillator.z; + this._oscillatorData.w = Math.PI * 2 / this._oscillator.w; + } + }; + /** @private */ + ParticleOscillatorState.OSCILLATOR_INDEX = 0; + return ParticleOscillatorState; +})(ParticleStateBase); +module.exports = ParticleOscillatorState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particleoscillatorstate.ts"],"names":["ParticleOscillatorState","ParticleOscillatorState.constructor","ParticleOscillatorState.oscillator","ParticleOscillatorState.setRenderState","ParticleOscillatorState.updateOscillatorData"],"mappings":"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","file":"animators/states/ParticleOscillatorState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleOscillatorNode\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleOscillatorNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n */\nclass ParticleOscillatorState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static OSCILLATOR_INDEX:number /*uint*/ = 0;\n\n\tprivate _particleOscillatorNode:ParticleOscillatorNode;\n\tprivate _oscillator:Vector3D;\n\tprivate _oscillatorData:Vector3D;\n\n\t/**\n\t * Defines the default oscillator axis (x, y, z) and cycleDuration (w) of the state, used when in global mode.\n\t */\n\tpublic get oscillator():Vector3D\n\t{\n\t\treturn this._oscillator;\n\t}\n\n\tpublic set oscillator(value:Vector3D)\n\t{\n\t\tthis._oscillator = value;\n\n\t\tthis.updateOscillatorData();\n\t}\n\n\tconstructor(animator:ParticleAnimator, particleOscillatorNode:ParticleOscillatorNode)\n\t{\n\t\tsuper(animator, particleOscillatorNode);\n\n\t\tthis._particleOscillatorNode = particleOscillatorNode;\n\t\tthis._oscillator = this._particleOscillatorNode._iOscillator;\n\n\t\tthis.updateOscillatorData();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tvar index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOscillatorState.OSCILLATOR_INDEX);\n\n\t\tif (this._particleOscillatorNode.mode == ParticlePropertiesMode.LOCAL_STATIC)\n\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleOscillatorNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\telse\n\t\t\tanimationRegisterCache.setVertexConst(index, this._oscillatorData.x, this._oscillatorData.y, this._oscillatorData.z, this._oscillatorData.w);\n\t}\n\n\tprivate updateOscillatorData()\n\t{\n\t\tif (this._particleOscillatorNode.mode == ParticlePropertiesMode.GLOBAL) {\n\t\t\tif (this._oscillator.w <= 0)\n\t\t\t\tthrow(new Error(\"the cycle duration must greater than zero\"));\n\n\t\t\tif (this._oscillatorData == null)\n\t\t\t\tthis._oscillatorData = new Vector3D();\n\n\t\t\tthis._oscillatorData.x = this._oscillator.x;\n\t\t\tthis._oscillatorData.y = this._oscillator.y;\n\t\t\tthis._oscillatorData.z = this._oscillator.z;\n\t\t\tthis._oscillatorData.w = Math.PI*2/this._oscillator.w;\n\t\t}\n\t}\n}\n\nexport = ParticleOscillatorState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleOscillatorState.ts b/lib/animators/states/ParticleOscillatorState.ts new file mode 100644 index 000000000..0ddbd5490 --- /dev/null +++ b/lib/animators/states/ParticleOscillatorState.ts @@ -0,0 +1,82 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleOscillatorNode = require("awayjs-renderergl/lib/animators/nodes/ParticleOscillatorNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleOscillatorState extends ParticleStateBase +{ + /** @private */ + public static OSCILLATOR_INDEX:number /*uint*/ = 0; + + private _particleOscillatorNode:ParticleOscillatorNode; + private _oscillator:Vector3D; + private _oscillatorData:Vector3D; + + /** + * Defines the default oscillator axis (x, y, z) and cycleDuration (w) of the state, used when in global mode. + */ + public get oscillator():Vector3D + { + return this._oscillator; + } + + public set oscillator(value:Vector3D) + { + this._oscillator = value; + + this.updateOscillatorData(); + } + + constructor(animator:ParticleAnimator, particleOscillatorNode:ParticleOscillatorNode) + { + super(animator, particleOscillatorNode); + + this._particleOscillatorNode = particleOscillatorNode; + this._oscillator = this._particleOscillatorNode._iOscillator; + + this.updateOscillatorData(); + } + + /** + * @inheritDoc + */ + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleOscillatorState.OSCILLATOR_INDEX); + + if (this._particleOscillatorNode.mode == ParticlePropertiesMode.LOCAL_STATIC) + animationSubGeometry.activateVertexBuffer(index, this._particleOscillatorNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + else + animationRegisterCache.setVertexConst(index, this._oscillatorData.x, this._oscillatorData.y, this._oscillatorData.z, this._oscillatorData.w); + } + + private updateOscillatorData() + { + if (this._particleOscillatorNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._oscillator.w <= 0) + throw(new Error("the cycle duration must greater than zero")); + + if (this._oscillatorData == null) + this._oscillatorData = new Vector3D(); + + this._oscillatorData.x = this._oscillator.x; + this._oscillatorData.y = this._oscillator.y; + this._oscillatorData.z = this._oscillator.z; + this._oscillatorData.w = Math.PI*2/this._oscillator.w; + } + } +} + +export = ParticleOscillatorState; \ No newline at end of file diff --git a/lib/animators/states/ParticlePositionState.js b/lib/animators/states/ParticlePositionState.js new file mode 100755 index 000000000..009a32b44 --- /dev/null +++ b/lib/animators/states/ParticlePositionState.js @@ -0,0 +1,62 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + * @author ... + */ +var ParticlePositionState = (function (_super) { + __extends(ParticlePositionState, _super); + function ParticlePositionState(animator, particlePositionNode) { + _super.call(this, animator, particlePositionNode); + this._particlePositionNode = particlePositionNode; + this._position = this._particlePositionNode._iPosition; + } + Object.defineProperty(ParticlePositionState.prototype, "position", { + /** + * Defines the position of the particle when in global mode. Defaults to 0,0,0. + */ + get: function () { + return this._position; + }, + set: function (value) { + this._position = value; + }, + enumerable: true, + configurable: true + }); + /** + * + */ + ParticlePositionState.prototype.getPositions = function () { + return this._pDynamicProperties; + }; + ParticlePositionState.prototype.setPositions = function (value) { + this._pDynamicProperties = value; + this._pDynamicPropertiesDirty = new Object(); + }; + /** + * @inheritDoc + */ + ParticlePositionState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (this._particlePositionNode.mode == ParticlePropertiesMode.LOCAL_DYNAMIC && !this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId]) + this._pUpdateDynamicProperties(animationSubGeometry); + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticlePositionState.POSITION_INDEX); + if (this._particlePositionNode.mode == ParticlePropertiesMode.GLOBAL) + animationRegisterCache.setVertexConst(index, this._position.x, this._position.y, this._position.z); + else + animationSubGeometry.activateVertexBuffer(index, this._particlePositionNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + }; + /** @private */ + ParticlePositionState.POSITION_INDEX = 0; + return ParticlePositionState; +})(ParticleStateBase); +module.exports = ParticlePositionState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/ParticlePositionState.ts b/lib/animators/states/ParticlePositionState.ts new file mode 100644 index 000000000..885418c9f --- /dev/null +++ b/lib/animators/states/ParticlePositionState.ts @@ -0,0 +1,80 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticlePositionNode = require("awayjs-renderergl/lib/animators/nodes/ParticlePositionNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + * @author ... + */ +class ParticlePositionState extends ParticleStateBase +{ + /** @private */ + public static POSITION_INDEX:number /*uint*/ = 0; + + private _particlePositionNode:ParticlePositionNode; + private _position:Vector3D; + + /** + * Defines the position of the particle when in global mode. Defaults to 0,0,0. + */ + public get position():Vector3D + { + return this._position; + } + + public set position(value:Vector3D) + { + this._position = value; + } + + /** + * + */ + public getPositions():Array + { + return this._pDynamicProperties; + } + + public setPositions(value:Array) + { + this._pDynamicProperties = value; + + this._pDynamicPropertiesDirty = new Object(); + } + + constructor(animator:ParticleAnimator, particlePositionNode:ParticlePositionNode) + { + super(animator, particlePositionNode); + + this._particlePositionNode = particlePositionNode; + this._position = this._particlePositionNode._iPosition; + } + + /** + * @inheritDoc + */ + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (this._particlePositionNode.mode == ParticlePropertiesMode.LOCAL_DYNAMIC && !this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId]) + this._pUpdateDynamicProperties(animationSubGeometry); + + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticlePositionState.POSITION_INDEX); + + if (this._particlePositionNode.mode == ParticlePropertiesMode.GLOBAL) + animationRegisterCache.setVertexConst(index, this._position.x, this._position.y, this._position.z); + else + animationSubGeometry.activateVertexBuffer(index, this._particlePositionNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } +} + +export = ParticlePositionState; \ No newline at end of file diff --git a/lib/animators/states/ParticleRotateToHeadingState.js b/lib/animators/states/ParticleRotateToHeadingState.js new file mode 100755 index 000000000..013d40eb3 --- /dev/null +++ b/lib/animators/states/ParticleRotateToHeadingState.js @@ -0,0 +1,31 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleRotateToHeadingState = (function (_super) { + __extends(ParticleRotateToHeadingState, _super); + function ParticleRotateToHeadingState(animator, particleNode) { + _super.call(this, animator, particleNode); + this._matrix = new Matrix3D(); + } + ParticleRotateToHeadingState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (animationRegisterCache.hasBillboard) { + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + this._matrix.append(camera.inverseSceneTransform); + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotateToHeadingState.MATRIX_INDEX), this._matrix); + } + }; + /** @private */ + ParticleRotateToHeadingState.MATRIX_INDEX = 0; + return ParticleRotateToHeadingState; +})(ParticleStateBase); +module.exports = ParticleRotateToHeadingState; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy9zdGF0ZXMvcGFydGljbGVyb3RhdGV0b2hlYWRpbmdzdGF0ZS50cyJdLCJuYW1lcyI6WyJQYXJ0aWNsZVJvdGF0ZVRvSGVhZGluZ1N0YXRlIiwiUGFydGljbGVSb3RhdGVUb0hlYWRpbmdTdGF0ZS5jb25zdHJ1Y3RvciIsIlBhcnRpY2xlUm90YXRlVG9IZWFkaW5nU3RhdGUuc2V0UmVuZGVyU3RhdGUiXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLElBQU8sUUFBUSxXQUFpQixvQ0FBb0MsQ0FBQyxDQUFDO0FBV3RFLElBQU8saUJBQWlCLFdBQWMsMERBQTBELENBQUMsQ0FBQztBQUVsRyxBQUdBOztHQURHO0lBQ0csNEJBQTRCO0lBQVNBLFVBQXJDQSw0QkFBNEJBLFVBQTBCQTtJQU8zREEsU0FQS0EsNEJBQTRCQSxDQU9yQkEsUUFBeUJBLEVBQUVBLFlBQTZCQTtRQUVuRUMsa0JBQU1BLFFBQVFBLEVBQUVBLFlBQVlBLENBQUNBLENBQUNBO1FBSnZCQSxZQUFPQSxHQUFZQSxJQUFJQSxRQUFRQSxFQUFFQSxDQUFDQTtJQUsxQ0EsQ0FBQ0E7SUFFTUQscURBQWNBLEdBQXJCQSxVQUFzQkEsS0FBV0EsRUFBRUEsVUFBeUJBLEVBQUVBLG9CQUF5Q0EsRUFBRUEsc0JBQTZDQSxFQUFFQSxNQUFhQTtRQUVwS0UsRUFBRUEsQ0FBQ0EsQ0FBQ0Esc0JBQXNCQSxDQUFDQSxZQUFZQSxDQUFDQSxDQUFDQSxDQUFDQTtZQUN6Q0EsSUFBSUEsQ0FBQ0EsT0FBT0EsQ0FBQ0EsUUFBUUEsQ0FBQ0EsVUFBVUEsQ0FBQ0EsWUFBWUEsQ0FBQ0EsY0FBY0EsQ0FBQ0EsQ0FBQ0E7WUFDOURBLElBQUlBLENBQUNBLE9BQU9BLENBQUNBLE1BQU1BLENBQUNBLE1BQU1BLENBQUNBLHFCQUFxQkEsQ0FBQ0EsQ0FBQ0E7WUFDbERBLHNCQUFzQkEsQ0FBQ0Esd0JBQXdCQSxDQUFDQSxzQkFBc0JBLENBQUNBLGdCQUFnQkEsQ0FBQ0EsSUFBSUEsQ0FBQ0EsZUFBZUEsRUFBRUEsNEJBQTRCQSxDQUFDQSxZQUFZQSxDQUFDQSxFQUFFQSxJQUFJQSxDQUFDQSxPQUFPQSxDQUFDQSxDQUFDQTtRQUN6S0EsQ0FBQ0E7SUFDRkEsQ0FBQ0E7SUFqQkRGLGVBQWVBO0lBQ0RBLHlDQUFZQSxHQUFrQkEsQ0FBQ0EsQ0FBQ0E7SUFrQi9DQSxtQ0FBQ0E7QUFBREEsQ0FyQkEsQUFxQkNBLEVBckIwQyxpQkFBaUIsRUFxQjNEO0FBRUQsQUFBc0MsaUJBQTdCLDRCQUE0QixDQUFDIiwiZmlsZSI6ImFuaW1hdG9ycy9zdGF0ZXMvUGFydGljbGVSb3RhdGVUb0hlYWRpbmdTdGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIvVXNlcnMvcm9iYmF0ZW1hbi9XZWJzdG9ybVByb2plY3RzL2F3YXlqcy1yZW5kZXJlcmdsLyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBNYXRyaXgzRFx0XHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLWNvcmUvbGliL2NvcmUvZ2VvbS9NYXRyaXgzRFwiKTtcbmltcG9ydCBDYW1lcmFcdFx0XHRcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1jb3JlL2xpYi9lbnRpdGllcy9DYW1lcmFcIik7XG5cbmltcG9ydCBBbmltYXRpb25SZWdpc3RlckNhY2hlXHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXN0YWdlZ2wvbGliL2FuaW1hdG9ycy9kYXRhL0FuaW1hdGlvblJlZ2lzdGVyQ2FjaGVcIik7XG5pbXBvcnQgU3RhZ2VcdFx0XHRcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1zdGFnZWdsL2xpYi9jb3JlL2Jhc2UvU3RhZ2VcIik7XG5pbXBvcnQgUmVuZGVyYWJsZUJhc2VcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXN0YWdlZ2wvbGliL2NvcmUvcG9vbC9SZW5kZXJhYmxlQmFzZVwiKTtcblxuaW1wb3J0IFBhcnRpY2xlQW5pbWF0b3JcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXJlbmRlcmVyZ2wvbGliL2FuaW1hdG9ycy9QYXJ0aWNsZUFuaW1hdG9yXCIpO1xuaW1wb3J0IEFuaW1hdGlvblN1Ykdlb21ldHJ5XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL2RhdGEvQW5pbWF0aW9uU3ViR2VvbWV0cnlcIik7XG5pbXBvcnQgUGFydGljbGVOb2RlQmFzZVx0XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL25vZGVzL1BhcnRpY2xlTm9kZUJhc2VcIik7XG5pbXBvcnQgUGFydGljbGVSb3RhdGVUb0hlYWRpbmdOb2RlXHRcdD0gcmVxdWlyZShcImF3YXlqcy1yZW5kZXJlcmdsL2xpYi9hbmltYXRvcnMvbm9kZXMvUGFydGljbGVSb3RhdGVUb0hlYWRpbmdOb2RlXCIpO1xuaW1wb3J0IFBhcnRpY2xlU3RhdGVCYXNlXHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL3N0YXRlcy9QYXJ0aWNsZVN0YXRlQmFzZVwiKTtcblxuLyoqXG4gKiAuLi5cbiAqL1xuY2xhc3MgUGFydGljbGVSb3RhdGVUb0hlYWRpbmdTdGF0ZSBleHRlbmRzIFBhcnRpY2xlU3RhdGVCYXNlXG57XG5cdC8qKiBAcHJpdmF0ZSAqL1xuXHRwdWJsaWMgc3RhdGljIE1BVFJJWF9JTkRFWDpudW1iZXIgLyppbnQqLyA9IDA7XG5cblx0cHJpdmF0ZSBfbWF0cml4Ok1hdHJpeDNEID0gbmV3IE1hdHJpeDNEKCk7XG5cblx0Y29uc3RydWN0b3IoYW5pbWF0b3I6UGFydGljbGVBbmltYXRvciwgcGFydGljbGVOb2RlOlBhcnRpY2xlTm9kZUJhc2UpXG5cdHtcblx0XHRzdXBlcihhbmltYXRvciwgcGFydGljbGVOb2RlKTtcblx0fVxuXG5cdHB1YmxpYyBzZXRSZW5kZXJTdGF0ZShzdGFnZTpTdGFnZSwgcmVuZGVyYWJsZTpSZW5kZXJhYmxlQmFzZSwgYW5pbWF0aW9uU3ViR2VvbWV0cnk6QW5pbWF0aW9uU3ViR2VvbWV0cnksIGFuaW1hdGlvblJlZ2lzdGVyQ2FjaGU6QW5pbWF0aW9uUmVnaXN0ZXJDYWNoZSwgY2FtZXJhOkNhbWVyYSlcblx0e1xuXHRcdGlmIChhbmltYXRpb25SZWdpc3RlckNhY2hlLmhhc0JpbGxib2FyZCkge1xuXHRcdFx0dGhpcy5fbWF0cml4LmNvcHlGcm9tKHJlbmRlcmFibGUuc291cmNlRW50aXR5LnNjZW5lVHJhbnNmb3JtKTtcblx0XHRcdHRoaXMuX21hdHJpeC5hcHBlbmQoY2FtZXJhLmludmVyc2VTY2VuZVRyYW5zZm9ybSk7XG5cdFx0XHRhbmltYXRpb25SZWdpc3RlckNhY2hlLnNldFZlcnRleENvbnN0RnJvbU1hdHJpeChhbmltYXRpb25SZWdpc3RlckNhY2hlLmdldFJlZ2lzdGVySW5kZXgodGhpcy5fcEFuaW1hdGlvbk5vZGUsIFBhcnRpY2xlUm90YXRlVG9IZWFkaW5nU3RhdGUuTUFUUklYX0lOREVYKSwgdGhpcy5fbWF0cml4KTtcblx0XHR9XG5cdH1cblxufVxuXG5leHBvcnQgPSBQYXJ0aWNsZVJvdGF0ZVRvSGVhZGluZ1N0YXRlOyJdfQ== \ No newline at end of file diff --git a/lib/animators/states/ParticleRotateToHeadingState.ts b/lib/animators/states/ParticleRotateToHeadingState.ts new file mode 100644 index 000000000..40939c73b --- /dev/null +++ b/lib/animators/states/ParticleRotateToHeadingState.ts @@ -0,0 +1,40 @@ +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import ParticleRotateToHeadingNode = require("awayjs-renderergl/lib/animators/nodes/ParticleRotateToHeadingNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleRotateToHeadingState extends ParticleStateBase +{ + /** @private */ + public static MATRIX_INDEX:number /*int*/ = 0; + + private _matrix:Matrix3D = new Matrix3D(); + + constructor(animator:ParticleAnimator, particleNode:ParticleNodeBase) + { + super(animator, particleNode); + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (animationRegisterCache.hasBillboard) { + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + this._matrix.append(camera.inverseSceneTransform); + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotateToHeadingState.MATRIX_INDEX), this._matrix); + } + } + +} + +export = ParticleRotateToHeadingState; \ No newline at end of file diff --git a/lib/animators/states/ParticleRotateToPositionState.js b/lib/animators/states/ParticleRotateToPositionState.js new file mode 100755 index 000000000..a8b30378c --- /dev/null +++ b/lib/animators/states/ParticleRotateToPositionState.js @@ -0,0 +1,57 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleRotateToPositionState = (function (_super) { + __extends(ParticleRotateToPositionState, _super); + function ParticleRotateToPositionState(animator, particleRotateToPositionNode) { + _super.call(this, animator, particleRotateToPositionNode); + this._matrix = new Matrix3D(); + this._particleRotateToPositionNode = particleRotateToPositionNode; + this._position = this._particleRotateToPositionNode._iPosition; + } + Object.defineProperty(ParticleRotateToPositionState.prototype, "position", { + /** + * Defines the position of the point the particle will rotate to face when in global mode. Defaults to 0,0,0. + */ + get: function () { + return this._position; + }, + set: function (value) { + this._position = value; + }, + enumerable: true, + configurable: true + }); + ParticleRotateToPositionState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotateToPositionState.POSITION_INDEX); + if (animationRegisterCache.hasBillboard) { + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + this._matrix.append(camera.inverseSceneTransform); + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotateToPositionState.MATRIX_INDEX), this._matrix); + } + if (this._particleRotateToPositionNode.mode == ParticlePropertiesMode.GLOBAL) { + this._offset = renderable.sourceEntity.inverseSceneTransform.transformVector(this._position); + animationRegisterCache.setVertexConst(index, this._offset.x, this._offset.y, this._offset.z); + } + else + animationSubGeometry.activateVertexBuffer(index, this._particleRotateToPositionNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + }; + /** @private */ + ParticleRotateToPositionState.MATRIX_INDEX = 0; + /** @private */ + ParticleRotateToPositionState.POSITION_INDEX = 1; + return ParticleRotateToPositionState; +})(ParticleStateBase); +module.exports = ParticleRotateToPositionState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/ParticleRotateToPositionState.ts b/lib/animators/states/ParticleRotateToPositionState.ts new file mode 100644 index 000000000..8455db2cd --- /dev/null +++ b/lib/animators/states/ParticleRotateToPositionState.ts @@ -0,0 +1,72 @@ +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleRotateToPositionNode = require("awayjs-renderergl/lib/animators/nodes/ParticleRotateToPositionNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleRotateToPositionState extends ParticleStateBase +{ + /** @private */ + public static MATRIX_INDEX:number /*int*/ = 0; + /** @private */ + public static POSITION_INDEX:number /*int*/ = 1; + + private _particleRotateToPositionNode:ParticleRotateToPositionNode; + private _position:Vector3D; + private _matrix:Matrix3D = new Matrix3D(); + private _offset:Vector3D; + + /** + * Defines the position of the point the particle will rotate to face when in global mode. Defaults to 0,0,0. + */ + public get position():Vector3D + { + return this._position; + } + + public set position(value:Vector3D) + { + this._position = value; + } + + constructor(animator:ParticleAnimator, particleRotateToPositionNode:ParticleRotateToPositionNode) + { + super(animator, particleRotateToPositionNode); + + this._particleRotateToPositionNode = particleRotateToPositionNode; + this._position = this._particleRotateToPositionNode._iPosition; + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotateToPositionState.POSITION_INDEX); + + if (animationRegisterCache.hasBillboard) { + this._matrix.copyFrom(renderable.sourceEntity.sceneTransform); + this._matrix.append(camera.inverseSceneTransform); + animationRegisterCache.setVertexConstFromMatrix(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotateToPositionState.MATRIX_INDEX), this._matrix); + } + + if (this._particleRotateToPositionNode.mode == ParticlePropertiesMode.GLOBAL) { + this._offset = renderable.sourceEntity.inverseSceneTransform.transformVector(this._position); + animationRegisterCache.setVertexConst(index, this._offset.x, this._offset.y, this._offset.z); + } else + animationSubGeometry.activateVertexBuffer(index, this._particleRotateToPositionNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + + } + +} + +export = ParticleRotateToPositionState; \ No newline at end of file diff --git a/lib/animators/states/ParticleRotationalVelocityState.js b/lib/animators/states/ParticleRotationalVelocityState.js new file mode 100755 index 000000000..7a88bb4c8 --- /dev/null +++ b/lib/animators/states/ParticleRotationalVelocityState.js @@ -0,0 +1,77 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleRotationalVelocityState = (function (_super) { + __extends(ParticleRotationalVelocityState, _super); + function ParticleRotationalVelocityState(animator, particleRotationNode) { + _super.call(this, animator, particleRotationNode); + this._particleRotationalVelocityNode = particleRotationNode; + this._rotationalVelocity = this._particleRotationalVelocityNode._iRotationalVelocity; + this.updateRotationalVelocityData(); + } + Object.defineProperty(ParticleRotationalVelocityState.prototype, "rotationalVelocity", { + /** + * Defines the default rotationalVelocity of the state, used when in global mode. + */ + get: function () { + return this._rotationalVelocity; + }, + set: function (value) { + this._rotationalVelocity = value; + this.updateRotationalVelocityData(); + }, + enumerable: true, + configurable: true + }); + /** + * + */ + ParticleRotationalVelocityState.prototype.getRotationalVelocities = function () { + return this._pDynamicProperties; + }; + ParticleRotationalVelocityState.prototype.setRotationalVelocities = function (value) { + this._pDynamicProperties = value; + this._pDynamicPropertiesDirty = new Object(); + }; + /** + * @inheritDoc + */ + ParticleRotationalVelocityState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.LOCAL_DYNAMIC && !this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId]) + this._pUpdateDynamicProperties(animationSubGeometry); + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotationalVelocityState.ROTATIONALVELOCITY_INDEX); + if (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.GLOBAL) + animationRegisterCache.setVertexConst(index, this._rotationalVelocityData.x, this._rotationalVelocityData.y, this._rotationalVelocityData.z, this._rotationalVelocityData.w); + else + animationSubGeometry.activateVertexBuffer(index, this._particleRotationalVelocityNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + }; + ParticleRotationalVelocityState.prototype.updateRotationalVelocityData = function () { + if (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._rotationalVelocity.w <= 0) + throw (new Error("the cycle duration must greater than zero")); + var rotation = this._rotationalVelocity.clone(); + if (rotation.length <= 0) + rotation.z = 1; //set the default direction + else + rotation.normalize(); + // w is used as angle/2 in agal + this._rotationalVelocityData = new Vector3D(rotation.x, rotation.y, rotation.z, Math.PI / rotation.w); + } + }; + /** @private */ + ParticleRotationalVelocityState.ROTATIONALVELOCITY_INDEX = 0; + return ParticleRotationalVelocityState; +})(ParticleStateBase); +module.exports = ParticleRotationalVelocityState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlerotationalvelocitystate.ts"],"names":["ParticleRotationalVelocityState","ParticleRotationalVelocityState.constructor","ParticleRotationalVelocityState.rotationalVelocity","ParticleRotationalVelocityState.getRotationalVelocities","ParticleRotationalVelocityState.setRotationalVelocities","ParticleRotationalVelocityState.setRenderState","ParticleRotationalVelocityState.updateRotationalVelocityData"],"mappings":";;;;;;AAAA,IAAO,QAAQ,WAAiB,oCAAoC,CAAC,CAAC;AAMtE,IAAO,2BAA2B,WAAY,6DAA6D,CAAC,CAAC;AAI7G,IAAO,sBAAsB,WAAa,6DAA6D,CAAC,CAAC;AAEzG,IAAO,iBAAiB,WAAc,0DAA0D,CAAC,CAAC;AAElG,AAGA;;GADG;IACG,+BAA+B;IAASA,UAAxCA,+BAA+BA,UAA0BA;IAuC9DA,SAvCKA,+BAA+BA,CAuCxBA,QAAyBA,EAAEA,oBAAmDA;QAEzFC,kBAAMA,QAAQA,EAAEA,oBAAoBA,CAACA,CAACA;QAEtCA,IAAIA,CAACA,+BAA+BA,GAAGA,oBAAoBA,CAACA;QAC5DA,IAAIA,CAACA,mBAAmBA,GAAGA,IAAIA,CAACA,+BAA+BA,CAACA,oBAAoBA,CAACA;QAErFA,IAAIA,CAACA,4BAA4BA,EAAEA,CAACA;IACrCA,CAACA;IAnCDD,sBAAWA,+DAAkBA;QAH7BA;;WAEGA;aACHA;YAECE,MAAMA,CAACA,IAAIA,CAACA,mBAAmBA,CAACA;QACjCA,CAACA;aAEDF,UAA8BA,KAAcA;YAE3CE,IAAIA,CAACA,mBAAmBA,GAAGA,KAAKA,CAACA;YAEjCA,IAAIA,CAACA,4BAA4BA,EAAEA,CAACA;QACrCA,CAACA;;;OAPAF;IASDA;;OAEGA;IACIA,iEAAuBA,GAA9BA;QAECG,MAAMA,CAACA,IAAIA,CAACA,mBAAmBA,CAACA;IACjCA,CAACA;IAEMH,iEAAuBA,GAA9BA,UAA+BA,KAAqBA;QAEnDI,IAAIA,CAACA,mBAAmBA,GAAGA,KAAKA,CAACA;QAEjCA,IAAIA,CAACA,wBAAwBA,GAAGA,IAAIA,MAAMA,EAAEA,CAACA;IAC9CA,CAACA;IAYDJ;;OAEGA;IACIA,wDAAcA,GAArBA,UAAsBA,KAAWA,EAAEA,UAAyBA,EAAEA,oBAAyCA,EAAEA,sBAA6CA,EAAEA,MAAaA;QAEpKK,EAAEA,CAACA,CAACA,IAAIA,CAACA,+BAA+BA,CAACA,IAAIA,IAAIA,sBAAsBA,CAACA,aAAaA,IAAIA,CAACA,IAAIA,CAACA,wBAAwBA,CAACA,oBAAoBA,CAACA,UAAUA,CAACA,CAACA;YACxJA,IAAIA,CAACA,yBAAyBA,CAACA,oBAAoBA,CAACA,CAACA;QAEtDA,IAAIA,KAAKA,GAAkBA,sBAAsBA,CAACA,gBAAgBA,CAACA,IAAIA,CAACA,eAAeA,EAAEA,+BAA+BA,CAACA,wBAAwBA,CAACA,CAACA;QAEnJA,EAAEA,CAACA,CAACA,IAAIA,CAACA,+BAA+BA,CAACA,IAAIA,IAAIA,sBAAsBA,CAACA,MAAMA,CAACA;YAC9EA,sBAAsBA,CAACA,cAAcA,CAACA,KAAKA,EAAEA,IAAIA,CAACA,uBAAuBA,CAACA,CAACA,EAAEA,IAAIA,CAACA,uBAAuBA,CAACA,CAACA,EAAEA,IAAIA,CAACA,uBAAuBA,CAACA,CAACA,EAAEA,IAAIA,CAACA,uBAAuBA,CAACA,CAACA,CAACA,CAACA;QAC9KA,IAAIA;YACHA,oBAAoBA,CAACA,oBAAoBA,CAACA,KAAKA,EAAEA,IAAIA,CAACA,+BAA+BA,CAACA,YAAYA,EAAEA,KAAKA,EAAEA,2BAA2BA,CAACA,OAAOA,CAACA,CAACA;IAClJA,CAACA;IAEOL,sEAA4BA,GAApCA;QAECM,EAAEA,CAACA,CAACA,IAAIA,CAACA,+BAA+BA,CAACA,IAAIA,IAAIA,sBAAsBA,CAACA,MAAMA,CAACA,CAACA,CAACA;YAChFA,EAAEA,CAACA,CAACA,IAAIA,CAACA,mBAAmBA,CAACA,CAACA,IAAIA,CAACA,CAACA;gBACnCA,MAAKA,CAACA,IAAIA,KAAKA,CAACA,2CAA2CA,CAACA,CAACA,CAACA;YAC/DA,IAAIA,QAAQA,GAAYA,IAAIA,CAACA,mBAAmBA,CAACA,KAAKA,EAAEA,CAACA;YAEzDA,EAAEA,CAACA,CAACA,QAAQA,CAACA,MAAMA,IAAIA,CAACA,CAACA;gBACxBA,QAAQA,CAACA,CAACA,GAAGA,CAACA,EAAEA,2BAA2BA;YAC5CA,IADgBA,AACZA;gBACHA,QAAQA,CAACA,SAASA,EAAEA,CAACA;YACtBA,AACAA,+BAD+BA;YAC/BA,IAAIA,CAACA,uBAAuBA,GAAGA,IAAIA,QAAQA,CAACA,QAAQA,CAACA,CAACA,EAAEA,QAAQA,CAACA,CAACA,EAAEA,QAAQA,CAACA,CAACA,EAAEA,IAAIA,CAACA,EAAEA,GAACA,QAAQA,CAACA,CAACA,CAACA,CAACA;QACrGA,CAACA;IACFA,CAACA;IA7EDN,eAAeA;IACDA,wDAAwBA,GAAmBA,CAACA,CAACA;IA6E5DA,sCAACA;AAADA,CAhFA,AAgFCA,EAhF6C,iBAAiB,EAgF9D;AAED,AAAyC,iBAAhC,+BAA+B,CAAC","file":"animators/states/ParticleRotationalVelocityState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleRotationalVelocityNode\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleRotationalVelocityNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n */\nclass ParticleRotationalVelocityState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static ROTATIONALVELOCITY_INDEX:number /*uint*/ = 0;\n\n\tprivate _particleRotationalVelocityNode:ParticleRotationalVelocityNode;\n\tprivate _rotationalVelocityData:Vector3D;\n\tprivate _rotationalVelocity:Vector3D;\n\n\t/**\n\t * Defines the default rotationalVelocity of the state, used when in global mode.\n\t */\n\tpublic get rotationalVelocity():Vector3D\n\t{\n\t\treturn this._rotationalVelocity;\n\t}\n\n\tpublic set rotationalVelocity(value:Vector3D)\n\t{\n\t\tthis._rotationalVelocity = value;\n\n\t\tthis.updateRotationalVelocityData();\n\t}\n\n\t/**\n\t *\n\t */\n\tpublic getRotationalVelocities():Array<Vector3D>\n\t{\n\t\treturn this._pDynamicProperties;\n\t}\n\n\tpublic setRotationalVelocities(value:Array<Vector3D>)\n\t{\n\t\tthis._pDynamicProperties = value;\n\n\t\tthis._pDynamicPropertiesDirty = new Object();\n\t}\n\n\tconstructor(animator:ParticleAnimator, particleRotationNode:ParticleRotationalVelocityNode)\n\t{\n\t\tsuper(animator, particleRotationNode);\n\n\t\tthis._particleRotationalVelocityNode = particleRotationNode;\n\t\tthis._rotationalVelocity = this._particleRotationalVelocityNode._iRotationalVelocity;\n\n\t\tthis.updateRotationalVelocityData();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tif (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.LOCAL_DYNAMIC && !this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId])\n\t\t\tthis._pUpdateDynamicProperties(animationSubGeometry);\n\n\t\tvar index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotationalVelocityState.ROTATIONALVELOCITY_INDEX);\n\n\t\tif (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.GLOBAL)\n\t\t\tanimationRegisterCache.setVertexConst(index, this._rotationalVelocityData.x, this._rotationalVelocityData.y, this._rotationalVelocityData.z, this._rotationalVelocityData.w);\n\t\telse\n\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleRotationalVelocityNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t}\n\n\tprivate updateRotationalVelocityData()\n\t{\n\t\tif (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.GLOBAL) {\n\t\t\tif (this._rotationalVelocity.w <= 0)\n\t\t\t\tthrow(new Error(\"the cycle duration must greater than zero\"));\n\t\t\tvar rotation:Vector3D = this._rotationalVelocity.clone();\n\n\t\t\tif (rotation.length <= 0)\n\t\t\t\trotation.z = 1; //set the default direction\n\t\t\telse\n\t\t\t\trotation.normalize();\n\t\t\t// w is used as angle/2 in agal\n\t\t\tthis._rotationalVelocityData = new Vector3D(rotation.x, rotation.y, rotation.z, Math.PI/rotation.w);\n\t\t}\n\t}\n}\n\nexport = ParticleRotationalVelocityState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleRotationalVelocityState.ts b/lib/animators/states/ParticleRotationalVelocityState.ts new file mode 100644 index 000000000..90a34fadf --- /dev/null +++ b/lib/animators/states/ParticleRotationalVelocityState.ts @@ -0,0 +1,100 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleRotationalVelocityNode = require("awayjs-renderergl/lib/animators/nodes/ParticleRotationalVelocityNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleRotationalVelocityState extends ParticleStateBase +{ + /** @private */ + public static ROTATIONALVELOCITY_INDEX:number /*uint*/ = 0; + + private _particleRotationalVelocityNode:ParticleRotationalVelocityNode; + private _rotationalVelocityData:Vector3D; + private _rotationalVelocity:Vector3D; + + /** + * Defines the default rotationalVelocity of the state, used when in global mode. + */ + public get rotationalVelocity():Vector3D + { + return this._rotationalVelocity; + } + + public set rotationalVelocity(value:Vector3D) + { + this._rotationalVelocity = value; + + this.updateRotationalVelocityData(); + } + + /** + * + */ + public getRotationalVelocities():Array + { + return this._pDynamicProperties; + } + + public setRotationalVelocities(value:Array) + { + this._pDynamicProperties = value; + + this._pDynamicPropertiesDirty = new Object(); + } + + constructor(animator:ParticleAnimator, particleRotationNode:ParticleRotationalVelocityNode) + { + super(animator, particleRotationNode); + + this._particleRotationalVelocityNode = particleRotationNode; + this._rotationalVelocity = this._particleRotationalVelocityNode._iRotationalVelocity; + + this.updateRotationalVelocityData(); + } + + /** + * @inheritDoc + */ + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.LOCAL_DYNAMIC && !this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId]) + this._pUpdateDynamicProperties(animationSubGeometry); + + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleRotationalVelocityState.ROTATIONALVELOCITY_INDEX); + + if (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.GLOBAL) + animationRegisterCache.setVertexConst(index, this._rotationalVelocityData.x, this._rotationalVelocityData.y, this._rotationalVelocityData.z, this._rotationalVelocityData.w); + else + animationSubGeometry.activateVertexBuffer(index, this._particleRotationalVelocityNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + } + + private updateRotationalVelocityData() + { + if (this._particleRotationalVelocityNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._rotationalVelocity.w <= 0) + throw(new Error("the cycle duration must greater than zero")); + var rotation:Vector3D = this._rotationalVelocity.clone(); + + if (rotation.length <= 0) + rotation.z = 1; //set the default direction + else + rotation.normalize(); + // w is used as angle/2 in agal + this._rotationalVelocityData = new Vector3D(rotation.x, rotation.y, rotation.z, Math.PI/rotation.w); + } + } +} + +export = ParticleRotationalVelocityState; \ No newline at end of file diff --git a/lib/animators/states/ParticleScaleState.js b/lib/animators/states/ParticleScaleState.js new file mode 100755 index 000000000..e04312cd2 --- /dev/null +++ b/lib/animators/states/ParticleScaleState.js @@ -0,0 +1,115 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleScaleState = (function (_super) { + __extends(ParticleScaleState, _super); + function ParticleScaleState(animator, particleScaleNode) { + _super.call(this, animator, particleScaleNode); + this._particleScaleNode = particleScaleNode; + this._usesCycle = this._particleScaleNode._iUsesCycle; + this._usesPhase = this._particleScaleNode._iUsesPhase; + this._minScale = this._particleScaleNode._iMinScale; + this._maxScale = this._particleScaleNode._iMaxScale; + this._cycleDuration = this._particleScaleNode._iCycleDuration; + this._cyclePhase = this._particleScaleNode._iCyclePhase; + this.updateScaleData(); + } + Object.defineProperty(ParticleScaleState.prototype, "minScale", { + /** + * Defines the end scale of the state, when in global mode. Defaults to 1. + */ + get: function () { + return this._minScale; + }, + set: function (value) { + this._minScale = value; + this.updateScaleData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleScaleState.prototype, "maxScale", { + /** + * Defines the end scale of the state, when in global mode. Defaults to 1. + */ + get: function () { + return this._maxScale; + }, + set: function (value) { + this._maxScale = value; + this.updateScaleData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleScaleState.prototype, "cycleDuration", { + /** + * Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + */ + get: function () { + return this._cycleDuration; + }, + set: function (value) { + this._cycleDuration = value; + this.updateScaleData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleScaleState.prototype, "cyclePhase", { + /** + * Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + get: function () { + return this._cyclePhase; + }, + set: function (value) { + this._cyclePhase = value; + this.updateScaleData(); + }, + enumerable: true, + configurable: true + }); + ParticleScaleState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleScaleState.SCALE_INDEX); + if (this._particleScaleNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + if (this._usesCycle) { + if (this._usesPhase) + animationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + else + animationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } + else + animationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_2); + } + else + animationRegisterCache.setVertexConst(index, this._scaleData.x, this._scaleData.y, this._scaleData.z, this._scaleData.w); + }; + ParticleScaleState.prototype.updateScaleData = function () { + if (this._particleScaleNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw (new Error("the cycle duration must be greater than zero")); + this._scaleData = new Vector3D((this._minScale + this._maxScale) / 2, Math.abs(this._minScale - this._maxScale) / 2, Math.PI * 2 / this._cycleDuration, this._cyclePhase * Math.PI / 180); + } + else + this._scaleData = new Vector3D(this._minScale, this._maxScale - this._minScale, 0, 0); + } + }; + /** @private */ + ParticleScaleState.SCALE_INDEX = 0; + return ParticleScaleState; +})(ParticleStateBase); +module.exports = ParticleScaleState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlescalestate.ts"],"names":["ParticleScaleState","ParticleScaleState.constructor","ParticleScaleState.minScale","ParticleScaleState.maxScale","ParticleScaleState.cycleDuration","ParticleScaleState.cyclePhase","ParticleScaleState.setRenderState","ParticleScaleState.updateScaleData"],"mappings":"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","file":"animators/states/ParticleScaleState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleScaleNode\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleScaleNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n */\nclass ParticleScaleState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static SCALE_INDEX:number /*uint*/ = 0;\n\n\tprivate _particleScaleNode:ParticleScaleNode;\n\tprivate _usesCycle:boolean;\n\tprivate _usesPhase:boolean;\n\tprivate _minScale:number;\n\tprivate _maxScale:number;\n\tprivate _cycleDuration:number;\n\tprivate _cyclePhase:number;\n\tprivate _scaleData:Vector3D;\n\n\t/**\n\t * Defines the end scale of the state, when in global mode. Defaults to 1.\n\t */\n\tpublic get minScale():number\n\t{\n\t\treturn this._minScale;\n\t}\n\n\tpublic set minScale(value:number)\n\t{\n\t\tthis._minScale = value;\n\n\t\tthis.updateScaleData();\n\t}\n\n\t/**\n\t * Defines the end scale of the state, when in global mode. Defaults to 1.\n\t */\n\tpublic get maxScale():number\n\t{\n\t\treturn this._maxScale;\n\t}\n\n\tpublic set maxScale(value:number)\n\t{\n\t\tthis._maxScale = value;\n\n\t\tthis.updateScaleData();\n\t}\n\n\t/**\n\t * Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1.\n\t */\n\tpublic get cycleDuration():number\n\t{\n\t\treturn this._cycleDuration;\n\t}\n\n\tpublic set cycleDuration(value:number)\n\t{\n\t\tthis._cycleDuration = value;\n\n\t\tthis.updateScaleData();\n\t}\n\n\t/**\n\t * Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0.\n\t */\n\tpublic get cyclePhase():number\n\t{\n\t\treturn this._cyclePhase;\n\t}\n\n\tpublic set cyclePhase(value:number)\n\t{\n\t\tthis._cyclePhase = value;\n\n\t\tthis.updateScaleData();\n\t}\n\n\tconstructor(animator:ParticleAnimator, particleScaleNode:ParticleScaleNode)\n\t{\n\t\tsuper(animator, particleScaleNode);\n\n\t\tthis._particleScaleNode = particleScaleNode;\n\t\tthis._usesCycle = this._particleScaleNode._iUsesCycle;\n\t\tthis._usesPhase = this._particleScaleNode._iUsesPhase;\n\t\tthis._minScale = this._particleScaleNode._iMinScale;\n\t\tthis._maxScale = this._particleScaleNode._iMaxScale;\n\t\tthis._cycleDuration = this._particleScaleNode._iCycleDuration;\n\t\tthis._cyclePhase = this._particleScaleNode._iCyclePhase;\n\n\t\tthis.updateScaleData();\n\t}\n\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tvar index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleScaleState.SCALE_INDEX);\n\n\t\tif (this._particleScaleNode.mode == ParticlePropertiesMode.LOCAL_STATIC) {\n\t\t\tif (this._usesCycle) {\n\t\t\t\tif (this._usesPhase)\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4);\n\t\t\t\telse\n\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3);\n\t\t\t} else\n\t\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_2);\n\t\t} else\n\t\t\tanimationRegisterCache.setVertexConst(index, this._scaleData.x, this._scaleData.y, this._scaleData.z, this._scaleData.w);\n\t}\n\n\tprivate updateScaleData()\n\t{\n\t\tif (this._particleScaleNode.mode == ParticlePropertiesMode.GLOBAL) {\n\t\t\tif (this._usesCycle) {\n\t\t\t\tif (this._cycleDuration <= 0)\n\t\t\t\t\tthrow(new Error(\"the cycle duration must be greater than zero\"));\n\t\t\t\tthis._scaleData = new Vector3D((this._minScale + this._maxScale)/2, Math.abs(this._minScale - this._maxScale)/2, Math.PI*2/this._cycleDuration, this._cyclePhase*Math.PI/180);\n\t\t\t} else\n\t\t\t\tthis._scaleData = new Vector3D(this._minScale, this._maxScale - this._minScale, 0, 0);\n\t\t}\n\t}\n}\n\nexport = ParticleScaleState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleScaleState.ts b/lib/animators/states/ParticleScaleState.ts new file mode 100644 index 000000000..e3e7a8802 --- /dev/null +++ b/lib/animators/states/ParticleScaleState.ts @@ -0,0 +1,136 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleScaleNode = require("awayjs-renderergl/lib/animators/nodes/ParticleScaleNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleScaleState extends ParticleStateBase +{ + /** @private */ + public static SCALE_INDEX:number /*uint*/ = 0; + + private _particleScaleNode:ParticleScaleNode; + private _usesCycle:boolean; + private _usesPhase:boolean; + private _minScale:number; + private _maxScale:number; + private _cycleDuration:number; + private _cyclePhase:number; + private _scaleData:Vector3D; + + /** + * Defines the end scale of the state, when in global mode. Defaults to 1. + */ + public get minScale():number + { + return this._minScale; + } + + public set minScale(value:number) + { + this._minScale = value; + + this.updateScaleData(); + } + + /** + * Defines the end scale of the state, when in global mode. Defaults to 1. + */ + public get maxScale():number + { + return this._maxScale; + } + + public set maxScale(value:number) + { + this._maxScale = value; + + this.updateScaleData(); + } + + /** + * Defines the duration of the animation in seconds, used as a period independent of particle duration when in global mode. Defaults to 1. + */ + public get cycleDuration():number + { + return this._cycleDuration; + } + + public set cycleDuration(value:number) + { + this._cycleDuration = value; + + this.updateScaleData(); + } + + /** + * Defines the phase of the cycle in degrees, used as the starting offset of the cycle when in global mode. Defaults to 0. + */ + public get cyclePhase():number + { + return this._cyclePhase; + } + + public set cyclePhase(value:number) + { + this._cyclePhase = value; + + this.updateScaleData(); + } + + constructor(animator:ParticleAnimator, particleScaleNode:ParticleScaleNode) + { + super(animator, particleScaleNode); + + this._particleScaleNode = particleScaleNode; + this._usesCycle = this._particleScaleNode._iUsesCycle; + this._usesPhase = this._particleScaleNode._iUsesPhase; + this._minScale = this._particleScaleNode._iMinScale; + this._maxScale = this._particleScaleNode._iMaxScale; + this._cycleDuration = this._particleScaleNode._iCycleDuration; + this._cyclePhase = this._particleScaleNode._iCyclePhase; + + this.updateScaleData(); + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleScaleState.SCALE_INDEX); + + if (this._particleScaleNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + if (this._usesCycle) { + if (this._usesPhase) + animationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + else + animationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } else + animationSubGeometry.activateVertexBuffer(index, this._particleScaleNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_2); + } else + animationRegisterCache.setVertexConst(index, this._scaleData.x, this._scaleData.y, this._scaleData.z, this._scaleData.w); + } + + private updateScaleData() + { + if (this._particleScaleNode.mode == ParticlePropertiesMode.GLOBAL) { + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw(new Error("the cycle duration must be greater than zero")); + this._scaleData = new Vector3D((this._minScale + this._maxScale)/2, Math.abs(this._minScale - this._maxScale)/2, Math.PI*2/this._cycleDuration, this._cyclePhase*Math.PI/180); + } else + this._scaleData = new Vector3D(this._minScale, this._maxScale - this._minScale, 0, 0); + } + } +} + +export = ParticleScaleState; \ No newline at end of file diff --git a/lib/animators/states/ParticleSegmentedColorState.js b/lib/animators/states/ParticleSegmentedColorState.js new file mode 100755 index 000000000..f89addc78 --- /dev/null +++ b/lib/animators/states/ParticleSegmentedColorState.js @@ -0,0 +1,153 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * + */ +var ParticleSegmentedColorState = (function (_super) { + __extends(ParticleSegmentedColorState, _super); + function ParticleSegmentedColorState(animator, particleSegmentedColorNode) { + _super.call(this, animator, particleSegmentedColorNode); + this._usesMultiplier = particleSegmentedColorNode._iUsesMultiplier; + this._usesOffset = particleSegmentedColorNode._iUsesOffset; + this._startColor = particleSegmentedColorNode._iStartColor; + this._endColor = particleSegmentedColorNode._iEndColor; + this._segmentPoints = particleSegmentedColorNode._iSegmentPoints; + this._numSegmentPoint = particleSegmentedColorNode._iNumSegmentPoint; + this.updateColorData(); + } + Object.defineProperty(ParticleSegmentedColorState.prototype, "startColor", { + /** + * Defines the start color transform of the state, when in global mode. + */ + get: function () { + return this._startColor; + }, + set: function (value) { + this._startColor = value; + this.updateColorData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSegmentedColorState.prototype, "endColor", { + /** + * Defines the end color transform of the state, when in global mode. + */ + get: function () { + return this._endColor; + }, + set: function (value) { + this._endColor = value; + this.updateColorData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSegmentedColorState.prototype, "numSegmentPoint", { + /** + * Defines the number of segments. + */ + get: function () { + return this._numSegmentPoint; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSegmentedColorState.prototype, "segmentPoints", { + /** + * Defines the key points of color + */ + get: function () { + return this._segmentPoints; + }, + set: function (value) { + this._segmentPoints = value; + this.updateColorData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSegmentedColorState.prototype, "usesMultiplier", { + get: function () { + return this._usesMultiplier; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSegmentedColorState.prototype, "usesOffset", { + get: function () { + return this._usesOffset; + }, + enumerable: true, + configurable: true + }); + ParticleSegmentedColorState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (animationRegisterCache.needFragmentAnimation) { + if (this._numSegmentPoint > 0) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.TIME_DATA_INDEX), this._timeLifeData[0], this._timeLifeData[1], this._timeLifeData[2], this._timeLifeData[3]); + if (this._usesMultiplier) + animationRegisterCache.setVertexConstFromArray(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.START_MULTIPLIER_INDEX), this._multiplierData); + if (this._usesOffset) + animationRegisterCache.setVertexConstFromArray(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.START_OFFSET_INDEX), this._offsetData); + } + }; + ParticleSegmentedColorState.prototype.updateColorData = function () { + this._timeLifeData = new Array(); + this._multiplierData = new Array(); + this._offsetData = new Array(); + var i /*int*/; + for (i = 0; i < this._numSegmentPoint; i++) { + if (i == 0) + this._timeLifeData.push(this._segmentPoints[i].life); + else + this._timeLifeData.push(this._segmentPoints[i].life - this._segmentPoints[i - 1].life); + } + if (this._numSegmentPoint == 0) + this._timeLifeData.push(1); + else + this._timeLifeData.push(1 - this._segmentPoints[i - 1].life); + if (this._usesMultiplier) { + this._multiplierData.push(this._startColor.redMultiplier, this._startColor.greenMultiplier, this._startColor.blueMultiplier, this._startColor.alphaMultiplier); + for (i = 0; i < this._numSegmentPoint; i++) { + if (i == 0) + this._multiplierData.push((this._segmentPoints[i].color.redMultiplier - this._startColor.redMultiplier) / this._timeLifeData[i], (this._segmentPoints[i].color.greenMultiplier - this._startColor.greenMultiplier) / this._timeLifeData[i], (this._segmentPoints[i].color.blueMultiplier - this._startColor.blueMultiplier) / this._timeLifeData[i], (this._segmentPoints[i].color.alphaMultiplier - this._startColor.alphaMultiplier) / this._timeLifeData[i]); + else + this._multiplierData.push((this._segmentPoints[i].color.redMultiplier - this._segmentPoints[i - 1].color.redMultiplier) / this._timeLifeData[i], (this._segmentPoints[i].color.greenMultiplier - this._segmentPoints[i - 1].color.greenMultiplier) / this._timeLifeData[i], (this._segmentPoints[i].color.blueMultiplier - this._segmentPoints[i - 1].color.blueMultiplier) / this._timeLifeData[i], (this._segmentPoints[i].color.alphaMultiplier - this._segmentPoints[i - 1].color.alphaMultiplier) / this._timeLifeData[i]); + } + if (this._numSegmentPoint == 0) + this._multiplierData.push(this._endColor.redMultiplier - this._startColor.redMultiplier, this._endColor.greenMultiplier - this._startColor.greenMultiplier, this._endColor.blueMultiplier - this._startColor.blueMultiplier, this._endColor.alphaMultiplier - this._startColor.alphaMultiplier); + else + this._multiplierData.push((this._endColor.redMultiplier - this._segmentPoints[i - 1].color.redMultiplier) / this._timeLifeData[i], (this._endColor.greenMultiplier - this._segmentPoints[i - 1].color.greenMultiplier) / this._timeLifeData[i], (this._endColor.blueMultiplier - this._segmentPoints[i - 1].color.blueMultiplier) / this._timeLifeData[i], (this._endColor.alphaMultiplier - this._segmentPoints[i - 1].color.alphaMultiplier) / this._timeLifeData[i]); + } + if (this._usesOffset) { + this._offsetData.push(this._startColor.redOffset / 255, this._startColor.greenOffset / 255, this._startColor.blueOffset / 255, this._startColor.alphaOffset / 255); + for (i = 0; i < this._numSegmentPoint; i++) { + if (i == 0) + this._offsetData.push((this._segmentPoints[i].color.redOffset - this._startColor.redOffset) / this._timeLifeData[i] / 255, (this._segmentPoints[i].color.greenOffset - this._startColor.greenOffset) / this._timeLifeData[i] / 255, (this._segmentPoints[i].color.blueOffset - this._startColor.blueOffset) / this._timeLifeData[i] / 255, (this._segmentPoints[i].color.alphaOffset - this._startColor.alphaOffset) / this._timeLifeData[i] / 255); + else + this._offsetData.push((this._segmentPoints[i].color.redOffset - this._segmentPoints[i - 1].color.redOffset) / this._timeLifeData[i] / 255, (this._segmentPoints[i].color.greenOffset - this._segmentPoints[i - 1].color.greenOffset) / this._timeLifeData[i] / 255, (this._segmentPoints[i].color.blueOffset - this._segmentPoints[i - 1].color.blueOffset) / this._timeLifeData[i] / 255, (this._segmentPoints[i].color.alphaOffset - this._segmentPoints[i - 1].color.alphaOffset) / this._timeLifeData[i] / 255); + } + if (this._numSegmentPoint == 0) + this._offsetData.push((this._endColor.redOffset - this._startColor.redOffset) / 255, (this._endColor.greenOffset - this._startColor.greenOffset) / 255, (this._endColor.blueOffset - this._startColor.blueOffset) / 255, (this._endColor.alphaOffset - this._startColor.alphaOffset) / 255); + else + this._offsetData.push((this._endColor.redOffset - this._segmentPoints[i - 1].color.redOffset) / this._timeLifeData[i] / 255, (this._endColor.greenOffset - this._segmentPoints[i - 1].color.greenOffset) / this._timeLifeData[i] / 255, (this._endColor.blueOffset - this._segmentPoints[i - 1].color.blueOffset) / this._timeLifeData[i] / 255, (this._endColor.alphaOffset - this._segmentPoints[i - 1].color.alphaOffset) / this._timeLifeData[i] / 255); + } + //cut off the data + this._timeLifeData.length = 4; + }; + /** @private */ + ParticleSegmentedColorState.START_MULTIPLIER_INDEX = 0; + /** @private */ + ParticleSegmentedColorState.START_OFFSET_INDEX = 1; + /** @private */ + ParticleSegmentedColorState.TIME_DATA_INDEX = 2; + return ParticleSegmentedColorState; +})(ParticleStateBase); +module.exports = ParticleSegmentedColorState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlesegmentedcolorstate.ts"],"names":["ParticleSegmentedColorState","ParticleSegmentedColorState.constructor","ParticleSegmentedColorState.startColor","ParticleSegmentedColorState.endColor","ParticleSegmentedColorState.numSegmentPoint","ParticleSegmentedColorState.segmentPoints","ParticleSegmentedColorState.usesMultiplier","ParticleSegmentedColorState.usesOffset","ParticleSegmentedColorState.setRenderState","ParticleSegmentedColorState.updateColorData"],"mappings":"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WAAWA,CAACA,cAAcA,EAAEA,IAAIA,CAACA,WAAWA,CAACA,eAAeA,CAACA,CAACA;YAC/JA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,gBAAgBA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBAC5CA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA;oBACVA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,aAAaA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,aAAaA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,eAAeA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,cAAcA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,cAAcA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,eAAeA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,CAACA,CAACA;gBACzbA,IAAIA;oBACHA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,aAAaA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,aAAaA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,cAAcA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,cAAcA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,CAACA,CAACA;YAC1fA,CAACA;YACDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,gBAAgBA,IAAIA,CAACA,CAACA;gBAC9BA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,IAAIA,CAACA,SAASA,CAACA,aAAaA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,aAAaA,EAAEA,IAAIA,CAACA,SAASA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,eAAeA,EAAEA,IAAIA,CAACA,SAASA,CAACA,cAAcA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,cAAcA,EAAEA,IAAIA,CAACA,SAASA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,eAAeA,CAACA,CAACA;YACjSA,IAAIA;gBACHA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,SAASA,CAACA,aAAaA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,aAAaA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,cAAcA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,cAAcA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,eAAeA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,eAAeA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,CAACA,CAACA;QAClcA,CAACA;QAEDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,CAACA;YACtBA,IAAIA,CAACA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,WAAWA,CAACA,SAASA,GAACA,GAAGA,EAAEA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,GAACA,GAAGA,EAAEA,IAAIA,CAACA,WAAWA,CAACA,UAAUA,GAACA,GAAGA,EAAEA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,GAACA,GAAGA,CAACA,CAACA;YAC3JA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,gBAAgBA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBAC5CA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA;oBACVA,IAAIA,CAACA,WAAWA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,SAASA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,SAASA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,UAAUA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,CAACA,CAACA;gBACraA,IAAIA;oBACHA,IAAIA,CAACA,WAAWA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,SAASA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,SAASA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,UAAUA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,CAACA,CAACA;YACteA,CAACA;YACDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,gBAAgBA,IAAIA,CAACA,CAACA;gBAC9BA,IAAIA,CAACA,WAAWA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,SAASA,CAACA,SAASA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,SAASA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,UAAUA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,WAAWA,CAACA,GAACA,GAAGA,CAACA,CAACA;YACrRA,IAAIA;gBACHA,IAAIA,CAACA,WAAWA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,SAASA,CAACA,SAASA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,SAASA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,UAAUA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,EAAEA,CAACA,IAAIA,CAACA,SAASA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,KAAKA,CAACA,WAAWA,CAACA,GAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,GAACA,GAAGA,CAACA,CAACA;QAC9aA,CAACA;QACDA,AACAA,kBADkBA;QAClBA,IAAIA,CAACA,aAAaA,CAACA,MAAMA,GAAGA,CAACA,CAACA;IAC/BA,CAACA;IAxJDT,eAAeA;IACDA,kDAAsBA,GAAmBA,CAACA,CAACA;IAEzDA,eAAeA;IACDA,8CAAkBA,GAAmBA,CAACA,CAACA;IAErDA,eAAeA;IACDA,2CAAeA,GAAmBA,CAACA,CAACA;IAkJnDA,kCAACA;AAADA,CA3JA,AA2JCA,EA3JyC,iBAAiB,EA2J1D;AAED,AAAqC,iBAA5B,2BAA2B,CAAC","file":"animators/states/ParticleSegmentedColorState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ColorTransform\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/ColorTransform\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ColorSegmentPoint\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ColorSegmentPoint\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleSegmentedColorNode\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleSegmentedColorNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n *\n */\nclass ParticleSegmentedColorState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static START_MULTIPLIER_INDEX:number /*uint*/ = 0;\n\n\t/** @private */\n\tpublic static START_OFFSET_INDEX:number /*uint*/ = 1;\n\n\t/** @private */\n\tpublic static TIME_DATA_INDEX:number /*uint*/ = 2;\n\n\tprivate _usesMultiplier:boolean;\n\tprivate _usesOffset:boolean;\n\tprivate _startColor:ColorTransform;\n\tprivate _endColor:ColorTransform;\n\tprivate _segmentPoints:Array<ColorSegmentPoint>;\n\tprivate _numSegmentPoint:number /*int*/;\n\n\tprivate _timeLifeData:Array<number>;\n\tprivate _multiplierData:Array<number>;\n\tprivate _offsetData:Array<number>;\n\n\t/**\n\t * Defines the start color transform of the state, when in global mode.\n\t */\n\tpublic get startColor():ColorTransform\n\t{\n\t\treturn this._startColor;\n\t}\n\n\tpublic set startColor(value:ColorTransform)\n\t{\n\t\tthis._startColor = value;\n\n\t\tthis.updateColorData();\n\t}\n\n\t/**\n\t * Defines the end color transform of the state, when in global mode.\n\t */\n\tpublic get endColor():ColorTransform\n\t{\n\t\treturn this._endColor;\n\t}\n\n\tpublic set endColor(value:ColorTransform)\n\t{\n\t\tthis._endColor = value;\n\t\tthis.updateColorData();\n\t}\n\n\t/**\n\t * Defines the number of segments.\n\t */\n\tpublic get numSegmentPoint():number /*int*/\n\t{\n\t\treturn this._numSegmentPoint;\n\t}\n\n\t/**\n\t * Defines the key points of color\n\t */\n\tpublic get segmentPoints():Array<ColorSegmentPoint>\n\t{\n\t\treturn this._segmentPoints;\n\t}\n\n\tpublic set segmentPoints(value:Array<ColorSegmentPoint>)\n\t{\n\t\tthis._segmentPoints = value;\n\t\tthis.updateColorData();\n\t}\n\n\tpublic get usesMultiplier():boolean\n\t{\n\t\treturn this._usesMultiplier;\n\t}\n\n\tpublic get usesOffset():boolean\n\t{\n\t\treturn this._usesOffset;\n\t}\n\n\tconstructor(animator:ParticleAnimator, particleSegmentedColorNode:ParticleSegmentedColorNode)\n\t{\n\t\tsuper(animator, particleSegmentedColorNode);\n\n\t\tthis._usesMultiplier = particleSegmentedColorNode._iUsesMultiplier;\n\t\tthis._usesOffset = particleSegmentedColorNode._iUsesOffset;\n\t\tthis._startColor = particleSegmentedColorNode._iStartColor;\n\t\tthis._endColor = particleSegmentedColorNode._iEndColor;\n\t\tthis._segmentPoints = particleSegmentedColorNode._iSegmentPoints;\n\t\tthis._numSegmentPoint = particleSegmentedColorNode._iNumSegmentPoint;\n\t\tthis.updateColorData();\n\t}\n\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tif (animationRegisterCache.needFragmentAnimation) {\n\t\t\tif (this._numSegmentPoint > 0)\n\t\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.TIME_DATA_INDEX), this._timeLifeData[0], this._timeLifeData[1], this._timeLifeData[2], this._timeLifeData[3]);\n\t\t\tif (this._usesMultiplier)\n\t\t\t\tanimationRegisterCache.setVertexConstFromArray(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.START_MULTIPLIER_INDEX), this._multiplierData);\n\t\t\tif (this._usesOffset)\n\t\t\t\tanimationRegisterCache.setVertexConstFromArray(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.START_OFFSET_INDEX), this._offsetData);\n\t\t}\n\t}\n\n\tprivate updateColorData()\n\t{\n\t\tthis._timeLifeData = new Array<number>();\n\t\tthis._multiplierData = new Array<number>();\n\t\tthis._offsetData = new Array<number>();\n\t\tvar i:number /*int*/;\n\t\tfor (i = 0; i < this._numSegmentPoint; i++) {\n\t\t\tif (i == 0)\n\t\t\t\tthis._timeLifeData.push(this._segmentPoints[i].life);\n\t\t\telse\n\t\t\t\tthis._timeLifeData.push(this._segmentPoints[i].life - this._segmentPoints[i - 1].life);\n\t\t}\n\t\tif (this._numSegmentPoint == 0)\n\t\t\tthis._timeLifeData.push(1);\n\t\telse\n\t\t\tthis._timeLifeData.push(1 - this._segmentPoints[i - 1].life);\n\n\t\tif (this._usesMultiplier) {\n\t\t\tthis._multiplierData.push(this._startColor.redMultiplier, this._startColor.greenMultiplier, this._startColor.blueMultiplier, this._startColor.alphaMultiplier);\n\t\t\tfor (i = 0; i < this._numSegmentPoint; i++) {\n\t\t\t\tif (i == 0)\n\t\t\t\t\tthis._multiplierData.push((this._segmentPoints[i].color.redMultiplier - this._startColor.redMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.greenMultiplier - this._startColor.greenMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.blueMultiplier - this._startColor.blueMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.alphaMultiplier - this._startColor.alphaMultiplier)/this._timeLifeData[i]);\n\t\t\t\telse\n\t\t\t\t\tthis._multiplierData.push((this._segmentPoints[i].color.redMultiplier - this._segmentPoints[i - 1].color.redMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.greenMultiplier - this._segmentPoints[i - 1].color.greenMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.blueMultiplier - this._segmentPoints[i - 1].color.blueMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.alphaMultiplier - this._segmentPoints[i - 1].color.alphaMultiplier)/this._timeLifeData[i]);\n\t\t\t}\n\t\t\tif (this._numSegmentPoint == 0)\n\t\t\t\tthis._multiplierData.push(this._endColor.redMultiplier - this._startColor.redMultiplier, this._endColor.greenMultiplier - this._startColor.greenMultiplier, this._endColor.blueMultiplier - this._startColor.blueMultiplier, this._endColor.alphaMultiplier - this._startColor.alphaMultiplier);\n\t\t\telse\n\t\t\t\tthis._multiplierData.push((this._endColor.redMultiplier - this._segmentPoints[i - 1].color.redMultiplier)/this._timeLifeData[i], (this._endColor.greenMultiplier - this._segmentPoints[i - 1].color.greenMultiplier)/this._timeLifeData[i], (this._endColor.blueMultiplier - this._segmentPoints[i - 1].color.blueMultiplier)/this._timeLifeData[i], (this._endColor.alphaMultiplier - this._segmentPoints[i - 1].color.alphaMultiplier)/this._timeLifeData[i]);\n\t\t}\n\n\t\tif (this._usesOffset) {\n\t\t\tthis._offsetData.push(this._startColor.redOffset/255, this._startColor.greenOffset/255, this._startColor.blueOffset/255, this._startColor.alphaOffset/255);\n\t\t\tfor (i = 0; i < this._numSegmentPoint; i++) {\n\t\t\t\tif (i == 0)\n\t\t\t\t\tthis._offsetData.push((this._segmentPoints[i].color.redOffset - this._startColor.redOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.greenOffset - this._startColor.greenOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.blueOffset - this._startColor.blueOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.alphaOffset - this._startColor.alphaOffset)/this._timeLifeData[i]/255);\n\t\t\t\telse\n\t\t\t\t\tthis._offsetData.push((this._segmentPoints[i].color.redOffset - this._segmentPoints[i - 1].color.redOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.greenOffset - this._segmentPoints[i - 1].color.greenOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.blueOffset - this._segmentPoints[i - 1].color.blueOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.alphaOffset - this._segmentPoints[i - 1].color.alphaOffset)/this._timeLifeData[i]/255);\n\t\t\t}\n\t\t\tif (this._numSegmentPoint == 0)\n\t\t\t\tthis._offsetData.push((this._endColor.redOffset - this._startColor.redOffset)/255, (this._endColor.greenOffset - this._startColor.greenOffset)/255, (this._endColor.blueOffset - this._startColor.blueOffset)/255, (this._endColor.alphaOffset - this._startColor.alphaOffset)/255);\n\t\t\telse\n\t\t\t\tthis._offsetData.push((this._endColor.redOffset - this._segmentPoints[i - 1].color.redOffset)/this._timeLifeData[i]/255, (this._endColor.greenOffset - this._segmentPoints[i - 1].color.greenOffset)/this._timeLifeData[i]/255, (this._endColor.blueOffset - this._segmentPoints[i - 1].color.blueOffset)/this._timeLifeData[i]/255, (this._endColor.alphaOffset - this._segmentPoints[i - 1].color.alphaOffset)/this._timeLifeData[i]/255);\n\t\t}\n\t\t//cut off the data\n\t\tthis._timeLifeData.length = 4;\n\t}\n}\n\nexport = ParticleSegmentedColorState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleSegmentedColorState.ts b/lib/animators/states/ParticleSegmentedColorState.ts new file mode 100644 index 000000000..8dff14261 --- /dev/null +++ b/lib/animators/states/ParticleSegmentedColorState.ts @@ -0,0 +1,177 @@ +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ColorSegmentPoint = require("awayjs-renderergl/lib/animators/data/ColorSegmentPoint"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleSegmentedColorNode = require("awayjs-renderergl/lib/animators/nodes/ParticleSegmentedColorNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * + */ +class ParticleSegmentedColorState extends ParticleStateBase +{ + /** @private */ + public static START_MULTIPLIER_INDEX:number /*uint*/ = 0; + + /** @private */ + public static START_OFFSET_INDEX:number /*uint*/ = 1; + + /** @private */ + public static TIME_DATA_INDEX:number /*uint*/ = 2; + + private _usesMultiplier:boolean; + private _usesOffset:boolean; + private _startColor:ColorTransform; + private _endColor:ColorTransform; + private _segmentPoints:Array; + private _numSegmentPoint:number /*int*/; + + private _timeLifeData:Array; + private _multiplierData:Array; + private _offsetData:Array; + + /** + * Defines the start color transform of the state, when in global mode. + */ + public get startColor():ColorTransform + { + return this._startColor; + } + + public set startColor(value:ColorTransform) + { + this._startColor = value; + + this.updateColorData(); + } + + /** + * Defines the end color transform of the state, when in global mode. + */ + public get endColor():ColorTransform + { + return this._endColor; + } + + public set endColor(value:ColorTransform) + { + this._endColor = value; + this.updateColorData(); + } + + /** + * Defines the number of segments. + */ + public get numSegmentPoint():number /*int*/ + { + return this._numSegmentPoint; + } + + /** + * Defines the key points of color + */ + public get segmentPoints():Array + { + return this._segmentPoints; + } + + public set segmentPoints(value:Array) + { + this._segmentPoints = value; + this.updateColorData(); + } + + public get usesMultiplier():boolean + { + return this._usesMultiplier; + } + + public get usesOffset():boolean + { + return this._usesOffset; + } + + constructor(animator:ParticleAnimator, particleSegmentedColorNode:ParticleSegmentedColorNode) + { + super(animator, particleSegmentedColorNode); + + this._usesMultiplier = particleSegmentedColorNode._iUsesMultiplier; + this._usesOffset = particleSegmentedColorNode._iUsesOffset; + this._startColor = particleSegmentedColorNode._iStartColor; + this._endColor = particleSegmentedColorNode._iEndColor; + this._segmentPoints = particleSegmentedColorNode._iSegmentPoints; + this._numSegmentPoint = particleSegmentedColorNode._iNumSegmentPoint; + this.updateColorData(); + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (animationRegisterCache.needFragmentAnimation) { + if (this._numSegmentPoint > 0) + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.TIME_DATA_INDEX), this._timeLifeData[0], this._timeLifeData[1], this._timeLifeData[2], this._timeLifeData[3]); + if (this._usesMultiplier) + animationRegisterCache.setVertexConstFromArray(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.START_MULTIPLIER_INDEX), this._multiplierData); + if (this._usesOffset) + animationRegisterCache.setVertexConstFromArray(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSegmentedColorState.START_OFFSET_INDEX), this._offsetData); + } + } + + private updateColorData() + { + this._timeLifeData = new Array(); + this._multiplierData = new Array(); + this._offsetData = new Array(); + var i:number /*int*/; + for (i = 0; i < this._numSegmentPoint; i++) { + if (i == 0) + this._timeLifeData.push(this._segmentPoints[i].life); + else + this._timeLifeData.push(this._segmentPoints[i].life - this._segmentPoints[i - 1].life); + } + if (this._numSegmentPoint == 0) + this._timeLifeData.push(1); + else + this._timeLifeData.push(1 - this._segmentPoints[i - 1].life); + + if (this._usesMultiplier) { + this._multiplierData.push(this._startColor.redMultiplier, this._startColor.greenMultiplier, this._startColor.blueMultiplier, this._startColor.alphaMultiplier); + for (i = 0; i < this._numSegmentPoint; i++) { + if (i == 0) + this._multiplierData.push((this._segmentPoints[i].color.redMultiplier - this._startColor.redMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.greenMultiplier - this._startColor.greenMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.blueMultiplier - this._startColor.blueMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.alphaMultiplier - this._startColor.alphaMultiplier)/this._timeLifeData[i]); + else + this._multiplierData.push((this._segmentPoints[i].color.redMultiplier - this._segmentPoints[i - 1].color.redMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.greenMultiplier - this._segmentPoints[i - 1].color.greenMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.blueMultiplier - this._segmentPoints[i - 1].color.blueMultiplier)/this._timeLifeData[i], (this._segmentPoints[i].color.alphaMultiplier - this._segmentPoints[i - 1].color.alphaMultiplier)/this._timeLifeData[i]); + } + if (this._numSegmentPoint == 0) + this._multiplierData.push(this._endColor.redMultiplier - this._startColor.redMultiplier, this._endColor.greenMultiplier - this._startColor.greenMultiplier, this._endColor.blueMultiplier - this._startColor.blueMultiplier, this._endColor.alphaMultiplier - this._startColor.alphaMultiplier); + else + this._multiplierData.push((this._endColor.redMultiplier - this._segmentPoints[i - 1].color.redMultiplier)/this._timeLifeData[i], (this._endColor.greenMultiplier - this._segmentPoints[i - 1].color.greenMultiplier)/this._timeLifeData[i], (this._endColor.blueMultiplier - this._segmentPoints[i - 1].color.blueMultiplier)/this._timeLifeData[i], (this._endColor.alphaMultiplier - this._segmentPoints[i - 1].color.alphaMultiplier)/this._timeLifeData[i]); + } + + if (this._usesOffset) { + this._offsetData.push(this._startColor.redOffset/255, this._startColor.greenOffset/255, this._startColor.blueOffset/255, this._startColor.alphaOffset/255); + for (i = 0; i < this._numSegmentPoint; i++) { + if (i == 0) + this._offsetData.push((this._segmentPoints[i].color.redOffset - this._startColor.redOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.greenOffset - this._startColor.greenOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.blueOffset - this._startColor.blueOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.alphaOffset - this._startColor.alphaOffset)/this._timeLifeData[i]/255); + else + this._offsetData.push((this._segmentPoints[i].color.redOffset - this._segmentPoints[i - 1].color.redOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.greenOffset - this._segmentPoints[i - 1].color.greenOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.blueOffset - this._segmentPoints[i - 1].color.blueOffset)/this._timeLifeData[i]/255, (this._segmentPoints[i].color.alphaOffset - this._segmentPoints[i - 1].color.alphaOffset)/this._timeLifeData[i]/255); + } + if (this._numSegmentPoint == 0) + this._offsetData.push((this._endColor.redOffset - this._startColor.redOffset)/255, (this._endColor.greenOffset - this._startColor.greenOffset)/255, (this._endColor.blueOffset - this._startColor.blueOffset)/255, (this._endColor.alphaOffset - this._startColor.alphaOffset)/255); + else + this._offsetData.push((this._endColor.redOffset - this._segmentPoints[i - 1].color.redOffset)/this._timeLifeData[i]/255, (this._endColor.greenOffset - this._segmentPoints[i - 1].color.greenOffset)/this._timeLifeData[i]/255, (this._endColor.blueOffset - this._segmentPoints[i - 1].color.blueOffset)/this._timeLifeData[i]/255, (this._endColor.alphaOffset - this._segmentPoints[i - 1].color.alphaOffset)/this._timeLifeData[i]/255); + } + //cut off the data + this._timeLifeData.length = 4; + } +} + +export = ParticleSegmentedColorState; \ No newline at end of file diff --git a/lib/animators/states/ParticleSpriteSheetState.js b/lib/animators/states/ParticleSpriteSheetState.js new file mode 100755 index 000000000..17993592b --- /dev/null +++ b/lib/animators/states/ParticleSpriteSheetState.js @@ -0,0 +1,94 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleSpriteSheetState = (function (_super) { + __extends(ParticleSpriteSheetState, _super); + function ParticleSpriteSheetState(animator, particleSpriteSheetNode) { + _super.call(this, animator, particleSpriteSheetNode); + this._particleSpriteSheetNode = particleSpriteSheetNode; + this._usesCycle = this._particleSpriteSheetNode._iUsesCycle; + this._usesPhase = this._particleSpriteSheetNode._iUsesCycle; + this._totalFrames = this._particleSpriteSheetNode._iTotalFrames; + this._numColumns = this._particleSpriteSheetNode._iNumColumns; + this._numRows = this._particleSpriteSheetNode._iNumRows; + this._cycleDuration = this._particleSpriteSheetNode._iCycleDuration; + this._cyclePhase = this._particleSpriteSheetNode._iCyclePhase; + this.updateSpriteSheetData(); + } + Object.defineProperty(ParticleSpriteSheetState.prototype, "cyclePhase", { + /** + * Defines the cycle phase, when in global mode. Defaults to zero. + */ + get: function () { + return this._cyclePhase; + }, + set: function (value) { + this._cyclePhase = value; + this.updateSpriteSheetData(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleSpriteSheetState.prototype, "cycleDuration", { + /** + * Defines the cycle duration in seconds, when in global mode. Defaults to 1. + */ + get: function () { + return this._cycleDuration; + }, + set: function (value) { + this._cycleDuration = value; + this.updateSpriteSheetData(); + }, + enumerable: true, + configurable: true + }); + ParticleSpriteSheetState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (animationRegisterCache.needUVAnimation) { + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSpriteSheetState.UV_INDEX_0), this._spriteSheetData[0], this._spriteSheetData[1], this._spriteSheetData[2], this._spriteSheetData[3]); + if (this._usesCycle) { + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSpriteSheetState.UV_INDEX_1); + if (this._particleSpriteSheetNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + if (this._usesPhase) + animationSubGeometry.activateVertexBuffer(index, this._particleSpriteSheetNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + else + animationSubGeometry.activateVertexBuffer(index, this._particleSpriteSheetNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_2); + } + else + animationRegisterCache.setVertexConst(index, this._spriteSheetData[4], this._spriteSheetData[5]); + } + } + }; + ParticleSpriteSheetState.prototype.updateSpriteSheetData = function () { + this._spriteSheetData = new Array(8); + var uTotal = this._totalFrames / this._numColumns; + this._spriteSheetData[0] = uTotal; + this._spriteSheetData[1] = 1 / this._numColumns; + this._spriteSheetData[2] = 1 / this._numRows; + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw (new Error("the cycle duration must be greater than zero")); + this._spriteSheetData[4] = uTotal / this._cycleDuration; + this._spriteSheetData[5] = this._cycleDuration; + if (this._usesPhase) + this._spriteSheetData[6] = this._cyclePhase; + } + }; + /** @private */ + ParticleSpriteSheetState.UV_INDEX_0 = 0; + /** @private */ + ParticleSpriteSheetState.UV_INDEX_1 = 1; + return ParticleSpriteSheetState; +})(ParticleStateBase); +module.exports = ParticleSpriteSheetState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlespritesheetstate.ts"],"names":["ParticleSpriteSheetState","ParticleSpriteSheetState.constructor","ParticleSpriteSheetState.cyclePhase","ParticleSpriteSheetState.cycleDuration","ParticleSpriteSheetState.setRenderState","ParticleSpriteSheetState.updateSpriteSheetData"],"mappings":"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","file":"animators/states/ParticleSpriteSheetState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLVertexBufferFormat\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticlePropertiesMode\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticlePropertiesMode\");\nimport ParticleSpriteSheetNode\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleSpriteSheetNode\");\nimport ParticleStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ParticleStateBase\");\n\n/**\n * ...\n */\nclass ParticleSpriteSheetState extends ParticleStateBase\n{\n\t/** @private */\n\tpublic static UV_INDEX_0:number /*uint*/ = 0;\n\n\t/** @private */\n\tpublic static UV_INDEX_1:number /*uint*/ = 1;\n\n\tprivate _particleSpriteSheetNode:ParticleSpriteSheetNode;\n\tprivate _usesCycle:boolean;\n\tprivate _usesPhase:boolean;\n\tprivate _totalFrames:number /*int*/;\n\tprivate _numColumns:number /*int*/;\n\tprivate _numRows:number /*int*/;\n\tprivate _cycleDuration:number;\n\tprivate _cyclePhase:number;\n\tprivate _spriteSheetData:Array<number>;\n\n\t/**\n\t * Defines the cycle phase, when in global mode. Defaults to zero.\n\t */\n\tpublic get cyclePhase():number\n\t{\n\t\treturn this._cyclePhase;\n\t}\n\n\tpublic set cyclePhase(value:number)\n\t{\n\t\tthis._cyclePhase = value;\n\n\t\tthis.updateSpriteSheetData();\n\t}\n\n\t/**\n\t * Defines the cycle duration in seconds, when in global mode. Defaults to 1.\n\t */\n\tpublic get cycleDuration():number\n\t{\n\t\treturn this._cycleDuration;\n\t}\n\n\tpublic set cycleDuration(value:number)\n\t{\n\t\tthis._cycleDuration = value;\n\n\t\tthis.updateSpriteSheetData();\n\t}\n\n\tconstructor(animator:ParticleAnimator, particleSpriteSheetNode:ParticleSpriteSheetNode)\n\t{\n\t\tsuper(animator, particleSpriteSheetNode);\n\n\t\tthis._particleSpriteSheetNode = particleSpriteSheetNode;\n\n\t\tthis._usesCycle = this._particleSpriteSheetNode._iUsesCycle;\n\t\tthis._usesPhase = this._particleSpriteSheetNode._iUsesCycle;\n\t\tthis._totalFrames = this._particleSpriteSheetNode._iTotalFrames;\n\t\tthis._numColumns = this._particleSpriteSheetNode._iNumColumns;\n\t\tthis._numRows = this._particleSpriteSheetNode._iNumRows;\n\t\tthis._cycleDuration = this._particleSpriteSheetNode._iCycleDuration;\n\t\tthis._cyclePhase = this._particleSpriteSheetNode._iCyclePhase;\n\n\t\tthis.updateSpriteSheetData();\n\t}\n\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\t\tif (animationRegisterCache.needUVAnimation) {\n\t\t\tanimationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSpriteSheetState.UV_INDEX_0), this._spriteSheetData[0], this._spriteSheetData[1], this._spriteSheetData[2], this._spriteSheetData[3]);\n\t\t\tif (this._usesCycle) {\n\t\t\t\tvar index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSpriteSheetState.UV_INDEX_1);\n\t\t\t\tif (this._particleSpriteSheetNode.mode == ParticlePropertiesMode.LOCAL_STATIC) {\n\t\t\t\t\tif (this._usesPhase)\n\t\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleSpriteSheetNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3);\n\t\t\t\t\telse\n\t\t\t\t\t\tanimationSubGeometry.activateVertexBuffer(index, this._particleSpriteSheetNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_2);\n\t\t\t\t} else\n\t\t\t\t\tanimationRegisterCache.setVertexConst(index, this._spriteSheetData[4], this._spriteSheetData[5]);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate updateSpriteSheetData()\n\t{\n\t\tthis._spriteSheetData = new Array<number>(8);\n\n\t\tvar uTotal:number = this._totalFrames/this._numColumns;\n\n\t\tthis._spriteSheetData[0] = uTotal;\n\t\tthis._spriteSheetData[1] = 1/this._numColumns;\n\t\tthis._spriteSheetData[2] = 1/this._numRows;\n\n\t\tif (this._usesCycle) {\n\t\t\tif (this._cycleDuration <= 0)\n\t\t\t\tthrow(new Error(\"the cycle duration must be greater than zero\"));\n\t\t\tthis._spriteSheetData[4] = uTotal/this._cycleDuration;\n\t\t\tthis._spriteSheetData[5] = this._cycleDuration;\n\t\t\tif (this._usesPhase)\n\t\t\t\tthis._spriteSheetData[6] = this._cyclePhase;\n\t\t}\n\t}\n}\n\nexport = ParticleSpriteSheetState;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleSpriteSheetState.ts b/lib/animators/states/ParticleSpriteSheetState.ts new file mode 100644 index 000000000..39952bb94 --- /dev/null +++ b/lib/animators/states/ParticleSpriteSheetState.ts @@ -0,0 +1,121 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleSpriteSheetNode = require("awayjs-renderergl/lib/animators/nodes/ParticleSpriteSheetNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleSpriteSheetState extends ParticleStateBase +{ + /** @private */ + public static UV_INDEX_0:number /*uint*/ = 0; + + /** @private */ + public static UV_INDEX_1:number /*uint*/ = 1; + + private _particleSpriteSheetNode:ParticleSpriteSheetNode; + private _usesCycle:boolean; + private _usesPhase:boolean; + private _totalFrames:number /*int*/; + private _numColumns:number /*int*/; + private _numRows:number /*int*/; + private _cycleDuration:number; + private _cyclePhase:number; + private _spriteSheetData:Array; + + /** + * Defines the cycle phase, when in global mode. Defaults to zero. + */ + public get cyclePhase():number + { + return this._cyclePhase; + } + + public set cyclePhase(value:number) + { + this._cyclePhase = value; + + this.updateSpriteSheetData(); + } + + /** + * Defines the cycle duration in seconds, when in global mode. Defaults to 1. + */ + public get cycleDuration():number + { + return this._cycleDuration; + } + + public set cycleDuration(value:number) + { + this._cycleDuration = value; + + this.updateSpriteSheetData(); + } + + constructor(animator:ParticleAnimator, particleSpriteSheetNode:ParticleSpriteSheetNode) + { + super(animator, particleSpriteSheetNode); + + this._particleSpriteSheetNode = particleSpriteSheetNode; + + this._usesCycle = this._particleSpriteSheetNode._iUsesCycle; + this._usesPhase = this._particleSpriteSheetNode._iUsesCycle; + this._totalFrames = this._particleSpriteSheetNode._iTotalFrames; + this._numColumns = this._particleSpriteSheetNode._iNumColumns; + this._numRows = this._particleSpriteSheetNode._iNumRows; + this._cycleDuration = this._particleSpriteSheetNode._iCycleDuration; + this._cyclePhase = this._particleSpriteSheetNode._iCyclePhase; + + this.updateSpriteSheetData(); + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (animationRegisterCache.needUVAnimation) { + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSpriteSheetState.UV_INDEX_0), this._spriteSheetData[0], this._spriteSheetData[1], this._spriteSheetData[2], this._spriteSheetData[3]); + if (this._usesCycle) { + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleSpriteSheetState.UV_INDEX_1); + if (this._particleSpriteSheetNode.mode == ParticlePropertiesMode.LOCAL_STATIC) { + if (this._usesPhase) + animationSubGeometry.activateVertexBuffer(index, this._particleSpriteSheetNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + else + animationSubGeometry.activateVertexBuffer(index, this._particleSpriteSheetNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_2); + } else + animationRegisterCache.setVertexConst(index, this._spriteSheetData[4], this._spriteSheetData[5]); + } + } + } + + private updateSpriteSheetData() + { + this._spriteSheetData = new Array(8); + + var uTotal:number = this._totalFrames/this._numColumns; + + this._spriteSheetData[0] = uTotal; + this._spriteSheetData[1] = 1/this._numColumns; + this._spriteSheetData[2] = 1/this._numRows; + + if (this._usesCycle) { + if (this._cycleDuration <= 0) + throw(new Error("the cycle duration must be greater than zero")); + this._spriteSheetData[4] = uTotal/this._cycleDuration; + this._spriteSheetData[5] = this._cycleDuration; + if (this._usesPhase) + this._spriteSheetData[6] = this._cyclePhase; + } + } +} + +export = ParticleSpriteSheetState; \ No newline at end of file diff --git a/lib/animators/states/ParticleStateBase.js b/lib/animators/states/ParticleStateBase.js new file mode 100755 index 000000000..d1f276583 --- /dev/null +++ b/lib/animators/states/ParticleStateBase.js @@ -0,0 +1,74 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +/** + * ... + */ +var ParticleStateBase = (function (_super) { + __extends(ParticleStateBase, _super); + function ParticleStateBase(animator, particleNode, needUpdateTime) { + if (needUpdateTime === void 0) { needUpdateTime = false; } + _super.call(this, animator, particleNode); + this._pDynamicProperties = new Array(); + this._pDynamicPropertiesDirty = new Object(); + this._particleNode = particleNode; + this._pNeedUpdateTime = needUpdateTime; + } + Object.defineProperty(ParticleStateBase.prototype, "needUpdateTime", { + get: function () { + return this._pNeedUpdateTime; + }, + enumerable: true, + configurable: true + }); + ParticleStateBase.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + }; + ParticleStateBase.prototype._pUpdateDynamicProperties = function (animationSubGeometry) { + this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId] = true; + var animationParticles = animationSubGeometry.animationParticles; + var vertexData = animationSubGeometry.vertexData; + var totalLenOfOneVertex = animationSubGeometry.totalLenOfOneVertex; + var dataLength = this._particleNode.dataLength; + var dataOffset = this._particleNode._iDataOffset; + var vertexLength /*uint*/; + // var particleOffset:number /*uint*/; + var startingOffset /*uint*/; + var vertexOffset /*uint*/; + var data; + var animationParticle; + // var numParticles:number /*uint*/ = _positions.length/dataLength; + var numParticles = this._pDynamicProperties.length; + var i = 0; + var j = 0; + var k = 0; + while (i < numParticles) { + while (j < numParticles && (animationParticle = animationParticles[j]).index == i) { + data = this._pDynamicProperties[i]; + vertexLength = animationParticle.numVertices * totalLenOfOneVertex; + startingOffset = animationParticle.startVertexIndex * totalLenOfOneVertex + dataOffset; + for (k = 0; k < vertexLength; k += totalLenOfOneVertex) { + vertexOffset = startingOffset + k; + for (k = 0; k < vertexLength; k += totalLenOfOneVertex) { + vertexOffset = startingOffset + k; + vertexData[vertexOffset++] = data.x; + vertexData[vertexOffset++] = data.y; + vertexData[vertexOffset++] = data.z; + if (dataLength == 4) + vertexData[vertexOffset++] = data.w; + } + } + j++; + } + i++; + } + animationSubGeometry.invalidateBuffer(); + }; + return ParticleStateBase; +})(AnimationStateBase); +module.exports = ParticleStateBase; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/particlestatebase.ts"],"names":["ParticleStateBase","ParticleStateBase.constructor","ParticleStateBase.needUpdateTime","ParticleStateBase.setRenderState","ParticleStateBase._pUpdateDynamicProperties"],"mappings":"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","file":"animators/states/ParticleStateBase.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport AnimationRegisterCache\t\t\t= require(\"awayjs-stagegl/lib/animators/data/AnimationRegisterCache\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\n\nimport ParticleAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/ParticleAnimator\");\nimport AnimationSubGeometry\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/AnimationSubGeometry\");\nimport ParticleAnimationData\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleAnimationData\");\nimport ParticleNodeBase\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/ParticleNodeBase\");\nimport AnimationStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/AnimationStateBase\");\n\n/**\n * ...\n */\nclass ParticleStateBase extends AnimationStateBase\n{\n\tprivate _particleNode:ParticleNodeBase;\n\n\tpublic _pDynamicProperties:Array<Vector3D> = new Array<Vector3D>();\n\tpublic _pDynamicPropertiesDirty:Object = new Object();\n\n\tpublic _pNeedUpdateTime:boolean;\n\n\tconstructor(animator:ParticleAnimator, particleNode:ParticleNodeBase, needUpdateTime:boolean = false)\n\t{\n\t\tsuper(animator, particleNode);\n\n\t\tthis._particleNode = particleNode;\n\t\tthis._pNeedUpdateTime = needUpdateTime;\n\t}\n\n\tpublic get needUpdateTime():boolean\n\t{\n\t\treturn this._pNeedUpdateTime;\n\t}\n\n\tpublic setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera)\n\t{\n\n\t}\n\n\tpublic _pUpdateDynamicProperties(animationSubGeometry:AnimationSubGeometry)\n\t{\n\t\tthis._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId] = true;\n\n\t\tvar animationParticles:Array<ParticleAnimationData> = animationSubGeometry.animationParticles;\n\t\tvar vertexData:Array<number> = animationSubGeometry.vertexData;\n\t\tvar totalLenOfOneVertex:number /*uint*/ = animationSubGeometry.totalLenOfOneVertex;\n\t\tvar dataLength:number /*uint*/ = this._particleNode.dataLength;\n\t\tvar dataOffset:number /*uint*/ = this._particleNode._iDataOffset;\n\t\tvar vertexLength:number /*uint*/;\n\t\t//\t\t\tvar particleOffset:number /*uint*/;\n\t\tvar startingOffset:number /*uint*/;\n\t\tvar vertexOffset:number /*uint*/;\n\t\tvar data:Vector3D;\n\t\tvar animationParticle:ParticleAnimationData;\n\n\t\t//\t\t\tvar numParticles:number /*uint*/ = _positions.length/dataLength;\n\t\tvar numParticles:number /*uint*/ = this._pDynamicProperties.length;\n\t\tvar i:number /*uint*/ = 0;\n\t\tvar j:number /*uint*/ = 0;\n\t\tvar k:number /*uint*/ = 0;\n\n\t\t//loop through all particles\n\t\twhile (i < numParticles) {\n\t\t\t//loop through each particle data for the current particle\n\t\t\twhile (j < numParticles && (animationParticle = animationParticles[j]).index == i) {\n\t\t\t\tdata = this._pDynamicProperties[i];\n\t\t\t\tvertexLength = animationParticle.numVertices*totalLenOfOneVertex;\n\t\t\t\tstartingOffset = animationParticle.startVertexIndex*totalLenOfOneVertex + dataOffset;\n\t\t\t\t//loop through each vertex in the particle data\n\t\t\t\tfor (k = 0; k < vertexLength; k += totalLenOfOneVertex) {\n\t\t\t\t\tvertexOffset = startingOffset + k;\n\t\t\t\t\t//\t\t\t\t\t\tparticleOffset = i * dataLength;\n\t\t\t\t\t//loop through all vertex data for the current particle data\n\t\t\t\t\tfor (k = 0; k < vertexLength; k += totalLenOfOneVertex) {\n\t\t\t\t\t\tvertexOffset = startingOffset + k;\n\t\t\t\t\t\tvertexData[vertexOffset++] = data.x;\n\t\t\t\t\t\tvertexData[vertexOffset++] = data.y;\n\t\t\t\t\t\tvertexData[vertexOffset++] = data.z;\n\n\t\t\t\t\t\tif (dataLength == 4)\n\t\t\t\t\t\t\tvertexData[vertexOffset++] = data.w;\n\t\t\t\t\t}\n\t\t\t\t\t\t//loop through each value in the particle vertex\n\t\t\t\t\t\t//\t\t\t\t\t\tswitch(dataLength) {\n\t\t\t\t\t\t//\t\t\t\t\t\t\tcase 4:\n\t\t\t\t\t\t//\t\t\t\t\t\t\t\tvertexData[vertexOffset++] = _positions[particleOffset++];\n\t\t\t\t\t\t//\t\t\t\t\t\t\tcase 3:\n\t\t\t\t\t\t//\t\t\t\t\t\t\t\tvertexData[vertexOffset++] = _positions[particleOffset++];\n\t\t\t\t\t\t//\t\t\t\t\t\t\tcase 2:\n\t\t\t\t\t\t//\t\t\t\t\t\t\t\tvertexData[vertexOffset++] = _positions[particleOffset++];\n\t\t\t\t\t\t//\t\t\t\t\t\t\tcase 1:\n\t\t\t\t\t\t//\t\t\t\t\t\t\t\tvertexData[vertexOffset++] = _positions[particleOffset++];\n\t\t\t\t\t\t//\t\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tj++;\n\t\t\t}\n\t\t\ti++;\n\t\t}\n\n\t\tanimationSubGeometry.invalidateBuffer();\n\t}\n\n}\n\nexport = ParticleStateBase;"]} \ No newline at end of file diff --git a/lib/animators/states/ParticleStateBase.ts b/lib/animators/states/ParticleStateBase.ts new file mode 100644 index 000000000..919d4c083 --- /dev/null +++ b/lib/animators/states/ParticleStateBase.ts @@ -0,0 +1,109 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticleAnimationData = require("awayjs-renderergl/lib/animators/data/ParticleAnimationData"); +import ParticleNodeBase = require("awayjs-renderergl/lib/animators/nodes/ParticleNodeBase"); +import AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); + +/** + * ... + */ +class ParticleStateBase extends AnimationStateBase +{ + private _particleNode:ParticleNodeBase; + + public _pDynamicProperties:Array = new Array(); + public _pDynamicPropertiesDirty:Object = new Object(); + + public _pNeedUpdateTime:boolean; + + constructor(animator:ParticleAnimator, particleNode:ParticleNodeBase, needUpdateTime:boolean = false) + { + super(animator, particleNode); + + this._particleNode = particleNode; + this._pNeedUpdateTime = needUpdateTime; + } + + public get needUpdateTime():boolean + { + return this._pNeedUpdateTime; + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + + } + + public _pUpdateDynamicProperties(animationSubGeometry:AnimationSubGeometry) + { + this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId] = true; + + var animationParticles:Array = animationSubGeometry.animationParticles; + var vertexData:Array = animationSubGeometry.vertexData; + var totalLenOfOneVertex:number /*uint*/ = animationSubGeometry.totalLenOfOneVertex; + var dataLength:number /*uint*/ = this._particleNode.dataLength; + var dataOffset:number /*uint*/ = this._particleNode._iDataOffset; + var vertexLength:number /*uint*/; + // var particleOffset:number /*uint*/; + var startingOffset:number /*uint*/; + var vertexOffset:number /*uint*/; + var data:Vector3D; + var animationParticle:ParticleAnimationData; + + // var numParticles:number /*uint*/ = _positions.length/dataLength; + var numParticles:number /*uint*/ = this._pDynamicProperties.length; + var i:number /*uint*/ = 0; + var j:number /*uint*/ = 0; + var k:number /*uint*/ = 0; + + //loop through all particles + while (i < numParticles) { + //loop through each particle data for the current particle + while (j < numParticles && (animationParticle = animationParticles[j]).index == i) { + data = this._pDynamicProperties[i]; + vertexLength = animationParticle.numVertices*totalLenOfOneVertex; + startingOffset = animationParticle.startVertexIndex*totalLenOfOneVertex + dataOffset; + //loop through each vertex in the particle data + for (k = 0; k < vertexLength; k += totalLenOfOneVertex) { + vertexOffset = startingOffset + k; + // particleOffset = i * dataLength; + //loop through all vertex data for the current particle data + for (k = 0; k < vertexLength; k += totalLenOfOneVertex) { + vertexOffset = startingOffset + k; + vertexData[vertexOffset++] = data.x; + vertexData[vertexOffset++] = data.y; + vertexData[vertexOffset++] = data.z; + + if (dataLength == 4) + vertexData[vertexOffset++] = data.w; + } + //loop through each value in the particle vertex + // switch(dataLength) { + // case 4: + // vertexData[vertexOffset++] = _positions[particleOffset++]; + // case 3: + // vertexData[vertexOffset++] = _positions[particleOffset++]; + // case 2: + // vertexData[vertexOffset++] = _positions[particleOffset++]; + // case 1: + // vertexData[vertexOffset++] = _positions[particleOffset++]; + // } + } + j++; + } + i++; + } + + animationSubGeometry.invalidateBuffer(); + } + +} + +export = ParticleStateBase; \ No newline at end of file diff --git a/lib/animators/states/ParticleTimeState.js b/lib/animators/states/ParticleTimeState.js new file mode 100755 index 000000000..51594a7e4 --- /dev/null +++ b/lib/animators/states/ParticleTimeState.js @@ -0,0 +1,31 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleTimeState = (function (_super) { + __extends(ParticleTimeState, _super); + function ParticleTimeState(animator, particleTimeNode) { + _super.call(this, animator, particleTimeNode, true); + this._particleTimeNode = particleTimeNode; + } + ParticleTimeState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleTimeState.TIME_STREAM_INDEX), this._particleTimeNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + var particleTime = this._pTime / 1000; + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleTimeState.TIME_CONSTANT_INDEX), particleTime, particleTime, particleTime, particleTime); + }; + /** @private */ + ParticleTimeState.TIME_STREAM_INDEX = 0; + /** @private */ + ParticleTimeState.TIME_CONSTANT_INDEX = 1; + return ParticleTimeState; +})(ParticleStateBase); +module.exports = ParticleTimeState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/ParticleTimeState.ts b/lib/animators/states/ParticleTimeState.ts new file mode 100644 index 000000000..2f6ee07e8 --- /dev/null +++ b/lib/animators/states/ParticleTimeState.ts @@ -0,0 +1,44 @@ +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleTimeNode = require("awayjs-renderergl/lib/animators/nodes/ParticleTimeNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleTimeState extends ParticleStateBase +{ + /** @private */ + public static TIME_STREAM_INDEX:number /*uint*/ = 0; + + /** @private */ + public static TIME_CONSTANT_INDEX:number /*uint*/ = 1; + + private _particleTimeNode:ParticleTimeNode; + + constructor(animator:ParticleAnimator, particleTimeNode:ParticleTimeNode) + { + super(animator, particleTimeNode, true); + + this._particleTimeNode = particleTimeNode; + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + animationSubGeometry.activateVertexBuffer(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleTimeState.TIME_STREAM_INDEX), this._particleTimeNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_4); + + var particleTime:number = this._pTime/1000; + animationRegisterCache.setVertexConst(animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleTimeState.TIME_CONSTANT_INDEX), particleTime, particleTime, particleTime, particleTime); + } + +} + +export = ParticleTimeState; \ No newline at end of file diff --git a/lib/animators/states/ParticleUVState.js b/lib/animators/states/ParticleUVState.js new file mode 100755 index 000000000..3c9d8b8f5 --- /dev/null +++ b/lib/animators/states/ParticleUVState.js @@ -0,0 +1,30 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleUVState = (function (_super) { + __extends(ParticleUVState, _super); + function ParticleUVState(animator, particleUVNode) { + _super.call(this, animator, particleUVNode); + this._particleUVNode = particleUVNode; + } + ParticleUVState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (animationRegisterCache.needUVAnimation) { + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleUVState.UV_INDEX); + var data = this._particleUVNode._iUvData; + animationRegisterCache.setVertexConst(index, data.x, data.y); + } + }; + /** @private */ + ParticleUVState.UV_INDEX = 0; + return ParticleUVState; +})(ParticleStateBase); +module.exports = ParticleUVState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/ParticleUVState.ts b/lib/animators/states/ParticleUVState.ts new file mode 100644 index 000000000..d66f7469f --- /dev/null +++ b/lib/animators/states/ParticleUVState.ts @@ -0,0 +1,41 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticleUVNode = require("awayjs-renderergl/lib/animators/nodes/ParticleUVNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleUVState extends ParticleStateBase +{ + /** @private */ + public static UV_INDEX:number /*uint*/ = 0; + + private _particleUVNode:ParticleUVNode; + + constructor(animator:ParticleAnimator, particleUVNode:ParticleUVNode) + { + super(animator, particleUVNode); + + this._particleUVNode = particleUVNode; + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (animationRegisterCache.needUVAnimation) { + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleUVState.UV_INDEX); + var data:Vector3D = this._particleUVNode._iUvData; + animationRegisterCache.setVertexConst(index, data.x, data.y); + } + } + +} + +export = ParticleUVState; \ No newline at end of file diff --git a/lib/animators/states/ParticleVelocityState.js b/lib/animators/states/ParticleVelocityState.js new file mode 100755 index 000000000..85016161e --- /dev/null +++ b/lib/animators/states/ParticleVelocityState.js @@ -0,0 +1,58 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); +var ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +var ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); +/** + * ... + */ +var ParticleVelocityState = (function (_super) { + __extends(ParticleVelocityState, _super); + function ParticleVelocityState(animator, particleVelocityNode) { + _super.call(this, animator, particleVelocityNode); + this._particleVelocityNode = particleVelocityNode; + this._velocity = this._particleVelocityNode._iVelocity; + } + Object.defineProperty(ParticleVelocityState.prototype, "velocity", { + /** + * Defines the default velocity vector of the state, used when in global mode. + */ + get: function () { + return this._velocity; + }, + set: function (value) { + this._velocity = value; + }, + enumerable: true, + configurable: true + }); + /** + * + */ + ParticleVelocityState.prototype.getVelocities = function () { + return this._pDynamicProperties; + }; + ParticleVelocityState.prototype.setVelocities = function (value) { + this._pDynamicProperties = value; + this._pDynamicPropertiesDirty = new Object(); + }; + ParticleVelocityState.prototype.setRenderState = function (stage, renderable, animationSubGeometry, animationRegisterCache, camera) { + if (this._particleVelocityNode.mode == ParticlePropertiesMode.LOCAL_DYNAMIC && !this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId]) + this._pUpdateDynamicProperties(animationSubGeometry); + var index = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleVelocityState.VELOCITY_INDEX); + if (this._particleVelocityNode.mode == ParticlePropertiesMode.GLOBAL) + animationRegisterCache.setVertexConst(index, this._velocity.x, this._velocity.y, this._velocity.z); + else + animationSubGeometry.activateVertexBuffer(index, this._particleVelocityNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + }; + /** @private */ + ParticleVelocityState.VELOCITY_INDEX = 0; + return ParticleVelocityState; +})(ParticleStateBase); +module.exports = ParticleVelocityState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/ParticleVelocityState.ts b/lib/animators/states/ParticleVelocityState.ts new file mode 100644 index 000000000..1aa8bb43c --- /dev/null +++ b/lib/animators/states/ParticleVelocityState.ts @@ -0,0 +1,76 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import AnimationRegisterCache = require("awayjs-stagegl/lib/animators/data/AnimationRegisterCache"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLVertexBufferFormat = require("awayjs-stagegl/lib/core/stagegl/ContextGLVertexBufferFormat"); + +import ParticleAnimator = require("awayjs-renderergl/lib/animators/ParticleAnimator"); +import AnimationSubGeometry = require("awayjs-renderergl/lib/animators/data/AnimationSubGeometry"); +import ParticlePropertiesMode = require("awayjs-renderergl/lib/animators/data/ParticlePropertiesMode"); +import ParticleVelocityNode = require("awayjs-renderergl/lib/animators/nodes/ParticleVelocityNode"); +import ParticleStateBase = require("awayjs-renderergl/lib/animators/states/ParticleStateBase"); + +/** + * ... + */ +class ParticleVelocityState extends ParticleStateBase +{ + /** @private */ + public static VELOCITY_INDEX:number /*int*/ = 0; + + private _particleVelocityNode:ParticleVelocityNode; + private _velocity:Vector3D; + + /** + * Defines the default velocity vector of the state, used when in global mode. + */ + public get velocity():Vector3D + { + return this._velocity; + } + + public set velocity(value:Vector3D) + { + this._velocity = value; + } + + /** + * + */ + public getVelocities():Array + { + return this._pDynamicProperties; + } + + public setVelocities(value:Array) + { + this._pDynamicProperties = value; + + this._pDynamicPropertiesDirty = new Object(); + } + + constructor(animator:ParticleAnimator, particleVelocityNode:ParticleVelocityNode) + { + super(animator, particleVelocityNode); + + this._particleVelocityNode = particleVelocityNode; + this._velocity = this._particleVelocityNode._iVelocity; + } + + public setRenderState(stage:Stage, renderable:RenderableBase, animationSubGeometry:AnimationSubGeometry, animationRegisterCache:AnimationRegisterCache, camera:Camera) + { + if (this._particleVelocityNode.mode == ParticlePropertiesMode.LOCAL_DYNAMIC && !this._pDynamicPropertiesDirty[animationSubGeometry._iUniqueId]) + this._pUpdateDynamicProperties(animationSubGeometry); + + var index:number /*int*/ = animationRegisterCache.getRegisterIndex(this._pAnimationNode, ParticleVelocityState.VELOCITY_INDEX); + + if (this._particleVelocityNode.mode == ParticlePropertiesMode.GLOBAL) + animationRegisterCache.setVertexConst(index, this._velocity.x, this._velocity.y, this._velocity.z); + else + animationSubGeometry.activateVertexBuffer(index, this._particleVelocityNode._iDataOffset, stage, ContextGLVertexBufferFormat.FLOAT_3); + } +} + +export = ParticleVelocityState; \ No newline at end of file diff --git a/lib/animators/states/SkeletonBinaryLERPState.js b/lib/animators/states/SkeletonBinaryLERPState.js new file mode 100755 index 000000000..a77755d1d --- /dev/null +++ b/lib/animators/states/SkeletonBinaryLERPState.js @@ -0,0 +1,117 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +/** + * + */ +var SkeletonBinaryLERPState = (function (_super) { + __extends(SkeletonBinaryLERPState, _super); + function SkeletonBinaryLERPState(animator, skeletonAnimationNode) { + _super.call(this, animator, skeletonAnimationNode); + this._blendWeight = 0; + this._skeletonPose = new SkeletonPose(); + this._skeletonPoseDirty = true; + this._skeletonAnimationNode = skeletonAnimationNode; + this._inputA = animator.getAnimationState(this._skeletonAnimationNode.inputA); + this._inputB = animator.getAnimationState(this._skeletonAnimationNode.inputB); + } + Object.defineProperty(SkeletonBinaryLERPState.prototype, "blendWeight", { + /** + * Defines a fractional value between 0 and 1 representing the blending ratio between inputA (0) and inputB (1), + * used to produce the skeleton pose output. + * + * @see inputA + * @see inputB + */ + get: function () { + return this._blendWeight; + }, + set: function (value) { + this._blendWeight = value; + this._pPositionDeltaDirty = true; + this._skeletonPoseDirty = true; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SkeletonBinaryLERPState.prototype.phase = function (value) { + this._skeletonPoseDirty = true; + this._pPositionDeltaDirty = true; + this._inputA.phase(value); + this._inputB.phase(value); + }; + /** + * @inheritDoc + */ + SkeletonBinaryLERPState.prototype._pUpdateTime = function (time /*int*/) { + this._skeletonPoseDirty = true; + this._inputA.update(time); + this._inputB.update(time); + _super.prototype._pUpdateTime.call(this, time); + }; + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + SkeletonBinaryLERPState.prototype.getSkeletonPose = function (skeleton) { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + return this._skeletonPose; + }; + /** + * @inheritDoc + */ + SkeletonBinaryLERPState.prototype._pUpdatePositionDelta = function () { + this._pPositionDeltaDirty = false; + var deltA = this._inputA.positionDelta; + var deltB = this._inputB.positionDelta; + this._pRootDelta.x = deltA.x + this._blendWeight * (deltB.x - deltA.x); + this._pRootDelta.y = deltA.y + this._blendWeight * (deltB.y - deltA.y); + this._pRootDelta.z = deltA.z + this._blendWeight * (deltB.z - deltA.z); + }; + /** + * Updates the output skeleton pose of the node based on the blendWeight value between input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + SkeletonBinaryLERPState.prototype.updateSkeletonPose = function (skeleton) { + this._skeletonPoseDirty = false; + var endPose; + var endPoses = this._skeletonPose.jointPoses; + var poses1 = this._inputA.getSkeletonPose(skeleton).jointPoses; + var poses2 = this._inputB.getSkeletonPose(skeleton).jointPoses; + var pose1, pose2; + var p1, p2; + var tr; + var numJoints = skeleton.numJoints; + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + for (var i = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + pose1 = poses1[i]; + pose2 = poses2[i]; + p1 = pose1.translation; + p2 = pose2.translation; + endPose.orientation.lerp(pose1.orientation, pose2.orientation, this._blendWeight); + tr = endPose.translation; + tr.x = p1.x + this._blendWeight * (p2.x - p1.x); + tr.y = p1.y + this._blendWeight * (p2.y - p1.y); + tr.z = p1.z + this._blendWeight * (p2.z - p1.z); + } + }; + return SkeletonBinaryLERPState; +})(AnimationStateBase); +module.exports = SkeletonBinaryLERPState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/skeletonbinarylerpstate.ts"],"names":["SkeletonBinaryLERPState","SkeletonBinaryLERPState.constructor","SkeletonBinaryLERPState.blendWeight","SkeletonBinaryLERPState.phase","SkeletonBinaryLERPState._pUpdateTime","SkeletonBinaryLERPState.getSkeletonPose","SkeletonBinaryLERPState._pUpdatePositionDelta","SkeletonBinaryLERPState.updateSkeletonPose"],"mappings":"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","file":"animators/states/SkeletonBinaryLERPState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\n\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport SkeletonBinaryLERPNode\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/SkeletonBinaryLERPNode\");\nimport AnimationStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/AnimationStateBase\");\nimport ISkeletonAnimationState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ISkeletonAnimationState\");\n\n/**\n *\n */\nclass SkeletonBinaryLERPState extends AnimationStateBase implements ISkeletonAnimationState\n{\n\tprivate _blendWeight:number = 0;\n\tprivate _skeletonAnimationNode:SkeletonBinaryLERPNode;\n\tprivate _skeletonPose:SkeletonPose = new SkeletonPose();\n\tprivate _skeletonPoseDirty:boolean = true;\n\tprivate _inputA:ISkeletonAnimationState;\n\tprivate _inputB:ISkeletonAnimationState;\n\n\t/**\n\t * Defines a fractional value between 0 and 1 representing the blending ratio between inputA (0) and inputB (1),\n\t * used to produce the skeleton pose output.\n\t *\n\t * @see inputA\n\t * @see inputB\n\t */\n\tpublic get blendWeight():number\n\t{\n\t\treturn this._blendWeight;\n\t}\n\n\tpublic set blendWeight(value:number)\n\t{\n\t\tthis._blendWeight = value;\n\n\t\tthis._pPositionDeltaDirty = true;\n\t\tthis._skeletonPoseDirty = true;\n\t}\n\n\tconstructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonBinaryLERPNode)\n\t{\n\t\tsuper(animator, skeletonAnimationNode);\n\n\t\tthis._skeletonAnimationNode = skeletonAnimationNode;\n\n\t\tthis._inputA = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.inputA);\n\t\tthis._inputB = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.inputB);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic phase(value:number)\n\t{\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tthis._pPositionDeltaDirty = true;\n\n\t\tthis._inputA.phase(value);\n\t\tthis._inputB.phase(value);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdateTime(time:number /*int*/)\n\t{\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tthis._inputA.update(time);\n\t\tthis._inputB.update(time);\n\n\t\tsuper._pUpdateTime(time);\n\t}\n\n\t/**\n\t * Returns the current skeleton pose of the animation in the clip based on the internal playhead position.\n\t */\n\tpublic getSkeletonPose(skeleton:Skeleton):SkeletonPose\n\t{\n\t\tif (this._skeletonPoseDirty)\n\t\t\tthis.updateSkeletonPose(skeleton);\n\n\t\treturn this._skeletonPose;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdatePositionDelta()\n\t{\n\t\tthis._pPositionDeltaDirty = false;\n\n\t\tvar deltA:Vector3D = this._inputA.positionDelta;\n\t\tvar deltB:Vector3D = this._inputB.positionDelta;\n\n\t\tthis._pRootDelta.x = deltA.x + this._blendWeight*(deltB.x - deltA.x);\n\t\tthis._pRootDelta.y = deltA.y + this._blendWeight*(deltB.y - deltA.y);\n\t\tthis._pRootDelta.z = deltA.z + this._blendWeight*(deltB.z - deltA.z);\n\t}\n\n\t/**\n\t * Updates the output skeleton pose of the node based on the blendWeight value between input nodes.\n\t *\n\t * @param skeleton The skeleton used by the animator requesting the ouput pose.\n\t */\n\tprivate updateSkeletonPose(skeleton:Skeleton)\n\t{\n\t\tthis._skeletonPoseDirty = false;\n\n\t\tvar endPose:JointPose;\n\t\tvar endPoses:Array<JointPose> = this._skeletonPose.jointPoses;\n\t\tvar poses1:Array<JointPose> = this._inputA.getSkeletonPose(skeleton).jointPoses;\n\t\tvar poses2:Array<JointPose> = this._inputB.getSkeletonPose(skeleton).jointPoses;\n\t\tvar pose1:JointPose, pose2:JointPose;\n\t\tvar p1:Vector3D, p2:Vector3D;\n\t\tvar tr:Vector3D;\n\t\tvar numJoints:number /*uint*/ = skeleton.numJoints;\n\n\t\t// :s\n\t\tif (endPoses.length != numJoints)\n\t\t\tendPoses.length = numJoints;\n\n\t\tfor (var i:number /*uint*/ = 0; i < numJoints; ++i) {\n\t\t\tendPose = endPoses[i];\n\n\t\t\tif (endPose == null)\n\t\t\t\tendPose = endPoses[i] = new JointPose();\n\n\t\t\tpose1 = poses1[i];\n\t\t\tpose2 = poses2[i];\n\t\t\tp1 = pose1.translation;\n\t\t\tp2 = pose2.translation;\n\n\t\t\tendPose.orientation.lerp(pose1.orientation, pose2.orientation, this._blendWeight);\n\n\t\t\ttr = endPose.translation;\n\t\t\ttr.x = p1.x + this._blendWeight*(p2.x - p1.x);\n\t\t\ttr.y = p1.y + this._blendWeight*(p2.y - p1.y);\n\t\t\ttr.z = p1.z + this._blendWeight*(p2.z - p1.z);\n\t\t}\n\t}\n}\n\nexport = SkeletonBinaryLERPState;"]} \ No newline at end of file diff --git a/lib/animators/states/SkeletonBinaryLERPState.ts b/lib/animators/states/SkeletonBinaryLERPState.ts new file mode 100644 index 000000000..5dee2247f --- /dev/null +++ b/lib/animators/states/SkeletonBinaryLERPState.ts @@ -0,0 +1,149 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import SkeletonBinaryLERPNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonBinaryLERPNode"); +import AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +import ISkeletonAnimationState = require("awayjs-renderergl/lib/animators/states/ISkeletonAnimationState"); + +/** + * + */ +class SkeletonBinaryLERPState extends AnimationStateBase implements ISkeletonAnimationState +{ + private _blendWeight:number = 0; + private _skeletonAnimationNode:SkeletonBinaryLERPNode; + private _skeletonPose:SkeletonPose = new SkeletonPose(); + private _skeletonPoseDirty:boolean = true; + private _inputA:ISkeletonAnimationState; + private _inputB:ISkeletonAnimationState; + + /** + * Defines a fractional value between 0 and 1 representing the blending ratio between inputA (0) and inputB (1), + * used to produce the skeleton pose output. + * + * @see inputA + * @see inputB + */ + public get blendWeight():number + { + return this._blendWeight; + } + + public set blendWeight(value:number) + { + this._blendWeight = value; + + this._pPositionDeltaDirty = true; + this._skeletonPoseDirty = true; + } + + constructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonBinaryLERPNode) + { + super(animator, skeletonAnimationNode); + + this._skeletonAnimationNode = skeletonAnimationNode; + + this._inputA = animator.getAnimationState(this._skeletonAnimationNode.inputA); + this._inputB = animator.getAnimationState(this._skeletonAnimationNode.inputB); + } + + /** + * @inheritDoc + */ + public phase(value:number) + { + this._skeletonPoseDirty = true; + + this._pPositionDeltaDirty = true; + + this._inputA.phase(value); + this._inputB.phase(value); + } + + /** + * @inheritDoc + */ + public _pUpdateTime(time:number /*int*/) + { + this._skeletonPoseDirty = true; + + this._inputA.update(time); + this._inputB.update(time); + + super._pUpdateTime(time); + } + + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + public getSkeletonPose(skeleton:Skeleton):SkeletonPose + { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + + return this._skeletonPose; + } + + /** + * @inheritDoc + */ + public _pUpdatePositionDelta() + { + this._pPositionDeltaDirty = false; + + var deltA:Vector3D = this._inputA.positionDelta; + var deltB:Vector3D = this._inputB.positionDelta; + + this._pRootDelta.x = deltA.x + this._blendWeight*(deltB.x - deltA.x); + this._pRootDelta.y = deltA.y + this._blendWeight*(deltB.y - deltA.y); + this._pRootDelta.z = deltA.z + this._blendWeight*(deltB.z - deltA.z); + } + + /** + * Updates the output skeleton pose of the node based on the blendWeight value between input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + private updateSkeletonPose(skeleton:Skeleton) + { + this._skeletonPoseDirty = false; + + var endPose:JointPose; + var endPoses:Array = this._skeletonPose.jointPoses; + var poses1:Array = this._inputA.getSkeletonPose(skeleton).jointPoses; + var poses2:Array = this._inputB.getSkeletonPose(skeleton).jointPoses; + var pose1:JointPose, pose2:JointPose; + var p1:Vector3D, p2:Vector3D; + var tr:Vector3D; + var numJoints:number /*uint*/ = skeleton.numJoints; + + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + + for (var i:number /*uint*/ = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + + pose1 = poses1[i]; + pose2 = poses2[i]; + p1 = pose1.translation; + p2 = pose2.translation; + + endPose.orientation.lerp(pose1.orientation, pose2.orientation, this._blendWeight); + + tr = endPose.translation; + tr.x = p1.x + this._blendWeight*(p2.x - p1.x); + tr.y = p1.y + this._blendWeight*(p2.y - p1.y); + tr.z = p1.z + this._blendWeight*(p2.z - p1.z); + } + } +} + +export = SkeletonBinaryLERPState; \ No newline at end of file diff --git a/lib/animators/states/SkeletonClipState.js b/lib/animators/states/SkeletonClipState.js new file mode 100755 index 000000000..958d9abbc --- /dev/null +++ b/lib/animators/states/SkeletonClipState.js @@ -0,0 +1,162 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var AnimationClipState = require("awayjs-renderergl/lib/animators/states/AnimationClipState"); +/** + * + */ +var SkeletonClipState = (function (_super) { + __extends(SkeletonClipState, _super); + function SkeletonClipState(animator, skeletonClipNode) { + _super.call(this, animator, skeletonClipNode); + this._rootPos = new Vector3D(); + this._skeletonPose = new SkeletonPose(); + this._skeletonPoseDirty = true; + this._skeletonClipNode = skeletonClipNode; + this._frames = this._skeletonClipNode.frames; + } + Object.defineProperty(SkeletonClipState.prototype, "currentPose", { + /** + * Returns the current skeleton pose frame of animation in the clip based on the internal playhead position. + */ + get: function () { + if (this._pFramesDirty) + this._pUpdateFrames(); + return this._currentPose; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SkeletonClipState.prototype, "nextPose", { + /** + * Returns the next skeleton pose frame of animation in the clip based on the internal playhead position. + */ + get: function () { + if (this._pFramesDirty) + this._pUpdateFrames(); + return this._nextPose; + }, + enumerable: true, + configurable: true + }); + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + SkeletonClipState.prototype.getSkeletonPose = function (skeleton) { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + return this._skeletonPose; + }; + /** + * @inheritDoc + */ + SkeletonClipState.prototype._pUpdateTime = function (time /*int*/) { + this._skeletonPoseDirty = true; + _super.prototype._pUpdateTime.call(this, time); + }; + /** + * @inheritDoc + */ + SkeletonClipState.prototype._pUpdateFrames = function () { + _super.prototype._pUpdateFrames.call(this); + this._currentPose = this._frames[this._pCurrentFrame]; + if (this._skeletonClipNode.looping && this._pNextFrame >= this._skeletonClipNode.lastFrame) { + this._nextPose = this._frames[0]; + this._pAnimator.dispatchCycleEvent(); + } + else + this._nextPose = this._frames[this._pNextFrame]; + }; + /** + * Updates the output skeleton pose of the node based on the internal playhead position. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + SkeletonClipState.prototype.updateSkeletonPose = function (skeleton) { + this._skeletonPoseDirty = false; + if (!this._skeletonClipNode.totalDuration) + return; + if (this._pFramesDirty) + this._pUpdateFrames(); + var currentPose = this._currentPose.jointPoses; + var nextPose = this._nextPose.jointPoses; + var numJoints = skeleton.numJoints; + var p1, p2; + var pose1, pose2; + var endPoses = this._skeletonPose.jointPoses; + var endPose; + var tr; + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + if ((numJoints != currentPose.length) || (numJoints != nextPose.length)) + throw new Error("joint counts don't match!"); + for (var i = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + pose1 = currentPose[i]; + pose2 = nextPose[i]; + p1 = pose1.translation; + p2 = pose2.translation; + if (this._skeletonClipNode.highQuality) + endPose.orientation.slerp(pose1.orientation, pose2.orientation, this._pBlendWeight); + else + endPose.orientation.lerp(pose1.orientation, pose2.orientation, this._pBlendWeight); + if (i > 0) { + tr = endPose.translation; + tr.x = p1.x + this._pBlendWeight * (p2.x - p1.x); + tr.y = p1.y + this._pBlendWeight * (p2.y - p1.y); + tr.z = p1.z + this._pBlendWeight * (p2.z - p1.z); + } + } + }; + /** + * @inheritDoc + */ + SkeletonClipState.prototype._pUpdatePositionDelta = function () { + this._pPositionDeltaDirty = false; + if (this._pFramesDirty) + this._pUpdateFrames(); + var p1, p2, p3; + var totalDelta = this._skeletonClipNode.totalDelta; + // jumping back, need to reset position + if ((this._pTimeDir > 0 && this._pNextFrame < this._pOldFrame) || (this._pTimeDir < 0 && this._pNextFrame > this._pOldFrame)) { + this._rootPos.x -= totalDelta.x * this._pTimeDir; + this._rootPos.y -= totalDelta.y * this._pTimeDir; + this._rootPos.z -= totalDelta.z * this._pTimeDir; + } + var dx = this._rootPos.x; + var dy = this._rootPos.y; + var dz = this._rootPos.z; + if (this._skeletonClipNode.stitchFinalFrame && this._pNextFrame == this._skeletonClipNode.lastFrame) { + p1 = this._frames[0].jointPoses[0].translation; + p2 = this._frames[1].jointPoses[0].translation; + p3 = this._currentPose.jointPoses[0].translation; + this._rootPos.x = p3.x + p1.x + this._pBlendWeight * (p2.x - p1.x); + this._rootPos.y = p3.y + p1.y + this._pBlendWeight * (p2.y - p1.y); + this._rootPos.z = p3.z + p1.z + this._pBlendWeight * (p2.z - p1.z); + } + else { + p1 = this._currentPose.jointPoses[0].translation; + p2 = this._frames[this._pNextFrame].jointPoses[0].translation; //cover the instances where we wrap the pose but still want the final frame translation values + this._rootPos.x = p1.x + this._pBlendWeight * (p2.x - p1.x); + this._rootPos.y = p1.y + this._pBlendWeight * (p2.y - p1.y); + this._rootPos.z = p1.z + this._pBlendWeight * (p2.z - p1.z); + } + this._pRootDelta.x = this._rootPos.x - dx; + this._pRootDelta.y = this._rootPos.y - dy; + this._pRootDelta.z = this._rootPos.z - dz; + this._pOldFrame = this._pNextFrame; + }; + return SkeletonClipState; +})(AnimationClipState); +module.exports = SkeletonClipState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/skeletonclipstate.ts"],"names":["SkeletonClipState","SkeletonClipState.constructor","SkeletonClipState.currentPose","SkeletonClipState.nextPose","SkeletonClipState.getSkeletonPose","SkeletonClipState._pUpdateTime","SkeletonClipState._pUpdateFrames","SkeletonClipState.updateSkeletonPose","SkeletonClipState._pUpdatePositionDelta"],"mappings":"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ACA,CAACA,GAACA,IAAIA,CAACA,SAASA,CAACA;YAC/CA,IAAIA,CAACA,QAAQA,CAACA,CAACA,IAAIA,UAAUA,CAACA,CAACA,GAACA,IAAIA,CAACA,SAASA,CAACA;QAChDA,CAACA;QAEDA,IAAIA,EAAEA,GAAUA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA;QAChCA,IAAIA,EAAEA,GAAUA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA;QAChCA,IAAIA,EAAEA,GAAUA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA;QAEhCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,iBAAiBA,CAACA,gBAAgBA,IAAIA,IAAIA,CAACA,WAAWA,IAAIA,IAAIA,CAACA,iBAAiBA,CAACA,SAASA,CAACA,CAACA,CAACA;YACrGA,EAAEA,GAAGA,IAAIA,CAACA,OAAOA,CAACA,CAACA,CAACA,CAACA,UAAUA,CAACA,CAACA,CAACA,CAACA,WAAWA,CAACA;YAC/CA,EAAEA,GAAGA,IAAIA,CAACA,OAAOA,CAACA,CAACA,CAACA,CAACA,UAAUA,CAACA,CAACA,CAACA,CAACA,WAAWA,CAACA;YAC/CA,EAAEA,GAAGA,IAAIA,CAACA,YAAYA,CAACA,UAAUA,CAACA,CAACA,CAACA,CAACA,WAAWA,CAACA;YAEjDA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,GAACA,CAACA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA,CAACA;YACjEA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,GAACA,CAACA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA,CAACA;YACjEA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,GAACA,CAACA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA,CAACA;QAClEA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,EAAEA,GAAGA,IAAIA,CAACA,YAAYA,CAACA,UAAUA,CAACA,CAACA,CAACA,CAACA,WAAWA,CAACA;YACjDA,EAAEA,GAAGA,IAAIA,CAACA,OAAOA,CAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,UAAUA,CAACA,CAACA,CAACA,CAACA,WAAWA,EAAEA,8FAA8FA;YAC7JA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,GAACA,CAACA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA,CAACA;YAC1DA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,GAACA,CAACA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA,CAACA;YAC1DA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,GAAGA,IAAIA,CAACA,aAAaA,GAACA,CAACA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA,CAACA;QAC3DA,CAACA;QAEDA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA;QAC1CA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA;QAC1CA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,IAAIA,CAACA,QAAQA,CAACA,CAACA,GAAGA,EAAEA,CAACA;QAE1CA,IAAIA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;IACpCA,CAACA;IACFR,wBAACA;AAADA,CAlLA,AAkLCA,EAlL+B,kBAAkB,EAkLjD;AAED,AAA2B,iBAAlB,iBAAiB,CAAC","file":"animators/states/SkeletonClipState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\n\nimport SkeletonAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/SkeletonAnimator\");\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport SkeletonClipNode\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/SkeletonClipNode\");\nimport AnimationClipState\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/AnimationClipState\");\nimport ISkeletonAnimationState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ISkeletonAnimationState\");\n\n/**\n *\n */\nclass SkeletonClipState extends AnimationClipState implements ISkeletonAnimationState\n{\n\tprivate _rootPos:Vector3D = new Vector3D();\n\tprivate _frames:Array<SkeletonPose>;\n\tprivate _skeletonClipNode:SkeletonClipNode;\n\tprivate _skeletonPose:SkeletonPose = new SkeletonPose();\n\tprivate _skeletonPoseDirty:boolean = true;\n\tprivate _currentPose:SkeletonPose;\n\tprivate _nextPose:SkeletonPose;\n\n\t/**\n\t * Returns the current skeleton pose frame of animation in the clip based on the internal playhead position.\n\t */\n\tpublic get currentPose():SkeletonPose\n\t{\n\t\tif (this._pFramesDirty)\n\t\t\tthis._pUpdateFrames();\n\n\t\treturn this._currentPose;\n\t}\n\n\t/**\n\t * Returns the next skeleton pose frame of animation in the clip based on the internal playhead position.\n\t */\n\tpublic get nextPose():SkeletonPose\n\t{\n\t\tif (this._pFramesDirty)\n\t\t\tthis._pUpdateFrames();\n\n\t\treturn this._nextPose;\n\t}\n\n\tconstructor(animator:AnimatorBase, skeletonClipNode:SkeletonClipNode)\n\t{\n\t\tsuper(animator, skeletonClipNode);\n\n\t\tthis._skeletonClipNode = skeletonClipNode;\n\t\tthis._frames = this._skeletonClipNode.frames;\n\t}\n\n\t/**\n\t * Returns the current skeleton pose of the animation in the clip based on the internal playhead position.\n\t */\n\tpublic getSkeletonPose(skeleton:Skeleton):SkeletonPose\n\t{\n\t\tif (this._skeletonPoseDirty)\n\t\t\tthis.updateSkeletonPose(skeleton);\n\n\t\treturn this._skeletonPose;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdateTime(time:number /*int*/)\n\t{\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tsuper._pUpdateTime(time);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdateFrames()\n\t{\n\t\tsuper._pUpdateFrames();\n\n\t\tthis._currentPose = this._frames[this._pCurrentFrame];\n\n\t\tif (this._skeletonClipNode.looping && this._pNextFrame >= this._skeletonClipNode.lastFrame) {\n\t\t\tthis._nextPose = this._frames[0];\n\t\t\t(<SkeletonAnimator> this._pAnimator).dispatchCycleEvent();\n\t\t} else\n\t\t\tthis._nextPose = this._frames[this._pNextFrame];\n\t}\n\n\t/**\n\t * Updates the output skeleton pose of the node based on the internal playhead position.\n\t *\n\t * @param skeleton The skeleton used by the animator requesting the ouput pose.\n\t */\n\tprivate updateSkeletonPose(skeleton:Skeleton)\n\t{\n\t\tthis._skeletonPoseDirty = false;\n\n\t\tif (!this._skeletonClipNode.totalDuration)\n\t\t\treturn;\n\n\t\tif (this._pFramesDirty)\n\t\t\tthis._pUpdateFrames();\n\n\t\tvar currentPose:Array<JointPose> = this._currentPose.jointPoses;\n\t\tvar nextPose:Array<JointPose> = this._nextPose.jointPoses;\n\t\tvar numJoints:number /*uint*/ = skeleton.numJoints;\n\t\tvar p1:Vector3D, p2:Vector3D;\n\t\tvar pose1:JointPose, pose2:JointPose;\n\t\tvar endPoses:Array<JointPose> = this._skeletonPose.jointPoses;\n\t\tvar endPose:JointPose;\n\t\tvar tr:Vector3D;\n\n\t\t// :s\n\t\tif (endPoses.length != numJoints)\n\t\t\tendPoses.length = numJoints;\n\n\t\tif ((numJoints != currentPose.length) || (numJoints != nextPose.length))\n\t\t\tthrow new Error(\"joint counts don't match!\");\n\n\t\tfor (var i:number /*uint*/ = 0; i < numJoints; ++i) {\n\t\t\tendPose = endPoses[i];\n\n\t\t\tif (endPose == null)\n\t\t\t\tendPose = endPoses[i] = new JointPose();\n\n\t\t\tpose1 = currentPose[i];\n\t\t\tpose2 = nextPose[i];\n\t\t\tp1 = pose1.translation;\n\t\t\tp2 = pose2.translation;\n\n\t\t\tif (this._skeletonClipNode.highQuality)\n\t\t\t\tendPose.orientation.slerp(pose1.orientation, pose2.orientation, this._pBlendWeight); else\n\t\t\t\tendPose.orientation.lerp(pose1.orientation, pose2.orientation, this._pBlendWeight);\n\n\t\t\tif (i > 0) {\n\t\t\t\ttr = endPose.translation;\n\t\t\t\ttr.x = p1.x + this._pBlendWeight*(p2.x - p1.x);\n\t\t\t\ttr.y = p1.y + this._pBlendWeight*(p2.y - p1.y);\n\t\t\t\ttr.z = p1.z + this._pBlendWeight*(p2.z - p1.z);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdatePositionDelta()\n\t{\n\t\tthis._pPositionDeltaDirty = false;\n\n\t\tif (this._pFramesDirty)\n\t\t\tthis._pUpdateFrames();\n\n\t\tvar p1:Vector3D, p2:Vector3D, p3:Vector3D;\n\t\tvar totalDelta:Vector3D = this._skeletonClipNode.totalDelta;\n\n\t\t// jumping back, need to reset position\n\t\tif ((this._pTimeDir > 0 && this._pNextFrame < this._pOldFrame) || (this._pTimeDir < 0 && this._pNextFrame > this._pOldFrame)) {\n\t\t\tthis._rootPos.x -= totalDelta.x*this._pTimeDir;\n\t\t\tthis._rootPos.y -= totalDelta.y*this._pTimeDir;\n\t\t\tthis._rootPos.z -= totalDelta.z*this._pTimeDir;\n\t\t}\n\n\t\tvar dx:number = this._rootPos.x;\n\t\tvar dy:number = this._rootPos.y;\n\t\tvar dz:number = this._rootPos.z;\n\n\t\tif (this._skeletonClipNode.stitchFinalFrame && this._pNextFrame == this._skeletonClipNode.lastFrame) {\n\t\t\tp1 = this._frames[0].jointPoses[0].translation;\n\t\t\tp2 = this._frames[1].jointPoses[0].translation;\n\t\t\tp3 = this._currentPose.jointPoses[0].translation;\n\n\t\t\tthis._rootPos.x = p3.x + p1.x + this._pBlendWeight*(p2.x - p1.x);\n\t\t\tthis._rootPos.y = p3.y + p1.y + this._pBlendWeight*(p2.y - p1.y);\n\t\t\tthis._rootPos.z = p3.z + p1.z + this._pBlendWeight*(p2.z - p1.z);\n\t\t} else {\n\t\t\tp1 = this._currentPose.jointPoses[0].translation;\n\t\t\tp2 = this._frames[this._pNextFrame].jointPoses[0].translation; //cover the instances where we wrap the pose but still want the final frame translation values\n\t\t\tthis._rootPos.x = p1.x + this._pBlendWeight*(p2.x - p1.x);\n\t\t\tthis._rootPos.y = p1.y + this._pBlendWeight*(p2.y - p1.y);\n\t\t\tthis._rootPos.z = p1.z + this._pBlendWeight*(p2.z - p1.z);\n\t\t}\n\n\t\tthis._pRootDelta.x = this._rootPos.x - dx;\n\t\tthis._pRootDelta.y = this._rootPos.y - dy;\n\t\tthis._pRootDelta.z = this._rootPos.z - dz;\n\n\t\tthis._pOldFrame = this._pNextFrame;\n\t}\n}\n\nexport = SkeletonClipState;"]} \ No newline at end of file diff --git a/lib/animators/states/SkeletonClipState.ts b/lib/animators/states/SkeletonClipState.ts new file mode 100644 index 000000000..c49d33ec6 --- /dev/null +++ b/lib/animators/states/SkeletonClipState.ts @@ -0,0 +1,196 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import SkeletonAnimator = require("awayjs-renderergl/lib/animators/SkeletonAnimator"); +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import SkeletonClipNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonClipNode"); +import AnimationClipState = require("awayjs-renderergl/lib/animators/states/AnimationClipState"); +import ISkeletonAnimationState = require("awayjs-renderergl/lib/animators/states/ISkeletonAnimationState"); + +/** + * + */ +class SkeletonClipState extends AnimationClipState implements ISkeletonAnimationState +{ + private _rootPos:Vector3D = new Vector3D(); + private _frames:Array; + private _skeletonClipNode:SkeletonClipNode; + private _skeletonPose:SkeletonPose = new SkeletonPose(); + private _skeletonPoseDirty:boolean = true; + private _currentPose:SkeletonPose; + private _nextPose:SkeletonPose; + + /** + * Returns the current skeleton pose frame of animation in the clip based on the internal playhead position. + */ + public get currentPose():SkeletonPose + { + if (this._pFramesDirty) + this._pUpdateFrames(); + + return this._currentPose; + } + + /** + * Returns the next skeleton pose frame of animation in the clip based on the internal playhead position. + */ + public get nextPose():SkeletonPose + { + if (this._pFramesDirty) + this._pUpdateFrames(); + + return this._nextPose; + } + + constructor(animator:AnimatorBase, skeletonClipNode:SkeletonClipNode) + { + super(animator, skeletonClipNode); + + this._skeletonClipNode = skeletonClipNode; + this._frames = this._skeletonClipNode.frames; + } + + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + public getSkeletonPose(skeleton:Skeleton):SkeletonPose + { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + + return this._skeletonPose; + } + + /** + * @inheritDoc + */ + public _pUpdateTime(time:number /*int*/) + { + this._skeletonPoseDirty = true; + + super._pUpdateTime(time); + } + + /** + * @inheritDoc + */ + public _pUpdateFrames() + { + super._pUpdateFrames(); + + this._currentPose = this._frames[this._pCurrentFrame]; + + if (this._skeletonClipNode.looping && this._pNextFrame >= this._skeletonClipNode.lastFrame) { + this._nextPose = this._frames[0]; + ( this._pAnimator).dispatchCycleEvent(); + } else + this._nextPose = this._frames[this._pNextFrame]; + } + + /** + * Updates the output skeleton pose of the node based on the internal playhead position. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + private updateSkeletonPose(skeleton:Skeleton) + { + this._skeletonPoseDirty = false; + + if (!this._skeletonClipNode.totalDuration) + return; + + if (this._pFramesDirty) + this._pUpdateFrames(); + + var currentPose:Array = this._currentPose.jointPoses; + var nextPose:Array = this._nextPose.jointPoses; + var numJoints:number /*uint*/ = skeleton.numJoints; + var p1:Vector3D, p2:Vector3D; + var pose1:JointPose, pose2:JointPose; + var endPoses:Array = this._skeletonPose.jointPoses; + var endPose:JointPose; + var tr:Vector3D; + + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + + if ((numJoints != currentPose.length) || (numJoints != nextPose.length)) + throw new Error("joint counts don't match!"); + + for (var i:number /*uint*/ = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + + pose1 = currentPose[i]; + pose2 = nextPose[i]; + p1 = pose1.translation; + p2 = pose2.translation; + + if (this._skeletonClipNode.highQuality) + endPose.orientation.slerp(pose1.orientation, pose2.orientation, this._pBlendWeight); else + endPose.orientation.lerp(pose1.orientation, pose2.orientation, this._pBlendWeight); + + if (i > 0) { + tr = endPose.translation; + tr.x = p1.x + this._pBlendWeight*(p2.x - p1.x); + tr.y = p1.y + this._pBlendWeight*(p2.y - p1.y); + tr.z = p1.z + this._pBlendWeight*(p2.z - p1.z); + } + } + } + + /** + * @inheritDoc + */ + public _pUpdatePositionDelta() + { + this._pPositionDeltaDirty = false; + + if (this._pFramesDirty) + this._pUpdateFrames(); + + var p1:Vector3D, p2:Vector3D, p3:Vector3D; + var totalDelta:Vector3D = this._skeletonClipNode.totalDelta; + + // jumping back, need to reset position + if ((this._pTimeDir > 0 && this._pNextFrame < this._pOldFrame) || (this._pTimeDir < 0 && this._pNextFrame > this._pOldFrame)) { + this._rootPos.x -= totalDelta.x*this._pTimeDir; + this._rootPos.y -= totalDelta.y*this._pTimeDir; + this._rootPos.z -= totalDelta.z*this._pTimeDir; + } + + var dx:number = this._rootPos.x; + var dy:number = this._rootPos.y; + var dz:number = this._rootPos.z; + + if (this._skeletonClipNode.stitchFinalFrame && this._pNextFrame == this._skeletonClipNode.lastFrame) { + p1 = this._frames[0].jointPoses[0].translation; + p2 = this._frames[1].jointPoses[0].translation; + p3 = this._currentPose.jointPoses[0].translation; + + this._rootPos.x = p3.x + p1.x + this._pBlendWeight*(p2.x - p1.x); + this._rootPos.y = p3.y + p1.y + this._pBlendWeight*(p2.y - p1.y); + this._rootPos.z = p3.z + p1.z + this._pBlendWeight*(p2.z - p1.z); + } else { + p1 = this._currentPose.jointPoses[0].translation; + p2 = this._frames[this._pNextFrame].jointPoses[0].translation; //cover the instances where we wrap the pose but still want the final frame translation values + this._rootPos.x = p1.x + this._pBlendWeight*(p2.x - p1.x); + this._rootPos.y = p1.y + this._pBlendWeight*(p2.y - p1.y); + this._rootPos.z = p1.z + this._pBlendWeight*(p2.z - p1.z); + } + + this._pRootDelta.x = this._rootPos.x - dx; + this._pRootDelta.y = this._rootPos.y - dy; + this._pRootDelta.z = this._rootPos.z - dz; + + this._pOldFrame = this._pNextFrame; + } +} + +export = SkeletonClipState; \ No newline at end of file diff --git a/lib/animators/states/SkeletonDifferenceState.js b/lib/animators/states/SkeletonDifferenceState.js new file mode 100755 index 000000000..52c964a13 --- /dev/null +++ b/lib/animators/states/SkeletonDifferenceState.js @@ -0,0 +1,120 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +/** + * + */ +var SkeletonDifferenceState = (function (_super) { + __extends(SkeletonDifferenceState, _super); + function SkeletonDifferenceState(animator, skeletonAnimationNode) { + _super.call(this, animator, skeletonAnimationNode); + this._blendWeight = 0; + this._skeletonPose = new SkeletonPose(); + this._skeletonPoseDirty = true; + this._skeletonAnimationNode = skeletonAnimationNode; + this._baseInput = animator.getAnimationState(this._skeletonAnimationNode.baseInput); + this._differenceInput = animator.getAnimationState(this._skeletonAnimationNode.differenceInput); + } + Object.defineProperty(SkeletonDifferenceState.prototype, "blendWeight", { + /** + * Defines a fractional value between 0 and 1 representing the blending ratio between the base input (0) and difference input (1), + * used to produce the skeleton pose output. + * + * @see #baseInput + * @see #differenceInput + */ + get: function () { + return this._blendWeight; + }, + set: function (value) { + this._blendWeight = value; + this._pPositionDeltaDirty = true; + this._skeletonPoseDirty = true; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SkeletonDifferenceState.prototype.phase = function (value) { + this._skeletonPoseDirty = true; + this._pPositionDeltaDirty = true; + this._baseInput.phase(value); + this._baseInput.phase(value); + }; + /** + * @inheritDoc + */ + SkeletonDifferenceState.prototype._pUpdateTime = function (time /*int*/) { + this._skeletonPoseDirty = true; + this._baseInput.update(time); + this._differenceInput.update(time); + _super.prototype._pUpdateTime.call(this, time); + }; + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + SkeletonDifferenceState.prototype.getSkeletonPose = function (skeleton) { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + return this._skeletonPose; + }; + /** + * @inheritDoc + */ + SkeletonDifferenceState.prototype._pUpdatePositionDelta = function () { + this._pPositionDeltaDirty = false; + var deltA = this._baseInput.positionDelta; + var deltB = this._differenceInput.positionDelta; + this.positionDelta.x = deltA.x + this._blendWeight * deltB.x; + this.positionDelta.y = deltA.y + this._blendWeight * deltB.y; + this.positionDelta.z = deltA.z + this._blendWeight * deltB.z; + }; + /** + * Updates the output skeleton pose of the node based on the blendWeight value between base input and difference input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + SkeletonDifferenceState.prototype.updateSkeletonPose = function (skeleton) { + this._skeletonPoseDirty = false; + var endPose; + var endPoses = this._skeletonPose.jointPoses; + var basePoses = this._baseInput.getSkeletonPose(skeleton).jointPoses; + var diffPoses = this._differenceInput.getSkeletonPose(skeleton).jointPoses; + var base, diff; + var basePos, diffPos; + var tr; + var numJoints = skeleton.numJoints; + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + for (var i = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + base = basePoses[i]; + diff = diffPoses[i]; + basePos = base.translation; + diffPos = diff.translation; + SkeletonDifferenceState._tempQuat.multiply(diff.orientation, base.orientation); + endPose.orientation.lerp(base.orientation, SkeletonDifferenceState._tempQuat, this._blendWeight); + tr = endPose.translation; + tr.x = basePos.x + this._blendWeight * diffPos.x; + tr.y = basePos.y + this._blendWeight * diffPos.y; + tr.z = basePos.z + this._blendWeight * diffPos.z; + } + }; + SkeletonDifferenceState._tempQuat = new Quaternion(); + return SkeletonDifferenceState; +})(AnimationStateBase); +module.exports = SkeletonDifferenceState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/skeletondifferencestate.ts"],"names":["SkeletonDifferenceState","SkeletonDifferenceState.constructor","SkeletonDifferenceState.blendWeight","SkeletonDifferenceState.phase","SkeletonDifferenceState._pUpdateTime","SkeletonDifferenceState.getSkeletonPose","SkeletonDifferenceState._pUpdatePositionDelta","SkeletonDifferenceState.updateSkeletonPose"],"mappings":"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","file":"animators/states/SkeletonDifferenceState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Quaternion\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Quaternion\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\n\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport SkeletonDifferenceNode\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/SkeletonDifferenceNode\");\nimport AnimationStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/AnimationStateBase\");\nimport ISkeletonAnimationState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ISkeletonAnimationState\");\n\n/**\n *\n */\nclass SkeletonDifferenceState extends AnimationStateBase implements ISkeletonAnimationState\n{\n\tprivate _blendWeight:number = 0;\n\tprivate static _tempQuat:Quaternion = new Quaternion();\n\tprivate _skeletonAnimationNode:SkeletonDifferenceNode;\n\tprivate _skeletonPose:SkeletonPose = new SkeletonPose();\n\tprivate _skeletonPoseDirty:boolean = true;\n\tprivate _baseInput:ISkeletonAnimationState;\n\tprivate _differenceInput:ISkeletonAnimationState;\n\n\t/**\n\t * Defines a fractional value between 0 and 1 representing the blending ratio between the base input (0) and difference input (1),\n\t * used to produce the skeleton pose output.\n\t *\n\t * @see #baseInput\n\t * @see #differenceInput\n\t */\n\tpublic get blendWeight():number\n\t{\n\t\treturn this._blendWeight;\n\t}\n\n\tpublic set blendWeight(value:number)\n\t{\n\t\tthis._blendWeight = value;\n\n\t\tthis._pPositionDeltaDirty = true;\n\t\tthis._skeletonPoseDirty = true;\n\t}\n\n\tconstructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonDifferenceNode)\n\t{\n\t\tsuper(animator, skeletonAnimationNode);\n\n\t\tthis._skeletonAnimationNode = skeletonAnimationNode;\n\n\t\tthis._baseInput = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.baseInput);\n\t\tthis._differenceInput = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.differenceInput);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic phase(value:number)\n\t{\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tthis._pPositionDeltaDirty = true;\n\n\t\tthis._baseInput.phase(value);\n\t\tthis._baseInput.phase(value);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdateTime(time:number /*int*/)\n\t{\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tthis._baseInput.update(time);\n\t\tthis._differenceInput.update(time);\n\n\t\tsuper._pUpdateTime(time);\n\t}\n\n\t/**\n\t * Returns the current skeleton pose of the animation in the clip based on the internal playhead position.\n\t */\n\tpublic getSkeletonPose(skeleton:Skeleton):SkeletonPose\n\t{\n\t\tif (this._skeletonPoseDirty)\n\t\t\tthis.updateSkeletonPose(skeleton);\n\n\t\treturn this._skeletonPose;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdatePositionDelta()\n\t{\n\t\tthis._pPositionDeltaDirty = false;\n\n\t\tvar deltA:Vector3D = this._baseInput.positionDelta;\n\t\tvar deltB:Vector3D = this._differenceInput.positionDelta;\n\n\t\tthis.positionDelta.x = deltA.x + this._blendWeight*deltB.x;\n\t\tthis.positionDelta.y = deltA.y + this._blendWeight*deltB.y;\n\t\tthis.positionDelta.z = deltA.z + this._blendWeight*deltB.z;\n\t}\n\n\t/**\n\t * Updates the output skeleton pose of the node based on the blendWeight value between base input and difference input nodes.\n\t *\n\t * @param skeleton The skeleton used by the animator requesting the ouput pose.\n\t */\n\tprivate updateSkeletonPose(skeleton:Skeleton)\n\t{\n\t\tthis._skeletonPoseDirty = false;\n\n\t\tvar endPose:JointPose;\n\t\tvar endPoses:Array<JointPose> = this._skeletonPose.jointPoses;\n\t\tvar basePoses:Array<JointPose> = this._baseInput.getSkeletonPose(skeleton).jointPoses;\n\t\tvar diffPoses:Array<JointPose> = this._differenceInput.getSkeletonPose(skeleton).jointPoses;\n\t\tvar base:JointPose, diff:JointPose;\n\t\tvar basePos:Vector3D, diffPos:Vector3D;\n\t\tvar tr:Vector3D;\n\t\tvar numJoints:number /*uint*/ = skeleton.numJoints;\n\n\t\t// :s\n\t\tif (endPoses.length != numJoints)\n\t\t\tendPoses.length = numJoints;\n\n\t\tfor (var i:number /*uint*/ = 0; i < numJoints; ++i) {\n\t\t\tendPose = endPoses[i];\n\n\t\t\tif (endPose == null)\n\t\t\t\tendPose = endPoses[i] = new JointPose();\n\n\t\t\tbase = basePoses[i];\n\t\t\tdiff = diffPoses[i];\n\t\t\tbasePos = base.translation;\n\t\t\tdiffPos = diff.translation;\n\n\t\t\tSkeletonDifferenceState._tempQuat.multiply(diff.orientation, base.orientation);\n\t\t\tendPose.orientation.lerp(base.orientation, SkeletonDifferenceState._tempQuat, this._blendWeight);\n\n\t\t\ttr = endPose.translation;\n\t\t\ttr.x = basePos.x + this._blendWeight*diffPos.x;\n\t\t\ttr.y = basePos.y + this._blendWeight*diffPos.y;\n\t\t\ttr.z = basePos.z + this._blendWeight*diffPos.z;\n\t\t}\n\t}\n}\n\nexport = SkeletonDifferenceState;"]} \ No newline at end of file diff --git a/lib/animators/states/SkeletonDifferenceState.ts b/lib/animators/states/SkeletonDifferenceState.ts new file mode 100644 index 000000000..d342ede65 --- /dev/null +++ b/lib/animators/states/SkeletonDifferenceState.ts @@ -0,0 +1,152 @@ +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import SkeletonDifferenceNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonDifferenceNode"); +import AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +import ISkeletonAnimationState = require("awayjs-renderergl/lib/animators/states/ISkeletonAnimationState"); + +/** + * + */ +class SkeletonDifferenceState extends AnimationStateBase implements ISkeletonAnimationState +{ + private _blendWeight:number = 0; + private static _tempQuat:Quaternion = new Quaternion(); + private _skeletonAnimationNode:SkeletonDifferenceNode; + private _skeletonPose:SkeletonPose = new SkeletonPose(); + private _skeletonPoseDirty:boolean = true; + private _baseInput:ISkeletonAnimationState; + private _differenceInput:ISkeletonAnimationState; + + /** + * Defines a fractional value between 0 and 1 representing the blending ratio between the base input (0) and difference input (1), + * used to produce the skeleton pose output. + * + * @see #baseInput + * @see #differenceInput + */ + public get blendWeight():number + { + return this._blendWeight; + } + + public set blendWeight(value:number) + { + this._blendWeight = value; + + this._pPositionDeltaDirty = true; + this._skeletonPoseDirty = true; + } + + constructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonDifferenceNode) + { + super(animator, skeletonAnimationNode); + + this._skeletonAnimationNode = skeletonAnimationNode; + + this._baseInput = animator.getAnimationState(this._skeletonAnimationNode.baseInput); + this._differenceInput = animator.getAnimationState(this._skeletonAnimationNode.differenceInput); + } + + /** + * @inheritDoc + */ + public phase(value:number) + { + this._skeletonPoseDirty = true; + + this._pPositionDeltaDirty = true; + + this._baseInput.phase(value); + this._baseInput.phase(value); + } + + /** + * @inheritDoc + */ + public _pUpdateTime(time:number /*int*/) + { + this._skeletonPoseDirty = true; + + this._baseInput.update(time); + this._differenceInput.update(time); + + super._pUpdateTime(time); + } + + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + public getSkeletonPose(skeleton:Skeleton):SkeletonPose + { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + + return this._skeletonPose; + } + + /** + * @inheritDoc + */ + public _pUpdatePositionDelta() + { + this._pPositionDeltaDirty = false; + + var deltA:Vector3D = this._baseInput.positionDelta; + var deltB:Vector3D = this._differenceInput.positionDelta; + + this.positionDelta.x = deltA.x + this._blendWeight*deltB.x; + this.positionDelta.y = deltA.y + this._blendWeight*deltB.y; + this.positionDelta.z = deltA.z + this._blendWeight*deltB.z; + } + + /** + * Updates the output skeleton pose of the node based on the blendWeight value between base input and difference input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + private updateSkeletonPose(skeleton:Skeleton) + { + this._skeletonPoseDirty = false; + + var endPose:JointPose; + var endPoses:Array = this._skeletonPose.jointPoses; + var basePoses:Array = this._baseInput.getSkeletonPose(skeleton).jointPoses; + var diffPoses:Array = this._differenceInput.getSkeletonPose(skeleton).jointPoses; + var base:JointPose, diff:JointPose; + var basePos:Vector3D, diffPos:Vector3D; + var tr:Vector3D; + var numJoints:number /*uint*/ = skeleton.numJoints; + + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + + for (var i:number /*uint*/ = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + + base = basePoses[i]; + diff = diffPoses[i]; + basePos = base.translation; + diffPos = diff.translation; + + SkeletonDifferenceState._tempQuat.multiply(diff.orientation, base.orientation); + endPose.orientation.lerp(base.orientation, SkeletonDifferenceState._tempQuat, this._blendWeight); + + tr = endPose.translation; + tr.x = basePos.x + this._blendWeight*diffPos.x; + tr.y = basePos.y + this._blendWeight*diffPos.y; + tr.z = basePos.z + this._blendWeight*diffPos.z; + } + } +} + +export = SkeletonDifferenceState; \ No newline at end of file diff --git a/lib/animators/states/SkeletonDirectionalState.js b/lib/animators/states/SkeletonDirectionalState.js new file mode 100755 index 000000000..2313201d1 --- /dev/null +++ b/lib/animators/states/SkeletonDirectionalState.js @@ -0,0 +1,162 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +/** + * + */ +var SkeletonDirectionalState = (function (_super) { + __extends(SkeletonDirectionalState, _super); + function SkeletonDirectionalState(animator, skeletonAnimationNode) { + _super.call(this, animator, skeletonAnimationNode); + this._skeletonPose = new SkeletonPose(); + this._skeletonPoseDirty = true; + this._blendWeight = 0; + this._direction = 0; + this._blendDirty = true; + this._skeletonAnimationNode = skeletonAnimationNode; + this._forward = animator.getAnimationState(this._skeletonAnimationNode.forward); + this._backward = animator.getAnimationState(this._skeletonAnimationNode.backward); + this._left = animator.getAnimationState(this._skeletonAnimationNode.left); + this._right = animator.getAnimationState(this._skeletonAnimationNode.right); + } + Object.defineProperty(SkeletonDirectionalState.prototype, "direction", { + get: function () { + return this._direction; + }, + /** + * Defines the direction in degrees of the aniamtion between the forwards (0), right(90) backwards (180) and left(270) input nodes, + * used to produce the skeleton pose output. + */ + set: function (value) { + if (this._direction == value) + return; + this._direction = value; + this._blendDirty = true; + this._skeletonPoseDirty = true; + this._pPositionDeltaDirty = true; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SkeletonDirectionalState.prototype.phase = function (value) { + if (this._blendDirty) + this.updateBlend(); + this._skeletonPoseDirty = true; + this._pPositionDeltaDirty = true; + this._inputA.phase(value); + this._inputB.phase(value); + }; + /** + * @inheritDoc + */ + SkeletonDirectionalState.prototype._pUdateTime = function (time /*int*/) { + if (this._blendDirty) + this.updateBlend(); + this._skeletonPoseDirty = true; + this._inputA.update(time); + this._inputB.update(time); + _super.prototype._pUpdateTime.call(this, time); + }; + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + SkeletonDirectionalState.prototype.getSkeletonPose = function (skeleton) { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + return this._skeletonPose; + }; + /** + * @inheritDoc + */ + SkeletonDirectionalState.prototype._pUpdatePositionDelta = function () { + this._pPositionDeltaDirty = false; + if (this._blendDirty) + this.updateBlend(); + var deltA = this._inputA.positionDelta; + var deltB = this._inputB.positionDelta; + this.positionDelta.x = deltA.x + this._blendWeight * (deltB.x - deltA.x); + this.positionDelta.y = deltA.y + this._blendWeight * (deltB.y - deltA.y); + this.positionDelta.z = deltA.z + this._blendWeight * (deltB.z - deltA.z); + }; + /** + * Updates the output skeleton pose of the node based on the direction value between forward, backwards, left and right input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + SkeletonDirectionalState.prototype.updateSkeletonPose = function (skeleton) { + this._skeletonPoseDirty = false; + if (this._blendDirty) + this.updateBlend(); + var endPose; + var endPoses = this._skeletonPose.jointPoses; + var poses1 = this._inputA.getSkeletonPose(skeleton).jointPoses; + var poses2 = this._inputB.getSkeletonPose(skeleton).jointPoses; + var pose1, pose2; + var p1, p2; + var tr; + var numJoints = skeleton.numJoints; + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + for (var i = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + pose1 = poses1[i]; + pose2 = poses2[i]; + p1 = pose1.translation; + p2 = pose2.translation; + endPose.orientation.lerp(pose1.orientation, pose2.orientation, this._blendWeight); + tr = endPose.translation; + tr.x = p1.x + this._blendWeight * (p2.x - p1.x); + tr.y = p1.y + this._blendWeight * (p2.y - p1.y); + tr.z = p1.z + this._blendWeight * (p2.z - p1.z); + } + }; + /** + * Updates the blend value for the animation output based on the direction value between forward, backwards, left and right input nodes. + * + * @private + */ + SkeletonDirectionalState.prototype.updateBlend = function () { + this._blendDirty = false; + if (this._direction < 0 || this._direction > 360) { + this._direction %= 360; + if (this._direction < 0) + this._direction += 360; + } + if (this._direction < 90) { + this._inputA = this._forward; + this._inputB = this._right; + this._blendWeight = this._direction / 90; + } + else if (this._direction < 180) { + this._inputA = this._right; + this._inputB = this._backward; + this._blendWeight = (this._direction - 90) / 90; + } + else if (this._direction < 270) { + this._inputA = this._backward; + this._inputB = this._left; + this._blendWeight = (this._direction - 180) / 90; + } + else { + this._inputA = this._left; + this._inputB = this._forward; + this._blendWeight = (this._direction - 270) / 90; + } + }; + return SkeletonDirectionalState; +})(AnimationStateBase); +module.exports = SkeletonDirectionalState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/skeletondirectionalstate.ts"],"names":["SkeletonDirectionalState","SkeletonDirectionalState.constructor","SkeletonDirectionalState.direction","SkeletonDirectionalState.phase","SkeletonDirectionalState._pUdateTime","SkeletonDirectionalState.getSkeletonPose","SkeletonDirectionalState._pUpdatePositionDelta","SkeletonDirectionalState.updateSkeletonPose","SkeletonDirectionalState.updateBlend"],"mappings":"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","file":"animators/states/SkeletonDirectionalState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\n\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport SkeletonDirectionalNode\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/SkeletonDirectionalNode\");\nimport AnimationStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/AnimationStateBase\");\nimport ISkeletonAnimationState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ISkeletonAnimationState\");\n\n/**\n *\n */\nclass SkeletonDirectionalState extends AnimationStateBase implements ISkeletonAnimationState\n{\n\tprivate _skeletonAnimationNode:SkeletonDirectionalNode;\n\tprivate _skeletonPose:SkeletonPose = new SkeletonPose();\n\tprivate _skeletonPoseDirty:boolean = true;\n\tprivate _inputA:ISkeletonAnimationState;\n\tprivate _inputB:ISkeletonAnimationState;\n\tprivate _blendWeight:number = 0;\n\tprivate _direction:number = 0;\n\tprivate _blendDirty:boolean = true;\n\tprivate _forward:ISkeletonAnimationState;\n\tprivate _backward:ISkeletonAnimationState;\n\tprivate _left:ISkeletonAnimationState;\n\tprivate _right:ISkeletonAnimationState;\n\n\t/**\n\t * Defines the direction in degrees of the aniamtion between the forwards (0), right(90) backwards (180) and left(270) input nodes,\n\t * used to produce the skeleton pose output.\n\t */\n\tpublic set direction(value:number)\n\t{\n\t\tif (this._direction == value)\n\t\t\treturn;\n\n\t\tthis._direction = value;\n\n\t\tthis._blendDirty = true;\n\n\t\tthis._skeletonPoseDirty = true;\n\t\tthis._pPositionDeltaDirty = true;\n\t}\n\n\tpublic get direction():number\n\t{\n\t\treturn this._direction;\n\t}\n\n\tconstructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonDirectionalNode)\n\t{\n\t\tsuper(animator, skeletonAnimationNode);\n\n\t\tthis._skeletonAnimationNode = skeletonAnimationNode;\n\n\t\tthis._forward = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.forward);\n\t\tthis._backward = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.backward);\n\t\tthis._left = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.left);\n\t\tthis._right = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode.right);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic phase(value:number)\n\t{\n\t\tif (this._blendDirty)\n\t\t\tthis.updateBlend();\n\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tthis._pPositionDeltaDirty = true;\n\n\t\tthis._inputA.phase(value);\n\t\tthis._inputB.phase(value);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUdateTime(time:number /*int*/)\n\t{\n\t\tif (this._blendDirty)\n\t\t\tthis.updateBlend();\n\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tthis._inputA.update(time);\n\t\tthis._inputB.update(time);\n\n\t\tsuper._pUpdateTime(time);\n\t}\n\n\t/**\n\t * Returns the current skeleton pose of the animation in the clip based on the internal playhead position.\n\t */\n\tpublic getSkeletonPose(skeleton:Skeleton):SkeletonPose\n\t{\n\t\tif (this._skeletonPoseDirty)\n\t\t\tthis.updateSkeletonPose(skeleton);\n\n\t\treturn this._skeletonPose;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdatePositionDelta()\n\t{\n\t\tthis._pPositionDeltaDirty = false;\n\n\t\tif (this._blendDirty)\n\t\t\tthis.updateBlend();\n\n\t\tvar deltA:Vector3D = this._inputA.positionDelta;\n\t\tvar deltB:Vector3D = this._inputB.positionDelta;\n\n\t\tthis.positionDelta.x = deltA.x + this._blendWeight*(deltB.x - deltA.x);\n\t\tthis.positionDelta.y = deltA.y + this._blendWeight*(deltB.y - deltA.y);\n\t\tthis.positionDelta.z = deltA.z + this._blendWeight*(deltB.z - deltA.z);\n\t}\n\n\t/**\n\t * Updates the output skeleton pose of the node based on the direction value between forward, backwards, left and right input nodes.\n\t *\n\t * @param skeleton The skeleton used by the animator requesting the ouput pose.\n\t */\n\tprivate updateSkeletonPose(skeleton:Skeleton)\n\t{\n\t\tthis._skeletonPoseDirty = false;\n\n\t\tif (this._blendDirty)\n\t\t\tthis.updateBlend();\n\n\t\tvar endPose:JointPose;\n\t\tvar endPoses:Array<JointPose> = this._skeletonPose.jointPoses;\n\t\tvar poses1:Array<JointPose> = this._inputA.getSkeletonPose(skeleton).jointPoses;\n\t\tvar poses2:Array<JointPose> = this._inputB.getSkeletonPose(skeleton).jointPoses;\n\t\tvar pose1:JointPose, pose2:JointPose;\n\t\tvar p1:Vector3D, p2:Vector3D;\n\t\tvar tr:Vector3D;\n\t\tvar numJoints:number /*uint*/ = skeleton.numJoints;\n\n\t\t// :s\n\t\tif (endPoses.length != numJoints)\n\t\t\tendPoses.length = numJoints;\n\n\t\tfor (var i:number /*uint*/ = 0; i < numJoints; ++i) {\n\t\t\tendPose = endPoses[i];\n\n\t\t\tif (endPose == null)\n\t\t\t\tendPose = endPoses[i] = new JointPose();\n\n\t\t\tpose1 = poses1[i];\n\t\t\tpose2 = poses2[i];\n\t\t\tp1 = pose1.translation;\n\t\t\tp2 = pose2.translation;\n\n\t\t\tendPose.orientation.lerp(pose1.orientation, pose2.orientation, this._blendWeight);\n\n\t\t\ttr = endPose.translation;\n\t\t\ttr.x = p1.x + this._blendWeight*(p2.x - p1.x);\n\t\t\ttr.y = p1.y + this._blendWeight*(p2.y - p1.y);\n\t\t\ttr.z = p1.z + this._blendWeight*(p2.z - p1.z);\n\t\t}\n\t}\n\n\t/**\n\t * Updates the blend value for the animation output based on the direction value between forward, backwards, left and right input nodes.\n\t *\n\t * @private\n\t */\n\tprivate updateBlend()\n\t{\n\t\tthis._blendDirty = false;\n\n\t\tif (this._direction < 0 || this._direction > 360) {\n\t\t\tthis._direction %= 360;\n\t\t\tif (this._direction < 0)\n\t\t\t\tthis._direction += 360;\n\t\t}\n\n\t\tif (this._direction < 90) {\n\t\t\tthis._inputA = this._forward;\n\t\t\tthis._inputB = this._right;\n\t\t\tthis._blendWeight = this._direction/90;\n\t\t} else if (this._direction < 180) {\n\t\t\tthis._inputA = this._right;\n\t\t\tthis._inputB = this._backward;\n\t\t\tthis._blendWeight = (this._direction - 90)/90;\n\t\t} else if (this._direction < 270) {\n\t\t\tthis._inputA = this._backward;\n\t\t\tthis._inputB = this._left;\n\t\t\tthis._blendWeight = (this._direction - 180)/90;\n\t\t} else {\n\t\t\tthis._inputA = this._left;\n\t\t\tthis._inputB = this._forward;\n\t\t\tthis._blendWeight = (this._direction - 270)/90;\n\t\t}\n\t}\n}\n\nexport = SkeletonDirectionalState;"]} \ No newline at end of file diff --git a/lib/animators/states/SkeletonDirectionalState.ts b/lib/animators/states/SkeletonDirectionalState.ts new file mode 100644 index 000000000..bc2047aaa --- /dev/null +++ b/lib/animators/states/SkeletonDirectionalState.ts @@ -0,0 +1,205 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import SkeletonDirectionalNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonDirectionalNode"); +import AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +import ISkeletonAnimationState = require("awayjs-renderergl/lib/animators/states/ISkeletonAnimationState"); + +/** + * + */ +class SkeletonDirectionalState extends AnimationStateBase implements ISkeletonAnimationState +{ + private _skeletonAnimationNode:SkeletonDirectionalNode; + private _skeletonPose:SkeletonPose = new SkeletonPose(); + private _skeletonPoseDirty:boolean = true; + private _inputA:ISkeletonAnimationState; + private _inputB:ISkeletonAnimationState; + private _blendWeight:number = 0; + private _direction:number = 0; + private _blendDirty:boolean = true; + private _forward:ISkeletonAnimationState; + private _backward:ISkeletonAnimationState; + private _left:ISkeletonAnimationState; + private _right:ISkeletonAnimationState; + + /** + * Defines the direction in degrees of the aniamtion between the forwards (0), right(90) backwards (180) and left(270) input nodes, + * used to produce the skeleton pose output. + */ + public set direction(value:number) + { + if (this._direction == value) + return; + + this._direction = value; + + this._blendDirty = true; + + this._skeletonPoseDirty = true; + this._pPositionDeltaDirty = true; + } + + public get direction():number + { + return this._direction; + } + + constructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonDirectionalNode) + { + super(animator, skeletonAnimationNode); + + this._skeletonAnimationNode = skeletonAnimationNode; + + this._forward = animator.getAnimationState(this._skeletonAnimationNode.forward); + this._backward = animator.getAnimationState(this._skeletonAnimationNode.backward); + this._left = animator.getAnimationState(this._skeletonAnimationNode.left); + this._right = animator.getAnimationState(this._skeletonAnimationNode.right); + } + + /** + * @inheritDoc + */ + public phase(value:number) + { + if (this._blendDirty) + this.updateBlend(); + + this._skeletonPoseDirty = true; + + this._pPositionDeltaDirty = true; + + this._inputA.phase(value); + this._inputB.phase(value); + } + + /** + * @inheritDoc + */ + public _pUdateTime(time:number /*int*/) + { + if (this._blendDirty) + this.updateBlend(); + + this._skeletonPoseDirty = true; + + this._inputA.update(time); + this._inputB.update(time); + + super._pUpdateTime(time); + } + + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + public getSkeletonPose(skeleton:Skeleton):SkeletonPose + { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + + return this._skeletonPose; + } + + /** + * @inheritDoc + */ + public _pUpdatePositionDelta() + { + this._pPositionDeltaDirty = false; + + if (this._blendDirty) + this.updateBlend(); + + var deltA:Vector3D = this._inputA.positionDelta; + var deltB:Vector3D = this._inputB.positionDelta; + + this.positionDelta.x = deltA.x + this._blendWeight*(deltB.x - deltA.x); + this.positionDelta.y = deltA.y + this._blendWeight*(deltB.y - deltA.y); + this.positionDelta.z = deltA.z + this._blendWeight*(deltB.z - deltA.z); + } + + /** + * Updates the output skeleton pose of the node based on the direction value between forward, backwards, left and right input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + private updateSkeletonPose(skeleton:Skeleton) + { + this._skeletonPoseDirty = false; + + if (this._blendDirty) + this.updateBlend(); + + var endPose:JointPose; + var endPoses:Array = this._skeletonPose.jointPoses; + var poses1:Array = this._inputA.getSkeletonPose(skeleton).jointPoses; + var poses2:Array = this._inputB.getSkeletonPose(skeleton).jointPoses; + var pose1:JointPose, pose2:JointPose; + var p1:Vector3D, p2:Vector3D; + var tr:Vector3D; + var numJoints:number /*uint*/ = skeleton.numJoints; + + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + + for (var i:number /*uint*/ = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + + pose1 = poses1[i]; + pose2 = poses2[i]; + p1 = pose1.translation; + p2 = pose2.translation; + + endPose.orientation.lerp(pose1.orientation, pose2.orientation, this._blendWeight); + + tr = endPose.translation; + tr.x = p1.x + this._blendWeight*(p2.x - p1.x); + tr.y = p1.y + this._blendWeight*(p2.y - p1.y); + tr.z = p1.z + this._blendWeight*(p2.z - p1.z); + } + } + + /** + * Updates the blend value for the animation output based on the direction value between forward, backwards, left and right input nodes. + * + * @private + */ + private updateBlend() + { + this._blendDirty = false; + + if (this._direction < 0 || this._direction > 360) { + this._direction %= 360; + if (this._direction < 0) + this._direction += 360; + } + + if (this._direction < 90) { + this._inputA = this._forward; + this._inputB = this._right; + this._blendWeight = this._direction/90; + } else if (this._direction < 180) { + this._inputA = this._right; + this._inputB = this._backward; + this._blendWeight = (this._direction - 90)/90; + } else if (this._direction < 270) { + this._inputA = this._backward; + this._inputB = this._left; + this._blendWeight = (this._direction - 180)/90; + } else { + this._inputA = this._left; + this._inputB = this._forward; + this._blendWeight = (this._direction - 270)/90; + } + } +} + +export = SkeletonDirectionalState; \ No newline at end of file diff --git a/lib/animators/states/SkeletonNaryLERPState.js b/lib/animators/states/SkeletonNaryLERPState.js new file mode 100755 index 000000000..d4d8142b4 --- /dev/null +++ b/lib/animators/states/SkeletonNaryLERPState.js @@ -0,0 +1,181 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +/** + * + */ +var SkeletonNaryLERPState = (function (_super) { + __extends(SkeletonNaryLERPState, _super); + function SkeletonNaryLERPState(animator, skeletonAnimationNode) { + _super.call(this, animator, skeletonAnimationNode); + this._skeletonPose = new SkeletonPose(); + this._skeletonPoseDirty = true; + this._blendWeights = new Array(); + this._inputs = new Array(); + this._skeletonAnimationNode = skeletonAnimationNode; + var i = this._skeletonAnimationNode.numInputs; + while (i--) + this._inputs[i] = animator.getAnimationState(this._skeletonAnimationNode._iInputs[i]); + } + /** + * @inheritDoc + */ + SkeletonNaryLERPState.prototype.phase = function (value) { + this._skeletonPoseDirty = true; + this._pPositionDeltaDirty = true; + for (var j = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + if (this._blendWeights[j]) + this._inputs[j].update(value); + } + }; + /** + * @inheritDoc + */ + SkeletonNaryLERPState.prototype._pUdateTime = function (time /*int*/) { + for (var j = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + if (this._blendWeights[j]) + this._inputs[j].update(time); + } + _super.prototype._pUpdateTime.call(this, time); + }; + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + SkeletonNaryLERPState.prototype.getSkeletonPose = function (skeleton) { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + return this._skeletonPose; + }; + /** + * Returns the blend weight of the skeleton aniamtion node that resides at the given input index. + * + * @param index The input index for which the skeleton animation node blend weight is requested. + */ + SkeletonNaryLERPState.prototype.getBlendWeightAt = function (index /*uint*/) { + return this._blendWeights[index]; + }; + /** + * Sets the blend weight of the skeleton aniamtion node that resides at the given input index. + * + * @param index The input index on which the skeleton animation node blend weight is to be set. + * @param blendWeight The blend weight value to use for the given skeleton animation node index. + */ + SkeletonNaryLERPState.prototype.setBlendWeightAt = function (index /*uint*/, blendWeight) { + this._blendWeights[index] = blendWeight; + this._pPositionDeltaDirty = true; + this._skeletonPoseDirty = true; + }; + /** + * @inheritDoc + */ + SkeletonNaryLERPState.prototype._pUpdatePositionDelta = function () { + this._pPositionDeltaDirty = false; + var delta; + var weight; + this.positionDelta.x = 0; + this.positionDelta.y = 0; + this.positionDelta.z = 0; + for (var j = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + weight = this._blendWeights[j]; + if (weight) { + delta = this._inputs[j].positionDelta; + this.positionDelta.x += weight * delta.x; + this.positionDelta.y += weight * delta.y; + this.positionDelta.z += weight * delta.z; + } + } + }; + /** + * Updates the output skeleton pose of the node based on the blend weight values given to the input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + SkeletonNaryLERPState.prototype.updateSkeletonPose = function (skeleton) { + this._skeletonPoseDirty = false; + var weight; + var endPoses = this._skeletonPose.jointPoses; + var poses; + var endPose, pose; + var endTr, tr; + var endQuat, q; + var firstPose; + var i /*uint*/; + var w0, x0, y0, z0; + var w1, x1, y1, z1; + var numJoints = skeleton.numJoints; + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + for (var j = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + weight = this._blendWeights[j]; + if (!weight) + continue; + poses = this._inputs[j].getSkeletonPose(skeleton).jointPoses; + if (!firstPose) { + firstPose = poses; + for (i = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + pose = poses[i]; + q = pose.orientation; + tr = pose.translation; + endQuat = endPose.orientation; + endQuat.x = weight * q.x; + endQuat.y = weight * q.y; + endQuat.z = weight * q.z; + endQuat.w = weight * q.w; + endTr = endPose.translation; + endTr.x = weight * tr.x; + endTr.y = weight * tr.y; + endTr.z = weight * tr.z; + } + } + else { + for (i = 0; i < skeleton.numJoints; ++i) { + endPose = endPoses[i]; + pose = poses[i]; + q = firstPose[i].orientation; + x0 = q.x; + y0 = q.y; + z0 = q.z; + w0 = q.w; + q = pose.orientation; + tr = pose.translation; + x1 = q.x; + y1 = q.y; + z1 = q.z; + w1 = q.w; + // find shortest direction + if (x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1 < 0) { + x1 = -x1; + y1 = -y1; + z1 = -z1; + w1 = -w1; + } + endQuat = endPose.orientation; + endQuat.x += weight * x1; + endQuat.y += weight * y1; + endQuat.z += weight * z1; + endQuat.w += weight * w1; + endTr = endPose.translation; + endTr.x += weight * tr.x; + endTr.y += weight * tr.y; + endTr.z += weight * tr.z; + } + } + } + for (i = 0; i < skeleton.numJoints; ++i) + endPoses[i].orientation.normalize(); + }; + return SkeletonNaryLERPState; +})(AnimationStateBase); +module.exports = SkeletonNaryLERPState; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["animators/states/skeletonnarylerpstate.ts"],"names":["SkeletonNaryLERPState","SkeletonNaryLERPState.constructor","SkeletonNaryLERPState.phase","SkeletonNaryLERPState._pUdateTime","SkeletonNaryLERPState.getSkeletonPose","SkeletonNaryLERPState.getBlendWeightAt","SkeletonNaryLERPState.setBlendWeightAt","SkeletonNaryLERPState._pUpdatePositionDelta","SkeletonNaryLERPState.updateSkeletonPose"],"mappings":"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A,OAAOA,CAACA,CAACA,GAAGA,MAAMA,GAACA,CAACA,CAACA,CAACA,CAACA;oBACvBA,OAAOA,CAACA,CAACA,GAAGA,MAAMA,GAACA,CAACA,CAACA,CAACA,CAACA;oBAEvBA,KAAKA,GAAGA,OAAOA,CAACA,WAAWA,CAACA;oBAC5BA,KAAKA,CAACA,CAACA,GAAGA,MAAMA,GAACA,EAAEA,CAACA,CAACA,CAACA;oBACtBA,KAAKA,CAACA,CAACA,GAAGA,MAAMA,GAACA,EAAEA,CAACA,CAACA,CAACA;oBACtBA,KAAKA,CAACA,CAACA,GAAGA,MAAMA,GAACA,EAAEA,CAACA,CAACA,CAACA;gBACvBA,CAACA;YACFA,CAACA;YAACA,IAAIA,CAACA,CAACA;gBACPA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,CAACA,SAASA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;oBACzCA,OAAOA,GAAGA,QAAQA,CAACA,CAACA,CAACA,CAACA;oBACtBA,IAAIA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA;oBAEhBA,CAACA,GAAGA,SAASA,CAACA,CAACA,CAACA,CAACA,WAAWA,CAACA;oBAC7BA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBACTA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBACTA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBACTA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBAETA,CAACA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;oBACrBA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;oBAEtBA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBACTA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBACTA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBACTA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBACTA,AACAA,0BAD0BA;oBAC1BA,EAAEA,CAACA,CAACA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,CAACA,CAACA,CAACA,CAACA;wBACvCA,EAAEA,GAAGA,CAACA,EAAEA,CAACA;wBACTA,EAAEA,GAAGA,CAACA,EAAEA,CAACA;wBACTA,EAAEA,GAAGA,CAACA,EAAEA,CAACA;wBACTA,EAAEA,GAAGA,CAACA,EAAEA,CAACA;oBACVA,CAACA;oBACDA,OAAOA,GAAGA,OAAOA,CAACA,WAAWA,CAACA;oBAC9BA,OAAOA,CAACA,CAACA,IAAIA,MAAMA,GAACA,EAAEA,CAACA;oBACvBA,OAAOA,CAACA,CAACA,IAAIA,MAAMA,GAACA,EAAEA,CAACA;oBACvBA,OAAOA,CAACA,CAACA,IAAIA,MAAMA,GAACA,EAAEA,CAACA;oBACvBA,OAAOA,CAACA,CAACA,IAAIA,MAAMA,GAACA,EAAEA,CAACA;oBAEvBA,KAAKA,GAAGA,OAAOA,CAACA,WAAWA,CAACA;oBAC5BA,KAAKA,CAACA,CAACA,IAAIA,MAAMA,GAACA,EAAEA,CAACA,CAACA,CAACA;oBACvBA,KAAKA,CAACA,CAACA,IAAIA,MAAMA,GAACA,EAAEA,CAACA,CAACA,CAACA;oBACvBA,KAAKA,CAACA,CAACA,IAAIA,MAAMA,GAACA,EAAEA,CAACA,CAACA,CAACA;gBACxBA,CAACA;YACFA,CAACA;QACFA,CAACA;QAEDA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,CAACA,SAASA,EAAEA,EAAEA,CAACA;YACtCA,QAAQA,CAACA,CAACA,CAACA,CAACA,WAAWA,CAACA,SAASA,EAAEA,CAACA;IACtCA,CAACA;IACFR,4BAACA;AAADA,CAhNA,AAgNCA,EAhNmC,kBAAkB,EAgNrD;AAED,AAA+B,iBAAtB,qBAAqB,CAAC","file":"animators/states/SkeletonNaryLERPState.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Quaternion\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Quaternion\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\n\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport SkeletonNaryLERPNode\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/SkeletonNaryLERPNode\");\nimport AnimationStateBase\t\t\t\t= require(\"awayjs-renderergl/lib/animators/states/AnimationStateBase\");\nimport ISkeletonAnimationState\t\t\t= require(\"awayjs-renderergl/lib/animators/states/ISkeletonAnimationState\");\n\n/**\n *\n */\nclass SkeletonNaryLERPState extends AnimationStateBase implements ISkeletonAnimationState\n{\n\tprivate _skeletonAnimationNode:SkeletonNaryLERPNode;\n\tprivate _skeletonPose:SkeletonPose = new SkeletonPose();\n\tprivate _skeletonPoseDirty:boolean = true;\n\tprivate _blendWeights:Array<number> = new Array<number>();\n\tprivate _inputs:Array<ISkeletonAnimationState> = new Array<ISkeletonAnimationState>();\n\n\tconstructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonNaryLERPNode)\n\t{\n\t\tsuper(animator, skeletonAnimationNode);\n\n\t\tthis._skeletonAnimationNode = skeletonAnimationNode;\n\n\t\tvar i:number /*uint*/ = this._skeletonAnimationNode.numInputs;\n\n\t\twhile (i--)\n\t\t\tthis._inputs[i] = <ISkeletonAnimationState> animator.getAnimationState(this._skeletonAnimationNode._iInputs[i]);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic phase(value:number)\n\t{\n\t\tthis._skeletonPoseDirty = true;\n\n\t\tthis._pPositionDeltaDirty = true;\n\n\t\tfor (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) {\n\t\t\tif (this._blendWeights[j])\n\t\t\t\tthis._inputs[j].update(value);\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUdateTime(time:number /*int*/)\n\t{\n\t\tfor (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) {\n\t\t\tif (this._blendWeights[j])\n\t\t\t\tthis._inputs[j].update(time);\n\t\t}\n\n\t\tsuper._pUpdateTime(time);\n\t}\n\n\t/**\n\t * Returns the current skeleton pose of the animation in the clip based on the internal playhead position.\n\t */\n\tpublic getSkeletonPose(skeleton:Skeleton):SkeletonPose\n\t{\n\t\tif (this._skeletonPoseDirty)\n\t\t\tthis.updateSkeletonPose(skeleton);\n\n\t\treturn this._skeletonPose;\n\t}\n\n\t/**\n\t * Returns the blend weight of the skeleton aniamtion node that resides at the given input index.\n\t *\n\t * @param index The input index for which the skeleton animation node blend weight is requested.\n\t */\n\tpublic getBlendWeightAt(index:number /*uint*/):number\n\t{\n\t\treturn this._blendWeights[index];\n\t}\n\n\t/**\n\t * Sets the blend weight of the skeleton aniamtion node that resides at the given input index.\n\t *\n\t * @param index The input index on which the skeleton animation node blend weight is to be set.\n\t * @param blendWeight The blend weight value to use for the given skeleton animation node index.\n\t */\n\tpublic setBlendWeightAt(index:number /*uint*/, blendWeight:number)\n\t{\n\t\tthis._blendWeights[index] = blendWeight;\n\n\t\tthis._pPositionDeltaDirty = true;\n\t\tthis._skeletonPoseDirty = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pUpdatePositionDelta()\n\t{\n\t\tthis._pPositionDeltaDirty = false;\n\n\t\tvar delta:Vector3D;\n\t\tvar weight:number;\n\n\t\tthis.positionDelta.x = 0;\n\t\tthis.positionDelta.y = 0;\n\t\tthis.positionDelta.z = 0;\n\n\t\tfor (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) {\n\t\t\tweight = this._blendWeights[j];\n\n\t\t\tif (weight) {\n\t\t\t\tdelta = this._inputs[j].positionDelta;\n\t\t\t\tthis.positionDelta.x += weight*delta.x;\n\t\t\t\tthis.positionDelta.y += weight*delta.y;\n\t\t\t\tthis.positionDelta.z += weight*delta.z;\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Updates the output skeleton pose of the node based on the blend weight values given to the input nodes.\n\t *\n\t * @param skeleton The skeleton used by the animator requesting the ouput pose.\n\t */\n\tprivate updateSkeletonPose(skeleton:Skeleton)\n\t{\n\t\tthis._skeletonPoseDirty = false;\n\n\t\tvar weight:number;\n\t\tvar endPoses:Array<JointPose> = this._skeletonPose.jointPoses;\n\t\tvar poses:Array<JointPose>;\n\t\tvar endPose:JointPose, pose:JointPose;\n\t\tvar endTr:Vector3D, tr:Vector3D;\n\t\tvar endQuat:Quaternion, q:Quaternion;\n\t\tvar firstPose:Array<JointPose>;\n\t\tvar i:number /*uint*/;\n\t\tvar w0:number, x0:number, y0:number, z0:number;\n\t\tvar w1:number, x1:number, y1:number, z1:number;\n\t\tvar numJoints:number /*uint*/ = skeleton.numJoints;\n\n\t\t// :s\n\t\tif (endPoses.length != numJoints)\n\t\t\tendPoses.length = numJoints;\n\n\t\tfor (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) {\n\t\t\tweight = this._blendWeights[j];\n\n\t\t\tif (!weight)\n\t\t\t\tcontinue;\n\n\t\t\tposes = this._inputs[j].getSkeletonPose(skeleton).jointPoses;\n\n\t\t\tif (!firstPose) {\n\t\t\t\tfirstPose = poses;\n\t\t\t\tfor (i = 0; i < numJoints; ++i) {\n\t\t\t\t\tendPose = endPoses[i];\n\n\t\t\t\t\tif (endPose == null)\n\t\t\t\t\t\tendPose = endPoses[i] = new JointPose();\n\n\t\t\t\t\tpose = poses[i];\n\t\t\t\t\tq = pose.orientation;\n\t\t\t\t\ttr = pose.translation;\n\n\t\t\t\t\tendQuat = endPose.orientation;\n\n\t\t\t\t\tendQuat.x = weight*q.x;\n\t\t\t\t\tendQuat.y = weight*q.y;\n\t\t\t\t\tendQuat.z = weight*q.z;\n\t\t\t\t\tendQuat.w = weight*q.w;\n\n\t\t\t\t\tendTr = endPose.translation;\n\t\t\t\t\tendTr.x = weight*tr.x;\n\t\t\t\t\tendTr.y = weight*tr.y;\n\t\t\t\t\tendTr.z = weight*tr.z;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor (i = 0; i < skeleton.numJoints; ++i) {\n\t\t\t\t\tendPose = endPoses[i];\n\t\t\t\t\tpose = poses[i];\n\n\t\t\t\t\tq = firstPose[i].orientation;\n\t\t\t\t\tx0 = q.x;\n\t\t\t\t\ty0 = q.y;\n\t\t\t\t\tz0 = q.z;\n\t\t\t\t\tw0 = q.w;\n\n\t\t\t\t\tq = pose.orientation;\n\t\t\t\t\ttr = pose.translation;\n\n\t\t\t\t\tx1 = q.x;\n\t\t\t\t\ty1 = q.y;\n\t\t\t\t\tz1 = q.z;\n\t\t\t\t\tw1 = q.w;\n\t\t\t\t\t// find shortest direction\n\t\t\t\t\tif (x0*x1 + y0*y1 + z0*z1 + w0*w1 < 0) {\n\t\t\t\t\t\tx1 = -x1;\n\t\t\t\t\t\ty1 = -y1;\n\t\t\t\t\t\tz1 = -z1;\n\t\t\t\t\t\tw1 = -w1;\n\t\t\t\t\t}\n\t\t\t\t\tendQuat = endPose.orientation;\n\t\t\t\t\tendQuat.x += weight*x1;\n\t\t\t\t\tendQuat.y += weight*y1;\n\t\t\t\t\tendQuat.z += weight*z1;\n\t\t\t\t\tendQuat.w += weight*w1;\n\n\t\t\t\t\tendTr = endPose.translation;\n\t\t\t\t\tendTr.x += weight*tr.x;\n\t\t\t\t\tendTr.y += weight*tr.y;\n\t\t\t\t\tendTr.z += weight*tr.z;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0; i < skeleton.numJoints; ++i)\n\t\t\tendPoses[i].orientation.normalize();\n\t}\n}\n\nexport = SkeletonNaryLERPState;"]} \ No newline at end of file diff --git a/lib/animators/states/SkeletonNaryLERPState.ts b/lib/animators/states/SkeletonNaryLERPState.ts new file mode 100644 index 000000000..16a84c27c --- /dev/null +++ b/lib/animators/states/SkeletonNaryLERPState.ts @@ -0,0 +1,226 @@ +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import SkeletonNaryLERPNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonNaryLERPNode"); +import AnimationStateBase = require("awayjs-renderergl/lib/animators/states/AnimationStateBase"); +import ISkeletonAnimationState = require("awayjs-renderergl/lib/animators/states/ISkeletonAnimationState"); + +/** + * + */ +class SkeletonNaryLERPState extends AnimationStateBase implements ISkeletonAnimationState +{ + private _skeletonAnimationNode:SkeletonNaryLERPNode; + private _skeletonPose:SkeletonPose = new SkeletonPose(); + private _skeletonPoseDirty:boolean = true; + private _blendWeights:Array = new Array(); + private _inputs:Array = new Array(); + + constructor(animator:AnimatorBase, skeletonAnimationNode:SkeletonNaryLERPNode) + { + super(animator, skeletonAnimationNode); + + this._skeletonAnimationNode = skeletonAnimationNode; + + var i:number /*uint*/ = this._skeletonAnimationNode.numInputs; + + while (i--) + this._inputs[i] = animator.getAnimationState(this._skeletonAnimationNode._iInputs[i]); + } + + /** + * @inheritDoc + */ + public phase(value:number) + { + this._skeletonPoseDirty = true; + + this._pPositionDeltaDirty = true; + + for (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + if (this._blendWeights[j]) + this._inputs[j].update(value); + } + } + + /** + * @inheritDoc + */ + public _pUdateTime(time:number /*int*/) + { + for (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + if (this._blendWeights[j]) + this._inputs[j].update(time); + } + + super._pUpdateTime(time); + } + + /** + * Returns the current skeleton pose of the animation in the clip based on the internal playhead position. + */ + public getSkeletonPose(skeleton:Skeleton):SkeletonPose + { + if (this._skeletonPoseDirty) + this.updateSkeletonPose(skeleton); + + return this._skeletonPose; + } + + /** + * Returns the blend weight of the skeleton aniamtion node that resides at the given input index. + * + * @param index The input index for which the skeleton animation node blend weight is requested. + */ + public getBlendWeightAt(index:number /*uint*/):number + { + return this._blendWeights[index]; + } + + /** + * Sets the blend weight of the skeleton aniamtion node that resides at the given input index. + * + * @param index The input index on which the skeleton animation node blend weight is to be set. + * @param blendWeight The blend weight value to use for the given skeleton animation node index. + */ + public setBlendWeightAt(index:number /*uint*/, blendWeight:number) + { + this._blendWeights[index] = blendWeight; + + this._pPositionDeltaDirty = true; + this._skeletonPoseDirty = true; + } + + /** + * @inheritDoc + */ + public _pUpdatePositionDelta() + { + this._pPositionDeltaDirty = false; + + var delta:Vector3D; + var weight:number; + + this.positionDelta.x = 0; + this.positionDelta.y = 0; + this.positionDelta.z = 0; + + for (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + weight = this._blendWeights[j]; + + if (weight) { + delta = this._inputs[j].positionDelta; + this.positionDelta.x += weight*delta.x; + this.positionDelta.y += weight*delta.y; + this.positionDelta.z += weight*delta.z; + } + } + } + + /** + * Updates the output skeleton pose of the node based on the blend weight values given to the input nodes. + * + * @param skeleton The skeleton used by the animator requesting the ouput pose. + */ + private updateSkeletonPose(skeleton:Skeleton) + { + this._skeletonPoseDirty = false; + + var weight:number; + var endPoses:Array = this._skeletonPose.jointPoses; + var poses:Array; + var endPose:JointPose, pose:JointPose; + var endTr:Vector3D, tr:Vector3D; + var endQuat:Quaternion, q:Quaternion; + var firstPose:Array; + var i:number /*uint*/; + var w0:number, x0:number, y0:number, z0:number; + var w1:number, x1:number, y1:number, z1:number; + var numJoints:number /*uint*/ = skeleton.numJoints; + + // :s + if (endPoses.length != numJoints) + endPoses.length = numJoints; + + for (var j:number /*uint*/ = 0; j < this._skeletonAnimationNode.numInputs; ++j) { + weight = this._blendWeights[j]; + + if (!weight) + continue; + + poses = this._inputs[j].getSkeletonPose(skeleton).jointPoses; + + if (!firstPose) { + firstPose = poses; + for (i = 0; i < numJoints; ++i) { + endPose = endPoses[i]; + + if (endPose == null) + endPose = endPoses[i] = new JointPose(); + + pose = poses[i]; + q = pose.orientation; + tr = pose.translation; + + endQuat = endPose.orientation; + + endQuat.x = weight*q.x; + endQuat.y = weight*q.y; + endQuat.z = weight*q.z; + endQuat.w = weight*q.w; + + endTr = endPose.translation; + endTr.x = weight*tr.x; + endTr.y = weight*tr.y; + endTr.z = weight*tr.z; + } + } else { + for (i = 0; i < skeleton.numJoints; ++i) { + endPose = endPoses[i]; + pose = poses[i]; + + q = firstPose[i].orientation; + x0 = q.x; + y0 = q.y; + z0 = q.z; + w0 = q.w; + + q = pose.orientation; + tr = pose.translation; + + x1 = q.x; + y1 = q.y; + z1 = q.z; + w1 = q.w; + // find shortest direction + if (x0*x1 + y0*y1 + z0*z1 + w0*w1 < 0) { + x1 = -x1; + y1 = -y1; + z1 = -z1; + w1 = -w1; + } + endQuat = endPose.orientation; + endQuat.x += weight*x1; + endQuat.y += weight*y1; + endQuat.z += weight*z1; + endQuat.w += weight*w1; + + endTr = endPose.translation; + endTr.x += weight*tr.x; + endTr.y += weight*tr.y; + endTr.z += weight*tr.z; + } + } + } + + for (i = 0; i < skeleton.numJoints; ++i) + endPoses[i].orientation.normalize(); + } +} + +export = SkeletonNaryLERPState; \ No newline at end of file diff --git a/lib/animators/states/VertexClipState.js b/lib/animators/states/VertexClipState.js new file mode 100755 index 000000000..fdace4ecd --- /dev/null +++ b/lib/animators/states/VertexClipState.js @@ -0,0 +1,65 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AnimationClipState = require("awayjs-renderergl/lib/animators/states/AnimationClipState"); +/** + * + */ +var VertexClipState = (function (_super) { + __extends(VertexClipState, _super); + function VertexClipState(animator, vertexClipNode) { + _super.call(this, animator, vertexClipNode); + this._vertexClipNode = vertexClipNode; + this._frames = this._vertexClipNode.frames; + } + Object.defineProperty(VertexClipState.prototype, "currentGeometry", { + /** + * @inheritDoc + */ + get: function () { + if (this._pFramesDirty) + this._pUpdateFrames(); + return this._currentGeometry; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(VertexClipState.prototype, "nextGeometry", { + /** + * @inheritDoc + */ + get: function () { + if (this._pFramesDirty) + this._pUpdateFrames(); + return this._nextGeometry; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + VertexClipState.prototype._pUpdateFrames = function () { + _super.prototype._pUpdateFrames.call(this); + this._currentGeometry = this._frames[this._pCurrentFrame]; + if (this._vertexClipNode.looping && this._pNextFrame >= this._vertexClipNode.lastFrame) { + this._nextGeometry = this._frames[0]; + this._pAnimator.dispatchCycleEvent(); + } + else + this._nextGeometry = this._frames[this._pNextFrame]; + }; + /** + * @inheritDoc + */ + VertexClipState.prototype._pUpdatePositionDelta = function () { + //TODO:implement positiondelta functionality for vertex animations + }; + return VertexClipState; +})(AnimationClipState); +module.exports = VertexClipState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/states/VertexClipState.ts b/lib/animators/states/VertexClipState.ts new file mode 100644 index 000000000..8e235d387 --- /dev/null +++ b/lib/animators/states/VertexClipState.ts @@ -0,0 +1,75 @@ +import Geometry = require("awayjs-core/lib/core/base/Geometry"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import VertexAnimator = require("awayjs-renderergl/lib/animators/VertexAnimator"); +import VertexClipNode = require("awayjs-renderergl/lib/animators/nodes/VertexClipNode"); +import AnimationClipState = require("awayjs-renderergl/lib/animators/states/AnimationClipState"); +import IVertexAnimationState = require("awayjs-renderergl/lib/animators/states/IVertexAnimationState"); + +/** + * + */ +class VertexClipState extends AnimationClipState implements IVertexAnimationState +{ + private _frames:Array; + private _vertexClipNode:VertexClipNode; + private _currentGeometry:Geometry; + private _nextGeometry:Geometry; + + /** + * @inheritDoc + */ + public get currentGeometry():Geometry + { + if (this._pFramesDirty) + this._pUpdateFrames(); + + return this._currentGeometry; + } + + /** + * @inheritDoc + */ + public get nextGeometry():Geometry + { + if (this._pFramesDirty) + this._pUpdateFrames(); + + return this._nextGeometry; + } + + constructor(animator:AnimatorBase, vertexClipNode:VertexClipNode) + { + super(animator, vertexClipNode); + + this._vertexClipNode = vertexClipNode; + this._frames = this._vertexClipNode.frames; + } + + /** + * @inheritDoc + */ + public _pUpdateFrames() + { + super._pUpdateFrames(); + + this._currentGeometry = this._frames[this._pCurrentFrame]; + + if (this._vertexClipNode.looping && this._pNextFrame >= this._vertexClipNode.lastFrame) { + this._nextGeometry = this._frames[0]; + ( this._pAnimator).dispatchCycleEvent(); + } else + this._nextGeometry = this._frames[this._pNextFrame]; + } + + /** + * @inheritDoc + */ + public _pUpdatePositionDelta() + { + //TODO:implement positiondelta functionality for vertex animations + } +} + +export = VertexClipState; \ No newline at end of file diff --git a/lib/animators/transitions/CrossfadeTransition.js b/lib/animators/transitions/CrossfadeTransition.js new file mode 100755 index 000000000..39a6500f2 --- /dev/null +++ b/lib/animators/transitions/CrossfadeTransition.js @@ -0,0 +1,22 @@ +var CrossfadeTransitionNode = require("awayjs-renderergl/lib/animators/transitions/CrossfadeTransitionNode"); +/** + * + */ +var CrossfadeTransition = (function () { + function CrossfadeTransition(blendSpeed) { + this.blendSpeed = 0.5; + this.blendSpeed = blendSpeed; + } + CrossfadeTransition.prototype.getAnimationNode = function (animator, startNode, endNode, startBlend /*int*/) { + var crossFadeTransitionNode = new CrossfadeTransitionNode(); + crossFadeTransitionNode.inputA = startNode; + crossFadeTransitionNode.inputB = endNode; + crossFadeTransitionNode.blendSpeed = this.blendSpeed; + crossFadeTransitionNode.startBlend = startBlend; + return crossFadeTransitionNode; + }; + return CrossfadeTransition; +})(); +module.exports = CrossfadeTransition; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/transitions/CrossfadeTransition.ts b/lib/animators/transitions/CrossfadeTransition.ts new file mode 100644 index 000000000..735490b90 --- /dev/null +++ b/lib/animators/transitions/CrossfadeTransition.ts @@ -0,0 +1,32 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import CrossfadeTransitionNode = require("awayjs-renderergl/lib/animators/transitions/CrossfadeTransitionNode"); +import IAnimationTransition = require("awayjs-renderergl/lib/animators/transitions/IAnimationTransition"); + +/** + * + */ +class CrossfadeTransition implements IAnimationTransition +{ + public blendSpeed:number = 0.5; + + constructor(blendSpeed:number) + { + this.blendSpeed = blendSpeed; + } + + public getAnimationNode(animator:AnimatorBase, startNode:AnimationNodeBase, endNode:AnimationNodeBase, startBlend:number /*int*/):AnimationNodeBase + { + var crossFadeTransitionNode:CrossfadeTransitionNode = new CrossfadeTransitionNode(); + crossFadeTransitionNode.inputA = startNode; + crossFadeTransitionNode.inputB = endNode; + crossFadeTransitionNode.blendSpeed = this.blendSpeed; + crossFadeTransitionNode.startBlend = startBlend; + + return crossFadeTransitionNode; + } +} + +export = CrossfadeTransition; \ No newline at end of file diff --git a/lib/animators/transitions/CrossfadeTransitionNode.js b/lib/animators/transitions/CrossfadeTransitionNode.js new file mode 100755 index 000000000..f0ce26b4d --- /dev/null +++ b/lib/animators/transitions/CrossfadeTransitionNode.js @@ -0,0 +1,25 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var SkeletonBinaryLERPNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonBinaryLERPNode"); +var CrossfadeTransitionState = require("awayjs-renderergl/lib/animators/transitions/CrossfadeTransitionState"); +/** + * A skeleton animation node that uses two animation node inputs to blend a lineraly interpolated output of a skeleton pose. + */ +var CrossfadeTransitionNode = (function (_super) { + __extends(CrossfadeTransitionNode, _super); + /** + * Creates a new CrossfadeTransitionNode object. + */ + function CrossfadeTransitionNode() { + _super.call(this); + this._pStateClass = CrossfadeTransitionState; + } + return CrossfadeTransitionNode; +})(SkeletonBinaryLERPNode); +module.exports = CrossfadeTransitionNode; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy90cmFuc2l0aW9ucy9jcm9zc2ZhZGV0cmFuc2l0aW9ubm9kZS50cyJdLCJuYW1lcyI6WyJDcm9zc2ZhZGVUcmFuc2l0aW9uTm9kZSIsIkNyb3NzZmFkZVRyYW5zaXRpb25Ob2RlLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxJQUFPLHNCQUFzQixXQUFhLDhEQUE4RCxDQUFDLENBQUM7QUFDMUcsSUFBTyx3QkFBd0IsV0FBYSxzRUFBc0UsQ0FBQyxDQUFDO0FBRXBILEFBR0E7O0dBREc7SUFDRyx1QkFBdUI7SUFBU0EsVUFBaENBLHVCQUF1QkEsVUFBK0JBO0lBTTNEQTs7T0FFR0E7SUFDSEEsU0FUS0EsdUJBQXVCQTtRQVczQkMsaUJBQU9BLENBQUNBO1FBRVJBLElBQUlBLENBQUNBLFlBQVlBLEdBQUdBLHdCQUF3QkEsQ0FBQ0E7SUFDOUNBLENBQUNBO0lBQ0ZELDhCQUFDQTtBQUFEQSxDQWZBLEFBZUNBLEVBZnFDLHNCQUFzQixFQWUzRDtBQUVELEFBQWlDLGlCQUF4Qix1QkFBdUIsQ0FBQyIsImZpbGUiOiJhbmltYXRvcnMvdHJhbnNpdGlvbnMvQ3Jvc3NmYWRlVHJhbnNpdGlvbk5vZGUuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgU2tlbGV0b25CaW5hcnlMRVJQTm9kZVx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1yZW5kZXJlcmdsL2xpYi9hbmltYXRvcnMvbm9kZXMvU2tlbGV0b25CaW5hcnlMRVJQTm9kZVwiKTtcbmltcG9ydCBDcm9zc2ZhZGVUcmFuc2l0aW9uU3RhdGVcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL3RyYW5zaXRpb25zL0Nyb3NzZmFkZVRyYW5zaXRpb25TdGF0ZVwiKTtcblxuLyoqXG4gKiBBIHNrZWxldG9uIGFuaW1hdGlvbiBub2RlIHRoYXQgdXNlcyB0d28gYW5pbWF0aW9uIG5vZGUgaW5wdXRzIHRvIGJsZW5kIGEgbGluZXJhbHkgaW50ZXJwb2xhdGVkIG91dHB1dCBvZiBhIHNrZWxldG9uIHBvc2UuXG4gKi9cbmNsYXNzIENyb3NzZmFkZVRyYW5zaXRpb25Ob2RlIGV4dGVuZHMgU2tlbGV0b25CaW5hcnlMRVJQTm9kZVxue1xuXHRwdWJsaWMgYmxlbmRTcGVlZDpudW1iZXI7XG5cblx0cHVibGljIHN0YXJ0QmxlbmQ6bnVtYmVyIC8qaW50Ki87XG5cblx0LyoqXG5cdCAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+Q3Jvc3NmYWRlVHJhbnNpdGlvbk5vZGU8L2NvZGU+IG9iamVjdC5cblx0ICovXG5cdGNvbnN0cnVjdG9yKClcblx0e1xuXHRcdHN1cGVyKCk7XG5cblx0XHR0aGlzLl9wU3RhdGVDbGFzcyA9IENyb3NzZmFkZVRyYW5zaXRpb25TdGF0ZTtcblx0fVxufVxuXG5leHBvcnQgPSBDcm9zc2ZhZGVUcmFuc2l0aW9uTm9kZTsiXX0= \ No newline at end of file diff --git a/lib/animators/transitions/CrossfadeTransitionNode.ts b/lib/animators/transitions/CrossfadeTransitionNode.ts new file mode 100644 index 000000000..129b27a6d --- /dev/null +++ b/lib/animators/transitions/CrossfadeTransitionNode.ts @@ -0,0 +1,24 @@ +import SkeletonBinaryLERPNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonBinaryLERPNode"); +import CrossfadeTransitionState = require("awayjs-renderergl/lib/animators/transitions/CrossfadeTransitionState"); + +/** + * A skeleton animation node that uses two animation node inputs to blend a lineraly interpolated output of a skeleton pose. + */ +class CrossfadeTransitionNode extends SkeletonBinaryLERPNode +{ + public blendSpeed:number; + + public startBlend:number /*int*/; + + /** + * Creates a new CrossfadeTransitionNode object. + */ + constructor() + { + super(); + + this._pStateClass = CrossfadeTransitionState; + } +} + +export = CrossfadeTransitionNode; \ No newline at end of file diff --git a/lib/animators/transitions/CrossfadeTransitionState.js b/lib/animators/transitions/CrossfadeTransitionState.js new file mode 100755 index 000000000..c55963505 --- /dev/null +++ b/lib/animators/transitions/CrossfadeTransitionState.js @@ -0,0 +1,35 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var SkeletonBinaryLERPState = require("awayjs-renderergl/lib/animators/states/SkeletonBinaryLERPState"); +var AnimationStateEvent = require("awayjs-renderergl/lib/events/AnimationStateEvent"); +/** + * + */ +var CrossfadeTransitionState = (function (_super) { + __extends(CrossfadeTransitionState, _super); + function CrossfadeTransitionState(animator, skeletonAnimationNode) { + _super.call(this, animator, skeletonAnimationNode); + this._crossfadeTransitionNode = skeletonAnimationNode; + } + /** + * @inheritDoc + */ + CrossfadeTransitionState.prototype._pUpdateTime = function (time /*int*/) { + this.blendWeight = Math.abs(time - this._crossfadeTransitionNode.startBlend) / (1000 * this._crossfadeTransitionNode.blendSpeed); + if (this.blendWeight >= 1) { + this.blendWeight = 1; + if (this._animationStateTransitionComplete == null) + this._animationStateTransitionComplete = new AnimationStateEvent(AnimationStateEvent.TRANSITION_COMPLETE, this._pAnimator, this, this._crossfadeTransitionNode); + this._crossfadeTransitionNode.dispatchEvent(this._animationStateTransitionComplete); + } + _super.prototype._pUpdateTime.call(this, time); + }; + return CrossfadeTransitionState; +})(SkeletonBinaryLERPState); +module.exports = CrossfadeTransitionState; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/animators/transitions/CrossfadeTransitionState.ts b/lib/animators/transitions/CrossfadeTransitionState.ts new file mode 100644 index 000000000..eff134e42 --- /dev/null +++ b/lib/animators/transitions/CrossfadeTransitionState.ts @@ -0,0 +1,43 @@ +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +import SkeletonBinaryLERPNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonBinaryLERPNode"); +import SkeletonBinaryLERPState = require("awayjs-renderergl/lib/animators/states/SkeletonBinaryLERPState"); +import CrossfadeTransitionNode = require("awayjs-renderergl/lib/animators/transitions/CrossfadeTransitionNode"); +import AnimationStateEvent = require("awayjs-renderergl/lib/events/AnimationStateEvent"); + +/** + * + */ +class CrossfadeTransitionState extends SkeletonBinaryLERPState +{ + private _crossfadeTransitionNode:CrossfadeTransitionNode; + private _animationStateTransitionComplete:AnimationStateEvent; + + constructor(animator:AnimatorBase, skeletonAnimationNode:CrossfadeTransitionNode) + { + super(animator, skeletonAnimationNode); + + this._crossfadeTransitionNode = skeletonAnimationNode; + } + + /** + * @inheritDoc + */ + public _pUpdateTime(time:number /*int*/) + { + this.blendWeight = Math.abs(time - this._crossfadeTransitionNode.startBlend)/(1000*this._crossfadeTransitionNode.blendSpeed); + + if (this.blendWeight >= 1) { + this.blendWeight = 1; + + if (this._animationStateTransitionComplete == null) + this._animationStateTransitionComplete = new AnimationStateEvent(AnimationStateEvent.TRANSITION_COMPLETE, this._pAnimator, this, this._crossfadeTransitionNode); + + this._crossfadeTransitionNode.dispatchEvent(this._animationStateTransitionComplete); + } + + super._pUpdateTime(time); + } +} + +export = CrossfadeTransitionState; \ No newline at end of file diff --git a/lib/animators/transitions/IAnimationTransition.js b/lib/animators/transitions/IAnimationTransition.js new file mode 100755 index 000000000..9eb8adebf --- /dev/null +++ b/lib/animators/transitions/IAnimationTransition.js @@ -0,0 +1,3 @@ + + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFuaW1hdG9ycy90cmFuc2l0aW9ucy9pYW5pbWF0aW9udHJhbnNpdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFZOEIiLCJmaWxlIjoiYW5pbWF0b3JzL3RyYW5zaXRpb25zL0lBbmltYXRpb25UcmFuc2l0aW9uLmpzIiwic291cmNlUm9vdCI6Ii9Vc2Vycy9yb2JiYXRlbWFuL1dlYnN0b3JtUHJvamVjdHMvYXdheWpzLXJlbmRlcmVyZ2wvIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IEFuaW1hdGlvbk5vZGVCYXNlXHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtY29yZS9saWIvYW5pbWF0b3JzL25vZGVzL0FuaW1hdGlvbk5vZGVCYXNlXCIpO1xuXG5pbXBvcnQgQW5pbWF0b3JCYXNlXHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLXN0YWdlZ2wvbGliL2FuaW1hdG9ycy9BbmltYXRvckJhc2VcIik7XG5cbi8qKlxuICpcbiAqL1xuaW50ZXJmYWNlIElBbmltYXRpb25UcmFuc2l0aW9uXG57XG5cdGdldEFuaW1hdGlvbk5vZGUoYW5pbWF0b3I6QW5pbWF0b3JCYXNlLCBzdGFydE5vZGU6QW5pbWF0aW9uTm9kZUJhc2UsIGVuZE5vZGU6QW5pbWF0aW9uTm9kZUJhc2UsIHN0YXJ0VGltZTpudW1iZXIgLyppbnQqLyk6QW5pbWF0aW9uTm9kZUJhc2Vcbn1cblxuZXhwb3J0ID0gSUFuaW1hdGlvblRyYW5zaXRpb247Il19 \ No newline at end of file diff --git a/lib/animators/transitions/IAnimationTransition.ts b/lib/animators/transitions/IAnimationTransition.ts new file mode 100644 index 000000000..da5e44e3d --- /dev/null +++ b/lib/animators/transitions/IAnimationTransition.ts @@ -0,0 +1,13 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); + +/** + * + */ +interface IAnimationTransition +{ + getAnimationNode(animator:AnimatorBase, startNode:AnimationNodeBase, endNode:AnimationNodeBase, startTime:number /*int*/):AnimationNodeBase +} + +export = IAnimationTransition; \ No newline at end of file diff --git a/lib/core/base/ParticleGeometry.js b/lib/core/base/ParticleGeometry.js new file mode 100755 index 000000000..0c2438190 --- /dev/null +++ b/lib/core/base/ParticleGeometry.js @@ -0,0 +1,20 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Geometry = require("awayjs-core/lib/core/base/Geometry"); +/** + * @class away.base.ParticleGeometry + */ +var ParticleGeometry = (function (_super) { + __extends(ParticleGeometry, _super); + function ParticleGeometry() { + _super.apply(this, arguments); + } + return ParticleGeometry; +})(Geometry); +module.exports = ParticleGeometry; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvcmUvYmFzZS9wYXJ0aWNsZWdlb21ldHJ5LnRzIl0sIm5hbWVzIjpbIlBhcnRpY2xlR2VvbWV0cnkiLCJQYXJ0aWNsZUdlb21ldHJ5LmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxJQUFPLFFBQVEsV0FBaUIsb0NBQW9DLENBQUMsQ0FBQztBQUl0RSxBQUdBOztHQURHO0lBQ0csZ0JBQWdCO0lBQVNBLFVBQXpCQSxnQkFBZ0JBLFVBQWlCQTtJQUF2Q0EsU0FBTUEsZ0JBQWdCQTtRQUFTQyw4QkFBUUE7SUFNdkNBLENBQUNBO0lBQURELHVCQUFDQTtBQUFEQSxDQU5BLEFBTUNBLEVBTjhCLFFBQVEsRUFNdEM7QUFFRCxBQUEwQixpQkFBakIsZ0JBQWdCLENBQUMiLCJmaWxlIjoiY29yZS9iYXNlL1BhcnRpY2xlR2VvbWV0cnkuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgR2VvbWV0cnlcdFx0XHRcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1jb3JlL2xpYi9jb3JlL2Jhc2UvR2VvbWV0cnlcIik7XG5cbmltcG9ydCBQYXJ0aWNsZURhdGFcdFx0XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvYW5pbWF0b3JzL2RhdGEvUGFydGljbGVEYXRhXCIpO1xuXG4vKipcbiAqIEBjbGFzcyBhd2F5LmJhc2UuUGFydGljbGVHZW9tZXRyeVxuICovXG5jbGFzcyBQYXJ0aWNsZUdlb21ldHJ5IGV4dGVuZHMgR2VvbWV0cnlcbntcblx0cHVibGljIHBhcnRpY2xlczpBcnJheTxQYXJ0aWNsZURhdGE+O1xuXG5cdHB1YmxpYyBudW1QYXJ0aWNsZXM6bnVtYmVyIC8qdWludCovO1xuXG59XG5cbmV4cG9ydCA9IFBhcnRpY2xlR2VvbWV0cnk7Il19 \ No newline at end of file diff --git a/lib/core/base/ParticleGeometry.ts b/lib/core/base/ParticleGeometry.ts new file mode 100644 index 000000000..ef3fe100b --- /dev/null +++ b/lib/core/base/ParticleGeometry.ts @@ -0,0 +1,16 @@ +import Geometry = require("awayjs-core/lib/core/base/Geometry"); + +import ParticleData = require("awayjs-renderergl/lib/animators/data/ParticleData"); + +/** + * @class away.base.ParticleGeometry + */ +class ParticleGeometry extends Geometry +{ + public particles:Array; + + public numParticles:number /*uint*/; + +} + +export = ParticleGeometry; \ No newline at end of file diff --git a/lib/core/pick/JSPickingCollider.js b/lib/core/pick/JSPickingCollider.js new file mode 100755 index 000000000..cfce29082 --- /dev/null +++ b/lib/core/pick/JSPickingCollider.js @@ -0,0 +1,137 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var PickingColliderBase = require("awayjs-renderergl/lib/core/pick/PickingColliderBase"); +/** + * Pure JS picking collider for display objects. Used with the RaycastPicker picking object. + * + * @see away.base.DisplayObject#pickingCollider + * @see away.pick.RaycastPicker + * + * @class away.pick.JSPickingCollider + */ +var JSPickingCollider = (function (_super) { + __extends(JSPickingCollider, _super); + /** + * Creates a new JSPickingCollider object. + * + * @param findClosestCollision Determines whether the picking collider searches for the closest collision along the ray. Defaults to false. + */ + function JSPickingCollider(findClosestCollision) { + if (findClosestCollision === void 0) { findClosestCollision = false; } + _super.call(this); + this._findClosestCollision = findClosestCollision; + } + /** + * @inheritDoc + */ + JSPickingCollider.prototype._pTestRenderableCollision = function (renderable, pickingCollisionVO, shortestCollisionDistance) { + var t; + var i0, i1, i2; + var rx, ry, rz; + var nx, ny, nz; + var cx, cy, cz; + var coeff, u, v, w; + var p0x, p0y, p0z; + var p1x, p1y, p1z; + var p2x, p2y, p2z; + var s0x, s0y, s0z; + var s1x, s1y, s1z; + var nl, nDotV, D, disToPlane; + var Q1Q2, Q1Q1, Q2Q2, RQ1, RQ2; + var indexData = renderable.getIndexData().data; + var collisionTriangleIndex = -1; + var bothSides = renderable.materialOwner.material.bothSides; + var positionData = renderable.getVertexData(TriangleSubGeometry.POSITION_DATA).data; + var positionStride = renderable.getVertexData(TriangleSubGeometry.POSITION_DATA).dataPerVertex; + var positionOffset = renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA); + var uvData = renderable.getVertexData(TriangleSubGeometry.UV_DATA).data; + var uvStride = renderable.getVertexData(TriangleSubGeometry.UV_DATA).dataPerVertex; + var uvOffset = renderable.getVertexOffset(TriangleSubGeometry.UV_DATA); + var numIndices = indexData.length; + for (var index = 0; index < numIndices; index += 3) { + // evaluate triangle indices + i0 = positionOffset + indexData[index] * positionStride; + i1 = positionOffset + indexData[(index + 1)] * positionStride; + i2 = positionOffset + indexData[(index + 2)] * positionStride; + // evaluate triangle positions + p0x = positionData[i0]; + p0y = positionData[(i0 + 1)]; + p0z = positionData[(i0 + 2)]; + p1x = positionData[i1]; + p1y = positionData[(i1 + 1)]; + p1z = positionData[(i1 + 2)]; + p2x = positionData[i2]; + p2y = positionData[(i2 + 1)]; + p2z = positionData[(i2 + 2)]; + // evaluate sides and triangle normal + s0x = p1x - p0x; // s0 = p1 - p0 + s0y = p1y - p0y; + s0z = p1z - p0z; + s1x = p2x - p0x; // s1 = p2 - p0 + s1y = p2y - p0y; + s1z = p2z - p0z; + nx = s0y * s1z - s0z * s1y; // n = s0 x s1 + ny = s0z * s1x - s0x * s1z; + nz = s0x * s1y - s0y * s1x; + nl = 1 / Math.sqrt(nx * nx + ny * ny + nz * nz); // normalize n + nx *= nl; + ny *= nl; + nz *= nl; + // -- plane intersection test -- + nDotV = nx * this.rayDirection.x + ny * +this.rayDirection.y + nz * this.rayDirection.z; // rayDirection . normal + if ((!bothSides && nDotV < 0.0) || (bothSides && nDotV != 0.0)) { + // find collision t + D = -(nx * p0x + ny * p0y + nz * p0z); + disToPlane = -(nx * this.rayPosition.x + ny * this.rayPosition.y + nz * this.rayPosition.z + D); + t = disToPlane / nDotV; + // find collision point + cx = this.rayPosition.x + t * this.rayDirection.x; + cy = this.rayPosition.y + t * this.rayDirection.y; + cz = this.rayPosition.z + t * this.rayDirection.z; + // collision point inside triangle? ( using barycentric coordinates ) + Q1Q2 = s0x * s1x + s0y * s1y + s0z * s1z; + Q1Q1 = s0x * s0x + s0y * s0y + s0z * s0z; + Q2Q2 = s1x * s1x + s1y * s1y + s1z * s1z; + rx = cx - p0x; + ry = cy - p0y; + rz = cz - p0z; + RQ1 = rx * s0x + ry * s0y + rz * s0z; + RQ2 = rx * s1x + ry * s1y + rz * s1z; + coeff = 1 / (Q1Q1 * Q2Q2 - Q1Q2 * Q1Q2); + v = coeff * (Q2Q2 * RQ1 - Q1Q2 * RQ2); + w = coeff * (-Q1Q2 * RQ1 + Q1Q1 * RQ2); + if (v < 0) + continue; + if (w < 0) + continue; + u = 1 - v - w; + if (!(u < 0) && t > 0 && t < shortestCollisionDistance) { + shortestCollisionDistance = t; + collisionTriangleIndex = index / 3; + pickingCollisionVO.rayEntryDistance = t; + pickingCollisionVO.localPosition = new Vector3D(cx, cy, cz); + pickingCollisionVO.localNormal = new Vector3D(nx, ny, nz); + pickingCollisionVO.uv = this._pGetCollisionUV(indexData, uvData, index, v, w, u, uvOffset, uvStride); + pickingCollisionVO.index = index; + // pickingCollisionVO.subGeometryIndex = this.pGetMeshSubMeshIndex(renderable); + // if not looking for best hit, first found will do... + if (!this._findClosestCollision) + return true; + } + } + } + if (collisionTriangleIndex >= 0) + return true; + return false; + }; + return JSPickingCollider; +})(PickingColliderBase); +module.exports = JSPickingCollider; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["core/pick/jspickingcollider.ts"],"names":["JSPickingCollider","JSPickingCollider.constructor","JSPickingCollider._pTestRenderableCollision"],"mappings":";;;;;;AAAA,IAAO,mBAAmB,WAAc,+CAA+C,CAAC,CAAC;AACzF,IAAO,QAAQ,WAAiB,oCAAoC,CAAC,CAAC;AAOtE,IAAO,mBAAmB,WAAc,qDAAqD,CAAC,CAAC;AAE/F,AAQA;;;;;;;GADG;IACG,iBAAiB;IAASA,UAA1BA,iBAAiBA,UAA4BA;IAIlDA;;;;OAIGA;IACHA,SATKA,iBAAiBA,CASVA,oBAAoCA;QAApCC,oCAAoCA,GAApCA,4BAAoCA;QAE/CA,iBAAOA,CAACA;QAERA,IAAIA,CAACA,qBAAqBA,GAAGA,oBAAoBA,CAACA;IACnDA,CAACA;IAEDD;;OAEGA;IACIA,qDAAyBA,GAAhCA,UAAiCA,UAAyBA,EAAEA,kBAAqCA,EAAEA,yBAAgCA;QAElIE,IAAIA,CAAQA,CAACA;QACbA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,KAAYA,EAAEA,CAAQA,EAAEA,CAAQA,EAAEA,CAAQA,CAACA;QAC/CA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,GAAUA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QACvCA,IAAIA,EAASA,EAAEA,KAAYA,EAAEA,CAAQA,EAAEA,UAAiBA,CAACA;QACzDA,IAAIA,IAAWA,EAAEA,IAAWA,EAAEA,IAAWA,EAAEA,GAAUA,EAAEA,GAAUA,CAACA;QAClEA,IAAIA,SAASA,GAAiBA,UAAUA,CAACA,YAAYA,EAAEA,CAACA,IAAIA,CAACA;QAC7DA,IAAIA,sBAAsBA,GAAUA,CAACA,CAACA,CAACA;QACvCA,IAAIA,SAASA,GAA2BA,UAAUA,CAACA,aAAaA,CAACA,QAASA,CAACA,SAASA,CAACA;QAErFA,IAAIA,YAAYA,GAAiBA,UAAUA,CAACA,aAAaA,CAACA,mBAAmBA,CAACA,aAAaA,CAACA,CAACA,IAAIA,CAACA;QAClGA,IAAIA,cAAcA,GAAUA,UAAUA,CAACA,aAAaA,CAACA,mBAAmBA,CAACA,aAAaA,CAACA,CAACA,aAAaA,CAACA;QACtGA,IAAIA,cAAcA,GAAUA,UAAUA,CAACA,eAAeA,CAACA,mBAAmBA,CAACA,aAAaA,CAACA,CAACA;QAC1FA,IAAIA,MAAMA,GAAiBA,UAAUA,CAACA,aAAaA,CAACA,mBAAmBA,CAACA,OAAOA,CAACA,CAACA,IAAIA,CAACA;QACtFA,IAAIA,QAAQA,GAAUA,UAAUA,CAACA,aAAaA,CAACA,mBAAmBA,CAACA,OAAOA,CAACA,CAACA,aAAaA,CAACA;QAC1FA,IAAIA,QAAQA,GAAUA,UAAUA,CAACA,eAAeA,CAACA,mBAAmBA,CAACA,OAAOA,CAACA,CAACA;QAC9EA,IAAIA,UAAUA,GAAUA,SAASA,CAACA,MAAMA,CAACA;QAEzCA,GAAGA,CAACA,CAACA,GAAGA,CAACA,KAAKA,GAAUA,CAACA,EAAEA,KAAKA,GAAGA,UAAUA,EAAEA,KAAKA,IAAIA,CAACA,EAAEA,CAACA;YAC3DA,AACAA,4BAD4BA;YAC5BA,EAAEA,GAAGA,cAAcA,GAAGA,SAASA,CAAEA,KAAKA,CAAEA,GAACA,cAAcA,CAACA;YACxDA,EAAEA,GAAGA,cAAcA,GAAGA,SAASA,CAAEA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAAEA,GAACA,cAAcA,CAACA;YAC9DA,EAAEA,GAAGA,cAAcA,GAAGA,SAASA,CAAEA,CAACA,KAAKA,GAAGA,CAACA,CAACA,CAAEA,GAACA,cAAcA,CAACA;YAE9DA,AACAA,8BAD8BA;YAC9BA,GAAGA,GAAGA,YAAYA,CAAEA,EAAEA,CAAEA,CAACA;YACzBA,GAAGA,GAAGA,YAAYA,CAAEA,CAACA,EAAEA,GAAGA,CAACA,CAACA,CAAEA,CAACA;YAC/BA,GAAGA,GAAGA,YAAYA,CAAEA,CAACA,EAAEA,GAAGA,CAACA,CAACA,CAAEA,CAACA;YAC/BA,GAAGA,GAAGA,YAAYA,CAAEA,EAAEA,CAAEA,CAACA;YACzBA,GAAGA,GAAGA,YAAYA,CAAEA,CAACA,EAAEA,GAAGA,CAACA,CAACA,CAAEA,CAACA;YAC/BA,GAAGA,GAAGA,YAAYA,CAAEA,CAACA,EAAEA,GAAGA,CAACA,CAACA,CAAEA,CAACA;YAC/BA,GAAGA,GAAGA,YAAYA,CAAEA,EAAEA,CAAEA,CAACA;YACzBA,GAAGA,GAAGA,YAAYA,CAAEA,CAACA,EAAEA,GAAGA,CAACA,CAACA,CAAEA,CAACA;YAC/BA,GAAGA,GAAGA,YAAYA,CAAEA,CAACA,EAAEA,GAAGA,CAACA,CAACA,CAAEA,CAACA;YAE/BA,AACAA,qCADqCA;YACrCA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,EAAEA,eAAeA;YAChCA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,EAAEA,eAAeA;YAChCA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,GAAGA,GAAGA,GAAGA,GAAGA,GAAGA,CAACA;YAChBA,EAAEA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,EAAEA,cAAcA;YACtCA,EAAEA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YACvBA,EAAEA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;YACvBA,EAAEA,GAAGA,CAACA,GAACA,IAAIA,CAACA,IAAIA,CAACA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,GAAGA,EAAEA,GAACA,EAAEA,CAACA,EAAEA,cAAcA;YACvDA,EAAEA,IAAIA,EAAEA,CAACA;YACTA,EAAEA,IAAIA,EAAEA,CAACA;YACTA,EAAEA,IAAIA,EAAEA,CAACA;YAETA,AACAA,gCADgCA;YAChCA,KAAKA,GAAGA,EAAEA,GAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,GAAGA,EAAEA,GAAEA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,GAAGA,EAAEA,GAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,EAAEA,wBAAwBA;YAC5GA,EAAEA,CAACA,CAACA,CAAEA,CAACA,SAASA,IAAIA,KAAKA,GAAGA,GAAGA,CAAEA,IAAIA,CAAEA,SAASA,IAAIA,KAAKA,IAAIA,GAAGA,CAAEA,CAACA,CAACA,CAACA;gBACpEA,AACAA,mBADmBA;gBACnBA,CAACA,GAAGA,CAACA,CAAEA,EAAEA,GAACA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,CAAEA,CAACA;gBAClCA,UAAUA,GAAGA,CAACA,CAAEA,EAAEA,GAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,EAAEA,GAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,EAAEA,GAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,CAACA,CAAEA,CAACA;gBAC5FA,CAACA,GAAGA,UAAUA,GAACA,KAAKA,CAACA;gBACrBA,AACAA,uBADuBA;gBACvBA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,CAACA,GAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;gBAChDA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,CAACA,GAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;gBAChDA,EAAEA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,CAACA,GAAGA,CAACA,GAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;gBAChDA,AACAA,qEADqEA;gBACrEA,IAAIA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;gBACnCA,IAAIA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;gBACnCA,IAAIA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,GAAGA,GAAGA,GAACA,GAAGA,CAACA;gBACnCA,EAAEA,GAAGA,EAAEA,GAAGA,GAAGA,CAACA;gBACdA,EAAEA,GAAGA,EAAEA,GAAGA,GAAGA,CAACA;gBACdA,EAAEA,GAAGA,EAAEA,GAAGA,GAAGA,CAACA;gBACdA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,CAACA;gBAC/BA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,GAAGA,EAAEA,GAACA,GAAGA,CAACA;gBAC/BA,KAAKA,GAAGA,CAACA,GAACA,CAAEA,IAAIA,GAACA,IAAIA,GAAGA,IAAIA,GAACA,IAAIA,CAAEA,CAACA;gBACpCA,CAACA,GAAGA,KAAKA,GAACA,CAAEA,IAAIA,GAACA,GAAGA,GAAGA,IAAIA,GAACA,GAAGA,CAAEA,CAACA;gBAClCA,CAACA,GAAGA,KAAKA,GAACA,CAAEA,CAACA,IAAIA,GAACA,GAAGA,GAAGA,IAAIA,GAACA,GAAGA,CAAEA,CAACA;gBACnCA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;oBACTA,QAAQA,CAACA;gBACVA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;oBACTA,QAAQA,CAACA;gBACVA,CAACA,GAAGA,CAACA,GAAGA,CAACA,GAAGA,CAACA,CAACA;gBACdA,EAAEA,CAACA,CAACA,CAACA,CAAEA,CAACA,GAAGA,CAACA,CAAEA,IAAIA,CAACA,GAAGA,CAACA,IAAIA,CAACA,GAAGA,yBAAyBA,CAACA,CAACA,CAACA;oBAC1DA,yBAAyBA,GAAGA,CAACA,CAACA;oBAC9BA,sBAAsBA,GAAGA,KAAKA,GAACA,CAACA,CAACA;oBACjCA,kBAAkBA,CAACA,gBAAgBA,GAAGA,CAACA,CAACA;oBACxCA,kBAAkBA,CAACA,aAAaA,GAAGA,IAAIA,QAAQA,CAACA,EAAEA,EAAEA,EAAEA,EAAEA,EAAEA,CAACA,CAACA;oBAC5DA,kBAAkBA,CAACA,WAAWA,GAAGA,IAAIA,QAAQA,CAACA,EAAEA,EAAEA,EAAEA,EAAEA,EAAEA,CAACA,CAACA;oBAC1DA,kBAAkBA,CAACA,EAAEA,GAAGA,IAAIA,CAACA,gBAAgBA,CAACA,SAASA,EAAEA,MAAMA,EAAEA,KAAKA,EAAEA,CAACA,EAAEA,CAACA,EAAEA,CAACA,EAAEA,QAAQA,EAAEA,QAAQA,CAACA,CAACA;oBACrGA,kBAAkBA,CAACA,KAAKA,GAAGA,KAAKA,CAACA;oBACtCA,AAGKA,oFAH+EA;oBAE/EA,sDAAsDA;oBACtDA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,qBAAqBA,CAACA;wBAC/BA,MAAMA,CAACA,IAAIA,CAACA;gBACdA,CAACA;YACFA,CAACA;QACFA,CAACA;QAGDA,EAAEA,CAACA,CAACA,sBAAsBA,IAAIA,CAACA,CAACA;YAC/BA,MAAMA,CAACA,IAAIA,CAACA;QAEbA,MAAMA,CAACA,KAAKA,CAACA;IACdA,CAACA;IACFF,wBAACA;AAADA,CAjIA,AAiICA,EAjI+B,mBAAmB,EAiIlD;AAED,AAA2B,iBAAlB,iBAAiB,CAAC","file":"core/pick/JSPickingCollider.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport PickingCollisionVO\t\t\t\t= require(\"awayjs-core/lib/core/pick/PickingCollisionVO\");\nimport IPickingCollider\t\t\t\t\t= require(\"awayjs-core/lib/core/pick/IPickingCollider\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\n\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\n\nimport PickingColliderBase\t\t\t\t= require(\"awayjs-renderergl/lib/core/pick/PickingColliderBase\");\n\n/**\n * Pure JS picking collider for display objects. Used with the <code>RaycastPicker</code> picking object.\n *\n * @see away.base.DisplayObject#pickingCollider\n * @see away.pick.RaycastPicker\n *\n * @class away.pick.JSPickingCollider\n */\nclass JSPickingCollider extends PickingColliderBase implements IPickingCollider\n{\n\tprivate _findClosestCollision:boolean;\n\n\t/**\n\t * Creates a new <code>JSPickingCollider</code> object.\n\t *\n\t * @param findClosestCollision Determines whether the picking collider searches for the closest collision along the ray. Defaults to false.\n\t */\n\tconstructor(findClosestCollision:boolean = false)\n\t{\n\t\tsuper();\n\n\t\tthis._findClosestCollision = findClosestCollision;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pTestRenderableCollision(renderable:RenderableBase, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number):boolean\n\t{\n\t\tvar t:number;\n\t\tvar i0:number, i1:number, i2:number;\n\t\tvar rx:number, ry:number, rz:number;\n\t\tvar nx:number, ny:number, nz:number;\n\t\tvar cx:number, cy:number, cz:number;\n\t\tvar coeff:number, u:number, v:number, w:number;\n\t\tvar p0x:number, p0y:number, p0z:number;\n\t\tvar p1x:number, p1y:number, p1z:number;\n\t\tvar p2x:number, p2y:number, p2z:number;\n\t\tvar s0x:number, s0y:number, s0z:number;\n\t\tvar s1x:number, s1y:number, s1z:number;\n\t\tvar nl:number, nDotV:number, D:number, disToPlane:number;\n\t\tvar Q1Q2:number, Q1Q1:number, Q2Q2:number, RQ1:number, RQ2:number;\n\t\tvar indexData:Array<number> = renderable.getIndexData().data;\n\t\tvar collisionTriangleIndex:number = -1;\n\t\tvar bothSides:boolean = (<MaterialBase> renderable.materialOwner.material).bothSides;\n\n\t\tvar positionData:Array<number> = renderable.getVertexData(TriangleSubGeometry.POSITION_DATA).data;\n\t\tvar positionStride:number = renderable.getVertexData(TriangleSubGeometry.POSITION_DATA).dataPerVertex;\n\t\tvar positionOffset:number = renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA);\n\t\tvar uvData:Array<number> = renderable.getVertexData(TriangleSubGeometry.UV_DATA).data;\n\t\tvar uvStride:number = renderable.getVertexData(TriangleSubGeometry.UV_DATA).dataPerVertex;\n\t\tvar uvOffset:number = renderable.getVertexOffset(TriangleSubGeometry.UV_DATA);\n\t\tvar numIndices:number = indexData.length;\n\n\t\tfor (var index:number = 0; index < numIndices; index += 3) { // sweep all triangles\n\t\t\t// evaluate triangle indices\n\t\t\ti0 = positionOffset + indexData[ index ]*positionStride;\n\t\t\ti1 = positionOffset + indexData[ (index + 1) ]*positionStride;\n\t\t\ti2 = positionOffset + indexData[ (index + 2) ]*positionStride;\n\n\t\t\t// evaluate triangle positions\n\t\t\tp0x = positionData[ i0 ];\n\t\t\tp0y = positionData[ (i0 + 1) ];\n\t\t\tp0z = positionData[ (i0 + 2) ];\n\t\t\tp1x = positionData[ i1 ];\n\t\t\tp1y = positionData[ (i1 + 1) ];\n\t\t\tp1z = positionData[ (i1 + 2) ];\n\t\t\tp2x = positionData[ i2 ];\n\t\t\tp2y = positionData[ (i2 + 1) ];\n\t\t\tp2z = positionData[ (i2 + 2) ];\n\n\t\t\t// evaluate sides and triangle normal\n\t\t\ts0x = p1x - p0x; // s0 = p1 - p0\n\t\t\ts0y = p1y - p0y;\n\t\t\ts0z = p1z - p0z;\n\t\t\ts1x = p2x - p0x; // s1 = p2 - p0\n\t\t\ts1y = p2y - p0y;\n\t\t\ts1z = p2z - p0z;\n\t\t\tnx = s0y*s1z - s0z*s1y; // n = s0 x s1\n\t\t\tny = s0z*s1x - s0x*s1z;\n\t\t\tnz = s0x*s1y - s0y*s1x;\n\t\t\tnl = 1/Math.sqrt(nx*nx + ny*ny + nz*nz); // normalize n\n\t\t\tnx *= nl;\n\t\t\tny *= nl;\n\t\t\tnz *= nl;\n\n\t\t\t// -- plane intersection test --\n\t\t\tnDotV = nx*this.rayDirection.x + ny* +this.rayDirection.y + nz*this.rayDirection.z; // rayDirection . normal\n\t\t\tif (( !bothSides && nDotV < 0.0 ) || ( bothSides && nDotV != 0.0 )) { // an intersection must exist\n\t\t\t\t// find collision t\n\t\t\t\tD = -( nx*p0x + ny*p0y + nz*p0z );\n\t\t\t\tdisToPlane = -( nx*this.rayPosition.x + ny*this.rayPosition.y + nz*this.rayPosition.z + D );\n\t\t\t\tt = disToPlane/nDotV;\n\t\t\t\t// find collision point\n\t\t\t\tcx = this.rayPosition.x + t*this.rayDirection.x;\n\t\t\t\tcy = this.rayPosition.y + t*this.rayDirection.y;\n\t\t\t\tcz = this.rayPosition.z + t*this.rayDirection.z;\n\t\t\t\t// collision point inside triangle? ( using barycentric coordinates )\n\t\t\t\tQ1Q2 = s0x*s1x + s0y*s1y + s0z*s1z;\n\t\t\t\tQ1Q1 = s0x*s0x + s0y*s0y + s0z*s0z;\n\t\t\t\tQ2Q2 = s1x*s1x + s1y*s1y + s1z*s1z;\n\t\t\t\trx = cx - p0x;\n\t\t\t\try = cy - p0y;\n\t\t\t\trz = cz - p0z;\n\t\t\t\tRQ1 = rx*s0x + ry*s0y + rz*s0z;\n\t\t\t\tRQ2 = rx*s1x + ry*s1y + rz*s1z;\n\t\t\t\tcoeff = 1/( Q1Q1*Q2Q2 - Q1Q2*Q1Q2 );\n\t\t\t\tv = coeff*( Q2Q2*RQ1 - Q1Q2*RQ2 );\n\t\t\t\tw = coeff*( -Q1Q2*RQ1 + Q1Q1*RQ2 );\n\t\t\t\tif (v < 0)\n\t\t\t\t\tcontinue;\n\t\t\t\tif (w < 0)\n\t\t\t\t\tcontinue;\n\t\t\t\tu = 1 - v - w;\n\t\t\t\tif (!( u < 0 ) && t > 0 && t < shortestCollisionDistance) { // all tests passed\n\t\t\t\t\tshortestCollisionDistance = t;\n\t\t\t\t\tcollisionTriangleIndex = index/3;\n\t\t\t\t\tpickingCollisionVO.rayEntryDistance = t;\n\t\t\t\t\tpickingCollisionVO.localPosition = new Vector3D(cx, cy, cz);\n\t\t\t\t\tpickingCollisionVO.localNormal = new Vector3D(nx, ny, nz);\n\t\t\t\t\tpickingCollisionVO.uv = this._pGetCollisionUV(indexData, uvData, index, v, w, u, uvOffset, uvStride);\n\t\t\t\t\tpickingCollisionVO.index = index;\n//\t\t\t\t\t\tpickingCollisionVO.subGeometryIndex = this.pGetMeshSubMeshIndex(renderable);\n\n\t\t\t\t\t// if not looking for best hit, first found will do...\n\t\t\t\t\tif (!this._findClosestCollision)\n\t\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\n\t\tif (collisionTriangleIndex >= 0)\n\t\t\treturn true;\n\n\t\treturn false;\n\t}\n}\n\nexport = JSPickingCollider;"]} \ No newline at end of file diff --git a/lib/core/pick/JSPickingCollider.ts b/lib/core/pick/JSPickingCollider.ts new file mode 100644 index 000000000..533fb78d2 --- /dev/null +++ b/lib/core/pick/JSPickingCollider.ts @@ -0,0 +1,150 @@ +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import PickingCollisionVO = require("awayjs-core/lib/core/pick/PickingCollisionVO"); +import IPickingCollider = require("awayjs-core/lib/core/pick/IPickingCollider"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); + +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); + +import PickingColliderBase = require("awayjs-renderergl/lib/core/pick/PickingColliderBase"); + +/** + * Pure JS picking collider for display objects. Used with the RaycastPicker picking object. + * + * @see away.base.DisplayObject#pickingCollider + * @see away.pick.RaycastPicker + * + * @class away.pick.JSPickingCollider + */ +class JSPickingCollider extends PickingColliderBase implements IPickingCollider +{ + private _findClosestCollision:boolean; + + /** + * Creates a new JSPickingCollider object. + * + * @param findClosestCollision Determines whether the picking collider searches for the closest collision along the ray. Defaults to false. + */ + constructor(findClosestCollision:boolean = false) + { + super(); + + this._findClosestCollision = findClosestCollision; + } + + /** + * @inheritDoc + */ + public _pTestRenderableCollision(renderable:RenderableBase, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number):boolean + { + var t:number; + var i0:number, i1:number, i2:number; + var rx:number, ry:number, rz:number; + var nx:number, ny:number, nz:number; + var cx:number, cy:number, cz:number; + var coeff:number, u:number, v:number, w:number; + var p0x:number, p0y:number, p0z:number; + var p1x:number, p1y:number, p1z:number; + var p2x:number, p2y:number, p2z:number; + var s0x:number, s0y:number, s0z:number; + var s1x:number, s1y:number, s1z:number; + var nl:number, nDotV:number, D:number, disToPlane:number; + var Q1Q2:number, Q1Q1:number, Q2Q2:number, RQ1:number, RQ2:number; + var indexData:Array = renderable.getIndexData().data; + var collisionTriangleIndex:number = -1; + var bothSides:boolean = ( renderable.materialOwner.material).bothSides; + + var positionData:Array = renderable.getVertexData(TriangleSubGeometry.POSITION_DATA).data; + var positionStride:number = renderable.getVertexData(TriangleSubGeometry.POSITION_DATA).dataPerVertex; + var positionOffset:number = renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA); + var uvData:Array = renderable.getVertexData(TriangleSubGeometry.UV_DATA).data; + var uvStride:number = renderable.getVertexData(TriangleSubGeometry.UV_DATA).dataPerVertex; + var uvOffset:number = renderable.getVertexOffset(TriangleSubGeometry.UV_DATA); + var numIndices:number = indexData.length; + + for (var index:number = 0; index < numIndices; index += 3) { // sweep all triangles + // evaluate triangle indices + i0 = positionOffset + indexData[ index ]*positionStride; + i1 = positionOffset + indexData[ (index + 1) ]*positionStride; + i2 = positionOffset + indexData[ (index + 2) ]*positionStride; + + // evaluate triangle positions + p0x = positionData[ i0 ]; + p0y = positionData[ (i0 + 1) ]; + p0z = positionData[ (i0 + 2) ]; + p1x = positionData[ i1 ]; + p1y = positionData[ (i1 + 1) ]; + p1z = positionData[ (i1 + 2) ]; + p2x = positionData[ i2 ]; + p2y = positionData[ (i2 + 1) ]; + p2z = positionData[ (i2 + 2) ]; + + // evaluate sides and triangle normal + s0x = p1x - p0x; // s0 = p1 - p0 + s0y = p1y - p0y; + s0z = p1z - p0z; + s1x = p2x - p0x; // s1 = p2 - p0 + s1y = p2y - p0y; + s1z = p2z - p0z; + nx = s0y*s1z - s0z*s1y; // n = s0 x s1 + ny = s0z*s1x - s0x*s1z; + nz = s0x*s1y - s0y*s1x; + nl = 1/Math.sqrt(nx*nx + ny*ny + nz*nz); // normalize n + nx *= nl; + ny *= nl; + nz *= nl; + + // -- plane intersection test -- + nDotV = nx*this.rayDirection.x + ny* +this.rayDirection.y + nz*this.rayDirection.z; // rayDirection . normal + if (( !bothSides && nDotV < 0.0 ) || ( bothSides && nDotV != 0.0 )) { // an intersection must exist + // find collision t + D = -( nx*p0x + ny*p0y + nz*p0z ); + disToPlane = -( nx*this.rayPosition.x + ny*this.rayPosition.y + nz*this.rayPosition.z + D ); + t = disToPlane/nDotV; + // find collision point + cx = this.rayPosition.x + t*this.rayDirection.x; + cy = this.rayPosition.y + t*this.rayDirection.y; + cz = this.rayPosition.z + t*this.rayDirection.z; + // collision point inside triangle? ( using barycentric coordinates ) + Q1Q2 = s0x*s1x + s0y*s1y + s0z*s1z; + Q1Q1 = s0x*s0x + s0y*s0y + s0z*s0z; + Q2Q2 = s1x*s1x + s1y*s1y + s1z*s1z; + rx = cx - p0x; + ry = cy - p0y; + rz = cz - p0z; + RQ1 = rx*s0x + ry*s0y + rz*s0z; + RQ2 = rx*s1x + ry*s1y + rz*s1z; + coeff = 1/( Q1Q1*Q2Q2 - Q1Q2*Q1Q2 ); + v = coeff*( Q2Q2*RQ1 - Q1Q2*RQ2 ); + w = coeff*( -Q1Q2*RQ1 + Q1Q1*RQ2 ); + if (v < 0) + continue; + if (w < 0) + continue; + u = 1 - v - w; + if (!( u < 0 ) && t > 0 && t < shortestCollisionDistance) { // all tests passed + shortestCollisionDistance = t; + collisionTriangleIndex = index/3; + pickingCollisionVO.rayEntryDistance = t; + pickingCollisionVO.localPosition = new Vector3D(cx, cy, cz); + pickingCollisionVO.localNormal = new Vector3D(nx, ny, nz); + pickingCollisionVO.uv = this._pGetCollisionUV(indexData, uvData, index, v, w, u, uvOffset, uvStride); + pickingCollisionVO.index = index; +// pickingCollisionVO.subGeometryIndex = this.pGetMeshSubMeshIndex(renderable); + + // if not looking for best hit, first found will do... + if (!this._findClosestCollision) + return true; + } + } + } + + + if (collisionTriangleIndex >= 0) + return true; + + return false; + } +} + +export = JSPickingCollider; \ No newline at end of file diff --git a/lib/core/pick/PickingColliderBase.js b/lib/core/pick/PickingColliderBase.js new file mode 100755 index 000000000..352dd9f8a --- /dev/null +++ b/lib/core/pick/PickingColliderBase.js @@ -0,0 +1,102 @@ +var RenderablePool = require("awayjs-core/lib/core/pool/RenderablePool"); +var Point = require("awayjs-core/lib/core/geom/Point"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AbstractMethodError = require("awayjs-core/lib/errors/AbstractMethodError"); +var BillboardRenderable = require("awayjs-stagegl/lib/core/pool/BillboardRenderable"); +var TriangleSubMeshRenderable = require("awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable"); +/** + * An abstract base class for all picking collider classes. It should not be instantiated directly. + * + * @class away.pick.PickingColliderBase + */ +var PickingColliderBase = (function () { + function PickingColliderBase() { + this._billboardRenderablePool = RenderablePool.getPool(BillboardRenderable); + this._subMeshRenderablePool = RenderablePool.getPool(TriangleSubMeshRenderable); + } + PickingColliderBase.prototype._pPetCollisionNormal = function (indexData /*uint*/, vertexData, triangleIndex) { + var normal = new Vector3D(); + var i0 = indexData[triangleIndex] * 3; + var i1 = indexData[triangleIndex + 1] * 3; + var i2 = indexData[triangleIndex + 2] * 3; + var p0 = new Vector3D(vertexData[i0], vertexData[i0 + 1], vertexData[i0 + 2]); + var p1 = new Vector3D(vertexData[i1], vertexData[i1 + 1], vertexData[i1 + 2]); + var p2 = new Vector3D(vertexData[i2], vertexData[i2 + 1], vertexData[i2 + 2]); + var side0 = p1.subtract(p0); + var side1 = p2.subtract(p0); + normal = side0.crossProduct(side1); + normal.normalize(); + return normal; + }; + PickingColliderBase.prototype._pGetCollisionUV = function (indexData /*uint*/, uvData, triangleIndex, v, w, u, uvOffset, uvStride) { + var uv = new Point(); + var uIndex = indexData[triangleIndex] * uvStride + uvOffset; + var uv0 = new Vector3D(uvData[uIndex], uvData[uIndex + 1]); + uIndex = indexData[triangleIndex + 1] * uvStride + uvOffset; + var uv1 = new Vector3D(uvData[uIndex], uvData[uIndex + 1]); + uIndex = indexData[triangleIndex + 2] * uvStride + uvOffset; + var uv2 = new Vector3D(uvData[uIndex], uvData[uIndex + 1]); + uv.x = u * uv0.x + v * uv1.x + w * uv2.x; + uv.y = u * uv0.y + v * uv1.y + w * uv2.y; + return uv; + }; + /** + * @inheritDoc + */ + PickingColliderBase.prototype._pTestRenderableCollision = function (renderable, pickingCollisionVO, shortestCollisionDistance) { + throw new AbstractMethodError(); + }; + /** + * @inheritDoc + */ + PickingColliderBase.prototype.setLocalRay = function (localPosition, localDirection) { + this.rayPosition = localPosition; + this.rayDirection = localDirection; + }; + /** + * Tests a Billboard object for a collision with the picking ray. + * + * @param billboard The billboard instance to be tested. + * @param pickingCollisionVO The collision object used to store the collision results + * @param shortestCollisionDistance The current value of the shortest distance to a detected collision along the ray. + * @param findClosest + */ + PickingColliderBase.prototype.testBillboardCollision = function (billboard, pickingCollisionVO, shortestCollisionDistance) { + this.setLocalRay(pickingCollisionVO.localRayPosition, pickingCollisionVO.localRayDirection); + pickingCollisionVO.materialOwner = null; + if (this._pTestRenderableCollision(this._billboardRenderablePool.getItem(billboard), pickingCollisionVO, shortestCollisionDistance)) { + shortestCollisionDistance = pickingCollisionVO.rayEntryDistance; + pickingCollisionVO.materialOwner = billboard; + return true; + } + return false; + }; + /** + * Tests a Mesh object for a collision with the picking ray. + * + * @param mesh The mesh instance to be tested. + * @param pickingCollisionVO The collision object used to store the collision results + * @param shortestCollisionDistance The current value of the shortest distance to a detected collision along the ray. + * @param findClosest + */ + PickingColliderBase.prototype.testMeshCollision = function (mesh, pickingCollisionVO, shortestCollisionDistance, findClosest) { + this.setLocalRay(pickingCollisionVO.localRayPosition, pickingCollisionVO.localRayDirection); + pickingCollisionVO.materialOwner = null; + var subMesh; + var len = mesh.subMeshes.length; + for (var i = 0; i < len; ++i) { + subMesh = mesh.subMeshes[i]; + if (this._pTestRenderableCollision(this._subMeshRenderablePool.getItem(subMesh), pickingCollisionVO, shortestCollisionDistance)) { + shortestCollisionDistance = pickingCollisionVO.rayEntryDistance; + pickingCollisionVO.materialOwner = subMesh; + if (!findClosest) + return true; + } + } + return pickingCollisionVO.materialOwner != null; + }; + return PickingColliderBase; +})(); +module.exports = PickingColliderBase; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["core/pick/pickingcolliderbase.ts"],"names":["PickingColliderBase","PickingColliderBase.constructor","PickingColliderBase._pPetCollisionNormal","PickingColliderBase._pGetCollisionUV","PickingColliderBase._pTestRenderableCollision","PickingColliderBase.setLocalRay","PickingColliderBase.testBillboardCollision","PickingColliderBase.testMeshCollision"],"mappings":"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","file":"core/pick/PickingColliderBase.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import ISubMesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/ISubMesh\");\nimport PickingCollisionVO\t\t\t\t= require(\"awayjs-core/lib/core/pick/PickingCollisionVO\");\nimport RenderablePool\t\t\t\t\t= require(\"awayjs-core/lib/core/pool/RenderablePool\");\nimport Point\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Point\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport Billboard\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Billboard\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport AbstractMethodError\t\t\t\t= require(\"awayjs-core/lib/errors/AbstractMethodError\");\n\nimport BillboardRenderable\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/BillboardRenderable\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport TriangleSubMeshRenderable\t\t= require(\"awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable\");\n\n/**\n * An abstract base class for all picking collider classes. It should not be instantiated directly.\n *\n * @class away.pick.PickingColliderBase\n */\nclass PickingColliderBase\n{\n\tprivate _billboardRenderablePool:RenderablePool;\n\tprivate _subMeshRenderablePool:RenderablePool;\n\n\tpublic rayPosition:Vector3D;\n\tpublic rayDirection:Vector3D;\n\n\tconstructor()\n\t{\n\t\tthis._billboardRenderablePool = RenderablePool.getPool(BillboardRenderable);\n\t\tthis._subMeshRenderablePool = RenderablePool.getPool(TriangleSubMeshRenderable);\n\t}\n\n\tpublic _pPetCollisionNormal(indexData:Array<number> /*uint*/, vertexData:Array<number>, triangleIndex:number):Vector3D // PROTECTED\n\t{\n\t\tvar normal:Vector3D = new Vector3D();\n\t\tvar i0:number = indexData[ triangleIndex ]*3;\n\t\tvar i1:number = indexData[ triangleIndex + 1 ]*3;\n\t\tvar i2:number = indexData[ triangleIndex + 2 ]*3;\n\t\tvar p0:Vector3D = new Vector3D(vertexData[ i0 ], vertexData[ i0 + 1 ], vertexData[ i0 + 2 ]);\n\t\tvar p1:Vector3D = new Vector3D(vertexData[ i1 ], vertexData[ i1 + 1 ], vertexData[ i1 + 2 ]);\n\t\tvar p2:Vector3D = new Vector3D(vertexData[ i2 ], vertexData[ i2 + 1 ], vertexData[ i2 + 2 ]);\n\t\tvar side0:Vector3D = p1.subtract(p0);\n\t\tvar side1:Vector3D = p2.subtract(p0);\n\t\tnormal = side0.crossProduct(side1);\n\t\tnormal.normalize();\n\t\treturn normal;\n\t}\n\n\tpublic _pGetCollisionUV(indexData:Array<number> /*uint*/, uvData:Array<number>, triangleIndex:number, v:number, w:number, u:number, uvOffset:number, uvStride:number):Point // PROTECTED\n\t{\n\t\tvar uv:Point = new Point();\n\t\tvar uIndex:number = indexData[ triangleIndex ]*uvStride + uvOffset;\n\t\tvar uv0:Vector3D = new Vector3D(uvData[ uIndex ], uvData[ uIndex + 1 ]);\n\t\tuIndex = indexData[ triangleIndex + 1 ]*uvStride + uvOffset;\n\t\tvar uv1:Vector3D = new Vector3D(uvData[ uIndex ], uvData[ uIndex + 1 ]);\n\t\tuIndex = indexData[ triangleIndex + 2 ]*uvStride + uvOffset;\n\t\tvar uv2:Vector3D = new Vector3D(uvData[ uIndex ], uvData[ uIndex + 1 ]);\n\t\tuv.x = u*uv0.x + v*uv1.x + w*uv2.x;\n\t\tuv.y = u*uv0.y + v*uv1.y + w*uv2.y;\n\t\treturn uv;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pTestRenderableCollision(renderable:RenderableBase, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number):boolean\n\t{\n\t\tthrow new AbstractMethodError();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic setLocalRay(localPosition:Vector3D, localDirection:Vector3D)\n\t{\n\t\tthis.rayPosition = localPosition;\n\t\tthis.rayDirection = localDirection;\n\t}\n\n\t/**\n\t * Tests a <code>Billboard</code> object for a collision with the picking ray.\n\t *\n\t * @param billboard The billboard instance to be tested.\n\t * @param pickingCollisionVO The collision object used to store the collision results\n\t * @param shortestCollisionDistance The current value of the shortest distance to a detected collision along the ray.\n\t * @param findClosest\n\t */\n\tpublic testBillboardCollision(billboard:Billboard, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number)\n\t{\n\t\tthis.setLocalRay(pickingCollisionVO.localRayPosition, pickingCollisionVO.localRayDirection);\n\t\tpickingCollisionVO.materialOwner = null;\n\n\t\tif (this._pTestRenderableCollision(<RenderableBase> this._billboardRenderablePool.getItem(billboard), pickingCollisionVO, shortestCollisionDistance)) {\n\t\t\tshortestCollisionDistance = pickingCollisionVO.rayEntryDistance;\n\n\t\t\tpickingCollisionVO.materialOwner = billboard;\n\n\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * Tests a <code>Mesh</code> object for a collision with the picking ray.\n\t *\n\t * @param mesh The mesh instance to be tested.\n\t * @param pickingCollisionVO The collision object used to store the collision results\n\t * @param shortestCollisionDistance The current value of the shortest distance to a detected collision along the ray.\n\t * @param findClosest\n\t */\n\tpublic testMeshCollision(mesh:Mesh, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number, findClosest:boolean):boolean\n\t{\n\t\tthis.setLocalRay(pickingCollisionVO.localRayPosition, pickingCollisionVO.localRayDirection);\n\t\tpickingCollisionVO.materialOwner = null;\n\n\t\tvar subMesh:ISubMesh;\n\n\t\tvar len:number = mesh.subMeshes.length;\n\t\tfor (var i:number = 0; i < len; ++i) {\n\t\t\tsubMesh = mesh.subMeshes[i];\n\n\t\t\tif (this._pTestRenderableCollision(<RenderableBase> this._subMeshRenderablePool.getItem(subMesh), pickingCollisionVO, shortestCollisionDistance)) {\n\t\t\t\tshortestCollisionDistance = pickingCollisionVO.rayEntryDistance;\n\n\t\t\t\tpickingCollisionVO.materialOwner = subMesh;\n\n\t\t\t\tif (!findClosest)\n\t\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn pickingCollisionVO.materialOwner != null;\n\t}\n}\n\nexport = PickingColliderBase;"]} \ No newline at end of file diff --git a/lib/core/pick/PickingColliderBase.ts b/lib/core/pick/PickingColliderBase.ts new file mode 100644 index 000000000..448cc19f5 --- /dev/null +++ b/lib/core/pick/PickingColliderBase.ts @@ -0,0 +1,137 @@ +import ISubMesh = require("awayjs-core/lib/core/base/ISubMesh"); +import PickingCollisionVO = require("awayjs-core/lib/core/pick/PickingCollisionVO"); +import RenderablePool = require("awayjs-core/lib/core/pool/RenderablePool"); +import Point = require("awayjs-core/lib/core/geom/Point"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import Billboard = require("awayjs-core/lib/entities/Billboard"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import AbstractMethodError = require("awayjs-core/lib/errors/AbstractMethodError"); + +import BillboardRenderable = require("awayjs-stagegl/lib/core/pool/BillboardRenderable"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import TriangleSubMeshRenderable = require("awayjs-stagegl/lib/core/pool/TriangleSubMeshRenderable"); + +/** + * An abstract base class for all picking collider classes. It should not be instantiated directly. + * + * @class away.pick.PickingColliderBase + */ +class PickingColliderBase +{ + private _billboardRenderablePool:RenderablePool; + private _subMeshRenderablePool:RenderablePool; + + public rayPosition:Vector3D; + public rayDirection:Vector3D; + + constructor() + { + this._billboardRenderablePool = RenderablePool.getPool(BillboardRenderable); + this._subMeshRenderablePool = RenderablePool.getPool(TriangleSubMeshRenderable); + } + + public _pPetCollisionNormal(indexData:Array /*uint*/, vertexData:Array, triangleIndex:number):Vector3D // PROTECTED + { + var normal:Vector3D = new Vector3D(); + var i0:number = indexData[ triangleIndex ]*3; + var i1:number = indexData[ triangleIndex + 1 ]*3; + var i2:number = indexData[ triangleIndex + 2 ]*3; + var p0:Vector3D = new Vector3D(vertexData[ i0 ], vertexData[ i0 + 1 ], vertexData[ i0 + 2 ]); + var p1:Vector3D = new Vector3D(vertexData[ i1 ], vertexData[ i1 + 1 ], vertexData[ i1 + 2 ]); + var p2:Vector3D = new Vector3D(vertexData[ i2 ], vertexData[ i2 + 1 ], vertexData[ i2 + 2 ]); + var side0:Vector3D = p1.subtract(p0); + var side1:Vector3D = p2.subtract(p0); + normal = side0.crossProduct(side1); + normal.normalize(); + return normal; + } + + public _pGetCollisionUV(indexData:Array /*uint*/, uvData:Array, triangleIndex:number, v:number, w:number, u:number, uvOffset:number, uvStride:number):Point // PROTECTED + { + var uv:Point = new Point(); + var uIndex:number = indexData[ triangleIndex ]*uvStride + uvOffset; + var uv0:Vector3D = new Vector3D(uvData[ uIndex ], uvData[ uIndex + 1 ]); + uIndex = indexData[ triangleIndex + 1 ]*uvStride + uvOffset; + var uv1:Vector3D = new Vector3D(uvData[ uIndex ], uvData[ uIndex + 1 ]); + uIndex = indexData[ triangleIndex + 2 ]*uvStride + uvOffset; + var uv2:Vector3D = new Vector3D(uvData[ uIndex ], uvData[ uIndex + 1 ]); + uv.x = u*uv0.x + v*uv1.x + w*uv2.x; + uv.y = u*uv0.y + v*uv1.y + w*uv2.y; + return uv; + } + + /** + * @inheritDoc + */ + public _pTestRenderableCollision(renderable:RenderableBase, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number):boolean + { + throw new AbstractMethodError(); + } + + /** + * @inheritDoc + */ + public setLocalRay(localPosition:Vector3D, localDirection:Vector3D) + { + this.rayPosition = localPosition; + this.rayDirection = localDirection; + } + + /** + * Tests a Billboard object for a collision with the picking ray. + * + * @param billboard The billboard instance to be tested. + * @param pickingCollisionVO The collision object used to store the collision results + * @param shortestCollisionDistance The current value of the shortest distance to a detected collision along the ray. + * @param findClosest + */ + public testBillboardCollision(billboard:Billboard, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number) + { + this.setLocalRay(pickingCollisionVO.localRayPosition, pickingCollisionVO.localRayDirection); + pickingCollisionVO.materialOwner = null; + + if (this._pTestRenderableCollision( this._billboardRenderablePool.getItem(billboard), pickingCollisionVO, shortestCollisionDistance)) { + shortestCollisionDistance = pickingCollisionVO.rayEntryDistance; + + pickingCollisionVO.materialOwner = billboard; + + return true; + } + + return false; + } + + /** + * Tests a Mesh object for a collision with the picking ray. + * + * @param mesh The mesh instance to be tested. + * @param pickingCollisionVO The collision object used to store the collision results + * @param shortestCollisionDistance The current value of the shortest distance to a detected collision along the ray. + * @param findClosest + */ + public testMeshCollision(mesh:Mesh, pickingCollisionVO:PickingCollisionVO, shortestCollisionDistance:number, findClosest:boolean):boolean + { + this.setLocalRay(pickingCollisionVO.localRayPosition, pickingCollisionVO.localRayDirection); + pickingCollisionVO.materialOwner = null; + + var subMesh:ISubMesh; + + var len:number = mesh.subMeshes.length; + for (var i:number = 0; i < len; ++i) { + subMesh = mesh.subMeshes[i]; + + if (this._pTestRenderableCollision( this._subMeshRenderablePool.getItem(subMesh), pickingCollisionVO, shortestCollisionDistance)) { + shortestCollisionDistance = pickingCollisionVO.rayEntryDistance; + + pickingCollisionVO.materialOwner = subMesh; + + if (!findClosest) + return true; + } + } + + return pickingCollisionVO.materialOwner != null; + } +} + +export = PickingColliderBase; \ No newline at end of file diff --git a/lib/core/pick/ShaderPicker.js b/lib/core/pick/ShaderPicker.js new file mode 100755 index 000000000..8c2b5aae5 --- /dev/null +++ b/lib/core/pick/ShaderPicker.js @@ -0,0 +1,415 @@ +var Debug = require("awayjs-core/lib/utils/Debug"); +var BitmapData = require("awayjs-core/lib/core/base/BitmapData"); +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Matrix3DUtils = require("awayjs-core/lib/core/geom/Matrix3DUtils"); +var Point = require("awayjs-core/lib/core/geom/Point"); +var Rectangle = require("awayjs-core/lib/core/geom/Rectangle"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AGALMiniAssembler = require("awayjs-stagegl/lib/aglsl/assembler/AGALMiniAssembler"); +var ContextGLBlendFactor = require("awayjs-stagegl/lib/core/stagegl/ContextGLBlendFactor"); +var ContextGLClearMask = require("awayjs-stagegl/lib/core/stagegl/ContextGLClearMask"); +var ContextGLCompareMode = require("awayjs-stagegl/lib/core/stagegl/ContextGLCompareMode"); +var ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +var ContextGLTriangleFace = require("awayjs-stagegl/lib/core/stagegl/ContextGLTriangleFace"); +/** + * Picks a 3d object from a view or scene by performing a separate render pass on the scene around the area being picked using key color values, + * then reading back the color value of the pixel in the render representing the picking ray. Requires multiple passes and readbacks for retriving details + * on an entity that has its shaderPickingDetails property set to true. + * + * A read-back operation from any GPU is not a very efficient process, and the amount of processing used can vary significantly between different hardware. + * + * @see away.entities.Entity#shaderPickingDetails + * + * @class away.pick.ShaderPicker + */ +var ShaderPicker = (function () { + /** + * Creates a new ShaderPicker object. + * + * @param shaderPickingDetails Determines whether the picker includes a second pass to calculate extra + * properties such as uv and normal coordinates. + */ + function ShaderPicker(shaderPickingDetails) { + if (shaderPickingDetails === void 0) { shaderPickingDetails = false; } + this._onlyMouseEnabled = true; + this._interactives = new Array(); + this._localHitPosition = new Vector3D(); + this._hitUV = new Point(); + this._localHitNormal = new Vector3D(); + this._rayPos = new Vector3D(); + this._rayDir = new Vector3D(); + this._shaderPickingDetails = shaderPickingDetails; + this._id = new Array(4); + this._viewportData = new Array(4); // first 2 contain scale, last 2 translation + this._boundOffsetScale = new Array(8); // first 2 contain scale, last 2 translation + this._boundOffsetScale[3] = 0; + this._boundOffsetScale[7] = 1; + } + Object.defineProperty(ShaderPicker.prototype, "onlyMouseEnabled", { + /** + * @inheritDoc + */ + get: function () { + return this._onlyMouseEnabled; + }, + set: function (value) { + this._onlyMouseEnabled = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ShaderPicker.prototype.getViewCollision = function (x, y, view) { + var collector = view.iEntityCollector; + this._stage = view.renderer.stage; + if (!this._stage) + return null; + this._context = this._stage.context; + this._viewportData[0] = view.width; + this._viewportData[1] = view.height; + this._viewportData[2] = -(this._projX = 2 * x / view.width - 1); + this._viewportData[3] = this._projY = 2 * y / view.height - 1; + // _potentialFound will be set to true if any object is actually rendered + this._potentialFound = false; + //reset head values + this._blendedRenderableHead = null; + this._opaqueRenderableHead = null; + this.pDraw(collector, null); + // clear buffers + this._context.setVertexBufferAt(0, null); + if (!this._context || !this._potentialFound) + return null; + if (!this._bitmapData) + this._bitmapData = new BitmapData(1, 1, false, 0); + this._context.drawToBitmapData(this._bitmapData); + this._hitColor = this._bitmapData.getPixel(0, 0); + if (!this._hitColor) { + this._context.present(); + return null; + } + this._hitRenderable = this._interactives[this._hitColor - 1]; + this._hitEntity = this._hitRenderable.sourceEntity; + if (this._onlyMouseEnabled && !this._hitEntity._iIsMouseEnabled()) + return null; + var _collisionVO = this._hitEntity._iPickingCollisionVO; + if (this._shaderPickingDetails) { + this.getHitDetails(view.camera); + _collisionVO.localPosition = this._localHitPosition; + _collisionVO.localNormal = this._localHitNormal; + _collisionVO.uv = this._hitUV; + _collisionVO.index = this._faceIndex; + } + else { + _collisionVO.localPosition = null; + _collisionVO.localNormal = null; + _collisionVO.uv = null; + _collisionVO.index = 0; + } + return _collisionVO; + }; + //*/ + /** + * @inheritDoc + */ + ShaderPicker.prototype.getSceneCollision = function (position, direction, scene) { + return null; + }; + /** + * @inheritDoc + */ + ShaderPicker.prototype.pDraw = function (entityCollector, target) { + var camera = entityCollector.camera; + this._context.clear(0, 0, 0, 1); + this._stage.scissorRect = ShaderPicker.MOUSE_SCISSOR_RECT; + this._interactives.length = this._interactiveId = 0; + if (!this._objectProgram) + this.initObjectProgram(); + this._context.setBlendFactors(ContextGLBlendFactor.ONE, ContextGLBlendFactor.ZERO); + this._context.setDepthTest(true, ContextGLCompareMode.LESS); + this._context.setProgram(this._objectProgram); + this._context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 4, this._viewportData, 1); + //this.drawRenderables(entityCollector.opaqueRenderableHead, camera); + //this.drawRenderables(entityCollector.blendedRenderableHead, camera); + //TODO: reimplement ShaderPicker inheriting from RendererBase + }; + /** + * Draw a list of renderables. + * @param renderables The renderables to draw. + * @param camera The camera for which to render. + */ + ShaderPicker.prototype.drawRenderables = function (renderable, camera) { + var matrix = Matrix3DUtils.CALCULATION_MATRIX; + var viewProjection = camera.viewProjection; + while (renderable) { + // it's possible that the renderable was already removed from the scene + if (!renderable.sourceEntity.scene || !renderable.sourceEntity._iIsMouseEnabled()) { + renderable = renderable.next; + continue; + } + this._potentialFound = true; + this._context.setCulling(renderable.materialOwner.material.bothSides ? ContextGLTriangleFace.NONE : ContextGLTriangleFace.BACK, camera.projection.coordinateSystem); + this._interactives[this._interactiveId++] = renderable; + // color code so that reading from bitmapdata will contain the correct value + this._id[1] = (this._interactiveId >> 8) / 255; // on green channel + this._id[2] = (this._interactiveId & 0xff) / 255; // on blue channel + matrix.copyFrom(renderable.sourceEntity.getRenderSceneTransform(camera)); + matrix.append(viewProjection); + this._context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, matrix, true); + this._context.setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, 0, this._id, 1); + this._context.activateBuffer(0, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + this._context.drawTriangles(this._context.getIndexBuffer(renderable.getIndexData()), 0, renderable.numTriangles); + renderable = renderable.next; + } + }; + ShaderPicker.prototype.updateRay = function (camera) { + this._rayPos = camera.scenePosition; + this._rayDir = camera.getRay(this._projX, this._projY, 1); + this._rayDir.normalize(); + }; + /** + * Creates the Program that color-codes objects. + */ + ShaderPicker.prototype.initObjectProgram = function () { + var vertexCode; + var fragmentCode; + this._objectProgram = this._context.createProgram(); + vertexCode = "m44 vt0, va0, vc0 \n" + "mul vt1.xy, vt0.w, vc4.zw \n" + "add vt0.xy, vt0.xy, vt1.xy \n" + "mul vt0.xy, vt0.xy, vc4.xy \n" + "mov op, vt0 \n"; + fragmentCode = "mov oc, fc0"; // write identifier + Debug.throwPIR('ShaderPicker', 'initTriangleProgram', 'Dependency: initObjectProgram'); + //_objectProgram.upload(new AGALMiniAssembler().assemble(ContextGLProgramType.VERTEX, vertexCode),new AGALMiniAssembler().assemble(ContextGLProgramType.FRAGMENT, fragmentCode)); + }; + /** + * Creates the Program that renders positions. + */ + ShaderPicker.prototype.initTriangleProgram = function () { + var vertexCode; + var fragmentCode; + this._triangleProgram = this._context.createProgram(); + // todo: add animation code + vertexCode = "add vt0, va0, vc5 \n" + "mul vt0, vt0, vc6 \n" + "mov v0, vt0 \n" + "m44 vt0, va0, vc0 \n" + "mul vt1.xy, vt0.w, vc4.zw \n" + "add vt0.xy, vt0.xy, vt1.xy \n" + "mul vt0.xy, vt0.xy, vc4.xy \n" + "mov op, vt0 \n"; + fragmentCode = "mov oc, v0"; // write identifier + var vertexByteCode = (new AGALMiniAssembler().assemble("part vertex 1\n" + vertexCode + "endpart"))['vertex'].data; + var fragmentByteCode = (new AGALMiniAssembler().assemble("part fragment 1\n" + fragmentCode + "endpart"))['fragment'].data; + this._triangleProgram.upload(vertexByteCode, fragmentByteCode); + }; + /** + * Gets more detailed information about the hir position, if required. + * @param camera The camera used to view the hit object. + */ + ShaderPicker.prototype.getHitDetails = function (camera) { + this.getApproximatePosition(camera); + this.getPreciseDetails(camera); + }; + /** + * Finds a first-guess approximate position about the hit position. + * + * @param camera The camera used to view the hit object. + */ + ShaderPicker.prototype.getApproximatePosition = function (camera) { + var bounds = this._hitRenderable.sourceEntity.bounds.aabb; + var col; + var scX, scY, scZ; + var offsX, offsY, offsZ; + var localViewProjection = Matrix3DUtils.CALCULATION_MATRIX; + localViewProjection.copyFrom(this._hitRenderable.sourceEntity.getRenderSceneTransform(camera)); + localViewProjection.append(camera.viewProjection); + if (!this._triangleProgram) { + this.initTriangleProgram(); + } + this._boundOffsetScale[4] = 1 / (scX = bounds.width); + this._boundOffsetScale[5] = 1 / (scY = bounds.height); + this._boundOffsetScale[6] = 1 / (scZ = bounds.depth); + this._boundOffsetScale[0] = offsX = -bounds.x; + this._boundOffsetScale[1] = offsY = -bounds.y; + this._boundOffsetScale[2] = offsZ = -bounds.z; + this._context.setProgram(this._triangleProgram); + this._context.clear(0, 0, 0, 0, 1, 0, ContextGLClearMask.DEPTH); + this._context.setScissorRectangle(ShaderPicker.MOUSE_SCISSOR_RECT); + this._context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, localViewProjection, true); + this._context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 5, this._boundOffsetScale, 2); + this._context.activateBuffer(0, this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA), this._hitRenderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + this._context.drawTriangles(this._context.getIndexBuffer(this._hitRenderable.getIndexData()), 0, this._hitRenderable.numTriangles); + this._context.drawToBitmapData(this._bitmapData); + col = this._bitmapData.getPixel(0, 0); + this._localHitPosition.x = ((col >> 16) & 0xff) * scX / 255 - offsX; + this._localHitPosition.y = ((col >> 8) & 0xff) * scY / 255 - offsY; + this._localHitPosition.z = (col & 0xff) * scZ / 255 - offsZ; + }; + /** + * Use the approximate position info to find the face under the mouse position from which we can derive the precise + * ray-face intersection point, then use barycentric coordinates to figure out the uv coordinates, etc. + * @param camera The camera used to view the hit object. + */ + ShaderPicker.prototype.getPreciseDetails = function (camera) { + var len = indices.length; + var x1, y1, z1; + var x2, y2, z2; + var x3, y3, z3; + var i = 0, j = 1, k = 2; + var t1, t2, t3; + var v0x, v0y, v0z; + var v1x, v1y, v1z; + var v2x, v2y, v2z; + var ni1, ni2, ni3; + var n1, n2, n3, nLength; + var dot00, dot01, dot02, dot11, dot12; + var s, t, invDenom; + var x = this._localHitPosition.x, y = this._localHitPosition.y, z = this._localHitPosition.z; + var u, v; + var ui1, ui2, ui3; + var s0x, s0y, s0z; + var s1x, s1y, s1z; + var nl; + var indices = this._hitRenderable.getIndexData().data; + var positions = this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA).data; + var positionStride = this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA).dataPerVertex; + var positionOffset = this._hitRenderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA); + var uvs = this._hitRenderable.getVertexData(TriangleSubGeometry.UV_DATA).data; + var uvStride = this._hitRenderable.getVertexData(TriangleSubGeometry.UV_DATA).dataPerVertex; + var uvOffset = this._hitRenderable.getVertexOffset(TriangleSubGeometry.UV_DATA); + var normals = this._hitRenderable.getVertexData(TriangleSubGeometry.NORMAL_DATA).data; + var normalStride = this._hitRenderable.getVertexData(TriangleSubGeometry.NORMAL_DATA).dataPerVertex; + var normalOffset = this._hitRenderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA); + this.updateRay(camera); + while (i < len) { + t1 = positionOffset + indices[i] * positionStride; + t2 = positionOffset + indices[j] * positionStride; + t3 = positionOffset + indices[k] * positionStride; + x1 = positions[t1]; + y1 = positions[t1 + 1]; + z1 = positions[t1 + 2]; + x2 = positions[t2]; + y2 = positions[t2 + 1]; + z2 = positions[t2 + 2]; + x3 = positions[t3]; + y3 = positions[t3 + 1]; + z3 = positions[t3 + 2]; + // if within bounds + if (!((x < x1 && x < x2 && x < x3) || (y < y1 && y < y2 && y < y3) || (z < z1 && z < z2 && z < z3) || (x > x1 && x > x2 && x > x3) || (y > y1 && y > y2 && y > y3) || (z > z1 && z > z2 && z > z3))) { + // calculate barycentric coords for approximated position + v0x = x3 - x1; + v0y = y3 - y1; + v0z = z3 - z1; + v1x = x2 - x1; + v1y = y2 - y1; + v1z = z2 - z1; + v2x = x - x1; + v2y = y - y1; + v2z = z - z1; + dot00 = v0x * v0x + v0y * v0y + v0z * v0z; + dot01 = v0x * v1x + v0y * v1y + v0z * v1z; + dot02 = v0x * v2x + v0y * v2y + v0z * v2z; + dot11 = v1x * v1x + v1y * v1y + v1z * v1z; + dot12 = v1x * v2x + v1y * v2y + v1z * v2z; + invDenom = 1 / (dot00 * dot11 - dot01 * dot01); + s = (dot11 * dot02 - dot01 * dot12) * invDenom; + t = (dot00 * dot12 - dot01 * dot02) * invDenom; + // if inside the current triangle, fetch details hit information + if (s >= 0 && t >= 0 && (s + t) <= 1) { + ni1 = normalOffset + indices[i] * normalStride; + ni2 = normalOffset + indices[j] * normalStride; + ni3 = normalOffset + indices[k] * normalStride; + n1 = indices[ni1] + indices[ni2] + indices[ni3]; + n2 = indices[ni1 + 1] + indices[ni2 + 1] + indices[ni3 + 1]; + n3 = indices[ni1 + 2] + indices[ni2 + 2] + indices[ni3 + 2]; + nLength = Math.sqrt(n1 * n1 + n2 * n2 + n3 * n3); + n1 /= nLength; + n2 /= nLength; + n3 /= nLength; + // this is def the triangle, now calculate precise coords + this.getPrecisePosition(this._hitRenderable.sourceEntity.inverseSceneTransform, n1, n2, n3, x1, y1, z1); + v2x = this._localHitPosition.x - x1; + v2y = this._localHitPosition.y - y1; + v2z = this._localHitPosition.z - z1; + s0x = x2 - x1; // s0 = p1 - p0 + s0y = y2 - y1; + s0z = z2 - z1; + s1x = x3 - x1; // s1 = p2 - p0 + s1y = y3 - y1; + s1z = z3 - z1; + this._localHitNormal.x = s0y * s1z - s0z * s1y; // n = s0 x s1 + this._localHitNormal.y = s0z * s1x - s0x * s1z; + this._localHitNormal.z = s0x * s1y - s0y * s1x; + nl = 1 / Math.sqrt(this._localHitNormal.x * this._localHitNormal.x + this._localHitNormal.y * this._localHitNormal.y + this._localHitNormal.z * this._localHitNormal.z); // normalize n + this._localHitNormal.x *= nl; + this._localHitNormal.y *= nl; + this._localHitNormal.z *= nl; + dot02 = v0x * v2x + v0y * v2y + v0z * v2z; + dot12 = v1x * v2x + v1y * v2y + v1z * v2z; + s = (dot11 * dot02 - dot01 * dot12) * invDenom; + t = (dot00 * dot12 - dot01 * dot02) * invDenom; + ui1 = uvOffset + indices[i] * uvStride; + ui2 = uvOffset + indices[j] * uvStride; + ui3 = uvOffset + indices[k] * uvStride; + u = uvs[ui1]; + v = uvs[ui1 + 1]; + this._hitUV.x = u + t * (uvs[ui2] - u) + s * (uvs[ui3] - u); + this._hitUV.y = v + t * (uvs[ui2 + 1] - v) + s * (uvs[ui3 + 1] - v); + this._faceIndex = i; + //TODO add back subGeometryIndex value + //this._subGeometryIndex = away.utils.GeometryUtils.getMeshSubGeometryIndex(subGeom); + return; + } + } + i += 3; + j += 3; + k += 3; + } + }; + /** + * Finds the precise hit position by unprojecting the screen coordinate back unto the hit face's plane and + * calculating the intersection point. + * @param camera The camera used to render the object. + * @param invSceneTransform The inverse scene transformation of the hit object. + * @param nx The x-coordinate of the face's plane normal. + * @param ny The y-coordinate of the face plane normal. + * @param nz The z-coordinate of the face plane normal. + * @param px The x-coordinate of a point on the face's plane (ie a face vertex) + * @param py The y-coordinate of a point on the face's plane (ie a face vertex) + * @param pz The z-coordinate of a point on the face's plane (ie a face vertex) + */ + ShaderPicker.prototype.getPrecisePosition = function (invSceneTransform, nx, ny, nz, px, py, pz) { + // calculate screen ray and find exact intersection position with triangle + var rx, ry, rz; + var ox, oy, oz; + var t; + var raw = Matrix3DUtils.RAW_DATA_CONTAINER; + var cx = this._rayPos.x, cy = this._rayPos.y, cz = this._rayPos.z; + // unprojected projection point, gives ray dir in cam space + ox = this._rayDir.x; + oy = this._rayDir.y; + oz = this._rayDir.z; + // transform ray dir and origin (cam pos) to object space + //invSceneTransform.copyRawDataTo( raw ); + invSceneTransform.copyRawDataTo(raw); + rx = raw[0] * ox + raw[4] * oy + raw[8] * oz; + ry = raw[1] * ox + raw[5] * oy + raw[9] * oz; + rz = raw[2] * ox + raw[6] * oy + raw[10] * oz; + ox = raw[0] * cx + raw[4] * cy + raw[8] * cz + raw[12]; + oy = raw[1] * cx + raw[5] * cy + raw[9] * cz + raw[13]; + oz = raw[2] * cx + raw[6] * cy + raw[10] * cz + raw[14]; + t = ((px - ox) * nx + (py - oy) * ny + (pz - oz) * nz) / (rx * nx + ry * ny + rz * nz); + this._localHitPosition.x = ox + rx * t; + this._localHitPosition.y = oy + ry * t; + this._localHitPosition.z = oz + rz * t; + }; + ShaderPicker.prototype.dispose = function () { + this._bitmapData.dispose(); + if (this._triangleProgram) + this._triangleProgram.dispose(); + if (this._objectProgram) + this._objectProgram.dispose(); + this._triangleProgram = null; + this._objectProgram = null; + this._bitmapData = null; + this._hitRenderable = null; + this._hitEntity = null; + }; + ShaderPicker.MOUSE_SCISSOR_RECT = new Rectangle(0, 0, 1, 1); + return ShaderPicker; +})(); +module.exports = ShaderPicker; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["core/pick/shaderpicker.ts"],"names":["ShaderPicker","ShaderPicker.constructor","ShaderPicker.onlyMouseEnabled","ShaderPicker.getViewCollision","ShaderPicker.getSceneCollision","ShaderPicker.pDraw","ShaderPicker.drawRenderables","ShaderPicker.updateRay","ShaderPicker.initObjectProgram","ShaderPicker.initTriangleProgram","ShaderPicker.getHitDetails","ShaderPicker.getApproximatePosition","ShaderPicker.getPreciseDetails","ShaderPicker.getPrecisePosition","ShaderPicker.dispose"],"mappings":"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","file":"core/pick/ShaderPicker.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Debug\t\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport BitmapData\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/BitmapData\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Scene\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/Scene\");\nimport View\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport Box\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Box\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Matrix3DUtils\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3DUtils\");\nimport Point\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Point\");\nimport Rectangle\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Rectangle\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport IPicker\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/pick/IPicker\");\nimport PickingCollisionVO\t\t\t\t= require(\"awayjs-core/lib/core/pick/PickingCollisionVO\");\nimport EntityCollector\t\t\t\t\t= require(\"awayjs-core/lib/core/traverse/EntityCollector\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport IEntity\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/IEntity\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\nimport ByteArray\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/ByteArray\");\n\nimport AGALMiniAssembler\t\t\t\t= require(\"awayjs-stagegl/lib/aglsl/assembler/AGALMiniAssembler\");\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport DefaultRenderer\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\nimport ContextGLBlendFactor\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLBlendFactor\");\nimport ContextGLClearMask\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLClearMask\");\nimport ContextGLCompareMode\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLCompareMode\");\nimport ContextGLProgramType\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLProgramType\");\nimport ContextGLTriangleFace\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLTriangleFace\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport IProgram\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IProgram\");\nimport ITextureBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ITextureBase\");\n\n/**\n * Picks a 3d object from a view or scene by performing a separate render pass on the scene around the area being picked using key color values,\n * then reading back the color value of the pixel in the render representing the picking ray. Requires multiple passes and readbacks for retriving details\n * on an entity that has its shaderPickingDetails property set to true.\n *\n * A read-back operation from any GPU is not a very efficient process, and the amount of processing used can vary significantly between different hardware.\n *\n * @see away.entities.Entity#shaderPickingDetails\n *\n * @class away.pick.ShaderPicker\n */\nclass ShaderPicker implements IPicker\n{\n\tprivate _opaqueRenderableHead:RenderableBase;\n\tprivate _blendedRenderableHead:RenderableBase;\n\n\tprivate _stage:Stage;\n\tprivate _context:IContextStageGL;\n\tprivate _onlyMouseEnabled:boolean = true;\n\n\tprivate _objectProgram:IProgram;\n\tprivate _triangleProgram:IProgram;\n\tprivate _bitmapData:BitmapData;\n\tprivate _viewportData:Array<number>;\n\tprivate _boundOffsetScale:Array<number>;\n\tprivate _id:Array<number>;\n\n\tprivate _interactives:Array<RenderableBase> = new Array<RenderableBase>();\n\tprivate _interactiveId:number;\n\tprivate _hitColor:number;\n\tprivate _projX:number;\n\tprivate _projY:number;\n\n\tprivate _hitRenderable:RenderableBase;\n\tprivate _hitEntity:IEntity;\n\tprivate _localHitPosition:Vector3D = new Vector3D();\n\tprivate _hitUV:Point = new Point();\n\tprivate _faceIndex:number;\n\tprivate _subGeometryIndex:number;\n\n\tprivate _localHitNormal:Vector3D = new Vector3D();\n\n\tprivate _rayPos:Vector3D = new Vector3D();\n\tprivate _rayDir:Vector3D = new Vector3D();\n\tprivate _potentialFound:boolean;\n\tprivate static MOUSE_SCISSOR_RECT:Rectangle = new Rectangle(0, 0, 1, 1);\n\n\tprivate _shaderPickingDetails:boolean;\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get onlyMouseEnabled():boolean\n\t{\n\t\treturn this._onlyMouseEnabled;\n\t}\n\n\tpublic set onlyMouseEnabled(value:boolean)\n\t{\n\t\tthis._onlyMouseEnabled = value;\n\t}\n\n\t/**\n\t * Creates a new <code>ShaderPicker</code> object.\n\t *\n\t * @param shaderPickingDetails Determines whether the picker includes a second pass to calculate extra\n\t * properties such as uv and normal coordinates.\n\t */\n\tconstructor(shaderPickingDetails:boolean = false)\n\t{\n\t\tthis._shaderPickingDetails = shaderPickingDetails;\n\n\t\tthis._id = new Array<number>(4);\n\t\tthis._viewportData = new Array<number>(4); // first 2 contain scale, last 2 translation\n\t\tthis._boundOffsetScale = new Array<number>(8); // first 2 contain scale, last 2 translation\n\t\tthis._boundOffsetScale[3] = 0;\n\t\tthis._boundOffsetScale[7] = 1;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getViewCollision(x:number, y:number, view:View):PickingCollisionVO\n\t{\n\t\tvar collector:EntityCollector = <EntityCollector> view.iEntityCollector;\n\n\t\tthis._stage = (<DefaultRenderer> view.renderer).stage;\n\n\t\tif (!this._stage)\n\t\t\treturn null;\n\n\t\tthis._context = <IContextStageGL> this._stage.context;\n\n\t\tthis._viewportData[0] = view.width;\n\t\tthis._viewportData[1] = view.height;\n\t\tthis._viewportData[2] = -(this._projX = 2*x/view.width - 1);\n\t\tthis._viewportData[3] = this._projY = 2*y/view.height - 1;\n\n\t\t// _potentialFound will be set to true if any object is actually rendered\n\t\tthis._potentialFound = false;\n\n\t\t//reset head values\n\t\tthis._blendedRenderableHead = null;\n\t\tthis._opaqueRenderableHead = null;\n\n\t\tthis.pDraw(collector, null);\n\n\t\t// clear buffers\n\t\tthis._context.setVertexBufferAt(0, null);\n\n\t\tif (!this._context || !this._potentialFound)\n\t\t\treturn null;\n\n\t\tif (!this._bitmapData)\n\t\t\tthis._bitmapData = new BitmapData(1, 1, false, 0);\n\n\t\tthis._context.drawToBitmapData(this._bitmapData);\n\t\tthis._hitColor = this._bitmapData.getPixel(0, 0);\n\n\t\tif (!this._hitColor) {\n\t\t\tthis._context.present();\n\t\t\treturn null;\n\t\t}\n\n\t\tthis._hitRenderable = this._interactives[this._hitColor - 1];\n\t\tthis._hitEntity = this._hitRenderable.sourceEntity;\n\n\t\tif (this._onlyMouseEnabled && !this._hitEntity._iIsMouseEnabled())\n\t\t\treturn null;\n\n\t\tvar _collisionVO:PickingCollisionVO = this._hitEntity._iPickingCollisionVO;\n\t\tif (this._shaderPickingDetails) {\n\t\t\tthis.getHitDetails(view.camera);\n\t\t\t_collisionVO.localPosition = this._localHitPosition;\n\t\t\t_collisionVO.localNormal = this._localHitNormal;\n\t\t\t_collisionVO.uv = this._hitUV;\n\t\t\t_collisionVO.index = this._faceIndex;\n\t\t\t//_collisionVO.subGeometryIndex = this._subGeometryIndex;\n\n\t\t} else {\n\t\t\t_collisionVO.localPosition = null;\n\t\t\t_collisionVO.localNormal = null;\n\t\t\t_collisionVO.uv = null;\n\t\t\t_collisionVO.index = 0;\n\t\t\t//_collisionVO.subGeometryIndex = 0;\n\t\t}\n\n\t\treturn _collisionVO;\n\t}\n\n\t//*/\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic getSceneCollision(position:Vector3D, direction:Vector3D, scene:Scene):PickingCollisionVO\n\t{\n\t\treturn null;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic pDraw(entityCollector:EntityCollector, target:ITextureBase)\n\t{\n\n\t\tvar camera:Camera = entityCollector.camera;\n\n\t\tthis._context.clear(0, 0, 0, 1);\n\t\tthis._stage.scissorRect = ShaderPicker.MOUSE_SCISSOR_RECT;\n\n\t\tthis._interactives.length = this._interactiveId = 0;\n\n\t\tif (!this._objectProgram)\n\t\t\tthis.initObjectProgram();\n\n\t\tthis._context.setBlendFactors(ContextGLBlendFactor.ONE, ContextGLBlendFactor.ZERO);\n\t\tthis._context.setDepthTest(true, ContextGLCompareMode.LESS);\n\t\tthis._context.setProgram(this._objectProgram);\n\t\tthis._context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 4, this._viewportData, 1);\n\t\t//this.drawRenderables(entityCollector.opaqueRenderableHead, camera);\n\t\t//this.drawRenderables(entityCollector.blendedRenderableHead, camera);\n\t\t//TODO: reimplement ShaderPicker inheriting from RendererBase\n\t}\n\n\t/**\n\t * Draw a list of renderables.\n\t * @param renderables The renderables to draw.\n\t * @param camera The camera for which to render.\n\t */\n\tprivate drawRenderables(renderable:RenderableBase, camera:Camera)\n\t{\n\t\tvar matrix:Matrix3D = Matrix3DUtils.CALCULATION_MATRIX;\n\t\tvar viewProjection:Matrix3D = camera.viewProjection;\n\n\t\twhile (renderable) {\n\t\t\t// it's possible that the renderable was already removed from the scene\n\t\t\tif (!renderable.sourceEntity.scene || !renderable.sourceEntity._iIsMouseEnabled()) {\n\t\t\t\trenderable = renderable.next;\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tthis._potentialFound = true;\n\n\t\t\tthis._context.setCulling((<MaterialBase> renderable.materialOwner.material).bothSides? ContextGLTriangleFace.NONE : ContextGLTriangleFace.BACK, camera.projection.coordinateSystem);\n\n\t\t\tthis._interactives[this._interactiveId++] = renderable;\n\t\t\t// color code so that reading from bitmapdata will contain the correct value\n\t\t\tthis._id[1] = (this._interactiveId >> 8)/255; // on green channel\n\t\t\tthis._id[2] = (this._interactiveId & 0xff)/255; // on blue channel\n\n\t\t\tmatrix.copyFrom(renderable.sourceEntity.getRenderSceneTransform(camera));\n\t\t\tmatrix.append(viewProjection);\n\t\t\tthis._context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, matrix, true);\n\t\t\tthis._context.setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, 0, this._id, 1);\n\t\t\tthis._context.activateBuffer(0, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT);\n\t\t\tthis._context.drawTriangles(this._context.getIndexBuffer(renderable.getIndexData()), 0, renderable.numTriangles);\n\n\t\t\trenderable = renderable.next;\n\t\t}\n\n\t}\n\n\tprivate updateRay(camera:Camera)\n\t{\n\t\tthis._rayPos = camera.scenePosition;\n\n\t\tthis._rayDir = camera.getRay(this._projX, this._projY, 1);\n\t\tthis._rayDir.normalize();\n\t}\n\n\t/**\n\t * Creates the Program that color-codes objects.\n\t */\n\tprivate initObjectProgram()\n\t{\n\t\tvar vertexCode:string;\n\t\tvar fragmentCode:string;\n\n\t\tthis._objectProgram = this._context.createProgram();\n\n\t\tvertexCode = \"m44 vt0, va0, vc0\t\t\t\\n\" + \"mul vt1.xy, vt0.w, vc4.zw\t\\n\" + \"add vt0.xy, vt0.xy, vt1.xy\t\\n\" + \"mul vt0.xy, vt0.xy, vc4.xy\t\\n\" + \"mov op, vt0\t\\n\";\n\t\tfragmentCode = \"mov oc, fc0\"; // write identifier\n\n\t\tDebug.throwPIR('ShaderPicker', 'initTriangleProgram', 'Dependency: initObjectProgram')\n\t\t//_objectProgram.upload(new AGALMiniAssembler().assemble(ContextGLProgramType.VERTEX, vertexCode),new AGALMiniAssembler().assemble(ContextGLProgramType.FRAGMENT, fragmentCode));\n\t}\n\n\t/**\n\t * Creates the Program that renders positions.\n\t */\n\n\tprivate initTriangleProgram()\n\t{\n\t\tvar vertexCode:string;\n\t\tvar fragmentCode:string;\n\n\t\tthis._triangleProgram = this._context.createProgram();\n\n\t\t// todo: add animation code\n\t\tvertexCode = \"add vt0, va0, vc5 \t\t\t\\n\" + \"mul vt0, vt0, vc6 \t\t\t\\n\" + \"mov v0, vt0\t\t\t\t\\n\" + \"m44 vt0, va0, vc0\t\t\t\\n\" + \"mul vt1.xy, vt0.w, vc4.zw\t\\n\" + \"add vt0.xy, vt0.xy, vt1.xy\t\\n\" + \"mul vt0.xy, vt0.xy, vc4.xy\t\\n\" + \"mov op, vt0\t\\n\";\n\t\tfragmentCode = \"mov oc, v0\"; // write identifier\n\n\t\tvar vertexByteCode:ByteArray = (new AGALMiniAssembler().assemble(\"part vertex 1\\n\" + vertexCode + \"endpart\"))['vertex'].data;\n\t\tvar fragmentByteCode:ByteArray = (new AGALMiniAssembler().assemble(\"part fragment 1\\n\" + fragmentCode + \"endpart\"))['fragment'].data;\n\t\tthis._triangleProgram.upload(vertexByteCode, fragmentByteCode);\n\t}\n\n\t/**\n\t * Gets more detailed information about the hir position, if required.\n\t * @param camera The camera used to view the hit object.\n\t */\n\tprivate getHitDetails(camera:Camera)\n\t{\n\t\tthis.getApproximatePosition(camera);\n\t\tthis.getPreciseDetails(camera);\n\t}\n\n\t/**\n\t * Finds a first-guess approximate position about the hit position.\n\t *\n\t * @param camera The camera used to view the hit object.\n\t */\n\tprivate getApproximatePosition(camera:Camera)\n\t{\n\t\tvar bounds:Box = this._hitRenderable.sourceEntity.bounds.aabb;\n\t\tvar col:number;\n\t\tvar scX:number, scY:number, scZ:number;\n\t\tvar offsX:number, offsY:number, offsZ:number;\n\t\tvar localViewProjection:Matrix3D = Matrix3DUtils.CALCULATION_MATRIX;\n\n\t\tlocalViewProjection.copyFrom(this._hitRenderable.sourceEntity.getRenderSceneTransform(camera));\n\t\tlocalViewProjection.append(camera.viewProjection);\n\t\tif (!this._triangleProgram) {\n\t\t\tthis.initTriangleProgram();\n\t\t}\n\n\t\tthis._boundOffsetScale[4] = 1/(scX = bounds.width);\n\t\tthis._boundOffsetScale[5] = 1/(scY = bounds.height);\n\t\tthis._boundOffsetScale[6] = 1/(scZ = bounds.depth);\n\t\tthis._boundOffsetScale[0] = offsX = -bounds.x;\n\t\tthis._boundOffsetScale[1] = offsY = -bounds.y;\n\t\tthis._boundOffsetScale[2] = offsZ = -bounds.z;\n\n\t\tthis._context.setProgram(this._triangleProgram);\n\t\tthis._context.clear(0, 0, 0, 0, 1, 0, ContextGLClearMask.DEPTH);\n\t\tthis._context.setScissorRectangle(ShaderPicker.MOUSE_SCISSOR_RECT);\n\t\tthis._context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, localViewProjection, true);\n\t\tthis._context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 5, this._boundOffsetScale, 2);\n\n\t\tthis._context.activateBuffer(0, this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA), this._hitRenderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT);\n\t\tthis._context.drawTriangles(this._context.getIndexBuffer(this._hitRenderable.getIndexData()), 0, this._hitRenderable.numTriangles);\n\n\t\tthis._context.drawToBitmapData(this._bitmapData);\n\n\t\tcol = this._bitmapData.getPixel(0, 0);\n\n\t\tthis._localHitPosition.x = ((col >> 16) & 0xff)*scX/255 - offsX;\n\t\tthis._localHitPosition.y = ((col >> 8) & 0xff)*scY/255 - offsY;\n\t\tthis._localHitPosition.z = (col & 0xff)*scZ/255 - offsZ;\n\t}\n\n\t/**\n\t * Use the approximate position info to find the face under the mouse position from which we can derive the precise\n\t * ray-face intersection point, then use barycentric coordinates to figure out the uv coordinates, etc.\n\t * @param camera The camera used to view the hit object.\n\t */\n\tprivate getPreciseDetails(camera:Camera)\n\t{\n\t\tvar len:number = indices.length;\n\t\tvar x1:number, y1:number, z1:number;\n\t\tvar x2:number, y2:number, z2:number;\n\t\tvar x3:number, y3:number, z3:number;\n\t\tvar i:number = 0, j:number = 1, k:number = 2;\n\t\tvar t1:number, t2:number, t3:number;\n\t\tvar v0x:number, v0y:number, v0z:number;\n\t\tvar v1x:number, v1y:number, v1z:number;\n\t\tvar v2x:number, v2y:number, v2z:number;\n\t\tvar ni1:number, ni2:number, ni3:number;\n\t\tvar n1:number, n2:number, n3:number, nLength:number;\n\t\tvar dot00:number, dot01:number, dot02:number, dot11:number, dot12:number;\n\t\tvar s:number, t:number, invDenom:number;\n\t\tvar x:number = this._localHitPosition.x, y:number = this._localHitPosition.y, z:number = this._localHitPosition.z;\n\t\tvar u:number, v:number;\n\t\tvar ui1:number, ui2:number, ui3:number;\n\t\tvar s0x:number, s0y:number, s0z:number;\n\t\tvar s1x:number, s1y:number, s1z:number;\n\t\tvar nl:number;\n\t\tvar indices:Array<number> = this._hitRenderable.getIndexData().data;\n\n\t\tvar positions:Array<number> = this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA).data;\n\t\tvar positionStride:number = this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA).dataPerVertex;\n\t\tvar positionOffset:number = this._hitRenderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA);\n\n\t\tvar uvs:Array<number> = this._hitRenderable.getVertexData(TriangleSubGeometry.UV_DATA).data;\n\t\tvar uvStride:number = this._hitRenderable.getVertexData(TriangleSubGeometry.UV_DATA).dataPerVertex;\n\t\tvar uvOffset:number = this._hitRenderable.getVertexOffset(TriangleSubGeometry.UV_DATA);\n\n\t\tvar normals:Array<number> = this._hitRenderable.getVertexData(TriangleSubGeometry.NORMAL_DATA).data;\n\t\tvar normalStride:number = this._hitRenderable.getVertexData(TriangleSubGeometry.NORMAL_DATA).dataPerVertex;\n\t\tvar normalOffset:number = this._hitRenderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA);\n\n\t\tthis.updateRay(camera);\n\n\t\twhile (i < len) {\n\t\t\tt1 = positionOffset + indices[i]*positionStride;\n\t\t\tt2 = positionOffset + indices[j]*positionStride;\n\t\t\tt3 = positionOffset + indices[k]*positionStride;\n\t\t\tx1 = positions[t1];\n\t\t\ty1 = positions[t1 + 1];\n\t\t\tz1 = positions[t1 + 2];\n\t\t\tx2 = positions[t2];\n\t\t\ty2 = positions[t2 + 1];\n\t\t\tz2 = positions[t2 + 2];\n\t\t\tx3 = positions[t3];\n\t\t\ty3 = positions[t3 + 1];\n\t\t\tz3 = positions[t3 + 2];\n\n\t\t\t// if within bounds\n\t\t\tif (!(    (x < x1 && x < x2 && x < x3) || (y < y1 && y < y2 && y < y3) || (z < z1 && z < z2 && z < z3) || (x > x1 && x > x2 && x > x3) || (y > y1 && y > y2 && y > y3) || (z > z1 && z > z2 && z > z3))) {\n\n\t\t\t\t// calculate barycentric coords for approximated position\n\t\t\t\tv0x = x3 - x1;\n\t\t\t\tv0y = y3 - y1;\n\t\t\t\tv0z = z3 - z1;\n\t\t\t\tv1x = x2 - x1;\n\t\t\t\tv1y = y2 - y1;\n\t\t\t\tv1z = z2 - z1;\n\t\t\t\tv2x = x - x1;\n\t\t\t\tv2y = y - y1;\n\t\t\t\tv2z = z - z1;\n\t\t\t\tdot00 = v0x*v0x + v0y*v0y + v0z*v0z;\n\t\t\t\tdot01 = v0x*v1x + v0y*v1y + v0z*v1z;\n\t\t\t\tdot02 = v0x*v2x + v0y*v2y + v0z*v2z;\n\t\t\t\tdot11 = v1x*v1x + v1y*v1y + v1z*v1z;\n\t\t\t\tdot12 = v1x*v2x + v1y*v2y + v1z*v2z;\n\t\t\t\tinvDenom = 1/(dot00*dot11 - dot01*dot01);\n\t\t\t\ts = (dot11*dot02 - dot01*dot12)*invDenom;\n\t\t\t\tt = (dot00*dot12 - dot01*dot02)*invDenom;\n\n\t\t\t\t// if inside the current triangle, fetch details hit information\n\t\t\t\tif (s >= 0 && t >= 0 && (s + t) <= 1) {\n\n\t\t\t\t\tni1 = normalOffset + indices[i]*normalStride;\n\t\t\t\t\tni2 = normalOffset + indices[j]*normalStride;\n\t\t\t\t\tni3 = normalOffset + indices[k]*normalStride;\n\n\t\t\t\t\tn1 = indices[ni1] + indices[ni2] + indices[ni3];\n\t\t\t\t\tn2 = indices[ni1 + 1] + indices[ni2 + 1] + indices[ni3 + 1];\n\t\t\t\t\tn3 = indices[ni1 + 2] + indices[ni2 + 2] + indices[ni3 + 2];\n\n\t\t\t\t\tnLength = Math.sqrt(n1*n1 + n2*n2 + n3*n3);\n\n\t\t\t\t\tn1 /= nLength;\n\t\t\t\t\tn2 /= nLength;\n\t\t\t\t\tn3 /= nLength;\n\n\t\t\t\t\t// this is def the triangle, now calculate precise coords\n\t\t\t\t\tthis.getPrecisePosition(this._hitRenderable.sourceEntity.inverseSceneTransform, n1, n2, n3, x1, y1, z1);\n\n\t\t\t\t\tv2x = this._localHitPosition.x - x1;\n\t\t\t\t\tv2y = this._localHitPosition.y - y1;\n\t\t\t\t\tv2z = this._localHitPosition.z - z1;\n\n\t\t\t\t\ts0x = x2 - x1; // s0 = p1 - p0\n\t\t\t\t\ts0y = y2 - y1;\n\t\t\t\t\ts0z = z2 - z1;\n\t\t\t\t\ts1x = x3 - x1; // s1 = p2 - p0\n\t\t\t\t\ts1y = y3 - y1;\n\t\t\t\t\ts1z = z3 - z1;\n\t\t\t\t\tthis._localHitNormal.x = s0y*s1z - s0z*s1y; // n = s0 x s1\n\t\t\t\t\tthis._localHitNormal.y = s0z*s1x - s0x*s1z;\n\t\t\t\t\tthis._localHitNormal.z = s0x*s1y - s0y*s1x;\n\t\t\t\t\tnl = 1/Math.sqrt(this._localHitNormal.x*this._localHitNormal.x + this._localHitNormal.y*this._localHitNormal.y + this._localHitNormal.z*this._localHitNormal.z); // normalize n\n\t\t\t\t\tthis._localHitNormal.x *= nl;\n\t\t\t\t\tthis._localHitNormal.y *= nl;\n\t\t\t\t\tthis._localHitNormal.z *= nl;\n\n\t\t\t\t\tdot02 = v0x*v2x + v0y*v2y + v0z*v2z;\n\t\t\t\t\tdot12 = v1x*v2x + v1y*v2y + v1z*v2z;\n\t\t\t\t\ts = (dot11*dot02 - dot01*dot12)*invDenom;\n\t\t\t\t\tt = (dot00*dot12 - dot01*dot02)*invDenom;\n\n\t\t\t\t\tui1 = uvOffset + indices[i]*uvStride\n\t\t\t\t\tui2 = uvOffset + indices[j]*uvStride\n\t\t\t\t\tui3 = uvOffset + indices[k]*uvStride\n\n\t\t\t\t\tu = uvs[ui1];\n\t\t\t\t\tv = uvs[ui1 + 1];\n\t\t\t\t\tthis._hitUV.x = u + t*(uvs[ui2] - u) + s*(uvs[ui3] - u);\n\t\t\t\t\tthis._hitUV.y = v + t*(uvs[ui2 + 1] - v) + s*(uvs[ui3 + 1] - v);\n\n\t\t\t\t\tthis._faceIndex = i;\n\t\t\t\t\t//TODO add back subGeometryIndex value\n\t\t\t\t\t//this._subGeometryIndex = away.utils.GeometryUtils.getMeshSubGeometryIndex(subGeom);\n\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ti += 3;\n\t\t\tj += 3;\n\t\t\tk += 3;\n\t\t}\n\t}\n\n\t/**\n\t * Finds the precise hit position by unprojecting the screen coordinate back unto the hit face's plane and\n\t * calculating the intersection point.\n\t * @param camera The camera used to render the object.\n\t * @param invSceneTransform The inverse scene transformation of the hit object.\n\t * @param nx The x-coordinate of the face's plane normal.\n\t * @param ny The y-coordinate of the face plane normal.\n\t * @param nz The z-coordinate of the face plane normal.\n\t * @param px The x-coordinate of a point on the face's plane (ie a face vertex)\n\t * @param py The y-coordinate of a point on the face's plane (ie a face vertex)\n\t * @param pz The z-coordinate of a point on the face's plane (ie a face vertex)\n\t */\n\n\tprivate getPrecisePosition(invSceneTransform:Matrix3D, nx:number, ny:number, nz:number, px:number, py:number, pz:number)\n\t{\n\t\t// calculate screen ray and find exact intersection position with triangle\n\t\tvar rx:number, ry:number, rz:number;\n\t\tvar ox:number, oy:number, oz:number;\n\t\tvar t:number;\n\t\tvar raw:Array<number> = Matrix3DUtils.RAW_DATA_CONTAINER;\n\t\tvar cx:number = this._rayPos.x, cy:number = this._rayPos.y, cz:number = this._rayPos.z;\n\n\t\t// unprojected projection point, gives ray dir in cam space\n\t\tox = this._rayDir.x;\n\t\toy = this._rayDir.y;\n\t\toz = this._rayDir.z;\n\n\t\t// transform ray dir and origin (cam pos) to object space\n\t\t//invSceneTransform.copyRawDataTo( raw  );\n\t\tinvSceneTransform.copyRawDataTo(raw);\n\t\trx = raw[0]*ox + raw[4]*oy + raw[8]*oz;\n\t\try = raw[1]*ox + raw[5]*oy + raw[9]*oz;\n\t\trz = raw[2]*ox + raw[6]*oy + raw[10]*oz;\n\n\t\tox = raw[0]*cx + raw[4]*cy + raw[8]*cz + raw[12];\n\t\toy = raw[1]*cx + raw[5]*cy + raw[9]*cz + raw[13];\n\t\toz = raw[2]*cx + raw[6]*cy + raw[10]*cz + raw[14];\n\n\t\tt = ((px - ox)*nx + (py - oy)*ny + (pz - oz)*nz)/(rx*nx + ry*ny + rz*nz);\n\n\t\tthis._localHitPosition.x = ox + rx*t;\n\t\tthis._localHitPosition.y = oy + ry*t;\n\t\tthis._localHitPosition.z = oz + rz*t;\n\t}\n\n\tpublic dispose()\n\t{\n\t\tthis._bitmapData.dispose();\n\t\tif (this._triangleProgram)\n\t\t\tthis._triangleProgram.dispose();\n\n\t\tif (this._objectProgram)\n\t\t\tthis._objectProgram.dispose();\n\n\t\tthis._triangleProgram = null;\n\t\tthis._objectProgram = null;\n\t\tthis._bitmapData = null;\n\t\tthis._hitRenderable = null;\n\t\tthis._hitEntity = null;\n\t}\n}\n\nexport = ShaderPicker;"]} \ No newline at end of file diff --git a/lib/core/pick/ShaderPicker.ts b/lib/core/pick/ShaderPicker.ts new file mode 100644 index 000000000..b480e38ff --- /dev/null +++ b/lib/core/pick/ShaderPicker.ts @@ -0,0 +1,560 @@ +import Debug = require("awayjs-core/lib/utils/Debug"); +import BitmapData = require("awayjs-core/lib/core/base/BitmapData"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Scene = require("awayjs-core/lib/containers/Scene"); +import View = require("awayjs-core/lib/containers/View"); +import Box = require("awayjs-core/lib/core/geom/Box"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Matrix3DUtils = require("awayjs-core/lib/core/geom/Matrix3DUtils"); +import Point = require("awayjs-core/lib/core/geom/Point"); +import Rectangle = require("awayjs-core/lib/core/geom/Rectangle"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import IPicker = require("awayjs-core/lib/core/pick/IPicker"); +import PickingCollisionVO = require("awayjs-core/lib/core/pick/PickingCollisionVO"); +import EntityCollector = require("awayjs-core/lib/core/traverse/EntityCollector"); +import Camera = require("awayjs-core/lib/entities/Camera"); +import IEntity = require("awayjs-core/lib/entities/IEntity"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); +import ByteArray = require("awayjs-core/lib/utils/ByteArray"); + +import AGALMiniAssembler = require("awayjs-stagegl/lib/aglsl/assembler/AGALMiniAssembler"); +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +import ContextGLBlendFactor = require("awayjs-stagegl/lib/core/stagegl/ContextGLBlendFactor"); +import ContextGLClearMask = require("awayjs-stagegl/lib/core/stagegl/ContextGLClearMask"); +import ContextGLCompareMode = require("awayjs-stagegl/lib/core/stagegl/ContextGLCompareMode"); +import ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +import ContextGLTriangleFace = require("awayjs-stagegl/lib/core/stagegl/ContextGLTriangleFace"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import IProgram = require("awayjs-stagegl/lib/core/stagegl/IProgram"); +import ITextureBase = require("awayjs-stagegl/lib/core/stagegl/ITextureBase"); + +/** + * Picks a 3d object from a view or scene by performing a separate render pass on the scene around the area being picked using key color values, + * then reading back the color value of the pixel in the render representing the picking ray. Requires multiple passes and readbacks for retriving details + * on an entity that has its shaderPickingDetails property set to true. + * + * A read-back operation from any GPU is not a very efficient process, and the amount of processing used can vary significantly between different hardware. + * + * @see away.entities.Entity#shaderPickingDetails + * + * @class away.pick.ShaderPicker + */ +class ShaderPicker implements IPicker +{ + private _opaqueRenderableHead:RenderableBase; + private _blendedRenderableHead:RenderableBase; + + private _stage:Stage; + private _context:IContextStageGL; + private _onlyMouseEnabled:boolean = true; + + private _objectProgram:IProgram; + private _triangleProgram:IProgram; + private _bitmapData:BitmapData; + private _viewportData:Array; + private _boundOffsetScale:Array; + private _id:Array; + + private _interactives:Array = new Array(); + private _interactiveId:number; + private _hitColor:number; + private _projX:number; + private _projY:number; + + private _hitRenderable:RenderableBase; + private _hitEntity:IEntity; + private _localHitPosition:Vector3D = new Vector3D(); + private _hitUV:Point = new Point(); + private _faceIndex:number; + private _subGeometryIndex:number; + + private _localHitNormal:Vector3D = new Vector3D(); + + private _rayPos:Vector3D = new Vector3D(); + private _rayDir:Vector3D = new Vector3D(); + private _potentialFound:boolean; + private static MOUSE_SCISSOR_RECT:Rectangle = new Rectangle(0, 0, 1, 1); + + private _shaderPickingDetails:boolean; + + /** + * @inheritDoc + */ + public get onlyMouseEnabled():boolean + { + return this._onlyMouseEnabled; + } + + public set onlyMouseEnabled(value:boolean) + { + this._onlyMouseEnabled = value; + } + + /** + * Creates a new ShaderPicker object. + * + * @param shaderPickingDetails Determines whether the picker includes a second pass to calculate extra + * properties such as uv and normal coordinates. + */ + constructor(shaderPickingDetails:boolean = false) + { + this._shaderPickingDetails = shaderPickingDetails; + + this._id = new Array(4); + this._viewportData = new Array(4); // first 2 contain scale, last 2 translation + this._boundOffsetScale = new Array(8); // first 2 contain scale, last 2 translation + this._boundOffsetScale[3] = 0; + this._boundOffsetScale[7] = 1; + } + + /** + * @inheritDoc + */ + public getViewCollision(x:number, y:number, view:View):PickingCollisionVO + { + var collector:EntityCollector = view.iEntityCollector; + + this._stage = ( view.renderer).stage; + + if (!this._stage) + return null; + + this._context = this._stage.context; + + this._viewportData[0] = view.width; + this._viewportData[1] = view.height; + this._viewportData[2] = -(this._projX = 2*x/view.width - 1); + this._viewportData[3] = this._projY = 2*y/view.height - 1; + + // _potentialFound will be set to true if any object is actually rendered + this._potentialFound = false; + + //reset head values + this._blendedRenderableHead = null; + this._opaqueRenderableHead = null; + + this.pDraw(collector, null); + + // clear buffers + this._context.setVertexBufferAt(0, null); + + if (!this._context || !this._potentialFound) + return null; + + if (!this._bitmapData) + this._bitmapData = new BitmapData(1, 1, false, 0); + + this._context.drawToBitmapData(this._bitmapData); + this._hitColor = this._bitmapData.getPixel(0, 0); + + if (!this._hitColor) { + this._context.present(); + return null; + } + + this._hitRenderable = this._interactives[this._hitColor - 1]; + this._hitEntity = this._hitRenderable.sourceEntity; + + if (this._onlyMouseEnabled && !this._hitEntity._iIsMouseEnabled()) + return null; + + var _collisionVO:PickingCollisionVO = this._hitEntity._iPickingCollisionVO; + if (this._shaderPickingDetails) { + this.getHitDetails(view.camera); + _collisionVO.localPosition = this._localHitPosition; + _collisionVO.localNormal = this._localHitNormal; + _collisionVO.uv = this._hitUV; + _collisionVO.index = this._faceIndex; + //_collisionVO.subGeometryIndex = this._subGeometryIndex; + + } else { + _collisionVO.localPosition = null; + _collisionVO.localNormal = null; + _collisionVO.uv = null; + _collisionVO.index = 0; + //_collisionVO.subGeometryIndex = 0; + } + + return _collisionVO; + } + + //*/ + /** + * @inheritDoc + */ + public getSceneCollision(position:Vector3D, direction:Vector3D, scene:Scene):PickingCollisionVO + { + return null; + } + + /** + * @inheritDoc + */ + public pDraw(entityCollector:EntityCollector, target:ITextureBase) + { + + var camera:Camera = entityCollector.camera; + + this._context.clear(0, 0, 0, 1); + this._stage.scissorRect = ShaderPicker.MOUSE_SCISSOR_RECT; + + this._interactives.length = this._interactiveId = 0; + + if (!this._objectProgram) + this.initObjectProgram(); + + this._context.setBlendFactors(ContextGLBlendFactor.ONE, ContextGLBlendFactor.ZERO); + this._context.setDepthTest(true, ContextGLCompareMode.LESS); + this._context.setProgram(this._objectProgram); + this._context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 4, this._viewportData, 1); + //this.drawRenderables(entityCollector.opaqueRenderableHead, camera); + //this.drawRenderables(entityCollector.blendedRenderableHead, camera); + //TODO: reimplement ShaderPicker inheriting from RendererBase + } + + /** + * Draw a list of renderables. + * @param renderables The renderables to draw. + * @param camera The camera for which to render. + */ + private drawRenderables(renderable:RenderableBase, camera:Camera) + { + var matrix:Matrix3D = Matrix3DUtils.CALCULATION_MATRIX; + var viewProjection:Matrix3D = camera.viewProjection; + + while (renderable) { + // it's possible that the renderable was already removed from the scene + if (!renderable.sourceEntity.scene || !renderable.sourceEntity._iIsMouseEnabled()) { + renderable = renderable.next; + continue; + } + + this._potentialFound = true; + + this._context.setCulling(( renderable.materialOwner.material).bothSides? ContextGLTriangleFace.NONE : ContextGLTriangleFace.BACK, camera.projection.coordinateSystem); + + this._interactives[this._interactiveId++] = renderable; + // color code so that reading from bitmapdata will contain the correct value + this._id[1] = (this._interactiveId >> 8)/255; // on green channel + this._id[2] = (this._interactiveId & 0xff)/255; // on blue channel + + matrix.copyFrom(renderable.sourceEntity.getRenderSceneTransform(camera)); + matrix.append(viewProjection); + this._context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, matrix, true); + this._context.setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, 0, this._id, 1); + this._context.activateBuffer(0, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + this._context.drawTriangles(this._context.getIndexBuffer(renderable.getIndexData()), 0, renderable.numTriangles); + + renderable = renderable.next; + } + + } + + private updateRay(camera:Camera) + { + this._rayPos = camera.scenePosition; + + this._rayDir = camera.getRay(this._projX, this._projY, 1); + this._rayDir.normalize(); + } + + /** + * Creates the Program that color-codes objects. + */ + private initObjectProgram() + { + var vertexCode:string; + var fragmentCode:string; + + this._objectProgram = this._context.createProgram(); + + vertexCode = "m44 vt0, va0, vc0 \n" + "mul vt1.xy, vt0.w, vc4.zw \n" + "add vt0.xy, vt0.xy, vt1.xy \n" + "mul vt0.xy, vt0.xy, vc4.xy \n" + "mov op, vt0 \n"; + fragmentCode = "mov oc, fc0"; // write identifier + + Debug.throwPIR('ShaderPicker', 'initTriangleProgram', 'Dependency: initObjectProgram') + //_objectProgram.upload(new AGALMiniAssembler().assemble(ContextGLProgramType.VERTEX, vertexCode),new AGALMiniAssembler().assemble(ContextGLProgramType.FRAGMENT, fragmentCode)); + } + + /** + * Creates the Program that renders positions. + */ + + private initTriangleProgram() + { + var vertexCode:string; + var fragmentCode:string; + + this._triangleProgram = this._context.createProgram(); + + // todo: add animation code + vertexCode = "add vt0, va0, vc5 \n" + "mul vt0, vt0, vc6 \n" + "mov v0, vt0 \n" + "m44 vt0, va0, vc0 \n" + "mul vt1.xy, vt0.w, vc4.zw \n" + "add vt0.xy, vt0.xy, vt1.xy \n" + "mul vt0.xy, vt0.xy, vc4.xy \n" + "mov op, vt0 \n"; + fragmentCode = "mov oc, v0"; // write identifier + + var vertexByteCode:ByteArray = (new AGALMiniAssembler().assemble("part vertex 1\n" + vertexCode + "endpart"))['vertex'].data; + var fragmentByteCode:ByteArray = (new AGALMiniAssembler().assemble("part fragment 1\n" + fragmentCode + "endpart"))['fragment'].data; + this._triangleProgram.upload(vertexByteCode, fragmentByteCode); + } + + /** + * Gets more detailed information about the hir position, if required. + * @param camera The camera used to view the hit object. + */ + private getHitDetails(camera:Camera) + { + this.getApproximatePosition(camera); + this.getPreciseDetails(camera); + } + + /** + * Finds a first-guess approximate position about the hit position. + * + * @param camera The camera used to view the hit object. + */ + private getApproximatePosition(camera:Camera) + { + var bounds:Box = this._hitRenderable.sourceEntity.bounds.aabb; + var col:number; + var scX:number, scY:number, scZ:number; + var offsX:number, offsY:number, offsZ:number; + var localViewProjection:Matrix3D = Matrix3DUtils.CALCULATION_MATRIX; + + localViewProjection.copyFrom(this._hitRenderable.sourceEntity.getRenderSceneTransform(camera)); + localViewProjection.append(camera.viewProjection); + if (!this._triangleProgram) { + this.initTriangleProgram(); + } + + this._boundOffsetScale[4] = 1/(scX = bounds.width); + this._boundOffsetScale[5] = 1/(scY = bounds.height); + this._boundOffsetScale[6] = 1/(scZ = bounds.depth); + this._boundOffsetScale[0] = offsX = -bounds.x; + this._boundOffsetScale[1] = offsY = -bounds.y; + this._boundOffsetScale[2] = offsZ = -bounds.z; + + this._context.setProgram(this._triangleProgram); + this._context.clear(0, 0, 0, 0, 1, 0, ContextGLClearMask.DEPTH); + this._context.setScissorRectangle(ShaderPicker.MOUSE_SCISSOR_RECT); + this._context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, localViewProjection, true); + this._context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 5, this._boundOffsetScale, 2); + + this._context.activateBuffer(0, this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA), this._hitRenderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + this._context.drawTriangles(this._context.getIndexBuffer(this._hitRenderable.getIndexData()), 0, this._hitRenderable.numTriangles); + + this._context.drawToBitmapData(this._bitmapData); + + col = this._bitmapData.getPixel(0, 0); + + this._localHitPosition.x = ((col >> 16) & 0xff)*scX/255 - offsX; + this._localHitPosition.y = ((col >> 8) & 0xff)*scY/255 - offsY; + this._localHitPosition.z = (col & 0xff)*scZ/255 - offsZ; + } + + /** + * Use the approximate position info to find the face under the mouse position from which we can derive the precise + * ray-face intersection point, then use barycentric coordinates to figure out the uv coordinates, etc. + * @param camera The camera used to view the hit object. + */ + private getPreciseDetails(camera:Camera) + { + var len:number = indices.length; + var x1:number, y1:number, z1:number; + var x2:number, y2:number, z2:number; + var x3:number, y3:number, z3:number; + var i:number = 0, j:number = 1, k:number = 2; + var t1:number, t2:number, t3:number; + var v0x:number, v0y:number, v0z:number; + var v1x:number, v1y:number, v1z:number; + var v2x:number, v2y:number, v2z:number; + var ni1:number, ni2:number, ni3:number; + var n1:number, n2:number, n3:number, nLength:number; + var dot00:number, dot01:number, dot02:number, dot11:number, dot12:number; + var s:number, t:number, invDenom:number; + var x:number = this._localHitPosition.x, y:number = this._localHitPosition.y, z:number = this._localHitPosition.z; + var u:number, v:number; + var ui1:number, ui2:number, ui3:number; + var s0x:number, s0y:number, s0z:number; + var s1x:number, s1y:number, s1z:number; + var nl:number; + var indices:Array = this._hitRenderable.getIndexData().data; + + var positions:Array = this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA).data; + var positionStride:number = this._hitRenderable.getVertexData(TriangleSubGeometry.POSITION_DATA).dataPerVertex; + var positionOffset:number = this._hitRenderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA); + + var uvs:Array = this._hitRenderable.getVertexData(TriangleSubGeometry.UV_DATA).data; + var uvStride:number = this._hitRenderable.getVertexData(TriangleSubGeometry.UV_DATA).dataPerVertex; + var uvOffset:number = this._hitRenderable.getVertexOffset(TriangleSubGeometry.UV_DATA); + + var normals:Array = this._hitRenderable.getVertexData(TriangleSubGeometry.NORMAL_DATA).data; + var normalStride:number = this._hitRenderable.getVertexData(TriangleSubGeometry.NORMAL_DATA).dataPerVertex; + var normalOffset:number = this._hitRenderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA); + + this.updateRay(camera); + + while (i < len) { + t1 = positionOffset + indices[i]*positionStride; + t2 = positionOffset + indices[j]*positionStride; + t3 = positionOffset + indices[k]*positionStride; + x1 = positions[t1]; + y1 = positions[t1 + 1]; + z1 = positions[t1 + 2]; + x2 = positions[t2]; + y2 = positions[t2 + 1]; + z2 = positions[t2 + 2]; + x3 = positions[t3]; + y3 = positions[t3 + 1]; + z3 = positions[t3 + 2]; + + // if within bounds + if (!( (x < x1 && x < x2 && x < x3) || (y < y1 && y < y2 && y < y3) || (z < z1 && z < z2 && z < z3) || (x > x1 && x > x2 && x > x3) || (y > y1 && y > y2 && y > y3) || (z > z1 && z > z2 && z > z3))) { + + // calculate barycentric coords for approximated position + v0x = x3 - x1; + v0y = y3 - y1; + v0z = z3 - z1; + v1x = x2 - x1; + v1y = y2 - y1; + v1z = z2 - z1; + v2x = x - x1; + v2y = y - y1; + v2z = z - z1; + dot00 = v0x*v0x + v0y*v0y + v0z*v0z; + dot01 = v0x*v1x + v0y*v1y + v0z*v1z; + dot02 = v0x*v2x + v0y*v2y + v0z*v2z; + dot11 = v1x*v1x + v1y*v1y + v1z*v1z; + dot12 = v1x*v2x + v1y*v2y + v1z*v2z; + invDenom = 1/(dot00*dot11 - dot01*dot01); + s = (dot11*dot02 - dot01*dot12)*invDenom; + t = (dot00*dot12 - dot01*dot02)*invDenom; + + // if inside the current triangle, fetch details hit information + if (s >= 0 && t >= 0 && (s + t) <= 1) { + + ni1 = normalOffset + indices[i]*normalStride; + ni2 = normalOffset + indices[j]*normalStride; + ni3 = normalOffset + indices[k]*normalStride; + + n1 = indices[ni1] + indices[ni2] + indices[ni3]; + n2 = indices[ni1 + 1] + indices[ni2 + 1] + indices[ni3 + 1]; + n3 = indices[ni1 + 2] + indices[ni2 + 2] + indices[ni3 + 2]; + + nLength = Math.sqrt(n1*n1 + n2*n2 + n3*n3); + + n1 /= nLength; + n2 /= nLength; + n3 /= nLength; + + // this is def the triangle, now calculate precise coords + this.getPrecisePosition(this._hitRenderable.sourceEntity.inverseSceneTransform, n1, n2, n3, x1, y1, z1); + + v2x = this._localHitPosition.x - x1; + v2y = this._localHitPosition.y - y1; + v2z = this._localHitPosition.z - z1; + + s0x = x2 - x1; // s0 = p1 - p0 + s0y = y2 - y1; + s0z = z2 - z1; + s1x = x3 - x1; // s1 = p2 - p0 + s1y = y3 - y1; + s1z = z3 - z1; + this._localHitNormal.x = s0y*s1z - s0z*s1y; // n = s0 x s1 + this._localHitNormal.y = s0z*s1x - s0x*s1z; + this._localHitNormal.z = s0x*s1y - s0y*s1x; + nl = 1/Math.sqrt(this._localHitNormal.x*this._localHitNormal.x + this._localHitNormal.y*this._localHitNormal.y + this._localHitNormal.z*this._localHitNormal.z); // normalize n + this._localHitNormal.x *= nl; + this._localHitNormal.y *= nl; + this._localHitNormal.z *= nl; + + dot02 = v0x*v2x + v0y*v2y + v0z*v2z; + dot12 = v1x*v2x + v1y*v2y + v1z*v2z; + s = (dot11*dot02 - dot01*dot12)*invDenom; + t = (dot00*dot12 - dot01*dot02)*invDenom; + + ui1 = uvOffset + indices[i]*uvStride + ui2 = uvOffset + indices[j]*uvStride + ui3 = uvOffset + indices[k]*uvStride + + u = uvs[ui1]; + v = uvs[ui1 + 1]; + this._hitUV.x = u + t*(uvs[ui2] - u) + s*(uvs[ui3] - u); + this._hitUV.y = v + t*(uvs[ui2 + 1] - v) + s*(uvs[ui3 + 1] - v); + + this._faceIndex = i; + //TODO add back subGeometryIndex value + //this._subGeometryIndex = away.utils.GeometryUtils.getMeshSubGeometryIndex(subGeom); + + return; + } + } + + i += 3; + j += 3; + k += 3; + } + } + + /** + * Finds the precise hit position by unprojecting the screen coordinate back unto the hit face's plane and + * calculating the intersection point. + * @param camera The camera used to render the object. + * @param invSceneTransform The inverse scene transformation of the hit object. + * @param nx The x-coordinate of the face's plane normal. + * @param ny The y-coordinate of the face plane normal. + * @param nz The z-coordinate of the face plane normal. + * @param px The x-coordinate of a point on the face's plane (ie a face vertex) + * @param py The y-coordinate of a point on the face's plane (ie a face vertex) + * @param pz The z-coordinate of a point on the face's plane (ie a face vertex) + */ + + private getPrecisePosition(invSceneTransform:Matrix3D, nx:number, ny:number, nz:number, px:number, py:number, pz:number) + { + // calculate screen ray and find exact intersection position with triangle + var rx:number, ry:number, rz:number; + var ox:number, oy:number, oz:number; + var t:number; + var raw:Array = Matrix3DUtils.RAW_DATA_CONTAINER; + var cx:number = this._rayPos.x, cy:number = this._rayPos.y, cz:number = this._rayPos.z; + + // unprojected projection point, gives ray dir in cam space + ox = this._rayDir.x; + oy = this._rayDir.y; + oz = this._rayDir.z; + + // transform ray dir and origin (cam pos) to object space + //invSceneTransform.copyRawDataTo( raw ); + invSceneTransform.copyRawDataTo(raw); + rx = raw[0]*ox + raw[4]*oy + raw[8]*oz; + ry = raw[1]*ox + raw[5]*oy + raw[9]*oz; + rz = raw[2]*ox + raw[6]*oy + raw[10]*oz; + + ox = raw[0]*cx + raw[4]*cy + raw[8]*cz + raw[12]; + oy = raw[1]*cx + raw[5]*cy + raw[9]*cz + raw[13]; + oz = raw[2]*cx + raw[6]*cy + raw[10]*cz + raw[14]; + + t = ((px - ox)*nx + (py - oy)*ny + (pz - oz)*nz)/(rx*nx + ry*ny + rz*nz); + + this._localHitPosition.x = ox + rx*t; + this._localHitPosition.y = oy + ry*t; + this._localHitPosition.z = oz + rz*t; + } + + public dispose() + { + this._bitmapData.dispose(); + if (this._triangleProgram) + this._triangleProgram.dispose(); + + if (this._objectProgram) + this._objectProgram.dispose(); + + this._triangleProgram = null; + this._objectProgram = null; + this._bitmapData = null; + this._hitRenderable = null; + this._hitEntity = null; + } +} + +export = ShaderPicker; \ No newline at end of file diff --git a/lib/events/AnimationStateEvent.js b/lib/events/AnimationStateEvent.js new file mode 100755 index 000000000..dcc3ef3ac --- /dev/null +++ b/lib/events/AnimationStateEvent.js @@ -0,0 +1,73 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Event = require("awayjs-core/lib/events/Event"); +/** + * Dispatched to notify changes in an animation state's state. + */ +var AnimationStateEvent = (function (_super) { + __extends(AnimationStateEvent, _super); + /** + * Create a new AnimatonStateEvent + * + * @param type The event type. + * @param animator The animation state object that is the subject of this event. + * @param animationNode The animation node inside the animation state from which the event originated. + */ + function AnimationStateEvent(type, animator, animationState, animationNode) { + _super.call(this, type); + this._animator = animator; + this._animationState = animationState; + this._animationNode = animationNode; + } + Object.defineProperty(AnimationStateEvent.prototype, "animator", { + /** + * The animator object that is the subject of this event. + */ + get: function () { + return this._animator; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationStateEvent.prototype, "animationState", { + /** + * The animation state object that is the subject of this event. + */ + get: function () { + return this._animationState; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(AnimationStateEvent.prototype, "animationNode", { + /** + * The animation node inside the animation state from which the event originated. + */ + get: function () { + return this._animationNode; + }, + enumerable: true, + configurable: true + }); + /** + * Clones the event. + * + * @return An exact duplicate of the current object. + */ + AnimationStateEvent.prototype.clone = function () { + return new AnimationStateEvent(this.type, this._animator, this._animationState, this._animationNode); + }; + /** + * Dispatched when a non-looping clip node inside an animation state reaches the end of its timeline. + */ + AnimationStateEvent.PLAYBACK_COMPLETE = "playbackComplete"; + AnimationStateEvent.TRANSITION_COMPLETE = "transitionComplete"; + return AnimationStateEvent; +})(Event); +module.exports = AnimationStateEvent; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/events/AnimationStateEvent.ts b/lib/events/AnimationStateEvent.ts new file mode 100644 index 000000000..cc709ce9e --- /dev/null +++ b/lib/events/AnimationStateEvent.ts @@ -0,0 +1,74 @@ +import AnimationNodeBase = require("awayjs-core/lib/animators/nodes/AnimationNodeBase"); +import Event = require("awayjs-core/lib/events/Event"); + +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import IAnimationState = require("awayjs-stagegl/lib/animators/states/IAnimationState"); + +/** + * Dispatched to notify changes in an animation state's state. + */ +class AnimationStateEvent extends Event +{ + /** + * Dispatched when a non-looping clip node inside an animation state reaches the end of its timeline. + */ + public static PLAYBACK_COMPLETE:string = "playbackComplete"; + + public static TRANSITION_COMPLETE:string = "transitionComplete"; + + private _animator:AnimatorBase; + private _animationState:IAnimationState; + private _animationNode:AnimationNodeBase; + + /** + * Create a new AnimatonStateEvent + * + * @param type The event type. + * @param animator The animation state object that is the subject of this event. + * @param animationNode The animation node inside the animation state from which the event originated. + */ + constructor(type:string, animator:AnimatorBase, animationState:IAnimationState, animationNode:AnimationNodeBase) + { + super(type); + + this._animator = animator; + this._animationState = animationState; + this._animationNode = animationNode; + } + + /** + * The animator object that is the subject of this event. + */ + public get animator():AnimatorBase + { + return this._animator; + } + + /** + * The animation state object that is the subject of this event. + */ + public get animationState():IAnimationState + { + return this._animationState; + } + + /** + * The animation node inside the animation state from which the event originated. + */ + public get animationNode():AnimationNodeBase + { + return this._animationNode; + } + + /** + * Clones the event. + * + * @return An exact duplicate of the current object. + */ + public clone():Event + { + return new AnimationStateEvent(this.type, this._animator, this._animationState, this._animationNode); + } +} + +export = AnimationStateEvent; \ No newline at end of file diff --git a/lib/materials/methods/AmbientEnvMapMethod.js b/lib/materials/methods/AmbientEnvMapMethod.js new file mode 100755 index 000000000..e67d79289 --- /dev/null +++ b/lib/materials/methods/AmbientEnvMapMethod.js @@ -0,0 +1,69 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var AmbientBasicMethod = require("awayjs-stagegl/lib/materials/methods/AmbientBasicMethod"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * AmbientEnvMapMethod provides a diffuse shading method that uses a diffuse irradiance environment map to + * approximate global lighting rather than lights. + */ +var AmbientEnvMapMethod = (function (_super) { + __extends(AmbientEnvMapMethod, _super); + /** + * Creates a new AmbientEnvMapMethod object. + * + * @param envMap The cube environment map to use for the ambient lighting. + */ + function AmbientEnvMapMethod(envMap) { + _super.call(this); + this._cubeTexture = envMap; + } + /** + * @inheritDoc + */ + AmbientEnvMapMethod.prototype.iInitVO = function (shaderObject, methodVO) { + _super.prototype.iInitVO.call(this, shaderObject, methodVO); + methodVO.needsNormals = true; + }; + Object.defineProperty(AmbientEnvMapMethod.prototype, "envMap", { + /** + * The cube environment map to use for the diffuse lighting. + */ + get: function () { + return this._cubeTexture; + }, + set: function (value) { + this._cubeTexture = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + AmbientEnvMapMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + stage.context.activateCubeTexture(methodVO.texturesIndex, this._cubeTexture); + }; + /** + * @inheritDoc + */ + AmbientEnvMapMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, regCache, sharedRegisters) { + var code = ""; + var ambientInputRegister; + var cubeMapReg = regCache.getFreeTextureReg(); + methodVO.texturesIndex = cubeMapReg.index; + code += ShaderCompilerHelper.getTexCubeSampleCode(targetReg, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, sharedRegisters.normalFragment); + ambientInputRegister = regCache.getFreeFragmentConstant(); + methodVO.fragmentConstantsIndex = ambientInputRegister.index; + code += "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + ambientInputRegister + ".xyz\n"; + return code; + }; + return AmbientEnvMapMethod; +})(AmbientBasicMethod); +module.exports = AmbientEnvMapMethod; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/materials/methods/AmbientEnvMapMethod.ts b/lib/materials/methods/AmbientEnvMapMethod.ts new file mode 100644 index 000000000..7090ece2b --- /dev/null +++ b/lib/materials/methods/AmbientEnvMapMethod.ts @@ -0,0 +1,86 @@ +import CubeTextureBase = require("awayjs-core/lib/textures/CubeTextureBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import AmbientBasicMethod = require("awayjs-stagegl/lib/materials/methods/AmbientBasicMethod"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * AmbientEnvMapMethod provides a diffuse shading method that uses a diffuse irradiance environment map to + * approximate global lighting rather than lights. + */ +class AmbientEnvMapMethod extends AmbientBasicMethod +{ + private _cubeTexture:CubeTextureBase; + + /** + * Creates a new AmbientEnvMapMethod object. + * + * @param envMap The cube environment map to use for the ambient lighting. + */ + constructor(envMap:CubeTextureBase) + { + super(); + this._cubeTexture = envMap; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + super.iInitVO(shaderObject, methodVO); + + methodVO.needsNormals = true; + } + + /** + * The cube environment map to use for the diffuse lighting. + */ + public get envMap():CubeTextureBase + { + return this._cubeTexture; + } + + public set envMap(value:CubeTextureBase) + { + this._cubeTexture = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + ( stage.context).activateCubeTexture(methodVO.texturesIndex, this._cubeTexture); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var ambientInputRegister:ShaderRegisterElement; + var cubeMapReg:ShaderRegisterElement = regCache.getFreeTextureReg(); + methodVO.texturesIndex = cubeMapReg.index; + + code += ShaderCompilerHelper.getTexCubeSampleCode(targetReg, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, sharedRegisters.normalFragment); + + ambientInputRegister = regCache.getFreeFragmentConstant(); + methodVO.fragmentConstantsIndex = ambientInputRegister.index; + + code += "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + ambientInputRegister + ".xyz\n"; + + return code; + } +} + +export = AmbientEnvMapMethod; \ No newline at end of file diff --git a/lib/materials/methods/DiffuseCelMethod.js b/lib/materials/methods/DiffuseCelMethod.js new file mode 100755 index 000000000..4905b6bc3 --- /dev/null +++ b/lib/materials/methods/DiffuseCelMethod.js @@ -0,0 +1,103 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DiffuseCompositeMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod"); +/** + * DiffuseCelMethod provides a shading method to add diffuse cel (cartoon) shading. + */ +var DiffuseCelMethod = (function (_super) { + __extends(DiffuseCelMethod, _super); + /** + * Creates a new DiffuseCelMethod object. + * @param levels The amount of shadow gradations. + * @param baseMethod An optional diffuse method on which the cartoon shading is based. If omitted, DiffuseBasicMethod is used. + */ + function DiffuseCelMethod(levels, baseMethod) { + var _this = this; + if (levels === void 0) { levels = 3; } + if (baseMethod === void 0) { baseMethod = null; } + _super.call(this, null, baseMethod); + this._smoothness = .1; + this.baseMethod._iModulateMethod = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { return _this.clampDiffuse(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); }; + this._levels = levels; + } + /** + * @inheritDoc + */ + DiffuseCelMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var data = shaderObject.fragmentConstantData; + var index = methodVO.secondaryFragmentConstantsIndex; + _super.prototype.iInitConstants.call(this, shaderObject, methodVO); + data[index + 1] = 1; + data[index + 2] = 0; + }; + Object.defineProperty(DiffuseCelMethod.prototype, "levels", { + /** + * The amount of shadow gradations. + */ + get: function () { + return this._levels; + }, + set: function (value /*uint*/) { + this._levels = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DiffuseCelMethod.prototype, "smoothness", { + /** + * The smoothness of the edge between 2 shading levels. + */ + get: function () { + return this._smoothness; + }, + set: function (value) { + this._smoothness = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + DiffuseCelMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._dataReg = null; + }; + /** + * @inheritDoc + */ + DiffuseCelMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + this._dataReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._dataReg.index * 4; + return _super.prototype.iGetFragmentPreLightingCode.call(this, shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + DiffuseCelMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var data = shaderObject.fragmentConstantData; + var index = methodVO.secondaryFragmentConstantsIndex; + data[index] = this._levels; + data[index + 3] = this._smoothness; + }; + /** + * Snaps the diffuse shading of the wrapped method to one of the levels. + * @param vo The MethodVO used to compile the current shader. + * @param t The register containing the diffuse strength in the "w" component. + * @param regCache The register cache used for the shader compilation. + * @param sharedRegisters The shared register data for this shader. + * @return The AGAL fragment code for the method. + */ + DiffuseCelMethod.prototype.clampDiffuse = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + return "mul " + targetReg + ".w, " + targetReg + ".w, " + this._dataReg + ".x\n" + "frc " + targetReg + ".z, " + targetReg + ".w\n" + "sub " + targetReg + ".y, " + targetReg + ".w, " + targetReg + ".z\n" + "mov " + targetReg + ".x, " + this._dataReg + ".x\n" + "sub " + targetReg + ".x, " + targetReg + ".x, " + this._dataReg + ".y\n" + "rcp " + targetReg + ".x," + targetReg + ".x\n" + "mul " + targetReg + ".w, " + targetReg + ".y, " + targetReg + ".x\n" + "sub " + targetReg + ".y, " + targetReg + ".w, " + targetReg + ".x\n" + "div " + targetReg + ".z, " + targetReg + ".z, " + this._dataReg + ".w\n" + "sat " + targetReg + ".z, " + targetReg + ".z\n" + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".z\n" + "sub " + targetReg + ".z, " + this._dataReg + ".y, " + targetReg + ".z\n" + "mul " + targetReg + ".y, " + targetReg + ".y, " + targetReg + ".z\n" + "add " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n" + "sat " + targetReg + ".w, " + targetReg + ".w\n"; + }; + return DiffuseCelMethod; +})(DiffuseCompositeMethod); +module.exports = DiffuseCelMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/diffusecelmethod.ts"],"names":["DiffuseCelMethod","DiffuseCelMethod.constructor","DiffuseCelMethod.iInitConstants","DiffuseCelMethod.levels","DiffuseCelMethod.smoothness","DiffuseCelMethod.iCleanCompilationData","DiffuseCelMethod.iGetFragmentPreLightingCode","DiffuseCelMethod.iActivate","DiffuseCelMethod.clampDiffuse"],"mappings":"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","file":"materials/methods/DiffuseCelMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport DiffuseBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\nimport DiffuseCompositeMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod\");\n\n/**\n * DiffuseCelMethod provides a shading method to add diffuse cel (cartoon) shading.\n */\nclass DiffuseCelMethod extends DiffuseCompositeMethod\n{\n\tprivate _levels:number /*uint*/;\n\tprivate _dataReg:ShaderRegisterElement;\n\tprivate _smoothness:number = .1;\n\n\t/**\n\t * Creates a new DiffuseCelMethod object.\n\t * @param levels The amount of shadow gradations.\n\t * @param baseMethod An optional diffuse method on which the cartoon shading is based. If omitted, DiffuseBasicMethod is used.\n\t */\n\tconstructor(levels:number /*uint*/ = 3, baseMethod:DiffuseBasicMethod = null)\n\t{\n\t\tsuper(null, baseMethod);\n\n\t\tthis.baseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.clampDiffuse(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\n\t\tthis._levels = levels;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tsuper.iInitConstants(shaderObject, methodVO);\n\t\tdata[index + 1] = 1;\n\t\tdata[index + 2] = 0;\n\t}\n\n\t/**\n\t * The amount of shadow gradations.\n\t */\n\tpublic get levels():number /*uint*/\n\t{\n\t\treturn this._levels;\n\t}\n\n\tpublic set levels(value:number /*uint*/)\n\t{\n\t\tthis._levels = value;\n\t}\n\n\t/**\n\t * The smoothness of the edge between 2 shading levels.\n\t */\n\tpublic get smoothness():number\n\t{\n\t\treturn this._smoothness;\n\t}\n\n\tpublic set smoothness(value:number)\n\t{\n\t\tthis._smoothness = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._dataReg = null;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tthis._dataReg = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.secondaryFragmentConstantsIndex = this._dataReg.index*4;\n\n\t\treturn super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tdata[index] = this._levels;\n\t\tdata[index + 3] = this._smoothness;\n\t}\n\n\t/**\n\t * Snaps the diffuse shading of the wrapped method to one of the levels.\n\t * @param vo The MethodVO used to compile the current shader.\n\t * @param t The register containing the diffuse strength in the \"w\" component.\n\t * @param regCache The register cache used for the shader compilation.\n\t * @param sharedRegisters The shared register data for this shader.\n\t * @return The AGAL fragment code for the method.\n\t */\n\tprivate clampDiffuse(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn \"mul \" + targetReg + \".w, \" + targetReg + \".w, \" + this._dataReg + \".x\\n\" +\n\t\t\t\"frc \" + targetReg + \".z, \" + targetReg + \".w\\n\" +\n\t\t\t\"sub \" + targetReg + \".y, \" + targetReg + \".w, \" + targetReg + \".z\\n\" +\n\t\t\t\"mov \" + targetReg + \".x, \" + this._dataReg + \".x\\n\" +\n\t\t\t\"sub \" + targetReg + \".x, \" + targetReg + \".x, \" + this._dataReg + \".y\\n\" +\n\t\t\t\"rcp \" + targetReg + \".x,\" + targetReg + \".x\\n\" +\n\t\t\t\"mul \" + targetReg + \".w, \" + targetReg + \".y, \" + targetReg + \".x\\n\" +\n\n\t\t\t// previous clamped strength\n\t\t\t\"sub \" + targetReg + \".y, \" + targetReg + \".w, \" + targetReg + \".x\\n\" +\n\n\t\t\t// fract/epsilon (so 0 - epsilon will become 0 - 1)\n\t\t\t\"div \" + targetReg + \".z, \" + targetReg + \".z, \" + this._dataReg + \".w\\n\" +\n\t\t\t\"sat \" + targetReg + \".z, \" + targetReg + \".z\\n\" +\n\n\t\t\t\"mul \" + targetReg + \".w, \" + targetReg + \".w, \" + targetReg + \".z\\n\" +\n\t\t\t// 1-z\n\t\t\t\"sub \" + targetReg + \".z, \" + this._dataReg + \".y, \" + targetReg + \".z\\n\" +\n\t\t\t\"mul \" + targetReg + \".y, \" + targetReg + \".y, \" + targetReg + \".z\\n\" +\n\t\t\t\"add \" + targetReg + \".w, \" + targetReg + \".w, \" + targetReg + \".y\\n\" +\n\t\t\t\"sat \" + targetReg + \".w, \" + targetReg + \".w\\n\";\n\t}\n}\n\nexport = DiffuseCelMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/DiffuseCelMethod.ts b/lib/materials/methods/DiffuseCelMethod.ts new file mode 100644 index 000000000..64f2dc654 --- /dev/null +++ b/lib/materials/methods/DiffuseCelMethod.ts @@ -0,0 +1,141 @@ +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +import DiffuseCompositeMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod"); + +/** + * DiffuseCelMethod provides a shading method to add diffuse cel (cartoon) shading. + */ +class DiffuseCelMethod extends DiffuseCompositeMethod +{ + private _levels:number /*uint*/; + private _dataReg:ShaderRegisterElement; + private _smoothness:number = .1; + + /** + * Creates a new DiffuseCelMethod object. + * @param levels The amount of shadow gradations. + * @param baseMethod An optional diffuse method on which the cartoon shading is based. If omitted, DiffuseBasicMethod is used. + */ + constructor(levels:number /*uint*/ = 3, baseMethod:DiffuseBasicMethod = null) + { + super(null, baseMethod); + + this.baseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.clampDiffuse(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + + this._levels = levels; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + var data:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + super.iInitConstants(shaderObject, methodVO); + data[index + 1] = 1; + data[index + 2] = 0; + } + + /** + * The amount of shadow gradations. + */ + public get levels():number /*uint*/ + { + return this._levels; + } + + public set levels(value:number /*uint*/) + { + this._levels = value; + } + + /** + * The smoothness of the edge between 2 shading levels. + */ + public get smoothness():number + { + return this._smoothness; + } + + public set smoothness(value:number) + { + this._smoothness = value; + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._dataReg = null; + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + this._dataReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._dataReg.index*4; + + return super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + var data:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + data[index] = this._levels; + data[index + 3] = this._smoothness; + } + + /** + * Snaps the diffuse shading of the wrapped method to one of the levels. + * @param vo The MethodVO used to compile the current shader. + * @param t The register containing the diffuse strength in the "w" component. + * @param regCache The register cache used for the shader compilation. + * @param sharedRegisters The shared register data for this shader. + * @return The AGAL fragment code for the method. + */ + private clampDiffuse(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return "mul " + targetReg + ".w, " + targetReg + ".w, " + this._dataReg + ".x\n" + + "frc " + targetReg + ".z, " + targetReg + ".w\n" + + "sub " + targetReg + ".y, " + targetReg + ".w, " + targetReg + ".z\n" + + "mov " + targetReg + ".x, " + this._dataReg + ".x\n" + + "sub " + targetReg + ".x, " + targetReg + ".x, " + this._dataReg + ".y\n" + + "rcp " + targetReg + ".x," + targetReg + ".x\n" + + "mul " + targetReg + ".w, " + targetReg + ".y, " + targetReg + ".x\n" + + + // previous clamped strength + "sub " + targetReg + ".y, " + targetReg + ".w, " + targetReg + ".x\n" + + + // fract/epsilon (so 0 - epsilon will become 0 - 1) + "div " + targetReg + ".z, " + targetReg + ".z, " + this._dataReg + ".w\n" + + "sat " + targetReg + ".z, " + targetReg + ".z\n" + + + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".z\n" + + // 1-z + "sub " + targetReg + ".z, " + this._dataReg + ".y, " + targetReg + ".z\n" + + "mul " + targetReg + ".y, " + targetReg + ".y, " + targetReg + ".z\n" + + "add " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n" + + "sat " + targetReg + ".w, " + targetReg + ".w\n"; + } +} + +export = DiffuseCelMethod; \ No newline at end of file diff --git a/lib/materials/methods/DiffuseCompositeMethod.js b/lib/materials/methods/DiffuseCompositeMethod.js new file mode 100755 index 000000000..621096f87 --- /dev/null +++ b/lib/materials/methods/DiffuseCompositeMethod.js @@ -0,0 +1,190 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +var DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +/** + * DiffuseCompositeMethod provides a base class for diffuse methods that wrap a diffuse method to alter the + * calculated diffuse reflection strength. + */ +var DiffuseCompositeMethod = (function (_super) { + __extends(DiffuseCompositeMethod, _super); + /** + * Creates a new DiffuseCompositeMethod object. + * + * @param modulateMethod The method which will add the code to alter the base method's strength. It needs to have the signature clampDiffuse(t:ShaderRegisterElement, regCache:ShaderRegisterCache):string, in which t.w will contain the diffuse strength. + * @param baseMethod The base diffuse method on which this method's shading is based. + */ + function DiffuseCompositeMethod(modulateMethod, baseMethod) { + var _this = this; + if (baseMethod === void 0) { baseMethod = null; } + _super.call(this); + this._onShaderInvalidatedDelegate = function (event) { return _this.onShaderInvalidated(event); }; + this.pBaseMethod = baseMethod || new DiffuseBasicMethod(); + this.pBaseMethod._iModulateMethod = modulateMethod; + this.pBaseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + } + Object.defineProperty(DiffuseCompositeMethod.prototype, "baseMethod", { + /** + * The base diffuse method on which this method's shading is based. + */ + get: function () { + return this.pBaseMethod; + }, + set: function (value) { + if (this.pBaseMethod == value) + return; + this.pBaseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.pBaseMethod = value; + this.pBaseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iInitVO = function (shaderObject, methodVO) { + this.pBaseMethod.iInitVO(shaderObject, methodVO); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + this.pBaseMethod.iInitConstants(shaderObject, methodVO); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.dispose = function () { + this.pBaseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.pBaseMethod.dispose(); + }; + Object.defineProperty(DiffuseCompositeMethod.prototype, "texture", { + /** + * @inheritDoc + */ + get: function () { + return this.pBaseMethod.texture; + }, + /** + * @inheritDoc + */ + set: function (value) { + this.pBaseMethod.texture = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DiffuseCompositeMethod.prototype, "diffuseColor", { + /** + * @inheritDoc + */ + get: function () { + return this.pBaseMethod.diffuseColor; + }, + /** + * @inheritDoc + */ + set: function (value) { + this.pBaseMethod.diffuseColor = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DiffuseCompositeMethod.prototype, "ambientColor", { + /** + * @inheritDoc + */ + get: function () { + return this.pBaseMethod.ambientColor; + }, + /** + * @inheritDoc + */ + set: function (value) { + this.pBaseMethod.ambientColor = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + return this.pBaseMethod.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iGetFragmentCodePerLight = function (shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters) { + var code = this.pBaseMethod.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters); + this._pTotalLightColorReg = this.pBaseMethod._pTotalLightColorReg; + return code; + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iGetFragmentCodePerProbe = function (shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters) { + var code = this.pBaseMethod.iGetFragmentCodePerProbe(shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters); + this._pTotalLightColorReg = this.pBaseMethod._pTotalLightColorReg; + return code; + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + this.pBaseMethod.iActivate(shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iSetRenderState = function (shaderObject, methodVO, renderable, stage, camera) { + this.pBaseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iDeactivate = function (shaderObject, methodVO, stage) { + this.pBaseMethod.iDeactivate(shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iGetVertexCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + return this.pBaseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iGetFragmentPostLightingCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + return this.pBaseMethod.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iReset = function () { + this.pBaseMethod.iReset(); + }; + /** + * @inheritDoc + */ + DiffuseCompositeMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this.pBaseMethod.iCleanCompilationData(); + }; + /** + * Called when the base method's shader code is invalidated. + */ + DiffuseCompositeMethod.prototype.onShaderInvalidated = function (event) { + this.iInvalidateShaderProgram(); + }; + return DiffuseCompositeMethod; +})(DiffuseBasicMethod); +module.exports = DiffuseCompositeMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/diffusecompositemethod.ts"],"names":["DiffuseCompositeMethod","DiffuseCompositeMethod.constructor","DiffuseCompositeMethod.baseMethod","DiffuseCompositeMethod.iInitVO","DiffuseCompositeMethod.iInitConstants","DiffuseCompositeMethod.dispose","DiffuseCompositeMethod.texture","DiffuseCompositeMethod.diffuseColor","DiffuseCompositeMethod.ambientColor","DiffuseCompositeMethod.iGetFragmentPreLightingCode","DiffuseCompositeMethod.iGetFragmentCodePerLight","DiffuseCompositeMethod.iGetFragmentCodePerProbe","DiffuseCompositeMethod.iActivate","DiffuseCompositeMethod.iSetRenderState","DiffuseCompositeMethod.iDeactivate","DiffuseCompositeMethod.iGetVertexCode","DiffuseCompositeMethod.iGetFragmentPostLightingCode","DiffuseCompositeMethod.iReset","DiffuseCompositeMethod.iCleanCompilationData","DiffuseCompositeMethod.onShaderInvalidated"],"mappings":"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","file":"materials/methods/DiffuseCompositeMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ShadingMethodEvent\t\t\t\t= require(\"awayjs-stagegl/lib/events/ShadingMethodEvent\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport DiffuseBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod\");\n\n/**\n * DiffuseCompositeMethod provides a base class for diffuse methods that wrap a diffuse method to alter the\n * calculated diffuse reflection strength.\n */\nclass DiffuseCompositeMethod extends DiffuseBasicMethod\n{\n\tpublic pBaseMethod:DiffuseBasicMethod;\n\n\tprivate _onShaderInvalidatedDelegate:Function;\n\n\t/**\n\t * Creates a new <code>DiffuseCompositeMethod</code> object.\n\t *\n\t * @param modulateMethod The method which will add the code to alter the base method's strength. It needs to have the signature clampDiffuse(t:ShaderRegisterElement, regCache:ShaderRegisterCache):string, in which t.w will contain the diffuse strength.\n\t * @param baseMethod The base diffuse method on which this method's shading is based.\n\t */\n\tconstructor(modulateMethod:(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => string, baseMethod:DiffuseBasicMethod = null)\n\t{\n\t\tsuper();\n\n\t\tthis._onShaderInvalidatedDelegate = (event:ShadingMethodEvent) => this.onShaderInvalidated(event);\n\n\t\tthis.pBaseMethod = baseMethod || new DiffuseBasicMethod();\n\t\tthis.pBaseMethod._iModulateMethod = modulateMethod;\n\t\tthis.pBaseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t}\n\n\t/**\n\t * The base diffuse method on which this method's shading is based.\n\t */\n\tpublic get baseMethod():DiffuseBasicMethod\n\t{\n\t\treturn this.pBaseMethod;\n\t}\n\n\tpublic set baseMethod(value:DiffuseBasicMethod)\n\t{\n\t\tif (this.pBaseMethod == value)\n\t\t\treturn;\n\n\t\tthis.pBaseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t\tthis.pBaseMethod = value;\n\t\tthis.pBaseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tthis.pBaseMethod.iInitVO(shaderObject, methodVO);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tthis.pBaseMethod.iInitConstants(shaderObject, methodVO);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t\tthis.pBaseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t\tthis.pBaseMethod.dispose();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get texture():Texture2DBase\n\t{\n\t\treturn this.pBaseMethod.texture;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic set texture(value:Texture2DBase)\n\t{\n\t\tthis.pBaseMethod.texture = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get diffuseColor():number\n\t{\n\t\treturn this.pBaseMethod.diffuseColor;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic set diffuseColor(value:number)\n\t{\n\t\tthis.pBaseMethod.diffuseColor = value;\n\t}\n\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get ambientColor():number\n\t{\n\t\treturn this.pBaseMethod.ambientColor;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic set ambientColor(value:number)\n\t{\n\t\tthis.pBaseMethod.ambientColor = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this.pBaseMethod.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = this.pBaseMethod.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters);\n\t\tthis._pTotalLightColorReg = this.pBaseMethod._pTotalLightColorReg;\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerProbe(shaderObject:ShaderLightingObject, methodVO:MethodVO, cubeMapReg:ShaderRegisterElement, weightRegister:string, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = this.pBaseMethod.iGetFragmentCodePerProbe(shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters);\n\t\tthis._pTotalLightColorReg = this.pBaseMethod._pTotalLightColorReg;\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tthis.pBaseMethod.iActivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iSetRenderState(shaderObject:ShaderLightingObject, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera)\n\t{\n\t\tthis.pBaseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iDeactivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tthis.pBaseMethod.iDeactivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this.pBaseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this.pBaseMethod.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iReset()\n\t{\n\t\tthis.pBaseMethod.iReset();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis.pBaseMethod.iCleanCompilationData();\n\t}\n\n\t/**\n\t * Called when the base method's shader code is invalidated.\n\t */\n\tprivate onShaderInvalidated(event:ShadingMethodEvent)\n\t{\n\t\tthis.iInvalidateShaderProgram();\n\t}\n}\n\nexport = DiffuseCompositeMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/DiffuseCompositeMethod.ts b/lib/materials/methods/DiffuseCompositeMethod.ts new file mode 100755 index 000000000..32a3a1c0c --- /dev/null +++ b/lib/materials/methods/DiffuseCompositeMethod.ts @@ -0,0 +1,229 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); + +/** + * DiffuseCompositeMethod provides a base class for diffuse methods that wrap a diffuse method to alter the + * calculated diffuse reflection strength. + */ +class DiffuseCompositeMethod extends DiffuseBasicMethod +{ + public pBaseMethod:DiffuseBasicMethod; + + private _onShaderInvalidatedDelegate:Function; + + /** + * Creates a new DiffuseCompositeMethod object. + * + * @param modulateMethod The method which will add the code to alter the base method's strength. It needs to have the signature clampDiffuse(t:ShaderRegisterElement, regCache:ShaderRegisterCache):string, in which t.w will contain the diffuse strength. + * @param baseMethod The base diffuse method on which this method's shading is based. + */ + constructor(modulateMethod:(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => string, baseMethod:DiffuseBasicMethod = null) + { + super(); + + this._onShaderInvalidatedDelegate = (event:ShadingMethodEvent) => this.onShaderInvalidated(event); + + this.pBaseMethod = baseMethod || new DiffuseBasicMethod(); + this.pBaseMethod._iModulateMethod = modulateMethod; + this.pBaseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + } + + /** + * The base diffuse method on which this method's shading is based. + */ + public get baseMethod():DiffuseBasicMethod + { + return this.pBaseMethod; + } + + public set baseMethod(value:DiffuseBasicMethod) + { + if (this.pBaseMethod == value) + return; + + this.pBaseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.pBaseMethod = value; + this.pBaseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.iInvalidateShaderProgram(); + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + this.pBaseMethod.iInitVO(shaderObject, methodVO); + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + this.pBaseMethod.iInitConstants(shaderObject, methodVO); + } + + /** + * @inheritDoc + */ + public dispose() + { + this.pBaseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.pBaseMethod.dispose(); + } + + /** + * @inheritDoc + */ + public get texture():Texture2DBase + { + return this.pBaseMethod.texture; + } + + /** + * @inheritDoc + */ + public set texture(value:Texture2DBase) + { + this.pBaseMethod.texture = value; + } + + /** + * @inheritDoc + */ + public get diffuseColor():number + { + return this.pBaseMethod.diffuseColor; + } + + /** + * @inheritDoc + */ + public set diffuseColor(value:number) + { + this.pBaseMethod.diffuseColor = value; + } + + + /** + * @inheritDoc + */ + public get ambientColor():number + { + return this.pBaseMethod.ambientColor; + } + + /** + * @inheritDoc + */ + public set ambientColor(value:number) + { + this.pBaseMethod.ambientColor = value; + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this.pBaseMethod.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = this.pBaseMethod.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters); + this._pTotalLightColorReg = this.pBaseMethod._pTotalLightColorReg; + return code; + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerProbe(shaderObject:ShaderLightingObject, methodVO:MethodVO, cubeMapReg:ShaderRegisterElement, weightRegister:string, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = this.pBaseMethod.iGetFragmentCodePerProbe(shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters); + this._pTotalLightColorReg = this.pBaseMethod._pTotalLightColorReg; + return code; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + this.pBaseMethod.iActivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iSetRenderState(shaderObject:ShaderLightingObject, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera) + { + this.pBaseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera); + } + + /** + * @inheritDoc + */ + public iDeactivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + this.pBaseMethod.iDeactivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this.pBaseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this.pBaseMethod.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iReset() + { + this.pBaseMethod.iReset(); + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this.pBaseMethod.iCleanCompilationData(); + } + + /** + * Called when the base method's shader code is invalidated. + */ + private onShaderInvalidated(event:ShadingMethodEvent) + { + this.iInvalidateShaderProgram(); + } +} + +export = DiffuseCompositeMethod; \ No newline at end of file diff --git a/lib/materials/methods/DiffuseDepthMethod.js b/lib/materials/methods/DiffuseDepthMethod.js new file mode 100755 index 000000000..330041fa5 --- /dev/null +++ b/lib/materials/methods/DiffuseDepthMethod.js @@ -0,0 +1,62 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * DiffuseDepthMethod provides a debug method to visualise depth maps + */ +var DiffuseDepthMethod = (function (_super) { + __extends(DiffuseDepthMethod, _super); + /** + * Creates a new DiffuseBasicMethod object. + */ + function DiffuseDepthMethod() { + _super.call(this); + } + /** + * @inheritDoc + */ + DiffuseDepthMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var data = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + data[index] = 1.0; + data[index + 1] = 1 / 255.0; + data[index + 2] = 1 / 65025.0; + data[index + 3] = 1 / 16581375.0; + }; + /** + * @inheritDoc + */ + DiffuseDepthMethod.prototype.iGetFragmentPostLightingCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var code = ""; + var temp; + var decReg; + if (!this._pUseTexture) + throw new Error("DiffuseDepthMethod requires texture!"); + // incorporate input from ambient + if (shaderObject.numLights > 0) { + if (sharedRegisters.shadowTarget) + code += "mul " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + sharedRegisters.shadowTarget + ".w\n"; + code += "add " + targetReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + targetReg + ".xyz\n" + "sat " + targetReg + ".xyz, " + targetReg + ".xyz\n"; + registerCache.removeFragmentTempUsage(this._pTotalLightColorReg); + } + temp = shaderObject.numLights > 0 ? registerCache.getFreeFragmentVectorTemp() : targetReg; + this._pDiffuseInputRegister = registerCache.getFreeTextureReg(); + methodVO.texturesIndex = this._pDiffuseInputRegister.index; + decReg = registerCache.getFreeFragmentConstant(); + methodVO.fragmentConstantsIndex = decReg.index * 4; + code += ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pDiffuseInputRegister, this.texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) + "dp4 " + temp + ".x, " + temp + ", " + decReg + "\n" + "mov " + temp + ".yz, " + temp + ".xx \n" + "mov " + temp + ".w, " + decReg + ".x\n" + "sub " + temp + ".xyz, " + decReg + ".xxx, " + temp + ".xyz\n"; + if (shaderObject.numLights == 0) + return code; + code += "mul " + targetReg + ".xyz, " + temp + ".xyz, " + targetReg + ".xyz\n" + "mov " + targetReg + ".w, " + temp + ".w\n"; + return code; + }; + return DiffuseDepthMethod; +})(DiffuseBasicMethod); +module.exports = DiffuseDepthMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/diffusedepthmethod.ts"],"names":["DiffuseDepthMethod","DiffuseDepthMethod.constructor","DiffuseDepthMethod.iInitConstants","DiffuseDepthMethod.iGetFragmentPostLightingCode"],"mappings":"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","file":"materials/methods/DiffuseDepthMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport DiffuseBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * DiffuseDepthMethod provides a debug method to visualise depth maps\n */\nclass DiffuseDepthMethod extends DiffuseBasicMethod\n{\n\t/**\n\t * Creates a new DiffuseBasicMethod object.\n\t */\n\tconstructor()\n\t{\n\t\tsuper();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tdata[index] = 1.0;\n\t\tdata[index + 1] = 1/255.0;\n\t\tdata[index + 2] = 1/65025.0;\n\t\tdata[index + 3] = 1/16581375.0;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar temp:ShaderRegisterElement;\n\t\tvar decReg:ShaderRegisterElement;\n\n\t\tif (!this._pUseTexture)\n\t\t\tthrow new Error(\"DiffuseDepthMethod requires texture!\");\n\n\t\t// incorporate input from ambient\n\t\tif (shaderObject.numLights > 0) {\n\t\t\tif (sharedRegisters.shadowTarget)\n\t\t\t\tcode += \"mul \" + this._pTotalLightColorReg + \".xyz, \" + this._pTotalLightColorReg + \".xyz, \" + sharedRegisters.shadowTarget + \".w\\n\";\n\t\t\tcode += \"add \" + targetReg + \".xyz, \" + this._pTotalLightColorReg + \".xyz, \" + targetReg + \".xyz\\n\" +\n\t\t\t\t\"sat \" + targetReg + \".xyz, \" + targetReg + \".xyz\\n\";\n\t\t\tregisterCache.removeFragmentTempUsage(this._pTotalLightColorReg);\n\t\t}\n\n\t\ttemp = shaderObject.numLights > 0? registerCache.getFreeFragmentVectorTemp():targetReg;\n\n\t\tthis._pDiffuseInputRegister = registerCache.getFreeTextureReg();\n\t\tmethodVO.texturesIndex = this._pDiffuseInputRegister.index;\n\t\tdecReg = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.fragmentConstantsIndex = decReg.index*4;\n\t\tcode += ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pDiffuseInputRegister, this.texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) +\n\t\t\t\"dp4 \" + temp + \".x, \" + temp + \", \" + decReg + \"\\n\" +\n\t\t\t\"mov \" + temp + \".yz, \" + temp + \".xx\t\t\t\\n\" +\n\t\t\t\"mov \" + temp + \".w, \" + decReg + \".x\\n\" +\n\t\t\t\"sub \" + temp + \".xyz, \" + decReg + \".xxx, \" + temp + \".xyz\\n\";\n\n\t\tif (shaderObject.numLights == 0)\n\t\t\treturn code;\n\n\t\tcode += \"mul \" + targetReg + \".xyz, \" + temp + \".xyz, \" + targetReg + \".xyz\\n\" +\n\t\t\t\"mov \" + targetReg + \".w, \" + temp + \".w\\n\";\n\n\t\treturn code;\n\t}\n}\n\nexport = DiffuseDepthMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/DiffuseDepthMethod.ts b/lib/materials/methods/DiffuseDepthMethod.ts new file mode 100644 index 000000000..513a7a50a --- /dev/null +++ b/lib/materials/methods/DiffuseDepthMethod.ts @@ -0,0 +1,79 @@ +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * DiffuseDepthMethod provides a debug method to visualise depth maps + */ +class DiffuseDepthMethod extends DiffuseBasicMethod +{ + /** + * Creates a new DiffuseBasicMethod object. + */ + constructor() + { + super(); + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + var data:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + data[index] = 1.0; + data[index + 1] = 1/255.0; + data[index + 2] = 1/65025.0; + data[index + 3] = 1/16581375.0; + } + + /** + * @inheritDoc + */ + public iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var temp:ShaderRegisterElement; + var decReg:ShaderRegisterElement; + + if (!this._pUseTexture) + throw new Error("DiffuseDepthMethod requires texture!"); + + // incorporate input from ambient + if (shaderObject.numLights > 0) { + if (sharedRegisters.shadowTarget) + code += "mul " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + sharedRegisters.shadowTarget + ".w\n"; + code += "add " + targetReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + targetReg + ".xyz\n" + + "sat " + targetReg + ".xyz, " + targetReg + ".xyz\n"; + registerCache.removeFragmentTempUsage(this._pTotalLightColorReg); + } + + temp = shaderObject.numLights > 0? registerCache.getFreeFragmentVectorTemp():targetReg; + + this._pDiffuseInputRegister = registerCache.getFreeTextureReg(); + methodVO.texturesIndex = this._pDiffuseInputRegister.index; + decReg = registerCache.getFreeFragmentConstant(); + methodVO.fragmentConstantsIndex = decReg.index*4; + code += ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pDiffuseInputRegister, this.texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) + + "dp4 " + temp + ".x, " + temp + ", " + decReg + "\n" + + "mov " + temp + ".yz, " + temp + ".xx \n" + + "mov " + temp + ".w, " + decReg + ".x\n" + + "sub " + temp + ".xyz, " + decReg + ".xxx, " + temp + ".xyz\n"; + + if (shaderObject.numLights == 0) + return code; + + code += "mul " + targetReg + ".xyz, " + temp + ".xyz, " + targetReg + ".xyz\n" + + "mov " + targetReg + ".w, " + temp + ".w\n"; + + return code; + } +} + +export = DiffuseDepthMethod; \ No newline at end of file diff --git a/lib/materials/methods/DiffuseGradientMethod.js b/lib/materials/methods/DiffuseGradientMethod.js new file mode 100755 index 000000000..1a5dc15da --- /dev/null +++ b/lib/materials/methods/DiffuseGradientMethod.js @@ -0,0 +1,103 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * DiffuseGradientMethod is an alternative to DiffuseBasicMethod in which the shading can be modulated with a gradient + * to introduce color-tinted shading as opposed to the single-channel diffuse strength. This can be used as a crude + * approximation to subsurface scattering (for instance, the mid-range shading for skin can be tinted red to similate + * scattered light within the skin attributing to the final colour) + */ +var DiffuseGradientMethod = (function (_super) { + __extends(DiffuseGradientMethod, _super); + /** + * Creates a new DiffuseGradientMethod object. + * @param gradient A texture that contains the light colour based on the angle. This can be used to change + * the light colour due to subsurface scattering when the surface faces away from the light. + */ + function DiffuseGradientMethod(gradient) { + _super.call(this); + this._gradient = gradient; + } + Object.defineProperty(DiffuseGradientMethod.prototype, "gradient", { + /** + * A texture that contains the light colour based on the angle. This can be used to change the light colour + * due to subsurface scattering when the surface faces away from the light. + */ + get: function () { + return this._gradient; + }, + set: function (value) { + if (value.hasMipmaps != this._gradient.hasMipmaps || value.format != this._gradient.format) + this.iInvalidateShaderProgram(); + this._gradient = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + DiffuseGradientMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._gradientTextureRegister = null; + }; + /** + * @inheritDoc + */ + DiffuseGradientMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + var code = _super.prototype.iGetFragmentPreLightingCode.call(this, shaderObject, methodVO, registerCache, sharedRegisters); + this._pIsFirstLight = true; + if (shaderObject.numLights > 0) { + this._gradientTextureRegister = registerCache.getFreeTextureReg(); + methodVO.secondaryTexturesIndex = this._gradientTextureRegister.index; + } + return code; + }; + /** + * @inheritDoc + */ + DiffuseGradientMethod.prototype.iGetFragmentCodePerLight = function (shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters) { + var code = ""; + var t; + // write in temporary if not first light, so we can add to total diffuse colour + if (this._pIsFirstLight) + t = this._pTotalLightColorReg; + else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + code += "dp3 " + t + ".w, " + lightDirReg + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + "mul " + t + ".w, " + t + ".w, " + sharedRegisters.commons + ".x\n" + "add " + t + ".w, " + t + ".w, " + sharedRegisters.commons + ".x\n" + "mul " + t + ".xyz, " + t + ".w, " + lightDirReg + ".w\n"; + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters); + code += ShaderCompilerHelper.getTex2DSampleCode(t, sharedRegisters, this._gradientTextureRegister, this._gradient, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, t, "clamp") + "mul " + t + ".xyz, " + t + ".xyz, " + lightColReg + ".xyz\n"; + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + this._pIsFirstLight = false; + return code; + }; + /** + * @inheritDoc + */ + DiffuseGradientMethod.prototype.pApplyShadow = function (shaderObject, methodVO, regCache, sharedRegisters) { + var t = regCache.getFreeFragmentVectorTemp(); + return "mov " + t + ", " + sharedRegisters.shadowTarget + ".wwww\n" + ShaderCompilerHelper.getTex2DSampleCode(t, sharedRegisters, this._gradientTextureRegister, this._gradient, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, t, "clamp") + "mul " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ", " + t + "\n"; + }; + /** + * @inheritDoc + */ + DiffuseGradientMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + stage.context.activateTexture(methodVO.secondaryTexturesIndex, this._gradient); + }; + return DiffuseGradientMethod; +})(DiffuseBasicMethod); +module.exports = DiffuseGradientMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/diffusegradientmethod.ts"],"names":["DiffuseGradientMethod","DiffuseGradientMethod.constructor","DiffuseGradientMethod.gradient","DiffuseGradientMethod.iCleanCompilationData","DiffuseGradientMethod.iGetFragmentPreLightingCode","DiffuseGradientMethod.iGetFragmentCodePerLight","DiffuseGradientMethod.pApplyShadow","DiffuseGradientMethod.iActivate"],"mappings":"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","file":"materials/methods/DiffuseGradientMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport DiffuseBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * DiffuseGradientMethod is an alternative to DiffuseBasicMethod in which the shading can be modulated with a gradient\n * to introduce color-tinted shading as opposed to the single-channel diffuse strength. This can be used as a crude\n * approximation to subsurface scattering (for instance, the mid-range shading for skin can be tinted red to similate\n * scattered light within the skin attributing to the final colour)\n */\nclass DiffuseGradientMethod extends DiffuseBasicMethod\n{\n\tprivate _gradientTextureRegister:ShaderRegisterElement;\n\tprivate _gradient:Texture2DBase;\n\n\t/**\n\t * Creates a new DiffuseGradientMethod object.\n\t * @param gradient A texture that contains the light colour based on the angle. This can be used to change\n\t * the light colour due to subsurface scattering when the surface faces away from the light.\n\t */\n\tconstructor(gradient:Texture2DBase)\n\t{\n\t\tsuper();\n\n\t\tthis._gradient = gradient;\n\t}\n\n\t/**\n\t * A texture that contains the light colour based on the angle. This can be used to change the light colour\n\t * due to subsurface scattering when the surface faces away from the light.\n\t */\n\tpublic get gradient():Texture2DBase\n\t{\n\t\treturn this._gradient;\n\t}\n\n\tpublic set gradient(value:Texture2DBase)\n\t{\n\t\tif (value.hasMipmaps != this._gradient.hasMipmaps || value.format != this._gradient.format)\n\t\t\tthis.iInvalidateShaderProgram();\n\t\tthis._gradient = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._gradientTextureRegister = null;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t\tthis._pIsFirstLight = true;\n\n\t\tif (shaderObject.numLights > 0) {\n\t\t\tthis._gradientTextureRegister = registerCache.getFreeTextureReg();\n\t\t\tmethodVO.secondaryTexturesIndex = this._gradientTextureRegister.index;\n\t\t}\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar t:ShaderRegisterElement;\n\n\t\t// write in temporary if not first light, so we can add to total diffuse colour\n\t\tif (this._pIsFirstLight)\n\t\t\tt = this._pTotalLightColorReg;\n\t\telse {\n\t\t\tt = registerCache.getFreeFragmentVectorTemp();\n\t\t\tregisterCache.addFragmentTempUsages(t, 1);\n\t\t}\n\n\t\tcode += \"dp3 \" + t + \".w, \" + lightDirReg + \".xyz, \" + sharedRegisters.normalFragment + \".xyz\\n\" +\n\t\t\t\"mul \" + t + \".w, \" + t + \".w, \" + sharedRegisters.commons + \".x\\n\" +\n\t\t\t\"add \" + t + \".w, \" + t + \".w, \" + sharedRegisters.commons + \".x\\n\" +\n\t\t\t\"mul \" + t + \".xyz, \" + t + \".w, \" + lightDirReg + \".w\\n\";\n\n\t\tif (this._iModulateMethod != null)\n\t\t\tcode += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters);\n\n\t\tcode += ShaderCompilerHelper.getTex2DSampleCode(t, sharedRegisters, this._gradientTextureRegister, this._gradient, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, t, \"clamp\") +\n\t\t\t//\t\t\t\t\t\"mul \" + t + \".xyz, \" + t + \".xyz, \" + t + \".w\\n\" +\n\t\t\t\"mul \" + t + \".xyz, \" + t + \".xyz, \" + lightColReg + \".xyz\\n\";\n\n\t\tif (!this._pIsFirstLight) {\n\t\t\tcode += \"add \" + this._pTotalLightColorReg + \".xyz, \" + this._pTotalLightColorReg + \".xyz, \" + t + \".xyz\\n\";\n\t\t\tregisterCache.removeFragmentTempUsage(t);\n\t\t}\n\n\t\tthis._pIsFirstLight = false;\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic pApplyShadow(shaderObject:ShaderLightingObject, methodVO:MethodVO, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar t:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp();\n\n\t\treturn \"mov \" + t + \", \" + sharedRegisters.shadowTarget + \".wwww\\n\" +\n\t\t\tShaderCompilerHelper.getTex2DSampleCode(t, sharedRegisters, this._gradientTextureRegister, this._gradient, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, t, \"clamp\") +\n\t\t\t\"mul \" + this._pTotalLightColorReg + \".xyz, \" + this._pTotalLightColorReg + \", \" + t + \"\\n\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.secondaryTexturesIndex, this._gradient);\n\t}\n}\n\nexport = DiffuseGradientMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/DiffuseGradientMethod.ts b/lib/materials/methods/DiffuseGradientMethod.ts new file mode 100644 index 000000000..5c51f52e2 --- /dev/null +++ b/lib/materials/methods/DiffuseGradientMethod.ts @@ -0,0 +1,137 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * DiffuseGradientMethod is an alternative to DiffuseBasicMethod in which the shading can be modulated with a gradient + * to introduce color-tinted shading as opposed to the single-channel diffuse strength. This can be used as a crude + * approximation to subsurface scattering (for instance, the mid-range shading for skin can be tinted red to similate + * scattered light within the skin attributing to the final colour) + */ +class DiffuseGradientMethod extends DiffuseBasicMethod +{ + private _gradientTextureRegister:ShaderRegisterElement; + private _gradient:Texture2DBase; + + /** + * Creates a new DiffuseGradientMethod object. + * @param gradient A texture that contains the light colour based on the angle. This can be used to change + * the light colour due to subsurface scattering when the surface faces away from the light. + */ + constructor(gradient:Texture2DBase) + { + super(); + + this._gradient = gradient; + } + + /** + * A texture that contains the light colour based on the angle. This can be used to change the light colour + * due to subsurface scattering when the surface faces away from the light. + */ + public get gradient():Texture2DBase + { + return this._gradient; + } + + public set gradient(value:Texture2DBase) + { + if (value.hasMipmaps != this._gradient.hasMipmaps || value.format != this._gradient.format) + this.iInvalidateShaderProgram(); + this._gradient = value; + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._gradientTextureRegister = null; + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + this._pIsFirstLight = true; + + if (shaderObject.numLights > 0) { + this._gradientTextureRegister = registerCache.getFreeTextureReg(); + methodVO.secondaryTexturesIndex = this._gradientTextureRegister.index; + } + return code; + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var t:ShaderRegisterElement; + + // write in temporary if not first light, so we can add to total diffuse colour + if (this._pIsFirstLight) + t = this._pTotalLightColorReg; + else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + + code += "dp3 " + t + ".w, " + lightDirReg + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + + "mul " + t + ".w, " + t + ".w, " + sharedRegisters.commons + ".x\n" + + "add " + t + ".w, " + t + ".w, " + sharedRegisters.commons + ".x\n" + + "mul " + t + ".xyz, " + t + ".w, " + lightDirReg + ".w\n"; + + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters); + + code += ShaderCompilerHelper.getTex2DSampleCode(t, sharedRegisters, this._gradientTextureRegister, this._gradient, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, t, "clamp") + + // "mul " + t + ".xyz, " + t + ".xyz, " + t + ".w\n" + + "mul " + t + ".xyz, " + t + ".xyz, " + lightColReg + ".xyz\n"; + + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + + this._pIsFirstLight = false; + + return code; + } + + /** + * @inheritDoc + */ + public pApplyShadow(shaderObject:ShaderLightingObject, methodVO:MethodVO, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var t:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp(); + + return "mov " + t + ", " + sharedRegisters.shadowTarget + ".wwww\n" + + ShaderCompilerHelper.getTex2DSampleCode(t, sharedRegisters, this._gradientTextureRegister, this._gradient, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, t, "clamp") + + "mul " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ", " + t + "\n"; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + ( stage.context).activateTexture(methodVO.secondaryTexturesIndex, this._gradient); + } +} + +export = DiffuseGradientMethod; \ No newline at end of file diff --git a/lib/materials/methods/DiffuseLightMapMethod.js b/lib/materials/methods/DiffuseLightMapMethod.js new file mode 100755 index 000000000..8cccaeafe --- /dev/null +++ b/lib/materials/methods/DiffuseLightMapMethod.js @@ -0,0 +1,115 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +var DiffuseCompositeMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod"); +/** + * DiffuseLightMapMethod provides a diffuse shading method that uses a light map to modulate the calculated diffuse + * lighting. It is different from EffectLightMapMethod in that the latter modulates the entire calculated pixel color, rather + * than only the diffuse lighting value. + */ +var DiffuseLightMapMethod = (function (_super) { + __extends(DiffuseLightMapMethod, _super); + /** + * Creates a new DiffuseLightMapMethod method. + * + * @param lightMap The texture containing the light map. + * @param blendMode The blend mode with which the light map should be applied to the lighting result. + * @param useSecondaryUV Indicates whether the secondary UV set should be used to map the light map. + * @param baseMethod The diffuse method used to calculate the regular diffuse-based lighting. + */ + function DiffuseLightMapMethod(lightMap, blendMode, useSecondaryUV, baseMethod) { + if (blendMode === void 0) { blendMode = "multiply"; } + if (useSecondaryUV === void 0) { useSecondaryUV = false; } + if (baseMethod === void 0) { baseMethod = null; } + _super.call(this, null, baseMethod); + this._useSecondaryUV = useSecondaryUV; + this._lightMapTexture = lightMap; + this.blendMode = blendMode; + } + /** + * @inheritDoc + */ + DiffuseLightMapMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsSecondaryUV = this._useSecondaryUV; + methodVO.needsUV = !this._useSecondaryUV; + }; + Object.defineProperty(DiffuseLightMapMethod.prototype, "blendMode", { + /** + * The blend mode with which the light map should be applied to the lighting result. + * + * @see DiffuseLightMapMethod.ADD + * @see DiffuseLightMapMethod.MULTIPLY + */ + get: function () { + return this._blendMode; + }, + set: function (value) { + if (value != DiffuseLightMapMethod.ADD && value != DiffuseLightMapMethod.MULTIPLY) + throw new Error("Unknown blendmode!"); + if (this._blendMode == value) + return; + this._blendMode = value; + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DiffuseLightMapMethod.prototype, "lightMapTexture", { + /** + * The texture containing the light map data. + */ + get: function () { + return this._lightMapTexture; + }, + set: function (value) { + this._lightMapTexture = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + DiffuseLightMapMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + stage.context.activateTexture(methodVO.secondaryTexturesIndex, this._lightMapTexture); + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + DiffuseLightMapMethod.prototype.iGetFragmentPostLightingCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var code; + var lightMapReg = registerCache.getFreeTextureReg(); + var temp = registerCache.getFreeFragmentVectorTemp(); + methodVO.secondaryTexturesIndex = lightMapReg.index; + code = ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, lightMapReg, this._lightMapTexture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, sharedRegisters.secondaryUVVarying); + switch (this._blendMode) { + case DiffuseLightMapMethod.MULTIPLY: + code += "mul " + this._pTotalLightColorReg + ", " + this._pTotalLightColorReg + ", " + temp + "\n"; + break; + case DiffuseLightMapMethod.ADD: + code += "add " + this._pTotalLightColorReg + ", " + this._pTotalLightColorReg + ", " + temp + "\n"; + break; + } + code += _super.prototype.iGetFragmentPostLightingCode.call(this, shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + return code; + }; + /** + * Indicates the light map should be multiplied with the calculated shading result. + * This can be used to add pre-calculated shadows or occlusion. + */ + DiffuseLightMapMethod.MULTIPLY = "multiply"; + /** + * Indicates the light map should be added into the calculated shading result. + * This can be used to add pre-calculated lighting or global illumination. + */ + DiffuseLightMapMethod.ADD = "add"; + return DiffuseLightMapMethod; +})(DiffuseCompositeMethod); +module.exports = DiffuseLightMapMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/diffuselightmapmethod.ts"],"names":["DiffuseLightMapMethod","DiffuseLightMapMethod.constructor","DiffuseLightMapMethod.iInitVO","DiffuseLightMapMethod.blendMode","DiffuseLightMapMethod.lightMapTexture","DiffuseLightMapMethod.iActivate","DiffuseLightMapMethod.iGetFragmentPostLightingCode"],"mappings":"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","file":"materials/methods/DiffuseLightMapMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport DiffuseBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\nimport DiffuseCompositeMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod\");\n\n/**\n * DiffuseLightMapMethod provides a diffuse shading method that uses a light map to modulate the calculated diffuse\n * lighting. It is different from EffectLightMapMethod in that the latter modulates the entire calculated pixel color, rather\n * than only the diffuse lighting value.\n */\nclass DiffuseLightMapMethod extends DiffuseCompositeMethod\n{\n\t/**\n\t * Indicates the light map should be multiplied with the calculated shading result.\n\t * This can be used to add pre-calculated shadows or occlusion.\n\t */\n\tpublic static MULTIPLY:string = \"multiply\";\n\n\t/**\n\t * Indicates the light map should be added into the calculated shading result.\n\t * This can be used to add pre-calculated lighting or global illumination.\n\t */\n\tpublic static ADD:string = \"add\";\n\n\tprivate _lightMapTexture:Texture2DBase;\n\tprivate _blendMode:string;\n\tprivate _useSecondaryUV:boolean;\n\n\t/**\n\t * Creates a new DiffuseLightMapMethod method.\n\t *\n\t * @param lightMap The texture containing the light map.\n\t * @param blendMode The blend mode with which the light map should be applied to the lighting result.\n\t * @param useSecondaryUV Indicates whether the secondary UV set should be used to map the light map.\n\t * @param baseMethod The diffuse method used to calculate the regular diffuse-based lighting.\n\t */\n\tconstructor(lightMap:Texture2DBase, blendMode:string = \"multiply\", useSecondaryUV:boolean = false, baseMethod:DiffuseBasicMethod = null)\n\t{\n\t\tsuper(null, baseMethod);\n\n\t\tthis._useSecondaryUV = useSecondaryUV;\n\t\tthis._lightMapTexture = lightMap;\n\t\tthis.blendMode = blendMode;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsSecondaryUV = this._useSecondaryUV;\n\t\tmethodVO.needsUV = !this._useSecondaryUV;\n\t}\n\n\t/**\n\t * The blend mode with which the light map should be applied to the lighting result.\n\t *\n\t * @see DiffuseLightMapMethod.ADD\n\t * @see DiffuseLightMapMethod.MULTIPLY\n\t */\n\tpublic get blendMode():string\n\t{\n\t\treturn this._blendMode;\n\t}\n\n\tpublic set blendMode(value:string)\n\t{\n\t\tif (value != DiffuseLightMapMethod.ADD && value != DiffuseLightMapMethod.MULTIPLY)\n\t\t\tthrow new Error(\"Unknown blendmode!\");\n\n\t\tif (this._blendMode == value)\n\t\t\treturn;\n\n\t\tthis._blendMode = value;\n\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * The texture containing the light map data.\n\t */\n\tpublic get lightMapTexture():Texture2DBase\n\t{\n\t\treturn this._lightMapTexture;\n\t}\n\n\tpublic set lightMapTexture(value:Texture2DBase)\n\t{\n\t\tthis._lightMapTexture = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.secondaryTexturesIndex, this._lightMapTexture);\n\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string;\n\t\tvar lightMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tmethodVO.secondaryTexturesIndex = lightMapReg.index;\n\n\t\tcode = ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, lightMapReg, this._lightMapTexture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, sharedRegisters.secondaryUVVarying);\n\n\t\tswitch (this._blendMode) {\n\t\t\tcase DiffuseLightMapMethod.MULTIPLY:\n\t\t\t\tcode += \"mul \" + this._pTotalLightColorReg + \", \" + this._pTotalLightColorReg + \", \" + temp + \"\\n\";\n\t\t\t\tbreak;\n\t\t\tcase DiffuseLightMapMethod.ADD:\n\t\t\t\tcode += \"add \" + this._pTotalLightColorReg + \", \" + this._pTotalLightColorReg + \", \" + temp + \"\\n\";\n\t\t\t\tbreak;\n\t\t}\n\n\t\tcode += super.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\n\t\treturn code;\n\t}\n}\n\nexport = DiffuseLightMapMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/DiffuseLightMapMethod.ts b/lib/materials/methods/DiffuseLightMapMethod.ts new file mode 100644 index 000000000..c58acc6fe --- /dev/null +++ b/lib/materials/methods/DiffuseLightMapMethod.ts @@ -0,0 +1,138 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +import DiffuseCompositeMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod"); + +/** + * DiffuseLightMapMethod provides a diffuse shading method that uses a light map to modulate the calculated diffuse + * lighting. It is different from EffectLightMapMethod in that the latter modulates the entire calculated pixel color, rather + * than only the diffuse lighting value. + */ +class DiffuseLightMapMethod extends DiffuseCompositeMethod +{ + /** + * Indicates the light map should be multiplied with the calculated shading result. + * This can be used to add pre-calculated shadows or occlusion. + */ + public static MULTIPLY:string = "multiply"; + + /** + * Indicates the light map should be added into the calculated shading result. + * This can be used to add pre-calculated lighting or global illumination. + */ + public static ADD:string = "add"; + + private _lightMapTexture:Texture2DBase; + private _blendMode:string; + private _useSecondaryUV:boolean; + + /** + * Creates a new DiffuseLightMapMethod method. + * + * @param lightMap The texture containing the light map. + * @param blendMode The blend mode with which the light map should be applied to the lighting result. + * @param useSecondaryUV Indicates whether the secondary UV set should be used to map the light map. + * @param baseMethod The diffuse method used to calculate the regular diffuse-based lighting. + */ + constructor(lightMap:Texture2DBase, blendMode:string = "multiply", useSecondaryUV:boolean = false, baseMethod:DiffuseBasicMethod = null) + { + super(null, baseMethod); + + this._useSecondaryUV = useSecondaryUV; + this._lightMapTexture = lightMap; + this.blendMode = blendMode; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + methodVO.needsSecondaryUV = this._useSecondaryUV; + methodVO.needsUV = !this._useSecondaryUV; + } + + /** + * The blend mode with which the light map should be applied to the lighting result. + * + * @see DiffuseLightMapMethod.ADD + * @see DiffuseLightMapMethod.MULTIPLY + */ + public get blendMode():string + { + return this._blendMode; + } + + public set blendMode(value:string) + { + if (value != DiffuseLightMapMethod.ADD && value != DiffuseLightMapMethod.MULTIPLY) + throw new Error("Unknown blendmode!"); + + if (this._blendMode == value) + return; + + this._blendMode = value; + + this.iInvalidateShaderProgram(); + } + + /** + * The texture containing the light map data. + */ + public get lightMapTexture():Texture2DBase + { + return this._lightMapTexture; + } + + public set lightMapTexture(value:Texture2DBase) + { + this._lightMapTexture = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + ( stage.context).activateTexture(methodVO.secondaryTexturesIndex, this._lightMapTexture); + + super.iActivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string; + var lightMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + methodVO.secondaryTexturesIndex = lightMapReg.index; + + code = ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, lightMapReg, this._lightMapTexture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, sharedRegisters.secondaryUVVarying); + + switch (this._blendMode) { + case DiffuseLightMapMethod.MULTIPLY: + code += "mul " + this._pTotalLightColorReg + ", " + this._pTotalLightColorReg + ", " + temp + "\n"; + break; + case DiffuseLightMapMethod.ADD: + code += "add " + this._pTotalLightColorReg + ", " + this._pTotalLightColorReg + ", " + temp + "\n"; + break; + } + + code += super.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + + return code; + } +} + +export = DiffuseLightMapMethod; \ No newline at end of file diff --git a/lib/materials/methods/DiffuseSubSurfaceMethod.js b/lib/materials/methods/DiffuseSubSurfaceMethod.js new file mode 100755 index 000000000..f3920f96d --- /dev/null +++ b/lib/materials/methods/DiffuseSubSurfaceMethod.js @@ -0,0 +1,211 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DiffuseCompositeMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod"); +var SingleObjectDepthPass = require("awayjs-renderergl/lib/materials/passes/SingleObjectDepthPass"); +/** + * DiffuseSubSurfaceMethod provides a depth map-based diffuse shading method that mimics the scattering of + * light inside translucent surfaces. It allows light to shine through an object and to soften the diffuse shading. + * It can be used for candle wax, ice, skin, ... + */ +var DiffuseSubSurfaceMethod = (function (_super) { + __extends(DiffuseSubSurfaceMethod, _super); + /** + * Creates a new DiffuseSubSurfaceMethod object. + * + * @param depthMapSize The size of the depth map used. + * @param depthMapOffset The amount by which the rendered object will be inflated, to prevent depth map rounding errors. + * @param baseMethod The diffuse method used to calculate the regular diffuse-based lighting. + */ + function DiffuseSubSurfaceMethod(depthMapSize, depthMapOffset, baseMethod) { + var _this = this; + if (depthMapSize === void 0) { depthMapSize = 512; } + if (depthMapOffset === void 0) { depthMapOffset = 15; } + if (baseMethod === void 0) { baseMethod = null; } + _super.call(this, null, baseMethod); + this._translucency = 1; + this._scatterColor = 0xffffff; + this._scatterR = 1.0; + this._scatterG = 1.0; + this._scatterB = 1.0; + this.pBaseMethod._iModulateMethod = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { return _this.scatterLight(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); }; + this._passes = new Array(); + this._depthPass = new SingleObjectDepthPass(); + this._depthPass.textureSize = depthMapSize; + this._depthPass.polyOffset = depthMapOffset; + this._passes.push(this._depthPass); + this._scattering = 0.2; + this._translucency = 1; + } + /** + * @inheritDoc + */ + DiffuseSubSurfaceMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + _super.prototype.iInitConstants.call(this, shaderObject, methodVO); + var data = shaderObject.vertexConstantData; + var index = methodVO.secondaryVertexConstantsIndex; + data[index] = .5; + data[index + 1] = -.5; + data[index + 2] = 0; + data[index + 3] = 1; + data = shaderObject.fragmentConstantData; + index = methodVO.secondaryFragmentConstantsIndex; + data[index + 3] = 1.0; + data[index + 4] = 1.0; + data[index + 5] = 1 / 255; + data[index + 6] = 1 / 65025; + data[index + 7] = 1 / 16581375; + data[index + 10] = .5; + data[index + 11] = -.1; + }; + DiffuseSubSurfaceMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._lightProjVarying = null; + this._propReg = null; + this._lightColorReg = null; + this._colorReg = null; + this._decReg = null; + this._targetReg = null; + }; + Object.defineProperty(DiffuseSubSurfaceMethod.prototype, "scattering", { + /** + * The amount by which the light scatters. It can be used to set the translucent surface's thickness. Use low + * values for skin. + */ + get: function () { + return this._scattering; + }, + set: function (value) { + this._scattering = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DiffuseSubSurfaceMethod.prototype, "translucency", { + /** + * The translucency of the object. + */ + get: function () { + return this._translucency; + }, + set: function (value) { + this._translucency = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DiffuseSubSurfaceMethod.prototype, "scatterColor", { + /** + * The colour of the "insides" of the object, ie: the colour the light becomes after leaving the object. + */ + get: function () { + return this._scatterColor; + }, + set: function (scatterColor /*uint*/) { + this._scatterColor = scatterColor; + this._scatterR = ((scatterColor >> 16) & 0xff) / 0xff; + this._scatterG = ((scatterColor >> 8) & 0xff) / 0xff; + this._scatterB = (scatterColor & 0xff) / 0xff; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + DiffuseSubSurfaceMethod.prototype.iGetVertexCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + var code = _super.prototype.iGetVertexCode.call(this, shaderObject, methodVO, registerCache, sharedRegisters); + var lightProjection; + var toTexRegister; + var temp = registerCache.getFreeVertexVectorTemp(); + toTexRegister = registerCache.getFreeVertexConstant(); + methodVO.secondaryVertexConstantsIndex = toTexRegister.index * 4; + this._lightProjVarying = registerCache.getFreeVarying(); + lightProjection = registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + code += "m44 " + temp + ", vt0, " + lightProjection + "\n" + "div " + temp + ".xyz, " + temp + ".xyz, " + temp + ".w\n" + "mul " + temp + ".xy, " + temp + ".xy, " + toTexRegister + ".xy\n" + "add " + temp + ".xy, " + temp + ".xy, " + toTexRegister + ".xx\n" + "mov " + this._lightProjVarying + ".xyz, " + temp + ".xyz\n" + "mov " + this._lightProjVarying + ".w, va0.w\n"; + return code; + }; + /** + * @inheritDoc + */ + DiffuseSubSurfaceMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + this._colorReg = registerCache.getFreeFragmentConstant(); + this._decReg = registerCache.getFreeFragmentConstant(); + this._propReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._colorReg.index * 4; + return _super.prototype.iGetFragmentPreLightingCode.call(this, shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + DiffuseSubSurfaceMethod.prototype.iGetFragmentCodePerLight = function (shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters) { + this._pIsFirstLight = true; + this._lightColorReg = lightColReg; + return _super.prototype.iGetFragmentCodePerLight.call(this, shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + DiffuseSubSurfaceMethod.prototype.iGetFragmentPostLightingCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var code = _super.prototype.iGetFragmentPostLightingCode.call(this, shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + var temp = registerCache.getFreeFragmentVectorTemp(); + code += "mul " + temp + ".xyz, " + this._lightColorReg + ".xyz, " + this._targetReg + ".w\n" + "mul " + temp + ".xyz, " + temp + ".xyz, " + this._colorReg + ".xyz\n" + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + if (this._targetReg != sharedRegisters.viewDirFragment) + registerCache.removeFragmentTempUsage(targetReg); + return code; + }; + /** + * @inheritDoc + */ + DiffuseSubSurfaceMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var index = methodVO.secondaryFragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = this._scatterR; + data[index + 1] = this._scatterG; + data[index + 2] = this._scatterB; + data[index + 8] = this._scattering; + data[index + 9] = this._translucency; + }; + /** + * @inheritDoc + */ + DiffuseSubSurfaceMethod.prototype.iSetRenderState = function (shaderObject, methodVO, renderable, stage, camera) { + stage.context.activateTexture(methodVO.secondaryTexturesIndex, this._depthPass._iGetDepthMap(renderable)); + this._depthPass._iGetProjection(renderable).copyRawDataTo(shaderObject.vertexConstantData, methodVO.secondaryVertexConstantsIndex + 4, true); + }; + /** + * Generates the code for this method + */ + DiffuseSubSurfaceMethod.prototype.scatterLight = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + // only scatter first light + if (!this._pIsFirstLight) + return ""; + this._pIsFirstLight = false; + var code = ""; + var depthReg = registerCache.getFreeTextureReg(); + if (sharedRegisters.viewDirFragment) { + this._targetReg = sharedRegisters.viewDirFragment; + } + else { + this._targetReg = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(this._targetReg, 1); + } + methodVO.secondaryTexturesIndex = depthReg.index; + var temp = registerCache.getFreeFragmentVectorTemp(); + code += "tex " + temp + ", " + this._lightProjVarying + ", " + depthReg + " <2d,nearest,clamp>\n" + "dp4 " + targetReg + ".z, " + temp + ", " + this._decReg + "\n"; + // currentDistanceToLight - closestDistanceToLight + code += "sub " + targetReg + ".z, " + this._lightProjVarying + ".z, " + targetReg + ".z\n" + "sub " + targetReg + ".z, " + this._propReg + ".x, " + targetReg + ".z\n" + "mul " + targetReg + ".z, " + this._propReg + ".y, " + targetReg + ".z\n" + "sat " + targetReg + ".z, " + targetReg + ".z\n" + "neg " + targetReg + ".y, " + targetReg + ".x\n" + "mul " + targetReg + ".y, " + targetReg + ".y, " + this._propReg + ".z\n" + "add " + targetReg + ".y, " + targetReg + ".y, " + this._propReg + ".z\n" + "mul " + this._targetReg + ".w, " + targetReg + ".z, " + targetReg + ".y\n" + "sub " + targetReg + ".y, " + this._colorReg + ".w, " + this._targetReg + ".w\n" + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n"; + return code; + }; + return DiffuseSubSurfaceMethod; +})(DiffuseCompositeMethod); +module.exports = DiffuseSubSurfaceMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/diffusesubsurfacemethod.ts"],"names":["DiffuseSubSurfaceMethod","DiffuseSubSurfaceMethod.constructor","DiffuseSubSurfaceMethod.iInitConstants","DiffuseSubSurfaceMethod.iCleanCompilationData","DiffuseSubSurfaceMethod.scattering","DiffuseSubSurfaceMethod.translucency","DiffuseSubSurfaceMethod.scatterColor","DiffuseSubSurfaceMethod.iGetVertexCode","DiffuseSubSurfaceMethod.iGetFragmentPreLightingCode","DiffuseSubSurfaceMethod.iGetFragmentCodePerLight","DiffuseSubSurfaceMethod.iGetFragmentPostLightingCode","DiffuseSubSurfaceMethod.iActivate","DiffuseSubSurfaceMethod.iSetRenderState","DiffuseSubSurfaceMethod.scatterLight"],"mappings":"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","file":"materials/methods/DiffuseSubSurfaceMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport DiffuseBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod\");\nimport MaterialPassBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/passes/MaterialPassBase\");\n\nimport DiffuseCompositeMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod\");\nimport SingleObjectDepthPass\t\t\t= require(\"awayjs-renderergl/lib/materials/passes/SingleObjectDepthPass\");\n\n/**\n * DiffuseSubSurfaceMethod provides a depth map-based diffuse shading method that mimics the scattering of\n * light inside translucent surfaces. It allows light to shine through an object and to soften the diffuse shading.\n * It can be used for candle wax, ice, skin, ...\n */\nclass DiffuseSubSurfaceMethod extends DiffuseCompositeMethod\n{\n\tprivate _depthPass:SingleObjectDepthPass;\n\tprivate _lightProjVarying:ShaderRegisterElement;\n\tprivate _propReg:ShaderRegisterElement;\n\tprivate _scattering:number;\n\tprivate _translucency:number = 1;\n\tprivate _lightColorReg:ShaderRegisterElement;\n\tprivate _scatterColor:number /*uint*/ = 0xffffff;\n\tprivate _colorReg:ShaderRegisterElement;\n\tprivate _decReg:ShaderRegisterElement;\n\tprivate _scatterR:number = 1.0;\n\tprivate _scatterG:number = 1.0;\n\tprivate _scatterB:number = 1.0;\n\tprivate _targetReg:ShaderRegisterElement;\n\t\n\t/**\n\t * Creates a new <code>DiffuseSubSurfaceMethod</code> object.\n\t *\n\t * @param depthMapSize The size of the depth map used.\n\t * @param depthMapOffset The amount by which the rendered object will be inflated, to prevent depth map rounding errors.\n\t * @param baseMethod The diffuse method used to calculate the regular diffuse-based lighting.\n\t */\n\tconstructor(depthMapSize:number /*int*/ = 512, depthMapOffset:number = 15, baseMethod:DiffuseBasicMethod = null)\n\t{\n\t\tsuper(null, baseMethod);\n\n\t\tthis.pBaseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.scatterLight(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\n\t\tthis._passes = new Array<MaterialPassBase>();\n\t\tthis._depthPass = new SingleObjectDepthPass();\n\t\tthis._depthPass.textureSize = depthMapSize;\n\t\tthis._depthPass.polyOffset = depthMapOffset;\n\t\tthis._passes.push(this._depthPass);\n\t\tthis._scattering = 0.2;\n\t\tthis._translucency = 1;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tsuper.iInitConstants(shaderObject, methodVO);\n\n\t\tvar data:Array<number> = shaderObject.vertexConstantData;\n\t\tvar index:number /*int*/ = methodVO.secondaryVertexConstantsIndex;\n\t\tdata[index] = .5;\n\t\tdata[index + 1] = -.5;\n\t\tdata[index + 2] = 0;\n\t\tdata[index + 3] = 1;\n\t\t\n\t\tdata = shaderObject.fragmentConstantData;\n\t\tindex = methodVO.secondaryFragmentConstantsIndex;\n\t\tdata[index + 3] = 1.0;\n\t\tdata[index + 4] = 1.0;\n\t\tdata[index + 5] = 1/255;\n\t\tdata[index + 6] = 1/65025;\n\t\tdata[index + 7] = 1/16581375;\n\t\tdata[index + 10] = .5;\n\t\tdata[index + 11] = -.1;\n\t}\n\t\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\n\t\tthis._lightProjVarying = null;\n\t\tthis._propReg = null;\n\t\tthis._lightColorReg = null;\n\t\tthis._colorReg = null;\n\t\tthis._decReg = null;\n\t\tthis._targetReg = null;\n\t}\n\t\n\t/**\n\t * The amount by which the light scatters. It can be used to set the translucent surface's thickness. Use low\n\t * values for skin.\n\t */\n\tpublic get scattering():number\n\t{\n\t\treturn this._scattering;\n\t}\n\t\n\tpublic set scattering(value:number)\n\t{\n\t\tthis._scattering = value;\n\t}\n\t\n\t/**\n\t * The translucency of the object.\n\t */\n\tpublic get translucency():number\n\t{\n\t\treturn this._translucency;\n\t}\n\t\n\tpublic set translucency(value:number)\n\t{\n\t\tthis._translucency = value;\n\t}\n\t\n\t/**\n\t * The colour of the \"insides\" of the object, ie: the colour the light becomes after leaving the object.\n\t */\n\tpublic get scatterColor():number /*uint*/\n\t{\n\t\treturn this._scatterColor;\n\t}\n\t\n\tpublic set scatterColor(scatterColor:number /*uint*/)\n\t{\n\t\tthis._scatterColor = scatterColor;\n\t\tthis._scatterR = ((scatterColor >> 16) & 0xff)/0xff;\n\t\tthis._scatterG = ((scatterColor >> 8) & 0xff)/0xff;\n\t\tthis._scatterB = (scatterColor & 0xff)/0xff;\n\t}\n\t\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = super.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t\tvar lightProjection:ShaderRegisterElement;\n\t\tvar toTexRegister:ShaderRegisterElement;\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeVertexVectorTemp();\n\t\t\n\t\ttoTexRegister = registerCache.getFreeVertexConstant();\n\t\tmethodVO.secondaryVertexConstantsIndex = toTexRegister.index*4;\n\n\t\tthis._lightProjVarying = registerCache.getFreeVarying();\n\t\tlightProjection = registerCache.getFreeVertexConstant();\n\t\tregisterCache.getFreeVertexConstant();\n\t\tregisterCache.getFreeVertexConstant();\n\t\tregisterCache.getFreeVertexConstant();\n\t\t\n\t\tcode += \"m44 \" + temp + \", vt0, \" + lightProjection + \"\\n\" +\n\t\t\t\"div \" + temp + \".xyz, \" + temp + \".xyz, \" + temp + \".w\\n\" +\n\t\t\t\"mul \" + temp + \".xy, \" + temp + \".xy, \" + toTexRegister + \".xy\\n\" +\n\t\t\t\"add \" + temp + \".xy, \" + temp + \".xy, \" + toTexRegister + \".xx\\n\" +\n\t\t\t\"mov \" + this._lightProjVarying + \".xyz, \" + temp + \".xyz\\n\" +\n\t\t\t\"mov \" + this._lightProjVarying + \".w, va0.w\\n\";\n\t\t\n\t\treturn code;\n\t}\n\t\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tthis._colorReg = registerCache.getFreeFragmentConstant();\n\t\tthis._decReg = registerCache.getFreeFragmentConstant();\n\t\tthis._propReg = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.secondaryFragmentConstantsIndex = this._colorReg.index*4;\n\t\t\n\t\treturn super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\t\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tthis._pIsFirstLight = true;\n\t\tthis._lightColorReg = lightColReg;\n\t\treturn super.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters);\n\t}\n\t\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = super.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\t\n\t\tcode += \"mul \" + temp + \".xyz, \" + this._lightColorReg + \".xyz, \" + this._targetReg + \".w\\n\" +\n\t\t\t\"mul \" + temp + \".xyz, \" + temp + \".xyz, \" + this._colorReg + \".xyz\\n\" +\n\t\t\t\"add \" + targetReg + \".xyz, \" + targetReg + \".xyz, \" + temp + \".xyz\\n\";\n\t\t\n\t\tif (this._targetReg != sharedRegisters.viewDirFragment)\n\t\t\tregisterCache.removeFragmentTempUsage(targetReg);\n\t\t\n\t\treturn code;\n\t}\n\t\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\t\t\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index] = this._scatterR;\n\t\tdata[index + 1] = this._scatterG;\n\t\tdata[index + 2] = this._scatterB;\n\t\tdata[index + 8] = this._scattering;\n\t\tdata[index + 9] = this._translucency;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iSetRenderState(shaderObject:ShaderObjectBase, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera)\n\t{\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.secondaryTexturesIndex, this._depthPass._iGetDepthMap(renderable));\n\n\t\tthis._depthPass._iGetProjection(renderable).copyRawDataTo(shaderObject.vertexConstantData, methodVO.secondaryVertexConstantsIndex + 4, true);\n\t}\n\t\n\t/**\n\t * Generates the code for this method\n\t */\n\tprivate scatterLight(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\t// only scatter first light\n\t\tif (!this._pIsFirstLight)\n\t\t\treturn \"\";\n\n\t\tthis._pIsFirstLight = false;\n\n\t\tvar code:string = \"\";\n\t\tvar depthReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\n\t\tif (sharedRegisters.viewDirFragment) {\n\t\t\tthis._targetReg = sharedRegisters.viewDirFragment;\n\t\t} else {\n\t\t\tthis._targetReg = registerCache.getFreeFragmentVectorTemp();\n\t\t\tregisterCache.addFragmentTempUsages(this._targetReg, 1);\n\t\t}\n\n\t\tmethodVO.secondaryTexturesIndex = depthReg.index;\n\t\t\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tcode += \"tex \" + temp + \", \" + this._lightProjVarying + \", \" + depthReg + \" <2d,nearest,clamp>\\n\" +\n\t\t\t// reencode RGBA\n\t\t\t\"dp4 \" + targetReg + \".z, \" + temp + \", \" + this._decReg + \"\\n\";\n\t\t// currentDistanceToLight - closestDistanceToLight\n\t\tcode += \"sub \" + targetReg + \".z, \" + this._lightProjVarying + \".z, \" + targetReg + \".z\\n\" +\n\t\t\t\n\t\t\t\"sub \" + targetReg + \".z, \" + this._propReg + \".x, \" + targetReg + \".z\\n\" +\n\t\t\t\"mul \" + targetReg + \".z, \" + this._propReg + \".y, \" + targetReg + \".z\\n\" +\n\t\t\t\"sat \" + targetReg + \".z, \" + targetReg + \".z\\n\" +\n\t\t\t\n\t\t\t// targetReg.x contains dot(lightDir, normal)\n\t\t\t// modulate according to incident light angle (scatter = scatter*(-.5*dot(light, normal) + .5)\n\t\t\t\"neg \" + targetReg + \".y, \" + targetReg + \".x\\n\" +\n\t\t\t\"mul \" + targetReg + \".y, \" + targetReg + \".y, \" + this._propReg + \".z\\n\" +\n\t\t\t\"add \" + targetReg + \".y, \" + targetReg + \".y, \" + this._propReg + \".z\\n\" +\n\t\t\t\"mul \" + this._targetReg + \".w, \" + targetReg + \".z, \" + targetReg + \".y\\n\" +\n\t\t\t\n\t\t\t// blend diffuse: d' = (1-s)*d + s*1\n\t\t\t\"sub \" + targetReg + \".y, \" + this._colorReg + \".w, \" + this._targetReg + \".w\\n\" +\n\t\t\t\"mul \" + targetReg + \".w, \" + targetReg + \".w, \" + targetReg + \".y\\n\";\n\t\t\n\t\treturn code;\n\t}\n}\n\nexport = DiffuseSubSurfaceMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/DiffuseSubSurfaceMethod.ts b/lib/materials/methods/DiffuseSubSurfaceMethod.ts new file mode 100644 index 000000000..6b0622b9a --- /dev/null +++ b/lib/materials/methods/DiffuseSubSurfaceMethod.ts @@ -0,0 +1,286 @@ +import Camera = require("awayjs-core/lib/entities/Camera"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +import MaterialPassBase = require("awayjs-stagegl/lib/materials/passes/MaterialPassBase"); + +import DiffuseCompositeMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCompositeMethod"); +import SingleObjectDepthPass = require("awayjs-renderergl/lib/materials/passes/SingleObjectDepthPass"); + +/** + * DiffuseSubSurfaceMethod provides a depth map-based diffuse shading method that mimics the scattering of + * light inside translucent surfaces. It allows light to shine through an object and to soften the diffuse shading. + * It can be used for candle wax, ice, skin, ... + */ +class DiffuseSubSurfaceMethod extends DiffuseCompositeMethod +{ + private _depthPass:SingleObjectDepthPass; + private _lightProjVarying:ShaderRegisterElement; + private _propReg:ShaderRegisterElement; + private _scattering:number; + private _translucency:number = 1; + private _lightColorReg:ShaderRegisterElement; + private _scatterColor:number /*uint*/ = 0xffffff; + private _colorReg:ShaderRegisterElement; + private _decReg:ShaderRegisterElement; + private _scatterR:number = 1.0; + private _scatterG:number = 1.0; + private _scatterB:number = 1.0; + private _targetReg:ShaderRegisterElement; + + /** + * Creates a new DiffuseSubSurfaceMethod object. + * + * @param depthMapSize The size of the depth map used. + * @param depthMapOffset The amount by which the rendered object will be inflated, to prevent depth map rounding errors. + * @param baseMethod The diffuse method used to calculate the regular diffuse-based lighting. + */ + constructor(depthMapSize:number /*int*/ = 512, depthMapOffset:number = 15, baseMethod:DiffuseBasicMethod = null) + { + super(null, baseMethod); + + this.pBaseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.scatterLight(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + + this._passes = new Array(); + this._depthPass = new SingleObjectDepthPass(); + this._depthPass.textureSize = depthMapSize; + this._depthPass.polyOffset = depthMapOffset; + this._passes.push(this._depthPass); + this._scattering = 0.2; + this._translucency = 1; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + super.iInitConstants(shaderObject, methodVO); + + var data:Array = shaderObject.vertexConstantData; + var index:number /*int*/ = methodVO.secondaryVertexConstantsIndex; + data[index] = .5; + data[index + 1] = -.5; + data[index + 2] = 0; + data[index + 3] = 1; + + data = shaderObject.fragmentConstantData; + index = methodVO.secondaryFragmentConstantsIndex; + data[index + 3] = 1.0; + data[index + 4] = 1.0; + data[index + 5] = 1/255; + data[index + 6] = 1/65025; + data[index + 7] = 1/16581375; + data[index + 10] = .5; + data[index + 11] = -.1; + } + + public iCleanCompilationData() + { + super.iCleanCompilationData(); + + this._lightProjVarying = null; + this._propReg = null; + this._lightColorReg = null; + this._colorReg = null; + this._decReg = null; + this._targetReg = null; + } + + /** + * The amount by which the light scatters. It can be used to set the translucent surface's thickness. Use low + * values for skin. + */ + public get scattering():number + { + return this._scattering; + } + + public set scattering(value:number) + { + this._scattering = value; + } + + /** + * The translucency of the object. + */ + public get translucency():number + { + return this._translucency; + } + + public set translucency(value:number) + { + this._translucency = value; + } + + /** + * The colour of the "insides" of the object, ie: the colour the light becomes after leaving the object. + */ + public get scatterColor():number /*uint*/ + { + return this._scatterColor; + } + + public set scatterColor(scatterColor:number /*uint*/) + { + this._scatterColor = scatterColor; + this._scatterR = ((scatterColor >> 16) & 0xff)/0xff; + this._scatterG = ((scatterColor >> 8) & 0xff)/0xff; + this._scatterB = (scatterColor & 0xff)/0xff; + } + + /** + * @inheritDoc + */ + public iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = super.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters); + var lightProjection:ShaderRegisterElement; + var toTexRegister:ShaderRegisterElement; + var temp:ShaderRegisterElement = registerCache.getFreeVertexVectorTemp(); + + toTexRegister = registerCache.getFreeVertexConstant(); + methodVO.secondaryVertexConstantsIndex = toTexRegister.index*4; + + this._lightProjVarying = registerCache.getFreeVarying(); + lightProjection = registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + + code += "m44 " + temp + ", vt0, " + lightProjection + "\n" + + "div " + temp + ".xyz, " + temp + ".xyz, " + temp + ".w\n" + + "mul " + temp + ".xy, " + temp + ".xy, " + toTexRegister + ".xy\n" + + "add " + temp + ".xy, " + temp + ".xy, " + toTexRegister + ".xx\n" + + "mov " + this._lightProjVarying + ".xyz, " + temp + ".xyz\n" + + "mov " + this._lightProjVarying + ".w, va0.w\n"; + + return code; + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + this._colorReg = registerCache.getFreeFragmentConstant(); + this._decReg = registerCache.getFreeFragmentConstant(); + this._propReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._colorReg.index*4; + + return super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + this._pIsFirstLight = true; + this._lightColorReg = lightColReg; + return super.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = super.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + + code += "mul " + temp + ".xyz, " + this._lightColorReg + ".xyz, " + this._targetReg + ".w\n" + + "mul " + temp + ".xyz, " + temp + ".xyz, " + this._colorReg + ".xyz\n" + + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + + if (this._targetReg != sharedRegisters.viewDirFragment) + registerCache.removeFragmentTempUsage(targetReg); + + return code; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index] = this._scatterR; + data[index + 1] = this._scatterG; + data[index + 2] = this._scatterB; + data[index + 8] = this._scattering; + data[index + 9] = this._translucency; + } + + /** + * @inheritDoc + */ + public iSetRenderState(shaderObject:ShaderObjectBase, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera) + { + ( stage.context).activateTexture(methodVO.secondaryTexturesIndex, this._depthPass._iGetDepthMap(renderable)); + + this._depthPass._iGetProjection(renderable).copyRawDataTo(shaderObject.vertexConstantData, methodVO.secondaryVertexConstantsIndex + 4, true); + } + + /** + * Generates the code for this method + */ + private scatterLight(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + // only scatter first light + if (!this._pIsFirstLight) + return ""; + + this._pIsFirstLight = false; + + var code:string = ""; + var depthReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + + if (sharedRegisters.viewDirFragment) { + this._targetReg = sharedRegisters.viewDirFragment; + } else { + this._targetReg = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(this._targetReg, 1); + } + + methodVO.secondaryTexturesIndex = depthReg.index; + + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + code += "tex " + temp + ", " + this._lightProjVarying + ", " + depthReg + " <2d,nearest,clamp>\n" + + // reencode RGBA + "dp4 " + targetReg + ".z, " + temp + ", " + this._decReg + "\n"; + // currentDistanceToLight - closestDistanceToLight + code += "sub " + targetReg + ".z, " + this._lightProjVarying + ".z, " + targetReg + ".z\n" + + + "sub " + targetReg + ".z, " + this._propReg + ".x, " + targetReg + ".z\n" + + "mul " + targetReg + ".z, " + this._propReg + ".y, " + targetReg + ".z\n" + + "sat " + targetReg + ".z, " + targetReg + ".z\n" + + + // targetReg.x contains dot(lightDir, normal) + // modulate according to incident light angle (scatter = scatter*(-.5*dot(light, normal) + .5) + "neg " + targetReg + ".y, " + targetReg + ".x\n" + + "mul " + targetReg + ".y, " + targetReg + ".y, " + this._propReg + ".z\n" + + "add " + targetReg + ".y, " + targetReg + ".y, " + this._propReg + ".z\n" + + "mul " + this._targetReg + ".w, " + targetReg + ".z, " + targetReg + ".y\n" + + + // blend diffuse: d' = (1-s)*d + s*1 + "sub " + targetReg + ".y, " + this._colorReg + ".w, " + this._targetReg + ".w\n" + + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n"; + + return code; + } +} + +export = DiffuseSubSurfaceMethod; \ No newline at end of file diff --git a/lib/materials/methods/DiffuseWrapMethod.js b/lib/materials/methods/DiffuseWrapMethod.js new file mode 100755 index 000000000..4dd9ee90f --- /dev/null +++ b/lib/materials/methods/DiffuseWrapMethod.js @@ -0,0 +1,93 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); +/** + * DiffuseWrapMethod is an alternative to DiffuseBasicMethod in which the light is allowed to be "wrapped around" the normally dark area, to some extent. + * It can be used as a crude approximation to Oren-Nayar or simple subsurface scattering. + */ +var DiffuseWrapMethod = (function (_super) { + __extends(DiffuseWrapMethod, _super); + /** + * Creates a new DiffuseWrapMethod object. + * @param wrapFactor A factor to indicate the amount by which the light is allowed to wrap + */ + function DiffuseWrapMethod(wrapFactor) { + if (wrapFactor === void 0) { wrapFactor = .5; } + _super.call(this); + this.wrapFactor = wrapFactor; + } + /** + * @inheritDoc + */ + DiffuseWrapMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._wrapDataRegister = null; + }; + Object.defineProperty(DiffuseWrapMethod.prototype, "wrapFactor", { + /** + * A factor to indicate the amount by which the light is allowed to wrap. + */ + get: function () { + return this._wrapFactor; + }, + set: function (value) { + this._wrapFactor = value; + this._wrapFactor = 1 / (value + 1); + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + DiffuseWrapMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + var code = _super.prototype.iGetFragmentPreLightingCode.call(this, shaderObject, methodVO, registerCache, sharedRegisters); + this._pIsFirstLight = true; + this._wrapDataRegister = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._wrapDataRegister.index * 4; + return code; + }; + /** + * @inheritDoc + */ + DiffuseWrapMethod.prototype.iGetFragmentCodePerLight = function (shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters) { + var code = ""; + var t; + // write in temporary if not first light, so we can add to total diffuse colour + if (this._pIsFirstLight) { + t = this._pTotalLightColorReg; + } + else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + code += "dp3 " + t + ".x, " + lightDirReg + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + "add " + t + ".y, " + t + ".x, " + this._wrapDataRegister + ".x\n" + "mul " + t + ".y, " + t + ".y, " + this._wrapDataRegister + ".y\n" + "sat " + t + ".w, " + t + ".y\n" + "mul " + t + ".xz, " + t + ".w, " + lightDirReg + ".wz\n"; + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, lightDirReg, registerCache, sharedRegisters); + code += "mul " + t + ", " + t + ".x, " + lightColReg + "\n"; + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + this._pIsFirstLight = false; + return code; + }; + /** + * @inheritDoc + */ + DiffuseWrapMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var index = methodVO.secondaryFragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = this._wrapFactor; + data[index + 1] = 1 / (this._wrapFactor + 1); + }; + return DiffuseWrapMethod; +})(DiffuseBasicMethod); +module.exports = DiffuseWrapMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/diffusewrapmethod.ts"],"names":["DiffuseWrapMethod","DiffuseWrapMethod.constructor","DiffuseWrapMethod.iCleanCompilationData","DiffuseWrapMethod.wrapFactor","DiffuseWrapMethod.iGetFragmentPreLightingCode","DiffuseWrapMethod.iGetFragmentCodePerLight","DiffuseWrapMethod.iActivate"],"mappings":"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","file":"materials/methods/DiffuseWrapMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport DiffuseBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod\");\n\n/**\n * DiffuseWrapMethod is an alternative to DiffuseBasicMethod in which the light is allowed to be \"wrapped around\" the normally dark area, to some extent.\n * It can be used as a crude approximation to Oren-Nayar or simple subsurface scattering.\n */\nclass DiffuseWrapMethod extends DiffuseBasicMethod\n{\n\tprivate _wrapDataRegister:ShaderRegisterElement;\n\tprivate _wrapFactor:number;\n\n\t/**\n\t * Creates a new DiffuseWrapMethod object.\n\t * @param wrapFactor A factor to indicate the amount by which the light is allowed to wrap\n\t */\n\tconstructor(wrapFactor:number = .5)\n\t{\n\t\tsuper();\n\n\t\tthis.wrapFactor = wrapFactor;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\n\t\tthis._wrapDataRegister = null;\n\t}\n\n\t/**\n\t * A factor to indicate the amount by which the light is allowed to wrap.\n\t */\n\tpublic get wrapFactor():number\n\t{\n\t\treturn this._wrapFactor;\n\t}\n\n\tpublic set wrapFactor(value:number)\n\t{\n\t\tthis._wrapFactor = value;\n\t\tthis._wrapFactor = 1/(value + 1);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t\tthis._pIsFirstLight = true;\n\t\tthis._wrapDataRegister = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.secondaryFragmentConstantsIndex = this._wrapDataRegister.index*4;\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar t:ShaderRegisterElement;\n\n\t\t// write in temporary if not first light, so we can add to total diffuse colour\n\t\tif (this._pIsFirstLight) {\n\t\t\tt = this._pTotalLightColorReg;\n\t\t} else {\n\t\t\tt = registerCache.getFreeFragmentVectorTemp();\n\t\t\tregisterCache.addFragmentTempUsages(t, 1);\n\t\t}\n\n\t\tcode += \"dp3 \" + t + \".x, \" + lightDirReg + \".xyz, \" + sharedRegisters.normalFragment + \".xyz\\n\" +\n\t\t\t\"add \" + t + \".y, \" + t + \".x, \" + this._wrapDataRegister + \".x\\n\" +\n\t\t\t\"mul \" + t + \".y, \" + t + \".y, \" + this._wrapDataRegister + \".y\\n\" +\n\t\t\t\"sat \" + t + \".w, \" + t + \".y\\n\" +\n\t\t\t\"mul \" + t + \".xz, \" + t + \".w, \" + lightDirReg + \".wz\\n\";\n\n\t\tif (this._iModulateMethod != null)\n\t\t\tcode += this._iModulateMethod(shaderObject, methodVO, lightDirReg, registerCache, sharedRegisters);\n\n\t\tcode += \"mul \" + t + \", \" + t + \".x, \" + lightColReg + \"\\n\";\n\n\t\tif (!this._pIsFirstLight) {\n\t\t\tcode += \"add \" + this._pTotalLightColorReg + \".xyz, \" + this._pTotalLightColorReg + \".xyz, \" + t + \".xyz\\n\";\n\t\t\tregisterCache.removeFragmentTempUsage(t);\n\t\t}\n\n\t\tthis._pIsFirstLight = false;\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index] = this._wrapFactor;\n\t\tdata[index + 1] = 1/(this._wrapFactor + 1);\n\t}\n}\n\nexport = DiffuseWrapMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/DiffuseWrapMethod.ts b/lib/materials/methods/DiffuseWrapMethod.ts new file mode 100644 index 000000000..1f84822d9 --- /dev/null +++ b/lib/materials/methods/DiffuseWrapMethod.ts @@ -0,0 +1,117 @@ +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import DiffuseBasicMethod = require("awayjs-stagegl/lib/materials/methods/DiffuseBasicMethod"); + +/** + * DiffuseWrapMethod is an alternative to DiffuseBasicMethod in which the light is allowed to be "wrapped around" the normally dark area, to some extent. + * It can be used as a crude approximation to Oren-Nayar or simple subsurface scattering. + */ +class DiffuseWrapMethod extends DiffuseBasicMethod +{ + private _wrapDataRegister:ShaderRegisterElement; + private _wrapFactor:number; + + /** + * Creates a new DiffuseWrapMethod object. + * @param wrapFactor A factor to indicate the amount by which the light is allowed to wrap + */ + constructor(wrapFactor:number = .5) + { + super(); + + this.wrapFactor = wrapFactor; + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + + this._wrapDataRegister = null; + } + + /** + * A factor to indicate the amount by which the light is allowed to wrap. + */ + public get wrapFactor():number + { + return this._wrapFactor; + } + + public set wrapFactor(value:number) + { + this._wrapFactor = value; + this._wrapFactor = 1/(value + 1); + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + this._pIsFirstLight = true; + this._wrapDataRegister = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._wrapDataRegister.index*4; + + return code; + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var t:ShaderRegisterElement; + + // write in temporary if not first light, so we can add to total diffuse colour + if (this._pIsFirstLight) { + t = this._pTotalLightColorReg; + } else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + + code += "dp3 " + t + ".x, " + lightDirReg + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + + "add " + t + ".y, " + t + ".x, " + this._wrapDataRegister + ".x\n" + + "mul " + t + ".y, " + t + ".y, " + this._wrapDataRegister + ".y\n" + + "sat " + t + ".w, " + t + ".y\n" + + "mul " + t + ".xz, " + t + ".w, " + lightDirReg + ".wz\n"; + + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, lightDirReg, registerCache, sharedRegisters); + + code += "mul " + t + ", " + t + ".x, " + lightColReg + "\n"; + + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + + this._pIsFirstLight = false; + + return code; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index] = this._wrapFactor; + data[index + 1] = 1/(this._wrapFactor + 1); + } +} + +export = DiffuseWrapMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectAlphaMaskMethod.js b/lib/materials/methods/EffectAlphaMaskMethod.js new file mode 100755 index 000000000..aa229bf2b --- /dev/null +++ b/lib/materials/methods/EffectAlphaMaskMethod.js @@ -0,0 +1,86 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * EffectAlphaMaskMethod allows the use of an additional texture to specify the alpha value of the material. When used + * with the secondary uv set, it allows for a tiled main texture with independently varying alpha (useful for water + * etc). + */ +var EffectAlphaMaskMethod = (function (_super) { + __extends(EffectAlphaMaskMethod, _super); + /** + * Creates a new EffectAlphaMaskMethod object. + * + * @param texture The texture to use as the alpha mask. + * @param useSecondaryUV Indicated whether or not the secondary uv set for the mask. This allows mapping alpha independently. + */ + function EffectAlphaMaskMethod(texture, useSecondaryUV) { + if (useSecondaryUV === void 0) { useSecondaryUV = false; } + _super.call(this); + this._texture = texture; + this._useSecondaryUV = useSecondaryUV; + } + /** + * @inheritDoc + */ + EffectAlphaMaskMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsSecondaryUV = this._useSecondaryUV; + methodVO.needsUV = !this._useSecondaryUV; + }; + Object.defineProperty(EffectAlphaMaskMethod.prototype, "useSecondaryUV", { + /** + * Indicated whether or not the secondary uv set for the mask. This allows mapping alpha independently, for + * instance to tile the main texture and normal map while providing untiled alpha, for example to define the + * transparency over a tiled water surface. + */ + get: function () { + return this._useSecondaryUV; + }, + set: function (value) { + if (this._useSecondaryUV == value) + return; + this._useSecondaryUV = value; + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectAlphaMaskMethod.prototype, "texture", { + /** + * The texture to use as the alpha mask. + */ + get: function () { + return this._texture; + }, + set: function (value) { + this._texture = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectAlphaMaskMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + stage.context.activateTexture(methodVO.texturesIndex, this._texture); + }; + /** + * @inheritDoc + */ + EffectAlphaMaskMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var textureReg = registerCache.getFreeTextureReg(); + var temp = registerCache.getFreeFragmentVectorTemp(); + var uvReg = this._useSecondaryUV ? sharedRegisters.secondaryUVVarying : sharedRegisters.uvVarying; + methodVO.texturesIndex = textureReg.index; + return ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, textureReg, this._texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, uvReg) + "mul " + targetReg + ", " + targetReg + ", " + temp + ".x\n"; + }; + return EffectAlphaMaskMethod; +})(EffectMethodBase); +module.exports = EffectAlphaMaskMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectalphamaskmethod.ts"],"names":["EffectAlphaMaskMethod","EffectAlphaMaskMethod.constructor","EffectAlphaMaskMethod.iInitVO","EffectAlphaMaskMethod.useSecondaryUV","EffectAlphaMaskMethod.texture","EffectAlphaMaskMethod.iActivate","EffectAlphaMaskMethod.iGetFragmentCode"],"mappings":";;;;;;AAUA,IAAO,gBAAgB,WAAe,uDAAuD,CAAC,CAAC;AAC/F,IAAO,oBAAoB,WAAc,yDAAyD,CAAC,CAAC;AAEpG,AAKA;;;;GADG;IACG,qBAAqB;IAASA,UAA9BA,qBAAqBA,UAAyBA;IAKnDA;;;;;OAKGA;IACHA,SAXKA,qBAAqBA,CAWdA,OAAqBA,EAAEA,cAA8BA;QAA9BC,8BAA8BA,GAA9BA,sBAA8BA;QAEhEA,iBAAOA,CAACA;QAERA,IAAIA,CAACA,QAAQA,GAAGA,OAAOA,CAACA;QACxBA,IAAIA,CAACA,eAAeA,GAAGA,cAAcA,CAACA;IACvCA,CAACA;IAEDD;;OAEGA;IACIA,uCAAOA,GAAdA,UAAeA,YAA6BA,EAAEA,QAAiBA;QAE9DE,QAAQA,CAACA,gBAAgBA,GAAGA,IAAIA,CAACA,eAAeA,CAACA;QACjDA,QAAQA,CAACA,OAAOA,GAAGA,CAACA,IAAIA,CAACA,eAAeA,CAACA;IAC1CA,CAACA;IAODF,sBAAWA,iDAAcA;QALzBA;;;;WAIGA;aACHA;YAECG,MAAMA,CAACA,IAAIA,CAACA,eAAeA,CAACA;QAC7BA,CAACA;aAEDH,UAA0BA,KAAaA;YAEtCG,EAAEA,CAACA,CAACA,IAAIA,CAACA,eAAeA,IAAIA,KAAKA,CAACA;gBACjCA,MAAMA,CAACA;YACRA,IAAIA,CAACA,eAAeA,GAAGA,KAAKA,CAACA;YAC7BA,IAAIA,CAACA,wBAAwBA,EAAEA,CAACA;QACjCA,CAACA;;;OARAH;IAaDA,sBAAWA,0CAAOA;QAHlBA;;WAEGA;aACHA;YAECI,MAAMA,CAACA,IAAIA,CAACA,QAAQA,CAACA;QACtBA,CAACA;aAEDJ,UAAmBA,KAAmBA;YAErCI,IAAIA,CAACA,QAAQA,GAAGA,KAAKA,CAACA;QACvBA,CAACA;;;OALAJ;IAODA;;OAEGA;IACIA,yCAASA,GAAhBA,UAAiBA,YAAiCA,EAAEA,QAAiBA,EAAEA,KAAWA;QAE9DK,KAAKA,CAACA,OAAQA,CAACA,eAAeA,CAACA,QAAQA,CAACA,aAAaA,EAAEA,IAAIA,CAACA,QAAQA,CAACA,CAACA;IAC1FA,CAACA;IAEDL;;OAEGA;IACIA,gDAAgBA,GAAvBA,UAAwBA,YAA6BA,EAAEA,QAAiBA,EAAEA,SAA+BA,EAAEA,aAAiCA,EAAEA,eAAkCA;QAE/KM,IAAIA,UAAUA,GAAyBA,aAAaA,CAACA,iBAAiBA,EAAEA,CAACA;QACzEA,IAAIA,IAAIA,GAAyBA,aAAaA,CAACA,yBAAyBA,EAAEA,CAACA;QAC3EA,IAAIA,KAAKA,GAAyBA,IAAIA,CAACA,eAAeA,GAAEA,eAAeA,CAACA,kBAAkBA,GAAGA,eAAeA,CAACA,SAASA,CAACA;QACvHA,QAAQA,CAACA,aAAaA,GAAGA,UAAUA,CAACA,KAAKA,CAACA;QAE1CA,MAAMA,CAACA,oBAAoBA,CAACA,kBAAkBA,CAACA,IAAIA,EAAEA,eAAeA,EAAEA,UAAUA,EAAEA,IAAIA,CAACA,QAAQA,EAAEA,YAAYA,CAACA,iBAAiBA,EAAEA,YAAYA,CAACA,cAAcA,EAAEA,YAAYA,CAACA,aAAaA,EAAEA,KAAKA,CAACA,GAC/LA,MAAMA,GAAGA,SAASA,GAAGA,IAAIA,GAAGA,SAASA,GAAGA,IAAIA,GAAGA,IAAIA,GAAGA,MAAMA,CAACA;IAC/DA,CAACA;IACFN,4BAACA;AAADA,CAhFA,AAgFCA,EAhFmC,gBAAgB,EAgFnD;AAED,AAA+B,iBAAtB,qBAAqB,CAAC","file":"materials/methods/EffectAlphaMaskMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * EffectAlphaMaskMethod allows the use of an additional texture to specify the alpha value of the material. When used\n * with the secondary uv set, it allows for a tiled main texture with independently varying alpha (useful for water\n * etc).\n */\nclass EffectAlphaMaskMethod extends EffectMethodBase\n{\n\tprivate _texture:Texture2DBase;\n\tprivate _useSecondaryUV:boolean;\n\n\t/**\n\t * Creates a new EffectAlphaMaskMethod object.\n\t *\n\t * @param texture The texture to use as the alpha mask.\n\t * @param useSecondaryUV Indicated whether or not the secondary uv set for the mask. This allows mapping alpha independently.\n\t */\n\tconstructor(texture:Texture2DBase, useSecondaryUV:boolean = false)\n\t{\n\t\tsuper();\n\n\t\tthis._texture = texture;\n\t\tthis._useSecondaryUV = useSecondaryUV;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsSecondaryUV = this._useSecondaryUV;\n\t\tmethodVO.needsUV = !this._useSecondaryUV;\n\t}\n\n\t/**\n\t * Indicated whether or not the secondary uv set for the mask. This allows mapping alpha independently, for\n\t * instance to tile the main texture and normal map while providing untiled alpha, for example to define the\n\t * transparency over a tiled water surface.\n\t */\n\tpublic get useSecondaryUV():boolean\n\t{\n\t\treturn this._useSecondaryUV;\n\t}\n\n\tpublic set useSecondaryUV(value:boolean)\n\t{\n\t\tif (this._useSecondaryUV == value)\n\t\t\treturn;\n\t\tthis._useSecondaryUV = value;\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * The texture to use as the alpha mask.\n\t */\n\tpublic get texture():Texture2DBase\n\t{\n\t\treturn this._texture;\n\t}\n\n\tpublic set texture(value:Texture2DBase)\n\t{\n\t\tthis._texture = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex, this._texture);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar textureReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tvar uvReg:ShaderRegisterElement = this._useSecondaryUV? sharedRegisters.secondaryUVVarying : sharedRegisters.uvVarying;\n\t\tmethodVO.texturesIndex = textureReg.index;\n\n\t\treturn ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, textureReg, this._texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, uvReg) +\n\t\t\t\"mul \" + targetReg + \", \" + targetReg + \", \" + temp + \".x\\n\";\n\t}\n}\n\nexport = EffectAlphaMaskMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectAlphaMaskMethod.ts b/lib/materials/methods/EffectAlphaMaskMethod.ts new file mode 100644 index 000000000..e4cc62a76 --- /dev/null +++ b/lib/materials/methods/EffectAlphaMaskMethod.ts @@ -0,0 +1,101 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * EffectAlphaMaskMethod allows the use of an additional texture to specify the alpha value of the material. When used + * with the secondary uv set, it allows for a tiled main texture with independently varying alpha (useful for water + * etc). + */ +class EffectAlphaMaskMethod extends EffectMethodBase +{ + private _texture:Texture2DBase; + private _useSecondaryUV:boolean; + + /** + * Creates a new EffectAlphaMaskMethod object. + * + * @param texture The texture to use as the alpha mask. + * @param useSecondaryUV Indicated whether or not the secondary uv set for the mask. This allows mapping alpha independently. + */ + constructor(texture:Texture2DBase, useSecondaryUV:boolean = false) + { + super(); + + this._texture = texture; + this._useSecondaryUV = useSecondaryUV; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + methodVO.needsSecondaryUV = this._useSecondaryUV; + methodVO.needsUV = !this._useSecondaryUV; + } + + /** + * Indicated whether or not the secondary uv set for the mask. This allows mapping alpha independently, for + * instance to tile the main texture and normal map while providing untiled alpha, for example to define the + * transparency over a tiled water surface. + */ + public get useSecondaryUV():boolean + { + return this._useSecondaryUV; + } + + public set useSecondaryUV(value:boolean) + { + if (this._useSecondaryUV == value) + return; + this._useSecondaryUV = value; + this.iInvalidateShaderProgram(); + } + + /** + * The texture to use as the alpha mask. + */ + public get texture():Texture2DBase + { + return this._texture; + } + + public set texture(value:Texture2DBase) + { + this._texture = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + ( stage.context).activateTexture(methodVO.texturesIndex, this._texture); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var textureReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + var uvReg:ShaderRegisterElement = this._useSecondaryUV? sharedRegisters.secondaryUVVarying : sharedRegisters.uvVarying; + methodVO.texturesIndex = textureReg.index; + + return ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, textureReg, this._texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, uvReg) + + "mul " + targetReg + ", " + targetReg + ", " + temp + ".x\n"; + } +} + +export = EffectAlphaMaskMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectColorMatrixMethod.js b/lib/materials/methods/EffectColorMatrixMethod.js new file mode 100755 index 000000000..a4d6299e6 --- /dev/null +++ b/lib/materials/methods/EffectColorMatrixMethod.js @@ -0,0 +1,89 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +/** + * EffectColorMatrixMethod provides a shading method that changes the colour of a material analogous to a ColorMatrixFilter. + */ +var EffectColorMatrixMethod = (function (_super) { + __extends(EffectColorMatrixMethod, _super); + /** + * Creates a new EffectColorTransformMethod. + * + * @param matrix An array of 20 items for 4 x 5 color transform. + */ + function EffectColorMatrixMethod(matrix) { + _super.call(this); + if (matrix.length != 20) + throw new Error("Matrix length must be 20!"); + this._matrix = matrix; + } + Object.defineProperty(EffectColorMatrixMethod.prototype, "colorMatrix", { + /** + * The 4 x 5 matrix to transform the color of the material. + */ + get: function () { + return this._matrix; + }, + set: function (value) { + this._matrix = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectColorMatrixMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var code = ""; + var colorMultReg = registerCache.getFreeFragmentConstant(); + registerCache.getFreeFragmentConstant(); + registerCache.getFreeFragmentConstant(); + registerCache.getFreeFragmentConstant(); + var colorOffsetReg = registerCache.getFreeFragmentConstant(); + methodVO.fragmentConstantsIndex = colorMultReg.index * 4; + var temp = registerCache.getFreeFragmentVectorTemp(); + code += "m44 " + temp + ", " + targetReg + ", " + colorMultReg + "\n" + "add " + targetReg + ", " + temp + ", " + colorOffsetReg + "\n"; + return code; + }; + /** + * @inheritDoc + */ + EffectColorMatrixMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + var matrix = this._matrix; + var index = methodVO.fragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + // r + data[index] = matrix[0]; + data[index + 1] = matrix[1]; + data[index + 2] = matrix[2]; + data[index + 3] = matrix[3]; + // g + data[index + 4] = matrix[5]; + data[index + 5] = matrix[6]; + data[index + 6] = matrix[7]; + data[index + 7] = matrix[8]; + // b + data[index + 8] = matrix[10]; + data[index + 9] = matrix[11]; + data[index + 10] = matrix[12]; + data[index + 11] = matrix[13]; + // a + data[index + 12] = matrix[15]; + data[index + 13] = matrix[16]; + data[index + 14] = matrix[17]; + data[index + 15] = matrix[18]; + // rgba offset + data[index + 16] = matrix[4]; + data[index + 17] = matrix[9]; + data[index + 18] = matrix[14]; + data[index + 19] = matrix[19]; + }; + return EffectColorMatrixMethod; +})(EffectMethodBase); +module.exports = EffectColorMatrixMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectcolormatrixmethod.ts"],"names":["EffectColorMatrixMethod","EffectColorMatrixMethod.constructor","EffectColorMatrixMethod.colorMatrix","EffectColorMatrixMethod.iGetFragmentCode","EffectColorMatrixMethod.iActivate"],"mappings":"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","file":"materials/methods/EffectColorMatrixMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\n\n/**\n * EffectColorMatrixMethod provides a shading method that changes the colour of a material analogous to a ColorMatrixFilter.\n */\nclass EffectColorMatrixMethod extends EffectMethodBase\n{\n\tprivate _matrix:Array<number>;\n\n\t/**\n\t * Creates a new EffectColorTransformMethod.\n\t *\n\t * @param matrix An array of 20 items for 4 x 5 color transform.\n\t */\n\tconstructor(matrix:Array<number>)\n\t{\n\t\tsuper();\n\n\t\tif (matrix.length != 20)\n\t\t\tthrow new Error(\"Matrix length must be 20!\");\n\n\t\tthis._matrix = matrix;\n\t}\n\n\t/**\n\t * The 4 x 5 matrix to transform the color of the material.\n\t */\n\tpublic get colorMatrix():Array<number>\n\t{\n\t\treturn this._matrix;\n\t}\n\n\tpublic set colorMatrix(value:Array<number>)\n\t{\n\t\tthis._matrix = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar colorMultReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tregisterCache.getFreeFragmentConstant();\n\t\tregisterCache.getFreeFragmentConstant();\n\t\tregisterCache.getFreeFragmentConstant();\n\n\t\tvar colorOffsetReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\n\t\tmethodVO.fragmentConstantsIndex = colorMultReg.index*4;\n\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\n\t\tcode += \"m44 \" + temp + \", \" + targetReg + \", \" + colorMultReg + \"\\n\" +\n\t\t\t\t\"add \" + targetReg + \", \" + temp + \", \" + colorOffsetReg + \"\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tvar matrix:Array<number> = this._matrix;\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\n\t\t// r\n\t\tdata[index] = matrix[0];\n\t\tdata[index + 1] = matrix[1];\n\t\tdata[index + 2] = matrix[2];\n\t\tdata[index + 3] = matrix[3];\n\n\t\t// g\n\t\tdata[index + 4] = matrix[5];\n\t\tdata[index + 5] = matrix[6];\n\t\tdata[index + 6] = matrix[7];\n\t\tdata[index + 7] = matrix[8];\n\n\t\t// b\n\t\tdata[index + 8] = matrix[10];\n\t\tdata[index + 9] = matrix[11];\n\t\tdata[index + 10] = matrix[12];\n\t\tdata[index + 11] = matrix[13];\n\n\t\t// a\n\t\tdata[index + 12] = matrix[15];\n\t\tdata[index + 13] = matrix[16];\n\t\tdata[index + 14] = matrix[17];\n\t\tdata[index + 15] = matrix[18];\n\n\t\t// rgba offset\n\t\tdata[index + 16] = matrix[4];\n\t\tdata[index + 17] = matrix[9];\n\t\tdata[index + 18] = matrix[14];\n\t\tdata[index + 19] = matrix[19];\n\t}\n}\n\nexport = EffectColorMatrixMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectColorMatrixMethod.ts b/lib/materials/methods/EffectColorMatrixMethod.ts new file mode 100644 index 000000000..d4fa01402 --- /dev/null +++ b/lib/materials/methods/EffectColorMatrixMethod.ts @@ -0,0 +1,108 @@ +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); + +/** + * EffectColorMatrixMethod provides a shading method that changes the colour of a material analogous to a ColorMatrixFilter. + */ +class EffectColorMatrixMethod extends EffectMethodBase +{ + private _matrix:Array; + + /** + * Creates a new EffectColorTransformMethod. + * + * @param matrix An array of 20 items for 4 x 5 color transform. + */ + constructor(matrix:Array) + { + super(); + + if (matrix.length != 20) + throw new Error("Matrix length must be 20!"); + + this._matrix = matrix; + } + + /** + * The 4 x 5 matrix to transform the color of the material. + */ + public get colorMatrix():Array + { + return this._matrix; + } + + public set colorMatrix(value:Array) + { + this._matrix = value; + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var colorMultReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + registerCache.getFreeFragmentConstant(); + registerCache.getFreeFragmentConstant(); + registerCache.getFreeFragmentConstant(); + + var colorOffsetReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + + methodVO.fragmentConstantsIndex = colorMultReg.index*4; + + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + + code += "m44 " + temp + ", " + targetReg + ", " + colorMultReg + "\n" + + "add " + targetReg + ", " + temp + ", " + colorOffsetReg + "\n"; + + return code; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + var matrix:Array = this._matrix; + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + + // r + data[index] = matrix[0]; + data[index + 1] = matrix[1]; + data[index + 2] = matrix[2]; + data[index + 3] = matrix[3]; + + // g + data[index + 4] = matrix[5]; + data[index + 5] = matrix[6]; + data[index + 6] = matrix[7]; + data[index + 7] = matrix[8]; + + // b + data[index + 8] = matrix[10]; + data[index + 9] = matrix[11]; + data[index + 10] = matrix[12]; + data[index + 11] = matrix[13]; + + // a + data[index + 12] = matrix[15]; + data[index + 13] = matrix[16]; + data[index + 14] = matrix[17]; + data[index + 15] = matrix[18]; + + // rgba offset + data[index + 16] = matrix[4]; + data[index + 17] = matrix[9]; + data[index + 18] = matrix[14]; + data[index + 19] = matrix[19]; + } +} + +export = EffectColorMatrixMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectEnvMapMethod.js b/lib/materials/methods/EffectEnvMapMethod.js new file mode 100755 index 000000000..a899ce018 --- /dev/null +++ b/lib/materials/methods/EffectEnvMapMethod.js @@ -0,0 +1,112 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * EffectEnvMapMethod provides a material method to perform reflection mapping using cube maps. + */ +var EffectEnvMapMethod = (function (_super) { + __extends(EffectEnvMapMethod, _super); + /** + * Creates an EffectEnvMapMethod object. + * @param envMap The environment map containing the reflected scene. + * @param alpha The reflectivity of the surface. + */ + function EffectEnvMapMethod(envMap, alpha) { + if (alpha === void 0) { alpha = 1; } + _super.call(this); + this._cubeTexture = envMap; + this._alpha = alpha; + } + Object.defineProperty(EffectEnvMapMethod.prototype, "mask", { + /** + * An optional texture to modulate the reflectivity of the surface. + */ + get: function () { + return this._mask; + }, + set: function (value) { + if (value != this._mask || (value && this._mask && (value.hasMipmaps != this._mask.hasMipmaps || value.format != this._mask.format))) + this.iInvalidateShaderProgram(); + this._mask = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectEnvMapMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsNormals = true; + methodVO.needsView = true; + methodVO.needsUV = this._mask != null; + }; + Object.defineProperty(EffectEnvMapMethod.prototype, "envMap", { + /** + * The cubic environment map containing the reflected scene. + */ + get: function () { + return this._cubeTexture; + }, + set: function (value) { + this._cubeTexture = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectEnvMapMethod.prototype.dispose = function () { + }; + Object.defineProperty(EffectEnvMapMethod.prototype, "alpha", { + /** + * The reflectivity of the surface. + */ + get: function () { + return this._alpha; + }, + set: function (value) { + this._alpha = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectEnvMapMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex] = this._alpha; + stage.context.activateCubeTexture(methodVO.texturesIndex, this._cubeTexture); + if (this._mask) + stage.context.activateTexture(methodVO.texturesIndex + 1, this._mask); + }; + /** + * @inheritDoc + */ + EffectEnvMapMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var dataRegister = registerCache.getFreeFragmentConstant(); + var temp = registerCache.getFreeFragmentVectorTemp(); + var code = ""; + var cubeMapReg = registerCache.getFreeTextureReg(); + methodVO.texturesIndex = cubeMapReg.index; + methodVO.fragmentConstantsIndex = dataRegister.index * 4; + registerCache.addFragmentTempUsages(temp, 1); + var temp2 = registerCache.getFreeFragmentVectorTemp(); + // r = I - 2(I.N)*N + code += "dp3 " + temp + ".w, " + sharedRegisters.viewDirFragment + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + "add " + temp + ".w, " + temp + ".w, " + temp + ".w\n" + "mul " + temp + ".xyz, " + sharedRegisters.normalFragment + ".xyz, " + temp + ".w\n" + "sub " + temp + ".xyz, " + temp + ".xyz, " + sharedRegisters.viewDirFragment + ".xyz\n" + ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, temp) + "sub " + temp2 + ".w, " + temp + ".w, fc0.x\n" + "kil " + temp2 + ".w\n" + "sub " + temp + ", " + temp + ", " + targetReg + "\n"; + if (this._mask) + code += ShaderCompilerHelper.getTex2DSampleCode(temp2, sharedRegisters, registerCache.getFreeTextureReg(), this._mask, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) + "mul " + temp + ", " + temp2 + ", " + temp + "\n"; + code += "mul " + temp + ", " + temp + ", " + dataRegister + ".x\n" + "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; + registerCache.removeFragmentTempUsage(temp); + return code; + }; + return EffectEnvMapMethod; +})(EffectMethodBase); +module.exports = EffectEnvMapMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectenvmapmethod.ts"],"names":["EffectEnvMapMethod","EffectEnvMapMethod.constructor","EffectEnvMapMethod.mask","EffectEnvMapMethod.iInitVO","EffectEnvMapMethod.envMap","EffectEnvMapMethod.dispose","EffectEnvMapMethod.alpha","EffectEnvMapMethod.iActivate","EffectEnvMapMethod.iGetFragmentCode"],"mappings":"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","file":"materials/methods/EffectEnvMapMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import CubeTextureBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/CubeTextureBase\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * EffectEnvMapMethod provides a material method to perform reflection mapping using cube maps.\n */\nclass EffectEnvMapMethod extends EffectMethodBase\n{\n\tprivate _cubeTexture:CubeTextureBase;\n\tprivate _alpha:number;\n\tprivate _mask:Texture2DBase;\n\n\t/**\n\t * Creates an EffectEnvMapMethod object.\n\t * @param envMap The environment map containing the reflected scene.\n\t * @param alpha The reflectivity of the surface.\n\t */\n\tconstructor(envMap:CubeTextureBase, alpha:number = 1)\n\t{\n\t\tsuper();\n\t\tthis._cubeTexture = envMap;\n\t\tthis._alpha = alpha;\n\n\t}\n\n\t/**\n\t * An optional texture to modulate the reflectivity of the surface.\n\t */\n\tpublic get mask():Texture2DBase\n\t{\n\t\treturn this._mask;\n\t}\n\n\tpublic set mask(value:Texture2DBase)\n\t{\n\t\tif (value != this._mask || (value && this._mask && (value.hasMipmaps != this._mask.hasMipmaps || value.format != this._mask.format)))\n\t\t\tthis.iInvalidateShaderProgram();\n\n\t\tthis._mask = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsNormals = true;\n\t\tmethodVO.needsView = true;\n\t\tmethodVO.needsUV = this._mask != null;\n\t}\n\n\t/**\n\t * The cubic environment map containing the reflected scene.\n\t */\n\tpublic get envMap():CubeTextureBase\n\t{\n\t\treturn this._cubeTexture;\n\t}\n\n\tpublic set envMap(value:CubeTextureBase)\n\t{\n\t\tthis._cubeTexture = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t}\n\n\t/**\n\t * The reflectivity of the surface.\n\t */\n\tpublic get alpha():number\n\t{\n\t\treturn this._alpha;\n\t}\n\n\tpublic set alpha(value:number)\n\t{\n\t\tthis._alpha = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tshaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex] = this._alpha;\n\n\t\t(<IContextStageGL> stage.context).activateCubeTexture(methodVO.texturesIndex, this._cubeTexture);\n\t\tif (this._mask)\n\t\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex + 1, this._mask);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar dataRegister:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tvar code:string = \"\";\n\t\tvar cubeMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\n\t\tmethodVO.texturesIndex = cubeMapReg.index;\n\t\tmethodVO.fragmentConstantsIndex = dataRegister.index*4;\n\n\t\tregisterCache.addFragmentTempUsages(temp, 1);\n\t\tvar temp2:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\n\t\t// r = I - 2(I.N)*N\n\t\tcode += \"dp3 \" + temp + \".w, \" + sharedRegisters.viewDirFragment + \".xyz, \" + sharedRegisters.normalFragment + \".xyz\\n\" +\n\t\t\t\t\"add \" + temp + \".w, \" + temp + \".w, \" + temp + \".w\\n\" +\n\t\t\t\t\"mul \" + temp + \".xyz, \" + sharedRegisters.normalFragment + \".xyz, \" + temp + \".w\\n\" +\n\t\t\t\t\"sub \" + temp + \".xyz, \" + temp + \".xyz, \" + sharedRegisters.viewDirFragment + \".xyz\\n\" +\n\t\t\tShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, temp) +\n\t\t\t\t\"sub \" + temp2 + \".w, \" + temp + \".w, fc0.x\\n\" + // -.5\n\t\t\t\t\"kil \" + temp2 + \".w\\n\" +\t// used for real time reflection mapping - if alpha is not 1 (mock texture) kil output\n\t\t\t\t\"sub \" + temp + \", \" + temp + \", \" + targetReg + \"\\n\";\n\n\t\tif (this._mask)\n\t\t\tcode += ShaderCompilerHelper.getTex2DSampleCode(temp2, sharedRegisters, registerCache.getFreeTextureReg(), this._mask, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) +\n\t\t\t\t\"mul \" + temp + \", \" + temp2 + \", \" + temp + \"\\n\";\n\n\t\tcode += \"mul \" + temp + \", \" + temp + \", \" + dataRegister + \".x\\n\" +\n\t\t\t\t\"add \" + targetReg + \", \" + targetReg + \", \" + temp + \"\\n\";\n\n\t\tregisterCache.removeFragmentTempUsage(temp);\n\n\t\treturn code;\n\t}\n}\n\nexport = EffectEnvMapMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectEnvMapMethod.ts b/lib/materials/methods/EffectEnvMapMethod.ts new file mode 100755 index 000000000..2571c0d45 --- /dev/null +++ b/lib/materials/methods/EffectEnvMapMethod.ts @@ -0,0 +1,146 @@ +import CubeTextureBase = require("awayjs-core/lib/textures/CubeTextureBase"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * EffectEnvMapMethod provides a material method to perform reflection mapping using cube maps. + */ +class EffectEnvMapMethod extends EffectMethodBase +{ + private _cubeTexture:CubeTextureBase; + private _alpha:number; + private _mask:Texture2DBase; + + /** + * Creates an EffectEnvMapMethod object. + * @param envMap The environment map containing the reflected scene. + * @param alpha The reflectivity of the surface. + */ + constructor(envMap:CubeTextureBase, alpha:number = 1) + { + super(); + this._cubeTexture = envMap; + this._alpha = alpha; + + } + + /** + * An optional texture to modulate the reflectivity of the surface. + */ + public get mask():Texture2DBase + { + return this._mask; + } + + public set mask(value:Texture2DBase) + { + if (value != this._mask || (value && this._mask && (value.hasMipmaps != this._mask.hasMipmaps || value.format != this._mask.format))) + this.iInvalidateShaderProgram(); + + this._mask = value; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + methodVO.needsNormals = true; + methodVO.needsView = true; + methodVO.needsUV = this._mask != null; + } + + /** + * The cubic environment map containing the reflected scene. + */ + public get envMap():CubeTextureBase + { + return this._cubeTexture; + } + + public set envMap(value:CubeTextureBase) + { + this._cubeTexture = value; + } + + /** + * @inheritDoc + */ + public dispose() + { + } + + /** + * The reflectivity of the surface. + */ + public get alpha():number + { + return this._alpha; + } + + public set alpha(value:number) + { + this._alpha = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex] = this._alpha; + + ( stage.context).activateCubeTexture(methodVO.texturesIndex, this._cubeTexture); + if (this._mask) + ( stage.context).activateTexture(methodVO.texturesIndex + 1, this._mask); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var dataRegister:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + var code:string = ""; + var cubeMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + + methodVO.texturesIndex = cubeMapReg.index; + methodVO.fragmentConstantsIndex = dataRegister.index*4; + + registerCache.addFragmentTempUsages(temp, 1); + var temp2:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + + // r = I - 2(I.N)*N + code += "dp3 " + temp + ".w, " + sharedRegisters.viewDirFragment + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + + "add " + temp + ".w, " + temp + ".w, " + temp + ".w\n" + + "mul " + temp + ".xyz, " + sharedRegisters.normalFragment + ".xyz, " + temp + ".w\n" + + "sub " + temp + ".xyz, " + temp + ".xyz, " + sharedRegisters.viewDirFragment + ".xyz\n" + + ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, temp) + + "sub " + temp2 + ".w, " + temp + ".w, fc0.x\n" + // -.5 + "kil " + temp2 + ".w\n" + // used for real time reflection mapping - if alpha is not 1 (mock texture) kil output + "sub " + temp + ", " + temp + ", " + targetReg + "\n"; + + if (this._mask) + code += ShaderCompilerHelper.getTex2DSampleCode(temp2, sharedRegisters, registerCache.getFreeTextureReg(), this._mask, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) + + "mul " + temp + ", " + temp2 + ", " + temp + "\n"; + + code += "mul " + temp + ", " + temp + ", " + dataRegister + ".x\n" + + "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; + + registerCache.removeFragmentTempUsage(temp); + + return code; + } +} + +export = EffectEnvMapMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectFogMethod.js b/lib/materials/methods/EffectFogMethod.js new file mode 100755 index 000000000..21319c6f3 --- /dev/null +++ b/lib/materials/methods/EffectFogMethod.js @@ -0,0 +1,117 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +/** + * EffectFogMethod provides a method to add distance-based fog to a material. + */ +var EffectFogMethod = (function (_super) { + __extends(EffectFogMethod, _super); + /** + * Creates a new EffectFogMethod object. + * @param minDistance The distance from which the fog starts appearing. + * @param maxDistance The distance at which the fog is densest. + * @param fogColor The colour of the fog. + */ + function EffectFogMethod(minDistance, maxDistance, fogColor) { + if (fogColor === void 0) { fogColor = 0x808080; } + _super.call(this); + this._minDistance = 0; + this._maxDistance = 1000; + this.minDistance = minDistance; + this.maxDistance = maxDistance; + this.fogColor = fogColor; + } + /** + * @inheritDoc + */ + EffectFogMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsProjection = true; + }; + /** + * @inheritDoc + */ + EffectFogMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var data = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + data[index + 3] = 1; + data[index + 6] = 0; + data[index + 7] = 0; + }; + Object.defineProperty(EffectFogMethod.prototype, "minDistance", { + /** + * The distance from which the fog starts appearing. + */ + get: function () { + return this._minDistance; + }, + set: function (value) { + this._minDistance = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectFogMethod.prototype, "maxDistance", { + /** + * The distance at which the fog is densest. + */ + get: function () { + return this._maxDistance; + }, + set: function (value) { + this._maxDistance = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectFogMethod.prototype, "fogColor", { + /** + * The colour of the fog. + */ + get: function () { + return this._fogColor; + }, + set: function (value /*uint*/) { + this._fogColor = value; + this._fogR = ((value >> 16) & 0xff) / 0xff; + this._fogG = ((value >> 8) & 0xff) / 0xff; + this._fogB = (value & 0xff) / 0xff; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectFogMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + var data = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + data[index] = this._fogR; + data[index + 1] = this._fogG; + data[index + 2] = this._fogB; + data[index + 4] = this._minDistance; + data[index + 5] = 1 / (this._maxDistance - this._minDistance); + }; + /** + * @inheritDoc + */ + EffectFogMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var fogColor = registerCache.getFreeFragmentConstant(); + var fogData = registerCache.getFreeFragmentConstant(); + var temp = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(temp, 1); + var temp2 = registerCache.getFreeFragmentVectorTemp(); + var code = ""; + methodVO.fragmentConstantsIndex = fogColor.index * 4; + code += "sub " + temp2 + ".w, " + sharedRegisters.projectionFragment + ".z, " + fogData + ".x\n" + "mul " + temp2 + ".w, " + temp2 + ".w, " + fogData + ".y\n" + "sat " + temp2 + ".w, " + temp2 + ".w\n" + "sub " + temp + ", " + fogColor + ", " + targetReg + "\n" + "mul " + temp + ", " + temp + ", " + temp2 + ".w\n" + "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; // fogRatio*(fogColor- col) + col + registerCache.removeFragmentTempUsage(temp); + return code; + }; + return EffectFogMethod; +})(EffectMethodBase); +module.exports = EffectFogMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectfogmethod.ts"],"names":["EffectFogMethod","EffectFogMethod.constructor","EffectFogMethod.iInitVO","EffectFogMethod.iInitConstants","EffectFogMethod.minDistance","EffectFogMethod.maxDistance","EffectFogMethod.fogColor","EffectFogMethod.iActivate","EffectFogMethod.iGetFragmentCode"],"mappings":"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","file":"materials/methods/EffectFogMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\n\n/**\n * EffectFogMethod provides a method to add distance-based fog to a material.\n */\nclass EffectFogMethod extends EffectMethodBase\n{\n\tprivate _minDistance:number = 0;\n\tprivate _maxDistance:number = 1000;\n\tprivate _fogColor:number /*uint*/;\n\tprivate _fogR:number;\n\tprivate _fogG:number;\n\tprivate _fogB:number;\n\n\t/**\n\t * Creates a new EffectFogMethod object.\n\t * @param minDistance The distance from which the fog starts appearing.\n\t * @param maxDistance The distance at which the fog is densest.\n\t * @param fogColor The colour of the fog.\n\t */\n\tconstructor(minDistance:number, maxDistance:number, fogColor:number /*uint*/ = 0x808080)\n\t{\n\t\tsuper();\n\t\tthis.minDistance = minDistance;\n\t\tthis.maxDistance = maxDistance;\n\t\tthis.fogColor = fogColor;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsProjection = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tdata[index + 3] = 1;\n\t\tdata[index + 6] = 0;\n\t\tdata[index + 7] = 0;\n\t}\n\n\t/**\n\t * The distance from which the fog starts appearing.\n\t */\n\tpublic get minDistance():number\n\t{\n\t\treturn this._minDistance;\n\t}\n\n\tpublic set minDistance(value:number)\n\t{\n\t\tthis._minDistance = value;\n\t}\n\n\t/**\n\t * The distance at which the fog is densest.\n\t */\n\tpublic get maxDistance():number\n\t{\n\t\treturn this._maxDistance;\n\t}\n\n\tpublic set maxDistance(value:number)\n\t{\n\t\tthis._maxDistance = value;\n\t}\n\n\t/**\n\t * The colour of the fog.\n\t */\n\tpublic get fogColor():number /*uint*/\n\t{\n\t\treturn this._fogColor;\n\t}\n\n\tpublic set fogColor(value:number/*uint*/)\n\t{\n\t\tthis._fogColor = value;\n\t\tthis._fogR = ((value >> 16) & 0xff)/0xff;\n\t\tthis._fogG = ((value >> 8) & 0xff)/0xff;\n\t\tthis._fogB = (value & 0xff)/0xff;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tdata[index] = this._fogR;\n\t\tdata[index + 1] = this._fogG;\n\t\tdata[index + 2] = this._fogB;\n\t\tdata[index + 4] = this._minDistance;\n\t\tdata[index + 5] = 1/(this._maxDistance - this._minDistance);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar fogColor:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar fogData:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tregisterCache.addFragmentTempUsages(temp, 1);\n\t\tvar temp2:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tvar code:string = \"\";\n\t\tmethodVO.fragmentConstantsIndex = fogColor.index*4;\n\n\t\tcode += \"sub \" + temp2 + \".w, \" + sharedRegisters.projectionFragment + \".z, \" + fogData + \".x\\n\" +\n\t\t\t\t\"mul \" + temp2 + \".w, \" + temp2 + \".w, \" + fogData + \".y\\n\" +\n\t\t\t\t\"sat \" + temp2 + \".w, \" + temp2 + \".w\\n\" +\n\t\t\t\t\"sub \" + temp + \", \" + fogColor + \", \" + targetReg + \"\\n\" + // (fogColor- col)\n\t\t\t\t\"mul \" + temp + \", \" + temp + \", \" + temp2 + \".w\\n\" + // (fogColor- col)*fogRatio\n\t\t\t\t\"add \" + targetReg + \", \" + targetReg + \", \" + temp + \"\\n\"; // fogRatio*(fogColor- col) + col\n\n\t\tregisterCache.removeFragmentTempUsage(temp);\n\n\t\treturn code;\n\t}\n}\n\nexport = EffectFogMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectFogMethod.ts b/lib/materials/methods/EffectFogMethod.ts new file mode 100644 index 000000000..a6be9b1d1 --- /dev/null +++ b/lib/materials/methods/EffectFogMethod.ts @@ -0,0 +1,138 @@ +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); + +/** + * EffectFogMethod provides a method to add distance-based fog to a material. + */ +class EffectFogMethod extends EffectMethodBase +{ + private _minDistance:number = 0; + private _maxDistance:number = 1000; + private _fogColor:number /*uint*/; + private _fogR:number; + private _fogG:number; + private _fogB:number; + + /** + * Creates a new EffectFogMethod object. + * @param minDistance The distance from which the fog starts appearing. + * @param maxDistance The distance at which the fog is densest. + * @param fogColor The colour of the fog. + */ + constructor(minDistance:number, maxDistance:number, fogColor:number /*uint*/ = 0x808080) + { + super(); + this.minDistance = minDistance; + this.maxDistance = maxDistance; + this.fogColor = fogColor; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + methodVO.needsProjection = true; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + var data:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + data[index + 3] = 1; + data[index + 6] = 0; + data[index + 7] = 0; + } + + /** + * The distance from which the fog starts appearing. + */ + public get minDistance():number + { + return this._minDistance; + } + + public set minDistance(value:number) + { + this._minDistance = value; + } + + /** + * The distance at which the fog is densest. + */ + public get maxDistance():number + { + return this._maxDistance; + } + + public set maxDistance(value:number) + { + this._maxDistance = value; + } + + /** + * The colour of the fog. + */ + public get fogColor():number /*uint*/ + { + return this._fogColor; + } + + public set fogColor(value:number/*uint*/) + { + this._fogColor = value; + this._fogR = ((value >> 16) & 0xff)/0xff; + this._fogG = ((value >> 8) & 0xff)/0xff; + this._fogB = (value & 0xff)/0xff; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + var data:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + data[index] = this._fogR; + data[index + 1] = this._fogG; + data[index + 2] = this._fogB; + data[index + 4] = this._minDistance; + data[index + 5] = 1/(this._maxDistance - this._minDistance); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var fogColor:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var fogData:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(temp, 1); + var temp2:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + var code:string = ""; + methodVO.fragmentConstantsIndex = fogColor.index*4; + + code += "sub " + temp2 + ".w, " + sharedRegisters.projectionFragment + ".z, " + fogData + ".x\n" + + "mul " + temp2 + ".w, " + temp2 + ".w, " + fogData + ".y\n" + + "sat " + temp2 + ".w, " + temp2 + ".w\n" + + "sub " + temp + ", " + fogColor + ", " + targetReg + "\n" + // (fogColor- col) + "mul " + temp + ", " + temp + ", " + temp2 + ".w\n" + // (fogColor- col)*fogRatio + "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; // fogRatio*(fogColor- col) + col + + registerCache.removeFragmentTempUsage(temp); + + return code; + } +} + +export = EffectFogMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectFresnelEnvMapMethod.js b/lib/materials/methods/EffectFresnelEnvMapMethod.js new file mode 100755 index 000000000..3b64df18e --- /dev/null +++ b/lib/materials/methods/EffectFresnelEnvMapMethod.js @@ -0,0 +1,155 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * EffectFresnelEnvMapMethod provides a method to add fresnel-based reflectivity to an object using cube maps, which gets + * stronger as the viewing angle becomes more grazing. + */ +var EffectFresnelEnvMapMethod = (function (_super) { + __extends(EffectFresnelEnvMapMethod, _super); + /** + * Creates a new EffectFresnelEnvMapMethod object. + * + * @param envMap The environment map containing the reflected scene. + * @param alpha The reflectivity of the material. + */ + function EffectFresnelEnvMapMethod(envMap, alpha) { + if (alpha === void 0) { alpha = 1; } + _super.call(this); + this._fresnelPower = 5; + this._normalReflectance = 0; + this._cubeTexture = envMap; + this._alpha = alpha; + } + /** + * @inheritDoc + */ + EffectFresnelEnvMapMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsNormals = true; + methodVO.needsView = true; + methodVO.needsUV = this._mask != null; + }; + /** + * @inheritDoc + */ + EffectFresnelEnvMapMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 3] = 1; + }; + Object.defineProperty(EffectFresnelEnvMapMethod.prototype, "mask", { + /** + * An optional texture to modulate the reflectivity of the surface. + */ + get: function () { + return this._mask; + }, + set: function (value) { + if (Boolean(value) != Boolean(this._mask) || (value && this._mask && (value.hasMipmaps != this._mask.hasMipmaps || value.format != this._mask.format))) { + this.iInvalidateShaderProgram(); + } + this._mask = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectFresnelEnvMapMethod.prototype, "fresnelPower", { + /** + * The power used in the Fresnel equation. Higher values make the fresnel effect more pronounced. Defaults to 5. + */ + get: function () { + return this._fresnelPower; + }, + set: function (value) { + this._fresnelPower = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectFresnelEnvMapMethod.prototype, "envMap", { + /** + * The cubic environment map containing the reflected scene. + */ + get: function () { + return this._cubeTexture; + }, + set: function (value) { + this._cubeTexture = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectFresnelEnvMapMethod.prototype, "alpha", { + /** + * The reflectivity of the surface. + */ + get: function () { + return this._alpha; + }, + set: function (value) { + this._alpha = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectFresnelEnvMapMethod.prototype, "normalReflectance", { + /** + * The minimum amount of reflectance, ie the reflectance when the view direction is normal to the surface or light direction. + */ + get: function () { + return this._normalReflectance; + }, + set: function (value) { + this._normalReflectance = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectFresnelEnvMapMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + var data = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + data[index] = this._alpha; + data[index + 1] = this._normalReflectance; + data[index + 2] = this._fresnelPower; + stage.context.activateCubeTexture(methodVO.texturesIndex, this._cubeTexture); + if (this._mask) + stage.context.activateTexture(methodVO.texturesIndex + 1, this._mask); + }; + /** + * @inheritDoc + */ + EffectFresnelEnvMapMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var dataRegister = registerCache.getFreeFragmentConstant(); + var temp = registerCache.getFreeFragmentVectorTemp(); + var code = ""; + var cubeMapReg = registerCache.getFreeTextureReg(); + var viewDirReg = sharedRegisters.viewDirFragment; + var normalReg = sharedRegisters.normalFragment; + methodVO.texturesIndex = cubeMapReg.index; + methodVO.fragmentConstantsIndex = dataRegister.index * 4; + registerCache.addFragmentTempUsages(temp, 1); + var temp2 = registerCache.getFreeFragmentVectorTemp(); + // r = V - 2(V.N)*N + code += "dp3 " + temp + ".w, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + "add " + temp + ".w, " + temp + ".w, " + temp + ".w\n" + "mul " + temp + ".xyz, " + normalReg + ".xyz, " + temp + ".w\n" + "sub " + temp + ".xyz, " + temp + ".xyz, " + viewDirReg + ".xyz\n" + ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, temp) + "sub " + temp2 + ".w, " + temp + ".w, fc0.x\n" + "kil " + temp2 + ".w\n" + "sub " + temp + ", " + temp + ", " + targetReg + "\n"; + // calculate fresnel term + code += "dp3 " + viewDirReg + ".w, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + "sub " + viewDirReg + ".w, " + dataRegister + ".w, " + viewDirReg + ".w\n" + "pow " + viewDirReg + ".w, " + viewDirReg + ".w, " + dataRegister + ".z\n" + "sub " + normalReg + ".w, " + dataRegister + ".w, " + viewDirReg + ".w\n" + "mul " + normalReg + ".w, " + dataRegister + ".y, " + normalReg + ".w\n" + "add " + viewDirReg + ".w, " + viewDirReg + ".w, " + normalReg + ".w\n" + "mul " + viewDirReg + ".w, " + dataRegister + ".x, " + viewDirReg + ".w\n"; + if (this._mask) { + var maskReg = registerCache.getFreeTextureReg(); + code += ShaderCompilerHelper.getTex2DSampleCode(temp2, sharedRegisters, maskReg, this._mask, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) + "mul " + viewDirReg + ".w, " + temp2 + ".x, " + viewDirReg + ".w\n"; + } + // blend + code += "mul " + temp + ", " + temp + ", " + viewDirReg + ".w\n" + "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; + registerCache.removeFragmentTempUsage(temp); + return code; + }; + return EffectFresnelEnvMapMethod; +})(EffectMethodBase); +module.exports = EffectFresnelEnvMapMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectfresnelenvmapmethod.ts"],"names":["EffectFresnelEnvMapMethod","EffectFresnelEnvMapMethod.constructor","EffectFresnelEnvMapMethod.iInitVO","EffectFresnelEnvMapMethod.iInitConstants","EffectFresnelEnvMapMethod.mask","EffectFresnelEnvMapMethod.fresnelPower","EffectFresnelEnvMapMethod.envMap","EffectFresnelEnvMapMethod.alpha","EffectFresnelEnvMapMethod.normalReflectance","EffectFresnelEnvMapMethod.iActivate","EffectFresnelEnvMapMethod.iGetFragmentCode"],"mappings":"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","file":"materials/methods/EffectFresnelEnvMapMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import CubeTextureBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/CubeTextureBase\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * EffectFresnelEnvMapMethod provides a method to add fresnel-based reflectivity to an object using cube maps, which gets\n * stronger as the viewing angle becomes more grazing.\n */\nclass EffectFresnelEnvMapMethod extends EffectMethodBase\n{\n\tprivate _cubeTexture:CubeTextureBase;\n\tprivate _fresnelPower:number = 5;\n\tprivate _normalReflectance:number = 0;\n\tprivate _alpha:number;\n\tprivate _mask:Texture2DBase;\n\n\t/**\n\t * Creates a new <code>EffectFresnelEnvMapMethod</code> object.\n\t *\n\t * @param envMap The environment map containing the reflected scene.\n\t * @param alpha The reflectivity of the material.\n\t */\n\tconstructor(envMap:CubeTextureBase, alpha:number = 1)\n\t{\n\t\tsuper();\n\n\t\tthis._cubeTexture = envMap;\n\t\tthis._alpha = alpha;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsNormals = true;\n\t\tmethodVO.needsView = true;\n\t\tmethodVO.needsUV = this._mask != null;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tshaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 3] = 1;\n\t}\n\n\t/**\n\t * An optional texture to modulate the reflectivity of the surface.\n\t */\n\tpublic get mask():Texture2DBase\n\t{\n\t\treturn this._mask;\n\t}\n\n\tpublic set mask(value:Texture2DBase)\n\t{\n\t\tif (Boolean(value) != Boolean(this._mask) ||\n\t\t\t(value && this._mask && (value.hasMipmaps != this._mask.hasMipmaps || value.format != this._mask.format))) {\n\t\t\tthis.iInvalidateShaderProgram();\n\t\t}\n\t\tthis._mask = value;\n\t}\n\n\t/**\n\t * The power used in the Fresnel equation. Higher values make the fresnel effect more pronounced. Defaults to 5.\n\t */\n\tpublic get fresnelPower():number\n\t{\n\t\treturn this._fresnelPower;\n\t}\n\n\tpublic set fresnelPower(value:number)\n\t{\n\t\tthis._fresnelPower = value;\n\t}\n\n\t/**\n\t * The cubic environment map containing the reflected scene.\n\t */\n\tpublic get envMap():CubeTextureBase\n\t{\n\t\treturn this._cubeTexture;\n\t}\n\n\tpublic set envMap(value:CubeTextureBase)\n\t{\n\t\tthis._cubeTexture = value;\n\t}\n\n\t/**\n\t * The reflectivity of the surface.\n\t */\n\tpublic get alpha():number\n\t{\n\t\treturn this._alpha;\n\t}\n\n\tpublic set alpha(value:number)\n\t{\n\t\tthis._alpha = value;\n\t}\n\n\t/**\n\t * The minimum amount of reflectance, ie the reflectance when the view direction is normal to the surface or light direction.\n\t */\n\tpublic get normalReflectance():number\n\t{\n\t\treturn this._normalReflectance;\n\t}\n\n\tpublic set normalReflectance(value:number)\n\t{\n\t\tthis._normalReflectance = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tdata[index] = this._alpha;\n\t\tdata[index + 1] = this._normalReflectance;\n\t\tdata[index + 2] = this._fresnelPower;\n\n\t\t(<IContextStageGL> stage.context).activateCubeTexture(methodVO.texturesIndex, this._cubeTexture);\n\n\t\tif (this._mask)\n\t\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex + 1, this._mask);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar dataRegister:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tvar code:string = \"\";\n\t\tvar cubeMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\t\tvar viewDirReg:ShaderRegisterElement = sharedRegisters.viewDirFragment;\n\t\tvar normalReg:ShaderRegisterElement = sharedRegisters.normalFragment;\n\n\t\tmethodVO.texturesIndex = cubeMapReg.index;\n\t\tmethodVO.fragmentConstantsIndex = dataRegister.index*4;\n\n\t\tregisterCache.addFragmentTempUsages(temp, 1);\n\t\tvar temp2:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\n\t\t// r = V - 2(V.N)*N\n\t\tcode += \"dp3 \" + temp + \".w, \" + viewDirReg + \".xyz, \" + normalReg + \".xyz\\n\" +\n\t\t\t\t\"add \" + temp + \".w, \" + temp + \".w, \" + temp + \".w\\n\" +\n\t\t\t\t\"mul \" + temp + \".xyz, \" + normalReg + \".xyz, \" + temp + \".w\\n\" +\n\t\t\t\t\"sub \" + temp + \".xyz, \" + temp + \".xyz, \" + viewDirReg + \".xyz\\n\" +\n\t\t\tShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, temp) +\n\t\t\t\t\"sub \" + temp2 + \".w, \" + temp + \".w, fc0.x\\n\" +               \t// -.5\n\t\t\t\t\"kil \" + temp2 + \".w\\n\" +\t// used for real time reflection mapping - if alpha is not 1 (mock texture) kil output\n\t\t\t\t\"sub \" + temp + \", \" + temp + \", \" + targetReg + \"\\n\";\n\n\t\t// calculate fresnel term\n\t\tcode += \"dp3 \" + viewDirReg + \".w, \" + viewDirReg + \".xyz, \" + normalReg + \".xyz\\n\" +  // dot(V, H)\n\t\t\t\t\"sub \" + viewDirReg + \".w, \" + dataRegister + \".w, \" + viewDirReg + \".w\\n\" +       // base = 1-dot(V, H)\n\t\t\t\t\"pow \" + viewDirReg + \".w, \" + viewDirReg + \".w, \" + dataRegister + \".z\\n\" +       // exp = pow(base, 5)\n\t\t\t\t\"sub \" + normalReg + \".w, \" + dataRegister + \".w, \" + viewDirReg + \".w\\n\" +        // 1 - exp\n\t\t\t\t\"mul \" + normalReg + \".w, \" + dataRegister + \".y, \" + normalReg + \".w\\n\" +         // f0*(1 - exp)\n\t\t\t\t\"add \" + viewDirReg + \".w, \" + viewDirReg + \".w, \" + normalReg + \".w\\n\" +          // exp + f0*(1 - exp)\n\n\t\t\t\t// total alpha\n\t\t\t\t\"mul \" + viewDirReg + \".w, \" + dataRegister + \".x, \" + viewDirReg + \".w\\n\";\n\n\t\tif (this._mask) {\n\t\t\tvar maskReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\t\t\tcode += ShaderCompilerHelper.getTex2DSampleCode(temp2, sharedRegisters, maskReg, this._mask, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) +\n\t\t\t\t\"mul \" + viewDirReg + \".w, \" + temp2 + \".x, \" + viewDirReg + \".w\\n\";\n\t\t}\n\n\t\t// blend\n\t\tcode += \"mul \" + temp + \", \" + temp + \", \" + viewDirReg + \".w\\n\" +\n\t\t\t\t\"add \" + targetReg + \", \" + targetReg + \", \" + temp + \"\\n\";\n\n\t\tregisterCache.removeFragmentTempUsage(temp);\n\n\t\treturn code;\n\t}\n}\n\nexport = EffectFresnelEnvMapMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectFresnelEnvMapMethod.ts b/lib/materials/methods/EffectFresnelEnvMapMethod.ts new file mode 100644 index 000000000..fe58a40fd --- /dev/null +++ b/lib/materials/methods/EffectFresnelEnvMapMethod.ts @@ -0,0 +1,199 @@ +import CubeTextureBase = require("awayjs-core/lib/textures/CubeTextureBase"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * EffectFresnelEnvMapMethod provides a method to add fresnel-based reflectivity to an object using cube maps, which gets + * stronger as the viewing angle becomes more grazing. + */ +class EffectFresnelEnvMapMethod extends EffectMethodBase +{ + private _cubeTexture:CubeTextureBase; + private _fresnelPower:number = 5; + private _normalReflectance:number = 0; + private _alpha:number; + private _mask:Texture2DBase; + + /** + * Creates a new EffectFresnelEnvMapMethod object. + * + * @param envMap The environment map containing the reflected scene. + * @param alpha The reflectivity of the material. + */ + constructor(envMap:CubeTextureBase, alpha:number = 1) + { + super(); + + this._cubeTexture = envMap; + this._alpha = alpha; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + methodVO.needsNormals = true; + methodVO.needsView = true; + methodVO.needsUV = this._mask != null; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 3] = 1; + } + + /** + * An optional texture to modulate the reflectivity of the surface. + */ + public get mask():Texture2DBase + { + return this._mask; + } + + public set mask(value:Texture2DBase) + { + if (Boolean(value) != Boolean(this._mask) || + (value && this._mask && (value.hasMipmaps != this._mask.hasMipmaps || value.format != this._mask.format))) { + this.iInvalidateShaderProgram(); + } + this._mask = value; + } + + /** + * The power used in the Fresnel equation. Higher values make the fresnel effect more pronounced. Defaults to 5. + */ + public get fresnelPower():number + { + return this._fresnelPower; + } + + public set fresnelPower(value:number) + { + this._fresnelPower = value; + } + + /** + * The cubic environment map containing the reflected scene. + */ + public get envMap():CubeTextureBase + { + return this._cubeTexture; + } + + public set envMap(value:CubeTextureBase) + { + this._cubeTexture = value; + } + + /** + * The reflectivity of the surface. + */ + public get alpha():number + { + return this._alpha; + } + + public set alpha(value:number) + { + this._alpha = value; + } + + /** + * The minimum amount of reflectance, ie the reflectance when the view direction is normal to the surface or light direction. + */ + public get normalReflectance():number + { + return this._normalReflectance; + } + + public set normalReflectance(value:number) + { + this._normalReflectance = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + var data:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + data[index] = this._alpha; + data[index + 1] = this._normalReflectance; + data[index + 2] = this._fresnelPower; + + ( stage.context).activateCubeTexture(methodVO.texturesIndex, this._cubeTexture); + + if (this._mask) + ( stage.context).activateTexture(methodVO.texturesIndex + 1, this._mask); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var dataRegister:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + var code:string = ""; + var cubeMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + var viewDirReg:ShaderRegisterElement = sharedRegisters.viewDirFragment; + var normalReg:ShaderRegisterElement = sharedRegisters.normalFragment; + + methodVO.texturesIndex = cubeMapReg.index; + methodVO.fragmentConstantsIndex = dataRegister.index*4; + + registerCache.addFragmentTempUsages(temp, 1); + var temp2:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + + // r = V - 2(V.N)*N + code += "dp3 " + temp + ".w, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + + "add " + temp + ".w, " + temp + ".w, " + temp + ".w\n" + + "mul " + temp + ".xyz, " + normalReg + ".xyz, " + temp + ".w\n" + + "sub " + temp + ".xyz, " + temp + ".xyz, " + viewDirReg + ".xyz\n" + + ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._cubeTexture, shaderObject.useSmoothTextures, shaderObject.useMipmapping, temp) + + "sub " + temp2 + ".w, " + temp + ".w, fc0.x\n" + // -.5 + "kil " + temp2 + ".w\n" + // used for real time reflection mapping - if alpha is not 1 (mock texture) kil output + "sub " + temp + ", " + temp + ", " + targetReg + "\n"; + + // calculate fresnel term + code += "dp3 " + viewDirReg + ".w, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + // dot(V, H) + "sub " + viewDirReg + ".w, " + dataRegister + ".w, " + viewDirReg + ".w\n" + // base = 1-dot(V, H) + "pow " + viewDirReg + ".w, " + viewDirReg + ".w, " + dataRegister + ".z\n" + // exp = pow(base, 5) + "sub " + normalReg + ".w, " + dataRegister + ".w, " + viewDirReg + ".w\n" + // 1 - exp + "mul " + normalReg + ".w, " + dataRegister + ".y, " + normalReg + ".w\n" + // f0*(1 - exp) + "add " + viewDirReg + ".w, " + viewDirReg + ".w, " + normalReg + ".w\n" + // exp + f0*(1 - exp) + + // total alpha + "mul " + viewDirReg + ".w, " + dataRegister + ".x, " + viewDirReg + ".w\n"; + + if (this._mask) { + var maskReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + code += ShaderCompilerHelper.getTex2DSampleCode(temp2, sharedRegisters, maskReg, this._mask, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping) + + "mul " + viewDirReg + ".w, " + temp2 + ".x, " + viewDirReg + ".w\n"; + } + + // blend + code += "mul " + temp + ", " + temp + ", " + viewDirReg + ".w\n" + + "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; + + registerCache.removeFragmentTempUsage(temp); + + return code; + } +} + +export = EffectFresnelEnvMapMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectLightMapMethod.js b/lib/materials/methods/EffectLightMapMethod.js new file mode 100755 index 000000000..b0363032e --- /dev/null +++ b/lib/materials/methods/EffectLightMapMethod.js @@ -0,0 +1,112 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * EffectLightMapMethod provides a method that allows applying a light map texture to the calculated pixel colour. + * It is different from DiffuseLightMapMethod in that the latter only modulates the diffuse shading value rather + * than the whole pixel colour. + */ +var EffectLightMapMethod = (function (_super) { + __extends(EffectLightMapMethod, _super); + /** + * Creates a new EffectLightMapMethod object. + * + * @param texture The texture containing the light map. + * @param blendMode The blend mode with which the light map should be applied to the lighting result. + * @param useSecondaryUV Indicates whether the secondary UV set should be used to map the light map. + */ + function EffectLightMapMethod(texture, blendMode, useSecondaryUV) { + if (blendMode === void 0) { blendMode = "multiply"; } + if (useSecondaryUV === void 0) { useSecondaryUV = false; } + _super.call(this); + this._useSecondaryUV = useSecondaryUV; + this._texture = texture; + this.blendMode = blendMode; + } + /** + * @inheritDoc + */ + EffectLightMapMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsUV = !this._useSecondaryUV; + methodVO.needsSecondaryUV = this._useSecondaryUV; + }; + Object.defineProperty(EffectLightMapMethod.prototype, "blendMode", { + /** + * The blend mode with which the light map should be applied to the lighting result. + * + * @see EffectLightMapMethod.ADD + * @see EffectLightMapMethod.MULTIPLY + */ + get: function () { + return this._blendMode; + }, + set: function (value) { + if (value != EffectLightMapMethod.ADD && value != EffectLightMapMethod.MULTIPLY) + throw new Error("Unknown blendmode!"); + if (this._blendMode == value) + return; + this._blendMode = value; + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectLightMapMethod.prototype, "texture", { + /** + * The texture containing the light map. + */ + get: function () { + return this._texture; + }, + set: function (value) { + if (value.hasMipmaps != this._texture.hasMipmaps || value.format != this._texture.format) + this.iInvalidateShaderProgram(); + this._texture = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectLightMapMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + stage.context.activateTexture(methodVO.texturesIndex, this._texture); + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + EffectLightMapMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var code; + var lightMapReg = registerCache.getFreeTextureReg(); + var temp = registerCache.getFreeFragmentVectorTemp(); + methodVO.texturesIndex = lightMapReg.index; + code = ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, lightMapReg, this._texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, this._useSecondaryUV ? sharedRegisters.secondaryUVVarying : sharedRegisters.uvVarying); + switch (this._blendMode) { + case EffectLightMapMethod.MULTIPLY: + code += "mul " + targetReg + ", " + targetReg + ", " + temp + "\n"; + break; + case EffectLightMapMethod.ADD: + code += "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; + break; + } + return code; + }; + /** + * Indicates the light map should be multiplied with the calculated shading result. + */ + EffectLightMapMethod.MULTIPLY = "multiply"; + /** + * Indicates the light map should be added into the calculated shading result. + */ + EffectLightMapMethod.ADD = "add"; + return EffectLightMapMethod; +})(EffectMethodBase); +module.exports = EffectLightMapMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectlightmapmethod.ts"],"names":["EffectLightMapMethod","EffectLightMapMethod.constructor","EffectLightMapMethod.iInitVO","EffectLightMapMethod.blendMode","EffectLightMapMethod.texture","EffectLightMapMethod.iActivate","EffectLightMapMethod.iGetFragmentCode"],"mappings":";;;;;;AASA,IAAO,gBAAgB,WAAe,uDAAuD,CAAC,CAAC;AAC/F,IAAO,oBAAoB,WAAc,yDAAyD,CAAC,CAAC;AAEpG,AAKA;;;;GADG;IACG,oBAAoB;IAASA,UAA7BA,oBAAoBA,UAAyBA;IAiBlDA;;;;;;OAMGA;IACHA,SAxBKA,oBAAoBA,CAwBbA,OAAqBA,EAAEA,SAA6BA,EAAEA,cAA8BA;QAA7DC,yBAA6BA,GAA7BA,sBAA6BA;QAAEA,8BAA8BA,GAA9BA,sBAA8BA;QAE/FA,iBAAOA,CAACA;QAERA,IAAIA,CAACA,eAAeA,GAAGA,cAAcA,CAACA;QACtCA,IAAIA,CAACA,QAAQA,GAAGA,OAAOA,CAACA;QACxBA,IAAIA,CAACA,SAASA,GAAGA,SAASA,CAACA;IAC5BA,CAACA;IAEDD;;OAEGA;IACIA,sCAAOA,GAAdA,UAAeA,YAA6BA,EAAEA,QAAiBA;QAE9DE,QAAQA,CAACA,OAAOA,GAAGA,CAACA,IAAIA,CAACA,eAAeA,CAACA;QACzCA,QAAQA,CAACA,gBAAgBA,GAAGA,IAAIA,CAACA,eAAeA,CAACA;IAClDA,CAACA;IAQDF,sBAAWA,2CAASA;QANpBA;;;;;WAKGA;aACHA;YAECG,MAAMA,CAACA,IAAIA,CAACA,UAAUA,CAACA;QACxBA,CAACA;aAEDH,UAAqBA,KAAYA;YAEhCG,EAAEA,CAACA,CAACA,KAAKA,IAAIA,oBAAoBA,CAACA,GAAGA,IAAIA,KAAKA,IAAIA,oBAAoBA,CAACA,QAAQA,CAACA;gBAC/EA,MAAMA,IAAIA,KAAKA,CAACA,oBAAoBA,CAACA,CAACA;YACvCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,UAAUA,IAAIA,KAAKA,CAACA;gBAC5BA,MAAMA,CAACA;YAERA,IAAIA,CAACA,UAAUA,GAAGA,KAAKA,CAACA;YAExBA,IAAIA,CAACA,wBAAwBA,EAAEA,CAACA;QACjCA,CAACA;;;OAZAH;IAiBDA,sBAAWA,yCAAOA;QAHlBA;;WAEGA;aACHA;YAECI,MAAMA,CAACA,IAAIA,CAACA,QAAQA,CAACA;QACtBA,CAACA;aAEDJ,UAAmBA,KAAmBA;YAErCI,EAAEA,CAACA,CAACA,KAAKA,CAACA,UAAUA,IAAIA,IAAIA,CAACA,QAAQA,CAACA,UAAUA,IAAIA,KAAKA,CAACA,MAAMA,IAAIA,IAAIA,CAACA,QAAQA,CAACA,MAAMA,CAACA;gBACxFA,IAAIA,CAACA,wBAAwBA,EAAEA,CAACA;YAEjCA,IAAIA,CAACA,QAAQA,GAAGA,KAAKA,CAACA;QACvBA,CAACA;;;OARAJ;IAUDA;;OAEGA;IACIA,wCAASA,GAAhBA,UAAiBA,YAA6BA,EAAEA,QAAiBA,EAAEA,KAAWA;QAE1DK,KAAKA,CAACA,OAAQA,CAACA,eAAeA,CAACA,QAAQA,CAACA,aAAaA,EAAEA,IAAIA,CAACA,QAAQA,CAACA,CAACA;QAEzFA,gBAAKA,CAACA,SAASA,YAACA,YAAYA,EAAEA,QAAQA,EAAEA,KAAKA,CAACA,CAACA;IAChDA,CAACA;IAEDL;;OAEGA;IACIA,+CAAgBA,GAAvBA,UAAwBA,YAA6BA,EAAEA,QAAiBA,EAAEA,SAA+BA,EAAEA,aAAiCA,EAAEA,eAAkCA;QAE/KM,IAAIA,IAAWA,CAACA;QAChBA,IAAIA,WAAWA,GAAyBA,aAAaA,CAACA,iBAAiBA,EAAEA,CAACA;QAC1EA,IAAIA,IAAIA,GAAyBA,aAAaA,CAACA,yBAAyBA,EAAEA,CAACA;QAC3EA,QAAQA,CAACA,aAAaA,GAAGA,WAAWA,CAACA,KAAKA,CAACA;QAE3CA,IAAIA,GAAGA,oBAAoBA,CAACA,kBAAkBA,CAACA,IAAIA,EAAEA,eAAeA,EAAEA,WAAWA,EAAEA,IAAIA,CAACA,QAAQA,EAAEA,YAAYA,CAACA,iBAAiBA,EAAEA,YAAYA,CAACA,cAAcA,EAAEA,YAAYA,CAACA,aAAaA,EAAEA,IAAIA,CAACA,eAAeA,GAAEA,eAAeA,CAACA,kBAAkBA,GAAGA,eAAeA,CAACA,SAASA,CAACA,CAACA;QAEjRA,MAAMA,CAACA,CAACA,IAAIA,CAACA,UAAUA,CAACA,CAACA,CAACA;YACzBA,KAAKA,oBAAoBA,CAACA,QAAQA;gBACjCA,IAAIA,IAAIA,MAAMA,GAAGA,SAASA,GAAGA,IAAIA,GAAGA,SAASA,GAAGA,IAAIA,GAAGA,IAAIA,GAAGA,IAAIA,CAACA;gBACnEA,KAAKA,CAACA;YACPA,KAAKA,oBAAoBA,CAACA,GAAGA;gBAC5BA,IAAIA,IAAIA,MAAMA,GAAGA,SAASA,GAAGA,IAAIA,GAAGA,SAASA,GAAGA,IAAIA,GAAGA,IAAIA,GAAGA,IAAIA,CAACA;gBACnEA,KAAKA,CAACA;QACRA,CAACA;QAEDA,MAAMA,CAACA,IAAIA,CAACA;IACbA,CAACA;IA/GDN;;OAEGA;IACWA,6BAAQA,GAAUA,UAAUA,CAACA;IAE3CA;;OAEGA;IACWA,wBAAGA,GAAUA,KAAKA,CAACA;IAwGlCA,2BAACA;AAADA,CAlHA,AAkHCA,EAlHkC,gBAAgB,EAkHlD;AAED,AAA8B,iBAArB,oBAAoB,CAAC","file":"materials/methods/EffectLightMapMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * EffectLightMapMethod provides a method that allows applying a light map texture to the calculated pixel colour.\n * It is different from DiffuseLightMapMethod in that the latter only modulates the diffuse shading value rather\n * than the whole pixel colour.\n */\nclass EffectLightMapMethod extends EffectMethodBase\n{\n\t/**\n\t * Indicates the light map should be multiplied with the calculated shading result.\n\t */\n\tpublic static MULTIPLY:string = \"multiply\";\n\n\t/**\n\t * Indicates the light map should be added into the calculated shading result.\n\t */\n\tpublic static ADD:string = \"add\";\n\n\tprivate _texture:Texture2DBase;\n\n\tprivate _blendMode:string;\n\tprivate _useSecondaryUV:boolean;\n\n\t/**\n\t * Creates a new EffectLightMapMethod object.\n\t *\n\t * @param texture The texture containing the light map.\n\t * @param blendMode The blend mode with which the light map should be applied to the lighting result.\n\t * @param useSecondaryUV Indicates whether the secondary UV set should be used to map the light map.\n\t */\n\tconstructor(texture:Texture2DBase, blendMode:string = \"multiply\", useSecondaryUV:boolean = false)\n\t{\n\t\tsuper();\n\n\t\tthis._useSecondaryUV = useSecondaryUV;\n\t\tthis._texture = texture;\n\t\tthis.blendMode = blendMode;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsUV = !this._useSecondaryUV;\n\t\tmethodVO.needsSecondaryUV = this._useSecondaryUV;\n\t}\n\n\t/**\n\t * The blend mode with which the light map should be applied to the lighting result.\n\t *\n\t * @see EffectLightMapMethod.ADD\n\t * @see EffectLightMapMethod.MULTIPLY\n\t */\n\tpublic get blendMode():string\n\t{\n\t\treturn this._blendMode;\n\t}\n\n\tpublic set blendMode(value:string)\n\t{\n\t\tif (value != EffectLightMapMethod.ADD && value != EffectLightMapMethod.MULTIPLY)\n\t\t\tthrow new Error(\"Unknown blendmode!\");\n\t\tif (this._blendMode == value)\n\t\t\treturn;\n\n\t\tthis._blendMode = value;\n\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * The texture containing the light map.\n\t */\n\tpublic get texture():Texture2DBase\n\t{\n\t\treturn this._texture;\n\t}\n\n\tpublic set texture(value:Texture2DBase)\n\t{\n\t\tif (value.hasMipmaps != this._texture.hasMipmaps || value.format != this._texture.format)\n\t\t\tthis.iInvalidateShaderProgram();\n\n\t\tthis._texture = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex, this._texture);\n\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string;\n\t\tvar lightMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tmethodVO.texturesIndex = lightMapReg.index;\n\n\t\tcode = ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, lightMapReg, this._texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, this._useSecondaryUV? sharedRegisters.secondaryUVVarying : sharedRegisters.uvVarying);\n\n\t\tswitch (this._blendMode) {\n\t\t\tcase EffectLightMapMethod.MULTIPLY:\n\t\t\t\tcode += \"mul \" + targetReg + \", \" + targetReg + \", \" + temp + \"\\n\";\n\t\t\t\tbreak;\n\t\t\tcase EffectLightMapMethod.ADD:\n\t\t\t\tcode += \"add \" + targetReg + \", \" + targetReg + \", \" + temp + \"\\n\";\n\t\t\t\tbreak;\n\t\t}\n\n\t\treturn code;\n\t}\n}\n\nexport = EffectLightMapMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectLightMapMethod.ts b/lib/materials/methods/EffectLightMapMethod.ts new file mode 100644 index 000000000..86df1f0d2 --- /dev/null +++ b/lib/materials/methods/EffectLightMapMethod.ts @@ -0,0 +1,134 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * EffectLightMapMethod provides a method that allows applying a light map texture to the calculated pixel colour. + * It is different from DiffuseLightMapMethod in that the latter only modulates the diffuse shading value rather + * than the whole pixel colour. + */ +class EffectLightMapMethod extends EffectMethodBase +{ + /** + * Indicates the light map should be multiplied with the calculated shading result. + */ + public static MULTIPLY:string = "multiply"; + + /** + * Indicates the light map should be added into the calculated shading result. + */ + public static ADD:string = "add"; + + private _texture:Texture2DBase; + + private _blendMode:string; + private _useSecondaryUV:boolean; + + /** + * Creates a new EffectLightMapMethod object. + * + * @param texture The texture containing the light map. + * @param blendMode The blend mode with which the light map should be applied to the lighting result. + * @param useSecondaryUV Indicates whether the secondary UV set should be used to map the light map. + */ + constructor(texture:Texture2DBase, blendMode:string = "multiply", useSecondaryUV:boolean = false) + { + super(); + + this._useSecondaryUV = useSecondaryUV; + this._texture = texture; + this.blendMode = blendMode; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + methodVO.needsUV = !this._useSecondaryUV; + methodVO.needsSecondaryUV = this._useSecondaryUV; + } + + /** + * The blend mode with which the light map should be applied to the lighting result. + * + * @see EffectLightMapMethod.ADD + * @see EffectLightMapMethod.MULTIPLY + */ + public get blendMode():string + { + return this._blendMode; + } + + public set blendMode(value:string) + { + if (value != EffectLightMapMethod.ADD && value != EffectLightMapMethod.MULTIPLY) + throw new Error("Unknown blendmode!"); + if (this._blendMode == value) + return; + + this._blendMode = value; + + this.iInvalidateShaderProgram(); + } + + /** + * The texture containing the light map. + */ + public get texture():Texture2DBase + { + return this._texture; + } + + public set texture(value:Texture2DBase) + { + if (value.hasMipmaps != this._texture.hasMipmaps || value.format != this._texture.format) + this.iInvalidateShaderProgram(); + + this._texture = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + ( stage.context).activateTexture(methodVO.texturesIndex, this._texture); + + super.iActivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string; + var lightMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + methodVO.texturesIndex = lightMapReg.index; + + code = ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, lightMapReg, this._texture, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, this._useSecondaryUV? sharedRegisters.secondaryUVVarying : sharedRegisters.uvVarying); + + switch (this._blendMode) { + case EffectLightMapMethod.MULTIPLY: + code += "mul " + targetReg + ", " + targetReg + ", " + temp + "\n"; + break; + case EffectLightMapMethod.ADD: + code += "add " + targetReg + ", " + targetReg + ", " + temp + "\n"; + break; + } + + return code; + } +} + +export = EffectLightMapMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectRefractionEnvMapMethod.js b/lib/materials/methods/EffectRefractionEnvMapMethod.js new file mode 100755 index 000000000..91991eb14 --- /dev/null +++ b/lib/materials/methods/EffectRefractionEnvMapMethod.js @@ -0,0 +1,208 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * EffectRefractionEnvMapMethod provides a method to add refracted transparency based on cube maps. + */ +var EffectRefractionEnvMapMethod = (function (_super) { + __extends(EffectRefractionEnvMapMethod, _super); + /** + * Creates a new EffectRefractionEnvMapMethod object. Example values for dispersion are: dispersionR: -0.03, dispersionG: -0.01, dispersionB: = .0015 + * + * @param envMap The environment map containing the refracted scene. + * @param refractionIndex The refractive index of the material. + * @param dispersionR The amount of chromatic dispersion of the red channel. Defaults to 0 (none). + * @param dispersionG The amount of chromatic dispersion of the green channel. Defaults to 0 (none). + * @param dispersionB The amount of chromatic dispersion of the blue channel. Defaults to 0 (none). + */ + function EffectRefractionEnvMapMethod(envMap, refractionIndex, dispersionR, dispersionG, dispersionB) { + if (refractionIndex === void 0) { refractionIndex = .1; } + if (dispersionR === void 0) { dispersionR = 0; } + if (dispersionG === void 0) { dispersionG = 0; } + if (dispersionB === void 0) { dispersionB = 0; } + _super.call(this); + this._dispersionR = 0; + this._dispersionG = 0; + this._dispersionB = 0; + this._alpha = 1; + this._envMap = envMap; + this._dispersionR = dispersionR; + this._dispersionG = dispersionG; + this._dispersionB = dispersionB; + this._useDispersion = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + this._refractionIndex = refractionIndex; + } + /** + * @inheritDoc + */ + EffectRefractionEnvMapMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var index = methodVO.fragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index + 4] = 1; + data[index + 5] = 0; + data[index + 7] = 1; + }; + /** + * @inheritDoc + */ + EffectRefractionEnvMapMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsNormals = true; + methodVO.needsView = true; + }; + Object.defineProperty(EffectRefractionEnvMapMethod.prototype, "envMap", { + /** + * The cube environment map to use for the refraction. + */ + get: function () { + return this._envMap; + }, + set: function (value) { + this._envMap = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRefractionEnvMapMethod.prototype, "refractionIndex", { + /** + * The refractive index of the material. + */ + get: function () { + return this._refractionIndex; + }, + set: function (value) { + this._refractionIndex = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRefractionEnvMapMethod.prototype, "dispersionR", { + /** + * The amount of chromatic dispersion of the red channel. Defaults to 0 (none). + */ + get: function () { + return this._dispersionR; + }, + set: function (value) { + this._dispersionR = value; + var useDispersion = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + if (this._useDispersion != useDispersion) { + this.iInvalidateShaderProgram(); + this._useDispersion = useDispersion; + } + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRefractionEnvMapMethod.prototype, "dispersionG", { + /** + * The amount of chromatic dispersion of the green channel. Defaults to 0 (none). + */ + get: function () { + return this._dispersionG; + }, + set: function (value) { + this._dispersionG = value; + var useDispersion = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + if (this._useDispersion != useDispersion) { + this.iInvalidateShaderProgram(); + this._useDispersion = useDispersion; + } + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRefractionEnvMapMethod.prototype, "dispersionB", { + /** + * The amount of chromatic dispersion of the blue channel. Defaults to 0 (none). + */ + get: function () { + return this._dispersionB; + }, + set: function (value) { + this._dispersionB = value; + var useDispersion = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + if (this._useDispersion != useDispersion) { + this.iInvalidateShaderProgram(); + this._useDispersion = useDispersion; + } + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRefractionEnvMapMethod.prototype, "alpha", { + /** + * The amount of transparency of the object. Warning: the alpha applies to the refracted color, not the actual + * material. A value of 1 will make it appear fully transparent. + */ + get: function () { + return this._alpha; + }, + set: function (value) { + this._alpha = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectRefractionEnvMapMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + var index = methodVO.fragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = this._dispersionR + this._refractionIndex; + if (this._useDispersion) { + data[index + 1] = this._dispersionG + this._refractionIndex; + data[index + 2] = this._dispersionB + this._refractionIndex; + } + data[index + 3] = this._alpha; + stage.context.activateCubeTexture(methodVO.texturesIndex, this._envMap); + }; + /** + * @inheritDoc + */ + EffectRefractionEnvMapMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + // todo: data2.x could use common reg, so only 1 reg is used + var data = registerCache.getFreeFragmentConstant(); + var data2 = registerCache.getFreeFragmentConstant(); + var code = ""; + var cubeMapReg = registerCache.getFreeTextureReg(); + var refractionDir; + var refractionColor; + var temp; + methodVO.texturesIndex = cubeMapReg.index; + methodVO.fragmentConstantsIndex = data.index * 4; + refractionDir = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(refractionDir, 1); + refractionColor = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(refractionColor, 1); + temp = registerCache.getFreeFragmentVectorTemp(); + var viewDirReg = sharedRegisters.viewDirFragment; + var normalReg = sharedRegisters.normalFragment; + code += "neg " + viewDirReg + ".xyz, " + viewDirReg + ".xyz\n"; + code += "dp3 " + temp + ".x, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + "mul " + temp + ".w, " + temp + ".x, " + temp + ".x\n" + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + "mul " + temp + ".w, " + data + ".x, " + temp + ".w\n" + "mul " + temp + ".w, " + data + ".x, " + temp + ".w\n" + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + "sqt " + temp + ".y, " + temp + ".w\n" + "mul " + temp + ".x, " + data + ".x, " + temp + ".x\n" + "add " + temp + ".x, " + temp + ".x, " + temp + ".y\n" + "mul " + temp + ".xyz, " + temp + ".x, " + normalReg + ".xyz\n" + "mul " + refractionDir + ", " + data + ".x, " + viewDirReg + "\n" + "sub " + refractionDir + ".xyz, " + refractionDir + ".xyz, " + temp + ".xyz\n" + "nrm " + refractionDir + ".xyz, " + refractionDir + ".xyz\n"; + code += ShaderCompilerHelper.getTexCubeSampleCode(refractionColor, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) + "sub " + refractionColor + ".w, " + refractionColor + ".w, fc0.x \n" + "kil " + refractionColor + ".w\n"; + if (this._useDispersion) { + // GREEN + code += "dp3 " + temp + ".x, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + "mul " + temp + ".w, " + temp + ".x, " + temp + ".x\n" + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + "mul " + temp + ".w, " + data + ".y, " + temp + ".w\n" + "mul " + temp + ".w, " + data + ".y, " + temp + ".w\n" + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + "sqt " + temp + ".y, " + temp + ".w\n" + "mul " + temp + ".x, " + data + ".y, " + temp + ".x\n" + "add " + temp + ".x, " + temp + ".x, " + temp + ".y\n" + "mul " + temp + ".xyz, " + temp + ".x, " + normalReg + ".xyz\n" + "mul " + refractionDir + ", " + data + ".y, " + viewDirReg + "\n" + "sub " + refractionDir + ".xyz, " + refractionDir + ".xyz, " + temp + ".xyz\n" + "nrm " + refractionDir + ".xyz, " + refractionDir + ".xyz\n"; + code += ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) + "mov " + refractionColor + ".y, " + temp + ".y\n"; + // BLUE + code += "dp3 " + temp + ".x, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + "mul " + temp + ".w, " + temp + ".x, " + temp + ".x\n" + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + "mul " + temp + ".w, " + data + ".z, " + temp + ".w\n" + "mul " + temp + ".w, " + data + ".z, " + temp + ".w\n" + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + "sqt " + temp + ".y, " + temp + ".w\n" + "mul " + temp + ".x, " + data + ".z, " + temp + ".x\n" + "add " + temp + ".x, " + temp + ".x, " + temp + ".y\n" + "mul " + temp + ".xyz, " + temp + ".x, " + normalReg + ".xyz\n" + "mul " + refractionDir + ", " + data + ".z, " + viewDirReg + "\n" + "sub " + refractionDir + ".xyz, " + refractionDir + ".xyz, " + temp + ".xyz\n" + "nrm " + refractionDir + ".xyz, " + refractionDir + ".xyz\n"; + code += ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) + "mov " + refractionColor + ".z, " + temp + ".z\n"; + } + registerCache.removeFragmentTempUsage(refractionDir); + code += "sub " + refractionColor + ".xyz, " + refractionColor + ".xyz, " + targetReg + ".xyz\n" + "mul " + refractionColor + ".xyz, " + refractionColor + ".xyz, " + data + ".w\n" + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + refractionColor + ".xyz\n"; + registerCache.removeFragmentTempUsage(refractionColor); + // restore + code += "neg " + viewDirReg + ".xyz, " + viewDirReg + ".xyz\n"; + return code; + }; + return EffectRefractionEnvMapMethod; +})(EffectMethodBase); +module.exports = EffectRefractionEnvMapMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectrefractionenvmapmethod.ts"],"names":["EffectRefractionEnvMapMethod","EffectRefractionEnvMapMethod.constructor","EffectRefractionEnvMapMethod.iInitConstants","EffectRefractionEnvMapMethod.iInitVO","EffectRefractionEnvMapMethod.envMap","EffectRefractionEnvMapMethod.refractionIndex","EffectRefractionEnvMapMethod.dispersionR","EffectRefractionEnvMapMethod.dispersionG","EffectRefractionEnvMapMethod.dispersionB","EffectRefractionEnvMapMethod.alpha","EffectRefractionEnvMapMethod.iActivate","EffectRefractionEnvMapMethod.iGetFragmentCode"],"mappings":"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","file":"materials/methods/EffectRefractionEnvMapMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import CubeTextureBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/CubeTextureBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * EffectRefractionEnvMapMethod provides a method to add refracted transparency based on cube maps.\n */\nclass EffectRefractionEnvMapMethod extends EffectMethodBase\n{\n\tprivate _envMap:CubeTextureBase;\n\n\tprivate _dispersionR:number = 0;\n\tprivate _dispersionG:number = 0;\n\tprivate _dispersionB:number = 0;\n\tprivate _useDispersion:boolean;\n\tprivate _refractionIndex:number;\n\tprivate _alpha:number = 1;\n\n\t/**\n\t * Creates a new EffectRefractionEnvMapMethod object. Example values for dispersion are: dispersionR: -0.03, dispersionG: -0.01, dispersionB: = .0015\n\t *\n\t * @param envMap The environment map containing the refracted scene.\n\t * @param refractionIndex The refractive index of the material.\n\t * @param dispersionR The amount of chromatic dispersion of the red channel. Defaults to 0 (none).\n\t * @param dispersionG The amount of chromatic dispersion of the green channel. Defaults to 0 (none).\n\t * @param dispersionB The amount of chromatic dispersion of the blue channel. Defaults to 0 (none).\n\t */\n\tconstructor(envMap:CubeTextureBase, refractionIndex:number = .1, dispersionR:number = 0, dispersionG:number = 0, dispersionB:number = 0)\n\t{\n\t\tsuper();\n\t\tthis._envMap = envMap;\n\t\tthis._dispersionR = dispersionR;\n\t\tthis._dispersionG = dispersionG;\n\t\tthis._dispersionB = dispersionB;\n\t\tthis._useDispersion = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG);\n\t\tthis._refractionIndex = refractionIndex;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index + 4] = 1;\n\t\tdata[index + 5] = 0;\n\t\tdata[index + 7] = 1;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsNormals = true;\n\t\tmethodVO.needsView = true;\n\t}\n\n\t/**\n\t * The cube environment map to use for the refraction.\n\t */\n\tpublic get envMap():CubeTextureBase\n\t{\n\t\treturn this._envMap;\n\t}\n\n\tpublic set envMap(value:CubeTextureBase)\n\t{\n\t\tthis._envMap = value;\n\t}\n\n\t/**\n\t * The refractive index of the material.\n\t */\n\tpublic get refractionIndex():number\n\t{\n\t\treturn this._refractionIndex;\n\t}\n\n\tpublic set refractionIndex(value:number)\n\t{\n\t\tthis._refractionIndex = value;\n\t}\n\n\t/**\n\t * The amount of chromatic dispersion of the red channel. Defaults to 0 (none).\n\t */\n\tpublic get dispersionR():number\n\t{\n\t\treturn this._dispersionR;\n\t}\n\n\tpublic set dispersionR(value:number)\n\t{\n\t\tthis._dispersionR = value;\n\n\t\tvar useDispersion:boolean = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG);\n\t\tif (this._useDispersion != useDispersion) {\n\t\t\tthis.iInvalidateShaderProgram();\n\t\t\tthis._useDispersion = useDispersion;\n\t\t}\n\t}\n\n\t/**\n\t * The amount of chromatic dispersion of the green channel. Defaults to 0 (none).\n\t */\n\tpublic get dispersionG():number\n\t{\n\t\treturn this._dispersionG;\n\t}\n\n\tpublic set dispersionG(value:number)\n\t{\n\t\tthis._dispersionG = value;\n\n\t\tvar useDispersion:boolean = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG);\n\t\tif (this._useDispersion != useDispersion) {\n\t\t\tthis.iInvalidateShaderProgram();\n\t\t\tthis._useDispersion = useDispersion;\n\t\t}\n\t}\n\n\t/**\n\t * The amount of chromatic dispersion of the blue channel. Defaults to 0 (none).\n\t */\n\tpublic get dispersionB():number\n\t{\n\t\treturn this._dispersionB;\n\t}\n\n\tpublic set dispersionB(value:number)\n\t{\n\t\tthis._dispersionB = value;\n\n\t\tvar useDispersion:boolean = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG);\n\t\tif (this._useDispersion != useDispersion) {\n\t\t\tthis.iInvalidateShaderProgram();\n\t\t\tthis._useDispersion = useDispersion;\n\t\t}\n\t}\n\n\t/**\n\t * The amount of transparency of the object. Warning: the alpha applies to the refracted color, not the actual\n\t * material. A value of 1 will make it appear fully transparent.\n\t */\n\tpublic get alpha():number\n\t{\n\t\treturn this._alpha;\n\t}\n\n\tpublic set alpha(value:number)\n\t{\n\t\tthis._alpha = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\n\t\tdata[index] = this._dispersionR + this._refractionIndex;\n\n\t\tif (this._useDispersion) {\n\t\t\tdata[index + 1] = this._dispersionG + this._refractionIndex;\n\t\t\tdata[index + 2] = this._dispersionB + this._refractionIndex;\n\t\t}\n\t\tdata[index + 3] = this._alpha;\n\n\t\t(<IContextStageGL> stage.context).activateCubeTexture(methodVO.texturesIndex, this._envMap);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\t// todo: data2.x could use common reg, so only 1 reg is used\n\t\tvar data:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar data2:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar code:string = \"\";\n\t\tvar cubeMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\t\tvar refractionDir:ShaderRegisterElement;\n\t\tvar refractionColor:ShaderRegisterElement;\n\t\tvar temp:ShaderRegisterElement;\n\n\t\tmethodVO.texturesIndex = cubeMapReg.index;\n\t\tmethodVO.fragmentConstantsIndex = data.index*4;\n\n\t\trefractionDir = registerCache.getFreeFragmentVectorTemp();\n\t\tregisterCache.addFragmentTempUsages(refractionDir, 1);\n\t\trefractionColor = registerCache.getFreeFragmentVectorTemp();\n\t\tregisterCache.addFragmentTempUsages(refractionColor, 1);\n\n\t\ttemp = registerCache.getFreeFragmentVectorTemp();\n\n\t\tvar viewDirReg:ShaderRegisterElement = sharedRegisters.viewDirFragment;\n\t\tvar normalReg:ShaderRegisterElement = sharedRegisters.normalFragment;\n\n\t\tcode += \"neg \" + viewDirReg + \".xyz, \" + viewDirReg + \".xyz\\n\";\n\n\t\tcode += \"dp3 \" + temp + \".x, \" + viewDirReg + \".xyz, \" + normalReg + \".xyz\\n\" +\n\t\t\t\"mul \" + temp + \".w, \" + temp + \".x, \" + temp + \".x\\n\" +\n\t\t\t\"sub \" + temp + \".w, \" + data2 + \".x, \" + temp + \".w\\n\" +\n\t\t\t\"mul \" + temp + \".w, \" + data + \".x, \" + temp + \".w\\n\" +\n\t\t\t\"mul \" + temp + \".w, \" + data + \".x, \" + temp + \".w\\n\" +\n\t\t\t\"sub \" + temp + \".w, \" + data2 + \".x, \" + temp + \".w\\n\" +\n\t\t\t\"sqt \" + temp + \".y, \" + temp + \".w\\n\" +\n\n\t\t\t\"mul \" + temp + \".x, \" + data + \".x, \" + temp + \".x\\n\" +\n\t\t\t\"add \" + temp + \".x, \" + temp + \".x, \" + temp + \".y\\n\" +\n\t\t\t\"mul \" + temp + \".xyz, \" + temp + \".x, \" + normalReg + \".xyz\\n\" +\n\n\t\t\t\"mul \" + refractionDir + \", \" + data + \".x, \" + viewDirReg + \"\\n\" +\n\t\t\t\"sub \" + refractionDir + \".xyz, \" + refractionDir + \".xyz, \" + temp + \".xyz\\n\" +\n\t\t\t\"nrm \" + refractionDir + \".xyz, \" + refractionDir + \".xyz\\n\";\n\t\tcode += ShaderCompilerHelper.getTexCubeSampleCode(refractionColor, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) +\n\t\t\t\"sub \" + refractionColor + \".w, \" + refractionColor + \".w, fc0.x\t\\n\" +\n\t\t\t\"kil \" + refractionColor + \".w\\n\";\n\n\t\tif (this._useDispersion) {\n\t\t\t// GREEN\n\t\t\tcode += \"dp3 \" + temp + \".x, \" + viewDirReg + \".xyz, \" + normalReg + \".xyz\\n\" +\n\t\t\t\t\"mul \" + temp + \".w, \" + temp + \".x, \" + temp + \".x\\n\" +\n\t\t\t\t\"sub \" + temp + \".w, \" + data2 + \".x, \" + temp + \".w\\n\" +\n\t\t\t\t\"mul \" + temp + \".w, \" + data + \".y, \" + temp + \".w\\n\" +\n\t\t\t\t\"mul \" + temp + \".w, \" + data + \".y, \" + temp + \".w\\n\" +\n\t\t\t\t\"sub \" + temp + \".w, \" + data2 + \".x, \" + temp + \".w\\n\" +\n\t\t\t\t\"sqt \" + temp + \".y, \" + temp + \".w\\n\" +\n\n\t\t\t\t\"mul \" + temp + \".x, \" + data + \".y, \" + temp + \".x\\n\" +\n\t\t\t\t\"add \" + temp + \".x, \" + temp + \".x, \" + temp + \".y\\n\" +\n\t\t\t\t\"mul \" + temp + \".xyz, \" + temp + \".x, \" + normalReg + \".xyz\\n\" +\n\n\t\t\t\t\"mul \" + refractionDir + \", \" + data + \".y, \" + viewDirReg + \"\\n\" +\n\t\t\t\t\"sub \" + refractionDir + \".xyz, \" + refractionDir + \".xyz, \" + temp + \".xyz\\n\" +\n\t\t\t\t\"nrm \" + refractionDir + \".xyz, \" + refractionDir + \".xyz\\n\";\n\t\t\tcode += ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) +\n\t\t\t\t\"mov \" + refractionColor + \".y, \" + temp + \".y\\n\";\n\n\t\t\t// BLUE\n\t\t\tcode += \"dp3 \" + temp + \".x, \" + viewDirReg + \".xyz, \" + normalReg + \".xyz\\n\" +\n\t\t\t\t\"mul \" + temp + \".w, \" + temp + \".x, \" + temp + \".x\\n\" +\n\t\t\t\t\"sub \" + temp + \".w, \" + data2 + \".x, \" + temp + \".w\\n\" +\n\t\t\t\t\"mul \" + temp + \".w, \" + data + \".z, \" + temp + \".w\\n\" +\n\t\t\t\t\"mul \" + temp + \".w, \" + data + \".z, \" + temp + \".w\\n\" +\n\t\t\t\t\"sub \" + temp + \".w, \" + data2 + \".x, \" + temp + \".w\\n\" +\n\t\t\t\t\"sqt \" + temp + \".y, \" + temp + \".w\\n\" +\n\n\t\t\t\t\"mul \" + temp + \".x, \" + data + \".z, \" + temp + \".x\\n\" +\n\t\t\t\t\"add \" + temp + \".x, \" + temp + \".x, \" + temp + \".y\\n\" +\n\t\t\t\t\"mul \" + temp + \".xyz, \" + temp + \".x, \" + normalReg + \".xyz\\n\" +\n\n\t\t\t\t\"mul \" + refractionDir + \", \" + data + \".z, \" + viewDirReg + \"\\n\" +\n\t\t\t\t\"sub \" + refractionDir + \".xyz, \" + refractionDir + \".xyz, \" + temp + \".xyz\\n\" +\n\t\t\t\t\"nrm \" + refractionDir + \".xyz, \" + refractionDir + \".xyz\\n\";\n\t\t\tcode += ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) +\n\t\t\t\t\"mov \" + refractionColor + \".z, \" + temp + \".z\\n\";\n\t\t}\n\n\t\tregisterCache.removeFragmentTempUsage(refractionDir);\n\n\t\tcode += \"sub \" + refractionColor + \".xyz, \" + refractionColor + \".xyz, \" + targetReg + \".xyz\\n\" +\n\t\t\t\"mul \" + refractionColor + \".xyz, \" + refractionColor + \".xyz, \" + data + \".w\\n\" +\n\t\t\t\"add \" + targetReg + \".xyz, \" + targetReg + \".xyz, \" + refractionColor + \".xyz\\n\";\n\n\t\tregisterCache.removeFragmentTempUsage(refractionColor);\n\n\t\t// restore\n\t\tcode += \"neg \" + viewDirReg + \".xyz, \" + viewDirReg + \".xyz\\n\";\n\n\t\treturn code;\n\t}\n}\n\nexport = EffectRefractionEnvMapMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectRefractionEnvMapMethod.ts b/lib/materials/methods/EffectRefractionEnvMapMethod.ts new file mode 100644 index 000000000..2e73baa6e --- /dev/null +++ b/lib/materials/methods/EffectRefractionEnvMapMethod.ts @@ -0,0 +1,287 @@ +import CubeTextureBase = require("awayjs-core/lib/textures/CubeTextureBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * EffectRefractionEnvMapMethod provides a method to add refracted transparency based on cube maps. + */ +class EffectRefractionEnvMapMethod extends EffectMethodBase +{ + private _envMap:CubeTextureBase; + + private _dispersionR:number = 0; + private _dispersionG:number = 0; + private _dispersionB:number = 0; + private _useDispersion:boolean; + private _refractionIndex:number; + private _alpha:number = 1; + + /** + * Creates a new EffectRefractionEnvMapMethod object. Example values for dispersion are: dispersionR: -0.03, dispersionG: -0.01, dispersionB: = .0015 + * + * @param envMap The environment map containing the refracted scene. + * @param refractionIndex The refractive index of the material. + * @param dispersionR The amount of chromatic dispersion of the red channel. Defaults to 0 (none). + * @param dispersionG The amount of chromatic dispersion of the green channel. Defaults to 0 (none). + * @param dispersionB The amount of chromatic dispersion of the blue channel. Defaults to 0 (none). + */ + constructor(envMap:CubeTextureBase, refractionIndex:number = .1, dispersionR:number = 0, dispersionG:number = 0, dispersionB:number = 0) + { + super(); + this._envMap = envMap; + this._dispersionR = dispersionR; + this._dispersionG = dispersionG; + this._dispersionB = dispersionB; + this._useDispersion = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + this._refractionIndex = refractionIndex; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index + 4] = 1; + data[index + 5] = 0; + data[index + 7] = 1; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + methodVO.needsNormals = true; + methodVO.needsView = true; + } + + /** + * The cube environment map to use for the refraction. + */ + public get envMap():CubeTextureBase + { + return this._envMap; + } + + public set envMap(value:CubeTextureBase) + { + this._envMap = value; + } + + /** + * The refractive index of the material. + */ + public get refractionIndex():number + { + return this._refractionIndex; + } + + public set refractionIndex(value:number) + { + this._refractionIndex = value; + } + + /** + * The amount of chromatic dispersion of the red channel. Defaults to 0 (none). + */ + public get dispersionR():number + { + return this._dispersionR; + } + + public set dispersionR(value:number) + { + this._dispersionR = value; + + var useDispersion:boolean = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + if (this._useDispersion != useDispersion) { + this.iInvalidateShaderProgram(); + this._useDispersion = useDispersion; + } + } + + /** + * The amount of chromatic dispersion of the green channel. Defaults to 0 (none). + */ + public get dispersionG():number + { + return this._dispersionG; + } + + public set dispersionG(value:number) + { + this._dispersionG = value; + + var useDispersion:boolean = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + if (this._useDispersion != useDispersion) { + this.iInvalidateShaderProgram(); + this._useDispersion = useDispersion; + } + } + + /** + * The amount of chromatic dispersion of the blue channel. Defaults to 0 (none). + */ + public get dispersionB():number + { + return this._dispersionB; + } + + public set dispersionB(value:number) + { + this._dispersionB = value; + + var useDispersion:boolean = !(this._dispersionR == this._dispersionB && this._dispersionR == this._dispersionG); + if (this._useDispersion != useDispersion) { + this.iInvalidateShaderProgram(); + this._useDispersion = useDispersion; + } + } + + /** + * The amount of transparency of the object. Warning: the alpha applies to the refracted color, not the actual + * material. A value of 1 will make it appear fully transparent. + */ + public get alpha():number + { + return this._alpha; + } + + public set alpha(value:number) + { + this._alpha = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + + data[index] = this._dispersionR + this._refractionIndex; + + if (this._useDispersion) { + data[index + 1] = this._dispersionG + this._refractionIndex; + data[index + 2] = this._dispersionB + this._refractionIndex; + } + data[index + 3] = this._alpha; + + ( stage.context).activateCubeTexture(methodVO.texturesIndex, this._envMap); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + // todo: data2.x could use common reg, so only 1 reg is used + var data:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var data2:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var code:string = ""; + var cubeMapReg:ShaderRegisterElement = registerCache.getFreeTextureReg(); + var refractionDir:ShaderRegisterElement; + var refractionColor:ShaderRegisterElement; + var temp:ShaderRegisterElement; + + methodVO.texturesIndex = cubeMapReg.index; + methodVO.fragmentConstantsIndex = data.index*4; + + refractionDir = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(refractionDir, 1); + refractionColor = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(refractionColor, 1); + + temp = registerCache.getFreeFragmentVectorTemp(); + + var viewDirReg:ShaderRegisterElement = sharedRegisters.viewDirFragment; + var normalReg:ShaderRegisterElement = sharedRegisters.normalFragment; + + code += "neg " + viewDirReg + ".xyz, " + viewDirReg + ".xyz\n"; + + code += "dp3 " + temp + ".x, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + + "mul " + temp + ".w, " + temp + ".x, " + temp + ".x\n" + + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + + "mul " + temp + ".w, " + data + ".x, " + temp + ".w\n" + + "mul " + temp + ".w, " + data + ".x, " + temp + ".w\n" + + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + + "sqt " + temp + ".y, " + temp + ".w\n" + + + "mul " + temp + ".x, " + data + ".x, " + temp + ".x\n" + + "add " + temp + ".x, " + temp + ".x, " + temp + ".y\n" + + "mul " + temp + ".xyz, " + temp + ".x, " + normalReg + ".xyz\n" + + + "mul " + refractionDir + ", " + data + ".x, " + viewDirReg + "\n" + + "sub " + refractionDir + ".xyz, " + refractionDir + ".xyz, " + temp + ".xyz\n" + + "nrm " + refractionDir + ".xyz, " + refractionDir + ".xyz\n"; + code += ShaderCompilerHelper.getTexCubeSampleCode(refractionColor, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) + + "sub " + refractionColor + ".w, " + refractionColor + ".w, fc0.x \n" + + "kil " + refractionColor + ".w\n"; + + if (this._useDispersion) { + // GREEN + code += "dp3 " + temp + ".x, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + + "mul " + temp + ".w, " + temp + ".x, " + temp + ".x\n" + + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + + "mul " + temp + ".w, " + data + ".y, " + temp + ".w\n" + + "mul " + temp + ".w, " + data + ".y, " + temp + ".w\n" + + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + + "sqt " + temp + ".y, " + temp + ".w\n" + + + "mul " + temp + ".x, " + data + ".y, " + temp + ".x\n" + + "add " + temp + ".x, " + temp + ".x, " + temp + ".y\n" + + "mul " + temp + ".xyz, " + temp + ".x, " + normalReg + ".xyz\n" + + + "mul " + refractionDir + ", " + data + ".y, " + viewDirReg + "\n" + + "sub " + refractionDir + ".xyz, " + refractionDir + ".xyz, " + temp + ".xyz\n" + + "nrm " + refractionDir + ".xyz, " + refractionDir + ".xyz\n"; + code += ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) + + "mov " + refractionColor + ".y, " + temp + ".y\n"; + + // BLUE + code += "dp3 " + temp + ".x, " + viewDirReg + ".xyz, " + normalReg + ".xyz\n" + + "mul " + temp + ".w, " + temp + ".x, " + temp + ".x\n" + + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + + "mul " + temp + ".w, " + data + ".z, " + temp + ".w\n" + + "mul " + temp + ".w, " + data + ".z, " + temp + ".w\n" + + "sub " + temp + ".w, " + data2 + ".x, " + temp + ".w\n" + + "sqt " + temp + ".y, " + temp + ".w\n" + + + "mul " + temp + ".x, " + data + ".z, " + temp + ".x\n" + + "add " + temp + ".x, " + temp + ".x, " + temp + ".y\n" + + "mul " + temp + ".xyz, " + temp + ".x, " + normalReg + ".xyz\n" + + + "mul " + refractionDir + ", " + data + ".z, " + viewDirReg + "\n" + + "sub " + refractionDir + ".xyz, " + refractionDir + ".xyz, " + temp + ".xyz\n" + + "nrm " + refractionDir + ".xyz, " + refractionDir + ".xyz\n"; + code += ShaderCompilerHelper.getTexCubeSampleCode(temp, cubeMapReg, this._envMap, shaderObject.useSmoothTextures, shaderObject.useMipmapping, refractionDir) + + "mov " + refractionColor + ".z, " + temp + ".z\n"; + } + + registerCache.removeFragmentTempUsage(refractionDir); + + code += "sub " + refractionColor + ".xyz, " + refractionColor + ".xyz, " + targetReg + ".xyz\n" + + "mul " + refractionColor + ".xyz, " + refractionColor + ".xyz, " + data + ".w\n" + + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + refractionColor + ".xyz\n"; + + registerCache.removeFragmentTempUsage(refractionColor); + + // restore + code += "neg " + viewDirReg + ".xyz, " + viewDirReg + ".xyz\n"; + + return code; + } +} + +export = EffectRefractionEnvMapMethod; \ No newline at end of file diff --git a/lib/materials/methods/EffectRimLightMethod.js b/lib/materials/methods/EffectRimLightMethod.js new file mode 100755 index 000000000..0715cbc8f --- /dev/null +++ b/lib/materials/methods/EffectRimLightMethod.js @@ -0,0 +1,147 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +/** + * EffectRimLightMethod provides a method to add rim lighting to a material. This adds a glow-like effect to edges of objects. + */ +var EffectRimLightMethod = (function (_super) { + __extends(EffectRimLightMethod, _super); + /** + * Creates a new EffectRimLightMethod object. + * + * @param color The colour of the rim light. + * @param strength The strength of the rim light. + * @param power The power of the rim light. Higher values will result in a higher edge fall-off. + * @param blend The blend mode with which to add the light to the object. + */ + function EffectRimLightMethod(color, strength, power, blend) { + if (color === void 0) { color = 0xffffff; } + if (strength === void 0) { strength = .4; } + if (power === void 0) { power = 2; } + if (blend === void 0) { blend = "mix"; } + _super.call(this); + this._blendMode = blend; + this._strength = strength; + this._power = power; + this.color = color; + } + /** + * @inheritDoc + */ + EffectRimLightMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 3] = 1; + }; + /** + * @inheritDoc + */ + EffectRimLightMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsNormals = true; + methodVO.needsView = true; + }; + Object.defineProperty(EffectRimLightMethod.prototype, "blendMode", { + /** + * The blend mode with which to add the light to the object. + * + * EffectRimLightMethod.MULTIPLY multiplies the rim light with the material's colour. + * EffectRimLightMethod.ADD adds the rim light with the material's colour. + * EffectRimLightMethod.MIX provides normal alpha blending. + */ + get: function () { + return this._blendMode; + }, + set: function (value) { + if (this._blendMode == value) + return; + this._blendMode = value; + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRimLightMethod.prototype, "color", { + /** + * The color of the rim light. + */ + get: function () { + return this._color; + }, + set: function (value /*uint*/) { + this._color = value; + this._colorR = ((value >> 16) & 0xff) / 0xff; + this._colorG = ((value >> 8) & 0xff) / 0xff; + this._colorB = (value & 0xff) / 0xff; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRimLightMethod.prototype, "strength", { + /** + * The strength of the rim light. + */ + get: function () { + return this._strength; + }, + set: function (value) { + this._strength = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(EffectRimLightMethod.prototype, "power", { + /** + * The power of the rim light. Higher values will result in a higher edge fall-off. + */ + get: function () { + return this._power; + }, + set: function (value) { + this._power = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + EffectRimLightMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + var index = methodVO.fragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = this._colorR; + data[index + 1] = this._colorG; + data[index + 2] = this._colorB; + data[index + 4] = this._strength; + data[index + 5] = this._power; + }; + /** + * @inheritDoc + */ + EffectRimLightMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var dataRegister = registerCache.getFreeFragmentConstant(); + var dataRegister2 = registerCache.getFreeFragmentConstant(); + var temp = registerCache.getFreeFragmentVectorTemp(); + var code = ""; + methodVO.fragmentConstantsIndex = dataRegister.index * 4; + code += "dp3 " + temp + ".x, " + sharedRegisters.viewDirFragment + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + "sat " + temp + ".x, " + temp + ".x\n" + "sub " + temp + ".x, " + dataRegister + ".w, " + temp + ".x\n" + "pow " + temp + ".x, " + temp + ".x, " + dataRegister2 + ".y\n" + "mul " + temp + ".x, " + temp + ".x, " + dataRegister2 + ".x\n" + "sub " + temp + ".x, " + dataRegister + ".w, " + temp + ".x\n" + "mul " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".x\n" + "sub " + temp + ".w, " + dataRegister + ".w, " + temp + ".x\n"; + if (this._blendMode == EffectRimLightMethod.ADD) { + code += "mul " + temp + ".xyz, " + temp + ".w, " + dataRegister + ".xyz\n" + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + } + else if (this._blendMode == EffectRimLightMethod.MULTIPLY) { + code += "mul " + temp + ".xyz, " + temp + ".w, " + dataRegister + ".xyz\n" + "mul " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + } + else { + code += "sub " + temp + ".xyz, " + dataRegister + ".xyz, " + targetReg + ".xyz\n" + "mul " + temp + ".xyz, " + temp + ".xyz, " + temp + ".w\n" + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + } + return code; + }; + EffectRimLightMethod.ADD = "add"; + EffectRimLightMethod.MULTIPLY = "multiply"; + EffectRimLightMethod.MIX = "mix"; + return EffectRimLightMethod; +})(EffectMethodBase); +module.exports = EffectRimLightMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/effectrimlightmethod.ts"],"names":["EffectRimLightMethod","EffectRimLightMethod.constructor","EffectRimLightMethod.iInitConstants","EffectRimLightMethod.iInitVO","EffectRimLightMethod.blendMode","EffectRimLightMethod.color","EffectRimLightMethod.strength","EffectRimLightMethod.power","EffectRimLightMethod.iActivate","EffectRimLightMethod.iGetFragmentCode"],"mappings":"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","file":"materials/methods/EffectRimLightMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\n\n/**\n * EffectRimLightMethod provides a method to add rim lighting to a material. This adds a glow-like effect to edges of objects.\n */\nclass EffectRimLightMethod extends EffectMethodBase\n{\n\tpublic static ADD:string = \"add\";\n\tpublic static MULTIPLY:string = \"multiply\";\n\tpublic static MIX:string = \"mix\";\n\n\tprivate _color:number /*uint*/;\n\tprivate _blendMode:string;\n\tprivate _colorR:number;\n\tprivate _colorG:number;\n\tprivate _colorB:number;\n\tprivate _strength:number;\n\tprivate _power:number;\n\n\t/**\n\t * Creates a new <code>EffectRimLightMethod</code> object.\n\t *\n\t * @param color The colour of the rim light.\n\t * @param strength The strength of the rim light.\n\t * @param power The power of the rim light. Higher values will result in a higher edge fall-off.\n\t * @param blend The blend mode with which to add the light to the object.\n\t */\n\tconstructor(color:number /*uint*/ = 0xffffff, strength:number = .4, power:number = 2, blend:string = \"mix\")\n\t{\n\t\tsuper();\n\n\t\tthis._blendMode = blend;\n\t\tthis._strength = strength;\n\t\tthis._power = power;\n\n\t\tthis.color = color;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tshaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 3] = 1;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsNormals = true;\n\t\tmethodVO.needsView = true;\n\t}\n\n\n\t/**\n\t * The blend mode with which to add the light to the object.\n\t *\n\t * EffectRimLightMethod.MULTIPLY multiplies the rim light with the material's colour.\n\t * EffectRimLightMethod.ADD adds the rim light with the material's colour.\n\t * EffectRimLightMethod.MIX provides normal alpha blending.\n\t */\n\tpublic get blendMode():string\n\t{\n\t\treturn this._blendMode;\n\t}\n\n\tpublic set blendMode(value:string)\n\t{\n\t\tif (this._blendMode == value)\n\t\t\treturn;\n\n\t\tthis._blendMode = value;\n\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * The color of the rim light.\n\t */\n\tpublic get color():number /*uint*/\n\t{\n\t\treturn this._color;\n\t}\n\n\tpublic set color(value:number /*uint*/)\n\t{\n\t\tthis._color = value;\n\t\tthis._colorR = ((value >> 16) & 0xff)/0xff;\n\t\tthis._colorG = ((value >> 8) & 0xff)/0xff;\n\t\tthis._colorB = (value & 0xff)/0xff;\n\t}\n\n\t/**\n\t * The strength of the rim light.\n\t */\n\tpublic get strength():number\n\t{\n\t\treturn this._strength;\n\t}\n\n\tpublic set strength(value:number)\n\t{\n\t\tthis._strength = value;\n\t}\n\n\t/**\n\t * The power of the rim light. Higher values will result in a higher edge fall-off.\n\t */\n\tpublic get power():number\n\t{\n\t\treturn this._power;\n\t}\n\n\tpublic set power(value:number)\n\t{\n\t\tthis._power = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index] = this._colorR;\n\t\tdata[index + 1] = this._colorG;\n\t\tdata[index + 2] = this._colorB;\n\t\tdata[index + 4] = this._strength;\n\t\tdata[index + 5] = this._power;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar dataRegister:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar dataRegister2:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tvar code:string = \"\";\n\n\t\tmethodVO.fragmentConstantsIndex = dataRegister.index*4;\n\n\t\tcode += \"dp3 \" + temp + \".x, \" + sharedRegisters.viewDirFragment + \".xyz, \" + sharedRegisters.normalFragment + \".xyz\\n\" +\n\t\t\t\"sat \" + temp + \".x, \" + temp + \".x\\n\" +\n\t\t\t\"sub \" + temp + \".x, \" + dataRegister + \".w, \" + temp + \".x\\n\" +\n\t\t\t\"pow \" + temp + \".x, \" + temp + \".x, \" + dataRegister2 + \".y\\n\" +\n\t\t\t\"mul \" + temp + \".x, \" + temp + \".x, \" + dataRegister2 + \".x\\n\" +\n\t\t\t\"sub \" + temp + \".x, \" + dataRegister + \".w, \" + temp + \".x\\n\" +\n\t\t\t\"mul \" + targetReg + \".xyz, \" + targetReg + \".xyz, \" + temp + \".x\\n\" +\n\t\t\t\"sub \" + temp + \".w, \" + dataRegister + \".w, \" + temp + \".x\\n\";\n\n\t\tif (this._blendMode == EffectRimLightMethod.ADD) {\n\t\t\tcode += \"mul \" + temp + \".xyz, \" + temp + \".w, \" + dataRegister + \".xyz\\n\" +\n\t\t\t\t\"add \" + targetReg + \".xyz, \" + targetReg + \".xyz, \" + temp + \".xyz\\n\";\n\t\t} else if (this._blendMode == EffectRimLightMethod.MULTIPLY) {\n\t\t\tcode += \"mul \" + temp + \".xyz, \" + temp + \".w, \" + dataRegister + \".xyz\\n\" +\n\t\t\t\t\"mul \" + targetReg + \".xyz, \" + targetReg + \".xyz, \" + temp + \".xyz\\n\";\n\t\t} else {\n\t\t\tcode += \"sub \" + temp + \".xyz, \" + dataRegister + \".xyz, \" + targetReg + \".xyz\\n\" +\n\t\t\t\t\"mul \" + temp + \".xyz, \" + temp + \".xyz, \" + temp + \".w\\n\" +\n\t\t\t\t\"add \" + targetReg + \".xyz, \" + targetReg + \".xyz, \" + temp + \".xyz\\n\";\n\t\t}\n\n\t\treturn code;\n\t}\n}\n\nexport = EffectRimLightMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/EffectRimLightMethod.ts b/lib/materials/methods/EffectRimLightMethod.ts new file mode 100644 index 000000000..793e47924 --- /dev/null +++ b/lib/materials/methods/EffectRimLightMethod.ts @@ -0,0 +1,178 @@ +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); + +/** + * EffectRimLightMethod provides a method to add rim lighting to a material. This adds a glow-like effect to edges of objects. + */ +class EffectRimLightMethod extends EffectMethodBase +{ + public static ADD:string = "add"; + public static MULTIPLY:string = "multiply"; + public static MIX:string = "mix"; + + private _color:number /*uint*/; + private _blendMode:string; + private _colorR:number; + private _colorG:number; + private _colorB:number; + private _strength:number; + private _power:number; + + /** + * Creates a new EffectRimLightMethod object. + * + * @param color The colour of the rim light. + * @param strength The strength of the rim light. + * @param power The power of the rim light. Higher values will result in a higher edge fall-off. + * @param blend The blend mode with which to add the light to the object. + */ + constructor(color:number /*uint*/ = 0xffffff, strength:number = .4, power:number = 2, blend:string = "mix") + { + super(); + + this._blendMode = blend; + this._strength = strength; + this._power = power; + + this.color = color; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 3] = 1; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + methodVO.needsNormals = true; + methodVO.needsView = true; + } + + + /** + * The blend mode with which to add the light to the object. + * + * EffectRimLightMethod.MULTIPLY multiplies the rim light with the material's colour. + * EffectRimLightMethod.ADD adds the rim light with the material's colour. + * EffectRimLightMethod.MIX provides normal alpha blending. + */ + public get blendMode():string + { + return this._blendMode; + } + + public set blendMode(value:string) + { + if (this._blendMode == value) + return; + + this._blendMode = value; + + this.iInvalidateShaderProgram(); + } + + /** + * The color of the rim light. + */ + public get color():number /*uint*/ + { + return this._color; + } + + public set color(value:number /*uint*/) + { + this._color = value; + this._colorR = ((value >> 16) & 0xff)/0xff; + this._colorG = ((value >> 8) & 0xff)/0xff; + this._colorB = (value & 0xff)/0xff; + } + + /** + * The strength of the rim light. + */ + public get strength():number + { + return this._strength; + } + + public set strength(value:number) + { + this._strength = value; + } + + /** + * The power of the rim light. Higher values will result in a higher edge fall-off. + */ + public get power():number + { + return this._power; + } + + public set power(value:number) + { + this._power = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index] = this._colorR; + data[index + 1] = this._colorG; + data[index + 2] = this._colorB; + data[index + 4] = this._strength; + data[index + 5] = this._power; + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var dataRegister:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var dataRegister2:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + var code:string = ""; + + methodVO.fragmentConstantsIndex = dataRegister.index*4; + + code += "dp3 " + temp + ".x, " + sharedRegisters.viewDirFragment + ".xyz, " + sharedRegisters.normalFragment + ".xyz\n" + + "sat " + temp + ".x, " + temp + ".x\n" + + "sub " + temp + ".x, " + dataRegister + ".w, " + temp + ".x\n" + + "pow " + temp + ".x, " + temp + ".x, " + dataRegister2 + ".y\n" + + "mul " + temp + ".x, " + temp + ".x, " + dataRegister2 + ".x\n" + + "sub " + temp + ".x, " + dataRegister + ".w, " + temp + ".x\n" + + "mul " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".x\n" + + "sub " + temp + ".w, " + dataRegister + ".w, " + temp + ".x\n"; + + if (this._blendMode == EffectRimLightMethod.ADD) { + code += "mul " + temp + ".xyz, " + temp + ".w, " + dataRegister + ".xyz\n" + + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + } else if (this._blendMode == EffectRimLightMethod.MULTIPLY) { + code += "mul " + temp + ".xyz, " + temp + ".w, " + dataRegister + ".xyz\n" + + "mul " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + } else { + code += "sub " + temp + ".xyz, " + dataRegister + ".xyz, " + targetReg + ".xyz\n" + + "mul " + temp + ".xyz, " + temp + ".xyz, " + temp + ".w\n" + + "add " + targetReg + ".xyz, " + targetReg + ".xyz, " + temp + ".xyz\n"; + } + + return code; + } +} + +export = EffectRimLightMethod; \ No newline at end of file diff --git a/lib/materials/methods/NormalHeightMapMethod.js b/lib/materials/methods/NormalHeightMapMethod.js new file mode 100755 index 000000000..edd8bf8ec --- /dev/null +++ b/lib/materials/methods/NormalHeightMapMethod.js @@ -0,0 +1,75 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var NormalBasicMethod = require("awayjs-stagegl/lib/materials/methods/NormalBasicMethod"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * NormalHeightMapMethod provides a normal map method that uses a height map to calculate the normals. + */ +var NormalHeightMapMethod = (function (_super) { + __extends(NormalHeightMapMethod, _super); + /** + * Creates a new NormalHeightMapMethod method. + * + * @param heightMap The texture containing the height data. 0 means low, 1 means high. + * @param worldWidth The width of the 'world'. This is used to map uv coordinates' u component to scene dimensions. + * @param worldHeight The height of the 'world'. This is used to map the height map values to scene dimensions. + * @param worldDepth The depth of the 'world'. This is used to map uv coordinates' v component to scene dimensions. + */ + function NormalHeightMapMethod(heightMap, worldWidth, worldHeight, worldDepth) { + _super.call(this); + this.normalMap = heightMap; + this._worldXYRatio = worldWidth / worldHeight; + this._worldXZRatio = worldDepth / worldHeight; + } + /** + * @inheritDoc + */ + NormalHeightMapMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var index = methodVO.fragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = 1 / this.normalMap.width; + data[index + 1] = 1 / this.normalMap.height; + data[index + 2] = 0; + data[index + 3] = 1; + data[index + 4] = this._worldXYRatio; + data[index + 5] = this._worldXZRatio; + }; + Object.defineProperty(NormalHeightMapMethod.prototype, "tangentSpace", { + /** + * @inheritDoc + */ + get: function () { + return false; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + NormalHeightMapMethod.prototype.copyFrom = function (method) { + _super.prototype.copyFrom.call(this, method); + this._worldXYRatio = method._worldXYRatio; + this._worldXZRatio = method._worldXZRatio; + }; + /** + * @inheritDoc + */ + NormalHeightMapMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var temp = registerCache.getFreeFragmentVectorTemp(); + var dataReg = registerCache.getFreeFragmentConstant(); + var dataReg2 = registerCache.getFreeFragmentConstant(); + this._pNormalTextureRegister = registerCache.getFreeTextureReg(); + methodVO.texturesIndex = this._pNormalTextureRegister.index; + methodVO.fragmentConstantsIndex = dataReg.index * 4; + return ShaderCompilerHelper.getTex2DSampleCode(targetReg, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, sharedRegisters.uvVarying, "clamp") + "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg + ".xzzz\n" + ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp, "clamp") + "sub " + targetReg + ".x, " + targetReg + ".x, " + temp + ".x\n" + "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg + ".zyzz\n" + ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp, "clamp") + "sub " + targetReg + ".z, " + targetReg + ".z, " + temp + ".x\n" + "mov " + targetReg + ".y, " + dataReg + ".w\n" + "mul " + targetReg + ".xz, " + targetReg + ".xz, " + dataReg2 + ".xy\n" + "nrm " + targetReg + ".xyz, " + targetReg + ".xyz\n"; + }; + return NormalHeightMapMethod; +})(NormalBasicMethod); +module.exports = NormalHeightMapMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/normalheightmapmethod.ts"],"names":["NormalHeightMapMethod","NormalHeightMapMethod.constructor","NormalHeightMapMethod.iInitConstants","NormalHeightMapMethod.tangentSpace","NormalHeightMapMethod.copyFrom","NormalHeightMapMethod.iGetFragmentCode"],"mappings":"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","file":"materials/methods/NormalHeightMapMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport NormalBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/NormalBasicMethod\");\nimport ShadingMethodBase\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadingMethodBase\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * NormalHeightMapMethod provides a normal map method that uses a height map to calculate the normals.\n */\nclass NormalHeightMapMethod extends NormalBasicMethod\n{\n\tprivate _worldXYRatio:number;\n\tprivate _worldXZRatio:number;\n\n\t/**\n\t * Creates a new NormalHeightMapMethod method.\n\t *\n\t * @param heightMap The texture containing the height data. 0 means low, 1 means high.\n\t * @param worldWidth The width of the 'world'. This is used to map uv coordinates' u component to scene dimensions.\n\t * @param worldHeight The height of the 'world'. This is used to map the height map values to scene dimensions.\n\t * @param worldDepth The depth of the 'world'. This is used to map uv coordinates' v component to scene dimensions.\n\t */\n\tconstructor(heightMap:Texture2DBase, worldWidth:number, worldHeight:number, worldDepth:number)\n\t{\n\t\tsuper();\n\n\t\tthis.normalMap = heightMap;\n\t\tthis._worldXYRatio = worldWidth/worldHeight;\n\t\tthis._worldXZRatio = worldDepth/worldHeight;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index] = 1/this.normalMap.width;\n\t\tdata[index + 1] = 1/this.normalMap.height;\n\t\tdata[index + 2] = 0;\n\t\tdata[index + 3] = 1;\n\t\tdata[index + 4] = this._worldXYRatio;\n\t\tdata[index + 5] = this._worldXZRatio;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get tangentSpace():boolean\n\t{\n\t\treturn false;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic copyFrom(method:ShadingMethodBase)\n\t{\n\t\tsuper.copyFrom(method);\n\n\t\tthis._worldXYRatio = (<NormalHeightMapMethod> method)._worldXYRatio;\n\t\tthis._worldXZRatio = (<NormalHeightMapMethod> method)._worldXZRatio;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar dataReg2:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tthis._pNormalTextureRegister = registerCache.getFreeTextureReg();\n\t\tmethodVO.texturesIndex = this._pNormalTextureRegister.index;\n\t\tmethodVO.fragmentConstantsIndex = dataReg.index*4;\n\n\t\treturn ShaderCompilerHelper.getTex2DSampleCode(targetReg, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, sharedRegisters.uvVarying, \"clamp\") +\n\n\t\t\t\"add \" + temp + \", \" + sharedRegisters.uvVarying + \", \" + dataReg + \".xzzz\\n\" +\n\n\t\t\tShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp, \"clamp\") +\n\n\t\t\t\"sub \" + targetReg + \".x, \" + targetReg + \".x, \" + temp + \".x\\n\" +\n\t\t\t\"add \" + temp + \", \" + sharedRegisters.uvVarying + \", \" + dataReg + \".zyzz\\n\" +\n\n\t\t\tShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp, \"clamp\") +\n\n\t\t\t\"sub \" + targetReg + \".z, \" + targetReg + \".z, \" + temp + \".x\\n\" +\n\t\t\t\"mov \" + targetReg + \".y, \" + dataReg + \".w\\n\" +\n\t\t\t\"mul \" + targetReg + \".xz, \" + targetReg + \".xz, \" + dataReg2 + \".xy\\n\" +\n\t\t\t\"nrm \" + targetReg + \".xyz, \" + targetReg + \".xyz\\n\";\n\t}\n}\n\nexport = NormalHeightMapMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/NormalHeightMapMethod.ts b/lib/materials/methods/NormalHeightMapMethod.ts new file mode 100644 index 000000000..5fffa81d5 --- /dev/null +++ b/lib/materials/methods/NormalHeightMapMethod.ts @@ -0,0 +1,101 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import NormalBasicMethod = require("awayjs-stagegl/lib/materials/methods/NormalBasicMethod"); +import ShadingMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadingMethodBase"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * NormalHeightMapMethod provides a normal map method that uses a height map to calculate the normals. + */ +class NormalHeightMapMethod extends NormalBasicMethod +{ + private _worldXYRatio:number; + private _worldXZRatio:number; + + /** + * Creates a new NormalHeightMapMethod method. + * + * @param heightMap The texture containing the height data. 0 means low, 1 means high. + * @param worldWidth The width of the 'world'. This is used to map uv coordinates' u component to scene dimensions. + * @param worldHeight The height of the 'world'. This is used to map the height map values to scene dimensions. + * @param worldDepth The depth of the 'world'. This is used to map uv coordinates' v component to scene dimensions. + */ + constructor(heightMap:Texture2DBase, worldWidth:number, worldHeight:number, worldDepth:number) + { + super(); + + this.normalMap = heightMap; + this._worldXYRatio = worldWidth/worldHeight; + this._worldXZRatio = worldDepth/worldHeight; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index] = 1/this.normalMap.width; + data[index + 1] = 1/this.normalMap.height; + data[index + 2] = 0; + data[index + 3] = 1; + data[index + 4] = this._worldXYRatio; + data[index + 5] = this._worldXZRatio; + } + + /** + * @inheritDoc + */ + public get tangentSpace():boolean + { + return false; + } + + /** + * @inheritDoc + */ + public copyFrom(method:ShadingMethodBase) + { + super.copyFrom(method); + + this._worldXYRatio = ( method)._worldXYRatio; + this._worldXZRatio = ( method)._worldXZRatio; + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + var dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var dataReg2:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + this._pNormalTextureRegister = registerCache.getFreeTextureReg(); + methodVO.texturesIndex = this._pNormalTextureRegister.index; + methodVO.fragmentConstantsIndex = dataReg.index*4; + + return ShaderCompilerHelper.getTex2DSampleCode(targetReg, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, sharedRegisters.uvVarying, "clamp") + + + "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg + ".xzzz\n" + + + ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp, "clamp") + + + "sub " + targetReg + ".x, " + targetReg + ".x, " + temp + ".x\n" + + "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg + ".zyzz\n" + + + ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp, "clamp") + + + "sub " + targetReg + ".z, " + targetReg + ".z, " + temp + ".x\n" + + "mov " + targetReg + ".y, " + dataReg + ".w\n" + + "mul " + targetReg + ".xz, " + targetReg + ".xz, " + dataReg2 + ".xy\n" + + "nrm " + targetReg + ".xyz, " + targetReg + ".xyz\n"; + } +} + +export = NormalHeightMapMethod; \ No newline at end of file diff --git a/lib/materials/methods/NormalSimpleWaterMethod.js b/lib/materials/methods/NormalSimpleWaterMethod.js new file mode 100755 index 000000000..9c5fc15b0 --- /dev/null +++ b/lib/materials/methods/NormalSimpleWaterMethod.js @@ -0,0 +1,158 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var NormalBasicMethod = require("awayjs-stagegl/lib/materials/methods/NormalBasicMethod"); +var ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); +/** + * NormalSimpleWaterMethod provides a basic normal map method to create water ripples by translating two wave normal maps. + */ +var NormalSimpleWaterMethod = (function (_super) { + __extends(NormalSimpleWaterMethod, _super); + /** + * Creates a new NormalSimpleWaterMethod object. + * @param waveMap1 A normal map containing one layer of a wave structure. + * @param waveMap2 A normal map containing a second layer of a wave structure. + */ + function NormalSimpleWaterMethod(waveMap1, waveMap2) { + _super.call(this); + this._useSecondNormalMap = false; + this._water1OffsetX = 0; + this._water1OffsetY = 0; + this._water2OffsetX = 0; + this._water2OffsetY = 0; + this.normalMap = waveMap1; + this.secondaryNormalMap = waveMap2; + } + /** + * @inheritDoc + */ + NormalSimpleWaterMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var index = methodVO.fragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = .5; + data[index + 1] = 0; + data[index + 2] = 0; + data[index + 3] = 1; + }; + /** + * @inheritDoc + */ + NormalSimpleWaterMethod.prototype.iInitVO = function (shaderObject, methodVO) { + _super.prototype.iInitVO.call(this, shaderObject, methodVO); + this._useSecondNormalMap = this.normalMap != this.secondaryNormalMap; + }; + Object.defineProperty(NormalSimpleWaterMethod.prototype, "water1OffsetX", { + /** + * The translation of the first wave layer along the X-axis. + */ + get: function () { + return this._water1OffsetX; + }, + set: function (value) { + this._water1OffsetX = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NormalSimpleWaterMethod.prototype, "water1OffsetY", { + /** + * The translation of the first wave layer along the Y-axis. + */ + get: function () { + return this._water1OffsetY; + }, + set: function (value) { + this._water1OffsetY = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NormalSimpleWaterMethod.prototype, "water2OffsetX", { + /** + * The translation of the second wave layer along the X-axis. + */ + get: function () { + return this._water2OffsetX; + }, + set: function (value) { + this._water2OffsetX = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NormalSimpleWaterMethod.prototype, "water2OffsetY", { + /** + * The translation of the second wave layer along the Y-axis. + */ + get: function () { + return this._water2OffsetY; + }, + set: function (value) { + this._water2OffsetY = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(NormalSimpleWaterMethod.prototype, "secondaryNormalMap", { + /** + * A second normal map that will be combined with the first to create a wave-like animation pattern. + */ + get: function () { + return this._texture2; + }, + set: function (value) { + this._texture2 = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + NormalSimpleWaterMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._normalTextureRegister2 = null; + }; + /** + * @inheritDoc + */ + NormalSimpleWaterMethod.prototype.dispose = function () { + _super.prototype.dispose.call(this); + this._texture2 = null; + }; + /** + * @inheritDoc + */ + NormalSimpleWaterMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var data = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + data[index + 4] = this._water1OffsetX; + data[index + 5] = this._water1OffsetY; + data[index + 6] = this._water2OffsetX; + data[index + 7] = this._water2OffsetY; + //if (this._useSecondNormalMap >= 0) + if (this._useSecondNormalMap) + stage.context.activateTexture(methodVO.texturesIndex + 1, this._texture2); + }; + /** + * @inheritDoc + */ + NormalSimpleWaterMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var temp = registerCache.getFreeFragmentVectorTemp(); + var dataReg = registerCache.getFreeFragmentConstant(); + var dataReg2 = registerCache.getFreeFragmentConstant(); + this._pNormalTextureRegister = registerCache.getFreeTextureReg(); + this._normalTextureRegister2 = this._useSecondNormalMap ? registerCache.getFreeTextureReg() : this._pNormalTextureRegister; + methodVO.texturesIndex = this._pNormalTextureRegister.index; + methodVO.fragmentConstantsIndex = dataReg.index * 4; + return "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg2 + ".xyxy\n" + ShaderCompilerHelper.getTex2DSampleCode(targetReg, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp) + "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg2 + ".zwzw\n" + ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._normalTextureRegister2, this._texture2, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp) + "add " + targetReg + ", " + targetReg + ", " + temp + " \n" + "mul " + targetReg + ", " + targetReg + ", " + dataReg + ".x \n" + "sub " + targetReg + ".xyz, " + targetReg + ".xyz, " + sharedRegisters.commons + ".xxx \n" + "nrm " + targetReg + ".xyz, " + targetReg + ".xyz \n"; + }; + return NormalSimpleWaterMethod; +})(NormalBasicMethod); +module.exports = NormalSimpleWaterMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/normalsimplewatermethod.ts"],"names":["NormalSimpleWaterMethod","NormalSimpleWaterMethod.constructor","NormalSimpleWaterMethod.iInitConstants","NormalSimpleWaterMethod.iInitVO","NormalSimpleWaterMethod.water1OffsetX","NormalSimpleWaterMethod.water1OffsetY","NormalSimpleWaterMethod.water2OffsetX","NormalSimpleWaterMethod.water2OffsetY","NormalSimpleWaterMethod.secondaryNormalMap","NormalSimpleWaterMethod.iCleanCompilationData","NormalSimpleWaterMethod.dispose","NormalSimpleWaterMethod.iActivate","NormalSimpleWaterMethod.iGetFragmentCode"],"mappings":"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","file":"materials/methods/NormalSimpleWaterMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport NormalBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/NormalBasicMethod\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * NormalSimpleWaterMethod provides a basic normal map method to create water ripples by translating two wave normal maps.\n */\nclass NormalSimpleWaterMethod extends NormalBasicMethod\n{\n\tprivate _texture2:Texture2DBase;\n\tprivate _normalTextureRegister2:ShaderRegisterElement;\n\tprivate _useSecondNormalMap:boolean = false;\n\tprivate _water1OffsetX:number = 0;\n\tprivate _water1OffsetY:number = 0;\n\tprivate _water2OffsetX:number = 0;\n\tprivate _water2OffsetY:number = 0;\n\n\t/**\n\t * Creates a new NormalSimpleWaterMethod object.\n\t * @param waveMap1 A normal map containing one layer of a wave structure.\n\t * @param waveMap2 A normal map containing a second layer of a wave structure.\n\t */\n\tconstructor(waveMap1:Texture2DBase, waveMap2:Texture2DBase)\n\t{\n\t\tsuper();\n\t\tthis.normalMap = waveMap1;\n\t\tthis.secondaryNormalMap = waveMap2;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tvar index:number = methodVO.fragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index] = .5;\n\t\tdata[index + 1] = 0;\n\t\tdata[index + 2] = 0;\n\t\tdata[index + 3] = 1;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tsuper.iInitVO(shaderObject, methodVO);\n\n\t\tthis._useSecondNormalMap = this.normalMap != this.secondaryNormalMap;\n\t}\n\n\t/**\n\t * The translation of the first wave layer along the X-axis.\n\t */\n\tpublic get water1OffsetX():number\n\t{\n\t\treturn this._water1OffsetX;\n\t}\n\n\tpublic set water1OffsetX(value:number)\n\t{\n\t\tthis._water1OffsetX = value;\n\t}\n\n\t/**\n\t * The translation of the first wave layer along the Y-axis.\n\t */\n\tpublic get water1OffsetY():number\n\t{\n\t\treturn this._water1OffsetY;\n\t}\n\n\tpublic set water1OffsetY(value:number)\n\t{\n\t\tthis._water1OffsetY = value;\n\t}\n\n\t/**\n\t * The translation of the second wave layer along the X-axis.\n\t */\n\tpublic get water2OffsetX():number\n\t{\n\t\treturn this._water2OffsetX;\n\t}\n\n\tpublic set water2OffsetX(value:number)\n\t{\n\t\tthis._water2OffsetX = value;\n\t}\n\n\t/**\n\t * The translation of the second wave layer along the Y-axis.\n\t */\n\tpublic get water2OffsetY():number\n\t{\n\t\treturn this._water2OffsetY;\n\t}\n\n\tpublic set water2OffsetY(value:number)\n\t{\n\t\tthis._water2OffsetY = value;\n\t}\n\n\t/**\n\t * A second normal map that will be combined with the first to create a wave-like animation pattern.\n\t */\n\tpublic get secondaryNormalMap():Texture2DBase\n\t{\n\t\treturn this._texture2;\n\t}\n\n\tpublic set secondaryNormalMap(value:Texture2DBase)\n\t{\n\t\tthis._texture2 = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._normalTextureRegister2 = null;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t\tsuper.dispose();\n\t\tthis._texture2 = null;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number = methodVO.fragmentConstantsIndex;\n\n\t\tdata[index + 4] = this._water1OffsetX;\n\t\tdata[index + 5] = this._water1OffsetY;\n\t\tdata[index + 6] = this._water2OffsetX;\n\t\tdata[index + 7] = this._water2OffsetY;\n\n\t\t//if (this._useSecondNormalMap >= 0)\n\t\tif (this._useSecondNormalMap)\n\t\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex + 1, this._texture2);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar dataReg2:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tthis._pNormalTextureRegister = registerCache.getFreeTextureReg();\n\t\tthis._normalTextureRegister2 = this._useSecondNormalMap? registerCache.getFreeTextureReg():this._pNormalTextureRegister;\n\t\tmethodVO.texturesIndex = this._pNormalTextureRegister.index;\n\n\t\tmethodVO.fragmentConstantsIndex = dataReg.index*4;\n\n\t\treturn \"add \" + temp + \", \" + sharedRegisters.uvVarying + \", \" + dataReg2 + \".xyxy\\n\" +\n\t\t\tShaderCompilerHelper.getTex2DSampleCode(targetReg, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp) +\n\t\t\t\"add \" + temp + \", \" + sharedRegisters.uvVarying + \", \" + dataReg2 + \".zwzw\\n\" +\n\t\t\tShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._normalTextureRegister2, this._texture2, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp) +\n\t\t\t\"add \" + targetReg + \", \" + targetReg + \", \" + temp + \"\t\t\\n\" +\n\t\t\t\"mul \" + targetReg + \", \" + targetReg + \", \" + dataReg + \".x\t\\n\" +\n\t\t\t\"sub \" + targetReg + \".xyz, \" + targetReg + \".xyz, \" + sharedRegisters.commons + \".xxx\t\\n\" +\n\t\t\t\"nrm \" + targetReg + \".xyz, \" + targetReg + \".xyz\t\t\t\t\t\t\t\\n\";\n\t}\n}\n\nexport = NormalSimpleWaterMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/NormalSimpleWaterMethod.ts b/lib/materials/methods/NormalSimpleWaterMethod.ts new file mode 100755 index 000000000..d097aae51 --- /dev/null +++ b/lib/materials/methods/NormalSimpleWaterMethod.ts @@ -0,0 +1,189 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import NormalBasicMethod = require("awayjs-stagegl/lib/materials/methods/NormalBasicMethod"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * NormalSimpleWaterMethod provides a basic normal map method to create water ripples by translating two wave normal maps. + */ +class NormalSimpleWaterMethod extends NormalBasicMethod +{ + private _texture2:Texture2DBase; + private _normalTextureRegister2:ShaderRegisterElement; + private _useSecondNormalMap:boolean = false; + private _water1OffsetX:number = 0; + private _water1OffsetY:number = 0; + private _water2OffsetX:number = 0; + private _water2OffsetY:number = 0; + + /** + * Creates a new NormalSimpleWaterMethod object. + * @param waveMap1 A normal map containing one layer of a wave structure. + * @param waveMap2 A normal map containing a second layer of a wave structure. + */ + constructor(waveMap1:Texture2DBase, waveMap2:Texture2DBase) + { + super(); + this.normalMap = waveMap1; + this.secondaryNormalMap = waveMap2; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + var index:number = methodVO.fragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index] = .5; + data[index + 1] = 0; + data[index + 2] = 0; + data[index + 3] = 1; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + super.iInitVO(shaderObject, methodVO); + + this._useSecondNormalMap = this.normalMap != this.secondaryNormalMap; + } + + /** + * The translation of the first wave layer along the X-axis. + */ + public get water1OffsetX():number + { + return this._water1OffsetX; + } + + public set water1OffsetX(value:number) + { + this._water1OffsetX = value; + } + + /** + * The translation of the first wave layer along the Y-axis. + */ + public get water1OffsetY():number + { + return this._water1OffsetY; + } + + public set water1OffsetY(value:number) + { + this._water1OffsetY = value; + } + + /** + * The translation of the second wave layer along the X-axis. + */ + public get water2OffsetX():number + { + return this._water2OffsetX; + } + + public set water2OffsetX(value:number) + { + this._water2OffsetX = value; + } + + /** + * The translation of the second wave layer along the Y-axis. + */ + public get water2OffsetY():number + { + return this._water2OffsetY; + } + + public set water2OffsetY(value:number) + { + this._water2OffsetY = value; + } + + /** + * A second normal map that will be combined with the first to create a wave-like animation pattern. + */ + public get secondaryNormalMap():Texture2DBase + { + return this._texture2; + } + + public set secondaryNormalMap(value:Texture2DBase) + { + this._texture2 = value; + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._normalTextureRegister2 = null; + } + + /** + * @inheritDoc + */ + public dispose() + { + super.dispose(); + this._texture2 = null; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var data:Array = shaderObject.fragmentConstantData; + var index:number = methodVO.fragmentConstantsIndex; + + data[index + 4] = this._water1OffsetX; + data[index + 5] = this._water1OffsetY; + data[index + 6] = this._water2OffsetX; + data[index + 7] = this._water2OffsetY; + + //if (this._useSecondNormalMap >= 0) + if (this._useSecondNormalMap) + ( stage.context).activateTexture(methodVO.texturesIndex + 1, this._texture2); + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + var dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var dataReg2:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + this._pNormalTextureRegister = registerCache.getFreeTextureReg(); + this._normalTextureRegister2 = this._useSecondNormalMap? registerCache.getFreeTextureReg():this._pNormalTextureRegister; + methodVO.texturesIndex = this._pNormalTextureRegister.index; + + methodVO.fragmentConstantsIndex = dataReg.index*4; + + return "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg2 + ".xyxy\n" + + ShaderCompilerHelper.getTex2DSampleCode(targetReg, sharedRegisters, this._pNormalTextureRegister, this.normalMap, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp) + + "add " + temp + ", " + sharedRegisters.uvVarying + ", " + dataReg2 + ".zwzw\n" + + ShaderCompilerHelper.getTex2DSampleCode(temp, sharedRegisters, this._normalTextureRegister2, this._texture2, shaderObject.useSmoothTextures, shaderObject.repeatTextures, shaderObject.useMipmapping, temp) + + "add " + targetReg + ", " + targetReg + ", " + temp + " \n" + + "mul " + targetReg + ", " + targetReg + ", " + dataReg + ".x \n" + + "sub " + targetReg + ".xyz, " + targetReg + ".xyz, " + sharedRegisters.commons + ".xxx \n" + + "nrm " + targetReg + ".xyz, " + targetReg + ".xyz \n"; + } +} + +export = NormalSimpleWaterMethod; \ No newline at end of file diff --git a/lib/materials/methods/ShadowCascadeMethod.js b/lib/materials/methods/ShadowCascadeMethod.js new file mode 100755 index 000000000..ce7bb735c --- /dev/null +++ b/lib/materials/methods/ShadowCascadeMethod.js @@ -0,0 +1,200 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +var Event = require("awayjs-core/lib/events/Event"); +var ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +var MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +var ShadowMapMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMapMethodBase"); +/** + * ShadowCascadeMethod is a shadow map method to apply cascade shadow mapping on materials. + * Must be used with a DirectionalLight with a CascadeShadowMapper assigned to its shadowMapper property. + * + * @see away.lights.CascadeShadowMapper + */ +var ShadowCascadeMethod = (function (_super) { + __extends(ShadowCascadeMethod, _super); + /** + * Creates a new ShadowCascadeMethod object. + * + * @param shadowMethodBase The shadow map sampling method used to sample individual cascades (fe: ShadowHardMethod, ShadowSoftMethod) + */ + function ShadowCascadeMethod(shadowMethodBase) { + var _this = this; + _super.call(this, shadowMethodBase.castingLight); + this._baseMethod = shadowMethodBase; + if (!(this._pCastingLight instanceof DirectionalLight)) + throw new Error("ShadowCascadeMethod is only compatible with DirectionalLight"); + this._cascadeShadowMapper = this._pCastingLight.shadowMapper; + if (!this._cascadeShadowMapper) + throw new Error("ShadowCascadeMethod requires a light that has a CascadeShadowMapper instance assigned to shadowMapper."); + this._cascadeShadowMapper.addEventListener(Event.CHANGE, function (event) { return _this.onCascadeChange(event); }); + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, function (event) { return _this.onShaderInvalidated(event); }); + } + Object.defineProperty(ShadowCascadeMethod.prototype, "baseMethod", { + /** + * The shadow map sampling method used to sample individual cascades. These are typically those used in conjunction + * with a DirectionalShadowMapper. + * + * @see ShadowHardMethod + * @see ShadowSoftMethod + */ + get: function () { + return this._baseMethod; + }, + set: function (value) { + var _this = this; + if (this._baseMethod == value) + return; + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, function (event) { return _this.onShaderInvalidated(event); }); + this._baseMethod = value; + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, function (event) { return _this.onShaderInvalidated(event); }); + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ShadowCascadeMethod.prototype.iInitVO = function (shaderObject, methodVO) { + var tempVO = new MethodVO(this._baseMethod); + this._baseMethod.iInitVO(shaderObject, tempVO); + methodVO.needsGlobalVertexPos = true; + methodVO.needsProjection = true; + }; + /** + * @inheritDoc + */ + ShadowCascadeMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var fragmentData = shaderObject.fragmentConstantData; + var vertexData = shaderObject.vertexConstantData; + var index = methodVO.fragmentConstantsIndex; + fragmentData[index] = 1.0; + fragmentData[index + 1] = 1 / 255.0; + fragmentData[index + 2] = 1 / 65025.0; + fragmentData[index + 3] = 1 / 16581375.0; + fragmentData[index + 6] = .5; + fragmentData[index + 7] = -.5; + index = methodVO.vertexConstantsIndex; + vertexData[index] = .5; + vertexData[index + 1] = -.5; + vertexData[index + 2] = 0; + }; + /** + * @inheritDoc + */ + ShadowCascadeMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._cascadeProjections = null; + this._depthMapCoordVaryings = null; + }; + /** + * @inheritDoc + */ + ShadowCascadeMethod.prototype.iGetVertexCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + var code = ""; + var dataReg = registerCache.getFreeVertexConstant(); + this.initProjectionsRegs(registerCache); + methodVO.vertexConstantsIndex = dataReg.index * 4; + var temp = registerCache.getFreeVertexVectorTemp(); + for (var i = 0; i < this._cascadeShadowMapper.numCascades; ++i) { + code += "m44 " + temp + ", " + sharedRegisters.globalPositionVertex + ", " + this._cascadeProjections[i] + "\n" + "add " + this._depthMapCoordVaryings[i] + ", " + temp + ", " + dataReg + ".zzwz\n"; + } + return code; + }; + /** + * Creates the registers for the cascades' projection coordinates. + */ + ShadowCascadeMethod.prototype.initProjectionsRegs = function (registerCache) { + this._cascadeProjections = new Array(this._cascadeShadowMapper.numCascades); + this._depthMapCoordVaryings = new Array(this._cascadeShadowMapper.numCascades); + for (var i = 0; i < this._cascadeShadowMapper.numCascades; ++i) { + this._depthMapCoordVaryings[i] = registerCache.getFreeVarying(); + this._cascadeProjections[i] = registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + } + }; + /** + * @inheritDoc + */ + ShadowCascadeMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var numCascades = this._cascadeShadowMapper.numCascades; + var depthMapRegister = registerCache.getFreeTextureReg(); + var decReg = registerCache.getFreeFragmentConstant(); + var dataReg = registerCache.getFreeFragmentConstant(); + var planeDistanceReg = registerCache.getFreeFragmentConstant(); + var planeDistances = Array(planeDistanceReg + ".x", planeDistanceReg + ".y", planeDistanceReg + ".z", planeDistanceReg + ".w"); + var code; + methodVO.fragmentConstantsIndex = decReg.index * 4; + methodVO.texturesIndex = depthMapRegister.index; + var inQuad = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(inQuad, 1); + var uvCoord = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(uvCoord, 1); + // assume lowest partition is selected, will be overwritten later otherwise + code = "mov " + uvCoord + ", " + this._depthMapCoordVaryings[numCascades - 1] + "\n"; + for (var i = numCascades - 2; i >= 0; --i) { + var uvProjection = this._depthMapCoordVaryings[i]; + // calculate if in texturemap (result == 0 or 1, only 1 for a single partition) + code += "slt " + inQuad + ".z, " + sharedRegisters.projectionFragment + ".z, " + planeDistances[i] + "\n"; // z = x > minX, w = y > minY + var temp = registerCache.getFreeFragmentVectorTemp(); + // linearly interpolate between old and new uv coords using predicate value == conditional toggle to new value if predicate == 1 (true) + code += "sub " + temp + ", " + uvProjection + ", " + uvCoord + "\n" + "mul " + temp + ", " + temp + ", " + inQuad + ".z\n" + "add " + uvCoord + ", " + uvCoord + ", " + temp + "\n"; + } + registerCache.removeFragmentTempUsage(inQuad); + code += "div " + uvCoord + ", " + uvCoord + ", " + uvCoord + ".w\n" + "mul " + uvCoord + ".xy, " + uvCoord + ".xy, " + dataReg + ".zw\n" + "add " + uvCoord + ".xy, " + uvCoord + ".xy, " + dataReg + ".zz\n"; + code += this._baseMethod._iGetCascadeFragmentCode(shaderObject, methodVO, decReg, depthMapRegister, uvCoord, targetReg, registerCache, sharedRegisters) + "add " + targetReg + ".w, " + targetReg + ".w, " + dataReg + ".y\n"; + registerCache.removeFragmentTempUsage(uvCoord); + return code; + }; + /** + * @inheritDoc + */ + ShadowCascadeMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + stage.context.activateTexture(methodVO.texturesIndex, this._pCastingLight.shadowMapper.depthMap); + var vertexData = shaderObject.vertexConstantData; + var vertexIndex = methodVO.vertexConstantsIndex; + shaderObject.vertexConstantData[methodVO.vertexConstantsIndex + 3] = -1 / (this._cascadeShadowMapper.depth * this._pEpsilon); + var numCascades = this._cascadeShadowMapper.numCascades; + vertexIndex += 4; + for (var k = 0; k < numCascades; ++k) { + this._cascadeShadowMapper.getDepthProjections(k).copyRawDataTo(vertexData, vertexIndex, true); + vertexIndex += 16; + } + var fragmentData = shaderObject.fragmentConstantData; + var fragmentIndex = methodVO.fragmentConstantsIndex; + fragmentData[fragmentIndex + 5] = 1 - this._pAlpha; + var nearPlaneDistances = this._cascadeShadowMapper._iNearPlaneDistances; + fragmentIndex += 8; + for (var i = 0; i < numCascades; ++i) + fragmentData[fragmentIndex + i] = nearPlaneDistances[i]; + this._baseMethod.iActivateForCascade(shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + ShadowCascadeMethod.prototype.iSetRenderState = function (shaderObject, methodVO, renderable, stage, camera) { + }; + /** + * Called when the shadow mappers cascade configuration changes. + */ + ShadowCascadeMethod.prototype.onCascadeChange = function (event) { + this.iInvalidateShaderProgram(); + }; + /** + * Called when the base method's shader code is invalidated. + */ + ShadowCascadeMethod.prototype.onShaderInvalidated = function (event) { + this.iInvalidateShaderProgram(); + }; + return ShadowCascadeMethod; +})(ShadowMapMethodBase); +module.exports = ShadowCascadeMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/shadowcascademethod.ts"],"names":["ShadowCascadeMethod","ShadowCascadeMethod.constructor","ShadowCascadeMethod.baseMethod","ShadowCascadeMethod.iInitVO","ShadowCascadeMethod.iInitConstants","ShadowCascadeMethod.iCleanCompilationData","ShadowCascadeMethod.iGetVertexCode","ShadowCascadeMethod.initProjectionsRegs","ShadowCascadeMethod.iGetFragmentCode","ShadowCascadeMethod.iActivate","ShadowCascadeMethod.iSetRenderState","ShadowCascadeMethod.onCascadeChange","ShadowCascadeMethod.onShaderInvalidated"],"mappings":"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","file":"materials/methods/ShadowCascadeMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport DirectionalLight\t\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\nimport Event\t\t\t\t\t\t\t= require(\"awayjs-core/lib/events/Event\");\nimport CascadeShadowMapper\t\t\t\t= require(\"awayjs-core/lib/materials/shadowmappers/CascadeShadowMapper\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport ShadingMethodEvent\t\t\t\t= require(\"awayjs-stagegl/lib/events/ShadingMethodEvent\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport ShadowMapMethodBase\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowMapMethodBase\");\nimport ShadowMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowMethodBase\");\nimport ShaderCompilerHelper\t\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper\");\n\n/**\n * ShadowCascadeMethod is a shadow map method to apply cascade shadow mapping on materials.\n * Must be used with a DirectionalLight with a CascadeShadowMapper assigned to its shadowMapper property.\n *\n * @see away.lights.CascadeShadowMapper\n */\nclass ShadowCascadeMethod extends ShadowMapMethodBase\n{\n\tprivate _baseMethod:ShadowMethodBase;\n\tprivate _cascadeShadowMapper:CascadeShadowMapper;\n\tprivate _depthMapCoordVaryings:Array<ShaderRegisterElement>;\n\tprivate _cascadeProjections:Array<ShaderRegisterElement>;\n\n\t/**\n\t * Creates a new ShadowCascadeMethod object.\n\t *\n\t * @param shadowMethodBase The shadow map sampling method used to sample individual cascades (fe: ShadowHardMethod, ShadowSoftMethod)\n\t */\n\tconstructor(shadowMethodBase:ShadowMethodBase)\n\t{\n\t\tsuper(shadowMethodBase.castingLight);\n\n\t\tthis._baseMethod = shadowMethodBase;\n\t\tif (!(this._pCastingLight instanceof DirectionalLight))\n\t\t\tthrow new Error(\"ShadowCascadeMethod is only compatible with DirectionalLight\");\n\n\t\tthis._cascadeShadowMapper = <CascadeShadowMapper> this._pCastingLight.shadowMapper;\n\n\t\tif (!this._cascadeShadowMapper)\n\t\t\tthrow new Error(\"ShadowCascadeMethod requires a light that has a CascadeShadowMapper instance assigned to shadowMapper.\");\n\n\t\tthis._cascadeShadowMapper.addEventListener(Event.CHANGE, (event:Event) => this.onCascadeChange(event));\n\t\tthis._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, (event:ShadingMethodEvent) => this.onShaderInvalidated(event));\n\t}\n\n\t/**\n\t * The shadow map sampling method used to sample individual cascades. These are typically those used in conjunction\n\t * with a DirectionalShadowMapper.\n\t *\n\t * @see ShadowHardMethod\n\t * @see ShadowSoftMethod\n\t */\n\tpublic get baseMethod():ShadowMethodBase\n\t{\n\t\treturn this._baseMethod;\n\t}\n\n\tpublic set baseMethod(value:ShadowMethodBase)\n\t{\n\t\tif (this._baseMethod == value)\n\t\t\treturn;\n\n\t\tthis._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, (event:ShadingMethodEvent) => this.onShaderInvalidated(event));\n\n\t\tthis._baseMethod = value;\n\n\t\tthis._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, (event:ShadingMethodEvent) => this.onShaderInvalidated(event));\n\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tvar tempVO:MethodVO = new MethodVO(this._baseMethod);\n\t\tthis._baseMethod.iInitVO(shaderObject, tempVO);\n\n\t\tmethodVO.needsGlobalVertexPos = true;\n\t\tmethodVO.needsProjection = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tvar fragmentData:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar vertexData:Array<number> = shaderObject.vertexConstantData;\n\t\tvar index:number = methodVO.fragmentConstantsIndex;\n\t\tfragmentData[index] = 1.0;\n\t\tfragmentData[index + 1] = 1/255.0;\n\t\tfragmentData[index + 2] = 1/65025.0;\n\t\tfragmentData[index + 3] = 1/16581375.0;\n\n\t\tfragmentData[index + 6] = .5;\n\t\tfragmentData[index + 7] = -.5;\n\n\t\tindex = methodVO.vertexConstantsIndex;\n\t\tvertexData[index] = .5;\n\t\tvertexData[index + 1] = -.5;\n\t\tvertexData[index + 2] = 0;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._cascadeProjections = null;\n\t\tthis._depthMapCoordVaryings = null;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeVertexConstant();\n\n\t\tthis.initProjectionsRegs(registerCache);\n\t\tmethodVO.vertexConstantsIndex = dataReg.index*4;\n\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeVertexVectorTemp();\n\n\t\tfor (var i:number = 0; i < this._cascadeShadowMapper.numCascades; ++i) {\n\t\t\tcode += \"m44 \" + temp + \", \" + sharedRegisters.globalPositionVertex + \", \" + this._cascadeProjections[i] + \"\\n\" +\n\t\t\t\t\"add \" + this._depthMapCoordVaryings[i] + \", \" + temp + \", \" + dataReg + \".zzwz\\n\";\n\t\t}\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * Creates the registers for the cascades' projection coordinates.\n\t */\n\tprivate initProjectionsRegs(registerCache:ShaderRegisterCache)\n\t{\n\t\tthis._cascadeProjections = new Array<ShaderRegisterElement>(this._cascadeShadowMapper.numCascades);\n\t\tthis._depthMapCoordVaryings = new Array<ShaderRegisterElement>(this._cascadeShadowMapper.numCascades);\n\n\t\tfor (var i:number = 0; i < this._cascadeShadowMapper.numCascades; ++i) {\n\t\t\tthis._depthMapCoordVaryings[i] = registerCache.getFreeVarying();\n\t\t\tthis._cascadeProjections[i] = registerCache.getFreeVertexConstant();\n\t\t\tregisterCache.getFreeVertexConstant();\n\t\t\tregisterCache.getFreeVertexConstant();\n\t\t\tregisterCache.getFreeVertexConstant();\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar numCascades:number = this._cascadeShadowMapper.numCascades;\n\t\tvar depthMapRegister:ShaderRegisterElement = registerCache.getFreeTextureReg();\n\t\tvar decReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar planeDistanceReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar planeDistances:Array<string> = Array<string>( planeDistanceReg + \".x\", planeDistanceReg + \".y\", planeDistanceReg + \".z\", planeDistanceReg + \".w\" );\n\t\tvar code:string;\n\n\t\tmethodVO.fragmentConstantsIndex = decReg.index*4;\n\t\tmethodVO.texturesIndex = depthMapRegister.index;\n\n\t\tvar inQuad:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tregisterCache.addFragmentTempUsages(inQuad, 1);\n\t\tvar uvCoord:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tregisterCache.addFragmentTempUsages(uvCoord, 1);\n\n\t\t// assume lowest partition is selected, will be overwritten later otherwise\n\t\tcode = \"mov \" + uvCoord + \", \" + this._depthMapCoordVaryings[numCascades - 1] + \"\\n\";\n\n\t\tfor (var i:number = numCascades - 2; i >= 0; --i) {\n\t\t\tvar uvProjection:ShaderRegisterElement = this._depthMapCoordVaryings[i];\n\n\t\t\t// calculate if in texturemap (result == 0 or 1, only 1 for a single partition)\n\t\t\tcode += \"slt \" + inQuad + \".z, \" + sharedRegisters.projectionFragment + \".z, \" + planeDistances[i] + \"\\n\"; // z = x > minX, w = y > minY\n\n\t\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\n\t\t\t// linearly interpolate between old and new uv coords using predicate value == conditional toggle to new value if predicate == 1 (true)\n\t\t\tcode += \"sub \" + temp + \", \" + uvProjection + \", \" + uvCoord + \"\\n\" +\n\t\t\t\t\"mul \" + temp + \", \" + temp + \", \" + inQuad + \".z\\n\" +\n\t\t\t\t\"add \" + uvCoord + \", \" + uvCoord + \", \" + temp + \"\\n\";\n\t\t}\n\n\t\tregisterCache.removeFragmentTempUsage(inQuad);\n\n\t\tcode += \"div \" + uvCoord + \", \" + uvCoord + \", \" + uvCoord + \".w\\n\" +\n\t\t\t\"mul \" + uvCoord + \".xy, \" + uvCoord + \".xy, \" + dataReg + \".zw\\n\" +\n\t\t\t\"add \" + uvCoord + \".xy, \" + uvCoord + \".xy, \" + dataReg + \".zz\\n\";\n\n\t\tcode += this._baseMethod._iGetCascadeFragmentCode(shaderObject, methodVO, decReg, depthMapRegister, uvCoord, targetReg, registerCache, sharedRegisters) +\n\t\t\t\"add \" + targetReg + \".w, \" + targetReg + \".w, \" + dataReg + \".y\\n\";\n\n\t\tregisterCache.removeFragmentTempUsage(uvCoord);\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex, <Texture2DBase> this._pCastingLight.shadowMapper.depthMap);\n\n\t\tvar vertexData:Array<number> = shaderObject.vertexConstantData;\n\t\tvar vertexIndex:number = methodVO.vertexConstantsIndex;\n\n\t\tshaderObject.vertexConstantData[methodVO.vertexConstantsIndex + 3] = -1/(this._cascadeShadowMapper.depth*this._pEpsilon);\n\n\t\tvar numCascades:number = this._cascadeShadowMapper.numCascades;\n\t\tvertexIndex += 4;\n\t\tfor (var k:number = 0; k < numCascades; ++k) {\n\t\t\tthis._cascadeShadowMapper.getDepthProjections(k).copyRawDataTo(vertexData, vertexIndex, true);\n\t\t\tvertexIndex += 16;\n\t\t}\n\n\t\tvar fragmentData:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar fragmentIndex:number = methodVO.fragmentConstantsIndex;\n\t\tfragmentData[fragmentIndex + 5] = 1 - this._pAlpha;\n\n\t\tvar nearPlaneDistances:Array<number> = this._cascadeShadowMapper._iNearPlaneDistances;\n\n\t\tfragmentIndex += 8;\n\t\tfor (var i:number = 0; i < numCascades; ++i)\n\t\t\tfragmentData[fragmentIndex + i] = nearPlaneDistances[i];\n\n\t\tthis._baseMethod.iActivateForCascade(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iSetRenderState(shaderObject:ShaderObjectBase, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera)\n\t{\n\t}\n\n\t/**\n\t * Called when the shadow mappers cascade configuration changes.\n\t */\n\tprivate onCascadeChange(event:Event)\n\t{\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * Called when the base method's shader code is invalidated.\n\t */\n\tprivate onShaderInvalidated(event:ShadingMethodEvent)\n\t{\n\t\tthis.iInvalidateShaderProgram();\n\t}\n}\n\nexport = ShadowCascadeMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/ShadowCascadeMethod.ts b/lib/materials/methods/ShadowCascadeMethod.ts new file mode 100644 index 000000000..3a20a6c22 --- /dev/null +++ b/lib/materials/methods/ShadowCascadeMethod.ts @@ -0,0 +1,272 @@ +import Camera = require("awayjs-core/lib/entities/Camera"); +import DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +import Event = require("awayjs-core/lib/events/Event"); +import CascadeShadowMapper = require("awayjs-core/lib/materials/shadowmappers/CascadeShadowMapper"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import ShadowMapMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMapMethodBase"); +import ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); +import ShaderCompilerHelper = require("awayjs-stagegl/lib/materials/utils/ShaderCompilerHelper"); + +/** + * ShadowCascadeMethod is a shadow map method to apply cascade shadow mapping on materials. + * Must be used with a DirectionalLight with a CascadeShadowMapper assigned to its shadowMapper property. + * + * @see away.lights.CascadeShadowMapper + */ +class ShadowCascadeMethod extends ShadowMapMethodBase +{ + private _baseMethod:ShadowMethodBase; + private _cascadeShadowMapper:CascadeShadowMapper; + private _depthMapCoordVaryings:Array; + private _cascadeProjections:Array; + + /** + * Creates a new ShadowCascadeMethod object. + * + * @param shadowMethodBase The shadow map sampling method used to sample individual cascades (fe: ShadowHardMethod, ShadowSoftMethod) + */ + constructor(shadowMethodBase:ShadowMethodBase) + { + super(shadowMethodBase.castingLight); + + this._baseMethod = shadowMethodBase; + if (!(this._pCastingLight instanceof DirectionalLight)) + throw new Error("ShadowCascadeMethod is only compatible with DirectionalLight"); + + this._cascadeShadowMapper = this._pCastingLight.shadowMapper; + + if (!this._cascadeShadowMapper) + throw new Error("ShadowCascadeMethod requires a light that has a CascadeShadowMapper instance assigned to shadowMapper."); + + this._cascadeShadowMapper.addEventListener(Event.CHANGE, (event:Event) => this.onCascadeChange(event)); + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, (event:ShadingMethodEvent) => this.onShaderInvalidated(event)); + } + + /** + * The shadow map sampling method used to sample individual cascades. These are typically those used in conjunction + * with a DirectionalShadowMapper. + * + * @see ShadowHardMethod + * @see ShadowSoftMethod + */ + public get baseMethod():ShadowMethodBase + { + return this._baseMethod; + } + + public set baseMethod(value:ShadowMethodBase) + { + if (this._baseMethod == value) + return; + + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, (event:ShadingMethodEvent) => this.onShaderInvalidated(event)); + + this._baseMethod = value; + + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, (event:ShadingMethodEvent) => this.onShaderInvalidated(event)); + + this.iInvalidateShaderProgram(); + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + var tempVO:MethodVO = new MethodVO(this._baseMethod); + this._baseMethod.iInitVO(shaderObject, tempVO); + + methodVO.needsGlobalVertexPos = true; + methodVO.needsProjection = true; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + var fragmentData:Array = shaderObject.fragmentConstantData; + var vertexData:Array = shaderObject.vertexConstantData; + var index:number = methodVO.fragmentConstantsIndex; + fragmentData[index] = 1.0; + fragmentData[index + 1] = 1/255.0; + fragmentData[index + 2] = 1/65025.0; + fragmentData[index + 3] = 1/16581375.0; + + fragmentData[index + 6] = .5; + fragmentData[index + 7] = -.5; + + index = methodVO.vertexConstantsIndex; + vertexData[index] = .5; + vertexData[index + 1] = -.5; + vertexData[index + 2] = 0; + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._cascadeProjections = null; + this._depthMapCoordVaryings = null; + } + + /** + * @inheritDoc + */ + public iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var dataReg:ShaderRegisterElement = registerCache.getFreeVertexConstant(); + + this.initProjectionsRegs(registerCache); + methodVO.vertexConstantsIndex = dataReg.index*4; + + var temp:ShaderRegisterElement = registerCache.getFreeVertexVectorTemp(); + + for (var i:number = 0; i < this._cascadeShadowMapper.numCascades; ++i) { + code += "m44 " + temp + ", " + sharedRegisters.globalPositionVertex + ", " + this._cascadeProjections[i] + "\n" + + "add " + this._depthMapCoordVaryings[i] + ", " + temp + ", " + dataReg + ".zzwz\n"; + } + + return code; + } + + /** + * Creates the registers for the cascades' projection coordinates. + */ + private initProjectionsRegs(registerCache:ShaderRegisterCache) + { + this._cascadeProjections = new Array(this._cascadeShadowMapper.numCascades); + this._depthMapCoordVaryings = new Array(this._cascadeShadowMapper.numCascades); + + for (var i:number = 0; i < this._cascadeShadowMapper.numCascades; ++i) { + this._depthMapCoordVaryings[i] = registerCache.getFreeVarying(); + this._cascadeProjections[i] = registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + registerCache.getFreeVertexConstant(); + } + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var numCascades:number = this._cascadeShadowMapper.numCascades; + var depthMapRegister:ShaderRegisterElement = registerCache.getFreeTextureReg(); + var decReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var planeDistanceReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var planeDistances:Array = Array( planeDistanceReg + ".x", planeDistanceReg + ".y", planeDistanceReg + ".z", planeDistanceReg + ".w" ); + var code:string; + + methodVO.fragmentConstantsIndex = decReg.index*4; + methodVO.texturesIndex = depthMapRegister.index; + + var inQuad:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(inQuad, 1); + var uvCoord:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(uvCoord, 1); + + // assume lowest partition is selected, will be overwritten later otherwise + code = "mov " + uvCoord + ", " + this._depthMapCoordVaryings[numCascades - 1] + "\n"; + + for (var i:number = numCascades - 2; i >= 0; --i) { + var uvProjection:ShaderRegisterElement = this._depthMapCoordVaryings[i]; + + // calculate if in texturemap (result == 0 or 1, only 1 for a single partition) + code += "slt " + inQuad + ".z, " + sharedRegisters.projectionFragment + ".z, " + planeDistances[i] + "\n"; // z = x > minX, w = y > minY + + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + + // linearly interpolate between old and new uv coords using predicate value == conditional toggle to new value if predicate == 1 (true) + code += "sub " + temp + ", " + uvProjection + ", " + uvCoord + "\n" + + "mul " + temp + ", " + temp + ", " + inQuad + ".z\n" + + "add " + uvCoord + ", " + uvCoord + ", " + temp + "\n"; + } + + registerCache.removeFragmentTempUsage(inQuad); + + code += "div " + uvCoord + ", " + uvCoord + ", " + uvCoord + ".w\n" + + "mul " + uvCoord + ".xy, " + uvCoord + ".xy, " + dataReg + ".zw\n" + + "add " + uvCoord + ".xy, " + uvCoord + ".xy, " + dataReg + ".zz\n"; + + code += this._baseMethod._iGetCascadeFragmentCode(shaderObject, methodVO, decReg, depthMapRegister, uvCoord, targetReg, registerCache, sharedRegisters) + + "add " + targetReg + ".w, " + targetReg + ".w, " + dataReg + ".y\n"; + + registerCache.removeFragmentTempUsage(uvCoord); + + return code; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + ( stage.context).activateTexture(methodVO.texturesIndex, this._pCastingLight.shadowMapper.depthMap); + + var vertexData:Array = shaderObject.vertexConstantData; + var vertexIndex:number = methodVO.vertexConstantsIndex; + + shaderObject.vertexConstantData[methodVO.vertexConstantsIndex + 3] = -1/(this._cascadeShadowMapper.depth*this._pEpsilon); + + var numCascades:number = this._cascadeShadowMapper.numCascades; + vertexIndex += 4; + for (var k:number = 0; k < numCascades; ++k) { + this._cascadeShadowMapper.getDepthProjections(k).copyRawDataTo(vertexData, vertexIndex, true); + vertexIndex += 16; + } + + var fragmentData:Array = shaderObject.fragmentConstantData; + var fragmentIndex:number = methodVO.fragmentConstantsIndex; + fragmentData[fragmentIndex + 5] = 1 - this._pAlpha; + + var nearPlaneDistances:Array = this._cascadeShadowMapper._iNearPlaneDistances; + + fragmentIndex += 8; + for (var i:number = 0; i < numCascades; ++i) + fragmentData[fragmentIndex + i] = nearPlaneDistances[i]; + + this._baseMethod.iActivateForCascade(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iSetRenderState(shaderObject:ShaderObjectBase, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera) + { + } + + /** + * Called when the shadow mappers cascade configuration changes. + */ + private onCascadeChange(event:Event) + { + this.iInvalidateShaderProgram(); + } + + /** + * Called when the base method's shader code is invalidated. + */ + private onShaderInvalidated(event:ShadingMethodEvent) + { + this.iInvalidateShaderProgram(); + } +} + +export = ShadowCascadeMethod; \ No newline at end of file diff --git a/lib/materials/methods/ShadowDitheredMethod.js b/lib/materials/methods/ShadowDitheredMethod.js new file mode 100755 index 000000000..8d54a6b02 --- /dev/null +++ b/lib/materials/methods/ShadowDitheredMethod.js @@ -0,0 +1,236 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var BitmapData = require("awayjs-core/lib/core/base/BitmapData"); +var BitmapTexture = require("awayjs-core/lib/textures/BitmapTexture"); +var ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); +/** + * ShadowDitheredMethod provides a soft shadowing technique by randomly distributing sample points differently for each fragment. + */ +var ShadowDitheredMethod = (function (_super) { + __extends(ShadowDitheredMethod, _super); + /** + * Creates a new ShadowDitheredMethod object. + * @param castingLight The light casting the shadows + * @param numSamples The amount of samples to take for dithering. Minimum 1, maximum 24. + */ + function ShadowDitheredMethod(castingLight, numSamples, range) { + if (numSamples === void 0) { numSamples = 4; } + if (range === void 0) { range = 1; } + _super.call(this, castingLight); + this._depthMapSize = this._pCastingLight.shadowMapper.depthMapSize; + this.numSamples = numSamples; + this.range = range; + ++ShadowDitheredMethod._grainUsages; + if (!ShadowDitheredMethod._grainTexture) + this.initGrainTexture(); + } + Object.defineProperty(ShadowDitheredMethod.prototype, "numSamples", { + /** + * The amount of samples to take for dithering. Minimum 1, maximum 24. The actual maximum may depend on the + * complexity of the shader. + */ + get: function () { + return this._numSamples; + }, + set: function (value /*int*/) { + this._numSamples = value; + if (this._numSamples < 1) + this._numSamples = 1; + else if (this._numSamples > 24) + this._numSamples = 24; + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ShadowDitheredMethod.prototype.iInitVO = function (shaderObject, methodVO) { + _super.prototype.iInitVO.call(this, shaderObject, methodVO); + methodVO.needsProjection = true; + }; + /** + * @inheritDoc + */ + ShadowDitheredMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + _super.prototype.iInitConstants.call(this, shaderObject, methodVO); + var fragmentData = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + fragmentData[index + 8] = 1 / this._numSamples; + }; + Object.defineProperty(ShadowDitheredMethod.prototype, "range", { + /** + * The range in the shadow map in which to distribute the samples. + */ + get: function () { + return this._range * 2; + }, + set: function (value) { + this._range = value / 2; + }, + enumerable: true, + configurable: true + }); + /** + * Creates a texture containing the dithering noise texture. + */ + ShadowDitheredMethod.prototype.initGrainTexture = function () { + ShadowDitheredMethod._grainBitmapData = new BitmapData(64, 64, false); + var vec = new Array(); + var len = 4096; + var step = 1 / (this._depthMapSize * this._range); + var r, g; + for (var i = 0; i < len; ++i) { + r = 2 * (Math.random() - .5); + g = 2 * (Math.random() - .5); + if (r < 0) + r -= step; + else + r += step; + if (g < 0) + g -= step; + else + g += step; + if (r > 1) + r = 1; + else if (r < -1) + r = -1; + if (g > 1) + g = 1; + else if (g < -1) + g = -1; + vec[i] = (Math.floor((r * .5 + .5) * 0xff) << 16) | (Math.floor((g * .5 + .5) * 0xff) << 8); + } + ShadowDitheredMethod._grainBitmapData.setVector(ShadowDitheredMethod._grainBitmapData.rect, vec); + ShadowDitheredMethod._grainTexture = new BitmapTexture(ShadowDitheredMethod._grainBitmapData); + }; + /** + * @inheritDoc + */ + ShadowDitheredMethod.prototype.dispose = function () { + if (--ShadowDitheredMethod._grainUsages == 0) { + ShadowDitheredMethod._grainTexture.dispose(); + ShadowDitheredMethod._grainBitmapData.dispose(); + ShadowDitheredMethod._grainTexture = null; + } + }; + /** + * @inheritDoc + */ + ShadowDitheredMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var data = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + data[index + 9] = (stage.width - 1) / 63; + data[index + 10] = (stage.height - 1) / 63; + data[index + 11] = 2 * this._range / this._depthMapSize; + stage.context.activateTexture(methodVO.texturesIndex + 1, ShadowDitheredMethod._grainTexture); + }; + /** + * @inheritDoc + */ + ShadowDitheredMethod.prototype._pGetPlanarFragmentCode = function (methodVO, targetReg, regCache, sharedRegisters) { + var depthMapRegister = regCache.getFreeTextureReg(); + var decReg = regCache.getFreeFragmentConstant(); + var dataReg = regCache.getFreeFragmentConstant(); + var customDataReg = regCache.getFreeFragmentConstant(); + methodVO.fragmentConstantsIndex = decReg.index * 4; + methodVO.texturesIndex = depthMapRegister.index; + return this.getSampleCode(customDataReg, depthMapRegister, decReg, targetReg, regCache, sharedRegisters); + }; + /** + * Get the actual shader code for shadow mapping + * @param regCache The register cache managing the registers. + * @param depthMapRegister The texture register containing the depth map. + * @param decReg The register containing the depth map decoding data. + * @param targetReg The target register to add the shadow coverage. + */ + ShadowDitheredMethod.prototype.getSampleCode = function (customDataReg, depthMapRegister, decReg, targetReg, regCache, sharedRegisters) { + var code = ""; + var grainRegister = regCache.getFreeTextureReg(); + var uvReg = regCache.getFreeFragmentVectorTemp(); + var numSamples = this._numSamples; + regCache.addFragmentTempUsages(uvReg, 1); + var temp = regCache.getFreeFragmentVectorTemp(); + var projectionReg = sharedRegisters.projectionFragment; + code += "div " + uvReg + ", " + projectionReg + ", " + projectionReg + ".w\n" + "mul " + uvReg + ".xy, " + uvReg + ".xy, " + customDataReg + ".yz\n"; + while (numSamples > 0) { + if (numSamples == this._numSamples) + code += "tex " + uvReg + ", " + uvReg + ", " + grainRegister + " <2d,nearest,repeat,mipnone>\n"; + else + code += "tex " + uvReg + ", " + uvReg + ".zwxy, " + grainRegister + " <2d,nearest,repeat,mipnone>\n"; + // keep grain in uvReg.zw + code += "sub " + uvReg + ".zw, " + uvReg + ".xy, fc0.xx\n" + "mul " + uvReg + ".zw, " + uvReg + ".zw, " + customDataReg + ".w\n"; // (tex unpack scale and tex scale in one) + if (numSamples == this._numSamples) { + // first sample + code += "add " + uvReg + ".xy, " + uvReg + ".zw, " + this._pDepthMapCoordReg + ".xy\n" + "tex " + temp + ", " + uvReg + ", " + depthMapRegister + " <2d,nearest,clamp,mipnone>\n" + "dp4 " + temp + ".z, " + temp + ", " + decReg + "\n" + "slt " + targetReg + ".w, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n"; // 0 if in shadow + } + else { + code += this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + } + if (numSamples > 4) + code += "add " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".zw\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + if (numSamples > 1) + code += "sub " + uvReg + ".xy, " + this._pDepthMapCoordReg + ".xy, " + uvReg + ".zw\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + if (numSamples > 5) + code += "sub " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".zw\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + if (numSamples > 2) { + code += "neg " + uvReg + ".w, " + uvReg + ".w\n"; // will be rotated 90 degrees when being accessed as wz + code += "add " + uvReg + ".xy, " + uvReg + ".wz, " + this._pDepthMapCoordReg + ".xy\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + } + if (numSamples > 6) + code += "add " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".wz\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + if (numSamples > 3) + code += "sub " + uvReg + ".xy, " + this._pDepthMapCoordReg + ".xy, " + uvReg + ".wz\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + if (numSamples > 7) + code += "sub " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".wz\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + numSamples -= 8; + } + regCache.removeFragmentTempUsage(uvReg); + code += "mul " + targetReg + ".w, " + targetReg + ".w, " + customDataReg + ".x\n"; // average + return code; + }; + /** + * Adds the code for another tap to the shader code. + * @param uvReg The uv register for the tap. + * @param depthMapRegister The texture register containing the depth map. + * @param decReg The register containing the depth map decoding data. + * @param targetReg The target register to add the tap comparison result. + * @param regCache The register cache managing the registers. + * @return + */ + ShadowDitheredMethod.prototype.addSample = function (uvReg, depthMapRegister, decReg, targetReg, regCache) { + var temp = regCache.getFreeFragmentVectorTemp(); + return "tex " + temp + ", " + uvReg + ", " + depthMapRegister + " <2d,nearest,clamp,mipnone>\n" + "dp4 " + temp + ".z, " + temp + ", " + decReg + "\n" + "slt " + temp + ".z, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n" + "add " + targetReg + ".w, " + targetReg + ".w, " + temp + ".z\n"; + }; + /** + * @inheritDoc + */ + ShadowDitheredMethod.prototype.iActivateForCascade = function (shaderObject, methodVO, stage) { + var data = shaderObject.fragmentConstantData; + var index = methodVO.secondaryFragmentConstantsIndex; + data[index] = 1 / this._numSamples; + data[index + 1] = (stage.width - 1) / 63; + data[index + 2] = (stage.height - 1) / 63; + data[index + 3] = 2 * this._range / this._depthMapSize; + stage.context.activateTexture(methodVO.texturesIndex + 1, ShadowDitheredMethod._grainTexture); + }; + /** + * @inheritDoc + */ + ShadowDitheredMethod.prototype._iGetCascadeFragmentCode = function (shaderObject, methodVO, decodeRegister, depthTexture, depthProjection, targetRegister, registerCache, sharedRegisters) { + this._pDepthMapCoordReg = depthProjection; + var dataReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index * 4; + return this.getSampleCode(dataReg, depthTexture, decodeRegister, targetRegister, registerCache, sharedRegisters); + }; + return ShadowDitheredMethod; +})(ShadowMethodBase); +module.exports = ShadowDitheredMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/shadowditheredmethod.ts"],"names":["ShadowDitheredMethod","ShadowDitheredMethod.constructor","ShadowDitheredMethod.numSamples","ShadowDitheredMethod.iInitVO","ShadowDitheredMethod.iInitConstants","ShadowDitheredMethod.range","ShadowDitheredMethod.initGrainTexture","ShadowDitheredMethod.dispose","ShadowDitheredMethod.iActivate","ShadowDitheredMethod._pGetPlanarFragmentCode","ShadowDitheredMethod.getSampleCode","ShadowDitheredMethod.addSample","ShadowDitheredMethod.iActivateForCascade","ShadowDitheredMethod._iGetCascadeFragmentCode"],"mappings":"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IA,CAACA,MAAMA,EAAEA,GAAGA,EAAEA,CAACA,CAACA;YAC3BA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;gBACTA,CAACA,IAAIA,IAAIA,CAACA;YAACA,IAAIA;gBACfA,CAACA,IAAIA,IAAIA,CAACA;YACXA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;gBACTA,CAACA,IAAIA,IAAIA,CAACA;YAACA,IAAIA;gBACfA,CAACA,IAAIA,IAAIA,CAACA;YACXA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;gBACTA,CAACA,GAAGA,CAACA,CAACA;YAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA;gBACvBA,CAACA,GAAGA,CAACA,CAACA,CAACA;YACRA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;gBACTA,CAACA,GAAGA,CAACA,CAACA;YAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA;gBACvBA,CAACA,GAAGA,CAACA,CAACA,CAACA;YACRA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA,CAACA,GAACA,EAAEA,GAAGA,EAAEA,CAACA,GAACA,IAAIA,CAACA,IAAIA,EAAEA,CAACA,GAAGA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA,CAACA,GAACA,EAAEA,GAAGA,EAAEA,CAACA,GAACA,IAAIA,CAACA,IAAIA,CAACA,CAACA,CAACA;QACrFA,CAACA;QAEDA,oBAAoBA,CAACA,gBAAgBA,CAACA,SAASA,CAACA,oBAAoBA,CAACA,gBAAgBA,CAACA,IAAIA,EAAEA,GAAGA,CAACA,CAACA;QACjGA,oBAAoBA,CAACA,aAAaA,GAAGA,IAAIA,aAAaA,CAACA,oBAAoBA,CAACA,gBAAgBA,CAACA,CAACA;IAC/FA,CAACA;IAEDN;;OAEGA;IACIA,sCAAOA,GAAdA;QAECO,EAAEA,CAACA,CAACA,EAAEA,oBA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","file":"materials/methods/ShadowDitheredMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import BitmapData\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/BitmapData\");\nimport DirectionalLight\t\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\nimport BitmapTexture\t\t\t\t\t= require(\"awayjs-core/lib/textures/BitmapTexture\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport ShadowMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowMethodBase\");\n\n/**\n * ShadowDitheredMethod provides a soft shadowing technique by randomly distributing sample points differently for each fragment.\n */\nclass ShadowDitheredMethod extends ShadowMethodBase\n{\n\tprivate static _grainTexture:BitmapTexture;\n\tprivate static _grainUsages:number /*int*/;\n\tprivate static _grainBitmapData:BitmapData;\n\tprivate _depthMapSize:number /*int*/;\n\tprivate _range:number;\n\tprivate _numSamples:number /*int*/;\n\n\t/**\n\t * Creates a new ShadowDitheredMethod object.\n\t * @param castingLight The light casting the shadows\n\t * @param numSamples The amount of samples to take for dithering. Minimum 1, maximum 24.\n\t */\n\tconstructor(castingLight:DirectionalLight, numSamples:number /*int*/ = 4, range:number = 1)\n\t{\n\t\tsuper(castingLight);\n\n\t\tthis._depthMapSize = this._pCastingLight.shadowMapper.depthMapSize;\n\n\t\tthis.numSamples = numSamples;\n\t\tthis.range = range;\n\n\t\t++ShadowDitheredMethod._grainUsages;\n\n\t\tif (!ShadowDitheredMethod._grainTexture)\n\t\t\tthis.initGrainTexture();\n\t}\n\n\t/**\n\t * The amount of samples to take for dithering. Minimum 1, maximum 24. The actual maximum may depend on the\n\t * complexity of the shader.\n\t */\n\tpublic get numSamples():number /*int*/\n\t{\n\t\treturn this._numSamples;\n\t}\n\n\tpublic set numSamples(value:number /*int*/)\n\t{\n\t\tthis._numSamples = value;\n\t\tif (this._numSamples < 1)\n\t\t\tthis._numSamples = 1; else if (this._numSamples > 24)\n\t\t\tthis._numSamples = 24;\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tsuper.iInitVO(shaderObject, methodVO);\n\n\t\tmethodVO.needsProjection = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tsuper.iInitConstants(shaderObject, methodVO);\n\n\t\tvar fragmentData:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tfragmentData[index + 8] = 1/this._numSamples;\n\t}\n\n\t/**\n\t * The range in the shadow map in which to distribute the samples.\n\t */\n\tpublic get range():number\n\t{\n\t\treturn this._range*2;\n\t}\n\n\tpublic set range(value:number)\n\t{\n\t\tthis._range = value/2;\n\t}\n\n\t/**\n\t * Creates a texture containing the dithering noise texture.\n\t */\n\tprivate initGrainTexture()\n\t{\n\t\tShadowDitheredMethod._grainBitmapData = new BitmapData(64, 64, false);\n\t\tvar vec:Array<number> /*uint*/ = new Array<number>();\n\t\tvar len:number /*uint*/ = 4096;\n\t\tvar step:number = 1/(this._depthMapSize*this._range);\n\t\tvar r:number, g:number;\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; ++i) {\n\t\t\tr = 2*(Math.random() - .5);\n\t\t\tg = 2*(Math.random() - .5);\n\t\t\tif (r < 0)\n\t\t\t\tr -= step; else\n\t\t\t\tr += step;\n\t\t\tif (g < 0)\n\t\t\t\tg -= step; else\n\t\t\t\tg += step;\n\t\t\tif (r > 1)\n\t\t\t\tr = 1; else if (r < -1)\n\t\t\t\tr = -1;\n\t\t\tif (g > 1)\n\t\t\t\tg = 1; else if (g < -1)\n\t\t\t\tg = -1;\n\t\t\tvec[i] = (Math.floor((r*.5 + .5)*0xff) << 16) | (Math.floor((g*.5 + .5)*0xff) << 8);\n\t\t}\n\n\t\tShadowDitheredMethod._grainBitmapData.setVector(ShadowDitheredMethod._grainBitmapData.rect, vec);\n\t\tShadowDitheredMethod._grainTexture = new BitmapTexture(ShadowDitheredMethod._grainBitmapData);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t\tif (--ShadowDitheredMethod._grainUsages == 0) {\n\t\t\tShadowDitheredMethod._grainTexture.dispose();\n\t\t\tShadowDitheredMethod._grainBitmapData.dispose();\n\t\t\tShadowDitheredMethod._grainTexture = null;\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*uint*/ = methodVO.fragmentConstantsIndex;\n\t\tdata[index + 9] = (stage.width - 1)/63;\n\t\tdata[index + 10] = (stage.height - 1)/63;\n\t\tdata[index + 11] = 2*this._range/this._depthMapSize;\n\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex + 1, ShadowDitheredMethod._grainTexture);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pGetPlanarFragmentCode(methodVO:MethodVO, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar depthMapRegister:ShaderRegisterElement = regCache.getFreeTextureReg();\n\t\tvar decReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\tvar dataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\tvar customDataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\n\t\tmethodVO.fragmentConstantsIndex = decReg.index*4;\n\t\tmethodVO.texturesIndex = depthMapRegister.index;\n\n\t\treturn this.getSampleCode(customDataReg, depthMapRegister, decReg, targetReg, regCache, sharedRegisters);\n\t}\n\n\t/**\n\t * Get the actual shader code for shadow mapping\n\t * @param regCache The register cache managing the registers.\n\t * @param depthMapRegister The texture register containing the depth map.\n\t * @param decReg The register containing the depth map decoding data.\n\t * @param targetReg The target register to add the shadow coverage.\n\t */\n\tprivate getSampleCode(customDataReg:ShaderRegisterElement, depthMapRegister:ShaderRegisterElement, decReg:ShaderRegisterElement, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar grainRegister:ShaderRegisterElement = regCache.getFreeTextureReg();\n\t\tvar uvReg:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp();\n\t\tvar numSamples:number /*int*/ = this._numSamples;\n\t\tregCache.addFragmentTempUsages(uvReg, 1);\n\n\t\tvar temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp();\n\n\t\tvar projectionReg:ShaderRegisterElement = sharedRegisters.projectionFragment;\n\n\t\tcode += \"div \" + uvReg + \", \" + projectionReg + \", \" + projectionReg + \".w\\n\" + \"mul \" + uvReg + \".xy, \" + uvReg + \".xy, \" + customDataReg + \".yz\\n\";\n\n\t\twhile (numSamples > 0) {\n\t\t\tif (numSamples == this._numSamples)\n\t\t\t\tcode += \"tex \" + uvReg + \", \" + uvReg + \", \" + grainRegister + \" <2d,nearest,repeat,mipnone>\\n\";\n\t\t\telse\n\t\t\t\tcode += \"tex \" + uvReg + \", \" + uvReg + \".zwxy, \" + grainRegister + \" <2d,nearest,repeat,mipnone>\\n\";\n\n\t\t\t// keep grain in uvReg.zw\n\t\t\tcode += \"sub \" + uvReg + \".zw, \" + uvReg + \".xy, fc0.xx\\n\" + // uv-.5\n\t\t\t\t\"mul \" + uvReg + \".zw, \" + uvReg + \".zw, \" + customDataReg + \".w\\n\"; // (tex unpack scale and tex scale in one)\n\n\t\t\tif (numSamples == this._numSamples) {\n\t\t\t\t// first sample\n\t\t\t\tcode += \"add \" + uvReg + \".xy, \" + uvReg + \".zw, \" + this._pDepthMapCoordReg + \".xy\\n\" +\n\t\t\t\t\t\"tex \" + temp + \", \" + uvReg + \", \" + depthMapRegister + \" <2d,nearest,clamp,mipnone>\\n\" +\n\t\t\t\t\t\"dp4 \" + temp + \".z, \" + temp + \", \" + decReg + \"\\n\" +\n\t\t\t\t\t\"slt \" + targetReg + \".w, \" + this._pDepthMapCoordReg + \".z, \" + temp + \".z\\n\"; // 0 if in shadow\n\t\t\t} else {\n\t\t\t\tcode += this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\t\t\t}\n\n\t\t\tif (numSamples > 4)\n\t\t\t\tcode += \"add \" + uvReg + \".xy, \" + uvReg + \".xy, \" + uvReg + \".zw\\n\" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\n\t\t\tif (numSamples > 1)\n\t\t\t\tcode += \"sub \" + uvReg + \".xy, \" + this._pDepthMapCoordReg + \".xy, \" + uvReg + \".zw\\n\" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\n\t\t\tif (numSamples > 5)\n\t\t\t\tcode += \"sub \" + uvReg + \".xy, \" + uvReg + \".xy, \" + uvReg + \".zw\\n\" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\n\t\t\tif (numSamples > 2) {\n\t\t\t\tcode += \"neg \" + uvReg + \".w, \" + uvReg + \".w\\n\"; // will be rotated 90 degrees when being accessed as wz\n\t\t\t\tcode += \"add \" + uvReg + \".xy, \" + uvReg + \".wz, \" + this._pDepthMapCoordReg + \".xy\\n\" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\t\t\t}\n\n\t\t\tif (numSamples > 6)\n\t\t\t\tcode += \"add \" + uvReg + \".xy, \" + uvReg + \".xy, \" + uvReg + \".wz\\n\" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\n\t\t\tif (numSamples > 3)\n\t\t\t\tcode += \"sub \" + uvReg + \".xy, \" + this._pDepthMapCoordReg + \".xy, \" + uvReg + \".wz\\n\" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\n\t\t\tif (numSamples > 7)\n\t\t\t\tcode += \"sub \" + uvReg + \".xy, \" + uvReg + \".xy, \" + uvReg + \".wz\\n\" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache);\n\n\t\t\tnumSamples -= 8;\n\t\t}\n\n\t\tregCache.removeFragmentTempUsage(uvReg);\n\t\tcode += \"mul \" + targetReg + \".w, \" + targetReg + \".w, \" + customDataReg + \".x\\n\"; // average\n\t\treturn code;\n\t}\n\n\t/**\n\t * Adds the code for another tap to the shader code.\n\t * @param uvReg The uv register for the tap.\n\t * @param depthMapRegister The texture register containing the depth map.\n\t * @param decReg The register containing the depth map decoding data.\n\t * @param targetReg The target register to add the tap comparison result.\n\t * @param regCache The register cache managing the registers.\n\t * @return\n\t */\n\tprivate addSample(uvReg:ShaderRegisterElement, depthMapRegister:ShaderRegisterElement, decReg:ShaderRegisterElement, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache):string\n\t{\n\t\tvar temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp();\n\n\t\treturn \"tex \" + temp + \", \" + uvReg + \", \" + depthMapRegister + \" <2d,nearest,clamp,mipnone>\\n\" +\n\t\t\t\"dp4 \" + temp + \".z, \" + temp + \", \" + decReg + \"\\n\" +\n\t\t\t\"slt \" + temp + \".z, \" + this._pDepthMapCoordReg + \".z, \" + temp + \".z\\n\" + // 0 if in shadow\n\t\t\t\"add \" + targetReg + \".w, \" + targetReg + \".w, \" + temp + \".z\\n\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivateForCascade(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*uint*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tdata[index] = 1/this._numSamples;\n\t\tdata[index + 1] = (stage.width - 1)/63;\n\t\tdata[index + 2] = (stage.height - 1)/63;\n\t\tdata[index + 3] = 2*this._range/this._depthMapSize;\n\n\t\t(<IContextStageGL> stage.context).activateTexture(methodVO.texturesIndex + 1, ShadowDitheredMethod._grainTexture);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGetCascadeFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, decodeRegister:ShaderRegisterElement, depthTexture:ShaderRegisterElement, depthProjection:ShaderRegisterElement, targetRegister:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tthis._pDepthMapCoordReg = depthProjection;\n\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.secondaryFragmentConstantsIndex = dataReg.index*4;\n\n\t\treturn this.getSampleCode(dataReg, depthTexture, decodeRegister, targetRegister, registerCache, sharedRegisters);\n\t}\n}\n\nexport = ShadowDitheredMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/ShadowDitheredMethod.ts b/lib/materials/methods/ShadowDitheredMethod.ts new file mode 100644 index 000000000..cbbfea3a4 --- /dev/null +++ b/lib/materials/methods/ShadowDitheredMethod.ts @@ -0,0 +1,297 @@ +import BitmapData = require("awayjs-core/lib/core/base/BitmapData"); +import DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +import BitmapTexture = require("awayjs-core/lib/textures/BitmapTexture"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); + +/** + * ShadowDitheredMethod provides a soft shadowing technique by randomly distributing sample points differently for each fragment. + */ +class ShadowDitheredMethod extends ShadowMethodBase +{ + private static _grainTexture:BitmapTexture; + private static _grainUsages:number /*int*/; + private static _grainBitmapData:BitmapData; + private _depthMapSize:number /*int*/; + private _range:number; + private _numSamples:number /*int*/; + + /** + * Creates a new ShadowDitheredMethod object. + * @param castingLight The light casting the shadows + * @param numSamples The amount of samples to take for dithering. Minimum 1, maximum 24. + */ + constructor(castingLight:DirectionalLight, numSamples:number /*int*/ = 4, range:number = 1) + { + super(castingLight); + + this._depthMapSize = this._pCastingLight.shadowMapper.depthMapSize; + + this.numSamples = numSamples; + this.range = range; + + ++ShadowDitheredMethod._grainUsages; + + if (!ShadowDitheredMethod._grainTexture) + this.initGrainTexture(); + } + + /** + * The amount of samples to take for dithering. Minimum 1, maximum 24. The actual maximum may depend on the + * complexity of the shader. + */ + public get numSamples():number /*int*/ + { + return this._numSamples; + } + + public set numSamples(value:number /*int*/) + { + this._numSamples = value; + if (this._numSamples < 1) + this._numSamples = 1; else if (this._numSamples > 24) + this._numSamples = 24; + this.iInvalidateShaderProgram(); + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + super.iInitVO(shaderObject, methodVO); + + methodVO.needsProjection = true; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + super.iInitConstants(shaderObject, methodVO); + + var fragmentData:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + fragmentData[index + 8] = 1/this._numSamples; + } + + /** + * The range in the shadow map in which to distribute the samples. + */ + public get range():number + { + return this._range*2; + } + + public set range(value:number) + { + this._range = value/2; + } + + /** + * Creates a texture containing the dithering noise texture. + */ + private initGrainTexture() + { + ShadowDitheredMethod._grainBitmapData = new BitmapData(64, 64, false); + var vec:Array /*uint*/ = new Array(); + var len:number /*uint*/ = 4096; + var step:number = 1/(this._depthMapSize*this._range); + var r:number, g:number; + + for (var i:number /*uint*/ = 0; i < len; ++i) { + r = 2*(Math.random() - .5); + g = 2*(Math.random() - .5); + if (r < 0) + r -= step; else + r += step; + if (g < 0) + g -= step; else + g += step; + if (r > 1) + r = 1; else if (r < -1) + r = -1; + if (g > 1) + g = 1; else if (g < -1) + g = -1; + vec[i] = (Math.floor((r*.5 + .5)*0xff) << 16) | (Math.floor((g*.5 + .5)*0xff) << 8); + } + + ShadowDitheredMethod._grainBitmapData.setVector(ShadowDitheredMethod._grainBitmapData.rect, vec); + ShadowDitheredMethod._grainTexture = new BitmapTexture(ShadowDitheredMethod._grainBitmapData); + } + + /** + * @inheritDoc + */ + public dispose() + { + if (--ShadowDitheredMethod._grainUsages == 0) { + ShadowDitheredMethod._grainTexture.dispose(); + ShadowDitheredMethod._grainBitmapData.dispose(); + ShadowDitheredMethod._grainTexture = null; + } + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var data:Array = shaderObject.fragmentConstantData; + var index:number /*uint*/ = methodVO.fragmentConstantsIndex; + data[index + 9] = (stage.width - 1)/63; + data[index + 10] = (stage.height - 1)/63; + data[index + 11] = 2*this._range/this._depthMapSize; + + ( stage.context).activateTexture(methodVO.texturesIndex + 1, ShadowDitheredMethod._grainTexture); + } + + /** + * @inheritDoc + */ + public _pGetPlanarFragmentCode(methodVO:MethodVO, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var depthMapRegister:ShaderRegisterElement = regCache.getFreeTextureReg(); + var decReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + var dataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + var customDataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + + methodVO.fragmentConstantsIndex = decReg.index*4; + methodVO.texturesIndex = depthMapRegister.index; + + return this.getSampleCode(customDataReg, depthMapRegister, decReg, targetReg, regCache, sharedRegisters); + } + + /** + * Get the actual shader code for shadow mapping + * @param regCache The register cache managing the registers. + * @param depthMapRegister The texture register containing the depth map. + * @param decReg The register containing the depth map decoding data. + * @param targetReg The target register to add the shadow coverage. + */ + private getSampleCode(customDataReg:ShaderRegisterElement, depthMapRegister:ShaderRegisterElement, decReg:ShaderRegisterElement, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var grainRegister:ShaderRegisterElement = regCache.getFreeTextureReg(); + var uvReg:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp(); + var numSamples:number /*int*/ = this._numSamples; + regCache.addFragmentTempUsages(uvReg, 1); + + var temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp(); + + var projectionReg:ShaderRegisterElement = sharedRegisters.projectionFragment; + + code += "div " + uvReg + ", " + projectionReg + ", " + projectionReg + ".w\n" + "mul " + uvReg + ".xy, " + uvReg + ".xy, " + customDataReg + ".yz\n"; + + while (numSamples > 0) { + if (numSamples == this._numSamples) + code += "tex " + uvReg + ", " + uvReg + ", " + grainRegister + " <2d,nearest,repeat,mipnone>\n"; + else + code += "tex " + uvReg + ", " + uvReg + ".zwxy, " + grainRegister + " <2d,nearest,repeat,mipnone>\n"; + + // keep grain in uvReg.zw + code += "sub " + uvReg + ".zw, " + uvReg + ".xy, fc0.xx\n" + // uv-.5 + "mul " + uvReg + ".zw, " + uvReg + ".zw, " + customDataReg + ".w\n"; // (tex unpack scale and tex scale in one) + + if (numSamples == this._numSamples) { + // first sample + code += "add " + uvReg + ".xy, " + uvReg + ".zw, " + this._pDepthMapCoordReg + ".xy\n" + + "tex " + temp + ", " + uvReg + ", " + depthMapRegister + " <2d,nearest,clamp,mipnone>\n" + + "dp4 " + temp + ".z, " + temp + ", " + decReg + "\n" + + "slt " + targetReg + ".w, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n"; // 0 if in shadow + } else { + code += this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + } + + if (numSamples > 4) + code += "add " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".zw\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + + if (numSamples > 1) + code += "sub " + uvReg + ".xy, " + this._pDepthMapCoordReg + ".xy, " + uvReg + ".zw\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + + if (numSamples > 5) + code += "sub " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".zw\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + + if (numSamples > 2) { + code += "neg " + uvReg + ".w, " + uvReg + ".w\n"; // will be rotated 90 degrees when being accessed as wz + code += "add " + uvReg + ".xy, " + uvReg + ".wz, " + this._pDepthMapCoordReg + ".xy\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + } + + if (numSamples > 6) + code += "add " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".wz\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + + if (numSamples > 3) + code += "sub " + uvReg + ".xy, " + this._pDepthMapCoordReg + ".xy, " + uvReg + ".wz\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + + if (numSamples > 7) + code += "sub " + uvReg + ".xy, " + uvReg + ".xy, " + uvReg + ".wz\n" + this.addSample(uvReg, depthMapRegister, decReg, targetReg, regCache); + + numSamples -= 8; + } + + regCache.removeFragmentTempUsage(uvReg); + code += "mul " + targetReg + ".w, " + targetReg + ".w, " + customDataReg + ".x\n"; // average + return code; + } + + /** + * Adds the code for another tap to the shader code. + * @param uvReg The uv register for the tap. + * @param depthMapRegister The texture register containing the depth map. + * @param decReg The register containing the depth map decoding data. + * @param targetReg The target register to add the tap comparison result. + * @param regCache The register cache managing the registers. + * @return + */ + private addSample(uvReg:ShaderRegisterElement, depthMapRegister:ShaderRegisterElement, decReg:ShaderRegisterElement, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache):string + { + var temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp(); + + return "tex " + temp + ", " + uvReg + ", " + depthMapRegister + " <2d,nearest,clamp,mipnone>\n" + + "dp4 " + temp + ".z, " + temp + ", " + decReg + "\n" + + "slt " + temp + ".z, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n" + // 0 if in shadow + "add " + targetReg + ".w, " + targetReg + ".w, " + temp + ".z\n"; + } + + /** + * @inheritDoc + */ + public iActivateForCascade(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + var data:Array = shaderObject.fragmentConstantData; + var index:number /*uint*/ = methodVO.secondaryFragmentConstantsIndex; + data[index] = 1/this._numSamples; + data[index + 1] = (stage.width - 1)/63; + data[index + 2] = (stage.height - 1)/63; + data[index + 3] = 2*this._range/this._depthMapSize; + + ( stage.context).activateTexture(methodVO.texturesIndex + 1, ShadowDitheredMethod._grainTexture); + } + + /** + * @inheritDoc + */ + public _iGetCascadeFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, decodeRegister:ShaderRegisterElement, depthTexture:ShaderRegisterElement, depthProjection:ShaderRegisterElement, targetRegister:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + this._pDepthMapCoordReg = depthProjection; + + var dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index*4; + + return this.getSampleCode(dataReg, depthTexture, decodeRegister, targetRegister, registerCache, sharedRegisters); + } +} + +export = ShadowDitheredMethod; \ No newline at end of file diff --git a/lib/materials/methods/ShadowFilteredMethod.js b/lib/materials/methods/ShadowFilteredMethod.js new file mode 100755 index 000000000..f10694e60 --- /dev/null +++ b/lib/materials/methods/ShadowFilteredMethod.js @@ -0,0 +1,87 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); +/** + * ShadowFilteredMethod provides a softened shadowing technique by bilinearly interpolating shadow comparison + * results of neighbouring pixels. + */ +var ShadowFilteredMethod = (function (_super) { + __extends(ShadowFilteredMethod, _super); + /** + * Creates a new DiffuseBasicMethod object. + * + * @param castingLight The light casting the shadow + */ + function ShadowFilteredMethod(castingLight) { + _super.call(this, castingLight); + } + /** + * @inheritDoc + */ + ShadowFilteredMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + _super.prototype.iInitConstants.call(this, shaderObject, methodVO); + var fragmentData = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex; + fragmentData[index + 8] = .5; + var size = this.castingLight.shadowMapper.depthMapSize; + fragmentData[index + 9] = size; + fragmentData[index + 10] = 1 / size; + }; + /** + * @inheritDoc + */ + ShadowFilteredMethod.prototype._pGetPlanarFragmentCode = function (methodVO, targetReg, regCache, sharedRegisters) { + var depthMapRegister = regCache.getFreeTextureReg(); + var decReg = regCache.getFreeFragmentConstant(); + var dataReg = regCache.getFreeFragmentConstant(); + // TODO: not used + dataReg = dataReg; + var customDataReg = regCache.getFreeFragmentConstant(); + var depthCol = regCache.getFreeFragmentVectorTemp(); + var uvReg; + var code = ""; + methodVO.fragmentConstantsIndex = decReg.index * 4; + regCache.addFragmentTempUsages(depthCol, 1); + uvReg = regCache.getFreeFragmentVectorTemp(); + regCache.addFragmentTempUsages(uvReg, 1); + code += "mov " + uvReg + ", " + this._pDepthMapCoordReg + "\n" + "tex " + depthCol + ", " + this._pDepthMapCoordReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".z, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + "add " + uvReg + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".z\n" + "tex " + depthCol + ", " + uvReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".w, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + "mul " + depthCol + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".y\n" + "frc " + depthCol + ".x, " + depthCol + ".x\n" + "sub " + uvReg + ".w, " + uvReg + ".w, " + uvReg + ".z\n" + "mul " + uvReg + ".w, " + uvReg + ".w, " + depthCol + ".x\n" + "add " + targetReg + ".w, " + uvReg + ".z, " + uvReg + ".w\n" + "mov " + uvReg + ".x, " + this._pDepthMapCoordReg + ".x\n" + "add " + uvReg + ".y, " + this._pDepthMapCoordReg + ".y, " + customDataReg + ".z\n" + "tex " + depthCol + ", " + uvReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".z, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + "add " + uvReg + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".z\n" + "tex " + depthCol + ", " + uvReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".w, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + "mul " + depthCol + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".y\n" + "frc " + depthCol + ".x, " + depthCol + ".x\n" + "sub " + uvReg + ".w, " + uvReg + ".w, " + uvReg + ".z\n" + "mul " + uvReg + ".w, " + uvReg + ".w, " + depthCol + ".x\n" + "add " + uvReg + ".w, " + uvReg + ".z, " + uvReg + ".w\n" + "mul " + depthCol + ".x, " + this._pDepthMapCoordReg + ".y, " + customDataReg + ".y\n" + "frc " + depthCol + ".x, " + depthCol + ".x\n" + "sub " + uvReg + ".w, " + uvReg + ".w, " + targetReg + ".w\n" + "mul " + uvReg + ".w, " + uvReg + ".w, " + depthCol + ".x\n" + "add " + targetReg + ".w, " + targetReg + ".w, " + uvReg + ".w\n"; + regCache.removeFragmentTempUsage(depthCol); + regCache.removeFragmentTempUsage(uvReg); + methodVO.texturesIndex = depthMapRegister.index; + return code; + }; + /** + * @inheritDoc + */ + ShadowFilteredMethod.prototype.iActivateForCascade = function (shaderObject, methodVO, stage) { + var size = this.castingLight.shadowMapper.depthMapSize; + var index = methodVO.secondaryFragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = size; + data[index + 1] = 1 / size; + }; + /** + * @inheritDoc + */ + ShadowFilteredMethod.prototype._iGetCascadeFragmentCode = function (shaderObject, methodVO, decodeRegister, depthTexture, depthProjection, targetRegister, registerCache, sharedRegisters) { + var code; + var dataReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index * 4; + var temp = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(temp, 1); + var predicate = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(predicate, 1); + code = "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".x, " + depthProjection + ".z, " + temp + ".z\n" + "add " + depthProjection + ".x, " + depthProjection + ".x, " + dataReg + ".y\n" + "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".z, " + depthProjection + ".z, " + temp + ".z\n" + "add " + depthProjection + ".y, " + depthProjection + ".y, " + dataReg + ".y\n" + "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".w, " + depthProjection + ".z, " + temp + ".z\n" + "sub " + depthProjection + ".x, " + depthProjection + ".x, " + dataReg + ".y\n" + "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".y, " + depthProjection + ".z, " + temp + ".z\n" + "mul " + temp + ".xy, " + depthProjection + ".xy, " + dataReg + ".x\n" + "frc " + temp + ".xy, " + temp + ".xy\n" + "sub " + depthProjection + ", " + predicate + ".xyzw, " + predicate + ".zwxy\n" + "mul " + depthProjection + ", " + depthProjection + ", " + temp + ".x\n" + "add " + predicate + ".xy, " + predicate + ".xy, " + depthProjection + ".zw\n" + "sub " + predicate + ".y, " + predicate + ".y, " + predicate + ".x\n" + "mul " + predicate + ".y, " + predicate + ".y, " + temp + ".y\n" + "add " + targetRegister + ".w, " + predicate + ".x, " + predicate + ".y\n"; + registerCache.removeFragmentTempUsage(temp); + registerCache.removeFragmentTempUsage(predicate); + return code; + }; + return ShadowFilteredMethod; +})(ShadowMethodBase); +module.exports = ShadowFilteredMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/shadowfilteredmethod.ts"],"names":["ShadowFilteredMethod","ShadowFilteredMethod.constructor","ShadowFilteredMethod.iInitConstants","ShadowFilteredMethod._pGetPlanarFragmentCode","ShadowFilteredMethod.iActivateForCascade","ShadowFilteredMethod._iGetCascadeFragmentCode"],"mappings":"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","file":"materials/methods/ShadowFilteredMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DirectionalLight\t\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport ShadowMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowMethodBase\");\n\n/**\n * ShadowFilteredMethod provides a softened shadowing technique by bilinearly interpolating shadow comparison\n * results of neighbouring pixels.\n */\nclass ShadowFilteredMethod extends ShadowMethodBase\n{\n\t/**\n\t * Creates a new DiffuseBasicMethod object.\n\t *\n\t * @param castingLight The light casting the shadow\n\t */\n\tconstructor(castingLight:DirectionalLight)\n\t{\n\t\tsuper(castingLight);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tsuper.iInitConstants(shaderObject, methodVO);\n\n\t\tvar fragmentData:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.fragmentConstantsIndex;\n\t\tfragmentData[index + 8] = .5;\n\t\tvar size:number /*int*/ = this.castingLight.shadowMapper.depthMapSize;\n\t\tfragmentData[index + 9] = size;\n\t\tfragmentData[index + 10] = 1/size;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pGetPlanarFragmentCode(methodVO:MethodVO, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar depthMapRegister:ShaderRegisterElement = regCache.getFreeTextureReg();\n\t\tvar decReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\tvar dataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\t// TODO: not used\n\t\tdataReg = dataReg;\n\t\tvar customDataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\tvar depthCol:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp();\n\t\tvar uvReg:ShaderRegisterElement;\n\t\tvar code:string = \"\";\n\t\tmethodVO.fragmentConstantsIndex = decReg.index*4;\n\n\t\tregCache.addFragmentTempUsages(depthCol, 1);\n\n\t\tuvReg = regCache.getFreeFragmentVectorTemp();\n\t\tregCache.addFragmentTempUsages(uvReg, 1);\n\n\t\tcode += \"mov \" + uvReg + \", \" + this._pDepthMapCoordReg + \"\\n\" +\n\n\t\t\t\"tex \" + depthCol + \", \" + this._pDepthMapCoordReg + \", \" + depthMapRegister + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + depthCol + \".z, \" + depthCol + \", \" + decReg + \"\\n\" + \"slt \" + uvReg + \".z, \" + this._pDepthMapCoordReg + \".z, \" + depthCol + \".z\\n\" +   // 0 if in shadow\n\n\t\t\t\"add \" + uvReg + \".x, \" + this._pDepthMapCoordReg + \".x, \" + customDataReg + \".z\\n\" + \t// (1, 0)\n\t\t\t\"tex \" + depthCol + \", \" + uvReg + \", \" + depthMapRegister + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + depthCol + \".z, \" + depthCol + \", \" + decReg + \"\\n\" + \"slt \" + uvReg + \".w, \" + this._pDepthMapCoordReg + \".z, \" + depthCol + \".z\\n\" +   // 0 if in shadow\n\n\t\t\t\"mul \" + depthCol + \".x, \" + this._pDepthMapCoordReg + \".x, \" + customDataReg + \".y\\n\" + \"frc \" + depthCol + \".x, \" + depthCol + \".x\\n\" + \"sub \" + uvReg + \".w, \" + uvReg + \".w, \" + uvReg + \".z\\n\" + \"mul \" + uvReg + \".w, \" + uvReg + \".w, \" + depthCol + \".x\\n\" + \"add \" + targetReg + \".w, \" + uvReg + \".z, \" + uvReg + \".w\\n\" +\n\n\t\t\t\"mov \" + uvReg + \".x, \" + this._pDepthMapCoordReg + \".x\\n\" + \"add \" + uvReg + \".y, \" + this._pDepthMapCoordReg + \".y, \" + customDataReg + \".z\\n\" +\t// (0, 1)\n\t\t\t\"tex \" + depthCol + \", \" + uvReg + \", \" + depthMapRegister + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + depthCol + \".z, \" + depthCol + \", \" + decReg + \"\\n\" + \"slt \" + uvReg + \".z, \" + this._pDepthMapCoordReg + \".z, \" + depthCol + \".z\\n\" +   // 0 if in shadow\n\n\t\t\t\"add \" + uvReg + \".x, \" + this._pDepthMapCoordReg + \".x, \" + customDataReg + \".z\\n\" +\t// (1, 1)\n\t\t\t\"tex \" + depthCol + \", \" + uvReg + \", \" + depthMapRegister + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + depthCol + \".z, \" + depthCol + \", \" + decReg + \"\\n\" + \"slt \" + uvReg + \".w, \" + this._pDepthMapCoordReg + \".z, \" + depthCol + \".z\\n\" +   // 0 if in shadow\n\n\t\t\t// recalculate fraction, since we ran out of registers :(\n\t\t\t\"mul \" + depthCol + \".x, \" + this._pDepthMapCoordReg + \".x, \" + customDataReg + \".y\\n\" + \"frc \" + depthCol + \".x, \" + depthCol + \".x\\n\" + \"sub \" + uvReg + \".w, \" + uvReg + \".w, \" + uvReg + \".z\\n\" + \"mul \" + uvReg + \".w, \" + uvReg + \".w, \" + depthCol + \".x\\n\" + \"add \" + uvReg + \".w, \" + uvReg + \".z, \" + uvReg + \".w\\n\" +\n\n\t\t\t\"mul \" + depthCol + \".x, \" + this._pDepthMapCoordReg + \".y, \" + customDataReg + \".y\\n\" + \"frc \" + depthCol + \".x, \" + depthCol + \".x\\n\" + \"sub \" + uvReg + \".w, \" + uvReg + \".w, \" + targetReg + \".w\\n\" + \"mul \" + uvReg + \".w, \" + uvReg + \".w, \" + depthCol + \".x\\n\" + \"add \" + targetReg + \".w, \" + targetReg + \".w, \" + uvReg + \".w\\n\";\n\n\t\tregCache.removeFragmentTempUsage(depthCol);\n\t\tregCache.removeFragmentTempUsage(uvReg);\n\n\t\tmethodVO.texturesIndex = depthMapRegister.index;\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivateForCascade(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tvar size:number /*int*/ = this.castingLight.shadowMapper.depthMapSize;\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index] = size;\n\t\tdata[index + 1] = 1/size;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGetCascadeFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, decodeRegister:ShaderRegisterElement, depthTexture:ShaderRegisterElement, depthProjection:ShaderRegisterElement, targetRegister:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string;\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.secondaryFragmentConstantsIndex = dataReg.index*4;\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tregisterCache.addFragmentTempUsages(temp, 1);\n\t\tvar predicate:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp();\n\t\tregisterCache.addFragmentTempUsages(predicate, 1);\n\n\t\tcode = \"tex \" + temp + \", \" + depthProjection + \", \" + depthTexture + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + temp + \".z, \" + temp + \", \" + decodeRegister + \"\\n\" + \"slt \" + predicate + \".x, \" + depthProjection + \".z, \" + temp + \".z\\n\" +\n\n\t\t\t\"add \" + depthProjection + \".x, \" + depthProjection + \".x, \" + dataReg + \".y\\n\" + \"tex \" + temp + \", \" + depthProjection + \", \" + depthTexture + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + temp + \".z, \" + temp + \", \" + decodeRegister + \"\\n\" + \"slt \" + predicate + \".z, \" + depthProjection + \".z, \" + temp + \".z\\n\" +\n\n\t\t\t\"add \" + depthProjection + \".y, \" + depthProjection + \".y, \" + dataReg + \".y\\n\" + \"tex \" + temp + \", \" + depthProjection + \", \" + depthTexture + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + temp + \".z, \" + temp + \", \" + decodeRegister + \"\\n\" + \"slt \" + predicate + \".w, \" + depthProjection + \".z, \" + temp + \".z\\n\" +\n\n\t\t\t\"sub \" + depthProjection + \".x, \" + depthProjection + \".x, \" + dataReg + \".y\\n\" + \"tex \" + temp + \", \" + depthProjection + \", \" + depthTexture + \" <2d, nearest, clamp>\\n\" + \"dp4 \" + temp + \".z, \" + temp + \", \" + decodeRegister + \"\\n\" + \"slt \" + predicate + \".y, \" + depthProjection + \".z, \" + temp + \".z\\n\" +\n\n\t\t\t\"mul \" + temp + \".xy, \" + depthProjection + \".xy, \" + dataReg + \".x\\n\" + \"frc \" + temp + \".xy, \" + temp + \".xy\\n\" +\n\n\t\t\t// some strange register juggling to prevent agal bugging out\n\t\t\t\"sub \" + depthProjection + \", \" + predicate + \".xyzw, \" + predicate + \".zwxy\\n\" + \"mul \" + depthProjection + \", \" + depthProjection + \", \" + temp + \".x\\n\" +\n\n\t\t\t\"add \" + predicate + \".xy, \" + predicate + \".xy, \" + depthProjection + \".zw\\n\" +\n\n\t\t\t\"sub \" + predicate + \".y, \" + predicate + \".y, \" + predicate + \".x\\n\" + \"mul \" + predicate + \".y, \" + predicate + \".y, \" + temp + \".y\\n\" + \"add \" + targetRegister + \".w, \" + predicate + \".x, \" + predicate + \".y\\n\";\n\n\t\tregisterCache.removeFragmentTempUsage(temp);\n\t\tregisterCache.removeFragmentTempUsage(predicate);\n\t\treturn code;\n\t}\n}\n\nexport = ShadowFilteredMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/ShadowFilteredMethod.ts b/lib/materials/methods/ShadowFilteredMethod.ts new file mode 100644 index 000000000..d234fecd3 --- /dev/null +++ b/lib/materials/methods/ShadowFilteredMethod.ts @@ -0,0 +1,140 @@ +import DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); + +/** + * ShadowFilteredMethod provides a softened shadowing technique by bilinearly interpolating shadow comparison + * results of neighbouring pixels. + */ +class ShadowFilteredMethod extends ShadowMethodBase +{ + /** + * Creates a new DiffuseBasicMethod object. + * + * @param castingLight The light casting the shadow + */ + constructor(castingLight:DirectionalLight) + { + super(castingLight); + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + super.iInitConstants(shaderObject, methodVO); + + var fragmentData:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.fragmentConstantsIndex; + fragmentData[index + 8] = .5; + var size:number /*int*/ = this.castingLight.shadowMapper.depthMapSize; + fragmentData[index + 9] = size; + fragmentData[index + 10] = 1/size; + } + + /** + * @inheritDoc + */ + public _pGetPlanarFragmentCode(methodVO:MethodVO, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var depthMapRegister:ShaderRegisterElement = regCache.getFreeTextureReg(); + var decReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + var dataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + // TODO: not used + dataReg = dataReg; + var customDataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + var depthCol:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp(); + var uvReg:ShaderRegisterElement; + var code:string = ""; + methodVO.fragmentConstantsIndex = decReg.index*4; + + regCache.addFragmentTempUsages(depthCol, 1); + + uvReg = regCache.getFreeFragmentVectorTemp(); + regCache.addFragmentTempUsages(uvReg, 1); + + code += "mov " + uvReg + ", " + this._pDepthMapCoordReg + "\n" + + + "tex " + depthCol + ", " + this._pDepthMapCoordReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".z, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + // 0 if in shadow + + "add " + uvReg + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".z\n" + // (1, 0) + "tex " + depthCol + ", " + uvReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".w, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + // 0 if in shadow + + "mul " + depthCol + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".y\n" + "frc " + depthCol + ".x, " + depthCol + ".x\n" + "sub " + uvReg + ".w, " + uvReg + ".w, " + uvReg + ".z\n" + "mul " + uvReg + ".w, " + uvReg + ".w, " + depthCol + ".x\n" + "add " + targetReg + ".w, " + uvReg + ".z, " + uvReg + ".w\n" + + + "mov " + uvReg + ".x, " + this._pDepthMapCoordReg + ".x\n" + "add " + uvReg + ".y, " + this._pDepthMapCoordReg + ".y, " + customDataReg + ".z\n" + // (0, 1) + "tex " + depthCol + ", " + uvReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".z, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + // 0 if in shadow + + "add " + uvReg + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".z\n" + // (1, 1) + "tex " + depthCol + ", " + uvReg + ", " + depthMapRegister + " <2d, nearest, clamp>\n" + "dp4 " + depthCol + ".z, " + depthCol + ", " + decReg + "\n" + "slt " + uvReg + ".w, " + this._pDepthMapCoordReg + ".z, " + depthCol + ".z\n" + // 0 if in shadow + + // recalculate fraction, since we ran out of registers :( + "mul " + depthCol + ".x, " + this._pDepthMapCoordReg + ".x, " + customDataReg + ".y\n" + "frc " + depthCol + ".x, " + depthCol + ".x\n" + "sub " + uvReg + ".w, " + uvReg + ".w, " + uvReg + ".z\n" + "mul " + uvReg + ".w, " + uvReg + ".w, " + depthCol + ".x\n" + "add " + uvReg + ".w, " + uvReg + ".z, " + uvReg + ".w\n" + + + "mul " + depthCol + ".x, " + this._pDepthMapCoordReg + ".y, " + customDataReg + ".y\n" + "frc " + depthCol + ".x, " + depthCol + ".x\n" + "sub " + uvReg + ".w, " + uvReg + ".w, " + targetReg + ".w\n" + "mul " + uvReg + ".w, " + uvReg + ".w, " + depthCol + ".x\n" + "add " + targetReg + ".w, " + targetReg + ".w, " + uvReg + ".w\n"; + + regCache.removeFragmentTempUsage(depthCol); + regCache.removeFragmentTempUsage(uvReg); + + methodVO.texturesIndex = depthMapRegister.index; + + return code; + } + + /** + * @inheritDoc + */ + public iActivateForCascade(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + var size:number /*int*/ = this.castingLight.shadowMapper.depthMapSize; + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index] = size; + data[index + 1] = 1/size; + } + + /** + * @inheritDoc + */ + public _iGetCascadeFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, decodeRegister:ShaderRegisterElement, depthTexture:ShaderRegisterElement, depthProjection:ShaderRegisterElement, targetRegister:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string; + var dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index*4; + var temp:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(temp, 1); + var predicate:ShaderRegisterElement = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(predicate, 1); + + code = "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".x, " + depthProjection + ".z, " + temp + ".z\n" + + + "add " + depthProjection + ".x, " + depthProjection + ".x, " + dataReg + ".y\n" + "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".z, " + depthProjection + ".z, " + temp + ".z\n" + + + "add " + depthProjection + ".y, " + depthProjection + ".y, " + dataReg + ".y\n" + "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".w, " + depthProjection + ".z, " + temp + ".z\n" + + + "sub " + depthProjection + ".x, " + depthProjection + ".x, " + dataReg + ".y\n" + "tex " + temp + ", " + depthProjection + ", " + depthTexture + " <2d, nearest, clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + predicate + ".y, " + depthProjection + ".z, " + temp + ".z\n" + + + "mul " + temp + ".xy, " + depthProjection + ".xy, " + dataReg + ".x\n" + "frc " + temp + ".xy, " + temp + ".xy\n" + + + // some strange register juggling to prevent agal bugging out + "sub " + depthProjection + ", " + predicate + ".xyzw, " + predicate + ".zwxy\n" + "mul " + depthProjection + ", " + depthProjection + ", " + temp + ".x\n" + + + "add " + predicate + ".xy, " + predicate + ".xy, " + depthProjection + ".zw\n" + + + "sub " + predicate + ".y, " + predicate + ".y, " + predicate + ".x\n" + "mul " + predicate + ".y, " + predicate + ".y, " + temp + ".y\n" + "add " + targetRegister + ".w, " + predicate + ".x, " + predicate + ".y\n"; + + registerCache.removeFragmentTempUsage(temp); + registerCache.removeFragmentTempUsage(predicate); + return code; + } +} + +export = ShadowFilteredMethod; \ No newline at end of file diff --git a/lib/materials/methods/ShadowNearMethod.js b/lib/materials/methods/ShadowNearMethod.js new file mode 100755 index 000000000..a2f82f4e2 --- /dev/null +++ b/lib/materials/methods/ShadowNearMethod.js @@ -0,0 +1,185 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +var ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); +// TODO: shadow mappers references in materials should be an interface so that this class should NOT extend ShadowMapMethodBase just for some delegation work +/** + * ShadowNearMethod provides a shadow map method that restricts the shadowed area near the camera to optimize + * shadow map usage. This method needs to be used in conjunction with a NearDirectionalShadowMapper. + * + * @see away.lights.NearDirectionalShadowMapper + */ +var ShadowNearMethod = (function (_super) { + __extends(ShadowNearMethod, _super); + /** + * Creates a new ShadowNearMethod object. + * @param baseMethod The shadow map sampling method used to sample individual cascades (fe: ShadowHardMethod, ShadowSoftMethod) + * @param fadeRatio The amount of shadow fading to the outer shadow area. A value of 1 would mean the shadows start fading from the camera's near plane. + */ + function ShadowNearMethod(baseMethod, fadeRatio) { + var _this = this; + if (fadeRatio === void 0) { fadeRatio = .1; } + _super.call(this, baseMethod.castingLight); + this._onShaderInvalidatedDelegate = function (event) { return _this.onShaderInvalidated(event); }; + this._baseMethod = baseMethod; + this._fadeRatio = fadeRatio; + this._nearShadowMapper = this._pCastingLight.shadowMapper; + if (!this._nearShadowMapper) + throw new Error("ShadowNearMethod requires a light that has a NearDirectionalShadowMapper instance assigned to shadowMapper."); + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + } + Object.defineProperty(ShadowNearMethod.prototype, "baseMethod", { + /** + * The base shadow map method on which this method's shading is based. + */ + get: function () { + return this._baseMethod; + }, + set: function (value) { + if (this._baseMethod == value) + return; + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this._baseMethod = value; + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + _super.prototype.iInitConstants.call(this, shaderObject, methodVO); + this._baseMethod.iInitConstants(shaderObject, methodVO); + var fragmentData = shaderObject.fragmentConstantData; + var index = methodVO.secondaryFragmentConstantsIndex; + fragmentData[index + 2] = 0; + fragmentData[index + 3] = 1; + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iInitVO = function (shaderObject, methodVO) { + this._baseMethod.iInitVO(shaderObject, methodVO); + methodVO.needsProjection = true; + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.dispose = function () { + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + }; + Object.defineProperty(ShadowNearMethod.prototype, "alpha", { + /** + * @inheritDoc + */ + get: function () { + return this._baseMethod.alpha; + }, + set: function (value) { + this._baseMethod.alpha = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ShadowNearMethod.prototype, "epsilon", { + /** + * @inheritDoc + */ + get: function () { + return this._baseMethod.epsilon; + }, + set: function (value) { + this._baseMethod.epsilon = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ShadowNearMethod.prototype, "fadeRatio", { + /** + * The amount of shadow fading to the outer shadow area. A value of 1 would mean the shadows start fading from the camera's near plane. + */ + get: function () { + return this._fadeRatio; + }, + set: function (value) { + this._fadeRatio = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iGetFragmentCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var code = this._baseMethod.iGetFragmentCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + var dataReg = registerCache.getFreeFragmentConstant(); + var temp = registerCache.getFreeFragmentSingleTemp(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index * 4; + code += "abs " + temp + ", " + sharedRegisters.projectionFragment + ".w\n" + "sub " + temp + ", " + temp + ", " + dataReg + ".x\n" + "mul " + temp + ", " + temp + ", " + dataReg + ".y\n" + "sat " + temp + ", " + temp + "\n" + "sub " + temp + ", " + dataReg + ".w," + temp + "\n" + "sub " + targetReg + ".w, " + dataReg + ".w," + targetReg + ".w\n" + "mul " + targetReg + ".w, " + targetReg + ".w, " + temp + "\n" + "sub " + targetReg + ".w, " + dataReg + ".w," + targetReg + ".w\n"; + return code; + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + this._baseMethod.iActivate(shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iDeactivate = function (shaderObject, methodVO, stage) { + this._baseMethod.iDeactivate(shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iSetRenderState = function (shaderObject, methodVO, renderable, stage, camera) { + // todo: move this to activate (needs camera) + var near = camera.projection.near; + var d = camera.projection.far - near; + var maxDistance = this._nearShadowMapper.coverageRatio; + var minDistance = maxDistance * (1 - this._fadeRatio); + maxDistance = near + maxDistance * d; + minDistance = near + minDistance * d; + var fragmentData = shaderObject.fragmentConstantData; + var index = methodVO.secondaryFragmentConstantsIndex; + fragmentData[index] = minDistance; + fragmentData[index + 1] = 1 / (maxDistance - minDistance); + this._baseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera); + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iGetVertexCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + return this._baseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iReset = function () { + this._baseMethod.iReset(); + }; + /** + * @inheritDoc + */ + ShadowNearMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._baseMethod.iCleanCompilationData(); + }; + /** + * Called when the base method's shader code is invalidated. + */ + ShadowNearMethod.prototype.onShaderInvalidated = function (event) { + this.iInvalidateShaderProgram(); + }; + return ShadowNearMethod; +})(ShadowMethodBase); +module.exports = ShadowNearMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/shadownearmethod.ts"],"names":["ShadowNearMethod","ShadowNearMethod.constructor","ShadowNearMethod.baseMethod","ShadowNearMethod.iInitConstants","ShadowNearMethod.iInitVO","ShadowNearMethod.dispose","ShadowNearMethod.alpha","ShadowNearMethod.epsilon","ShadowNearMethod.fadeRatio","ShadowNearMethod.iGetFragmentCode","ShadowNearMethod.iActivate","ShadowNearMethod.iDeactivate","ShadowNearMethod.iSetRenderState","ShadowNearMethod.iGetVertexCode","ShadowNearMethod.iReset","ShadowNearMethod.iCleanCompilationData","ShadowNearMethod.onShaderInvalidated"],"mappings":"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","file":"materials/methods/ShadowNearMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import NearDirectionalShadowMapper\t\t= require(\"awayjs-core/lib/materials/shadowmappers/NearDirectionalShadowMapper\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ShadingMethodEvent\t\t\t\t= require(\"awayjs-stagegl/lib/events/ShadingMethodEvent\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport ShadowMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowMethodBase\");\n\n// TODO: shadow mappers references in materials should be an interface so that this class should NOT extend ShadowMapMethodBase just for some delegation work\n/**\n * ShadowNearMethod provides a shadow map method that restricts the shadowed area near the camera to optimize\n * shadow map usage. This method needs to be used in conjunction with a NearDirectionalShadowMapper.\n *\n * @see away.lights.NearDirectionalShadowMapper\n */\nclass ShadowNearMethod extends ShadowMethodBase\n{\n\tprivate _baseMethod:ShadowMethodBase;\n\n\tprivate _fadeRatio:number;\n\tprivate _nearShadowMapper:NearDirectionalShadowMapper;\n\n\tprivate _onShaderInvalidatedDelegate:Function;\n\n\t/**\n\t * Creates a new ShadowNearMethod object.\n\t * @param baseMethod The shadow map sampling method used to sample individual cascades (fe: ShadowHardMethod, ShadowSoftMethod)\n\t * @param fadeRatio The amount of shadow fading to the outer shadow area. A value of 1 would mean the shadows start fading from the camera's near plane.\n\t */\n\tconstructor(baseMethod:ShadowMethodBase, fadeRatio:number = .1)\n\t{\n\t\tsuper(baseMethod.castingLight);\n\n\t\tthis._onShaderInvalidatedDelegate = (event:ShadingMethodEvent) => this.onShaderInvalidated(event);\n\n\t\tthis._baseMethod = baseMethod;\n\t\tthis._fadeRatio = fadeRatio;\n\t\tthis._nearShadowMapper = <NearDirectionalShadowMapper> this._pCastingLight.shadowMapper;\n\t\tif (!this._nearShadowMapper)\n\t\t\tthrow new Error(\"ShadowNearMethod requires a light that has a NearDirectionalShadowMapper instance assigned to shadowMapper.\");\n\t\tthis._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t}\n\n\t/**\n\t * The base shadow map method on which this method's shading is based.\n\t */\n\tpublic get baseMethod():ShadowMethodBase\n\t{\n\t\treturn this._baseMethod;\n\t}\n\n\tpublic set baseMethod(value:ShadowMethodBase)\n\t{\n\t\tif (this._baseMethod == value)\n\t\t\treturn;\n\n\t\tthis._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\n\t\tthis._baseMethod = value;\n\n\t\tthis._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tsuper.iInitConstants(shaderObject, methodVO);\n\t\tthis._baseMethod.iInitConstants(shaderObject, methodVO);\n\n\t\tvar fragmentData:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tfragmentData[index + 2] = 0;\n\t\tfragmentData[index + 3] = 1;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tthis._baseMethod.iInitVO(shaderObject, methodVO);\n\n\t\tmethodVO.needsProjection = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t\tthis._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get alpha():number\n\t{\n\t\treturn this._baseMethod.alpha;\n\t}\n\n\tpublic set alpha(value:number)\n\t{\n\t\tthis._baseMethod.alpha = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get epsilon():number\n\t{\n\t\treturn this._baseMethod.epsilon;\n\t}\n\n\tpublic set epsilon(value:number)\n\t{\n\t\tthis._baseMethod.epsilon = value;\n\t}\n\n\t/**\n\t * The amount of shadow fading to the outer shadow area. A value of 1 would mean the shadows start fading from the camera's near plane.\n\t */\n\tpublic get fadeRatio():number\n\t{\n\t\treturn this._fadeRatio;\n\t}\n\n\tpublic set fadeRatio(value:number)\n\t{\n\t\tthis._fadeRatio = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = this._baseMethod.iGetFragmentCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tvar temp:ShaderRegisterElement = registerCache.getFreeFragmentSingleTemp();\n\t\tmethodVO.secondaryFragmentConstantsIndex = dataReg.index*4;\n\n\t\tcode += \"abs \" + temp + \", \" + sharedRegisters.projectionFragment + \".w\\n\" +\n\t\t\t\"sub \" + temp + \", \" + temp + \", \" + dataReg + \".x\\n\" +\n\t\t\t\"mul \" + temp + \", \" + temp + \", \" + dataReg + \".y\\n\" +\n\t\t\t\"sat \" + temp + \", \" + temp + \"\\n\" +\n\t\t\t\"sub \" + temp + \", \" + dataReg + \".w,\" + temp + \"\\n\" +\n\t\t\t\"sub \" + targetReg + \".w, \" + dataReg + \".w,\" + targetReg + \".w\\n\" +\n\t\t\t\"mul \" + targetReg + \".w, \" + targetReg + \".w, \" + temp + \"\\n\" +\n\t\t\t\"sub \" + targetReg + \".w, \" + dataReg + \".w,\" + targetReg + \".w\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tthis._baseMethod.iActivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iDeactivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tthis._baseMethod.iDeactivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iSetRenderState(shaderObject:ShaderObjectBase, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera)\n\t{\n\t\t// todo: move this to activate (needs camera)\n\t\tvar near:number = camera.projection.near;\n\t\tvar d:number = camera.projection.far - near;\n\t\tvar maxDistance:number = this._nearShadowMapper.coverageRatio;\n\t\tvar minDistance:number = maxDistance*(1 - this._fadeRatio);\n\n\t\tmaxDistance = near + maxDistance*d;\n\t\tminDistance = near + minDistance*d;\n\n\t\tvar fragmentData:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tfragmentData[index] = minDistance;\n\t\tfragmentData[index + 1] = 1/(maxDistance - minDistance);\n\n\t\tthis._baseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this._baseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iReset()\n\t{\n\t\tthis._baseMethod.iReset();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._baseMethod.iCleanCompilationData();\n\t}\n\n\t/**\n\t * Called when the base method's shader code is invalidated.\n\t */\n\tprivate onShaderInvalidated(event:ShadingMethodEvent)\n\t{\n\t\tthis.iInvalidateShaderProgram();\n\t}\n}\n\nexport = ShadowNearMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/ShadowNearMethod.ts b/lib/materials/methods/ShadowNearMethod.ts new file mode 100644 index 000000000..5588edebf --- /dev/null +++ b/lib/materials/methods/ShadowNearMethod.ts @@ -0,0 +1,238 @@ +import NearDirectionalShadowMapper = require("awayjs-core/lib/materials/shadowmappers/NearDirectionalShadowMapper"); +import Camera = require("awayjs-core/lib/entities/Camera"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); + +// TODO: shadow mappers references in materials should be an interface so that this class should NOT extend ShadowMapMethodBase just for some delegation work +/** + * ShadowNearMethod provides a shadow map method that restricts the shadowed area near the camera to optimize + * shadow map usage. This method needs to be used in conjunction with a NearDirectionalShadowMapper. + * + * @see away.lights.NearDirectionalShadowMapper + */ +class ShadowNearMethod extends ShadowMethodBase +{ + private _baseMethod:ShadowMethodBase; + + private _fadeRatio:number; + private _nearShadowMapper:NearDirectionalShadowMapper; + + private _onShaderInvalidatedDelegate:Function; + + /** + * Creates a new ShadowNearMethod object. + * @param baseMethod The shadow map sampling method used to sample individual cascades (fe: ShadowHardMethod, ShadowSoftMethod) + * @param fadeRatio The amount of shadow fading to the outer shadow area. A value of 1 would mean the shadows start fading from the camera's near plane. + */ + constructor(baseMethod:ShadowMethodBase, fadeRatio:number = .1) + { + super(baseMethod.castingLight); + + this._onShaderInvalidatedDelegate = (event:ShadingMethodEvent) => this.onShaderInvalidated(event); + + this._baseMethod = baseMethod; + this._fadeRatio = fadeRatio; + this._nearShadowMapper = this._pCastingLight.shadowMapper; + if (!this._nearShadowMapper) + throw new Error("ShadowNearMethod requires a light that has a NearDirectionalShadowMapper instance assigned to shadowMapper."); + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + } + + /** + * The base shadow map method on which this method's shading is based. + */ + public get baseMethod():ShadowMethodBase + { + return this._baseMethod; + } + + public set baseMethod(value:ShadowMethodBase) + { + if (this._baseMethod == value) + return; + + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + + this._baseMethod = value; + + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + + this.iInvalidateShaderProgram(); + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + super.iInitConstants(shaderObject, methodVO); + this._baseMethod.iInitConstants(shaderObject, methodVO); + + var fragmentData:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + fragmentData[index + 2] = 0; + fragmentData[index + 3] = 1; + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + this._baseMethod.iInitVO(shaderObject, methodVO); + + methodVO.needsProjection = true; + } + + /** + * @inheritDoc + */ + public dispose() + { + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + } + + /** + * @inheritDoc + */ + public get alpha():number + { + return this._baseMethod.alpha; + } + + public set alpha(value:number) + { + this._baseMethod.alpha = value; + } + + /** + * @inheritDoc + */ + public get epsilon():number + { + return this._baseMethod.epsilon; + } + + public set epsilon(value:number) + { + this._baseMethod.epsilon = value; + } + + /** + * The amount of shadow fading to the outer shadow area. A value of 1 would mean the shadows start fading from the camera's near plane. + */ + public get fadeRatio():number + { + return this._fadeRatio; + } + + public set fadeRatio(value:number) + { + this._fadeRatio = value; + } + + /** + * @inheritDoc + */ + public iGetFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = this._baseMethod.iGetFragmentCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + + var dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + var temp:ShaderRegisterElement = registerCache.getFreeFragmentSingleTemp(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index*4; + + code += "abs " + temp + ", " + sharedRegisters.projectionFragment + ".w\n" + + "sub " + temp + ", " + temp + ", " + dataReg + ".x\n" + + "mul " + temp + ", " + temp + ", " + dataReg + ".y\n" + + "sat " + temp + ", " + temp + "\n" + + "sub " + temp + ", " + dataReg + ".w," + temp + "\n" + + "sub " + targetReg + ".w, " + dataReg + ".w," + targetReg + ".w\n" + + "mul " + targetReg + ".w, " + targetReg + ".w, " + temp + "\n" + + "sub " + targetReg + ".w, " + dataReg + ".w," + targetReg + ".w\n"; + + return code; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + this._baseMethod.iActivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iDeactivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + this._baseMethod.iDeactivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iSetRenderState(shaderObject:ShaderObjectBase, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera) + { + // todo: move this to activate (needs camera) + var near:number = camera.projection.near; + var d:number = camera.projection.far - near; + var maxDistance:number = this._nearShadowMapper.coverageRatio; + var minDistance:number = maxDistance*(1 - this._fadeRatio); + + maxDistance = near + maxDistance*d; + minDistance = near + minDistance*d; + + var fragmentData:Array = shaderObject.fragmentConstantData; + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + fragmentData[index] = minDistance; + fragmentData[index + 1] = 1/(maxDistance - minDistance); + + this._baseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera); + } + + /** + * @inheritDoc + */ + public iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this._baseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iReset() + { + this._baseMethod.iReset(); + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._baseMethod.iCleanCompilationData(); + } + + /** + * Called when the base method's shader code is invalidated. + */ + private onShaderInvalidated(event:ShadingMethodEvent) + { + this.iInvalidateShaderProgram(); + } +} + +export = ShadowNearMethod; \ No newline at end of file diff --git a/lib/materials/methods/ShadowSoftMethod.js b/lib/materials/methods/ShadowSoftMethod.js new file mode 100755 index 000000000..08fc6b728 --- /dev/null +++ b/lib/materials/methods/ShadowSoftMethod.js @@ -0,0 +1,172 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var PoissonLookup = require("awayjs-core/lib/core/geom/PoissonLookup"); +var ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); +/** + * ShadowSoftMethod provides a soft shadowing technique by randomly distributing sample points. + */ +var ShadowSoftMethod = (function (_super) { + __extends(ShadowSoftMethod, _super); + /** + * Creates a new DiffuseBasicMethod object. + * + * @param castingLight The light casting the shadows + * @param numSamples The amount of samples to take for dithering. Minimum 1, maximum 32. + */ + function ShadowSoftMethod(castingLight, numSamples, range) { + if (numSamples === void 0) { numSamples = 5; } + if (range === void 0) { range = 1; } + _super.call(this, castingLight); + this._range = 1; + this.numSamples = numSamples; + this.range = range; + } + Object.defineProperty(ShadowSoftMethod.prototype, "numSamples", { + /** + * The amount of samples to take for dithering. Minimum 1, maximum 32. The actual maximum may depend on the + * complexity of the shader. + */ + get: function () { + return this._numSamples; + }, + set: function (value /*int*/) { + this._numSamples = value; + if (this._numSamples < 1) + this._numSamples = 1; + else if (this._numSamples > 32) + this._numSamples = 32; + this._offsets = PoissonLookup.getDistribution(this._numSamples); + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ShadowSoftMethod.prototype, "range", { + /** + * The range in the shadow map in which to distribute the samples. + */ + get: function () { + return this._range; + }, + set: function (value) { + this._range = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + ShadowSoftMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + _super.prototype.iInitConstants.call(this, shaderObject, methodVO); + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 8] = 1 / this._numSamples; + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 9] = 0; + }; + /** + * @inheritDoc + */ + ShadowSoftMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var texRange = .5 * this._range / this._pCastingLight.shadowMapper.depthMapSize; + var data = shaderObject.fragmentConstantData; + var index = methodVO.fragmentConstantsIndex + 10; + var len = this._numSamples << 1; + for (var i = 0; i < len; ++i) + data[index + i] = this._offsets[i] * texRange; + }; + /** + * @inheritDoc + */ + ShadowSoftMethod.prototype._pGetPlanarFragmentCode = function (methodVO, targetReg, regCache, sharedRegisters) { + // todo: move some things to super + var depthMapRegister = regCache.getFreeTextureReg(); + var decReg = regCache.getFreeFragmentConstant(); + var dataReg = regCache.getFreeFragmentConstant(); + var customDataReg = regCache.getFreeFragmentConstant(); + methodVO.fragmentConstantsIndex = decReg.index * 4; + methodVO.texturesIndex = depthMapRegister.index; + return this.getSampleCode(regCache, depthMapRegister, decReg, targetReg, customDataReg); + }; + /** + * Adds the code for another tap to the shader code. + * @param uv The uv register for the tap. + * @param texture The texture register containing the depth map. + * @param decode The register containing the depth map decoding data. + * @param target The target register to add the tap comparison result. + * @param regCache The register cache managing the registers. + * @return + */ + ShadowSoftMethod.prototype.addSample = function (uv, texture, decode, target, regCache) { + var temp = regCache.getFreeFragmentVectorTemp(); + return "tex " + temp + ", " + uv + ", " + texture + " <2d,nearest,clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decode + "\n" + "slt " + uv + ".w, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n" + "add " + target + ".w, " + target + ".w, " + uv + ".w\n"; + }; + /** + * @inheritDoc + */ + ShadowSoftMethod.prototype.iActivateForCascade = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var texRange = this._range / this._pCastingLight.shadowMapper.depthMapSize; + var data = shaderObject.fragmentConstantData; + var index = methodVO.secondaryFragmentConstantsIndex; + var len = this._numSamples << 1; + data[index] = 1 / this._numSamples; + data[index + 1] = 0; + index += 2; + for (var i = 0; i < len; ++i) + data[index + i] = this._offsets[i] * texRange; + if (len % 4 == 0) { + data[index + len] = 0; + data[index + len + 1] = 0; + } + }; + /** + * @inheritDoc + */ + ShadowSoftMethod.prototype._iGetCascadeFragmentCode = function (shaderObject, methodVO, decodeRegister, depthTexture, depthProjection, targetRegister, registerCache, sharedRegisters) { + this._pDepthMapCoordReg = depthProjection; + var dataReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index * 4; + return this.getSampleCode(registerCache, depthTexture, decodeRegister, targetRegister, dataReg); + }; + /** + * Get the actual shader code for shadow mapping + * @param regCache The register cache managing the registers. + * @param depthTexture The texture register containing the depth map. + * @param decodeRegister The register containing the depth map decoding data. + * @param targetReg The target register to add the shadow coverage. + * @param dataReg The register containing additional data. + */ + ShadowSoftMethod.prototype.getSampleCode = function (regCache, depthTexture, decodeRegister, targetRegister, dataReg) { + var uvReg; + var code; + var offsets = new Array(dataReg + ".zw"); + uvReg = regCache.getFreeFragmentVectorTemp(); + regCache.addFragmentTempUsages(uvReg, 1); + var temp = regCache.getFreeFragmentVectorTemp(); + var numRegs = this._numSamples >> 1; + for (var i = 0; i < numRegs; ++i) { + var reg = regCache.getFreeFragmentConstant(); + offsets.push(reg + ".xy"); + offsets.push(reg + ".zw"); + } + for (i = 0; i < this._numSamples; ++i) { + if (i == 0) { + code = "add " + uvReg + ", " + this._pDepthMapCoordReg + ", " + dataReg + ".zwyy\n" + "tex " + temp + ", " + uvReg + ", " + depthTexture + " <2d,nearest,clamp>\n" + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + "slt " + targetRegister + ".w, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n"; // 0 if in shadow; + } + else { + code += "add " + uvReg + ".xy, " + this._pDepthMapCoordReg + ".xy, " + offsets[i] + "\n" + this.addSample(uvReg, depthTexture, decodeRegister, targetRegister, regCache); + } + } + regCache.removeFragmentTempUsage(uvReg); + code += "mul " + targetRegister + ".w, " + targetRegister + ".w, " + dataReg + ".x\n"; // average + return code; + }; + return ShadowSoftMethod; +})(ShadowMethodBase); +module.exports = ShadowSoftMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/shadowsoftmethod.ts"],"names":["ShadowSoftMethod","ShadowSoftMethod.constructor","ShadowSoftMethod.numSamples","ShadowSoftMethod.range","ShadowSoftMethod.iInitConstants","ShadowSoftMethod.iActivate","ShadowSoftMethod._pGetPlanarFragmentCode","ShadowSoftMethod.addSample","ShadowSoftMethod.iActivateForCascade","ShadowSoftMethod._iGetCascadeFragmentCode","ShadowSoftMethod.getSampleCode"],"mappings":"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","file":"materials/methods/ShadowSoftMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import PoissonLookup\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/PoissonLookup\");\nimport DirectionalLight\t\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport ShadowMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowMethodBase\");\n\n/**\n * ShadowSoftMethod provides a soft shadowing technique by randomly distributing sample points.\n */\nclass ShadowSoftMethod extends ShadowMethodBase\n{\n\tprivate _range:number = 1;\n\tprivate _numSamples:number /*int*/;\n\tprivate _offsets:Array<number>;\n\n\t/**\n\t * Creates a new DiffuseBasicMethod object.\n\t *\n\t * @param castingLight The light casting the shadows\n\t * @param numSamples The amount of samples to take for dithering. Minimum 1, maximum 32.\n\t */\n\tconstructor(castingLight:DirectionalLight, numSamples:number /*int*/ = 5, range:number = 1)\n\t{\n\t\tsuper(castingLight);\n\n\t\tthis.numSamples = numSamples;\n\t\tthis.range = range;\n\t}\n\n\t/**\n\t * The amount of samples to take for dithering. Minimum 1, maximum 32. The actual maximum may depend on the\n\t * complexity of the shader.\n\t */\n\tpublic get numSamples():number /*int*/\n\t{\n\t\treturn this._numSamples;\n\t}\n\n\tpublic set numSamples(value:number /*int*/)\n\t{\n\t\tthis._numSamples = value;\n\t\t\n\t\tif (this._numSamples < 1)\n\t\t\tthis._numSamples = 1;\n\t\telse if (this._numSamples > 32)\n\t\t\tthis._numSamples = 32;\n\n\t\tthis._offsets = PoissonLookup.getDistribution(this._numSamples);\n\t\t\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * The range in the shadow map in which to distribute the samples.\n\t */\n\tpublic get range():number\n\t{\n\t\treturn this._range;\n\t}\n\n\tpublic set range(value:number)\n\t{\n\t\tthis._range = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tsuper.iInitConstants(shaderObject, methodVO);\n\n\t\tshaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 8] = 1/this._numSamples;\n\t\tshaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 9] = 0;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\tvar texRange:number = .5*this._range/this._pCastingLight.shadowMapper.depthMapSize;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*uint*/ = methodVO.fragmentConstantsIndex + 10;\n\t\tvar len:number /*uint*/ = this._numSamples << 1;\n\n\t\tfor (var i:number /*int*/ = 0; i < len; ++i)\n\t\t\tdata[index + i] = this._offsets[i]*texRange;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pGetPlanarFragmentCode(methodVO:MethodVO, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\t// todo: move some things to super\n\t\tvar depthMapRegister:ShaderRegisterElement = regCache.getFreeTextureReg();\n\t\tvar decReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\tvar dataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\tvar customDataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\n\t\tmethodVO.fragmentConstantsIndex = decReg.index*4;\n\t\tmethodVO.texturesIndex = depthMapRegister.index;\n\n\t\treturn this.getSampleCode(regCache, depthMapRegister, decReg, targetReg, customDataReg);\n\t}\n\n\t/**\n\t * Adds the code for another tap to the shader code.\n\t * @param uv The uv register for the tap.\n\t * @param texture The texture register containing the depth map.\n\t * @param decode The register containing the depth map decoding data.\n\t * @param target The target register to add the tap comparison result.\n\t * @param regCache The register cache managing the registers.\n\t * @return\n\t */\n\tprivate addSample(uv:ShaderRegisterElement, texture:ShaderRegisterElement, decode:ShaderRegisterElement, target:ShaderRegisterElement, regCache:ShaderRegisterCache):string\n\t{\n\t\tvar temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp();\n\t\treturn \"tex \" + temp + \", \" + uv + \", \" + texture + \" <2d,nearest,clamp>\\n\" +\n\t\t\t\"dp4 \" + temp + \".z, \" + temp + \", \" + decode + \"\\n\" +\n\t\t\t\"slt \" + uv + \".w, \" + this._pDepthMapCoordReg + \".z, \" + temp + \".z\\n\" + // 0 if in shadow\n\t\t\t\"add \" + target + \".w, \" + target + \".w, \" + uv + \".w\\n\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivateForCascade(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\tvar texRange:number = this._range/this._pCastingLight.shadowMapper.depthMapSize;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tvar index:number /*uint*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tvar len:number /*uint*/ = this._numSamples << 1;\n\t\tdata[index] = 1/this._numSamples;\n\t\tdata[index + 1] = 0;\n\t\tindex += 2;\n\n\t\tfor (var i:number /*int*/ = 0; i < len; ++i)\n\t\t\tdata[index + i] = this._offsets[i]*texRange;\n\n\t\tif (len%4 == 0) {\n\t\t\tdata[index + len] = 0;\n\t\t\tdata[index + len + 1] = 0;\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGetCascadeFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, decodeRegister:ShaderRegisterElement, depthTexture:ShaderRegisterElement, depthProjection:ShaderRegisterElement, targetRegister:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tthis._pDepthMapCoordReg = depthProjection;\n\n\t\tvar dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.secondaryFragmentConstantsIndex = dataReg.index*4;\n\n\t\treturn this.getSampleCode(registerCache, depthTexture, decodeRegister, targetRegister, dataReg);\n\t}\n\n\t/**\n\t * Get the actual shader code for shadow mapping\n\t * @param regCache The register cache managing the registers.\n\t * @param depthTexture The texture register containing the depth map.\n\t * @param decodeRegister The register containing the depth map decoding data.\n\t * @param targetReg The target register to add the shadow coverage.\n\t * @param dataReg The register containing additional data.\n\t */\n\tprivate getSampleCode(regCache:ShaderRegisterCache, depthTexture:ShaderRegisterElement, decodeRegister:ShaderRegisterElement, targetRegister:ShaderRegisterElement, dataReg:ShaderRegisterElement):string\n\t{\n\t\tvar uvReg:ShaderRegisterElement;\n\t\tvar code:string;\n\t\tvar offsets:Array<string> = new Array<string>(dataReg + \".zw\");\n\t\tuvReg = regCache.getFreeFragmentVectorTemp();\n\t\tregCache.addFragmentTempUsages(uvReg, 1);\n\n\t\tvar temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp();\n\n\t\tvar numRegs:number /*int*/ = this._numSamples >> 1;\n\t\tfor (var i:number /*int*/ = 0; i < numRegs; ++i) {\n\t\t\tvar reg:ShaderRegisterElement = regCache.getFreeFragmentConstant();\n\t\t\toffsets.push(reg + \".xy\");\n\t\t\toffsets.push(reg + \".zw\");\n\t\t}\n\n\t\tfor (i = 0; i < this._numSamples; ++i) {\n\t\t\tif (i == 0) {\n\t\t\t\tcode = \"add \" + uvReg + \", \" + this._pDepthMapCoordReg + \", \" + dataReg + \".zwyy\\n\" +\n\t\t\t\t\t\"tex \" + temp + \", \" + uvReg + \", \" + depthTexture + \" <2d,nearest,clamp>\\n\" +\n\t\t\t\t\t\"dp4 \" + temp + \".z, \" + temp + \", \" + decodeRegister + \"\\n\" +\n\t\t\t\t\t\"slt \" + targetRegister + \".w, \" + this._pDepthMapCoordReg + \".z, \" + temp + \".z\\n\"; // 0 if in shadow;\n\t\t\t} else {\n\t\t\t\tcode += \"add \" + uvReg + \".xy, \" + this._pDepthMapCoordReg + \".xy, \" + offsets[i] + \"\\n\" +\n\t\t\t\t\tthis.addSample(uvReg, depthTexture, decodeRegister, targetRegister, regCache);\n\t\t\t}\n\t\t}\n\n\t\tregCache.removeFragmentTempUsage(uvReg);\n\n\t\tcode += \"mul \" + targetRegister + \".w, \" + targetRegister + \".w, \" + dataReg + \".x\\n\"; // average\n\n\t\treturn code;\n\t}\n}\n\nexport = ShadowSoftMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/ShadowSoftMethod.ts b/lib/materials/methods/ShadowSoftMethod.ts new file mode 100644 index 000000000..c17216a81 --- /dev/null +++ b/lib/materials/methods/ShadowSoftMethod.ts @@ -0,0 +1,215 @@ +import PoissonLookup = require("awayjs-core/lib/core/geom/PoissonLookup"); +import DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); + +/** + * ShadowSoftMethod provides a soft shadowing technique by randomly distributing sample points. + */ +class ShadowSoftMethod extends ShadowMethodBase +{ + private _range:number = 1; + private _numSamples:number /*int*/; + private _offsets:Array; + + /** + * Creates a new DiffuseBasicMethod object. + * + * @param castingLight The light casting the shadows + * @param numSamples The amount of samples to take for dithering. Minimum 1, maximum 32. + */ + constructor(castingLight:DirectionalLight, numSamples:number /*int*/ = 5, range:number = 1) + { + super(castingLight); + + this.numSamples = numSamples; + this.range = range; + } + + /** + * The amount of samples to take for dithering. Minimum 1, maximum 32. The actual maximum may depend on the + * complexity of the shader. + */ + public get numSamples():number /*int*/ + { + return this._numSamples; + } + + public set numSamples(value:number /*int*/) + { + this._numSamples = value; + + if (this._numSamples < 1) + this._numSamples = 1; + else if (this._numSamples > 32) + this._numSamples = 32; + + this._offsets = PoissonLookup.getDistribution(this._numSamples); + + this.iInvalidateShaderProgram(); + } + + /** + * The range in the shadow map in which to distribute the samples. + */ + public get range():number + { + return this._range; + } + + public set range(value:number) + { + this._range = value; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + super.iInitConstants(shaderObject, methodVO); + + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 8] = 1/this._numSamples; + shaderObject.fragmentConstantData[methodVO.fragmentConstantsIndex + 9] = 0; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var texRange:number = .5*this._range/this._pCastingLight.shadowMapper.depthMapSize; + var data:Array = shaderObject.fragmentConstantData; + var index:number /*uint*/ = methodVO.fragmentConstantsIndex + 10; + var len:number /*uint*/ = this._numSamples << 1; + + for (var i:number /*int*/ = 0; i < len; ++i) + data[index + i] = this._offsets[i]*texRange; + } + + /** + * @inheritDoc + */ + public _pGetPlanarFragmentCode(methodVO:MethodVO, targetReg:ShaderRegisterElement, regCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + // todo: move some things to super + var depthMapRegister:ShaderRegisterElement = regCache.getFreeTextureReg(); + var decReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + var dataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + var customDataReg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + + methodVO.fragmentConstantsIndex = decReg.index*4; + methodVO.texturesIndex = depthMapRegister.index; + + return this.getSampleCode(regCache, depthMapRegister, decReg, targetReg, customDataReg); + } + + /** + * Adds the code for another tap to the shader code. + * @param uv The uv register for the tap. + * @param texture The texture register containing the depth map. + * @param decode The register containing the depth map decoding data. + * @param target The target register to add the tap comparison result. + * @param regCache The register cache managing the registers. + * @return + */ + private addSample(uv:ShaderRegisterElement, texture:ShaderRegisterElement, decode:ShaderRegisterElement, target:ShaderRegisterElement, regCache:ShaderRegisterCache):string + { + var temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp(); + return "tex " + temp + ", " + uv + ", " + texture + " <2d,nearest,clamp>\n" + + "dp4 " + temp + ".z, " + temp + ", " + decode + "\n" + + "slt " + uv + ".w, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n" + // 0 if in shadow + "add " + target + ".w, " + target + ".w, " + uv + ".w\n"; + } + + /** + * @inheritDoc + */ + public iActivateForCascade(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var texRange:number = this._range/this._pCastingLight.shadowMapper.depthMapSize; + var data:Array = shaderObject.fragmentConstantData; + var index:number /*uint*/ = methodVO.secondaryFragmentConstantsIndex; + var len:number /*uint*/ = this._numSamples << 1; + data[index] = 1/this._numSamples; + data[index + 1] = 0; + index += 2; + + for (var i:number /*int*/ = 0; i < len; ++i) + data[index + i] = this._offsets[i]*texRange; + + if (len%4 == 0) { + data[index + len] = 0; + data[index + len + 1] = 0; + } + } + + /** + * @inheritDoc + */ + public _iGetCascadeFragmentCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, decodeRegister:ShaderRegisterElement, depthTexture:ShaderRegisterElement, depthProjection:ShaderRegisterElement, targetRegister:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + this._pDepthMapCoordReg = depthProjection; + + var dataReg:ShaderRegisterElement = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = dataReg.index*4; + + return this.getSampleCode(registerCache, depthTexture, decodeRegister, targetRegister, dataReg); + } + + /** + * Get the actual shader code for shadow mapping + * @param regCache The register cache managing the registers. + * @param depthTexture The texture register containing the depth map. + * @param decodeRegister The register containing the depth map decoding data. + * @param targetReg The target register to add the shadow coverage. + * @param dataReg The register containing additional data. + */ + private getSampleCode(regCache:ShaderRegisterCache, depthTexture:ShaderRegisterElement, decodeRegister:ShaderRegisterElement, targetRegister:ShaderRegisterElement, dataReg:ShaderRegisterElement):string + { + var uvReg:ShaderRegisterElement; + var code:string; + var offsets:Array = new Array(dataReg + ".zw"); + uvReg = regCache.getFreeFragmentVectorTemp(); + regCache.addFragmentTempUsages(uvReg, 1); + + var temp:ShaderRegisterElement = regCache.getFreeFragmentVectorTemp(); + + var numRegs:number /*int*/ = this._numSamples >> 1; + for (var i:number /*int*/ = 0; i < numRegs; ++i) { + var reg:ShaderRegisterElement = regCache.getFreeFragmentConstant(); + offsets.push(reg + ".xy"); + offsets.push(reg + ".zw"); + } + + for (i = 0; i < this._numSamples; ++i) { + if (i == 0) { + code = "add " + uvReg + ", " + this._pDepthMapCoordReg + ", " + dataReg + ".zwyy\n" + + "tex " + temp + ", " + uvReg + ", " + depthTexture + " <2d,nearest,clamp>\n" + + "dp4 " + temp + ".z, " + temp + ", " + decodeRegister + "\n" + + "slt " + targetRegister + ".w, " + this._pDepthMapCoordReg + ".z, " + temp + ".z\n"; // 0 if in shadow; + } else { + code += "add " + uvReg + ".xy, " + this._pDepthMapCoordReg + ".xy, " + offsets[i] + "\n" + + this.addSample(uvReg, depthTexture, decodeRegister, targetRegister, regCache); + } + } + + regCache.removeFragmentTempUsage(uvReg); + + code += "mul " + targetRegister + ".w, " + targetRegister + ".w, " + dataReg + ".x\n"; // average + + return code; + } +} + +export = ShadowSoftMethod; \ No newline at end of file diff --git a/lib/materials/methods/SpecularAnisotropicMethod.js b/lib/materials/methods/SpecularAnisotropicMethod.js new file mode 100755 index 000000000..41ccc09b5 --- /dev/null +++ b/lib/materials/methods/SpecularAnisotropicMethod.js @@ -0,0 +1,66 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); +/** + * SpecularAnisotropicMethod provides a specular method resulting in anisotropic highlights. These are typical for + * surfaces with microfacet details such as tiny grooves. In particular, this uses the Heidrich-Seidel distrubution. + * The tangent vectors are used as the surface groove directions. + */ +var SpecularAnisotropicMethod = (function (_super) { + __extends(SpecularAnisotropicMethod, _super); + /** + * Creates a new SpecularAnisotropicMethod object. + */ + function SpecularAnisotropicMethod() { + _super.call(this); + } + /** + * @inheritDoc + */ + SpecularAnisotropicMethod.prototype.iInitVO = function (shaderObject, methodVO) { + methodVO.needsTangents = true; + methodVO.needsView = true; + }; + /** + * @inheritDoc + */ + SpecularAnisotropicMethod.prototype.iGetFragmentCodePerLight = function (shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters) { + var code = ""; + var t; + if (this._pIsFirstLight) + t = this._pTotalLightColorReg; + else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + // (sin(l,t) * sin(v,t) - cos(l,t)*cos(v,t)) ^ k + code += "nrm " + t + ".xyz, " + sharedRegisters.tangentVarying + ".xyz\n" + "dp3 " + t + ".w, " + t + ".xyz, " + lightDirReg + ".xyz\n" + "dp3 " + t + ".z, " + t + ".xyz, " + sharedRegisters.viewDirFragment + ".xyz\n"; + // (sin(t.w) * sin(t.z) - cos(t.w)*cos(t.z)) ^ k + code += "sin " + t + ".x, " + t + ".w\n" + "sin " + t + ".y, " + t + ".z\n" + "mul " + t + ".x, " + t + ".x, " + t + ".y\n" + "cos " + t + ".z, " + t + ".z\n" + "cos " + t + ".w, " + t + ".w\n" + "mul " + t + ".w, " + t + ".w, " + t + ".z\n" + "sub " + t + ".w, " + t + ".x, " + t + ".w\n"; + if (this._pUseTexture) { + // apply gloss modulation from texture + code += "mul " + this._pSpecularTexData + ".w, " + this._pSpecularTexData + ".y, " + this._pSpecularDataRegister + ".w\n" + "pow " + t + ".w, " + t + ".w, " + this._pSpecularTexData + ".w\n"; + } + else + code += "pow " + t + ".w, " + t + ".w, " + this._pSpecularDataRegister + ".w\n"; + // attenuate + code += "mul " + t + ".w, " + t + ".w, " + lightDirReg + ".w\n"; + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters); + code += "mul " + t + ".xyz, " + lightColReg + ".xyz, " + t + ".w\n"; + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + this._pIsFirstLight = false; + return code; + }; + return SpecularAnisotropicMethod; +})(SpecularBasicMethod); +module.exports = SpecularAnisotropicMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/specularanisotropicmethod.ts"],"names":["SpecularAnisotropicMethod","SpecularAnisotropicMethod.constructor","SpecularAnisotropicMethod.iInitVO","SpecularAnisotropicMethod.iGetFragmentCodePerLight"],"mappings":"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","file":"materials/methods/SpecularAnisotropicMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport SpecularBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/SpecularBasicMethod\");\n\n/**\n * SpecularAnisotropicMethod provides a specular method resulting in anisotropic highlights. These are typical for\n * surfaces with microfacet details such as tiny grooves. In particular, this uses the Heidrich-Seidel distrubution.\n * The tangent vectors are used as the surface groove directions.\n */\nclass SpecularAnisotropicMethod extends SpecularBasicMethod\n{\n\t/**\n\t * Creates a new SpecularAnisotropicMethod object.\n\t */\n\tconstructor()\n\t{\n\t\tsuper();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tmethodVO.needsTangents = true;\n\t\tmethodVO.needsView = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar t:ShaderRegisterElement;\n\n\t\tif (this._pIsFirstLight)\n\t\t\tt = this._pTotalLightColorReg;\n\t\telse {\n\t\t\tt = registerCache.getFreeFragmentVectorTemp();\n\t\t\tregisterCache.addFragmentTempUsages(t, 1);\n\t\t}\n\n\t\t// (sin(l,t) * sin(v,t) - cos(l,t)*cos(v,t)) ^ k\n\n\t\tcode += \"nrm \" + t + \".xyz, \" + sharedRegisters.tangentVarying + \".xyz\\n\" +\n\t\t\t\"dp3 \" + t + \".w, \" + t + \".xyz, \" + lightDirReg + \".xyz\\n\" +\n\t\t\t\"dp3 \" + t + \".z, \" + t + \".xyz, \" + sharedRegisters.viewDirFragment + \".xyz\\n\";\n\n\t\t// (sin(t.w) * sin(t.z) - cos(t.w)*cos(t.z)) ^ k\n\t\tcode += \"sin \" + t + \".x, \" + t + \".w\\n\" +\n\t\t\t\"sin \" + t + \".y, \" + t + \".z\\n\" +\n\t\t\t// (t.x * t.y - cos(t.w)*cos(t.z)) ^ k\n\t\t\t\"mul \" + t + \".x, \" + t + \".x, \" + t + \".y\\n\" +\n\t\t\t// (t.x - cos(t.w)*cos(t.z)) ^ k\n\t\t\t\"cos \" + t + \".z, \" + t + \".z\\n\" +\n\t\t\t\"cos \" + t + \".w, \" + t + \".w\\n\" +\n\t\t\t// (t.x - t.w*t.z) ^ k\n\t\t\t\"mul \" + t + \".w, \" + t + \".w, \" + t + \".z\\n\" +\n\t\t\t// (t.x - t.w) ^ k\n\t\t\t\"sub \" + t + \".w, \" + t + \".x, \" + t + \".w\\n\";\n\n\t\tif (this._pUseTexture) {\n\t\t\t// apply gloss modulation from texture\n\t\t\tcode += \"mul \" + this._pSpecularTexData + \".w, \" + this._pSpecularTexData + \".y, \" + this._pSpecularDataRegister + \".w\\n\" +\n\t\t\t\t\"pow \" + t + \".w, \" + t + \".w, \" + this._pSpecularTexData + \".w\\n\";\n\t\t} else\n\t\t\tcode += \"pow \" + t + \".w, \" + t + \".w, \" + this._pSpecularDataRegister + \".w\\n\";\n\n\t\t// attenuate\n\t\tcode += \"mul \" + t + \".w, \" + t + \".w, \" + lightDirReg + \".w\\n\";\n\n\t\tif (this._iModulateMethod != null)\n\t\t\tcode += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters);\n\n\t\tcode += \"mul \" + t + \".xyz, \" + lightColReg + \".xyz, \" + t + \".w\\n\";\n\n\t\tif (!this._pIsFirstLight) {\n\t\t\tcode += \"add \" + this._pTotalLightColorReg + \".xyz, \" + this._pTotalLightColorReg + \".xyz, \" + t + \".xyz\\n\";\n\t\t\tregisterCache.removeFragmentTempUsage(t);\n\t\t}\n\n\t\tthis._pIsFirstLight = false;\n\n\t\treturn code;\n\t}\n}\n\nexport = SpecularAnisotropicMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/SpecularAnisotropicMethod.ts b/lib/materials/methods/SpecularAnisotropicMethod.ts new file mode 100644 index 000000000..6a2100d3e --- /dev/null +++ b/lib/materials/methods/SpecularAnisotropicMethod.ts @@ -0,0 +1,92 @@ +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); + +/** + * SpecularAnisotropicMethod provides a specular method resulting in anisotropic highlights. These are typical for + * surfaces with microfacet details such as tiny grooves. In particular, this uses the Heidrich-Seidel distrubution. + * The tangent vectors are used as the surface groove directions. + */ +class SpecularAnisotropicMethod extends SpecularBasicMethod +{ + /** + * Creates a new SpecularAnisotropicMethod object. + */ + constructor() + { + super(); + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + methodVO.needsTangents = true; + methodVO.needsView = true; + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var t:ShaderRegisterElement; + + if (this._pIsFirstLight) + t = this._pTotalLightColorReg; + else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + + // (sin(l,t) * sin(v,t) - cos(l,t)*cos(v,t)) ^ k + + code += "nrm " + t + ".xyz, " + sharedRegisters.tangentVarying + ".xyz\n" + + "dp3 " + t + ".w, " + t + ".xyz, " + lightDirReg + ".xyz\n" + + "dp3 " + t + ".z, " + t + ".xyz, " + sharedRegisters.viewDirFragment + ".xyz\n"; + + // (sin(t.w) * sin(t.z) - cos(t.w)*cos(t.z)) ^ k + code += "sin " + t + ".x, " + t + ".w\n" + + "sin " + t + ".y, " + t + ".z\n" + + // (t.x * t.y - cos(t.w)*cos(t.z)) ^ k + "mul " + t + ".x, " + t + ".x, " + t + ".y\n" + + // (t.x - cos(t.w)*cos(t.z)) ^ k + "cos " + t + ".z, " + t + ".z\n" + + "cos " + t + ".w, " + t + ".w\n" + + // (t.x - t.w*t.z) ^ k + "mul " + t + ".w, " + t + ".w, " + t + ".z\n" + + // (t.x - t.w) ^ k + "sub " + t + ".w, " + t + ".x, " + t + ".w\n"; + + if (this._pUseTexture) { + // apply gloss modulation from texture + code += "mul " + this._pSpecularTexData + ".w, " + this._pSpecularTexData + ".y, " + this._pSpecularDataRegister + ".w\n" + + "pow " + t + ".w, " + t + ".w, " + this._pSpecularTexData + ".w\n"; + } else + code += "pow " + t + ".w, " + t + ".w, " + this._pSpecularDataRegister + ".w\n"; + + // attenuate + code += "mul " + t + ".w, " + t + ".w, " + lightDirReg + ".w\n"; + + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters); + + code += "mul " + t + ".xyz, " + lightColReg + ".xyz, " + t + ".w\n"; + + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + + this._pIsFirstLight = false; + + return code; + } +} + +export = SpecularAnisotropicMethod; \ No newline at end of file diff --git a/lib/materials/methods/SpecularCelMethod.js b/lib/materials/methods/SpecularCelMethod.js new file mode 100755 index 000000000..c1425ee2b --- /dev/null +++ b/lib/materials/methods/SpecularCelMethod.js @@ -0,0 +1,94 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var SpecularCompositeMethod = require("awayjs-renderergl/lib/materials/methods/SpecularCompositeMethod"); +/** + * SpecularCelMethod provides a shading method to add specular cel (cartoon) shading. + */ +var SpecularCelMethod = (function (_super) { + __extends(SpecularCelMethod, _super); + /** + * Creates a new SpecularCelMethod object. + * @param specularCutOff The threshold at which the specular highlight should be shown. + * @param baseMethod An optional specular method on which the cartoon shading is based. If ommitted, SpecularBasicMethod is used. + */ + function SpecularCelMethod(specularCutOff, baseMethod) { + var _this = this; + if (specularCutOff === void 0) { specularCutOff = .5; } + if (baseMethod === void 0) { baseMethod = null; } + _super.call(this, null, baseMethod); + this._smoothness = .1; + this._specularCutOff = .1; + this.baseMethod._iModulateMethod = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { return _this.clampSpecular(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); }; + this._specularCutOff = specularCutOff; + } + Object.defineProperty(SpecularCelMethod.prototype, "smoothness", { + /** + * The smoothness of the highlight edge. + */ + get: function () { + return this._smoothness; + }, + set: function (value) { + this._smoothness = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SpecularCelMethod.prototype, "specularCutOff", { + /** + * The threshold at which the specular highlight should be shown. + */ + get: function () { + return this._specularCutOff; + }, + set: function (value) { + this._specularCutOff = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SpecularCelMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var index = methodVO.secondaryFragmentConstantsIndex; + var data = shaderObject.fragmentConstantData; + data[index] = this._smoothness; + data[index + 1] = this._specularCutOff; + }; + /** + * @inheritDoc + */ + SpecularCelMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._dataReg = null; + }; + /** + * Snaps the specular shading strength of the wrapped method to zero or one, depending on whether or not it exceeds the specularCutOff + * @param vo The MethodVO used to compile the current shader. + * @param t The register containing the specular strength in the "w" component, and either the half-vector or the reflection vector in "xyz". + * @param regCache The register cache used for the shader compilation. + * @param sharedRegisters The shared register data for this shader. + * @return The AGAL fragment code for the method. + */ + SpecularCelMethod.prototype.clampSpecular = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + return "sub " + targetReg + ".y, " + targetReg + ".w, " + this._dataReg + ".y\n" + "div " + targetReg + ".y, " + targetReg + ".y, " + this._dataReg + ".x\n" + "sat " + targetReg + ".y, " + targetReg + ".y\n" + "sge " + targetReg + ".w, " + targetReg + ".w, " + this._dataReg + ".y\n" + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n"; + }; + /** + * @inheritDoc + */ + SpecularCelMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + this._dataReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._dataReg.index * 4; + return _super.prototype.iGetFragmentPreLightingCode.call(this, shaderObject, methodVO, registerCache, sharedRegisters); + }; + return SpecularCelMethod; +})(SpecularCompositeMethod); +module.exports = SpecularCelMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/specularcelmethod.ts"],"names":["SpecularCelMethod","SpecularCelMethod.constructor","SpecularCelMethod.smoothness","SpecularCelMethod.specularCutOff","SpecularCelMethod.iActivate","SpecularCelMethod.iCleanCompilationData","SpecularCelMethod.clampSpecular","SpecularCelMethod.iGetFragmentPreLightingCode"],"mappings":"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","file":"materials/methods/SpecularCelMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport SpecularBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/SpecularBasicMethod\");\n\nimport SpecularCompositeMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/SpecularCompositeMethod\");\n\n/**\n * SpecularCelMethod provides a shading method to add specular cel (cartoon) shading.\n */\nclass SpecularCelMethod extends SpecularCompositeMethod\n{\n\tprivate _dataReg:ShaderRegisterElement;\n\tprivate _smoothness:number = .1;\n\tprivate _specularCutOff:number = .1;\n\n\t/**\n\t * Creates a new SpecularCelMethod object.\n\t * @param specularCutOff The threshold at which the specular highlight should be shown.\n\t * @param baseMethod An optional specular method on which the cartoon shading is based. If ommitted, SpecularBasicMethod is used.\n\t */\n\tconstructor(specularCutOff:number = .5, baseMethod:SpecularBasicMethod = null)\n\t{\n\t\tsuper(null, baseMethod);\n\n\t\tthis.baseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.clampSpecular(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\n\t\tthis._specularCutOff = specularCutOff;\n\t}\n\n\t/**\n\t * The smoothness of the highlight edge.\n\t */\n\tpublic get smoothness():number\n\t{\n\t\treturn this._smoothness;\n\t}\n\n\tpublic set smoothness(value:number)\n\t{\n\t\tthis._smoothness = value;\n\t}\n\n\t/**\n\t * The threshold at which the specular highlight should be shown.\n\t */\n\tpublic get specularCutOff():number\n\t{\n\t\treturn this._specularCutOff;\n\t}\n\n\tpublic set specularCutOff(value:number)\n\t{\n\t\tthis._specularCutOff = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\tvar index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex;\n\t\tvar data:Array<number> = shaderObject.fragmentConstantData;\n\t\tdata[index] = this._smoothness;\n\t\tdata[index + 1] = this._specularCutOff;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._dataReg = null;\n\t}\n\n\t/**\n\t * Snaps the specular shading strength of the wrapped method to zero or one, depending on whether or not it exceeds the specularCutOff\n\t * @param vo The MethodVO used to compile the current shader.\n\t * @param t The register containing the specular strength in the \"w\" component, and either the half-vector or the reflection vector in \"xyz\".\n\t * @param regCache The register cache used for the shader compilation.\n\t * @param sharedRegisters The shared register data for this shader.\n\t * @return The AGAL fragment code for the method.\n\t */\n\tprivate clampSpecular(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn \"sub \" + targetReg + \".y, \" + targetReg + \".w, \" + this._dataReg + \".y\\n\" + // x - cutoff\n\t\t\t\"div \" + targetReg + \".y, \" + targetReg + \".y, \" + this._dataReg + \".x\\n\" + // (x - cutoff)/epsilon\n\t\t\t\"sat \" + targetReg + \".y, \" + targetReg + \".y\\n\" +\n\t\t\t\"sge \" + targetReg + \".w, \" + targetReg + \".w, \" + this._dataReg + \".y\\n\" +\n\t\t\t\"mul \" + targetReg + \".w, \" + targetReg + \".w, \" + targetReg + \".y\\n\";\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tthis._dataReg = registerCache.getFreeFragmentConstant();\n\t\tmethodVO.secondaryFragmentConstantsIndex = this._dataReg.index*4;\n\n\t\treturn super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n}\n\nexport = SpecularCelMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/SpecularCelMethod.ts b/lib/materials/methods/SpecularCelMethod.ts new file mode 100644 index 000000000..53ada1afb --- /dev/null +++ b/lib/materials/methods/SpecularCelMethod.ts @@ -0,0 +1,112 @@ +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); + +import SpecularCompositeMethod = require("awayjs-renderergl/lib/materials/methods/SpecularCompositeMethod"); + +/** + * SpecularCelMethod provides a shading method to add specular cel (cartoon) shading. + */ +class SpecularCelMethod extends SpecularCompositeMethod +{ + private _dataReg:ShaderRegisterElement; + private _smoothness:number = .1; + private _specularCutOff:number = .1; + + /** + * Creates a new SpecularCelMethod object. + * @param specularCutOff The threshold at which the specular highlight should be shown. + * @param baseMethod An optional specular method on which the cartoon shading is based. If ommitted, SpecularBasicMethod is used. + */ + constructor(specularCutOff:number = .5, baseMethod:SpecularBasicMethod = null) + { + super(null, baseMethod); + + this.baseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.clampSpecular(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + + this._specularCutOff = specularCutOff; + } + + /** + * The smoothness of the highlight edge. + */ + public get smoothness():number + { + return this._smoothness; + } + + public set smoothness(value:number) + { + this._smoothness = value; + } + + /** + * The threshold at which the specular highlight should be shown. + */ + public get specularCutOff():number + { + return this._specularCutOff; + } + + public set specularCutOff(value:number) + { + this._specularCutOff = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var index:number /*int*/ = methodVO.secondaryFragmentConstantsIndex; + var data:Array = shaderObject.fragmentConstantData; + data[index] = this._smoothness; + data[index + 1] = this._specularCutOff; + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._dataReg = null; + } + + /** + * Snaps the specular shading strength of the wrapped method to zero or one, depending on whether or not it exceeds the specularCutOff + * @param vo The MethodVO used to compile the current shader. + * @param t The register containing the specular strength in the "w" component, and either the half-vector or the reflection vector in "xyz". + * @param regCache The register cache used for the shader compilation. + * @param sharedRegisters The shared register data for this shader. + * @return The AGAL fragment code for the method. + */ + private clampSpecular(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return "sub " + targetReg + ".y, " + targetReg + ".w, " + this._dataReg + ".y\n" + // x - cutoff + "div " + targetReg + ".y, " + targetReg + ".y, " + this._dataReg + ".x\n" + // (x - cutoff)/epsilon + "sat " + targetReg + ".y, " + targetReg + ".y\n" + + "sge " + targetReg + ".w, " + targetReg + ".w, " + this._dataReg + ".y\n" + + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n"; + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + this._dataReg = registerCache.getFreeFragmentConstant(); + methodVO.secondaryFragmentConstantsIndex = this._dataReg.index*4; + + return super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + } +} + +export = SpecularCelMethod; \ No newline at end of file diff --git a/lib/materials/methods/SpecularCompositeMethod.js b/lib/materials/methods/SpecularCompositeMethod.js new file mode 100755 index 000000000..0dff27405 --- /dev/null +++ b/lib/materials/methods/SpecularCompositeMethod.js @@ -0,0 +1,188 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +var SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); +/** + * SpecularCompositeMethod provides a base class for specular methods that wrap a specular method to alter the + * calculated specular reflection strength. + */ +var SpecularCompositeMethod = (function (_super) { + __extends(SpecularCompositeMethod, _super); + /** + * Creates a new SpecularCompositeMethod object. + * + * @param modulateMethod The method which will add the code to alter the base method's strength. It needs to have the signature modSpecular(t:ShaderRegisterElement, regCache:ShaderRegisterCache):string, in which t.w will contain the specular strength and t.xyz will contain the half-vector or the reflection vector. + * @param baseMethod The base specular method on which this method's shading is based. + */ + function SpecularCompositeMethod(modulateMethod, baseMethod) { + var _this = this; + if (baseMethod === void 0) { baseMethod = null; } + _super.call(this); + this._onShaderInvalidatedDelegate = function (event) { return _this.onShaderInvalidated(event); }; + this._baseMethod = baseMethod || new SpecularBasicMethod(); + this._baseMethod._iModulateMethod = modulateMethod; + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + } + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iInitVO = function (shaderObject, methodVO) { + this._baseMethod.iInitVO(shaderObject, methodVO); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + this._baseMethod.iInitConstants(shaderObject, methodVO); + }; + Object.defineProperty(SpecularCompositeMethod.prototype, "baseMethod", { + /** + * The base specular method on which this method's shading is based. + */ + get: function () { + return this._baseMethod; + }, + set: function (value) { + if (this._baseMethod == value) + return; + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this._baseMethod = value; + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SpecularCompositeMethod.prototype, "gloss", { + /** + * @inheritDoc + */ + get: function () { + return this._baseMethod.gloss; + }, + set: function (value) { + this._baseMethod.gloss = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SpecularCompositeMethod.prototype, "specular", { + /** + * @inheritDoc + */ + get: function () { + return this._baseMethod.specular; + }, + set: function (value) { + this._baseMethod.specular = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SpecularCompositeMethod.prototype, "passes", { + /** + * @inheritDoc + */ + get: function () { + return this._baseMethod.passes; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.dispose = function () { + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this._baseMethod.dispose(); + }; + Object.defineProperty(SpecularCompositeMethod.prototype, "texture", { + /** + * @inheritDoc + */ + get: function () { + return this._baseMethod.texture; + }, + set: function (value) { + this._baseMethod.texture = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + this._baseMethod.iActivate(shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iSetRenderState = function (shaderObject, methodVO, renderable, stage, camera) { + this._baseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iDeactivate = function (shaderObject, methodVO, stage) { + this._baseMethod.iDeactivate(shaderObject, methodVO, stage); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iGetVertexCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + return this._baseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + return this._baseMethod.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iGetFragmentCodePerLight = function (shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters) { + return this._baseMethod.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + * @return + */ + SpecularCompositeMethod.prototype.iGetFragmentCodePerProbe = function (shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters) { + return this._baseMethod.iGetFragmentCodePerProbe(shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iGetFragmentPostLightingCode = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + return this._baseMethod.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iReset = function () { + this._baseMethod.iReset(); + }; + /** + * @inheritDoc + */ + SpecularCompositeMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._baseMethod.iCleanCompilationData(); + }; + /** + * Called when the base method's shader code is invalidated. + */ + SpecularCompositeMethod.prototype.onShaderInvalidated = function (event) { + this.iInvalidateShaderProgram(); + }; + return SpecularCompositeMethod; +})(SpecularBasicMethod); +module.exports = SpecularCompositeMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/specularcompositemethod.ts"],"names":["SpecularCompositeMethod","SpecularCompositeMethod.constructor","SpecularCompositeMethod.iInitVO","SpecularCompositeMethod.iInitConstants","SpecularCompositeMethod.baseMethod","SpecularCompositeMethod.gloss","SpecularCompositeMethod.specular","SpecularCompositeMethod.passes","SpecularCompositeMethod.dispose","SpecularCompositeMethod.texture","SpecularCompositeMethod.iActivate","SpecularCompositeMethod.iSetRenderState","SpecularCompositeMethod.iDeactivate","SpecularCompositeMethod.iGetVertexCode","SpecularCompositeMethod.iGetFragmentPreLightingCode","SpecularCompositeMethod.iGetFragmentCodePerLight","SpecularCompositeMethod.iGetFragmentCodePerProbe","SpecularCompositeMethod.iGetFragmentPostLightingCode","SpecularCompositeMethod.iReset","SpecularCompositeMethod.iCleanCompilationData","SpecularCompositeMethod.onShaderInvalidated"],"mappings":"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","file":"materials/methods/SpecularCompositeMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ShadingMethodEvent\t\t\t\t= require(\"awayjs-stagegl/lib/events/ShadingMethodEvent\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport SpecularBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/SpecularBasicMethod\");\nimport MaterialPassBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/passes/MaterialPassBase\");\n\n/**\n * SpecularCompositeMethod provides a base class for specular methods that wrap a specular method to alter the\n * calculated specular reflection strength.\n */\nclass SpecularCompositeMethod extends SpecularBasicMethod\n{\n\tprivate _baseMethod:SpecularBasicMethod;\n\n\tprivate _onShaderInvalidatedDelegate:Function;\n\n\t/**\n\t * Creates a new <code>SpecularCompositeMethod</code> object.\n\t *\n\t * @param modulateMethod The method which will add the code to alter the base method's strength. It needs to have the signature modSpecular(t:ShaderRegisterElement, regCache:ShaderRegisterCache):string, in which t.w will contain the specular strength and t.xyz will contain the half-vector or the reflection vector.\n\t * @param baseMethod The base specular method on which this method's shading is based.\n\t */\n\tconstructor(modulateMethod:(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => string, baseMethod:SpecularBasicMethod = null)\n\t{\n\t\tsuper();\n\n\t\tthis._onShaderInvalidatedDelegate = (event:ShadingMethodEvent) => this.onShaderInvalidated(event);\n\n\t\tthis._baseMethod = baseMethod || new SpecularBasicMethod();\n\t\tthis._baseMethod._iModulateMethod = modulateMethod;\n\t\tthis._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO)\n\t{\n\t\tthis._baseMethod.iInitVO(shaderObject, methodVO);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\t\tthis._baseMethod.iInitConstants(shaderObject, methodVO);\n\t}\n\n\t/**\n\t * The base specular method on which this method's shading is based.\n\t */\n\tpublic get baseMethod():SpecularBasicMethod\n\t{\n\t\treturn this._baseMethod;\n\t}\n\n\tpublic set baseMethod(value:SpecularBasicMethod)\n\t{\n\t\tif (this._baseMethod == value)\n\t\t\treturn;\n\n\t\tthis._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\n\t\tthis._baseMethod = value;\n\n\t\tthis._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get gloss():number\n\t{\n\t\treturn this._baseMethod.gloss;\n\t}\n\n\tpublic set gloss(value:number)\n\t{\n\t\tthis._baseMethod.gloss = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get specular():number\n\t{\n\t\treturn this._baseMethod.specular;\n\t}\n\n\tpublic set specular(value:number)\n\t{\n\t\tthis._baseMethod.specular = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get passes():Array<MaterialPassBase>\n\t{\n\t\treturn this._baseMethod.passes;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t\tthis._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate);\n\t\tthis._baseMethod.dispose();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic get texture():Texture2DBase\n\t{\n\t\treturn this._baseMethod.texture;\n\t}\n\n\tpublic set texture(value:Texture2DBase)\n\t{\n\t\tthis._baseMethod.texture = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tthis._baseMethod.iActivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iSetRenderState(shaderObject:ShaderLightingObject, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera)\n\t{\n\t\tthis._baseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iDeactivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tthis._baseMethod.iDeactivate(shaderObject, methodVO, stage);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this._baseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this._baseMethod.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this._baseMethod.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t * @return\n\t */\n\tpublic iGetFragmentCodePerProbe(shaderObject:ShaderLightingObject, methodVO:MethodVO, cubeMapReg:ShaderRegisterElement, weightRegister:string, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this._baseMethod.iGetFragmentCodePerProbe(shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\treturn this._baseMethod.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iReset()\n\t{\n\t\tthis._baseMethod.iReset();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._baseMethod.iCleanCompilationData();\n\t}\n\n\t/**\n\t * Called when the base method's shader code is invalidated.\n\t */\n\tprivate onShaderInvalidated(event:ShadingMethodEvent)\n\t{\n\t\tthis.iInvalidateShaderProgram();\n\t}\n}\n\nexport = SpecularCompositeMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/SpecularCompositeMethod.ts b/lib/materials/methods/SpecularCompositeMethod.ts new file mode 100755 index 000000000..51f0ea6a2 --- /dev/null +++ b/lib/materials/methods/SpecularCompositeMethod.ts @@ -0,0 +1,228 @@ +import Camera = require("awayjs-core/lib/entities/Camera"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ShadingMethodEvent = require("awayjs-stagegl/lib/events/ShadingMethodEvent"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); +import MaterialPassBase = require("awayjs-stagegl/lib/materials/passes/MaterialPassBase"); + +/** + * SpecularCompositeMethod provides a base class for specular methods that wrap a specular method to alter the + * calculated specular reflection strength. + */ +class SpecularCompositeMethod extends SpecularBasicMethod +{ + private _baseMethod:SpecularBasicMethod; + + private _onShaderInvalidatedDelegate:Function; + + /** + * Creates a new SpecularCompositeMethod object. + * + * @param modulateMethod The method which will add the code to alter the base method's strength. It needs to have the signature modSpecular(t:ShaderRegisterElement, regCache:ShaderRegisterCache):string, in which t.w will contain the specular strength and t.xyz will contain the half-vector or the reflection vector. + * @param baseMethod The base specular method on which this method's shading is based. + */ + constructor(modulateMethod:(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => string, baseMethod:SpecularBasicMethod = null) + { + super(); + + this._onShaderInvalidatedDelegate = (event:ShadingMethodEvent) => this.onShaderInvalidated(event); + + this._baseMethod = baseMethod || new SpecularBasicMethod(); + this._baseMethod._iModulateMethod = modulateMethod; + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + } + + /** + * @inheritDoc + */ + public iInitVO(shaderObject:ShaderLightingObject, methodVO:MethodVO) + { + this._baseMethod.iInitVO(shaderObject, methodVO); + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + this._baseMethod.iInitConstants(shaderObject, methodVO); + } + + /** + * The base specular method on which this method's shading is based. + */ + public get baseMethod():SpecularBasicMethod + { + return this._baseMethod; + } + + public set baseMethod(value:SpecularBasicMethod) + { + if (this._baseMethod == value) + return; + + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + + this._baseMethod = value; + + this._baseMethod.addEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + + this.iInvalidateShaderProgram(); + } + + /** + * @inheritDoc + */ + public get gloss():number + { + return this._baseMethod.gloss; + } + + public set gloss(value:number) + { + this._baseMethod.gloss = value; + } + + /** + * @inheritDoc + */ + public get specular():number + { + return this._baseMethod.specular; + } + + public set specular(value:number) + { + this._baseMethod.specular = value; + } + + /** + * @inheritDoc + */ + public get passes():Array + { + return this._baseMethod.passes; + } + + /** + * @inheritDoc + */ + public dispose() + { + this._baseMethod.removeEventListener(ShadingMethodEvent.SHADER_INVALIDATED, this._onShaderInvalidatedDelegate); + this._baseMethod.dispose(); + } + + /** + * @inheritDoc + */ + public get texture():Texture2DBase + { + return this._baseMethod.texture; + } + + public set texture(value:Texture2DBase) + { + this._baseMethod.texture = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + this._baseMethod.iActivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iSetRenderState(shaderObject:ShaderLightingObject, methodVO:MethodVO, renderable:RenderableBase, stage:Stage, camera:Camera) + { + this._baseMethod.iSetRenderState(shaderObject, methodVO, renderable, stage, camera); + } + + /** + * @inheritDoc + */ + public iDeactivate(shaderObject:ShaderObjectBase, methodVO:MethodVO, stage:Stage) + { + this._baseMethod.iDeactivate(shaderObject, methodVO, stage); + } + + /** + * @inheritDoc + */ + public iGetVertexCode(shaderObject:ShaderObjectBase, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this._baseMethod.iGetVertexCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this._baseMethod.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this._baseMethod.iGetFragmentCodePerLight(shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + * @return + */ + public iGetFragmentCodePerProbe(shaderObject:ShaderLightingObject, methodVO:MethodVO, cubeMapReg:ShaderRegisterElement, weightRegister:string, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this._baseMethod.iGetFragmentCodePerProbe(shaderObject, methodVO, cubeMapReg, weightRegister, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iGetFragmentPostLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + return this._baseMethod.iGetFragmentPostLightingCode(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + } + + /** + * @inheritDoc + */ + public iReset() + { + this._baseMethod.iReset(); + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._baseMethod.iCleanCompilationData(); + } + + /** + * Called when the base method's shader code is invalidated. + */ + private onShaderInvalidated(event:ShadingMethodEvent) + { + this.iInvalidateShaderProgram(); + } +} + +export = SpecularCompositeMethod; \ No newline at end of file diff --git a/lib/materials/methods/SpecularFresnelMethod.js b/lib/materials/methods/SpecularFresnelMethod.js new file mode 100755 index 000000000..8a90fc249 --- /dev/null +++ b/lib/materials/methods/SpecularFresnelMethod.js @@ -0,0 +1,124 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var SpecularCompositeMethod = require("awayjs-renderergl/lib/materials/methods/SpecularCompositeMethod"); +/** + * SpecularFresnelMethod provides a specular shading method that causes stronger highlights on grazing view angles. + */ +var SpecularFresnelMethod = (function (_super) { + __extends(SpecularFresnelMethod, _super); + /** + * Creates a new SpecularFresnelMethod object. + * @param basedOnSurface Defines whether the fresnel effect should be based on the view angle on the surface (if true), or on the angle between the light and the view. + * @param baseMethod The specular method to which the fresnel equation. Defaults to SpecularBasicMethod. + */ + function SpecularFresnelMethod(basedOnSurface, baseMethod) { + var _this = this; + if (basedOnSurface === void 0) { basedOnSurface = true; } + if (baseMethod === void 0) { baseMethod = null; } + // may want to offer diff speculars + _super.call(this, null, baseMethod); + this._fresnelPower = 5; + this._normalReflectance = .028; // default value for skin + this.baseMethod._iModulateMethod = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { return _this.modulateSpecular(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); }; + this._incidentLight = !basedOnSurface; + } + /** + * @inheritDoc + */ + SpecularFresnelMethod.prototype.iInitConstants = function (shaderObject, methodVO) { + var index = methodVO.secondaryFragmentConstantsIndex; + shaderObject.fragmentConstantData[index + 2] = 1; + shaderObject.fragmentConstantData[index + 3] = 0; + }; + Object.defineProperty(SpecularFresnelMethod.prototype, "basedOnSurface", { + /** + * Defines whether the fresnel effect should be based on the view angle on the surface (if true), or on the angle between the light and the view. + */ + get: function () { + return !this._incidentLight; + }, + set: function (value) { + if (this._incidentLight != value) + return; + this._incidentLight = !value; + this.iInvalidateShaderProgram(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SpecularFresnelMethod.prototype, "fresnelPower", { + /** + * The power used in the Fresnel equation. Higher values make the fresnel effect more pronounced. Defaults to 5. + */ + get: function () { + return this._fresnelPower; + }, + set: function (value) { + this._fresnelPower = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SpecularFresnelMethod.prototype.iCleanCompilationData = function () { + _super.prototype.iCleanCompilationData.call(this); + this._dataReg = null; + }; + Object.defineProperty(SpecularFresnelMethod.prototype, "normalReflectance", { + /** + * The minimum amount of reflectance, ie the reflectance when the view direction is normal to the surface or light direction. + */ + get: function () { + return this._normalReflectance; + }, + set: function (value) { + this._normalReflectance = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SpecularFresnelMethod.prototype.iActivate = function (shaderObject, methodVO, stage) { + _super.prototype.iActivate.call(this, shaderObject, methodVO, stage); + var fragmentData = shaderObject.fragmentConstantData; + var index = methodVO.secondaryFragmentConstantsIndex; + fragmentData[index] = this._normalReflectance; + fragmentData[index + 1] = this._fresnelPower; + }; + /** + * @inheritDoc + */ + SpecularFresnelMethod.prototype.iGetFragmentPreLightingCode = function (shaderObject, methodVO, registerCache, sharedRegisters) { + this._dataReg = registerCache.getFreeFragmentConstant(); + console.log('SpecularFresnelMethod', 'iGetFragmentPreLightingCode', this._dataReg); + methodVO.secondaryFragmentConstantsIndex = this._dataReg.index * 4; + return _super.prototype.iGetFragmentPreLightingCode.call(this, shaderObject, methodVO, registerCache, sharedRegisters); + }; + /** + * Applies the fresnel effect to the specular strength. + * + * @param vo The MethodVO object containing the method data for the currently compiled material pass. + * @param target The register containing the specular strength in the "w" component, and the half-vector/reflection vector in "xyz". + * @param regCache The register cache used for the shader compilation. + * @param sharedRegisters The shared registers created by the compiler. + * @return The AGAL fragment code for the method. + */ + SpecularFresnelMethod.prototype.modulateSpecular = function (shaderObject, methodVO, targetReg, registerCache, sharedRegisters) { + var code; + code = "dp3 " + targetReg + ".y, " + sharedRegisters.viewDirFragment + ".xyz, " + (this._incidentLight ? targetReg : sharedRegisters.normalFragment) + ".xyz\n" + "sub " + targetReg + ".y, " + this._dataReg + ".z, " + targetReg + ".y\n" + "pow " + targetReg + ".x, " + targetReg + ".y, " + this._dataReg + ".y\n" + "sub " + targetReg + ".y, " + this._dataReg + ".z, " + targetReg + ".y\n" + "mul " + targetReg + ".y, " + this._dataReg + ".x, " + targetReg + ".y\n" + "add " + targetReg + ".y, " + targetReg + ".x, " + targetReg + ".y\n" + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n"; + console.log('SpecularFresnelMethod', 'modulateSpecular', code); + return code; + }; + return SpecularFresnelMethod; +})(SpecularCompositeMethod); +module.exports = SpecularFresnelMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/specularfresnelmethod.ts"],"names":["SpecularFresnelMethod","SpecularFresnelMethod.constructor","SpecularFresnelMethod.iInitConstants","SpecularFresnelMethod.basedOnSurface","SpecularFresnelMethod.fresnelPower","SpecularFresnelMethod.iCleanCompilationData","SpecularFresnelMethod.normalReflectance","SpecularFresnelMethod.iActivate","SpecularFresnelMethod.iGetFragmentPreLightingCode","SpecularFresnelMethod.modulateSpecular"],"mappings":"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","file":"materials/methods/SpecularFresnelMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport SpecularBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/SpecularBasicMethod\");\n\nimport SpecularCompositeMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/SpecularCompositeMethod\");\n\n/**\n * SpecularFresnelMethod provides a specular shading method that causes stronger highlights on grazing view angles.\n */\nclass SpecularFresnelMethod extends SpecularCompositeMethod\n{\n\tprivate _dataReg:ShaderRegisterElement;\n\tprivate _incidentLight:boolean;\n\tprivate _fresnelPower:number = 5;\n\tprivate _normalReflectance:number = .028; // default value for skin\n\n\t/**\n\t * Creates a new SpecularFresnelMethod object.\n\t * @param basedOnSurface Defines whether the fresnel effect should be based on the view angle on the surface (if true), or on the angle between the light and the view.\n\t * @param baseMethod The specular method to which the fresnel equation. Defaults to SpecularBasicMethod.\n\t */\n\tconstructor(basedOnSurface:boolean = true, baseMethod:SpecularBasicMethod = null)\n\t{\n\t\t// may want to offer diff speculars\n\t\tsuper(null, baseMethod);\n\n\t\tthis.baseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.modulateSpecular(shaderObject, methodVO, targetReg, registerCache, sharedRegisters);\n\n\t\tthis._incidentLight = !basedOnSurface;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO)\n\t{\n\n\t\tvar index:number = methodVO.secondaryFragmentConstantsIndex;\n\t\tshaderObject.fragmentConstantData[index + 2] = 1;\n\t\tshaderObject.fragmentConstantData[index + 3] = 0;\n\t}\n\n\t/**\n\t * Defines whether the fresnel effect should be based on the view angle on the surface (if true), or on the angle between the light and the view.\n\t */\n\tpublic get basedOnSurface():boolean\n\t{\n\t\treturn !this._incidentLight;\n\t}\n\n\tpublic set basedOnSurface(value:boolean)\n\t{\n\t\tif (this._incidentLight != value)\n\t\t\treturn;\n\n\t\tthis._incidentLight = !value;\n\n\t\tthis.iInvalidateShaderProgram();\n\t}\n\n\t/**\n\t * The power used in the Fresnel equation. Higher values make the fresnel effect more pronounced. Defaults to 5.\n\t */\n\tpublic get fresnelPower():number\n\t{\n\t\treturn this._fresnelPower;\n\t}\n\n\tpublic set fresnelPower(value:number)\n\t{\n\t\tthis._fresnelPower = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iCleanCompilationData()\n\t{\n\t\tsuper.iCleanCompilationData();\n\t\tthis._dataReg = null;\n\t}\n\n\t/**\n\t * The minimum amount of reflectance, ie the reflectance when the view direction is normal to the surface or light direction.\n\t */\n\tpublic get normalReflectance():number\n\t{\n\t\treturn this._normalReflectance;\n\t}\n\n\tpublic set normalReflectance(value:number)\n\t{\n\t\tthis._normalReflectance = value;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage)\n\t{\n\t\tsuper.iActivate(shaderObject, methodVO, stage);\n\n\t\tvar fragmentData:Array<number> = shaderObject.fragmentConstantData;\n\n\t\tvar index:number = methodVO.secondaryFragmentConstantsIndex;\n\t\tfragmentData[index] = this._normalReflectance;\n\t\tfragmentData[index + 1] = this._fresnelPower;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tthis._dataReg = registerCache.getFreeFragmentConstant();\n\n\t\tconsole.log('SpecularFresnelMethod', 'iGetFragmentPreLightingCode', this._dataReg);\n\n\t\tmethodVO.secondaryFragmentConstantsIndex = this._dataReg.index*4;\n\n\t\treturn super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters);\n\t}\n\n\t/**\n\t * Applies the fresnel effect to the specular strength.\n\t *\n\t * @param vo The MethodVO object containing the method data for the currently compiled material pass.\n\t * @param target The register containing the specular strength in the \"w\" component, and the half-vector/reflection vector in \"xyz\".\n\t * @param regCache The register cache used for the shader compilation.\n\t * @param sharedRegisters The shared registers created by the compiler.\n\t * @return The AGAL fragment code for the method.\n\t */\n\tprivate modulateSpecular(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string;\n\n\t\tcode = \"dp3 \" + targetReg + \".y, \" + sharedRegisters.viewDirFragment + \".xyz, \" + (this._incidentLight? targetReg : sharedRegisters.normalFragment) + \".xyz\\n\" +   // dot(V, H)\n\t\t\t\"sub \" + targetReg + \".y, \" + this._dataReg + \".z, \" + targetReg + \".y\\n\" +             // base = 1-dot(V, H)\n\t\t\t\"pow \" + targetReg + \".x, \" + targetReg + \".y, \" + this._dataReg + \".y\\n\" +             // exp = pow(base, 5)\n\t\t\t\"sub \" + targetReg + \".y, \" + this._dataReg + \".z, \" + targetReg + \".y\\n\" +             // 1 - exp\n\t\t\t\"mul \" + targetReg + \".y, \" + this._dataReg + \".x, \" + targetReg + \".y\\n\" +             // f0*(1 - exp)\n\t\t\t\"add \" + targetReg + \".y, \" + targetReg + \".x, \" + targetReg + \".y\\n\" +          // exp + f0*(1 - exp)\n\t\t\t\"mul \" + targetReg + \".w, \" + targetReg + \".w, \" + targetReg + \".y\\n\";\n\n\n\t\tconsole.log('SpecularFresnelMethod', 'modulateSpecular', code);\n\n\t\treturn code;\n\t}\n\n}\n\nexport = SpecularFresnelMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/SpecularFresnelMethod.ts b/lib/materials/methods/SpecularFresnelMethod.ts new file mode 100755 index 000000000..848414229 --- /dev/null +++ b/lib/materials/methods/SpecularFresnelMethod.ts @@ -0,0 +1,160 @@ +import Camera = require("awayjs-core/lib/entities/Camera"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); + +import SpecularCompositeMethod = require("awayjs-renderergl/lib/materials/methods/SpecularCompositeMethod"); + +/** + * SpecularFresnelMethod provides a specular shading method that causes stronger highlights on grazing view angles. + */ +class SpecularFresnelMethod extends SpecularCompositeMethod +{ + private _dataReg:ShaderRegisterElement; + private _incidentLight:boolean; + private _fresnelPower:number = 5; + private _normalReflectance:number = .028; // default value for skin + + /** + * Creates a new SpecularFresnelMethod object. + * @param basedOnSurface Defines whether the fresnel effect should be based on the view angle on the surface (if true), or on the angle between the light and the view. + * @param baseMethod The specular method to which the fresnel equation. Defaults to SpecularBasicMethod. + */ + constructor(basedOnSurface:boolean = true, baseMethod:SpecularBasicMethod = null) + { + // may want to offer diff speculars + super(null, baseMethod); + + this.baseMethod._iModulateMethod = (shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData) => this.modulateSpecular(shaderObject, methodVO, targetReg, registerCache, sharedRegisters); + + this._incidentLight = !basedOnSurface; + } + + /** + * @inheritDoc + */ + public iInitConstants(shaderObject:ShaderObjectBase, methodVO:MethodVO) + { + + var index:number = methodVO.secondaryFragmentConstantsIndex; + shaderObject.fragmentConstantData[index + 2] = 1; + shaderObject.fragmentConstantData[index + 3] = 0; + } + + /** + * Defines whether the fresnel effect should be based on the view angle on the surface (if true), or on the angle between the light and the view. + */ + public get basedOnSurface():boolean + { + return !this._incidentLight; + } + + public set basedOnSurface(value:boolean) + { + if (this._incidentLight != value) + return; + + this._incidentLight = !value; + + this.iInvalidateShaderProgram(); + } + + /** + * The power used in the Fresnel equation. Higher values make the fresnel effect more pronounced. Defaults to 5. + */ + public get fresnelPower():number + { + return this._fresnelPower; + } + + public set fresnelPower(value:number) + { + this._fresnelPower = value; + } + + /** + * @inheritDoc + */ + public iCleanCompilationData() + { + super.iCleanCompilationData(); + this._dataReg = null; + } + + /** + * The minimum amount of reflectance, ie the reflectance when the view direction is normal to the surface or light direction. + */ + public get normalReflectance():number + { + return this._normalReflectance; + } + + public set normalReflectance(value:number) + { + this._normalReflectance = value; + } + + /** + * @inheritDoc + */ + public iActivate(shaderObject:ShaderLightingObject, methodVO:MethodVO, stage:Stage) + { + super.iActivate(shaderObject, methodVO, stage); + + var fragmentData:Array = shaderObject.fragmentConstantData; + + var index:number = methodVO.secondaryFragmentConstantsIndex; + fragmentData[index] = this._normalReflectance; + fragmentData[index + 1] = this._fresnelPower; + } + + /** + * @inheritDoc + */ + public iGetFragmentPreLightingCode(shaderObject:ShaderLightingObject, methodVO:MethodVO, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + this._dataReg = registerCache.getFreeFragmentConstant(); + + console.log('SpecularFresnelMethod', 'iGetFragmentPreLightingCode', this._dataReg); + + methodVO.secondaryFragmentConstantsIndex = this._dataReg.index*4; + + return super.iGetFragmentPreLightingCode(shaderObject, methodVO, registerCache, sharedRegisters); + } + + /** + * Applies the fresnel effect to the specular strength. + * + * @param vo The MethodVO object containing the method data for the currently compiled material pass. + * @param target The register containing the specular strength in the "w" component, and the half-vector/reflection vector in "xyz". + * @param regCache The register cache used for the shader compilation. + * @param sharedRegisters The shared registers created by the compiler. + * @return The AGAL fragment code for the method. + */ + private modulateSpecular(shaderObject:ShaderObjectBase, methodVO:MethodVO, targetReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string; + + code = "dp3 " + targetReg + ".y, " + sharedRegisters.viewDirFragment + ".xyz, " + (this._incidentLight? targetReg : sharedRegisters.normalFragment) + ".xyz\n" + // dot(V, H) + "sub " + targetReg + ".y, " + this._dataReg + ".z, " + targetReg + ".y\n" + // base = 1-dot(V, H) + "pow " + targetReg + ".x, " + targetReg + ".y, " + this._dataReg + ".y\n" + // exp = pow(base, 5) + "sub " + targetReg + ".y, " + this._dataReg + ".z, " + targetReg + ".y\n" + // 1 - exp + "mul " + targetReg + ".y, " + this._dataReg + ".x, " + targetReg + ".y\n" + // f0*(1 - exp) + "add " + targetReg + ".y, " + targetReg + ".x, " + targetReg + ".y\n" + // exp + f0*(1 - exp) + "mul " + targetReg + ".w, " + targetReg + ".w, " + targetReg + ".y\n"; + + + console.log('SpecularFresnelMethod', 'modulateSpecular', code); + + return code; + } + +} + +export = SpecularFresnelMethod; \ No newline at end of file diff --git a/lib/materials/methods/SpecularPhongMethod.js b/lib/materials/methods/SpecularPhongMethod.js new file mode 100755 index 000000000..c9244cec4 --- /dev/null +++ b/lib/materials/methods/SpecularPhongMethod.js @@ -0,0 +1,59 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); +/** + * SpecularPhongMethod provides a specular method that provides Phong highlights. + */ +var SpecularPhongMethod = (function (_super) { + __extends(SpecularPhongMethod, _super); + /** + * Creates a new SpecularPhongMethod object. + */ + function SpecularPhongMethod() { + _super.call(this); + } + /** + * @inheritDoc + */ + SpecularPhongMethod.prototype.iGetFragmentCodePerLight = function (shaderObject, methodVO, lightDirReg, lightColReg, registerCache, sharedRegisters) { + var code = ""; + var t; + if (this._pIsFirstLight) { + t = this._pTotalLightColorReg; + } + else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + var viewDirReg = sharedRegisters.viewDirFragment; + var normalReg = sharedRegisters.normalFragment; + // phong model + code += "dp3 " + t + ".w, " + lightDirReg + ", " + normalReg + "\n" + "add " + t + ".w, " + t + ".w, " + t + ".w\n" + "mul " + t + ".xyz, " + normalReg + ", " + t + ".w\n" + "sub " + t + ".xyz, " + t + ", " + lightDirReg + "\n" + "add " + t + ".w, " + t + ".w, " + sharedRegisters.commons + ".w\n" + "sat " + t + ".w, " + t + ".w\n" + "mul " + t + ".xyz, " + t + ", " + t + ".w\n" + "dp3 " + t + ".w, " + t + ", " + viewDirReg + "\n" + "sat " + t + ".w, " + t + ".w\n"; + if (this._pUseTexture) { + // apply gloss modulation from texture + code += "mul " + this._pSpecularTexData + ".w, " + this._pSpecularTexData + ".y, " + this._pSpecularDataRegister + ".w\n" + "pow " + t + ".w, " + t + ".w, " + this._pSpecularTexData + ".w\n"; + } + else + code += "pow " + t + ".w, " + t + ".w, " + this._pSpecularDataRegister + ".w\n"; + // attenuate + if (shaderObject.usesLightFallOff) + code += "mul " + t + ".w, " + t + ".w, " + lightDirReg + ".w\n"; + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters); + code += "mul " + t + ".xyz, " + lightColReg + ".xyz, " + t + ".w\n"; + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + this._pIsFirstLight = false; + return code; + }; + return SpecularPhongMethod; +})(SpecularBasicMethod); +module.exports = SpecularPhongMethod; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/methods/specularphongmethod.ts"],"names":["SpecularPhongMethod","SpecularPhongMethod.constructor","SpecularPhongMethod.iGetFragmentCodePerLight"],"mappings":"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","file":"materials/methods/SpecularPhongMethod.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderLightingObject\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderLightingObject\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport ShaderRegisterElement\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement\");\nimport SpecularBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/SpecularBasicMethod\");\n\n/**\n * SpecularPhongMethod provides a specular method that provides Phong highlights.\n */\nclass SpecularPhongMethod extends SpecularBasicMethod\n{\n\t/**\n\t * Creates a new SpecularPhongMethod object.\n\t */\n\tconstructor()\n\t{\n\t\tsuper();\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\t\tvar t:ShaderRegisterElement;\n\n\t\tif (this._pIsFirstLight) {\n\t\t\tt = this._pTotalLightColorReg;\n\t\t} else {\n\t\t\tt = registerCache.getFreeFragmentVectorTemp();\n\t\t\tregisterCache.addFragmentTempUsages(t, 1);\n\t\t}\n\n\t\tvar viewDirReg:ShaderRegisterElement =sharedRegisters.viewDirFragment;\n\t\tvar normalReg:ShaderRegisterElement =sharedRegisters.normalFragment;\n\n\t\t// phong model\n\t\tcode += \"dp3 \" + t + \".w, \" + lightDirReg + \", \" + normalReg + \"\\n\" + // sca1 = light.normal\n\n\t\t\t//find the reflected light vector R\n\t\t\t\"add \" + t + \".w, \" + t + \".w, \" + t + \".w\\n\" + // sca1 = sca1*2\n\t\t\t\"mul \" + t + \".xyz, \" + normalReg + \", \" + t + \".w\\n\" + // vec1 = normal*sca1\n\t\t\t\"sub \" + t + \".xyz, \" + t + \", \" + lightDirReg + \"\\n\" + // vec1 = vec1 - light (light vector is negative)\n\n\t\t\t//smooth the edge as incidence angle approaches 90\n\t\t\t\"add \" + t + \".w, \" + t + \".w, \" +sharedRegisters.commons + \".w\\n\" + // sca1 = sca1 + smoothtep;\n\t\t\t\"sat \" + t + \".w, \" + t + \".w\\n\" + // sca1 range 0 - 1\n\t\t\t\"mul \" + t + \".xyz, \" + t + \", \" + t + \".w\\n\" + // vec1 = vec1*sca1\n\n\t\t\t//find the dot product between R and V\n\t\t\t\"dp3 \" + t + \".w, \" + t + \", \" + viewDirReg + \"\\n\" + // sca1 = vec1.view\n\t\t\t\"sat \" + t + \".w, \" + t + \".w\\n\";\n\n\t\tif (this._pUseTexture) {\n\t\t\t// apply gloss modulation from texture\n\t\t\tcode += \"mul \" + this._pSpecularTexData + \".w, \" + this._pSpecularTexData + \".y, \" + this._pSpecularDataRegister + \".w\\n\" + \"pow \" + t + \".w, \" + t + \".w, \" + this._pSpecularTexData + \".w\\n\";\n\t\t} else\n\t\t\tcode += \"pow \" + t + \".w, \" + t + \".w, \" + this._pSpecularDataRegister + \".w\\n\";\n\n\t\t// attenuate\n\t\tif (shaderObject.usesLightFallOff)\n\t\t\tcode += \"mul \" + t + \".w, \" + t + \".w, \" + lightDirReg + \".w\\n\";\n\n\t\tif (this._iModulateMethod != null)\n\t\t\tcode += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters);\n\n\t\tcode += \"mul \" + t + \".xyz, \" + lightColReg + \".xyz, \" + t + \".w\\n\";\n\n\t\tif (!this._pIsFirstLight) {\n\t\t\tcode += \"add \" + this._pTotalLightColorReg + \".xyz, \" + this._pTotalLightColorReg + \".xyz, \" + t + \".xyz\\n\";\n\t\t\tregisterCache.removeFragmentTempUsage(t);\n\t\t}\n\n\t\tthis._pIsFirstLight = false;\n\n\t\treturn code;\n\t}\n}\n\nexport = SpecularPhongMethod;"]} \ No newline at end of file diff --git a/lib/materials/methods/SpecularPhongMethod.ts b/lib/materials/methods/SpecularPhongMethod.ts new file mode 100644 index 000000000..f41a05ee9 --- /dev/null +++ b/lib/materials/methods/SpecularPhongMethod.ts @@ -0,0 +1,82 @@ +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderLightingObject = require("awayjs-stagegl/lib/materials/compilation/ShaderLightingObject"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import ShaderRegisterElement = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterElement"); +import SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); + +/** + * SpecularPhongMethod provides a specular method that provides Phong highlights. + */ +class SpecularPhongMethod extends SpecularBasicMethod +{ + /** + * Creates a new SpecularPhongMethod object. + */ + constructor() + { + super(); + } + + /** + * @inheritDoc + */ + public iGetFragmentCodePerLight(shaderObject:ShaderLightingObject, methodVO:MethodVO, lightDirReg:ShaderRegisterElement, lightColReg:ShaderRegisterElement, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + var t:ShaderRegisterElement; + + if (this._pIsFirstLight) { + t = this._pTotalLightColorReg; + } else { + t = registerCache.getFreeFragmentVectorTemp(); + registerCache.addFragmentTempUsages(t, 1); + } + + var viewDirReg:ShaderRegisterElement =sharedRegisters.viewDirFragment; + var normalReg:ShaderRegisterElement =sharedRegisters.normalFragment; + + // phong model + code += "dp3 " + t + ".w, " + lightDirReg + ", " + normalReg + "\n" + // sca1 = light.normal + + //find the reflected light vector R + "add " + t + ".w, " + t + ".w, " + t + ".w\n" + // sca1 = sca1*2 + "mul " + t + ".xyz, " + normalReg + ", " + t + ".w\n" + // vec1 = normal*sca1 + "sub " + t + ".xyz, " + t + ", " + lightDirReg + "\n" + // vec1 = vec1 - light (light vector is negative) + + //smooth the edge as incidence angle approaches 90 + "add " + t + ".w, " + t + ".w, " +sharedRegisters.commons + ".w\n" + // sca1 = sca1 + smoothtep; + "sat " + t + ".w, " + t + ".w\n" + // sca1 range 0 - 1 + "mul " + t + ".xyz, " + t + ", " + t + ".w\n" + // vec1 = vec1*sca1 + + //find the dot product between R and V + "dp3 " + t + ".w, " + t + ", " + viewDirReg + "\n" + // sca1 = vec1.view + "sat " + t + ".w, " + t + ".w\n"; + + if (this._pUseTexture) { + // apply gloss modulation from texture + code += "mul " + this._pSpecularTexData + ".w, " + this._pSpecularTexData + ".y, " + this._pSpecularDataRegister + ".w\n" + "pow " + t + ".w, " + t + ".w, " + this._pSpecularTexData + ".w\n"; + } else + code += "pow " + t + ".w, " + t + ".w, " + this._pSpecularDataRegister + ".w\n"; + + // attenuate + if (shaderObject.usesLightFallOff) + code += "mul " + t + ".w, " + t + ".w, " + lightDirReg + ".w\n"; + + if (this._iModulateMethod != null) + code += this._iModulateMethod(shaderObject, methodVO, t, registerCache, sharedRegisters); + + code += "mul " + t + ".xyz, " + lightColReg + ".xyz, " + t + ".w\n"; + + if (!this._pIsFirstLight) { + code += "add " + this._pTotalLightColorReg + ".xyz, " + this._pTotalLightColorReg + ".xyz, " + t + ".xyz\n"; + registerCache.removeFragmentTempUsage(t); + } + + this._pIsFirstLight = false; + + return code; + } +} + +export = SpecularPhongMethod; \ No newline at end of file diff --git a/lib/materials/passes/SingleObjectDepthPass.js b/lib/materials/passes/SingleObjectDepthPass.js new file mode 100755 index 000000000..44dac4493 --- /dev/null +++ b/lib/materials/passes/SingleObjectDepthPass.js @@ -0,0 +1,164 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var RenderTexture = require("awayjs-core/lib/textures/RenderTexture"); +var ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +var MaterialPassBase = require("awayjs-stagegl/lib/materials/passes/MaterialPassBase"); +/** + * The SingleObjectDepthPass provides a material pass that renders a single object to a depth map from the point + * of view from a light. + */ +var SingleObjectDepthPass = (function (_super) { + __extends(SingleObjectDepthPass, _super); + /** + * Creates a new SingleObjectDepthPass object. + */ + function SingleObjectDepthPass() { + _super.call(this); + this._textureSize = 512; + this._polyOffset = Array(15, 0, 0, 0); + this._projectionTexturesInvalid = true; + //this._pNumUsedStreams = 2; + //this._pNumUsedVertexConstants = 7; + //this._enc = Array(1.0, 255.0, 65025.0, 16581375.0, 1.0/255.0, 1.0/255.0, 1.0/255.0, 0.0); + // + //this._pAnimatableAttributes = Array("va0", "va1"); + //this._pAnimationTargetRegisters = Array("vt0", "vt1"); + } + Object.defineProperty(SingleObjectDepthPass.prototype, "textureSize", { + /** + * The size of the depth map texture to render to. + */ + get: function () { + return this._textureSize; + }, + set: function (value) { + this._textureSize = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SingleObjectDepthPass.prototype, "polyOffset", { + /** + * The amount by which the rendered object will be inflated, to prevent depth map rounding errors. + */ + get: function () { + return this._polyOffset[0]; + }, + set: function (value) { + this._polyOffset[0] = value; + }, + enumerable: true, + configurable: true + }); + /** + * @inheritDoc + */ + SingleObjectDepthPass.prototype.dispose = function () { + if (this._textures) { + for (var key in this._textures) { + var texture = this._textures[key]; + texture.dispose(); + } + this._textures = null; + } + }; + /** + * Updates the projection textures used to contain the depth renders. + */ + SingleObjectDepthPass.prototype.updateProjectionTextures = function () { + if (this._textures) { + for (var key in this._textures) { + var texture = this._textures[key]; + texture.dispose(); + } + } + this._textures = new Object(); + this._projections = new Object(); + this._projectionTexturesInvalid = false; + }; + /** + * @inheritDoc + */ + SingleObjectDepthPass.prototype._iGetVertexCode = function () { + var code; + // offset + code = "mul vt7, vt1, vc4.x \n" + "add vt7, vt7, vt0\n" + "mov vt7.w, vt0.w\n"; + // project + code += "m44 vt2, vt7, vc0\n" + "mov op, vt2\n"; + // perspective divide + code += "div v0, vt2, vt2.w\n"; + return code; + }; + /** + * @inheritDoc + */ + SingleObjectDepthPass.prototype._iGetFragmentCode = function (shaderObject, registerCache, sharedRegisters) { + var code = ""; + // encode float -> rgba + code += "mul ft0, fc0, v0.z\n" + "frc ft0, ft0\n" + "mul ft1, ft0.yzww, fc1\n" + "sub ft0, ft0, ft1\n" + "mov oc, ft0\n"; + return code; + }; + /** + * Gets the depth maps rendered for this object from all lights. + * @param renderable The renderable for which to retrieve the depth maps. + * @param stage3DProxy The Stage3DProxy object currently used for rendering. + * @return A list of depth map textures for all supported lights. + */ + SingleObjectDepthPass.prototype._iGetDepthMap = function (renderable) { + return this._textures[renderable.materialOwner.id]; + }; + /** + * Retrieves the depth map projection maps for all lights. + * @param renderable The renderable for which to retrieve the projection maps. + * @return A list of projection maps for all supported lights. + */ + SingleObjectDepthPass.prototype._iGetProjection = function (renderable) { + return this._projections[renderable.materialOwner.id]; + }; + /** + * @inheritDoc + */ + SingleObjectDepthPass.prototype._iRender = function (pass, renderable, stage, camera, viewProjection) { + var matrix; + var context = stage.context; + var len /*uint*/; + var light; + var lights = this._pLightPicker.allPickedLights; + var rId = renderable.materialOwner.id; + if (!this._textures[rId]) + this._textures[rId] = new RenderTexture(this._textureSize, this._textureSize); + if (!this._projections[rId]) + this._projections[rId] = new Matrix3D(); + len = lights.length; + // local position = enough + light = lights[0]; + matrix = light.iGetObjectProjectionMatrix(renderable.sourceEntity, camera, this._projections[rId]); + context.setRenderTarget(this._textures[rId], true); + context.clear(1.0, 1.0, 1.0); + context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, matrix, true); + context.setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, 0, this._enc, 2); + context.activateBuffer(0, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + context.activateBuffer(1, renderable.getVertexData(TriangleSubGeometry.NORMAL_DATA), renderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT); + context.drawTriangles(context.getIndexBuffer(renderable.getIndexData()), 0, renderable.numTriangles); + }; + /** + * @inheritDoc + */ + SingleObjectDepthPass.prototype._iActivate = function (pass, stage, camera) { + if (this._projectionTexturesInvalid) + this.updateProjectionTextures(); + // never scale + _super.prototype._iActivate.call(this, pass, stage, camera); + stage.context.setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 4, this._polyOffset, 1); + }; + return SingleObjectDepthPass; +})(MaterialPassBase); +module.exports = SingleObjectDepthPass; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/passes/singleobjectdepthpass.ts"],"names":["SingleObjectDepthPass","SingleObjectDepthPass.constructor","SingleObjectDepthPass.textureSize","SingleObjectDepthPass.polyOffset","SingleObjectDepthPass.dispose","SingleObjectDepthPass.updateProjectionTextures","SingleObjectDepthPass._iGetVertexCode","SingleObjectDepthPass._iGetFragmentCode","SingleObjectDepthPass._iGetDepthMap","SingleObjectDepthPass._iGetProjection","SingleObjectDepthPass._iRender","SingleObjectDepthPass._iActivate"],"mappings":"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","file":"materials/passes/SingleObjectDepthPass.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import LightBase\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/LightBase\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\nimport RenderTexture\t\t\t\t\t= require(\"awayjs-core/lib/textures/RenderTexture\");\n\nimport Stage\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/base/Stage\");\nimport MaterialPassData\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/MaterialPassData\");\nimport RenderableBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/pool/RenderableBase\");\nimport ContextGLProgramType\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/ContextGLProgramType\");\nimport IContextStageGL\t\t\t\t\t= require(\"awayjs-stagegl/lib/core/stagegl/IContextStageGL\");\nimport MethodVO\t\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/MethodVO\");\nimport ShaderObjectBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderObjectBase\");\nimport ShaderRegisterCache\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache\");\nimport ShaderRegisterData\t\t\t\t= require(\"awayjs-stagegl/lib/materials/compilation/ShaderRegisterData\");\nimport MaterialPassBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/passes/MaterialPassBase\");\n\n/**\n * The SingleObjectDepthPass provides a material pass that renders a single object to a depth map from the point\n * of view from a light.\n */\nclass SingleObjectDepthPass extends MaterialPassBase\n{\n\tprivate _textures:Object;\n\tprivate _projections:Object;\n\tprivate _textureSize:number /*uint*/ = 512;\n\tprivate _polyOffset:Array<number> = Array<number>(15, 0, 0, 0);\n\tprivate _enc:Array<number>;\n\tprivate _projectionTexturesInvalid:Boolean = true;\n\n\t/**\n\t * The size of the depth map texture to render to.\n\t */\n\tpublic get textureSize():number\n\t{\n\t\treturn this._textureSize;\n\t}\n\n\tpublic set textureSize(value:number)\n\t{\n\t\tthis._textureSize = value;\n\t}\n\n\t/**\n\t * The amount by which the rendered object will be inflated, to prevent depth map rounding errors.\n\t */\n\tpublic get polyOffset():number\n\t{\n\t\treturn this._polyOffset[0];\n\t}\n\n\tpublic set polyOffset(value:number)\n\t{\n\t\tthis._polyOffset[0] = value;\n\t}\n\n\t/**\n\t * Creates a new SingleObjectDepthPass object.\n\t */\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\t//this._pNumUsedStreams = 2;\n\t\t//this._pNumUsedVertexConstants = 7;\n\t\t//this._enc = Array<number>(1.0, 255.0, 65025.0, 16581375.0, 1.0/255.0, 1.0/255.0, 1.0/255.0, 0.0);\n\t\t//\n\t\t//this._pAnimatableAttributes = Array<string>(\"va0\", \"va1\");\n\t\t//this._pAnimationTargetRegisters = Array<string>(\"vt0\", \"vt1\");\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic dispose()\n\t{\n\t\tif (this._textures) {\n\t\t\tfor (var key in this._textures) {\n\t\t\t\tvar texture:RenderTexture = this._textures[key];\n\t\t\t\ttexture.dispose();\n\t\t\t}\n\t\t\tthis._textures = null;\n\t\t}\n\t}\n\n\t/**\n\t * Updates the projection textures used to contain the depth renders.\n\t */\n\tprivate updateProjectionTextures()\n\t{\n\t\tif (this._textures) {\n\t\t\tfor (var key in this._textures) {\n\t\t\t\tvar texture:RenderTexture = this._textures[key];\n\t\t\t\ttexture.dispose();\n\t\t\t}\n\t\t}\n\n\t\tthis._textures = new Object();\n\t\tthis._projections = new Object();\n\t\tthis._projectionTexturesInvalid = false;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGetVertexCode():string\n\t{\n\t\tvar code:string;\n\t\t// offset\n\t\tcode = \"mul vt7, vt1, vc4.x\t\\n\" +\n\t\t\t\t\"add vt7, vt7, vt0\\n\" +\n\t\t\t\t\"mov vt7.w, vt0.w\\n\";\n\t\t// project\n\t\tcode += \"m44 vt2, vt7, vc0\\n\" +\n\t\t\t\t\"mov op, vt2\\n\";\n\n\t\t// perspective divide\n\t\tcode += \"div v0, vt2, vt2.w\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iGetFragmentCode(shaderObject:ShaderObjectBase, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string\n\t{\n\t\tvar code:string = \"\";\n\n\t\t// encode float -> rgba\n\t\tcode += \"mul ft0, fc0, v0.z\\n\" +\n\t\t\t\t\"frc ft0, ft0\\n\" +\n\t\t\t\t\"mul ft1, ft0.yzww, fc1\\n\" +\n\t\t\t\t\"sub ft0, ft0, ft1\\n\" +\n\t\t\t\t\"mov oc, ft0\\n\";\n\n\t\treturn code;\n\t}\n\n\t/**\n\t * Gets the depth maps rendered for this object from all lights.\n\t * @param renderable The renderable for which to retrieve the depth maps.\n\t * @param stage3DProxy The Stage3DProxy object currently used for rendering.\n\t * @return A list of depth map textures for all supported lights.\n\t */\n\tpublic _iGetDepthMap(renderable:RenderableBase):RenderTexture\n\t{\n\t\treturn this._textures[renderable.materialOwner.id];\n\t}\n\n\t/**\n\t * Retrieves the depth map projection maps for all lights.\n\t * @param renderable The renderable for which to retrieve the projection maps.\n\t * @return A list of projection maps for all supported lights.\n\t */\n\tpublic _iGetProjection(renderable:RenderableBase):Matrix3D\n\t{\n\t\treturn this._projections[renderable.materialOwner.id];\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iRender(pass:MaterialPassData, renderable:RenderableBase, stage:Stage, camera:Camera, viewProjection:Matrix3D)\n\t{\n\t\tvar matrix:Matrix3D;\n\t\tvar context:IContextStageGL = <IContextStageGL> stage.context;\n\t\tvar len:number /*uint*/;\n\t\tvar light:LightBase;\n\t\tvar lights:Array<LightBase> = this._pLightPicker.allPickedLights;\n\t\tvar rId:number = renderable.materialOwner.id;\n\n\t\tif (!this._textures[rId])\n\t\t\tthis._textures[rId] = new RenderTexture(this._textureSize, this._textureSize);\n\n\t\tif (!this._projections[rId])\n\t\t\tthis._projections[rId] = new Matrix3D();\n\n\t\tlen = lights.length;\n\n\t\t// local position = enough\n\t\tlight = lights[0];\n\n\t\tmatrix = light.iGetObjectProjectionMatrix(renderable.sourceEntity, camera, this._projections[rId]);\n\n\t\tcontext.setRenderTarget(this._textures[rId], true);\n\t\tcontext.clear(1.0, 1.0, 1.0);\n\t\tcontext.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, matrix, true);\n\t\tcontext.setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, 0, this._enc, 2);\n\n\t\tcontext.activateBuffer(0, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT);\n\t\tcontext.activateBuffer(1, renderable.getVertexData(TriangleSubGeometry.NORMAL_DATA), renderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT);\n\t\tcontext.drawTriangles(context.getIndexBuffer(renderable.getIndexData()), 0, renderable.numTriangles);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iActivate(pass:MaterialPassData, stage:Stage, camera:Camera)\n\t{\n\t\tif (this._projectionTexturesInvalid)\n\t\t\tthis.updateProjectionTextures();\n\n\t\t// never scale\n\t\tsuper._iActivate(pass, stage, camera);\n\n\t\t(<IContextStageGL> stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 4, this._polyOffset, 1);\n\t}\n}\n\nexport = SingleObjectDepthPass;"]} \ No newline at end of file diff --git a/lib/materials/passes/SingleObjectDepthPass.ts b/lib/materials/passes/SingleObjectDepthPass.ts new file mode 100644 index 000000000..62006f4ea --- /dev/null +++ b/lib/materials/passes/SingleObjectDepthPass.ts @@ -0,0 +1,212 @@ +import LightBase = require("awayjs-core/lib/core/base/LightBase"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Camera = require("awayjs-core/lib/entities/Camera"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); +import RenderTexture = require("awayjs-core/lib/textures/RenderTexture"); + +import Stage = require("awayjs-stagegl/lib/core/base/Stage"); +import MaterialPassData = require("awayjs-stagegl/lib/core/pool/MaterialPassData"); +import RenderableBase = require("awayjs-stagegl/lib/core/pool/RenderableBase"); +import ContextGLProgramType = require("awayjs-stagegl/lib/core/stagegl/ContextGLProgramType"); +import IContextStageGL = require("awayjs-stagegl/lib/core/stagegl/IContextStageGL"); +import MethodVO = require("awayjs-stagegl/lib/materials/compilation/MethodVO"); +import ShaderObjectBase = require("awayjs-stagegl/lib/materials/compilation/ShaderObjectBase"); +import ShaderRegisterCache = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterCache"); +import ShaderRegisterData = require("awayjs-stagegl/lib/materials/compilation/ShaderRegisterData"); +import MaterialPassBase = require("awayjs-stagegl/lib/materials/passes/MaterialPassBase"); + +/** + * The SingleObjectDepthPass provides a material pass that renders a single object to a depth map from the point + * of view from a light. + */ +class SingleObjectDepthPass extends MaterialPassBase +{ + private _textures:Object; + private _projections:Object; + private _textureSize:number /*uint*/ = 512; + private _polyOffset:Array = Array(15, 0, 0, 0); + private _enc:Array; + private _projectionTexturesInvalid:Boolean = true; + + /** + * The size of the depth map texture to render to. + */ + public get textureSize():number + { + return this._textureSize; + } + + public set textureSize(value:number) + { + this._textureSize = value; + } + + /** + * The amount by which the rendered object will be inflated, to prevent depth map rounding errors. + */ + public get polyOffset():number + { + return this._polyOffset[0]; + } + + public set polyOffset(value:number) + { + this._polyOffset[0] = value; + } + + /** + * Creates a new SingleObjectDepthPass object. + */ + constructor() + { + super(); + + //this._pNumUsedStreams = 2; + //this._pNumUsedVertexConstants = 7; + //this._enc = Array(1.0, 255.0, 65025.0, 16581375.0, 1.0/255.0, 1.0/255.0, 1.0/255.0, 0.0); + // + //this._pAnimatableAttributes = Array("va0", "va1"); + //this._pAnimationTargetRegisters = Array("vt0", "vt1"); + } + + /** + * @inheritDoc + */ + public dispose() + { + if (this._textures) { + for (var key in this._textures) { + var texture:RenderTexture = this._textures[key]; + texture.dispose(); + } + this._textures = null; + } + } + + /** + * Updates the projection textures used to contain the depth renders. + */ + private updateProjectionTextures() + { + if (this._textures) { + for (var key in this._textures) { + var texture:RenderTexture = this._textures[key]; + texture.dispose(); + } + } + + this._textures = new Object(); + this._projections = new Object(); + this._projectionTexturesInvalid = false; + } + + /** + * @inheritDoc + */ + public _iGetVertexCode():string + { + var code:string; + // offset + code = "mul vt7, vt1, vc4.x \n" + + "add vt7, vt7, vt0\n" + + "mov vt7.w, vt0.w\n"; + // project + code += "m44 vt2, vt7, vc0\n" + + "mov op, vt2\n"; + + // perspective divide + code += "div v0, vt2, vt2.w\n"; + + return code; + } + + /** + * @inheritDoc + */ + public _iGetFragmentCode(shaderObject:ShaderObjectBase, registerCache:ShaderRegisterCache, sharedRegisters:ShaderRegisterData):string + { + var code:string = ""; + + // encode float -> rgba + code += "mul ft0, fc0, v0.z\n" + + "frc ft0, ft0\n" + + "mul ft1, ft0.yzww, fc1\n" + + "sub ft0, ft0, ft1\n" + + "mov oc, ft0\n"; + + return code; + } + + /** + * Gets the depth maps rendered for this object from all lights. + * @param renderable The renderable for which to retrieve the depth maps. + * @param stage3DProxy The Stage3DProxy object currently used for rendering. + * @return A list of depth map textures for all supported lights. + */ + public _iGetDepthMap(renderable:RenderableBase):RenderTexture + { + return this._textures[renderable.materialOwner.id]; + } + + /** + * Retrieves the depth map projection maps for all lights. + * @param renderable The renderable for which to retrieve the projection maps. + * @return A list of projection maps for all supported lights. + */ + public _iGetProjection(renderable:RenderableBase):Matrix3D + { + return this._projections[renderable.materialOwner.id]; + } + + /** + * @inheritDoc + */ + public _iRender(pass:MaterialPassData, renderable:RenderableBase, stage:Stage, camera:Camera, viewProjection:Matrix3D) + { + var matrix:Matrix3D; + var context:IContextStageGL = stage.context; + var len:number /*uint*/; + var light:LightBase; + var lights:Array = this._pLightPicker.allPickedLights; + var rId:number = renderable.materialOwner.id; + + if (!this._textures[rId]) + this._textures[rId] = new RenderTexture(this._textureSize, this._textureSize); + + if (!this._projections[rId]) + this._projections[rId] = new Matrix3D(); + + len = lights.length; + + // local position = enough + light = lights[0]; + + matrix = light.iGetObjectProjectionMatrix(renderable.sourceEntity, camera, this._projections[rId]); + + context.setRenderTarget(this._textures[rId], true); + context.clear(1.0, 1.0, 1.0); + context.setProgramConstantsFromMatrix(ContextGLProgramType.VERTEX, 0, matrix, true); + context.setProgramConstantsFromArray(ContextGLProgramType.FRAGMENT, 0, this._enc, 2); + + context.activateBuffer(0, renderable.getVertexData(TriangleSubGeometry.POSITION_DATA), renderable.getVertexOffset(TriangleSubGeometry.POSITION_DATA), TriangleSubGeometry.POSITION_FORMAT); + context.activateBuffer(1, renderable.getVertexData(TriangleSubGeometry.NORMAL_DATA), renderable.getVertexOffset(TriangleSubGeometry.NORMAL_DATA), TriangleSubGeometry.NORMAL_FORMAT); + context.drawTriangles(context.getIndexBuffer(renderable.getIndexData()), 0, renderable.numTriangles); + } + + /** + * @inheritDoc + */ + public _iActivate(pass:MaterialPassData, stage:Stage, camera:Camera) + { + if (this._projectionTexturesInvalid) + this.updateProjectionTextures(); + + // never scale + super._iActivate(pass, stage, camera); + + ( stage.context).setProgramConstantsFromArray(ContextGLProgramType.VERTEX, 4, this._polyOffset, 1); + } +} + +export = SingleObjectDepthPass; \ No newline at end of file diff --git a/lib/parsers/AWDParser.js b/lib/parsers/AWDParser.js new file mode 100755 index 000000000..22d460026 --- /dev/null +++ b/lib/parsers/AWDParser.js @@ -0,0 +1,2202 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +var BlendMode = require("awayjs-core/lib/core/base/BlendMode"); +var Geometry = require("awayjs-core/lib/core/base/Geometry"); +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +var PointLight = require("awayjs-core/lib/entities/PointLight"); +var Camera = require("awayjs-core/lib/entities/Camera"); +var Mesh = require("awayjs-core/lib/entities/Mesh"); +var Skybox = require("awayjs-core/lib/entities/Skybox"); +var StaticLightPicker = require("awayjs-core/lib/materials/lightpickers/StaticLightPicker"); +var CubeMapShadowMapper = require("awayjs-core/lib/materials/shadowmappers/CubeMapShadowMapper"); +var DirectionalShadowMapper = require("awayjs-core/lib/materials/shadowmappers/DirectionalShadowMapper"); +var PrefabBase = require("awayjs-core/lib/prefabs/PrefabBase"); +var PrimitiveCapsulePrefab = require("awayjs-core/lib/prefabs/PrimitiveCapsulePrefab"); +var PrimitiveConePrefab = require("awayjs-core/lib/prefabs/PrimitiveConePrefab"); +var PrimitiveCubePrefab = require("awayjs-core/lib/prefabs/PrimitiveCubePrefab"); +var PrimitiveCylinderPrefab = require("awayjs-core/lib/prefabs/PrimitiveCylinderPrefab"); +var PrimitivePlanePrefab = require("awayjs-core/lib/prefabs/PrimitivePlanePrefab"); +var PrimitiveSpherePrefab = require("awayjs-core/lib/prefabs/PrimitiveSpherePrefab"); +var PrimitiveTorusPrefab = require("awayjs-core/lib/prefabs/PrimitiveTorusPrefab"); +var ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +var ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +var PerspectiveProjection = require("awayjs-core/lib/projections/PerspectiveProjection"); +var OrthographicProjection = require("awayjs-core/lib/projections/OrthographicProjection"); +var OrthographicOffCenterProjection = require("awayjs-core/lib/projections/OrthographicOffCenterProjection"); +var BitmapCubeTexture = require("awayjs-core/lib/textures/BitmapCubeTexture"); +var ImageCubeTexture = require("awayjs-core/lib/textures/ImageCubeTexture"); +var ImageTexture = require("awayjs-core/lib/textures/ImageTexture"); +var ByteArray = require("awayjs-core/lib/utils/ByteArray"); +var SkyboxMaterial = require("awayjs-stagegl/lib/materials/SkyboxMaterial"); +var TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); +var TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +var DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); +var VertexAnimationSet = require("awayjs-renderergl/lib/animators/VertexAnimationSet"); +var VertexAnimator = require("awayjs-renderergl/lib/animators/VertexAnimator"); +var SkeletonAnimationSet = require("awayjs-renderergl/lib/animators/SkeletonAnimationSet"); +var SkeletonAnimator = require("awayjs-renderergl/lib/animators/SkeletonAnimator"); +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var SkeletonJoint = require("awayjs-renderergl/lib/animators/data/SkeletonJoint"); +var SkeletonClipNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonClipNode"); +var VertexClipNode = require("awayjs-renderergl/lib/animators/nodes/VertexClipNode"); +var AmbientEnvMapMethod = require("awayjs-renderergl/lib/materials/methods/AmbientEnvMapMethod"); +var DiffuseDepthMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseDepthMethod"); +var DiffuseCelMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCelMethod"); +var DiffuseGradientMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseGradientMethod"); +var DiffuseLightMapMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseLightMapMethod"); +var DiffuseWrapMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseWrapMethod"); +var EffectAlphaMaskMethod = require("awayjs-renderergl/lib/materials/methods/EffectAlphaMaskMethod"); +var EffectColorMatrixMethod = require("awayjs-renderergl/lib/materials/methods/EffectColorMatrixMethod"); +var EffectColorTransformMethod = require("awayjs-stagegl/lib/materials/methods/EffectColorTransformMethod"); +var EffectEnvMapMethod = require("awayjs-renderergl/lib/materials/methods/EffectEnvMapMethod"); +var EffectFogMethod = require("awayjs-renderergl/lib/materials/methods/EffectFogMethod"); +var EffectFresnelEnvMapMethod = require("awayjs-renderergl/lib/materials/methods/EffectFresnelEnvMapMethod"); +var EffectLightMapMethod = require("awayjs-renderergl/lib/materials/methods/EffectLightMapMethod"); +var EffectRimLightMethod = require("awayjs-renderergl/lib/materials/methods/EffectRimLightMethod"); +var NormalSimpleWaterMethod = require("awayjs-renderergl/lib/materials/methods/NormalSimpleWaterMethod"); +var ShadowDitheredMethod = require("awayjs-renderergl/lib/materials/methods/ShadowDitheredMethod"); +var ShadowFilteredMethod = require("awayjs-renderergl/lib/materials/methods/ShadowFilteredMethod"); +var SpecularFresnelMethod = require("awayjs-renderergl/lib/materials/methods/SpecularFresnelMethod"); +var ShadowHardMethod = require("awayjs-stagegl/lib/materials/methods/ShadowHardMethod"); +var SpecularAnisotropicMethod = require("awayjs-renderergl/lib/materials/methods/SpecularAnisotropicMethod"); +var SpecularCelMethod = require("awayjs-renderergl/lib/materials/methods/SpecularCelMethod"); +var SpecularPhongMethod = require("awayjs-renderergl/lib/materials/methods/SpecularPhongMethod"); +var ShadowNearMethod = require("awayjs-renderergl/lib/materials/methods/ShadowNearMethod"); +var ShadowSoftMethod = require("awayjs-renderergl/lib/materials/methods/ShadowSoftMethod"); +var AWDBlock = require("awayjs-renderergl/lib/parsers/data/AWDBlock"); +var AWDProperties = require("awayjs-renderergl/lib/parsers/data/AWDProperties"); +var BitFlags = require("awayjs-renderergl/lib/parsers/data/BitFlags"); +/** + * AWDParser provides a parser for the AWD data type. + */ +var AWDParser = (function (_super) { + __extends(AWDParser, _super); + /** + * Creates a new AWDParser object. + * @param uri The url or id of the data or file to be parsed. + * @param extra The holder for extra contextual data that the parser might need. + */ + function AWDParser() { + _super.call(this, URLLoaderDataFormat.ARRAY_BUFFER); + //set to "true" to have some console.logs in the Console + this._debug = false; + this._startedParsing = false; + this._texture_users = {}; + this._parsed_header = false; + this._blocks = new Array(); + this._blocks[0] = new AWDBlock(); + this._blocks[0].data = null; // Zero address means null in AWD + this.blendModeDic = new Array(); // used to translate ints to blendMode-strings + this.blendModeDic.push(BlendMode.NORMAL); + this.blendModeDic.push(BlendMode.ADD); + this.blendModeDic.push(BlendMode.ALPHA); + this.blendModeDic.push(BlendMode.DARKEN); + this.blendModeDic.push(BlendMode.DIFFERENCE); + this.blendModeDic.push(BlendMode.ERASE); + this.blendModeDic.push(BlendMode.HARDLIGHT); + this.blendModeDic.push(BlendMode.INVERT); + this.blendModeDic.push(BlendMode.LAYER); + this.blendModeDic.push(BlendMode.LIGHTEN); + this.blendModeDic.push(BlendMode.MULTIPLY); + this.blendModeDic.push(BlendMode.NORMAL); + this.blendModeDic.push(BlendMode.OVERLAY); + this.blendModeDic.push(BlendMode.SCREEN); + this.blendModeDic.push(BlendMode.SHADER); + this.blendModeDic.push(BlendMode.OVERLAY); + this._depthSizeDic = new Array(); // used to translate ints to depthSize-values + this._depthSizeDic.push(256); + this._depthSizeDic.push(512); + this._depthSizeDic.push(2048); + this._depthSizeDic.push(1024); + this._version = Array(); // will contain 2 int (major-version, minor-version) for awd-version-check + } + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + AWDParser.supportsType = function (extension) { + extension = extension.toLowerCase(); + return extension == "awd"; + }; + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + AWDParser.supportsData = function (data) { + return (ParserUtils.toString(data, 3) == 'AWD'); + }; + /** + * @inheritDoc + */ + AWDParser.prototype._iResolveDependency = function (resourceDependency) { + // this will be called when Dependency has finished loading. + // the Assets waiting for this Bitmap, can be Texture or CubeTexture. + // if the Bitmap is awaited by a CubeTexture, we need to check if its the last Bitmap of the CubeTexture, + // so we know if we have to finalize the Asset (CubeTexture) or not. + if (resourceDependency.assets.length == 1) { + var isCubeTextureArray = resourceDependency.id.split("#"); + var ressourceID = isCubeTextureArray[0]; + var asset; + var thisBitmapTexture; + var block; + if (isCubeTextureArray.length == 1) { + asset = resourceDependency.assets[0]; + if (asset) { + var mat; + var users; + block = this._blocks[resourceDependency.id]; + block.data = asset; // Store finished asset + // Reset name of texture to the one defined in the AWD file, + // as opposed to whatever the image parser came up with. + asset.resetAssetPath(block.name, null, true); + block.name = asset.name; + // Finalize texture asset to dispatch texture event, which was + // previously suppressed while the dependency was loaded. + this._pFinalizeAsset(asset); + if (this._debug) { + console.log("Successfully loaded Bitmap for texture"); + console.log("Parsed texture: Name = " + block.name); + } + } + } + if (isCubeTextureArray.length > 1) { + thisBitmapTexture = resourceDependency.assets[0]; + var tx = thisBitmapTexture; + this._cubeTextures[isCubeTextureArray[1]] = tx.htmlImageElement; // ? + this._texture_users[ressourceID].push(1); + if (this._debug) { + console.log("Successfully loaded Bitmap " + this._texture_users[ressourceID].length + " / 6 for Cubetexture"); + } + if (this._texture_users[ressourceID].length == this._cubeTextures.length) { + var posX = this._cubeTextures[0]; + var negX = this._cubeTextures[1]; + var posY = this._cubeTextures[2]; + var negY = this._cubeTextures[3]; + var posZ = this._cubeTextures[4]; + var negZ = this._cubeTextures[5]; + asset = new ImageCubeTexture(posX, negX, posY, negY, posZ, negZ); + block = this._blocks[ressourceID]; + block.data = asset; // Store finished asset + // Reset name of texture to the one defined in the AWD file, + // as opposed to whatever the image parser came up with. + asset.resetAssetPath(block.name, null, true); + block.name = asset.name; + // Finalize texture asset to dispatch texture event, which was + // previously suppressed while the dependency was loaded. + this._pFinalizeAsset(asset); + if (this._debug) { + console.log("Parsed CubeTexture: Name = " + block.name); + } + } + } + } + }; + /** + * @inheritDoc + */ + AWDParser.prototype._iResolveDependencyFailure = function (resourceDependency) { + //not used - if a dependcy fails, the awaiting Texture or CubeTexture will never be finalized, and the default-bitmaps will be used. + // this means, that if one Bitmap of a CubeTexture fails, the CubeTexture will have the DefaultTexture applied for all six Bitmaps. + }; + /** + * Resolve a dependency name + * + * @param resourceDependency The dependency to be resolved. + */ + AWDParser.prototype._iResolveDependencyName = function (resourceDependency, asset) { + var oldName = asset.name; + if (asset) { + var block = this._blocks[parseInt(resourceDependency.id)]; + // Reset name of texture to the one defined in the AWD file, + // as opposed to whatever the image parser came up with. + asset.resetAssetPath(block.name, null, true); + } + var newName = asset.name; + asset.name = oldName; + return newName; + }; + /** + * @inheritDoc + */ + AWDParser.prototype._pProceedParsing = function () { + if (!this._startedParsing) { + this._byteData = this._pGetByteData(); //getByteData(); + this._startedParsing = true; + } + if (!this._parsed_header) { + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._byteData.endian = Endian.LITTLE_ENDIAN; + //---------------------------------------------------------------------------- + //---------------------------------------------------------------------------- + // Parse header and decompress body if needed + this.parseHeader(); + switch (this._compression) { + case AWDParser.DEFLATE: + case AWDParser.LZMA: + this._pDieWithError('Compressed AWD formats not yet supported'); + break; + case AWDParser.UNCOMPRESSED: + this._body = this._byteData; + break; + } + this._parsed_header = true; + } + if (this._body) { + while (this._body.getBytesAvailable() > 0 && !this.parsingPaused) { + this.parseNextBlock(); + } + //---------------------------------------------------------------------------- + // Return complete status + if (this._body.getBytesAvailable() == 0) { + this.dispose(); + return ParserBase.PARSING_DONE; + } + else { + return ParserBase.MORE_TO_PARSE; + } + } + else { + switch (this._compression) { + case AWDParser.DEFLATE: + case AWDParser.LZMA: + if (this._debug) { + console.log("(!) AWDParser Error: Compressed AWD formats not yet supported (!)"); + } + break; + } + // Error - most likely _body not set because we do not support compression. + return ParserBase.PARSING_DONE; + } + }; + AWDParser.prototype._pStartParsing = function (frameLimit) { + _super.prototype._pStartParsing.call(this, frameLimit); + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + }; + AWDParser.prototype.dispose = function () { + for (var c in this._blocks) { + var b = this._blocks[c]; + b.dispose(); + } + }; + AWDParser.prototype.parseNextBlock = function () { + var block; + var assetData; + var isParsed = false; + var ns; + var type; + var flags; + var len; + this._cur_block_id = this._body.readUnsignedInt(); + ns = this._body.readUnsignedByte(); + type = this._body.readUnsignedByte(); + flags = this._body.readUnsignedByte(); + len = this._body.readUnsignedInt(); + var blockCompression = BitFlags.test(flags, BitFlags.FLAG4); + var blockCompressionLZMA = BitFlags.test(flags, BitFlags.FLAG5); + if (this._accuracyOnBlocks) { + this._accuracyMatrix = BitFlags.test(flags, BitFlags.FLAG1); + this._accuracyGeo = BitFlags.test(flags, BitFlags.FLAG2); + this._accuracyProps = BitFlags.test(flags, BitFlags.FLAG3); + this._geoNrType = AWDParser.FLOAT32; + if (this._accuracyGeo) { + this._geoNrType = AWDParser.FLOAT64; + } + this._matrixNrType = AWDParser.FLOAT32; + if (this._accuracyMatrix) { + this._matrixNrType = AWDParser.FLOAT64; + } + this._propsNrType = AWDParser.FLOAT32; + if (this._accuracyProps) { + this._propsNrType = AWDParser.FLOAT64; + } + } + var blockEndAll = this._body.position + len; + if (len > this._body.getBytesAvailable()) { + this._pDieWithError('AWD2 block length is bigger than the bytes that are available!'); + this._body.position += this._body.getBytesAvailable(); + return; + } + this._newBlockBytes = new ByteArray(); + this._body.readBytes(this._newBlockBytes, 0, len); + //---------------------------------------------------------------------------- + // Compressed AWD Formats not yet supported + if (blockCompression) { + this._pDieWithError('Compressed AWD formats not yet supported'); + } + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._newBlockBytes.endian = Endian.LITTLE_ENDIAN; + //---------------------------------------------------------------------------- + this._newBlockBytes.position = 0; + block = new AWDBlock(); + block.len = this._newBlockBytes.position + len; + block.id = this._cur_block_id; + var blockEndBlock = this._newBlockBytes.position + len; + if (blockCompression) { + this._pDieWithError('Compressed AWD formats not yet supported'); + } + if (this._debug) { + console.log("AWDBlock: ID = " + this._cur_block_id + " | TypeID = " + type + " | Compression = " + blockCompression + " | Matrix-Precision = " + this._accuracyMatrix + " | Geometry-Precision = " + this._accuracyGeo + " | Properties-Precision = " + this._accuracyProps); + } + this._blocks[this._cur_block_id] = block; + if ((this._version[0] == 2) && (this._version[1] == 1)) { + switch (type) { + case 11: + this.parsePrimitves(this._cur_block_id); + isParsed = true; + break; + case 31: + this.parseSkyboxInstance(this._cur_block_id); + isParsed = true; + break; + case 41: + this.parseLight(this._cur_block_id); + isParsed = true; + break; + case 42: + this.parseCamera(this._cur_block_id); + isParsed = true; + break; + case 51: + this.parseLightPicker(this._cur_block_id); + isParsed = true; + break; + case 81: + this.parseMaterial_v1(this._cur_block_id); + isParsed = true; + break; + case 83: + this.parseCubeTexture(this._cur_block_id); + isParsed = true; + break; + case 91: + this.parseSharedMethodBlock(this._cur_block_id); + isParsed = true; + break; + case 92: + this.parseShadowMethodBlock(this._cur_block_id); + isParsed = true; + break; + case 111: + this.parseMeshPoseAnimation(this._cur_block_id, true); + isParsed = true; + break; + case 112: + this.parseMeshPoseAnimation(this._cur_block_id); + isParsed = true; + break; + case 113: + this.parseVertexAnimationSet(this._cur_block_id); + isParsed = true; + break; + case 122: + this.parseAnimatorSet(this._cur_block_id); + isParsed = true; + break; + case 253: + this.parseCommand(this._cur_block_id); + isParsed = true; + break; + } + } + //* + if (isParsed == false) { + switch (type) { + case 1: + this.parseTriangleGeometrieBlock(this._cur_block_id); + break; + case 22: + this.parseContainer(this._cur_block_id); + break; + case 23: + this.parseMeshInstance(this._cur_block_id); + break; + case 81: + this.parseMaterial(this._cur_block_id); + break; + case 82: + this.parseTexture(this._cur_block_id); + break; + case 101: + this.parseSkeleton(this._cur_block_id); + break; + case 102: + this.parseSkeletonPose(this._cur_block_id); + break; + case 103: + this.parseSkeletonAnimation(this._cur_block_id); + break; + case 121: + case 254: + this.parseNameSpace(this._cur_block_id); + break; + case 255: + this.parseMetaData(this._cur_block_id); + break; + default: + if (this._debug) { + console.log("AWDBlock: Unknown BlockType (BlockID = " + this._cur_block_id + ") - Skip " + len + " bytes"); + } + this._newBlockBytes.position += len; + break; + } + } + //*/ + var msgCnt = 0; + if (this._newBlockBytes.position == blockEndBlock) { + if (this._debug) { + if (block.errorMessages) { + while (msgCnt < block.errorMessages.length) { + console.log(" (!) Error: " + block.errorMessages[msgCnt] + " (!)"); + msgCnt++; + } + } + } + if (this._debug) { + console.log("\n"); + } + } + else { + if (this._debug) { + console.log(" (!)(!)(!) Error while reading AWDBlock ID " + this._cur_block_id + " = skip to next block"); + if (block.errorMessages) { + while (msgCnt < block.errorMessages.length) { + console.log(" (!) Error: " + block.errorMessages[msgCnt] + " (!)"); + msgCnt++; + } + } + } + } + this._body.position = blockEndAll; + this._newBlockBytes = null; + }; + //--Parser Blocks--------------------------------------------------------------------------- + //Block ID = 1 + AWDParser.prototype.parseTriangleGeometrieBlock = function (blockID) { + var geom = new Geometry(); + // Read name and sub count + var name = this.parseVarStr(); + var num_subs = this._newBlockBytes.readUnsignedShort(); + // Read optional properties + var props = this.parseProperties({ 1: this._geoNrType, 2: this._geoNrType }); + var geoScaleU = props.get(1, 1); + var geoScaleV = props.get(2, 1); + // Loop through sub meshes + var subs_parsed = 0; + while (subs_parsed < num_subs) { + var i; + var sm_len, sm_end; + var sub_geom; + var w_indices; + var weights; + sm_len = this._newBlockBytes.readUnsignedInt(); + sm_end = this._newBlockBytes.position + sm_len; + // Ignore for now + var subProps = this.parseProperties({ 1: this._geoNrType, 2: this._geoNrType }); + while (this._newBlockBytes.position < sm_end) { + var idx = 0; + var str_ftype, str_type, str_len, str_end; + // Type, field type, length + str_type = this._newBlockBytes.readUnsignedByte(); + str_ftype = this._newBlockBytes.readUnsignedByte(); + str_len = this._newBlockBytes.readUnsignedInt(); + str_end = this._newBlockBytes.position + str_len; + var x, y, z; + if (str_type == 1) { + var verts = new Array(); + while (this._newBlockBytes.position < str_end) { + // TODO: Respect stream field type + x = this.readNumber(this._accuracyGeo); + y = this.readNumber(this._accuracyGeo); + z = this.readNumber(this._accuracyGeo); + verts[idx++] = x; + verts[idx++] = y; + verts[idx++] = z; + } + } + else if (str_type == 2) { + var indices = new Array(); + while (this._newBlockBytes.position < str_end) { + // TODO: Respect stream field type + indices[idx++] = this._newBlockBytes.readUnsignedShort(); + } + } + else if (str_type == 3) { + var uvs = new Array(); + while (this._newBlockBytes.position < str_end) { + uvs[idx++] = this.readNumber(this._accuracyGeo); + } + } + else if (str_type == 4) { + var normals = new Array(); + while (this._newBlockBytes.position < str_end) { + normals[idx++] = this.readNumber(this._accuracyGeo); + } + } + else if (str_type == 6) { + w_indices = Array(); + while (this._newBlockBytes.position < str_end) { + w_indices[idx++] = this._newBlockBytes.readUnsignedShort() * 3; // TODO: Respect stream field type + } + } + else if (str_type == 7) { + weights = new Array(); + while (this._newBlockBytes.position < str_end) { + weights[idx++] = this.readNumber(this._accuracyGeo); + } + } + else { + this._newBlockBytes.position = str_end; + } + } + this.parseUserAttributes(); // Ignore sub-mesh attributes for now + sub_geom = new TriangleSubGeometry(true); + if (weights) + sub_geom.jointsPerVertex = weights.length / (verts.length / 3); + if (normals) + sub_geom.autoDeriveNormals = false; + if (uvs) + sub_geom.autoDeriveUVs = false; + sub_geom.updateIndices(indices); + sub_geom.updatePositions(verts); + sub_geom.updateVertexNormals(normals); + sub_geom.updateUVs(uvs); + sub_geom.updateVertexTangents(null); + sub_geom.updateJointWeights(weights); + sub_geom.updateJointIndices(w_indices); + var scaleU = subProps.get(1, 1); + var scaleV = subProps.get(2, 1); + var setSubUVs = false; //this should remain false atm, because in AwayBuilder the uv is only scaled by the geometry + if ((geoScaleU != scaleU) || (geoScaleV != scaleV)) { + setSubUVs = true; + scaleU = geoScaleU / scaleU; + scaleV = geoScaleV / scaleV; + } + if (setSubUVs) + sub_geom.scaleUV(scaleU, scaleV); + geom.addSubGeometry(sub_geom); + // TODO: Somehow map in-sub to out-sub indices to enable look-up + // when creating meshes (and their material assignments.) + subs_parsed++; + } + if ((geoScaleU != 1) || (geoScaleV != 1)) + geom.scaleUV(geoScaleU, geoScaleV); + this.parseUserAttributes(); + this._pFinalizeAsset(geom, name); + this._blocks[blockID].data = geom; + if (this._debug) { + console.log("Parsed a TriangleGeometry: Name = " + name + "| Id = " + sub_geom.id); + } + }; + //Block ID = 11 + AWDParser.prototype.parsePrimitves = function (blockID) { + var name; + var prefab; + var primType; + var subs_parsed; + var props; + var bsm; + // Read name and sub count + name = this.parseVarStr(); + primType = this._newBlockBytes.readUnsignedByte(); + props = this.parseProperties({ 101: this._geoNrType, 102: this._geoNrType, 103: this._geoNrType, 110: this._geoNrType, 111: this._geoNrType, 301: AWDParser.UINT16, 302: AWDParser.UINT16, 303: AWDParser.UINT16, 701: AWDParser.BOOL, 702: AWDParser.BOOL, 703: AWDParser.BOOL, 704: AWDParser.BOOL }); + var primitiveTypes = ["Unsupported Type-ID", "PrimitivePlanePrefab", "PrimitiveCubePrefab", "PrimitiveSpherePrefab", "PrimitiveCylinderPrefab", "PrimitivesConePrefab", "PrimitivesCapsulePrefab", "PrimitivesTorusPrefab"]; + switch (primType) { + case 1: + prefab = new PrimitivePlanePrefab(props.get(101, 100), props.get(102, 100), props.get(301, 1), props.get(302, 1), props.get(701, true), props.get(702, false)); + break; + case 2: + prefab = new PrimitiveCubePrefab(props.get(101, 100), props.get(102, 100), props.get(103, 100), props.get(301, 1), props.get(302, 1), props.get(303, 1), props.get(701, true)); + break; + case 3: + prefab = new PrimitiveSpherePrefab(props.get(101, 50), props.get(301, 16), props.get(302, 12), props.get(701, true)); + break; + case 4: + prefab = new PrimitiveCylinderPrefab(props.get(101, 50), props.get(102, 50), props.get(103, 100), props.get(301, 16), props.get(302, 1), true, true, true); // bool701, bool702, bool703, bool704); + if (!props.get(701, true)) + prefab.topClosed = false; + if (!props.get(702, true)) + prefab.bottomClosed = false; + if (!props.get(703, true)) + prefab.yUp = false; + break; + case 5: + prefab = new PrimitiveConePrefab(props.get(101, 50), props.get(102, 100), props.get(301, 16), props.get(302, 1), props.get(701, true), props.get(702, true)); + break; + case 6: + prefab = new PrimitiveCapsulePrefab(props.get(101, 50), props.get(102, 100), props.get(301, 16), props.get(302, 15), props.get(701, true)); + break; + case 7: + prefab = new PrimitiveTorusPrefab(props.get(101, 50), props.get(102, 50), props.get(301, 16), props.get(302, 8), props.get(701, true)); + break; + default: + prefab = new PrefabBase(); + console.log("ERROR: UNSUPPORTED PREFAB_TYPE"); + break; + } + if ((props.get(110, 1) != 1) || (props.get(111, 1) != 1)) { + } + this.parseUserAttributes(); + prefab.name = name; + this._pFinalizeAsset(prefab, name); + this._blocks[blockID].data = prefab; + if (this._debug) { + if ((primType < 0) || (primType > 7)) { + primType = 0; + } + console.log("Parsed a Primivite: Name = " + name + "| type = " + primitiveTypes[primType]); + } + }; + // Block ID = 22 + AWDParser.prototype.parseContainer = function (blockID) { + var name; + var par_id; + var mtx; + var ctr; + var parent; + par_id = this._newBlockBytes.readUnsignedInt(); + mtx = this.parseMatrix3D(); + name = this.parseVarStr(); + var parentName = "Root (TopLevel)"; + ctr = new DisplayObjectContainer(); + ctr.transform.matrix3D = mtx; + var returnedArray = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]); + if (returnedArray[0]) { + var obj = returnedArray[1].addChild(ctr); + parentName = returnedArray[1].name; + } + else if (par_id > 0) { + this._blocks[blockID].addError("Could not find a parent for this ObjectContainer3D"); + } + else { + //add to the content property + this._pContent.addChild(ctr); + } + // in AWD version 2.1 we read the Container properties + if ((this._version[0] == 2) && (this._version[1] == 1)) { + var props = this.parseProperties({ 1: this._matrixNrType, 2: this._matrixNrType, 3: this._matrixNrType, 4: AWDParser.UINT8 }); + ctr.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + } + else { + this.parseProperties(null); + } + // the extraProperties should only be set for AWD2.1-Files, but is read for both versions + ctr.extra = this.parseUserAttributes(); + this._pFinalizeAsset(ctr, name); + this._blocks[blockID].data = ctr; + if (this._debug) { + console.log("Parsed a Container: Name = '" + name + "' | Parent-Name = " + parentName); + } + }; + // Block ID = 23 + AWDParser.prototype.parseMeshInstance = function (blockID) { + var num_materials; + var materials_parsed; + var parent; + var par_id = this._newBlockBytes.readUnsignedInt(); + var mtx = this.parseMatrix3D(); + var name = this.parseVarStr(); + var parentName = "Root (TopLevel)"; + var data_id = this._newBlockBytes.readUnsignedInt(); + var geom; + var returnedArrayGeometry = this.getAssetByID(data_id, [AssetType.GEOMETRY]); + if (returnedArrayGeometry[0]) { + geom = returnedArrayGeometry[1]; + } + else { + this._blocks[blockID].addError("Could not find a Geometry for this Mesh. A empty Geometry is created!"); + geom = new Geometry(); + } + this._blocks[blockID].geoID = data_id; + var materials = new Array(); + num_materials = this._newBlockBytes.readUnsignedShort(); + var materialNames = new Array(); + materials_parsed = 0; + var returnedArrayMaterial; + while (materials_parsed < num_materials) { + var mat_id; + mat_id = this._newBlockBytes.readUnsignedInt(); + returnedArrayMaterial = this.getAssetByID(mat_id, [AssetType.MATERIAL]); + if ((!returnedArrayMaterial[0]) && (mat_id > 0)) { + this._blocks[blockID].addError("Could not find Material Nr " + materials_parsed + " (ID = " + mat_id + " ) for this Mesh"); + } + var m = returnedArrayMaterial[1]; + materials.push(m); + materialNames.push(m.name); + materials_parsed++; + } + var mesh = new Mesh(geom, null); + mesh.transform.matrix3D = mtx; + var returnedArrayParent = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]); + if (returnedArrayParent[0]) { + var objC = returnedArrayParent[1]; + objC.addChild(mesh); + parentName = objC.name; + } + else if (par_id > 0) { + this._blocks[blockID].addError("Could not find a parent for this Mesh"); + } + else { + //add to the content property + this._pContent.addChild(mesh); + } + if (materials.length >= 1 && mesh.subMeshes.length == 1) { + mesh.material = materials[0]; + } + else if (materials.length > 1) { + var i; + for (i = 0; i < mesh.subMeshes.length; i++) { + mesh.subMeshes[i].material = materials[Math.min(materials.length - 1, i)]; + } + } + if ((this._version[0] == 2) && (this._version[1] == 1)) { + var props = this.parseProperties({ 1: this._matrixNrType, 2: this._matrixNrType, 3: this._matrixNrType, 4: AWDParser.UINT8, 5: AWDParser.BOOL }); + mesh.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + mesh.castsShadows = props.get(5, true); + } + else { + this.parseProperties(null); + } + mesh.extra = this.parseUserAttributes(); + this._pFinalizeAsset(mesh, name); + this._blocks[blockID].data = mesh; + if (this._debug) { + console.log("Parsed a Mesh: Name = '" + name + "' | Parent-Name = " + parentName + "| Geometry-Name = " + geom.name + " | SubMeshes = " + mesh.subMeshes.length + " | Mat-Names = " + materialNames.toString()); + } + }; + //Block ID 31 + AWDParser.prototype.parseSkyboxInstance = function (blockID) { + var name = this.parseVarStr(); + var cubeTexAddr = this._newBlockBytes.readUnsignedInt(); + var returnedArrayCubeTex = this.getAssetByID(cubeTexAddr, [AssetType.TEXTURE], "CubeTexture"); + if ((!returnedArrayCubeTex[0]) && (cubeTexAddr != 0)) + this._blocks[blockID].addError("Could not find the Cubetexture (ID = " + cubeTexAddr + " ) for this Skybox"); + var asset = new Skybox(new SkyboxMaterial(returnedArrayCubeTex[1])); + this.parseProperties(null); + asset.extra = this.parseUserAttributes(); + this._pFinalizeAsset(asset, name); + this._blocks[blockID].data = asset; + if (this._debug) + console.log("Parsed a Skybox: Name = '" + name + "' | CubeTexture-Name = " + returnedArrayCubeTex[1].name); + }; + //Block ID = 41 + AWDParser.prototype.parseLight = function (blockID) { + var light; + var newShadowMapper; + var par_id = this._newBlockBytes.readUnsignedInt(); + var mtx = this.parseMatrix3D(); + var name = this.parseVarStr(); + var lightType = this._newBlockBytes.readUnsignedByte(); + var props = this.parseProperties({ 1: this._propsNrType, 2: this._propsNrType, 3: AWDParser.COLOR, 4: this._propsNrType, 5: this._propsNrType, 6: AWDParser.BOOL, 7: AWDParser.COLOR, 8: this._propsNrType, 9: AWDParser.UINT8, 10: AWDParser.UINT8, 11: this._propsNrType, 12: AWDParser.UINT16, 21: this._matrixNrType, 22: this._matrixNrType, 23: this._matrixNrType }); + var shadowMapperType = props.get(9, 0); + var parentName = "Root (TopLevel)"; + var lightTypes = ["Unsupported LightType", "PointLight", "DirectionalLight"]; + var shadowMapperTypes = ["No ShadowMapper", "DirectionalShadowMapper", "NearDirectionalShadowMapper", "CascadeShadowMapper", "CubeMapShadowMapper"]; + if (lightType == 1) { + light = new PointLight(); + light.radius = props.get(1, 90000); + light.fallOff = props.get(2, 100000); + if (shadowMapperType > 0) { + if (shadowMapperType == 4) { + newShadowMapper = new CubeMapShadowMapper(); + } + } + light.transform.matrix3D = mtx; + } + if (lightType == 2) { + light = new DirectionalLight(props.get(21, 0), props.get(22, -1), props.get(23, 1)); + if (shadowMapperType > 0) { + if (shadowMapperType == 1) { + newShadowMapper = new DirectionalShadowMapper(); + } + } + } + light.color = props.get(3, 0xffffff); + light.specular = props.get(4, 1.0); + light.diffuse = props.get(5, 1.0); + light.ambientColor = props.get(7, 0xffffff); + light.ambient = props.get(8, 0.0); + // if a shadowMapper has been created, adjust the depthMapSize if needed, assign to light and set castShadows to true + if (newShadowMapper) { + if (newShadowMapper instanceof CubeMapShadowMapper) { + if (props.get(10, 1) != 1) { + newShadowMapper.depthMapSize = this._depthSizeDic[props.get(10, 1)]; + } + } + else { + if (props.get(10, 2) != 2) { + newShadowMapper.depthMapSize = this._depthSizeDic[props.get(10, 2)]; + } + } + light.shadowMapper = newShadowMapper; + light.castsShadows = true; + } + if (par_id != 0) { + var returnedArrayParent = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]); + if (returnedArrayParent[0]) { + returnedArrayParent[1].addChild(light); + parentName = returnedArrayParent[1].name; + } + else { + this._blocks[blockID].addError("Could not find a parent for this Light"); + } + } + else { + //add to the content property + this._pContent.addChild(light); + } + this.parseUserAttributes(); + this._pFinalizeAsset(light, name); + this._blocks[blockID].data = light; + if (this._debug) + console.log("Parsed a Light: Name = '" + name + "' | Type = " + lightTypes[lightType] + " | Parent-Name = " + parentName + " | ShadowMapper-Type = " + shadowMapperTypes[shadowMapperType]); + }; + //Block ID = 43 + AWDParser.prototype.parseCamera = function (blockID) { + var par_id = this._newBlockBytes.readUnsignedInt(); + var mtx = this.parseMatrix3D(); + var name = this.parseVarStr(); + var parentName = "Root (TopLevel)"; + var projection; + this._newBlockBytes.readUnsignedByte(); //set as active camera + this._newBlockBytes.readShort(); //lengthof lenses - not used yet + var projectiontype = this._newBlockBytes.readShort(); + var props = this.parseProperties({ 101: this._propsNrType, 102: this._propsNrType, 103: this._propsNrType, 104: this._propsNrType }); + switch (projectiontype) { + case 5001: + projection = new PerspectiveProjection(props.get(101, 60)); + break; + case 5002: + projection = new OrthographicProjection(props.get(101, 500)); + break; + case 5003: + projection = new OrthographicOffCenterProjection(props.get(101, -400), props.get(102, 400), props.get(103, -300), props.get(104, 300)); + break; + default: + console.log("unsupportedLenstype"); + return; + } + var camera = new Camera(projection); + camera.transform.matrix3D = mtx; + var returnedArrayParent = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]); + if (returnedArrayParent[0]) { + var objC = returnedArrayParent[1]; + objC.addChild(camera); + parentName = objC.name; + } + else if (par_id > 0) { + this._blocks[blockID].addError("Could not find a parent for this Camera"); + } + else { + //add to the content property + this._pContent.addChild(camera); + } + camera.name = name; + props = this.parseProperties({ 1: this._matrixNrType, 2: this._matrixNrType, 3: this._matrixNrType, 4: AWDParser.UINT8 }); + camera.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + camera.extra = this.parseUserAttributes(); + this._pFinalizeAsset(camera, name); + this._blocks[blockID].data = camera; + if (this._debug) { + console.log("Parsed a Camera: Name = '" + name + "' | Projectiontype = " + projection + " | Parent-Name = " + parentName); + } + }; + //Block ID = 51 + AWDParser.prototype.parseLightPicker = function (blockID) { + var name = this.parseVarStr(); + var numLights = this._newBlockBytes.readUnsignedShort(); + var lightsArray = new Array(); + var k = 0; + var lightID = 0; + var returnedArrayLight; + var lightsArrayNames = new Array(); + for (k = 0; k < numLights; k++) { + lightID = this._newBlockBytes.readUnsignedInt(); + returnedArrayLight = this.getAssetByID(lightID, [AssetType.LIGHT]); + if (returnedArrayLight[0]) { + lightsArray.push(returnedArrayLight[1]); + lightsArrayNames.push(returnedArrayLight[1].name); + } + else { + this._blocks[blockID].addError("Could not find a Light Nr " + k + " (ID = " + lightID + " ) for this LightPicker"); + } + } + if (lightsArray.length == 0) { + this._blocks[blockID].addError("Could not create this LightPicker, cause no Light was found."); + this.parseUserAttributes(); + return; //return without any more parsing for this block + } + var lightPick = new StaticLightPicker(lightsArray); + lightPick.name = name; + this.parseUserAttributes(); + this._pFinalizeAsset(lightPick, name); + this._blocks[blockID].data = lightPick; + if (this._debug) { + console.log("Parsed a StaticLightPicker: Name = '" + name + "' | Texture-Name = " + lightsArrayNames.toString()); + } + }; + //Block ID = 81 + AWDParser.prototype.parseMaterial = function (blockID) { + // TODO: not used + ////blockLength = block.len; + var name; + var type; + var props; + var mat; + var attributes; + var finalize; + var num_methods; + var methods_parsed; + var returnedArray; + name = this.parseVarStr(); + type = this._newBlockBytes.readUnsignedByte(); + num_methods = this._newBlockBytes.readUnsignedByte(); + // Read material numerical properties + // (1=color, 2=bitmap url, 10=alpha, 11=alpha_blending, 12=alpha_threshold, 13=repeat) + props = this.parseProperties({ 1: AWDParser.INT32, 2: AWDParser.BADDR, 10: this._propsNrType, 11: AWDParser.BOOL, 12: this._propsNrType, 13: AWDParser.BOOL }); + methods_parsed = 0; + while (methods_parsed < num_methods) { + var method_type; + method_type = this._newBlockBytes.readUnsignedShort(); + this.parseProperties(null); + this.parseUserAttributes(); + methods_parsed += 1; + } + var debugString = ""; + attributes = this.parseUserAttributes(); + if (type === 1) { + debugString += "Parsed a ColorMaterial(SinglePass): Name = '" + name + "' | "; + var color; + color = props.get(1, 0xffffff); + if (this.materialMode < 2) { + mat = new TriangleMethodMaterial(color, props.get(10, 1.0)); + } + else { + mat = new TriangleMethodMaterial(color); + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + } + } + else if (type === 2) { + var tex_addr = props.get(2, 0); + returnedArray = this.getAssetByID(tex_addr, [AssetType.TEXTURE]); + if ((!returnedArray[0]) && (tex_addr > 0)) + this._blocks[blockID].addError("Could not find the DiffsueTexture (ID = " + tex_addr + " ) for this Material"); + mat = new TriangleMethodMaterial(returnedArray[1]); + if (this.materialMode < 2) { + mat.alphaBlending = props.get(11, false); + mat.alpha = props.get(10, 1.0); + debugString += "Parsed a TriangleMethodMaterial(SinglePass): Name = '" + name + "' | Texture-Name = " + mat.name; + } + else { + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + debugString += "Parsed a TriangleMethodMaterial(MultiPass): Name = '" + name + "' | Texture-Name = " + mat.name; + } + } + mat.extra = attributes; + mat.alphaThreshold = props.get(12, 0.0); + mat.repeat = props.get(13, false); + this._pFinalizeAsset(mat, name); + this._blocks[blockID].data = mat; + if (this._debug) { + console.log(debugString); + } + }; + // Block ID = 81 AWD2.1 + AWDParser.prototype.parseMaterial_v1 = function (blockID) { + var mat; + var normalTexture; + var specTexture; + var returnedArray; + var name = this.parseVarStr(); + var type = this._newBlockBytes.readUnsignedByte(); + var num_methods = this._newBlockBytes.readUnsignedByte(); + var props = this.parseProperties({ 1: AWDParser.UINT32, 2: AWDParser.BADDR, 3: AWDParser.BADDR, 4: AWDParser.UINT8, 5: AWDParser.BOOL, 6: AWDParser.BOOL, 7: AWDParser.BOOL, 8: AWDParser.BOOL, 9: AWDParser.UINT8, 10: this._propsNrType, 11: AWDParser.BOOL, 12: this._propsNrType, 13: AWDParser.BOOL, 15: this._propsNrType, 16: AWDParser.UINT32, 17: AWDParser.BADDR, 18: this._propsNrType, 19: this._propsNrType, 20: AWDParser.UINT32, 21: AWDParser.BADDR, 22: AWDParser.BADDR }); + var spezialType = props.get(4, 0); + var debugString = ""; + if (spezialType >= 2) { + this._blocks[blockID].addError("Material-spezialType '" + spezialType + "' is not supported, can only be 0:singlePass, 1:MultiPass !"); + return; + } + if (this.materialMode == 1) + spezialType = 0; + else if (this.materialMode == 2) + spezialType = 1; + if (spezialType < 2) { + if (type == 1) { + var color = props.get(1, 0xcccccc); //TODO temporarily swapped so that diffuse color goes to ambient + if (spezialType == 1) { + mat = new TriangleMethodMaterial(color); + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + debugString += "Parsed a ColorMaterial(MultiPass): Name = '" + name + "' | "; + } + else { + mat = new TriangleMethodMaterial(color, props.get(10, 1.0)); + mat.alphaBlending = props.get(11, false); + debugString += "Parsed a ColorMaterial(SinglePass): Name = '" + name + "' | "; + } + } + else if (type == 2) { + var tex_addr = props.get(2, 0); //TODO temporarily swapped so that diffuse texture goes to ambient + returnedArray = this.getAssetByID(tex_addr, [AssetType.TEXTURE]); + if ((!returnedArray[0]) && (tex_addr > 0)) + this._blocks[blockID].addError("Could not find the AmbientTexture (ID = " + tex_addr + " ) for this TriangleMethodMaterial"); + var texture = returnedArray[1]; + mat = new TriangleMethodMaterial(texture); + if (spezialType == 1) { + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + debugString += "Parsed a TriangleMethodMaterial(MultiPass): Name = '" + name + "' | Texture-Name = " + texture.name; + } + else { + mat.alpha = props.get(10, 1.0); + mat.alphaBlending = props.get(11, false); + debugString += "Parsed a TriangleMethodMaterial(SinglePass): Name = '" + name + "' | Texture-Name = " + texture.name; + } + } + var diffuseTexture; + var diffuseTex_addr = props.get(17, 0); + returnedArray = this.getAssetByID(diffuseTex_addr, [AssetType.TEXTURE]); + if ((!returnedArray[0]) && (diffuseTex_addr != 0)) { + this._blocks[blockID].addError("Could not find the DiffuseTexture (ID = " + diffuseTex_addr + " ) for this TriangleMethodMaterial"); + } + if (returnedArray[0]) + diffuseTexture = returnedArray[1]; + if (diffuseTexture) { + mat.diffuseTexture = diffuseTexture; + debugString += " | DiffuseTexture-Name = " + diffuseTexture.name; + } + var normalTex_addr = props.get(3, 0); + returnedArray = this.getAssetByID(normalTex_addr, [AssetType.TEXTURE]); + if ((!returnedArray[0]) && (normalTex_addr != 0)) { + this._blocks[blockID].addError("Could not find the NormalTexture (ID = " + normalTex_addr + " ) for this TriangleMethodMaterial"); + } + if (returnedArray[0]) { + normalTexture = returnedArray[1]; + debugString += " | NormalTexture-Name = " + normalTexture.name; + } + var specTex_addr = props.get(21, 0); + returnedArray = this.getAssetByID(specTex_addr, [AssetType.TEXTURE]); + if ((!returnedArray[0]) && (specTex_addr != 0)) { + this._blocks[blockID].addError("Could not find the SpecularTexture (ID = " + specTex_addr + " ) for this TriangleMethodMaterial"); + } + if (returnedArray[0]) { + specTexture = returnedArray[1]; + debugString += " | SpecularTexture-Name = " + specTexture.name; + } + var lightPickerAddr = props.get(22, 0); + returnedArray = this.getAssetByID(lightPickerAddr, [AssetType.LIGHT_PICKER]); + if ((!returnedArray[0]) && (lightPickerAddr)) { + this._blocks[blockID].addError("Could not find the LightPicker (ID = " + lightPickerAddr + " ) for this TriangleMethodMaterial"); + } + else { + mat.lightPicker = returnedArray[1]; + } + mat.smooth = props.get(5, true); + mat.mipmap = props.get(6, true); + mat.bothSides = props.get(7, false); + mat.alphaPremultiplied = props.get(8, false); + mat.blendMode = this.blendModeDic[props.get(9, 0)]; + mat.repeat = props.get(13, false); + if (normalTexture) + mat.normalMap = normalTexture; + if (specTexture) + mat.specularMap = specTexture; + mat.alphaThreshold = props.get(12, 0.0); + mat.ambient = props.get(15, 1.0); + mat.diffuseColor = props.get(16, 0xffffff); + mat.specular = props.get(18, 1.0); + mat.gloss = props.get(19, 50); + mat.specularColor = props.get(20, 0xffffff); + var methods_parsed = 0; + var targetID; + while (methods_parsed < num_methods) { + var method_type; + method_type = this._newBlockBytes.readUnsignedShort(); + props = this.parseProperties({ 1: AWDParser.BADDR, 2: AWDParser.BADDR, 3: AWDParser.BADDR, 101: this._propsNrType, 102: this._propsNrType, 103: this._propsNrType, 201: AWDParser.UINT32, 202: AWDParser.UINT32, 301: AWDParser.UINT16, 302: AWDParser.UINT16, 401: AWDParser.UINT8, 402: AWDParser.UINT8, 601: AWDParser.COLOR, 602: AWDParser.COLOR, 701: AWDParser.BOOL, 702: AWDParser.BOOL, 801: AWDParser.MTX4x4 }); + switch (method_type) { + case 999: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.EFFECTS_METHOD]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the EffectMethod (ID = " + targetID + " ) for this Material"); + } + else { + mat.addEffectMethod(returnedArray[1]); + debugString += " | EffectMethod-Name = " + returnedArray[1].name; + } + break; + case 998: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the ShadowMethod (ID = " + targetID + " ) for this Material"); + } + else { + mat.shadowMethod = returnedArray[1]; + debugString += " | ShadowMethod-Name = " + returnedArray[1].name; + } + break; + case 1: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE], "CubeTexture"); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the EnvMap (ID = " + targetID + " ) for this EnvMapAmbientMethodMaterial"); + mat.ambientMethod = new AmbientEnvMapMethod(returnedArray[1]); + debugString += " | AmbientEnvMapMethod | EnvMap-Name =" + returnedArray[1].name; + break; + case 51: + mat.diffuseMethod = new DiffuseDepthMethod(); + debugString += " | DiffuseDepthMethod"; + break; + case 52: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the GradientDiffuseTexture (ID = " + targetID + " ) for this GradientDiffuseMethod"); + mat.diffuseMethod = new DiffuseGradientMethod(returnedArray[1]); + debugString += " | DiffuseGradientMethod | GradientDiffuseTexture-Name =" + returnedArray[1].name; + break; + case 53: + mat.diffuseMethod = new DiffuseWrapMethod(props.get(101, 5)); + debugString += " | DiffuseWrapMethod"; + break; + case 54: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the LightMap (ID = " + targetID + " ) for this LightMapDiffuseMethod"); + mat.diffuseMethod = new DiffuseLightMapMethod(returnedArray[1], this.blendModeDic[props.get(401, 10)], false, mat.diffuseMethod); + debugString += " | DiffuseLightMapMethod | LightMapTexture-Name =" + returnedArray[1].name; + break; + case 55: + mat.diffuseMethod = new DiffuseCelMethod(props.get(401, 3), mat.diffuseMethod); + mat.diffuseMethod.smoothness = props.get(101, 0.1); + debugString += " | DiffuseCelMethod"; + break; + case 56: + break; + case 101: + mat.specularMethod = new SpecularAnisotropicMethod(); + debugString += " | SpecularAnisotropicMethod"; + break; + case 102: + mat.specularMethod = new SpecularPhongMethod(); + debugString += " | SpecularPhongMethod"; + break; + case 103: + mat.specularMethod = new SpecularCelMethod(props.get(101, 0.5), mat.specularMethod); + mat.specularMethod.smoothness = props.get(102, 0.1); + debugString += " | SpecularCelMethod"; + break; + case 104: + mat.specularMethod = new SpecularFresnelMethod(props.get(701, true), mat.specularMethod); + mat.specularMethod.fresnelPower = props.get(101, 5); + mat.specularMethod.normalReflectance = props.get(102, 0.1); + debugString += " | SpecularFresnelMethod"; + break; + case 151: + break; + case 152: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the SecoundNormalMap (ID = " + targetID + " ) for this SimpleWaterNormalMethod"); + if (!mat.normalMap) + this._blocks[blockID].addError("Could not find a normal Map on this Material to use with this SimpleWaterNormalMethod"); + mat.normalMap = returnedArray[1]; + mat.normalMethod = new NormalSimpleWaterMethod(mat.normalMap, returnedArray[1]); + debugString += " | NormalSimpleWaterMethod | Second-NormalTexture-Name = " + returnedArray[1].name; + break; + } + this.parseUserAttributes(); + methods_parsed += 1; + } + } + mat.extra = this.parseUserAttributes(); + this._pFinalizeAsset(mat, name); + this._blocks[blockID].data = mat; + if (this._debug) { + console.log(debugString); + } + }; + //Block ID = 82 + AWDParser.prototype.parseTexture = function (blockID) { + var asset; + this._blocks[blockID].name = this.parseVarStr(); + var type = this._newBlockBytes.readUnsignedByte(); + var data_len; + this._texture_users[this._cur_block_id.toString()] = []; + // External + if (type == 0) { + data_len = this._newBlockBytes.readUnsignedInt(); + var url; + url = this._newBlockBytes.readUTFBytes(data_len); + this._pAddDependency(this._cur_block_id.toString(), new URLRequest(url), false, null, true); + } + else { + data_len = this._newBlockBytes.readUnsignedInt(); + var data; + data = new ByteArray(); + this._newBlockBytes.readBytes(data, 0, data_len); + // + // AWDParser - Fix for FireFox Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=715075 . + // + // Converting data to image here instead of parser - fix FireFox bug where image width / height is 0 when created from data + // This gives the browser time to initialise image width / height. + this._pAddDependency(this._cur_block_id.toString(), null, false, ParserUtils.byteArrayToImage(data), true); + } + // Ignore for now + this.parseProperties(null); + this._blocks[blockID].extras = this.parseUserAttributes(); + this._pPauseAndRetrieveDependencies(); + this._blocks[blockID].data = asset; + if (this._debug) { + var textureStylesNames = ["external", "embed"]; + console.log("Start parsing a " + textureStylesNames[type] + " Bitmap for Texture"); + } + }; + //Block ID = 83 + AWDParser.prototype.parseCubeTexture = function (blockID) { + //blockLength = block.len; + var data_len; + var asset; + var i; + this._cubeTextures = new Array(); + this._texture_users[this._cur_block_id.toString()] = []; + var type = this._newBlockBytes.readUnsignedByte(); + this._blocks[blockID].name = this.parseVarStr(); + for (i = 0; i < 6; i++) { + this._texture_users[this._cur_block_id.toString()] = []; + this._cubeTextures.push(null); + // External + if (type == 0) { + data_len = this._newBlockBytes.readUnsignedInt(); + var url; + url = this._newBlockBytes.readUTFBytes(data_len); + this._pAddDependency(this._cur_block_id.toString() + "#" + i, new URLRequest(url), false, null, true); + } + else { + data_len = this._newBlockBytes.readUnsignedInt(); + var data; + data = new ByteArray(); + this._newBlockBytes.readBytes(data, 0, data_len); + this._pAddDependency(this._cur_block_id.toString() + "#" + i, null, false, ParserUtils.byteArrayToImage(data), true); + } + } + // Ignore for now + this.parseProperties(null); + this._blocks[blockID].extras = this.parseUserAttributes(); + this._pPauseAndRetrieveDependencies(); + this._blocks[blockID].data = asset; + if (this._debug) { + var textureStylesNames = ["external", "embed"]; + console.log("Start parsing 6 " + textureStylesNames[type] + " Bitmaps for CubeTexture"); + } + }; + //Block ID = 91 + AWDParser.prototype.parseSharedMethodBlock = function (blockID) { + var asset; + this._blocks[blockID].name = this.parseVarStr(); + asset = this.parseSharedMethodList(blockID); + this.parseUserAttributes(); + this._blocks[blockID].data = asset; + this._pFinalizeAsset(asset, this._blocks[blockID].name); + this._blocks[blockID].data = asset; + if (this._debug) { + console.log("Parsed a EffectMethod: Name = " + asset.name + " Type = " + asset); + } + }; + //Block ID = 92 + AWDParser.prototype.parseShadowMethodBlock = function (blockID) { + var type; + var data_len; + var asset; + var shadowLightID; + this._blocks[blockID].name = this.parseVarStr(); + shadowLightID = this._newBlockBytes.readUnsignedInt(); + var returnedArray = this.getAssetByID(shadowLightID, [AssetType.LIGHT]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the TargetLight (ID = " + shadowLightID + " ) for this ShadowMethod - ShadowMethod not created"); + return; + } + asset = this.parseShadowMethodList(returnedArray[1], blockID); + if (!asset) + return; + this.parseUserAttributes(); // Ignore for now + this._pFinalizeAsset(asset, this._blocks[blockID].name); + this._blocks[blockID].data = asset; + if (this._debug) { + console.log("Parsed a ShadowMapMethodMethod: Name = " + asset.name + " | Type = " + asset + " | Light-Name = ", returnedArray[1].name); + } + }; + //Block ID = 253 + AWDParser.prototype.parseCommand = function (blockID) { + var hasBlocks = (this._newBlockBytes.readUnsignedByte() == 1); + var par_id = this._newBlockBytes.readUnsignedInt(); + var mtx = this.parseMatrix3D(); + var name = this.parseVarStr(); + var parentObject; + var targetObject; + var returnedArray = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]); + if (returnedArray[0]) { + parentObject = returnedArray[1]; + } + var numCommands = this._newBlockBytes.readShort(); + var typeCommand = this._newBlockBytes.readShort(); + var props = this.parseProperties({ 1: AWDParser.BADDR }); + switch (typeCommand) { + case 1: + var targetID = props.get(1, 0); + var returnedArrayTarget = this.getAssetByID(targetID, [AssetType.LIGHT, AssetType.TEXTURE_PROJECTOR]); //for no only light is requested!!!! + if ((!returnedArrayTarget[0]) && (targetID != 0)) { + this._blocks[blockID].addError("Could not find the light (ID = " + targetID + " ( for this CommandBock!"); + return; + } + targetObject = returnedArrayTarget[1]; + if (parentObject) { + parentObject.addChild(targetObject); + } + targetObject.transform.matrix3D = mtx; + break; + } + if (targetObject) { + props = this.parseProperties({ 1: this._matrixNrType, 2: this._matrixNrType, 3: this._matrixNrType, 4: AWDParser.UINT8 }); + targetObject.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + targetObject.extra = this.parseUserAttributes(); + } + this._blocks[blockID].data = targetObject; + if (this._debug) { + console.log("Parsed a CommandBlock: Name = '" + name); + } + }; + //blockID 255 + AWDParser.prototype.parseMetaData = function (blockID) { + var props = this.parseProperties({ 1: AWDParser.UINT32, 2: AWDParser.AWDSTRING, 3: AWDParser.AWDSTRING, 4: AWDParser.AWDSTRING, 5: AWDParser.AWDSTRING }); + if (this._debug) { + console.log("Parsed a MetaDataBlock: TimeStamp = " + props.get(1, 0)); + console.log(" EncoderName = " + props.get(2, "unknown")); + console.log(" EncoderVersion = " + props.get(3, "unknown")); + console.log(" GeneratorName = " + props.get(4, "unknown")); + console.log(" GeneratorVersion = " + props.get(5, "unknown")); + } + }; + //blockID 254 + AWDParser.prototype.parseNameSpace = function (blockID) { + var id = this._newBlockBytes.readUnsignedByte(); + var nameSpaceString = this.parseVarStr(); + if (this._debug) + console.log("Parsed a NameSpaceBlock: ID = " + id + " | String = " + nameSpaceString); + }; + //--Parser UTILS--------------------------------------------------------------------------- + // this functions reads and creates a ShadowMethodMethod + AWDParser.prototype.parseShadowMethodList = function (light, blockID) { + var methodType = this._newBlockBytes.readUnsignedShort(); + var shadowMethod; + var props = this.parseProperties({ 1: AWDParser.BADDR, 2: AWDParser.BADDR, 3: AWDParser.BADDR, 101: this._propsNrType, 102: this._propsNrType, 103: this._propsNrType, 201: AWDParser.UINT32, 202: AWDParser.UINT32, 301: AWDParser.UINT16, 302: AWDParser.UINT16, 401: AWDParser.UINT8, 402: AWDParser.UINT8, 601: AWDParser.COLOR, 602: AWDParser.COLOR, 701: AWDParser.BOOL, 702: AWDParser.BOOL, 801: AWDParser.MTX4x4 }); + var targetID; + var returnedArray; + switch (methodType) { + case 1002: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the ShadowBaseMethod (ID = " + targetID + " ) for this ShadowNearMethod - ShadowMethod not created"); + return shadowMethod; + } + shadowMethod = new ShadowNearMethod(returnedArray[1]); + break; + case 1101: + shadowMethod = new ShadowFilteredMethod(light); + shadowMethod.alpha = props.get(101, 1); + shadowMethod.epsilon = props.get(102, 0.002); + break; + case 1102: + shadowMethod = new ShadowDitheredMethod(light, props.get(201, 5)); + shadowMethod.alpha = props.get(101, 1); + shadowMethod.epsilon = props.get(102, 0.002); + shadowMethod.range = props.get(103, 1); + break; + case 1103: + shadowMethod = new ShadowSoftMethod(light, props.get(201, 5)); + shadowMethod.alpha = props.get(101, 1); + shadowMethod.epsilon = props.get(102, 0.002); + shadowMethod.range = props.get(103, 1); + break; + case 1104: + shadowMethod = new ShadowHardMethod(light); + shadowMethod.alpha = props.get(101, 1); + shadowMethod.epsilon = props.get(102, 0.002); + break; + } + this.parseUserAttributes(); + return shadowMethod; + }; + //Block ID 101 + AWDParser.prototype.parseSkeleton = function (blockID /*uint*/) { + var name = this.parseVarStr(); + var num_joints = this._newBlockBytes.readUnsignedShort(); + var skeleton = new Skeleton(); + this.parseProperties(null); // Discard properties for now + var joints_parsed = 0; + while (joints_parsed < num_joints) { + var joint; + var ibp; + // Ignore joint id + this._newBlockBytes.readUnsignedShort(); + joint = new SkeletonJoint(); + joint.parentIndex = this._newBlockBytes.readUnsignedShort() - 1; // 0=null in AWD + joint.name = this.parseVarStr(); + ibp = this.parseMatrix3D(); + joint.inverseBindPose = ibp.rawData; + // Ignore joint props/attributes for now + this.parseProperties(null); + this.parseUserAttributes(); + skeleton.joints.push(joint); + joints_parsed++; + } + // Discard attributes for now + this.parseUserAttributes(); + this._pFinalizeAsset(skeleton, name); + this._blocks[blockID].data = skeleton; + if (this._debug) + console.log("Parsed a Skeleton: Name = " + skeleton.name + " | Number of Joints = " + joints_parsed); + }; + //Block ID = 102 + AWDParser.prototype.parseSkeletonPose = function (blockID /*uint*/) { + var name = this.parseVarStr(); + var num_joints = this._newBlockBytes.readUnsignedShort(); + this.parseProperties(null); // Ignore properties for now + var pose = new SkeletonPose(); + var joints_parsed = 0; + while (joints_parsed < num_joints) { + var joint_pose; + var has_transform /*uint*/; + joint_pose = new JointPose(); + has_transform = this._newBlockBytes.readUnsignedByte(); + if (has_transform == 1) { + var mtx_data = this.parseMatrix43RawData(); + var mtx = new Matrix3D(mtx_data); + joint_pose.orientation.fromMatrix(mtx); + joint_pose.translation.copyFrom(mtx.position); + pose.jointPoses[joints_parsed] = joint_pose; + } + joints_parsed++; + } + // Skip attributes for now + this.parseUserAttributes(); + this._pFinalizeAsset(pose, name); + this._blocks[blockID].data = pose; + if (this._debug) + console.log("Parsed a SkeletonPose: Name = " + pose.name + " | Number of Joints = " + joints_parsed); + }; + //blockID 103 + AWDParser.prototype.parseSkeletonAnimation = function (blockID /*uint*/) { + var frame_dur; + var pose_addr /*uint*/; + var name = this.parseVarStr(); + var clip = new SkeletonClipNode(); + var num_frames = this._newBlockBytes.readUnsignedShort(); + this.parseProperties(null); // Ignore properties for now + var frames_parsed = 0; + var returnedArray; + while (frames_parsed < num_frames) { + pose_addr = this._newBlockBytes.readUnsignedInt(); + frame_dur = this._newBlockBytes.readUnsignedShort(); + returnedArray = this.getAssetByID(pose_addr, [AssetType.SKELETON_POSE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the SkeletonPose Frame # " + frames_parsed + " (ID = " + pose_addr + " ) for this SkeletonClipNode"); + else + clip.addFrame(this._blocks[pose_addr].data, frame_dur); + frames_parsed++; + } + if (clip.frames.length == 0) { + this._blocks[blockID].addError("Could not this SkeletonClipNode, because no Frames where set."); + return; + } + // Ignore attributes for now + this.parseUserAttributes(); + this._pFinalizeAsset(clip, name); + this._blocks[blockID].data = clip; + if (this._debug) + console.log("Parsed a SkeletonClipNode: Name = " + clip.name + " | Number of Frames = " + clip.frames.length); + }; + //Block ID = 111 / Block ID = 112 + AWDParser.prototype.parseMeshPoseAnimation = function (blockID /*uint*/, poseOnly) { + if (poseOnly === void 0) { poseOnly = false; } + var num_frames = 1; + var num_submeshes /*uint*/; + var frames_parsed /*uint*/; + var subMeshParsed /*uint*/; + var frame_dur; + var x; + var y; + var z; + var str_len; + var str_end; + var geometry; + var subGeom; + var idx = 0; + var clip = new VertexClipNode(); + var indices /*uint*/; + var verts; + var num_Streams = 0; + var streamsParsed = 0; + var streamtypes = new Array() /*int*/; + var props; + var thisGeo; + var name = this.parseVarStr(); + var geoAdress = this._newBlockBytes.readUnsignedInt(); + var returnedArray = this.getAssetByID(geoAdress, [AssetType.GEOMETRY]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the target-Geometry-Object " + geoAdress + " ) for this VertexClipNode"); + return; + } + var uvs = this.getUVForVertexAnimation(geoAdress); + if (!poseOnly) + num_frames = this._newBlockBytes.readUnsignedShort(); + num_submeshes = this._newBlockBytes.readUnsignedShort(); + num_Streams = this._newBlockBytes.readUnsignedShort(); + streamsParsed = 0; + while (streamsParsed < num_Streams) { + streamtypes.push(this._newBlockBytes.readUnsignedShort()); + streamsParsed++; + } + props = this.parseProperties({ 1: AWDParser.BOOL, 2: AWDParser.BOOL }); + clip.looping = props.get(1, true); + clip.stitchFinalFrame = props.get(2, false); + frames_parsed = 0; + while (frames_parsed < num_frames) { + frame_dur = this._newBlockBytes.readUnsignedShort(); + geometry = new Geometry(); + subMeshParsed = 0; + while (subMeshParsed < num_submeshes) { + streamsParsed = 0; + str_len = this._newBlockBytes.readUnsignedInt(); + str_end = this._newBlockBytes.position + str_len; + while (streamsParsed < num_Streams) { + if (streamtypes[streamsParsed] == 1) { + indices = returnedArray[1].subGeometries[subMeshParsed].indices; + verts = new Array(); + idx = 0; + while (this._newBlockBytes.position < str_end) { + x = this.readNumber(this._accuracyGeo); + y = this.readNumber(this._accuracyGeo); + z = this.readNumber(this._accuracyGeo); + verts[idx++] = x; + verts[idx++] = y; + verts[idx++] = z; + } + subGeom = new TriangleSubGeometry(true); + subGeom.updateIndices(indices); + subGeom.updatePositions(verts); + subGeom.updateUVs(uvs[subMeshParsed]); + subGeom.updateVertexNormals(null); + subGeom.updateVertexTangents(null); + subGeom.autoDeriveNormals = false; + subGeom.autoDeriveTangents = false; + subMeshParsed++; + geometry.addSubGeometry(subGeom); + } + else + this._newBlockBytes.position = str_end; + streamsParsed++; + } + } + clip.addFrame(geometry, frame_dur); + frames_parsed++; + } + this.parseUserAttributes(); + this._pFinalizeAsset(clip, name); + this._blocks[blockID].data = clip; + if (this._debug) + console.log("Parsed a VertexClipNode: Name = " + clip.name + " | Target-Geometry-Name = " + returnedArray[1].name + " | Number of Frames = " + clip.frames.length); + }; + //BlockID 113 + AWDParser.prototype.parseVertexAnimationSet = function (blockID /*uint*/) { + var poseBlockAdress; /*int*/ + var outputString = ""; + var name = this.parseVarStr(); + var num_frames = this._newBlockBytes.readUnsignedShort(); + var props = this.parseProperties({ 1: AWDParser.UINT16 }); + var frames_parsed = 0; + var skeletonFrames = new Array(); + var vertexFrames = new Array(); + while (frames_parsed < num_frames) { + poseBlockAdress = this._newBlockBytes.readUnsignedInt(); + var returnedArray = this.getAssetByID(poseBlockAdress, [AssetType.ANIMATION_NODE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the AnimationClipNode Nr " + frames_parsed + " ( " + poseBlockAdress + " ) for this AnimationSet"); + else { + if (returnedArray[1] instanceof VertexClipNode) + vertexFrames.push(returnedArray[1]); + if (returnedArray[1] instanceof SkeletonClipNode) + skeletonFrames.push(returnedArray[1]); + } + frames_parsed++; + } + if ((vertexFrames.length == 0) && (skeletonFrames.length == 0)) { + this._blocks[blockID].addError("Could not create this AnimationSet, because it contains no animations"); + return; + } + this.parseUserAttributes(); + if (vertexFrames.length > 0) { + var newVertexAnimationSet = new VertexAnimationSet(); + for (var i = 0; i < vertexFrames.length; i++) + newVertexAnimationSet.addAnimation(vertexFrames[i]); + this._pFinalizeAsset(newVertexAnimationSet, name); + this._blocks[blockID].data = newVertexAnimationSet; + if (this._debug) + console.log("Parsed a VertexAnimationSet: Name = " + name + " | Animations = " + newVertexAnimationSet.animations.length + " | Animation-Names = " + newVertexAnimationSet.animationNames.toString()); + } + else if (skeletonFrames.length > 0) { + returnedArray = this.getAssetByID(poseBlockAdress, [AssetType.ANIMATION_NODE]); + var newSkeletonAnimationSet = new SkeletonAnimationSet(props.get(1, 4)); //props.get(1,4)); + for (var i = 0; i < skeletonFrames.length; i++) + newSkeletonAnimationSet.addAnimation(skeletonFrames[i]); + this._pFinalizeAsset(newSkeletonAnimationSet, name); + this._blocks[blockID].data = newSkeletonAnimationSet; + if (this._debug) + console.log("Parsed a SkeletonAnimationSet: Name = " + name + " | Animations = " + newSkeletonAnimationSet.animations.length + " | Animation-Names = " + newSkeletonAnimationSet.animationNames.toString()); + } + }; + //BlockID 122 + AWDParser.prototype.parseAnimatorSet = function (blockID /*uint*/) { + var targetMesh; + var animSetBlockAdress; /*int*/ + var targetAnimationSet; + var outputString = ""; + var name = this.parseVarStr(); + var type = this._newBlockBytes.readUnsignedShort(); + var props = this.parseProperties({ 1: AWDParser.BADDR }); + animSetBlockAdress = this._newBlockBytes.readUnsignedInt(); + var targetMeshLength = this._newBlockBytes.readUnsignedShort(); + var meshAdresses = new Array() /*uint*/; + for (var i = 0; i < targetMeshLength; i++) + meshAdresses.push(this._newBlockBytes.readUnsignedInt()); + var activeState = this._newBlockBytes.readUnsignedShort(); + var autoplay = (this._newBlockBytes.readUnsignedByte() == 1); + this.parseUserAttributes(); + this.parseUserAttributes(); + var returnedArray; + var targetMeshes = new Array(); + for (i = 0; i < meshAdresses.length; i++) { + returnedArray = this.getAssetByID(meshAdresses[i], [AssetType.MESH]); + if (returnedArray[0]) + targetMeshes.push(returnedArray[1]); + } + returnedArray = this.getAssetByID(animSetBlockAdress, [AssetType.ANIMATION_SET]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the AnimationSet ( " + animSetBlockAdress + " ) for this Animator"); + ; + return; + } + targetAnimationSet = returnedArray[1]; + var thisAnimator; + if (type == 1) { + returnedArray = this.getAssetByID(props.get(1, 0), [AssetType.SKELETON]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the Skeleton ( " + props.get(1, 0) + " ) for this Animator"); + return; + } + thisAnimator = new SkeletonAnimator(targetAnimationSet, returnedArray[1]); + } + else if (type == 2) + thisAnimator = new VertexAnimator(targetAnimationSet); + this._pFinalizeAsset(thisAnimator, name); + this._blocks[blockID].data = thisAnimator; + for (i = 0; i < targetMeshes.length; i++) { + if (type == 1) + targetMeshes[i].animator = thisAnimator; + if (type == 2) + targetMeshes[i].animator = thisAnimator; + } + if (this._debug) + console.log("Parsed a Animator: Name = " + name); + }; + // this functions reads and creates a EffectMethod + AWDParser.prototype.parseSharedMethodList = function (blockID) { + var methodType = this._newBlockBytes.readUnsignedShort(); + var effectMethodReturn; + var props = this.parseProperties({ 1: AWDParser.BADDR, 2: AWDParser.BADDR, 3: AWDParser.BADDR, 101: this._propsNrType, 102: this._propsNrType, 103: this._propsNrType, 104: this._propsNrType, 105: this._propsNrType, 106: this._propsNrType, 107: this._propsNrType, 201: AWDParser.UINT32, 202: AWDParser.UINT32, 301: AWDParser.UINT16, 302: AWDParser.UINT16, 401: AWDParser.UINT8, 402: AWDParser.UINT8, 601: AWDParser.COLOR, 602: AWDParser.COLOR, 701: AWDParser.BOOL, 702: AWDParser.BOOL }); + var targetID; + var returnedArray; + switch (methodType) { + case 401: + effectMethodReturn = new EffectColorMatrixMethod(props.get(101, new Array(0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1))); + break; + case 402: + effectMethodReturn = new EffectColorTransformMethod(); + var offCol = props.get(601, 0x00000000); + effectMethodReturn.colorTransform = new ColorTransform(props.get(102, 1), props.get(103, 1), props.get(104, 1), props.get(101, 1), ((offCol >> 16) & 0xFF), ((offCol >> 8) & 0xFF), (offCol & 0xFF), ((offCol >> 24) & 0xFF)); + break; + case 403: + targetID = props.get(1, 0); + console.log('ENV MAP', targetID); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE], "CubeTexture"); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the EnvMap (ID = " + targetID + " ) for this EnvMapMethod"); + effectMethodReturn = new EffectEnvMapMethod(returnedArray[1], props.get(101, 1)); + targetID = props.get(2, 0); + if (targetID > 0) { + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the Mask-texture (ID = " + targetID + " ) for this EnvMapMethod"); + } + break; + case 404: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the LightMap (ID = " + targetID + " ) for this LightMapMethod"); + effectMethodReturn = new EffectLightMapMethod(returnedArray[1], this.blendModeDic[props.get(401, 10)]); //usesecondaryUV not set + break; + case 406: + effectMethodReturn = new EffectRimLightMethod(props.get(601, 0xffffff), props.get(101, 0.4), props.get(101, 2)); //blendMode + break; + case 407: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the Alpha-texture (ID = " + targetID + " ) for this AlphaMaskMethod"); + effectMethodReturn = new EffectAlphaMaskMethod(returnedArray[1], props.get(701, false)); + break; + case 410: + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE], "CubeTexture"); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the EnvMap (ID = " + targetID + " ) for this FresnelEnvMapMethod"); + effectMethodReturn = new EffectFresnelEnvMapMethod(returnedArray[1], props.get(101, 1)); + break; + case 411: + effectMethodReturn = new EffectFogMethod(props.get(101, 0), props.get(102, 1000), props.get(601, 0x808080)); + break; + } + this.parseUserAttributes(); + return effectMethodReturn; + }; + AWDParser.prototype.parseUserAttributes = function () { + var attributes; + var list_len; + var attibuteCnt; + list_len = this._newBlockBytes.readUnsignedInt(); + if (list_len > 0) { + var list_end; + attributes = {}; + list_end = this._newBlockBytes.position + list_len; + while (this._newBlockBytes.position < list_end) { + var ns_id; + var attr_key; + var attr_type; + var attr_len; + var attr_val; + // TODO: Properly tend to namespaces in attributes + ns_id = this._newBlockBytes.readUnsignedByte(); + attr_key = this.parseVarStr(); + attr_type = this._newBlockBytes.readUnsignedByte(); + attr_len = this._newBlockBytes.readUnsignedInt(); + if ((this._newBlockBytes.position + attr_len) > list_end) { + console.log(" Error in reading attribute # " + attibuteCnt + " = skipped to end of attribute-list"); + this._newBlockBytes.position = list_end; + return attributes; + } + switch (attr_type) { + case AWDParser.AWDSTRING: + attr_val = this._newBlockBytes.readUTFBytes(attr_len); + break; + case AWDParser.INT8: + attr_val = this._newBlockBytes.readByte(); + break; + case AWDParser.INT16: + attr_val = this._newBlockBytes.readShort(); + break; + case AWDParser.INT32: + attr_val = this._newBlockBytes.readInt(); + break; + case AWDParser.BOOL: + case AWDParser.UINT8: + attr_val = this._newBlockBytes.readUnsignedByte(); + break; + case AWDParser.UINT16: + attr_val = this._newBlockBytes.readUnsignedShort(); + break; + case AWDParser.UINT32: + case AWDParser.BADDR: + attr_val = this._newBlockBytes.readUnsignedInt(); + break; + case AWDParser.FLOAT32: + attr_val = this._newBlockBytes.readFloat(); + break; + case AWDParser.FLOAT64: + attr_val = this._newBlockBytes.readDouble(); + break; + default: + attr_val = 'unimplemented attribute type ' + attr_type; + this._newBlockBytes.position += attr_len; + break; + } + if (this._debug) { + console.log("attribute = name: " + attr_key + " / value = " + attr_val); + } + attributes[attr_key] = attr_val; + attibuteCnt += 1; + } + } + return attributes; + }; + AWDParser.prototype.parseProperties = function (expected) { + var list_end; + var list_len; + var propertyCnt = 0; + var props = new AWDProperties(); + list_len = this._newBlockBytes.readUnsignedInt(); + list_end = this._newBlockBytes.position + list_len; + if (expected) { + while (this._newBlockBytes.position < list_end) { + var len; + var key; + var type; + key = this._newBlockBytes.readUnsignedShort(); + len = this._newBlockBytes.readUnsignedInt(); + if ((this._newBlockBytes.position + len) > list_end) { + console.log(" Error in reading property # " + propertyCnt + " = skipped to end of propertie-list"); + this._newBlockBytes.position = list_end; + return props; + } + if (expected.hasOwnProperty(key.toString())) { + type = expected[key]; + props.set(key, this.parseAttrValue(type, len)); + } + else { + this._newBlockBytes.position += len; + } + propertyCnt += 1; + } + } + else { + this._newBlockBytes.position = list_end; + } + return props; + }; + AWDParser.prototype.parseAttrValue = function (type, len) { + var elem_len; + var read_func; + switch (type) { + case AWDParser.BOOL: + case AWDParser.INT8: + elem_len = 1; + read_func = this._newBlockBytes.readByte; + break; + case AWDParser.INT16: + elem_len = 2; + read_func = this._newBlockBytes.readShort; + break; + case AWDParser.INT32: + elem_len = 4; + read_func = this._newBlockBytes.readInt; + break; + case AWDParser.UINT8: + elem_len = 1; + read_func = this._newBlockBytes.readUnsignedByte; + break; + case AWDParser.UINT16: + elem_len = 2; + read_func = this._newBlockBytes.readUnsignedShort; + break; + case AWDParser.UINT32: + case AWDParser.COLOR: + case AWDParser.BADDR: + elem_len = 4; + read_func = this._newBlockBytes.readUnsignedInt; + break; + case AWDParser.FLOAT32: + elem_len = 4; + read_func = this._newBlockBytes.readFloat; + break; + case AWDParser.FLOAT64: + elem_len = 8; + read_func = this._newBlockBytes.readDouble; + break; + case AWDParser.AWDSTRING: + return this._newBlockBytes.readUTFBytes(len); + case AWDParser.VECTOR2x1: + case AWDParser.VECTOR3x1: + case AWDParser.VECTOR4x1: + case AWDParser.MTX3x2: + case AWDParser.MTX3x3: + case AWDParser.MTX4x3: + case AWDParser.MTX4x4: + elem_len = 8; + read_func = this._newBlockBytes.readDouble; + break; + } + if (elem_len < len) { + var list = []; + var num_read = 0; + var num_elems = len / elem_len; + while (num_read < num_elems) { + list.push(read_func.apply(this._newBlockBytes)); // list.push(read_func()); + num_read++; + } + return list; + } + else { + var val = read_func.apply(this._newBlockBytes); //read_func(); + return val; + } + }; + AWDParser.prototype.parseHeader = function () { + var flags; + var body_len; + this._byteData.position = 3; // Skip magic string and parse version + this._version[0] = this._byteData.readUnsignedByte(); + this._version[1] = this._byteData.readUnsignedByte(); + flags = this._byteData.readUnsignedShort(); // Parse bit flags + this._streaming = BitFlags.test(flags, BitFlags.FLAG1); + if ((this._version[0] == 2) && (this._version[1] == 1)) { + this._accuracyMatrix = BitFlags.test(flags, BitFlags.FLAG2); + this._accuracyGeo = BitFlags.test(flags, BitFlags.FLAG3); + this._accuracyProps = BitFlags.test(flags, BitFlags.FLAG4); + } + // if we set _accuracyOnBlocks, the precision-values are read from each block-header. + // set storagePrecision types + this._geoNrType = AWDParser.FLOAT32; + if (this._accuracyGeo) { + this._geoNrType = AWDParser.FLOAT64; + } + this._matrixNrType = AWDParser.FLOAT32; + if (this._accuracyMatrix) { + this._matrixNrType = AWDParser.FLOAT64; + } + this._propsNrType = AWDParser.FLOAT32; + if (this._accuracyProps) { + this._propsNrType = AWDParser.FLOAT64; + } + this._compression = this._byteData.readUnsignedByte(); // compression + if (this._debug) { + console.log("Import AWDFile of version = " + this._version[0] + " - " + this._version[1]); + console.log("Global Settings = Compression = " + this._compression + " | Streaming = " + this._streaming + " | Matrix-Precision = " + this._accuracyMatrix + " | Geometry-Precision = " + this._accuracyGeo + " | Properties-Precision = " + this._accuracyProps); + } + // Check file integrity + body_len = this._byteData.readUnsignedInt(); + if (!this._streaming && body_len != this._byteData.getBytesAvailable()) { + this._pDieWithError('AWD2 body length does not match header integrity field'); + } + }; + // Helper - functions + AWDParser.prototype.getUVForVertexAnimation = function (meshID /*uint*/) { + if (this._blocks[meshID].data instanceof Mesh) + meshID = this._blocks[meshID].geoID; + if (this._blocks[meshID].uvsForVertexAnimation) + return this._blocks[meshID].uvsForVertexAnimation; + var geometry = this._blocks[meshID].data; + var geoCnt = 0; + var ud; + var uStride /*uint*/; + var uOffs /*uint*/; + var numPoints /*uint*/; + var i /*int*/; + var newUvs; + var sub_geom; + this._blocks[meshID].uvsForVertexAnimation = new Array(); + while (geoCnt < geometry.subGeometries.length) { + newUvs = new Array(); + sub_geom = geometry.subGeometries[geoCnt]; + numPoints = sub_geom.numVertices; + ud = sub_geom.uvs; + uStride = sub_geom.getStride(TriangleSubGeometry.UV_DATA); + uOffs = sub_geom.getOffset(TriangleSubGeometry.UV_DATA); + for (i = 0; i < numPoints; i++) { + newUvs.push(ud[uOffs + i * uStride + 0]); + newUvs.push(ud[uOffs + i * uStride + 1]); + } + this._blocks[meshID].uvsForVertexAnimation.push(newUvs); + geoCnt++; + } + return this._blocks[meshID].uvsForVertexAnimation; + }; + AWDParser.prototype.parseVarStr = function () { + var len = this._newBlockBytes.readUnsignedShort(); + return this._newBlockBytes.readUTFBytes(len); + }; + AWDParser.prototype.getAssetByID = function (assetID, assetTypesToGet, extraTypeInfo) { + if (extraTypeInfo === void 0) { extraTypeInfo = "SingleTexture"; } + var returnArray = new Array(); + var typeCnt = 0; + if (assetID > 0) { + if (this._blocks[assetID]) { + if (this._blocks[assetID].data) { + while (typeCnt < assetTypesToGet.length) { + var iasset = this._blocks[assetID].data; + if (iasset.assetType == assetTypesToGet[typeCnt]) { + //if the right assetType was found + if ((assetTypesToGet[typeCnt] == AssetType.TEXTURE) && (extraTypeInfo == "CubeTexture")) { + if (this._blocks[assetID].data instanceof ImageCubeTexture) { + returnArray.push(true); + returnArray.push(this._blocks[assetID].data); + return returnArray; + } + } + if ((assetTypesToGet[typeCnt] == AssetType.TEXTURE) && (extraTypeInfo == "SingleTexture")) { + if (this._blocks[assetID].data instanceof ImageTexture) { + returnArray.push(true); + returnArray.push(this._blocks[assetID].data); + return returnArray; + } + } + else { + returnArray.push(true); + returnArray.push(this._blocks[assetID].data); + return returnArray; + } + } + //if ((assetTypesToGet[typeCnt] == AssetType.GEOMETRY) && (IAsset(_blocks[assetID].data).assetType == AssetType.MESH)) { + if ((assetTypesToGet[typeCnt] == AssetType.GEOMETRY) && (iasset.assetType == AssetType.MESH)) { + var mesh = this._blocks[assetID].data; + returnArray.push(true); + returnArray.push(mesh.geometry); + return returnArray; + } + typeCnt++; + } + } + } + } + // if the has not returned anything yet, the asset is not found, or the found asset is not the right type. + returnArray.push(false); + returnArray.push(this.getDefaultAsset(assetTypesToGet[0], extraTypeInfo)); + return returnArray; + }; + AWDParser.prototype.getDefaultAsset = function (assetType, extraTypeInfo) { + switch (true) { + case (assetType == AssetType.TEXTURE): + if (extraTypeInfo == "CubeTexture") + return this.getDefaultCubeTexture(); + if (extraTypeInfo == "SingleTexture") + return this.getDefaultTexture(); + break; + case (assetType == AssetType.MATERIAL): + return this.getDefaultMaterial(); + break; + default: + break; + } + return null; + }; + AWDParser.prototype.getDefaultMaterial = function () { + if (!this._defaultBitmapMaterial) + this._defaultBitmapMaterial = DefaultMaterialManager.getDefaultMaterial(); + return this._defaultBitmapMaterial; + }; + AWDParser.prototype.getDefaultTexture = function () { + if (!this._defaultTexture) + this._defaultTexture = DefaultMaterialManager.getDefaultTexture(); + return this._defaultTexture; + }; + AWDParser.prototype.getDefaultCubeTexture = function () { + if (!this._defaultCubeTexture) { + var defaultBitmap = DefaultMaterialManager.createCheckeredBitmapData(); + this._defaultCubeTexture = new BitmapCubeTexture(defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap); + this._defaultCubeTexture.name = "defaultCubeTexture"; + } + return this._defaultCubeTexture; + }; + AWDParser.prototype.readNumber = function (precision) { + if (precision === void 0) { precision = false; } + if (precision) + return this._newBlockBytes.readDouble(); + return this._newBlockBytes.readFloat(); + }; + AWDParser.prototype.parseMatrix3D = function () { + return new Matrix3D(this.parseMatrix43RawData()); + }; + AWDParser.prototype.parseMatrix32RawData = function () { + var i; + var mtx_raw = new Array(6); + for (i = 0; i < 6; i++) { + mtx_raw[i] = this._newBlockBytes.readFloat(); + } + return mtx_raw; + }; + AWDParser.prototype.parseMatrix43RawData = function () { + var mtx_raw = new Array(16); + mtx_raw[0] = this.readNumber(this._accuracyMatrix); + mtx_raw[1] = this.readNumber(this._accuracyMatrix); + mtx_raw[2] = this.readNumber(this._accuracyMatrix); + mtx_raw[3] = 0.0; + mtx_raw[4] = this.readNumber(this._accuracyMatrix); + mtx_raw[5] = this.readNumber(this._accuracyMatrix); + mtx_raw[6] = this.readNumber(this._accuracyMatrix); + mtx_raw[7] = 0.0; + mtx_raw[8] = this.readNumber(this._accuracyMatrix); + mtx_raw[9] = this.readNumber(this._accuracyMatrix); + mtx_raw[10] = this.readNumber(this._accuracyMatrix); + mtx_raw[11] = 0.0; + mtx_raw[12] = this.readNumber(this._accuracyMatrix); + mtx_raw[13] = this.readNumber(this._accuracyMatrix); + mtx_raw[14] = this.readNumber(this._accuracyMatrix); + mtx_raw[15] = 1.0; + //TODO: fix max exporter to remove NaN values in joint 0 inverse bind pose + if (isNaN(mtx_raw[0])) { + mtx_raw[0] = 1; + mtx_raw[1] = 0; + mtx_raw[2] = 0; + mtx_raw[4] = 0; + mtx_raw[5] = 1; + mtx_raw[6] = 0; + mtx_raw[8] = 0; + mtx_raw[9] = 0; + mtx_raw[10] = 1; + mtx_raw[12] = 0; + mtx_raw[13] = 0; + mtx_raw[14] = 0; + } + return mtx_raw; + }; + AWDParser.COMPRESSIONMODE_LZMA = "lzma"; + AWDParser.UNCOMPRESSED = 0; + AWDParser.DEFLATE = 1; + AWDParser.LZMA = 2; + AWDParser.INT8 = 1; + AWDParser.INT16 = 2; + AWDParser.INT32 = 3; + AWDParser.UINT8 = 4; + AWDParser.UINT16 = 5; + AWDParser.UINT32 = 6; + AWDParser.FLOAT32 = 7; + AWDParser.FLOAT64 = 8; + AWDParser.BOOL = 21; + AWDParser.COLOR = 22; + AWDParser.BADDR = 23; + AWDParser.AWDSTRING = 31; + AWDParser.AWDBYTEARRAY = 32; + AWDParser.VECTOR2x1 = 41; + AWDParser.VECTOR3x1 = 42; + AWDParser.VECTOR4x1 = 43; + AWDParser.MTX3x2 = 44; + AWDParser.MTX3x3 = 45; + AWDParser.MTX4x3 = 46; + AWDParser.MTX4x4 = 47; + return AWDParser; +})(ParserBase); +module.exports = AWDParser; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/awdparser.ts"],"names":["AWDParser","AWDParser.constructor","AWDParser.supportsType","AWDParser.supportsData","AWDParser._iResolveDependency","AWDParser._iResolveDependencyFailure","AWDParser._iResolveDependencyName","AWDParser._pProceedParsing","AWDParser._pStartParsing","AWDParser.dispose","AWDParser.parseNextBlock","AWDParser.parseTriangleGeometrieBlock","AWDParser.parsePrimitves","AWDParser.parseContainer","AWDParser.parseMeshInstance","AWDParser.parseSkyboxInstance","AWDParser.parseLight","AWDParser.parseCamera","AWDParser.parseLightPicker","AWDParser.parseMaterial","AWDParser.parseMaterial_v1","AWDParser.parseTexture","AWDParser.parseCubeTexture","AWDParser.parseSharedMethodBlock","AWDParser.parseShadowMethodBlock","AWDParser.parseCommand","AWDParser.parseMetaData","AWDParser.parseNameSpace","AWDParser.parseShadowMethodList","AWDParser.parseSkeleton","AWDParser.parseSkeletonPose","AWDParser.parseSkeletonAnimation","AWDParser.parseMeshPoseAnimation","AWDParser.parseVertexAnimationSet","AWDParser.parseAnimatorSet","AWDParser.parseSharedMethodList","AWDParser.parseUserAttributes","AWDParser.parseProperties","AWDParser.parseAttrValue","AWDParser.parseHeader","AWDParser.getUVForVertexAnimation","AWDParser.parseVarStr","AWDParser.getAssetByID","AWDParser.getDefaultAsset","AWDParser.getDefaultMaterial","AWDParser.getDefaultTexture","AWDParser.getDefaultCubeTexture","AWDParser.readNumber","AWDParser.parseMatrix3D","AWDParser.parseMatrix32RawData","AWDParser.parseMatrix43RawData"],"mappings":"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AACA,SAASA,CAACA,MAAMA,CAACA,CAACA;QACzCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,GAAGA,CAACA,CAACA;QACtCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,KAAKA,CAACA,CAACA;QACxCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,MAAMA,CAACA,CAACA;QACzCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,UAAUA,CAACA,CAACA;QAC7CA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,KAAKA,CAACA,CAACA;QACxCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,SAASA,CAACA,CAACA;QAC5CA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,MAAMA,CAACA,CAACA;QACzCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,KAAKA,CAACA,CAACA;QACxCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,OAAOA,CAACA,CAACA;QAC1CA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,QAAQA,CAACA,CAACA;QAC3CA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,MAAMA,CAACA,CAACA;QACzCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,OAAOA,CAACA,CAACA;QAC1CA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,MAAMA,CAACA,CAACA;QACzCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,MAAMA,CAACA,CAACA;QACzCA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,SAASA,CAACA,OAAOA,CAACA,CAACA;QAE1CA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,KAAKA,EAAUA,EAAEA,6CAA6CA;QACvFA,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CA;QACzEA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,AACAA,6BAD6BA;YACHA,IAAIA,CAACA,SAAUA,CAACA,QAAQA,CAACA,IAAIA,CAACA,CAACA;QAC1DA,CAACA;QAEDA,EAAEA,CAACA,CAACA,SAASA,CAACA,MAAMA,IAAIA,CAACA,IAAIA,IAAIA,CAACA,SAASA,CAACA,MAAMA,IAAIA,CAACA,CAACA,CAACA,CAACA;YACzDA,IAAIA,CAACA,QAAQA,GAAGA,SAASA,CAACA,CAACA,CAACA,CAACA;QAC9BA,CAACA;QAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,SAASA,CAACA,MAAMA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACjCA,IAAIA,CAAQA,CAACA;YAIbA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,MAAMA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBAC5CA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA,CAACA,QAAQA,GAAGA,SAASA,CAACA,IAAIA,CAACA,GAAGA,CAACA,SAASA,CAACA,MAAMA,GAAGA,CAACA,EAAEA,CAACA,CAACA,CAACA,CAACA;YAC3EA,CAACA;QACFA,CAACA;QACDA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,CAACA,CAACA,CAACA;YACxDA,IAAIA,KAAKA,GAAiBA,IAAIA,CAACA,eAAeA,CAACA,EAACA,CAACA,EAACA,IAAIA,CAACA,aAAaA,EAAEA,CAACA,EAACA,IAAIA,CAACA,aAAaA,EAAEA,CAACA,EAACA,IAAIA,CAACA,aAAaA,EAAEA,CAACA,EAACA,SAASA,CAACA,KAAKA,EAAEA,CAACA,EAACA,SAASA,CAACA,IAAIA,EAACA,CAACA,CAACA;YACxJA,IAAIA,CAACA,KAAKA,GAAGA,IAAIA,QAAQA,CA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CA,CAACA,IAAIA,CAACA,CAACA,CAACA,CAACA;oBAC3BA,eAAeA,CAACA,YAAYA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,KAAKA,CAACA,GAAGA,CAACA,EAAEA,EAAEA,CAACA,CAACA,CAACA,CAACA;gBACrEA,CAACA;YACFA,CAACA;YAACA,IAAIA,CAACA,CAACA;gBACPA,EAAEA,CAACA,CAACA,KAAKA,CAACA,GAAGA,CAACA,EAAEA,EAAEA,CAACA,CAACA,IAAIA,CAACA,CAACA,CAACA,CAACA;oBAC3BA,eAAeA,CAACA,YAAYA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,KAAKA,CAACA,GAAGA,CAACA,EAAEA,EAAEA,CAACA,CAACA,CAACA,CAACA;gBACrEA,CAACA;YACFA,CAACA;YAEDA,KAAKA,CAACA,YAAYA,GAAGA,eAAeA,CAACA;YACrCA,KAAKA,CAACA,YAAYA,GAAGA,IAAIA,CAACA;QAC3BA,CAACA;QAEDA,EAAEA,CAACA,CAACA,MAAMA,IAAIA,CAACA,CAACA,CAACA,CAACA;YAEjBA,IAAIA,mBAAmBA,GAAcA,IAAIA,CAACA,YAAYA,CAACA,MAAMA,EAAEA,CAACA,SAASA,CAACA,SAASA,EAAEA,SAASA,CAACA,KAAKA,EAAEA,SAASA,CAACA,IAAIA,CAACA,CAACA,CAAAA;YAEtHA,EAAEA,CAACA,CAACA,mBAAmBA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;gBACFA,mBAAmBA,CAACA,CAACA,CAAEA,CAACA,QAAQA,CAACA,KAAKA,CAACA,CAACA;gBAClEA,UAAUA,GAA6BA,mBAAmBA,CAACA,CAACA,CAAEA,CAACA,IAAIA,CAACA;YACrEA,CAACA;YAACA,IAAIA,CAACA,CAACA;gBACPA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,QAAQA,CAACA,wCAAwCA,CAACA,CAACA;YAC1EA,CAACA;QACFA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,AACAA,6BAD6BA;YACHA,IAAIA,CAACA,SAAUA,CAACA,QAAQA,CAACA,KAAKA,C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A,CAACA,CAACA;YAClBA,KAAKA,GAAGA,IAAIA,CAACA,eAAeA,CAACA,EAACA,CAACA,EAACA,IAAIA,CAACA,aAAaA,EAAEA,CAACA,EAACA,IAAIA,CAACA,aAAaA,EAAEA,CAACA,EAACA,IAAIA,CAACA,aAAaA,EAAEA,CAACA,EAACA,SAASA,CAACA,KAAKA,EAACA,CAACA,CAACA;YAEpHA,YAAYA,CAACA,KAAKA,GAAGA,IAAIA,QAAQA,CAACA,KAAKA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,EAAEA,KAAKA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,EAAEA,KAAKA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA,CAACA;YACrFA,YAAYA,CAACA,KAAKA,GAAGA,IAAIA,CAACA,mBAAmBA,EAAEA,CAACA;QAEjDA,CAACA;QACDA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,IAAIA,GAAGA,YAAYA,CAAAA;QAEzCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,MAAMA,CAACA,CAACA,CAACA;YACjBA,OAAOA,CAACA,GAAGA,CAACA,iCAAiCA,GAAGA,IAAIA,CAACA,CAACA;QACvDA,CAACA;IAEFA,CAACA;IAEDzB,aAAaA;IACLA,iCAAaA,GAArBA,UAAsBA,OAAcA;QAEnC0B,IAAIA,KAAKA,GAAiBA,IAAIA,CAACA,eAAeA,CAACA,EAACA,CAACA,EAACA,SAASA,CAACA,MAAMA,EAAEA,CAACA,EAACA,SAASA,CAACA,SAASA,EAAEA,CAACA,EAACA,SAASA,CAACA,SAASA,EAAEA,CAACA,EAACA,SAASA,CAACA,SAASA,EAAEA,CAACA,EAACA,SAASA,CAACA,SAASA,EAACA,CAACA,CAACA;QAEjKA,EAAEA,CAACA,CAACA,IAAIA,CAACA,MAAMA,CAACA,CAACA,CAACA;YACjBA,OAAOA,CAACA,GAAGA,CAACA,8CAA8CA,GAAGA,KAAKA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA,CAACA;YAC9EA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A,CAACA,CAACA;YACrEA,EAAEA,CAACA,CAACA,aAAaA,CAACA,CAACA,CAACA,CAACA;gBACpBA,YAAYA,CAACA,IAAIA,CAAQA,aAAaA,CAACA,CAACA,CAACA,CAACA,CAACA;QAC7CA,CAACA;QACDA,aAAaA,GAAGA,IAAIA,CAACA,YAAYA,CAACA,kBAAkBA,EAAEA,CAACA,SAASA,CAACA,aAAaA,CAACA,CAACA,CAACA;QACjFA,EAAEA,CAACA,CAACA,CAACA,aAAaA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;YACvBA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,QAAQA,CAACA,oCAAoCA,GAAGA,kBAAkBA,GAAGA,sBAAsBA,CAACA,CAACA;YAAAA,CAACA;YACpHA,MAAMA,CAAAA;QACPA,CAACA;QACDA,kBAAkBA,GAAsBA,aAAaA,CAACA,CAACA,CAACA,CAACA;QACzDA,IAAIA,YAAyBA,CAACA;QAC9BA,EAAEA,CAACA,CAACA,IAAIA,IAAIA,CAACA,CAACA,CAACA,CAACA;YAEfA,aAAaA,GAAGA,IAAIA,CAACA,YAAYA,CAACA,KAAKA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,EAAEA,CAACA,SAASA,CAACA,QAAQA,CAACA,CAACA,CAACA;YACzEA,EAAEA,CAACA,CAACA,CAACA,aAAaA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;gBACvBA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,QAAQA,CAACA,gCAAgCA,GAAGA,KAAKA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,GAAGA,sBAAsBA,CAACA,CAACA;gBAC5GA,MAAMA,CAAAA;YACPA,CAACA;YACDA,YAAYA,GAAGA,IAAIA,gBAAgBA,CAAwBA,kBAAkBA,EAAaA,aAAaA,CAACA,CAACA,CAACA,CAACA,CAACA;QAE7GA,CAACA;QAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,IAAIA,IAAIA,CAACA,CAACA;YACpBA,YAAYA,GAAGA,IAAIA,cAAcA,CAA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CAACA,MAAMA;gBACpBA,QAAQA,GAAGA,CAACA,CAACA;gBACbA,SAASA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,iBAAiBA,CAACA;gBAClDA,KAAKA,CAACA;YAEPA,KAAKA,SAASA,CAACA,MAAMA,CAACA;YACtBA,KAAKA,SAASA,CAACA,KAAKA,CAACA;YACrBA,KAAKA,SAASA,CAACA,KAAKA;gBACnBA,QAAQA,GAAGA,CAACA,CAACA;gBACbA,SAASA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,eAAeA,CAACA;gBAChDA,KAAKA,CAACA;YAEPA,KAAKA,SAASA,CAACA,OAAOA;gBACrBA,QAAQA,GAAGA,CAACA,CAACA;gBACbA,SAASA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,SAASA,CAACA;gBAC1CA,KAAKA,CAACA;YAEPA,KAAKA,SAASA,CAACA,OAAOA;gBACrBA,QAAQA,GAAGA,CAACA,CAACA;gBACbA,SAASA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,UAAUA,CAACA;gBAC3CA,KAAKA,CAACA;YAEPA,KAAKA,SAASA,CAACA,SAASA;gBACvBA,MAAMA,CAACA,IAAIA,CAACA,cAAcA,CAACA,YAAYA,CAACA,GAAGA,CAACA,CAACA;YAE9CA,KAAKA,SAASA,CAACA,SAASA,CAACA;YACzBA,KAAKA,SAASA,CAACA,SAASA,CAACA;YACzBA,KAAKA,SAASA,CAACA,SAASA,CAACA;YACzBA,KAAKA,SAASA,CAACA,MAAMA,CAACA;YACtBA,KAAKA,SAASA,CAACA,MAAMA,CAACA;YACtBA,KAAKA,SAASA,CAACA,MAAMA,CAACA;YACtBA,KAAKA,SAASA,CAACA,MAAMA;gBACpBA,QAAQA,GAAGA,CAACA,CAACA;gBACbA,SAASA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,UAAUA,CAACA;gBAC3CA,KAAKA,CAACA;QAERA,CAACA;QAEDA,EAAEA,CAACA,CAACA,QAAQA,GAAGA,GAAGA,CAACA,CAACA,CAACA;YACpBA,IAAIA,IAAIA,GAAcA,EAAEA,CAACA;YACzBA,IAAIA,QAAQA,GA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,CAACA,CAACA;gCAC3FA,EAAEA,CAACA,CAACA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,IAAIA,YAAYA,YAAYA,CAACA,CAACA,CAACA;oCACxDA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,CAACA;oCACvBA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,IAAIA,CAACA,CAACA;oCAC7CA,MAAMA,CAACA,WAAWA,CAACA;gCACpBA,CAACA;4BACFA,CAACA;4BAACA,IAAIA,CAACA,CAACA;gCACPA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,CAACA;gCACvBA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,IAAIA,CAACA,CAACA;gCAC7CA,MAAMA,CAACA,WAAWA,CAACA;4BAEpBA,CAACA;wBACFA,CAACA;wBACDA,AACAA,wHADwHA;wBACxHA,EAAEA,CAACA,CAACA,CAACA,eAAeA,CAACA,OAAOA,CAACA,IAAIA,SAASA,CAACA,QAAQA,CAACA,IAAIA,CAACA,MAAMA,CAACA,SAASA,IAAIA,SAASA,CAACA,IAAIA,CAACA,CAACA,CAACA,CAACA;4BAE9FA,IAAIA,IAAIA,GAAeA,IAAIA,CAACA,OAAOA,CAACA,OAAOA,CAACA,CAACA,IAAIA,CAAAA;4BAEjDA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,CAACA;4BACvBA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,QAAQA,CAACA,CAACA;4BAChCA,MAAMA,CAACA,WAAWA,CAACA;wBAEpBA,CAACA;wBAEDA,OAAOA,EAAEA,CAACA;oBACXA,CAACA;gBACFA,CAACA;YACFA,CAACA;QACFA,CAACA;QACDA,AACAA,0GAD0GA;QAC1GA,WAAWA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;QACxBA,WAAWA,CAACA,IAAIA,CAACA,IAAIA,CAACA,eAAeA,CAACA,eAAeA,CAACA,CAACA,CAACA,EAAEA,aAAaA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CA,CAACA;QACnDA,OAAOA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACnDA,OAAOA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA;QACjBA,OAAOA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACnDA,OAAOA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACnDA,OAAOA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACnDA,OAAOA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA;QACjBA,OAAOA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACnDA,OAAOA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACnDA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACpDA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,CAACA;QAClBA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACpDA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACpDA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA;QACpDA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,CAACA;QAElBA,AAEAA,0EAF0EA;QAE1EA,EAAEA,CAACA,CAACA,KAAKA,CAACA,OAAOA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;YACvBA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACfA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAChBA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAChBA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;YAChBA,OAAOA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;QAEjBA,CAACA;QAEDA,MAAMA,CAACA,OAAOA,CAACA;IAChBA,CAACA;IAhoFalD,8BAAoBA,GAAUA,MAAMA,CAACA;IACrCA,sBAAYA,GAAUA,CAACA,CAACA;IACxBA,iBAAOA,GAAUA,CAACA,CAACA;IACnBA,cAAIA,GAAUA,CAACA,CAACA;IAChBA,cAAIA,GAAUA,CAACA,CAACA;IAChBA,eAAKA,GAAUA,CAACA,CAACA;IACjBA,eAAKA,GAAUA,CAACA,CAACA;IACjBA,eAAKA,GAAUA,CAACA,CAACA;IACjBA,gBAAMA,GAAUA,CAACA,CAACA;IAClBA,gBAAMA,GAAUA,CAACA,CAACA;IAClBA,iBAAOA,GAAUA,CAACA,CAACA;IACnBA,iBAAOA,GAAUA,CAACA,CAACA;IACnBA,cAAIA,GAAUA,EAAEA,CAACA;IACjBA,eAAKA,GAAUA,EAAEA,CAACA;IAClBA,eAAKA,GAAUA,EAAEA,CAACA;IAClBA,mBAASA,GAAUA,EAAEA,CAACA;IACtBA,sBAAYA,GAAUA,EAAEA,CAACA;IACzBA,mBAASA,GAAUA,EAAEA,CAACA;IACtBA,mBAASA,GAAUA,EAAEA,CAACA;IACtBA,mBAASA,GAAUA,EAAEA,CAACA;IACtBA,gBAAMA,GAAUA,EAAEA,CAACA;IACnBA,gBAAMA,GAAUA,EAAEA,CAACA;IACnBA,gBAAMA,GAAUA,EAAEA,CAACA;IACnBA,gBAAMA,GAAUA,EAAEA,CAACA;IA2mFlCA,gBAACA;AAADA,CA7pFA,AA6pFCA,EA7pFuB,UAAU,EA6pFjC;AAED,AAAmB,iBAAV,SAAS,CAAC","file":"parsers/AWDParser.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObjectContainer\t\t\t= require(\"awayjs-core/lib/containers/DisplayObjectContainer\");\nimport BitmapData\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/BitmapData\");\nimport BlendMode\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/BlendMode\");\nimport DisplayObject\t\t\t\t\t= require(\"awayjs-core/lib/core/base/DisplayObject\");\nimport Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport LightBase\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/LightBase\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport ColorTransform\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/ColorTransform\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport URLLoaderDataFormat\t\t\t\t= require(\"awayjs-core/lib/core/net/URLLoaderDataFormat\");\nimport URLRequest\t\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport AssetType\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport DirectionalLight\t\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\nimport PointLight\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/PointLight\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport Skybox\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Skybox\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\nimport LightPickerBase\t\t\t\t\t= require(\"awayjs-core/lib/materials/lightpickers/LightPickerBase\");\nimport StaticLightPicker\t\t\t\t= require(\"awayjs-core/lib/materials/lightpickers/StaticLightPicker\");\nimport CubeMapShadowMapper\t\t\t\t= require(\"awayjs-core/lib/materials/shadowmappers/CubeMapShadowMapper\");\nimport DirectionalShadowMapper\t\t\t= require(\"awayjs-core/lib/materials/shadowmappers/DirectionalShadowMapper\");\nimport ShadowMapperBase\t\t\t\t\t= require(\"awayjs-core/lib/materials/shadowmappers/ShadowMapperBase\");\nimport PrefabBase\t\t\t\t\t\t= require(\"awayjs-core/lib/prefabs/PrefabBase\");\nimport PrimitiveCapsulePrefab\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveCapsulePrefab\");\nimport PrimitiveConePrefab\t\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveConePrefab\");\nimport PrimitiveCubePrefab\t\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveCubePrefab\");\nimport PrimitiveCylinderPrefab\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveCylinderPrefab\");\nimport PrimitivePlanePrefab\t\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitivePlanePrefab\");\nimport PrimitiveSpherePrefab\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveSpherePrefab\");\nimport PrimitiveTorusPrefab\t\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveTorusPrefab\");\nimport ParserBase\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserBase\");\nimport ParserUtils\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserUtils\");\nimport ResourceDependency\t\t\t\t= require(\"awayjs-core/lib/parsers/ResourceDependency\");\nimport ProjectionBase\t\t\t\t\t= require(\"awayjs-core/lib/projections/ProjectionBase\");\nimport PerspectiveProjection\t\t\t= require(\"awayjs-core/lib/projections/PerspectiveProjection\");\nimport OrthographicProjection\t\t\t= require(\"awayjs-core/lib/projections/OrthographicProjection\");\nimport OrthographicOffCenterProjection\t= require(\"awayjs-core/lib/projections/OrthographicOffCenterProjection\");\nimport BitmapCubeTexture\t\t\t\t= require(\"awayjs-core/lib/textures/BitmapCubeTexture\");\nimport BitmapTexture\t\t\t\t\t= require(\"awayjs-core/lib/textures/BitmapTexture\");\nimport CubeTextureBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/CubeTextureBase\");\nimport ImageCubeTexture\t\t\t\t\t= require(\"awayjs-core/lib/textures/ImageCubeTexture\");\nimport ImageTexture\t\t\t\t\t\t= require(\"awayjs-core/lib/textures/ImageTexture\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\nimport TextureProxyBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/TextureProxyBase\");\nimport ByteArray\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/ByteArray\");\n\nimport AnimationSetBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimationSetBase\");\nimport AnimatorBase\t\t\t\t\t\t= require(\"awayjs-stagegl/lib/animators/AnimatorBase\");\nimport SkyboxMaterial\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/SkyboxMaterial\");\nimport TriangleMaterialMode\t\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMaterialMode\");\nimport TriangleMethodMaterial\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\nimport DefaultMaterialManager\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/DefaultMaterialManager\");\n\nimport VertexAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/VertexAnimationSet\");\nimport VertexAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/VertexAnimator\");\nimport SkeletonAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/SkeletonAnimationSet\");\nimport SkeletonAnimator\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/SkeletonAnimator\");\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport SkeletonJoint\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonJoint\");\nimport SkeletonClipNode\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/SkeletonClipNode\");\nimport VertexClipNode\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/VertexClipNode\");\nimport AmbientEnvMapMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/AmbientEnvMapMethod\");\nimport DiffuseDepthMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseDepthMethod\");\nimport DiffuseCelMethod\t\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseCelMethod\");\nimport DiffuseGradientMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseGradientMethod\");\nimport DiffuseLightMapMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseLightMapMethod\");\nimport DiffuseWrapMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/DiffuseWrapMethod\");\nimport EffectAlphaMaskMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/EffectAlphaMaskMethod\");\nimport EffectColorMatrixMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/EffectColorMatrixMethod\");\nimport EffectColorTransformMethod\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectColorTransformMethod\");\nimport EffectEnvMapMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/EffectEnvMapMethod\");\nimport EffectFogMethod\t\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/EffectFogMethod\");\nimport EffectFresnelEnvMapMethod\t\t= require(\"awayjs-renderergl/lib/materials/methods/EffectFresnelEnvMapMethod\");\nimport EffectLightMapMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/EffectLightMapMethod\");\nimport EffectMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/EffectMethodBase\");\nimport EffectRimLightMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/EffectRimLightMethod\");\nimport NormalSimpleWaterMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/NormalSimpleWaterMethod\");\nimport ShadowDitheredMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/ShadowDitheredMethod\");\nimport ShadowFilteredMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/ShadowFilteredMethod\");\nimport ShadowMethodBase\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowMethodBase\");\nimport SpecularFresnelMethod\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/SpecularFresnelMethod\");\nimport ShadowHardMethod\t\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/ShadowHardMethod\");\nimport SpecularAnisotropicMethod\t\t= require(\"awayjs-renderergl/lib/materials/methods/SpecularAnisotropicMethod\");\nimport SpecularCelMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/SpecularCelMethod\");\nimport SpecularPhongMethod\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/SpecularPhongMethod\");\nimport ShadowNearMethod\t\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/ShadowNearMethod\");\nimport ShadowSoftMethod\t\t\t\t\t= require(\"awayjs-renderergl/lib/materials/methods/ShadowSoftMethod\");\n\nimport AWDBlock\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/AWDBlock\");\nimport AWDProperties\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/AWDProperties\");\nimport BitFlags\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/BitFlags\");\n\n/**\n * AWDParser provides a parser for the AWD data type.\n */\nclass AWDParser extends ParserBase\n{\n\t//set to \"true\" to have some console.logs in the Console\n\tprivate _debug:boolean = false;\n\tprivate _byteData:ByteArray;\n\tprivate _startedParsing:boolean = false;\n\tprivate _cur_block_id:number;\n\tprivate _blocks:Array<AWDBlock>;\n\tprivate _newBlockBytes:ByteArray;\n\tprivate _version:Array<number>;\n\tprivate _compression:number;\n\tprivate _accuracyOnBlocks:boolean;\n\tprivate _accuracyMatrix:boolean;\n\tprivate _accuracyGeo:boolean;\n\tprivate _accuracyProps:boolean;\n\tprivate _matrixNrType:number;\n\tprivate _geoNrType:number;\n\tprivate _propsNrType:number;\n\tprivate _streaming:boolean;\n\tprivate _texture_users:Object = {};\n\tprivate _parsed_header:boolean = false;\n\tprivate _body:ByteArray;\n\tprivate _defaultTexture:BitmapTexture;     // HTML IMAGE TEXTURE >? !\n\tprivate _cubeTextures:Array<any>;\n\tprivate _defaultBitmapMaterial:TriangleMethodMaterial;\n\tprivate _defaultCubeTexture:BitmapCubeTexture;\n\n\tpublic static COMPRESSIONMODE_LZMA:string = \"lzma\";\n\tpublic static UNCOMPRESSED:number = 0;\n\tpublic static DEFLATE:number = 1;\n\tpublic static LZMA:number = 2;\n\tpublic static INT8:number = 1;\n\tpublic static INT16:number = 2;\n\tpublic static INT32:number = 3;\n\tpublic static UINT8:number = 4;\n\tpublic static UINT16:number = 5;\n\tpublic static UINT32:number = 6;\n\tpublic static FLOAT32:number = 7;\n\tpublic static FLOAT64:number = 8;\n\tpublic static BOOL:number = 21;\n\tpublic static COLOR:number = 22;\n\tpublic static BADDR:number = 23;\n\tpublic static AWDSTRING:number = 31;\n\tpublic static AWDBYTEARRAY:number = 32;\n\tpublic static VECTOR2x1:number = 41;\n\tpublic static VECTOR3x1:number = 42;\n\tpublic static VECTOR4x1:number = 43;\n\tpublic static MTX3x2:number = 44;\n\tpublic static MTX3x3:number = 45;\n\tpublic static MTX4x3:number = 46;\n\tpublic static MTX4x4:number = 47;\n\n\tprivate blendModeDic:Array<string>;\n\tprivate _depthSizeDic:Array<number>;\n\n\t/**\n\t * Creates a new AWDParser object.\n\t * @param uri The url or id of the data or file to be parsed.\n\t * @param extra The holder for extra contextual data that the parser might need.\n\t */\n\tconstructor()\n\t{\n\t\tsuper(URLLoaderDataFormat.ARRAY_BUFFER);\n\n\t\tthis._blocks = new Array<AWDBlock>();\n\t\tthis._blocks[0] = new AWDBlock();\n\t\tthis._blocks[0].data = null; // Zero address means null in AWD\n\n\t\tthis.blendModeDic = new Array<string>(); // used to translate ints to blendMode-strings\n\t\tthis.blendModeDic.push(BlendMode.NORMAL);\n\t\tthis.blendModeDic.push(BlendMode.ADD);\n\t\tthis.blendModeDic.push(BlendMode.ALPHA);\n\t\tthis.blendModeDic.push(BlendMode.DARKEN);\n\t\tthis.blendModeDic.push(BlendMode.DIFFERENCE);\n\t\tthis.blendModeDic.push(BlendMode.ERASE);\n\t\tthis.blendModeDic.push(BlendMode.HARDLIGHT);\n\t\tthis.blendModeDic.push(BlendMode.INVERT);\n\t\tthis.blendModeDic.push(BlendMode.LAYER);\n\t\tthis.blendModeDic.push(BlendMode.LIGHTEN);\n\t\tthis.blendModeDic.push(BlendMode.MULTIPLY);\n\t\tthis.blendModeDic.push(BlendMode.NORMAL);\n\t\tthis.blendModeDic.push(BlendMode.OVERLAY);\n\t\tthis.blendModeDic.push(BlendMode.SCREEN);\n\t\tthis.blendModeDic.push(BlendMode.SHADER);\n\t\tthis.blendModeDic.push(BlendMode.OVERLAY);\n\n\t\tthis._depthSizeDic = new Array<number>(); // used to translate ints to depthSize-values\n\t\tthis._depthSizeDic.push(256);\n\t\tthis._depthSizeDic.push(512);\n\t\tthis._depthSizeDic.push(2048);\n\t\tthis._depthSizeDic.push(1024);\n\t\tthis._version = Array<number>(); // will contain 2 int (major-version, minor-version) for awd-version-check\n\t}\n\n\t/**\n\t * Indicates whether or not a given file extension is supported by the parser.\n\t * @param extension The file extension of a potential file to be parsed.\n\t * @return Whether or not the given file type is supported.\n\t */\n\tpublic static supportsType(extension:string):boolean\n\t{\n\t\textension = extension.toLowerCase();\n\t\treturn extension == \"awd\";\n\t}\n\n\t/**\n\t * Tests whether a data block can be parsed by the parser.\n\t * @param data The data block to potentially be parsed.\n\t * @return Whether or not the given data is supported.\n\t */\n\tpublic static supportsData(data:any):boolean\n\t{\n\t\treturn (ParserUtils.toString(data, 3) == 'AWD');\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependency(resourceDependency:ResourceDependency):void\n\t{\n\t\t// this will be called when Dependency has finished loading.\n\t\t// the Assets waiting for this Bitmap, can be Texture or CubeTexture.\n\t\t// if the Bitmap is awaited by a CubeTexture, we need to check if its the last Bitmap of the CubeTexture,\n\t\t// so we know if we have to finalize the Asset (CubeTexture) or not.\n\t\tif (resourceDependency.assets.length == 1) {\n\t\t\tvar isCubeTextureArray:Array<string> = resourceDependency.id.split(\"#\");\n\t\t\tvar ressourceID:string = isCubeTextureArray[0];\n\t\t\tvar asset:TextureProxyBase;\n\t\t\tvar thisBitmapTexture:Texture2DBase;\n\t\t\tvar block:AWDBlock;\n\n\t\t\tif (isCubeTextureArray.length == 1) // Not a cube texture\n\t\t\t{\n\t\t\t\tasset = <Texture2DBase> resourceDependency.assets[0];\n\t\t\t\tif (asset) {\n\t\t\t\t\tvar mat:TriangleMethodMaterial;\n\t\t\t\t\tvar users:Array<string>;\n\n\t\t\t\t\tblock = this._blocks[ resourceDependency.id ];\n\t\t\t\t\tblock.data = asset; // Store finished asset\n\n\t\t\t\t\t// Reset name of texture to the one defined in the AWD file,\n\t\t\t\t\t// as opposed to whatever the image parser came up with.\n\t\t\t\t\tasset.resetAssetPath(block.name, null, true);\n\t\t\t\t\tblock.name = asset.name;\n\t\t\t\t\t// Finalize texture asset to dispatch texture event, which was\n\t\t\t\t\t// previously suppressed while the dependency was loaded.\n\t\t\t\t\tthis._pFinalizeAsset(<IAsset> asset);\n\n\t\t\t\t\tif (this._debug) {\n\t\t\t\t\t\tconsole.log(\"Successfully loaded Bitmap for texture\");\n\t\t\t\t\t\tconsole.log(\"Parsed texture: Name = \" + block.name);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (isCubeTextureArray.length > 1) // Cube Texture\n\t\t\t{\n\t\t\t\tthisBitmapTexture = <BitmapTexture> resourceDependency.assets[0];\n\n\t\t\t\tvar tx:ImageTexture = <ImageTexture> thisBitmapTexture;\n\n\t\t\t\tthis._cubeTextures[ isCubeTextureArray[1] ] = tx.htmlImageElement; // ?\n\t\t\t\tthis._texture_users[ressourceID].push(1);\n\n\t\t\t\tif (this._debug) {\n\t\t\t\t\tconsole.log(\"Successfully loaded Bitmap \" + this._texture_users[ressourceID].length + \" / 6 for Cubetexture\");\n\t\t\t\t}\n\t\t\t\tif (this._texture_users[ressourceID].length == this._cubeTextures.length) {\n\n\t\t\t\t\tvar posX:any = this._cubeTextures[0];\n\t\t\t\t\tvar negX:any = this._cubeTextures[1];\n\t\t\t\t\tvar posY:any = this._cubeTextures[2];\n\t\t\t\t\tvar negY:any = this._cubeTextures[3];\n\t\t\t\t\tvar posZ:any = this._cubeTextures[4];\n\t\t\t\t\tvar negZ:any = this._cubeTextures[5];\n\n\t\t\t\t\tasset = <TextureProxyBase> new ImageCubeTexture(posX, negX, posY, negY, posZ, negZ);\n\t\t\t\t\tblock = this._blocks[ressourceID];\n\t\t\t\t\tblock.data = asset; // Store finished asset\n\n\t\t\t\t\t// Reset name of texture to the one defined in the AWD file,\n\t\t\t\t\t// as opposed to whatever the image parser came up with.\n\t\t\t\t\tasset.resetAssetPath(block.name, null, true);\n\t\t\t\t\tblock.name = asset.name;\n\t\t\t\t\t// Finalize texture asset to dispatch texture event, which was\n\t\t\t\t\t// previously suppressed while the dependency was loaded.\n\t\t\t\t\tthis._pFinalizeAsset(<IAsset> asset);\n\t\t\t\t\tif (this._debug) {\n\t\t\t\t\t\tconsole.log(\"Parsed CubeTexture: Name = \" + block.name);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependencyFailure(resourceDependency:ResourceDependency):void\n\t{\n\t\t//not used - if a dependcy fails, the awaiting Texture or CubeTexture will never be finalized, and the default-bitmaps will be used.\n\t\t// this means, that if one Bitmap of a CubeTexture fails, the CubeTexture will have the DefaultTexture applied for all six Bitmaps.\n\t}\n\n\t/**\n\t * Resolve a dependency name\n\t *\n\t * @param resourceDependency The dependency to be resolved.\n\t */\n\tpublic _iResolveDependencyName(resourceDependency:ResourceDependency, asset:IAsset):string\n\t{\n\t\tvar oldName:string = asset.name;\n\n\t\tif (asset) {\n\t\t\tvar block:AWDBlock = this._blocks[parseInt(resourceDependency.id)];\n\t\t\t// Reset name of texture to the one defined in the AWD file,\n\t\t\t// as opposed to whatever the image parser came up with.\n\t\t\tasset.resetAssetPath(block.name, null, true);\n\t\t}\n\n\t\tvar newName:string = asset.name;\n\n\t\tasset.name = oldName;\n\n\t\treturn newName;\n\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pProceedParsing():boolean\n\t{\n\n\t\tif (!this._startedParsing) {\n\t\t\tthis._byteData = this._pGetByteData();//getByteData();\n\t\t\tthis._startedParsing = true;\n\t\t}\n\n\t\tif (!this._parsed_header) {\n\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t// LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t//this._byteData.endian = Endian.LITTLE_ENDIAN;\n\t\t\t//----------------------------------------------------------------------------\n\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t// Parse header and decompress body if needed\n\t\t\tthis.parseHeader();\n\n\t\t\tswitch (this._compression) {\n\n\t\t\t\tcase AWDParser.DEFLATE:\n\t\t\t\tcase AWDParser.LZMA:\n\t\t\t\t\tthis._pDieWithError('Compressed AWD formats not yet supported');\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AWDParser.UNCOMPRESSED:\n\t\t\t\t\tthis._body = this._byteData;\n\t\t\t\t\tbreak;\n\n\t\t\t\t//----------------------------------------------------------------------------\n\t\t\t\t// Compressed AWD Formats not yet supported\n\t\t\t\t//----------------------------------------------------------------------------\n\n\t\t\t\t/*\n\t\t\t\t case AWDParser.DEFLATE:\n\n\t\t\t\t this._body = new ByteArray();\n\t\t\t\t this._byteData.readBytes(this._body, 0, this._byteData.getBytesAvailable());\n\t\t\t\t this._body.uncompress();\n\n\t\t\t\t break;\n\t\t\t\t case AWDParser.LZMA:\n\n\t\t\t\t this._body = new ByteArray();\n\t\t\t\t this._byteData.readBytes(this._body, 0, this._byteData.getBytesAvailable());\n\t\t\t\t this._body.uncompress(COMPRESSIONMODE_LZMA);\n\n\t\t\t\t break;\n\t\t\t\t //*/\n\n\t\t\t}\n\n\t\t\tthis._parsed_header = true;\n\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t// LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t//this._body.endian = Endian.LITTLE_ENDIAN;// Should be default\n\t\t\t//----------------------------------------------------------------------------\n\n\t\t}\n\n\t\tif (this._body) {\n\n\t\t\twhile (this._body.getBytesAvailable() > 0 && !this.parsingPaused) //&& this._pHasTime() )\n\t\t\t{\n\t\t\t\tthis.parseNextBlock();\n\n\t\t\t}\n\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t// Return complete status\n\t\t\tif (this._body.getBytesAvailable() == 0) {\n\t\t\t\tthis.dispose();\n\t\t\t\treturn  ParserBase.PARSING_DONE;\n\t\t\t} else {\n\t\t\t\treturn  ParserBase.MORE_TO_PARSE;\n\t\t\t}\n\t\t} else {\n\n\t\t\tswitch (this._compression) {\n\n\t\t\t\tcase AWDParser.DEFLATE:\n\t\t\t\tcase AWDParser.LZMA:\n\n\t\t\t\t\tif (this._debug) {\n\t\t\t\t\t\tconsole.log(\"(!) AWDParser Error: Compressed AWD formats not yet supported (!)\");\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\t\t\t// Error - most likely _body not set because we do not support compression.\n\t\t\treturn  ParserBase.PARSING_DONE;\n\n\t\t}\n\n\t}\n\n\tpublic _pStartParsing(frameLimit:number)\n\t{\n\t\tsuper._pStartParsing(frameLimit);\n\n\t\t//create a content object for Loaders\n\t\tthis._pContent = new DisplayObjectContainer();\n\t}\n\n\tprivate dispose():void\n\t{\n\n\t\tfor (var c in this._blocks) {\n\n\t\t\tvar b:AWDBlock = <AWDBlock> this._blocks[ c ];\n\t\t\tb.dispose();\n\n\t\t}\n\n\t}\n\n\tprivate parseNextBlock():void\n\t{\n\t\tvar block:AWDBlock;\n\t\tvar assetData:IAsset;\n\t\tvar isParsed:boolean = false;\n\t\tvar ns:number;\n\t\tvar type:number;\n\t\tvar flags:number;\n\t\tvar len:number;\n\n\t\tthis._cur_block_id = this._body.readUnsignedInt();\n\n\t\tns = this._body.readUnsignedByte();\n\t\ttype = this._body.readUnsignedByte();\n\t\tflags = this._body.readUnsignedByte();\n\t\tlen = this._body.readUnsignedInt();\n\n\t\tvar blockCompression:boolean = BitFlags.test(flags, BitFlags.FLAG4);\n\t\tvar blockCompressionLZMA:boolean = BitFlags.test(flags, BitFlags.FLAG5);\n\n\t\tif (this._accuracyOnBlocks) {\n\t\t\tthis._accuracyMatrix = BitFlags.test(flags, BitFlags.FLAG1);\n\t\t\tthis._accuracyGeo = BitFlags.test(flags, BitFlags.FLAG2);\n\t\t\tthis._accuracyProps = BitFlags.test(flags, BitFlags.FLAG3);\n\t\t\tthis._geoNrType = AWDParser.FLOAT32;\n\n\t\t\tif (this._accuracyGeo) {\n\t\t\t\tthis._geoNrType = AWDParser.FLOAT64;\n\t\t\t}\n\n\t\t\tthis._matrixNrType = AWDParser.FLOAT32;\n\n\t\t\tif (this._accuracyMatrix) {\n\t\t\t\tthis._matrixNrType = AWDParser.FLOAT64;\n\t\t\t}\n\n\t\t\tthis._propsNrType = AWDParser.FLOAT32;\n\n\t\t\tif (this._accuracyProps) {\n\t\t\t\tthis._propsNrType = AWDParser.FLOAT64;\n\t\t\t}\n\t\t}\n\n\t\tvar blockEndAll:number = this._body.position + len;\n\n\t\tif (len > this._body.getBytesAvailable()) {\n\t\t\tthis._pDieWithError('AWD2 block length is bigger than the bytes that are available!');\n\t\t\tthis._body.position += this._body.getBytesAvailable();\n\t\t\treturn;\n\t\t}\n\t\tthis._newBlockBytes = new ByteArray();\n\n\n\t\tthis._body.readBytes(this._newBlockBytes, 0, len);\n\n\t\t//----------------------------------------------------------------------------\n\t\t// Compressed AWD Formats not yet supported\n\n\t\tif (blockCompression) {\n\t\t\tthis._pDieWithError('Compressed AWD formats not yet supported');\n\n\t\t\t/*\n\t\t\t if (blockCompressionLZMA)\n\t\t\t {\n\t\t\t this._newBlockBytes.uncompress(AWDParser.COMPRESSIONMODE_LZMA);\n\t\t\t }\n\t\t\t else\n\t\t\t {\n\t\t\t this._newBlockBytes.uncompress();\n\t\t\t }\n\t\t\t */\n\n\t\t}\n\n\t\t//----------------------------------------------------------------------------\n\t\t// LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray\n\t\t//----------------------------------------------------------------------------\n\t\t//this._newBlockBytes.endian = Endian.LITTLE_ENDIAN;\n\t\t//----------------------------------------------------------------------------\n\n\t\tthis._newBlockBytes.position = 0;\n\t\tblock = new AWDBlock();\n\t\tblock.len = this._newBlockBytes.position + len;\n\t\tblock.id = this._cur_block_id;\n\n\t\tvar blockEndBlock:number = this._newBlockBytes.position + len;\n\n\t\tif (blockCompression) {\n\t\t\tthis._pDieWithError('Compressed AWD formats not yet supported');\n\t\t\t//blockEndBlock   = this._newBlockBytes.position + this._newBlockBytes.length;\n\t\t\t//block.len       = blockEndBlock;\n\t\t}\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"AWDBlock:  ID = \" + this._cur_block_id + \" | TypeID = \" + type + \" | Compression = \" + blockCompression + \" | Matrix-Precision = \" + this._accuracyMatrix + \" | Geometry-Precision = \" + this._accuracyGeo + \" | Properties-Precision = \" + this._accuracyProps);\n\t\t}\n\n\t\tthis._blocks[this._cur_block_id] = block;\n\n\t\tif ((this._version[0] == 2) && (this._version[1] == 1)) {\n\n\t\t\tswitch (type) {\n\t\t\t\tcase 11:\n\t\t\t\t\tthis.parsePrimitves(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 31:\n\t\t\t\t\tthis.parseSkyboxInstance(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 41:\n\t\t\t\t\tthis.parseLight(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 42:\n\t\t\t\t\tthis.parseCamera(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\n\t\t\t\t//  case 43:\n\t\t\t\t//      parseTextureProjector(_cur_block_id);\n\t\t\t\t//      isParsed = true;\n\t\t\t\t//      break;\n\n\t\t\t\tcase 51:\n\t\t\t\t\tthis.parseLightPicker(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 81:\n\t\t\t\t\tthis.parseMaterial_v1(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 83:\n\t\t\t\t\tthis.parseCubeTexture(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 91:\n\t\t\t\t\tthis.parseSharedMethodBlock(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 92:\n\t\t\t\t\tthis.parseShadowMethodBlock(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 111:\n\t\t\t\t\tthis.parseMeshPoseAnimation(this._cur_block_id, true);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 112:\n\t\t\t\t\tthis.parseMeshPoseAnimation(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 113:\n\t\t\t\t\tthis.parseVertexAnimationSet(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 122:\n\t\t\t\t\tthis.parseAnimatorSet(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\tcase 253:\n\t\t\t\t\tthis.parseCommand(this._cur_block_id);\n\t\t\t\t\tisParsed = true;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\t//*/\n\t\t}\n\t\t//*\n\t\tif (isParsed == false) {\n\t\t\tswitch (type) {\n\n\t\t\t\tcase 1:\n\t\t\t\t\tthis.parseTriangleGeometrieBlock(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 22:\n\t\t\t\t\tthis.parseContainer(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 23:\n\t\t\t\t\tthis.parseMeshInstance(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 81:\n\t\t\t\t\tthis.parseMaterial(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 82:\n\t\t\t\t\tthis.parseTexture(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 101:\n\t\t\t\t\tthis.parseSkeleton(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 102:\n\t\t\t\t\tthis.parseSkeletonPose(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 103:\n\t\t\t\t\tthis.parseSkeletonAnimation(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 121:\n\t\t\t\t\t//this.parseUVAnimation(this._cur_block_id);\n\t\t\t\t\t//break;\n\t\t\t\tcase 254:\n\t\t\t\t\tthis.parseNameSpace(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 255:\n\t\t\t\t\tthis.parseMetaData(this._cur_block_id);\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tif (this._debug) {\n\t\t\t\t\t\tconsole.log(\"AWDBlock:   Unknown BlockType  (BlockID = \" + this._cur_block_id + \") - Skip \" + len + \" bytes\");\n\t\t\t\t\t}\n\t\t\t\t\tthis._newBlockBytes.position += len;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\t//*/\n\n\t\tvar msgCnt:number = 0;\n\t\tif (this._newBlockBytes.position == blockEndBlock) {\n\t\t\tif (this._debug) {\n\t\t\t\tif (block.errorMessages) {\n\t\t\t\t\twhile (msgCnt < block.errorMessages.length) {\n\t\t\t\t\t\tconsole.log(\"        (!) Error: \" + block.errorMessages[msgCnt] + \" (!)\");\n\t\t\t\t\t\tmsgCnt++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this._debug) {\n\t\t\t\tconsole.log(\"\\n\");\n\t\t\t}\n\t\t} else {\n\t\t\tif (this._debug) {\n\n\t\t\t\tconsole.log(\"  (!)(!)(!) Error while reading AWDBlock ID \" + this._cur_block_id + \" = skip to next block\");\n\n\t\t\t\tif (block.errorMessages) {\n\t\t\t\t\twhile (msgCnt < block.errorMessages.length) {\n\t\t\t\t\t\tconsole.log(\"        (!) Error: \" + block.errorMessages[msgCnt] + \" (!)\");\n\t\t\t\t\t\tmsgCnt++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis._body.position = blockEndAll;\n\t\tthis._newBlockBytes = null;\n\n\t}\n\n\n\t//--Parser Blocks---------------------------------------------------------------------------\n\n\t//Block ID = 1\n\tprivate parseTriangleGeometrieBlock(blockID:number):void\n\t{\n\n\t\tvar geom:Geometry = new Geometry();\n\n\t\t// Read name and sub count\n\t\tvar name:string = this.parseVarStr();\n\t\tvar num_subs:number = this._newBlockBytes.readUnsignedShort();\n\n\t\t// Read optional properties\n\t\tvar props:AWDProperties = this.parseProperties({1:this._geoNrType, 2:this._geoNrType});\n\t\tvar geoScaleU:number = props.get(1, 1);\n\t\tvar geoScaleV:number = props.get(2, 1);\n\n\t\t// Loop through sub meshes\n\t\tvar subs_parsed:number = 0;\n\t\twhile (subs_parsed < num_subs) {\n\t\t\tvar i:number;\n\t\t\tvar sm_len:number, sm_end:number;\n\t\t\tvar sub_geom:TriangleSubGeometry;\n\t\t\tvar w_indices:Array<number>;\n\t\t\tvar weights:Array<number>;\n\n\t\t\tsm_len = this._newBlockBytes.readUnsignedInt();\n\t\t\tsm_end = this._newBlockBytes.position + sm_len;\n\n\t\t\t// Ignore for now\n\t\t\tvar subProps:AWDProperties = this.parseProperties({1:this._geoNrType, 2:this._geoNrType});\n\t\t\t// Loop through data streams\n\t\t\twhile (this._newBlockBytes.position < sm_end) {\n\t\t\t\tvar idx:number = 0;\n\t\t\t\tvar str_ftype:number, str_type:number, str_len:number, str_end:number;\n\n\t\t\t\t// Type, field type, length\n\t\t\t\tstr_type = this._newBlockBytes.readUnsignedByte();\n\t\t\t\tstr_ftype = this._newBlockBytes.readUnsignedByte();\n\t\t\t\tstr_len = this._newBlockBytes.readUnsignedInt();\n\t\t\t\tstr_end = this._newBlockBytes.position + str_len;\n\n\t\t\t\tvar x:number, y:number, z:number;\n\n\t\t\t\tif (str_type == 1) {\n\t\t\t\t\tvar verts:Array<number> = new Array<number>();\n\n\t\t\t\t\twhile (this._newBlockBytes.position < str_end) {\n\t\t\t\t\t\t// TODO: Respect stream field type\n\t\t\t\t\t\tx = this.readNumber(this._accuracyGeo);\n\t\t\t\t\t\ty = this.readNumber(this._accuracyGeo);\n\t\t\t\t\t\tz = this.readNumber(this._accuracyGeo);\n\n\t\t\t\t\t\tverts[idx++] = x;\n\t\t\t\t\t\tverts[idx++] = y;\n\t\t\t\t\t\tverts[idx++] = z;\n\t\t\t\t\t}\n\t\t\t\t} else if (str_type == 2) {\n\t\t\t\t\tvar indices:Array<number> = new Array<number>();\n\n\t\t\t\t\twhile (this._newBlockBytes.position < str_end) {\n\t\t\t\t\t\t// TODO: Respect stream field type\n\t\t\t\t\t\tindices[idx++] = this._newBlockBytes.readUnsignedShort();\n\t\t\t\t\t}\n\n\t\t\t\t} else if (str_type == 3) {\n\t\t\t\t\tvar uvs:Array<number> = new Array<number>();\n\t\t\t\t\twhile (this._newBlockBytes.position < str_end) {\n\t\t\t\t\t\tuvs[idx++] = this.readNumber(this._accuracyGeo);\n\n\t\t\t\t\t}\n\t\t\t\t} else if (str_type == 4) {\n\n\t\t\t\t\tvar normals:Array<number> = new Array<number>();\n\n\t\t\t\t\twhile (this._newBlockBytes.position < str_end) {\n\t\t\t\t\t\tnormals[idx++] = this.readNumber(this._accuracyGeo);\n\t\t\t\t\t}\n\n\t\t\t\t} else if (str_type == 6) {\n\t\t\t\t\tw_indices = Array<number>();\n\n\t\t\t\t\twhile (this._newBlockBytes.position < str_end) {\n\t\t\t\t\t\tw_indices[idx++] = this._newBlockBytes.readUnsignedShort()*3; // TODO: Respect stream field type\n\t\t\t\t\t}\n\n\t\t\t\t} else if (str_type == 7) {\n\n\t\t\t\t\tweights = new Array<number>();\n\n\t\t\t\t\twhile (this._newBlockBytes.position < str_end) {\n\t\t\t\t\t\tweights[idx++] = this.readNumber(this._accuracyGeo);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tthis._newBlockBytes.position = str_end;\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis.parseUserAttributes(); // Ignore sub-mesh attributes for now\n\n\t\t\tsub_geom = new TriangleSubGeometry(true);\n\t\t\tif (weights)\n\t\t\t\tsub_geom.jointsPerVertex = weights.length/(verts.length/3);\n\t\t\tif (normals)\n\t\t\t\tsub_geom.autoDeriveNormals = false;\n\t\t\tif (uvs)\n\t\t\t\tsub_geom.autoDeriveUVs = false;\n\t\t\tsub_geom.updateIndices(indices);\n\t\t\tsub_geom.updatePositions(verts);\n\t\t\tsub_geom.updateVertexNormals(normals);\n\t\t\tsub_geom.updateUVs(uvs);\n\t\t\tsub_geom.updateVertexTangents(null);\n\t\t\tsub_geom.updateJointWeights(weights);\n\t\t\tsub_geom.updateJointIndices(w_indices);\n\n\t\t\tvar scaleU:number = subProps.get(1, 1);\n\t\t\tvar scaleV:number = subProps.get(2, 1);\n\t\t\tvar setSubUVs:boolean = false; //this should remain false atm, because in AwayBuilder the uv is only scaled by the geometry\n\n\t\t\tif ((geoScaleU != scaleU) || (geoScaleV != scaleV)) {\n\t\t\t\tsetSubUVs = true;\n\t\t\t\tscaleU = geoScaleU/scaleU;\n\t\t\t\tscaleV = geoScaleV/scaleV;\n\t\t\t}\n\n\t\t\tif (setSubUVs)\n\t\t\t\tsub_geom.scaleUV(scaleU, scaleV);\n\n\t\t\tgeom.addSubGeometry(sub_geom);\n\n\t\t\t// TODO: Somehow map in-sub to out-sub indices to enable look-up\n\t\t\t// when creating meshes (and their material assignments.)\n\n\t\t\tsubs_parsed++;\n\t\t}\n\t\tif ((geoScaleU != 1) || (geoScaleV != 1))\n\t\t\tgeom.scaleUV(geoScaleU, geoScaleV);\n\t\tthis.parseUserAttributes();\n\t\tthis._pFinalizeAsset(<IAsset> geom, name);\n\t\tthis._blocks[blockID].data = geom;\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a TriangleGeometry: Name = \" + name + \"| Id = \" + sub_geom.id);\n\t\t}\n\n\t}\n\n\t//Block ID = 11\n\tprivate parsePrimitves(blockID:number):void\n\t{\n\t\tvar name:string;\n\t\tvar prefab:PrefabBase;\n\t\tvar primType:number;\n\t\tvar subs_parsed:number;\n\t\tvar props:AWDProperties;\n\t\tvar bsm:Matrix3D;\n\n\t\t// Read name and sub count\n\t\tname = this.parseVarStr();\n\t\tprimType = this._newBlockBytes.readUnsignedByte();\n\t\tprops = this.parseProperties({101:this._geoNrType, 102:this._geoNrType, 103:this._geoNrType, 110:this._geoNrType, 111:this._geoNrType, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 303:AWDParser.UINT16, 701:AWDParser.BOOL, 702:AWDParser.BOOL, 703:AWDParser.BOOL, 704:AWDParser.BOOL});\n\n\t\tvar primitiveTypes:Array<string> = [\"Unsupported Type-ID\", \"PrimitivePlanePrefab\", \"PrimitiveCubePrefab\", \"PrimitiveSpherePrefab\", \"PrimitiveCylinderPrefab\", \"PrimitivesConePrefab\", \"PrimitivesCapsulePrefab\", \"PrimitivesTorusPrefab\"]\n\n\t\tswitch (primType) {\n\t\t\t// to do, not all properties are set on all primitives\n\n\t\t\tcase 1:\n\t\t\t\tprefab = new PrimitivePlanePrefab(props.get(101, 100), props.get(102, 100), props.get(301, 1), props.get(302, 1), props.get(701, true), props.get(702, false));\n\t\t\t\tbreak;\n\n\t\t\tcase 2:\n\t\t\t\tprefab = new PrimitiveCubePrefab(props.get(101, 100), props.get(102, 100), props.get(103, 100), props.get(301, 1), props.get(302, 1), props.get(303, 1), props.get(701, true));\n\t\t\t\tbreak;\n\n\t\t\tcase 3:\n\t\t\t\tprefab = new PrimitiveSpherePrefab(props.get(101, 50), props.get(301, 16), props.get(302, 12), props.get(701, true));\n\t\t\t\tbreak;\n\n\t\t\tcase 4:\n\t\t\t\tprefab = new PrimitiveCylinderPrefab(props.get(101, 50), props.get(102, 50), props.get(103, 100), props.get(301, 16), props.get(302, 1), true, true, true); // bool701, bool702, bool703, bool704);\n\t\t\t\tif (!props.get(701, true))\n\t\t\t\t\t(<PrimitiveCylinderPrefab>prefab).topClosed = false;\n\t\t\t\tif (!props.get(702, true))\n\t\t\t\t\t(<PrimitiveCylinderPrefab>prefab).bottomClosed = false;\n\t\t\t\tif (!props.get(703, true))\n\t\t\t\t\t(<PrimitiveCylinderPrefab>prefab).yUp = false;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 5:\n\t\t\t\tprefab = new PrimitiveConePrefab(props.get(101, 50), props.get(102, 100), props.get(301, 16), props.get(302, 1), props.get(701, true), props.get(702, true));\n\t\t\t\tbreak;\n\n\t\t\tcase 6:\n\t\t\t\tprefab = new PrimitiveCapsulePrefab(props.get(101, 50), props.get(102, 100), props.get(301, 16), props.get(302, 15), props.get(701, true));\n\t\t\t\tbreak;\n\n\t\t\tcase 7:\n\t\t\t\tprefab = new PrimitiveTorusPrefab(props.get(101, 50), props.get(102, 50), props.get(301, 16), props.get(302, 8), props.get(701, true));\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tprefab = new PrefabBase();\n\t\t\t\tconsole.log(\"ERROR: UNSUPPORTED PREFAB_TYPE\");\n\t\t\t\tbreak;\n\t\t}\n\n\t\tif ((props.get(110, 1) != 1) || (props.get(111, 1) != 1)) {\n\t\t\t//geom.subGeometries;\n\t\t\t//geom.scaleUV(props.get(110, 1), props.get(111, 1)); //TODO add back scaling to prefabs\n\t\t}\n\n\t\tthis.parseUserAttributes();\n\t\tprefab.name = name;\n\t\tthis._pFinalizeAsset(prefab, name);\n\t\tthis._blocks[blockID].data = prefab;\n\n\t\tif (this._debug) {\n\t\t\tif ((primType < 0) || (primType > 7)) {\n\t\t\t\tprimType = 0;\n\t\t\t}\n\t\t\tconsole.log(\"Parsed a Primivite: Name = \" + name + \"| type = \" + primitiveTypes[primType]);\n\t\t}\n\t}\n\n\t// Block ID = 22\n\tprivate parseContainer(blockID:number):void\n\t{\n\t\tvar name:string;\n\t\tvar par_id:number;\n\t\tvar mtx:Matrix3D;\n\t\tvar ctr:DisplayObjectContainer;\n\t\tvar parent:DisplayObjectContainer;\n\n\t\tpar_id = this._newBlockBytes.readUnsignedInt();\n\t\tmtx = this.parseMatrix3D();\n\t\tname = this.parseVarStr();\n\n\t\tvar parentName:string = \"Root (TopLevel)\";\n\t\tctr = new DisplayObjectContainer();\n\t\tctr.transform.matrix3D = mtx;\n\n\t\tvar returnedArray:Array<any> = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]);\n\n\t\tif (returnedArray[0]) {\n\t\t\tvar obj:DisplayObject = (<DisplayObjectContainer> returnedArray[1]).addChild(ctr);\n\t\t\tparentName = (<DisplayObjectContainer> returnedArray[1]).name;\n\t\t} else if (par_id > 0) {\n\t\t\tthis._blocks[ blockID ].addError(\"Could not find a parent for this ObjectContainer3D\");\n\t\t} else {\n\t\t\t//add to the content property\n\t\t\t(<DisplayObjectContainer> this._pContent).addChild(ctr);\n\t\t}\n\n\t\t// in AWD version 2.1 we read the Container properties\n\t\tif ((this._version[0] == 2) && (this._version[1] == 1)) {\n\t\t\tvar props:AWDProperties = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8});\n\t\t\tctr.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0));\n\t\t}\n\t\t// in other versions we do not read the Container properties\n\t\telse {\n\t\t\tthis.parseProperties(null);\n\t\t}\n\n\t\t// the extraProperties should only be set for AWD2.1-Files, but is read for both versions\n\t\tctr.extra = this.parseUserAttributes();\n\n\t\tthis._pFinalizeAsset(<IAsset> ctr, name);\n\t\tthis._blocks[blockID].data = ctr;\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a Container: Name = '\" + name + \"' | Parent-Name = \" + parentName);\n\t\t}\n\t}\n\n\t// Block ID = 23\n\tprivate parseMeshInstance(blockID:number):void\n\t{\n\t\tvar num_materials:number;\n\t\tvar materials_parsed:number;\n\t\tvar parent:DisplayObjectContainer;\n\t\tvar par_id:number = this._newBlockBytes.readUnsignedInt();\n\t\tvar mtx:Matrix3D = this.parseMatrix3D();\n\t\tvar name:string = this.parseVarStr();\n\t\tvar parentName:string = \"Root (TopLevel)\";\n\t\tvar data_id:number = this._newBlockBytes.readUnsignedInt();\n\t\tvar geom:Geometry;\n\t\tvar returnedArrayGeometry:Array<any> = this.getAssetByID(data_id, [AssetType.GEOMETRY])\n\n\t\tif (returnedArrayGeometry[0]) {\n\t\t\tgeom = <Geometry> returnedArrayGeometry[1];\n\t\t} else {\n\t\t\tthis._blocks[blockID].addError(\"Could not find a Geometry for this Mesh. A empty Geometry is created!\");\n\t\t\tgeom = new Geometry();\n\t\t}\n\n\t\tthis._blocks[blockID].geoID = data_id;\n\t\tvar materials:Array<MaterialBase> = new Array<MaterialBase>();\n\t\tnum_materials = this._newBlockBytes.readUnsignedShort();\n\n\t\tvar materialNames:Array<string> = new Array<string>();\n\t\tmaterials_parsed = 0;\n\n\t\tvar returnedArrayMaterial:Array<any>;\n\n\t\twhile (materials_parsed < num_materials) {\n\t\t\tvar mat_id:number;\n\t\t\tmat_id = this._newBlockBytes.readUnsignedInt();\n\t\t\treturnedArrayMaterial = this.getAssetByID(mat_id, [AssetType.MATERIAL])\n\t\t\tif ((!returnedArrayMaterial[0]) && (mat_id > 0)) {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find Material Nr \" + materials_parsed + \" (ID = \" + mat_id + \" ) for this Mesh\");\n\t\t\t}\n\n\t\t\tvar m:MaterialBase = <MaterialBase> returnedArrayMaterial[1];\n\n\t\t\tmaterials.push(m);\n\t\t\tmaterialNames.push(m.name);\n\n\t\t\tmaterials_parsed++;\n\t\t}\n\n\t\tvar mesh:Mesh = new Mesh(geom, null);\n\t\tmesh.transform.matrix3D = mtx;\n\n\t\tvar returnedArrayParent:Array<any> = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH])\n\n\t\tif (returnedArrayParent[0]) {\n\t\t\tvar objC:DisplayObjectContainer = <DisplayObjectContainer> returnedArrayParent[1];\n\t\t\tobjC.addChild(mesh);\n\t\t\tparentName = objC.name;\n\t\t} else if (par_id > 0) {\n\t\t\tthis._blocks[blockID].addError(\"Could not find a parent for this Mesh\");\n\t\t} else {\n\t\t\t//add to the content property\n\t\t\t(<DisplayObjectContainer> this._pContent).addChild(mesh);\n\t\t}\n\n\t\tif (materials.length >= 1 && mesh.subMeshes.length == 1) {\n\t\t\tmesh.material = materials[0];\n\t\t} else if (materials.length > 1) {\n\t\t\tvar i:number;\n\n\t\t\t// Assign each sub-mesh in the mesh a material from the list. If more sub-meshes\n\t\t\t// than materials, repeat the last material for all remaining sub-meshes.\n\t\t\tfor (i = 0; i < mesh.subMeshes.length; i++) {\n\t\t\t\tmesh.subMeshes[i].material = materials[Math.min(materials.length - 1, i)];\n\t\t\t}\n\t\t}\n\t\tif ((this._version[0] == 2) && (this._version[1] == 1)) {\n\t\t\tvar props:AWDProperties = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8, 5:AWDParser.BOOL});\n\t\t\tmesh.pivot = new Vector3D(<number>props.get(1, 0), <number>props.get(2, 0), <number> props.get(3, 0));\n\t\t\tmesh.castsShadows = props.get(5, true);\n\t\t} else {\n\t\t\tthis.parseProperties(null);\n\t\t}\n\n\t\tmesh.extra = this.parseUserAttributes();\n\n\t\tthis._pFinalizeAsset(<IAsset> mesh, name);\n\t\tthis._blocks[blockID].data = mesh;\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a Mesh: Name = '\" + name + \"' | Parent-Name = \" + parentName + \"| Geometry-Name = \" + geom.name + \" | SubMeshes = \" + mesh.subMeshes.length + \" | Mat-Names = \" + materialNames.toString());\n\t\t}\n\t}\n\n\n\t//Block ID 31\n\tprivate parseSkyboxInstance(blockID:number):void\n\t{\n\t\tvar name:string = this.parseVarStr();\n\t\tvar cubeTexAddr:number = this._newBlockBytes.readUnsignedInt();\n\n\t\tvar returnedArrayCubeTex:Array<any> = this.getAssetByID(cubeTexAddr, [AssetType.TEXTURE], \"CubeTexture\");\n\t\tif ((!returnedArrayCubeTex[0]) && (cubeTexAddr != 0))\n\t\t\tthis._blocks[blockID].addError(\"Could not find the Cubetexture (ID = \" + cubeTexAddr + \" ) for this Skybox\");\n\t\tvar asset:Skybox = new Skybox(new SkyboxMaterial(<ImageCubeTexture> returnedArrayCubeTex[1]));\n\n\t\tthis.parseProperties(null)\n\t\tasset.extra = this.parseUserAttributes();\n\t\tthis._pFinalizeAsset(asset, name);\n\t\tthis._blocks[blockID].data = asset;\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a Skybox: Name = '\" + name + \"' | CubeTexture-Name = \" + (<ImageCubeTexture> returnedArrayCubeTex[1]).name);\n\n\t}\n\n\t//Block ID = 41\n\tprivate parseLight(blockID:number):void\n\t{\n\t\tvar light:LightBase;\n\t\tvar newShadowMapper:ShadowMapperBase;\n\n\t\tvar par_id:number = this._newBlockBytes.readUnsignedInt();\n\t\tvar mtx:Matrix3D = this.parseMatrix3D();\n\t\tvar name:string = this.parseVarStr();\n\t\tvar lightType:number = this._newBlockBytes.readUnsignedByte();\n\t\tvar props:AWDProperties = this.parseProperties({1:this._propsNrType, 2:this._propsNrType, 3:AWDParser.COLOR, 4:this._propsNrType, 5:this._propsNrType, 6:AWDParser.BOOL, 7:AWDParser.COLOR, 8:this._propsNrType, 9:AWDParser.UINT8, 10:AWDParser.UINT8, 11:this._propsNrType, 12:AWDParser.UINT16, 21:this._matrixNrType, 22:this._matrixNrType, 23:this._matrixNrType});\n\t\tvar shadowMapperType:number = props.get(9, 0);\n\t\tvar parentName:string = \"Root (TopLevel)\";\n\t\tvar lightTypes:Array<string> = [\"Unsupported LightType\", \"PointLight\", \"DirectionalLight\"];\n\t\tvar shadowMapperTypes:Array<string> = [\"No ShadowMapper\", \"DirectionalShadowMapper\", \"NearDirectionalShadowMapper\", \"CascadeShadowMapper\", \"CubeMapShadowMapper\"];\n\n\t\tif (lightType == 1) {\n\t\t\tlight = new PointLight();\n\n\t\t\t(<PointLight> light).radius = props.get(1, 90000);\n\t\t\t(<PointLight> light).fallOff = props.get(2, 100000);\n\n\t\t\tif (shadowMapperType > 0) {\n\t\t\t\tif (shadowMapperType == 4) {\n\t\t\t\t\tnewShadowMapper = new CubeMapShadowMapper();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tlight.transform.matrix3D = mtx;\n\n\t\t}\n\n\t\tif (lightType == 2) {\n\n\t\t\tlight = new DirectionalLight(props.get(21, 0), props.get(22, -1), props.get(23, 1));\n\n\t\t\tif (shadowMapperType > 0) {\n\t\t\t\tif (shadowMapperType == 1) {\n\t\t\t\t\tnewShadowMapper = new DirectionalShadowMapper();\n\t\t\t\t}\n\n\t\t\t\t//if (shadowMapperType == 2)\n\t\t\t\t//  newShadowMapper = new NearDirectionalShadowMapper(props.get(11, 0.5));\n\t\t\t\t//if (shadowMapperType == 3)\n\t\t\t\t//   newShadowMapper = new CascadeShadowMapper(props.get(12, 3));\n\n\t\t\t}\n\n\t\t}\n\t\tlight.color = props.get(3, 0xffffff);\n\t\tlight.specular = props.get(4, 1.0);\n\t\tlight.diffuse = props.get(5, 1.0);\n\t\tlight.ambientColor = props.get(7, 0xffffff);\n\t\tlight.ambient = props.get(8, 0.0);\n\n\t\t// if a shadowMapper has been created, adjust the depthMapSize if needed, assign to light and set castShadows to true\n\t\tif (newShadowMapper) {\n\t\t\tif (newShadowMapper instanceof CubeMapShadowMapper) {\n\t\t\t\tif (props.get(10, 1) != 1) {\n\t\t\t\t\tnewShadowMapper.depthMapSize = this._depthSizeDic[props.get(10, 1)];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (props.get(10, 2) != 2) {\n\t\t\t\t\tnewShadowMapper.depthMapSize = this._depthSizeDic[props.get(10, 2)];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tlight.shadowMapper = newShadowMapper;\n\t\t\tlight.castsShadows = true;\n\t\t}\n\n\t\tif (par_id != 0) {\n\n\t\t\tvar returnedArrayParent:Array<any> = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH])\n\n\t\t\tif (returnedArrayParent[0]) {\n\t\t\t\t(<DisplayObjectContainer> returnedArrayParent[1]).addChild(light);\n\t\t\t\tparentName = (<DisplayObjectContainer> returnedArrayParent[1]).name;\n\t\t\t} else {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find a parent for this Light\");\n\t\t\t}\n\t\t} else {\n\t\t\t//add to the content property\n\t\t\t(<DisplayObjectContainer> this._pContent).addChild(light);\n\t\t}\n\n\t\tthis.parseUserAttributes();\n\n\t\tthis._pFinalizeAsset(< IAsset> light, name);\n\n\t\tthis._blocks[blockID].data = light;\n\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a Light: Name = '\" + name + \"' | Type = \" + lightTypes[lightType] + \" | Parent-Name = \" + parentName + \" | ShadowMapper-Type = \" + shadowMapperTypes[shadowMapperType]);\n\n\t}\n\n\t//Block ID = 43\n\tprivate parseCamera(blockID:number):void\n\t{\n\n\t\tvar par_id:number = this._newBlockBytes.readUnsignedInt();\n\t\tvar mtx:Matrix3D = this.parseMatrix3D();\n\t\tvar name:string = this.parseVarStr();\n\t\tvar parentName:string = \"Root (TopLevel)\";\n\t\tvar projection:ProjectionBase;\n\n\t\tthis._newBlockBytes.readUnsignedByte(); //set as active camera\n\t\tthis._newBlockBytes.readShort(); //lengthof lenses - not used yet\n\n\t\tvar projectiontype:number = this._newBlockBytes.readShort();\n\t\tvar props:AWDProperties = this.parseProperties({101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 104:this._propsNrType});\n\n\t\tswitch (projectiontype) {\n\t\t\tcase 5001:\n\t\t\t\tprojection = new PerspectiveProjection(props.get(101, 60));\n\t\t\t\tbreak;\n\t\t\tcase 5002:\n\t\t\t\tprojection = new OrthographicProjection(props.get(101, 500));\n\t\t\t\tbreak;\n\t\t\tcase 5003:\n\t\t\t\tprojection = new OrthographicOffCenterProjection(props.get(101, -400), props.get(102, 400), props.get(103, -300), props.get(104, 300));\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tconsole.log(\"unsupportedLenstype\");\n\t\t\t\treturn;\n\t\t}\n\n\t\tvar camera:Camera = new Camera(projection);\n\t\tcamera.transform.matrix3D = mtx;\n\n\t\tvar returnedArrayParent:Array<any> = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH])\n\n\t\tif (returnedArrayParent[0]) {\n\n\t\t\tvar objC:DisplayObjectContainer = <DisplayObjectContainer> returnedArrayParent[1];\n\t\t\tobjC.addChild(camera);\n\n\t\t\tparentName = objC.name;\n\n\t\t} else if (par_id > 0) {\n\t\t\tthis._blocks[blockID].addError(\"Could not find a parent for this Camera\");\n\t\t} else {\n\t\t\t//add to the content property\n\t\t\t(<DisplayObjectContainer> this._pContent).addChild(camera);\n\t\t}\n\n\t\tcamera.name = name;\n\t\tprops = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8});\n\t\tcamera.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0));\n\t\tcamera.extra = this.parseUserAttributes();\n\n\t\tthis._pFinalizeAsset(camera, name);\n\n\t\tthis._blocks[blockID].data = camera\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a Camera: Name = '\" + name + \"' | Projectiontype = \" + projection + \" | Parent-Name = \" + parentName);\n\t\t}\n\n\t}\n\n\t//Block ID = 51\n\tprivate parseLightPicker(blockID:number):void\n\t{\n\t\tvar name:string = this.parseVarStr();\n\t\tvar numLights:number = this._newBlockBytes.readUnsignedShort();\n\t\tvar lightsArray:Array<LightBase> = new Array<LightBase>();\n\t\tvar k:number = 0;\n\t\tvar lightID:number = 0;\n\n\t\tvar returnedArrayLight:Array<any>;\n\t\tvar lightsArrayNames:Array<string> = new Array<string>();\n\n\t\tfor (k = 0; k < numLights; k++) {\n\t\t\tlightID = this._newBlockBytes.readUnsignedInt();\n\t\t\treturnedArrayLight = this.getAssetByID(lightID, [AssetType.LIGHT])\n\n\t\t\tif (returnedArrayLight[0]) {\n\t\t\t\tlightsArray.push(<LightBase> returnedArrayLight[1]);\n\t\t\t\tlightsArrayNames.push(( <LightBase> returnedArrayLight[1]).name);\n\n\t\t\t} else {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find a Light Nr \" + k + \" (ID = \" + lightID + \" ) for this LightPicker\");\n\t\t\t}\n\t\t}\n\n\t\tif (lightsArray.length == 0) {\n\t\t\tthis._blocks[blockID].addError(\"Could not create this LightPicker, cause no Light was found.\");\n\t\t\tthis.parseUserAttributes();\n\t\t\treturn; //return without any more parsing for this block\n\t\t}\n\n\t\tvar lightPick:LightPickerBase = new StaticLightPicker(lightsArray);\n\t\tlightPick.name = name;\n\n\t\tthis.parseUserAttributes();\n\t\tthis._pFinalizeAsset(<IAsset> lightPick, name);\n\n\t\tthis._blocks[blockID].data = lightPick\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a StaticLightPicker: Name = '\" + name + \"' | Texture-Name = \" + lightsArrayNames.toString());\n\t\t}\n\t}\n\n\t//Block ID = 81\n\tprivate parseMaterial(blockID:number):void\n\t{\n\t\t// TODO: not used\n\t\t////blockLength = block.len;\n\t\tvar name:string;\n\t\tvar type:number;\n\t\tvar props:AWDProperties;\n\t\tvar mat:TriangleMethodMaterial;\n\t\tvar attributes:Object;\n\t\tvar finalize:boolean;\n\t\tvar num_methods:number;\n\t\tvar methods_parsed:number;\n\t\tvar returnedArray:Array<any>;\n\n\t\tname = this.parseVarStr();\n\t\ttype = this._newBlockBytes.readUnsignedByte();\n\t\tnum_methods = this._newBlockBytes.readUnsignedByte();\n\n\t\t// Read material numerical properties\n\t\t// (1=color, 2=bitmap url, 10=alpha, 11=alpha_blending, 12=alpha_threshold, 13=repeat)\n\t\tprops = this.parseProperties({ 1:AWDParser.INT32, 2:AWDParser.BADDR, 10:this._propsNrType, 11:AWDParser.BOOL, 12:this._propsNrType, 13:AWDParser.BOOL});\n\n\t\tmethods_parsed = 0;\n\t\twhile (methods_parsed < num_methods) {\n\t\t\tvar method_type:number;\n\n\t\t\tmethod_type = this._newBlockBytes.readUnsignedShort();\n\t\t\tthis.parseProperties(null);\n\t\t\tthis.parseUserAttributes();\n\t\t\tmethods_parsed += 1;\n\t\t}\n\t\tvar debugString:string = \"\";\n\t\tattributes = this.parseUserAttributes();\n\t\tif (type === 1) { // Color material\n\t\t\tdebugString += \"Parsed a ColorMaterial(SinglePass): Name = '\" + name + \"' | \";\n\t\t\tvar color:number;\n\t\t\tcolor = props.get(1, 0xffffff);\n\t\t\tif (this.materialMode < 2) {\n\t\t\t\tmat = new TriangleMethodMaterial(color, props.get(10, 1.0));\n\t\t\t} else {\n\t\t\t\tmat = new TriangleMethodMaterial(color);\n\t\t\t\tmat.materialMode = TriangleMaterialMode.MULTI_PASS;\n\t\t\t}\n\t\t} else if (type === 2) {\n\t\t\tvar tex_addr:number = props.get(2, 0);\n\n\t\t\treturnedArray = this.getAssetByID(tex_addr, [AssetType.TEXTURE]);\n\n\t\t\tif ((!returnedArray[0]) && (tex_addr > 0))\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the DiffsueTexture (ID = \" + tex_addr + \" ) for this Material\");\n\n\t\t\tmat = new TriangleMethodMaterial(<Texture2DBase> returnedArray[1]);\n\n\t\t\tif (this.materialMode < 2) {\n\t\t\t\tmat.alphaBlending = props.get(11, false);\n\t\t\t\tmat.alpha = props.get(10, 1.0);\n\t\t\t\tdebugString += \"Parsed a TriangleMethodMaterial(SinglePass): Name = '\" + name + \"' | Texture-Name = \" + mat.name;\n\t\t\t} else {\n\t\t\t\tmat.materialMode = TriangleMaterialMode.MULTI_PASS;\n\t\t\t\tdebugString += \"Parsed a TriangleMethodMaterial(MultiPass): Name = '\" + name + \"' | Texture-Name = \" + mat.name;\n\t\t\t}\n\t\t}\n\n\t\tmat.extra = attributes;\n\t\tmat.alphaThreshold = props.get(12, 0.0);\n\t\tmat.repeat = props.get(13, false);\n\t\tthis._pFinalizeAsset(<IAsset> mat, name);\n\t\tthis._blocks[blockID].data = mat;\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(debugString);\n\n\t\t}\n\t}\n\n\t// Block ID = 81 AWD2.1\n\tprivate parseMaterial_v1(blockID:number):void\n\t{\n\t\tvar mat:TriangleMethodMaterial;\n\t\tvar normalTexture:Texture2DBase;\n\t\tvar specTexture:Texture2DBase;\n\t\tvar returnedArray:Array<any>;\n\n\t\tvar name:string = this.parseVarStr();\n\t\tvar type:number = this._newBlockBytes.readUnsignedByte();\n\t\tvar num_methods:number = this._newBlockBytes.readUnsignedByte();\n\t\tvar props:AWDProperties = this.parseProperties({1:AWDParser.UINT32, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 4:AWDParser.UINT8, 5:AWDParser.BOOL, 6:AWDParser.BOOL, 7:AWDParser.BOOL, 8:AWDParser.BOOL, 9:AWDParser.UINT8, 10:this._propsNrType, 11:AWDParser.BOOL, 12:this._propsNrType, 13:AWDParser.BOOL, 15:this._propsNrType, 16:AWDParser.UINT32, 17:AWDParser.BADDR, 18:this._propsNrType, 19:this._propsNrType, 20:AWDParser.UINT32, 21:AWDParser.BADDR, 22:AWDParser.BADDR});\n\t\tvar spezialType:number = props.get(4, 0);\n\t\tvar debugString:string = \"\";\n\n\t\tif (spezialType >= 2) {//this is no supported material\n\t\t\tthis._blocks[blockID].addError(\"Material-spezialType '\" + spezialType + \"' is not supported, can only be 0:singlePass, 1:MultiPass !\");\n\t\t\treturn;\n\t\t}\n\n\t\tif (this.materialMode == 1)\n\t\t\tspezialType = 0;\n\t\telse if (this.materialMode == 2)\n\t\t\tspezialType = 1;\n\n\t\tif (spezialType < 2) {//this is SinglePass or MultiPass\n\n\t\t\tif (type == 1) {// Color material\n\t\t\t\tvar color:number = props.get(1, 0xcccccc);//TODO temporarily swapped so that diffuse color goes to ambient\n\n\t\t\t\tif (spezialType == 1) {//\tMultiPassMaterial\n\t\t\t\t\tmat = new TriangleMethodMaterial(color);\n\t\t\t\t\tmat.materialMode = TriangleMaterialMode.MULTI_PASS;\n\t\t\t\t\tdebugString += \"Parsed a ColorMaterial(MultiPass): Name = '\" + name + \"' | \";\n\n\t\t\t\t} else { //\tSinglePassMaterial\n\t\t\t\t\tmat = new TriangleMethodMaterial(color, props.get(10, 1.0));\n\t\t\t\t\tmat.alphaBlending = props.get(11, false);\n\t\t\t\t\tdebugString += \"Parsed a ColorMaterial(SinglePass): Name = '\" + name + \"' | \";\n\t\t\t\t}\n\n\t\t\t} else if (type == 2) {// texture material\n\t\t\t\tvar tex_addr:number = props.get(2, 0);//TODO temporarily swapped so that diffuse texture goes to ambient\n\t\t\t\treturnedArray = this.getAssetByID(tex_addr, [AssetType.TEXTURE]);\n\n\t\t\t\tif ((!returnedArray[0]) && (tex_addr > 0))\n\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the AmbientTexture (ID = \" + tex_addr + \" ) for this TriangleMethodMaterial\");\n\n\t\t\t\tvar texture:Texture2DBase = returnedArray[1];\n\n\t\t\t\tmat = new TriangleMethodMaterial(texture);\n\n\t\t\t\tif (spezialType == 1) {// MultiPassMaterial\n\t\t\t\t\tmat.materialMode = TriangleMaterialMode.MULTI_PASS;\n\n\t\t\t\t\tdebugString += \"Parsed a TriangleMethodMaterial(MultiPass): Name = '\" + name + \"' | Texture-Name = \" + texture.name;\n\t\t\t\t} else {//\tSinglePassMaterial\n\t\t\t\t\tmat.alpha = props.get(10, 1.0);\n\t\t\t\t\tmat.alphaBlending = props.get(11, false);\n\n\t\t\t\t\tdebugString += \"Parsed a TriangleMethodMaterial(SinglePass): Name = '\" + name + \"' | Texture-Name = \" + texture.name;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar diffuseTexture:Texture2DBase;\n\t\t\tvar diffuseTex_addr:number = props.get(17, 0);\n\n\t\t\treturnedArray = this.getAssetByID(diffuseTex_addr, [AssetType.TEXTURE]);\n\n\t\t\tif ((!returnedArray[0]) && (diffuseTex_addr != 0)) {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the DiffuseTexture (ID = \" + diffuseTex_addr + \" ) for this TriangleMethodMaterial\");\n\t\t\t}\n\n\t\t\tif (returnedArray[0])\n\t\t\t\tdiffuseTexture = returnedArray[1];\n\n\t\t\tif (diffuseTexture) {\n\t\t\t\tmat.diffuseTexture = diffuseTexture;\n\t\t\t\tdebugString += \" | DiffuseTexture-Name = \" + diffuseTexture.name;\n\t\t\t}\n\n\t\t\tvar normalTex_addr:number = props.get(3, 0);\n\n\t\t\treturnedArray = this.getAssetByID(normalTex_addr, [AssetType.TEXTURE]);\n\n\t\t\tif ((!returnedArray[0]) && (normalTex_addr != 0)) {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the NormalTexture (ID = \" + normalTex_addr + \" ) for this TriangleMethodMaterial\");\n\t\t\t}\n\n\t\t\tif (returnedArray[0]) {\n\t\t\t\tnormalTexture = returnedArray[1];\n\t\t\t\tdebugString += \" | NormalTexture-Name = \" + normalTexture.name;\n\t\t\t}\n\n\t\t\tvar specTex_addr:number = props.get(21, 0);\n\t\t\treturnedArray = this.getAssetByID(specTex_addr, [AssetType.TEXTURE]);\n\n\t\t\tif ((!returnedArray[0]) && (specTex_addr != 0)) {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the SpecularTexture (ID = \" + specTex_addr + \" ) for this TriangleMethodMaterial\");\n\t\t\t}\n\t\t\tif (returnedArray[0]) {\n\t\t\t\tspecTexture = returnedArray[1];\n\t\t\t\tdebugString += \" | SpecularTexture-Name = \" + specTexture.name;\n\t\t\t}\n\n\t\t\tvar lightPickerAddr:number = props.get(22, 0);\n\t\t\treturnedArray = this.getAssetByID(lightPickerAddr, [AssetType.LIGHT_PICKER])\n\n\t\t\tif ((!returnedArray[0]) && (lightPickerAddr)) {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the LightPicker (ID = \" + lightPickerAddr + \" ) for this TriangleMethodMaterial\");\n\t\t\t} else {\n\t\t\t\tmat.lightPicker = <LightPickerBase> returnedArray[1];\n\t\t\t\t//debugString+=\" | Lightpicker-Name = \"+LightPickerBase(returnedArray[1]).name;\n\t\t\t}\n\n\t\t\tmat.smooth = props.get(5, true);\n\t\t\tmat.mipmap = props.get(6, true);\n\t\t\tmat.bothSides = props.get(7, false);\n\t\t\tmat.alphaPremultiplied = props.get(8, false);\n\t\t\tmat.blendMode = this.blendModeDic[props.get(9, 0)];\n\t\t\tmat.repeat = props.get(13, false);\n\n\t\t\tif (normalTexture)\n\t\t\t\tmat.normalMap = normalTexture;\n\n\t\t\tif (specTexture)\n\t\t\t\tmat.specularMap = specTexture;\n\n\t\t\tmat.alphaThreshold = props.get(12, 0.0);\n\t\t\tmat.ambient = props.get(15, 1.0);\n\t\t\tmat.diffuseColor = props.get(16, 0xffffff);\n\t\t\tmat.specular = props.get(18, 1.0);\n\t\t\tmat.gloss = props.get(19, 50);\n\t\t\tmat.specularColor = props.get(20, 0xffffff);\n\n\t\t\tvar methods_parsed:number = 0;\n\t\t\tvar targetID:number;\n\n\t\t\twhile (methods_parsed < num_methods) {\n\t\t\t\tvar method_type:number;\n\t\t\t\tmethod_type = this._newBlockBytes.readUnsignedShort();\n\n\t\t\t\tprops = this.parseProperties({1:AWDParser.BADDR, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 201:AWDParser.UINT32, 202:AWDParser.UINT32, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 401:AWDParser.UINT8, 402:AWDParser.UINT8, 601:AWDParser.COLOR, 602:AWDParser.COLOR, 701:AWDParser.BOOL, 702:AWDParser.BOOL, 801:AWDParser.MTX4x4});\n\n\t\t\t\tswitch (method_type) {\n\t\t\t\t\tcase 999: //wrapper-Methods that will load a previous parsed EffektMethod returned\n\n\t\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.EFFECTS_METHOD]);\n\n\t\t\t\t\t\tif (!returnedArray[0]) {\n\t\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the EffectMethod (ID = \" + targetID + \" ) for this Material\");\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tmat.addEffectMethod(returnedArray[1]);\n\n\t\t\t\t\t\t\tdebugString += \" | EffectMethod-Name = \" + (<EffectMethodBase> returnedArray[1]).name;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 998: //wrapper-Methods that will load a previous parsed ShadowMapMethod\n\n\t\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]);\n\n\t\t\t\t\t\tif (!returnedArray[0]) {\n\t\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the ShadowMethod (ID = \" + targetID + \" ) for this Material\");\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tmat.shadowMethod = returnedArray[1];\n\t\t\t\t\t\t\tdebugString += \" | ShadowMethod-Name = \" + (<ShadowMethodBase> returnedArray[1]).name;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 1: //EnvMapAmbientMethod\n\t\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE], \"CubeTexture\");\n\t\t\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the EnvMap (ID = \" + targetID + \" ) for this EnvMapAmbientMethodMaterial\");\n\t\t\t\t\t\tmat.ambientMethod = new AmbientEnvMapMethod(returnedArray[1]);\n\t\t\t\t\t\tdebugString += \" | AmbientEnvMapMethod | EnvMap-Name =\" + (<CubeTextureBase> returnedArray[1]).name;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 51: //DepthDiffuseMethod\n\t\t\t\t\t\tmat.diffuseMethod = new DiffuseDepthMethod();\n\t\t\t\t\t\tdebugString += \" | DiffuseDepthMethod\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 52: //GradientDiffuseMethod\n\t\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]);\n\t\t\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the GradientDiffuseTexture (ID = \" + targetID + \" ) for this GradientDiffuseMethod\");\n\t\t\t\t\t\tmat.diffuseMethod = new DiffuseGradientMethod(returnedArray[1]);\n\t\t\t\t\t\tdebugString += \" | DiffuseGradientMethod | GradientDiffuseTexture-Name =\" + (<Texture2DBase> returnedArray[1]).name;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 53: //WrapDiffuseMethod\n\t\t\t\t\t\tmat.diffuseMethod = new DiffuseWrapMethod(props.get(101, 5));\n\t\t\t\t\t\tdebugString += \" | DiffuseWrapMethod\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 54: //LightMapDiffuseMethod\n\t\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]);\n\t\t\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the LightMap (ID = \" + targetID + \" ) for this LightMapDiffuseMethod\");\n\t\t\t\t\t\tmat.diffuseMethod = new DiffuseLightMapMethod(returnedArray[1], this.blendModeDic[props.get(401, 10)], false, mat.diffuseMethod);\n\t\t\t\t\t\tdebugString += \" | DiffuseLightMapMethod | LightMapTexture-Name =\" + (<Texture2DBase> returnedArray[1]).name;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 55: //CelDiffuseMethod\n\t\t\t\t\t\tmat.diffuseMethod = new DiffuseCelMethod(props.get(401, 3), mat.diffuseMethod);\n\t\t\t\t\t\t(<DiffuseCelMethod> mat.diffuseMethod).smoothness = props.get(101, 0.1);\n\t\t\t\t\t\tdebugString += \" | DiffuseCelMethod\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 56: //SubSurfaceScatteringMethod\n//\t\t\t\t\t\t\tmat.diffuseMethod = new DiffuseSubSurfaceMethod(); //depthMapSize and depthMapOffset ?\n//\t\t\t\t\t\t\t(<DiffuseSubSurfaceMethod> mat.diffuseMethod).scattering = props.get(101, 0.2);\n//\t\t\t\t\t\t\t(<DiffuseSubSurfaceMethod> mat.diffuseMethod).translucency = props.get(102, 1);\n//\t\t\t\t\t\t\t(<DiffuseSubSurfaceMethod> mat.diffuseMethod).scatterColor = props.get(601, 0xffffff);\n//\t\t\t\t\t\t\tdebugString += \" | DiffuseSubSurfaceMethod\";\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 101: //AnisotropicSpecularMethod\n\t\t\t\t\t\tmat.specularMethod = new SpecularAnisotropicMethod();\n\t\t\t\t\t\tdebugString += \" | SpecularAnisotropicMethod\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 102: //SpecularPhongMethod\n\t\t\t\t\t\tmat.specularMethod = new SpecularPhongMethod();\n\t\t\t\t\t\tdebugString += \" | SpecularPhongMethod\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 103: //CellSpecularMethod\n\t\t\t\t\t\tmat.specularMethod = new SpecularCelMethod(props.get(101, 0.5), mat.specularMethod);\n\t\t\t\t\t\t(<SpecularCelMethod> mat.specularMethod).smoothness = props.get(102, 0.1);\n\t\t\t\t\t\tdebugString += \" | SpecularCelMethod\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 104: //SpecularFresnelMethod\n\t\t\t\t\t\tmat.specularMethod = new SpecularFresnelMethod(props.get(701, true), mat.specularMethod);\n\t\t\t\t\t\t(<SpecularFresnelMethod> mat.specularMethod).fresnelPower = props.get(101, 5);\n\t\t\t\t\t\t(<SpecularFresnelMethod> mat.specularMethod).normalReflectance = props.get(102, 0.1);\n\t\t\t\t\t\tdebugString += \" | SpecularFresnelMethod\";\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 151://HeightMapNormalMethod - thios is not implemented for now, but might appear later\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 152: //SimpleWaterNormalMethod\n\t\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]);\n\t\t\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the SecoundNormalMap (ID = \" + targetID + \" ) for this SimpleWaterNormalMethod\");\n\t\t\t\t\t\tif (!mat.normalMap)\n\t\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find a normal Map on this Material to use with this SimpleWaterNormalMethod\");\n\n\t\t\t\t\t\tmat.normalMap = returnedArray[1];\n\t\t\t\t\t\tmat.normalMethod = new NormalSimpleWaterMethod(mat.normalMap, returnedArray[1]);\n\t\t\t\t\t\tdebugString += \" | NormalSimpleWaterMethod | Second-NormalTexture-Name = \" + (<Texture2DBase> returnedArray[1]).name;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tthis.parseUserAttributes();\n\t\t\t\tmethods_parsed += 1;\n\t\t\t}\n\t\t}\n\t\tmat.extra = this.parseUserAttributes();\n\t\tthis._pFinalizeAsset(<IAsset> mat, name);\n\n\t\tthis._blocks[blockID].data = mat;\n\t\tif (this._debug) {\n\t\t\tconsole.log(debugString);\n\t\t}\n\t}\n\n\t//Block ID = 82\n\tprivate parseTexture(blockID:number):void\n\t{\n\n\t\tvar asset:Texture2DBase;\n\n\t\tthis._blocks[blockID].name = this.parseVarStr();\n\n\t\tvar type:number = this._newBlockBytes.readUnsignedByte();\n\t\tvar data_len:number;\n\n\t\tthis._texture_users[this._cur_block_id.toString()] = [];\n\n\t\t// External\n\t\tif (type == 0) {\n\t\t\tdata_len = this._newBlockBytes.readUnsignedInt();\n\t\t\tvar url:string;\n\t\t\turl = this._newBlockBytes.readUTFBytes(data_len);\n\t\t\tthis._pAddDependency(this._cur_block_id.toString(), new URLRequest(url), false, null, true);\n\n\t\t} else {\n\t\t\tdata_len = this._newBlockBytes.readUnsignedInt();\n\n\t\t\tvar data:ByteArray;\n\t\t\tdata = new ByteArray();\n\t\t\tthis._newBlockBytes.readBytes(data, 0, data_len);\n\n\t\t\t//\n\t\t\t// AWDParser - Fix for FireFox Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=715075 .\n\t\t\t//\n\t\t\t// Converting data to image here instead of parser - fix FireFox bug where image width / height is 0 when created from data\n\t\t\t// This gives the browser time to initialise image width / height.\n\n\t\t\tthis._pAddDependency(this._cur_block_id.toString(), null, false, ParserUtils.byteArrayToImage(data), true);\n\t\t\t//this._pAddDependency(this._cur_block_id.toString(), null, false, data, true);\n\n\t\t}\n\n\t\t// Ignore for now\n\t\tthis.parseProperties(null);\n\t\tthis._blocks[blockID].extras = this.parseUserAttributes();\n\t\tthis._pPauseAndRetrieveDependencies();\n\t\tthis._blocks[blockID].data = asset;\n\n\t\tif (this._debug) {\n\t\t\tvar textureStylesNames:Array<string> = [\"external\", \"embed\"]\n\t\t\tconsole.log(\"Start parsing a \" + textureStylesNames[type] + \" Bitmap for Texture\");\n\t\t}\n\n\t}\n\n\t//Block ID = 83\n\tprivate parseCubeTexture(blockID:number):void\n\t{\n\t\t//blockLength = block.len;\n\t\tvar data_len:number;\n\t\tvar asset:CubeTextureBase;\n\t\tvar i:number;\n\n\t\tthis._cubeTextures = new Array<any>();\n\t\tthis._texture_users[ this._cur_block_id.toString() ] = [];\n\n\t\tvar type:number = this._newBlockBytes.readUnsignedByte();\n\n\t\tthis._blocks[blockID].name = this.parseVarStr();\n\n\t\tfor (i = 0; i < 6; i++) {\n\t\t\tthis._texture_users[this._cur_block_id.toString()] = [];\n\t\t\tthis._cubeTextures.push(null);\n\n\t\t\t// External\n\t\t\tif (type == 0) {\n\t\t\t\tdata_len = this._newBlockBytes.readUnsignedInt();\n\t\t\t\tvar url:string;\n\t\t\t\turl = this._newBlockBytes.readUTFBytes(data_len);\n\n\t\t\t\tthis._pAddDependency(this._cur_block_id.toString() + \"#\" + i, new URLRequest(url), false, null, true);\n\t\t\t} else {\n\n\t\t\t\tdata_len = this._newBlockBytes.readUnsignedInt();\n\t\t\t\tvar data:ByteArray;\n\t\t\t\tdata = new ByteArray();\n\n\t\t\t\tthis._newBlockBytes.readBytes(data, 0, data_len);\n\n\t\t\t\tthis._pAddDependency(this._cur_block_id.toString() + \"#\" + i, null, false, ParserUtils.byteArrayToImage(data), true);\n\t\t\t}\n\t\t}\n\n\t\t// Ignore for now\n\t\tthis.parseProperties(null);\n\t\tthis._blocks[blockID].extras = this.parseUserAttributes();\n\t\tthis._pPauseAndRetrieveDependencies();\n\t\tthis._blocks[blockID].data = asset;\n\n\t\tif (this._debug) {\n\t\t\tvar textureStylesNames:Array<string> = [\"external\", \"embed\"]\n\t\t\tconsole.log(\"Start parsing 6 \" + textureStylesNames[type] + \" Bitmaps for CubeTexture\");\n\t\t}\n\t}\n\n\t//Block ID = 91\n\tprivate parseSharedMethodBlock(blockID:number):void\n\t{\n\t\tvar asset:EffectMethodBase;\n\n\t\tthis._blocks[blockID].name = this.parseVarStr();\n\t\tasset = this.parseSharedMethodList(blockID);\n\t\tthis.parseUserAttributes();\n\t\tthis._blocks[blockID].data = asset;\n\t\tthis._pFinalizeAsset(<IAsset> asset, this._blocks[blockID].name);\n\t\tthis._blocks[blockID].data = asset;\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a EffectMethod: Name = \" + asset.name + \" Type = \" + asset);\n\t\t}\n\t}\n\n\t//Block ID = 92\n\tprivate parseShadowMethodBlock(blockID:number):void\n\t{\n\t\tvar type:number;\n\t\tvar data_len:number;\n\t\tvar asset:ShadowMethodBase;\n\t\tvar shadowLightID:number;\n\t\tthis._blocks[blockID].name = this.parseVarStr();\n\n\t\tshadowLightID = this._newBlockBytes.readUnsignedInt();\n\t\tvar returnedArray:Array<any> = this.getAssetByID(shadowLightID, [AssetType.LIGHT]);\n\n\t\tif (!returnedArray[0]) {\n\t\t\tthis._blocks[blockID].addError(\"Could not find the TargetLight (ID = \" + shadowLightID + \" ) for this ShadowMethod - ShadowMethod not created\");\n\t\t\treturn;\n\t\t}\n\n\t\tasset = this.parseShadowMethodList(<LightBase> returnedArray[1], blockID);\n\n\t\tif (!asset)\n\t\t\treturn;\n\n\t\tthis.parseUserAttributes(); // Ignore for now\n\t\tthis._pFinalizeAsset(<IAsset> asset, this._blocks[blockID].name);\n\t\tthis._blocks[blockID].data = asset;\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a ShadowMapMethodMethod: Name = \" + asset.name + \" | Type = \" + asset + \" | Light-Name = \", ( <LightBase> returnedArray[1] ).name);\n\t\t}\n\t}\n\n\n\t//Block ID = 253\n\tprivate parseCommand(blockID:number):void\n\t{\n\t\tvar hasBlocks:boolean = ( this._newBlockBytes.readUnsignedByte() == 1 );\n\t\tvar par_id:number = this._newBlockBytes.readUnsignedInt();\n\t\tvar mtx:Matrix3D = this.parseMatrix3D();\n\t\tvar name:string = this.parseVarStr();\n\n\t\tvar parentObject:DisplayObjectContainer;\n\t\tvar targetObject:DisplayObjectContainer;\n\n\t\tvar returnedArray:Array<any> = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]);\n\n\t\tif (returnedArray[0]) {\n\t\t\tparentObject = <DisplayObjectContainer> returnedArray[1];\n\t\t}\n\n\t\tvar numCommands:number = this._newBlockBytes.readShort();\n\t\tvar typeCommand:number = this._newBlockBytes.readShort();\n\n\t\tvar props:AWDProperties = this.parseProperties({1:AWDParser.BADDR});\n\n\t\tswitch (typeCommand) {\n\t\t\tcase 1:\n\n\t\t\t\tvar targetID:number = props.get(1, 0);\n\t\t\t\tvar returnedArrayTarget:Array<any> = this.getAssetByID(targetID, [AssetType.LIGHT, AssetType.TEXTURE_PROJECTOR]); //for no only light is requested!!!!\n\n\t\t\t\tif ((!returnedArrayTarget[0]) && (targetID != 0)) {\n\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the light (ID = \" + targetID + \" ( for this CommandBock!\");\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\ttargetObject = returnedArrayTarget[1];\n\n\t\t\t\tif (parentObject) {\n\t\t\t\t\tparentObject.addChild(targetObject);\n\t\t\t\t}\n\n\t\t\t\ttargetObject.transform.matrix3D = mtx;\n\n\t\t\t\tbreak;\n\t\t}\n\n\t\tif (targetObject) {\n\t\t\tprops = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8});\n\n\t\t\ttargetObject.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0));\n\t\t\ttargetObject.extra = this.parseUserAttributes();\n\n\t\t}\n\t\tthis._blocks[blockID].data = targetObject\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a CommandBlock: Name = '\" + name);\n\t\t}\n\n\t}\n\n\t//blockID 255\n\tprivate parseMetaData(blockID:number):void\n\t{\n\t\tvar props:AWDProperties = this.parseProperties({1:AWDParser.UINT32, 2:AWDParser.AWDSTRING, 3:AWDParser.AWDSTRING, 4:AWDParser.AWDSTRING, 5:AWDParser.AWDSTRING});\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Parsed a MetaDataBlock: TimeStamp         = \" + props.get(1, 0));\n\t\t\tconsole.log(\"                        EncoderName       = \" + props.get(2, \"unknown\"));\n\t\t\tconsole.log(\"                        EncoderVersion    = \" + props.get(3, \"unknown\"));\n\t\t\tconsole.log(\"                        GeneratorName     = \" + props.get(4, \"unknown\"));\n\t\t\tconsole.log(\"                        GeneratorVersion  = \" + props.get(5, \"unknown\"));\n\t\t}\n\t}\n\n\t//blockID 254\n\tprivate parseNameSpace(blockID:number):void\n\t{\n\t\tvar id:number = this._newBlockBytes.readUnsignedByte();\n\t\tvar nameSpaceString:string = this.parseVarStr();\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a NameSpaceBlock: ID = \" + id + \" | String = \" + nameSpaceString);\n\t}\n\n\t//--Parser UTILS---------------------------------------------------------------------------\n\n\t// this functions reads and creates a ShadowMethodMethod\n\tprivate parseShadowMethodList(light:LightBase, blockID:number):ShadowMethodBase\n\t{\n\n\t\tvar methodType:number = this._newBlockBytes.readUnsignedShort();\n\t\tvar shadowMethod:ShadowMethodBase;\n\t\tvar props:AWDProperties = this.parseProperties({1:AWDParser.BADDR, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 201:AWDParser.UINT32, 202:AWDParser.UINT32, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 401:AWDParser.UINT8, 402:AWDParser.UINT8, 601:AWDParser.COLOR, 602:AWDParser.COLOR, 701:AWDParser.BOOL, 702:AWDParser.BOOL, 801:AWDParser.MTX4x4});\n\n\t\tvar targetID:number;\n\t\tvar returnedArray:Array<any>\n\t\tswitch (methodType) {\n\t\t\t//\t\t\t\tcase 1001: //CascadeShadowMapMethod\n\t\t\t//\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t//\t\t\t\t\treturnedArray = getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]);\n\t\t\t//\t\t\t\t\tif (!returnedArray[0]) {\n\t\t\t//\t\t\t\t\t\t_blocks[blockID].addError(\"Could not find the ShadowBaseMethod (ID = \" + targetID + \" ) for this CascadeShadowMapMethod - ShadowMethod not created\");\n\t\t\t//\t\t\t\t\t\treturn shadowMethod;\n\t\t\t//\t\t\t\t\t}\n\t\t\t//\t\t\t\t\tshadowMethod = new CascadeShadowMapMethod(returnedArray[1]);\n\t\t\t//\t\t\t\t\tbreak;\n\t\t\tcase 1002: //ShadowNearMethod\n\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]);\n\t\t\t\tif (!returnedArray[0]) {\n\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the ShadowBaseMethod (ID = \" + targetID + \" ) for this ShadowNearMethod - ShadowMethod not created\");\n\t\t\t\t\treturn shadowMethod;\n\t\t\t\t}\n\t\t\t\tshadowMethod = new ShadowNearMethod(<ShadowMethodBase> returnedArray[1]);\n\t\t\t\tbreak;\n\t\t\tcase 1101: //ShadowFilteredMethod\n\n\t\t\t\tshadowMethod = new ShadowFilteredMethod(<DirectionalLight> light);\n\t\t\t\t(<ShadowFilteredMethod> shadowMethod).alpha = props.get(101, 1);\n\t\t\t\t(<ShadowFilteredMethod> shadowMethod).epsilon = props.get(102, 0.002);\n\t\t\t\tbreak;\n\n\t\t\tcase 1102: //ShadowDitheredMethod\n\n\n\t\t\t\tshadowMethod = new ShadowDitheredMethod(<DirectionalLight> light, <number> props.get(201, 5));\n\t\t\t\t(<ShadowDitheredMethod> shadowMethod).alpha = props.get(101, 1);\n\t\t\t\t(<ShadowDitheredMethod> shadowMethod).epsilon = props.get(102, 0.002);\n\t\t\t\t(<ShadowDitheredMethod> shadowMethod).range = props.get(103, 1);\n\n\t\t\t\tbreak;\n\t\t\tcase 1103: //ShadowSoftMethod\n\n\t\t\t\tshadowMethod = new ShadowSoftMethod(<DirectionalLight> light, <number> props.get(201, 5));\n\t\t\t\t(<ShadowSoftMethod> shadowMethod).alpha = props.get(101, 1);\n\t\t\t\t(<ShadowSoftMethod> shadowMethod).epsilon = props.get(102, 0.002);\n\t\t\t\t(<ShadowSoftMethod> shadowMethod).range = props.get(103, 1);\n\n\t\t\t\tbreak;\n\t\t\tcase 1104: //ShadowHardMethod\n\t\t\t\tshadowMethod = new ShadowHardMethod(light);\n\t\t\t\t(<ShadowHardMethod> shadowMethod).alpha = props.get(101, 1);\n\t\t\t\t(<ShadowHardMethod> shadowMethod).epsilon = props.get(102, 0.002);\n\t\t\t\tbreak;\n\n\t\t}\n\t\tthis.parseUserAttributes();\n\t\treturn shadowMethod;\n\t}\n\n\t//Block ID 101\n\tprivate parseSkeleton(blockID:number /*uint*/):void\n\t{\n\t\tvar name:string = this.parseVarStr();\n\t\tvar num_joints:number /*uint*/ = this._newBlockBytes.readUnsignedShort();\n\t\tvar skeleton:Skeleton = new Skeleton();\n\t\tthis.parseProperties(null); // Discard properties for now\t\t\n\n\t\tvar joints_parsed:number /*uint*/ = 0;\n\t\twhile (joints_parsed < num_joints) {\n\t\t\tvar joint:SkeletonJoint;\n\t\t\tvar ibp:Matrix3D;\n\t\t\t// Ignore joint id\n\t\t\tthis._newBlockBytes.readUnsignedShort();\n\t\t\tjoint = new SkeletonJoint();\n\t\t\tjoint.parentIndex = this._newBlockBytes.readUnsignedShort() - 1; // 0=null in AWD\n\t\t\tjoint.name = this.parseVarStr();\n\n\t\t\tibp = this.parseMatrix3D();\n\t\t\tjoint.inverseBindPose = ibp.rawData;\n\t\t\t// Ignore joint props/attributes for now\n\t\t\tthis.parseProperties(null);\n\t\t\tthis.parseUserAttributes();\n\t\t\tskeleton.joints.push(joint);\n\t\t\tjoints_parsed++;\n\t\t}\n\n\t\t// Discard attributes for now\n\t\tthis.parseUserAttributes();\n\t\tthis._pFinalizeAsset(skeleton, name);\n\t\tthis._blocks[blockID].data = skeleton;\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a Skeleton: Name = \" + skeleton.name + \" | Number of Joints = \" + joints_parsed);\n\t}\n\n\t//Block ID = 102\n\tprivate parseSkeletonPose(blockID:number /*uint*/):void\n\t{\n\t\tvar name:string = this.parseVarStr();\n\t\tvar num_joints:number /*uint*/ = this._newBlockBytes.readUnsignedShort();\n\t\tthis.parseProperties(null); // Ignore properties for now\n\n\t\tvar pose:SkeletonPose = new SkeletonPose();\n\n\t\tvar joints_parsed:number /*uint*/ = 0;\n\t\twhile (joints_parsed < num_joints) {\n\t\t\tvar joint_pose:JointPose;\n\t\t\tvar has_transform:number /*uint*/;\n\t\t\tjoint_pose = new JointPose();\n\t\t\thas_transform = this._newBlockBytes.readUnsignedByte();\n\t\t\tif (has_transform == 1) {\n\t\t\t\tvar mtx_data:Array<number> = this.parseMatrix43RawData();\n\n\t\t\t\tvar mtx:Matrix3D = new Matrix3D(mtx_data);\n\t\t\t\tjoint_pose.orientation.fromMatrix(mtx);\n\t\t\t\tjoint_pose.translation.copyFrom(mtx.position);\n\n\t\t\t\tpose.jointPoses[joints_parsed] = joint_pose;\n\t\t\t}\n\t\t\tjoints_parsed++;\n\t\t}\n\t\t// Skip attributes for now\n\t\tthis.parseUserAttributes();\n\t\tthis._pFinalizeAsset(pose, name);\n\t\tthis._blocks[blockID].data = pose;\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a SkeletonPose: Name = \" + pose.name + \" | Number of Joints = \" + joints_parsed);\n\t}\n\n\t//blockID 103\n\tprivate parseSkeletonAnimation(blockID:number /*uint*/):void\n\t{\n\t\tvar frame_dur:number;\n\t\tvar pose_addr:number /*uint*/;\n\t\tvar name:string = this.parseVarStr();\n\t\tvar clip:SkeletonClipNode = new SkeletonClipNode();\n\t\tvar num_frames:number /*uint*/ = this._newBlockBytes.readUnsignedShort();\n\t\tthis.parseProperties(null); // Ignore properties for now\n\n\t\tvar frames_parsed:number /*uint*/ = 0;\n\t\tvar returnedArray:Array<any>;\n\t\twhile (frames_parsed < num_frames) {\n\t\t\tpose_addr = this._newBlockBytes.readUnsignedInt();\n\t\t\tframe_dur = this._newBlockBytes.readUnsignedShort();\n\t\t\treturnedArray = this.getAssetByID(pose_addr, [AssetType.SKELETON_POSE]);\n\t\t\tif (!returnedArray[0])\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the SkeletonPose Frame # \" + frames_parsed + \" (ID = \" + pose_addr + \" ) for this SkeletonClipNode\");\n\t\t\telse\n\t\t\t\tclip.addFrame(<SkeletonPose> this._blocks[pose_addr].data, frame_dur);\n\t\t\tframes_parsed++;\n\t\t}\n\t\tif (clip.frames.length == 0) {\n\t\t\tthis._blocks[blockID].addError(\"Could not this SkeletonClipNode, because no Frames where set.\");\n\t\t\treturn;\n\t\t}\n\t\t// Ignore attributes for now\n\t\tthis.parseUserAttributes();\n\t\tthis._pFinalizeAsset(clip, name);\n\t\tthis._blocks[blockID].data = clip;\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a SkeletonClipNode: Name = \" + clip.name + \" | Number of Frames = \" + clip.frames.length);\n\t}\n\n\t//Block ID = 111 /  Block ID = 112\n\tprivate parseMeshPoseAnimation(blockID:number /*uint*/, poseOnly:boolean = false):void\n\t{\n\t\tvar num_frames:number /*uint*/ = 1;\n\t\tvar num_submeshes:number /*uint*/;\n\t\tvar frames_parsed:number /*uint*/;\n\t\tvar subMeshParsed:number /*uint*/;\n\t\tvar frame_dur:number;\n\t\tvar x:number;\n\t\tvar y:number;\n\t\tvar z:number;\n\t\tvar str_len:number;\n\t\tvar str_end:number;\n\t\tvar geometry:Geometry;\n\t\tvar subGeom:TriangleSubGeometry;\n\t\tvar idx:number /*int*/ = 0;\n\t\tvar clip:VertexClipNode = new VertexClipNode();\n\t\tvar indices:Array<number> /*uint*/;\n\t\tvar verts:Array<number>;\n\t\tvar num_Streams:number /*int*/ = 0;\n\t\tvar streamsParsed:number /*int*/ = 0;\n\t\tvar streamtypes:Array<number> /*int*/ = new Array<number>() /*int*/;\n\t\tvar props:AWDProperties;\n\t\tvar thisGeo:Geometry;\n\t\tvar name:string = this.parseVarStr();\n\t\tvar geoAdress:number /*int*/ = this._newBlockBytes.readUnsignedInt();\n\t\tvar returnedArray:Array<any> = this.getAssetByID(geoAdress, [AssetType.GEOMETRY]);\n\t\tif (!returnedArray[0]) {\n\t\t\tthis._blocks[blockID].addError(\"Could not find the target-Geometry-Object \" + geoAdress + \" ) for this VertexClipNode\");\n\t\t\treturn;\n\t\t}\n\t\tvar uvs:Array<Array<number>> = this.getUVForVertexAnimation(geoAdress);\n\t\tif (!poseOnly)\n\t\t\tnum_frames = this._newBlockBytes.readUnsignedShort();\n\n\t\tnum_submeshes = this._newBlockBytes.readUnsignedShort();\n\t\tnum_Streams = this._newBlockBytes.readUnsignedShort();\n\t\tstreamsParsed = 0;\n\t\twhile (streamsParsed < num_Streams) {\n\t\t\tstreamtypes.push(this._newBlockBytes.readUnsignedShort());\n\t\t\tstreamsParsed++;\n\t\t}\n\t\tprops = this.parseProperties({1:AWDParser.BOOL, 2:AWDParser.BOOL});\n\n\t\tclip.looping = props.get(1, true);\n\t\tclip.stitchFinalFrame = props.get(2, false);\n\n\t\tframes_parsed = 0;\n\t\twhile (frames_parsed < num_frames) {\n\t\t\tframe_dur = this._newBlockBytes.readUnsignedShort();\n\t\t\tgeometry = new Geometry();\n\t\t\tsubMeshParsed = 0;\n\t\t\twhile (subMeshParsed < num_submeshes) {\n\t\t\t\tstreamsParsed = 0;\n\t\t\t\tstr_len = this._newBlockBytes.readUnsignedInt();\n\t\t\t\tstr_end = this._newBlockBytes.position + str_len;\n\t\t\t\twhile (streamsParsed < num_Streams) {\n\t\t\t\t\tif (streamtypes[streamsParsed] == 1) {\n\t\t\t\t\t\tindices = (<Geometry> returnedArray[1]).subGeometries[subMeshParsed].indices;\n\t\t\t\t\t\tverts = new Array<number>();\n\t\t\t\t\t\tidx = 0;\n\t\t\t\t\t\twhile (this._newBlockBytes.position < str_end) {\n\t\t\t\t\t\t\tx = this.readNumber(this._accuracyGeo)\n\t\t\t\t\t\t\ty = this.readNumber(this._accuracyGeo)\n\t\t\t\t\t\t\tz = this.readNumber(this._accuracyGeo)\n\t\t\t\t\t\t\tverts[idx++] = x;\n\t\t\t\t\t\t\tverts[idx++] = y;\n\t\t\t\t\t\t\tverts[idx++] = z;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsubGeom = new TriangleSubGeometry(true);\n\t\t\t\t\t\tsubGeom.updateIndices(indices);\n\t\t\t\t\t\tsubGeom.updatePositions(verts);\n\t\t\t\t\t\tsubGeom.updateUVs(uvs[subMeshParsed]);\n\t\t\t\t\t\tsubGeom.updateVertexNormals(null);\n\t\t\t\t\t\tsubGeom.updateVertexTangents(null);\n\t\t\t\t\t\tsubGeom.autoDeriveNormals = false;\n\t\t\t\t\t\tsubGeom.autoDeriveTangents = false;\n\t\t\t\t\t\tsubMeshParsed++;\n\t\t\t\t\t\tgeometry.addSubGeometry(subGeom)\n\t\t\t\t\t} else\n\t\t\t\t\t\tthis._newBlockBytes.position = str_end;\n\t\t\t\t\tstreamsParsed++;\n\t\t\t\t}\n\t\t\t}\n\t\t\tclip.addFrame(geometry, frame_dur);\n\t\t\tframes_parsed++;\n\t\t}\n\t\tthis.parseUserAttributes();\n\t\tthis._pFinalizeAsset(clip, name);\n\n\t\tthis._blocks[blockID].data = clip;\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a VertexClipNode: Name = \" + clip.name + \" | Target-Geometry-Name = \" + (<Geometry> returnedArray[1]).name + \" | Number of Frames = \" + clip.frames.length);\n\t}\n\n\t//BlockID 113\n\tprivate parseVertexAnimationSet(blockID:number /*uint*/):void\n\t{\n\t\tvar poseBlockAdress:number /*int*/\n\t\tvar outputString:string = \"\";\n\t\tvar name:string = this.parseVarStr();\n\t\tvar num_frames:number /*uint*/ = this._newBlockBytes.readUnsignedShort();\n\t\tvar props:AWDProperties = this.parseProperties({1:AWDParser.UINT16});\n\t\tvar frames_parsed:number /*uint*/ = 0;\n\t\tvar skeletonFrames:Array<SkeletonClipNode> = new Array<SkeletonClipNode>();\n\t\tvar vertexFrames:Array<VertexClipNode> = new Array<VertexClipNode>();\n\t\twhile (frames_parsed < num_frames) {\n\t\t\tposeBlockAdress = this._newBlockBytes.readUnsignedInt();\n\t\t\tvar returnedArray:Array<any> = this.getAssetByID(poseBlockAdress, [AssetType.ANIMATION_NODE]);\n\t\t\tif (!returnedArray[0])\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the AnimationClipNode Nr \" + frames_parsed + \" ( \" + poseBlockAdress + \" ) for this AnimationSet\");\n\t\t\telse {\n\t\t\t\tif (returnedArray[1] instanceof VertexClipNode)\n\t\t\t\tvertexFrames.push(returnedArray[1])\n\t\t\t\tif (returnedArray[1] instanceof SkeletonClipNode)\n\t\t\t\tskeletonFrames.push(returnedArray[1])\n\t\t\t}\n\t\t\tframes_parsed++;\n\t\t}\n\t\tif ((vertexFrames.length == 0) && (skeletonFrames.length == 0)) {\n\t\t\tthis._blocks[blockID].addError(\"Could not create this AnimationSet, because it contains no animations\");\n\t\t\treturn;\n\t\t}\n\t\tthis.parseUserAttributes();\n\t\tif (vertexFrames.length > 0) {\n\t\t\tvar newVertexAnimationSet:VertexAnimationSet = new VertexAnimationSet();\n\t\t\tfor (var i:number /*int*/ = 0; i < vertexFrames.length; i++)\n\t\t\t\tnewVertexAnimationSet.addAnimation(vertexFrames[i]);\n\t\t\tthis._pFinalizeAsset(newVertexAnimationSet, name);\n\t\t\tthis._blocks[blockID].data = newVertexAnimationSet;\n\t\t\tif (this._debug)\n\t\t\t\tconsole.log(\"Parsed a VertexAnimationSet: Name = \" + name + \" | Animations = \" + newVertexAnimationSet.animations.length + \" | Animation-Names = \" + newVertexAnimationSet.animationNames.toString());\n\n\t\t} else if (skeletonFrames.length > 0) {\n\t\t\treturnedArray = this.getAssetByID(poseBlockAdress, [AssetType.ANIMATION_NODE]);\n\t\t\tvar newSkeletonAnimationSet:SkeletonAnimationSet = new SkeletonAnimationSet(props.get(1, 4)); //props.get(1,4));\n\t\t\tfor (var i:number /*int*/ = 0; i < skeletonFrames.length; i++)\n\t\t\t\tnewSkeletonAnimationSet.addAnimation(skeletonFrames[i]);\n\t\t\tthis._pFinalizeAsset(newSkeletonAnimationSet, name);\n\t\t\tthis._blocks[blockID].data = newSkeletonAnimationSet;\n\t\t\tif (this._debug)\n\t\t\t\tconsole.log(\"Parsed a SkeletonAnimationSet: Name = \" + name + \" | Animations = \" + newSkeletonAnimationSet.animations.length + \" | Animation-Names = \" + newSkeletonAnimationSet.animationNames.toString());\n\n\t\t}\n\t}\n\n\t//BlockID 122\n\tprivate parseAnimatorSet(blockID:number /*uint*/):void\n\t{\n\t\tvar targetMesh:Mesh;\n\t\tvar animSetBlockAdress:number /*int*/\n\t\tvar targetAnimationSet:AnimationSetBase;\n\t\tvar outputString:string = \"\";\n\t\tvar name:string = this.parseVarStr();\n\t\tvar type:number /*uint*/ = this._newBlockBytes.readUnsignedShort();\n\n\t\tvar props:AWDProperties = this.parseProperties({1:AWDParser.BADDR});\n\n\t\tanimSetBlockAdress = this._newBlockBytes.readUnsignedInt();\n\t\tvar targetMeshLength:number /*uint*/ = this._newBlockBytes.readUnsignedShort();\n\t\tvar meshAdresses:Array<number> /*uint*/ = new Array<number>() /*uint*/;\n\t\tfor (var i:number /*int*/ = 0; i < targetMeshLength; i++)\n\t\t\tmeshAdresses.push(this._newBlockBytes.readUnsignedInt());\n\n\t\tvar activeState:number /*uint*/ = this._newBlockBytes.readUnsignedShort();\n\t\tvar autoplay:boolean = ( this._newBlockBytes.readUnsignedByte() == 1 );\n\t\tthis.parseUserAttributes();\n\t\tthis.parseUserAttributes();\n\n\t\tvar returnedArray:Array<any>;\n\t\tvar targetMeshes:Array<Mesh> = new Array<Mesh>();\n\n\t\tfor (i = 0; i < meshAdresses.length; i++) {\n\t\t\treturnedArray = this.getAssetByID(meshAdresses[i], [AssetType.MESH]);\n\t\t\tif (returnedArray[0])\n\t\t\t\ttargetMeshes.push(<Mesh> returnedArray[1]);\n\t\t}\n\t\treturnedArray = this.getAssetByID(animSetBlockAdress, [AssetType.ANIMATION_SET]);\n\t\tif (!returnedArray[0]) {\n\t\t\tthis._blocks[blockID].addError(\"Could not find the AnimationSet ( \" + animSetBlockAdress + \" ) for this Animator\");;\n\t\t\treturn\n\t\t}\n\t\ttargetAnimationSet = <AnimationSetBase> returnedArray[1];\n\t\tvar thisAnimator:AnimatorBase;\n\t\tif (type == 1) {\n\n\t\t\treturnedArray = this.getAssetByID(props.get(1, 0), [AssetType.SKELETON]);\n\t\t\tif (!returnedArray[0]) {\n\t\t\t\tthis._blocks[blockID].addError(\"Could not find the Skeleton ( \" + props.get(1, 0) + \" ) for this Animator\");\n\t\t\t\treturn\n\t\t\t}\n\t\t\tthisAnimator = new SkeletonAnimator(<SkeletonAnimationSet> targetAnimationSet, <Skeleton> returnedArray[1]);\n\n\t\t} else if (type == 2)\n\t\t\tthisAnimator = new VertexAnimator(<VertexAnimationSet> targetAnimationSet);\n\n\t\tthis._pFinalizeAsset(thisAnimator, name);\n\t\tthis._blocks[blockID].data = thisAnimator;\n\t\tfor (i = 0; i < targetMeshes.length; i++) {\n\t\t\tif (type == 1)\n\t\t\t\ttargetMeshes[i].animator = (<SkeletonAnimator> thisAnimator);\n\t\t\tif (type == 2)\n\t\t\t\ttargetMeshes[i].animator = (<VertexAnimator> thisAnimator);\n\n\t\t}\n\t\tif (this._debug)\n\t\t\tconsole.log(\"Parsed a Animator: Name = \" + name);\n\t}\n\t\n\t// this functions reads and creates a EffectMethod\n\tprivate parseSharedMethodList(blockID:number):EffectMethodBase\n\t{\n\n\t\tvar methodType:number = this._newBlockBytes.readUnsignedShort();\n\t\tvar effectMethodReturn:EffectMethodBase;\n\n\t\tvar props:AWDProperties = this.parseProperties({1:AWDParser.BADDR, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 104:this._propsNrType, 105:this._propsNrType, 106:this._propsNrType, 107:this._propsNrType, 201:AWDParser.UINT32, 202:AWDParser.UINT32, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 401:AWDParser.UINT8, 402:AWDParser.UINT8, 601:AWDParser.COLOR, 602:AWDParser.COLOR, 701:AWDParser.BOOL, 702:AWDParser.BOOL});\n\t\tvar targetID:number;\n\t\tvar returnedArray:Array<any>;\n\n\t\tswitch (methodType) {\n\t\t\t// Effect Methods\n\t\t\tcase 401: //ColorMatrix\n\t\t\t\teffectMethodReturn = new EffectColorMatrixMethod(props.get(101, new Array(0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)));\n\t\t\t\tbreak;\n\t\t\tcase 402: //ColorTransform\n\t\t\t\teffectMethodReturn = new EffectColorTransformMethod();\n\t\t\t\tvar offCol:number /*uint*/ = props.get(601, 0x00000000);\n\t\t\t\t(<EffectColorTransformMethod> effectMethodReturn).colorTransform = new ColorTransform(props.get(102, 1), props.get(103, 1), props.get(104, 1), props.get(101, 1), ((offCol >> 16) & 0xFF), ((offCol >> 8) & 0xFF), (offCol & 0xFF), ((offCol >> 24) & 0xFF));\n\t\t\t\tbreak;\n\t\t\tcase 403: //EnvMap\n\n\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\tconsole.log('ENV MAP', targetID);\n\n\n\t\t\t\treturnedArray = this.getAssetByID(targetID, [ AssetType.TEXTURE ], \"CubeTexture\");\n\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the EnvMap (ID = \" + targetID + \" ) for this EnvMapMethod\");\n\t\t\t\teffectMethodReturn = new EffectEnvMapMethod(<CubeTextureBase> returnedArray[1], <number> props.get(101, 1));\n\t\t\t\ttargetID = props.get(2, 0);\n\t\t\t\tif (targetID > 0) {\n\t\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]);\n\t\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the Mask-texture (ID = \" + targetID + \" ) for this EnvMapMethod\");\n\n\t\t\t\t\t// Todo: test mask with EnvMapMethod\n\t\t\t\t\t//(<EnvMapMethod> effectMethodReturn).mask = <Texture2DBase> returnedArray[1];\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 404: //LightMapMethod\n\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]);\n\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the LightMap (ID = \" + targetID + \" ) for this LightMapMethod\");\n\t\t\t\teffectMethodReturn = new EffectLightMapMethod(returnedArray[1], this.blendModeDic[props.get(401, 10)]); //usesecondaryUV not set\n\t\t\t\tbreak;\n\t\t\t//\t\t\t\tcase 405: //ProjectiveTextureMethod\n\t\t\t//\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t//\t\t\t\t\treturnedArray = getAssetByID(targetID, [AssetType.TEXTURE_PROJECTOR]);\n\t\t\t//\t\t\t\t\tif (!returnedArray[0])\n\t\t\t//\t\t\t\t\t\t_blocks[blockID].addError(\"Could not find the TextureProjector (ID = \" + targetID + \" ) for this ProjectiveTextureMethod\");\n\t\t\t//\t\t\t\t\teffectMethodReturn = new ProjectiveTextureMethod(returnedArray[1], blendModeDic[props.get(401, 10)]);\n\t\t\t//\t\t\t\t\tbreak;\n\t\t\tcase 406: //RimLightMethod\n\t\t\t\teffectMethodReturn = new EffectRimLightMethod(props.get(601, 0xffffff), props.get(101, 0.4), props.get(101, 2)); //blendMode\n\t\t\t\tbreak;\n\t\t\tcase 407: //AlphaMaskMethod\n\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]);\n\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the Alpha-texture (ID = \" + targetID + \" ) for this AlphaMaskMethod\");\n\t\t\t\teffectMethodReturn = new EffectAlphaMaskMethod(returnedArray[1], props.get(701, false));\n\t\t\t\tbreak;\n\t\t\t//\t\t\t\tcase 408: //RefractionEnvMapMethod\n\t\t\t//\t\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t//\t\t\t\t\treturnedArray = getAssetByID(targetID, [AssetType.TEXTURE], \"CubeTexture\");\n\t\t\t//\t\t\t\t\tif (!returnedArray[0])\n\t\t\t//\t\t\t\t\t\t_blocks[blockID].addError(\"Could not find the EnvMap (ID = \" + targetID + \" ) for this RefractionEnvMapMethod\");\n\t\t\t//\t\t\t\t\teffectMethodReturn = new RefractionEnvMapMethod(returnedArray[1], props.get(101, 0.1), props.get(102, 0.01), props.get(103, 0.01), props.get(104, 0.01));\n\t\t\t//\t\t\t\t\tRefractionEnvMapMethod(effectMethodReturn).alpha = props.get(104, 1);\n\t\t\t//\t\t\t\t\tbreak;\n\t\t\t//\t\t\t\tcase 409: //OutlineMethod\n\t\t\t//\t\t\t\t\teffectMethodReturn = new OutlineMethod(props.get(601, 0x00000000), props.get(101, 1), props.get(701, true), props.get(702, false));\n\t\t\t//\t\t\t\t\tbreak;\n\t\t\tcase 410: //FresnelEnvMapMethod\n\t\t\t\ttargetID = props.get(1, 0);\n\t\t\t\treturnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE], \"CubeTexture\");\n\t\t\t\tif (!returnedArray[0])\n\t\t\t\t\tthis._blocks[blockID].addError(\"Could not find the EnvMap (ID = \" + targetID + \" ) for this FresnelEnvMapMethod\");\n\t\t\t\teffectMethodReturn = new EffectFresnelEnvMapMethod(returnedArray[1], props.get(101, 1));\n\t\t\t\tbreak;\n\t\t\tcase 411: //FogMethod\n\t\t\t\teffectMethodReturn = new EffectFogMethod(props.get(101, 0), props.get(102, 1000), props.get(601, 0x808080));\n\t\t\t\tbreak;\n\n\t\t}\n\t\tthis.parseUserAttributes();\n\t\treturn effectMethodReturn;\n\n\t}\n\n\tprivate parseUserAttributes():Object\n\t{\n\t\tvar attributes:Object;\n\t\tvar list_len:number;\n\t\tvar attibuteCnt:number;\n\n\t\tlist_len = this._newBlockBytes.readUnsignedInt();\n\n\t\tif (list_len > 0) {\n\n\t\t\tvar list_end:number;\n\n\t\t\tattributes = {};\n\n\t\t\tlist_end = this._newBlockBytes.position + list_len;\n\n\t\t\twhile (this._newBlockBytes.position < list_end) {\n\t\t\t\tvar ns_id:number;\n\t\t\t\tvar attr_key:string;\n\t\t\t\tvar attr_type:number;\n\t\t\t\tvar attr_len:number;\n\t\t\t\tvar attr_val:any;\n\n\t\t\t\t// TODO: Properly tend to namespaces in attributes\n\t\t\t\tns_id = this._newBlockBytes.readUnsignedByte();\n\t\t\t\tattr_key = this.parseVarStr();\n\t\t\t\tattr_type = this._newBlockBytes.readUnsignedByte();\n\t\t\t\tattr_len = this._newBlockBytes.readUnsignedInt();\n\n\t\t\t\tif ((this._newBlockBytes.position + attr_len) > list_end) {\n\t\t\t\t\tconsole.log(\"           Error in reading attribute # \" + attibuteCnt + \" = skipped to end of attribute-list\");\n\t\t\t\t\tthis._newBlockBytes.position = list_end;\n\t\t\t\t\treturn attributes;\n\t\t\t\t}\n\n\t\t\t\tswitch (attr_type) {\n\t\t\t\t\tcase AWDParser.AWDSTRING:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readUTFBytes(attr_len);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.INT8:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readByte();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.INT16:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readShort();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.INT32:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readInt();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.BOOL:\n\t\t\t\t\tcase AWDParser.UINT8:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readUnsignedByte();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.UINT16:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readUnsignedShort();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.UINT32:\n\t\t\t\t\tcase AWDParser.BADDR:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readUnsignedInt();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.FLOAT32:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readFloat();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AWDParser.FLOAT64:\n\t\t\t\t\t\tattr_val = this._newBlockBytes.readDouble();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tattr_val = 'unimplemented attribute type ' + attr_type;\n\t\t\t\t\t\tthis._newBlockBytes.position += attr_len;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif (this._debug) {\n\t\t\t\t\tconsole.log(\"attribute = name: \" + attr_key + \"  / value = \" + attr_val);\n\t\t\t\t}\n\n\t\t\t\tattributes[attr_key] = attr_val;\n\t\t\t\tattibuteCnt += 1;\n\t\t\t}\n\t\t}\n\n\t\treturn attributes;\n\t}\n\n\tprivate parseProperties(expected:Object):AWDProperties\n\t{\n\t\tvar list_end:number;\n\t\tvar list_len:number;\n\t\tvar propertyCnt:number = 0;\n\t\tvar props:AWDProperties = new AWDProperties();\n\n\t\tlist_len = this._newBlockBytes.readUnsignedInt();\n\t\tlist_end = this._newBlockBytes.position + list_len;\n\n\t\tif (expected) {\n\n\t\t\twhile (this._newBlockBytes.position < list_end) {\n\t\t\t\tvar len:number;\n\t\t\t\tvar key:number;\n\t\t\t\tvar type:number;\n\n\t\t\t\tkey = this._newBlockBytes.readUnsignedShort();\n\t\t\t\tlen = this._newBlockBytes.readUnsignedInt();\n\n\t\t\t\tif ((this._newBlockBytes.position + len) > list_end) {\n\t\t\t\t\tconsole.log(\"           Error in reading property # \" + propertyCnt + \" = skipped to end of propertie-list\");\n\t\t\t\t\tthis._newBlockBytes.position = list_end;\n\t\t\t\t\treturn props;\n\t\t\t\t}\n\n\t\t\t\tif (expected.hasOwnProperty(key.toString())) {\n\t\t\t\t\ttype = expected[key];\n\t\t\t\t\tprops.set(key, this.parseAttrValue(type, len));\n\t\t\t\t} else {\n\t\t\t\t\tthis._newBlockBytes.position += len;\n\t\t\t\t}\n\n\t\t\t\tpropertyCnt += 1;\n\n\t\t\t}\n\t\t} else {\n\t\t\tthis._newBlockBytes.position = list_end;\n\t\t}\n\n\t\treturn props;\n\n\t}\n\n\tprivate parseAttrValue(type:number, len:number):any\n\t{\n\t\tvar elem_len:number;\n\t\tvar read_func:Function;\n\n\t\tswitch (type) {\n\n\t\t\tcase AWDParser.BOOL:\n\t\t\tcase AWDParser.INT8:\n\t\t\t\telem_len = 1;\n\t\t\t\tread_func = this._newBlockBytes.readByte;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.INT16:\n\t\t\t\telem_len = 2;\n\t\t\t\tread_func = this._newBlockBytes.readShort;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.INT32:\n\t\t\t\telem_len = 4;\n\t\t\t\tread_func = this._newBlockBytes.readInt;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.UINT8:\n\t\t\t\telem_len = 1;\n\t\t\t\tread_func = this._newBlockBytes.readUnsignedByte;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.UINT16:\n\t\t\t\telem_len = 2;\n\t\t\t\tread_func = this._newBlockBytes.readUnsignedShort;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.UINT32:\n\t\t\tcase AWDParser.COLOR:\n\t\t\tcase AWDParser.BADDR:\n\t\t\t\telem_len = 4;\n\t\t\t\tread_func = this._newBlockBytes.readUnsignedInt;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.FLOAT32:\n\t\t\t\telem_len = 4;\n\t\t\t\tread_func = this._newBlockBytes.readFloat;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.FLOAT64:\n\t\t\t\telem_len = 8;\n\t\t\t\tread_func = this._newBlockBytes.readDouble;\n\t\t\t\tbreak;\n\n\t\t\tcase AWDParser.AWDSTRING:\n\t\t\t\treturn this._newBlockBytes.readUTFBytes(len);\n\n\t\t\tcase AWDParser.VECTOR2x1:\n\t\t\tcase AWDParser.VECTOR3x1:\n\t\t\tcase AWDParser.VECTOR4x1:\n\t\t\tcase AWDParser.MTX3x2:\n\t\t\tcase AWDParser.MTX3x3:\n\t\t\tcase AWDParser.MTX4x3:\n\t\t\tcase AWDParser.MTX4x4:\n\t\t\t\telem_len = 8;\n\t\t\t\tread_func = this._newBlockBytes.readDouble;\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\tif (elem_len < len) {\n\t\t\tvar list:Array<any> = [];\n\t\t\tvar num_read:number = 0;\n\t\t\tvar num_elems:number = len/elem_len;\n\n\t\t\twhile (num_read < num_elems) {\n\t\t\t\tlist.push(read_func.apply(this._newBlockBytes)); // list.push(read_func());\n\t\t\t\tnum_read++;\n\t\t\t}\n\n\t\t\treturn list;\n\t\t} else {\n\n\t\t\tvar val:any = read_func.apply(this._newBlockBytes);//read_func();\n\t\t\treturn val;\n\t\t}\n\t}\n\n\tprivate parseHeader():void\n\t{\n\t\tvar flags:number;\n\t\tvar body_len:number;\n\n\t\tthis._byteData.position = 3; // Skip magic string and parse version\n\n\t\tthis._version[0] = this._byteData.readUnsignedByte();\n\t\tthis._version[1] = this._byteData.readUnsignedByte();\n\n\t\tflags = this._byteData.readUnsignedShort(); // Parse bit flags\n\n\t\tthis._streaming = BitFlags.test(flags, BitFlags.FLAG1);\n\n\t\tif ((this._version[0] == 2) && (this._version[1] == 1)) {\n\t\t\tthis._accuracyMatrix = BitFlags.test(flags, BitFlags.FLAG2);\n\t\t\tthis._accuracyGeo = BitFlags.test(flags, BitFlags.FLAG3);\n\t\t\tthis._accuracyProps = BitFlags.test(flags, BitFlags.FLAG4);\n\t\t}\n\n\t\t// if we set _accuracyOnBlocks, the precision-values are read from each block-header.\n\n\t\t// set storagePrecision types\n\t\tthis._geoNrType = AWDParser.FLOAT32;\n\n\t\tif (this._accuracyGeo) {\n\t\t\tthis._geoNrType = AWDParser.FLOAT64;\n\t\t}\n\n\t\tthis._matrixNrType = AWDParser.FLOAT32;\n\n\t\tif (this._accuracyMatrix) {\n\t\t\tthis._matrixNrType = AWDParser.FLOAT64;\n\t\t}\n\n\t\tthis._propsNrType = AWDParser.FLOAT32;\n\n\t\tif (this._accuracyProps) {\n\t\t\tthis._propsNrType = AWDParser.FLOAT64;\n\t\t}\n\n\t\tthis._compression = this._byteData.readUnsignedByte(); // compression\n\n\t\tif (this._debug) {\n\t\t\tconsole.log(\"Import AWDFile of version = \" + this._version[0] + \" - \" + this._version[1]);\n\t\t\tconsole.log(\"Global Settings = Compression = \" + this._compression + \" | Streaming = \" + this._streaming + \" | Matrix-Precision = \" + this._accuracyMatrix + \" | Geometry-Precision = \" + this._accuracyGeo + \" | Properties-Precision = \" + this._accuracyProps);\n\t\t}\n\n\t\t// Check file integrity\n\t\tbody_len = this._byteData.readUnsignedInt();\n\t\tif (!this._streaming && body_len != this._byteData.getBytesAvailable()) {\n\t\t\tthis._pDieWithError('AWD2 body length does not match header integrity field');\n\t\t}\n\n\t}\n\t// Helper - functions\n\tprivate getUVForVertexAnimation(meshID:number /*uint*/):Array<Array<number>>\n\t{\n\t\tif (this._blocks[meshID].data instanceof Mesh)\n\t\tmeshID = this._blocks[meshID].geoID;\n\t\tif (this._blocks[meshID].uvsForVertexAnimation)\n\t\t\treturn this._blocks[meshID].uvsForVertexAnimation;\n\t\tvar geometry:Geometry = (<Geometry> this._blocks[meshID].data);\n\t\tvar geoCnt:number /*int*/ = 0;\n\t\tvar ud:Array<number>;\n\t\tvar uStride:number /*uint*/;\n\t\tvar uOffs:number /*uint*/;\n\t\tvar numPoints:number /*uint*/;\n\t\tvar i:number /*int*/;\n\t\tvar newUvs:Array<number>;\n\t\tvar sub_geom:TriangleSubGeometry;\n\t\tthis._blocks[meshID].uvsForVertexAnimation = new Array<Array<number>>();\n\t\twhile (geoCnt < geometry.subGeometries.length) {\n\t\t\tnewUvs = new Array<number>();\n\t\t\tsub_geom = <TriangleSubGeometry> geometry.subGeometries[geoCnt];\n\t\t\tnumPoints = sub_geom.numVertices;\n\t\t\tud = sub_geom.uvs;\n\t\t\tuStride = sub_geom.getStride(TriangleSubGeometry.UV_DATA);\n\t\t\tuOffs = sub_geom.getOffset(TriangleSubGeometry.UV_DATA);\n\t\t\tfor (i = 0; i < numPoints; i++) {\n\t\t\t\tnewUvs.push(ud[uOffs + i*uStride + 0]);\n\t\t\t\tnewUvs.push(ud[uOffs + i*uStride + 1]);\n\t\t\t}\n\t\t\tthis._blocks[meshID].uvsForVertexAnimation.push(newUvs);\n\t\t\tgeoCnt++;\n\t\t}\n\t\treturn this._blocks[meshID].uvsForVertexAnimation;\n\t}\n\t\n\tprivate parseVarStr():string\n\t{\n\n\t\tvar len:number = this._newBlockBytes.readUnsignedShort();\n\t\treturn this._newBlockBytes.readUTFBytes(len);\n\t}\n\n\tprivate getAssetByID(assetID:number, assetTypesToGet:Array<string>, extraTypeInfo:string = \"SingleTexture\"):Array<any>\n\t{\n\t\tvar returnArray:Array<any> = new Array<any>();\n\t\tvar typeCnt:number = 0;\n\t\tif (assetID > 0) {\n\t\t\tif (this._blocks[assetID]) {\n\t\t\t\tif (this._blocks[assetID].data) {\n\t\t\t\t\twhile (typeCnt < assetTypesToGet.length) {\n\n\t\t\t\t\t\tvar iasset:IAsset = <IAsset> this._blocks[assetID].data;\n\n\t\t\t\t\t\tif (iasset.assetType == assetTypesToGet[typeCnt]) {\n\t\t\t\t\t\t\t//if the right assetType was found\n\t\t\t\t\t\t\tif ((assetTypesToGet[typeCnt] == AssetType.TEXTURE) && (extraTypeInfo == \"CubeTexture\")) {\n\t\t\t\t\t\t\t\tif (this._blocks[assetID].data instanceof ImageCubeTexture) {\n\t\t\t\t\t\t\t\t\treturnArray.push(true);\n\t\t\t\t\t\t\t\t\treturnArray.push(this._blocks[assetID].data);\n\t\t\t\t\t\t\t\t\treturn returnArray;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif ((assetTypesToGet[typeCnt] == AssetType.TEXTURE) && (extraTypeInfo == \"SingleTexture\")) {\n\t\t\t\t\t\t\t\tif (this._blocks[assetID].data instanceof ImageTexture) {\n\t\t\t\t\t\t\t\t\treturnArray.push(true);\n\t\t\t\t\t\t\t\t\treturnArray.push(this._blocks[assetID].data);\n\t\t\t\t\t\t\t\t\treturn returnArray;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\treturnArray.push(true);\n\t\t\t\t\t\t\t\treturnArray.push(this._blocks[assetID].data);\n\t\t\t\t\t\t\t\treturn returnArray;\n\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\t//if ((assetTypesToGet[typeCnt] == AssetType.GEOMETRY) && (IAsset(_blocks[assetID].data).assetType == AssetType.MESH)) {\n\t\t\t\t\t\tif ((assetTypesToGet[typeCnt] == AssetType.GEOMETRY) && (iasset.assetType == AssetType.MESH)) {\n\n\t\t\t\t\t\t\tvar mesh:Mesh = <Mesh> this._blocks[assetID].data\n\n\t\t\t\t\t\t\treturnArray.push(true);\n\t\t\t\t\t\t\treturnArray.push(mesh.geometry);\n\t\t\t\t\t\t\treturn returnArray;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\ttypeCnt++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t// if the has not returned anything yet, the asset is not found, or the found asset is not the right type.\n\t\treturnArray.push(false);\n\t\treturnArray.push(this.getDefaultAsset(assetTypesToGet[0], extraTypeInfo));\n\t\treturn returnArray;\n\t}\n\n\tprivate getDefaultAsset(assetType:string, extraTypeInfo:string):IAsset\n\t{\n\t\tswitch (true) {\n\t\t\tcase (assetType == AssetType.TEXTURE):\n\t\t\t\tif (extraTypeInfo == \"CubeTexture\")\n\t\t\t\t\treturn this.getDefaultCubeTexture();\n\t\t\t\tif (extraTypeInfo == \"SingleTexture\")\n\t\t\t\t\treturn this.getDefaultTexture();\n\t\t\t\tbreak;\n\t\t\tcase (assetType == AssetType.MATERIAL):\n\t\t\t\treturn this.getDefaultMaterial()\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tprivate getDefaultMaterial():IAsset\n\t{\n\t\tif (!this._defaultBitmapMaterial)\n\t\t\tthis._defaultBitmapMaterial = <TriangleMethodMaterial> DefaultMaterialManager.getDefaultMaterial();\n\n\t\treturn  <IAsset>  this._defaultBitmapMaterial;\n\t}\n\n\tprivate getDefaultTexture():IAsset\n\t{\n\t\tif (!this._defaultTexture)\n\t\t\tthis._defaultTexture = DefaultMaterialManager.getDefaultTexture();\n\n\t\treturn <IAsset> this._defaultTexture;\n\n\t}\n\n\tprivate getDefaultCubeTexture():IAsset\n\t{\n\t\tif (!this._defaultCubeTexture) {\n\t\t\tvar defaultBitmap:BitmapData = DefaultMaterialManager.createCheckeredBitmapData();\n\n\t\t\tthis._defaultCubeTexture = new BitmapCubeTexture(defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap);\n\t\t\tthis._defaultCubeTexture.name = \"defaultCubeTexture\";\n\t\t}\n\n\t\treturn <IAsset> this._defaultCubeTexture;\n\t}\n\n\tprivate readNumber(precision:boolean = false):number\n\t{\n\t\tif (precision)\n\t\t\treturn this._newBlockBytes.readDouble();\n\t\treturn this._newBlockBytes.readFloat();\n\n\t}\n\n\tprivate parseMatrix3D():Matrix3D\n\t{\n\t\treturn new Matrix3D(this.parseMatrix43RawData());\n\t}\n\n\tprivate parseMatrix32RawData():Array<number>\n\t{\n\t\tvar i:number;\n\t\tvar mtx_raw:Array<number> = new Array<number>(6);\n\t\tfor (i = 0; i < 6; i++) {\n\t\t\tmtx_raw[i] = this._newBlockBytes.readFloat();\n\t\t}\n\n\t\treturn mtx_raw;\n\t}\n\n\tprivate parseMatrix43RawData():Array<number>\n\t{\n\t\tvar mtx_raw:Array<number> = new Array<number>(16);\n\n\t\tmtx_raw[0] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[1] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[2] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[3] = 0.0;\n\t\tmtx_raw[4] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[5] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[6] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[7] = 0.0;\n\t\tmtx_raw[8] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[9] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[10] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[11] = 0.0;\n\t\tmtx_raw[12] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[13] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[14] = this.readNumber(this._accuracyMatrix);\n\t\tmtx_raw[15] = 1.0;\n\n\t\t//TODO: fix max exporter to remove NaN values in joint 0 inverse bind pose\n\n\t\tif (isNaN(mtx_raw[0])) {\n\t\t\tmtx_raw[0] = 1;\n\t\t\tmtx_raw[1] = 0;\n\t\t\tmtx_raw[2] = 0;\n\t\t\tmtx_raw[4] = 0;\n\t\t\tmtx_raw[5] = 1;\n\t\t\tmtx_raw[6] = 0;\n\t\t\tmtx_raw[8] = 0;\n\t\t\tmtx_raw[9] = 0;\n\t\t\tmtx_raw[10] = 1;\n\t\t\tmtx_raw[12] = 0;\n\t\t\tmtx_raw[13] = 0;\n\t\t\tmtx_raw[14] = 0;\n\n\t\t}\n\n\t\treturn mtx_raw;\n\t}\n\n}\n\nexport = AWDParser;"]} \ No newline at end of file diff --git a/lib/parsers/AWDParser.ts b/lib/parsers/AWDParser.ts new file mode 100644 index 000000000..4fe68a457 --- /dev/null +++ b/lib/parsers/AWDParser.ts @@ -0,0 +1,2820 @@ +import DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +import BitmapData = require("awayjs-core/lib/core/base/BitmapData"); +import BlendMode = require("awayjs-core/lib/core/base/BlendMode"); +import DisplayObject = require("awayjs-core/lib/core/base/DisplayObject"); +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import LightBase = require("awayjs-core/lib/core/base/LightBase"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import ColorTransform = require("awayjs-core/lib/core/geom/ColorTransform"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +import URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +import AssetType = require("awayjs-core/lib/core/library/AssetType"); +import IAsset = require("awayjs-core/lib/core/library/IAsset"); +import DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +import PointLight = require("awayjs-core/lib/entities/PointLight"); +import Camera = require("awayjs-core/lib/entities/Camera"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import Skybox = require("awayjs-core/lib/entities/Skybox"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); +import LightPickerBase = require("awayjs-core/lib/materials/lightpickers/LightPickerBase"); +import StaticLightPicker = require("awayjs-core/lib/materials/lightpickers/StaticLightPicker"); +import CubeMapShadowMapper = require("awayjs-core/lib/materials/shadowmappers/CubeMapShadowMapper"); +import DirectionalShadowMapper = require("awayjs-core/lib/materials/shadowmappers/DirectionalShadowMapper"); +import ShadowMapperBase = require("awayjs-core/lib/materials/shadowmappers/ShadowMapperBase"); +import PrefabBase = require("awayjs-core/lib/prefabs/PrefabBase"); +import PrimitiveCapsulePrefab = require("awayjs-core/lib/prefabs/PrimitiveCapsulePrefab"); +import PrimitiveConePrefab = require("awayjs-core/lib/prefabs/PrimitiveConePrefab"); +import PrimitiveCubePrefab = require("awayjs-core/lib/prefabs/PrimitiveCubePrefab"); +import PrimitiveCylinderPrefab = require("awayjs-core/lib/prefabs/PrimitiveCylinderPrefab"); +import PrimitivePlanePrefab = require("awayjs-core/lib/prefabs/PrimitivePlanePrefab"); +import PrimitiveSpherePrefab = require("awayjs-core/lib/prefabs/PrimitiveSpherePrefab"); +import PrimitiveTorusPrefab = require("awayjs-core/lib/prefabs/PrimitiveTorusPrefab"); +import ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +import ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +import ResourceDependency = require("awayjs-core/lib/parsers/ResourceDependency"); +import ProjectionBase = require("awayjs-core/lib/projections/ProjectionBase"); +import PerspectiveProjection = require("awayjs-core/lib/projections/PerspectiveProjection"); +import OrthographicProjection = require("awayjs-core/lib/projections/OrthographicProjection"); +import OrthographicOffCenterProjection = require("awayjs-core/lib/projections/OrthographicOffCenterProjection"); +import BitmapCubeTexture = require("awayjs-core/lib/textures/BitmapCubeTexture"); +import BitmapTexture = require("awayjs-core/lib/textures/BitmapTexture"); +import CubeTextureBase = require("awayjs-core/lib/textures/CubeTextureBase"); +import ImageCubeTexture = require("awayjs-core/lib/textures/ImageCubeTexture"); +import ImageTexture = require("awayjs-core/lib/textures/ImageTexture"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); +import TextureProxyBase = require("awayjs-core/lib/textures/TextureProxyBase"); +import ByteArray = require("awayjs-core/lib/utils/ByteArray"); + +import AnimationSetBase = require("awayjs-stagegl/lib/animators/AnimationSetBase"); +import AnimatorBase = require("awayjs-stagegl/lib/animators/AnimatorBase"); +import SkyboxMaterial = require("awayjs-stagegl/lib/materials/SkyboxMaterial"); +import TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); +import TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +import DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); + +import VertexAnimationSet = require("awayjs-renderergl/lib/animators/VertexAnimationSet"); +import VertexAnimator = require("awayjs-renderergl/lib/animators/VertexAnimator"); +import SkeletonAnimationSet = require("awayjs-renderergl/lib/animators/SkeletonAnimationSet"); +import SkeletonAnimator = require("awayjs-renderergl/lib/animators/SkeletonAnimator"); +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import SkeletonJoint = require("awayjs-renderergl/lib/animators/data/SkeletonJoint"); +import SkeletonClipNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonClipNode"); +import VertexClipNode = require("awayjs-renderergl/lib/animators/nodes/VertexClipNode"); +import AmbientEnvMapMethod = require("awayjs-renderergl/lib/materials/methods/AmbientEnvMapMethod"); +import DiffuseDepthMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseDepthMethod"); +import DiffuseCelMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseCelMethod"); +import DiffuseGradientMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseGradientMethod"); +import DiffuseLightMapMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseLightMapMethod"); +import DiffuseWrapMethod = require("awayjs-renderergl/lib/materials/methods/DiffuseWrapMethod"); +import EffectAlphaMaskMethod = require("awayjs-renderergl/lib/materials/methods/EffectAlphaMaskMethod"); +import EffectColorMatrixMethod = require("awayjs-renderergl/lib/materials/methods/EffectColorMatrixMethod"); +import EffectColorTransformMethod = require("awayjs-stagegl/lib/materials/methods/EffectColorTransformMethod"); +import EffectEnvMapMethod = require("awayjs-renderergl/lib/materials/methods/EffectEnvMapMethod"); +import EffectFogMethod = require("awayjs-renderergl/lib/materials/methods/EffectFogMethod"); +import EffectFresnelEnvMapMethod = require("awayjs-renderergl/lib/materials/methods/EffectFresnelEnvMapMethod"); +import EffectLightMapMethod = require("awayjs-renderergl/lib/materials/methods/EffectLightMapMethod"); +import EffectMethodBase = require("awayjs-stagegl/lib/materials/methods/EffectMethodBase"); +import EffectRimLightMethod = require("awayjs-renderergl/lib/materials/methods/EffectRimLightMethod"); +import NormalSimpleWaterMethod = require("awayjs-renderergl/lib/materials/methods/NormalSimpleWaterMethod"); +import ShadowDitheredMethod = require("awayjs-renderergl/lib/materials/methods/ShadowDitheredMethod"); +import ShadowFilteredMethod = require("awayjs-renderergl/lib/materials/methods/ShadowFilteredMethod"); +import ShadowMethodBase = require("awayjs-stagegl/lib/materials/methods/ShadowMethodBase"); +import SpecularFresnelMethod = require("awayjs-renderergl/lib/materials/methods/SpecularFresnelMethod"); +import ShadowHardMethod = require("awayjs-stagegl/lib/materials/methods/ShadowHardMethod"); +import SpecularAnisotropicMethod = require("awayjs-renderergl/lib/materials/methods/SpecularAnisotropicMethod"); +import SpecularCelMethod = require("awayjs-renderergl/lib/materials/methods/SpecularCelMethod"); +import SpecularPhongMethod = require("awayjs-renderergl/lib/materials/methods/SpecularPhongMethod"); +import ShadowNearMethod = require("awayjs-renderergl/lib/materials/methods/ShadowNearMethod"); +import ShadowSoftMethod = require("awayjs-renderergl/lib/materials/methods/ShadowSoftMethod"); + +import AWDBlock = require("awayjs-renderergl/lib/parsers/data/AWDBlock"); +import AWDProperties = require("awayjs-renderergl/lib/parsers/data/AWDProperties"); +import BitFlags = require("awayjs-renderergl/lib/parsers/data/BitFlags"); + +/** + * AWDParser provides a parser for the AWD data type. + */ +class AWDParser extends ParserBase +{ + //set to "true" to have some console.logs in the Console + private _debug:boolean = false; + private _byteData:ByteArray; + private _startedParsing:boolean = false; + private _cur_block_id:number; + private _blocks:Array; + private _newBlockBytes:ByteArray; + private _version:Array; + private _compression:number; + private _accuracyOnBlocks:boolean; + private _accuracyMatrix:boolean; + private _accuracyGeo:boolean; + private _accuracyProps:boolean; + private _matrixNrType:number; + private _geoNrType:number; + private _propsNrType:number; + private _streaming:boolean; + private _texture_users:Object = {}; + private _parsed_header:boolean = false; + private _body:ByteArray; + private _defaultTexture:BitmapTexture; // HTML IMAGE TEXTURE >? ! + private _cubeTextures:Array; + private _defaultBitmapMaterial:TriangleMethodMaterial; + private _defaultCubeTexture:BitmapCubeTexture; + + public static COMPRESSIONMODE_LZMA:string = "lzma"; + public static UNCOMPRESSED:number = 0; + public static DEFLATE:number = 1; + public static LZMA:number = 2; + public static INT8:number = 1; + public static INT16:number = 2; + public static INT32:number = 3; + public static UINT8:number = 4; + public static UINT16:number = 5; + public static UINT32:number = 6; + public static FLOAT32:number = 7; + public static FLOAT64:number = 8; + public static BOOL:number = 21; + public static COLOR:number = 22; + public static BADDR:number = 23; + public static AWDSTRING:number = 31; + public static AWDBYTEARRAY:number = 32; + public static VECTOR2x1:number = 41; + public static VECTOR3x1:number = 42; + public static VECTOR4x1:number = 43; + public static MTX3x2:number = 44; + public static MTX3x3:number = 45; + public static MTX4x3:number = 46; + public static MTX4x4:number = 47; + + private blendModeDic:Array; + private _depthSizeDic:Array; + + /** + * Creates a new AWDParser object. + * @param uri The url or id of the data or file to be parsed. + * @param extra The holder for extra contextual data that the parser might need. + */ + constructor() + { + super(URLLoaderDataFormat.ARRAY_BUFFER); + + this._blocks = new Array(); + this._blocks[0] = new AWDBlock(); + this._blocks[0].data = null; // Zero address means null in AWD + + this.blendModeDic = new Array(); // used to translate ints to blendMode-strings + this.blendModeDic.push(BlendMode.NORMAL); + this.blendModeDic.push(BlendMode.ADD); + this.blendModeDic.push(BlendMode.ALPHA); + this.blendModeDic.push(BlendMode.DARKEN); + this.blendModeDic.push(BlendMode.DIFFERENCE); + this.blendModeDic.push(BlendMode.ERASE); + this.blendModeDic.push(BlendMode.HARDLIGHT); + this.blendModeDic.push(BlendMode.INVERT); + this.blendModeDic.push(BlendMode.LAYER); + this.blendModeDic.push(BlendMode.LIGHTEN); + this.blendModeDic.push(BlendMode.MULTIPLY); + this.blendModeDic.push(BlendMode.NORMAL); + this.blendModeDic.push(BlendMode.OVERLAY); + this.blendModeDic.push(BlendMode.SCREEN); + this.blendModeDic.push(BlendMode.SHADER); + this.blendModeDic.push(BlendMode.OVERLAY); + + this._depthSizeDic = new Array(); // used to translate ints to depthSize-values + this._depthSizeDic.push(256); + this._depthSizeDic.push(512); + this._depthSizeDic.push(2048); + this._depthSizeDic.push(1024); + this._version = Array(); // will contain 2 int (major-version, minor-version) for awd-version-check + } + + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + public static supportsType(extension:string):boolean + { + extension = extension.toLowerCase(); + return extension == "awd"; + } + + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + public static supportsData(data:any):boolean + { + return (ParserUtils.toString(data, 3) == 'AWD'); + } + + /** + * @inheritDoc + */ + public _iResolveDependency(resourceDependency:ResourceDependency):void + { + // this will be called when Dependency has finished loading. + // the Assets waiting for this Bitmap, can be Texture or CubeTexture. + // if the Bitmap is awaited by a CubeTexture, we need to check if its the last Bitmap of the CubeTexture, + // so we know if we have to finalize the Asset (CubeTexture) or not. + if (resourceDependency.assets.length == 1) { + var isCubeTextureArray:Array = resourceDependency.id.split("#"); + var ressourceID:string = isCubeTextureArray[0]; + var asset:TextureProxyBase; + var thisBitmapTexture:Texture2DBase; + var block:AWDBlock; + + if (isCubeTextureArray.length == 1) // Not a cube texture + { + asset = resourceDependency.assets[0]; + if (asset) { + var mat:TriangleMethodMaterial; + var users:Array; + + block = this._blocks[ resourceDependency.id ]; + block.data = asset; // Store finished asset + + // Reset name of texture to the one defined in the AWD file, + // as opposed to whatever the image parser came up with. + asset.resetAssetPath(block.name, null, true); + block.name = asset.name; + // Finalize texture asset to dispatch texture event, which was + // previously suppressed while the dependency was loaded. + this._pFinalizeAsset( asset); + + if (this._debug) { + console.log("Successfully loaded Bitmap for texture"); + console.log("Parsed texture: Name = " + block.name); + } + } + } + + if (isCubeTextureArray.length > 1) // Cube Texture + { + thisBitmapTexture = resourceDependency.assets[0]; + + var tx:ImageTexture = thisBitmapTexture; + + this._cubeTextures[ isCubeTextureArray[1] ] = tx.htmlImageElement; // ? + this._texture_users[ressourceID].push(1); + + if (this._debug) { + console.log("Successfully loaded Bitmap " + this._texture_users[ressourceID].length + " / 6 for Cubetexture"); + } + if (this._texture_users[ressourceID].length == this._cubeTextures.length) { + + var posX:any = this._cubeTextures[0]; + var negX:any = this._cubeTextures[1]; + var posY:any = this._cubeTextures[2]; + var negY:any = this._cubeTextures[3]; + var posZ:any = this._cubeTextures[4]; + var negZ:any = this._cubeTextures[5]; + + asset = new ImageCubeTexture(posX, negX, posY, negY, posZ, negZ); + block = this._blocks[ressourceID]; + block.data = asset; // Store finished asset + + // Reset name of texture to the one defined in the AWD file, + // as opposed to whatever the image parser came up with. + asset.resetAssetPath(block.name, null, true); + block.name = asset.name; + // Finalize texture asset to dispatch texture event, which was + // previously suppressed while the dependency was loaded. + this._pFinalizeAsset( asset); + if (this._debug) { + console.log("Parsed CubeTexture: Name = " + block.name); + } + } + } + + } + } + + /** + * @inheritDoc + */ + public _iResolveDependencyFailure(resourceDependency:ResourceDependency):void + { + //not used - if a dependcy fails, the awaiting Texture or CubeTexture will never be finalized, and the default-bitmaps will be used. + // this means, that if one Bitmap of a CubeTexture fails, the CubeTexture will have the DefaultTexture applied for all six Bitmaps. + } + + /** + * Resolve a dependency name + * + * @param resourceDependency The dependency to be resolved. + */ + public _iResolveDependencyName(resourceDependency:ResourceDependency, asset:IAsset):string + { + var oldName:string = asset.name; + + if (asset) { + var block:AWDBlock = this._blocks[parseInt(resourceDependency.id)]; + // Reset name of texture to the one defined in the AWD file, + // as opposed to whatever the image parser came up with. + asset.resetAssetPath(block.name, null, true); + } + + var newName:string = asset.name; + + asset.name = oldName; + + return newName; + + } + + /** + * @inheritDoc + */ + public _pProceedParsing():boolean + { + + if (!this._startedParsing) { + this._byteData = this._pGetByteData();//getByteData(); + this._startedParsing = true; + } + + if (!this._parsed_header) { + + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._byteData.endian = Endian.LITTLE_ENDIAN; + //---------------------------------------------------------------------------- + + //---------------------------------------------------------------------------- + // Parse header and decompress body if needed + this.parseHeader(); + + switch (this._compression) { + + case AWDParser.DEFLATE: + case AWDParser.LZMA: + this._pDieWithError('Compressed AWD formats not yet supported'); + break; + + case AWDParser.UNCOMPRESSED: + this._body = this._byteData; + break; + + //---------------------------------------------------------------------------- + // Compressed AWD Formats not yet supported + //---------------------------------------------------------------------------- + + /* + case AWDParser.DEFLATE: + + this._body = new ByteArray(); + this._byteData.readBytes(this._body, 0, this._byteData.getBytesAvailable()); + this._body.uncompress(); + + break; + case AWDParser.LZMA: + + this._body = new ByteArray(); + this._byteData.readBytes(this._body, 0, this._byteData.getBytesAvailable()); + this._body.uncompress(COMPRESSIONMODE_LZMA); + + break; + //*/ + + } + + this._parsed_header = true; + + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._body.endian = Endian.LITTLE_ENDIAN;// Should be default + //---------------------------------------------------------------------------- + + } + + if (this._body) { + + while (this._body.getBytesAvailable() > 0 && !this.parsingPaused) //&& this._pHasTime() ) + { + this.parseNextBlock(); + + } + + //---------------------------------------------------------------------------- + // Return complete status + if (this._body.getBytesAvailable() == 0) { + this.dispose(); + return ParserBase.PARSING_DONE; + } else { + return ParserBase.MORE_TO_PARSE; + } + } else { + + switch (this._compression) { + + case AWDParser.DEFLATE: + case AWDParser.LZMA: + + if (this._debug) { + console.log("(!) AWDParser Error: Compressed AWD formats not yet supported (!)"); + } + + break; + + } + // Error - most likely _body not set because we do not support compression. + return ParserBase.PARSING_DONE; + + } + + } + + public _pStartParsing(frameLimit:number) + { + super._pStartParsing(frameLimit); + + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + } + + private dispose():void + { + + for (var c in this._blocks) { + + var b:AWDBlock = this._blocks[ c ]; + b.dispose(); + + } + + } + + private parseNextBlock():void + { + var block:AWDBlock; + var assetData:IAsset; + var isParsed:boolean = false; + var ns:number; + var type:number; + var flags:number; + var len:number; + + this._cur_block_id = this._body.readUnsignedInt(); + + ns = this._body.readUnsignedByte(); + type = this._body.readUnsignedByte(); + flags = this._body.readUnsignedByte(); + len = this._body.readUnsignedInt(); + + var blockCompression:boolean = BitFlags.test(flags, BitFlags.FLAG4); + var blockCompressionLZMA:boolean = BitFlags.test(flags, BitFlags.FLAG5); + + if (this._accuracyOnBlocks) { + this._accuracyMatrix = BitFlags.test(flags, BitFlags.FLAG1); + this._accuracyGeo = BitFlags.test(flags, BitFlags.FLAG2); + this._accuracyProps = BitFlags.test(flags, BitFlags.FLAG3); + this._geoNrType = AWDParser.FLOAT32; + + if (this._accuracyGeo) { + this._geoNrType = AWDParser.FLOAT64; + } + + this._matrixNrType = AWDParser.FLOAT32; + + if (this._accuracyMatrix) { + this._matrixNrType = AWDParser.FLOAT64; + } + + this._propsNrType = AWDParser.FLOAT32; + + if (this._accuracyProps) { + this._propsNrType = AWDParser.FLOAT64; + } + } + + var blockEndAll:number = this._body.position + len; + + if (len > this._body.getBytesAvailable()) { + this._pDieWithError('AWD2 block length is bigger than the bytes that are available!'); + this._body.position += this._body.getBytesAvailable(); + return; + } + this._newBlockBytes = new ByteArray(); + + + this._body.readBytes(this._newBlockBytes, 0, len); + + //---------------------------------------------------------------------------- + // Compressed AWD Formats not yet supported + + if (blockCompression) { + this._pDieWithError('Compressed AWD formats not yet supported'); + + /* + if (blockCompressionLZMA) + { + this._newBlockBytes.uncompress(AWDParser.COMPRESSIONMODE_LZMA); + } + else + { + this._newBlockBytes.uncompress(); + } + */ + + } + + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._newBlockBytes.endian = Endian.LITTLE_ENDIAN; + //---------------------------------------------------------------------------- + + this._newBlockBytes.position = 0; + block = new AWDBlock(); + block.len = this._newBlockBytes.position + len; + block.id = this._cur_block_id; + + var blockEndBlock:number = this._newBlockBytes.position + len; + + if (blockCompression) { + this._pDieWithError('Compressed AWD formats not yet supported'); + //blockEndBlock = this._newBlockBytes.position + this._newBlockBytes.length; + //block.len = blockEndBlock; + } + + if (this._debug) { + console.log("AWDBlock: ID = " + this._cur_block_id + " | TypeID = " + type + " | Compression = " + blockCompression + " | Matrix-Precision = " + this._accuracyMatrix + " | Geometry-Precision = " + this._accuracyGeo + " | Properties-Precision = " + this._accuracyProps); + } + + this._blocks[this._cur_block_id] = block; + + if ((this._version[0] == 2) && (this._version[1] == 1)) { + + switch (type) { + case 11: + this.parsePrimitves(this._cur_block_id); + isParsed = true; + break; + case 31: + this.parseSkyboxInstance(this._cur_block_id); + isParsed = true; + break; + case 41: + this.parseLight(this._cur_block_id); + isParsed = true; + break; + case 42: + this.parseCamera(this._cur_block_id); + isParsed = true; + break; + + // case 43: + // parseTextureProjector(_cur_block_id); + // isParsed = true; + // break; + + case 51: + this.parseLightPicker(this._cur_block_id); + isParsed = true; + break; + case 81: + this.parseMaterial_v1(this._cur_block_id); + isParsed = true; + break; + case 83: + this.parseCubeTexture(this._cur_block_id); + isParsed = true; + break; + case 91: + this.parseSharedMethodBlock(this._cur_block_id); + isParsed = true; + break; + case 92: + this.parseShadowMethodBlock(this._cur_block_id); + isParsed = true; + break; + case 111: + this.parseMeshPoseAnimation(this._cur_block_id, true); + isParsed = true; + break; + case 112: + this.parseMeshPoseAnimation(this._cur_block_id); + isParsed = true; + break; + case 113: + this.parseVertexAnimationSet(this._cur_block_id); + isParsed = true; + break; + case 122: + this.parseAnimatorSet(this._cur_block_id); + isParsed = true; + break; + case 253: + this.parseCommand(this._cur_block_id); + isParsed = true; + break; + } + //*/ + } + //* + if (isParsed == false) { + switch (type) { + + case 1: + this.parseTriangleGeometrieBlock(this._cur_block_id); + break; + case 22: + this.parseContainer(this._cur_block_id); + break; + case 23: + this.parseMeshInstance(this._cur_block_id); + break; + case 81: + this.parseMaterial(this._cur_block_id); + break; + case 82: + this.parseTexture(this._cur_block_id); + break; + case 101: + this.parseSkeleton(this._cur_block_id); + break; + case 102: + this.parseSkeletonPose(this._cur_block_id); + break; + case 103: + this.parseSkeletonAnimation(this._cur_block_id); + break; + case 121: + //this.parseUVAnimation(this._cur_block_id); + //break; + case 254: + this.parseNameSpace(this._cur_block_id); + break; + case 255: + this.parseMetaData(this._cur_block_id); + break; + default: + if (this._debug) { + console.log("AWDBlock: Unknown BlockType (BlockID = " + this._cur_block_id + ") - Skip " + len + " bytes"); + } + this._newBlockBytes.position += len; + break; + } + } + //*/ + + var msgCnt:number = 0; + if (this._newBlockBytes.position == blockEndBlock) { + if (this._debug) { + if (block.errorMessages) { + while (msgCnt < block.errorMessages.length) { + console.log(" (!) Error: " + block.errorMessages[msgCnt] + " (!)"); + msgCnt++; + } + } + } + if (this._debug) { + console.log("\n"); + } + } else { + if (this._debug) { + + console.log(" (!)(!)(!) Error while reading AWDBlock ID " + this._cur_block_id + " = skip to next block"); + + if (block.errorMessages) { + while (msgCnt < block.errorMessages.length) { + console.log(" (!) Error: " + block.errorMessages[msgCnt] + " (!)"); + msgCnt++; + } + } + } + } + + this._body.position = blockEndAll; + this._newBlockBytes = null; + + } + + + //--Parser Blocks--------------------------------------------------------------------------- + + //Block ID = 1 + private parseTriangleGeometrieBlock(blockID:number):void + { + + var geom:Geometry = new Geometry(); + + // Read name and sub count + var name:string = this.parseVarStr(); + var num_subs:number = this._newBlockBytes.readUnsignedShort(); + + // Read optional properties + var props:AWDProperties = this.parseProperties({1:this._geoNrType, 2:this._geoNrType}); + var geoScaleU:number = props.get(1, 1); + var geoScaleV:number = props.get(2, 1); + + // Loop through sub meshes + var subs_parsed:number = 0; + while (subs_parsed < num_subs) { + var i:number; + var sm_len:number, sm_end:number; + var sub_geom:TriangleSubGeometry; + var w_indices:Array; + var weights:Array; + + sm_len = this._newBlockBytes.readUnsignedInt(); + sm_end = this._newBlockBytes.position + sm_len; + + // Ignore for now + var subProps:AWDProperties = this.parseProperties({1:this._geoNrType, 2:this._geoNrType}); + // Loop through data streams + while (this._newBlockBytes.position < sm_end) { + var idx:number = 0; + var str_ftype:number, str_type:number, str_len:number, str_end:number; + + // Type, field type, length + str_type = this._newBlockBytes.readUnsignedByte(); + str_ftype = this._newBlockBytes.readUnsignedByte(); + str_len = this._newBlockBytes.readUnsignedInt(); + str_end = this._newBlockBytes.position + str_len; + + var x:number, y:number, z:number; + + if (str_type == 1) { + var verts:Array = new Array(); + + while (this._newBlockBytes.position < str_end) { + // TODO: Respect stream field type + x = this.readNumber(this._accuracyGeo); + y = this.readNumber(this._accuracyGeo); + z = this.readNumber(this._accuracyGeo); + + verts[idx++] = x; + verts[idx++] = y; + verts[idx++] = z; + } + } else if (str_type == 2) { + var indices:Array = new Array(); + + while (this._newBlockBytes.position < str_end) { + // TODO: Respect stream field type + indices[idx++] = this._newBlockBytes.readUnsignedShort(); + } + + } else if (str_type == 3) { + var uvs:Array = new Array(); + while (this._newBlockBytes.position < str_end) { + uvs[idx++] = this.readNumber(this._accuracyGeo); + + } + } else if (str_type == 4) { + + var normals:Array = new Array(); + + while (this._newBlockBytes.position < str_end) { + normals[idx++] = this.readNumber(this._accuracyGeo); + } + + } else if (str_type == 6) { + w_indices = Array(); + + while (this._newBlockBytes.position < str_end) { + w_indices[idx++] = this._newBlockBytes.readUnsignedShort()*3; // TODO: Respect stream field type + } + + } else if (str_type == 7) { + + weights = new Array(); + + while (this._newBlockBytes.position < str_end) { + weights[idx++] = this.readNumber(this._accuracyGeo); + } + } else { + this._newBlockBytes.position = str_end; + } + + } + + this.parseUserAttributes(); // Ignore sub-mesh attributes for now + + sub_geom = new TriangleSubGeometry(true); + if (weights) + sub_geom.jointsPerVertex = weights.length/(verts.length/3); + if (normals) + sub_geom.autoDeriveNormals = false; + if (uvs) + sub_geom.autoDeriveUVs = false; + sub_geom.updateIndices(indices); + sub_geom.updatePositions(verts); + sub_geom.updateVertexNormals(normals); + sub_geom.updateUVs(uvs); + sub_geom.updateVertexTangents(null); + sub_geom.updateJointWeights(weights); + sub_geom.updateJointIndices(w_indices); + + var scaleU:number = subProps.get(1, 1); + var scaleV:number = subProps.get(2, 1); + var setSubUVs:boolean = false; //this should remain false atm, because in AwayBuilder the uv is only scaled by the geometry + + if ((geoScaleU != scaleU) || (geoScaleV != scaleV)) { + setSubUVs = true; + scaleU = geoScaleU/scaleU; + scaleV = geoScaleV/scaleV; + } + + if (setSubUVs) + sub_geom.scaleUV(scaleU, scaleV); + + geom.addSubGeometry(sub_geom); + + // TODO: Somehow map in-sub to out-sub indices to enable look-up + // when creating meshes (and their material assignments.) + + subs_parsed++; + } + if ((geoScaleU != 1) || (geoScaleV != 1)) + geom.scaleUV(geoScaleU, geoScaleV); + this.parseUserAttributes(); + this._pFinalizeAsset( geom, name); + this._blocks[blockID].data = geom; + + if (this._debug) { + console.log("Parsed a TriangleGeometry: Name = " + name + "| Id = " + sub_geom.id); + } + + } + + //Block ID = 11 + private parsePrimitves(blockID:number):void + { + var name:string; + var prefab:PrefabBase; + var primType:number; + var subs_parsed:number; + var props:AWDProperties; + var bsm:Matrix3D; + + // Read name and sub count + name = this.parseVarStr(); + primType = this._newBlockBytes.readUnsignedByte(); + props = this.parseProperties({101:this._geoNrType, 102:this._geoNrType, 103:this._geoNrType, 110:this._geoNrType, 111:this._geoNrType, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 303:AWDParser.UINT16, 701:AWDParser.BOOL, 702:AWDParser.BOOL, 703:AWDParser.BOOL, 704:AWDParser.BOOL}); + + var primitiveTypes:Array = ["Unsupported Type-ID", "PrimitivePlanePrefab", "PrimitiveCubePrefab", "PrimitiveSpherePrefab", "PrimitiveCylinderPrefab", "PrimitivesConePrefab", "PrimitivesCapsulePrefab", "PrimitivesTorusPrefab"] + + switch (primType) { + // to do, not all properties are set on all primitives + + case 1: + prefab = new PrimitivePlanePrefab(props.get(101, 100), props.get(102, 100), props.get(301, 1), props.get(302, 1), props.get(701, true), props.get(702, false)); + break; + + case 2: + prefab = new PrimitiveCubePrefab(props.get(101, 100), props.get(102, 100), props.get(103, 100), props.get(301, 1), props.get(302, 1), props.get(303, 1), props.get(701, true)); + break; + + case 3: + prefab = new PrimitiveSpherePrefab(props.get(101, 50), props.get(301, 16), props.get(302, 12), props.get(701, true)); + break; + + case 4: + prefab = new PrimitiveCylinderPrefab(props.get(101, 50), props.get(102, 50), props.get(103, 100), props.get(301, 16), props.get(302, 1), true, true, true); // bool701, bool702, bool703, bool704); + if (!props.get(701, true)) + (prefab).topClosed = false; + if (!props.get(702, true)) + (prefab).bottomClosed = false; + if (!props.get(703, true)) + (prefab).yUp = false; + + break; + + case 5: + prefab = new PrimitiveConePrefab(props.get(101, 50), props.get(102, 100), props.get(301, 16), props.get(302, 1), props.get(701, true), props.get(702, true)); + break; + + case 6: + prefab = new PrimitiveCapsulePrefab(props.get(101, 50), props.get(102, 100), props.get(301, 16), props.get(302, 15), props.get(701, true)); + break; + + case 7: + prefab = new PrimitiveTorusPrefab(props.get(101, 50), props.get(102, 50), props.get(301, 16), props.get(302, 8), props.get(701, true)); + break; + + default: + prefab = new PrefabBase(); + console.log("ERROR: UNSUPPORTED PREFAB_TYPE"); + break; + } + + if ((props.get(110, 1) != 1) || (props.get(111, 1) != 1)) { + //geom.subGeometries; + //geom.scaleUV(props.get(110, 1), props.get(111, 1)); //TODO add back scaling to prefabs + } + + this.parseUserAttributes(); + prefab.name = name; + this._pFinalizeAsset(prefab, name); + this._blocks[blockID].data = prefab; + + if (this._debug) { + if ((primType < 0) || (primType > 7)) { + primType = 0; + } + console.log("Parsed a Primivite: Name = " + name + "| type = " + primitiveTypes[primType]); + } + } + + // Block ID = 22 + private parseContainer(blockID:number):void + { + var name:string; + var par_id:number; + var mtx:Matrix3D; + var ctr:DisplayObjectContainer; + var parent:DisplayObjectContainer; + + par_id = this._newBlockBytes.readUnsignedInt(); + mtx = this.parseMatrix3D(); + name = this.parseVarStr(); + + var parentName:string = "Root (TopLevel)"; + ctr = new DisplayObjectContainer(); + ctr.transform.matrix3D = mtx; + + var returnedArray:Array = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]); + + if (returnedArray[0]) { + var obj:DisplayObject = ( returnedArray[1]).addChild(ctr); + parentName = ( returnedArray[1]).name; + } else if (par_id > 0) { + this._blocks[ blockID ].addError("Could not find a parent for this ObjectContainer3D"); + } else { + //add to the content property + ( this._pContent).addChild(ctr); + } + + // in AWD version 2.1 we read the Container properties + if ((this._version[0] == 2) && (this._version[1] == 1)) { + var props:AWDProperties = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8}); + ctr.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + } + // in other versions we do not read the Container properties + else { + this.parseProperties(null); + } + + // the extraProperties should only be set for AWD2.1-Files, but is read for both versions + ctr.extra = this.parseUserAttributes(); + + this._pFinalizeAsset( ctr, name); + this._blocks[blockID].data = ctr; + + if (this._debug) { + console.log("Parsed a Container: Name = '" + name + "' | Parent-Name = " + parentName); + } + } + + // Block ID = 23 + private parseMeshInstance(blockID:number):void + { + var num_materials:number; + var materials_parsed:number; + var parent:DisplayObjectContainer; + var par_id:number = this._newBlockBytes.readUnsignedInt(); + var mtx:Matrix3D = this.parseMatrix3D(); + var name:string = this.parseVarStr(); + var parentName:string = "Root (TopLevel)"; + var data_id:number = this._newBlockBytes.readUnsignedInt(); + var geom:Geometry; + var returnedArrayGeometry:Array = this.getAssetByID(data_id, [AssetType.GEOMETRY]) + + if (returnedArrayGeometry[0]) { + geom = returnedArrayGeometry[1]; + } else { + this._blocks[blockID].addError("Could not find a Geometry for this Mesh. A empty Geometry is created!"); + geom = new Geometry(); + } + + this._blocks[blockID].geoID = data_id; + var materials:Array = new Array(); + num_materials = this._newBlockBytes.readUnsignedShort(); + + var materialNames:Array = new Array(); + materials_parsed = 0; + + var returnedArrayMaterial:Array; + + while (materials_parsed < num_materials) { + var mat_id:number; + mat_id = this._newBlockBytes.readUnsignedInt(); + returnedArrayMaterial = this.getAssetByID(mat_id, [AssetType.MATERIAL]) + if ((!returnedArrayMaterial[0]) && (mat_id > 0)) { + this._blocks[blockID].addError("Could not find Material Nr " + materials_parsed + " (ID = " + mat_id + " ) for this Mesh"); + } + + var m:MaterialBase = returnedArrayMaterial[1]; + + materials.push(m); + materialNames.push(m.name); + + materials_parsed++; + } + + var mesh:Mesh = new Mesh(geom, null); + mesh.transform.matrix3D = mtx; + + var returnedArrayParent:Array = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]) + + if (returnedArrayParent[0]) { + var objC:DisplayObjectContainer = returnedArrayParent[1]; + objC.addChild(mesh); + parentName = objC.name; + } else if (par_id > 0) { + this._blocks[blockID].addError("Could not find a parent for this Mesh"); + } else { + //add to the content property + ( this._pContent).addChild(mesh); + } + + if (materials.length >= 1 && mesh.subMeshes.length == 1) { + mesh.material = materials[0]; + } else if (materials.length > 1) { + var i:number; + + // Assign each sub-mesh in the mesh a material from the list. If more sub-meshes + // than materials, repeat the last material for all remaining sub-meshes. + for (i = 0; i < mesh.subMeshes.length; i++) { + mesh.subMeshes[i].material = materials[Math.min(materials.length - 1, i)]; + } + } + if ((this._version[0] == 2) && (this._version[1] == 1)) { + var props:AWDProperties = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8, 5:AWDParser.BOOL}); + mesh.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + mesh.castsShadows = props.get(5, true); + } else { + this.parseProperties(null); + } + + mesh.extra = this.parseUserAttributes(); + + this._pFinalizeAsset( mesh, name); + this._blocks[blockID].data = mesh; + + if (this._debug) { + console.log("Parsed a Mesh: Name = '" + name + "' | Parent-Name = " + parentName + "| Geometry-Name = " + geom.name + " | SubMeshes = " + mesh.subMeshes.length + " | Mat-Names = " + materialNames.toString()); + } + } + + + //Block ID 31 + private parseSkyboxInstance(blockID:number):void + { + var name:string = this.parseVarStr(); + var cubeTexAddr:number = this._newBlockBytes.readUnsignedInt(); + + var returnedArrayCubeTex:Array = this.getAssetByID(cubeTexAddr, [AssetType.TEXTURE], "CubeTexture"); + if ((!returnedArrayCubeTex[0]) && (cubeTexAddr != 0)) + this._blocks[blockID].addError("Could not find the Cubetexture (ID = " + cubeTexAddr + " ) for this Skybox"); + var asset:Skybox = new Skybox(new SkyboxMaterial( returnedArrayCubeTex[1])); + + this.parseProperties(null) + asset.extra = this.parseUserAttributes(); + this._pFinalizeAsset(asset, name); + this._blocks[blockID].data = asset; + if (this._debug) + console.log("Parsed a Skybox: Name = '" + name + "' | CubeTexture-Name = " + ( returnedArrayCubeTex[1]).name); + + } + + //Block ID = 41 + private parseLight(blockID:number):void + { + var light:LightBase; + var newShadowMapper:ShadowMapperBase; + + var par_id:number = this._newBlockBytes.readUnsignedInt(); + var mtx:Matrix3D = this.parseMatrix3D(); + var name:string = this.parseVarStr(); + var lightType:number = this._newBlockBytes.readUnsignedByte(); + var props:AWDProperties = this.parseProperties({1:this._propsNrType, 2:this._propsNrType, 3:AWDParser.COLOR, 4:this._propsNrType, 5:this._propsNrType, 6:AWDParser.BOOL, 7:AWDParser.COLOR, 8:this._propsNrType, 9:AWDParser.UINT8, 10:AWDParser.UINT8, 11:this._propsNrType, 12:AWDParser.UINT16, 21:this._matrixNrType, 22:this._matrixNrType, 23:this._matrixNrType}); + var shadowMapperType:number = props.get(9, 0); + var parentName:string = "Root (TopLevel)"; + var lightTypes:Array = ["Unsupported LightType", "PointLight", "DirectionalLight"]; + var shadowMapperTypes:Array = ["No ShadowMapper", "DirectionalShadowMapper", "NearDirectionalShadowMapper", "CascadeShadowMapper", "CubeMapShadowMapper"]; + + if (lightType == 1) { + light = new PointLight(); + + ( light).radius = props.get(1, 90000); + ( light).fallOff = props.get(2, 100000); + + if (shadowMapperType > 0) { + if (shadowMapperType == 4) { + newShadowMapper = new CubeMapShadowMapper(); + } + } + + light.transform.matrix3D = mtx; + + } + + if (lightType == 2) { + + light = new DirectionalLight(props.get(21, 0), props.get(22, -1), props.get(23, 1)); + + if (shadowMapperType > 0) { + if (shadowMapperType == 1) { + newShadowMapper = new DirectionalShadowMapper(); + } + + //if (shadowMapperType == 2) + // newShadowMapper = new NearDirectionalShadowMapper(props.get(11, 0.5)); + //if (shadowMapperType == 3) + // newShadowMapper = new CascadeShadowMapper(props.get(12, 3)); + + } + + } + light.color = props.get(3, 0xffffff); + light.specular = props.get(4, 1.0); + light.diffuse = props.get(5, 1.0); + light.ambientColor = props.get(7, 0xffffff); + light.ambient = props.get(8, 0.0); + + // if a shadowMapper has been created, adjust the depthMapSize if needed, assign to light and set castShadows to true + if (newShadowMapper) { + if (newShadowMapper instanceof CubeMapShadowMapper) { + if (props.get(10, 1) != 1) { + newShadowMapper.depthMapSize = this._depthSizeDic[props.get(10, 1)]; + } + } else { + if (props.get(10, 2) != 2) { + newShadowMapper.depthMapSize = this._depthSizeDic[props.get(10, 2)]; + } + } + + light.shadowMapper = newShadowMapper; + light.castsShadows = true; + } + + if (par_id != 0) { + + var returnedArrayParent:Array = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]) + + if (returnedArrayParent[0]) { + ( returnedArrayParent[1]).addChild(light); + parentName = ( returnedArrayParent[1]).name; + } else { + this._blocks[blockID].addError("Could not find a parent for this Light"); + } + } else { + //add to the content property + ( this._pContent).addChild(light); + } + + this.parseUserAttributes(); + + this._pFinalizeAsset(< IAsset> light, name); + + this._blocks[blockID].data = light; + + if (this._debug) + console.log("Parsed a Light: Name = '" + name + "' | Type = " + lightTypes[lightType] + " | Parent-Name = " + parentName + " | ShadowMapper-Type = " + shadowMapperTypes[shadowMapperType]); + + } + + //Block ID = 43 + private parseCamera(blockID:number):void + { + + var par_id:number = this._newBlockBytes.readUnsignedInt(); + var mtx:Matrix3D = this.parseMatrix3D(); + var name:string = this.parseVarStr(); + var parentName:string = "Root (TopLevel)"; + var projection:ProjectionBase; + + this._newBlockBytes.readUnsignedByte(); //set as active camera + this._newBlockBytes.readShort(); //lengthof lenses - not used yet + + var projectiontype:number = this._newBlockBytes.readShort(); + var props:AWDProperties = this.parseProperties({101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 104:this._propsNrType}); + + switch (projectiontype) { + case 5001: + projection = new PerspectiveProjection(props.get(101, 60)); + break; + case 5002: + projection = new OrthographicProjection(props.get(101, 500)); + break; + case 5003: + projection = new OrthographicOffCenterProjection(props.get(101, -400), props.get(102, 400), props.get(103, -300), props.get(104, 300)); + break; + default: + console.log("unsupportedLenstype"); + return; + } + + var camera:Camera = new Camera(projection); + camera.transform.matrix3D = mtx; + + var returnedArrayParent:Array = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]) + + if (returnedArrayParent[0]) { + + var objC:DisplayObjectContainer = returnedArrayParent[1]; + objC.addChild(camera); + + parentName = objC.name; + + } else if (par_id > 0) { + this._blocks[blockID].addError("Could not find a parent for this Camera"); + } else { + //add to the content property + ( this._pContent).addChild(camera); + } + + camera.name = name; + props = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8}); + camera.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + camera.extra = this.parseUserAttributes(); + + this._pFinalizeAsset(camera, name); + + this._blocks[blockID].data = camera + + if (this._debug) { + console.log("Parsed a Camera: Name = '" + name + "' | Projectiontype = " + projection + " | Parent-Name = " + parentName); + } + + } + + //Block ID = 51 + private parseLightPicker(blockID:number):void + { + var name:string = this.parseVarStr(); + var numLights:number = this._newBlockBytes.readUnsignedShort(); + var lightsArray:Array = new Array(); + var k:number = 0; + var lightID:number = 0; + + var returnedArrayLight:Array; + var lightsArrayNames:Array = new Array(); + + for (k = 0; k < numLights; k++) { + lightID = this._newBlockBytes.readUnsignedInt(); + returnedArrayLight = this.getAssetByID(lightID, [AssetType.LIGHT]) + + if (returnedArrayLight[0]) { + lightsArray.push( returnedArrayLight[1]); + lightsArrayNames.push(( returnedArrayLight[1]).name); + + } else { + this._blocks[blockID].addError("Could not find a Light Nr " + k + " (ID = " + lightID + " ) for this LightPicker"); + } + } + + if (lightsArray.length == 0) { + this._blocks[blockID].addError("Could not create this LightPicker, cause no Light was found."); + this.parseUserAttributes(); + return; //return without any more parsing for this block + } + + var lightPick:LightPickerBase = new StaticLightPicker(lightsArray); + lightPick.name = name; + + this.parseUserAttributes(); + this._pFinalizeAsset( lightPick, name); + + this._blocks[blockID].data = lightPick + if (this._debug) { + console.log("Parsed a StaticLightPicker: Name = '" + name + "' | Texture-Name = " + lightsArrayNames.toString()); + } + } + + //Block ID = 81 + private parseMaterial(blockID:number):void + { + // TODO: not used + ////blockLength = block.len; + var name:string; + var type:number; + var props:AWDProperties; + var mat:TriangleMethodMaterial; + var attributes:Object; + var finalize:boolean; + var num_methods:number; + var methods_parsed:number; + var returnedArray:Array; + + name = this.parseVarStr(); + type = this._newBlockBytes.readUnsignedByte(); + num_methods = this._newBlockBytes.readUnsignedByte(); + + // Read material numerical properties + // (1=color, 2=bitmap url, 10=alpha, 11=alpha_blending, 12=alpha_threshold, 13=repeat) + props = this.parseProperties({ 1:AWDParser.INT32, 2:AWDParser.BADDR, 10:this._propsNrType, 11:AWDParser.BOOL, 12:this._propsNrType, 13:AWDParser.BOOL}); + + methods_parsed = 0; + while (methods_parsed < num_methods) { + var method_type:number; + + method_type = this._newBlockBytes.readUnsignedShort(); + this.parseProperties(null); + this.parseUserAttributes(); + methods_parsed += 1; + } + var debugString:string = ""; + attributes = this.parseUserAttributes(); + if (type === 1) { // Color material + debugString += "Parsed a ColorMaterial(SinglePass): Name = '" + name + "' | "; + var color:number; + color = props.get(1, 0xffffff); + if (this.materialMode < 2) { + mat = new TriangleMethodMaterial(color, props.get(10, 1.0)); + } else { + mat = new TriangleMethodMaterial(color); + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + } + } else if (type === 2) { + var tex_addr:number = props.get(2, 0); + + returnedArray = this.getAssetByID(tex_addr, [AssetType.TEXTURE]); + + if ((!returnedArray[0]) && (tex_addr > 0)) + this._blocks[blockID].addError("Could not find the DiffsueTexture (ID = " + tex_addr + " ) for this Material"); + + mat = new TriangleMethodMaterial( returnedArray[1]); + + if (this.materialMode < 2) { + mat.alphaBlending = props.get(11, false); + mat.alpha = props.get(10, 1.0); + debugString += "Parsed a TriangleMethodMaterial(SinglePass): Name = '" + name + "' | Texture-Name = " + mat.name; + } else { + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + debugString += "Parsed a TriangleMethodMaterial(MultiPass): Name = '" + name + "' | Texture-Name = " + mat.name; + } + } + + mat.extra = attributes; + mat.alphaThreshold = props.get(12, 0.0); + mat.repeat = props.get(13, false); + this._pFinalizeAsset( mat, name); + this._blocks[blockID].data = mat; + + if (this._debug) { + console.log(debugString); + + } + } + + // Block ID = 81 AWD2.1 + private parseMaterial_v1(blockID:number):void + { + var mat:TriangleMethodMaterial; + var normalTexture:Texture2DBase; + var specTexture:Texture2DBase; + var returnedArray:Array; + + var name:string = this.parseVarStr(); + var type:number = this._newBlockBytes.readUnsignedByte(); + var num_methods:number = this._newBlockBytes.readUnsignedByte(); + var props:AWDProperties = this.parseProperties({1:AWDParser.UINT32, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 4:AWDParser.UINT8, 5:AWDParser.BOOL, 6:AWDParser.BOOL, 7:AWDParser.BOOL, 8:AWDParser.BOOL, 9:AWDParser.UINT8, 10:this._propsNrType, 11:AWDParser.BOOL, 12:this._propsNrType, 13:AWDParser.BOOL, 15:this._propsNrType, 16:AWDParser.UINT32, 17:AWDParser.BADDR, 18:this._propsNrType, 19:this._propsNrType, 20:AWDParser.UINT32, 21:AWDParser.BADDR, 22:AWDParser.BADDR}); + var spezialType:number = props.get(4, 0); + var debugString:string = ""; + + if (spezialType >= 2) {//this is no supported material + this._blocks[blockID].addError("Material-spezialType '" + spezialType + "' is not supported, can only be 0:singlePass, 1:MultiPass !"); + return; + } + + if (this.materialMode == 1) + spezialType = 0; + else if (this.materialMode == 2) + spezialType = 1; + + if (spezialType < 2) {//this is SinglePass or MultiPass + + if (type == 1) {// Color material + var color:number = props.get(1, 0xcccccc);//TODO temporarily swapped so that diffuse color goes to ambient + + if (spezialType == 1) {// MultiPassMaterial + mat = new TriangleMethodMaterial(color); + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + debugString += "Parsed a ColorMaterial(MultiPass): Name = '" + name + "' | "; + + } else { // SinglePassMaterial + mat = new TriangleMethodMaterial(color, props.get(10, 1.0)); + mat.alphaBlending = props.get(11, false); + debugString += "Parsed a ColorMaterial(SinglePass): Name = '" + name + "' | "; + } + + } else if (type == 2) {// texture material + var tex_addr:number = props.get(2, 0);//TODO temporarily swapped so that diffuse texture goes to ambient + returnedArray = this.getAssetByID(tex_addr, [AssetType.TEXTURE]); + + if ((!returnedArray[0]) && (tex_addr > 0)) + this._blocks[blockID].addError("Could not find the AmbientTexture (ID = " + tex_addr + " ) for this TriangleMethodMaterial"); + + var texture:Texture2DBase = returnedArray[1]; + + mat = new TriangleMethodMaterial(texture); + + if (spezialType == 1) {// MultiPassMaterial + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + + debugString += "Parsed a TriangleMethodMaterial(MultiPass): Name = '" + name + "' | Texture-Name = " + texture.name; + } else {// SinglePassMaterial + mat.alpha = props.get(10, 1.0); + mat.alphaBlending = props.get(11, false); + + debugString += "Parsed a TriangleMethodMaterial(SinglePass): Name = '" + name + "' | Texture-Name = " + texture.name; + } + } + + var diffuseTexture:Texture2DBase; + var diffuseTex_addr:number = props.get(17, 0); + + returnedArray = this.getAssetByID(diffuseTex_addr, [AssetType.TEXTURE]); + + if ((!returnedArray[0]) && (diffuseTex_addr != 0)) { + this._blocks[blockID].addError("Could not find the DiffuseTexture (ID = " + diffuseTex_addr + " ) for this TriangleMethodMaterial"); + } + + if (returnedArray[0]) + diffuseTexture = returnedArray[1]; + + if (diffuseTexture) { + mat.diffuseTexture = diffuseTexture; + debugString += " | DiffuseTexture-Name = " + diffuseTexture.name; + } + + var normalTex_addr:number = props.get(3, 0); + + returnedArray = this.getAssetByID(normalTex_addr, [AssetType.TEXTURE]); + + if ((!returnedArray[0]) && (normalTex_addr != 0)) { + this._blocks[blockID].addError("Could not find the NormalTexture (ID = " + normalTex_addr + " ) for this TriangleMethodMaterial"); + } + + if (returnedArray[0]) { + normalTexture = returnedArray[1]; + debugString += " | NormalTexture-Name = " + normalTexture.name; + } + + var specTex_addr:number = props.get(21, 0); + returnedArray = this.getAssetByID(specTex_addr, [AssetType.TEXTURE]); + + if ((!returnedArray[0]) && (specTex_addr != 0)) { + this._blocks[blockID].addError("Could not find the SpecularTexture (ID = " + specTex_addr + " ) for this TriangleMethodMaterial"); + } + if (returnedArray[0]) { + specTexture = returnedArray[1]; + debugString += " | SpecularTexture-Name = " + specTexture.name; + } + + var lightPickerAddr:number = props.get(22, 0); + returnedArray = this.getAssetByID(lightPickerAddr, [AssetType.LIGHT_PICKER]) + + if ((!returnedArray[0]) && (lightPickerAddr)) { + this._blocks[blockID].addError("Could not find the LightPicker (ID = " + lightPickerAddr + " ) for this TriangleMethodMaterial"); + } else { + mat.lightPicker = returnedArray[1]; + //debugString+=" | Lightpicker-Name = "+LightPickerBase(returnedArray[1]).name; + } + + mat.smooth = props.get(5, true); + mat.mipmap = props.get(6, true); + mat.bothSides = props.get(7, false); + mat.alphaPremultiplied = props.get(8, false); + mat.blendMode = this.blendModeDic[props.get(9, 0)]; + mat.repeat = props.get(13, false); + + if (normalTexture) + mat.normalMap = normalTexture; + + if (specTexture) + mat.specularMap = specTexture; + + mat.alphaThreshold = props.get(12, 0.0); + mat.ambient = props.get(15, 1.0); + mat.diffuseColor = props.get(16, 0xffffff); + mat.specular = props.get(18, 1.0); + mat.gloss = props.get(19, 50); + mat.specularColor = props.get(20, 0xffffff); + + var methods_parsed:number = 0; + var targetID:number; + + while (methods_parsed < num_methods) { + var method_type:number; + method_type = this._newBlockBytes.readUnsignedShort(); + + props = this.parseProperties({1:AWDParser.BADDR, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 201:AWDParser.UINT32, 202:AWDParser.UINT32, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 401:AWDParser.UINT8, 402:AWDParser.UINT8, 601:AWDParser.COLOR, 602:AWDParser.COLOR, 701:AWDParser.BOOL, 702:AWDParser.BOOL, 801:AWDParser.MTX4x4}); + + switch (method_type) { + case 999: //wrapper-Methods that will load a previous parsed EffektMethod returned + + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.EFFECTS_METHOD]); + + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the EffectMethod (ID = " + targetID + " ) for this Material"); + } else { + mat.addEffectMethod(returnedArray[1]); + + debugString += " | EffectMethod-Name = " + ( returnedArray[1]).name; + } + + break; + + case 998: //wrapper-Methods that will load a previous parsed ShadowMapMethod + + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]); + + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the ShadowMethod (ID = " + targetID + " ) for this Material"); + } else { + mat.shadowMethod = returnedArray[1]; + debugString += " | ShadowMethod-Name = " + ( returnedArray[1]).name; + } + + break; + + case 1: //EnvMapAmbientMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE], "CubeTexture"); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the EnvMap (ID = " + targetID + " ) for this EnvMapAmbientMethodMaterial"); + mat.ambientMethod = new AmbientEnvMapMethod(returnedArray[1]); + debugString += " | AmbientEnvMapMethod | EnvMap-Name =" + ( returnedArray[1]).name; + break; + + case 51: //DepthDiffuseMethod + mat.diffuseMethod = new DiffuseDepthMethod(); + debugString += " | DiffuseDepthMethod"; + break; + case 52: //GradientDiffuseMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the GradientDiffuseTexture (ID = " + targetID + " ) for this GradientDiffuseMethod"); + mat.diffuseMethod = new DiffuseGradientMethod(returnedArray[1]); + debugString += " | DiffuseGradientMethod | GradientDiffuseTexture-Name =" + ( returnedArray[1]).name; + break; + case 53: //WrapDiffuseMethod + mat.diffuseMethod = new DiffuseWrapMethod(props.get(101, 5)); + debugString += " | DiffuseWrapMethod"; + break; + case 54: //LightMapDiffuseMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the LightMap (ID = " + targetID + " ) for this LightMapDiffuseMethod"); + mat.diffuseMethod = new DiffuseLightMapMethod(returnedArray[1], this.blendModeDic[props.get(401, 10)], false, mat.diffuseMethod); + debugString += " | DiffuseLightMapMethod | LightMapTexture-Name =" + ( returnedArray[1]).name; + break; + case 55: //CelDiffuseMethod + mat.diffuseMethod = new DiffuseCelMethod(props.get(401, 3), mat.diffuseMethod); + ( mat.diffuseMethod).smoothness = props.get(101, 0.1); + debugString += " | DiffuseCelMethod"; + break; + case 56: //SubSurfaceScatteringMethod +// mat.diffuseMethod = new DiffuseSubSurfaceMethod(); //depthMapSize and depthMapOffset ? +// ( mat.diffuseMethod).scattering = props.get(101, 0.2); +// ( mat.diffuseMethod).translucency = props.get(102, 1); +// ( mat.diffuseMethod).scatterColor = props.get(601, 0xffffff); +// debugString += " | DiffuseSubSurfaceMethod"; + break; + + case 101: //AnisotropicSpecularMethod + mat.specularMethod = new SpecularAnisotropicMethod(); + debugString += " | SpecularAnisotropicMethod"; + break; + case 102: //SpecularPhongMethod + mat.specularMethod = new SpecularPhongMethod(); + debugString += " | SpecularPhongMethod"; + break; + case 103: //CellSpecularMethod + mat.specularMethod = new SpecularCelMethod(props.get(101, 0.5), mat.specularMethod); + ( mat.specularMethod).smoothness = props.get(102, 0.1); + debugString += " | SpecularCelMethod"; + break; + case 104: //SpecularFresnelMethod + mat.specularMethod = new SpecularFresnelMethod(props.get(701, true), mat.specularMethod); + ( mat.specularMethod).fresnelPower = props.get(101, 5); + ( mat.specularMethod).normalReflectance = props.get(102, 0.1); + debugString += " | SpecularFresnelMethod"; + break; + case 151://HeightMapNormalMethod - thios is not implemented for now, but might appear later + break; + case 152: //SimpleWaterNormalMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the SecoundNormalMap (ID = " + targetID + " ) for this SimpleWaterNormalMethod"); + if (!mat.normalMap) + this._blocks[blockID].addError("Could not find a normal Map on this Material to use with this SimpleWaterNormalMethod"); + + mat.normalMap = returnedArray[1]; + mat.normalMethod = new NormalSimpleWaterMethod(mat.normalMap, returnedArray[1]); + debugString += " | NormalSimpleWaterMethod | Second-NormalTexture-Name = " + ( returnedArray[1]).name; + break; + } + this.parseUserAttributes(); + methods_parsed += 1; + } + } + mat.extra = this.parseUserAttributes(); + this._pFinalizeAsset( mat, name); + + this._blocks[blockID].data = mat; + if (this._debug) { + console.log(debugString); + } + } + + //Block ID = 82 + private parseTexture(blockID:number):void + { + + var asset:Texture2DBase; + + this._blocks[blockID].name = this.parseVarStr(); + + var type:number = this._newBlockBytes.readUnsignedByte(); + var data_len:number; + + this._texture_users[this._cur_block_id.toString()] = []; + + // External + if (type == 0) { + data_len = this._newBlockBytes.readUnsignedInt(); + var url:string; + url = this._newBlockBytes.readUTFBytes(data_len); + this._pAddDependency(this._cur_block_id.toString(), new URLRequest(url), false, null, true); + + } else { + data_len = this._newBlockBytes.readUnsignedInt(); + + var data:ByteArray; + data = new ByteArray(); + this._newBlockBytes.readBytes(data, 0, data_len); + + // + // AWDParser - Fix for FireFox Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=715075 . + // + // Converting data to image here instead of parser - fix FireFox bug where image width / height is 0 when created from data + // This gives the browser time to initialise image width / height. + + this._pAddDependency(this._cur_block_id.toString(), null, false, ParserUtils.byteArrayToImage(data), true); + //this._pAddDependency(this._cur_block_id.toString(), null, false, data, true); + + } + + // Ignore for now + this.parseProperties(null); + this._blocks[blockID].extras = this.parseUserAttributes(); + this._pPauseAndRetrieveDependencies(); + this._blocks[blockID].data = asset; + + if (this._debug) { + var textureStylesNames:Array = ["external", "embed"] + console.log("Start parsing a " + textureStylesNames[type] + " Bitmap for Texture"); + } + + } + + //Block ID = 83 + private parseCubeTexture(blockID:number):void + { + //blockLength = block.len; + var data_len:number; + var asset:CubeTextureBase; + var i:number; + + this._cubeTextures = new Array(); + this._texture_users[ this._cur_block_id.toString() ] = []; + + var type:number = this._newBlockBytes.readUnsignedByte(); + + this._blocks[blockID].name = this.parseVarStr(); + + for (i = 0; i < 6; i++) { + this._texture_users[this._cur_block_id.toString()] = []; + this._cubeTextures.push(null); + + // External + if (type == 0) { + data_len = this._newBlockBytes.readUnsignedInt(); + var url:string; + url = this._newBlockBytes.readUTFBytes(data_len); + + this._pAddDependency(this._cur_block_id.toString() + "#" + i, new URLRequest(url), false, null, true); + } else { + + data_len = this._newBlockBytes.readUnsignedInt(); + var data:ByteArray; + data = new ByteArray(); + + this._newBlockBytes.readBytes(data, 0, data_len); + + this._pAddDependency(this._cur_block_id.toString() + "#" + i, null, false, ParserUtils.byteArrayToImage(data), true); + } + } + + // Ignore for now + this.parseProperties(null); + this._blocks[blockID].extras = this.parseUserAttributes(); + this._pPauseAndRetrieveDependencies(); + this._blocks[blockID].data = asset; + + if (this._debug) { + var textureStylesNames:Array = ["external", "embed"] + console.log("Start parsing 6 " + textureStylesNames[type] + " Bitmaps for CubeTexture"); + } + } + + //Block ID = 91 + private parseSharedMethodBlock(blockID:number):void + { + var asset:EffectMethodBase; + + this._blocks[blockID].name = this.parseVarStr(); + asset = this.parseSharedMethodList(blockID); + this.parseUserAttributes(); + this._blocks[blockID].data = asset; + this._pFinalizeAsset( asset, this._blocks[blockID].name); + this._blocks[blockID].data = asset; + + if (this._debug) { + console.log("Parsed a EffectMethod: Name = " + asset.name + " Type = " + asset); + } + } + + //Block ID = 92 + private parseShadowMethodBlock(blockID:number):void + { + var type:number; + var data_len:number; + var asset:ShadowMethodBase; + var shadowLightID:number; + this._blocks[blockID].name = this.parseVarStr(); + + shadowLightID = this._newBlockBytes.readUnsignedInt(); + var returnedArray:Array = this.getAssetByID(shadowLightID, [AssetType.LIGHT]); + + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the TargetLight (ID = " + shadowLightID + " ) for this ShadowMethod - ShadowMethod not created"); + return; + } + + asset = this.parseShadowMethodList( returnedArray[1], blockID); + + if (!asset) + return; + + this.parseUserAttributes(); // Ignore for now + this._pFinalizeAsset( asset, this._blocks[blockID].name); + this._blocks[blockID].data = asset; + + if (this._debug) { + console.log("Parsed a ShadowMapMethodMethod: Name = " + asset.name + " | Type = " + asset + " | Light-Name = ", ( returnedArray[1] ).name); + } + } + + + //Block ID = 253 + private parseCommand(blockID:number):void + { + var hasBlocks:boolean = ( this._newBlockBytes.readUnsignedByte() == 1 ); + var par_id:number = this._newBlockBytes.readUnsignedInt(); + var mtx:Matrix3D = this.parseMatrix3D(); + var name:string = this.parseVarStr(); + + var parentObject:DisplayObjectContainer; + var targetObject:DisplayObjectContainer; + + var returnedArray:Array = this.getAssetByID(par_id, [AssetType.CONTAINER, AssetType.LIGHT, AssetType.MESH]); + + if (returnedArray[0]) { + parentObject = returnedArray[1]; + } + + var numCommands:number = this._newBlockBytes.readShort(); + var typeCommand:number = this._newBlockBytes.readShort(); + + var props:AWDProperties = this.parseProperties({1:AWDParser.BADDR}); + + switch (typeCommand) { + case 1: + + var targetID:number = props.get(1, 0); + var returnedArrayTarget:Array = this.getAssetByID(targetID, [AssetType.LIGHT, AssetType.TEXTURE_PROJECTOR]); //for no only light is requested!!!! + + if ((!returnedArrayTarget[0]) && (targetID != 0)) { + this._blocks[blockID].addError("Could not find the light (ID = " + targetID + " ( for this CommandBock!"); + return; + } + + targetObject = returnedArrayTarget[1]; + + if (parentObject) { + parentObject.addChild(targetObject); + } + + targetObject.transform.matrix3D = mtx; + + break; + } + + if (targetObject) { + props = this.parseProperties({1:this._matrixNrType, 2:this._matrixNrType, 3:this._matrixNrType, 4:AWDParser.UINT8}); + + targetObject.pivot = new Vector3D(props.get(1, 0), props.get(2, 0), props.get(3, 0)); + targetObject.extra = this.parseUserAttributes(); + + } + this._blocks[blockID].data = targetObject + + if (this._debug) { + console.log("Parsed a CommandBlock: Name = '" + name); + } + + } + + //blockID 255 + private parseMetaData(blockID:number):void + { + var props:AWDProperties = this.parseProperties({1:AWDParser.UINT32, 2:AWDParser.AWDSTRING, 3:AWDParser.AWDSTRING, 4:AWDParser.AWDSTRING, 5:AWDParser.AWDSTRING}); + + if (this._debug) { + console.log("Parsed a MetaDataBlock: TimeStamp = " + props.get(1, 0)); + console.log(" EncoderName = " + props.get(2, "unknown")); + console.log(" EncoderVersion = " + props.get(3, "unknown")); + console.log(" GeneratorName = " + props.get(4, "unknown")); + console.log(" GeneratorVersion = " + props.get(5, "unknown")); + } + } + + //blockID 254 + private parseNameSpace(blockID:number):void + { + var id:number = this._newBlockBytes.readUnsignedByte(); + var nameSpaceString:string = this.parseVarStr(); + if (this._debug) + console.log("Parsed a NameSpaceBlock: ID = " + id + " | String = " + nameSpaceString); + } + + //--Parser UTILS--------------------------------------------------------------------------- + + // this functions reads and creates a ShadowMethodMethod + private parseShadowMethodList(light:LightBase, blockID:number):ShadowMethodBase + { + + var methodType:number = this._newBlockBytes.readUnsignedShort(); + var shadowMethod:ShadowMethodBase; + var props:AWDProperties = this.parseProperties({1:AWDParser.BADDR, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 201:AWDParser.UINT32, 202:AWDParser.UINT32, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 401:AWDParser.UINT8, 402:AWDParser.UINT8, 601:AWDParser.COLOR, 602:AWDParser.COLOR, 701:AWDParser.BOOL, 702:AWDParser.BOOL, 801:AWDParser.MTX4x4}); + + var targetID:number; + var returnedArray:Array + switch (methodType) { + // case 1001: //CascadeShadowMapMethod + // targetID = props.get(1, 0); + // returnedArray = getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]); + // if (!returnedArray[0]) { + // _blocks[blockID].addError("Could not find the ShadowBaseMethod (ID = " + targetID + " ) for this CascadeShadowMapMethod - ShadowMethod not created"); + // return shadowMethod; + // } + // shadowMethod = new CascadeShadowMapMethod(returnedArray[1]); + // break; + case 1002: //ShadowNearMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.SHADOW_MAP_METHOD]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the ShadowBaseMethod (ID = " + targetID + " ) for this ShadowNearMethod - ShadowMethod not created"); + return shadowMethod; + } + shadowMethod = new ShadowNearMethod( returnedArray[1]); + break; + case 1101: //ShadowFilteredMethod + + shadowMethod = new ShadowFilteredMethod( light); + ( shadowMethod).alpha = props.get(101, 1); + ( shadowMethod).epsilon = props.get(102, 0.002); + break; + + case 1102: //ShadowDitheredMethod + + + shadowMethod = new ShadowDitheredMethod( light, props.get(201, 5)); + ( shadowMethod).alpha = props.get(101, 1); + ( shadowMethod).epsilon = props.get(102, 0.002); + ( shadowMethod).range = props.get(103, 1); + + break; + case 1103: //ShadowSoftMethod + + shadowMethod = new ShadowSoftMethod( light, props.get(201, 5)); + ( shadowMethod).alpha = props.get(101, 1); + ( shadowMethod).epsilon = props.get(102, 0.002); + ( shadowMethod).range = props.get(103, 1); + + break; + case 1104: //ShadowHardMethod + shadowMethod = new ShadowHardMethod(light); + ( shadowMethod).alpha = props.get(101, 1); + ( shadowMethod).epsilon = props.get(102, 0.002); + break; + + } + this.parseUserAttributes(); + return shadowMethod; + } + + //Block ID 101 + private parseSkeleton(blockID:number /*uint*/):void + { + var name:string = this.parseVarStr(); + var num_joints:number /*uint*/ = this._newBlockBytes.readUnsignedShort(); + var skeleton:Skeleton = new Skeleton(); + this.parseProperties(null); // Discard properties for now + + var joints_parsed:number /*uint*/ = 0; + while (joints_parsed < num_joints) { + var joint:SkeletonJoint; + var ibp:Matrix3D; + // Ignore joint id + this._newBlockBytes.readUnsignedShort(); + joint = new SkeletonJoint(); + joint.parentIndex = this._newBlockBytes.readUnsignedShort() - 1; // 0=null in AWD + joint.name = this.parseVarStr(); + + ibp = this.parseMatrix3D(); + joint.inverseBindPose = ibp.rawData; + // Ignore joint props/attributes for now + this.parseProperties(null); + this.parseUserAttributes(); + skeleton.joints.push(joint); + joints_parsed++; + } + + // Discard attributes for now + this.parseUserAttributes(); + this._pFinalizeAsset(skeleton, name); + this._blocks[blockID].data = skeleton; + if (this._debug) + console.log("Parsed a Skeleton: Name = " + skeleton.name + " | Number of Joints = " + joints_parsed); + } + + //Block ID = 102 + private parseSkeletonPose(blockID:number /*uint*/):void + { + var name:string = this.parseVarStr(); + var num_joints:number /*uint*/ = this._newBlockBytes.readUnsignedShort(); + this.parseProperties(null); // Ignore properties for now + + var pose:SkeletonPose = new SkeletonPose(); + + var joints_parsed:number /*uint*/ = 0; + while (joints_parsed < num_joints) { + var joint_pose:JointPose; + var has_transform:number /*uint*/; + joint_pose = new JointPose(); + has_transform = this._newBlockBytes.readUnsignedByte(); + if (has_transform == 1) { + var mtx_data:Array = this.parseMatrix43RawData(); + + var mtx:Matrix3D = new Matrix3D(mtx_data); + joint_pose.orientation.fromMatrix(mtx); + joint_pose.translation.copyFrom(mtx.position); + + pose.jointPoses[joints_parsed] = joint_pose; + } + joints_parsed++; + } + // Skip attributes for now + this.parseUserAttributes(); + this._pFinalizeAsset(pose, name); + this._blocks[blockID].data = pose; + if (this._debug) + console.log("Parsed a SkeletonPose: Name = " + pose.name + " | Number of Joints = " + joints_parsed); + } + + //blockID 103 + private parseSkeletonAnimation(blockID:number /*uint*/):void + { + var frame_dur:number; + var pose_addr:number /*uint*/; + var name:string = this.parseVarStr(); + var clip:SkeletonClipNode = new SkeletonClipNode(); + var num_frames:number /*uint*/ = this._newBlockBytes.readUnsignedShort(); + this.parseProperties(null); // Ignore properties for now + + var frames_parsed:number /*uint*/ = 0; + var returnedArray:Array; + while (frames_parsed < num_frames) { + pose_addr = this._newBlockBytes.readUnsignedInt(); + frame_dur = this._newBlockBytes.readUnsignedShort(); + returnedArray = this.getAssetByID(pose_addr, [AssetType.SKELETON_POSE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the SkeletonPose Frame # " + frames_parsed + " (ID = " + pose_addr + " ) for this SkeletonClipNode"); + else + clip.addFrame( this._blocks[pose_addr].data, frame_dur); + frames_parsed++; + } + if (clip.frames.length == 0) { + this._blocks[blockID].addError("Could not this SkeletonClipNode, because no Frames where set."); + return; + } + // Ignore attributes for now + this.parseUserAttributes(); + this._pFinalizeAsset(clip, name); + this._blocks[blockID].data = clip; + if (this._debug) + console.log("Parsed a SkeletonClipNode: Name = " + clip.name + " | Number of Frames = " + clip.frames.length); + } + + //Block ID = 111 / Block ID = 112 + private parseMeshPoseAnimation(blockID:number /*uint*/, poseOnly:boolean = false):void + { + var num_frames:number /*uint*/ = 1; + var num_submeshes:number /*uint*/; + var frames_parsed:number /*uint*/; + var subMeshParsed:number /*uint*/; + var frame_dur:number; + var x:number; + var y:number; + var z:number; + var str_len:number; + var str_end:number; + var geometry:Geometry; + var subGeom:TriangleSubGeometry; + var idx:number /*int*/ = 0; + var clip:VertexClipNode = new VertexClipNode(); + var indices:Array /*uint*/; + var verts:Array; + var num_Streams:number /*int*/ = 0; + var streamsParsed:number /*int*/ = 0; + var streamtypes:Array /*int*/ = new Array() /*int*/; + var props:AWDProperties; + var thisGeo:Geometry; + var name:string = this.parseVarStr(); + var geoAdress:number /*int*/ = this._newBlockBytes.readUnsignedInt(); + var returnedArray:Array = this.getAssetByID(geoAdress, [AssetType.GEOMETRY]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the target-Geometry-Object " + geoAdress + " ) for this VertexClipNode"); + return; + } + var uvs:Array> = this.getUVForVertexAnimation(geoAdress); + if (!poseOnly) + num_frames = this._newBlockBytes.readUnsignedShort(); + + num_submeshes = this._newBlockBytes.readUnsignedShort(); + num_Streams = this._newBlockBytes.readUnsignedShort(); + streamsParsed = 0; + while (streamsParsed < num_Streams) { + streamtypes.push(this._newBlockBytes.readUnsignedShort()); + streamsParsed++; + } + props = this.parseProperties({1:AWDParser.BOOL, 2:AWDParser.BOOL}); + + clip.looping = props.get(1, true); + clip.stitchFinalFrame = props.get(2, false); + + frames_parsed = 0; + while (frames_parsed < num_frames) { + frame_dur = this._newBlockBytes.readUnsignedShort(); + geometry = new Geometry(); + subMeshParsed = 0; + while (subMeshParsed < num_submeshes) { + streamsParsed = 0; + str_len = this._newBlockBytes.readUnsignedInt(); + str_end = this._newBlockBytes.position + str_len; + while (streamsParsed < num_Streams) { + if (streamtypes[streamsParsed] == 1) { + indices = ( returnedArray[1]).subGeometries[subMeshParsed].indices; + verts = new Array(); + idx = 0; + while (this._newBlockBytes.position < str_end) { + x = this.readNumber(this._accuracyGeo) + y = this.readNumber(this._accuracyGeo) + z = this.readNumber(this._accuracyGeo) + verts[idx++] = x; + verts[idx++] = y; + verts[idx++] = z; + } + subGeom = new TriangleSubGeometry(true); + subGeom.updateIndices(indices); + subGeom.updatePositions(verts); + subGeom.updateUVs(uvs[subMeshParsed]); + subGeom.updateVertexNormals(null); + subGeom.updateVertexTangents(null); + subGeom.autoDeriveNormals = false; + subGeom.autoDeriveTangents = false; + subMeshParsed++; + geometry.addSubGeometry(subGeom) + } else + this._newBlockBytes.position = str_end; + streamsParsed++; + } + } + clip.addFrame(geometry, frame_dur); + frames_parsed++; + } + this.parseUserAttributes(); + this._pFinalizeAsset(clip, name); + + this._blocks[blockID].data = clip; + if (this._debug) + console.log("Parsed a VertexClipNode: Name = " + clip.name + " | Target-Geometry-Name = " + ( returnedArray[1]).name + " | Number of Frames = " + clip.frames.length); + } + + //BlockID 113 + private parseVertexAnimationSet(blockID:number /*uint*/):void + { + var poseBlockAdress:number /*int*/ + var outputString:string = ""; + var name:string = this.parseVarStr(); + var num_frames:number /*uint*/ = this._newBlockBytes.readUnsignedShort(); + var props:AWDProperties = this.parseProperties({1:AWDParser.UINT16}); + var frames_parsed:number /*uint*/ = 0; + var skeletonFrames:Array = new Array(); + var vertexFrames:Array = new Array(); + while (frames_parsed < num_frames) { + poseBlockAdress = this._newBlockBytes.readUnsignedInt(); + var returnedArray:Array = this.getAssetByID(poseBlockAdress, [AssetType.ANIMATION_NODE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the AnimationClipNode Nr " + frames_parsed + " ( " + poseBlockAdress + " ) for this AnimationSet"); + else { + if (returnedArray[1] instanceof VertexClipNode) + vertexFrames.push(returnedArray[1]) + if (returnedArray[1] instanceof SkeletonClipNode) + skeletonFrames.push(returnedArray[1]) + } + frames_parsed++; + } + if ((vertexFrames.length == 0) && (skeletonFrames.length == 0)) { + this._blocks[blockID].addError("Could not create this AnimationSet, because it contains no animations"); + return; + } + this.parseUserAttributes(); + if (vertexFrames.length > 0) { + var newVertexAnimationSet:VertexAnimationSet = new VertexAnimationSet(); + for (var i:number /*int*/ = 0; i < vertexFrames.length; i++) + newVertexAnimationSet.addAnimation(vertexFrames[i]); + this._pFinalizeAsset(newVertexAnimationSet, name); + this._blocks[blockID].data = newVertexAnimationSet; + if (this._debug) + console.log("Parsed a VertexAnimationSet: Name = " + name + " | Animations = " + newVertexAnimationSet.animations.length + " | Animation-Names = " + newVertexAnimationSet.animationNames.toString()); + + } else if (skeletonFrames.length > 0) { + returnedArray = this.getAssetByID(poseBlockAdress, [AssetType.ANIMATION_NODE]); + var newSkeletonAnimationSet:SkeletonAnimationSet = new SkeletonAnimationSet(props.get(1, 4)); //props.get(1,4)); + for (var i:number /*int*/ = 0; i < skeletonFrames.length; i++) + newSkeletonAnimationSet.addAnimation(skeletonFrames[i]); + this._pFinalizeAsset(newSkeletonAnimationSet, name); + this._blocks[blockID].data = newSkeletonAnimationSet; + if (this._debug) + console.log("Parsed a SkeletonAnimationSet: Name = " + name + " | Animations = " + newSkeletonAnimationSet.animations.length + " | Animation-Names = " + newSkeletonAnimationSet.animationNames.toString()); + + } + } + + //BlockID 122 + private parseAnimatorSet(blockID:number /*uint*/):void + { + var targetMesh:Mesh; + var animSetBlockAdress:number /*int*/ + var targetAnimationSet:AnimationSetBase; + var outputString:string = ""; + var name:string = this.parseVarStr(); + var type:number /*uint*/ = this._newBlockBytes.readUnsignedShort(); + + var props:AWDProperties = this.parseProperties({1:AWDParser.BADDR}); + + animSetBlockAdress = this._newBlockBytes.readUnsignedInt(); + var targetMeshLength:number /*uint*/ = this._newBlockBytes.readUnsignedShort(); + var meshAdresses:Array /*uint*/ = new Array() /*uint*/; + for (var i:number /*int*/ = 0; i < targetMeshLength; i++) + meshAdresses.push(this._newBlockBytes.readUnsignedInt()); + + var activeState:number /*uint*/ = this._newBlockBytes.readUnsignedShort(); + var autoplay:boolean = ( this._newBlockBytes.readUnsignedByte() == 1 ); + this.parseUserAttributes(); + this.parseUserAttributes(); + + var returnedArray:Array; + var targetMeshes:Array = new Array(); + + for (i = 0; i < meshAdresses.length; i++) { + returnedArray = this.getAssetByID(meshAdresses[i], [AssetType.MESH]); + if (returnedArray[0]) + targetMeshes.push( returnedArray[1]); + } + returnedArray = this.getAssetByID(animSetBlockAdress, [AssetType.ANIMATION_SET]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the AnimationSet ( " + animSetBlockAdress + " ) for this Animator");; + return + } + targetAnimationSet = returnedArray[1]; + var thisAnimator:AnimatorBase; + if (type == 1) { + + returnedArray = this.getAssetByID(props.get(1, 0), [AssetType.SKELETON]); + if (!returnedArray[0]) { + this._blocks[blockID].addError("Could not find the Skeleton ( " + props.get(1, 0) + " ) for this Animator"); + return + } + thisAnimator = new SkeletonAnimator( targetAnimationSet, returnedArray[1]); + + } else if (type == 2) + thisAnimator = new VertexAnimator( targetAnimationSet); + + this._pFinalizeAsset(thisAnimator, name); + this._blocks[blockID].data = thisAnimator; + for (i = 0; i < targetMeshes.length; i++) { + if (type == 1) + targetMeshes[i].animator = ( thisAnimator); + if (type == 2) + targetMeshes[i].animator = ( thisAnimator); + + } + if (this._debug) + console.log("Parsed a Animator: Name = " + name); + } + + // this functions reads and creates a EffectMethod + private parseSharedMethodList(blockID:number):EffectMethodBase + { + + var methodType:number = this._newBlockBytes.readUnsignedShort(); + var effectMethodReturn:EffectMethodBase; + + var props:AWDProperties = this.parseProperties({1:AWDParser.BADDR, 2:AWDParser.BADDR, 3:AWDParser.BADDR, 101:this._propsNrType, 102:this._propsNrType, 103:this._propsNrType, 104:this._propsNrType, 105:this._propsNrType, 106:this._propsNrType, 107:this._propsNrType, 201:AWDParser.UINT32, 202:AWDParser.UINT32, 301:AWDParser.UINT16, 302:AWDParser.UINT16, 401:AWDParser.UINT8, 402:AWDParser.UINT8, 601:AWDParser.COLOR, 602:AWDParser.COLOR, 701:AWDParser.BOOL, 702:AWDParser.BOOL}); + var targetID:number; + var returnedArray:Array; + + switch (methodType) { + // Effect Methods + case 401: //ColorMatrix + effectMethodReturn = new EffectColorMatrixMethod(props.get(101, new Array(0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1))); + break; + case 402: //ColorTransform + effectMethodReturn = new EffectColorTransformMethod(); + var offCol:number /*uint*/ = props.get(601, 0x00000000); + ( effectMethodReturn).colorTransform = new ColorTransform(props.get(102, 1), props.get(103, 1), props.get(104, 1), props.get(101, 1), ((offCol >> 16) & 0xFF), ((offCol >> 8) & 0xFF), (offCol & 0xFF), ((offCol >> 24) & 0xFF)); + break; + case 403: //EnvMap + + targetID = props.get(1, 0); + console.log('ENV MAP', targetID); + + + returnedArray = this.getAssetByID(targetID, [ AssetType.TEXTURE ], "CubeTexture"); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the EnvMap (ID = " + targetID + " ) for this EnvMapMethod"); + effectMethodReturn = new EffectEnvMapMethod( returnedArray[1], props.get(101, 1)); + targetID = props.get(2, 0); + if (targetID > 0) { + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the Mask-texture (ID = " + targetID + " ) for this EnvMapMethod"); + + // Todo: test mask with EnvMapMethod + //( effectMethodReturn).mask = returnedArray[1]; + } + break; + case 404: //LightMapMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the LightMap (ID = " + targetID + " ) for this LightMapMethod"); + effectMethodReturn = new EffectLightMapMethod(returnedArray[1], this.blendModeDic[props.get(401, 10)]); //usesecondaryUV not set + break; + // case 405: //ProjectiveTextureMethod + // targetID = props.get(1, 0); + // returnedArray = getAssetByID(targetID, [AssetType.TEXTURE_PROJECTOR]); + // if (!returnedArray[0]) + // _blocks[blockID].addError("Could not find the TextureProjector (ID = " + targetID + " ) for this ProjectiveTextureMethod"); + // effectMethodReturn = new ProjectiveTextureMethod(returnedArray[1], blendModeDic[props.get(401, 10)]); + // break; + case 406: //RimLightMethod + effectMethodReturn = new EffectRimLightMethod(props.get(601, 0xffffff), props.get(101, 0.4), props.get(101, 2)); //blendMode + break; + case 407: //AlphaMaskMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE]); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the Alpha-texture (ID = " + targetID + " ) for this AlphaMaskMethod"); + effectMethodReturn = new EffectAlphaMaskMethod(returnedArray[1], props.get(701, false)); + break; + // case 408: //RefractionEnvMapMethod + // targetID = props.get(1, 0); + // returnedArray = getAssetByID(targetID, [AssetType.TEXTURE], "CubeTexture"); + // if (!returnedArray[0]) + // _blocks[blockID].addError("Could not find the EnvMap (ID = " + targetID + " ) for this RefractionEnvMapMethod"); + // effectMethodReturn = new RefractionEnvMapMethod(returnedArray[1], props.get(101, 0.1), props.get(102, 0.01), props.get(103, 0.01), props.get(104, 0.01)); + // RefractionEnvMapMethod(effectMethodReturn).alpha = props.get(104, 1); + // break; + // case 409: //OutlineMethod + // effectMethodReturn = new OutlineMethod(props.get(601, 0x00000000), props.get(101, 1), props.get(701, true), props.get(702, false)); + // break; + case 410: //FresnelEnvMapMethod + targetID = props.get(1, 0); + returnedArray = this.getAssetByID(targetID, [AssetType.TEXTURE], "CubeTexture"); + if (!returnedArray[0]) + this._blocks[blockID].addError("Could not find the EnvMap (ID = " + targetID + " ) for this FresnelEnvMapMethod"); + effectMethodReturn = new EffectFresnelEnvMapMethod(returnedArray[1], props.get(101, 1)); + break; + case 411: //FogMethod + effectMethodReturn = new EffectFogMethod(props.get(101, 0), props.get(102, 1000), props.get(601, 0x808080)); + break; + + } + this.parseUserAttributes(); + return effectMethodReturn; + + } + + private parseUserAttributes():Object + { + var attributes:Object; + var list_len:number; + var attibuteCnt:number; + + list_len = this._newBlockBytes.readUnsignedInt(); + + if (list_len > 0) { + + var list_end:number; + + attributes = {}; + + list_end = this._newBlockBytes.position + list_len; + + while (this._newBlockBytes.position < list_end) { + var ns_id:number; + var attr_key:string; + var attr_type:number; + var attr_len:number; + var attr_val:any; + + // TODO: Properly tend to namespaces in attributes + ns_id = this._newBlockBytes.readUnsignedByte(); + attr_key = this.parseVarStr(); + attr_type = this._newBlockBytes.readUnsignedByte(); + attr_len = this._newBlockBytes.readUnsignedInt(); + + if ((this._newBlockBytes.position + attr_len) > list_end) { + console.log(" Error in reading attribute # " + attibuteCnt + " = skipped to end of attribute-list"); + this._newBlockBytes.position = list_end; + return attributes; + } + + switch (attr_type) { + case AWDParser.AWDSTRING: + attr_val = this._newBlockBytes.readUTFBytes(attr_len); + break; + case AWDParser.INT8: + attr_val = this._newBlockBytes.readByte(); + break; + case AWDParser.INT16: + attr_val = this._newBlockBytes.readShort(); + break; + case AWDParser.INT32: + attr_val = this._newBlockBytes.readInt(); + break; + case AWDParser.BOOL: + case AWDParser.UINT8: + attr_val = this._newBlockBytes.readUnsignedByte(); + break; + case AWDParser.UINT16: + attr_val = this._newBlockBytes.readUnsignedShort(); + break; + case AWDParser.UINT32: + case AWDParser.BADDR: + attr_val = this._newBlockBytes.readUnsignedInt(); + break; + case AWDParser.FLOAT32: + attr_val = this._newBlockBytes.readFloat(); + break; + case AWDParser.FLOAT64: + attr_val = this._newBlockBytes.readDouble(); + break; + default: + attr_val = 'unimplemented attribute type ' + attr_type; + this._newBlockBytes.position += attr_len; + break; + } + + if (this._debug) { + console.log("attribute = name: " + attr_key + " / value = " + attr_val); + } + + attributes[attr_key] = attr_val; + attibuteCnt += 1; + } + } + + return attributes; + } + + private parseProperties(expected:Object):AWDProperties + { + var list_end:number; + var list_len:number; + var propertyCnt:number = 0; + var props:AWDProperties = new AWDProperties(); + + list_len = this._newBlockBytes.readUnsignedInt(); + list_end = this._newBlockBytes.position + list_len; + + if (expected) { + + while (this._newBlockBytes.position < list_end) { + var len:number; + var key:number; + var type:number; + + key = this._newBlockBytes.readUnsignedShort(); + len = this._newBlockBytes.readUnsignedInt(); + + if ((this._newBlockBytes.position + len) > list_end) { + console.log(" Error in reading property # " + propertyCnt + " = skipped to end of propertie-list"); + this._newBlockBytes.position = list_end; + return props; + } + + if (expected.hasOwnProperty(key.toString())) { + type = expected[key]; + props.set(key, this.parseAttrValue(type, len)); + } else { + this._newBlockBytes.position += len; + } + + propertyCnt += 1; + + } + } else { + this._newBlockBytes.position = list_end; + } + + return props; + + } + + private parseAttrValue(type:number, len:number):any + { + var elem_len:number; + var read_func:Function; + + switch (type) { + + case AWDParser.BOOL: + case AWDParser.INT8: + elem_len = 1; + read_func = this._newBlockBytes.readByte; + break; + + case AWDParser.INT16: + elem_len = 2; + read_func = this._newBlockBytes.readShort; + break; + + case AWDParser.INT32: + elem_len = 4; + read_func = this._newBlockBytes.readInt; + break; + + case AWDParser.UINT8: + elem_len = 1; + read_func = this._newBlockBytes.readUnsignedByte; + break; + + case AWDParser.UINT16: + elem_len = 2; + read_func = this._newBlockBytes.readUnsignedShort; + break; + + case AWDParser.UINT32: + case AWDParser.COLOR: + case AWDParser.BADDR: + elem_len = 4; + read_func = this._newBlockBytes.readUnsignedInt; + break; + + case AWDParser.FLOAT32: + elem_len = 4; + read_func = this._newBlockBytes.readFloat; + break; + + case AWDParser.FLOAT64: + elem_len = 8; + read_func = this._newBlockBytes.readDouble; + break; + + case AWDParser.AWDSTRING: + return this._newBlockBytes.readUTFBytes(len); + + case AWDParser.VECTOR2x1: + case AWDParser.VECTOR3x1: + case AWDParser.VECTOR4x1: + case AWDParser.MTX3x2: + case AWDParser.MTX3x3: + case AWDParser.MTX4x3: + case AWDParser.MTX4x4: + elem_len = 8; + read_func = this._newBlockBytes.readDouble; + break; + + } + + if (elem_len < len) { + var list:Array = []; + var num_read:number = 0; + var num_elems:number = len/elem_len; + + while (num_read < num_elems) { + list.push(read_func.apply(this._newBlockBytes)); // list.push(read_func()); + num_read++; + } + + return list; + } else { + + var val:any = read_func.apply(this._newBlockBytes);//read_func(); + return val; + } + } + + private parseHeader():void + { + var flags:number; + var body_len:number; + + this._byteData.position = 3; // Skip magic string and parse version + + this._version[0] = this._byteData.readUnsignedByte(); + this._version[1] = this._byteData.readUnsignedByte(); + + flags = this._byteData.readUnsignedShort(); // Parse bit flags + + this._streaming = BitFlags.test(flags, BitFlags.FLAG1); + + if ((this._version[0] == 2) && (this._version[1] == 1)) { + this._accuracyMatrix = BitFlags.test(flags, BitFlags.FLAG2); + this._accuracyGeo = BitFlags.test(flags, BitFlags.FLAG3); + this._accuracyProps = BitFlags.test(flags, BitFlags.FLAG4); + } + + // if we set _accuracyOnBlocks, the precision-values are read from each block-header. + + // set storagePrecision types + this._geoNrType = AWDParser.FLOAT32; + + if (this._accuracyGeo) { + this._geoNrType = AWDParser.FLOAT64; + } + + this._matrixNrType = AWDParser.FLOAT32; + + if (this._accuracyMatrix) { + this._matrixNrType = AWDParser.FLOAT64; + } + + this._propsNrType = AWDParser.FLOAT32; + + if (this._accuracyProps) { + this._propsNrType = AWDParser.FLOAT64; + } + + this._compression = this._byteData.readUnsignedByte(); // compression + + if (this._debug) { + console.log("Import AWDFile of version = " + this._version[0] + " - " + this._version[1]); + console.log("Global Settings = Compression = " + this._compression + " | Streaming = " + this._streaming + " | Matrix-Precision = " + this._accuracyMatrix + " | Geometry-Precision = " + this._accuracyGeo + " | Properties-Precision = " + this._accuracyProps); + } + + // Check file integrity + body_len = this._byteData.readUnsignedInt(); + if (!this._streaming && body_len != this._byteData.getBytesAvailable()) { + this._pDieWithError('AWD2 body length does not match header integrity field'); + } + + } + // Helper - functions + private getUVForVertexAnimation(meshID:number /*uint*/):Array> + { + if (this._blocks[meshID].data instanceof Mesh) + meshID = this._blocks[meshID].geoID; + if (this._blocks[meshID].uvsForVertexAnimation) + return this._blocks[meshID].uvsForVertexAnimation; + var geometry:Geometry = ( this._blocks[meshID].data); + var geoCnt:number /*int*/ = 0; + var ud:Array; + var uStride:number /*uint*/; + var uOffs:number /*uint*/; + var numPoints:number /*uint*/; + var i:number /*int*/; + var newUvs:Array; + var sub_geom:TriangleSubGeometry; + this._blocks[meshID].uvsForVertexAnimation = new Array>(); + while (geoCnt < geometry.subGeometries.length) { + newUvs = new Array(); + sub_geom = geometry.subGeometries[geoCnt]; + numPoints = sub_geom.numVertices; + ud = sub_geom.uvs; + uStride = sub_geom.getStride(TriangleSubGeometry.UV_DATA); + uOffs = sub_geom.getOffset(TriangleSubGeometry.UV_DATA); + for (i = 0; i < numPoints; i++) { + newUvs.push(ud[uOffs + i*uStride + 0]); + newUvs.push(ud[uOffs + i*uStride + 1]); + } + this._blocks[meshID].uvsForVertexAnimation.push(newUvs); + geoCnt++; + } + return this._blocks[meshID].uvsForVertexAnimation; + } + + private parseVarStr():string + { + + var len:number = this._newBlockBytes.readUnsignedShort(); + return this._newBlockBytes.readUTFBytes(len); + } + + private getAssetByID(assetID:number, assetTypesToGet:Array, extraTypeInfo:string = "SingleTexture"):Array + { + var returnArray:Array = new Array(); + var typeCnt:number = 0; + if (assetID > 0) { + if (this._blocks[assetID]) { + if (this._blocks[assetID].data) { + while (typeCnt < assetTypesToGet.length) { + + var iasset:IAsset = this._blocks[assetID].data; + + if (iasset.assetType == assetTypesToGet[typeCnt]) { + //if the right assetType was found + if ((assetTypesToGet[typeCnt] == AssetType.TEXTURE) && (extraTypeInfo == "CubeTexture")) { + if (this._blocks[assetID].data instanceof ImageCubeTexture) { + returnArray.push(true); + returnArray.push(this._blocks[assetID].data); + return returnArray; + } + } + if ((assetTypesToGet[typeCnt] == AssetType.TEXTURE) && (extraTypeInfo == "SingleTexture")) { + if (this._blocks[assetID].data instanceof ImageTexture) { + returnArray.push(true); + returnArray.push(this._blocks[assetID].data); + return returnArray; + } + } else { + returnArray.push(true); + returnArray.push(this._blocks[assetID].data); + return returnArray; + + } + } + //if ((assetTypesToGet[typeCnt] == AssetType.GEOMETRY) && (IAsset(_blocks[assetID].data).assetType == AssetType.MESH)) { + if ((assetTypesToGet[typeCnt] == AssetType.GEOMETRY) && (iasset.assetType == AssetType.MESH)) { + + var mesh:Mesh = this._blocks[assetID].data + + returnArray.push(true); + returnArray.push(mesh.geometry); + return returnArray; + + } + + typeCnt++; + } + } + } + } + // if the has not returned anything yet, the asset is not found, or the found asset is not the right type. + returnArray.push(false); + returnArray.push(this.getDefaultAsset(assetTypesToGet[0], extraTypeInfo)); + return returnArray; + } + + private getDefaultAsset(assetType:string, extraTypeInfo:string):IAsset + { + switch (true) { + case (assetType == AssetType.TEXTURE): + if (extraTypeInfo == "CubeTexture") + return this.getDefaultCubeTexture(); + if (extraTypeInfo == "SingleTexture") + return this.getDefaultTexture(); + break; + case (assetType == AssetType.MATERIAL): + return this.getDefaultMaterial() + break; + default: + break; + } + + return null; + } + + private getDefaultMaterial():IAsset + { + if (!this._defaultBitmapMaterial) + this._defaultBitmapMaterial = DefaultMaterialManager.getDefaultMaterial(); + + return this._defaultBitmapMaterial; + } + + private getDefaultTexture():IAsset + { + if (!this._defaultTexture) + this._defaultTexture = DefaultMaterialManager.getDefaultTexture(); + + return this._defaultTexture; + + } + + private getDefaultCubeTexture():IAsset + { + if (!this._defaultCubeTexture) { + var defaultBitmap:BitmapData = DefaultMaterialManager.createCheckeredBitmapData(); + + this._defaultCubeTexture = new BitmapCubeTexture(defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap, defaultBitmap); + this._defaultCubeTexture.name = "defaultCubeTexture"; + } + + return this._defaultCubeTexture; + } + + private readNumber(precision:boolean = false):number + { + if (precision) + return this._newBlockBytes.readDouble(); + return this._newBlockBytes.readFloat(); + + } + + private parseMatrix3D():Matrix3D + { + return new Matrix3D(this.parseMatrix43RawData()); + } + + private parseMatrix32RawData():Array + { + var i:number; + var mtx_raw:Array = new Array(6); + for (i = 0; i < 6; i++) { + mtx_raw[i] = this._newBlockBytes.readFloat(); + } + + return mtx_raw; + } + + private parseMatrix43RawData():Array + { + var mtx_raw:Array = new Array(16); + + mtx_raw[0] = this.readNumber(this._accuracyMatrix); + mtx_raw[1] = this.readNumber(this._accuracyMatrix); + mtx_raw[2] = this.readNumber(this._accuracyMatrix); + mtx_raw[3] = 0.0; + mtx_raw[4] = this.readNumber(this._accuracyMatrix); + mtx_raw[5] = this.readNumber(this._accuracyMatrix); + mtx_raw[6] = this.readNumber(this._accuracyMatrix); + mtx_raw[7] = 0.0; + mtx_raw[8] = this.readNumber(this._accuracyMatrix); + mtx_raw[9] = this.readNumber(this._accuracyMatrix); + mtx_raw[10] = this.readNumber(this._accuracyMatrix); + mtx_raw[11] = 0.0; + mtx_raw[12] = this.readNumber(this._accuracyMatrix); + mtx_raw[13] = this.readNumber(this._accuracyMatrix); + mtx_raw[14] = this.readNumber(this._accuracyMatrix); + mtx_raw[15] = 1.0; + + //TODO: fix max exporter to remove NaN values in joint 0 inverse bind pose + + if (isNaN(mtx_raw[0])) { + mtx_raw[0] = 1; + mtx_raw[1] = 0; + mtx_raw[2] = 0; + mtx_raw[4] = 0; + mtx_raw[5] = 1; + mtx_raw[6] = 0; + mtx_raw[8] = 0; + mtx_raw[9] = 0; + mtx_raw[10] = 1; + mtx_raw[12] = 0; + mtx_raw[13] = 0; + mtx_raw[14] = 0; + + } + + return mtx_raw; + } + +} + +export = AWDParser; \ No newline at end of file diff --git a/lib/parsers/MD2Parser.js b/lib/parsers/MD2Parser.js new file mode 100755 index 000000000..9671b39df --- /dev/null +++ b/lib/parsers/MD2Parser.js @@ -0,0 +1,390 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +var Geometry = require("awayjs-core/lib/core/base/Geometry"); +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var Mesh = require("awayjs-core/lib/entities/Mesh"); +var ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +var ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +var DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); +var TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +var TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); +var VertexClipNode = require("awayjs-renderergl/lib/animators/nodes/VertexClipNode"); +var VertexAnimationSet = require("awayjs-renderergl/lib/animators/VertexAnimationSet"); +/** + * MD2Parser provides a parser for the MD2 data type. + */ +var MD2Parser = (function (_super) { + __extends(MD2Parser, _super); + /** + * Creates a new MD2Parser object. + * @param textureType The extension of the texture (e.g. jpg/png/...) + * @param ignoreTexturePath If true, the path of the texture is ignored + */ + function MD2Parser(textureType, ignoreTexturePath) { + if (textureType === void 0) { textureType = "jpg"; } + if (ignoreTexturePath === void 0) { ignoreTexturePath = true; } + _super.call(this, URLLoaderDataFormat.ARRAY_BUFFER); + this._clipNodes = new Object(); + // the current subgeom being built + this._animationSet = new VertexAnimationSet(); + this.materialFinal = false; + this.geoCreated = false; + this._textureType = textureType; + this._ignoreTexturePath = ignoreTexturePath; + } + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + MD2Parser.supportsType = function (extension) { + extension = extension.toLowerCase(); + return extension == "md2"; + }; + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + MD2Parser.supportsData = function (data) { + return (ParserUtils.toString(data, 4) == 'IDP2'); + }; + /** + * @inheritDoc + */ + MD2Parser.prototype._iResolveDependency = function (resourceDependency) { + if (resourceDependency.assets.length != 1) + return; + var asset = resourceDependency.assets[0]; + if (asset) { + var material = new TriangleMethodMaterial(asset); + if (this.materialMode >= 2) + material.materialMode = TriangleMaterialMode.MULTI_PASS; + //add to the content property + this._pContent.addChild(this._mesh); + material.name = this._mesh.material.name; + this._mesh.material = material; + this._pFinalizeAsset(material); + this._pFinalizeAsset(this._mesh.geometry); + this._pFinalizeAsset(this._mesh); + } + this.materialFinal = true; + }; + /** + * @inheritDoc + */ + MD2Parser.prototype._iResolveDependencyFailure = function (resourceDependency) { + // apply system default + if (this.materialMode < 2) { + this._mesh.material = DefaultMaterialManager.getDefaultMaterial(); + } + else { + this._mesh.material = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture()); + this._mesh.material.materialMode = TriangleMaterialMode.MULTI_PASS; + } + //add to the content property + this._pContent.addChild(this._mesh); + this._pFinalizeAsset(this._mesh.geometry); + this._pFinalizeAsset(this._mesh); + this.materialFinal = true; + }; + /** + * @inheritDoc + */ + MD2Parser.prototype._pProceedParsing = function () { + if (!this._startedParsing) { + this._byteData = this._pGetByteData(); + this._startedParsing = true; + // Reset bytearray read position (which may have been + // moved forward by the supportsData() function.) + this._byteData.position = 0; + } + while (this._pHasTime()) { + if (!this._parsedHeader) { + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._byteData.endian = Endian.LITTLE_ENDIAN; + // TODO: Create a mesh only when encountered (if it makes sense + // for this file format) and return it using this._pFinalizeAsset() + this._geometry = new Geometry(); + this._mesh = new Mesh(this._geometry, null); + if (this.materialMode < 2) { + this._mesh.material = DefaultMaterialManager.getDefaultMaterial(); + } + else { + this._mesh.material = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture()); + this._mesh.material.materialMode = TriangleMaterialMode.MULTI_PASS; + } + //_geometry.animation = new VertexAnimation(2, VertexAnimationMode.ABSOLUTE); + //_animator = new VertexAnimator(VertexAnimationState(_mesh.animationState)); + // Parse header and decompress body + this.parseHeader(); + this.parseMaterialNames(); + } + else if (!this._parsedUV) { + this.parseUV(); + } + else if (!this._parsedFaces) { + this.parseFaces(); + } + else if (!this._parsedFrames) { + this.parseFrames(); + } + else if ((this.geoCreated) && (this.materialFinal)) { + return ParserBase.PARSING_DONE; + } + else if (!this.geoCreated) { + this.geoCreated = true; + //create default subgeometry + this._geometry.addSubGeometry(this._firstSubGeom.clone()); + // Force name to be chosen by this._pFinalizeAsset() + this._mesh.name = ""; + if (this.materialFinal) { + //add to the content property + this._pContent.addChild(this._mesh); + this._pFinalizeAsset(this._mesh.geometry); + this._pFinalizeAsset(this._mesh); + } + this._pPauseAndRetrieveDependencies(); + } + } + return ParserBase.MORE_TO_PARSE; + }; + MD2Parser.prototype._pStartParsing = function (frameLimit) { + _super.prototype._pStartParsing.call(this, frameLimit); + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + }; + /** + * Reads in all that MD2 Header data that is declared as private variables. + * I know its a lot, and it looks ugly, but only way to do it in Flash + */ + MD2Parser.prototype.parseHeader = function () { + this._ident = this._byteData.readInt(); + this._version = this._byteData.readInt(); + this._skinWidth = this._byteData.readInt(); + this._skinHeight = this._byteData.readInt(); + //skip this._frameSize + this._byteData.readInt(); + this._numSkins = this._byteData.readInt(); + this._numVertices = this._byteData.readInt(); + this._numST = this._byteData.readInt(); + this._numTris = this._byteData.readInt(); + //skip this._numGlCmds + this._byteData.readInt(); + this._numFrames = this._byteData.readInt(); + this._offsetSkins = this._byteData.readInt(); + this._offsetST = this._byteData.readInt(); + this._offsetTris = this._byteData.readInt(); + this._offsetFrames = this._byteData.readInt(); + //skip this._offsetGlCmds + this._byteData.readInt(); + this._offsetEnd = this._byteData.readInt(); + this._parsedHeader = true; + }; + /** + * Parses the file names for the materials. + */ + MD2Parser.prototype.parseMaterialNames = function () { + var url; + var name; + var extIndex /*int*/; + var slashIndex /*int*/; + this._materialNames = new Array(); + this._byteData.position = this._offsetSkins; + var regExp = new RegExp("[^a-zA-Z0-9\\_\/.]", "g"); + for (var i = 0; i < this._numSkins; ++i) { + name = this._byteData.readUTFBytes(64); + name = name.replace(regExp, ""); + extIndex = name.lastIndexOf("."); + if (this._ignoreTexturePath) + slashIndex = name.lastIndexOf("/"); + if (name.toLowerCase().indexOf(".jpg") == -1 && name.toLowerCase().indexOf(".png") == -1) { + name = name.substring(slashIndex + 1, extIndex); + url = name + "." + this._textureType; + } + else { + url = name; + } + this._materialNames[i] = name; + // only support 1 skin TODO: really? + if (this.dependencies.length == 0) + this._pAddDependency(name, new URLRequest(url)); + } + if (this._materialNames.length > 0) + this._mesh.material.name = this._materialNames[0]; + else + this.materialFinal = true; + }; + /** + * Parses the uv data for the mesh. + */ + MD2Parser.prototype.parseUV = function () { + var j = 0; + this._uvs = new Array(this._numST * 2); + this._byteData.position = this._offsetST; + for (var i = 0; i < this._numST; i++) { + this._uvs[j++] = this._byteData.readShort() / this._skinWidth; + this._uvs[j++] = this._byteData.readShort() / this._skinHeight; + } + this._parsedUV = true; + }; + /** + * Parses unique indices for the faces. + */ + MD2Parser.prototype.parseFaces = function () { + var a /*uint*/, b /*uint*/, c /*uint*/, ta /*uint*/, tb /*uint*/, tc /*uint*/; + var i /*uint*/; + this._vertIndices = new Array(); + this._uvIndices = new Array(); + this._indices = new Array(); + this._byteData.position = this._offsetTris; + for (i = 0; i < this._numTris; i++) { + //collect vertex indices + a = this._byteData.readUnsignedShort(); + b = this._byteData.readUnsignedShort(); + c = this._byteData.readUnsignedShort(); + //collect uv indices + ta = this._byteData.readUnsignedShort(); + tb = this._byteData.readUnsignedShort(); + tc = this._byteData.readUnsignedShort(); + this.addIndex(a, ta); + this.addIndex(b, tb); + this.addIndex(c, tc); + } + var len = this._uvIndices.length; + this._finalUV = new Array(len * 2); + for (i = 0; i < len; ++i) { + this._finalUV[i << 1] = this._uvs[this._uvIndices[i] << 1]; + this._finalUV[(i << 1) + 1] = this._uvs[(this._uvIndices[i] << 1) + 1]; + } + this._parsedFaces = true; + }; + /** + * Adds a face index to the list if it doesn't exist yet, based on vertexIndex and uvIndex, and adds the + * corresponding vertex and uv data in the correct location. + * @param vertexIndex The original index in the vertex list. + * @param uvIndex The original index in the uv list. + */ + MD2Parser.prototype.addIndex = function (vertexIndex /*uint*/, uvIndex /*uint*/) { + var index = this.findIndex(vertexIndex, uvIndex); + if (index == -1) { + this._indices.push(this._vertIndices.length); + this._vertIndices.push(vertexIndex); + this._uvIndices.push(uvIndex); + } + else + this._indices.push(index); + }; + /** + * Finds the final index corresponding to the original MD2's vertex and uv indices. Returns -1 if it wasn't added yet. + * @param vertexIndex The original index in the vertex list. + * @param uvIndex The original index in the uv list. + * @return The index of the final mesh corresponding to the original vertex and uv index. -1 if it doesn't exist yet. + */ + MD2Parser.prototype.findIndex = function (vertexIndex /*uint*/, uvIndex /*uint*/) { + var len = this._vertIndices.length; + for (var i = 0; i < len; ++i) { + if (this._vertIndices[i] == vertexIndex && this._uvIndices[i] == uvIndex) + return i; + } + return -1; + }; + /** + * Parses all the frame geometries. + */ + MD2Parser.prototype.parseFrames = function () { + var sx, sy, sz; + var tx, ty, tz; + var geometry; + var subGeom; + var vertLen = this._vertIndices.length; + var fvertices; + var tvertices; + var i /*uint*/, j /*int*/, k /*uint*/; + //var ch : number /*uint*/; + var name = ""; + var prevClip = null; + this._byteData.position = this._offsetFrames; + for (i = 0; i < this._numFrames; i++) { + tvertices = new Array(); + fvertices = new Array(vertLen * 3); + sx = this._byteData.readFloat(); + sy = this._byteData.readFloat(); + sz = this._byteData.readFloat(); + tx = this._byteData.readFloat(); + ty = this._byteData.readFloat(); + tz = this._byteData.readFloat(); + name = this.readFrameName(); + for (j = 0; j < this._numVertices; j++, this._byteData.position++) + tvertices.push(sx * this._byteData.readUnsignedByte() + tx, sy * this._byteData.readUnsignedByte() + ty, sz * this._byteData.readUnsignedByte() + tz); + k = 0; + for (j = 0; j < vertLen; j++) { + fvertices[k++] = tvertices[this._vertIndices[j] * 3]; + fvertices[k++] = tvertices[this._vertIndices[j] * 3 + 2]; + fvertices[k++] = tvertices[this._vertIndices[j] * 3 + 1]; + } + subGeom = new TriangleSubGeometry(true); + if (this._firstSubGeom == null) + this._firstSubGeom = subGeom; + geometry = new Geometry(); + geometry.addSubGeometry(subGeom); + subGeom.updateIndices(this._indices); + subGeom.updatePositions(fvertices); + subGeom.updateUVs(this._finalUV); + subGeom.vertexNormals; + subGeom.vertexTangents; + subGeom.autoDeriveNormals = false; + subGeom.autoDeriveTangents = false; + var clip = this._clipNodes[name]; + if (!clip) { + // If another sequence was parsed before this one, starting + // a new state means the previous one is complete and can + // hence be finalized. + if (prevClip) { + this._pFinalizeAsset(prevClip); + this._animationSet.addAnimation(prevClip); + } + clip = new VertexClipNode(); + clip.name = name; + clip.stitchFinalFrame = true; + this._clipNodes[name] = clip; + prevClip = clip; + } + clip.addFrame(geometry, 1000 / MD2Parser.FPS); + } + // Finalize the last state + if (prevClip) { + this._pFinalizeAsset(prevClip); + this._animationSet.addAnimation(prevClip); + } + // Force this._pFinalizeAsset() to decide name + this._pFinalizeAsset(this._animationSet); + this._parsedFrames = true; + }; + MD2Parser.prototype.readFrameName = function () { + var name = ""; + var k = 0; + for (var j = 0; j < 16; j++) { + var ch = this._byteData.readUnsignedByte(); + if (Math.floor(ch) > 0x39 && Math.floor(ch) <= 0x7A && k == 0) + name += String.fromCharCode(ch); + if (Math.floor(ch) >= 0x30 && Math.floor(ch) <= 0x39) + k++; + } + return name; + }; + MD2Parser.FPS = 6; + return MD2Parser; +})(ParserBase); +module.exports = MD2Parser; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/md2parser.ts"],"names":["MD2Parser","MD2Parser.constructor","MD2Parser.supportsType","MD2Parser.supportsData","MD2Parser._iResolveDependency","MD2Parser._iResolveDependencyFailure","MD2Parser._pProceedParsing","MD2Parser._pStartParsing","MD2Parser.parseHeader","MD2Parser.parseMaterialNames","MD2Parser.parseUV","MD2Parser.parseFaces","MD2Parser.addIndex","MD2Parser.findIndex","MD2Parser.parseFrames","MD2Parser.readFrameName"],"mappings":";;;;;;AAAA,IAAO,sBAAsB,WAAa,mDAAmD,CAAC,CAAC;AAG/F,IAAO,QAAQ,WAAiB,oCAAoC,CAAC,CAAC;AACtE,IAAO,mBAAmB,WAAc,+CAA+C,CAAC,CAAC;AAEzF,IAAO,mBAAmB,WAAc,8CAA8C,CAAC,CAAC;AACxF,IAAO,UAAU,WAAgB,qCAAqC,CAAC,CAAC;AAExE,IAAO,IAAI,WAAkB,+BAA+B,CAAC,CAAC;AAC9D,IAAO,UAAU,WAAgB,oCAAoC,CAAC,CAAC;AACvE,IAAO,WAAW,WAAgB,qCAAqC,CAAC,CAAC;AAKzE,IAAO,sBAAsB,WAAa,2DAA2D,CAAC,CAAC;AACvG,IAAO,sBAAsB,WAAa,qDAAqD,CAAC,CAAC;AACjG,IAAO,oBAAoB,WAAc,mDAAmD,CAAC,CAAC;AAE9F,IAAO,cAAc,WAAe,sDAAsD,CAAC,CAAC;AAC5F,IAAO,kBAAkB,WAAc,oDAAoD,CAAC,CAAC;AAE7F,AAGA;;GADG;IACG,SAAS;IAASA,UAAlBA,SAASA,UAAmBA;IAiDjCA;;;;OAIGA;IACHA,SAtDKA,SAASA,CAsDFA,WAA0BA,EAAEA,iBAAgCA;QAA5DC,2BAA0BA,GAA1BA,mBAA0BA;QAAEA,iCAAgCA,GAAhCA,wBAAgCA;QAEvEA,kBAAMA,mBAAmBA,CAACA,YAAYA,CAACA,CAACA;QApDjCA,eAAUA,GAAUA,IAAIA,MAAMA,EAAEA,CAACA;QA8BzCA,kCAAkCA;QAC1BA,kBAAaA,GAAsBA,IAAIA,kBAAkBA,EAAEA,CAACA;QAW5DA,kBAAaA,GAAWA,KAAKA,CAACA;QAC9BA,eAAUA,GAAWA,KAAKA,CAACA;QAUlCA,IAAIA,CAACA,YAAYA,GAAGA,WAAWA,CAACA;QAChCA,IAAIA,CAACA,kBAAkBA,GAAGA,iBAAiBA,CAACA;IAC7CA,CAACA;IAEDD;;;;OAIGA;IACWA,sBAAYA,GAA1BA,UAA2BA,SAAgBA;QAE1CE,SAASA,GAAGA,SAASA,CAACA,WAAWA,EAAEA,CAACA;QACpCA,MAAMA,CAACA,SAASA,IAAIA,KAAKA,CAACA;IAC3BA,CAACA;IAEDF;;;;OAIGA;IACWA,sBAAYA,GAA1BA,UAA2BA,IAAQA;QAElCG,MAAMA,CAACA,CAACA,WAAWA,CAACA,QAAQA,CAACA,IAAIA,EAAEA,CAACA,CAACA,IAAIA,MAAMA,CAACA,CAACA;IAClDA,CAACA;IAEDH;;OAEGA;IACIA,uCAAmBA,GAA1BA,UAA2BA,kBAAqCA;QAE/DI,EAAEA,CAACA,CAACA,kBAAkBA,CAACA,MAAMA,CAACA,MAAMA,IAAIA,CAACA,CAACA;YACzCA,MAAMA,CAACA;QAERA,IAAIA,KAAKA,GAAiCA,kBAAkBA,CAACA,MAAMA,CAACA,CAACA,CAACA,CAACA;QAEvEA,EAAEA,CAACA,CAACA,KAAKA,CAACA,CAACA,CAACA;YACXA,IAAIA,QAAQA,GAA0BA,IAAIA,sBAAsBA,CAACA,KAAKA,CAACA,CAACA;YAExEA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,IAAIA,CAACA,CAACA;gBAC1BA,QAAQA,CAACA,YAAYA,GAAGA,oBAAoBA,CAACA,UAAUA,CAACA;YAEzDA,AACAA,6BAD6BA;YACHA,IAAIA,CAACA,SAAUA,CAACA,QAAQA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;YAE/DA,QAAQA,CAACA,IAAIA,GAAGA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,IAAIA,CAACA;YACzCA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,GAAGA,QAAQA,CAACA;YAC/BA,IAAIA,CAACA,eAAeA,CAACA,QAAQA,CAACA,CAACA;YAC/BA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,CAACA;YAC1CA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;QAClCA,CAACA;QACDA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,CAACA;IAC3BA,CAACA;IAEDJ;;OAEGA;IACIA,8CAA0BA,GAAjCA,UAAkCA,kBAAqCA;QAEtEK,AACAA,uBADuBA;QACvBA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,GAAGA,CAACA,CAACA,CAACA,CAACA;YAC3BA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,GAAGA,sBAAsBA,CAACA,kBAAkBA,EAAEA,CAACA;QACnEA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,GAAGA,IAAIA,sBAAsBA,CAACA,sBAAsBA,CAACA,iBAAiBA,EAAEA,CAACA,CAACA;YACnEA,IAAIA,CAACA,KAAKA,CAACA,QAASA,CAACA,YAAYA,GAAGA,oBAAoBA,CAACA,UAAUA,CAACA;QAC/FA,CAACA;QAEDA,AACAA,6BAD6BA;QACHA,IAAIA,CAACA,SAAUA,CAACA,QAAQA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;QAE/DA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,CAACA;QAC1CA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;QACjCA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,CAACA;IAE3BA,CAACA;IAEDL;;OAEGA;IACIA,oCAAgBA,GAAvBA;QAECM,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,eAAeA,CAACA,CAACA,CAACA;YAC3BA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,CAACA,aAAaA,EAAEA,CAACA;YACtCA,IAAIA,CAACA,eAAeA,GAAGA,IAAIA,CAACA;YAE5BA,AAEAA,qDAFqDA;YACrDA,iDAAiDA;YACjDA,IAAIA,CAACA,SAASA,CAACA,QAAQA,GAAGA,CAACA,CAACA;QAC7BA,CAACA;QAEDA,OAAOA,IAAIA,CAACA,SAASA,EAAEA,EAAEA,CAACA;YACzBA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA;gBACzBA,AAOAA,8EAP8EA;gBAC9EA,yEAAyEA;gBACzEA,8EAA8EA;gBAC9EA,+CAA+CA;gBAE/CA,+DAA+DA;gBAC/DA,mEAAmEA;gBACnEA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,QAAQA,EAAEA,CAACA;gBAChCA,IAAIA,CAACA,KAAKA,GAAGA,IAAIA,IAAIA,CAACA,IAAIA,CAACA,SAASA,EAAEA,IAAIA,CAACA,CAACA;gBAC5CA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,GAAGA,CAACA,CAACA,CAACA,CAACA;oBAC3BA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,GAAGA,sBAAsBA,CAACA,kBAAkBA,EAAEA,CAACA;gBACnEA,CAACA;gBAACA,IAAIA,CAACA,CAACA;oBACPA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,GAAGA,IAAIA,sBAAsBA,CAACA,sBAAsBA,CAACA,iBAAiBA,EAAEA,CAACA,CAACA;oBACnEA,IAAIA,CAACA,KAAKA,CAACA,QAASA,CAACA,YAAYA,GAAGA,oBAAoBA,CAACA,UAAUA,CAACA;gBAC/FA,CAACA;gBAEDA,AAIAA,6EAJ6EA;gBAC7EA,6EAA6EA;gBAE7EA,mCAAmCA;gBACnCA,IAAIA,CAACA,WAAWA,EAAEA,CAACA;gBACnBA,IAAIA,CAACA,kBAAkBA,EAAEA,CAACA;YAC3BA,CAACA;YAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,SAASA,CAACA,CAACA,CAACA;gBAC5BA,IAAIA,CAACA,OAAOA,EAAEA,CAACA;YAChBA,CAACA;YAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA;gBAC/BA,IAAIA,CAACA,UAAUA,EAAEA,CAACA;YACnBA,CAACA;YAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA;gBAChCA,IAAIA,CAACA,WAAWA,EAAEA,CAACA;YACpBA,CAACA;YAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA,CAACA;gBACtDA,MAAMA,CAACA,UAAUA,CAACA,YAAYA,CAACA;YAChCA,CAACA;YAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,UAAUA,CAACA,CAACA,CAACA;gBAC7BA,IAAIA,CAACA,UAAUA,GAAGA,IAAIA,CAACA;gBACvBA,AACAA,4BAD4BA;gBAC5BA,IAAIA,CAACA,SAASA,CAACA,cAAcA,CAACA,IAAIA,CAACA,aAAaA,CAACA,KAAKA,EAAEA,CAACA,CAACA;gBAC1DA,AACAA,oDADoDA;gBACpDA,IAAIA,CAACA,KAAKA,CAACA,IAAIA,GAAGA,EAAEA,CAACA;gBACrBA,EAAEA,CAACA,CAACA,IAAIA,CAACA,aAAaA,CAACA,CAACA,CAACA;oBACxBA,AACAA,6BAD6BA;oBACHA,IAAIA,CAACA,SAAUA,CAACA,QAAQA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;oBAE/DA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,CAACA;oBAC1CA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;gBAClCA,CAACA;gBAEDA,IAAIA,CAACA,8BAA8BA,EAAEA,CAACA;YACvCA,CAACA;QACFA,CAACA;QAEDA,MAAMA,CAACA,UAAUA,CAACA,aAAaA,CAACA;IACjCA,CAACA;IAEMN,kCAAcA,GAArBA,UAAsBA,UAAiBA;QAEtCO,gBAAKA,CAACA,cAAcA,YAACA,UAAUA,CAACA,CAACA;QAEjCA,AACAA,qCADqCA;QACrCA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,sBAAsBA,EAAEA,CAACA;IAC/CA,CAACA;IAEDP;;;OAGGA;IACKA,+BAAWA,GAAnBA;QAECQ,IAAIA,CAACA,MAAMA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QACvCA,IAAIA,CAACA,QAAQA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QACzCA,IAAIA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC3CA,IAAIA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC5CA,AACAA,sBADsBA;QACtBA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QACzBA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC1CA,IAAIA,CAACA,YAAYA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC7CA,IAAIA,CAACA,MAAMA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QACvCA,IAAIA,CAACA,QAAQA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QACzCA,AACAA,sBADsBA;QACtBA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QACzBA,IAAIA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC3CA,IAAIA,CAACA,YAAYA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC7CA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC1CA,IAAIA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC5CA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAC9CA,AACAA,yBADyBA;QACzBA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QACzBA,IAAIA,CAACA,UAAUA,GAAGA,IAAIA,CAACA,SAASA,CAACA,OAAOA,EAAEA,CAACA;QAE3CA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,CAACA;IAC3BA,CAACA;IAEDR;;OAEGA;IACKA,sCAAkBA,GAA1BA;QAECS,IAAIA,GAAUA,CAACA;QACfA,IAAIA,IAAWA,CAACA;QAChBA,IAAIA,QAAQA,CAAQA,OAADA,AAAQA,CAACA;QAC5BA,IAAIA,UAAUA,CAAQA,OAADA,AAAQA,CAACA;QAC9BA,IAAIA,CAACA,cAAcA,GAAGA,IAAIA,KAAKA,EAAUA,CAACA;QAC1CA,IAAIA,CAACA,SAASA,CAACA,QAAQA,GAAGA,IAAIA,CAACA,YAAYA,CAACA;QAE5CA,IAAIA,MAAMA,GAAUA,IAAIA,MAAMA,CAACA,oBAAoBA,EAAEA,GAAGA,CAACA,CAACA;QAC1DA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,SAASA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YACzDA,IAAIA,GAAGA,IAAIA,CAACA,SAASA,CAACA,YAAYA,CAACA,EAAEA,CAACA,CAACA;YACvCA,IAAIA,GAAGA,IAAIA,CAACA,OAAOA,CAACA,MAAMA,EAAEA,EAAEA,CAACA,CAACA;YAChCA,QAAQA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,GAAGA,CAACA,CAACA;YACjCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,kBAAkBA,CAACA;gBAC3BA,UAAUA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,GAAGA,CAACA,CAACA;YACpCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,WAAWA,EAAEA,CAACA,OAAOA,CAACA,MAAMA,CAACA,IAAIA,CAACA,CAACA,IAAIA,IAAIA,CAACA,WAAWA,EAAEA,CAACA,OAAOA,CAACA,MAAMA,CAACA,IAAIA,CAACA,CAACA,CAACA,CAACA,CAACA;gBAC1FA,IAAIA,GAAGA,IAAIA,CAACA,SAASA,CAACA,UAAUA,GAAGA,CAACA,EAAEA,QAAQA,CAACA,CAACA;gBAChDA,GAAGA,GAAGA,IAAIA,GAAGA,GAAGA,GAAGA,IAAIA,CAACA,YAAYA,CAACA;YACtCA,CAACA;YAACA,IAAIA,CAACA,CAACA;gBACPA,GAAGA,GAAGA,IAAIA,CAACA;YACZA,CAACA;YAEDA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,GAAGA,IAAIA,CAACA;YAE9BA,AACAA,oCADoCA;YACpCA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA,MAAMA,IAAIA,CAACA,CAACA;gBACjCA,IAAIA,CAACA,eAAeA,CAACA,IAAIA,EAAEA,IAAIA,UAAUA,CAACA,GAAGA,CAACA,CAACA,CAACA;QAClDA,CAACA;QAEDA,EAAEA,CAACA,CAACA,IAAIA,CAACA,cAAcA,CAACA,MAAMA,GAAGA,CAACA,CAACA;YAClCA,IAAIA,CAACA,KAAKA,CAACA,QAAQA,CAACA,IAAIA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA;QAACA,IAAIA;YACvDA,IAAIA,CAACA,aAAaA,GAAGA,IAAIA,CAACA;IAC5BA,CAACA;IAEDT;;OAEGA;IACKA,2BAAOA,GAAfA;QAECU,IAAIA,CAACA,GAAmBA,CAACA,CAACA;QAE1BA,IAAIA,CAACA,IAAIA,GAAGA,IAAIA,KAAKA,CAASA,IAAIA,CAACA,MAAMA,GAACA,CAACA,CAACA,CAACA;QAC7CA,IAAIA,CAACA,SAASA,CAACA,QAAQA,GAAGA,IAAIA,CAACA,SAASA,CAACA;QACzCA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,MAAMA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;YACtDA,IAAIA,CAACA,IAAIA,CAACA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,GAACA,IAAIA,CAACA,UAAUA,CAACA;YAC5DA,IAAIA,CAACA,IAAIA,CAACA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,GAACA,IAAIA,CAACA,WAAWA,CAACA;QAC9DA,CAACA;QAEDA,IAAIA,CAACA,SAASA,GAAGA,IAAIA,CAACA;IACvBA,CAACA;IAEDV;;OAEGA;IACKA,8BAAUA,GAAlBA;QAECW,IAAIA,CAACA,CAAQA,QAADA,AAASA,EAAEA,CAACA,CAAQA,QAADA,AAASA,EAAEA,CAACA,CAAQA,QAADA,AAASA,EAAEA,EAAEA,CAAQA,QAADA,AAASA,EAAEA,EAAEA,CAAQA,QAADA,AAASA,EAAEA,EAAEA,CAAQA,QAADA,AAASA,CAACA;QACxHA,IAAIA,CAACA,CAAQA,QAADA,AAASA,CAACA;QAEtBA,IAAIA,CAACA,YAAYA,GAAGA,IAAIA,KAAKA,EAAUA,CAACA;QACxCA,IAAIA,CAACA,UAAUA,GAAGA,IAAIA,KAAKA,EAAUA,CAACA;QACtCA,IAAIA,CAACA,QAAQA,GAAGA,IAAIA,KAAKA,EAAUA,CAAUA;QAE7CA,IAAIA,CAACA,SAASA,CAACA,QAAQA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;QAE3CA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,QAAQA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;YACpCA,AACAA,wBADwBA;YACxBA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,iBAAiBA,EAAEA,CAACA;YACvCA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,iBAAiBA,EAAEA,CAACA;YACvCA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,iBAAiBA,EAAEA,CAACA;YAEvCA,AACAA,oBADoBA;YACpBA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,iBAAiBA,EAAEA,CAACA;YACxCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,iBAAiBA,EAAEA,CAACA;YACxCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,iBAAiBA,EAAEA,CAACA;YAExCA,IAAIA,CAACA,QAAQA,CAACA,CAACA,EAAEA,EAAEA,CAACA,CAACA;YACrBA,IAAIA,CAACA,QAAQA,CAACA,CAACA,EAAEA,EAAEA,CAACA,CAACA;YACrBA,IAAIA,CAACA,QAAQA,CAACA,CAACA,EAAEA,EAAEA,CAACA,CAACA;QACtBA,CAACA;QAEDA,IAAIA,GAAGA,GAAmBA,IAAIA,CAACA,UAAUA,CAACA,MAAMA,CAACA;QACjDA,IAAIA,CAACA,QAAQA,GAAGA,IAAIA,KAAKA,CAASA,GAAGA,GAACA,CAACA,CAACA,CAACA;QAEzCA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YAC1BA,IAAIA,CAACA,QAAQA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAGA,IAAIA,CAACA,IAAIA,CAACA,IAAIA,CAACA,UAAUA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,CAACA;YAC3DA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAGA,IAAIA,CAACA,IAAIA,CAACA,CAACA,IAAIA,CAACA,UAAUA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA;QACxEA,CAACA;QAEDA,IAAIA,CAACA,YAAYA,GAAGA,IAAIA,CAACA;IAC1BA,CAACA;IAEDX;;;;;OAKGA;IACKA,4BAAQA,GAAhBA,UAAiBA,WAAWA,CAAQA,QAADA,AAASA,EAAEA,OAAOA,CAAQA,QAADA,AAASA;QAEpEY,IAAIA,KAAKA,GAAkBA,IAAIA,CAACA,SAASA,CAACA,WAAWA,EAAEA,OAAOA,CAACA,CAACA;QAEhEA,EAAEA,CAACA,CAACA,KAAKA,IAAIA,CAACA,CAACA,CAACA,CAACA,CAACA;YACjBA,IAAIA,CAACA,QAAQA,CAACA,IAAIA,CAACA,IAAIA,CAACA,YAAYA,CAACA,MAAMA,CAACA,CAACA;YAC7CA,IAAIA,CAACA,YAAYA,CAACA,IAAIA,CAACA,WAAWA,CAACA,CAACA;YACpCA,IAAIA,CAACA,UAAUA,CAACA,IAAIA,CAACA,OAAOA,CAACA,CAACA;QAC/BA,CAACA;QAACA,IAAIA;YACLA,IAAIA,CAACA,QAAQA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;IAC5BA,CAACA;IAEDZ;;;;;OAKGA;IACKA,6BAASA,GAAjBA,UAAkBA,WAAWA,CAAQA,QAADA,AAASA,EAAEA,OAAOA,CAAQA,QAADA,AAASA;QAErEa,IAAIA,GAAGA,GAAmBA,IAAIA,CAACA,YAAYA,CAACA,MAAMA,CAACA;QAEnDA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAmBA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YAC9CA,EAAEA,CAACA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA,IAAIA,WAAWA,IAAIA,IAAIA,CAACA,UAAUA,CAACA,CAACA,CAACA,IAAIA,OAAOA,CAACA;gBACxEA,MAAMA,CAACA,CAACA,CAACA;QACXA,CAACA;QAEDA,MAAMA,CAACA,CAACA,CAACA,CAACA;IACXA,CAACA;IAEDb;;OAEGA;IACKA,+BAAWA,GAAnBA;QAECc,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,EAASA,EAAEA,EAASA,EAAEA,EAASA,CAACA;QACpCA,IAAIA,QAAiBA,CAACA;QACtBA,IAAIA,OAA2BA,CAACA;QAChCA,IAAIA,OAAOA,GAAmBA,IAAIA,CAACA,YAAYA,CAACA,MAAMA,CAACA;QACvDA,IAAIA,SAAuBA,CAACA;QAC5BA,IAAIA,SAAuBA,CAACA;QAC5BA,IAAIA,CAACA,CAAQA,QAADA,AAASA,EAAEA,CAACA,CAAQA,OAADA,AAAQA,EAAEA,CAACA,CAAQA,QAADA,AAASA,CAACA;QAC3DA,AACAA,2BAD2BA;YACvBA,IAAIA,GAAUA,EAAEA,CAACA;QACrBA,IAAIA,QAAQA,GAAkBA,IAAIA,CAACA;QAEnCA,IAAIA,CAACA,SAASA,CAACA,QAAQA,GAAGA,IAAIA,CAACA,aAAaA,CAACA;QAE7CA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;YAEtCA,SAASA,GAAGA,IAAIA,KAAKA,EAAUA,CAACA;YAChCA,SAASA,GAAGA,IAAIA,KAAKA,CAASA,OAAOA,GAACA,CAACA,CAACA,CAACA;YAEzCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,CAACA;YAChCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,CAACA;YAChCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,CAACA;YAEhCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,CAACA;YAChCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,CAACA;YAChCA,EAAEA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,CAACA;YAEhCA,IAAIA,GAAGA,IAAIA,CAACA,aAAaA,EAAEA,CAACA;YAI5BA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,YAAYA,EAAEA,CAACA,EAAEA,EAAEA,IAAIA,CAACA,SAASA,CAACA,QAAQA,EAAEA;gBAChEA,SAASA,CAACA,IAAIA,CAACA,EAAEA,GAACA,IAAIA,CAACA,SAASA,CAACA,gBAAgBA,EAAEA,GAAGA,EAAEA,EAAEA,EAAEA,GAACA,IAAIA,CAACA,SAASA,CAACA,gBAAgBA,EAAEA,GAAGA,EAAEA,EAAEA,EAAEA,GAACA,IAAIA,CAACA,SAASA,CAACA,gBAAgBA,EAAEA,GAAGA,EAAEA,CAACA,CAACA;YAEjJA,CAACA,GAAGA,CAACA,CAACA;YACNA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,OAAOA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBAC9BA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,SAASA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA,GAACA,CAACA,CAACA,CAACA;gBACnDA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,SAASA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA,GAACA,CAACA,GAAGA,CAACA,CAACA,CAACA;gBACvDA,SAASA,CAACA,CAACA,EAAEA,CAACA,GAAGA,SAASA,CAACA,IAAIA,CAACA,YAAYA,CAACA,CAACA,CAACA,GAACA,CAACA,GAAGA,CAACA,CAACA,CAACA;YACxDA,CAACA;YAEDA,OAAOA,GAAGA,IAAIA,mBAAmBA,CAA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","file":"parsers/MD2Parser.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObjectContainer\t\t\t= require(\"awayjs-core/lib/containers/DisplayObjectContainer\");\nimport BitmapData\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/BitmapData\");\nimport DisplayObject\t\t\t\t\t= require(\"awayjs-core/lib/core/base/DisplayObject\");\nimport Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport URLLoaderDataFormat\t\t\t\t= require(\"awayjs-core/lib/core/net/URLLoaderDataFormat\");\nimport URLRequest\t\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport Camera\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Camera\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport ParserBase\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserBase\");\nimport ParserUtils\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserUtils\");\nimport ResourceDependency\t\t\t\t= require(\"awayjs-core/lib/parsers/ResourceDependency\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\nimport ByteArray\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/ByteArray\");\n\nimport DefaultMaterialManager\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/DefaultMaterialManager\");\nimport TriangleMethodMaterial\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\nimport TriangleMaterialMode\t\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMaterialMode\");\n\nimport VertexClipNode\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/VertexClipNode\");\nimport VertexAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/VertexAnimationSet\");\n\n/**\n * MD2Parser provides a parser for the MD2 data type.\n */\nclass MD2Parser extends ParserBase\n{\n\tpublic static FPS:number /*int*/ = 6;\n\n\tprivate _clipNodes:Object = new Object();\n\tprivate _byteData:ByteArray;\n\tprivate _startedParsing:boolean;\n\tprivate _parsedHeader:boolean;\n\tprivate _parsedUV:boolean;\n\tprivate _parsedFaces:boolean;\n\tprivate _parsedFrames:boolean;\n\n\tprivate _ident:number /*uint*/;\n\tprivate _version:number /*uint*/;\n\tprivate _skinWidth:number /*uint*/;\n\tprivate _skinHeight:number /*uint*/;\n\t//private _frameSize : number /*uint*/;\n\tprivate _numSkins:number /*uint*/;\n\tprivate _numVertices:number /*uint*/;\n\tprivate _numST:number /*uint*/;\n\tprivate _numTris:number /*uint*/;\n\t//private _numGlCmds : number /*uint*/;\n\tprivate _numFrames:number /*uint*/;\n\tprivate _offsetSkins:number /*uint*/;\n\tprivate _offsetST:number /*uint*/;\n\tprivate _offsetTris:number /*uint*/;\n\tprivate _offsetFrames:number /*uint*/;\n\t//private _offsetGlCmds : number /*uint*/;\n\tprivate _offsetEnd:number /*uint*/;\n\n\tprivate _uvIndices:Array<number>;\n\tprivate _indices:Array<number> /*uint*/;\n\tprivate _vertIndices:Array<number>;\n\n\t// the current subgeom being built\n\tprivate _animationSet:VertexAnimationSet = new VertexAnimationSet();\n\tprivate _firstSubGeom:TriangleSubGeometry;\n\tprivate _uvs:Array<number>;\n\tprivate _finalUV:Array<number>;\n\n\tprivate _materialNames:Array<string>;\n\tprivate _textureType:string;\n\tprivate _ignoreTexturePath:boolean;\n\tprivate _mesh:Mesh;\n\tprivate _geometry:Geometry;\n\n\tprivate materialFinal:boolean = false;\n\tprivate geoCreated:boolean = false;\n\n\t/**\n\t * Creates a new MD2Parser object.\n\t * @param textureType The extension of the texture (e.g. jpg/png/...)\n\t * @param ignoreTexturePath If true, the path of the texture is ignored\n\t */\n\tconstructor(textureType:string = \"jpg\", ignoreTexturePath:boolean = true)\n\t{\n\t\tsuper(URLLoaderDataFormat.ARRAY_BUFFER);\n\t\tthis._textureType = textureType;\n\t\tthis._ignoreTexturePath = ignoreTexturePath;\n\t}\n\n\t/**\n\t * Indicates whether or not a given file extension is supported by the parser.\n\t * @param extension The file extension of a potential file to be parsed.\n\t * @return Whether or not the given file type is supported.\n\t */\n\tpublic static supportsType(extension:string):boolean\n\t{\n\t\textension = extension.toLowerCase();\n\t\treturn extension == \"md2\";\n\t}\n\n\t/**\n\t * Tests whether a data block can be parsed by the parser.\n\t * @param data The data block to potentially be parsed.\n\t * @return Whether or not the given data is supported.\n\t */\n\tpublic static supportsData(data:any):boolean\n\t{\n\t\treturn (ParserUtils.toString(data, 4) == 'IDP2');\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependency(resourceDependency:ResourceDependency):void\n\t{\n\t\tif (resourceDependency.assets.length != 1)\n\t\t\treturn;\n\n\t\tvar asset:Texture2DBase = <Texture2DBase> resourceDependency.assets[0];\n\n\t\tif (asset) {\n\t\t\tvar material:TriangleMethodMaterial = new TriangleMethodMaterial(asset);\n\n\t\t\tif (this.materialMode >= 2)\n\t\t\t\tmaterial.materialMode = TriangleMaterialMode.MULTI_PASS;\n\n\t\t\t//add to the content property\n\t\t\t(<DisplayObjectContainer> this._pContent).addChild(this._mesh);\n\n\t\t\tmaterial.name = this._mesh.material.name;\n\t\t\tthis._mesh.material = material;\n\t\t\tthis._pFinalizeAsset(material);\n\t\t\tthis._pFinalizeAsset(this._mesh.geometry);\n\t\t\tthis._pFinalizeAsset(this._mesh);\n\t\t}\n\t\tthis.materialFinal = true;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependencyFailure(resourceDependency:ResourceDependency):void\n\t{\n\t\t// apply system default\n\t\tif (this.materialMode < 2) {\n\t\t\tthis._mesh.material = DefaultMaterialManager.getDefaultMaterial();\n\t\t} else {\n\t\t\tthis._mesh.material = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture());\n\t\t\t(<TriangleMethodMaterial> this._mesh.material).materialMode = TriangleMaterialMode.MULTI_PASS;\n\t\t}\n\n\t\t//add to the content property\n\t\t(<DisplayObjectContainer> this._pContent).addChild(this._mesh);\n\n\t\tthis._pFinalizeAsset(this._mesh.geometry);\n\t\tthis._pFinalizeAsset(this._mesh);\n\t\tthis.materialFinal = true;\n\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pProceedParsing():boolean\n\t{\n\t\tif (!this._startedParsing) {\n\t\t\tthis._byteData = this._pGetByteData();\n\t\t\tthis._startedParsing = true;\n\n\t\t\t// Reset bytearray read position (which may have been\n\t\t\t// moved forward by the supportsData() function.)\n\t\t\tthis._byteData.position = 0;\n\t\t}\n\n\t\twhile (this._pHasTime()) {\n\t\t\tif (!this._parsedHeader) {\n\t\t\t\t//----------------------------------------------------------------------------\n\t\t\t\t// LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray\n\t\t\t\t//----------------------------------------------------------------------------\n\t\t\t\t//this._byteData.endian = Endian.LITTLE_ENDIAN;\n\n\t\t\t\t// TODO: Create a mesh only when encountered (if it makes sense\n\t\t\t\t// for this file format) and return it using this._pFinalizeAsset()\n\t\t\t\tthis._geometry = new Geometry();\n\t\t\t\tthis._mesh = new Mesh(this._geometry, null);\n\t\t\t\tif (this.materialMode < 2) {\n\t\t\t\t\tthis._mesh.material = DefaultMaterialManager.getDefaultMaterial();\n\t\t\t\t} else {\n\t\t\t\t\tthis._mesh.material = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture());\n\t\t\t\t\t(<TriangleMethodMaterial> this._mesh.material).materialMode = TriangleMaterialMode.MULTI_PASS;\n\t\t\t\t}\n\n\t\t\t\t//_geometry.animation = new VertexAnimation(2, VertexAnimationMode.ABSOLUTE);\n\t\t\t\t//_animator = new VertexAnimator(VertexAnimationState(_mesh.animationState));\n\n\t\t\t\t// Parse header and decompress body\n\t\t\t\tthis.parseHeader();\n\t\t\t\tthis.parseMaterialNames();\n\t\t\t} else if (!this._parsedUV) {\n\t\t\t\tthis.parseUV();\n\t\t\t} else if (!this._parsedFaces) {\n\t\t\t\tthis.parseFaces();\n\t\t\t} else if (!this._parsedFrames) {\n\t\t\t\tthis.parseFrames();\n\t\t\t} else if ((this.geoCreated) && (this.materialFinal)) {\n\t\t\t\treturn ParserBase.PARSING_DONE;\n\t\t\t} else if (!this.geoCreated) {\n\t\t\t\tthis.geoCreated = true;\n\t\t\t\t//create default subgeometry\n\t\t\t\tthis._geometry.addSubGeometry(this._firstSubGeom.clone());\n\t\t\t\t// Force name to be chosen by this._pFinalizeAsset()\n\t\t\t\tthis._mesh.name = \"\";\n\t\t\t\tif (this.materialFinal) {\n\t\t\t\t\t//add to the content property\n\t\t\t\t\t(<DisplayObjectContainer> this._pContent).addChild(this._mesh);\n\n\t\t\t\t\tthis._pFinalizeAsset(this._mesh.geometry);\n\t\t\t\t\tthis._pFinalizeAsset(this._mesh);\n\t\t\t\t}\n\n\t\t\t\tthis._pPauseAndRetrieveDependencies();\n\t\t\t}\n\t\t}\n\n\t\treturn ParserBase.MORE_TO_PARSE;\n\t}\n\n\tpublic _pStartParsing(frameLimit:number)\n\t{\n\t\tsuper._pStartParsing(frameLimit);\n\n\t\t//create a content object for Loaders\n\t\tthis._pContent = new DisplayObjectContainer();\n\t}\n\n\t/**\n\t * Reads in all that MD2 Header data that is declared as private variables.\n\t * I know its a lot, and it looks ugly, but only way to do it in Flash\n\t */\n\tprivate parseHeader():void\n\t{\n\t\tthis._ident = this._byteData.readInt();\n\t\tthis._version = this._byteData.readInt();\n\t\tthis._skinWidth = this._byteData.readInt();\n\t\tthis._skinHeight = this._byteData.readInt();\n\t\t//skip this._frameSize\n\t\tthis._byteData.readInt();\n\t\tthis._numSkins = this._byteData.readInt();\n\t\tthis._numVertices = this._byteData.readInt();\n\t\tthis._numST = this._byteData.readInt();\n\t\tthis._numTris = this._byteData.readInt();\n\t\t//skip this._numGlCmds\n\t\tthis._byteData.readInt();\n\t\tthis._numFrames = this._byteData.readInt();\n\t\tthis._offsetSkins = this._byteData.readInt();\n\t\tthis._offsetST = this._byteData.readInt();\n\t\tthis._offsetTris = this._byteData.readInt();\n\t\tthis._offsetFrames = this._byteData.readInt();\n\t\t//skip this._offsetGlCmds\n\t\tthis._byteData.readInt();\n\t\tthis._offsetEnd = this._byteData.readInt();\n\n\t\tthis._parsedHeader = true;\n\t}\n\n\t/**\n\t * Parses the file names for the materials.\n\t */\n\tprivate parseMaterialNames():void\n\t{\n\t\tvar url:string;\n\t\tvar name:string;\n\t\tvar extIndex:number /*int*/;\n\t\tvar slashIndex:number /*int*/;\n\t\tthis._materialNames = new Array<string>();\n\t\tthis._byteData.position = this._offsetSkins;\n\n\t\tvar regExp:RegExp = new RegExp(\"[^a-zA-Z0-9\\\\_\\/.]\", \"g\");\n\t\tfor (var i:number /*uint*/ = 0; i < this._numSkins; ++i) {\n\t\t\tname = this._byteData.readUTFBytes(64);\n\t\t\tname = name.replace(regExp, \"\");\n\t\t\textIndex = name.lastIndexOf(\".\");\n\t\t\tif (this._ignoreTexturePath)\n\t\t\t\tslashIndex = name.lastIndexOf(\"/\");\n\t\t\tif (name.toLowerCase().indexOf(\".jpg\") == -1 && name.toLowerCase().indexOf(\".png\") == -1) {\n\t\t\t\tname = name.substring(slashIndex + 1, extIndex);\n\t\t\t\turl = name + \".\" + this._textureType;\n\t\t\t} else {\n\t\t\t\turl = name;\n\t\t\t}\n\n\t\t\tthis._materialNames[i] = name;\n\n\t\t\t// only support 1 skin TODO: really?\n\t\t\tif (this.dependencies.length == 0)\n\t\t\t\tthis._pAddDependency(name, new URLRequest(url));\n\t\t}\n\n\t\tif (this._materialNames.length > 0)\n\t\t\tthis._mesh.material.name = this._materialNames[0]; else\n\t\t\tthis.materialFinal = true;\n\t}\n\n\t/**\n\t * Parses the uv data for the mesh.\n\t */\n\tprivate parseUV():void\n\t{\n\t\tvar j:number /*uint*/ = 0;\n\n\t\tthis._uvs = new Array<number>(this._numST*2);\n\t\tthis._byteData.position = this._offsetST;\n\t\tfor (var i:number /*uint*/ = 0; i < this._numST; i++) {\n\t\t\tthis._uvs[j++] = this._byteData.readShort()/this._skinWidth;\n\t\t\tthis._uvs[j++] = this._byteData.readShort()/this._skinHeight;\n\t\t}\n\n\t\tthis._parsedUV = true;\n\t}\n\n\t/**\n\t * Parses unique indices for the faces.\n\t */\n\tprivate parseFaces():void\n\t{\n\t\tvar a:number /*uint*/, b:number /*uint*/, c:number /*uint*/, ta:number /*uint*/, tb:number /*uint*/, tc:number /*uint*/;\n\t\tvar i:number /*uint*/;\n\n\t\tthis._vertIndices = new Array<number>();\n\t\tthis._uvIndices = new Array<number>();\n\t\tthis._indices = new Array<number>() /*uint*/;\n\n\t\tthis._byteData.position = this._offsetTris;\n\n\t\tfor (i = 0; i < this._numTris; i++) {\n\t\t\t//collect vertex indices\n\t\t\ta = this._byteData.readUnsignedShort();\n\t\t\tb = this._byteData.readUnsignedShort();\n\t\t\tc = this._byteData.readUnsignedShort();\n\n\t\t\t//collect uv indices\n\t\t\tta = this._byteData.readUnsignedShort();\n\t\t\ttb = this._byteData.readUnsignedShort();\n\t\t\ttc = this._byteData.readUnsignedShort();\n\n\t\t\tthis.addIndex(a, ta);\n\t\t\tthis.addIndex(b, tb);\n\t\t\tthis.addIndex(c, tc);\n\t\t}\n\n\t\tvar len:number /*uint*/ = this._uvIndices.length;\n\t\tthis._finalUV = new Array<number>(len*2);\n\n\t\tfor (i = 0; i < len; ++i) {\n\t\t\tthis._finalUV[i << 1] = this._uvs[this._uvIndices[i] << 1];\n\t\t\tthis._finalUV[(i << 1) + 1] = this._uvs[(this._uvIndices[i] << 1) + 1];\n\t\t}\n\n\t\tthis._parsedFaces = true;\n\t}\n\n\t/**\n\t * Adds a face index to the list if it doesn't exist yet, based on vertexIndex and uvIndex, and adds the\n\t * corresponding vertex and uv data in the correct location.\n\t * @param vertexIndex The original index in the vertex list.\n\t * @param uvIndex The original index in the uv list.\n\t */\n\tprivate addIndex(vertexIndex:number /*uint*/, uvIndex:number /*uint*/):void\n\t{\n\t\tvar index:number /*int*/ = this.findIndex(vertexIndex, uvIndex);\n\n\t\tif (index == -1) {\n\t\t\tthis._indices.push(this._vertIndices.length);\n\t\t\tthis._vertIndices.push(vertexIndex);\n\t\t\tthis._uvIndices.push(uvIndex);\n\t\t} else\n\t\t\tthis._indices.push(index);\n\t}\n\n\t/**\n\t * Finds the final index corresponding to the original MD2's vertex and uv indices. Returns -1 if it wasn't added yet.\n\t * @param vertexIndex The original index in the vertex list.\n\t * @param uvIndex The original index in the uv list.\n\t * @return The index of the final mesh corresponding to the original vertex and uv index. -1 if it doesn't exist yet.\n\t */\n\tprivate findIndex(vertexIndex:number /*uint*/, uvIndex:number /*uint*/):number /*int*/\n\t{\n\t\tvar len:number /*uint*/ = this._vertIndices.length;\n\n\t\tfor (var i:number /*uint*/ = 0; i < len; ++i) {\n\t\t\tif (this._vertIndices[i] == vertexIndex && this._uvIndices[i] == uvIndex)\n\t\t\t\treturn i;\n\t\t}\n\n\t\treturn -1;\n\t}\n\n\t/**\n\t * Parses all the frame geometries.\n\t */\n\tprivate parseFrames():void\n\t{\n\t\tvar sx:number, sy:number, sz:number;\n\t\tvar tx:number, ty:number, tz:number;\n\t\tvar geometry:Geometry;\n\t\tvar subGeom:TriangleSubGeometry;\n\t\tvar vertLen:number /*uint*/ = this._vertIndices.length;\n\t\tvar fvertices:Array<number>;\n\t\tvar tvertices:Array<number>;\n\t\tvar i:number /*uint*/, j:number /*int*/, k:number /*uint*/;\n\t\t//var ch : number /*uint*/;\n\t\tvar name:string = \"\";\n\t\tvar prevClip:VertexClipNode = null;\n\n\t\tthis._byteData.position = this._offsetFrames;\n\n\t\tfor (i = 0; i < this._numFrames; i++) {\n\n\t\t\ttvertices = new Array<number>();\n\t\t\tfvertices = new Array<number>(vertLen*3);\n\n\t\t\tsx = this._byteData.readFloat();\n\t\t\tsy = this._byteData.readFloat();\n\t\t\tsz = this._byteData.readFloat();\n\n\t\t\ttx = this._byteData.readFloat();\n\t\t\tty = this._byteData.readFloat();\n\t\t\ttz = this._byteData.readFloat();\n\n\t\t\tname = this.readFrameName();\n\n\t\t\t// Note, the extra data.position++ in the for loop is there\n\t\t\t// to skip over a byte that holds the \"vertex normal index\"\n\t\t\tfor (j = 0; j < this._numVertices; j++, this._byteData.position++)\n\t\t\t\ttvertices.push(sx*this._byteData.readUnsignedByte() + tx, sy*this._byteData.readUnsignedByte() + ty, sz*this._byteData.readUnsignedByte() + tz);\n\n\t\t\tk = 0;\n\t\t\tfor (j = 0; j < vertLen; j++) {\n\t\t\t\tfvertices[k++] = tvertices[this._vertIndices[j]*3];\n\t\t\t\tfvertices[k++] = tvertices[this._vertIndices[j]*3 + 2];\n\t\t\t\tfvertices[k++] = tvertices[this._vertIndices[j]*3 + 1];\n\t\t\t}\n\n\t\t\tsubGeom = new TriangleSubGeometry(true);\n\n\t\t\tif (this._firstSubGeom == null)\n\t\t\t\tthis._firstSubGeom = subGeom;\n\n\t\t\tgeometry = new Geometry();\n\t\t\tgeometry.addSubGeometry(subGeom);\n\n\t\t\tsubGeom.updateIndices(this._indices);\n\t\t\tsubGeom.updatePositions(fvertices);\n\t\t\tsubGeom.updateUVs(this._finalUV);\n\t\t\tsubGeom.vertexNormals;\n\t\t\tsubGeom.vertexTangents;\n\t\t\tsubGeom.autoDeriveNormals = false;\n\t\t\tsubGeom.autoDeriveTangents = false;\n\n\t\t\tvar clip:VertexClipNode = this._clipNodes[name];\n\n\t\t\tif (!clip) {\n\t\t\t\t// If another sequence was parsed before this one, starting\n\t\t\t\t// a new state means the previous one is complete and can\n\t\t\t\t// hence be finalized.\n\t\t\t\tif (prevClip) {\n\t\t\t\t\tthis._pFinalizeAsset(prevClip);\n\t\t\t\t\tthis._animationSet.addAnimation(prevClip);\n\t\t\t\t}\n\n\t\t\t\tclip = new VertexClipNode();\n\t\t\t\tclip.name = name;\n\t\t\t\tclip.stitchFinalFrame = true;\n\n\t\t\t\tthis._clipNodes[name] = clip;\n\n\t\t\t\tprevClip = clip;\n\t\t\t}\n\t\t\tclip.addFrame(geometry, 1000/MD2Parser.FPS);\n\t\t}\n\n\t\t// Finalize the last state\n\t\tif (prevClip) {\n\t\t\tthis._pFinalizeAsset(prevClip);\n\t\t\tthis._animationSet.addAnimation(prevClip);\n\t\t}\n\n\t\t// Force this._pFinalizeAsset() to decide name\n\t\tthis._pFinalizeAsset(this._animationSet);\n\n\t\tthis._parsedFrames = true;\n\t}\n\n\tprivate readFrameName():string\n\t{\n\t\tvar name:string = \"\";\n\t\tvar k:number /*uint*/ = 0;\n\t\tfor (var j:number /*uint*/ = 0; j < 16; j++) {\n\t\t\tvar ch:number /*uint*/ = this._byteData.readUnsignedByte();\n\n\t\t\tif (Math.floor(ch) > 0x39 && Math.floor(ch) <= 0x7A && k == 0)\n\t\t\t\tname += String.fromCharCode(ch);\n\n\t\t\tif (Math.floor(ch) >= 0x30 && Math.floor(ch) <= 0x39)\n\t\t\t\tk++;\n\t\t}\n\t\treturn name;\n\t}\n}\n\nexport = MD2Parser;"]} \ No newline at end of file diff --git a/lib/parsers/MD2Parser.ts b/lib/parsers/MD2Parser.ts new file mode 100644 index 000000000..bdeb0811c --- /dev/null +++ b/lib/parsers/MD2Parser.ts @@ -0,0 +1,509 @@ +import DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +import BitmapData = require("awayjs-core/lib/core/base/BitmapData"); +import DisplayObject = require("awayjs-core/lib/core/base/DisplayObject"); +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +import URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +import Camera = require("awayjs-core/lib/entities/Camera"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +import ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +import ResourceDependency = require("awayjs-core/lib/parsers/ResourceDependency"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); +import ByteArray = require("awayjs-core/lib/utils/ByteArray"); + +import DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); +import TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +import TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); + +import VertexClipNode = require("awayjs-renderergl/lib/animators/nodes/VertexClipNode"); +import VertexAnimationSet = require("awayjs-renderergl/lib/animators/VertexAnimationSet"); + +/** + * MD2Parser provides a parser for the MD2 data type. + */ +class MD2Parser extends ParserBase +{ + public static FPS:number /*int*/ = 6; + + private _clipNodes:Object = new Object(); + private _byteData:ByteArray; + private _startedParsing:boolean; + private _parsedHeader:boolean; + private _parsedUV:boolean; + private _parsedFaces:boolean; + private _parsedFrames:boolean; + + private _ident:number /*uint*/; + private _version:number /*uint*/; + private _skinWidth:number /*uint*/; + private _skinHeight:number /*uint*/; + //private _frameSize : number /*uint*/; + private _numSkins:number /*uint*/; + private _numVertices:number /*uint*/; + private _numST:number /*uint*/; + private _numTris:number /*uint*/; + //private _numGlCmds : number /*uint*/; + private _numFrames:number /*uint*/; + private _offsetSkins:number /*uint*/; + private _offsetST:number /*uint*/; + private _offsetTris:number /*uint*/; + private _offsetFrames:number /*uint*/; + //private _offsetGlCmds : number /*uint*/; + private _offsetEnd:number /*uint*/; + + private _uvIndices:Array; + private _indices:Array /*uint*/; + private _vertIndices:Array; + + // the current subgeom being built + private _animationSet:VertexAnimationSet = new VertexAnimationSet(); + private _firstSubGeom:TriangleSubGeometry; + private _uvs:Array; + private _finalUV:Array; + + private _materialNames:Array; + private _textureType:string; + private _ignoreTexturePath:boolean; + private _mesh:Mesh; + private _geometry:Geometry; + + private materialFinal:boolean = false; + private geoCreated:boolean = false; + + /** + * Creates a new MD2Parser object. + * @param textureType The extension of the texture (e.g. jpg/png/...) + * @param ignoreTexturePath If true, the path of the texture is ignored + */ + constructor(textureType:string = "jpg", ignoreTexturePath:boolean = true) + { + super(URLLoaderDataFormat.ARRAY_BUFFER); + this._textureType = textureType; + this._ignoreTexturePath = ignoreTexturePath; + } + + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + public static supportsType(extension:string):boolean + { + extension = extension.toLowerCase(); + return extension == "md2"; + } + + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + public static supportsData(data:any):boolean + { + return (ParserUtils.toString(data, 4) == 'IDP2'); + } + + /** + * @inheritDoc + */ + public _iResolveDependency(resourceDependency:ResourceDependency):void + { + if (resourceDependency.assets.length != 1) + return; + + var asset:Texture2DBase = resourceDependency.assets[0]; + + if (asset) { + var material:TriangleMethodMaterial = new TriangleMethodMaterial(asset); + + if (this.materialMode >= 2) + material.materialMode = TriangleMaterialMode.MULTI_PASS; + + //add to the content property + ( this._pContent).addChild(this._mesh); + + material.name = this._mesh.material.name; + this._mesh.material = material; + this._pFinalizeAsset(material); + this._pFinalizeAsset(this._mesh.geometry); + this._pFinalizeAsset(this._mesh); + } + this.materialFinal = true; + } + + /** + * @inheritDoc + */ + public _iResolveDependencyFailure(resourceDependency:ResourceDependency):void + { + // apply system default + if (this.materialMode < 2) { + this._mesh.material = DefaultMaterialManager.getDefaultMaterial(); + } else { + this._mesh.material = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture()); + ( this._mesh.material).materialMode = TriangleMaterialMode.MULTI_PASS; + } + + //add to the content property + ( this._pContent).addChild(this._mesh); + + this._pFinalizeAsset(this._mesh.geometry); + this._pFinalizeAsset(this._mesh); + this.materialFinal = true; + + } + + /** + * @inheritDoc + */ + public _pProceedParsing():boolean + { + if (!this._startedParsing) { + this._byteData = this._pGetByteData(); + this._startedParsing = true; + + // Reset bytearray read position (which may have been + // moved forward by the supportsData() function.) + this._byteData.position = 0; + } + + while (this._pHasTime()) { + if (!this._parsedHeader) { + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._byteData.endian = Endian.LITTLE_ENDIAN; + + // TODO: Create a mesh only when encountered (if it makes sense + // for this file format) and return it using this._pFinalizeAsset() + this._geometry = new Geometry(); + this._mesh = new Mesh(this._geometry, null); + if (this.materialMode < 2) { + this._mesh.material = DefaultMaterialManager.getDefaultMaterial(); + } else { + this._mesh.material = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture()); + ( this._mesh.material).materialMode = TriangleMaterialMode.MULTI_PASS; + } + + //_geometry.animation = new VertexAnimation(2, VertexAnimationMode.ABSOLUTE); + //_animator = new VertexAnimator(VertexAnimationState(_mesh.animationState)); + + // Parse header and decompress body + this.parseHeader(); + this.parseMaterialNames(); + } else if (!this._parsedUV) { + this.parseUV(); + } else if (!this._parsedFaces) { + this.parseFaces(); + } else if (!this._parsedFrames) { + this.parseFrames(); + } else if ((this.geoCreated) && (this.materialFinal)) { + return ParserBase.PARSING_DONE; + } else if (!this.geoCreated) { + this.geoCreated = true; + //create default subgeometry + this._geometry.addSubGeometry(this._firstSubGeom.clone()); + // Force name to be chosen by this._pFinalizeAsset() + this._mesh.name = ""; + if (this.materialFinal) { + //add to the content property + ( this._pContent).addChild(this._mesh); + + this._pFinalizeAsset(this._mesh.geometry); + this._pFinalizeAsset(this._mesh); + } + + this._pPauseAndRetrieveDependencies(); + } + } + + return ParserBase.MORE_TO_PARSE; + } + + public _pStartParsing(frameLimit:number) + { + super._pStartParsing(frameLimit); + + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + } + + /** + * Reads in all that MD2 Header data that is declared as private variables. + * I know its a lot, and it looks ugly, but only way to do it in Flash + */ + private parseHeader():void + { + this._ident = this._byteData.readInt(); + this._version = this._byteData.readInt(); + this._skinWidth = this._byteData.readInt(); + this._skinHeight = this._byteData.readInt(); + //skip this._frameSize + this._byteData.readInt(); + this._numSkins = this._byteData.readInt(); + this._numVertices = this._byteData.readInt(); + this._numST = this._byteData.readInt(); + this._numTris = this._byteData.readInt(); + //skip this._numGlCmds + this._byteData.readInt(); + this._numFrames = this._byteData.readInt(); + this._offsetSkins = this._byteData.readInt(); + this._offsetST = this._byteData.readInt(); + this._offsetTris = this._byteData.readInt(); + this._offsetFrames = this._byteData.readInt(); + //skip this._offsetGlCmds + this._byteData.readInt(); + this._offsetEnd = this._byteData.readInt(); + + this._parsedHeader = true; + } + + /** + * Parses the file names for the materials. + */ + private parseMaterialNames():void + { + var url:string; + var name:string; + var extIndex:number /*int*/; + var slashIndex:number /*int*/; + this._materialNames = new Array(); + this._byteData.position = this._offsetSkins; + + var regExp:RegExp = new RegExp("[^a-zA-Z0-9\\_\/.]", "g"); + for (var i:number /*uint*/ = 0; i < this._numSkins; ++i) { + name = this._byteData.readUTFBytes(64); + name = name.replace(regExp, ""); + extIndex = name.lastIndexOf("."); + if (this._ignoreTexturePath) + slashIndex = name.lastIndexOf("/"); + if (name.toLowerCase().indexOf(".jpg") == -1 && name.toLowerCase().indexOf(".png") == -1) { + name = name.substring(slashIndex + 1, extIndex); + url = name + "." + this._textureType; + } else { + url = name; + } + + this._materialNames[i] = name; + + // only support 1 skin TODO: really? + if (this.dependencies.length == 0) + this._pAddDependency(name, new URLRequest(url)); + } + + if (this._materialNames.length > 0) + this._mesh.material.name = this._materialNames[0]; else + this.materialFinal = true; + } + + /** + * Parses the uv data for the mesh. + */ + private parseUV():void + { + var j:number /*uint*/ = 0; + + this._uvs = new Array(this._numST*2); + this._byteData.position = this._offsetST; + for (var i:number /*uint*/ = 0; i < this._numST; i++) { + this._uvs[j++] = this._byteData.readShort()/this._skinWidth; + this._uvs[j++] = this._byteData.readShort()/this._skinHeight; + } + + this._parsedUV = true; + } + + /** + * Parses unique indices for the faces. + */ + private parseFaces():void + { + var a:number /*uint*/, b:number /*uint*/, c:number /*uint*/, ta:number /*uint*/, tb:number /*uint*/, tc:number /*uint*/; + var i:number /*uint*/; + + this._vertIndices = new Array(); + this._uvIndices = new Array(); + this._indices = new Array() /*uint*/; + + this._byteData.position = this._offsetTris; + + for (i = 0; i < this._numTris; i++) { + //collect vertex indices + a = this._byteData.readUnsignedShort(); + b = this._byteData.readUnsignedShort(); + c = this._byteData.readUnsignedShort(); + + //collect uv indices + ta = this._byteData.readUnsignedShort(); + tb = this._byteData.readUnsignedShort(); + tc = this._byteData.readUnsignedShort(); + + this.addIndex(a, ta); + this.addIndex(b, tb); + this.addIndex(c, tc); + } + + var len:number /*uint*/ = this._uvIndices.length; + this._finalUV = new Array(len*2); + + for (i = 0; i < len; ++i) { + this._finalUV[i << 1] = this._uvs[this._uvIndices[i] << 1]; + this._finalUV[(i << 1) + 1] = this._uvs[(this._uvIndices[i] << 1) + 1]; + } + + this._parsedFaces = true; + } + + /** + * Adds a face index to the list if it doesn't exist yet, based on vertexIndex and uvIndex, and adds the + * corresponding vertex and uv data in the correct location. + * @param vertexIndex The original index in the vertex list. + * @param uvIndex The original index in the uv list. + */ + private addIndex(vertexIndex:number /*uint*/, uvIndex:number /*uint*/):void + { + var index:number /*int*/ = this.findIndex(vertexIndex, uvIndex); + + if (index == -1) { + this._indices.push(this._vertIndices.length); + this._vertIndices.push(vertexIndex); + this._uvIndices.push(uvIndex); + } else + this._indices.push(index); + } + + /** + * Finds the final index corresponding to the original MD2's vertex and uv indices. Returns -1 if it wasn't added yet. + * @param vertexIndex The original index in the vertex list. + * @param uvIndex The original index in the uv list. + * @return The index of the final mesh corresponding to the original vertex and uv index. -1 if it doesn't exist yet. + */ + private findIndex(vertexIndex:number /*uint*/, uvIndex:number /*uint*/):number /*int*/ + { + var len:number /*uint*/ = this._vertIndices.length; + + for (var i:number /*uint*/ = 0; i < len; ++i) { + if (this._vertIndices[i] == vertexIndex && this._uvIndices[i] == uvIndex) + return i; + } + + return -1; + } + + /** + * Parses all the frame geometries. + */ + private parseFrames():void + { + var sx:number, sy:number, sz:number; + var tx:number, ty:number, tz:number; + var geometry:Geometry; + var subGeom:TriangleSubGeometry; + var vertLen:number /*uint*/ = this._vertIndices.length; + var fvertices:Array; + var tvertices:Array; + var i:number /*uint*/, j:number /*int*/, k:number /*uint*/; + //var ch : number /*uint*/; + var name:string = ""; + var prevClip:VertexClipNode = null; + + this._byteData.position = this._offsetFrames; + + for (i = 0; i < this._numFrames; i++) { + + tvertices = new Array(); + fvertices = new Array(vertLen*3); + + sx = this._byteData.readFloat(); + sy = this._byteData.readFloat(); + sz = this._byteData.readFloat(); + + tx = this._byteData.readFloat(); + ty = this._byteData.readFloat(); + tz = this._byteData.readFloat(); + + name = this.readFrameName(); + + // Note, the extra data.position++ in the for loop is there + // to skip over a byte that holds the "vertex normal index" + for (j = 0; j < this._numVertices; j++, this._byteData.position++) + tvertices.push(sx*this._byteData.readUnsignedByte() + tx, sy*this._byteData.readUnsignedByte() + ty, sz*this._byteData.readUnsignedByte() + tz); + + k = 0; + for (j = 0; j < vertLen; j++) { + fvertices[k++] = tvertices[this._vertIndices[j]*3]; + fvertices[k++] = tvertices[this._vertIndices[j]*3 + 2]; + fvertices[k++] = tvertices[this._vertIndices[j]*3 + 1]; + } + + subGeom = new TriangleSubGeometry(true); + + if (this._firstSubGeom == null) + this._firstSubGeom = subGeom; + + geometry = new Geometry(); + geometry.addSubGeometry(subGeom); + + subGeom.updateIndices(this._indices); + subGeom.updatePositions(fvertices); + subGeom.updateUVs(this._finalUV); + subGeom.vertexNormals; + subGeom.vertexTangents; + subGeom.autoDeriveNormals = false; + subGeom.autoDeriveTangents = false; + + var clip:VertexClipNode = this._clipNodes[name]; + + if (!clip) { + // If another sequence was parsed before this one, starting + // a new state means the previous one is complete and can + // hence be finalized. + if (prevClip) { + this._pFinalizeAsset(prevClip); + this._animationSet.addAnimation(prevClip); + } + + clip = new VertexClipNode(); + clip.name = name; + clip.stitchFinalFrame = true; + + this._clipNodes[name] = clip; + + prevClip = clip; + } + clip.addFrame(geometry, 1000/MD2Parser.FPS); + } + + // Finalize the last state + if (prevClip) { + this._pFinalizeAsset(prevClip); + this._animationSet.addAnimation(prevClip); + } + + // Force this._pFinalizeAsset() to decide name + this._pFinalizeAsset(this._animationSet); + + this._parsedFrames = true; + } + + private readFrameName():string + { + var name:string = ""; + var k:number /*uint*/ = 0; + for (var j:number /*uint*/ = 0; j < 16; j++) { + var ch:number /*uint*/ = this._byteData.readUnsignedByte(); + + if (Math.floor(ch) > 0x39 && Math.floor(ch) <= 0x7A && k == 0) + name += String.fromCharCode(ch); + + if (Math.floor(ch) >= 0x30 && Math.floor(ch) <= 0x39) + k++; + } + return name; + } +} + +export = MD2Parser; \ No newline at end of file diff --git a/lib/parsers/MD5AnimParser.js b/lib/parsers/MD5AnimParser.js new file mode 100755 index 000000000..8cf1968db --- /dev/null +++ b/lib/parsers/MD5AnimParser.js @@ -0,0 +1,492 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +var ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +var JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +var SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +var SkeletonClipNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonClipNode"); +var BaseFrameData = require("awayjs-renderergl/lib/parsers/data/BaseFrameData"); +var BoundsData = require("awayjs-renderergl/lib/parsers/data/BoundsData"); +var FrameData = require("awayjs-renderergl/lib/parsers/data/FrameData"); +var HierarchyData = require("awayjs-renderergl/lib/parsers/data/HierarchyData"); +/** + * MD5AnimParser provides a parser for the md5anim data type, providing an animation sequence for the md5 format. + * + * todo: optimize + */ +var MD5AnimParser = (function (_super) { + __extends(MD5AnimParser, _super); + /** + * Creates a new MD5AnimParser object. + * @param uri The url or id of the data or file to be parsed. + * @param extra The holder for extra contextual data that the parser might need. + */ + function MD5AnimParser(additionalRotationAxis, additionalRotationRadians) { + if (additionalRotationAxis === void 0) { additionalRotationAxis = null; } + if (additionalRotationRadians === void 0) { additionalRotationRadians = 0; } + _super.call(this, URLLoaderDataFormat.TEXT); + this._parseIndex = 0; + this._line = 0; + this._charLineIndex = 0; + this._rotationQuat = new Quaternion(); + var t1 = new Quaternion(); + var t2 = new Quaternion(); + t1.fromAxisAngle(Vector3D.X_AXIS, -Math.PI * .5); + t2.fromAxisAngle(Vector3D.Y_AXIS, -Math.PI * .5); + this._rotationQuat.multiply(t2, t1); + if (additionalRotationAxis) { + this._rotationQuat.multiply(t2, t1); + t1.fromAxisAngle(additionalRotationAxis, additionalRotationRadians); + this._rotationQuat.multiply(t1, this._rotationQuat); + } + } + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + MD5AnimParser.supportsType = function (extension) { + extension = extension.toLowerCase(); + return extension == "md5anim"; + }; + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + MD5AnimParser.supportsData = function (data) { + return false; + }; + /** + * @inheritDoc + */ + MD5AnimParser.prototype._pProceedParsing = function () { + var token; + if (!this._startedParsing) { + this._textData = this._pGetTextData(); + this._startedParsing = true; + } + while (this._pHasTime()) { + token = this.getNextToken(); + switch (token) { + case MD5AnimParser.COMMENT_TOKEN: + this.ignoreLine(); + break; + case "": + break; + case MD5AnimParser.VERSION_TOKEN: + this._version = this.getNextInt(); + if (this._version != 10) + throw new Error("Unknown version number encountered!"); + break; + case MD5AnimParser.COMMAND_LINE_TOKEN: + this.parseCMD(); + break; + case MD5AnimParser.NUM_FRAMES_TOKEN: + this._numFrames = this.getNextInt(); + this._bounds = new Array(); + this._frameData = new Array(); + break; + case MD5AnimParser.NUM_JOINTS_TOKEN: + this._numJoints = this.getNextInt(); + this._hierarchy = new Array(this._numJoints); + this._baseFrameData = new Array(this._numJoints); + break; + case MD5AnimParser.FRAME_RATE_TOKEN: + this._frameRate = this.getNextInt(); + break; + case MD5AnimParser.NUM_ANIMATED_COMPONENTS_TOKEN: + this._numAnimatedComponents = this.getNextInt(); + break; + case MD5AnimParser.HIERARCHY_TOKEN: + this.parseHierarchy(); + break; + case MD5AnimParser.BOUNDS_TOKEN: + this.parseBounds(); + break; + case MD5AnimParser.BASE_FRAME_TOKEN: + this.parseBaseFrame(); + break; + case MD5AnimParser.FRAME_TOKEN: + this.parseFrame(); + break; + default: + if (!this._reachedEOF) + this.sendUnknownKeywordError(); + } + if (this._reachedEOF) { + this._clip = new SkeletonClipNode(); + this.translateClip(); + this._pFinalizeAsset(this._clip); + return ParserBase.PARSING_DONE; + } + } + return ParserBase.MORE_TO_PARSE; + }; + /** + * Converts all key frame data to an SkinnedAnimationSequence. + */ + MD5AnimParser.prototype.translateClip = function () { + for (var i = 0; i < this._numFrames; ++i) + this._clip.addFrame(this.translatePose(this._frameData[i]), 1000 / this._frameRate); + }; + /** + * Converts a single key frame data to a SkeletonPose. + * @param frameData The actual frame data. + * @return A SkeletonPose containing the frame data's pose. + */ + MD5AnimParser.prototype.translatePose = function (frameData) { + var hierarchy; + var pose; + var base; + var flags /*int*/; + var j /*int*/; + var translate = new Vector3D(); + var orientation = new Quaternion(); + var components = frameData.components; + var skelPose = new SkeletonPose(); + var jointPoses = skelPose.jointPoses; + for (var i = 0; i < this._numJoints; ++i) { + j = 0; + pose = new JointPose(); + hierarchy = this._hierarchy[i]; + base = this._baseFrameData[i]; + flags = hierarchy.flags; + translate.x = base.position.x; + translate.y = base.position.y; + translate.z = base.position.z; + orientation.x = base.orientation.x; + orientation.y = base.orientation.y; + orientation.z = base.orientation.z; + if (flags & 1) + translate.x = components[hierarchy.startIndex + (j++)]; + if (flags & 2) + translate.y = components[hierarchy.startIndex + (j++)]; + if (flags & 4) + translate.z = components[hierarchy.startIndex + (j++)]; + if (flags & 8) + orientation.x = components[hierarchy.startIndex + (j++)]; + if (flags & 16) + orientation.y = components[hierarchy.startIndex + (j++)]; + if (flags & 32) + orientation.z = components[hierarchy.startIndex + (j++)]; + var w = 1 - orientation.x * orientation.x - orientation.y * orientation.y - orientation.z * orientation.z; + orientation.w = w < 0 ? 0 : -Math.sqrt(w); + if (hierarchy.parentIndex < 0) { + pose.orientation.multiply(this._rotationQuat, orientation); + pose.translation = this._rotationQuat.rotatePoint(translate); + } + else { + pose.orientation.copyFrom(orientation); + pose.translation.x = translate.x; + pose.translation.y = translate.y; + pose.translation.z = translate.z; + } + pose.orientation.y = -pose.orientation.y; + pose.orientation.z = -pose.orientation.z; + pose.translation.x = -pose.translation.x; + jointPoses[i] = pose; + } + return skelPose; + }; + /** + * Parses the skeleton's hierarchy data. + */ + MD5AnimParser.prototype.parseHierarchy = function () { + var ch; + var data; + var token = this.getNextToken(); + var i = 0; + if (token != "{") + this.sendUnknownKeywordError(); + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new HierarchyData(); + data.name = this.parseLiteralstring(); + data.parentIndex = this.getNextInt(); + data.flags = this.getNextInt(); + data.startIndex = this.getNextInt(); + this._hierarchy[i++] = data; + ch = this.getNextChar(); + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + if (ch != "}") + this.putBack(); + } while (ch != "}"); + }; + /** + * Parses frame bounds. + */ + MD5AnimParser.prototype.parseBounds = function () { + var ch; + var data; + var token = this.getNextToken(); + var i = 0; + if (token != "{") + this.sendUnknownKeywordError(); + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new BoundsData(); + data.min = this.parseVector3D(); + data.max = this.parseVector3D(); + this._bounds[i++] = data; + ch = this.getNextChar(); + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + if (ch != "}") + this.putBack(); + } while (ch != "}"); + }; + /** + * Parses the base frame. + */ + MD5AnimParser.prototype.parseBaseFrame = function () { + var ch; + var data; + var token = this.getNextToken(); + var i = 0; + if (token != "{") + this.sendUnknownKeywordError(); + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new BaseFrameData(); + data.position = this.parseVector3D(); + data.orientation = this.parseQuaternion(); + this._baseFrameData[i++] = data; + ch = this.getNextChar(); + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + if (ch != "}") + this.putBack(); + } while (ch != "}"); + }; + /** + * Parses a single frame. + */ + MD5AnimParser.prototype.parseFrame = function () { + var ch; + var data; + var token; + var frameIndex /*int*/; + frameIndex = this.getNextInt(); + token = this.getNextToken(); + if (token != "{") + this.sendUnknownKeywordError(); + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new FrameData(); + data.components = new Array(this._numAnimatedComponents); + for (var i = 0; i < this._numAnimatedComponents; ++i) + data.components[i] = this.getNextNumber(); + this._frameData[frameIndex] = data; + ch = this.getNextChar(); + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + if (ch != "}") + this.putBack(); + } while (ch != "}"); + }; + /** + * Puts back the last read character into the data stream. + */ + MD5AnimParser.prototype.putBack = function () { + this._parseIndex--; + this._charLineIndex--; + this._reachedEOF = this._parseIndex >= this._textData.length; + }; + /** + * Gets the next token in the data stream. + */ + MD5AnimParser.prototype.getNextToken = function () { + var ch; + var token = ""; + while (!this._reachedEOF) { + ch = this.getNextChar(); + if (ch == " " || ch == "\r" || ch == "\n" || ch == "\t") { + if (token != MD5AnimParser.COMMENT_TOKEN) + this.skipWhiteSpace(); + if (token != "") + return token; + } + else + token += ch; + if (token == MD5AnimParser.COMMENT_TOKEN) + return token; + } + return token; + }; + /** + * Skips all whitespace in the data stream. + */ + MD5AnimParser.prototype.skipWhiteSpace = function () { + var ch; + do + ch = this.getNextChar(); + while (ch == "\n" || ch == " " || ch == "\r" || ch == "\t"); + this.putBack(); + }; + /** + * Skips to the next line. + */ + MD5AnimParser.prototype.ignoreLine = function () { + var ch; + while (!this._reachedEOF && ch != "\n") + ch = this.getNextChar(); + }; + /** + * Retrieves the next single character in the data stream. + */ + MD5AnimParser.prototype.getNextChar = function () { + var ch = this._textData.charAt(this._parseIndex++); + if (ch == "\n") { + ++this._line; + this._charLineIndex = 0; + } + else if (ch != "\r") + ++this._charLineIndex; + if (this._parseIndex == this._textData.length) + this._reachedEOF = true; + return ch; + }; + /** + * Retrieves the next integer in the data stream. + */ + MD5AnimParser.prototype.getNextInt = function () { + var i = parseInt(this.getNextToken()); + if (isNaN(i)) + this.sendParseError("int type"); + return i; + }; + /** + * Retrieves the next floating point number in the data stream. + */ + MD5AnimParser.prototype.getNextNumber = function () { + var f = parseFloat(this.getNextToken()); + if (isNaN(f)) + this.sendParseError("float type"); + return f; + }; + /** + * Retrieves the next 3d vector in the data stream. + */ + MD5AnimParser.prototype.parseVector3D = function () { + var vec = new Vector3D(); + var ch = this.getNextToken(); + if (ch != "(") + this.sendParseError("("); + vec.x = this.getNextNumber(); + vec.y = this.getNextNumber(); + vec.z = this.getNextNumber(); + if (this.getNextToken() != ")") + this.sendParseError(")"); + return vec; + }; + /** + * Retrieves the next quaternion in the data stream. + */ + MD5AnimParser.prototype.parseQuaternion = function () { + var quat = new Quaternion(); + var ch = this.getNextToken(); + if (ch != "(") + this.sendParseError("("); + quat.x = this.getNextNumber(); + quat.y = this.getNextNumber(); + quat.z = this.getNextNumber(); + // quat supposed to be unit length + var t = 1 - (quat.x * quat.x) - (quat.y * quat.y) - (quat.z * quat.z); + quat.w = t < 0 ? 0 : -Math.sqrt(t); + if (this.getNextToken() != ")") + this.sendParseError(")"); + return quat; + }; + /** + * Parses the command line data. + */ + MD5AnimParser.prototype.parseCMD = function () { + // just ignore the command line property + this.parseLiteralstring(); + }; + /** + * Retrieves the next literal string in the data stream. A literal string is a sequence of characters bounded + * by double quotes. + */ + MD5AnimParser.prototype.parseLiteralstring = function () { + this.skipWhiteSpace(); + var ch = this.getNextChar(); + var str = ""; + if (ch != "\"") + this.sendParseError("\""); + do { + if (this._reachedEOF) + this.sendEOFError(); + ch = this.getNextChar(); + if (ch != "\"") + str += ch; + } while (ch != "\""); + return str; + }; + /** + * Throws an end-of-file error when a premature end of file was encountered. + */ + MD5AnimParser.prototype.sendEOFError = function () { + throw new Error("Unexpected end of file"); + }; + /** + * Throws an error when an unexpected token was encountered. + * @param expected The token type that was actually expected. + */ + MD5AnimParser.prototype.sendParseError = function (expected) { + throw new Error("Unexpected token at line " + (this._line + 1) + ", character " + this._charLineIndex + ". " + expected + " expected, but " + this._textData.charAt(this._parseIndex - 1) + " encountered"); + }; + /** + * Throws an error when an unknown keyword was encountered. + */ + MD5AnimParser.prototype.sendUnknownKeywordError = function () { + throw new Error("Unknown keyword at line " + (this._line + 1) + ", character " + this._charLineIndex + ". "); + }; + MD5AnimParser.VERSION_TOKEN = "MD5Version"; + MD5AnimParser.COMMAND_LINE_TOKEN = "commandline"; + MD5AnimParser.NUM_FRAMES_TOKEN = "numFrames"; + MD5AnimParser.NUM_JOINTS_TOKEN = "numJoints"; + MD5AnimParser.FRAME_RATE_TOKEN = "frameRate"; + MD5AnimParser.NUM_ANIMATED_COMPONENTS_TOKEN = "numAnimatedComponents"; + MD5AnimParser.HIERARCHY_TOKEN = "hierarchy"; + MD5AnimParser.BOUNDS_TOKEN = "bounds"; + MD5AnimParser.BASE_FRAME_TOKEN = "baseframe"; + MD5AnimParser.FRAME_TOKEN = "frame"; + MD5AnimParser.COMMENT_TOKEN = "//"; + return MD5AnimParser; +})(ParserBase); +module.exports = MD5AnimParser; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/md5animparser.ts"],"names":["MD5AnimParser","MD5AnimParser.constructor","MD5AnimParser.supportsType","MD5AnimParser.supportsData","MD5AnimParser._pProceedParsing","MD5AnimParser.translateClip","MD5AnimParser.translatePose","MD5AnimParser.parseHierarchy","MD5AnimParser.parseBounds","MD5AnimParser.parseBaseFrame","MD5AnimParser.parseFrame","MD5AnimParser.putBack","MD5AnimParser.getNextToken","MD5AnimParser.skipWhiteSpace","MD5AnimParser.ignoreLine","MD5AnimParser.getNextChar","MD5AnimParser.getNextInt","MD5AnimParser.getNextNumber","MD5AnimParser.parseVector3D","MD5AnimParser.parseQuaternion","MD5AnimParser.parseCMD","MD5AnimParser.parseLiteralstring","MD5AnimParser.sendEOFError","MD5AnimParser.sendParseError","MD5AnimParser.sendUnknownKeywordError"],"mappings":"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AIA,QAAQA,GAAgBA,IAAIA,YAAYA,EAAEA,CAACA;QAC/CA,IAAIA,UAAUA,GAAoBA,QAAQA,CAACA,UAAUA,CAACA;QAEtDA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAkBA,CAACA,EAAEA,CAACA,GAAGA,IAAIA,CAACA,UAAUA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;YACzDA,CAACA,GAAGA,CAACA,CAACA;YACNA,IAAIA,GAAGA,IAAIA,SAASA,EAAEA,CAACA;YACvBA,SAASA,GAAGA,IAAIA,CAACA,UAAUA,CAACA,CAACA,CAACA,CAACA;YAC/BA,IAAIA,GAAGA,IAAIA,CAACA,cAAcA,CAACA,CAACA,CAACA,CAACA;YAC9BA,KAAKA,GAAGA,SAASA,CAACA,KAAKA,CAACA;YACxBA,SAASA,CAACA,CAACA,GAAGA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA;YAC9BA,SAASA,CAACA,CAACA,GAAGA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA;YAC9BA,SAASA,CAACA,CAACA,GAAGA,IAAIA,CAACA,QAAQA,CAACA,CAACA,CAACA;YAC9BA,WAAWA,CAACA,CAACA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,CAACA,CAACA;YACnCA,WAAWA,CAACA,CAACA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,CAACA,CAACA;YACnCA,WAAWA,CAACA,CAACA,GAAGA,IAAIA,CAACA,WAAWA,CAACA,CAACA,CAACA;YAEnCA,EAAEA,CAACA,CAACA,KAAKA,GAAGA,CAACA,CAACA;gBACbA,SAASA,CAACA,CAACA,GAAGA,UAAUA,CAACA,SAASA,CAACA,UAAUA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;YACxDA,EAAEA,CAACA,CAACA,KAAKA,GAAGA,CAACA,CAACA;gBACbA,SAASA,CAACA,CAACA,GAAGA,UAAUA,CAACA,SAASA,CAACA,UAAUA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;YACxDA,EAAEA,CAACA,CAACA,KAAKA,GAAGA,CAACA,CAACA;gBACbA,SAASA,CAACA,CAACA,GAAGA,UAAUA,CAACA,SAASA,CAACA,UAAUA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;YACxDA,EAAEA,CAACA,CAACA,KAAKA,GAAGA,CAACA,CAACA;gBACbA,WAAWA,CAACA,CAACA,GAAGA,UAAUA,CAACA,SAASA,CAACA,UAAUA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;YAC1DA,EAAEA,CAACA,CAACA,KAAKA,GAAGA,EAAEA,CAACA;gBACdA,WAAWA,CAACA,CAACA,GAAGA,UAAUA,CAACA,SAASA,CAACA,UAAUA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;YAC1DA,EAAEA,CAACA,CAACA,KAAKA,GAAGA,EAAEA,CAACA;gBACdA,WAAWA,CAACA,CAACA,GAAGA,UAAUA,CAACA,SAASA,CAACA,UAAUA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;YAE1DA,IAAIA,CAACA,GAAUA,CAACA,GAAGA,WAAWA,CAACA,CAACA,GAACA,WAAWA,CAACA,CAACA,GAAGA,WAAWA,CAACA,CAACA,GAACA,WAAWA,CAACA,CAACA,GAAGA,WAAWA,CAACA,CAACA,GAACA,WAAWA,CAACA,CAACA,CAACA;YAC3GA,WAAWA,CAACA,CAACA,GAAGA,CAACA,GAAGA,CAACA,GAAEA,CAACA,GAAGA,CAACA,IAAIA,CAACA,IAAIA,CAACA,CAACA,CAACA,CAACA;YAEzCA,EAAEA,CAACA,CAACA,SAASA,CAACA,WAAWA,GAAGA,CAACA,CAACA,CAACA,CAACA;gBAC/BA,IAAIA,CAACA,WAAWA,CAACA,QAAQA,CAACA,IAAIA,CAACA,aAAaA,EAAEA,WAAWA,CAACA,CAACA;gBAC3DA,IAAIA,CAACA,WAAWA,GAAGA,IAAIA,CAACA,aAAaA,CAACA,WAAWA,CAACA,SAASA,CAACA,CAACA;YAC9DA,CAACA;YAACA,IAAIA,CAACA,CAACA;gBACPA,IAAIA,CAACA,WAAWA,CAACA,QAAQA,CAACA,WAAWA,CAACA,CA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","file":"parsers/MD5AnimParser.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Quaternion\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Quaternion\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport URLLoaderDataFormat\t\t\t\t= require(\"awayjs-core/lib/core/net/URLLoaderDataFormat\");\nimport ParserBase\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserBase\");\n\nimport JointPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/JointPose\");\nimport SkeletonPose\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonPose\");\nimport SkeletonClipNode\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/nodes/SkeletonClipNode\");\nimport BaseFrameData\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/BaseFrameData\");\nimport BoundsData\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/BoundsData\");\nimport FrameData\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/FrameData\");\nimport HierarchyData\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/HierarchyData\");\n\n/**\n * MD5AnimParser provides a parser for the md5anim data type, providing an animation sequence for the md5 format.\n *\n * todo: optimize\n */\nclass MD5AnimParser extends ParserBase\n{\n\tprivate _textData:string;\n\tprivate _startedParsing:boolean;\n\tpublic static VERSION_TOKEN:string = \"MD5Version\";\n\tpublic static COMMAND_LINE_TOKEN:string = \"commandline\";\n\tpublic static NUM_FRAMES_TOKEN:string = \"numFrames\";\n\tpublic static NUM_JOINTS_TOKEN:string = \"numJoints\";\n\tpublic static FRAME_RATE_TOKEN:string = \"frameRate\";\n\tpublic static NUM_ANIMATED_COMPONENTS_TOKEN:string = \"numAnimatedComponents\";\n\n\tpublic static HIERARCHY_TOKEN:string = \"hierarchy\";\n\tpublic static BOUNDS_TOKEN:string = \"bounds\";\n\tpublic static BASE_FRAME_TOKEN:string = \"baseframe\";\n\tpublic static FRAME_TOKEN:string = \"frame\";\n\n\tpublic static COMMENT_TOKEN:string = \"//\";\n\n\tprivate _parseIndex:number /*int*/ = 0;\n\tprivate _reachedEOF:boolean;\n\tprivate _line:number /*int*/ = 0;\n\tprivate _charLineIndex:number /*int*/ = 0;\n\tprivate _version:number /*int*/;\n\tprivate _frameRate:number /*int*/;\n\tprivate _numFrames:number /*int*/;\n\tprivate _numJoints:number /*int*/;\n\tprivate _numAnimatedComponents:number /*int*/;\n\n\tprivate _hierarchy:Array<HierarchyData>;\n\tprivate _bounds:Array<BoundsData>;\n\tprivate _frameData:Array<FrameData>;\n\tprivate _baseFrameData:Array<BaseFrameData>;\n\n\tprivate _rotationQuat:Quaternion;\n\tprivate _clip:SkeletonClipNode;\n\n\t/**\n\t * Creates a new MD5AnimParser object.\n\t * @param uri The url or id of the data or file to be parsed.\n\t * @param extra The holder for extra contextual data that the parser might need.\n\t */\n\tconstructor(additionalRotationAxis:Vector3D = null, additionalRotationRadians:number = 0)\n\t{\n\t\tsuper(URLLoaderDataFormat.TEXT);\n\t\tthis._rotationQuat = new Quaternion();\n\t\tvar t1:Quaternion = new Quaternion();\n\t\tvar t2:Quaternion = new Quaternion();\n\n\t\tt1.fromAxisAngle(Vector3D.X_AXIS, -Math.PI*.5);\n\t\tt2.fromAxisAngle(Vector3D.Y_AXIS, -Math.PI*.5);\n\n\t\tthis._rotationQuat.multiply(t2, t1);\n\n\t\tif (additionalRotationAxis) {\n\t\t\tthis._rotationQuat.multiply(t2, t1);\n\t\t\tt1.fromAxisAngle(additionalRotationAxis, additionalRotationRadians);\n\t\t\tthis._rotationQuat.multiply(t1, this._rotationQuat);\n\t\t}\n\t}\n\n\t/**\n\t * Indicates whether or not a given file extension is supported by the parser.\n\t * @param extension The file extension of a potential file to be parsed.\n\t * @return Whether or not the given file type is supported.\n\t */\n\tpublic static supportsType(extension:string):boolean\n\t{\n\t\textension = extension.toLowerCase();\n\t\treturn extension == \"md5anim\";\n\t}\n\n\t/**\n\t * Tests whether a data block can be parsed by the parser.\n\t * @param data The data block to potentially be parsed.\n\t * @return Whether or not the given data is supported.\n\t */\n\tpublic static supportsData(data:any):boolean\n\t{\n\t\treturn false;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pProceedParsing():boolean\n\t{\n\t\tvar token:string;\n\n\t\tif (!this._startedParsing) {\n\t\t\tthis._textData = this._pGetTextData();\n\t\t\tthis._startedParsing = true;\n\t\t}\n\n\t\twhile (this._pHasTime()) {\n\t\t\ttoken = this.getNextToken();\n\t\t\tswitch (token) {\n\t\t\t\tcase MD5AnimParser.COMMENT_TOKEN:\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"\":\n\t\t\t\t\t// can occur at the end of a file\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.VERSION_TOKEN:\n\t\t\t\t\tthis._version = this.getNextInt();\n\t\t\t\t\tif (this._version != 10)\n\t\t\t\t\t\tthrow new Error(\"Unknown version number encountered!\");\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.COMMAND_LINE_TOKEN:\n\t\t\t\t\tthis.parseCMD();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.NUM_FRAMES_TOKEN:\n\t\t\t\t\tthis._numFrames = this.getNextInt();\n\t\t\t\t\tthis._bounds = new Array<BoundsData>();\n\t\t\t\t\tthis._frameData = new Array<FrameData>();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.NUM_JOINTS_TOKEN:\n\t\t\t\t\tthis._numJoints = this.getNextInt();\n\t\t\t\t\tthis._hierarchy = new Array<HierarchyData>(this._numJoints);\n\t\t\t\t\tthis._baseFrameData = new Array<BaseFrameData>(this._numJoints);\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.FRAME_RATE_TOKEN:\n\t\t\t\t\tthis._frameRate = this.getNextInt();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.NUM_ANIMATED_COMPONENTS_TOKEN:\n\t\t\t\t\tthis._numAnimatedComponents = this.getNextInt();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.HIERARCHY_TOKEN:\n\t\t\t\t\tthis.parseHierarchy();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.BOUNDS_TOKEN:\n\t\t\t\t\tthis.parseBounds();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.BASE_FRAME_TOKEN:\n\t\t\t\t\tthis.parseBaseFrame();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5AnimParser.FRAME_TOKEN:\n\t\t\t\t\tthis.parseFrame();\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tif (!this._reachedEOF)\n\t\t\t\t\t\tthis.sendUnknownKeywordError();\n\t\t\t}\n\n\t\t\tif (this._reachedEOF) {\n\t\t\t\tthis._clip = new SkeletonClipNode();\n\t\t\t\tthis.translateClip();\n\t\t\t\tthis._pFinalizeAsset(this._clip);\n\t\t\t\treturn ParserBase.PARSING_DONE;\n\t\t\t}\n\t\t}\n\t\treturn ParserBase.MORE_TO_PARSE;\n\t}\n\n\t/**\n\t * Converts all key frame data to an SkinnedAnimationSequence.\n\t */\n\tprivate translateClip():void\n\t{\n\t\tfor (var i:number /*int*/ = 0; i < this._numFrames; ++i)\n\t\t\tthis._clip.addFrame(this.translatePose(this._frameData[i]), 1000/this._frameRate);\n\t}\n\n\t/**\n\t * Converts a single key frame data to a SkeletonPose.\n\t * @param frameData The actual frame data.\n\t * @return A SkeletonPose containing the frame data's pose.\n\t */\n\tprivate translatePose(frameData:FrameData):SkeletonPose\n\t{\n\t\tvar hierarchy:HierarchyData;\n\t\tvar pose:JointPose;\n\t\tvar base:BaseFrameData;\n\t\tvar flags:number /*int*/;\n\t\tvar j:number /*int*/;\n\t\tvar translate:Vector3D = new Vector3D();\n\t\tvar orientation:Quaternion = new Quaternion();\n\t\tvar components:Array<number> = frameData.components;\n\t\tvar skelPose:SkeletonPose = new SkeletonPose();\n\t\tvar jointPoses:Array<JointPose> = skelPose.jointPoses;\n\n\t\tfor (var i:number /*int*/ = 0; i < this._numJoints; ++i) {\n\t\t\tj = 0;\n\t\t\tpose = new JointPose();\n\t\t\thierarchy = this._hierarchy[i];\n\t\t\tbase = this._baseFrameData[i];\n\t\t\tflags = hierarchy.flags;\n\t\t\ttranslate.x = base.position.x;\n\t\t\ttranslate.y = base.position.y;\n\t\t\ttranslate.z = base.position.z;\n\t\t\torientation.x = base.orientation.x;\n\t\t\torientation.y = base.orientation.y;\n\t\t\torientation.z = base.orientation.z;\n\n\t\t\tif (flags & 1)\n\t\t\t\ttranslate.x = components[hierarchy.startIndex + (j++)];\n\t\t\tif (flags & 2)\n\t\t\t\ttranslate.y = components[hierarchy.startIndex + (j++)];\n\t\t\tif (flags & 4)\n\t\t\t\ttranslate.z = components[hierarchy.startIndex + (j++)];\n\t\t\tif (flags & 8)\n\t\t\t\torientation.x = components[hierarchy.startIndex + (j++)];\n\t\t\tif (flags & 16)\n\t\t\t\torientation.y = components[hierarchy.startIndex + (j++)];\n\t\t\tif (flags & 32)\n\t\t\t\torientation.z = components[hierarchy.startIndex + (j++)];\n\n\t\t\tvar w:number = 1 - orientation.x*orientation.x - orientation.y*orientation.y - orientation.z*orientation.z;\n\t\t\torientation.w = w < 0? 0 : -Math.sqrt(w);\n\n\t\t\tif (hierarchy.parentIndex < 0) {\n\t\t\t\tpose.orientation.multiply(this._rotationQuat, orientation);\n\t\t\t\tpose.translation = this._rotationQuat.rotatePoint(translate);\n\t\t\t} else {\n\t\t\t\tpose.orientation.copyFrom(orientation);\n\t\t\t\tpose.translation.x = translate.x;\n\t\t\t\tpose.translation.y = translate.y;\n\t\t\t\tpose.translation.z = translate.z;\n\t\t\t}\n\t\t\tpose.orientation.y = -pose.orientation.y;\n\t\t\tpose.orientation.z = -pose.orientation.z;\n\t\t\tpose.translation.x = -pose.translation.x;\n\n\t\t\tjointPoses[i] = pose;\n\t\t}\n\n\t\treturn skelPose;\n\t}\n\n\t/**\n\t * Parses the skeleton's hierarchy data.\n\t */\n\tprivate parseHierarchy():void\n\t{\n\t\tvar ch:string;\n\t\tvar data:HierarchyData;\n\t\tvar token:string = this.getNextToken();\n\t\tvar i:number /*int*/ = 0;\n\n\t\tif (token != \"{\")\n\t\t\tthis.sendUnknownKeywordError();\n\n\t\tdo {\n\t\t\tif (this._reachedEOF)\n\t\t\t\tthis.sendEOFError();\n\t\t\tdata = new HierarchyData();\n\t\t\tdata.name = this.parseLiteralstring();\n\t\t\tdata.parentIndex = this.getNextInt();\n\t\t\tdata.flags = this.getNextInt();\n\t\t\tdata.startIndex = this.getNextInt();\n\t\t\tthis._hierarchy[i++] = data;\n\n\t\t\tch = this.getNextChar();\n\n\t\t\tif (ch == \"/\") {\n\t\t\t\tthis.putBack();\n\t\t\t\tch = this.getNextToken();\n\t\t\t\tif (ch == MD5AnimParser.COMMENT_TOKEN)\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\tch = this.getNextChar();\n\t\t\t}\n\n\t\t\tif (ch != \"}\")\n\t\t\t\tthis.putBack();\n\n\t\t} while (ch != \"}\");\n\t}\n\n\t/**\n\t * Parses frame bounds.\n\t */\n\tprivate parseBounds():void\n\t{\n\t\tvar ch:string;\n\t\tvar data:BoundsData;\n\t\tvar token:string = this.getNextToken();\n\t\tvar i:number /*int*/ = 0;\n\n\t\tif (token != \"{\")\n\t\t\tthis.sendUnknownKeywordError();\n\n\t\tdo {\n\t\t\tif (this._reachedEOF)\n\t\t\t\tthis.sendEOFError();\n\t\t\tdata = new BoundsData();\n\t\t\tdata.min = this.parseVector3D();\n\t\t\tdata.max = this.parseVector3D();\n\t\t\tthis._bounds[i++] = data;\n\n\t\t\tch = this.getNextChar();\n\n\t\t\tif (ch == \"/\") {\n\t\t\t\tthis.putBack();\n\t\t\t\tch = this.getNextToken();\n\t\t\t\tif (ch == MD5AnimParser.COMMENT_TOKEN)\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\tch = this.getNextChar();\n\t\t\t}\n\n\t\t\tif (ch != \"}\")\n\t\t\t\tthis.putBack();\n\n\t\t} while (ch != \"}\");\n\t}\n\n\t/**\n\t * Parses the base frame.\n\t */\n\tprivate parseBaseFrame():void\n\t{\n\t\tvar ch:string;\n\t\tvar data:BaseFrameData;\n\t\tvar token:string = this.getNextToken();\n\t\tvar i:number /*int*/ = 0;\n\n\t\tif (token != \"{\")\n\t\t\tthis.sendUnknownKeywordError();\n\n\t\tdo {\n\t\t\tif (this._reachedEOF)\n\t\t\t\tthis.sendEOFError();\n\t\t\tdata = new BaseFrameData();\n\t\t\tdata.position = this.parseVector3D();\n\t\t\tdata.orientation = this.parseQuaternion();\n\t\t\tthis._baseFrameData[i++] = data;\n\n\t\t\tch = this.getNextChar();\n\n\t\t\tif (ch == \"/\") {\n\t\t\t\tthis.putBack();\n\t\t\t\tch = this.getNextToken();\n\t\t\t\tif (ch == MD5AnimParser.COMMENT_TOKEN)\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\tch = this.getNextChar();\n\t\t\t}\n\n\t\t\tif (ch != \"}\")\n\t\t\t\tthis.putBack();\n\n\t\t} while (ch != \"}\");\n\t}\n\n\t/**\n\t * Parses a single frame.\n\t */\n\tprivate parseFrame():void\n\t{\n\t\tvar ch:string;\n\t\tvar data:FrameData;\n\t\tvar token:string;\n\t\tvar frameIndex:number /*int*/;\n\n\t\tframeIndex = this.getNextInt();\n\n\t\ttoken = this.getNextToken();\n\t\tif (token != \"{\")\n\t\t\tthis.sendUnknownKeywordError();\n\n\t\tdo {\n\t\t\tif (this._reachedEOF)\n\t\t\t\tthis.sendEOFError();\n\t\t\tdata = new FrameData();\n\t\t\tdata.components = new Array<number>(this._numAnimatedComponents);\n\n\t\t\tfor (var i:number /*int*/ = 0; i < this._numAnimatedComponents; ++i)\n\t\t\t\tdata.components[i] = this.getNextNumber();\n\n\t\t\tthis._frameData[frameIndex] = data;\n\n\t\t\tch = this.getNextChar();\n\n\t\t\tif (ch == \"/\") {\n\t\t\t\tthis.putBack();\n\t\t\t\tch = this.getNextToken();\n\t\t\t\tif (ch == MD5AnimParser.COMMENT_TOKEN)\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\tch = this.getNextChar();\n\t\t\t}\n\n\t\t\tif (ch != \"}\")\n\t\t\t\tthis.putBack();\n\n\t\t} while (ch != \"}\");\n\t}\n\n\t/**\n\t * Puts back the last read character into the data stream.\n\t */\n\tprivate putBack():void\n\t{\n\t\tthis._parseIndex--;\n\t\tthis._charLineIndex--;\n\t\tthis._reachedEOF = this._parseIndex >= this._textData.length;\n\t}\n\n\t/**\n\t * Gets the next token in the data stream.\n\t */\n\tprivate getNextToken():string\n\t{\n\t\tvar ch:string;\n\t\tvar token:string = \"\";\n\n\t\twhile (!this._reachedEOF) {\n\t\t\tch = this.getNextChar();\n\t\t\tif (ch == \" \" || ch == \"\\r\" || ch == \"\\n\" || ch == \"\\t\") {\n\t\t\t\tif (token != MD5AnimParser.COMMENT_TOKEN)\n\t\t\t\t\tthis.skipWhiteSpace();\n\t\t\t\tif (token != \"\")\n\t\t\t\t\treturn token;\n\t\t\t} else\n\t\t\t\ttoken += ch;\n\n\t\t\tif (token == MD5AnimParser.COMMENT_TOKEN)\n\t\t\t\treturn token;\n\t\t}\n\n\t\treturn token;\n\t}\n\n\t/**\n\t * Skips all whitespace in the data stream.\n\t */\n\tprivate skipWhiteSpace():void\n\t{\n\t\tvar ch:string;\n\n\t\tdo\n\t\t\tch = this.getNextChar(); while (ch == \"\\n\" || ch == \" \" || ch == \"\\r\" || ch == \"\\t\");\n\n\t\tthis.putBack();\n\t}\n\n\t/**\n\t * Skips to the next line.\n\t */\n\tprivate ignoreLine():void\n\t{\n\t\tvar ch:string;\n\t\twhile (!this._reachedEOF && ch != \"\\n\")\n\t\t\tch = this.getNextChar();\n\t}\n\n\t/**\n\t * Retrieves the next single character in the data stream.\n\t */\n\tprivate getNextChar():string\n\t{\n\t\tvar ch:string = this._textData.charAt(this._parseIndex++);\n\n\t\tif (ch == \"\\n\") {\n\t\t\t++this._line;\n\t\t\tthis._charLineIndex = 0;\n\t\t} else if (ch != \"\\r\")\n\t\t\t++this._charLineIndex;\n\n\t\tif (this._parseIndex == this._textData.length)\n\t\t\tthis._reachedEOF = true;\n\n\t\treturn ch;\n\t}\n\n\t/**\n\t * Retrieves the next integer in the data stream.\n\t */\n\tprivate getNextInt():number /*int*/\n\t{\n\t\tvar i:number = parseInt(this.getNextToken());\n\t\tif (isNaN(i))\n\t\t\tthis.sendParseError(\"int type\");\n\t\treturn i;\n\t}\n\n\t/**\n\t * Retrieves the next floating point number in the data stream.\n\t */\n\tprivate getNextNumber():number\n\t{\n\t\tvar f:number = parseFloat(this.getNextToken());\n\t\tif (isNaN(f))\n\t\t\tthis.sendParseError(\"float type\");\n\t\treturn f;\n\t}\n\n\t/**\n\t * Retrieves the next 3d vector in the data stream.\n\t */\n\tprivate parseVector3D():Vector3D\n\t{\n\t\tvar vec:Vector3D = new Vector3D();\n\t\tvar ch:string = this.getNextToken();\n\n\t\tif (ch != \"(\")\n\t\t\tthis.sendParseError(\"(\");\n\t\tvec.x = this.getNextNumber();\n\t\tvec.y = this.getNextNumber();\n\t\tvec.z = this.getNextNumber();\n\n\t\tif (this.getNextToken() != \")\")\n\t\t\tthis.sendParseError(\")\");\n\n\t\treturn vec;\n\t}\n\n\t/**\n\t * Retrieves the next quaternion in the data stream.\n\t */\n\tprivate parseQuaternion():Quaternion\n\t{\n\t\tvar quat:Quaternion = new Quaternion();\n\t\tvar ch:string = this.getNextToken();\n\n\t\tif (ch != \"(\")\n\t\t\tthis.sendParseError(\"(\");\n\t\tquat.x = this.getNextNumber();\n\t\tquat.y = this.getNextNumber();\n\t\tquat.z = this.getNextNumber();\n\n\t\t// quat supposed to be unit length\n\t\tvar t:number = 1 - (quat.x*quat.x) - (quat.y*quat.y) - (quat.z*quat.z);\n\t\tquat.w = t < 0? 0 : -Math.sqrt(t);\n\n\t\tif (this.getNextToken() != \")\")\n\t\t\tthis.sendParseError(\")\");\n\n\t\treturn quat;\n\t}\n\n\t/**\n\t * Parses the command line data.\n\t */\n\tprivate parseCMD():void\n\t{\n\t\t// just ignore the command line property\n\t\tthis.parseLiteralstring();\n\t}\n\n\t/**\n\t * Retrieves the next literal string in the data stream. A literal string is a sequence of characters bounded\n\t * by double quotes.\n\t */\n\tprivate parseLiteralstring():string\n\t{\n\t\tthis.skipWhiteSpace();\n\n\t\tvar ch:string = this.getNextChar();\n\t\tvar str:string = \"\";\n\n\t\tif (ch != \"\\\"\")\n\t\t\tthis.sendParseError(\"\\\"\");\n\n\t\tdo {\n\t\t\tif (this._reachedEOF)\n\t\t\t\tthis.sendEOFError();\n\t\t\tch = this.getNextChar();\n\t\t\tif (ch != \"\\\"\")\n\t\t\t\tstr += ch;\n\t\t} while (ch != \"\\\"\");\n\n\t\treturn str;\n\t}\n\n\t/**\n\t * Throws an end-of-file error when a premature end of file was encountered.\n\t */\n\tprivate sendEOFError():void\n\t{\n\t\tthrow new Error(\"Unexpected end of file\");\n\t}\n\n\t/**\n\t * Throws an error when an unexpected token was encountered.\n\t * @param expected The token type that was actually expected.\n\t */\n\tprivate sendParseError(expected:string):void\n\t{\n\t\tthrow new Error(\"Unexpected token at line \" + (this._line + 1) + \", character \" + this._charLineIndex + \". \" + expected + \" expected, but \" + this._textData.charAt(this._parseIndex - 1) + \" encountered\");\n\t}\n\n\t/**\n\t * Throws an error when an unknown keyword was encountered.\n\t */\n\tprivate sendUnknownKeywordError():void\n\t{\n\t\tthrow new Error(\"Unknown keyword at line \" + (this._line + 1) + \", character \" + this._charLineIndex + \". \");\n\t}\n}\n\nexport = MD5AnimParser;"]} \ No newline at end of file diff --git a/lib/parsers/MD5AnimParser.ts b/lib/parsers/MD5AnimParser.ts new file mode 100644 index 000000000..c4f5d6be3 --- /dev/null +++ b/lib/parsers/MD5AnimParser.ts @@ -0,0 +1,606 @@ +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +import ParserBase = require("awayjs-core/lib/parsers/ParserBase"); + +import JointPose = require("awayjs-renderergl/lib/animators/data/JointPose"); +import SkeletonPose = require("awayjs-renderergl/lib/animators/data/SkeletonPose"); +import SkeletonClipNode = require("awayjs-renderergl/lib/animators/nodes/SkeletonClipNode"); +import BaseFrameData = require("awayjs-renderergl/lib/parsers/data/BaseFrameData"); +import BoundsData = require("awayjs-renderergl/lib/parsers/data/BoundsData"); +import FrameData = require("awayjs-renderergl/lib/parsers/data/FrameData"); +import HierarchyData = require("awayjs-renderergl/lib/parsers/data/HierarchyData"); + +/** + * MD5AnimParser provides a parser for the md5anim data type, providing an animation sequence for the md5 format. + * + * todo: optimize + */ +class MD5AnimParser extends ParserBase +{ + private _textData:string; + private _startedParsing:boolean; + public static VERSION_TOKEN:string = "MD5Version"; + public static COMMAND_LINE_TOKEN:string = "commandline"; + public static NUM_FRAMES_TOKEN:string = "numFrames"; + public static NUM_JOINTS_TOKEN:string = "numJoints"; + public static FRAME_RATE_TOKEN:string = "frameRate"; + public static NUM_ANIMATED_COMPONENTS_TOKEN:string = "numAnimatedComponents"; + + public static HIERARCHY_TOKEN:string = "hierarchy"; + public static BOUNDS_TOKEN:string = "bounds"; + public static BASE_FRAME_TOKEN:string = "baseframe"; + public static FRAME_TOKEN:string = "frame"; + + public static COMMENT_TOKEN:string = "//"; + + private _parseIndex:number /*int*/ = 0; + private _reachedEOF:boolean; + private _line:number /*int*/ = 0; + private _charLineIndex:number /*int*/ = 0; + private _version:number /*int*/; + private _frameRate:number /*int*/; + private _numFrames:number /*int*/; + private _numJoints:number /*int*/; + private _numAnimatedComponents:number /*int*/; + + private _hierarchy:Array; + private _bounds:Array; + private _frameData:Array; + private _baseFrameData:Array; + + private _rotationQuat:Quaternion; + private _clip:SkeletonClipNode; + + /** + * Creates a new MD5AnimParser object. + * @param uri The url or id of the data or file to be parsed. + * @param extra The holder for extra contextual data that the parser might need. + */ + constructor(additionalRotationAxis:Vector3D = null, additionalRotationRadians:number = 0) + { + super(URLLoaderDataFormat.TEXT); + this._rotationQuat = new Quaternion(); + var t1:Quaternion = new Quaternion(); + var t2:Quaternion = new Quaternion(); + + t1.fromAxisAngle(Vector3D.X_AXIS, -Math.PI*.5); + t2.fromAxisAngle(Vector3D.Y_AXIS, -Math.PI*.5); + + this._rotationQuat.multiply(t2, t1); + + if (additionalRotationAxis) { + this._rotationQuat.multiply(t2, t1); + t1.fromAxisAngle(additionalRotationAxis, additionalRotationRadians); + this._rotationQuat.multiply(t1, this._rotationQuat); + } + } + + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + public static supportsType(extension:string):boolean + { + extension = extension.toLowerCase(); + return extension == "md5anim"; + } + + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + public static supportsData(data:any):boolean + { + return false; + } + + /** + * @inheritDoc + */ + public _pProceedParsing():boolean + { + var token:string; + + if (!this._startedParsing) { + this._textData = this._pGetTextData(); + this._startedParsing = true; + } + + while (this._pHasTime()) { + token = this.getNextToken(); + switch (token) { + case MD5AnimParser.COMMENT_TOKEN: + this.ignoreLine(); + break; + case "": + // can occur at the end of a file + break; + case MD5AnimParser.VERSION_TOKEN: + this._version = this.getNextInt(); + if (this._version != 10) + throw new Error("Unknown version number encountered!"); + break; + case MD5AnimParser.COMMAND_LINE_TOKEN: + this.parseCMD(); + break; + case MD5AnimParser.NUM_FRAMES_TOKEN: + this._numFrames = this.getNextInt(); + this._bounds = new Array(); + this._frameData = new Array(); + break; + case MD5AnimParser.NUM_JOINTS_TOKEN: + this._numJoints = this.getNextInt(); + this._hierarchy = new Array(this._numJoints); + this._baseFrameData = new Array(this._numJoints); + break; + case MD5AnimParser.FRAME_RATE_TOKEN: + this._frameRate = this.getNextInt(); + break; + case MD5AnimParser.NUM_ANIMATED_COMPONENTS_TOKEN: + this._numAnimatedComponents = this.getNextInt(); + break; + case MD5AnimParser.HIERARCHY_TOKEN: + this.parseHierarchy(); + break; + case MD5AnimParser.BOUNDS_TOKEN: + this.parseBounds(); + break; + case MD5AnimParser.BASE_FRAME_TOKEN: + this.parseBaseFrame(); + break; + case MD5AnimParser.FRAME_TOKEN: + this.parseFrame(); + break; + default: + if (!this._reachedEOF) + this.sendUnknownKeywordError(); + } + + if (this._reachedEOF) { + this._clip = new SkeletonClipNode(); + this.translateClip(); + this._pFinalizeAsset(this._clip); + return ParserBase.PARSING_DONE; + } + } + return ParserBase.MORE_TO_PARSE; + } + + /** + * Converts all key frame data to an SkinnedAnimationSequence. + */ + private translateClip():void + { + for (var i:number /*int*/ = 0; i < this._numFrames; ++i) + this._clip.addFrame(this.translatePose(this._frameData[i]), 1000/this._frameRate); + } + + /** + * Converts a single key frame data to a SkeletonPose. + * @param frameData The actual frame data. + * @return A SkeletonPose containing the frame data's pose. + */ + private translatePose(frameData:FrameData):SkeletonPose + { + var hierarchy:HierarchyData; + var pose:JointPose; + var base:BaseFrameData; + var flags:number /*int*/; + var j:number /*int*/; + var translate:Vector3D = new Vector3D(); + var orientation:Quaternion = new Quaternion(); + var components:Array = frameData.components; + var skelPose:SkeletonPose = new SkeletonPose(); + var jointPoses:Array = skelPose.jointPoses; + + for (var i:number /*int*/ = 0; i < this._numJoints; ++i) { + j = 0; + pose = new JointPose(); + hierarchy = this._hierarchy[i]; + base = this._baseFrameData[i]; + flags = hierarchy.flags; + translate.x = base.position.x; + translate.y = base.position.y; + translate.z = base.position.z; + orientation.x = base.orientation.x; + orientation.y = base.orientation.y; + orientation.z = base.orientation.z; + + if (flags & 1) + translate.x = components[hierarchy.startIndex + (j++)]; + if (flags & 2) + translate.y = components[hierarchy.startIndex + (j++)]; + if (flags & 4) + translate.z = components[hierarchy.startIndex + (j++)]; + if (flags & 8) + orientation.x = components[hierarchy.startIndex + (j++)]; + if (flags & 16) + orientation.y = components[hierarchy.startIndex + (j++)]; + if (flags & 32) + orientation.z = components[hierarchy.startIndex + (j++)]; + + var w:number = 1 - orientation.x*orientation.x - orientation.y*orientation.y - orientation.z*orientation.z; + orientation.w = w < 0? 0 : -Math.sqrt(w); + + if (hierarchy.parentIndex < 0) { + pose.orientation.multiply(this._rotationQuat, orientation); + pose.translation = this._rotationQuat.rotatePoint(translate); + } else { + pose.orientation.copyFrom(orientation); + pose.translation.x = translate.x; + pose.translation.y = translate.y; + pose.translation.z = translate.z; + } + pose.orientation.y = -pose.orientation.y; + pose.orientation.z = -pose.orientation.z; + pose.translation.x = -pose.translation.x; + + jointPoses[i] = pose; + } + + return skelPose; + } + + /** + * Parses the skeleton's hierarchy data. + */ + private parseHierarchy():void + { + var ch:string; + var data:HierarchyData; + var token:string = this.getNextToken(); + var i:number /*int*/ = 0; + + if (token != "{") + this.sendUnknownKeywordError(); + + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new HierarchyData(); + data.name = this.parseLiteralstring(); + data.parentIndex = this.getNextInt(); + data.flags = this.getNextInt(); + data.startIndex = this.getNextInt(); + this._hierarchy[i++] = data; + + ch = this.getNextChar(); + + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + + if (ch != "}") + this.putBack(); + + } while (ch != "}"); + } + + /** + * Parses frame bounds. + */ + private parseBounds():void + { + var ch:string; + var data:BoundsData; + var token:string = this.getNextToken(); + var i:number /*int*/ = 0; + + if (token != "{") + this.sendUnknownKeywordError(); + + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new BoundsData(); + data.min = this.parseVector3D(); + data.max = this.parseVector3D(); + this._bounds[i++] = data; + + ch = this.getNextChar(); + + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + + if (ch != "}") + this.putBack(); + + } while (ch != "}"); + } + + /** + * Parses the base frame. + */ + private parseBaseFrame():void + { + var ch:string; + var data:BaseFrameData; + var token:string = this.getNextToken(); + var i:number /*int*/ = 0; + + if (token != "{") + this.sendUnknownKeywordError(); + + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new BaseFrameData(); + data.position = this.parseVector3D(); + data.orientation = this.parseQuaternion(); + this._baseFrameData[i++] = data; + + ch = this.getNextChar(); + + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + + if (ch != "}") + this.putBack(); + + } while (ch != "}"); + } + + /** + * Parses a single frame. + */ + private parseFrame():void + { + var ch:string; + var data:FrameData; + var token:string; + var frameIndex:number /*int*/; + + frameIndex = this.getNextInt(); + + token = this.getNextToken(); + if (token != "{") + this.sendUnknownKeywordError(); + + do { + if (this._reachedEOF) + this.sendEOFError(); + data = new FrameData(); + data.components = new Array(this._numAnimatedComponents); + + for (var i:number /*int*/ = 0; i < this._numAnimatedComponents; ++i) + data.components[i] = this.getNextNumber(); + + this._frameData[frameIndex] = data; + + ch = this.getNextChar(); + + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5AnimParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + + if (ch != "}") + this.putBack(); + + } while (ch != "}"); + } + + /** + * Puts back the last read character into the data stream. + */ + private putBack():void + { + this._parseIndex--; + this._charLineIndex--; + this._reachedEOF = this._parseIndex >= this._textData.length; + } + + /** + * Gets the next token in the data stream. + */ + private getNextToken():string + { + var ch:string; + var token:string = ""; + + while (!this._reachedEOF) { + ch = this.getNextChar(); + if (ch == " " || ch == "\r" || ch == "\n" || ch == "\t") { + if (token != MD5AnimParser.COMMENT_TOKEN) + this.skipWhiteSpace(); + if (token != "") + return token; + } else + token += ch; + + if (token == MD5AnimParser.COMMENT_TOKEN) + return token; + } + + return token; + } + + /** + * Skips all whitespace in the data stream. + */ + private skipWhiteSpace():void + { + var ch:string; + + do + ch = this.getNextChar(); while (ch == "\n" || ch == " " || ch == "\r" || ch == "\t"); + + this.putBack(); + } + + /** + * Skips to the next line. + */ + private ignoreLine():void + { + var ch:string; + while (!this._reachedEOF && ch != "\n") + ch = this.getNextChar(); + } + + /** + * Retrieves the next single character in the data stream. + */ + private getNextChar():string + { + var ch:string = this._textData.charAt(this._parseIndex++); + + if (ch == "\n") { + ++this._line; + this._charLineIndex = 0; + } else if (ch != "\r") + ++this._charLineIndex; + + if (this._parseIndex == this._textData.length) + this._reachedEOF = true; + + return ch; + } + + /** + * Retrieves the next integer in the data stream. + */ + private getNextInt():number /*int*/ + { + var i:number = parseInt(this.getNextToken()); + if (isNaN(i)) + this.sendParseError("int type"); + return i; + } + + /** + * Retrieves the next floating point number in the data stream. + */ + private getNextNumber():number + { + var f:number = parseFloat(this.getNextToken()); + if (isNaN(f)) + this.sendParseError("float type"); + return f; + } + + /** + * Retrieves the next 3d vector in the data stream. + */ + private parseVector3D():Vector3D + { + var vec:Vector3D = new Vector3D(); + var ch:string = this.getNextToken(); + + if (ch != "(") + this.sendParseError("("); + vec.x = this.getNextNumber(); + vec.y = this.getNextNumber(); + vec.z = this.getNextNumber(); + + if (this.getNextToken() != ")") + this.sendParseError(")"); + + return vec; + } + + /** + * Retrieves the next quaternion in the data stream. + */ + private parseQuaternion():Quaternion + { + var quat:Quaternion = new Quaternion(); + var ch:string = this.getNextToken(); + + if (ch != "(") + this.sendParseError("("); + quat.x = this.getNextNumber(); + quat.y = this.getNextNumber(); + quat.z = this.getNextNumber(); + + // quat supposed to be unit length + var t:number = 1 - (quat.x*quat.x) - (quat.y*quat.y) - (quat.z*quat.z); + quat.w = t < 0? 0 : -Math.sqrt(t); + + if (this.getNextToken() != ")") + this.sendParseError(")"); + + return quat; + } + + /** + * Parses the command line data. + */ + private parseCMD():void + { + // just ignore the command line property + this.parseLiteralstring(); + } + + /** + * Retrieves the next literal string in the data stream. A literal string is a sequence of characters bounded + * by double quotes. + */ + private parseLiteralstring():string + { + this.skipWhiteSpace(); + + var ch:string = this.getNextChar(); + var str:string = ""; + + if (ch != "\"") + this.sendParseError("\""); + + do { + if (this._reachedEOF) + this.sendEOFError(); + ch = this.getNextChar(); + if (ch != "\"") + str += ch; + } while (ch != "\""); + + return str; + } + + /** + * Throws an end-of-file error when a premature end of file was encountered. + */ + private sendEOFError():void + { + throw new Error("Unexpected end of file"); + } + + /** + * Throws an error when an unexpected token was encountered. + * @param expected The token type that was actually expected. + */ + private sendParseError(expected:string):void + { + throw new Error("Unexpected token at line " + (this._line + 1) + ", character " + this._charLineIndex + ". " + expected + " expected, but " + this._textData.charAt(this._parseIndex - 1) + " encountered"); + } + + /** + * Throws an error when an unknown keyword was encountered. + */ + private sendUnknownKeywordError():void + { + throw new Error("Unknown keyword at line " + (this._line + 1) + ", character " + this._charLineIndex + ". "); + } +} + +export = MD5AnimParser; \ No newline at end of file diff --git a/lib/parsers/MD5MeshParser.js b/lib/parsers/MD5MeshParser.js new file mode 100755 index 000000000..4853e8379 --- /dev/null +++ b/lib/parsers/MD5MeshParser.js @@ -0,0 +1,549 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +var Geometry = require("awayjs-core/lib/core/base/Geometry"); +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +var Mesh = require("awayjs-core/lib/entities/Mesh"); +var ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +var SkeletonAnimationSet = require("awayjs-renderergl/lib/animators/SkeletonAnimationSet"); +var Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +var SkeletonJoint = require("awayjs-renderergl/lib/animators/data/SkeletonJoint"); +// todo: create animation system, parse skeleton +/** + * MD5MeshParser provides a parser for the md5mesh data type, providing the geometry of the md5 format. + * + * todo: optimize + */ +var MD5MeshParser = (function (_super) { + __extends(MD5MeshParser, _super); + /** + * Creates a new MD5MeshParser object. + */ + function MD5MeshParser(additionalRotationAxis, additionalRotationRadians) { + if (additionalRotationAxis === void 0) { additionalRotationAxis = null; } + if (additionalRotationRadians === void 0) { additionalRotationRadians = 0; } + _super.call(this, URLLoaderDataFormat.TEXT); + this._parseIndex = 0; + this._line = 0; + this._charLineIndex = 0; + this._rotationQuat = new Quaternion(); + this._rotationQuat.fromAxisAngle(Vector3D.X_AXIS, -Math.PI * .5); + if (additionalRotationAxis) { + var quat = new Quaternion(); + quat.fromAxisAngle(additionalRotationAxis, additionalRotationRadians); + this._rotationQuat.multiply(this._rotationQuat, quat); + } + } + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + MD5MeshParser.supportsType = function (extension) { + extension = extension.toLowerCase(); + return extension == "md5mesh"; + }; + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + MD5MeshParser.supportsData = function (data) { + return false; + }; + /** + * @inheritDoc + */ + MD5MeshParser.prototype._pProceedParsing = function () { + var token; + if (!this._startedParsing) { + this._textData = this._pGetTextData(); + this._startedParsing = true; + } + while (this._pHasTime()) { + token = this.getNextToken(); + switch (token) { + case MD5MeshParser.COMMENT_TOKEN: + this.ignoreLine(); + break; + case MD5MeshParser.VERSION_TOKEN: + this._version = this.getNextInt(); + if (this._version != 10) + throw new Error("Unknown version number encountered!"); + break; + case MD5MeshParser.COMMAND_LINE_TOKEN: + this.parseCMD(); + break; + case MD5MeshParser.NUM_JOINTS_TOKEN: + this._numJoints = this.getNextInt(); + this._bindPoses = new Array(this._numJoints); + break; + case MD5MeshParser.NUM_MESHES_TOKEN: + this._numMeshes = this.getNextInt(); + break; + case MD5MeshParser.JOINTS_TOKEN: + this.parseJoints(); + break; + case MD5MeshParser.MESH_TOKEN: + this.parseMesh(); + break; + default: + if (!this._reachedEOF) + this.sendUnknownKeywordError(); + } + if (this._reachedEOF) { + this.calculateMaxJointCount(); + this._animationSet = new SkeletonAnimationSet(this._maxJointCount); + this._mesh = new Mesh(new Geometry(), null); + this._geometry = this._mesh.geometry; + for (var i = 0; i < this._meshData.length; ++i) + this._geometry.addSubGeometry(this.translateGeom(this._meshData[i].vertexData, this._meshData[i].weightData, this._meshData[i].indices)); + //_geometry.animation = _animation; + // _mesh.animationController = _animationController; + //add to the content property + this._pContent.addChild(this._mesh); + this._pFinalizeAsset(this._geometry); + this._pFinalizeAsset(this._mesh); + this._pFinalizeAsset(this._skeleton); + this._pFinalizeAsset(this._animationSet); + return ParserBase.PARSING_DONE; + } + } + return ParserBase.MORE_TO_PARSE; + }; + MD5MeshParser.prototype._pStartParsing = function (frameLimit) { + _super.prototype._pStartParsing.call(this, frameLimit); + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + }; + MD5MeshParser.prototype.calculateMaxJointCount = function () { + this._maxJointCount = 0; + var numMeshData = this._meshData.length; + for (var i = 0; i < numMeshData; ++i) { + var meshData = this._meshData[i]; + var vertexData = meshData.vertexData; + var numVerts = vertexData.length; + for (var j = 0; j < numVerts; ++j) { + var zeroWeights = this.countZeroWeightJoints(vertexData[j], meshData.weightData); + var totalJoints = vertexData[j].countWeight - zeroWeights; + if (totalJoints > this._maxJointCount) + this._maxJointCount = totalJoints; + } + } + }; + MD5MeshParser.prototype.countZeroWeightJoints = function (vertex, weights) { + var start = vertex.startWeight; + var end = vertex.startWeight + vertex.countWeight; + var count = 0; + var weight; + for (var i = start; i < end; ++i) { + weight = weights[i].bias; + if (weight == 0) + ++count; + } + return count; + }; + /** + * Parses the skeleton's joints. + */ + MD5MeshParser.prototype.parseJoints = function () { + var ch; + var joint; + var pos; + var quat; + var i = 0; + var token = this.getNextToken(); + if (token != "{") + this.sendUnknownKeywordError(); + this._skeleton = new Skeleton(); + do { + if (this._reachedEOF) + this.sendEOFError(); + joint = new SkeletonJoint(); + joint.name = this.parseLiteralstring(); + joint.parentIndex = this.getNextInt(); + pos = this.parseVector3D(); + pos = this._rotationQuat.rotatePoint(pos); + quat = this.parseQuaternion(); + // todo: check if this is correct, or maybe we want to actually store it as quats? + this._bindPoses[i] = quat.toMatrix3D(); + this._bindPoses[i].appendTranslation(pos.x, pos.y, pos.z); + var inv = this._bindPoses[i].clone(); + inv.invert(); + joint.inverseBindPose = inv.rawData; + this._skeleton.joints[i++] = joint; + ch = this.getNextChar(); + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5MeshParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + } + if (ch != "}") + this.putBack(); + } while (ch != "}"); + }; + /** + * Puts back the last read character into the data stream. + */ + MD5MeshParser.prototype.putBack = function () { + this._parseIndex--; + this._charLineIndex--; + this._reachedEOF = this._parseIndex >= this._textData.length; + }; + /** + * Parses the mesh geometry. + */ + MD5MeshParser.prototype.parseMesh = function () { + var token = this.getNextToken(); + var ch; + var vertexData; + var weights; + var indices /*uint*/; + if (token != "{") + this.sendUnknownKeywordError(); + if (this._shaders == null) + this._shaders = new Array(); + while (ch != "}") { + ch = this.getNextToken(); + switch (ch) { + case MD5MeshParser.COMMENT_TOKEN: + this.ignoreLine(); + break; + case MD5MeshParser.MESH_SHADER_TOKEN: + this._shaders.push(this.parseLiteralstring()); + break; + case MD5MeshParser.MESH_NUM_VERTS_TOKEN: + vertexData = new Array(this.getNextInt()); + break; + case MD5MeshParser.MESH_NUM_TRIS_TOKEN: + indices = new Array(this.getNextInt() * 3); + break; + case MD5MeshParser.MESH_NUM_WEIGHTS_TOKEN: + weights = new Array(this.getNextInt()); + break; + case MD5MeshParser.MESH_VERT_TOKEN: + this.parseVertex(vertexData); + break; + case MD5MeshParser.MESH_TRI_TOKEN: + this.parseTri(indices); + break; + case MD5MeshParser.MESH_WEIGHT_TOKEN: + this.parseJoint(weights); + break; + } + } + if (this._meshData == null) + this._meshData = new Array(); + var i = this._meshData.length; + this._meshData[i] = new MeshData(); + this._meshData[i].vertexData = vertexData; + this._meshData[i].weightData = weights; + this._meshData[i].indices = indices; + }; + /** + * Converts the mesh data to a SkinnedSub instance. + * @param vertexData The mesh's vertices. + * @param weights The joint weights per vertex. + * @param indices The indices for the faces. + * @return A SubGeometry instance containing all geometrical data for the current mesh. + */ + MD5MeshParser.prototype.translateGeom = function (vertexData, weights, indices /*uint*/) { + var len = vertexData.length; + var v1 /*int*/, v2 /*int*/, v3 /*int*/; + var vertex; + var weight; + var bindPose; + var pos; + var subGeom = new TriangleSubGeometry(true); + var uvs = new Array(len * 2); + var vertices = new Array(len * 3); + var jointIndices = new Array(len * this._maxJointCount); + var jointWeights = new Array(len * this._maxJointCount); + var l = 0; + var nonZeroWeights /*int*/; + for (var i = 0; i < len; ++i) { + vertex = vertexData[i]; + v1 = vertex.index * 3; + v2 = v1 + 1; + v3 = v1 + 2; + vertices[v1] = vertices[v2] = vertices[v3] = 0; + nonZeroWeights = 0; + for (var j = 0; j < vertex.countWeight; ++j) { + weight = weights[vertex.startWeight + j]; + if (weight.bias > 0) { + bindPose = this._bindPoses[weight.joint]; + pos = bindPose.transformVector(weight.pos); + vertices[v1] += pos.x * weight.bias; + vertices[v2] += pos.y * weight.bias; + vertices[v3] += pos.z * weight.bias; + // indices need to be multiplied by 3 (amount of matrix registers) + jointIndices[l] = weight.joint * 3; + jointWeights[l++] = weight.bias; + ++nonZeroWeights; + } + } + for (j = nonZeroWeights; j < this._maxJointCount; ++j) { + jointIndices[l] = 0; + jointWeights[l++] = 0; + } + v1 = vertex.index << 1; + uvs[v1++] = vertex.s; + uvs[v1] = vertex.t; + } + subGeom.jointsPerVertex = this._maxJointCount; + subGeom.updateIndices(indices); + subGeom.updatePositions(vertices); + subGeom.updateUVs(uvs); + subGeom.updateJointIndices(jointIndices); + subGeom.updateJointWeights(jointWeights); + // cause explicit updates + subGeom.vertexNormals; + subGeom.vertexTangents; + // turn auto updates off because they may be animated and set explicitly + subGeom.autoDeriveTangents = false; + subGeom.autoDeriveNormals = false; + return subGeom; + }; + /** + * Retrieve the next triplet of vertex indices that form a face. + * @param indices The index list in which to store the read data. + */ + MD5MeshParser.prototype.parseTri = function (indices /*uint*/) { + var index = this.getNextInt() * 3; + indices[index] = this.getNextInt(); + indices[index + 1] = this.getNextInt(); + indices[index + 2] = this.getNextInt(); + }; + /** + * Reads a new joint data set for a single joint. + * @param weights the target list to contain the weight data. + */ + MD5MeshParser.prototype.parseJoint = function (weights) { + var weight = new JointData(); + weight.index = this.getNextInt(); + weight.joint = this.getNextInt(); + weight.bias = this.getNextNumber(); + weight.pos = this.parseVector3D(); + weights[weight.index] = weight; + }; + /** + * Reads the data for a single vertex. + * @param vertexData The list to contain the vertex data. + */ + MD5MeshParser.prototype.parseVertex = function (vertexData) { + var vertex = new VertexData(); + vertex.index = this.getNextInt(); + this.parseUV(vertex); + vertex.startWeight = this.getNextInt(); + vertex.countWeight = this.getNextInt(); + // if (vertex.countWeight > _maxJointCount) _maxJointCount = vertex.countWeight; + vertexData[vertex.index] = vertex; + }; + /** + * Reads the next uv coordinate. + * @param vertexData The vertexData to contain the UV coordinates. + */ + MD5MeshParser.prototype.parseUV = function (vertexData) { + var ch = this.getNextToken(); + if (ch != "(") + this.sendParseError("("); + vertexData.s = this.getNextNumber(); + vertexData.t = this.getNextNumber(); + if (this.getNextToken() != ")") + this.sendParseError(")"); + }; + /** + * Gets the next token in the data stream. + */ + MD5MeshParser.prototype.getNextToken = function () { + var ch; + var token = ""; + while (!this._reachedEOF) { + ch = this.getNextChar(); + if (ch == " " || ch == "\r" || ch == "\n" || ch == "\t") { + if (token != MD5MeshParser.COMMENT_TOKEN) + this.skipWhiteSpace(); + if (token != "") + return token; + } + else + token += ch; + if (token == MD5MeshParser.COMMENT_TOKEN) + return token; + } + return token; + }; + /** + * Skips all whitespace in the data stream. + */ + MD5MeshParser.prototype.skipWhiteSpace = function () { + var ch; + do + ch = this.getNextChar(); + while (ch == "\n" || ch == " " || ch == "\r" || ch == "\t"); + this.putBack(); + }; + /** + * Skips to the next line. + */ + MD5MeshParser.prototype.ignoreLine = function () { + var ch; + while (!this._reachedEOF && ch != "\n") + ch = this.getNextChar(); + }; + /** + * Retrieves the next single character in the data stream. + */ + MD5MeshParser.prototype.getNextChar = function () { + var ch = this._textData.charAt(this._parseIndex++); + if (ch == "\n") { + ++this._line; + this._charLineIndex = 0; + } + else if (ch != "\r") + ++this._charLineIndex; + if (this._parseIndex >= this._textData.length) + this._reachedEOF = true; + return ch; + }; + /** + * Retrieves the next integer in the data stream. + */ + MD5MeshParser.prototype.getNextInt = function () { + var i = parseInt(this.getNextToken()); + if (isNaN(i)) + this.sendParseError("int type"); + return i; + }; + /** + * Retrieves the next floating point number in the data stream. + */ + MD5MeshParser.prototype.getNextNumber = function () { + var f = parseFloat(this.getNextToken()); + if (isNaN(f)) + this.sendParseError("float type"); + return f; + }; + /** + * Retrieves the next 3d vector in the data stream. + */ + MD5MeshParser.prototype.parseVector3D = function () { + var vec = new Vector3D(); + var ch = this.getNextToken(); + if (ch != "(") + this.sendParseError("("); + vec.x = -this.getNextNumber(); + vec.y = this.getNextNumber(); + vec.z = this.getNextNumber(); + if (this.getNextToken() != ")") + this.sendParseError(")"); + return vec; + }; + /** + * Retrieves the next quaternion in the data stream. + */ + MD5MeshParser.prototype.parseQuaternion = function () { + var quat = new Quaternion(); + var ch = this.getNextToken(); + if (ch != "(") + this.sendParseError("("); + quat.x = this.getNextNumber(); + quat.y = -this.getNextNumber(); + quat.z = -this.getNextNumber(); + // quat supposed to be unit length + var t = 1 - quat.x * quat.x - quat.y * quat.y - quat.z * quat.z; + quat.w = t < 0 ? 0 : -Math.sqrt(t); + if (this.getNextToken() != ")") + this.sendParseError(")"); + var rotQuat = new Quaternion(); + rotQuat.multiply(this._rotationQuat, quat); + return rotQuat; + }; + /** + * Parses the command line data. + */ + MD5MeshParser.prototype.parseCMD = function () { + // just ignore the command line property + this.parseLiteralstring(); + }; + /** + * Retrieves the next literal string in the data stream. A literal string is a sequence of characters bounded + * by double quotes. + */ + MD5MeshParser.prototype.parseLiteralstring = function () { + this.skipWhiteSpace(); + var ch = this.getNextChar(); + var str = ""; + if (ch != "\"") + this.sendParseError("\""); + do { + if (this._reachedEOF) + this.sendEOFError(); + ch = this.getNextChar(); + if (ch != "\"") + str += ch; + } while (ch != "\""); + return str; + }; + /** + * Throws an end-of-file error when a premature end of file was encountered. + */ + MD5MeshParser.prototype.sendEOFError = function () { + throw new Error("Unexpected end of file"); + }; + /** + * Throws an error when an unexpected token was encountered. + * @param expected The token type that was actually expected. + */ + MD5MeshParser.prototype.sendParseError = function (expected) { + throw new Error("Unexpected token at line " + (this._line + 1) + ", character " + this._charLineIndex + ". " + expected + " expected, but " + this._textData.charAt(this._parseIndex - 1) + " encountered"); + }; + /** + * Throws an error when an unknown keyword was encountered. + */ + MD5MeshParser.prototype.sendUnknownKeywordError = function () { + throw new Error("Unknown keyword at line " + (this._line + 1) + ", character " + this._charLineIndex + ". "); + }; + MD5MeshParser.VERSION_TOKEN = "MD5Version"; + MD5MeshParser.COMMAND_LINE_TOKEN = "commandline"; + MD5MeshParser.NUM_JOINTS_TOKEN = "numJoints"; + MD5MeshParser.NUM_MESHES_TOKEN = "numMeshes"; + MD5MeshParser.COMMENT_TOKEN = "//"; + MD5MeshParser.JOINTS_TOKEN = "joints"; + MD5MeshParser.MESH_TOKEN = "mesh"; + MD5MeshParser.MESH_SHADER_TOKEN = "shader"; + MD5MeshParser.MESH_NUM_VERTS_TOKEN = "numverts"; + MD5MeshParser.MESH_VERT_TOKEN = "vert"; + MD5MeshParser.MESH_NUM_TRIS_TOKEN = "numtris"; + MD5MeshParser.MESH_TRI_TOKEN = "tri"; + MD5MeshParser.MESH_NUM_WEIGHTS_TOKEN = "numweights"; + MD5MeshParser.MESH_WEIGHT_TOKEN = "weight"; + return MD5MeshParser; +})(ParserBase); +var VertexData = (function () { + function VertexData() { + } + return VertexData; +})(); +var JointData = (function () { + function JointData() { + } + return JointData; +})(); +var MeshData = (function () { + function MeshData() { + } + return MeshData; +})(); +module.exports = MD5MeshParser; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/md5meshparser.ts"],"names":["MD5MeshParser","MD5MeshParser.constructor","MD5MeshParser.supportsType","MD5MeshParser.supportsData","MD5MeshParser._pProceedParsing","MD5MeshParser._pStartParsing","MD5MeshParser.calculateMaxJointCount","MD5MeshParser.countZeroWeightJoints","MD5MeshParser.parseJoints","MD5MeshParser.putBack","MD5MeshParser.parseMesh","MD5MeshParser.translateGeom","MD5MeshParser.parseTri","MD5MeshParser.parseJoint","MD5MeshParser.parseVertex","MD5MeshParser.parseUV","MD5MeshParser.getNextToken","MD5MeshParser.skipWhiteSpace","MD5MeshParser.ignoreLine","MD5MeshParser.getNextChar","MD5MeshParser.getNextInt","MD5MeshParser.getNextNumber","MD5MeshParser.parseVector3D","MD5MeshParser.parseQuaternion","MD5MeshParser.parseCMD","MD5MeshParser.parseLiteralstring","MD5MeshParser.sendEOFError","MD5MeshParser.sendParseError","MD5MeshParser.sendUnknownKeywordError","VertexData","VertexData.constructor","JointData","JointData.constructor","MeshData","MeshData.constructor"],"mappings":"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","file":"parsers/MD5MeshParser.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObjectContainer\t\t\t= require(\"awayjs-core/lib/containers/DisplayObjectContainer\");\nimport Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Quaternion\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Quaternion\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport URLLoaderDataFormat\t\t\t\t= require(\"awayjs-core/lib/core/net/URLLoaderDataFormat\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport ParserBase\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserBase\");\n\nimport SkeletonAnimationSet\t\t\t\t= require(\"awayjs-renderergl/lib/animators/SkeletonAnimationSet\");\nimport Skeleton\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/Skeleton\");\nimport SkeletonJoint\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/SkeletonJoint\");\n\n// todo: create animation system, parse skeleton\n\n/**\n * MD5MeshParser provides a parser for the md5mesh data type, providing the geometry of the md5 format.\n *\n * todo: optimize\n */\nclass MD5MeshParser extends ParserBase\n{\n\tprivate _textData:string;\n\tprivate _startedParsing:boolean;\n\tpublic static VERSION_TOKEN:string = \"MD5Version\";\n\tpublic static COMMAND_LINE_TOKEN:string = \"commandline\";\n\tpublic static NUM_JOINTS_TOKEN:string = \"numJoints\";\n\tpublic static NUM_MESHES_TOKEN:string = \"numMeshes\";\n\tpublic static COMMENT_TOKEN:string = \"//\";\n\tpublic static JOINTS_TOKEN:string = \"joints\";\n\tpublic static MESH_TOKEN:string = \"mesh\";\n\n\tpublic static MESH_SHADER_TOKEN:string = \"shader\";\n\tpublic static MESH_NUM_VERTS_TOKEN:string = \"numverts\";\n\tpublic static MESH_VERT_TOKEN:string = \"vert\";\n\tpublic static MESH_NUM_TRIS_TOKEN:string = \"numtris\";\n\tpublic static MESH_TRI_TOKEN:string = \"tri\";\n\tpublic static MESH_NUM_WEIGHTS_TOKEN:string = \"numweights\";\n\tpublic static MESH_WEIGHT_TOKEN:string = \"weight\";\n\n\tprivate _parseIndex:number /*int*/ = 0;\n\tprivate _reachedEOF:boolean;\n\tprivate _line:number /*int*/ = 0;\n\tprivate _charLineIndex:number /*int*/ = 0;\n\tprivate _version:number /*int*/;\n\tprivate _numJoints:number /*int*/;\n\tprivate _numMeshes:number /*int*/;\n\n\tprivate _mesh:Mesh;\n\tprivate _shaders:Array<string>;\n\n\tprivate _maxJointCount:number /*int*/;\n\tprivate _meshData:Array<MeshData>;\n\tprivate _bindPoses:Array<Matrix3D>;\n\tprivate _geometry:Geometry;\n\n\tprivate _skeleton:Skeleton;\n\tprivate _animationSet:SkeletonAnimationSet;\n\n\tprivate _rotationQuat:Quaternion;\n\n\t/**\n\t * Creates a new MD5MeshParser object.\n\t */\n\tconstructor(additionalRotationAxis:Vector3D = null, additionalRotationRadians:number = 0)\n\t{\n\t\tsuper(URLLoaderDataFormat.TEXT);\n\t\tthis._rotationQuat = new Quaternion();\n\n\t\tthis._rotationQuat.fromAxisAngle(Vector3D.X_AXIS, -Math.PI*.5);\n\n\t\tif (additionalRotationAxis) {\n\t\t\tvar quat:Quaternion = new Quaternion();\n\t\t\tquat.fromAxisAngle(additionalRotationAxis, additionalRotationRadians);\n\t\t\tthis._rotationQuat.multiply(this._rotationQuat, quat);\n\t\t}\n\t}\n\n\t/**\n\t * Indicates whether or not a given file extension is supported by the parser.\n\t * @param extension The file extension of a potential file to be parsed.\n\t * @return Whether or not the given file type is supported.\n\t */\n\tpublic static supportsType(extension:string):boolean\n\t{\n\t\textension = extension.toLowerCase();\n\t\treturn extension == \"md5mesh\";\n\t}\n\n\t/**\n\t * Tests whether a data block can be parsed by the parser.\n\t * @param data The data block to potentially be parsed.\n\t * @return Whether or not the given data is supported.\n\t */\n\tpublic static supportsData(data:any):boolean\n\t{\n\t\treturn false;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pProceedParsing():boolean\n\t{\n\t\tvar token:string;\n\n\t\tif (!this._startedParsing) {\n\t\t\tthis._textData = this._pGetTextData();\n\t\t\tthis._startedParsing = true;\n\t\t}\n\n\t\twhile (this._pHasTime()) {\n\t\t\ttoken = this.getNextToken();\n\t\t\tswitch (token) {\n\t\t\t\tcase MD5MeshParser.COMMENT_TOKEN:\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.VERSION_TOKEN:\n\t\t\t\t\tthis._version = this.getNextInt();\n\t\t\t\t\tif (this._version != 10)\n\t\t\t\t\t\tthrow new Error(\"Unknown version number encountered!\");\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.COMMAND_LINE_TOKEN:\n\t\t\t\t\tthis.parseCMD();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.NUM_JOINTS_TOKEN:\n\t\t\t\t\tthis._numJoints = this.getNextInt();\n\t\t\t\t\tthis._bindPoses = new Array<Matrix3D>(this._numJoints);\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.NUM_MESHES_TOKEN:\n\t\t\t\t\tthis._numMeshes = this.getNextInt();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.JOINTS_TOKEN:\n\t\t\t\t\tthis.parseJoints();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_TOKEN:\n\t\t\t\t\tthis.parseMesh();\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tif (!this._reachedEOF)\n\t\t\t\t\t\tthis.sendUnknownKeywordError();\n\t\t\t}\n\n\t\t\tif (this._reachedEOF) {\n\t\t\t\tthis.calculateMaxJointCount();\n\t\t\t\tthis._animationSet = new SkeletonAnimationSet(this._maxJointCount);\n\n\t\t\t\tthis._mesh = new Mesh(new Geometry(), null);\n\t\t\t\tthis._geometry = this._mesh.geometry;\n\n\t\t\t\tfor (var i:number /*int*/ = 0; i < this._meshData.length; ++i)\n\t\t\t\t\tthis._geometry.addSubGeometry(this.translateGeom(this._meshData[i].vertexData, this._meshData[i].weightData, this._meshData[i].indices));\n\n\t\t\t\t//_geometry.animation = _animation;\n\t\t\t\t//\t\t\t\t\t_mesh.animationController = _animationController;\n\n\t\t\t\t//add to the content property\n\t\t\t\t(<DisplayObjectContainer> this._pContent).addChild(this._mesh);\n\n\t\t\t\tthis._pFinalizeAsset(this._geometry);\n\t\t\t\tthis._pFinalizeAsset(this._mesh);\n\t\t\t\tthis._pFinalizeAsset(this._skeleton);\n\t\t\t\tthis._pFinalizeAsset(this._animationSet);\n\t\t\t\treturn ParserBase.PARSING_DONE;\n\t\t\t}\n\t\t}\n\t\treturn ParserBase.MORE_TO_PARSE;\n\t}\n\n\tpublic _pStartParsing(frameLimit:number)\n\t{\n\t\tsuper._pStartParsing(frameLimit);\n\n\t\t//create a content object for Loaders\n\t\tthis._pContent = new DisplayObjectContainer();\n\t}\n\n\tprivate calculateMaxJointCount():void\n\t{\n\t\tthis._maxJointCount = 0;\n\n\t\tvar numMeshData:number /*int*/ = this._meshData.length;\n\t\tfor (var i:number /*int*/ = 0; i < numMeshData; ++i) {\n\t\t\tvar meshData:MeshData = this._meshData[i];\n\t\t\tvar vertexData:Array<VertexData> = meshData.vertexData;\n\t\t\tvar numVerts:number /*int*/ = vertexData.length;\n\n\t\t\tfor (var j:number /*int*/ = 0; j < numVerts; ++j) {\n\t\t\t\tvar zeroWeights:number /*int*/ = this.countZeroWeightJoints(vertexData[j], meshData.weightData);\n\t\t\t\tvar totalJoints:number /*int*/ = vertexData[j].countWeight - zeroWeights;\n\t\t\t\tif (totalJoints > this._maxJointCount)\n\t\t\t\t\tthis._maxJointCount = totalJoints;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate countZeroWeightJoints(vertex:VertexData, weights:Array<JointData>):number /*int*/\n\t{\n\t\tvar start:number /*int*/ = vertex.startWeight;\n\t\tvar end:number /*int*/ = vertex.startWeight + vertex.countWeight;\n\t\tvar count:number /*int*/ = 0;\n\t\tvar weight:number;\n\n\t\tfor (var i:number /*int*/ = start; i < end; ++i) {\n\t\t\tweight = weights[i].bias;\n\t\t\tif (weight == 0)\n\t\t\t\t++count;\n\t\t}\n\n\t\treturn count;\n\t}\n\n\t/**\n\t * Parses the skeleton's joints.\n\t */\n\tprivate parseJoints():void\n\t{\n\t\tvar ch:string;\n\t\tvar joint:SkeletonJoint;\n\t\tvar pos:Vector3D;\n\t\tvar quat:Quaternion;\n\t\tvar i:number /*int*/ = 0;\n\t\tvar token:string = this.getNextToken();\n\n\t\tif (token != \"{\")\n\t\t\tthis.sendUnknownKeywordError();\n\n\t\tthis._skeleton = new Skeleton();\n\n\t\tdo {\n\t\t\tif (this._reachedEOF)\n\t\t\t\tthis.sendEOFError();\n\t\t\tjoint = new SkeletonJoint();\n\t\t\tjoint.name = this.parseLiteralstring();\n\t\t\tjoint.parentIndex = this.getNextInt();\n\t\t\tpos = this.parseVector3D();\n\t\t\tpos = this._rotationQuat.rotatePoint(pos);\n\t\t\tquat = this.parseQuaternion();\n\n\t\t\t// todo: check if this is correct, or maybe we want to actually store it as quats?\n\t\t\tthis._bindPoses[i] = quat.toMatrix3D();\n\t\t\tthis._bindPoses[i].appendTranslation(pos.x, pos.y, pos.z);\n\t\t\tvar inv:Matrix3D = this._bindPoses[i].clone();\n\t\t\tinv.invert();\n\t\t\tjoint.inverseBindPose = inv.rawData;\n\n\t\t\tthis._skeleton.joints[i++] = joint;\n\n\t\t\tch = this.getNextChar();\n\n\t\t\tif (ch == \"/\") {\n\t\t\t\tthis.putBack();\n\t\t\t\tch = this.getNextToken();\n\t\t\t\tif (ch == MD5MeshParser.COMMENT_TOKEN)\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\tch = this.getNextChar();\n\n\t\t\t}\n\n\t\t\tif (ch != \"}\")\n\t\t\t\tthis.putBack();\n\t\t} while (ch != \"}\");\n\t}\n\n\t/**\n\t * Puts back the last read character into the data stream.\n\t */\n\tprivate putBack():void\n\t{\n\t\tthis._parseIndex--;\n\t\tthis._charLineIndex--;\n\t\tthis._reachedEOF = this._parseIndex >= this._textData.length;\n\t}\n\n\t/**\n\t * Parses the mesh geometry.\n\t */\n\tprivate parseMesh():void\n\t{\n\t\tvar token:string = this.getNextToken();\n\t\tvar ch:string;\n\t\tvar vertexData:Array<VertexData>;\n\t\tvar weights:Array<JointData>;\n\t\tvar indices:Array<number> /*uint*/;\n\n\t\tif (token != \"{\")\n\t\t\tthis.sendUnknownKeywordError();\n\n\t\tif (this._shaders == null)\n\t\t\tthis._shaders = new Array<string>();\n\n\t\twhile (ch != \"}\") {\n\t\t\tch = this.getNextToken();\n\t\t\tswitch (ch) {\n\t\t\t\tcase MD5MeshParser.COMMENT_TOKEN:\n\t\t\t\t\tthis.ignoreLine();\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_SHADER_TOKEN:\n\t\t\t\t\tthis._shaders.push(this.parseLiteralstring());\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_NUM_VERTS_TOKEN:\n\t\t\t\t\tvertexData = new Array<VertexData>(this.getNextInt());\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_NUM_TRIS_TOKEN:\n\t\t\t\t\tindices = new Array<number>(this.getNextInt()*3) /*uint*/;\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_NUM_WEIGHTS_TOKEN:\n\t\t\t\t\tweights = new Array<JointData>(this.getNextInt());\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_VERT_TOKEN:\n\t\t\t\t\tthis.parseVertex(vertexData);\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_TRI_TOKEN:\n\t\t\t\t\tthis.parseTri(indices);\n\t\t\t\t\tbreak;\n\t\t\t\tcase MD5MeshParser.MESH_WEIGHT_TOKEN:\n\t\t\t\t\tthis.parseJoint(weights);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (this._meshData == null)\n\t\t\tthis._meshData = new Array<MeshData>();\n\n\t\tvar i:number /*uint*/ = this._meshData.length;\n\t\tthis._meshData[i] = new MeshData();\n\t\tthis._meshData[i].vertexData = vertexData;\n\t\tthis._meshData[i].weightData = weights;\n\t\tthis._meshData[i].indices = indices;\n\t}\n\n\t/**\n\t * Converts the mesh data to a SkinnedSub instance.\n\t * @param vertexData The mesh's vertices.\n\t * @param weights The joint weights per vertex.\n\t * @param indices The indices for the faces.\n\t * @return A SubGeometry instance containing all geometrical data for the current mesh.\n\t */\n\tprivate translateGeom(vertexData:Array<VertexData>, weights:Array<JointData>, indices:Array<number> /*uint*/):TriangleSubGeometry\n\t{\n\t\tvar len:number /*int*/ = vertexData.length;\n\t\tvar v1:number /*int*/, v2:number /*int*/, v3:number /*int*/;\n\t\tvar vertex:VertexData;\n\t\tvar weight:JointData;\n\t\tvar bindPose:Matrix3D;\n\t\tvar pos:Vector3D;\n\t\tvar subGeom:TriangleSubGeometry = new TriangleSubGeometry(true);\n\t\tvar uvs:Array<number> = new Array<number>(len*2);\n\t\tvar vertices:Array<number> = new Array<number>(len*3);\n\t\tvar jointIndices:Array<number> = new Array<number>(len*this._maxJointCount);\n\t\tvar jointWeights:Array<number> = new Array<number>(len*this._maxJointCount);\n\t\tvar l:number /*int*/ = 0;\n\t\tvar nonZeroWeights:number /*int*/;\n\n\t\tfor (var i:number /*int*/ = 0; i < len; ++i) {\n\t\t\tvertex = vertexData[i];\n\t\t\tv1 = vertex.index*3;\n\t\t\tv2 = v1 + 1;\n\t\t\tv3 = v1 + 2;\n\t\t\tvertices[v1] = vertices[v2] = vertices[v3] = 0;\n\n\t\t\tnonZeroWeights = 0;\n\t\t\tfor (var j:number /*int*/ = 0; j < vertex.countWeight; ++j) {\n\t\t\t\tweight = weights[vertex.startWeight + j];\n\t\t\t\tif (weight.bias > 0) {\n\t\t\t\t\tbindPose = this._bindPoses[weight.joint];\n\t\t\t\t\tpos = bindPose.transformVector(weight.pos);\n\t\t\t\t\tvertices[v1] += pos.x*weight.bias;\n\t\t\t\t\tvertices[v2] += pos.y*weight.bias;\n\t\t\t\t\tvertices[v3] += pos.z*weight.bias;\n\n\t\t\t\t\t// indices need to be multiplied by 3 (amount of matrix registers)\n\t\t\t\t\tjointIndices[l] = weight.joint*3;\n\t\t\t\t\tjointWeights[l++] = weight.bias;\n\t\t\t\t\t++nonZeroWeights;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor (j = nonZeroWeights; j < this._maxJointCount; ++j) {\n\t\t\t\tjointIndices[l] = 0;\n\t\t\t\tjointWeights[l++] = 0;\n\t\t\t}\n\n\t\t\tv1 = vertex.index << 1;\n\t\t\tuvs[v1++] = vertex.s;\n\t\t\tuvs[v1] = vertex.t;\n\t\t}\n\n\t\tsubGeom.jointsPerVertex = this._maxJointCount;\n\t\tsubGeom.updateIndices(indices);\n\t\tsubGeom.updatePositions(vertices);\n\t\tsubGeom.updateUVs(uvs);\n\t\tsubGeom.updateJointIndices(jointIndices);\n\t\tsubGeom.updateJointWeights(jointWeights);\n\t\t// cause explicit updates\n\t\tsubGeom.vertexNormals;\n\t\tsubGeom.vertexTangents;\n\t\t// turn auto updates off because they may be animated and set explicitly\n\t\tsubGeom.autoDeriveTangents = false;\n\t\tsubGeom.autoDeriveNormals = false;\n\n\t\treturn subGeom;\n\t}\n\n\t/**\n\t * Retrieve the next triplet of vertex indices that form a face.\n\t * @param indices The index list in which to store the read data.\n\t */\n\tprivate parseTri(indices:Array<number> /*uint*/):void\n\t{\n\t\tvar index:number /*int*/ = this.getNextInt()*3;\n\t\tindices[index] = this.getNextInt();\n\t\tindices[index + 1] = this.getNextInt();\n\t\tindices[index + 2] = this.getNextInt();\n\t}\n\n\t/**\n\t * Reads a new joint data set for a single joint.\n\t * @param weights the target list to contain the weight data.\n\t */\n\tprivate parseJoint(weights:Array<JointData>):void\n\t{\n\t\tvar weight:JointData = new JointData();\n\t\tweight.index = this.getNextInt();\n\t\tweight.joint = this.getNextInt();\n\t\tweight.bias = this.getNextNumber();\n\t\tweight.pos = this.parseVector3D();\n\t\tweights[weight.index] = weight;\n\t}\n\n\t/**\n\t * Reads the data for a single vertex.\n\t * @param vertexData The list to contain the vertex data.\n\t */\n\tprivate parseVertex(vertexData:Array<VertexData>):void\n\t{\n\t\tvar vertex:VertexData = new VertexData();\n\t\tvertex.index = this.getNextInt();\n\t\tthis.parseUV(vertex);\n\t\tvertex.startWeight = this.getNextInt();\n\t\tvertex.countWeight = this.getNextInt();\n\t\t//\t\t\tif (vertex.countWeight > _maxJointCount) _maxJointCount = vertex.countWeight;\n\t\tvertexData[vertex.index] = vertex;\n\t}\n\n\t/**\n\t * Reads the next uv coordinate.\n\t * @param vertexData The vertexData to contain the UV coordinates.\n\t */\n\tprivate parseUV(vertexData:VertexData):void\n\t{\n\t\tvar ch:string = this.getNextToken();\n\t\tif (ch != \"(\")\n\t\t\tthis.sendParseError(\"(\");\n\t\tvertexData.s = this.getNextNumber();\n\t\tvertexData.t = this.getNextNumber();\n\n\t\tif (this.getNextToken() != \")\")\n\t\t\tthis.sendParseError(\")\");\n\t}\n\n\t/**\n\t * Gets the next token in the data stream.\n\t */\n\tprivate getNextToken():string\n\t{\n\t\tvar ch:string;\n\t\tvar token:string = \"\";\n\n\t\twhile (!this._reachedEOF) {\n\t\t\tch = this.getNextChar();\n\t\t\tif (ch == \" \" || ch == \"\\r\" || ch == \"\\n\" || ch == \"\\t\") {\n\t\t\t\tif (token != MD5MeshParser.COMMENT_TOKEN)\n\t\t\t\t\tthis.skipWhiteSpace();\n\t\t\t\tif (token != \"\")\n\t\t\t\t\treturn token;\n\t\t\t} else\n\t\t\t\ttoken += ch;\n\n\t\t\tif (token == MD5MeshParser.COMMENT_TOKEN)\n\t\t\t\treturn token;\n\t\t}\n\n\t\treturn token;\n\t}\n\n\t/**\n\t * Skips all whitespace in the data stream.\n\t */\n\tprivate skipWhiteSpace():void\n\t{\n\t\tvar ch:string;\n\n\t\tdo\n\t\t\tch = this.getNextChar(); while (ch == \"\\n\" || ch == \" \" || ch == \"\\r\" || ch == \"\\t\");\n\n\t\tthis.putBack();\n\t}\n\n\t/**\n\t * Skips to the next line.\n\t */\n\tprivate ignoreLine():void\n\t{\n\t\tvar ch:string;\n\t\twhile (!this._reachedEOF && ch != \"\\n\")\n\t\t\tch = this.getNextChar();\n\t}\n\n\t/**\n\t * Retrieves the next single character in the data stream.\n\t */\n\tprivate getNextChar():string\n\t{\n\t\tvar ch:string = this._textData.charAt(this._parseIndex++);\n\n\t\tif (ch == \"\\n\") {\n\t\t\t++this._line;\n\t\t\tthis._charLineIndex = 0;\n\t\t} else if (ch != \"\\r\")\n\t\t\t++this._charLineIndex;\n\n\t\tif (this._parseIndex >= this._textData.length)\n\t\t\tthis._reachedEOF = true;\n\n\t\treturn ch;\n\t}\n\n\t/**\n\t * Retrieves the next integer in the data stream.\n\t */\n\tprivate getNextInt():number /*int*/\n\t{\n\t\tvar i:number = parseInt(this.getNextToken());\n\t\tif (isNaN(i))\n\t\t\tthis.sendParseError(\"int type\");\n\t\treturn i;\n\t}\n\n\t/**\n\t * Retrieves the next floating point number in the data stream.\n\t */\n\tprivate getNextNumber():number\n\t{\n\t\tvar f:number = parseFloat(this.getNextToken());\n\t\tif (isNaN(f))\n\t\t\tthis.sendParseError(\"float type\");\n\t\treturn f;\n\t}\n\n\t/**\n\t * Retrieves the next 3d vector in the data stream.\n\t */\n\tprivate parseVector3D():Vector3D\n\t{\n\t\tvar vec:Vector3D = new Vector3D();\n\t\tvar ch:string = this.getNextToken();\n\n\t\tif (ch != \"(\")\n\t\t\tthis.sendParseError(\"(\");\n\t\tvec.x = -this.getNextNumber();\n\t\tvec.y = this.getNextNumber();\n\t\tvec.z = this.getNextNumber();\n\n\t\tif (this.getNextToken() != \")\")\n\t\t\tthis.sendParseError(\")\");\n\n\t\treturn vec;\n\t}\n\n\t/**\n\t * Retrieves the next quaternion in the data stream.\n\t */\n\tprivate parseQuaternion():Quaternion\n\t{\n\t\tvar quat:Quaternion = new Quaternion();\n\t\tvar ch:string = this.getNextToken();\n\n\t\tif (ch != \"(\")\n\t\t\tthis.sendParseError(\"(\");\n\t\tquat.x = this.getNextNumber();\n\t\tquat.y = -this.getNextNumber();\n\t\tquat.z = -this.getNextNumber();\n\n\t\t// quat supposed to be unit length\n\t\tvar t:number = 1 - quat.x*quat.x - quat.y*quat.y - quat.z*quat.z;\n\t\tquat.w = t < 0? 0 : -Math.sqrt(t);\n\n\t\tif (this.getNextToken() != \")\")\n\t\t\tthis.sendParseError(\")\");\n\n\t\tvar rotQuat:Quaternion = new Quaternion();\n\t\trotQuat.multiply(this._rotationQuat, quat);\n\t\treturn rotQuat;\n\t}\n\n\t/**\n\t * Parses the command line data.\n\t */\n\tprivate parseCMD():void\n\t{\n\t\t// just ignore the command line property\n\t\tthis.parseLiteralstring();\n\t}\n\n\t/**\n\t * Retrieves the next literal string in the data stream. A literal string is a sequence of characters bounded\n\t * by double quotes.\n\t */\n\tprivate parseLiteralstring():string\n\t{\n\t\tthis.skipWhiteSpace();\n\n\t\tvar ch:string = this.getNextChar();\n\t\tvar str:string = \"\";\n\n\t\tif (ch != \"\\\"\")\n\t\t\tthis.sendParseError(\"\\\"\");\n\n\t\tdo {\n\t\t\tif (this._reachedEOF)\n\t\t\t\tthis.sendEOFError();\n\t\t\tch = this.getNextChar();\n\t\t\tif (ch != \"\\\"\")\n\t\t\t\tstr += ch;\n\t\t} while (ch != \"\\\"\");\n\n\t\treturn str;\n\t}\n\n\t/**\n\t * Throws an end-of-file error when a premature end of file was encountered.\n\t */\n\tprivate sendEOFError():void\n\t{\n\t\tthrow new Error(\"Unexpected end of file\");\n\t}\n\n\t/**\n\t * Throws an error when an unexpected token was encountered.\n\t * @param expected The token type that was actually expected.\n\t */\n\tprivate sendParseError(expected:string):void\n\t{\n\t\tthrow new Error(\"Unexpected token at line \" + (this._line + 1) + \", character \" + this._charLineIndex + \". \" + expected + \" expected, but \" + this._textData.charAt(this._parseIndex - 1) + \" encountered\");\n\t}\n\n\t/**\n\t * Throws an error when an unknown keyword was encountered.\n\t */\n\tprivate sendUnknownKeywordError():void\n\t{\n\t\tthrow new Error(\"Unknown keyword at line \" + (this._line + 1) + \", character \" + this._charLineIndex + \". \");\n\t}\n}\n\nexport = MD5MeshParser;\n\n\nclass VertexData\n{\n\tpublic index:number /*int*/;\n\tpublic s:number;\n\tpublic t:number;\n\tpublic startWeight:number /*int*/;\n\tpublic countWeight:number /*int*/;\n}\n\nclass JointData\n{\n\tpublic index:number /*int*/;\n\tpublic joint:number /*int*/;\n\tpublic bias:number;\n\tpublic pos:Vector3D;\n}\n\nclass MeshData\n{\n\tpublic vertexData:Array<VertexData>;\n\tpublic weightData:Array<JointData>;\n\tpublic indices:Array<number> /*uint*/;\n}\n"]} \ No newline at end of file diff --git a/lib/parsers/MD5MeshParser.ts b/lib/parsers/MD5MeshParser.ts new file mode 100644 index 000000000..2eb85b19d --- /dev/null +++ b/lib/parsers/MD5MeshParser.ts @@ -0,0 +1,683 @@ +import DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import ParserBase = require("awayjs-core/lib/parsers/ParserBase"); + +import SkeletonAnimationSet = require("awayjs-renderergl/lib/animators/SkeletonAnimationSet"); +import Skeleton = require("awayjs-renderergl/lib/animators/data/Skeleton"); +import SkeletonJoint = require("awayjs-renderergl/lib/animators/data/SkeletonJoint"); + +// todo: create animation system, parse skeleton + +/** + * MD5MeshParser provides a parser for the md5mesh data type, providing the geometry of the md5 format. + * + * todo: optimize + */ +class MD5MeshParser extends ParserBase +{ + private _textData:string; + private _startedParsing:boolean; + public static VERSION_TOKEN:string = "MD5Version"; + public static COMMAND_LINE_TOKEN:string = "commandline"; + public static NUM_JOINTS_TOKEN:string = "numJoints"; + public static NUM_MESHES_TOKEN:string = "numMeshes"; + public static COMMENT_TOKEN:string = "//"; + public static JOINTS_TOKEN:string = "joints"; + public static MESH_TOKEN:string = "mesh"; + + public static MESH_SHADER_TOKEN:string = "shader"; + public static MESH_NUM_VERTS_TOKEN:string = "numverts"; + public static MESH_VERT_TOKEN:string = "vert"; + public static MESH_NUM_TRIS_TOKEN:string = "numtris"; + public static MESH_TRI_TOKEN:string = "tri"; + public static MESH_NUM_WEIGHTS_TOKEN:string = "numweights"; + public static MESH_WEIGHT_TOKEN:string = "weight"; + + private _parseIndex:number /*int*/ = 0; + private _reachedEOF:boolean; + private _line:number /*int*/ = 0; + private _charLineIndex:number /*int*/ = 0; + private _version:number /*int*/; + private _numJoints:number /*int*/; + private _numMeshes:number /*int*/; + + private _mesh:Mesh; + private _shaders:Array; + + private _maxJointCount:number /*int*/; + private _meshData:Array; + private _bindPoses:Array; + private _geometry:Geometry; + + private _skeleton:Skeleton; + private _animationSet:SkeletonAnimationSet; + + private _rotationQuat:Quaternion; + + /** + * Creates a new MD5MeshParser object. + */ + constructor(additionalRotationAxis:Vector3D = null, additionalRotationRadians:number = 0) + { + super(URLLoaderDataFormat.TEXT); + this._rotationQuat = new Quaternion(); + + this._rotationQuat.fromAxisAngle(Vector3D.X_AXIS, -Math.PI*.5); + + if (additionalRotationAxis) { + var quat:Quaternion = new Quaternion(); + quat.fromAxisAngle(additionalRotationAxis, additionalRotationRadians); + this._rotationQuat.multiply(this._rotationQuat, quat); + } + } + + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + public static supportsType(extension:string):boolean + { + extension = extension.toLowerCase(); + return extension == "md5mesh"; + } + + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + public static supportsData(data:any):boolean + { + return false; + } + + /** + * @inheritDoc + */ + public _pProceedParsing():boolean + { + var token:string; + + if (!this._startedParsing) { + this._textData = this._pGetTextData(); + this._startedParsing = true; + } + + while (this._pHasTime()) { + token = this.getNextToken(); + switch (token) { + case MD5MeshParser.COMMENT_TOKEN: + this.ignoreLine(); + break; + case MD5MeshParser.VERSION_TOKEN: + this._version = this.getNextInt(); + if (this._version != 10) + throw new Error("Unknown version number encountered!"); + break; + case MD5MeshParser.COMMAND_LINE_TOKEN: + this.parseCMD(); + break; + case MD5MeshParser.NUM_JOINTS_TOKEN: + this._numJoints = this.getNextInt(); + this._bindPoses = new Array(this._numJoints); + break; + case MD5MeshParser.NUM_MESHES_TOKEN: + this._numMeshes = this.getNextInt(); + break; + case MD5MeshParser.JOINTS_TOKEN: + this.parseJoints(); + break; + case MD5MeshParser.MESH_TOKEN: + this.parseMesh(); + break; + default: + if (!this._reachedEOF) + this.sendUnknownKeywordError(); + } + + if (this._reachedEOF) { + this.calculateMaxJointCount(); + this._animationSet = new SkeletonAnimationSet(this._maxJointCount); + + this._mesh = new Mesh(new Geometry(), null); + this._geometry = this._mesh.geometry; + + for (var i:number /*int*/ = 0; i < this._meshData.length; ++i) + this._geometry.addSubGeometry(this.translateGeom(this._meshData[i].vertexData, this._meshData[i].weightData, this._meshData[i].indices)); + + //_geometry.animation = _animation; + // _mesh.animationController = _animationController; + + //add to the content property + ( this._pContent).addChild(this._mesh); + + this._pFinalizeAsset(this._geometry); + this._pFinalizeAsset(this._mesh); + this._pFinalizeAsset(this._skeleton); + this._pFinalizeAsset(this._animationSet); + return ParserBase.PARSING_DONE; + } + } + return ParserBase.MORE_TO_PARSE; + } + + public _pStartParsing(frameLimit:number) + { + super._pStartParsing(frameLimit); + + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + } + + private calculateMaxJointCount():void + { + this._maxJointCount = 0; + + var numMeshData:number /*int*/ = this._meshData.length; + for (var i:number /*int*/ = 0; i < numMeshData; ++i) { + var meshData:MeshData = this._meshData[i]; + var vertexData:Array = meshData.vertexData; + var numVerts:number /*int*/ = vertexData.length; + + for (var j:number /*int*/ = 0; j < numVerts; ++j) { + var zeroWeights:number /*int*/ = this.countZeroWeightJoints(vertexData[j], meshData.weightData); + var totalJoints:number /*int*/ = vertexData[j].countWeight - zeroWeights; + if (totalJoints > this._maxJointCount) + this._maxJointCount = totalJoints; + } + } + } + + private countZeroWeightJoints(vertex:VertexData, weights:Array):number /*int*/ + { + var start:number /*int*/ = vertex.startWeight; + var end:number /*int*/ = vertex.startWeight + vertex.countWeight; + var count:number /*int*/ = 0; + var weight:number; + + for (var i:number /*int*/ = start; i < end; ++i) { + weight = weights[i].bias; + if (weight == 0) + ++count; + } + + return count; + } + + /** + * Parses the skeleton's joints. + */ + private parseJoints():void + { + var ch:string; + var joint:SkeletonJoint; + var pos:Vector3D; + var quat:Quaternion; + var i:number /*int*/ = 0; + var token:string = this.getNextToken(); + + if (token != "{") + this.sendUnknownKeywordError(); + + this._skeleton = new Skeleton(); + + do { + if (this._reachedEOF) + this.sendEOFError(); + joint = new SkeletonJoint(); + joint.name = this.parseLiteralstring(); + joint.parentIndex = this.getNextInt(); + pos = this.parseVector3D(); + pos = this._rotationQuat.rotatePoint(pos); + quat = this.parseQuaternion(); + + // todo: check if this is correct, or maybe we want to actually store it as quats? + this._bindPoses[i] = quat.toMatrix3D(); + this._bindPoses[i].appendTranslation(pos.x, pos.y, pos.z); + var inv:Matrix3D = this._bindPoses[i].clone(); + inv.invert(); + joint.inverseBindPose = inv.rawData; + + this._skeleton.joints[i++] = joint; + + ch = this.getNextChar(); + + if (ch == "/") { + this.putBack(); + ch = this.getNextToken(); + if (ch == MD5MeshParser.COMMENT_TOKEN) + this.ignoreLine(); + ch = this.getNextChar(); + + } + + if (ch != "}") + this.putBack(); + } while (ch != "}"); + } + + /** + * Puts back the last read character into the data stream. + */ + private putBack():void + { + this._parseIndex--; + this._charLineIndex--; + this._reachedEOF = this._parseIndex >= this._textData.length; + } + + /** + * Parses the mesh geometry. + */ + private parseMesh():void + { + var token:string = this.getNextToken(); + var ch:string; + var vertexData:Array; + var weights:Array; + var indices:Array /*uint*/; + + if (token != "{") + this.sendUnknownKeywordError(); + + if (this._shaders == null) + this._shaders = new Array(); + + while (ch != "}") { + ch = this.getNextToken(); + switch (ch) { + case MD5MeshParser.COMMENT_TOKEN: + this.ignoreLine(); + break; + case MD5MeshParser.MESH_SHADER_TOKEN: + this._shaders.push(this.parseLiteralstring()); + break; + case MD5MeshParser.MESH_NUM_VERTS_TOKEN: + vertexData = new Array(this.getNextInt()); + break; + case MD5MeshParser.MESH_NUM_TRIS_TOKEN: + indices = new Array(this.getNextInt()*3) /*uint*/; + break; + case MD5MeshParser.MESH_NUM_WEIGHTS_TOKEN: + weights = new Array(this.getNextInt()); + break; + case MD5MeshParser.MESH_VERT_TOKEN: + this.parseVertex(vertexData); + break; + case MD5MeshParser.MESH_TRI_TOKEN: + this.parseTri(indices); + break; + case MD5MeshParser.MESH_WEIGHT_TOKEN: + this.parseJoint(weights); + break; + } + } + + if (this._meshData == null) + this._meshData = new Array(); + + var i:number /*uint*/ = this._meshData.length; + this._meshData[i] = new MeshData(); + this._meshData[i].vertexData = vertexData; + this._meshData[i].weightData = weights; + this._meshData[i].indices = indices; + } + + /** + * Converts the mesh data to a SkinnedSub instance. + * @param vertexData The mesh's vertices. + * @param weights The joint weights per vertex. + * @param indices The indices for the faces. + * @return A SubGeometry instance containing all geometrical data for the current mesh. + */ + private translateGeom(vertexData:Array, weights:Array, indices:Array /*uint*/):TriangleSubGeometry + { + var len:number /*int*/ = vertexData.length; + var v1:number /*int*/, v2:number /*int*/, v3:number /*int*/; + var vertex:VertexData; + var weight:JointData; + var bindPose:Matrix3D; + var pos:Vector3D; + var subGeom:TriangleSubGeometry = new TriangleSubGeometry(true); + var uvs:Array = new Array(len*2); + var vertices:Array = new Array(len*3); + var jointIndices:Array = new Array(len*this._maxJointCount); + var jointWeights:Array = new Array(len*this._maxJointCount); + var l:number /*int*/ = 0; + var nonZeroWeights:number /*int*/; + + for (var i:number /*int*/ = 0; i < len; ++i) { + vertex = vertexData[i]; + v1 = vertex.index*3; + v2 = v1 + 1; + v3 = v1 + 2; + vertices[v1] = vertices[v2] = vertices[v3] = 0; + + nonZeroWeights = 0; + for (var j:number /*int*/ = 0; j < vertex.countWeight; ++j) { + weight = weights[vertex.startWeight + j]; + if (weight.bias > 0) { + bindPose = this._bindPoses[weight.joint]; + pos = bindPose.transformVector(weight.pos); + vertices[v1] += pos.x*weight.bias; + vertices[v2] += pos.y*weight.bias; + vertices[v3] += pos.z*weight.bias; + + // indices need to be multiplied by 3 (amount of matrix registers) + jointIndices[l] = weight.joint*3; + jointWeights[l++] = weight.bias; + ++nonZeroWeights; + } + } + + for (j = nonZeroWeights; j < this._maxJointCount; ++j) { + jointIndices[l] = 0; + jointWeights[l++] = 0; + } + + v1 = vertex.index << 1; + uvs[v1++] = vertex.s; + uvs[v1] = vertex.t; + } + + subGeom.jointsPerVertex = this._maxJointCount; + subGeom.updateIndices(indices); + subGeom.updatePositions(vertices); + subGeom.updateUVs(uvs); + subGeom.updateJointIndices(jointIndices); + subGeom.updateJointWeights(jointWeights); + // cause explicit updates + subGeom.vertexNormals; + subGeom.vertexTangents; + // turn auto updates off because they may be animated and set explicitly + subGeom.autoDeriveTangents = false; + subGeom.autoDeriveNormals = false; + + return subGeom; + } + + /** + * Retrieve the next triplet of vertex indices that form a face. + * @param indices The index list in which to store the read data. + */ + private parseTri(indices:Array /*uint*/):void + { + var index:number /*int*/ = this.getNextInt()*3; + indices[index] = this.getNextInt(); + indices[index + 1] = this.getNextInt(); + indices[index + 2] = this.getNextInt(); + } + + /** + * Reads a new joint data set for a single joint. + * @param weights the target list to contain the weight data. + */ + private parseJoint(weights:Array):void + { + var weight:JointData = new JointData(); + weight.index = this.getNextInt(); + weight.joint = this.getNextInt(); + weight.bias = this.getNextNumber(); + weight.pos = this.parseVector3D(); + weights[weight.index] = weight; + } + + /** + * Reads the data for a single vertex. + * @param vertexData The list to contain the vertex data. + */ + private parseVertex(vertexData:Array):void + { + var vertex:VertexData = new VertexData(); + vertex.index = this.getNextInt(); + this.parseUV(vertex); + vertex.startWeight = this.getNextInt(); + vertex.countWeight = this.getNextInt(); + // if (vertex.countWeight > _maxJointCount) _maxJointCount = vertex.countWeight; + vertexData[vertex.index] = vertex; + } + + /** + * Reads the next uv coordinate. + * @param vertexData The vertexData to contain the UV coordinates. + */ + private parseUV(vertexData:VertexData):void + { + var ch:string = this.getNextToken(); + if (ch != "(") + this.sendParseError("("); + vertexData.s = this.getNextNumber(); + vertexData.t = this.getNextNumber(); + + if (this.getNextToken() != ")") + this.sendParseError(")"); + } + + /** + * Gets the next token in the data stream. + */ + private getNextToken():string + { + var ch:string; + var token:string = ""; + + while (!this._reachedEOF) { + ch = this.getNextChar(); + if (ch == " " || ch == "\r" || ch == "\n" || ch == "\t") { + if (token != MD5MeshParser.COMMENT_TOKEN) + this.skipWhiteSpace(); + if (token != "") + return token; + } else + token += ch; + + if (token == MD5MeshParser.COMMENT_TOKEN) + return token; + } + + return token; + } + + /** + * Skips all whitespace in the data stream. + */ + private skipWhiteSpace():void + { + var ch:string; + + do + ch = this.getNextChar(); while (ch == "\n" || ch == " " || ch == "\r" || ch == "\t"); + + this.putBack(); + } + + /** + * Skips to the next line. + */ + private ignoreLine():void + { + var ch:string; + while (!this._reachedEOF && ch != "\n") + ch = this.getNextChar(); + } + + /** + * Retrieves the next single character in the data stream. + */ + private getNextChar():string + { + var ch:string = this._textData.charAt(this._parseIndex++); + + if (ch == "\n") { + ++this._line; + this._charLineIndex = 0; + } else if (ch != "\r") + ++this._charLineIndex; + + if (this._parseIndex >= this._textData.length) + this._reachedEOF = true; + + return ch; + } + + /** + * Retrieves the next integer in the data stream. + */ + private getNextInt():number /*int*/ + { + var i:number = parseInt(this.getNextToken()); + if (isNaN(i)) + this.sendParseError("int type"); + return i; + } + + /** + * Retrieves the next floating point number in the data stream. + */ + private getNextNumber():number + { + var f:number = parseFloat(this.getNextToken()); + if (isNaN(f)) + this.sendParseError("float type"); + return f; + } + + /** + * Retrieves the next 3d vector in the data stream. + */ + private parseVector3D():Vector3D + { + var vec:Vector3D = new Vector3D(); + var ch:string = this.getNextToken(); + + if (ch != "(") + this.sendParseError("("); + vec.x = -this.getNextNumber(); + vec.y = this.getNextNumber(); + vec.z = this.getNextNumber(); + + if (this.getNextToken() != ")") + this.sendParseError(")"); + + return vec; + } + + /** + * Retrieves the next quaternion in the data stream. + */ + private parseQuaternion():Quaternion + { + var quat:Quaternion = new Quaternion(); + var ch:string = this.getNextToken(); + + if (ch != "(") + this.sendParseError("("); + quat.x = this.getNextNumber(); + quat.y = -this.getNextNumber(); + quat.z = -this.getNextNumber(); + + // quat supposed to be unit length + var t:number = 1 - quat.x*quat.x - quat.y*quat.y - quat.z*quat.z; + quat.w = t < 0? 0 : -Math.sqrt(t); + + if (this.getNextToken() != ")") + this.sendParseError(")"); + + var rotQuat:Quaternion = new Quaternion(); + rotQuat.multiply(this._rotationQuat, quat); + return rotQuat; + } + + /** + * Parses the command line data. + */ + private parseCMD():void + { + // just ignore the command line property + this.parseLiteralstring(); + } + + /** + * Retrieves the next literal string in the data stream. A literal string is a sequence of characters bounded + * by double quotes. + */ + private parseLiteralstring():string + { + this.skipWhiteSpace(); + + var ch:string = this.getNextChar(); + var str:string = ""; + + if (ch != "\"") + this.sendParseError("\""); + + do { + if (this._reachedEOF) + this.sendEOFError(); + ch = this.getNextChar(); + if (ch != "\"") + str += ch; + } while (ch != "\""); + + return str; + } + + /** + * Throws an end-of-file error when a premature end of file was encountered. + */ + private sendEOFError():void + { + throw new Error("Unexpected end of file"); + } + + /** + * Throws an error when an unexpected token was encountered. + * @param expected The token type that was actually expected. + */ + private sendParseError(expected:string):void + { + throw new Error("Unexpected token at line " + (this._line + 1) + ", character " + this._charLineIndex + ". " + expected + " expected, but " + this._textData.charAt(this._parseIndex - 1) + " encountered"); + } + + /** + * Throws an error when an unknown keyword was encountered. + */ + private sendUnknownKeywordError():void + { + throw new Error("Unknown keyword at line " + (this._line + 1) + ", character " + this._charLineIndex + ". "); + } +} + +export = MD5MeshParser; + + +class VertexData +{ + public index:number /*int*/; + public s:number; + public t:number; + public startWeight:number /*int*/; + public countWeight:number /*int*/; +} + +class JointData +{ + public index:number /*int*/; + public joint:number /*int*/; + public bias:number; + public pos:Vector3D; +} + +class MeshData +{ + public vertexData:Array; + public weightData:Array; + public indices:Array /*uint*/; +} diff --git a/lib/parsers/Max3DSParser.js b/lib/parsers/Max3DSParser.js new file mode 100755 index 000000000..5e0b3b58b --- /dev/null +++ b/lib/parsers/Max3DSParser.js @@ -0,0 +1,651 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +var Geometry = require("awayjs-core/lib/core/base/Geometry"); +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var Mesh = require("awayjs-core/lib/entities/Mesh"); +var ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +var ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +var DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); +var TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +var TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); +var FaceVO = require("awayjs-renderergl/lib/parsers/data/FaceVO"); +var MaterialVO = require("awayjs-renderergl/lib/parsers/data/MaterialVO"); +var ObjectVO = require("awayjs-renderergl/lib/parsers/data/ObjectVO"); +var TextureVO = require("awayjs-renderergl/lib/parsers/data/TextureVO"); +var VertexVO = require("awayjs-renderergl/lib/parsers/data/VertexVO"); +/** + * Max3DSParser provides a parser for the 3ds data type. + */ +var Max3DSParser = (function (_super) { + __extends(Max3DSParser, _super); + /** + * Creates a new Max3DSParser object. + * + * @param useSmoothingGroups Determines whether the parser looks for smoothing groups in the 3ds file or assumes uniform smoothing. Defaults to true. + */ + function Max3DSParser(useSmoothingGroups) { + if (useSmoothingGroups === void 0) { useSmoothingGroups = true; } + _super.call(this, URLLoaderDataFormat.ARRAY_BUFFER); + this._useSmoothingGroups = useSmoothingGroups; + } + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + Max3DSParser.supportsType = function (extension) { + extension = extension.toLowerCase(); + return extension == "3ds"; + }; + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + Max3DSParser.supportsData = function (data) { + var ba; + ba = ParserUtils.toByteArray(data); + if (ba) { + ba.position = 0; + if (ba.readShort() == 0x4d4d) + return true; + } + return false; + }; + /** + * @inheritDoc + */ + Max3DSParser.prototype._iResolveDependency = function (resourceDependency) { + if (resourceDependency.assets.length == 1) { + var asset; + asset = resourceDependency.assets[0]; + if (asset.assetType == AssetType.TEXTURE) { + var tex; + tex = this._textures[resourceDependency.id]; + tex.texture = asset; + } + } + }; + /** + * @inheritDoc + */ + Max3DSParser.prototype._iResolveDependencyFailure = function (resourceDependency) { + // TODO: Implement + }; + /** + * @inheritDoc + */ + Max3DSParser.prototype._pProceedParsing = function () { + if (!this._byteData) { + this._byteData = this._pGetByteData(); + this._byteData.position = 0; + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._byteData.endian = Endian.LITTLE_ENDIAN;// Should be default + //---------------------------------------------------------------------------- + this._textures = {}; + this._materials = {}; + this._unfinalized_objects = {}; + } + while (this._pHasTime()) { + // If we are currently working on an object, and the most recent chunk was + // the last one in that object, finalize the current object. + if (this._cur_mat && this._byteData.position >= this._cur_mat_end) + this.finalizeCurrentMaterial(); + else if (this._cur_obj && this._byteData.position >= this._cur_obj_end) { + // Can't finalize at this point, because we have to wait until the full + // animation section has been parsed for any potential pivot definitions + this._unfinalized_objects[this._cur_obj.name] = this._cur_obj; + this._cur_obj_end = Number.MAX_VALUE; + this._cur_obj = null; + } + if (this._byteData.getBytesAvailable() > 0) { + var cid /*uint*/; + var len /*uint*/; + var end /*uint*/; + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + end = this._byteData.position + (len - 6); + switch (cid) { + case 0x4D4D: + case 0x3D3D: + case 0xB000: + continue; + break; + case 0xAFFF: + this._cur_mat_end = end; + this._cur_mat = this.parseMaterial(); + break; + case 0x4000: + this._cur_obj_end = end; + this._cur_obj = new ObjectVO(); + this._cur_obj.name = this.readNulTermstring(); + this._cur_obj.materials = new Array(); + this._cur_obj.materialFaces = {}; + break; + case 0x4100: + this._cur_obj.type = AssetType.MESH; + break; + case 0x4110: + this.parseVertexList(); + break; + case 0x4120: + this.parseFaceList(); + break; + case 0x4140: + this.parseUVList(); + break; + case 0x4130: + this.parseFaceMaterialList(); + break; + case 0x4160: + this._cur_obj.transform = this.readTransform(); + break; + case 0xB002: + this.parseObjectAnimation(end); + break; + case 0x4150: + this.parseSmoothingGroups(); + break; + default: + // Skip this (unknown) chunk + this._byteData.position += (len - 6); + break; + } + // Pause parsing if there were any dependencies found during this + // iteration (i.e. if there are any dependencies that need to be + // retrieved at this time.) + if (this.dependencies.length) { + this._pPauseAndRetrieveDependencies(); + break; + } + } + } + // More parsing is required if the entire byte array has not yet + // been read, or if there is a currently non-finalized object in + // the pipeline. + if (this._byteData.getBytesAvailable() || this._cur_obj || this._cur_mat) { + return ParserBase.MORE_TO_PARSE; + } + else { + var name; + for (name in this._unfinalized_objects) { + var obj; + obj = this.constructObject(this._unfinalized_objects[name]); + if (obj) { + //add to the content property + this._pContent.addChild(obj); + this._pFinalizeAsset(obj, name); + } + } + return ParserBase.PARSING_DONE; + } + }; + Max3DSParser.prototype._pStartParsing = function (frameLimit) { + _super.prototype._pStartParsing.call(this, frameLimit); + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + }; + Max3DSParser.prototype.parseMaterial = function () { + var mat; + mat = new MaterialVO(); + while (this._byteData.position < this._cur_mat_end) { + var cid /*uint*/; + var len /*uint*/; + var end /*uint*/; + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + end = this._byteData.position + (len - 6); + switch (cid) { + case 0xA000: + mat.name = this.readNulTermstring(); + break; + case 0xA010: + mat.ambientColor = this.readColor(); + break; + case 0xA020: + mat.diffuseColor = this.readColor(); + break; + case 0xA030: + mat.specularColor = this.readColor(); + break; + case 0xA081: + mat.twoSided = true; + break; + case 0xA200: + mat.colorMap = this.parseTexture(end); + break; + case 0xA204: + mat.specularMap = this.parseTexture(end); + break; + default: + this._byteData.position = end; + break; + } + } + return mat; + }; + Max3DSParser.prototype.parseTexture = function (end /*uint*/) { + var tex; + tex = new TextureVO(); + while (this._byteData.position < end) { + var cid /*uint*/; + var len /*uint*/; + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + switch (cid) { + case 0xA300: + tex.url = this.readNulTermstring(); + break; + default: + // Skip this unknown texture sub-chunk + this._byteData.position += (len - 6); + break; + } + } + this._textures[tex.url] = tex; + this._pAddDependency(tex.url, new URLRequest(tex.url)); + return tex; + }; + Max3DSParser.prototype.parseVertexList = function () { + var i /*uint*/; + var len /*uint*/; + var count /*uint*/; + count = this._byteData.readUnsignedShort(); + this._cur_obj.verts = new Array(count * 3); + i = 0; + len = this._cur_obj.verts.length; + while (i < len) { + var x, y, z; + x = this._byteData.readFloat(); + y = this._byteData.readFloat(); + z = this._byteData.readFloat(); + this._cur_obj.verts[i++] = x; + this._cur_obj.verts[i++] = z; + this._cur_obj.verts[i++] = y; + } + }; + Max3DSParser.prototype.parseFaceList = function () { + var i /*uint*/; + var len /*uint*/; + var count /*uint*/; + count = this._byteData.readUnsignedShort(); + this._cur_obj.indices = new Array(count * 3); + i = 0; + len = this._cur_obj.indices.length; + while (i < len) { + var i0 /*uint*/, i1 /*uint*/, i2 /*uint*/; + i0 = this._byteData.readUnsignedShort(); + i1 = this._byteData.readUnsignedShort(); + i2 = this._byteData.readUnsignedShort(); + this._cur_obj.indices[i++] = i0; + this._cur_obj.indices[i++] = i2; + this._cur_obj.indices[i++] = i1; + // Skip "face info", irrelevant in Away3D + this._byteData.position += 2; + } + this._cur_obj.smoothingGroups = new Array(count); + }; + Max3DSParser.prototype.parseSmoothingGroups = function () { + var len = this._cur_obj.indices.length / 3; + var i = 0; + while (i < len) { + this._cur_obj.smoothingGroups[i] = this._byteData.readUnsignedInt(); + i++; + } + }; + Max3DSParser.prototype.parseUVList = function () { + var i /*uint*/; + var len /*uint*/; + var count /*uint*/; + count = this._byteData.readUnsignedShort(); + this._cur_obj.uvs = new Array(count * 2); + i = 0; + len = this._cur_obj.uvs.length; + while (i < len) { + this._cur_obj.uvs[i++] = this._byteData.readFloat(); + this._cur_obj.uvs[i++] = 1.0 - this._byteData.readFloat(); + } + }; + Max3DSParser.prototype.parseFaceMaterialList = function () { + var mat; + var count /*uint*/; + var i /*uint*/; + var faces /*uint*/; + mat = this.readNulTermstring(); + count = this._byteData.readUnsignedShort(); + faces = new Array(count); + i = 0; + while (i < faces.length) + faces[i++] = this._byteData.readUnsignedShort(); + this._cur_obj.materials.push(mat); + this._cur_obj.materialFaces[mat] = faces; + }; + Max3DSParser.prototype.parseObjectAnimation = function (end) { + var vo; + var obj; + var pivot; + var name; + var hier /*uint*/; + // Pivot defaults to origin + pivot = new Vector3D; + while (this._byteData.position < end) { + var cid /*uint*/; + var len /*uint*/; + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + switch (cid) { + case 0xb010: + name = this.readNulTermstring(); + this._byteData.position += 4; + hier = this._byteData.readShort(); + break; + case 0xb013: + pivot.x = this._byteData.readFloat(); + pivot.z = this._byteData.readFloat(); + pivot.y = this._byteData.readFloat(); + break; + default: + this._byteData.position += (len - 6); + break; + } + } + // If name is "$$$DUMMY" this is an empty object (e.g. a container) + // and will be ignored in this version of the parser + // TODO: Implement containers in 3DS parser. + if (name != '$$$DUMMY' && this._unfinalized_objects.hasOwnProperty(name)) { + vo = this._unfinalized_objects[name]; + obj = this.constructObject(vo, pivot); + if (obj) { + //add to the content property + this._pContent.addChild(obj); + this._pFinalizeAsset(obj, vo.name); + } + delete this._unfinalized_objects[name]; + } + }; + Max3DSParser.prototype.constructObject = function (obj, pivot) { + if (pivot === void 0) { pivot = null; } + if (obj.type == AssetType.MESH) { + var i /*uint*/; + var sub; + var geom; + var mat; + var mesh; + var mtx; + var vertices; + var faces; + if (obj.materials.length > 1) + console.log("The Away3D 3DS parser does not support multiple materials per mesh at this point."); + // Ignore empty objects + if (!obj.indices || obj.indices.length == 0) + return null; + vertices = new Array(obj.verts.length / 3); + faces = new Array(obj.indices.length / 3); + this.prepareData(vertices, faces, obj); + if (this._useSmoothingGroups) + this.applySmoothGroups(vertices, faces); + obj.verts = new Array(vertices.length * 3); + for (i = 0; i < vertices.length; i++) { + obj.verts[i * 3] = vertices[i].x; + obj.verts[i * 3 + 1] = vertices[i].y; + obj.verts[i * 3 + 2] = vertices[i].z; + } + obj.indices = new Array(faces.length * 3); + for (i = 0; i < faces.length; i++) { + obj.indices[i * 3] = faces[i].a; + obj.indices[i * 3 + 1] = faces[i].b; + obj.indices[i * 3 + 2] = faces[i].c; + } + if (obj.uvs) { + // If the object had UVs to start with, use UVs generated by + // smoothing group splitting algorithm. Otherwise those UVs + // will be nonsense and should be skipped. + obj.uvs = new Array(vertices.length * 2); + for (i = 0; i < vertices.length; i++) { + obj.uvs[i * 2] = vertices[i].u; + obj.uvs[i * 2 + 1] = vertices[i].v; + } + } + geom = new Geometry(); + // Construct sub-geometries (potentially splitting buffers) + // and add them to geometry. + sub = new TriangleSubGeometry(true); + sub.updateIndices(obj.indices); + sub.updatePositions(obj.verts); + sub.updateUVs(obj.uvs); + geom.addSubGeometry(sub); + if (obj.materials.length > 0) { + var mname; + mname = obj.materials[0]; + mat = this._materials[mname].material; + } + // Apply pivot translation to geometry if a pivot was + // found while parsing the keyframe chunk earlier. + if (pivot) { + if (obj.transform) { + // If a transform was found while parsing the + // object chunk, use it to find the local pivot vector + var dat = obj.transform.concat(); + dat[12] = 0; + dat[13] = 0; + dat[14] = 0; + mtx = new Matrix3D(dat); + pivot = mtx.transformVector(pivot); + } + pivot.scaleBy(-1); + mtx = new Matrix3D(); + mtx.appendTranslation(pivot.x, pivot.y, pivot.z); + geom.applyTransformation(mtx); + } + // Apply transformation to geometry if a transformation + // was found while parsing the object chunk earlier. + if (obj.transform) { + mtx = new Matrix3D(obj.transform); + mtx.invert(); + geom.applyTransformation(mtx); + } + // Final transform applied to geometry. Finalize the geometry, + // which will no longer be modified after this point. + this._pFinalizeAsset(geom, obj.name.concat('_geom')); + // Build mesh and return it + mesh = new Mesh(geom, mat); + mesh.transform.matrix3D = new Matrix3D(obj.transform); + return mesh; + } + // If reached, unknown + return null; + }; + Max3DSParser.prototype.prepareData = function (vertices, faces, obj) { + // convert raw ObjectVO's data to structured VertexVO and FaceVO + var i /*int*/; + var j /*int*/; + var k /*int*/; + var len = obj.verts.length; + for (i = 0, j = 0, k = 0; i < len;) { + var v = new VertexVO; + v.x = obj.verts[i++]; + v.y = obj.verts[i++]; + v.z = obj.verts[i++]; + if (obj.uvs) { + v.u = obj.uvs[j++]; + v.v = obj.uvs[j++]; + } + vertices[k++] = v; + } + len = obj.indices.length; + for (i = 0, k = 0; i < len;) { + var f = new FaceVO(); + f.a = obj.indices[i++]; + f.b = obj.indices[i++]; + f.c = obj.indices[i++]; + f.smoothGroup = obj.smoothingGroups[k] || 0; + faces[k++] = f; + } + }; + Max3DSParser.prototype.applySmoothGroups = function (vertices, faces) { + // clone vertices according to following rule: + // clone if vertex's in faces from groups 1+2 and 3 + // don't clone if vertex's in faces from groups 1+2, 3 and 1+3 + var i /*int*/; + var j /*int*/; + var k /*int*/; + var l /*int*/; + var len /*int*/; + var numVerts = vertices.length; + var numFaces = faces.length; + // extract groups data for vertices + var vGroups = new Array(numVerts) /*uint*/; + for (i = 0; i < numVerts; i++) + vGroups[i] = new Array(); + for (i = 0; i < numFaces; i++) { + var face = faces[i]; + for (j = 0; j < 3; j++) { + var groups = vGroups[(j == 0) ? face.a : ((j == 1) ? face.b : face.c)]; + var group = face.smoothGroup; + for (k = groups.length - 1; k >= 0; k--) { + if ((group & groups[k]) > 0) { + group |= groups[k]; + groups.splice(k, 1); + k = groups.length - 1; + } + } + groups.push(group); + } + } + // clone vertices + var vClones = new Array(numVerts) /*uint*/; + for (i = 0; i < numVerts; i++) { + if ((len = vGroups[i].length) < 1) + continue; + var clones = new Array(len) /*uint*/; + vClones[i] = clones; + clones[0] = i; + var v0 = vertices[i]; + for (j = 1; j < len; j++) { + var v1 = new VertexVO; + v1.x = v0.x; + v1.y = v0.y; + v1.z = v0.z; + v1.u = v0.u; + v1.v = v0.v; + clones[j] = vertices.length; + vertices.push(v1); + } + } + numVerts = vertices.length; + for (i = 0; i < numFaces; i++) { + face = faces[i]; + group = face.smoothGroup; + for (j = 0; j < 3; j++) { + k = (j == 0) ? face.a : ((j == 1) ? face.b : face.c); + groups = vGroups[k]; + len = groups.length; + clones = vClones[k]; + for (l = 0; l < len; l++) { + if (((group == 0) && (groups[l] == 0)) || ((group & groups[l]) > 0)) { + var index = clones[l]; + if (group == 0) { + // vertex is unique if no smoothGroup found + groups.splice(l, 1); + clones.splice(l, 1); + } + if (j == 0) + face.a = index; + else if (j == 1) + face.b = index; + else + face.c = index; + l = len; + } + } + } + } + }; + Max3DSParser.prototype.finalizeCurrentMaterial = function () { + var mat; + if (this._cur_mat.colorMap) + mat = new TriangleMethodMaterial(this._cur_mat.colorMap.texture || DefaultMaterialManager.getDefaultTexture()); + else + mat = new TriangleMethodMaterial(this._cur_mat.ambientColor); + mat.diffuseColor = this._cur_mat.diffuseColor; + mat.specularColor = this._cur_mat.specularColor; + if (this.materialMode >= 2) + mat.materialMode = TriangleMaterialMode.MULTI_PASS; + mat.bothSides = this._cur_mat.twoSided; + this._pFinalizeAsset(mat, this._cur_mat.name); + this._materials[this._cur_mat.name] = this._cur_mat; + this._cur_mat.material = mat; + this._cur_mat = null; + }; + Max3DSParser.prototype.readNulTermstring = function () { + var chr /*int*/; + var str = ""; + while ((chr = this._byteData.readUnsignedByte()) > 0) + str += String.fromCharCode(chr); + return str; + }; + Max3DSParser.prototype.readTransform = function () { + var data; + data = new Array(16); + // X axis + data[0] = this._byteData.readFloat(); // X + data[2] = this._byteData.readFloat(); // Z + data[1] = this._byteData.readFloat(); // Y + data[3] = 0; + // Z axis + data[8] = this._byteData.readFloat(); // X + data[10] = this._byteData.readFloat(); // Z + data[9] = this._byteData.readFloat(); // Y + data[11] = 0; + // Y Axis + data[4] = this._byteData.readFloat(); // X + data[6] = this._byteData.readFloat(); // Z + data[5] = this._byteData.readFloat(); // Y + data[7] = 0; + // Translation + data[12] = this._byteData.readFloat(); // X + data[14] = this._byteData.readFloat(); // Z + data[13] = this._byteData.readFloat(); // Y + data[15] = 1; + return data; + }; + Max3DSParser.prototype.readColor = function () { + var cid /*int*/; + var len /*int*/; + var r /*int*/, g /*int*/, b /*int*/; + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + switch (cid) { + case 0x0010: + r = this._byteData.readFloat() * 255; + g = this._byteData.readFloat() * 255; + b = this._byteData.readFloat() * 255; + break; + case 0x0011: + r = this._byteData.readUnsignedByte(); + g = this._byteData.readUnsignedByte(); + b = this._byteData.readUnsignedByte(); + break; + default: + this._byteData.position += (len - 6); + break; + } + return (r << 16) | (g << 8) | b; + }; + return Max3DSParser; +})(ParserBase); +module.exports = Max3DSParser; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/max3dsparser.ts"],"names":["Max3DSParser","Max3DSParser.constructor","Max3DSParser.supportsType","Max3DSParser.supportsData","Max3DSParser._iResolveDependency","Max3DSParser._iResolveDependencyFailure","Max3DSParser._pProceedParsing","Max3DSParser._pStartParsing","Max3DSParser.parseMaterial","Max3DSParser.parseTexture","Max3DSParser.parseVertexList","Max3DSParser.parseFaceList","Max3DSParser.parseSmoothingGroups","Max3DSParser.parseUVList","Max3DSParser.parseFaceMaterialList","Max3DSParser.parseObjectAnimation","Max3DSParser.constructObject","Max3DSParser.prepareData","Max3DSParser.applySmoothGroups","Max3DSParser.finalizeCurrentMaterial","Max3DSParser.readNulTermstring","Max3DSParser.readTransform","Max3DSParser.readColor"],"mappings":"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ACA,GAACA,CAACA,GAAGA,CAACA,CAACA,GAAGA,QAAQA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;YACpCA,CAACA;YACDA,GAAGA,CAACA,OAAOA,GAAGA,IAAIA,KAAKA,CAASA,KAAKA,CAACA,MAAMA,GAACA,CAACA,CAACA,CAAUA;YAEzDA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,KAAKA,CAACA,MAAMA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBACnCA,GAAGA,CAACA,OAAOA,CAACA,CAACA,GAACA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;gBAC9BA,GAAGA,CAACA,OAAOA,CAACA,CAACA,GAACA,CAACA,GAAGA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;gBAClCA,GAAGA,CAACA,OAAOA,CAACA,CAACA,GAACA,CAACA,GAAGA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;YACnCA,CAACA;YAEDA,EAAEA,CAACA,CAACA,GAAGA,CAACA,GAAGA,CAACA,CAACA,CAACA;gBACbA,AAGAA,4DAH4DA;gBAC5DA,2DAA2DA;gBAC3DA,0CAA0CA;gBAC1CA,GAAGA,CAACA,GAAGA,GAAGA,IAAIA,KAAKA,CAASA,QAAQA,CAACA,MAAMA,GAACA,CAACA,CAACA,CAACA;gBAC/CA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,CAACA,MAAMA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;oBACtCA,GAAGA,CAACA,GAAGA,CAACA,CAACA,GAACA,CAACA,CAACA,GAAGA,QAAQA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;oBAC7BA,GAAGA,CAACA,GAAGA,CAACA,CAACA,GAACA,CAACA,GAAGA,CAACA,CAACA,GAAGA,QAAQA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;gBAClCA,CAACA;YACFA,CA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,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,GAAGA,CAACA;YACpCA,IAAIA,CAACA,GAAYA,IAAIA,QAAQA,CAACA;YAC9BA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,KAAKA,CAACA,CAACA,EAAEA,CAACA,CAACA;YACrBA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,KAAKA,CAACA,CAACA,EAAEA,CAACA,CAACA;YACrBA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,KAAKA,CAACA,CAACA,EAAEA,CAACA,CAACA;YACrBA,EAAEA,CAACA,CAACA,GAAGA,CAACA,GAAGA,CAACA,CAACA,CAACA;gBACbA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA;gBACnBA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,GAAGA,CAACA,CAACA,EAAEA,CAACA,CAACA;YACpBA,CAACA;YACDA,QAAQA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;QACnBA,CAACA;QACDA,GAAGA,GAAGA,GAAGA,CAACA,OAAOA,CAACA,MAAMA,CAACA;QACzBA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,GAAGA,CAACA;YAC7BA,IAAIA,CAACA,GAAUA,IAAIA,MAAMA,EAAEA,CAACA;YAC5BA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,OAAOA,CAACA,CAACA,EAAEA,CAACA,CAACA;YACvBA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,OAAOA,CAACA,CAACA,EAAEA,CAACA,CAACA;YACvBA,CAACA,CAACA,CAACA,GAAGA,GAAGA,CAACA,OAAOA,CAACA,CAACA,EAAEA,CAACA,CAACA;YACvBA,CAACA,CAACA,WAAWA,GAAGA,GAAGA,CAACA,eAAeA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA;YAC5CA,KAAKA,CAACA,CAACA,EAAEA,CAACA,GAAGA,CAACA,CAACA;QAChBA,CAACA;IACFA,CAACA;IAEOjB,wCAAiBA,GAAzBA,UAA0BA,QAAwBA,EAAEA,KAAmBA;QAEtEkB,8CAA8CA;QAC9CA,mDAAmDA;QACnDA,8DAA8DA;QAE9DA,IAAIA,CAACA,CAAQA,OAADA,AAAQA,CAACA;QACrBA,IAAIA,CAACA,CAAQA,OAADA,AAAQA,CAACA;QACrBA,IAAIA,CAACA,CAAQA,OAADA,AAAQA,CAACA;QACrBA,IAAIA,CAACA,CAAQA,OAADA,AAAQA,CAACA;QACrBA,IAAIA,GAAGA,CAAQA,OAADA,AAAQA,CAACA;QACvBA,IAAIA,QAAQA,GAAmBA,QAAQA,CAACA,MAAMA,CAACA;QAC/CA,IAAIA,QAAQA,GAAmBA,KAAKA,CAACA,MAAMA,CAACA;QAE5CA,AACAA,mCADmCA;YAC/BA,OAAOA,GAAiCA,IAAIA,KAAKA,CAAgBA,QAAQA,CAACA,CAACA,QAADA,AAASA,CAACA;QACxFA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,EAAEA,CAACA,EAAEA;YAC5BA,OAAOA,CAACA,CAACA,CAACA,GAAGA,IAAIA,KAAKA,EAAUA,CAAUA;QAC3CA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;YAC/BA,IAAIA,IAAIA,GAAUA,KAAKA,CAACA,CAACA,CAACA,CAACA;YAC3BA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,CAACA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBACxBA,IAAIA,MAAMA,GAA0BA,OAAOA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAEA,IAAIA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAEA,IAAIA,CAACA,CAACA,GAAGA,IAAIA,CAACA,CAACA,CAACA,CAACA,CAACA;gBAC5FA,IAAIA,KAAKA,GAAmBA,IAAIA,CAACA,WAAWA,CAACA;gBAC7CA,GAAGA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA,MAAMA,GAAGA,CAACA,EAAEA,CAACA,IAAIA,CAACA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;oBACzCA,EAAEA,CAACA,CAACA,CAACA,KAAKA,GAAGA,MAAMA,CAACA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,CAACA;wBAC7BA,KAAKA,IAAIA,MAAMA,CAACA,CAACA,CAACA,CAACA;wBACnBA,MAAMA,CAACA,MAAMA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;wBACpBA,CAACA,GAAGA,MAAMA,CAACA,MAAMA,GAAGA,CAACA,CAACA;oBACvBA,CAACA;gBACFA,CAACA;gBACDA,MAAMA,CAACA,IAAIA,CAACA,KAAKA,CAACA,CAACA;YACpBA,CAACA;QACFA,CAACA;QACDA,AACAA,iBADiBA;YACbA,OAAOA,GAAiCA,IAAIA,KAAKA,CAAgBA,QAAQA,CAACA,CAACA,QAADA,AAASA,CAACA;QACxFA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;YAC/BA,EAAEA,CAACA,CAACA,CAACA,GAAGA,GAAGA,OAAOA,CAACA,CAACA,CAACA,CAACA,MAAMA,CAACA,GAAGA,CAACA,CAACA;gBACjCA,QAAQA,CAACA;YACVA,IAAIA,MAAMA,GAA0BA,IAAIA,KAAKA,CAASA,GAAGA,CAACA,CAACA,QAADA,AAASA,CAACA;YACpEA,OAAOA,CAACA,CAACA,CAACA,GAAGA,MAAMA,CAACA;YACpBA,MAAMA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA;YACdA,IAAIA,EAAEA,GAAYA,QAAQA,CAACA,CAACA,CAACA,CAACA;YAC9BA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBAC1BA,IAAIA,EAAEA,GAAYA,IAAIA,QAAQA,CAACA;gBAC/BA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACZA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACZA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACZA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACZA,EAAEA,CAACA,CAACA,GAAGA,EAAEA,CAACA,CAACA,CAACA;gBACZA,MAAMA,CAACA,CAACA,CAACA,GAAGA,QAAQA,CAACA,MAAMA,CAACA;gBAC5BA,QAAQA,CAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA;YACnBA,CAACA;QACFA,CAACA;QACDA,QAAQA,GAAGA,QAAQA,CAACA,MAAMA,CAACA;QAE3BA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,QAAQA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;YAC/BA,IAAIA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA;YAChBA,KAAKA,GAAGA,IAAIA,CAACA,WAAWA,CAACA;YACzBA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,CAACA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;gBACxBA,CAACA,GAAGA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAEA,IAAIA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAEA,IAAIA,CAACA,CAACA,GAAGA,IAAIA,CAACA,CAACA,CAACA,CAACA;gBACnDA,MAAMA,GAAGA,OAAOA,CAACA,CAACA,CAACA,CAACA;gBACpBA,GAAGA,GAAGA,MAAMA,CAACA,MAAMA,CAACA;gBACpBA,MAAMA,GAAGA,OAAOA,CAACA,CAACA,CAACA,CAACA;gBACpBA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,GAAGA,EAAEA,CAACA,EAAEA,EAAEA,CAACA;oBAC1BA,EAAEA,CAACA,CAACA,CAACA,CAACA,KAAKA,IAAIA,CAACA,CAACA,IAAIA,CAACA,MAAMA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,KAAKA,GAAGA,MAAMA,CAACA,CAACA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA,CAACA,CAACA;wBACrEA,IAAIA,KAAKA,GAAmBA,MAAMA,CAACA,CAACA,CAACA,CAACA;wBACtCA,EAAEA,CAACA,CAACA,KAAKA,IAAIA,CAACA,CAACA,CAACA,CAACA;4BAChBA,AACAA,2CAD2CA;4BAC3CA,MAAMA,CAACA,MAAMA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;4BACpBA,MAAMA,CAACA,MAAMA,CAACA,CAACA,EAAEA,CAACA,CAACA,CAACA;wBACrBA,CAACA;wBACDA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA;4BACVA,IAAIA,CAACA,CAACA,GAAGA,KAAKA,CAACA;wBAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA;4BAChCA,IAAIA,CAACA,CAACA,GAAGA,KAAKA,CAACA;wBAACA,IAAIA;4BACpBA,IAAIA,CAACA,CAACA,GAAGA,KAAKA,CAACA;wBAChBA,CAACA,GAAGA,GAAGA,CAACA;oBACTA,CAACA;gBACFA,CAACA;YACFA,CAACA;QACFA,CAACA;IACFA,CAACA;IAEOlB,8CAAuBA,GAA/BA;QAECmB,IAAIA,GAA0BA,CAACA;QAE/BA,EAAEA,CAACA,CAACA,IAAIA,CAACA,QAAQA,CAACA,QAAQA,CAACA;YAC1BA,GAAGA,GAAGA,IAAIA,sBAAsBA,CAACA,IAAIA,CAACA,QAAQA,CAACA,QAAQA,CAACA,OAAOA,IAAIA,sBAAsBA,CAACA,iBAAiBA,EAAEA,CAACA,CAACA;QAChHA,IAAIA;YACHA,GAAGA,GAAGA,IAAIA,sBAAsBA,CAACA,IAAIA,CAACA,QAAQA,CAACA,YAAYA,CAACA,CAACA;QAE9DA,GAAGA,CAACA,YAAYA,GAAGA,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AQA,CAACA;QACvBA,IAAIA,CAACA,CAAQA,OAADA,AAAQA,EAAEA,CAACA,CAAQA,OAADA,AAAQA,EAAEA,CAACA,CAAQA,OAADA,AAAQA,CAACA;QAEzDA,GAAGA,GAAGA,IAAIA,CAACA,SAASA,CAACA,iBAAiBA,EAAEA,CAACA;QACzCA,GAAGA,GAAGA,IAAIA,CAACA,SAASA,CAACA,eAAeA,EAAEA,CAACA;QAEvCA,MAAMA,CAACA,CAACA,GAAGA,CAACA,CAACA,CAACA;YACbA,KAAKA,MAAMA;gBACVA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,GAACA,GAAGA,CAACA;gBACnCA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,GAACA,GAAGA,CAACA;gBACnCA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,SAASA,EAAEA,GAACA,GAAGA,CAACA;gBACnCA,KAAKA,CAACA;YACPA,KAAKA,MAAMA;gBACVA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,gBAAgBA,EAAEA,CAACA;gBACtCA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,gBAAgBA,EAAEA,CAACA;gBACtCA,CAACA,GAAGA,IAAIA,CAACA,SAASA,CAACA,gBAAgBA,EAAEA,CAACA;gBACtCA,KAAKA,CAACA;YACPA;gBACCA,IAAIA,CAACA,SAASA,CAACA,QAAQA,IAAIA,CAACA,GAAGA,GAAGA,CAACA,CAACA,CAACA;gBACrCA,KAAKA,CAACA;QACRA,CAACA;QAEDA,MAAMA,CAACA,CAACA,CAACA,IAAIA,EAAEA,CAACA,GAAGA,CAACA,CAACA,IAAIA,CAACA,CAACA,GAAGA,CAACA,CAACA;IACjCA,CAACA;IACFtB,mBAACA;AAADA,CA1xBA,AA0xBCA,EA1xB0B,UAAU,EA0xBpC;AAED,AAAsB,iBAAb,YAAY,CAAC","file":"parsers/Max3DSParser.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObjectContainer\t\t\t= require(\"awayjs-core/lib/containers/DisplayObjectContainer\");\nimport Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetType\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLLoaderDataFormat\t\t\t\t= require(\"awayjs-core/lib/core/net/URLLoaderDataFormat\");\nimport URLRequest\t\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport ParserBase\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserBase\");\nimport ParserUtils\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserUtils\");\nimport ResourceDependency\t\t\t\t= require(\"awayjs-core/lib/parsers/ResourceDependency\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\nimport TextureProxyBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/TextureProxyBase\");\nimport ByteArray\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/ByteArray\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\n\nimport DefaultMaterialManager\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/DefaultMaterialManager\");\nimport TriangleMethodMaterial\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\nimport TriangleMaterialMode\t\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMaterialMode\");\n\nimport FaceVO\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/FaceVO\");\nimport MaterialVO\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/MaterialVO\");\nimport ObjectVO\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/ObjectVO\");\nimport TextureVO\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/TextureVO\");\nimport VertexVO\t\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/data/VertexVO\");\n\n/**\n * Max3DSParser provides a parser for the 3ds data type.\n */\nclass Max3DSParser extends ParserBase\n{\n\tprivate _byteData:ByteArray;\n\n\tprivate _textures:Object;\n\tprivate _materials:Object;\n\tprivate _unfinalized_objects:Object;\n\n\tprivate _cur_obj_end:number;\n\tprivate _cur_obj:ObjectVO;\n\n\tprivate _cur_mat_end:number;\n\tprivate _cur_mat:MaterialVO;\n\tprivate _useSmoothingGroups:boolean;\n\n\t/**\n\t * Creates a new <code>Max3DSParser</code> object.\n\t *\n\t * @param useSmoothingGroups Determines whether the parser looks for smoothing groups in the 3ds file or assumes uniform smoothing. Defaults to true.\n\t */\n\tconstructor(useSmoothingGroups:boolean = true)\n\t{\n\t\tsuper(URLLoaderDataFormat.ARRAY_BUFFER);\n\n\t\tthis._useSmoothingGroups = useSmoothingGroups;\n\t}\n\n\t/**\n\t * Indicates whether or not a given file extension is supported by the parser.\n\t * @param extension The file extension of a potential file to be parsed.\n\t * @return Whether or not the given file type is supported.\n\t */\n\tpublic static supportsType(extension:string):boolean\n\t{\n\t\textension = extension.toLowerCase();\n\t\treturn extension == \"3ds\";\n\t}\n\n\t/**\n\t * Tests whether a data block can be parsed by the parser.\n\t * @param data The data block to potentially be parsed.\n\t * @return Whether or not the given data is supported.\n\t */\n\tpublic static supportsData(data:any):boolean\n\t{\n\t\tvar ba:ByteArray;\n\n\t\tba = ParserUtils.toByteArray(data);\n\t\tif (ba) {\n\t\t\tba.position = 0;\n\t\t\tif (ba.readShort() == 0x4d4d)\n\t\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependency(resourceDependency:ResourceDependency):void\n\t{\n\t\tif (resourceDependency.assets.length == 1) {\n\t\t\tvar asset:IAsset;\n\n\t\t\tasset = resourceDependency.assets[0];\n\t\t\tif (asset.assetType == AssetType.TEXTURE) {\n\t\t\t\tvar tex:TextureVO;\n\n\t\t\t\ttex = this._textures[resourceDependency.id];\n\t\t\t\ttex.texture = <Texture2DBase> asset;\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependencyFailure(resourceDependency:ResourceDependency):void\n\t{\n\t\t// TODO: Implement\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pProceedParsing():boolean\n\t{\n\t\tif (!this._byteData) {\n\t\t\tthis._byteData = this._pGetByteData();\n\t\t\tthis._byteData.position = 0;\n\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t// LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray\n\t\t\t//----------------------------------------------------------------------------\n\t\t\t//this._byteData.endian = Endian.LITTLE_ENDIAN;// Should be default\n\t\t\t//----------------------------------------------------------------------------\n\n\t\t\tthis._textures = {};\n\t\t\tthis._materials = {};\n\t\t\tthis._unfinalized_objects = {};\n\t\t}\n\n\t\t// TODO: With this construct, the loop will run no-op for as long\n\t\t// as there is time once file has finished reading. Consider a nice\n\t\t// way to stop loop when byte array is empty, without putting it in\n\t\t// the while-conditional, which will prevent finalizations from\n\t\t// happening after the last chunk.\n\t\twhile (this._pHasTime()) {\n\n\t\t\t// If we are currently working on an object, and the most recent chunk was\n\t\t\t// the last one in that object, finalize the current object.\n\t\t\tif (this._cur_mat && this._byteData.position >= this._cur_mat_end)\n\t\t\t\tthis.finalizeCurrentMaterial();\n\t\t\telse if (this._cur_obj && this._byteData.position >= this._cur_obj_end) {\n\t\t\t\t// Can't finalize at this point, because we have to wait until the full\n\t\t\t\t// animation section has been parsed for any potential pivot definitions\n\t\t\t\tthis._unfinalized_objects[this._cur_obj.name] = this._cur_obj;\n\t\t\t\tthis._cur_obj_end = Number.MAX_VALUE /*uint*/;\n\t\t\t\tthis._cur_obj = null;\n\t\t\t}\n\n\t\t\tif (this._byteData.getBytesAvailable() > 0) {\n\t\t\t\tvar cid:number /*uint*/;\n\t\t\t\tvar len:number /*uint*/;\n\t\t\t\tvar end:number /*uint*/;\n\n\t\t\t\tcid = this._byteData.readUnsignedShort();\n\t\t\t\tlen = this._byteData.readUnsignedInt();\n\t\t\t\tend = this._byteData.position + (len - 6);\n\n\t\t\t\tswitch (cid) {\n\t\t\t\t\tcase 0x4D4D: // MAIN3DS\n\t\t\t\t\tcase 0x3D3D: // EDIT3DS\n\t\t\t\t\tcase 0xB000: // KEYF3DS\n\t\t\t\t\t\t// This types are \"container chunks\" and contain only\n\t\t\t\t\t\t// sub-chunks (no data on their own.) This means that\n\t\t\t\t\t\t// there is nothing more to parse at this point, and\n\t\t\t\t\t\t// instead we should progress to the next chunk, which\n\t\t\t\t\t\t// will be the first sub-chunk of this one.\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0xAFFF: // MATERIAL\n\t\t\t\t\t\tthis._cur_mat_end = end;\n\t\t\t\t\t\tthis._cur_mat = this.parseMaterial();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4000: // EDIT_OBJECT\n\t\t\t\t\t\tthis._cur_obj_end = end;\n\t\t\t\t\t\tthis._cur_obj = new ObjectVO();\n\t\t\t\t\t\tthis._cur_obj.name = this.readNulTermstring();\n\t\t\t\t\t\tthis._cur_obj.materials = new Array<string>();\n\t\t\t\t\t\tthis._cur_obj.materialFaces = {};\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4100: // OBJ_TRIMESH\n\t\t\t\t\t\tthis._cur_obj.type = AssetType.MESH;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4110: // TRI_VERTEXL\n\t\t\t\t\t\tthis.parseVertexList();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4120: // TRI_FACELIST\n\t\t\t\t\t\tthis.parseFaceList();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4140: // TRI_MAPPINGCOORDS\n\t\t\t\t\t\tthis.parseUVList();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4130: // Face materials\n\t\t\t\t\t\tthis.parseFaceMaterialList();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4160: // Transform\n\t\t\t\t\t\tthis._cur_obj.transform = this.readTransform();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0xB002: // Object animation (including pivot)\n\t\t\t\t\t\tthis.parseObjectAnimation(end);\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 0x4150: // Smoothing groups\n\t\t\t\t\t\tthis.parseSmoothingGroups();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tdefault:\n\t\t\t\t\t\t// Skip this (unknown) chunk\n\t\t\t\t\t\tthis._byteData.position += (len - 6);\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\t// Pause parsing if there were any dependencies found during this\n\t\t\t\t// iteration (i.e. if there are any dependencies that need to be\n\t\t\t\t// retrieved at this time.)\n\t\t\t\tif (this.dependencies.length) {\n\t\t\t\t\tthis._pPauseAndRetrieveDependencies();\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// More parsing is required if the entire byte array has not yet\n\t\t// been read, or if there is a currently non-finalized object in\n\t\t// the pipeline.\n\t\tif (this._byteData.getBytesAvailable() || this._cur_obj || this._cur_mat) {\n\t\t\treturn ParserBase.MORE_TO_PARSE;\n\t\t} else {\n\t\t\tvar name:string;\n\n\t\t\t// Finalize any remaining objects before ending.\n\t\t\tfor (name in this._unfinalized_objects) {\n\t\t\t\tvar obj:DisplayObjectContainer;\n\t\t\t\tobj = this.constructObject(this._unfinalized_objects[name]);\n\t\t\t\tif (obj) {\n\t\t\t\t\t//add to the content property\n\t\t\t\t\t(<DisplayObjectContainer> this._pContent).addChild(obj);\n\n\t\t\t\t\tthis._pFinalizeAsset(obj, name);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn ParserBase.PARSING_DONE;\n\t\t}\n\t}\n\n\tpublic _pStartParsing(frameLimit:number)\n\t{\n\t\tsuper._pStartParsing(frameLimit);\n\n\t\t//create a content object for Loaders\n\t\tthis._pContent = new DisplayObjectContainer();\n\t}\n\n\tprivate parseMaterial():MaterialVO\n\t{\n\t\tvar mat:MaterialVO;\n\n\t\tmat = new MaterialVO();\n\n\t\twhile (this._byteData.position < this._cur_mat_end) {\n\t\t\tvar cid:number /*uint*/;\n\t\t\tvar len:number /*uint*/;\n\t\t\tvar end:number /*uint*/;\n\n\t\t\tcid = this._byteData.readUnsignedShort();\n\t\t\tlen = this._byteData.readUnsignedInt();\n\t\t\tend = this._byteData.position + (len - 6);\n\n\t\t\tswitch (cid) {\n\t\t\t\tcase 0xA000: // Material name\n\t\t\t\t\tmat.name = this.readNulTermstring();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 0xA010: // Ambient color\n\t\t\t\t\tmat.ambientColor = this.readColor();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 0xA020: // Diffuse color\n\t\t\t\t\tmat.diffuseColor = this.readColor();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 0xA030: // Specular color\n\t\t\t\t\tmat.specularColor = this.readColor();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 0xA081: // Two-sided, existence indicates \"true\"\n\t\t\t\t\tmat.twoSided = true;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 0xA200: // Main (color) texture\n\t\t\t\t\tmat.colorMap = this.parseTexture(end);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 0xA204: // Specular map\n\t\t\t\t\tmat.specularMap = this.parseTexture(end);\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\tthis._byteData.position = end;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn mat;\n\t}\n\n\tprivate parseTexture(end:number /*uint*/):TextureVO\n\t{\n\t\tvar tex:TextureVO;\n\n\t\ttex = new TextureVO();\n\n\t\twhile (this._byteData.position < end) {\n\t\t\tvar cid:number /*uint*/;\n\t\t\tvar len:number /*uint*/;\n\n\t\t\tcid = this._byteData.readUnsignedShort();\n\t\t\tlen = this._byteData.readUnsignedInt();\n\n\t\t\tswitch (cid) {\n\t\t\t\tcase 0xA300:\n\t\t\t\t\ttex.url = this.readNulTermstring();\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\t// Skip this unknown texture sub-chunk\n\t\t\t\t\tthis._byteData.position += (len - 6);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tthis._textures[tex.url] = tex;\n\t\tthis._pAddDependency(tex.url, new URLRequest(tex.url));\n\n\t\treturn tex;\n\t}\n\n\tprivate parseVertexList():void\n\t{\n\t\tvar i:number /*uint*/;\n\t\tvar len:number /*uint*/;\n\t\tvar count:number /*uint*/;\n\n\t\tcount = this._byteData.readUnsignedShort();\n\t\tthis._cur_obj.verts = new Array<number>(count*3);\n\n\t\ti = 0;\n\t\tlen = this._cur_obj.verts.length;\n\t\twhile (i < len) {\n\t\t\tvar x:number, y:number, z:number;\n\n\t\t\tx = this._byteData.readFloat();\n\t\t\ty = this._byteData.readFloat();\n\t\t\tz = this._byteData.readFloat();\n\n\t\t\tthis._cur_obj.verts[i++] = x;\n\t\t\tthis._cur_obj.verts[i++] = z;\n\t\t\tthis._cur_obj.verts[i++] = y;\n\t\t}\n\t}\n\n\tprivate parseFaceList():void\n\t{\n\t\tvar i:number /*uint*/;\n\t\tvar len:number /*uint*/;\n\t\tvar count:number /*uint*/;\n\n\t\tcount = this._byteData.readUnsignedShort();\n\t\tthis._cur_obj.indices = new Array<number>(count*3) /*uint*/;\n\n\t\ti = 0;\n\t\tlen = this._cur_obj.indices.length;\n\t\twhile (i < len) {\n\t\t\tvar i0:number /*uint*/, i1:number /*uint*/, i2:number /*uint*/;\n\n\t\t\ti0 = this._byteData.readUnsignedShort();\n\t\t\ti1 = this._byteData.readUnsignedShort();\n\t\t\ti2 = this._byteData.readUnsignedShort();\n\n\t\t\tthis._cur_obj.indices[i++] = i0;\n\t\t\tthis._cur_obj.indices[i++] = i2;\n\t\t\tthis._cur_obj.indices[i++] = i1;\n\n\t\t\t// Skip \"face info\", irrelevant in Away3D\n\t\t\tthis._byteData.position += 2;\n\t\t}\n\n\t\tthis._cur_obj.smoothingGroups = new Array<number>(count) /*uint*/;\n\t}\n\n\tprivate parseSmoothingGroups():void\n\t{\n\t\tvar len:number /*uint*/ = this._cur_obj.indices.length/3;\n\t\tvar i:number /*uint*/ = 0;\n\t\twhile (i < len) {\n\t\t\tthis._cur_obj.smoothingGroups[i] = this._byteData.readUnsignedInt();\n\t\t\ti++;\n\t\t}\n\t}\n\n\tprivate parseUVList():void\n\t{\n\t\tvar i:number /*uint*/;\n\t\tvar len:number /*uint*/;\n\t\tvar count:number /*uint*/;\n\n\t\tcount = this._byteData.readUnsignedShort();\n\t\tthis._cur_obj.uvs = new Array<number>(count*2);\n\n\t\ti = 0;\n\t\tlen = this._cur_obj.uvs.length;\n\t\twhile (i < len) {\n\t\t\tthis._cur_obj.uvs[i++] = this._byteData.readFloat();\n\t\t\tthis._cur_obj.uvs[i++] = 1.0 - this._byteData.readFloat();\n\t\t}\n\t}\n\n\tprivate parseFaceMaterialList():void\n\t{\n\t\tvar mat:string;\n\t\tvar count:number /*uint*/;\n\t\tvar i:number /*uint*/;\n\t\tvar faces:Array<number> /*uint*/;\n\n\t\tmat = this.readNulTermstring();\n\t\tcount = this._byteData.readUnsignedShort();\n\n\t\tfaces = new Array<number>(count) /*uint*/;\n\t\ti = 0;\n\t\twhile (i < faces.length)\n\t\t\tfaces[i++] = this._byteData.readUnsignedShort();\n\n\t\tthis._cur_obj.materials.push(mat);\n\t\tthis._cur_obj.materialFaces[mat] = faces;\n\t}\n\n\tprivate parseObjectAnimation(end:number):void\n\t{\n\t\tvar vo:ObjectVO;\n\t\tvar obj:DisplayObjectContainer;\n\t\tvar pivot:Vector3D;\n\t\tvar name:string;\n\t\tvar hier:number /*uint*/;\n\n\t\t// Pivot defaults to origin\n\t\tpivot = new Vector3D;\n\n\t\twhile (this._byteData.position < end) {\n\t\t\tvar cid:number /*uint*/;\n\t\t\tvar len:number /*uint*/;\n\n\t\t\tcid = this._byteData.readUnsignedShort();\n\t\t\tlen = this._byteData.readUnsignedInt();\n\n\t\t\tswitch (cid) {\n\t\t\t\tcase 0xb010: // Name/hierarchy\n\t\t\t\t\tname = this.readNulTermstring();\n\t\t\t\t\tthis._byteData.position += 4;\n\t\t\t\t\thier = this._byteData.readShort();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 0xb013: // Pivot\n\t\t\t\t\tpivot.x = this._byteData.readFloat();\n\t\t\t\t\tpivot.z = this._byteData.readFloat();\n\t\t\t\t\tpivot.y = this._byteData.readFloat();\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\tthis._byteData.position += (len - 6);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\t// If name is \"$$$DUMMY\" this is an empty object (e.g. a container)\n\t\t// and will be ignored in this version of the parser\n\t\t// TODO: Implement containers in 3DS parser.\n\t\tif (name != '$$$DUMMY' && this._unfinalized_objects.hasOwnProperty(name)) {\n\t\t\tvo = this._unfinalized_objects[name];\n\t\t\tobj = this.constructObject(vo, pivot);\n\n\t\t\tif (obj) {\n\t\t\t\t//add to the content property\n\t\t\t\t(<DisplayObjectContainer> this._pContent).addChild(obj);\n\n\t\t\t\tthis._pFinalizeAsset(obj, vo.name);\n\t\t\t}\n\n\n\t\t\tdelete this._unfinalized_objects[name];\n\t\t}\n\t}\n\n\tprivate constructObject(obj:ObjectVO, pivot:Vector3D = null):DisplayObjectContainer\n\t{\n\t\tif (obj.type == AssetType.MESH) {\n\t\t\tvar i:number /*uint*/;\n\t\t\tvar sub:TriangleSubGeometry;\n\t\t\tvar geom:Geometry;\n\t\t\tvar mat:MaterialBase;\n\t\t\tvar mesh:Mesh;\n\t\t\tvar mtx:Matrix3D;\n\t\t\tvar vertices:Array<VertexVO>;\n\t\t\tvar faces:Array<FaceVO>;\n\n\t\t\tif (obj.materials.length > 1)\n\t\t\t\tconsole.log(\"The Away3D 3DS parser does not support multiple materials per mesh at this point.\");\n\n\t\t\t// Ignore empty objects\n\t\t\tif (!obj.indices || obj.indices.length == 0)\n\t\t\t\treturn null;\n\n\t\t\tvertices = new Array<VertexVO>(obj.verts.length/3);\n\t\t\tfaces = new Array<FaceVO>(obj.indices.length/3);\n\n\t\t\tthis.prepareData(vertices, faces, obj);\n\n\t\t\tif (this._useSmoothingGroups)\n\t\t\t\tthis.applySmoothGroups(vertices, faces);\n\n\t\t\tobj.verts = new Array<number>(vertices.length*3);\n\t\t\tfor (i = 0; i < vertices.length; i++) {\n\t\t\t\tobj.verts[i*3] = vertices[i].x;\n\t\t\t\tobj.verts[i*3 + 1] = vertices[i].y;\n\t\t\t\tobj.verts[i*3 + 2] = vertices[i].z;\n\t\t\t}\n\t\t\tobj.indices = new Array<number>(faces.length*3) /*uint*/;\n\n\t\t\tfor (i = 0; i < faces.length; i++) {\n\t\t\t\tobj.indices[i*3] = faces[i].a;\n\t\t\t\tobj.indices[i*3 + 1] = faces[i].b;\n\t\t\t\tobj.indices[i*3 + 2] = faces[i].c;\n\t\t\t}\n\n\t\t\tif (obj.uvs) {\n\t\t\t\t// If the object had UVs to start with, use UVs generated by\n\t\t\t\t// smoothing group splitting algorithm. Otherwise those UVs\n\t\t\t\t// will be nonsense and should be skipped.\n\t\t\t\tobj.uvs = new Array<number>(vertices.length*2);\n\t\t\t\tfor (i = 0; i < vertices.length; i++) {\n\t\t\t\t\tobj.uvs[i*2] = vertices[i].u;\n\t\t\t\t\tobj.uvs[i*2 + 1] = vertices[i].v;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tgeom = new Geometry();\n\n\t\t\t// Construct sub-geometries (potentially splitting buffers)\n\t\t\t// and add them to geometry.\n\t\t\tsub = new TriangleSubGeometry(true);\n\t\t\tsub.updateIndices(obj.indices);\n\t\t\tsub.updatePositions(obj.verts);\n\t\t\tsub.updateUVs(obj.uvs);\n\n\t\t\tgeom.addSubGeometry(sub);\n\n\t\t\tif (obj.materials.length > 0) {\n\t\t\t\tvar mname:string;\n\t\t\t\tmname = obj.materials[0];\n\t\t\t\tmat = this._materials[mname].material;\n\t\t\t}\n\n\t\t\t// Apply pivot translation to geometry if a pivot was\n\t\t\t// found while parsing the keyframe chunk earlier.\n\t\t\tif (pivot) {\n\t\t\t\tif (obj.transform) {\n\t\t\t\t\t// If a transform was found while parsing the\n\t\t\t\t\t// object chunk, use it to find the local pivot vector\n\t\t\t\t\tvar dat:Array<number> = obj.transform.concat();\n\t\t\t\t\tdat[12] = 0;\n\t\t\t\t\tdat[13] = 0;\n\t\t\t\t\tdat[14] = 0;\n\t\t\t\t\tmtx = new Matrix3D(dat);\n\t\t\t\t\tpivot = mtx.transformVector(pivot);\n\t\t\t\t}\n\n\t\t\t\tpivot.scaleBy(-1);\n\n\t\t\t\tmtx = new Matrix3D();\n\t\t\t\tmtx.appendTranslation(pivot.x, pivot.y, pivot.z);\n\t\t\t\tgeom.applyTransformation(mtx);\n\t\t\t}\n\n\t\t\t// Apply transformation to geometry if a transformation\n\t\t\t// was found while parsing the object chunk earlier.\n\t\t\tif (obj.transform) {\n\t\t\t\tmtx = new Matrix3D(obj.transform);\n\t\t\t\tmtx.invert();\n\t\t\t\tgeom.applyTransformation(mtx);\n\t\t\t}\n\n\t\t\t// Final transform applied to geometry. Finalize the geometry,\n\t\t\t// which will no longer be modified after this point.\n\t\t\tthis._pFinalizeAsset(geom, obj.name.concat('_geom'));\n\n\t\t\t// Build mesh and return it\n\t\t\tmesh = new Mesh(geom, mat);\n\t\t\tmesh.transform.matrix3D = new Matrix3D(obj.transform);\n\t\t\treturn mesh;\n\t\t}\n\n\t\t// If reached, unknown\n\t\treturn null;\n\t}\n\n\tprivate prepareData(vertices:Array<VertexVO>, faces:Array<FaceVO>, obj:ObjectVO):void\n\t{\n\t\t// convert raw ObjectVO's data to structured VertexVO and FaceVO\n\t\tvar i:number /*int*/;\n\t\tvar j:number /*int*/;\n\t\tvar k:number /*int*/;\n\t\tvar len:number /*int*/ = obj.verts.length;\n\t\tfor (i = 0, j = 0, k = 0; i < len;) {\n\t\t\tvar v:VertexVO = new VertexVO;\n\t\t\tv.x = obj.verts[i++];\n\t\t\tv.y = obj.verts[i++];\n\t\t\tv.z = obj.verts[i++];\n\t\t\tif (obj.uvs) {\n\t\t\t\tv.u = obj.uvs[j++];\n\t\t\t\tv.v = obj.uvs[j++];\n\t\t\t}\n\t\t\tvertices[k++] = v;\n\t\t}\n\t\tlen = obj.indices.length;\n\t\tfor (i = 0, k = 0; i < len;) {\n\t\t\tvar f:FaceVO = new FaceVO();\n\t\t\tf.a = obj.indices[i++];\n\t\t\tf.b = obj.indices[i++];\n\t\t\tf.c = obj.indices[i++];\n\t\t\tf.smoothGroup = obj.smoothingGroups[k] || 0;\n\t\t\tfaces[k++] = f;\n\t\t}\n\t}\n\n\tprivate applySmoothGroups(vertices:Array<VertexVO>, faces:Array<FaceVO>):void\n\t{\n\t\t// clone vertices according to following rule:\n\t\t// clone if vertex's in faces from groups 1+2 and 3\n\t\t// don't clone if vertex's in faces from groups 1+2, 3 and 1+3\n\n\t\tvar i:number /*int*/;\n\t\tvar j:number /*int*/;\n\t\tvar k:number /*int*/;\n\t\tvar l:number /*int*/;\n\t\tvar len:number /*int*/;\n\t\tvar numVerts:number /*uint*/ = vertices.length;\n\t\tvar numFaces:number /*uint*/ = faces.length;\n\n\t\t// extract groups data for vertices\n\t\tvar vGroups:Array<Array<number>> /*uint*/ = new Array<Array<number>>(numVerts) /*uint*/;\n\t\tfor (i = 0; i < numVerts; i++)\n\t\t\tvGroups[i] = new Array<number>() /*uint*/;\n\t\tfor (i = 0; i < numFaces; i++) {\n\t\t\tvar face:FaceVO = faces[i];\n\t\t\tfor (j = 0; j < 3; j++) {\n\t\t\t\tvar groups:Array<number> /*uint*/ = vGroups[(j == 0)? face.a : ((j == 1)? face.b : face.c)];\n\t\t\t\tvar group:number /*uint*/ = face.smoothGroup;\n\t\t\t\tfor (k = groups.length - 1; k >= 0; k--) {\n\t\t\t\t\tif ((group & groups[k]) > 0) {\n\t\t\t\t\t\tgroup |= groups[k];\n\t\t\t\t\t\tgroups.splice(k, 1);\n\t\t\t\t\t\tk = groups.length - 1;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tgroups.push(group);\n\t\t\t}\n\t\t}\n\t\t// clone vertices\n\t\tvar vClones:Array<Array<number>> /*uint*/ = new Array<Array<number>>(numVerts) /*uint*/;\n\t\tfor (i = 0; i < numVerts; i++) {\n\t\t\tif ((len = vGroups[i].length) < 1)\n\t\t\t\tcontinue;\n\t\t\tvar clones:Array<number> /*uint*/ = new Array<number>(len) /*uint*/;\n\t\t\tvClones[i] = clones;\n\t\t\tclones[0] = i;\n\t\t\tvar v0:VertexVO = vertices[i];\n\t\t\tfor (j = 1; j < len; j++) {\n\t\t\t\tvar v1:VertexVO = new VertexVO;\n\t\t\t\tv1.x = v0.x;\n\t\t\t\tv1.y = v0.y;\n\t\t\t\tv1.z = v0.z;\n\t\t\t\tv1.u = v0.u;\n\t\t\t\tv1.v = v0.v;\n\t\t\t\tclones[j] = vertices.length;\n\t\t\t\tvertices.push(v1);\n\t\t\t}\n\t\t}\n\t\tnumVerts = vertices.length;\n\n\t\tfor (i = 0; i < numFaces; i++) {\n\t\t\tface = faces[i];\n\t\t\tgroup = face.smoothGroup;\n\t\t\tfor (j = 0; j < 3; j++) {\n\t\t\t\tk = (j == 0)? face.a : ((j == 1)? face.b : face.c);\n\t\t\t\tgroups = vGroups[k];\n\t\t\t\tlen = groups.length;\n\t\t\t\tclones = vClones[k];\n\t\t\t\tfor (l = 0; l < len; l++) {\n\t\t\t\t\tif (((group == 0) && (groups[l] == 0)) || ((group & groups[l]) > 0)) {\n\t\t\t\t\t\tvar index:number /*uint*/ = clones[l];\n\t\t\t\t\t\tif (group == 0) {\n\t\t\t\t\t\t\t// vertex is unique if no smoothGroup found\n\t\t\t\t\t\t\tgroups.splice(l, 1);\n\t\t\t\t\t\t\tclones.splice(l, 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (j == 0)\n\t\t\t\t\t\t\tface.a = index; else if (j == 1)\n\t\t\t\t\t\t\tface.b = index; else\n\t\t\t\t\t\t\tface.c = index;\n\t\t\t\t\t\tl = len;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate finalizeCurrentMaterial():void\n\t{\n\t\tvar mat:TriangleMethodMaterial;\n\n\t\tif (this._cur_mat.colorMap)\n\t\t\tmat = new TriangleMethodMaterial(this._cur_mat.colorMap.texture || DefaultMaterialManager.getDefaultTexture());\n\t\telse\n\t\t\tmat = new TriangleMethodMaterial(this._cur_mat.ambientColor);\n\n\t\tmat.diffuseColor = this._cur_mat.diffuseColor;\n\t\tmat.specularColor = this._cur_mat.specularColor;\n\n\t\tif (this.materialMode >= 2)\n\t\t\tmat.materialMode = TriangleMaterialMode.MULTI_PASS\n\n\t\tmat.bothSides = this._cur_mat.twoSided;\n\n\t\tthis._pFinalizeAsset(mat, this._cur_mat.name);\n\n\t\tthis._materials[this._cur_mat.name] = this._cur_mat;\n\t\tthis._cur_mat.material = mat;\n\n\t\tthis._cur_mat = null;\n\t}\n\n\tprivate readNulTermstring():string\n\t{\n\t\tvar chr:number /*int*/;\n\t\tvar str:string = \"\";\n\n\t\twhile ((chr = this._byteData.readUnsignedByte()) > 0)\n\t\t\tstr += String.fromCharCode(chr);\n\n\t\treturn str;\n\t}\n\n\tprivate readTransform():Array<number>\n\t{\n\t\tvar data:Array<number>;\n\n\t\tdata = new Array<number>(16);\n\n\t\t// X axis\n\t\tdata[0] = this._byteData.readFloat(); // X\n\t\tdata[2] = this._byteData.readFloat(); // Z\n\t\tdata[1] = this._byteData.readFloat(); // Y\n\t\tdata[3] = 0;\n\n\t\t// Z axis\n\t\tdata[8] = this._byteData.readFloat(); // X\n\t\tdata[10] = this._byteData.readFloat(); // Z\n\t\tdata[9] = this._byteData.readFloat(); // Y\n\t\tdata[11] = 0;\n\n\t\t// Y Axis\n\t\tdata[4] = this._byteData.readFloat(); // X\n\t\tdata[6] = this._byteData.readFloat(); // Z\n\t\tdata[5] = this._byteData.readFloat(); // Y\n\t\tdata[7] = 0;\n\n\t\t// Translation\n\t\tdata[12] = this._byteData.readFloat(); // X\n\t\tdata[14] = this._byteData.readFloat(); // Z\n\t\tdata[13] = this._byteData.readFloat(); // Y\n\t\tdata[15] = 1;\n\n\t\treturn data;\n\t}\n\n\tprivate readColor():number /*int*/\n\t{\n\t\tvar cid:number /*int*/;\n\t\tvar len:number /*int*/;\n\t\tvar r:number /*int*/, g:number /*int*/, b:number /*int*/;\n\n\t\tcid = this._byteData.readUnsignedShort();\n\t\tlen = this._byteData.readUnsignedInt();\n\n\t\tswitch (cid) {\n\t\t\tcase 0x0010: // Floats\n\t\t\t\tr = this._byteData.readFloat()*255;\n\t\t\t\tg = this._byteData.readFloat()*255;\n\t\t\t\tb = this._byteData.readFloat()*255;\n\t\t\t\tbreak;\n\t\t\tcase 0x0011: // 24-bit color\n\t\t\t\tr = this._byteData.readUnsignedByte();\n\t\t\t\tg = this._byteData.readUnsignedByte();\n\t\t\t\tb = this._byteData.readUnsignedByte();\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthis._byteData.position += (len - 6);\n\t\t\t\tbreak;\n\t\t}\n\n\t\treturn (r << 16) | (g << 8) | b;\n\t}\n}\n\nexport = Max3DSParser;\n\n\n"]} \ No newline at end of file diff --git a/lib/parsers/Max3DSParser.ts b/lib/parsers/Max3DSParser.ts new file mode 100644 index 000000000..89cc3e442 --- /dev/null +++ b/lib/parsers/Max3DSParser.ts @@ -0,0 +1,830 @@ +import DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import AssetType = require("awayjs-core/lib/core/library/AssetType"); +import IAsset = require("awayjs-core/lib/core/library/IAsset"); +import URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +import URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +import ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +import ResourceDependency = require("awayjs-core/lib/parsers/ResourceDependency"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); +import TextureProxyBase = require("awayjs-core/lib/textures/TextureProxyBase"); +import ByteArray = require("awayjs-core/lib/utils/ByteArray"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); + +import DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); +import TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +import TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); + +import FaceVO = require("awayjs-renderergl/lib/parsers/data/FaceVO"); +import MaterialVO = require("awayjs-renderergl/lib/parsers/data/MaterialVO"); +import ObjectVO = require("awayjs-renderergl/lib/parsers/data/ObjectVO"); +import TextureVO = require("awayjs-renderergl/lib/parsers/data/TextureVO"); +import VertexVO = require("awayjs-renderergl/lib/parsers/data/VertexVO"); + +/** + * Max3DSParser provides a parser for the 3ds data type. + */ +class Max3DSParser extends ParserBase +{ + private _byteData:ByteArray; + + private _textures:Object; + private _materials:Object; + private _unfinalized_objects:Object; + + private _cur_obj_end:number; + private _cur_obj:ObjectVO; + + private _cur_mat_end:number; + private _cur_mat:MaterialVO; + private _useSmoothingGroups:boolean; + + /** + * Creates a new Max3DSParser object. + * + * @param useSmoothingGroups Determines whether the parser looks for smoothing groups in the 3ds file or assumes uniform smoothing. Defaults to true. + */ + constructor(useSmoothingGroups:boolean = true) + { + super(URLLoaderDataFormat.ARRAY_BUFFER); + + this._useSmoothingGroups = useSmoothingGroups; + } + + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + public static supportsType(extension:string):boolean + { + extension = extension.toLowerCase(); + return extension == "3ds"; + } + + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + public static supportsData(data:any):boolean + { + var ba:ByteArray; + + ba = ParserUtils.toByteArray(data); + if (ba) { + ba.position = 0; + if (ba.readShort() == 0x4d4d) + return true; + } + + return false; + } + + /** + * @inheritDoc + */ + public _iResolveDependency(resourceDependency:ResourceDependency):void + { + if (resourceDependency.assets.length == 1) { + var asset:IAsset; + + asset = resourceDependency.assets[0]; + if (asset.assetType == AssetType.TEXTURE) { + var tex:TextureVO; + + tex = this._textures[resourceDependency.id]; + tex.texture = asset; + } + } + } + + /** + * @inheritDoc + */ + public _iResolveDependencyFailure(resourceDependency:ResourceDependency):void + { + // TODO: Implement + } + + /** + * @inheritDoc + */ + public _pProceedParsing():boolean + { + if (!this._byteData) { + this._byteData = this._pGetByteData(); + this._byteData.position = 0; + + //---------------------------------------------------------------------------- + // LITTLE_ENDIAN - Default for ArrayBuffer / Not implemented in ByteArray + //---------------------------------------------------------------------------- + //this._byteData.endian = Endian.LITTLE_ENDIAN;// Should be default + //---------------------------------------------------------------------------- + + this._textures = {}; + this._materials = {}; + this._unfinalized_objects = {}; + } + + // TODO: With this construct, the loop will run no-op for as long + // as there is time once file has finished reading. Consider a nice + // way to stop loop when byte array is empty, without putting it in + // the while-conditional, which will prevent finalizations from + // happening after the last chunk. + while (this._pHasTime()) { + + // If we are currently working on an object, and the most recent chunk was + // the last one in that object, finalize the current object. + if (this._cur_mat && this._byteData.position >= this._cur_mat_end) + this.finalizeCurrentMaterial(); + else if (this._cur_obj && this._byteData.position >= this._cur_obj_end) { + // Can't finalize at this point, because we have to wait until the full + // animation section has been parsed for any potential pivot definitions + this._unfinalized_objects[this._cur_obj.name] = this._cur_obj; + this._cur_obj_end = Number.MAX_VALUE /*uint*/; + this._cur_obj = null; + } + + if (this._byteData.getBytesAvailable() > 0) { + var cid:number /*uint*/; + var len:number /*uint*/; + var end:number /*uint*/; + + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + end = this._byteData.position + (len - 6); + + switch (cid) { + case 0x4D4D: // MAIN3DS + case 0x3D3D: // EDIT3DS + case 0xB000: // KEYF3DS + // This types are "container chunks" and contain only + // sub-chunks (no data on their own.) This means that + // there is nothing more to parse at this point, and + // instead we should progress to the next chunk, which + // will be the first sub-chunk of this one. + continue; + break; + + case 0xAFFF: // MATERIAL + this._cur_mat_end = end; + this._cur_mat = this.parseMaterial(); + break; + + case 0x4000: // EDIT_OBJECT + this._cur_obj_end = end; + this._cur_obj = new ObjectVO(); + this._cur_obj.name = this.readNulTermstring(); + this._cur_obj.materials = new Array(); + this._cur_obj.materialFaces = {}; + break; + + case 0x4100: // OBJ_TRIMESH + this._cur_obj.type = AssetType.MESH; + break; + + case 0x4110: // TRI_VERTEXL + this.parseVertexList(); + break; + + case 0x4120: // TRI_FACELIST + this.parseFaceList(); + break; + + case 0x4140: // TRI_MAPPINGCOORDS + this.parseUVList(); + break; + + case 0x4130: // Face materials + this.parseFaceMaterialList(); + break; + + case 0x4160: // Transform + this._cur_obj.transform = this.readTransform(); + break; + + case 0xB002: // Object animation (including pivot) + this.parseObjectAnimation(end); + break; + + case 0x4150: // Smoothing groups + this.parseSmoothingGroups(); + break; + + default: + // Skip this (unknown) chunk + this._byteData.position += (len - 6); + break; + } + + // Pause parsing if there were any dependencies found during this + // iteration (i.e. if there are any dependencies that need to be + // retrieved at this time.) + if (this.dependencies.length) { + this._pPauseAndRetrieveDependencies(); + break; + } + } + } + + // More parsing is required if the entire byte array has not yet + // been read, or if there is a currently non-finalized object in + // the pipeline. + if (this._byteData.getBytesAvailable() || this._cur_obj || this._cur_mat) { + return ParserBase.MORE_TO_PARSE; + } else { + var name:string; + + // Finalize any remaining objects before ending. + for (name in this._unfinalized_objects) { + var obj:DisplayObjectContainer; + obj = this.constructObject(this._unfinalized_objects[name]); + if (obj) { + //add to the content property + ( this._pContent).addChild(obj); + + this._pFinalizeAsset(obj, name); + } + } + + return ParserBase.PARSING_DONE; + } + } + + public _pStartParsing(frameLimit:number) + { + super._pStartParsing(frameLimit); + + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + } + + private parseMaterial():MaterialVO + { + var mat:MaterialVO; + + mat = new MaterialVO(); + + while (this._byteData.position < this._cur_mat_end) { + var cid:number /*uint*/; + var len:number /*uint*/; + var end:number /*uint*/; + + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + end = this._byteData.position + (len - 6); + + switch (cid) { + case 0xA000: // Material name + mat.name = this.readNulTermstring(); + break; + + case 0xA010: // Ambient color + mat.ambientColor = this.readColor(); + break; + + case 0xA020: // Diffuse color + mat.diffuseColor = this.readColor(); + break; + + case 0xA030: // Specular color + mat.specularColor = this.readColor(); + break; + + case 0xA081: // Two-sided, existence indicates "true" + mat.twoSided = true; + break; + + case 0xA200: // Main (color) texture + mat.colorMap = this.parseTexture(end); + break; + + case 0xA204: // Specular map + mat.specularMap = this.parseTexture(end); + break; + + default: + this._byteData.position = end; + break; + } + } + + return mat; + } + + private parseTexture(end:number /*uint*/):TextureVO + { + var tex:TextureVO; + + tex = new TextureVO(); + + while (this._byteData.position < end) { + var cid:number /*uint*/; + var len:number /*uint*/; + + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + + switch (cid) { + case 0xA300: + tex.url = this.readNulTermstring(); + break; + + default: + // Skip this unknown texture sub-chunk + this._byteData.position += (len - 6); + break; + } + } + + this._textures[tex.url] = tex; + this._pAddDependency(tex.url, new URLRequest(tex.url)); + + return tex; + } + + private parseVertexList():void + { + var i:number /*uint*/; + var len:number /*uint*/; + var count:number /*uint*/; + + count = this._byteData.readUnsignedShort(); + this._cur_obj.verts = new Array(count*3); + + i = 0; + len = this._cur_obj.verts.length; + while (i < len) { + var x:number, y:number, z:number; + + x = this._byteData.readFloat(); + y = this._byteData.readFloat(); + z = this._byteData.readFloat(); + + this._cur_obj.verts[i++] = x; + this._cur_obj.verts[i++] = z; + this._cur_obj.verts[i++] = y; + } + } + + private parseFaceList():void + { + var i:number /*uint*/; + var len:number /*uint*/; + var count:number /*uint*/; + + count = this._byteData.readUnsignedShort(); + this._cur_obj.indices = new Array(count*3) /*uint*/; + + i = 0; + len = this._cur_obj.indices.length; + while (i < len) { + var i0:number /*uint*/, i1:number /*uint*/, i2:number /*uint*/; + + i0 = this._byteData.readUnsignedShort(); + i1 = this._byteData.readUnsignedShort(); + i2 = this._byteData.readUnsignedShort(); + + this._cur_obj.indices[i++] = i0; + this._cur_obj.indices[i++] = i2; + this._cur_obj.indices[i++] = i1; + + // Skip "face info", irrelevant in Away3D + this._byteData.position += 2; + } + + this._cur_obj.smoothingGroups = new Array(count) /*uint*/; + } + + private parseSmoothingGroups():void + { + var len:number /*uint*/ = this._cur_obj.indices.length/3; + var i:number /*uint*/ = 0; + while (i < len) { + this._cur_obj.smoothingGroups[i] = this._byteData.readUnsignedInt(); + i++; + } + } + + private parseUVList():void + { + var i:number /*uint*/; + var len:number /*uint*/; + var count:number /*uint*/; + + count = this._byteData.readUnsignedShort(); + this._cur_obj.uvs = new Array(count*2); + + i = 0; + len = this._cur_obj.uvs.length; + while (i < len) { + this._cur_obj.uvs[i++] = this._byteData.readFloat(); + this._cur_obj.uvs[i++] = 1.0 - this._byteData.readFloat(); + } + } + + private parseFaceMaterialList():void + { + var mat:string; + var count:number /*uint*/; + var i:number /*uint*/; + var faces:Array /*uint*/; + + mat = this.readNulTermstring(); + count = this._byteData.readUnsignedShort(); + + faces = new Array(count) /*uint*/; + i = 0; + while (i < faces.length) + faces[i++] = this._byteData.readUnsignedShort(); + + this._cur_obj.materials.push(mat); + this._cur_obj.materialFaces[mat] = faces; + } + + private parseObjectAnimation(end:number):void + { + var vo:ObjectVO; + var obj:DisplayObjectContainer; + var pivot:Vector3D; + var name:string; + var hier:number /*uint*/; + + // Pivot defaults to origin + pivot = new Vector3D; + + while (this._byteData.position < end) { + var cid:number /*uint*/; + var len:number /*uint*/; + + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + + switch (cid) { + case 0xb010: // Name/hierarchy + name = this.readNulTermstring(); + this._byteData.position += 4; + hier = this._byteData.readShort(); + break; + + case 0xb013: // Pivot + pivot.x = this._byteData.readFloat(); + pivot.z = this._byteData.readFloat(); + pivot.y = this._byteData.readFloat(); + break; + + default: + this._byteData.position += (len - 6); + break; + } + } + + // If name is "$$$DUMMY" this is an empty object (e.g. a container) + // and will be ignored in this version of the parser + // TODO: Implement containers in 3DS parser. + if (name != '$$$DUMMY' && this._unfinalized_objects.hasOwnProperty(name)) { + vo = this._unfinalized_objects[name]; + obj = this.constructObject(vo, pivot); + + if (obj) { + //add to the content property + ( this._pContent).addChild(obj); + + this._pFinalizeAsset(obj, vo.name); + } + + + delete this._unfinalized_objects[name]; + } + } + + private constructObject(obj:ObjectVO, pivot:Vector3D = null):DisplayObjectContainer + { + if (obj.type == AssetType.MESH) { + var i:number /*uint*/; + var sub:TriangleSubGeometry; + var geom:Geometry; + var mat:MaterialBase; + var mesh:Mesh; + var mtx:Matrix3D; + var vertices:Array; + var faces:Array; + + if (obj.materials.length > 1) + console.log("The Away3D 3DS parser does not support multiple materials per mesh at this point."); + + // Ignore empty objects + if (!obj.indices || obj.indices.length == 0) + return null; + + vertices = new Array(obj.verts.length/3); + faces = new Array(obj.indices.length/3); + + this.prepareData(vertices, faces, obj); + + if (this._useSmoothingGroups) + this.applySmoothGroups(vertices, faces); + + obj.verts = new Array(vertices.length*3); + for (i = 0; i < vertices.length; i++) { + obj.verts[i*3] = vertices[i].x; + obj.verts[i*3 + 1] = vertices[i].y; + obj.verts[i*3 + 2] = vertices[i].z; + } + obj.indices = new Array(faces.length*3) /*uint*/; + + for (i = 0; i < faces.length; i++) { + obj.indices[i*3] = faces[i].a; + obj.indices[i*3 + 1] = faces[i].b; + obj.indices[i*3 + 2] = faces[i].c; + } + + if (obj.uvs) { + // If the object had UVs to start with, use UVs generated by + // smoothing group splitting algorithm. Otherwise those UVs + // will be nonsense and should be skipped. + obj.uvs = new Array(vertices.length*2); + for (i = 0; i < vertices.length; i++) { + obj.uvs[i*2] = vertices[i].u; + obj.uvs[i*2 + 1] = vertices[i].v; + } + } + + geom = new Geometry(); + + // Construct sub-geometries (potentially splitting buffers) + // and add them to geometry. + sub = new TriangleSubGeometry(true); + sub.updateIndices(obj.indices); + sub.updatePositions(obj.verts); + sub.updateUVs(obj.uvs); + + geom.addSubGeometry(sub); + + if (obj.materials.length > 0) { + var mname:string; + mname = obj.materials[0]; + mat = this._materials[mname].material; + } + + // Apply pivot translation to geometry if a pivot was + // found while parsing the keyframe chunk earlier. + if (pivot) { + if (obj.transform) { + // If a transform was found while parsing the + // object chunk, use it to find the local pivot vector + var dat:Array = obj.transform.concat(); + dat[12] = 0; + dat[13] = 0; + dat[14] = 0; + mtx = new Matrix3D(dat); + pivot = mtx.transformVector(pivot); + } + + pivot.scaleBy(-1); + + mtx = new Matrix3D(); + mtx.appendTranslation(pivot.x, pivot.y, pivot.z); + geom.applyTransformation(mtx); + } + + // Apply transformation to geometry if a transformation + // was found while parsing the object chunk earlier. + if (obj.transform) { + mtx = new Matrix3D(obj.transform); + mtx.invert(); + geom.applyTransformation(mtx); + } + + // Final transform applied to geometry. Finalize the geometry, + // which will no longer be modified after this point. + this._pFinalizeAsset(geom, obj.name.concat('_geom')); + + // Build mesh and return it + mesh = new Mesh(geom, mat); + mesh.transform.matrix3D = new Matrix3D(obj.transform); + return mesh; + } + + // If reached, unknown + return null; + } + + private prepareData(vertices:Array, faces:Array, obj:ObjectVO):void + { + // convert raw ObjectVO's data to structured VertexVO and FaceVO + var i:number /*int*/; + var j:number /*int*/; + var k:number /*int*/; + var len:number /*int*/ = obj.verts.length; + for (i = 0, j = 0, k = 0; i < len;) { + var v:VertexVO = new VertexVO; + v.x = obj.verts[i++]; + v.y = obj.verts[i++]; + v.z = obj.verts[i++]; + if (obj.uvs) { + v.u = obj.uvs[j++]; + v.v = obj.uvs[j++]; + } + vertices[k++] = v; + } + len = obj.indices.length; + for (i = 0, k = 0; i < len;) { + var f:FaceVO = new FaceVO(); + f.a = obj.indices[i++]; + f.b = obj.indices[i++]; + f.c = obj.indices[i++]; + f.smoothGroup = obj.smoothingGroups[k] || 0; + faces[k++] = f; + } + } + + private applySmoothGroups(vertices:Array, faces:Array):void + { + // clone vertices according to following rule: + // clone if vertex's in faces from groups 1+2 and 3 + // don't clone if vertex's in faces from groups 1+2, 3 and 1+3 + + var i:number /*int*/; + var j:number /*int*/; + var k:number /*int*/; + var l:number /*int*/; + var len:number /*int*/; + var numVerts:number /*uint*/ = vertices.length; + var numFaces:number /*uint*/ = faces.length; + + // extract groups data for vertices + var vGroups:Array> /*uint*/ = new Array>(numVerts) /*uint*/; + for (i = 0; i < numVerts; i++) + vGroups[i] = new Array() /*uint*/; + for (i = 0; i < numFaces; i++) { + var face:FaceVO = faces[i]; + for (j = 0; j < 3; j++) { + var groups:Array /*uint*/ = vGroups[(j == 0)? face.a : ((j == 1)? face.b : face.c)]; + var group:number /*uint*/ = face.smoothGroup; + for (k = groups.length - 1; k >= 0; k--) { + if ((group & groups[k]) > 0) { + group |= groups[k]; + groups.splice(k, 1); + k = groups.length - 1; + } + } + groups.push(group); + } + } + // clone vertices + var vClones:Array> /*uint*/ = new Array>(numVerts) /*uint*/; + for (i = 0; i < numVerts; i++) { + if ((len = vGroups[i].length) < 1) + continue; + var clones:Array /*uint*/ = new Array(len) /*uint*/; + vClones[i] = clones; + clones[0] = i; + var v0:VertexVO = vertices[i]; + for (j = 1; j < len; j++) { + var v1:VertexVO = new VertexVO; + v1.x = v0.x; + v1.y = v0.y; + v1.z = v0.z; + v1.u = v0.u; + v1.v = v0.v; + clones[j] = vertices.length; + vertices.push(v1); + } + } + numVerts = vertices.length; + + for (i = 0; i < numFaces; i++) { + face = faces[i]; + group = face.smoothGroup; + for (j = 0; j < 3; j++) { + k = (j == 0)? face.a : ((j == 1)? face.b : face.c); + groups = vGroups[k]; + len = groups.length; + clones = vClones[k]; + for (l = 0; l < len; l++) { + if (((group == 0) && (groups[l] == 0)) || ((group & groups[l]) > 0)) { + var index:number /*uint*/ = clones[l]; + if (group == 0) { + // vertex is unique if no smoothGroup found + groups.splice(l, 1); + clones.splice(l, 1); + } + if (j == 0) + face.a = index; else if (j == 1) + face.b = index; else + face.c = index; + l = len; + } + } + } + } + } + + private finalizeCurrentMaterial():void + { + var mat:TriangleMethodMaterial; + + if (this._cur_mat.colorMap) + mat = new TriangleMethodMaterial(this._cur_mat.colorMap.texture || DefaultMaterialManager.getDefaultTexture()); + else + mat = new TriangleMethodMaterial(this._cur_mat.ambientColor); + + mat.diffuseColor = this._cur_mat.diffuseColor; + mat.specularColor = this._cur_mat.specularColor; + + if (this.materialMode >= 2) + mat.materialMode = TriangleMaterialMode.MULTI_PASS + + mat.bothSides = this._cur_mat.twoSided; + + this._pFinalizeAsset(mat, this._cur_mat.name); + + this._materials[this._cur_mat.name] = this._cur_mat; + this._cur_mat.material = mat; + + this._cur_mat = null; + } + + private readNulTermstring():string + { + var chr:number /*int*/; + var str:string = ""; + + while ((chr = this._byteData.readUnsignedByte()) > 0) + str += String.fromCharCode(chr); + + return str; + } + + private readTransform():Array + { + var data:Array; + + data = new Array(16); + + // X axis + data[0] = this._byteData.readFloat(); // X + data[2] = this._byteData.readFloat(); // Z + data[1] = this._byteData.readFloat(); // Y + data[3] = 0; + + // Z axis + data[8] = this._byteData.readFloat(); // X + data[10] = this._byteData.readFloat(); // Z + data[9] = this._byteData.readFloat(); // Y + data[11] = 0; + + // Y Axis + data[4] = this._byteData.readFloat(); // X + data[6] = this._byteData.readFloat(); // Z + data[5] = this._byteData.readFloat(); // Y + data[7] = 0; + + // Translation + data[12] = this._byteData.readFloat(); // X + data[14] = this._byteData.readFloat(); // Z + data[13] = this._byteData.readFloat(); // Y + data[15] = 1; + + return data; + } + + private readColor():number /*int*/ + { + var cid:number /*int*/; + var len:number /*int*/; + var r:number /*int*/, g:number /*int*/, b:number /*int*/; + + cid = this._byteData.readUnsignedShort(); + len = this._byteData.readUnsignedInt(); + + switch (cid) { + case 0x0010: // Floats + r = this._byteData.readFloat()*255; + g = this._byteData.readFloat()*255; + b = this._byteData.readFloat()*255; + break; + case 0x0011: // 24-bit color + r = this._byteData.readUnsignedByte(); + g = this._byteData.readUnsignedByte(); + b = this._byteData.readUnsignedByte(); + break; + default: + this._byteData.position += (len - 6); + break; + } + + return (r << 16) | (g << 8) | b; + } +} + +export = Max3DSParser; + + diff --git a/lib/parsers/OBJParser.js b/lib/parsers/OBJParser.js new file mode 100755 index 000000000..c5d26b38d --- /dev/null +++ b/lib/parsers/OBJParser.js @@ -0,0 +1,911 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Geometry = require("awayjs-core/lib/core/base/Geometry"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var Mesh = require("awayjs-core/lib/entities/Mesh"); +var ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +var ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +var DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); +var SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); +var TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +var TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); +/** + * OBJParser provides a parser for the OBJ data type. + */ +var OBJParser = (function (_super) { + __extends(OBJParser, _super); + /** + * Creates a new OBJParser object. + * @param uri The url or id of the data or file to be parsed. + * @param extra The holder for extra contextual data that the parser might need. + */ + function OBJParser(scale) { + if (scale === void 0) { scale = 1; } + _super.call(this, URLLoaderDataFormat.TEXT); + this._mtlLibLoaded = true; + this._activeMaterialID = ""; + this._scale = scale; + } + Object.defineProperty(OBJParser.prototype, "scale", { + /** + * Scaling factor applied directly to vertices data + * @param value The scaling factor. + */ + set: function (value) { + this._scale = value; + }, + enumerable: true, + configurable: true + }); + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + OBJParser.supportsType = function (extension) { + extension = extension.toLowerCase(); + return extension == "obj"; + }; + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + OBJParser.supportsData = function (data) { + var content = ParserUtils.toString(data); + var hasV = false; + var hasF = false; + if (content) { + hasV = content.indexOf("\nv ") != -1; + hasF = content.indexOf("\nf ") != -1; + } + return hasV && hasF; + }; + /** + * @inheritDoc + */ + OBJParser.prototype._iResolveDependency = function (resourceDependency) { + if (resourceDependency.id == 'mtl') { + var str = ParserUtils.toString(resourceDependency.data); + this.parseMtl(str); + } + else { + var asset; + if (resourceDependency.assets.length != 1) { + return; + } + asset = resourceDependency.assets[0]; + if (asset.assetType == AssetType.TEXTURE) { + var lm = new LoadedMaterial(); + lm.materialID = resourceDependency.id; + lm.texture = asset; + this._materialLoaded.push(lm); + if (this._meshes.length > 0) { + this.applyMaterial(lm); + } + } + } + }; + /** + * @inheritDoc + */ + OBJParser.prototype._iResolveDependencyFailure = function (resourceDependency) { + if (resourceDependency.id == "mtl") { + this._mtlLib = false; + this._mtlLibLoaded = false; + } + else { + var lm = new LoadedMaterial(); + lm.materialID = resourceDependency.id; + this._materialLoaded.push(lm); + } + if (this._meshes.length > 0) + this.applyMaterial(lm); + }; + /** + * @inheritDoc + */ + OBJParser.prototype._pProceedParsing = function () { + var line; + var creturn = String.fromCharCode(10); + var trunk; + if (!this._startedParsing) { + this._textData = this._pGetTextData(); + // Merge linebreaks that are immediately preceeded by + // the "escape" backward slash into single lines. + this._textData = this._textData.replace(/\\[\r\n]+\s*/gm, ' '); + } + if (this._textData.indexOf(creturn) == -1) + creturn = String.fromCharCode(13); + if (!this._startedParsing) { + this._startedParsing = true; + this._vertices = new Array(); + this._vertexNormals = new Array(); + this._materialIDs = new Array(); + this._materialLoaded = new Array(); + this._meshes = new Array(); + this._uvs = new Array(); + this._stringLength = this._textData.length; + this._charIndex = this._textData.indexOf(creturn, 0); + this._oldIndex = 0; + this._objects = new Array(); + this._objectIndex = 0; + } + while (this._charIndex < this._stringLength && this._pHasTime()) { + this._charIndex = this._textData.indexOf(creturn, this._oldIndex); + if (this._charIndex == -1) + this._charIndex = this._stringLength; + line = this._textData.substring(this._oldIndex, this._charIndex); + line = line.split('\r').join(""); + line = line.replace(" ", " "); + trunk = line.split(" "); + this._oldIndex = this._charIndex + 1; + this.parseLine(trunk); + // If whatever was parsed on this line resulted in the + // parsing being paused to retrieve dependencies, break + // here and do not continue parsing until un-paused. + if (this.parsingPaused) { + return ParserBase.MORE_TO_PARSE; + } + } + if (this._charIndex >= this._stringLength) { + if (this._mtlLib && !this._mtlLibLoaded) { + return ParserBase.MORE_TO_PARSE; + } + this.translate(); + this.applyMaterials(); + return ParserBase.PARSING_DONE; + } + return ParserBase.MORE_TO_PARSE; + }; + OBJParser.prototype._pStartParsing = function (frameLimit) { + _super.prototype._pStartParsing.call(this, frameLimit); + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + }; + /** + * Parses a single line in the OBJ file. + */ + OBJParser.prototype.parseLine = function (trunk) { + switch (trunk[0]) { + case "mtllib": + this._mtlLib = true; + this._mtlLibLoaded = false; + this.loadMtl(trunk[1]); + break; + case "g": + this.createGroup(trunk); + break; + case "o": + this.createObject(trunk); + break; + case "usemtl": + if (this._mtlLib) { + if (!trunk[1]) + trunk[1] = "def000"; + this._materialIDs.push(trunk[1]); + this._activeMaterialID = trunk[1]; + if (this._currentGroup) + this._currentGroup.materialID = this._activeMaterialID; + } + break; + case "v": + this.parseVertex(trunk); + break; + case "vt": + this.parseUV(trunk); + break; + case "vn": + this.parseVertexNormal(trunk); + break; + case "f": + this.parseFace(trunk); + } + }; + /** + * Converts the parsed data into an Away3D scenegraph structure + */ + OBJParser.prototype.translate = function () { + for (var objIndex = 0; objIndex < this._objects.length; ++objIndex) { + var groups = this._objects[objIndex].groups; + var numGroups = groups.length; + var materialGroups; + var numMaterialGroups; + var geometry; + var mesh; + var m; + var sm; + var bmMaterial; + for (var g = 0; g < numGroups; ++g) { + geometry = new Geometry(); + materialGroups = groups[g].materialGroups; + numMaterialGroups = materialGroups.length; + for (m = 0; m < numMaterialGroups; ++m) + this.translateMaterialGroup(materialGroups[m], geometry); + if (geometry.subGeometries.length == 0) + continue; + // Finalize and force type-based name + this._pFinalizeAsset(geometry); //, ""); + bmMaterial = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture()); + //check for multipass + if (this.materialMode >= 2) + bmMaterial.materialMode = TriangleMaterialMode.MULTI_PASS; + mesh = new Mesh(geometry, bmMaterial); + if (this._objects[objIndex].name) { + // this is a full independent object ('o' tag in OBJ file) + mesh.name = this._objects[objIndex].name; + } + else if (groups[g].name) { + // this is a group so the sub groups contain the actual mesh object names ('g' tag in OBJ file) + mesh.name = groups[g].name; + } + else { + // No name stored. Use empty string which will force it + // to be overridden by finalizeAsset() to type default. + mesh.name = ""; + } + this._meshes.push(mesh); + if (groups[g].materialID != "") + bmMaterial.name = groups[g].materialID + "~" + mesh.name; + else + bmMaterial.name = this._lastMtlID + "~" + mesh.name; + if (mesh.subMeshes.length > 1) { + for (sm = 1; sm < mesh.subMeshes.length; ++sm) + mesh.subMeshes[sm].material = bmMaterial; + } + //add to the content property + this._pContent.addChild(mesh); + this._pFinalizeAsset(mesh); + } + } + }; + /** + * Translates an obj's material group to a subgeometry. + * @param materialGroup The material group data to convert. + * @param geometry The Geometry to contain the converted SubGeometry. + */ + OBJParser.prototype.translateMaterialGroup = function (materialGroup, geometry) { + var faces = materialGroup.faces; + var face; + var numFaces = faces.length; + var numVerts; + var sub; + var vertices = new Array(); + var uvs = new Array(); + var normals = new Array(); + var indices = new Array(); + this._realIndices = []; + this._vertexIndex = 0; + var j; + for (var i = 0; i < numFaces; ++i) { + face = faces[i]; + numVerts = face.indexIds.length - 1; + for (j = 1; j < numVerts; ++j) { + this.translateVertexData(face, j, vertices, uvs, indices, normals); + this.translateVertexData(face, 0, vertices, uvs, indices, normals); + this.translateVertexData(face, j + 1, vertices, uvs, indices, normals); + } + } + if (vertices.length > 0) { + sub = new TriangleSubGeometry(true); + sub.autoDeriveNormals = normals.length ? false : true; + sub.updateIndices(indices); + sub.updatePositions(vertices); + sub.updateVertexNormals(normals); + sub.updateUVs(uvs); + geometry.addSubGeometry(sub); + } + }; + OBJParser.prototype.translateVertexData = function (face, vertexIndex, vertices, uvs, indices /*uint*/, normals) { + var index; + var vertex; + var vertexNormal; + var uv; + if (!this._realIndices[face.indexIds[vertexIndex]]) { + index = this._vertexIndex; + this._realIndices[face.indexIds[vertexIndex]] = ++this._vertexIndex; + vertex = this._vertices[face.vertexIndices[vertexIndex] - 1]; + vertices.push(vertex.x * this._scale, vertex.y * this._scale, vertex.z * this._scale); + if (face.normalIndices.length > 0) { + vertexNormal = this._vertexNormals[face.normalIndices[vertexIndex] - 1]; + normals.push(vertexNormal.x, vertexNormal.y, vertexNormal.z); + } + if (face.uvIndices.length > 0) { + try { + uv = this._uvs[face.uvIndices[vertexIndex] - 1]; + uvs.push(uv.u, uv.v); + } + catch (e) { + switch (vertexIndex) { + case 0: + uvs.push(0, 1); + break; + case 1: + uvs.push(.5, 0); + break; + case 2: + uvs.push(1, 1); + } + } + } + } + else { + index = this._realIndices[face.indexIds[vertexIndex]] - 1; + } + indices.push(index); + }; + /** + * Creates a new object group. + * @param trunk The data block containing the object tag and its parameters + */ + OBJParser.prototype.createObject = function (trunk) { + this._currentGroup = null; + this._currentMaterialGroup = null; + this._objects.push(this._currentObject = new ObjectGroup()); + if (trunk) + this._currentObject.name = trunk[1]; + }; + /** + * Creates a new group. + * @param trunk The data block containing the group tag and its parameters + */ + OBJParser.prototype.createGroup = function (trunk) { + if (!this._currentObject) + this.createObject(null); + this._currentGroup = new Group(); + this._currentGroup.materialID = this._activeMaterialID; + if (trunk) + this._currentGroup.name = trunk[1]; + this._currentObject.groups.push(this._currentGroup); + this.createMaterialGroup(null); + }; + /** + * Creates a new material group. + * @param trunk The data block containing the material tag and its parameters + */ + OBJParser.prototype.createMaterialGroup = function (trunk) { + this._currentMaterialGroup = new MaterialGroup(); + if (trunk) + this._currentMaterialGroup.url = trunk[1]; + this._currentGroup.materialGroups.push(this._currentMaterialGroup); + }; + /** + * Reads the next vertex coordinates. + * @param trunk The data block containing the vertex tag and its parameters + */ + OBJParser.prototype.parseVertex = function (trunk) { + //for the very rare cases of other delimiters/charcodes seen in some obj files + var v1, v2, v3; + if (trunk.length > 4) { + var nTrunk = []; + var val; + for (var i = 1; i < trunk.length; ++i) { + val = parseFloat(trunk[i]); + if (!isNaN(val)) + nTrunk.push(val); + } + v1 = nTrunk[0]; + v2 = nTrunk[1]; + v3 = -nTrunk[2]; + this._vertices.push(new Vertex(v1, v2, v3)); + } + else { + v1 = parseFloat(trunk[1]); + v2 = parseFloat(trunk[2]); + v3 = -parseFloat(trunk[3]); + this._vertices.push(new Vertex(v1, v2, v3)); + } + }; + /** + * Reads the next uv coordinates. + * @param trunk The data block containing the uv tag and its parameters + */ + OBJParser.prototype.parseUV = function (trunk) { + if (trunk.length > 3) { + var nTrunk = []; + var val; + for (var i = 1; i < trunk.length; ++i) { + val = parseFloat(trunk[i]); + if (!isNaN(val)) + nTrunk.push(val); + } + this._uvs.push(new UV(nTrunk[0], 1 - nTrunk[1])); + } + else { + this._uvs.push(new UV(parseFloat(trunk[1]), 1 - parseFloat(trunk[2]))); + } + }; + /** + * Reads the next vertex normal coordinates. + * @param trunk The data block containing the vertex normal tag and its parameters + */ + OBJParser.prototype.parseVertexNormal = function (trunk) { + if (trunk.length > 4) { + var nTrunk = []; + var val; + for (var i = 1; i < trunk.length; ++i) { + val = parseFloat(trunk[i]); + if (!isNaN(val)) + nTrunk.push(val); + } + this._vertexNormals.push(new Vertex(nTrunk[0], nTrunk[1], -nTrunk[2])); + } + else { + this._vertexNormals.push(new Vertex(parseFloat(trunk[1]), parseFloat(trunk[2]), -parseFloat(trunk[3]))); + } + }; + /** + * Reads the next face's indices. + * @param trunk The data block containing the face tag and its parameters + */ + OBJParser.prototype.parseFace = function (trunk) { + var len = trunk.length; + var face = new FaceData(); + if (!this._currentGroup) { + this.createGroup(null); + } + var indices; + for (var i = 1; i < len; ++i) { + if (trunk[i] == "") { + continue; + } + indices = trunk[i].split("/"); + face.vertexIndices.push(this.parseIndex(parseInt(indices[0]), this._vertices.length)); + if (indices[1] && String(indices[1]).length > 0) + face.uvIndices.push(this.parseIndex(parseInt(indices[1]), this._uvs.length)); + if (indices[2] && String(indices[2]).length > 0) + face.normalIndices.push(this.parseIndex(parseInt(indices[2]), this._vertexNormals.length)); + face.indexIds.push(trunk[i]); + } + this._currentMaterialGroup.faces.push(face); + }; + /** + * This is a hack around negative face coords + */ + OBJParser.prototype.parseIndex = function (index, length) { + if (index < 0) + return index + length + 1; + else + return index; + }; + OBJParser.prototype.parseMtl = function (data) { + var materialDefinitions = data.split('newmtl'); + var lines; + var trunk; + var j; + var basicSpecularMethod; + var useSpecular; + var useColor; + var diffuseColor; + var color; + var specularColor; + var specular; + var alpha; + var mapkd; + for (var i = 0; i < materialDefinitions.length; ++i) { + lines = (materialDefinitions[i].split('\r')).join("").split('\n'); + //lines = (materialDefinitions[i].split('\r') as Array).join("").split('\n'); + if (lines.length == 1) + lines = materialDefinitions[i].split(String.fromCharCode(13)); + diffuseColor = color = specularColor = 0xFFFFFF; + specular = 0; + useSpecular = false; + useColor = false; + alpha = 1; + mapkd = ""; + for (j = 0; j < lines.length; ++j) { + lines[j] = lines[j].replace(/\s+$/, ""); + if (lines[j].substring(0, 1) != "#" && (j == 0 || lines[j] != "")) { + trunk = lines[j].split(" "); + if (String(trunk[0]).charCodeAt(0) == 9 || String(trunk[0]).charCodeAt(0) == 32) + trunk[0] = trunk[0].substring(1, trunk[0].length); + if (j == 0) { + this._lastMtlID = trunk.join(""); + this._lastMtlID = (this._lastMtlID == "") ? "def000" : this._lastMtlID; + } + else { + switch (trunk[0]) { + case "Ka": + if (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) + color = trunk[1] * 255 << 16 | trunk[2] * 255 << 8 | trunk[3] * 255; + break; + case "Ks": + if (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) { + specularColor = trunk[1] * 255 << 16 | trunk[2] * 255 << 8 | trunk[3] * 255; + useSpecular = true; + } + break; + case "Ns": + if (trunk[1] && !isNaN(Number(trunk[1]))) + specular = Number(trunk[1]) * 0.001; + if (specular == 0) + useSpecular = false; + break; + case "Kd": + if (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) { + diffuseColor = trunk[1] * 255 << 16 | trunk[2] * 255 << 8 | trunk[3] * 255; + useColor = true; + } + break; + case "tr": + case "d": + if (trunk[1] && !isNaN(Number(trunk[1]))) + alpha = Number(trunk[1]); + break; + case "map_Kd": + mapkd = this.parseMapKdString(trunk); + mapkd = mapkd.replace(/\\/g, "/"); + } + } + } + } + if (mapkd != "") { + if (useSpecular) { + basicSpecularMethod = new SpecularBasicMethod(); + basicSpecularMethod.specularColor = specularColor; + basicSpecularMethod.specular = specular; + var specularData = new SpecularData(); + specularData.alpha = alpha; + specularData.basicSpecularMethod = basicSpecularMethod; + specularData.materialID = this._lastMtlID; + if (!this._materialSpecularData) + this._materialSpecularData = new Array(); + this._materialSpecularData.push(specularData); + } + this._pAddDependency(this._lastMtlID, new URLRequest(mapkd)); + } + else if (useColor && !isNaN(color)) { + var lm = new LoadedMaterial(); + lm.materialID = this._lastMtlID; + if (alpha == 0) + console.log("Warning: an alpha value of 0 was found in mtl color tag (Tr or d) ref:" + this._lastMtlID + ", mesh(es) using it will be invisible!"); + var cm; + if (this.materialMode < 2) { + cm = new TriangleMethodMaterial(color); + var colorMat = cm; + colorMat.alpha = alpha; + colorMat.diffuseColor = diffuseColor; + colorMat.repeat = true; + if (useSpecular) { + colorMat.specularColor = specularColor; + colorMat.specular = specular; + } + } + else { + cm = new TriangleMethodMaterial(color); + cm.materialMode = TriangleMaterialMode.MULTI_PASS; + var colorMultiMat = cm; + colorMultiMat.diffuseColor = diffuseColor; + colorMultiMat.repeat = true; + if (useSpecular) { + colorMultiMat.specularColor = specularColor; + colorMultiMat.specular = specular; + } + } + lm.cm = cm; + this._materialLoaded.push(lm); + if (this._meshes.length > 0) + this.applyMaterial(lm); + } + } + this._mtlLibLoaded = true; + }; + OBJParser.prototype.parseMapKdString = function (trunk) { + var url = ""; + var i; + var breakflag; + for (i = 1; i < trunk.length;) { + switch (trunk[i]) { + case "-blendu": + case "-blendv": + case "-cc": + case "-clamp": + case "-texres": + i += 2; //Skip ahead 1 attribute + break; + case "-mm": + i += 3; //Skip ahead 2 attributes + break; + case "-o": + case "-s": + case "-t": + i += 4; //Skip ahead 3 attributes + continue; + default: + breakflag = true; + break; + } + if (breakflag) + break; + } + for (i; i < trunk.length; i++) { + url += trunk[i]; + url += " "; + } + //Remove the extraneous space and/or newline from the right side + url = url.replace(/\s+$/, ""); + return url; + }; + OBJParser.prototype.loadMtl = function (mtlurl) { + // Add raw-data dependency to queue and load dependencies now, + // which will pause the parsing in the meantime. + this._pAddDependency('mtl', new URLRequest(mtlurl), true); + this._pPauseAndRetrieveDependencies(); // + }; + OBJParser.prototype.applyMaterial = function (lm) { + var decomposeID; + var mesh; + var tm; + var j; + var specularData; + for (var i = 0; i < this._meshes.length; ++i) { + mesh = this._meshes[i]; + decomposeID = mesh.material.name.split("~"); + if (decomposeID[0] == lm.materialID) { + if (lm.cm) { + if (mesh.material) + mesh.material = null; + mesh.material = lm.cm; + } + else if (lm.texture) { + if (this.materialMode < 2) { + tm = mesh.material; + tm.texture = lm.texture; + tm.color = lm.color; + tm.alpha = lm.alpha; + tm.repeat = true; + if (lm.specularMethod) { + // By setting the specularMethod property to null before assigning + // the actual method instance, we avoid having the properties of + // the new method being overridden with the settings from the old + // one, which is default behavior of the setter. + tm.specularMethod = null; + tm.specularMethod = lm.specularMethod; + } + else if (this._materialSpecularData) { + for (j = 0; j < this._materialSpecularData.length; ++j) { + specularData = this._materialSpecularData[j]; + if (specularData.materialID == lm.materialID) { + tm.specularMethod = null; // Prevent property overwrite (see above) + tm.specularMethod = specularData.basicSpecularMethod; + tm.color = specularData.color; + tm.alpha = specularData.alpha; + break; + } + } + } + } + else { + tm = mesh.material; + tm.materialMode = TriangleMaterialMode.MULTI_PASS; + tm.texture = lm.texture; + tm.color = lm.color; + tm.repeat = true; + if (lm.specularMethod) { + // By setting the specularMethod property to null before assigning + // the actual method instance, we avoid having the properties of + // the new method being overridden with the settings from the old + // one, which is default behavior of the setter. + tm.specularMethod = null; + tm.specularMethod = lm.specularMethod; + } + else if (this._materialSpecularData) { + for (j = 0; j < this._materialSpecularData.length; ++j) { + specularData = this._materialSpecularData[j]; + if (specularData.materialID == lm.materialID) { + tm.specularMethod = null; // Prevent property overwrite (see above) + tm.specularMethod = specularData.basicSpecularMethod; + tm.color = specularData.color; + break; + } + } + } + } + } + mesh.material.name = decomposeID[1] ? decomposeID[1] : decomposeID[0]; + this._meshes.splice(i, 1); + --i; + } + } + if (lm.cm || tm) + this._pFinalizeAsset(lm.cm || tm); + }; + OBJParser.prototype.applyMaterials = function () { + if (this._materialLoaded.length == 0) + return; + for (var i = 0; i < this._materialLoaded.length; ++i) + this.applyMaterial(this._materialLoaded[i]); + }; + return OBJParser; +})(ParserBase); +var ObjectGroup = (function () { + function ObjectGroup() { + this.groups = new Array(); + } + return ObjectGroup; +})(); +var Group = (function () { + function Group() { + this.materialGroups = new Array(); + } + return Group; +})(); +var MaterialGroup = (function () { + function MaterialGroup() { + this.faces = new Array(); + } + return MaterialGroup; +})(); +var SpecularData = (function () { + function SpecularData() { + this.color = 0xFFFFFF; + this.alpha = 1; + } + return SpecularData; +})(); +var LoadedMaterial = (function () { + function LoadedMaterial() { + this.color = 0xFFFFFF; + this.alpha = 1; + } + return LoadedMaterial; +})(); +var FaceData = (function () { + function FaceData() { + this.vertexIndices = new Array(); + this.uvIndices = new Array(); + this.normalIndices = new Array(); + this.indexIds = new Array(); // used for real index lookups + } + return FaceData; +})(); +/** +* Texture coordinates value object. +*/ +var UV = (function () { + /** + * Creates a new UV object. + * + * @param u [optional] The horizontal coordinate of the texture value. Defaults to 0. + * @param v [optional] The vertical coordinate of the texture value. Defaults to 0. + */ + function UV(u, v) { + if (u === void 0) { u = 0; } + if (v === void 0) { v = 0; } + this._u = u; + this._v = v; + } + Object.defineProperty(UV.prototype, "v", { + /** + * Defines the vertical coordinate of the texture value. + */ + get: function () { + return this._v; + }, + set: function (value) { + this._v = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(UV.prototype, "u", { + /** + * Defines the horizontal coordinate of the texture value. + */ + get: function () { + return this._u; + }, + set: function (value) { + this._u = value; + }, + enumerable: true, + configurable: true + }); + /** + * returns a new UV value Object + */ + UV.prototype.clone = function () { + return new UV(this._u, this._v); + }; + /** + * returns the value object as a string for trace/debug purpose + */ + UV.prototype.toString = function () { + return this._u + "," + this._v; + }; + return UV; +})(); +var Vertex = (function () { + /** + * Creates a new Vertex value object. + * + * @param x [optional] The x value. Defaults to 0. + * @param y [optional] The y value. Defaults to 0. + * @param z [optional] The z value. Defaults to 0. + * @param index [optional] The index value. Defaults is NaN. + */ + function Vertex(x, y, z, index) { + if (x === void 0) { x = 0; } + if (y === void 0) { y = 0; } + if (z === void 0) { z = 0; } + if (index === void 0) { index = 0; } + this._x = x; + this._y = y; + this._z = z; + this._index = index; + } + Object.defineProperty(Vertex.prototype, "index", { + get: function () { + return this._index; + }, + /** + * To define/store the index of value object + * @param ind The index + */ + set: function (ind) { + this._index = ind; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Vertex.prototype, "x", { + /** + * To define/store the x value of the value object + * @param value The x value + */ + get: function () { + return this._x; + }, + set: function (value) { + this._x = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Vertex.prototype, "y", { + /** + * To define/store the y value of the value object + * @param value The y value + */ + get: function () { + return this._y; + }, + set: function (value) { + this._y = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Vertex.prototype, "z", { + /** + * To define/store the z value of the value object + * @param value The z value + */ + get: function () { + return this._z; + }, + set: function (value) { + this._z = value; + }, + enumerable: true, + configurable: true + }); + /** + * returns a new Vertex value Object + */ + Vertex.prototype.clone = function () { + return new Vertex(this._x, this._y, this._z); + }; + return Vertex; +})(); +module.exports = OBJParser; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/objparser.ts"],"names":["OBJParser","OBJParser.constructor","OBJParser.scale","OBJParser.supportsType","OBJParser.supportsData","OBJParser._iResolveDependency","OBJParser._iResolveDependencyFailure","OBJParser._pProceedParsing","OBJParser._pStartParsing","OBJParser.parseLine","OBJParser.translate","OBJParser.translateMaterialGroup","OBJParser.translateVertexData","OBJParser.createObject","OBJParser.createGroup","OBJParser.createMaterialGroup","OBJParser.parseVertex","OBJParser.parseUV","OBJParser.parseVertexNormal","OBJParser.parseFace","OBJParser.parseIndex","OBJParser.parseMtl","OBJParser.parseMapKdString","OBJParser.loadMtl","OBJParser.applyMaterial","OBJParser.applyMaterials","ObjectGroup","ObjectGroup.constructor","Group","Group.constructor","MaterialGroup","MaterialGroup.constructor","SpecularData","SpecularData.constructor","LoadedMaterial","LoadedMaterial.constructor","FaceData","FaceData.constructor","UV","UV.constructor","UV.v","UV.u","UV.clone","UV.toString","Vertex","Vertex.constructor","Vertex.index","Vertex.x","Vertex.y","Vertex.z","Vertex.clone"],"mappings":"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AACA,CAACA,CAACA;YACxBA,EAAEA,GAAYA,CAACA,MAAMA,CAACA,CAACA,CAACA,CAACA;YACzBA,IAAIA,CAACA,SAASA,CAACA,IAAIA,CAACA,IAAIA,MAAMA,CAACA,EAAEA,EAAEA,EAAEA,EAAEA,EAAEA,CAACA,CAACA,CAACA;QAE7CA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,EAAEA,GAAYA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA;YACnCA,EAAEA,GAAYA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA;YACnCA,EAAEA,GAAYA,CAACA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA;YAEpCA,IAAIA,CAACA,SAASA,CAACA,IAAIA,CAACA,IAAIA,MAAMA,CAACA,EAAEA,EAAEA,EAAEA,EAAEA,EAAEA,CAACA,CAACA,CAACA;QAC7CA,CAACA;IAEFA,CAACA;IAEDhB;;;OAGGA;IACKA,2BAAOA,GAAfA,UAAgBA,KAAKA;QAEpBiB,EAAEA,CAACA,CAACA,KAAKA,CAACA,MAAMA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACtBA,IAAIA,MAAMA,GAAGA,EAAEA,CAACA;YAChBA,IAAIA,GAAUA,CAACA;YACfA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAUA,CAACA,EAAEA,CAACA,GAAGA,KAAKA,CAACA,MAAMA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;gBAC9CA,GAAGA,GAAGA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA;gBAC3BA,EAAEA,CAACA,CAACA,CAACA,KAAKA,CAACA,GAAGA,CAACA,CAACA;oBACfA,MAAMA,CAACA,IAAIA,CAACA,GAAGA,CAACA,CAACA;YACnBA,CAACA;YACDA,IAAIA,CAACA,IAAIA,CAACA,IAAIA,CAACA,IAAIA,EAAEA,CAACA,MAAMA,CAACA,CAACA,CAACA,EAAEA,CAACA,GAAGA,MAAMA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;QAElDA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,IAAIA,CAACA,IAAIA,CAACA,IAAIA,CAACA,IAAIA,EAAEA,CAACA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,EAAEA,CAACA,GAAGA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;QACxEA,CAACA;IAEFA,CAACA;IAEDjB;;;OAGGA;IACKA,qCAAiBA,GAAzBA,UAA0BA,KAAKA;QAE9BkB,EAAEA,CAACA,CAACA,KAAKA,CAACA,MAAMA,GAAGA,CAACA,CAACA,CAACA,CAACA;YACtBA,IAAIA,MAAMA,GAAGA,EAAEA,CAACA;YAChBA,IAAIA,GAAUA,CAACA;YACfA,GAAGA,CAACA,CAACA,GAAGA,CAACA,CAACA,GAAUA,CAACA,EAAEA,CAACA,GAAGA,KAAKA,CAACA,MAAMA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;gBAC9CA,GAAGA,GAAGA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA;gBAC3BA,EAAEA,CAACA,CAACA,CAACA,KAAKA,CAACA,GAAGA,CAACA,CAACA;oBACfA,MAAMA,CAACA,IAAIA,CAACA,GAAGA,CAACA,CAACA;YACnBA,CAACA;YACDA,IAAIA,CAACA,cAAcA,CAACA,IAAIA,CAACA,IAAIA,MAAMA,CAACA,MAAMA,CAACA,CAACA,CAACA,EAAEA,MAAMA,CAACA,CAACA,CAACA,EAAEA,CAACA,MAAMA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;QAExEA,CAACA;QAACA,IAAIA,CAACA,CAACA;YACPA,IAAIA,CAACA,cAAcA,CAACA,IAAIA,CAACA,IAAIA,MAAMA,CAACA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,EAAEA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,EAAEA,CAACA,UAAUA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;QACzGA,CAACA;IACFA,CAACA;IAEDlB;;;OAG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ACA,CAACA;YAClEA,AAEAA,6EAF6EA;YAE7EA,EAAEA,CAACA,CAACA,KAAKA,CAACA,MAAMA,IAAIA,CAACA,CAACA;gBACrBA,KAAKA,GAAGA,mBAAmBA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,MAAMA,CAACA,YAAYA,CAACA,EAAEA,CAACA,CAACA,CAACA;YAE/DA,YAAYA,GAAGA,KAAKA,GAAGA,aAAaA,GAAGA,QAAQA,CAACA;YAChDA,QAAQA,GAAGA,CAACA,CAACA;YACbA,WAAWA,GAAGA,KAAKA,CAACA;YACpBA,QAAQA,GAAGA,KAAKA,CAACA;YACjBA,KAAKA,GAAGA,CAACA,CAACA;YACVA,KAAKA,GAAGA,EAAEA,CAACA;YAEXA,GAAGA,CAACA,CAACA,CAACA,GAAGA,CAACA,EAAEA,CAACA,GAAGA,KAAKA,CAACA,MAAMA,EAAEA,EAAEA,CAACA,EAAEA,CAACA;gBAEnCA,KAAKA,CAACA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA,OAAOA,CAACA,MAAMA,EAAEA,EAAEA,CAACA,CAACA;gBAExCA,EAAEA,CAACA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,SAASA,CAACA,CAACA,EAAEA,CAACA,CAACA,IAAIA,GAAGA,IAAIA,CAACA,CAACA,IAAIA,CAACA,IAAIA,KAAKA,CAACA,CAACA,CAACA,IAAIA,EAAEA,CAACA,CAACA,CAACA,CAACA;oBACnEA,KAAKA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA,KAAKA,CAACA,GAAGA,CAACA,CAACA;oBAE5BA,EAAEA,CAACA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,UAAUA,CAACA,CAACA,CAACA,IAAIA,CAACA,IAAIA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,UAAUA,CAACA,CAACA,CAACA,IAAIA,EAAEA,CAACA;wBAC/EA,KAAKA,CAACA,CAACA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,CAACA,SAASA,CAACA,CAACA,EAAEA,KAAKA,CAACA,CAACA,CAACA,CAACA,MAAMA,CAACA,CAACA;oBAEnDA,EAAEA,CAACA,CAACA,CAACA,IAAIA,CAACA,CAACA,CAACA,CAACA;wBACZA,IAAIA,CAACA,UAAUA,GAAGA,KAAKA,CAACA,IAAIA,CAACA,EAAEA,CAACA,CAACA;wBACjCA,IAAIA,CAACA,UAAUA,GAAGA,CAACA,IAAIA,CAACA,UAAUA,IAAIA,EAAEA,CAACA,GAAEA,QAAQA,GAAGA,IAAIA,CAACA,UAAUA,CAACA;oBAEvEA,CAACA;oBAACA,IAAIA,CAACA,CAACA;wBAEPA,MAAMA,CAACA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;4BAElBA,KAAKA,IAAIA;gCACRA,EAAEA,CAACA,CAACA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,IAAIA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,IAAIA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;oCACxHA,KAAKA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,IAAIA,EAAEA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,IAAIA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,CAACA;gCAC/DA,KAAKA,CAACA;4BAEPA,KAAKA,IAAIA;gCACRA,EAAEA,CAACA,CAACA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,IAAIA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,IAAIA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;oCAC1HA,aAAaA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,IAAIA,EAAEA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,IAAIA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,CAACA;oCACtEA,WAAWA,GAAGA,IAAIA,CAACA;gCACpBA,CAACA;gCACDA,KAAKA,CAACA;4BAEPA,KAAKA,IAAIA;gCACRA,EAAEA,CAACA,CAACA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;oCACxCA,QAAQA,GAAGA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,GAACA,KAAKA,CAACA;gCACnCA,EAAEA,CAACA,CAACA,QAAQA,IAAIA,CAACA,CAACA;oCACjBA,WAAWA,GAAGA,KAAKA,CAACA;gCACrBA,KAAKA,CAACA;4BAEPA,KAAKA,IAAIA;gCACRA,EAAEA,CAACA,CAACA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,IAAIA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,IAAIA,KAAKA,CAACA,CAACA,CAACA,IAAIA,CAACA,KAAKA,CAACA,MAAMA,CAACA,KAAKA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA,CAACA;oCAC1HA,YAAYA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,IAAIA,EAAEA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,GAAGA,IAAIA,CAACA,GAAGA,KAAKA,CAACA,CAACA,CAACA,GAACA,G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","file":"parsers/OBJParser.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObjectContainer\t\t\t= require(\"awayjs-core/lib/containers/DisplayObjectContainer\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Quaternion\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Quaternion\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetType\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLLoaderDataFormat\t\t\t\t= require(\"awayjs-core/lib/core/net/URLLoaderDataFormat\");\nimport URLRequest\t\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\nimport ParserBase\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserBase\");\nimport ParserUtils\t\t\t\t\t\t= require(\"awayjs-core/lib/parsers/ParserUtils\");\nimport ResourceDependency\t\t\t\t= require(\"awayjs-core/lib/parsers/ResourceDependency\");\nimport Texture2DBase\t\t\t\t\t= require(\"awayjs-core/lib/textures/Texture2DBase\");\n\nimport DefaultMaterialManager\t\t\t= require(\"awayjs-stagegl/lib/materials/utils/DefaultMaterialManager\");\nimport SpecularBasicMethod\t\t\t\t= require(\"awayjs-stagegl/lib/materials/methods/SpecularBasicMethod\");\nimport TriangleMethodMaterial\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\nimport TriangleMaterialMode\t\t\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMaterialMode\");\n\n/**\n * OBJParser provides a parser for the OBJ data type.\n */\nclass OBJParser extends ParserBase\n{\n\tprivate _textData:string;\n\tprivate _startedParsing:boolean;\n\tprivate _charIndex:number;\n\tprivate _oldIndex:number;\n\tprivate _stringLength:number;\n\tprivate _currentObject:ObjectGroup;\n\tprivate _currentGroup:Group;\n\tprivate _currentMaterialGroup:MaterialGroup;\n\tprivate _objects:Array<ObjectGroup>;\n\tprivate _materialIDs:string[];\n\tprivate _materialLoaded:Array<LoadedMaterial>;\n\tprivate _materialSpecularData:Array<SpecularData>;\n\tprivate _meshes:Array<Mesh>;\n\tprivate _lastMtlID:string;\n\tprivate _objectIndex:number;\n\tprivate _realIndices;\n\tprivate _vertexIndex:number;\n\tprivate _vertices:Array<Vertex>;\n\tprivate _vertexNormals:Array<Vertex>;\n\tprivate _uvs:Array<UV>;\n\tprivate _scale:number;\n\tprivate _mtlLib:boolean;\n\tprivate _mtlLibLoaded:boolean = true;\n\tprivate _activeMaterialID:string = \"\";\n\n\t/**\n\t * Creates a new OBJParser object.\n\t * @param uri The url or id of the data or file to be parsed.\n\t * @param extra The holder for extra contextual data that the parser might need.\n\t */\n\tconstructor(scale:number = 1)\n\t{\n\t\tsuper(URLLoaderDataFormat.TEXT);\n\t\tthis._scale = scale;\n\t}\n\n\t/**\n\t * Scaling factor applied directly to vertices data\n\t * @param value The scaling factor.\n\t */\n\tpublic set scale(value:number)\n\t{\n\t\tthis._scale = value;\n\t}\n\n\t/**\n\t * Indicates whether or not a given file extension is supported by the parser.\n\t * @param extension The file extension of a potential file to be parsed.\n\t * @return Whether or not the given file type is supported.\n\t */\n\tpublic static supportsType(extension:string):boolean\n\t{\n\t\textension = extension.toLowerCase();\n\t\treturn extension == \"obj\";\n\t}\n\n\t/**\n\t * Tests whether a data block can be parsed by the parser.\n\t * @param data The data block to potentially be parsed.\n\t * @return Whether or not the given data is supported.\n\t */\n\tpublic static supportsData(data:any):boolean\n\t{\n\t\tvar content:string = ParserUtils.toString(data);\n\t\tvar hasV:boolean = false;\n\t\tvar hasF:boolean = false;\n\n\t\tif (content) {\n\t\t\thasV = content.indexOf(\"\\nv \") != -1;\n\t\t\thasF = content.indexOf(\"\\nf \") != -1;\n\t\t}\n\n\t\treturn hasV && hasF;\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependency(resourceDependency:ResourceDependency)\n\t{\n\t\tif (resourceDependency.id == 'mtl') {\n\t\t\tvar str:string = ParserUtils.toString(resourceDependency.data);\n\t\t\tthis.parseMtl(str);\n\n\t\t} else {\n\t\t\tvar asset:IAsset;\n\n\t\t\tif (resourceDependency.assets.length != 1) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tasset = resourceDependency.assets[0];\n\n\t\t\tif (asset.assetType == AssetType.TEXTURE) {\n\n\t\t\t\tvar lm:LoadedMaterial = new LoadedMaterial();\n\t\t\t\tlm.materialID = resourceDependency.id;\n\t\t\t\tlm.texture = <Texture2DBase> asset;\n\n\t\t\t\tthis._materialLoaded.push(lm);\n\n\t\t\t\tif (this._meshes.length > 0) {\n\t\t\t\t\tthis.applyMaterial(lm);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _iResolveDependencyFailure(resourceDependency:ResourceDependency)\n\t{\n\t\tif (resourceDependency.id == \"mtl\") {\n\t\t\tthis._mtlLib = false;\n\t\t\tthis._mtlLibLoaded = false;\n\t\t} else {\n\t\t\tvar lm:LoadedMaterial = new LoadedMaterial();\n\t\t\tlm.materialID = resourceDependency.id;\n\t\t\tthis._materialLoaded.push(lm);\n\t\t}\n\n\t\tif (this._meshes.length > 0)\n\t\t\tthis.applyMaterial(lm);\n\t}\n\n\t/**\n\t * @inheritDoc\n\t */\n\tpublic _pProceedParsing():boolean\n\t{\n\t\tvar line:string;\n\t\tvar creturn:string = String.fromCharCode(10);\n\t\tvar trunk;\n\n\t\tif (!this._startedParsing) {\n\t\t\tthis._textData = this._pGetTextData();\n\t\t\t// Merge linebreaks that are immediately preceeded by\n\t\t\t// the \"escape\" backward slash into single lines.\n\t\t\tthis._textData = this._textData.replace(/\\\\[\\r\\n]+\\s*/gm, ' ');\n\t\t}\n\n\t\tif (this._textData.indexOf(creturn) == -1)\n\t\t\tcreturn = String.fromCharCode(13);\n\n\t\tif (!this._startedParsing) {\n\t\t\tthis._startedParsing = true;\n\t\t\tthis._vertices = new Array<Vertex>();\n\t\t\tthis._vertexNormals = new Array<Vertex>();\n\t\t\tthis._materialIDs = new Array<string>();\n\t\t\tthis._materialLoaded = new Array<LoadedMaterial>();\n\t\t\tthis._meshes = new Array<Mesh>();\n\t\t\tthis._uvs = new Array<UV>();\n\t\t\tthis._stringLength = this._textData.length;\n\t\t\tthis._charIndex = this._textData.indexOf(creturn, 0);\n\t\t\tthis._oldIndex = 0;\n\t\t\tthis._objects = new Array<ObjectGroup>();\n\t\t\tthis._objectIndex = 0;\n\t\t}\n\n\t\twhile (this._charIndex < this._stringLength && this._pHasTime()) {\n\t\t\tthis._charIndex = this._textData.indexOf(creturn, this._oldIndex);\n\n\t\t\tif (this._charIndex == -1)\n\t\t\t\tthis._charIndex = this._stringLength;\n\n\t\t\tline = this._textData.substring(this._oldIndex, this._charIndex);\n\t\t\tline = line.split('\\r').join(\"\");\n\t\t\tline = line.replace(\"  \", \" \");\n\t\t\ttrunk = line.split(\" \");\n\t\t\tthis._oldIndex = this._charIndex + 1;\n\t\t\tthis.parseLine(trunk);\n\n\t\t\t// If whatever was parsed on this line resulted in the\n\t\t\t// parsing being paused to retrieve dependencies, break\n\t\t\t// here and do not continue parsing until un-paused.\n\t\t\tif (this.parsingPaused) {\n\t\t\t\treturn ParserBase.MORE_TO_PARSE;\n\t\t\t}\n\n\t\t}\n\n\t\tif (this._charIndex >= this._stringLength) {\n\n\t\t\tif (this._mtlLib && !this._mtlLibLoaded) {\n\t\t\t\treturn ParserBase.MORE_TO_PARSE;\n\t\t\t}\n\n\t\t\tthis.translate();\n\t\t\tthis.applyMaterials();\n\n\t\t\treturn ParserBase.PARSING_DONE;\n\t\t}\n\n\t\treturn ParserBase.MORE_TO_PARSE;\n\t}\n\n\tpublic _pStartParsing(frameLimit:number)\n\t{\n\t\tsuper._pStartParsing(frameLimit);\n\n\t\t//create a content object for Loaders\n\t\tthis._pContent = new DisplayObjectContainer();\n\t}\n\n\t/**\n\t * Parses a single line in the OBJ file.\n\t */\n\tprivate parseLine(trunk)\n\t{\n\t\tswitch (trunk[0]) {\n\n\t\t\tcase \"mtllib\":\n\n\t\t\t\tthis._mtlLib = true;\n\t\t\t\tthis._mtlLibLoaded = false;\n\t\t\t\tthis.loadMtl(trunk[1]);\n\n\t\t\t\tbreak;\n\n\t\t\tcase \"g\":\n\n\t\t\t\tthis.createGroup(trunk);\n\n\t\t\t\tbreak;\n\n\t\t\tcase \"o\":\n\n\t\t\t\tthis.createObject(trunk);\n\n\t\t\t\tbreak;\n\n\t\t\tcase \"usemtl\":\n\n\t\t\t\tif (this._mtlLib) {\n\n\t\t\t\t\tif (!trunk[1])\n\t\t\t\t\t\ttrunk[1] = \"def000\";\n\n\t\t\t\t\tthis._materialIDs.push(trunk[1]);\n\t\t\t\t\tthis._activeMaterialID = trunk[1];\n\n\t\t\t\t\tif (this._currentGroup)\n\t\t\t\t\t\tthis._currentGroup.materialID = this._activeMaterialID;\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t\tcase \"v\":\n\n\t\t\t\tthis.parseVertex(trunk);\n\n\t\t\t\tbreak;\n\n\t\t\tcase \"vt\":\n\n\t\t\t\tthis.parseUV(trunk);\n\n\t\t\t\tbreak;\n\n\t\t\tcase \"vn\":\n\n\t\t\t\tthis.parseVertexNormal(trunk);\n\n\t\t\t\tbreak;\n\n\t\t\tcase \"f\":\n\n\t\t\t\tthis.parseFace(trunk);\n\n\t\t}\n\t}\n\n\t/**\n\t * Converts the parsed data into an Away3D scenegraph structure\n\t */\n\tprivate translate()\n\t{\n\t\tfor (var objIndex:number = 0; objIndex < this._objects.length; ++objIndex) {\n\t\t\tvar groups:Array<Group> = this._objects[objIndex].groups;\n\t\t\tvar numGroups:number = groups.length;\n\t\t\tvar materialGroups:Array<MaterialGroup>;\n\t\t\tvar numMaterialGroups:number;\n\t\t\tvar geometry:Geometry;\n\t\t\tvar mesh:Mesh;\n\n\t\t\tvar m:number;\n\t\t\tvar sm:number;\n\t\t\tvar bmMaterial:TriangleMethodMaterial;\n\n\t\t\tfor (var g:number = 0; g < numGroups; ++g) {\n\t\t\t\tgeometry = new Geometry();\n\t\t\t\tmaterialGroups = groups[g].materialGroups;\n\t\t\t\tnumMaterialGroups = materialGroups.length;\n\n\t\t\t\tfor (m = 0; m < numMaterialGroups; ++m)\n\t\t\t\t\tthis.translateMaterialGroup(materialGroups[m], geometry);\n\n\t\t\t\tif (geometry.subGeometries.length == 0)\n\t\t\t\t\tcontinue;\n\n\t\t\t\t// Finalize and force type-based name\n\t\t\t\tthis._pFinalizeAsset(<IAsset> geometry);//, \"\");\n\n\t\t\t\tbmMaterial = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture());\n\n\t\t\t\t//check for multipass\n\t\t\t\tif (this.materialMode >= 2)\n\t\t\t\t\tbmMaterial.materialMode = TriangleMaterialMode.MULTI_PASS;\n\n\t\t\t\tmesh = new Mesh(geometry, bmMaterial);\n\n\t\t\t\tif (this._objects[objIndex].name) {\n\t\t\t\t\t// this is a full independent object ('o' tag in OBJ file)\n\t\t\t\t\tmesh.name = this._objects[objIndex].name;\n\n\t\t\t\t} else if (groups[g].name) {\n\n\t\t\t\t\t// this is a group so the sub groups contain the actual mesh object names ('g' tag in OBJ file)\n\t\t\t\t\tmesh.name = groups[g].name;\n\n\t\t\t\t} else {\n\t\t\t\t\t// No name stored. Use empty string which will force it\n\t\t\t\t\t// to be overridden by finalizeAsset() to type default.\n\t\t\t\t\tmesh.name = \"\";\n\t\t\t\t}\n\n\t\t\t\tthis._meshes.push(mesh);\n\n\t\t\t\tif (groups[g].materialID != \"\")\n\t\t\t\t\tbmMaterial.name = groups[g].materialID + \"~\" + mesh.name; else\n\t\t\t\t\tbmMaterial.name = this._lastMtlID + \"~\" + mesh.name;\n\n\t\t\t\tif (mesh.subMeshes.length > 1) {\n\t\t\t\t\tfor (sm = 1; sm < mesh.subMeshes.length; ++sm)\n\t\t\t\t\t\tmesh.subMeshes[sm].material = bmMaterial;\n\t\t\t\t}\n\n\t\t\t\t//add to the content property\n\t\t\t\t(<DisplayObjectContainer> this._pContent).addChild(mesh);\n\n\t\t\t\tthis._pFinalizeAsset(<IAsset> mesh);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Translates an obj's material group to a subgeometry.\n\t * @param materialGroup The material group data to convert.\n\t * @param geometry The Geometry to contain the converted SubGeometry.\n\t */\n\tprivate translateMaterialGroup(materialGroup:MaterialGroup, geometry:Geometry)\n\t{\n\t\tvar faces:Array<FaceData> = materialGroup.faces;\n\t\tvar face:FaceData;\n\t\tvar numFaces:number = faces.length;\n\t\tvar numVerts:number;\n\t\tvar sub:TriangleSubGeometry;\n\n\t\tvar vertices:Array<number> = new Array<number>();\n\t\tvar uvs:Array<number> = new Array<number>();\n\t\tvar normals:Array<number> = new Array<number>();\n\t\tvar indices:Array<number> /*uint*/ = new Array<number>();\n\n\t\tthis._realIndices = [];\n\t\tthis._vertexIndex = 0;\n\n\t\tvar j:number;\n\t\tfor (var i:number = 0; i < numFaces; ++i) {\n\n\t\t\tface = faces[i];\n\t\t\tnumVerts = face.indexIds.length - 1;\n\n\t\t\tfor (j = 1; j < numVerts; ++j) {\n\n\t\t\t\tthis.translateVertexData(face, j, vertices, uvs, indices, normals);\n\t\t\t\tthis.translateVertexData(face, 0, vertices, uvs, indices, normals);\n\t\t\t\tthis.translateVertexData(face, j + 1, vertices, uvs, indices, normals);\n\t\t\t}\n\t\t}\n\t\tif (vertices.length > 0) {\n\t\t\tsub = new TriangleSubGeometry(true);\n\t\t\tsub.autoDeriveNormals = normals.length? false : true;\n\t\t\tsub.updateIndices(indices);\n\t\t\tsub.updatePositions(vertices);\n\t\t\tsub.updateVertexNormals(normals);\n\t\t\tsub.updateUVs(uvs);\n\n\t\t\tgeometry.addSubGeometry(sub);\n\t\t}\n\t}\n\n\tprivate translateVertexData(face:FaceData, vertexIndex:number, vertices:Array<number>, uvs:Array<number>, indices:Array<number> /*uint*/, normals:Array<number>)\n\t{\n\t\tvar index:number;\n\t\tvar vertex:Vertex;\n\t\tvar vertexNormal:Vertex;\n\t\tvar uv:UV;\n\n\t\tif (!this._realIndices[face.indexIds[vertexIndex]]) {\n\n\t\t\tindex = this._vertexIndex;\n\t\t\tthis._realIndices[face.indexIds[vertexIndex]] = ++this._vertexIndex;\n\t\t\tvertex = this._vertices[face.vertexIndices[vertexIndex] - 1];\n\t\t\tvertices.push(vertex.x*this._scale, vertex.y*this._scale, vertex.z*this._scale);\n\n\t\t\tif (face.normalIndices.length > 0) {\n\t\t\t\tvertexNormal = this._vertexNormals[face.normalIndices[vertexIndex] - 1];\n\t\t\t\tnormals.push(vertexNormal.x, vertexNormal.y, vertexNormal.z);\n\t\t\t}\n\n\t\t\tif (face.uvIndices.length > 0) {\n\n\t\t\t\ttry {\n\t\t\t\t\tuv = this._uvs[face.uvIndices[vertexIndex] - 1];\n\t\t\t\t\tuvs.push(uv.u, uv.v);\n\n\t\t\t\t} catch (e) {\n\n\t\t\t\t\tswitch (vertexIndex) {\n\t\t\t\t\t\tcase 0:\n\t\t\t\t\t\t\tuvs.push(0, 1);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 1:\n\t\t\t\t\t\t\tuvs.push(.5, 0);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 2:\n\t\t\t\t\t\t\tuvs.push(1, 1);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\t\t\tindex = this._realIndices[face.indexIds[vertexIndex]] - 1;\n\t\t}\n\n\t\tindices.push(index);\n\t}\n\n\t/**\n\t * Creates a new object group.\n\t * @param trunk The data block containing the object tag and its parameters\n\t */\n\tprivate createObject(trunk)\n\t{\n\t\tthis._currentGroup = null;\n\t\tthis._currentMaterialGroup = null;\n\t\tthis._objects.push(this._currentObject = new ObjectGroup());\n\n\t\tif (trunk)\n\t\t\tthis._currentObject.name = trunk[1];\n\t}\n\n\t/**\n\t * Creates a new group.\n\t * @param trunk The data block containing the group tag and its parameters\n\t */\n\tprivate createGroup(trunk)\n\t{\n\t\tif (!this._currentObject)\n\t\t\tthis.createObject(null);\n\t\tthis._currentGroup = new Group();\n\n\t\tthis._currentGroup.materialID = this._activeMaterialID;\n\n\t\tif (trunk)\n\t\t\tthis._currentGroup.name = trunk[1];\n\t\tthis._currentObject.groups.push(this._currentGroup);\n\n\t\tthis.createMaterialGroup(null);\n\t}\n\n\t/**\n\t * Creates a new material group.\n\t * @param trunk The data block containing the material tag and its parameters\n\t */\n\tprivate createMaterialGroup(trunk)\n\t{\n\t\tthis._currentMaterialGroup = new MaterialGroup();\n\t\tif (trunk)\n\t\t\tthis._currentMaterialGroup.url = trunk[1];\n\t\tthis._currentGroup.materialGroups.push(this._currentMaterialGroup);\n\t}\n\n\t/**\n\t * Reads the next vertex coordinates.\n\t * @param trunk The data block containing the vertex tag and its parameters\n\t */\n\tprivate parseVertex(trunk)\n\t{\n\t\t//for the very rare cases of other delimiters/charcodes seen in some obj files\n\n\t\tvar v1:number, v2:number , v3:number;\n\t\tif (trunk.length > 4) {\n\t\t\tvar nTrunk = [];\n\t\t\tvar val:number;\n\n\t\t\tfor (var i:number = 1; i < trunk.length; ++i) {\n\t\t\t\tval = parseFloat(trunk[i]);\n\t\t\t\tif (!isNaN(val))\n\t\t\t\t\tnTrunk.push(val);\n\t\t\t}\n\n\t\t\tv1 = <number> nTrunk[0];\n\t\t\tv2 = <number> nTrunk[1];\n\t\t\tv3 = <number> -nTrunk[2];\n\t\t\tthis._vertices.push(new Vertex(v1, v2, v3));\n\n\t\t} else {\n\t\t\tv1 = <number> parseFloat(trunk[1]);\n\t\t\tv2 = <number> parseFloat(trunk[2]);\n\t\t\tv3 = <number> -parseFloat(trunk[3]);\n\n\t\t\tthis._vertices.push(new Vertex(v1, v2, v3));\n\t\t}\n\n\t}\n\n\t/**\n\t * Reads the next uv coordinates.\n\t * @param trunk The data block containing the uv tag and its parameters\n\t */\n\tprivate parseUV(trunk)\n\t{\n\t\tif (trunk.length > 3) {\n\t\t\tvar nTrunk = [];\n\t\t\tvar val:number;\n\t\t\tfor (var i:number = 1; i < trunk.length; ++i) {\n\t\t\t\tval = parseFloat(trunk[i]);\n\t\t\t\tif (!isNaN(val))\n\t\t\t\t\tnTrunk.push(val);\n\t\t\t}\n\t\t\tthis._uvs.push(new UV(nTrunk[0], 1 - nTrunk[1]));\n\n\t\t} else {\n\t\t\tthis._uvs.push(new UV(parseFloat(trunk[1]), 1 - parseFloat(trunk[2])));\n\t\t}\n\n\t}\n\n\t/**\n\t * Reads the next vertex normal coordinates.\n\t * @param trunk The data block containing the vertex normal tag and its parameters\n\t */\n\tprivate parseVertexNormal(trunk)\n\t{\n\t\tif (trunk.length > 4) {\n\t\t\tvar nTrunk = [];\n\t\t\tvar val:number;\n\t\t\tfor (var i:number = 1; i < trunk.length; ++i) {\n\t\t\t\tval = parseFloat(trunk[i]);\n\t\t\t\tif (!isNaN(val))\n\t\t\t\t\tnTrunk.push(val);\n\t\t\t}\n\t\t\tthis._vertexNormals.push(new Vertex(nTrunk[0], nTrunk[1], -nTrunk[2]));\n\n\t\t} else {\n\t\t\tthis._vertexNormals.push(new Vertex(parseFloat(trunk[1]), parseFloat(trunk[2]), -parseFloat(trunk[3])));\n\t\t}\n\t}\n\n\t/**\n\t * Reads the next face's indices.\n\t * @param trunk The data block containing the face tag and its parameters\n\t */\n\tprivate parseFace(trunk)\n\t{\n\t\tvar len:number = trunk.length;\n\t\tvar face:FaceData = new FaceData();\n\n\t\tif (!this._currentGroup) {\n\t\t\tthis.createGroup(null);\n\t\t}\n\n\t\tvar indices;\n\t\tfor (var i:number = 1; i < len; ++i) {\n\n\t\t\tif (trunk[i] == \"\") {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tindices = trunk[i].split(\"/\");\n\t\t\tface.vertexIndices.push(this.parseIndex(parseInt(indices[0]), this._vertices.length));\n\n\t\t\tif (indices[1] && String(indices[1]).length > 0)\n\t\t\t\tface.uvIndices.push(this.parseIndex(parseInt(indices[1]), this._uvs.length));\n\n\t\t\tif (indices[2] && String(indices[2]).length > 0)\n\t\t\t\tface.normalIndices.push(this.parseIndex(parseInt(indices[2]), this._vertexNormals.length));\n\n\t\t\tface.indexIds.push(trunk[i]);\n\t\t}\n\n\t\tthis._currentMaterialGroup.faces.push(face);\n\t}\n\n\t/**\n\t * This is a hack around negative face coords\n\t */\n\tprivate parseIndex(index:number, length:number):number\n\t{\n\t\tif (index < 0)\n\t\t\treturn index + length + 1; else\n\t\t\treturn index;\n\t}\n\n\tprivate parseMtl(data:string)\n\t{\n\t\tvar materialDefinitions = data.split('newmtl');\n\t\tvar lines;\n\t\tvar trunk;\n\t\tvar j:number;\n\n\t\tvar basicSpecularMethod:SpecularBasicMethod;\n\t\tvar useSpecular:boolean;\n\t\tvar useColor:boolean;\n\t\tvar diffuseColor:number;\n\t\tvar color:number;\n\t\tvar specularColor:number;\n\t\tvar specular:number;\n\t\tvar alpha:number;\n\t\tvar mapkd:string;\n\n\t\tfor (var i:number = 0; i < materialDefinitions.length; ++i) {\n\n\n\t\t\tlines = (materialDefinitions[i].split('\\r')).join(\"\").split('\\n');\n\t\t\t//lines = (materialDefinitions[i].split('\\r') as Array).join(\"\").split('\\n');\n\n\t\t\tif (lines.length == 1)\n\t\t\t\tlines = materialDefinitions[i].split(String.fromCharCode(13));\n\n\t\t\tdiffuseColor = color = specularColor = 0xFFFFFF;\n\t\t\tspecular = 0;\n\t\t\tuseSpecular = false;\n\t\t\tuseColor = false;\n\t\t\talpha = 1;\n\t\t\tmapkd = \"\";\n\n\t\t\tfor (j = 0; j < lines.length; ++j) {\n\n\t\t\t\tlines[j] = lines[j].replace(/\\s+$/, \"\");\n\n\t\t\t\tif (lines[j].substring(0, 1) != \"#\" && (j == 0 || lines[j] != \"\")) {\n\t\t\t\t\ttrunk = lines[j].split(\" \");\n\n\t\t\t\t\tif (String(trunk[0]).charCodeAt(0) == 9 || String(trunk[0]).charCodeAt(0) == 32)\n\t\t\t\t\t\ttrunk[0] = trunk[0].substring(1, trunk[0].length);\n\n\t\t\t\t\tif (j == 0) {\n\t\t\t\t\t\tthis._lastMtlID = trunk.join(\"\");\n\t\t\t\t\t\tthis._lastMtlID = (this._lastMtlID == \"\")? \"def000\" : this._lastMtlID;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tswitch (trunk[0]) {\n\n\t\t\t\t\t\t\tcase \"Ka\":\n\t\t\t\t\t\t\t\tif (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3])))\n\t\t\t\t\t\t\t\t\tcolor = trunk[1]*255 << 16 | trunk[2]*255 << 8 | trunk[3]*255;\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase \"Ks\":\n\t\t\t\t\t\t\t\tif (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) {\n\t\t\t\t\t\t\t\t\tspecularColor = trunk[1]*255 << 16 | trunk[2]*255 << 8 | trunk[3]*255;\n\t\t\t\t\t\t\t\t\tuseSpecular = true;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase \"Ns\":\n\t\t\t\t\t\t\t\tif (trunk[1] && !isNaN(Number(trunk[1])))\n\t\t\t\t\t\t\t\t\tspecular = Number(trunk[1])*0.001;\n\t\t\t\t\t\t\t\tif (specular == 0)\n\t\t\t\t\t\t\t\t\tuseSpecular = false;\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase \"Kd\":\n\t\t\t\t\t\t\t\tif (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) {\n\t\t\t\t\t\t\t\t\tdiffuseColor = trunk[1]*255 << 16 | trunk[2]*255 << 8 | trunk[3]*255;\n\t\t\t\t\t\t\t\t\tuseColor = true;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase \"tr\":\n\t\t\t\t\t\t\tcase \"d\":\n\t\t\t\t\t\t\t\tif (trunk[1] && !isNaN(Number(trunk[1])))\n\t\t\t\t\t\t\t\t\talpha = Number(trunk[1]);\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase \"map_Kd\":\n\t\t\t\t\t\t\t\tmapkd = this.parseMapKdString(trunk);\n\t\t\t\t\t\t\t\tmapkd = mapkd.replace(/\\\\/g, \"/\");\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (mapkd != \"\") {\n\n\t\t\t\tif (useSpecular) {\n\n\t\t\t\t\tbasicSpecularMethod = new SpecularBasicMethod();\n\t\t\t\t\tbasicSpecularMethod.specularColor = specularColor;\n\t\t\t\t\tbasicSpecularMethod.specular = specular;\n\n\t\t\t\t\tvar specularData:SpecularData = new SpecularData();\n\t\t\t\t\tspecularData.alpha = alpha;\n\t\t\t\t\tspecularData.basicSpecularMethod = basicSpecularMethod;\n\t\t\t\t\tspecularData.materialID = this._lastMtlID;\n\n\t\t\t\t\tif (!this._materialSpecularData)\n\t\t\t\t\t\tthis._materialSpecularData = new Array<SpecularData>();\n\n\t\t\t\t\tthis._materialSpecularData.push(specularData);\n\n\t\t\t\t}\n\n\t\t\t\tthis._pAddDependency(this._lastMtlID, new URLRequest(mapkd));\n\n\t\t\t} else if (useColor && !isNaN(color)) {\n\n\t\t\t\tvar lm:LoadedMaterial = new LoadedMaterial();\n\t\t\t\tlm.materialID = this._lastMtlID;\n\n\t\t\t\tif (alpha == 0)\n\t\t\t\t\tconsole.log(\"Warning: an alpha value of 0 was found in mtl color tag (Tr or d) ref:\" + this._lastMtlID + \", mesh(es) using it will be invisible!\");\n\n\t\t\t\tvar cm:TriangleMethodMaterial;\n\n\t\t\t\tif (this.materialMode < 2) {\n\t\t\t\t\tcm = new TriangleMethodMaterial(color);\n\n\t\t\t\t\tvar colorMat:TriangleMethodMaterial = <TriangleMethodMaterial> cm;\n\n\t\t\t\t\tcolorMat.alpha = alpha;\n\t\t\t\t\tcolorMat.diffuseColor = diffuseColor;\n\t\t\t\t\tcolorMat.repeat = true;\n\n\t\t\t\t\tif (useSpecular) {\n\t\t\t\t\t\tcolorMat.specularColor = specularColor;\n\t\t\t\t\t\tcolorMat.specular = specular;\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\t\t\t\t\tcm = new TriangleMethodMaterial(color);\n\t\t\t\t\tcm.materialMode = TriangleMaterialMode.MULTI_PASS;\n\n\t\t\t\t\tvar colorMultiMat:TriangleMethodMaterial = <TriangleMethodMaterial> cm;\n\n\n\t\t\t\t\tcolorMultiMat.diffuseColor = diffuseColor;\n\t\t\t\t\tcolorMultiMat.repeat = true;\n\n\t\t\t\t\tif (useSpecular) {\n\t\t\t\t\t\tcolorMultiMat.specularColor = specularColor;\n\t\t\t\t\t\tcolorMultiMat.specular = specular;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tlm.cm = cm;\n\n\t\t\t\tthis._materialLoaded.push(lm);\n\n\t\t\t\tif (this._meshes.length > 0)\n\t\t\t\t\tthis.applyMaterial(lm);\n\n\t\t\t}\n\t\t}\n\n\t\tthis._mtlLibLoaded = true;\n\t}\n\n\tprivate parseMapKdString(trunk):string\n\t{\n\t\tvar url:string = \"\";\n\t\tvar i:number;\n\t\tvar breakflag:boolean;\n\n\t\tfor (i = 1; i < trunk.length;) {\n\t\t\tswitch (trunk[i]) {\n\t\t\t\tcase \"-blendu\":\n\t\t\t\tcase \"-blendv\":\n\t\t\t\tcase \"-cc\":\n\t\t\t\tcase \"-clamp\":\n\t\t\t\tcase \"-texres\":\n\t\t\t\t\ti += 2; //Skip ahead 1 attribute\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"-mm\":\n\t\t\t\t\ti += 3; //Skip ahead 2 attributes\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"-o\":\n\t\t\t\tcase \"-s\":\n\t\t\t\tcase \"-t\":\n\t\t\t\t\ti += 4; //Skip ahead 3 attributes\n\t\t\t\t\tcontinue;\n\t\t\t\tdefault:\n\t\t\t\t\tbreakflag = true;\n\t\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tif (breakflag)\n\t\t\t\tbreak;\n\t\t}\n\n\t\t//Reconstruct URL/filename\n\t\tfor (i; i < trunk.length; i++) {\n\t\t\turl += trunk[i];\n\t\t\turl += \" \";\n\t\t}\n\n\t\t//Remove the extraneous space and/or newline from the right side\n\t\turl = url.replace(/\\s+$/, \"\");\n\n\t\treturn url;\n\t}\n\n\tprivate loadMtl(mtlurl:string)\n\t{\n\t\t// Add raw-data dependency to queue and load dependencies now,\n\t\t// which will pause the parsing in the meantime.\n\t\tthis._pAddDependency('mtl', new URLRequest(mtlurl), true);\n\t\tthis._pPauseAndRetrieveDependencies();//\n\t}\n\n\tprivate applyMaterial(lm:LoadedMaterial)\n\t{\n\t\tvar decomposeID;\n\t\tvar mesh:Mesh;\n\t\tvar tm:TriangleMethodMaterial;\n\t\tvar j:number;\n\t\tvar specularData:SpecularData;\n\n\t\tfor (var i:number = 0; i < this._meshes.length; ++i) {\n\t\t\tmesh = this._meshes[i];\n\t\t\tdecomposeID = mesh.material.name.split(\"~\");\n\n\t\t\tif (decomposeID[0] == lm.materialID) {\n\n\t\t\t\tif (lm.cm) {\n\t\t\t\t\tif (mesh.material)\n\t\t\t\t\t\tmesh.material = null;\n\t\t\t\t\tmesh.material = lm.cm;\n\n\t\t\t\t} else if (lm.texture) {\n\t\t\t\t\tif (this.materialMode < 2) { // if materialMode is 0 or 1, we create a SinglePass\n\t\t\t\t\t\ttm = <TriangleMethodMaterial > mesh.material;\n\n\t\t\t\t\t\ttm.texture = lm.texture;\n\t\t\t\t\t\ttm.color = lm.color;\n\t\t\t\t\t\ttm.alpha = lm.alpha;\n\t\t\t\t\t\ttm.repeat = true;\n\n\t\t\t\t\t\tif (lm.specularMethod) {\n\n\t\t\t\t\t\t\t// By setting the specularMethod property to null before assigning\n\t\t\t\t\t\t\t// the actual method instance, we avoid having the properties of\n\t\t\t\t\t\t\t// the new method being overridden with the settings from the old\n\t\t\t\t\t\t\t// one, which is default behavior of the setter.\n\t\t\t\t\t\t\ttm.specularMethod = null;\n\t\t\t\t\t\t\ttm.specularMethod = lm.specularMethod;\n\n\t\t\t\t\t\t} else if (this._materialSpecularData) {\n\n\t\t\t\t\t\t\tfor (j = 0; j < this._materialSpecularData.length; ++j) {\n\t\t\t\t\t\t\t\tspecularData = this._materialSpecularData[j];\n\n\t\t\t\t\t\t\t\tif (specularData.materialID == lm.materialID) {\n\t\t\t\t\t\t\t\t\ttm.specularMethod = null; // Prevent property overwrite (see above)\n\t\t\t\t\t\t\t\t\ttm.specularMethod = specularData.basicSpecularMethod;\n\t\t\t\t\t\t\t\t\ttm.color = specularData.color;\n\t\t\t\t\t\t\t\t\ttm.alpha = specularData.alpha;\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} else { //if materialMode==2 this is a MultiPassTexture\n\t\t\t\t\t\ttm = <TriangleMethodMaterial> mesh.material;\n\t\t\t\t\t\ttm.materialMode = TriangleMaterialMode.MULTI_PASS;\n\n\t\t\t\t\t\ttm.texture = lm.texture;\n\t\t\t\t\t\ttm.color = lm.color;\n\t\t\t\t\t\ttm.repeat = true;\n\n\t\t\t\t\t\tif (lm.specularMethod) {\n\t\t\t\t\t\t\t// By setting the specularMethod property to null before assigning\n\t\t\t\t\t\t\t// the actual method instance, we avoid having the properties of\n\t\t\t\t\t\t\t// the new method being overridden with the settings from the old\n\t\t\t\t\t\t\t// one, which is default behavior of the setter.\n\t\t\t\t\t\t\ttm.specularMethod = null;\n\t\t\t\t\t\t\ttm.specularMethod = lm.specularMethod;\n\t\t\t\t\t\t} else if (this._materialSpecularData) {\n\t\t\t\t\t\t\tfor (j = 0; j < this._materialSpecularData.length; ++j) {\n\t\t\t\t\t\t\t\tspecularData = this._materialSpecularData[j];\n\n\t\t\t\t\t\t\t\tif (specularData.materialID == lm.materialID) {\n\t\t\t\t\t\t\t\t\ttm.specularMethod = null; // Prevent property overwrite (see above)\n\t\t\t\t\t\t\t\t\ttm.specularMethod = specularData.basicSpecularMethod;\n\t\t\t\t\t\t\t\t\ttm.color = specularData.color;\n\n\t\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tmesh.material.name = decomposeID[1]? decomposeID[1] : decomposeID[0];\n\t\t\t\tthis._meshes.splice(i, 1);\n\t\t\t\t--i;\n\t\t\t}\n\t\t}\n\n\t\tif (lm.cm || tm)\n\t\t\tthis._pFinalizeAsset(lm.cm || tm);\n\t}\n\n\tprivate applyMaterials()\n\t{\n\t\tif (this._materialLoaded.length == 0)\n\t\t\treturn;\n\n\t\tfor (var i:number = 0; i < this._materialLoaded.length; ++i)\n\t\t\tthis.applyMaterial(this._materialLoaded[i]);\n\t}\n}\n\nexport = OBJParser;\n\nclass ObjectGroup\n{\n\tpublic name:string;\n\tpublic groups:Group[] = new Array<Group>();\n}\n\nclass Group\n{\n\tpublic name:string;\n\tpublic materialID:string;\n\tpublic materialGroups:MaterialGroup[] = new Array<MaterialGroup>();\n}\n\nclass MaterialGroup\n{\n\tpublic url:string;\n\tpublic faces:FaceData[] = new Array<FaceData>();\n}\n\nclass SpecularData\n{\n\tpublic materialID:string;\n\tpublic basicSpecularMethod:SpecularBasicMethod;\n\tpublic color:number = 0xFFFFFF;\n\tpublic alpha:number = 1;\n}\n\nclass LoadedMaterial\n{\n\tpublic materialID:string;\n\tpublic texture:Texture2DBase;\n\tpublic cm:MaterialBase;\n\tpublic specularMethod:SpecularBasicMethod;\n\tpublic color:number = 0xFFFFFF;\n\tpublic alpha:number = 1;\n}\n\nclass FaceData\n{\n\tpublic vertexIndices:Array<number> /*uint*/ = new Array<number>();\n\tpublic uvIndices:Array<number> /*uint*/ = new Array<number>();\n\tpublic normalIndices:Array<number> /*uint*/ = new Array<number>();\n\tpublic indexIds:string[] = new Array<string>(); // used for real index lookups\n}\n\n/**\n* Texture coordinates value object.\n*/\nclass UV\n{\n\tprivate _u:number;\n\tprivate _v:number;\n\n\t/**\n\t * Creates a new <code>UV</code> object.\n\t *\n\t * @param    u        [optional]    The horizontal coordinate of the texture value. Defaults to 0.\n\t * @param    v        [optional]    The vertical coordinate of the texture value. Defaults to 0.\n\t */\n\tconstructor(u:number = 0, v:number = 0)\n\t{\n\t\tthis._u = u;\n\t\tthis._v = v;\n\t}\n\n\t/**\n\t * Defines the vertical coordinate of the texture value.\n\t */\n\tpublic get v():number\n\t{\n\t\treturn this._v;\n\t}\n\n\tpublic set v(value:number)\n\t{\n\t\tthis._v = value;\n\t}\n\n\t/**\n\t * Defines the horizontal coordinate of the texture value.\n\t */\n\tpublic get u():number\n\t{\n\t\treturn this._u;\n\t}\n\n\tpublic set u(value:number)\n\t{\n\t\tthis._u = value;\n\t}\n\n\t/**\n\t * returns a new UV value Object\n\t */\n\tpublic clone():UV\n\t{\n\t\treturn new UV(this._u, this._v);\n\t}\n\n\t/**\n\t * returns the value object as a string for trace/debug purpose\n\t */\n\tpublic toString():string\n\t{\n\t\treturn this._u + \",\" + this._v;\n\t}\n}\n\nclass Vertex\n{\n\tprivate _x:number;\n\tprivate _y:number;\n\tprivate _z:number;\n\tprivate _index:number;\n\n\t/**\n\t * Creates a new <code>Vertex</code> value object.\n\t *\n\t * @param    x            [optional]    The x value. Defaults to 0.\n\t * @param    y            [optional]    The y value. Defaults to 0.\n\t * @param    z            [optional]    The z value. Defaults to 0.\n\t * @param    index        [optional]    The index value. Defaults is NaN.\n\t */\n\tconstructor(x:number = 0, y:number = 0, z:number = 0, index:number = 0)\n\t{\n\t\tthis._x = x;\n\t\tthis._y = y;\n\t\tthis._z = z;\n\t\tthis._index = index;\n\t}\n\n\t/**\n\t * To define/store the index of value object\n\t * @param    ind        The index\n\t */\n\tpublic set index(ind:number)\n\t{\n\t\tthis._index = ind;\n\t}\n\n\tpublic get index():number\n\t{\n\t\treturn this._index;\n\t}\n\n\t/**\n\t * To define/store the x value of the value object\n\t * @param    value        The x value\n\t */\n\tpublic get x():number\n\t{\n\t\treturn this._x;\n\t}\n\n\tpublic set x(value:number)\n\t{\n\t\tthis._x = value;\n\t}\n\n\t/**\n\t * To define/store the y value of the value object\n\t * @param    value        The y value\n\t */\n\tpublic get y():number\n\t{\n\t\treturn this._y;\n\t}\n\n\tpublic set y(value:number)\n\t{\n\t\tthis._y = value;\n\t}\n\n\t/**\n\t * To define/store the z value of the value object\n\t * @param    value        The z value\n\t */\n\tpublic get z():number\n\t{\n\t\treturn this._z;\n\t}\n\n\tpublic set z(value:number)\n\t{\n\t\tthis._z = value;\n\t}\n\n\t/**\n\t * returns a new Vertex value Object\n\t */\n\tpublic clone():Vertex\n\t{\n\t\treturn new Vertex(this._x, this._y, this._z);\n\t}\n}"]} \ No newline at end of file diff --git a/lib/parsers/OBJParser.ts b/lib/parsers/OBJParser.ts new file mode 100644 index 000000000..30591f9a1 --- /dev/null +++ b/lib/parsers/OBJParser.ts @@ -0,0 +1,1152 @@ +import DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +import AssetType = require("awayjs-core/lib/core/library/AssetType"); +import IAsset = require("awayjs-core/lib/core/library/IAsset"); +import URLLoaderDataFormat = require("awayjs-core/lib/core/net/URLLoaderDataFormat"); +import URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); +import ParserBase = require("awayjs-core/lib/parsers/ParserBase"); +import ParserUtils = require("awayjs-core/lib/parsers/ParserUtils"); +import ResourceDependency = require("awayjs-core/lib/parsers/ResourceDependency"); +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +import DefaultMaterialManager = require("awayjs-stagegl/lib/materials/utils/DefaultMaterialManager"); +import SpecularBasicMethod = require("awayjs-stagegl/lib/materials/methods/SpecularBasicMethod"); +import TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +import TriangleMaterialMode = require("awayjs-stagegl/lib/materials/TriangleMaterialMode"); + +/** + * OBJParser provides a parser for the OBJ data type. + */ +class OBJParser extends ParserBase +{ + private _textData:string; + private _startedParsing:boolean; + private _charIndex:number; + private _oldIndex:number; + private _stringLength:number; + private _currentObject:ObjectGroup; + private _currentGroup:Group; + private _currentMaterialGroup:MaterialGroup; + private _objects:Array; + private _materialIDs:string[]; + private _materialLoaded:Array; + private _materialSpecularData:Array; + private _meshes:Array; + private _lastMtlID:string; + private _objectIndex:number; + private _realIndices; + private _vertexIndex:number; + private _vertices:Array; + private _vertexNormals:Array; + private _uvs:Array; + private _scale:number; + private _mtlLib:boolean; + private _mtlLibLoaded:boolean = true; + private _activeMaterialID:string = ""; + + /** + * Creates a new OBJParser object. + * @param uri The url or id of the data or file to be parsed. + * @param extra The holder for extra contextual data that the parser might need. + */ + constructor(scale:number = 1) + { + super(URLLoaderDataFormat.TEXT); + this._scale = scale; + } + + /** + * Scaling factor applied directly to vertices data + * @param value The scaling factor. + */ + public set scale(value:number) + { + this._scale = value; + } + + /** + * Indicates whether or not a given file extension is supported by the parser. + * @param extension The file extension of a potential file to be parsed. + * @return Whether or not the given file type is supported. + */ + public static supportsType(extension:string):boolean + { + extension = extension.toLowerCase(); + return extension == "obj"; + } + + /** + * Tests whether a data block can be parsed by the parser. + * @param data The data block to potentially be parsed. + * @return Whether or not the given data is supported. + */ + public static supportsData(data:any):boolean + { + var content:string = ParserUtils.toString(data); + var hasV:boolean = false; + var hasF:boolean = false; + + if (content) { + hasV = content.indexOf("\nv ") != -1; + hasF = content.indexOf("\nf ") != -1; + } + + return hasV && hasF; + } + + /** + * @inheritDoc + */ + public _iResolveDependency(resourceDependency:ResourceDependency) + { + if (resourceDependency.id == 'mtl') { + var str:string = ParserUtils.toString(resourceDependency.data); + this.parseMtl(str); + + } else { + var asset:IAsset; + + if (resourceDependency.assets.length != 1) { + return; + } + + asset = resourceDependency.assets[0]; + + if (asset.assetType == AssetType.TEXTURE) { + + var lm:LoadedMaterial = new LoadedMaterial(); + lm.materialID = resourceDependency.id; + lm.texture = asset; + + this._materialLoaded.push(lm); + + if (this._meshes.length > 0) { + this.applyMaterial(lm); + } + } + } + } + + /** + * @inheritDoc + */ + public _iResolveDependencyFailure(resourceDependency:ResourceDependency) + { + if (resourceDependency.id == "mtl") { + this._mtlLib = false; + this._mtlLibLoaded = false; + } else { + var lm:LoadedMaterial = new LoadedMaterial(); + lm.materialID = resourceDependency.id; + this._materialLoaded.push(lm); + } + + if (this._meshes.length > 0) + this.applyMaterial(lm); + } + + /** + * @inheritDoc + */ + public _pProceedParsing():boolean + { + var line:string; + var creturn:string = String.fromCharCode(10); + var trunk; + + if (!this._startedParsing) { + this._textData = this._pGetTextData(); + // Merge linebreaks that are immediately preceeded by + // the "escape" backward slash into single lines. + this._textData = this._textData.replace(/\\[\r\n]+\s*/gm, ' '); + } + + if (this._textData.indexOf(creturn) == -1) + creturn = String.fromCharCode(13); + + if (!this._startedParsing) { + this._startedParsing = true; + this._vertices = new Array(); + this._vertexNormals = new Array(); + this._materialIDs = new Array(); + this._materialLoaded = new Array(); + this._meshes = new Array(); + this._uvs = new Array(); + this._stringLength = this._textData.length; + this._charIndex = this._textData.indexOf(creturn, 0); + this._oldIndex = 0; + this._objects = new Array(); + this._objectIndex = 0; + } + + while (this._charIndex < this._stringLength && this._pHasTime()) { + this._charIndex = this._textData.indexOf(creturn, this._oldIndex); + + if (this._charIndex == -1) + this._charIndex = this._stringLength; + + line = this._textData.substring(this._oldIndex, this._charIndex); + line = line.split('\r').join(""); + line = line.replace(" ", " "); + trunk = line.split(" "); + this._oldIndex = this._charIndex + 1; + this.parseLine(trunk); + + // If whatever was parsed on this line resulted in the + // parsing being paused to retrieve dependencies, break + // here and do not continue parsing until un-paused. + if (this.parsingPaused) { + return ParserBase.MORE_TO_PARSE; + } + + } + + if (this._charIndex >= this._stringLength) { + + if (this._mtlLib && !this._mtlLibLoaded) { + return ParserBase.MORE_TO_PARSE; + } + + this.translate(); + this.applyMaterials(); + + return ParserBase.PARSING_DONE; + } + + return ParserBase.MORE_TO_PARSE; + } + + public _pStartParsing(frameLimit:number) + { + super._pStartParsing(frameLimit); + + //create a content object for Loaders + this._pContent = new DisplayObjectContainer(); + } + + /** + * Parses a single line in the OBJ file. + */ + private parseLine(trunk) + { + switch (trunk[0]) { + + case "mtllib": + + this._mtlLib = true; + this._mtlLibLoaded = false; + this.loadMtl(trunk[1]); + + break; + + case "g": + + this.createGroup(trunk); + + break; + + case "o": + + this.createObject(trunk); + + break; + + case "usemtl": + + if (this._mtlLib) { + + if (!trunk[1]) + trunk[1] = "def000"; + + this._materialIDs.push(trunk[1]); + this._activeMaterialID = trunk[1]; + + if (this._currentGroup) + this._currentGroup.materialID = this._activeMaterialID; + } + + break; + + case "v": + + this.parseVertex(trunk); + + break; + + case "vt": + + this.parseUV(trunk); + + break; + + case "vn": + + this.parseVertexNormal(trunk); + + break; + + case "f": + + this.parseFace(trunk); + + } + } + + /** + * Converts the parsed data into an Away3D scenegraph structure + */ + private translate() + { + for (var objIndex:number = 0; objIndex < this._objects.length; ++objIndex) { + var groups:Array = this._objects[objIndex].groups; + var numGroups:number = groups.length; + var materialGroups:Array; + var numMaterialGroups:number; + var geometry:Geometry; + var mesh:Mesh; + + var m:number; + var sm:number; + var bmMaterial:TriangleMethodMaterial; + + for (var g:number = 0; g < numGroups; ++g) { + geometry = new Geometry(); + materialGroups = groups[g].materialGroups; + numMaterialGroups = materialGroups.length; + + for (m = 0; m < numMaterialGroups; ++m) + this.translateMaterialGroup(materialGroups[m], geometry); + + if (geometry.subGeometries.length == 0) + continue; + + // Finalize and force type-based name + this._pFinalizeAsset( geometry);//, ""); + + bmMaterial = new TriangleMethodMaterial(DefaultMaterialManager.getDefaultTexture()); + + //check for multipass + if (this.materialMode >= 2) + bmMaterial.materialMode = TriangleMaterialMode.MULTI_PASS; + + mesh = new Mesh(geometry, bmMaterial); + + if (this._objects[objIndex].name) { + // this is a full independent object ('o' tag in OBJ file) + mesh.name = this._objects[objIndex].name; + + } else if (groups[g].name) { + + // this is a group so the sub groups contain the actual mesh object names ('g' tag in OBJ file) + mesh.name = groups[g].name; + + } else { + // No name stored. Use empty string which will force it + // to be overridden by finalizeAsset() to type default. + mesh.name = ""; + } + + this._meshes.push(mesh); + + if (groups[g].materialID != "") + bmMaterial.name = groups[g].materialID + "~" + mesh.name; else + bmMaterial.name = this._lastMtlID + "~" + mesh.name; + + if (mesh.subMeshes.length > 1) { + for (sm = 1; sm < mesh.subMeshes.length; ++sm) + mesh.subMeshes[sm].material = bmMaterial; + } + + //add to the content property + ( this._pContent).addChild(mesh); + + this._pFinalizeAsset( mesh); + } + } + } + + /** + * Translates an obj's material group to a subgeometry. + * @param materialGroup The material group data to convert. + * @param geometry The Geometry to contain the converted SubGeometry. + */ + private translateMaterialGroup(materialGroup:MaterialGroup, geometry:Geometry) + { + var faces:Array = materialGroup.faces; + var face:FaceData; + var numFaces:number = faces.length; + var numVerts:number; + var sub:TriangleSubGeometry; + + var vertices:Array = new Array(); + var uvs:Array = new Array(); + var normals:Array = new Array(); + var indices:Array /*uint*/ = new Array(); + + this._realIndices = []; + this._vertexIndex = 0; + + var j:number; + for (var i:number = 0; i < numFaces; ++i) { + + face = faces[i]; + numVerts = face.indexIds.length - 1; + + for (j = 1; j < numVerts; ++j) { + + this.translateVertexData(face, j, vertices, uvs, indices, normals); + this.translateVertexData(face, 0, vertices, uvs, indices, normals); + this.translateVertexData(face, j + 1, vertices, uvs, indices, normals); + } + } + if (vertices.length > 0) { + sub = new TriangleSubGeometry(true); + sub.autoDeriveNormals = normals.length? false : true; + sub.updateIndices(indices); + sub.updatePositions(vertices); + sub.updateVertexNormals(normals); + sub.updateUVs(uvs); + + geometry.addSubGeometry(sub); + } + } + + private translateVertexData(face:FaceData, vertexIndex:number, vertices:Array, uvs:Array, indices:Array /*uint*/, normals:Array) + { + var index:number; + var vertex:Vertex; + var vertexNormal:Vertex; + var uv:UV; + + if (!this._realIndices[face.indexIds[vertexIndex]]) { + + index = this._vertexIndex; + this._realIndices[face.indexIds[vertexIndex]] = ++this._vertexIndex; + vertex = this._vertices[face.vertexIndices[vertexIndex] - 1]; + vertices.push(vertex.x*this._scale, vertex.y*this._scale, vertex.z*this._scale); + + if (face.normalIndices.length > 0) { + vertexNormal = this._vertexNormals[face.normalIndices[vertexIndex] - 1]; + normals.push(vertexNormal.x, vertexNormal.y, vertexNormal.z); + } + + if (face.uvIndices.length > 0) { + + try { + uv = this._uvs[face.uvIndices[vertexIndex] - 1]; + uvs.push(uv.u, uv.v); + + } catch (e) { + + switch (vertexIndex) { + case 0: + uvs.push(0, 1); + break; + case 1: + uvs.push(.5, 0); + break; + case 2: + uvs.push(1, 1); + } + } + + } + + } else { + index = this._realIndices[face.indexIds[vertexIndex]] - 1; + } + + indices.push(index); + } + + /** + * Creates a new object group. + * @param trunk The data block containing the object tag and its parameters + */ + private createObject(trunk) + { + this._currentGroup = null; + this._currentMaterialGroup = null; + this._objects.push(this._currentObject = new ObjectGroup()); + + if (trunk) + this._currentObject.name = trunk[1]; + } + + /** + * Creates a new group. + * @param trunk The data block containing the group tag and its parameters + */ + private createGroup(trunk) + { + if (!this._currentObject) + this.createObject(null); + this._currentGroup = new Group(); + + this._currentGroup.materialID = this._activeMaterialID; + + if (trunk) + this._currentGroup.name = trunk[1]; + this._currentObject.groups.push(this._currentGroup); + + this.createMaterialGroup(null); + } + + /** + * Creates a new material group. + * @param trunk The data block containing the material tag and its parameters + */ + private createMaterialGroup(trunk) + { + this._currentMaterialGroup = new MaterialGroup(); + if (trunk) + this._currentMaterialGroup.url = trunk[1]; + this._currentGroup.materialGroups.push(this._currentMaterialGroup); + } + + /** + * Reads the next vertex coordinates. + * @param trunk The data block containing the vertex tag and its parameters + */ + private parseVertex(trunk) + { + //for the very rare cases of other delimiters/charcodes seen in some obj files + + var v1:number, v2:number , v3:number; + if (trunk.length > 4) { + var nTrunk = []; + var val:number; + + for (var i:number = 1; i < trunk.length; ++i) { + val = parseFloat(trunk[i]); + if (!isNaN(val)) + nTrunk.push(val); + } + + v1 = nTrunk[0]; + v2 = nTrunk[1]; + v3 = -nTrunk[2]; + this._vertices.push(new Vertex(v1, v2, v3)); + + } else { + v1 = parseFloat(trunk[1]); + v2 = parseFloat(trunk[2]); + v3 = -parseFloat(trunk[3]); + + this._vertices.push(new Vertex(v1, v2, v3)); + } + + } + + /** + * Reads the next uv coordinates. + * @param trunk The data block containing the uv tag and its parameters + */ + private parseUV(trunk) + { + if (trunk.length > 3) { + var nTrunk = []; + var val:number; + for (var i:number = 1; i < trunk.length; ++i) { + val = parseFloat(trunk[i]); + if (!isNaN(val)) + nTrunk.push(val); + } + this._uvs.push(new UV(nTrunk[0], 1 - nTrunk[1])); + + } else { + this._uvs.push(new UV(parseFloat(trunk[1]), 1 - parseFloat(trunk[2]))); + } + + } + + /** + * Reads the next vertex normal coordinates. + * @param trunk The data block containing the vertex normal tag and its parameters + */ + private parseVertexNormal(trunk) + { + if (trunk.length > 4) { + var nTrunk = []; + var val:number; + for (var i:number = 1; i < trunk.length; ++i) { + val = parseFloat(trunk[i]); + if (!isNaN(val)) + nTrunk.push(val); + } + this._vertexNormals.push(new Vertex(nTrunk[0], nTrunk[1], -nTrunk[2])); + + } else { + this._vertexNormals.push(new Vertex(parseFloat(trunk[1]), parseFloat(trunk[2]), -parseFloat(trunk[3]))); + } + } + + /** + * Reads the next face's indices. + * @param trunk The data block containing the face tag and its parameters + */ + private parseFace(trunk) + { + var len:number = trunk.length; + var face:FaceData = new FaceData(); + + if (!this._currentGroup) { + this.createGroup(null); + } + + var indices; + for (var i:number = 1; i < len; ++i) { + + if (trunk[i] == "") { + continue; + } + + indices = trunk[i].split("/"); + face.vertexIndices.push(this.parseIndex(parseInt(indices[0]), this._vertices.length)); + + if (indices[1] && String(indices[1]).length > 0) + face.uvIndices.push(this.parseIndex(parseInt(indices[1]), this._uvs.length)); + + if (indices[2] && String(indices[2]).length > 0) + face.normalIndices.push(this.parseIndex(parseInt(indices[2]), this._vertexNormals.length)); + + face.indexIds.push(trunk[i]); + } + + this._currentMaterialGroup.faces.push(face); + } + + /** + * This is a hack around negative face coords + */ + private parseIndex(index:number, length:number):number + { + if (index < 0) + return index + length + 1; else + return index; + } + + private parseMtl(data:string) + { + var materialDefinitions = data.split('newmtl'); + var lines; + var trunk; + var j:number; + + var basicSpecularMethod:SpecularBasicMethod; + var useSpecular:boolean; + var useColor:boolean; + var diffuseColor:number; + var color:number; + var specularColor:number; + var specular:number; + var alpha:number; + var mapkd:string; + + for (var i:number = 0; i < materialDefinitions.length; ++i) { + + + lines = (materialDefinitions[i].split('\r')).join("").split('\n'); + //lines = (materialDefinitions[i].split('\r') as Array).join("").split('\n'); + + if (lines.length == 1) + lines = materialDefinitions[i].split(String.fromCharCode(13)); + + diffuseColor = color = specularColor = 0xFFFFFF; + specular = 0; + useSpecular = false; + useColor = false; + alpha = 1; + mapkd = ""; + + for (j = 0; j < lines.length; ++j) { + + lines[j] = lines[j].replace(/\s+$/, ""); + + if (lines[j].substring(0, 1) != "#" && (j == 0 || lines[j] != "")) { + trunk = lines[j].split(" "); + + if (String(trunk[0]).charCodeAt(0) == 9 || String(trunk[0]).charCodeAt(0) == 32) + trunk[0] = trunk[0].substring(1, trunk[0].length); + + if (j == 0) { + this._lastMtlID = trunk.join(""); + this._lastMtlID = (this._lastMtlID == "")? "def000" : this._lastMtlID; + + } else { + + switch (trunk[0]) { + + case "Ka": + if (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) + color = trunk[1]*255 << 16 | trunk[2]*255 << 8 | trunk[3]*255; + break; + + case "Ks": + if (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) { + specularColor = trunk[1]*255 << 16 | trunk[2]*255 << 8 | trunk[3]*255; + useSpecular = true; + } + break; + + case "Ns": + if (trunk[1] && !isNaN(Number(trunk[1]))) + specular = Number(trunk[1])*0.001; + if (specular == 0) + useSpecular = false; + break; + + case "Kd": + if (trunk[1] && !isNaN(Number(trunk[1])) && trunk[2] && !isNaN(Number(trunk[2])) && trunk[3] && !isNaN(Number(trunk[3]))) { + diffuseColor = trunk[1]*255 << 16 | trunk[2]*255 << 8 | trunk[3]*255; + useColor = true; + } + break; + + case "tr": + case "d": + if (trunk[1] && !isNaN(Number(trunk[1]))) + alpha = Number(trunk[1]); + break; + + case "map_Kd": + mapkd = this.parseMapKdString(trunk); + mapkd = mapkd.replace(/\\/g, "/"); + } + } + } + } + + if (mapkd != "") { + + if (useSpecular) { + + basicSpecularMethod = new SpecularBasicMethod(); + basicSpecularMethod.specularColor = specularColor; + basicSpecularMethod.specular = specular; + + var specularData:SpecularData = new SpecularData(); + specularData.alpha = alpha; + specularData.basicSpecularMethod = basicSpecularMethod; + specularData.materialID = this._lastMtlID; + + if (!this._materialSpecularData) + this._materialSpecularData = new Array(); + + this._materialSpecularData.push(specularData); + + } + + this._pAddDependency(this._lastMtlID, new URLRequest(mapkd)); + + } else if (useColor && !isNaN(color)) { + + var lm:LoadedMaterial = new LoadedMaterial(); + lm.materialID = this._lastMtlID; + + if (alpha == 0) + console.log("Warning: an alpha value of 0 was found in mtl color tag (Tr or d) ref:" + this._lastMtlID + ", mesh(es) using it will be invisible!"); + + var cm:TriangleMethodMaterial; + + if (this.materialMode < 2) { + cm = new TriangleMethodMaterial(color); + + var colorMat:TriangleMethodMaterial = cm; + + colorMat.alpha = alpha; + colorMat.diffuseColor = diffuseColor; + colorMat.repeat = true; + + if (useSpecular) { + colorMat.specularColor = specularColor; + colorMat.specular = specular; + } + + } else { + cm = new TriangleMethodMaterial(color); + cm.materialMode = TriangleMaterialMode.MULTI_PASS; + + var colorMultiMat:TriangleMethodMaterial = cm; + + + colorMultiMat.diffuseColor = diffuseColor; + colorMultiMat.repeat = true; + + if (useSpecular) { + colorMultiMat.specularColor = specularColor; + colorMultiMat.specular = specular; + } + } + + lm.cm = cm; + + this._materialLoaded.push(lm); + + if (this._meshes.length > 0) + this.applyMaterial(lm); + + } + } + + this._mtlLibLoaded = true; + } + + private parseMapKdString(trunk):string + { + var url:string = ""; + var i:number; + var breakflag:boolean; + + for (i = 1; i < trunk.length;) { + switch (trunk[i]) { + case "-blendu": + case "-blendv": + case "-cc": + case "-clamp": + case "-texres": + i += 2; //Skip ahead 1 attribute + break; + case "-mm": + i += 3; //Skip ahead 2 attributes + break; + case "-o": + case "-s": + case "-t": + i += 4; //Skip ahead 3 attributes + continue; + default: + breakflag = true; + break; + } + + if (breakflag) + break; + } + + //Reconstruct URL/filename + for (i; i < trunk.length; i++) { + url += trunk[i]; + url += " "; + } + + //Remove the extraneous space and/or newline from the right side + url = url.replace(/\s+$/, ""); + + return url; + } + + private loadMtl(mtlurl:string) + { + // Add raw-data dependency to queue and load dependencies now, + // which will pause the parsing in the meantime. + this._pAddDependency('mtl', new URLRequest(mtlurl), true); + this._pPauseAndRetrieveDependencies();// + } + + private applyMaterial(lm:LoadedMaterial) + { + var decomposeID; + var mesh:Mesh; + var tm:TriangleMethodMaterial; + var j:number; + var specularData:SpecularData; + + for (var i:number = 0; i < this._meshes.length; ++i) { + mesh = this._meshes[i]; + decomposeID = mesh.material.name.split("~"); + + if (decomposeID[0] == lm.materialID) { + + if (lm.cm) { + if (mesh.material) + mesh.material = null; + mesh.material = lm.cm; + + } else if (lm.texture) { + if (this.materialMode < 2) { // if materialMode is 0 or 1, we create a SinglePass + tm = mesh.material; + + tm.texture = lm.texture; + tm.color = lm.color; + tm.alpha = lm.alpha; + tm.repeat = true; + + if (lm.specularMethod) { + + // By setting the specularMethod property to null before assigning + // the actual method instance, we avoid having the properties of + // the new method being overridden with the settings from the old + // one, which is default behavior of the setter. + tm.specularMethod = null; + tm.specularMethod = lm.specularMethod; + + } else if (this._materialSpecularData) { + + for (j = 0; j < this._materialSpecularData.length; ++j) { + specularData = this._materialSpecularData[j]; + + if (specularData.materialID == lm.materialID) { + tm.specularMethod = null; // Prevent property overwrite (see above) + tm.specularMethod = specularData.basicSpecularMethod; + tm.color = specularData.color; + tm.alpha = specularData.alpha; + break; + } + } + } + } else { //if materialMode==2 this is a MultiPassTexture + tm = mesh.material; + tm.materialMode = TriangleMaterialMode.MULTI_PASS; + + tm.texture = lm.texture; + tm.color = lm.color; + tm.repeat = true; + + if (lm.specularMethod) { + // By setting the specularMethod property to null before assigning + // the actual method instance, we avoid having the properties of + // the new method being overridden with the settings from the old + // one, which is default behavior of the setter. + tm.specularMethod = null; + tm.specularMethod = lm.specularMethod; + } else if (this._materialSpecularData) { + for (j = 0; j < this._materialSpecularData.length; ++j) { + specularData = this._materialSpecularData[j]; + + if (specularData.materialID == lm.materialID) { + tm.specularMethod = null; // Prevent property overwrite (see above) + tm.specularMethod = specularData.basicSpecularMethod; + tm.color = specularData.color; + + break; + + } + } + } + } + } + + mesh.material.name = decomposeID[1]? decomposeID[1] : decomposeID[0]; + this._meshes.splice(i, 1); + --i; + } + } + + if (lm.cm || tm) + this._pFinalizeAsset(lm.cm || tm); + } + + private applyMaterials() + { + if (this._materialLoaded.length == 0) + return; + + for (var i:number = 0; i < this._materialLoaded.length; ++i) + this.applyMaterial(this._materialLoaded[i]); + } +} + +export = OBJParser; + +class ObjectGroup +{ + public name:string; + public groups:Group[] = new Array(); +} + +class Group +{ + public name:string; + public materialID:string; + public materialGroups:MaterialGroup[] = new Array(); +} + +class MaterialGroup +{ + public url:string; + public faces:FaceData[] = new Array(); +} + +class SpecularData +{ + public materialID:string; + public basicSpecularMethod:SpecularBasicMethod; + public color:number = 0xFFFFFF; + public alpha:number = 1; +} + +class LoadedMaterial +{ + public materialID:string; + public texture:Texture2DBase; + public cm:MaterialBase; + public specularMethod:SpecularBasicMethod; + public color:number = 0xFFFFFF; + public alpha:number = 1; +} + +class FaceData +{ + public vertexIndices:Array /*uint*/ = new Array(); + public uvIndices:Array /*uint*/ = new Array(); + public normalIndices:Array /*uint*/ = new Array(); + public indexIds:string[] = new Array(); // used for real index lookups +} + +/** +* Texture coordinates value object. +*/ +class UV +{ + private _u:number; + private _v:number; + + /** + * Creates a new UV object. + * + * @param u [optional] The horizontal coordinate of the texture value. Defaults to 0. + * @param v [optional] The vertical coordinate of the texture value. Defaults to 0. + */ + constructor(u:number = 0, v:number = 0) + { + this._u = u; + this._v = v; + } + + /** + * Defines the vertical coordinate of the texture value. + */ + public get v():number + { + return this._v; + } + + public set v(value:number) + { + this._v = value; + } + + /** + * Defines the horizontal coordinate of the texture value. + */ + public get u():number + { + return this._u; + } + + public set u(value:number) + { + this._u = value; + } + + /** + * returns a new UV value Object + */ + public clone():UV + { + return new UV(this._u, this._v); + } + + /** + * returns the value object as a string for trace/debug purpose + */ + public toString():string + { + return this._u + "," + this._v; + } +} + +class Vertex +{ + private _x:number; + private _y:number; + private _z:number; + private _index:number; + + /** + * Creates a new Vertex value object. + * + * @param x [optional] The x value. Defaults to 0. + * @param y [optional] The y value. Defaults to 0. + * @param z [optional] The z value. Defaults to 0. + * @param index [optional] The index value. Defaults is NaN. + */ + constructor(x:number = 0, y:number = 0, z:number = 0, index:number = 0) + { + this._x = x; + this._y = y; + this._z = z; + this._index = index; + } + + /** + * To define/store the index of value object + * @param ind The index + */ + public set index(ind:number) + { + this._index = ind; + } + + public get index():number + { + return this._index; + } + + /** + * To define/store the x value of the value object + * @param value The x value + */ + public get x():number + { + return this._x; + } + + public set x(value:number) + { + this._x = value; + } + + /** + * To define/store the y value of the value object + * @param value The y value + */ + public get y():number + { + return this._y; + } + + public set y(value:number) + { + this._y = value; + } + + /** + * To define/store the z value of the value object + * @param value The z value + */ + public get z():number + { + return this._z; + } + + public set z(value:number) + { + this._z = value; + } + + /** + * returns a new Vertex value Object + */ + public clone():Vertex + { + return new Vertex(this._x, this._y, this._z); + } +} \ No newline at end of file diff --git a/lib/parsers/Parsers.js b/lib/parsers/Parsers.js new file mode 100755 index 000000000..7cb8d3a02 --- /dev/null +++ b/lib/parsers/Parsers.js @@ -0,0 +1,62 @@ +var AssetLoader = require("awayjs-core/lib/core/library/AssetLoader"); +var AWDParser = require("awayjs-renderergl/lib/parsers/AWDParser"); +var Max3DSParser = require("awayjs-renderergl/lib/parsers/Max3DSParser"); +var MD2Parser = require("awayjs-renderergl/lib/parsers/MD2Parser"); +var OBJParser = require("awayjs-renderergl/lib/parsers/OBJParser"); +/** + * + */ +var Parsers = (function () { + function Parsers() { + } + /** + * Short-hand function to enable all bundled parsers for auto-detection. In practice, + * this is the same as invoking enableParsers(Parsers.ALL_BUNDLED) on any of the + * loader classes SingleFileLoader, AssetLoader, AssetLibrary or Loader3D. + * + * See notes about file size in the documentation for the ALL_BUNDLED constant. + * + * @see away.parsers.Parsers.ALL_BUNDLED + */ + Parsers.enableAllBundled = function () { + AssetLoader.enableParsers(Parsers.ALL_BUNDLED); + }; + /** + * A list of all parsers that come bundled with Away3D. Use this to quickly + * enable support for all bundled parsers to the file format auto-detection + * feature, using any of the enableParsers() methods on loaders, e.g.: + * + * AssetLibrary.enableParsers(Parsers.ALL_BUNDLED); + * + * Beware however that this requires all parser classes to be included in the + * SWF file, which will add 50-100 kb to the file. When only a limited set of + * file formats are used, SWF file size can be saved by adding the parsers + * individually using AssetLibrary.enableParser() + * + * A third way is to specify a parser for each loaded file, thereby bypassing + * the auto-detection mechanisms altogether, while at the same time allowing + * any properties that are unique to that parser to be set for that load. + * + * The bundled parsers are: + * + *
    + *
  • AC3D (.ac)
    • + *
  • Away Data version 1 ASCII and version 2 binary (.awd). AWD1 BSP unsupported
    • + *
  • 3DMax (.3ds)
    • + *
  • DXF (.dxf)
    • + *
  • Quake 2 MD2 models (.md2)
    • + *
  • Doom 3 MD5 animation clips (.md5anim)
    • + *
  • Doom 3 MD5 meshes (.md5mesh)
    • + *
  • Wavefront OBJ (.obj)
    • + *
  • Collada (.dae)
    • + *
  • Images (.jpg, .png)
    • + *
+ * + * @see away.library.AssetLibrary.enableParser + */ + Parsers.ALL_BUNDLED = Array(AWDParser, Max3DSParser, MD2Parser, OBJParser); + return Parsers; +})(); +module.exports = Parsers; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/parsers/Parsers.ts b/lib/parsers/Parsers.ts new file mode 100644 index 000000000..ae5b2590d --- /dev/null +++ b/lib/parsers/Parsers.ts @@ -0,0 +1,63 @@ +import AssetLoader = require("awayjs-core/lib/core/library/AssetLoader"); + +import AWDParser = require("awayjs-renderergl/lib/parsers/AWDParser"); +import Max3DSParser = require("awayjs-renderergl/lib/parsers/Max3DSParser"); +import MD2Parser = require("awayjs-renderergl/lib/parsers/MD2Parser"); +import OBJParser = require("awayjs-renderergl/lib/parsers/OBJParser"); + +/** + * + */ +class Parsers +{ + /** + * A list of all parsers that come bundled with Away3D. Use this to quickly + * enable support for all bundled parsers to the file format auto-detection + * feature, using any of the enableParsers() methods on loaders, e.g.: + * + * AssetLibrary.enableParsers(Parsers.ALL_BUNDLED); + * + * Beware however that this requires all parser classes to be included in the + * SWF file, which will add 50-100 kb to the file. When only a limited set of + * file formats are used, SWF file size can be saved by adding the parsers + * individually using AssetLibrary.enableParser() + * + * A third way is to specify a parser for each loaded file, thereby bypassing + * the auto-detection mechanisms altogether, while at the same time allowing + * any properties that are unique to that parser to be set for that load. + * + * The bundled parsers are: + * + *
    + *
  • AC3D (.ac)
    • + *
  • Away Data version 1 ASCII and version 2 binary (.awd). AWD1 BSP unsupported
    • + *
  • 3DMax (.3ds)
    • + *
  • DXF (.dxf)
    • + *
  • Quake 2 MD2 models (.md2)
    • + *
  • Doom 3 MD5 animation clips (.md5anim)
    • + *
  • Doom 3 MD5 meshes (.md5mesh)
    • + *
  • Wavefront OBJ (.obj)
    • + *
  • Collada (.dae)
    • + *
  • Images (.jpg, .png)
    • + *
+ * + * @see away.library.AssetLibrary.enableParser + */ + public static ALL_BUNDLED:Array = Array(AWDParser, Max3DSParser, MD2Parser, OBJParser); + + /** + * Short-hand function to enable all bundled parsers for auto-detection. In practice, + * this is the same as invoking enableParsers(Parsers.ALL_BUNDLED) on any of the + * loader classes SingleFileLoader, AssetLoader, AssetLibrary or Loader3D. + * + * See notes about file size in the documentation for the ALL_BUNDLED constant. + * + * @see away.parsers.Parsers.ALL_BUNDLED + */ + public static enableAllBundled():void + { + AssetLoader.enableParsers(Parsers.ALL_BUNDLED); + } +} + +export = Parsers; \ No newline at end of file diff --git a/lib/parsers/data/AWDBlock.js b/lib/parsers/data/AWDBlock.js new file mode 100755 index 000000000..279d78b75 --- /dev/null +++ b/lib/parsers/data/AWDBlock.js @@ -0,0 +1,22 @@ +/** + * + */ +var AWDBlock = (function () { + function AWDBlock() { + } + AWDBlock.prototype.dispose = function () { + this.id = null; + this.bytes = null; + this.errorMessages = null; + this.uvsForVertexAnimation = null; + }; + AWDBlock.prototype.addError = function (errorMsg) { + if (!this.errorMessages) + this.errorMessages = new Array(); + this.errorMessages.push(errorMsg); + }; + return AWDBlock; +})(); +module.exports = AWDBlock; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/parsers/data/AWDBlock.ts b/lib/parsers/data/AWDBlock.ts new file mode 100644 index 000000000..107b252e6 --- /dev/null +++ b/lib/parsers/data/AWDBlock.ts @@ -0,0 +1,41 @@ +import ByteArray = require("awayjs-core/lib/utils/ByteArray"); + +/** + * + */ +class AWDBlock +{ + public id:number; + public name:string; + public data:any; + public len:any; + public geoID:number; + public extras:Object; + public bytes:ByteArray; + public errorMessages:Array; + public uvsForVertexAnimation:Array>; + + constructor() + { + } + + public dispose() + { + + this.id = null; + this.bytes = null; + this.errorMessages = null; + this.uvsForVertexAnimation = null; + + } + + public addError(errorMsg:string):void + { + if (!this.errorMessages) + this.errorMessages = new Array(); + + this.errorMessages.push(errorMsg); + } +} + +export = AWDBlock; \ No newline at end of file diff --git a/lib/parsers/data/AWDProperties.js b/lib/parsers/data/AWDProperties.js new file mode 100755 index 000000000..3724a3e7b --- /dev/null +++ b/lib/parsers/data/AWDProperties.js @@ -0,0 +1,19 @@ +var AWDProperties = (function () { + function AWDProperties() { + } + AWDProperties.prototype.set = function (key, value) { + this[key.toString()] = value; + }; + AWDProperties.prototype.get = function (key, fallback) { + if (this.hasOwnProperty(key.toString())) { + return this[key.toString()]; + } + else { + return fallback; + } + }; + return AWDProperties; +})(); +module.exports = AWDProperties; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9hd2Rwcm9wZXJ0aWVzLnRzIl0sIm5hbWVzIjpbIkFXRFByb3BlcnRpZXMiLCJBV0RQcm9wZXJ0aWVzLmNvbnN0cnVjdG9yIiwiQVdEUHJvcGVydGllcy5zZXQiLCJBV0RQcm9wZXJ0aWVzLmdldCJdLCJtYXBwaW5ncyI6IkFBQUEsSUFBTSxhQUFhO0lBQW5CQSxTQUFNQSxhQUFhQTtJQWVuQkMsQ0FBQ0E7SUFiT0QsMkJBQUdBLEdBQVZBLFVBQVdBLEdBQVVBLEVBQUVBLEtBQVNBO1FBRS9CRSxJQUFJQSxDQUFFQSxHQUFHQSxDQUFDQSxRQUFRQSxFQUFFQSxDQUFFQSxHQUFHQSxLQUFLQSxDQUFDQTtJQUNoQ0EsQ0FBQ0E7SUFFTUYsMkJBQUdBLEdBQVZBLFVBQVdBLEdBQVVBLEVBQUVBLFFBQVlBO1FBRWxDRyxFQUFFQSxDQUFDQSxDQUFDQSxJQUFJQSxDQUFDQSxjQUFjQSxDQUFDQSxHQUFHQSxDQUFDQSxRQUFRQSxFQUFFQSxDQUFDQSxDQUFDQSxDQUFDQSxDQUFDQTtZQUN6Q0EsTUFBTUEsQ0FBQ0EsSUFBSUEsQ0FBQ0EsR0FBR0EsQ0FBQ0EsUUFBUUEsRUFBRUEsQ0FBQ0EsQ0FBQ0E7UUFDN0JBLENBQUNBO1FBQUNBLElBQUlBLENBQUNBLENBQUNBO1lBQ1BBLE1BQU1BLENBQUNBLFFBQVFBLENBQUNBO1FBQ2pCQSxDQUFDQTtJQUNGQSxDQUFDQTtJQUNGSCxvQkFBQ0E7QUFBREEsQ0FmQSxBQWVDQSxJQUFBO0FBRUQsQUFBdUIsaUJBQWQsYUFBYSxDQUFDIiwiZmlsZSI6InBhcnNlcnMvZGF0YS9BV0RQcm9wZXJ0aWVzLmpzIiwic291cmNlUm9vdCI6Ii9Vc2Vycy9yb2JiYXRlbWFuL1dlYnN0b3JtUHJvamVjdHMvYXdheWpzLXJlbmRlcmVyZ2wvIiwic291cmNlc0NvbnRlbnQiOlsiY2xhc3MgQVdEUHJvcGVydGllc1xue1xuXHRwdWJsaWMgc2V0KGtleTpudW1iZXIsIHZhbHVlOmFueSk6dm9pZFxuXHR7XG5cdFx0dGhpc1sga2V5LnRvU3RyaW5nKCkgXSA9IHZhbHVlO1xuXHR9XG5cblx0cHVibGljIGdldChrZXk6bnVtYmVyLCBmYWxsYmFjazphbnkpOmFueVxuXHR7XG5cdFx0aWYgKHRoaXMuaGFzT3duUHJvcGVydHkoa2V5LnRvU3RyaW5nKCkpKSB7XG5cdFx0XHRyZXR1cm4gdGhpc1trZXkudG9TdHJpbmcoKV07XG5cdFx0fSBlbHNlIHtcblx0XHRcdHJldHVybiBmYWxsYmFjaztcblx0XHR9XG5cdH1cbn1cblxuZXhwb3J0ID0gQVdEUHJvcGVydGllczsiXX0= \ No newline at end of file diff --git a/lib/parsers/data/AWDProperties.ts b/lib/parsers/data/AWDProperties.ts new file mode 100644 index 000000000..214081e9b --- /dev/null +++ b/lib/parsers/data/AWDProperties.ts @@ -0,0 +1,18 @@ +class AWDProperties +{ + public set(key:number, value:any):void + { + this[ key.toString() ] = value; + } + + public get(key:number, fallback:any):any + { + if (this.hasOwnProperty(key.toString())) { + return this[key.toString()]; + } else { + return fallback; + } + } +} + +export = AWDProperties; \ No newline at end of file diff --git a/lib/parsers/data/BaseFrameData.js b/lib/parsers/data/BaseFrameData.js new file mode 100755 index 000000000..81d8cefbf --- /dev/null +++ b/lib/parsers/data/BaseFrameData.js @@ -0,0 +1,11 @@ +/** + * + */ +var BaseFrameData = (function () { + function BaseFrameData() { + } + return BaseFrameData; +})(); +module.exports = BaseFrameData; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9iYXNlZnJhbWVkYXRhLnRzIl0sIm5hbWVzIjpbIkJhc2VGcmFtZURhdGEiLCJCYXNlRnJhbWVEYXRhLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFHQSxBQUdBOztHQURHO0lBQ0csYUFBYTtJQUFuQkEsU0FBTUEsYUFBYUE7SUFXbkJDLENBQUNBO0lBQURELG9CQUFDQTtBQUFEQSxDQVhBLEFBV0NBLElBQUE7QUFFRCxBQUF1QixpQkFBZCxhQUFhLENBQUMiLCJmaWxlIjoicGFyc2Vycy9kYXRhL0Jhc2VGcmFtZURhdGEuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUXVhdGVybmlvblx0XHRcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1jb3JlL2xpYi9jb3JlL2dlb20vUXVhdGVybmlvblwiKTtcbmltcG9ydCBWZWN0b3IzRFx0XHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLWNvcmUvbGliL2NvcmUvZ2VvbS9WZWN0b3IzRFwiKTtcblxuLyoqXG4gKiBcbiAqL1xuY2xhc3MgQmFzZUZyYW1lRGF0YVxue1xuXHQvKipcblx0ICpcblx0ICovXG5cdHB1YmxpYyBwb3NpdGlvbjpWZWN0b3IzRDtcblxuXHQvKipcblx0ICpcblx0ICovXG5cdHB1YmxpYyBvcmllbnRhdGlvbjpRdWF0ZXJuaW9uO1xufVxuXG5leHBvcnQgPSBCYXNlRnJhbWVEYXRhOyJdfQ== \ No newline at end of file diff --git a/lib/parsers/data/BaseFrameData.ts b/lib/parsers/data/BaseFrameData.ts new file mode 100644 index 000000000..7076ace64 --- /dev/null +++ b/lib/parsers/data/BaseFrameData.ts @@ -0,0 +1,20 @@ +import Quaternion = require("awayjs-core/lib/core/geom/Quaternion"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +/** + * + */ +class BaseFrameData +{ + /** + * + */ + public position:Vector3D; + + /** + * + */ + public orientation:Quaternion; +} + +export = BaseFrameData; \ No newline at end of file diff --git a/lib/parsers/data/BitFlags.js b/lib/parsers/data/BitFlags.js new file mode 100755 index 000000000..2177d07af --- /dev/null +++ b/lib/parsers/data/BitFlags.js @@ -0,0 +1,30 @@ +/** + * + */ +var BitFlags = (function () { + function BitFlags() { + } + BitFlags.test = function (flags, testFlag) { + return (flags & testFlag) == testFlag; + }; + BitFlags.FLAG1 = 1; + BitFlags.FLAG2 = 2; + BitFlags.FLAG3 = 4; + BitFlags.FLAG4 = 8; + BitFlags.FLAG5 = 16; + BitFlags.FLAG6 = 32; + BitFlags.FLAG7 = 64; + BitFlags.FLAG8 = 128; + BitFlags.FLAG9 = 256; + BitFlags.FLAG10 = 512; + BitFlags.FLAG11 = 1024; + BitFlags.FLAG12 = 2048; + BitFlags.FLAG13 = 4096; + BitFlags.FLAG14 = 8192; + BitFlags.FLAG15 = 16384; + BitFlags.FLAG16 = 32768; + return BitFlags; +})(); +module.exports = BitFlags; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/parsers/data/BitFlags.ts b/lib/parsers/data/BitFlags.ts new file mode 100644 index 000000000..968468dbb --- /dev/null +++ b/lib/parsers/data/BitFlags.ts @@ -0,0 +1,29 @@ +/** + * + */ +class BitFlags +{ + public static FLAG1:number = 1; + public static FLAG2:number = 2; + public static FLAG3:number = 4; + public static FLAG4:number = 8; + public static FLAG5:number = 16; + public static FLAG6:number = 32; + public static FLAG7:number = 64; + public static FLAG8:number = 128; + public static FLAG9:number = 256; + public static FLAG10:number = 512; + public static FLAG11:number = 1024; + public static FLAG12:number = 2048; + public static FLAG13:number = 4096; + public static FLAG14:number = 8192; + public static FLAG15:number = 16384; + public static FLAG16:number = 32768; + + public static test(flags:number, testFlag:number):boolean + { + return (flags & testFlag) == testFlag; + } +} + +export = BitFlags; \ No newline at end of file diff --git a/lib/parsers/data/BoundsData.js b/lib/parsers/data/BoundsData.js new file mode 100755 index 000000000..46ac6b1e4 --- /dev/null +++ b/lib/parsers/data/BoundsData.js @@ -0,0 +1,11 @@ +/** + * + */ +var BoundsData = (function () { + function BoundsData() { + } + return BoundsData; +})(); +module.exports = BoundsData; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9ib3VuZHNkYXRhLnRzIl0sIm5hbWVzIjpbIkJvdW5kc0RhdGEiLCJCb3VuZHNEYXRhLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFFQSxBQUdBOztHQURHO0lBQ0csVUFBVTtJQUFoQkEsU0FBTUEsVUFBVUE7SUFXaEJDLENBQUNBO0lBQURELGlCQUFDQTtBQUFEQSxDQVhBLEFBV0NBLElBQUE7QUFFRCxBQUFvQixpQkFBWCxVQUFVLENBQUMiLCJmaWxlIjoicGFyc2Vycy9kYXRhL0JvdW5kc0RhdGEuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgVmVjdG9yM0RcdFx0XHRcdFx0XHRcdD0gcmVxdWlyZShcImF3YXlqcy1jb3JlL2xpYi9jb3JlL2dlb20vVmVjdG9yM0RcIik7XG5cbi8qKlxuICogXG4gKi9cbmNsYXNzIEJvdW5kc0RhdGFcbntcblx0LyoqXG5cdCAqXG5cdCAqL1xuXHRwdWJsaWMgbWluOlZlY3RvcjNEO1xuXG5cdC8qKlxuXHQgKlxuXHQgKi9cblx0cHVibGljIG1heDpWZWN0b3IzRDtcbn1cblxuZXhwb3J0ID0gQm91bmRzRGF0YTsiXX0= \ No newline at end of file diff --git a/lib/parsers/data/BoundsData.ts b/lib/parsers/data/BoundsData.ts new file mode 100644 index 000000000..92dc77501 --- /dev/null +++ b/lib/parsers/data/BoundsData.ts @@ -0,0 +1,19 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +/** + * + */ +class BoundsData +{ + /** + * + */ + public min:Vector3D; + + /** + * + */ + public max:Vector3D; +} + +export = BoundsData; \ No newline at end of file diff --git a/lib/parsers/data/FaceVO.js b/lib/parsers/data/FaceVO.js new file mode 100755 index 000000000..e98944040 --- /dev/null +++ b/lib/parsers/data/FaceVO.js @@ -0,0 +1,11 @@ +/** + * + */ +var FaceVO = (function () { + function FaceVO() { + } + return FaceVO; +})(); +module.exports = FaceVO; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9mYWNldm8udHMiXSwibmFtZXMiOlsiRmFjZVZPIiwiRmFjZVZPLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFBQSxBQUdBOztHQURHO0lBQ0csTUFBTTtJQUFaQSxTQUFNQSxNQUFNQTtJQU1aQyxDQUFDQTtJQUFERCxhQUFDQTtBQUFEQSxDQU5BLEFBTUNBLElBQUE7QUFFRCxBQUFnQixpQkFBUCxNQUFNLENBQUMiLCJmaWxlIjoicGFyc2Vycy9kYXRhL0ZhY2VWTy5qcyIsInNvdXJjZVJvb3QiOiIvVXNlcnMvcm9iYmF0ZW1hbi9XZWJzdG9ybVByb2plY3RzL2F3YXlqcy1yZW5kZXJlcmdsLyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICpcbiAqL1xuY2xhc3MgRmFjZVZPXG57XG5cdHB1YmxpYyBhOm51bWJlciAvKmludCovO1xuXHRwdWJsaWMgYjpudW1iZXIgLyppbnQqLztcblx0cHVibGljIGM6bnVtYmVyIC8qaW50Ki87XG5cdHB1YmxpYyBzbW9vdGhHcm91cDpudW1iZXIgLyppbnQqLztcbn1cblxuZXhwb3J0ID0gRmFjZVZPOyJdfQ== \ No newline at end of file diff --git a/lib/parsers/data/FaceVO.ts b/lib/parsers/data/FaceVO.ts new file mode 100644 index 000000000..3474416d8 --- /dev/null +++ b/lib/parsers/data/FaceVO.ts @@ -0,0 +1,12 @@ +/** + * + */ +class FaceVO +{ + public a:number /*int*/; + public b:number /*int*/; + public c:number /*int*/; + public smoothGroup:number /*int*/; +} + +export = FaceVO; \ No newline at end of file diff --git a/lib/parsers/data/FrameData.js b/lib/parsers/data/FrameData.js new file mode 100755 index 000000000..83ede906b --- /dev/null +++ b/lib/parsers/data/FrameData.js @@ -0,0 +1,11 @@ +/** + * + */ +var FrameData = (function () { + function FrameData() { + } + return FrameData; +})(); +module.exports = FrameData; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9mcmFtZWRhdGEudHMiXSwibmFtZXMiOlsiRnJhbWVEYXRhIiwiRnJhbWVEYXRhLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFBQSxBQUdBOztHQURHO0lBQ0csU0FBUztJQUFmQSxTQUFNQSxTQUFTQTtJQVdmQyxDQUFDQTtJQUFERCxnQkFBQ0E7QUFBREEsQ0FYQSxBQVdDQSxJQUFBO0FBRUQsQUFBbUIsaUJBQVYsU0FBUyxDQUFDIiwiZmlsZSI6InBhcnNlcnMvZGF0YS9GcmFtZURhdGEuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqXG4gKi9cbmNsYXNzIEZyYW1lRGF0YVxue1xuXHQvKipcblx0ICpcblx0ICovXG5cdHB1YmxpYyBpbmRleDpudW1iZXIgLyppbnQqLztcblxuXHQvKipcblx0ICpcblx0ICovXG5cdHB1YmxpYyBjb21wb25lbnRzOkFycmF5PG51bWJlcj47XG59XG5cbmV4cG9ydCA9IEZyYW1lRGF0YTsiXX0= \ No newline at end of file diff --git a/lib/parsers/data/FrameData.ts b/lib/parsers/data/FrameData.ts new file mode 100644 index 000000000..9ca2e1328 --- /dev/null +++ b/lib/parsers/data/FrameData.ts @@ -0,0 +1,17 @@ +/** + * + */ +class FrameData +{ + /** + * + */ + public index:number /*int*/; + + /** + * + */ + public components:Array; +} + +export = FrameData; \ No newline at end of file diff --git a/lib/parsers/data/HierarchyData.js b/lib/parsers/data/HierarchyData.js new file mode 100755 index 000000000..35dfd619e --- /dev/null +++ b/lib/parsers/data/HierarchyData.js @@ -0,0 +1,11 @@ +/** + * + */ +var HierarchyData = (function () { + function HierarchyData() { + } + return HierarchyData; +})(); +module.exports = HierarchyData; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9oaWVyYXJjaHlkYXRhLnRzIl0sIm5hbWVzIjpbIkhpZXJhcmNoeURhdGEiLCJIaWVyYXJjaHlEYXRhLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFBQSxBQUdBOztHQURHO0lBQ0csYUFBYTtJQUFuQkEsU0FBTUEsYUFBYUE7SUFxQm5CQyxDQUFDQTtJQUFERCxvQkFBQ0E7QUFBREEsQ0FyQkEsQUFxQkNBLElBQUE7QUFFRCxBQUF1QixpQkFBZCxhQUFhLENBQUMiLCJmaWxlIjoicGFyc2Vycy9kYXRhL0hpZXJhcmNoeURhdGEuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqXG4gKi9cbmNsYXNzIEhpZXJhcmNoeURhdGFcbntcblx0LyoqXG5cdCAqXG5cdCAqL1xuXHRwdWJsaWMgbmFtZTpzdHJpbmc7XG5cblx0LyoqXG5cdCAqXG5cdCAqL1xuXHRwdWJsaWMgcGFyZW50SW5kZXg6bnVtYmVyIC8qaW50Ki87XG5cblx0LyoqXG5cdCAqXG5cdCAqL1xuXHRwdWJsaWMgZmxhZ3M6bnVtYmVyIC8qaW50Ki87XG5cblx0LyoqXG5cdCAqXG5cdCAqL1xuXHRwdWJsaWMgc3RhcnRJbmRleDpudW1iZXIgLyppbnQqLztcbn1cblxuZXhwb3J0ID0gSGllcmFyY2h5RGF0YTsiXX0= \ No newline at end of file diff --git a/lib/parsers/data/HierarchyData.ts b/lib/parsers/data/HierarchyData.ts new file mode 100644 index 000000000..ed06ddce7 --- /dev/null +++ b/lib/parsers/data/HierarchyData.ts @@ -0,0 +1,27 @@ +/** + * + */ +class HierarchyData +{ + /** + * + */ + public name:string; + + /** + * + */ + public parentIndex:number /*int*/; + + /** + * + */ + public flags:number /*int*/; + + /** + * + */ + public startIndex:number /*int*/; +} + +export = HierarchyData; \ No newline at end of file diff --git a/lib/parsers/data/MaterialVO.js b/lib/parsers/data/MaterialVO.js new file mode 100755 index 000000000..d66542769 --- /dev/null +++ b/lib/parsers/data/MaterialVO.js @@ -0,0 +1,11 @@ +/** + * + */ +var MaterialVO = (function () { + function MaterialVO() { + } + return MaterialVO; +})(); +module.exports = MaterialVO; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9tYXRlcmlhbHZvLnRzIl0sIm5hbWVzIjpbIk1hdGVyaWFsVk8iLCJNYXRlcmlhbFZPLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFJQSxBQUdBOztHQURHO0lBQ0csVUFBVTtJQUFoQkEsU0FBTUEsVUFBVUE7SUFVaEJDLENBQUNBO0lBQURELGlCQUFDQTtBQUFEQSxDQVZBLEFBVUNBLElBQUE7QUFFRCxBQUFvQixpQkFBWCxVQUFVLENBQUMiLCJmaWxlIjoicGFyc2Vycy9kYXRhL01hdGVyaWFsVk8uanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTWF0ZXJpYWxCYXNlXHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLWNvcmUvbGliL21hdGVyaWFscy9NYXRlcmlhbEJhc2VcIik7XG5cbmltcG9ydCBUZXh0dXJlVk9cdFx0XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtcmVuZGVyZXJnbC9saWIvcGFyc2Vycy9kYXRhL1RleHR1cmVWT1wiKTtcblxuLyoqXG4gKlxuICovXG5jbGFzcyBNYXRlcmlhbFZPXG57XG5cdHB1YmxpYyBuYW1lOnN0cmluZztcblx0cHVibGljIGFtYmllbnRDb2xvcjpudW1iZXIgLyppbnQqLztcblx0cHVibGljIGRpZmZ1c2VDb2xvcjpudW1iZXIgLyppbnQqLztcblx0cHVibGljIHNwZWN1bGFyQ29sb3I6bnVtYmVyIC8qaW50Ki87XG5cdHB1YmxpYyB0d29TaWRlZDpib29sZWFuO1xuXHRwdWJsaWMgY29sb3JNYXA6VGV4dHVyZVZPO1xuXHRwdWJsaWMgc3BlY3VsYXJNYXA6VGV4dHVyZVZPO1xuXHRwdWJsaWMgbWF0ZXJpYWw6TWF0ZXJpYWxCYXNlO1xufVxuXG5leHBvcnQgPSBNYXRlcmlhbFZPOyJdfQ== \ No newline at end of file diff --git a/lib/parsers/data/MaterialVO.ts b/lib/parsers/data/MaterialVO.ts new file mode 100644 index 000000000..dd7b0592a --- /dev/null +++ b/lib/parsers/data/MaterialVO.ts @@ -0,0 +1,20 @@ +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); + +import TextureVO = require("awayjs-renderergl/lib/parsers/data/TextureVO"); + +/** + * + */ +class MaterialVO +{ + public name:string; + public ambientColor:number /*int*/; + public diffuseColor:number /*int*/; + public specularColor:number /*int*/; + public twoSided:boolean; + public colorMap:TextureVO; + public specularMap:TextureVO; + public material:MaterialBase; +} + +export = MaterialVO; \ No newline at end of file diff --git a/lib/parsers/data/ObjectVO.js b/lib/parsers/data/ObjectVO.js new file mode 100755 index 000000000..9f925e3e5 --- /dev/null +++ b/lib/parsers/data/ObjectVO.js @@ -0,0 +1,8 @@ +var ObjectVO = (function () { + function ObjectVO() { + } + return ObjectVO; +})(); +module.exports = ObjectVO; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS9vYmplY3R2by50cyJdLCJuYW1lcyI6WyJPYmplY3RWTyIsIk9iamVjdFZPLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFNLFFBQVE7SUFBZEEsU0FBTUEsUUFBUUE7SUFjZEMsQ0FBQ0E7SUFBREQsZUFBQ0E7QUFBREEsQ0FkQSxBQWNDQSxJQUFBO0FBRUQsQUFBa0IsaUJBQVQsUUFBUSxDQUFDIiwiZmlsZSI6InBhcnNlcnMvZGF0YS9PYmplY3RWTy5qcyIsInNvdXJjZVJvb3QiOiIvVXNlcnMvcm9iYmF0ZW1hbi9XZWJzdG9ybVByb2plY3RzL2F3YXlqcy1yZW5kZXJlcmdsLyIsInNvdXJjZXNDb250ZW50IjpbImNsYXNzIE9iamVjdFZPXG57XG5cdHB1YmxpYyBuYW1lOnN0cmluZztcblx0cHVibGljIHR5cGU6c3RyaW5nO1xuXHRwdWJsaWMgcGl2b3RYOm51bWJlcjtcblx0cHVibGljIHBpdm90WTpudW1iZXI7XG5cdHB1YmxpYyBwaXZvdFo6bnVtYmVyO1xuXHRwdWJsaWMgdHJhbnNmb3JtOkFycmF5PG51bWJlcj47XG5cdHB1YmxpYyB2ZXJ0czpBcnJheTxudW1iZXI+O1xuXHRwdWJsaWMgaW5kaWNlczpBcnJheTxudW1iZXI+IC8qaW50Ki87XG5cdHB1YmxpYyB1dnM6QXJyYXk8bnVtYmVyPjtcblx0cHVibGljIG1hdGVyaWFsRmFjZXM6T2JqZWN0O1xuXHRwdWJsaWMgbWF0ZXJpYWxzOkFycmF5PHN0cmluZz47XG5cdHB1YmxpYyBzbW9vdGhpbmdHcm91cHM6QXJyYXk8bnVtYmVyPiAvKmludCovO1xufVxuXG5leHBvcnQgPSBPYmplY3RWTzsiXX0= \ No newline at end of file diff --git a/lib/parsers/data/ObjectVO.ts b/lib/parsers/data/ObjectVO.ts new file mode 100644 index 000000000..11a211d5a --- /dev/null +++ b/lib/parsers/data/ObjectVO.ts @@ -0,0 +1,17 @@ +class ObjectVO +{ + public name:string; + public type:string; + public pivotX:number; + public pivotY:number; + public pivotZ:number; + public transform:Array; + public verts:Array; + public indices:Array /*int*/; + public uvs:Array; + public materialFaces:Object; + public materials:Array; + public smoothingGroups:Array /*int*/; +} + +export = ObjectVO; \ No newline at end of file diff --git a/lib/parsers/data/TextureVO.js b/lib/parsers/data/TextureVO.js new file mode 100755 index 000000000..ee24c4af4 --- /dev/null +++ b/lib/parsers/data/TextureVO.js @@ -0,0 +1,11 @@ +/** + * + */ +var TextureVO = (function () { + function TextureVO() { + } + return TextureVO; +})(); +module.exports = TextureVO; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS90ZXh0dXJldm8udHMiXSwibmFtZXMiOlsiVGV4dHVyZVZPIiwiVGV4dHVyZVZPLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFFQSxBQUdBOztHQURHO0lBQ0csU0FBUztJQUFmQSxTQUFNQSxTQUFTQTtJQUlmQyxDQUFDQTtJQUFERCxnQkFBQ0E7QUFBREEsQ0FKQSxBQUlDQSxJQUFBO0FBRUQsQUFBbUIsaUJBQVYsU0FBUyxDQUFDIiwiZmlsZSI6InBhcnNlcnMvZGF0YS9UZXh0dXJlVk8uanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL3JvYmJhdGVtYW4vV2Vic3Rvcm1Qcm9qZWN0cy9hd2F5anMtcmVuZGVyZXJnbC8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgVGV4dHVyZTJEQmFzZVx0XHRcdFx0XHQ9IHJlcXVpcmUoXCJhd2F5anMtY29yZS9saWIvdGV4dHVyZXMvVGV4dHVyZTJEQmFzZVwiKTtcblxuLyoqXG4gKlxuICovXG5jbGFzcyBUZXh0dXJlVk9cbntcblx0cHVibGljIHVybDpzdHJpbmc7XG5cdHB1YmxpYyB0ZXh0dXJlOlRleHR1cmUyREJhc2U7XG59XG5cbmV4cG9ydCA9IFRleHR1cmVWTzsiXX0= \ No newline at end of file diff --git a/lib/parsers/data/TextureVO.ts b/lib/parsers/data/TextureVO.ts new file mode 100644 index 000000000..7a60d0e4c --- /dev/null +++ b/lib/parsers/data/TextureVO.ts @@ -0,0 +1,12 @@ +import Texture2DBase = require("awayjs-core/lib/textures/Texture2DBase"); + +/** + * + */ +class TextureVO +{ + public url:string; + public texture:Texture2DBase; +} + +export = TextureVO; \ No newline at end of file diff --git a/lib/parsers/data/VertexVO.js b/lib/parsers/data/VertexVO.js new file mode 100755 index 000000000..87165a1de --- /dev/null +++ b/lib/parsers/data/VertexVO.js @@ -0,0 +1,8 @@ +var VertexVO = (function () { + function VertexVO() { + } + return VertexVO; +})(); +module.exports = VertexVO; + +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhcnNlcnMvZGF0YS92ZXJ0ZXh2by50cyJdLCJuYW1lcyI6WyJWZXJ0ZXhWTyIsIlZlcnRleFZPLmNvbnN0cnVjdG9yIl0sIm1hcHBpbmdzIjoiQUFFQSxJQUFNLFFBQVE7SUFBZEEsU0FBTUEsUUFBUUE7SUFTZEMsQ0FBQ0E7SUFBREQsZUFBQ0E7QUFBREEsQ0FUQSxBQVNDQSxJQUFBO0FBRUQsQUFBa0IsaUJBQVQsUUFBUSxDQUFDIiwiZmlsZSI6InBhcnNlcnMvZGF0YS9WZXJ0ZXhWTy5qcyIsInNvdXJjZVJvb3QiOiIvVXNlcnMvcm9iYmF0ZW1hbi9XZWJzdG9ybVByb2plY3RzL2F3YXlqcy1yZW5kZXJlcmdsLyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBWZWN0b3IzRFx0XHRcdFx0XHRcdFx0PSByZXF1aXJlKFwiYXdheWpzLWNvcmUvbGliL2NvcmUvZ2VvbS9WZWN0b3IzRFwiKTtcblxuY2xhc3MgVmVydGV4Vk9cbntcblx0cHVibGljIHg6bnVtYmVyO1xuXHRwdWJsaWMgeTpudW1iZXI7XG5cdHB1YmxpYyB6Om51bWJlcjtcblx0cHVibGljIHU6bnVtYmVyO1xuXHRwdWJsaWMgdjpudW1iZXI7XG5cdHB1YmxpYyBub3JtYWw6VmVjdG9yM0Q7XG5cdHB1YmxpYyB0YW5nZW50OlZlY3RvcjNEO1xufVxuXG5leHBvcnQgPSBWZXJ0ZXhWTzsiXX0= \ No newline at end of file diff --git a/lib/parsers/data/VertexVO.ts b/lib/parsers/data/VertexVO.ts new file mode 100644 index 000000000..5ee4473e2 --- /dev/null +++ b/lib/parsers/data/VertexVO.ts @@ -0,0 +1,14 @@ +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +class VertexVO +{ + public x:number; + public y:number; + public z:number; + public u:number; + public v:number; + public normal:Vector3D; + public tangent:Vector3D; +} + +export = VertexVO; \ No newline at end of file diff --git a/lib/tools/commands/Merge.js b/lib/tools/commands/Merge.js new file mode 100755 index 000000000..c69224cdb --- /dev/null +++ b/lib/tools/commands/Merge.js @@ -0,0 +1,293 @@ +var Geometry = require("awayjs-core/lib/core/base/Geometry"); +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Matrix3DUtils = require("awayjs-core/lib/core/geom/Matrix3DUtils"); +var Mesh = require("awayjs-core/lib/entities/Mesh"); +/** + * Class Merge merges two or more static meshes into one.Merge + */ +var Merge = (function () { + /** + * @param keepMaterial [optional] Determines if the merged object uses the recevier mesh material information or keeps its source material(s). Defaults to false. + * If false and receiver object has multiple materials, the last material found in receiver submeshes is applied to the merged submesh(es). + * @param disposeSources [optional] Determines if the mesh and geometry source(s) used for the merging are disposed. Defaults to false. + * If true, only receiver geometry and resulting mesh are kept in memory. + * @param objectSpace [optional] Determines if source mesh(es) is/are merged using objectSpace or worldspace. Defaults to false. + */ + function Merge(keepMaterial, disposeSources, objectSpace) { + if (keepMaterial === void 0) { keepMaterial = false; } + if (disposeSources === void 0) { disposeSources = false; } + if (objectSpace === void 0) { objectSpace = false; } + this._keepMaterial = keepMaterial; + this._disposeSources = disposeSources; + this._objectSpace = objectSpace; + } + Object.defineProperty(Merge.prototype, "disposeSources", { + get: function () { + return this._disposeSources; + }, + /** + * Determines if the mesh and geometry source(s) used for the merging are disposed. Defaults to false. + */ + set: function (b) { + this._disposeSources = b; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Merge.prototype, "keepMaterial", { + get: function () { + return this._keepMaterial; + }, + /** + * Determines if the material source(s) used for the merging are disposed. Defaults to false. + */ + set: function (b) { + this._keepMaterial = b; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Merge.prototype, "objectSpace", { + get: function () { + return this._objectSpace; + }, + /** + * Determines if source mesh(es) is/are merged using objectSpace or worldspace. Defaults to false. + */ + set: function (b) { + this._objectSpace = b; + }, + enumerable: true, + configurable: true + }); + /** + * Merges all the children of a container into a single Mesh. If no Mesh object is found, method returns the receiver without modification. + * + * @param receiver The Mesh to receive the merged contents of the container. + * @param objectContainer The DisplayObjectContainer holding the meshes to be mergd. + * + * @return The merged Mesh instance. + */ + Merge.prototype.applyToContainer = function (receiver, objectContainer) { + this.reset(); + //collect container meshes + this.parseContainer(receiver, objectContainer); + //collect receiver + this.collect(receiver, false); + //merge to receiver + this.merge(receiver, this._disposeSources); + }; + /** + * Merges all the meshes found in the Array<Mesh> into a single Mesh. + * + * @param receiver The Mesh to receive the merged contents of the meshes. + * @param meshes A series of Meshes to be merged with the reciever mesh. + */ + Merge.prototype.applyToMeshes = function (receiver, meshes) { + this.reset(); + if (!meshes.length) + return; + for (var i = 0; i < meshes.length; i++) + if (meshes[i] != receiver) + this.collect(meshes[i], this._disposeSources); + //collect receiver + this.collect(receiver, false); + //merge to receiver + this.merge(receiver, this._disposeSources); + }; + /** + * Merges 2 meshes into one. It is recommand to use apply when 2 meshes are to be merged. If more need to be merged, use either applyToMeshes or applyToContainer methods. + * + * @param receiver The Mesh to receive the merged contents of both meshes. + * @param mesh The Mesh to be merged with the receiver mesh + */ + Merge.prototype.apply = function (receiver, mesh) { + this.reset(); + //collect mesh + this.collect(mesh, this._disposeSources); + //collect receiver + this.collect(receiver, false); + //merge to receiver + this.merge(receiver, this._disposeSources); + }; + Merge.prototype.reset = function () { + this._toDispose = new Array(); + this._geomVOs = new Array(); + }; + Merge.prototype.merge = function (destMesh, dispose) { + var i /*uint*/; + var subIdx /*uint*/; + var oldGeom; + var destGeom; + var useSubMaterials; + oldGeom = destMesh.geometry; + destGeom = destMesh.geometry = new Geometry(); + subIdx = destMesh.subMeshes.length; + // Only apply materials directly to sub-meshes if necessary, + // i.e. if there is more than one material available. + useSubMaterials = (this._geomVOs.length > 1); + for (i = 0; i < this._geomVOs.length; i++) { + var s /*uint*/; + var data; + var sub = new TriangleSubGeometry(true); + sub.autoDeriveNormals = false; + sub.autoDeriveTangents = false; + data = this._geomVOs[i]; + sub.updateIndices(data.indices); + sub.updatePositions(data.vertices); + sub.updateVertexNormals(data.normals); + sub.updateVertexTangents(data.tangents); + sub.updateUVs(data.uvs); + destGeom.addSubGeometry(sub); + if (this._keepMaterial && useSubMaterials) + destMesh.subMeshes[subIdx].material = data.material; + } + if (this._keepMaterial && !useSubMaterials && this._geomVOs.length) + destMesh.material = this._geomVOs[0].material; + if (dispose) { + var m; + var len = this._toDispose.length; + for (var i; i < len; i++) { + m = this._toDispose[i]; + m.geometry.dispose(); + m.dispose(); + } + //dispose of the original receiver geometry + oldGeom.dispose(); + } + this._toDispose = null; + }; + Merge.prototype.collect = function (mesh, dispose) { + if (mesh.geometry) { + var subIdx /*uint*/; + var subGeometries = mesh.geometry.subGeometries; + var calc /*uint*/; + for (subIdx = 0; subIdx < subGeometries.length; subIdx++) { + var i /*uint*/; + var len /*uint*/; + var iIdx /*uint*/, vIdx /*uint*/, nIdx /*uint*/, tIdx /*uint*/, uIdx /*uint*/; + var indexOffset /*uint*/; + var subGeom; + var vo; + var vertices; + var normals; + var tangents; + var pd, nd, td, ud; + subGeom = subGeometries[subIdx]; + pd = subGeom.positions; + nd = subGeom.vertexNormals; + td = subGeom.vertexTangents; + ud = subGeom.uvs; + // Get (or create) a VO for this material + vo = this.getSubGeomData(mesh.subMeshes[subIdx].material || mesh.material); + // Vertices and normals are copied to temporary vectors, to be transformed + // before concatenated onto those of the data. This is unnecessary if no + // transformation will be performed, i.e. for object space merging. + vertices = (this._objectSpace) ? vo.vertices : new Array(); + normals = (this._objectSpace) ? vo.normals : new Array(); + tangents = (this._objectSpace) ? vo.tangents : new Array(); + // Copy over vertex attributes + vIdx = vertices.length; + nIdx = normals.length; + tIdx = tangents.length; + uIdx = vo.uvs.length; + len = subGeom.numVertices; + for (i = 0; i < len; i++) { + calc = i * 3; + // Position + vertices[vIdx++] = pd[calc]; + vertices[vIdx++] = pd[calc + 1]; + vertices[vIdx++] = pd[calc + 2]; + // Normal + normals[nIdx++] = nd[calc]; + normals[nIdx++] = nd[calc + 1]; + normals[nIdx++] = nd[calc + 2]; + // Tangent + tangents[tIdx++] = td[calc]; + tangents[tIdx++] = td[calc + 1]; + tangents[tIdx++] = td[calc + 2]; + // UV + vo.uvs[uIdx++] = ud[i * 2]; + vo.uvs[uIdx++] = ud[i * 2 + 1]; + } + // Copy over triangle indices + indexOffset = (!this._objectSpace) ? vo.vertices.length / 3 : 0; + iIdx = vo.indices.length; + len = subGeom.numTriangles; + for (i = 0; i < len; i++) { + calc = i * 3; + vo.indices[iIdx++] = subGeom.indices[calc] + indexOffset; + vo.indices[iIdx++] = subGeom.indices[calc + 1] + indexOffset; + vo.indices[iIdx++] = subGeom.indices[calc + 2] + indexOffset; + } + if (!this._objectSpace) { + mesh.sceneTransform.transformVectors(vertices, vertices); + Matrix3DUtils.deltaTransformVectors(mesh.sceneTransform, normals, normals); + Matrix3DUtils.deltaTransformVectors(mesh.sceneTransform, tangents, tangents); + // Copy vertex data from temporary (transformed) vectors + vIdx = vo.vertices.length; + nIdx = vo.normals.length; + tIdx = vo.tangents.length; + len = vertices.length; + for (i = 0; i < len; i++) { + vo.vertices[vIdx++] = vertices[i]; + vo.normals[nIdx++] = normals[i]; + vo.tangents[tIdx++] = tangents[i]; + } + } + } + if (dispose) + this._toDispose.push(mesh); + } + }; + Merge.prototype.getSubGeomData = function (material) { + var data; + if (this._keepMaterial) { + var i /*uint*/; + var len /*uint*/; + len = this._geomVOs.length; + for (i = 0; i < len; i++) { + if (this._geomVOs[i].material == material) { + data = this._geomVOs[i]; + break; + } + } + } + else if (this._geomVOs.length) { + // If materials are not to be kept, all data can be + // put into a single VO, so return that one. + data = this._geomVOs[0]; + } + // No data (for this material) found, create new. + if (!data) { + data = new GeometryVO(); + data.vertices = new Array(); + data.normals = new Array(); + data.tangents = new Array(); + data.uvs = new Array(); + data.indices = new Array(); + data.material = material; + this._geomVOs.push(data); + } + return data; + }; + Merge.prototype.parseContainer = function (receiver, object) { + var child; + var i /*uint*/; + if (object instanceof Mesh && object != receiver) + this.collect(object, this._disposeSources); + for (i = 0; i < object.numChildren; ++i) { + child = object.getChildAt(i); + this.parseContainer(receiver, child); + } + }; + return Merge; +})(); +var GeometryVO = (function () { + function GeometryVO() { + } + return GeometryVO; +})(); +module.exports = Merge; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["tools/commands/merge.ts"],"names":["Merge","Merge.constructor","Merge.disposeSources","Merge.keepMaterial","Merge.objectSpace","Merge.applyToContainer","Merge.applyToMeshes","Merge.apply","Merge.reset","Merge.merge","Merge.collect","Merge.getSubGeomData","Merge.parseContainer","GeometryVO","GeometryVO.constructor"],"mappings":"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","file":"tools/commands/Merge.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObjectContainer\t\t\t= require(\"awayjs-core/lib/containers/DisplayObjectContainer\");\nimport Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Matrix3DUtils\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3DUtils\");\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\n\n/**\n *  Class Merge merges two or more static meshes into one.<code>Merge</code>\n */\nclass Merge\n{\n\n\t//private const LIMIT:uint = 196605;\n\tprivate _objectSpace:boolean;\n\tprivate _keepMaterial:boolean;\n\tprivate _disposeSources:boolean;\n\tprivate _geomVOs:Array<GeometryVO>;\n\tprivate _toDispose:Array<Mesh>;\n\n\t/**\n\t * @param    keepMaterial    [optional]    Determines if the merged object uses the recevier mesh material information or keeps its source material(s). Defaults to false.\n\t * If false and receiver object has multiple materials, the last material found in receiver submeshes is applied to the merged submesh(es).\n\t * @param    disposeSources  [optional]    Determines if the mesh and geometry source(s) used for the merging are disposed. Defaults to false.\n\t * If true, only receiver geometry and resulting mesh are kept in  memory.\n\t * @param    objectSpace     [optional]    Determines if source mesh(es) is/are merged using objectSpace or worldspace. Defaults to false.\n\t */\n\tconstructor(keepMaterial:boolean = false, disposeSources:boolean = false, objectSpace:boolean = false)\n\t{\n\t\tthis._keepMaterial = keepMaterial;\n\t\tthis._disposeSources = disposeSources;\n\t\tthis._objectSpace = objectSpace;\n\t}\n\n\t/**\n\t * Determines if the mesh and geometry source(s) used for the merging are disposed. Defaults to false.\n\t */\n\tpublic set disposeSources(b:boolean)\n\t{\n\t\tthis._disposeSources = b;\n\t}\n\n\tpublic get disposeSources():boolean\n\t{\n\t\treturn this._disposeSources;\n\t}\n\n\t/**\n\t * Determines if the material source(s) used for the merging are disposed. Defaults to false.\n\t */\n\tpublic set keepMaterial(b:boolean)\n\t{\n\t\tthis._keepMaterial = b;\n\t}\n\n\tpublic get keepMaterial():boolean\n\t{\n\t\treturn this._keepMaterial;\n\t}\n\n\t/**\n\t * Determines if source mesh(es) is/are merged using objectSpace or worldspace. Defaults to false.\n\t */\n\tpublic set objectSpace(b:boolean)\n\t{\n\t\tthis._objectSpace = b;\n\t}\n\n\tpublic get objectSpace():boolean\n\t{\n\t\treturn this._objectSpace;\n\t}\n\n\t/**\n\t * Merges all the children of a container into a single Mesh. If no Mesh object is found, method returns the receiver without modification.\n\t *\n\t * @param    receiver           The Mesh to receive the merged contents of the container.\n\t * @param    objectContainer    The DisplayObjectContainer holding the meshes to be mergd.\n\t *\n\t * @return The merged Mesh instance.\n\t */\n\tpublic applyToContainer(receiver:Mesh, objectContainer:DisplayObjectContainer)\n\t{\n\t\tthis.reset();\n\n\t\t//collect container meshes\n\t\tthis.parseContainer(receiver, objectContainer);\n\n\t\t//collect receiver\n\t\tthis.collect(receiver, false);\n\n\t\t//merge to receiver\n\t\tthis.merge(receiver, this._disposeSources);\n\t}\n\n\t/**\n\t * Merges all the meshes found in the Array&lt;Mesh&gt; into a single Mesh.\n\t *\n\t * @param    receiver    The Mesh to receive the merged contents of the meshes.\n\t * @param    meshes      A series of Meshes to be merged with the reciever mesh.\n\t */\n\tpublic applyToMeshes(receiver:Mesh, meshes:Array<Mesh>)\n\t{\n\t\tthis.reset();\n\n\t\tif (!meshes.length)\n\t\t\treturn;\n\n\t\t//collect meshes in vector\n\t\tfor (var i:number /*uint*/ = 0; i < meshes.length; i++)\n\t\t\tif (meshes[i] != receiver)\n\t\t\t\tthis.collect(meshes[i], this._disposeSources);\n\n\t\t//collect receiver\n\t\tthis.collect(receiver, false);\n\n\t\t//merge to receiver\n\t\tthis.merge(receiver, this._disposeSources);\n\t}\n\n\t/**\n\t *  Merges 2 meshes into one. It is recommand to use apply when 2 meshes are to be merged. If more need to be merged, use either applyToMeshes or applyToContainer methods.\n\t *\n\t * @param    receiver    The Mesh to receive the merged contents of both meshes.\n\t * @param    mesh        The Mesh to be merged with the receiver mesh\n\t */\n\tpublic apply(receiver:Mesh, mesh:Mesh)\n\t{\n\t\tthis.reset();\n\n\t\t//collect mesh\n\t\tthis.collect(mesh, this._disposeSources);\n\n\t\t//collect receiver\n\t\tthis.collect(receiver, false);\n\n\t\t//merge to receiver\n\t\tthis.merge(receiver, this._disposeSources);\n\t}\n\n\tprivate reset()\n\t{\n\t\tthis._toDispose  = new Array<Mesh>();\n\t\tthis._geomVOs = new Array<GeometryVO>();\n\t}\n\n\tprivate merge(destMesh:Mesh, dispose:boolean)\n\t{\n\t\tvar i:number /*uint*/;\n\t\tvar subIdx:number /*uint*/;\n\t\tvar oldGeom:Geometry;\n\t\tvar destGeom:Geometry;\n\t\tvar useSubMaterials:boolean;\n\n\t\toldGeom = destMesh.geometry;\n\t\tdestGeom = destMesh.geometry = new Geometry();\n\t\tsubIdx = destMesh.subMeshes.length;\n\n\t\t// Only apply materials directly to sub-meshes if necessary,\n\t\t// i.e. if there is more than one material available.\n\t\tuseSubMaterials = (this._geomVOs.length > 1);\n\n\t\tfor (i = 0; i < this._geomVOs.length; i++) {\n\t\t\tvar s:number /*uint*/;\n\t\t\tvar data:GeometryVO;\n\t\t\tvar sub:TriangleSubGeometry = new TriangleSubGeometry(true);\n\t\t\tsub.autoDeriveNormals = false;\n\t\t\tsub.autoDeriveTangents = false;\n\n\t\t\tdata = this._geomVOs[i];\n\t\t\tsub.updateIndices(data.indices);\n\t\t\tsub.updatePositions(data.vertices);\n\t\t\tsub.updateVertexNormals(data.normals);\n\t\t\tsub.updateVertexTangents(data.tangents);\n\t\t\tsub.updateUVs(data.uvs);\n\n\t\t\tdestGeom.addSubGeometry(sub);\n\n\t\t\tif (this._keepMaterial && useSubMaterials)\n\t\t\t\tdestMesh.subMeshes[subIdx].material = data.material;\n\t\t}\n\n\t\tif (this._keepMaterial && !useSubMaterials && this._geomVOs.length)\n\t\t\tdestMesh.material = this._geomVOs[0].material;\n\n\t\tif (dispose) {\n\t\t\tvar m:Mesh;\n\t\t\tvar len:number = this._toDispose.length;\n\t\t\tfor (var i:number; i < len; i++) {\n\t\t\t\tm = this._toDispose[i];\n\t\t\t\tm.geometry.dispose();\n\t\t\t\tm.dispose();\n\t\t\t}\n\n\t\t\t//dispose of the original receiver geometry\n\t\t\toldGeom.dispose();\n\t\t}\n\n\t\tthis._toDispose = null;\n\t}\n\n\tprivate collect(mesh:Mesh, dispose:boolean)\n\t{\n\t\tif (mesh.geometry) {\n\t\t\tvar subIdx:number /*uint*/;\n\t\t\tvar subGeometries:Array<TriangleSubGeometry> = <Array<TriangleSubGeometry>> mesh.geometry.subGeometries;\n\t\t\tvar calc:number /*uint*/;\n\t\t\tfor (subIdx = 0; subIdx < subGeometries.length; subIdx++) {\n\t\t\t\tvar i:number /*uint*/;\n\t\t\t\tvar len:number /*uint*/;\n\t\t\t\tvar iIdx:number /*uint*/, vIdx:number /*uint*/, nIdx:number /*uint*/, tIdx:number /*uint*/, uIdx:number /*uint*/;\n\t\t\t\tvar indexOffset:number /*uint*/;\n\t\t\t\tvar subGeom:TriangleSubGeometry;\n\t\t\t\tvar vo:GeometryVO;\n\t\t\t\tvar vertices:Array<number>;\n\t\t\t\tvar normals:Array<number>;\n\t\t\t\tvar tangents:Array<number>;\n\t\t\t\tvar pd:Array<number>, nd:Array<number>, td:Array<number>, ud:Array<number>;\n\n\t\t\t\tsubGeom = subGeometries[subIdx];\n\t\t\t\tpd = subGeom.positions;\n\t\t\t\tnd = subGeom.vertexNormals;\n\t\t\t\ttd = subGeom.vertexTangents;\n\t\t\t\tud = subGeom.uvs;\n\n\t\t\t\t// Get (or create) a VO for this material\n\t\t\t\tvo = this.getSubGeomData(mesh.subMeshes[subIdx].material || mesh.material);\n\n\t\t\t\t// Vertices and normals are copied to temporary vectors, to be transformed\n\t\t\t\t// before concatenated onto those of the data. This is unnecessary if no\n\t\t\t\t// transformation will be performed, i.e. for object space merging.\n\t\t\t\tvertices = (this._objectSpace)? vo.vertices : new Array<number>();\n\t\t\t\tnormals = (this._objectSpace)? vo.normals : new Array<number>();\n\t\t\t\ttangents = (this._objectSpace)? vo.tangents : new Array<number>();\n\n\t\t\t\t// Copy over vertex attributes\n\t\t\t\tvIdx = vertices.length;\n\t\t\t\tnIdx = normals.length;\n\t\t\t\ttIdx = tangents.length;\n\t\t\t\tuIdx = vo.uvs.length;\n\t\t\t\tlen = subGeom.numVertices;\n\t\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\t\tcalc = i*3;\n\n\t\t\t\t\t// Position\n\t\t\t\t\tvertices[vIdx++] = pd[calc];\n\t\t\t\t\tvertices[vIdx++] = pd[calc + 1];\n\t\t\t\t\tvertices[vIdx++] = pd[calc + 2];\n\n\t\t\t\t\t// Normal\n\t\t\t\t\tnormals[nIdx++] = nd[calc];\n\t\t\t\t\tnormals[nIdx++] = nd[calc + 1];\n\t\t\t\t\tnormals[nIdx++] = nd[calc + 2];\n\n\t\t\t\t\t// Tangent\n\t\t\t\t\ttangents[tIdx++] = td[calc];\n\t\t\t\t\ttangents[tIdx++] = td[calc + 1];\n\t\t\t\t\ttangents[tIdx++] = td[calc + 2];\n\n\t\t\t\t\t// UV\n\t\t\t\t\tvo.uvs[uIdx++] = ud[i*2];\n\t\t\t\t\tvo.uvs[uIdx++] = ud[i*2 + 1];\n\t\t\t\t}\n\n\t\t\t\t// Copy over triangle indices\n\t\t\t\tindexOffset = (!this._objectSpace)? vo.vertices.length/3 :0;\n\t\t\t\tiIdx = vo.indices.length;\n\t\t\t\tlen = subGeom.numTriangles;\n\t\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\t\tcalc = i*3;\n\t\t\t\t\tvo.indices[iIdx++] = subGeom.indices[calc] + indexOffset;\n\t\t\t\t\tvo.indices[iIdx++] = subGeom.indices[calc + 1] + indexOffset;\n\t\t\t\t\tvo.indices[iIdx++] = subGeom.indices[calc + 2] + indexOffset;\n\t\t\t\t}\n\n\t\t\t\tif (!this._objectSpace) {\n\t\t\t\t\tmesh.sceneTransform.transformVectors(vertices, vertices);\n\t\t\t\t\tMatrix3DUtils.deltaTransformVectors(mesh.sceneTransform, normals, normals);\n\t\t\t\t\tMatrix3DUtils.deltaTransformVectors(mesh.sceneTransform, tangents, tangents);\n\n\t\t\t\t\t// Copy vertex data from temporary (transformed) vectors\n\t\t\t\t\tvIdx = vo.vertices.length;\n\t\t\t\t\tnIdx = vo.normals.length;\n\t\t\t\t\ttIdx = vo.tangents.length;\n\t\t\t\t\tlen = vertices.length;\n\t\t\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\t\t\tvo.vertices[vIdx++] = vertices[i];\n\t\t\t\t\t\tvo.normals[nIdx++] = normals[i];\n\t\t\t\t\t\tvo.tangents[tIdx++] = tangents[i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (dispose)\n\t\t\t\tthis._toDispose.push(mesh);\n\t\t}\n\t}\n\n\tprivate getSubGeomData(material:MaterialBase):GeometryVO\n\t{\n\t\tvar data:GeometryVO;\n\n\t\tif (this._keepMaterial) {\n\t\t\tvar i:number /*uint*/;\n\t\t\tvar len:number /*uint*/;\n\n\t\t\tlen = this._geomVOs.length;\n\t\t\tfor (i = 0; i < len; i++) {\n\t\t\t\tif (this._geomVOs[i].material == material) {\n\t\t\t\t\tdata = this._geomVOs[i];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (this._geomVOs.length) {\n\t\t\t// If materials are not to be kept, all data can be\n\t\t\t// put into a single VO, so return that one.\n\t\t\tdata = this._geomVOs[0];\n\t\t}\n\n\t\t// No data (for this material) found, create new.\n\t\tif (!data) {\n\t\t\tdata = new GeometryVO();\n\t\t\tdata.vertices = new Array<number>();\n\t\t\tdata.normals = new Array<number>();\n\t\t\tdata.tangents = new Array<number>();\n\t\t\tdata.uvs = new Array<number>();\n\t\t\tdata.indices = new Array<number /*uint*/>();\n\t\t\tdata.material = material;\n\n\t\t\tthis._geomVOs.push(data);\n\t\t}\n\n\t\treturn data;\n\t}\n\n\tprivate parseContainer(receiver:Mesh, object:DisplayObjectContainer)\n\t{\n\t\tvar child:DisplayObjectContainer;\n\t\tvar i:number /*uint*/;\n\n\t\tif (object instanceof Mesh && object != (<DisplayObjectContainer> receiver))\n\t\t\tthis.collect(<Mesh> object, this._disposeSources);\n\n\t\tfor (i = 0; i < object.numChildren; ++i) {\n\t\t\tchild = <DisplayObjectContainer> object.getChildAt(i);\n\t\t\tthis.parseContainer(receiver, child);\n\t\t}\n\t}\n}\n\nexport = Merge;\n\nclass GeometryVO\n{\n\tpublic uvs:Array<number>;\n\tpublic vertices:Array<number>;\n\tpublic normals:Array<number>;\n\tpublic tangents:Array<number>;\n\tpublic indices:Array<number /*uint*/>;\n\tpublic material:MaterialBase;\n}\n"]} \ No newline at end of file diff --git a/lib/tools/commands/Merge.ts b/lib/tools/commands/Merge.ts new file mode 100644 index 000000000..2255db97b --- /dev/null +++ b/lib/tools/commands/Merge.ts @@ -0,0 +1,361 @@ +import DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Matrix3DUtils = require("awayjs-core/lib/core/geom/Matrix3DUtils"); +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); + +/** + * Class Merge merges two or more static meshes into one.Merge + */ +class Merge +{ + + //private const LIMIT:uint = 196605; + private _objectSpace:boolean; + private _keepMaterial:boolean; + private _disposeSources:boolean; + private _geomVOs:Array; + private _toDispose:Array; + + /** + * @param keepMaterial [optional] Determines if the merged object uses the recevier mesh material information or keeps its source material(s). Defaults to false. + * If false and receiver object has multiple materials, the last material found in receiver submeshes is applied to the merged submesh(es). + * @param disposeSources [optional] Determines if the mesh and geometry source(s) used for the merging are disposed. Defaults to false. + * If true, only receiver geometry and resulting mesh are kept in memory. + * @param objectSpace [optional] Determines if source mesh(es) is/are merged using objectSpace or worldspace. Defaults to false. + */ + constructor(keepMaterial:boolean = false, disposeSources:boolean = false, objectSpace:boolean = false) + { + this._keepMaterial = keepMaterial; + this._disposeSources = disposeSources; + this._objectSpace = objectSpace; + } + + /** + * Determines if the mesh and geometry source(s) used for the merging are disposed. Defaults to false. + */ + public set disposeSources(b:boolean) + { + this._disposeSources = b; + } + + public get disposeSources():boolean + { + return this._disposeSources; + } + + /** + * Determines if the material source(s) used for the merging are disposed. Defaults to false. + */ + public set keepMaterial(b:boolean) + { + this._keepMaterial = b; + } + + public get keepMaterial():boolean + { + return this._keepMaterial; + } + + /** + * Determines if source mesh(es) is/are merged using objectSpace or worldspace. Defaults to false. + */ + public set objectSpace(b:boolean) + { + this._objectSpace = b; + } + + public get objectSpace():boolean + { + return this._objectSpace; + } + + /** + * Merges all the children of a container into a single Mesh. If no Mesh object is found, method returns the receiver without modification. + * + * @param receiver The Mesh to receive the merged contents of the container. + * @param objectContainer The DisplayObjectContainer holding the meshes to be mergd. + * + * @return The merged Mesh instance. + */ + public applyToContainer(receiver:Mesh, objectContainer:DisplayObjectContainer) + { + this.reset(); + + //collect container meshes + this.parseContainer(receiver, objectContainer); + + //collect receiver + this.collect(receiver, false); + + //merge to receiver + this.merge(receiver, this._disposeSources); + } + + /** + * Merges all the meshes found in the Array<Mesh> into a single Mesh. + * + * @param receiver The Mesh to receive the merged contents of the meshes. + * @param meshes A series of Meshes to be merged with the reciever mesh. + */ + public applyToMeshes(receiver:Mesh, meshes:Array) + { + this.reset(); + + if (!meshes.length) + return; + + //collect meshes in vector + for (var i:number /*uint*/ = 0; i < meshes.length; i++) + if (meshes[i] != receiver) + this.collect(meshes[i], this._disposeSources); + + //collect receiver + this.collect(receiver, false); + + //merge to receiver + this.merge(receiver, this._disposeSources); + } + + /** + * Merges 2 meshes into one. It is recommand to use apply when 2 meshes are to be merged. If more need to be merged, use either applyToMeshes or applyToContainer methods. + * + * @param receiver The Mesh to receive the merged contents of both meshes. + * @param mesh The Mesh to be merged with the receiver mesh + */ + public apply(receiver:Mesh, mesh:Mesh) + { + this.reset(); + + //collect mesh + this.collect(mesh, this._disposeSources); + + //collect receiver + this.collect(receiver, false); + + //merge to receiver + this.merge(receiver, this._disposeSources); + } + + private reset() + { + this._toDispose = new Array(); + this._geomVOs = new Array(); + } + + private merge(destMesh:Mesh, dispose:boolean) + { + var i:number /*uint*/; + var subIdx:number /*uint*/; + var oldGeom:Geometry; + var destGeom:Geometry; + var useSubMaterials:boolean; + + oldGeom = destMesh.geometry; + destGeom = destMesh.geometry = new Geometry(); + subIdx = destMesh.subMeshes.length; + + // Only apply materials directly to sub-meshes if necessary, + // i.e. if there is more than one material available. + useSubMaterials = (this._geomVOs.length > 1); + + for (i = 0; i < this._geomVOs.length; i++) { + var s:number /*uint*/; + var data:GeometryVO; + var sub:TriangleSubGeometry = new TriangleSubGeometry(true); + sub.autoDeriveNormals = false; + sub.autoDeriveTangents = false; + + data = this._geomVOs[i]; + sub.updateIndices(data.indices); + sub.updatePositions(data.vertices); + sub.updateVertexNormals(data.normals); + sub.updateVertexTangents(data.tangents); + sub.updateUVs(data.uvs); + + destGeom.addSubGeometry(sub); + + if (this._keepMaterial && useSubMaterials) + destMesh.subMeshes[subIdx].material = data.material; + } + + if (this._keepMaterial && !useSubMaterials && this._geomVOs.length) + destMesh.material = this._geomVOs[0].material; + + if (dispose) { + var m:Mesh; + var len:number = this._toDispose.length; + for (var i:number; i < len; i++) { + m = this._toDispose[i]; + m.geometry.dispose(); + m.dispose(); + } + + //dispose of the original receiver geometry + oldGeom.dispose(); + } + + this._toDispose = null; + } + + private collect(mesh:Mesh, dispose:boolean) + { + if (mesh.geometry) { + var subIdx:number /*uint*/; + var subGeometries:Array = > mesh.geometry.subGeometries; + var calc:number /*uint*/; + for (subIdx = 0; subIdx < subGeometries.length; subIdx++) { + var i:number /*uint*/; + var len:number /*uint*/; + var iIdx:number /*uint*/, vIdx:number /*uint*/, nIdx:number /*uint*/, tIdx:number /*uint*/, uIdx:number /*uint*/; + var indexOffset:number /*uint*/; + var subGeom:TriangleSubGeometry; + var vo:GeometryVO; + var vertices:Array; + var normals:Array; + var tangents:Array; + var pd:Array, nd:Array, td:Array, ud:Array; + + subGeom = subGeometries[subIdx]; + pd = subGeom.positions; + nd = subGeom.vertexNormals; + td = subGeom.vertexTangents; + ud = subGeom.uvs; + + // Get (or create) a VO for this material + vo = this.getSubGeomData(mesh.subMeshes[subIdx].material || mesh.material); + + // Vertices and normals are copied to temporary vectors, to be transformed + // before concatenated onto those of the data. This is unnecessary if no + // transformation will be performed, i.e. for object space merging. + vertices = (this._objectSpace)? vo.vertices : new Array(); + normals = (this._objectSpace)? vo.normals : new Array(); + tangents = (this._objectSpace)? vo.tangents : new Array(); + + // Copy over vertex attributes + vIdx = vertices.length; + nIdx = normals.length; + tIdx = tangents.length; + uIdx = vo.uvs.length; + len = subGeom.numVertices; + for (i = 0; i < len; i++) { + calc = i*3; + + // Position + vertices[vIdx++] = pd[calc]; + vertices[vIdx++] = pd[calc + 1]; + vertices[vIdx++] = pd[calc + 2]; + + // Normal + normals[nIdx++] = nd[calc]; + normals[nIdx++] = nd[calc + 1]; + normals[nIdx++] = nd[calc + 2]; + + // Tangent + tangents[tIdx++] = td[calc]; + tangents[tIdx++] = td[calc + 1]; + tangents[tIdx++] = td[calc + 2]; + + // UV + vo.uvs[uIdx++] = ud[i*2]; + vo.uvs[uIdx++] = ud[i*2 + 1]; + } + + // Copy over triangle indices + indexOffset = (!this._objectSpace)? vo.vertices.length/3 :0; + iIdx = vo.indices.length; + len = subGeom.numTriangles; + for (i = 0; i < len; i++) { + calc = i*3; + vo.indices[iIdx++] = subGeom.indices[calc] + indexOffset; + vo.indices[iIdx++] = subGeom.indices[calc + 1] + indexOffset; + vo.indices[iIdx++] = subGeom.indices[calc + 2] + indexOffset; + } + + if (!this._objectSpace) { + mesh.sceneTransform.transformVectors(vertices, vertices); + Matrix3DUtils.deltaTransformVectors(mesh.sceneTransform, normals, normals); + Matrix3DUtils.deltaTransformVectors(mesh.sceneTransform, tangents, tangents); + + // Copy vertex data from temporary (transformed) vectors + vIdx = vo.vertices.length; + nIdx = vo.normals.length; + tIdx = vo.tangents.length; + len = vertices.length; + for (i = 0; i < len; i++) { + vo.vertices[vIdx++] = vertices[i]; + vo.normals[nIdx++] = normals[i]; + vo.tangents[tIdx++] = tangents[i]; + } + } + } + + if (dispose) + this._toDispose.push(mesh); + } + } + + private getSubGeomData(material:MaterialBase):GeometryVO + { + var data:GeometryVO; + + if (this._keepMaterial) { + var i:number /*uint*/; + var len:number /*uint*/; + + len = this._geomVOs.length; + for (i = 0; i < len; i++) { + if (this._geomVOs[i].material == material) { + data = this._geomVOs[i]; + break; + } + } + } else if (this._geomVOs.length) { + // If materials are not to be kept, all data can be + // put into a single VO, so return that one. + data = this._geomVOs[0]; + } + + // No data (for this material) found, create new. + if (!data) { + data = new GeometryVO(); + data.vertices = new Array(); + data.normals = new Array(); + data.tangents = new Array(); + data.uvs = new Array(); + data.indices = new Array(); + data.material = material; + + this._geomVOs.push(data); + } + + return data; + } + + private parseContainer(receiver:Mesh, object:DisplayObjectContainer) + { + var child:DisplayObjectContainer; + var i:number /*uint*/; + + if (object instanceof Mesh && object != ( receiver)) + this.collect( object, this._disposeSources); + + for (i = 0; i < object.numChildren; ++i) { + child = object.getChildAt(i); + this.parseContainer(receiver, child); + } + } +} + +export = Merge; + +class GeometryVO +{ + public uvs:Array; + public vertices:Array; + public normals:Array; + public tangents:Array; + public indices:Array; + public material:MaterialBase; +} diff --git a/lib/tools/data/ParticleGeometryTransform.js b/lib/tools/data/ParticleGeometryTransform.js new file mode 100755 index 000000000..55ead879d --- /dev/null +++ b/lib/tools/data/ParticleGeometryTransform.js @@ -0,0 +1,41 @@ +/** + * ... + */ +var ParticleGeometryTransform = (function () { + function ParticleGeometryTransform() { + } + Object.defineProperty(ParticleGeometryTransform.prototype, "vertexTransform", { + get: function () { + return this._defaultVertexTransform; + }, + set: function (value) { + this._defaultVertexTransform = value; + this._defaultInvVertexTransform = value.clone(); + this._defaultInvVertexTransform.invert(); + this._defaultInvVertexTransform.transpose(); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleGeometryTransform.prototype, "UVTransform", { + get: function () { + return this._defaultUVTransform; + }, + set: function (value) { + this._defaultUVTransform = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParticleGeometryTransform.prototype, "invVertexTransform", { + get: function () { + return this._defaultInvVertexTransform; + }, + enumerable: true, + configurable: true + }); + return ParticleGeometryTransform; +})(); +module.exports = ParticleGeometryTransform; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/tools/data/ParticleGeometryTransform.ts b/lib/tools/data/ParticleGeometryTransform.ts new file mode 100644 index 000000000..f431de15e --- /dev/null +++ b/lib/tools/data/ParticleGeometryTransform.ts @@ -0,0 +1,42 @@ +import Matrix = require("awayjs-core/lib/core/geom/Matrix"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); + +/** + * ... + */ +class ParticleGeometryTransform +{ + private _defaultVertexTransform:Matrix3D; + private _defaultInvVertexTransform:Matrix3D; + private _defaultUVTransform:Matrix; + + public set vertexTransform(value:Matrix3D) + { + this._defaultVertexTransform = value; + this._defaultInvVertexTransform = value.clone(); + this._defaultInvVertexTransform.invert(); + this._defaultInvVertexTransform.transpose(); + } + + public set UVTransform(value:Matrix) + { + this._defaultUVTransform = value; + } + + public get UVTransform():Matrix + { + return this._defaultUVTransform; + } + + public get vertexTransform():Matrix3D + { + return this._defaultVertexTransform; + } + + public get invVertexTransform():Matrix3D + { + return this._defaultInvVertexTransform; + } +} + +export = ParticleGeometryTransform; \ No newline at end of file diff --git a/lib/tools/helpers/ParticleGeometryHelper.js b/lib/tools/helpers/ParticleGeometryHelper.js new file mode 100755 index 000000000..ae954cad7 --- /dev/null +++ b/lib/tools/helpers/ParticleGeometryHelper.js @@ -0,0 +1,180 @@ +var TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +var Point = require("awayjs-core/lib/core/geom/Point"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var ParticleData = require("awayjs-renderergl/lib/animators/data/ParticleData"); +var ParticleGeometry = require("awayjs-renderergl/lib/core/base/ParticleGeometry"); +/** + * ... + */ +var ParticleGeometryHelper = (function () { + function ParticleGeometryHelper() { + } + ParticleGeometryHelper.generateGeometry = function (geometries, transforms) { + if (transforms === void 0) { transforms = null; } + var indicesVector = new Array() /*uint*/; + var positionsVector = new Array(); + var normalsVector = new Array(); + var tangentsVector = new Array(); + var uvsVector = new Array(); + var vertexCounters = new Array() /*uint*/; + var particles = new Array(); + var subGeometries = new Array(); + var numParticles = geometries.length; + var sourceSubGeometries; + var sourceSubGeometry; + var numSubGeometries /*uint*/; + var indices /*uint*/; + var positions; + var normals; + var tangents; + var uvs; + var vertexCounter /*uint*/; + var subGeometry; + var i /*int*/; + var j /*int*/; + var sub2SubMap = new Array() /*int*/; + var tempVertex = new Vector3D; + var tempNormal = new Vector3D; + var tempTangents = new Vector3D; + var tempUV = new Point; + for (i = 0; i < numParticles; i++) { + sourceSubGeometries = geometries[i].subGeometries; + numSubGeometries = sourceSubGeometries.length; + for (var srcIndex = 0; srcIndex < numSubGeometries; srcIndex++) { + //create a different particle subgeometry group for each source subgeometry in a particle. + if (sub2SubMap.length <= srcIndex) { + sub2SubMap.push(subGeometries.length); + indicesVector.push(new Array()); + positionsVector.push(new Array()); + normalsVector.push(new Array()); + tangentsVector.push(new Array()); + uvsVector.push(new Array()); + subGeometries.push(new TriangleSubGeometry(true)); + vertexCounters.push(0); + } + sourceSubGeometry = sourceSubGeometries[srcIndex]; + //add a new particle subgeometry if this source subgeometry will take us over the maxvertex limit + if (sourceSubGeometry.numVertices + vertexCounters[sub2SubMap[srcIndex]] > ParticleGeometryHelper.MAX_VERTEX) { + //update submap and add new subgeom vectors + sub2SubMap[srcIndex] = subGeometries.length; + indicesVector.push(new Array()); + positionsVector.push(new Array()); + normalsVector.push(new Array()); + tangentsVector.push(new Array()); + uvsVector.push(new Array()); + subGeometries.push(new TriangleSubGeometry(true)); + vertexCounters.push(0); + } + j = sub2SubMap[srcIndex]; + //select the correct vector + indices = indicesVector[j]; + positions = positionsVector[j]; + normals = normalsVector[j]; + tangents = tangentsVector[j]; + uvs = uvsVector[j]; + vertexCounter = vertexCounters[j]; + subGeometry = subGeometries[j]; + var particleData = new ParticleData(); + particleData.numVertices = sourceSubGeometry.numVertices; + particleData.startVertexIndex = vertexCounter; + particleData.particleIndex = i; + particleData.subGeometry = subGeometry; + particles.push(particleData); + vertexCounters[j] += sourceSubGeometry.numVertices; + var k /*int*/; + var tempLen /*int*/; + var compact = sourceSubGeometry; + var product /*uint*/; + var sourcePositions; + var sourceNormals; + var sourceTangents; + var sourceUVs; + if (compact) { + tempLen = compact.numVertices; + compact.numTriangles; + sourcePositions = compact.positions; + sourceNormals = compact.vertexNormals; + sourceTangents = compact.vertexTangents; + sourceUVs = compact.uvs; + if (transforms) { + var particleGeometryTransform = transforms[i]; + var vertexTransform = particleGeometryTransform.vertexTransform; + var invVertexTransform = particleGeometryTransform.invVertexTransform; + var UVTransform = particleGeometryTransform.UVTransform; + for (k = 0; k < tempLen; k++) { + /* + * 0 - 2: vertex position X, Y, Z + * 3 - 5: normal X, Y, Z + * 6 - 8: tangent X, Y, Z + * 9 - 10: U V + * 11 - 12: Secondary U V*/ + product = k * 3; + tempVertex.x = sourcePositions[product]; + tempVertex.y = sourcePositions[product + 1]; + tempVertex.z = sourcePositions[product + 2]; + tempNormal.x = sourceNormals[product]; + tempNormal.y = sourceNormals[product + 1]; + tempNormal.z = sourceNormals[product + 2]; + tempTangents.x = sourceTangents[product]; + tempTangents.y = sourceTangents[product + 1]; + tempTangents.z = sourceTangents[product + 2]; + tempUV.x = sourceUVs[k * 2]; + tempUV.y = sourceUVs[k * 2 + 1]; + if (vertexTransform) { + tempVertex = vertexTransform.transformVector(tempVertex); + tempNormal = invVertexTransform.deltaTransformVector(tempNormal); + tempTangents = invVertexTransform.deltaTransformVector(tempNormal); + } + if (UVTransform) + tempUV = UVTransform.transformPoint(tempUV); + //this is faster than that only push one data + sourcePositions.push(tempVertex.x, tempVertex.y, tempVertex.z); + sourceNormals.push(tempNormal.x, tempNormal.y, tempNormal.z); + sourceTangents.push(tempTangents.x, tempTangents.y, tempTangents.z); + sourceUVs.push(tempUV.x, tempUV.y); + } + } + else { + for (k = 0; k < tempLen; k++) { + product = k * 3; + //this is faster than that only push one data + positions.push(sourcePositions[product], sourcePositions[product + 1], sourcePositions[product + 2]); + normals.push(sourceNormals[product], sourceNormals[product + 1], sourceNormals[product + 2]); + tangents.push(sourceTangents[product], sourceTangents[product + 1], sourceTangents[product + 2]); + uvs.push(sourceUVs[k * 2], sourceUVs[k * 2 + 1]); + } + } + } + else { + } + var sourceIndices = sourceSubGeometry.indices; + tempLen = sourceSubGeometry.numTriangles; + for (k = 0; k < tempLen; k++) { + product = k * 3; + indices.push(sourceIndices[product] + vertexCounter, sourceIndices[product + 1] + vertexCounter, sourceIndices[product + 2] + vertexCounter); + } + } + } + var particleGeometry = new ParticleGeometry(); + particleGeometry.particles = particles; + particleGeometry.numParticles = numParticles; + numParticles = subGeometries.length; + for (i = 0; i < numParticles; i++) { + subGeometry = subGeometries[i]; + subGeometry.autoDeriveNormals = false; + subGeometry.autoDeriveTangents = false; + subGeometry.updateIndices(indicesVector[i]); + subGeometry.updatePositions(positionsVector[i]); + subGeometry.updateVertexNormals(normalsVector[i]); + subGeometry.updateVertexTangents(tangentsVector[i]); + subGeometry.updateUVs(uvsVector[i]); + particleGeometry.addSubGeometry(subGeometry); + } + return particleGeometry; + }; + ParticleGeometryHelper.MAX_VERTEX = 65535; + return ParticleGeometryHelper; +})(); +module.exports = ParticleGeometryHelper; + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["tools/helpers/particlegeometryhelper.ts"],"names":["ParticleGeometryHelper","ParticleGeometryHelper.constructor","ParticleGeometryHelper.generateGeometry"],"mappings":"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","file":"tools/helpers/ParticleGeometryHelper.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Geometry\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/base/Geometry\");\nimport TriangleSubGeometry\t\t\t\t= require(\"awayjs-core/lib/core/base/TriangleSubGeometry\");\nimport Matrix\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix\");\nimport Matrix3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Matrix3D\");\nimport Point\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Point\");\nimport Vector3D\t\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\n\nimport Mesh\t\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport MaterialBase\t\t\t\t\t\t= require(\"awayjs-core/lib/materials/MaterialBase\");\n\nimport ParticleData\t\t\t\t\t\t= require(\"awayjs-renderergl/lib/animators/data/ParticleData\");\nimport ParticleGeometry\t\t\t\t\t= require(\"awayjs-renderergl/lib/core/base/ParticleGeometry\");\nimport ParticleGeometryTransform\t\t= require(\"awayjs-renderergl/lib/tools/data/ParticleGeometryTransform\");\n\n/**\n * ...\n */\nclass ParticleGeometryHelper\n{\n\tpublic static MAX_VERTEX:number /*int*/ = 65535;\n\n\tpublic static generateGeometry(geometries:Array<Geometry>, transforms:Array<ParticleGeometryTransform> = null):ParticleGeometry\n\t{\n\t\tvar indicesVector:Array<Array<number>> /*uint*/ = new Array<Array<number>>() /*uint*/;\n\t\tvar positionsVector:Array<Array<number>> = new Array<Array<number>>();\n\t\tvar normalsVector:Array<Array<number>> = new Array<Array<number>>();\n\t\tvar tangentsVector:Array<Array<number>> = new Array<Array<number>>();\n\t\tvar uvsVector:Array<Array<number>> = new Array<Array<number>>();\n\t\tvar vertexCounters:Array<number> /*uint*/ = new Array<number>() /*uint*/;\n\t\tvar particles:Array<ParticleData> = new Array<ParticleData>();\n\t\tvar subGeometries:Array<TriangleSubGeometry> = new Array<TriangleSubGeometry>();\n\t\tvar numParticles:number /*uint*/ = geometries.length;\n\n\t\tvar sourceSubGeometries:Array<TriangleSubGeometry>;\n\t\tvar sourceSubGeometry:TriangleSubGeometry;\n\t\tvar numSubGeometries:number /*uint*/;\n\t\tvar indices:Array<number> /*uint*/;\n\t\tvar positions:Array<number>;\n\t\tvar normals:Array<number>;\n\t\tvar tangents:Array<number>;\n\t\tvar uvs:Array<number>;\n\t\tvar vertexCounter:number /*uint*/;\n\t\tvar subGeometry:TriangleSubGeometry;\n\t\tvar i:number /*int*/;\n\t\tvar j:number /*int*/;\n\t\tvar sub2SubMap:Array<number> /*int*/ = new Array<number>() /*int*/;\n\n\t\tvar tempVertex:Vector3D = new Vector3D;\n\t\tvar tempNormal:Vector3D = new Vector3D;\n\t\tvar tempTangents:Vector3D = new Vector3D;\n\t\tvar tempUV:Point = new Point;\n\n\t\tfor (i = 0; i < numParticles; i++) {\n\t\t\tsourceSubGeometries = <Array<TriangleSubGeometry>> geometries[i].subGeometries;\n\t\t\tnumSubGeometries = sourceSubGeometries.length;\n\t\t\tfor (var srcIndex:number /*int*/ = 0; srcIndex < numSubGeometries; srcIndex++) {\n\t\t\t\t//create a different particle subgeometry group for each source subgeometry in a particle.\n\t\t\t\tif (sub2SubMap.length <= srcIndex) {\n\t\t\t\t\tsub2SubMap.push(subGeometries.length);\n\t\t\t\t\tindicesVector.push(new Array<number>() /*uint*/);\n\t\t\t\t\tpositionsVector.push(new Array<number>());\n\t\t\t\t\tnormalsVector.push(new Array<number>());\n\t\t\t\t\ttangentsVector.push(new Array<number>());\n\t\t\t\t\tuvsVector.push(new Array<number>());\n\t\t\t\t\tsubGeometries.push(new TriangleSubGeometry(true));\n\t\t\t\t\tvertexCounters.push(0);\n\t\t\t\t}\n\n\t\t\t\tsourceSubGeometry = sourceSubGeometries[srcIndex];\n\n\t\t\t\t//add a new particle subgeometry if this source subgeometry will take us over the maxvertex limit\n\t\t\t\tif (sourceSubGeometry.numVertices + vertexCounters[sub2SubMap[srcIndex]] > ParticleGeometryHelper.MAX_VERTEX) {\n\t\t\t\t\t//update submap and add new subgeom vectors\n\t\t\t\t\tsub2SubMap[srcIndex] = subGeometries.length;\n\t\t\t\t\tindicesVector.push(new Array<number>() /*uint*/);\n\t\t\t\t\tpositionsVector.push(new Array<number>());\n\t\t\t\t\tnormalsVector.push(new Array<number>());\n\t\t\t\t\ttangentsVector.push(new Array<number>());\n\t\t\t\t\tuvsVector.push(new Array<number>());\n\t\t\t\t\tsubGeometries.push(new TriangleSubGeometry(true));\n\t\t\t\t\tvertexCounters.push(0);\n\t\t\t\t}\n\n\t\t\t\tj = sub2SubMap[srcIndex];\n\n\t\t\t\t//select the correct vector\n\t\t\t\tindices = indicesVector[j];\n\t\t\t\tpositions = positionsVector[j];\n\t\t\t\tnormals = normalsVector[j];\n\t\t\t\ttangents = tangentsVector[j];\n\t\t\t\tuvs = uvsVector[j];\n\t\t\t\tvertexCounter = vertexCounters[j];\n\t\t\t\tsubGeometry = subGeometries[j];\n\n\t\t\t\tvar particleData:ParticleData = new ParticleData();\n\t\t\t\tparticleData.numVertices = sourceSubGeometry.numVertices;\n\t\t\t\tparticleData.startVertexIndex = vertexCounter;\n\t\t\t\tparticleData.particleIndex = i;\n\t\t\t\tparticleData.subGeometry = subGeometry;\n\t\t\t\tparticles.push(particleData);\n\n\t\t\t\tvertexCounters[j] += sourceSubGeometry.numVertices;\n\n\t\t\t\tvar k:number /*int*/;\n\t\t\t\tvar tempLen:number /*int*/;\n\t\t\t\tvar compact:TriangleSubGeometry = sourceSubGeometry;\n\t\t\t\tvar product:number /*uint*/;\n\t\t\t\tvar sourcePositions:Array<number>;\n\t\t\t\tvar sourceNormals:Array<number>;\n\t\t\t\tvar sourceTangents:Array<number>;\n\t\t\t\tvar sourceUVs:Array<number>;\n\n\t\t\t\tif (compact) {\n\t\t\t\t\ttempLen = compact.numVertices;\n\t\t\t\t\tcompact.numTriangles;\n\t\t\t\t\tsourcePositions = compact.positions;\n\t\t\t\t\tsourceNormals = compact.vertexNormals;\n\t\t\t\t\tsourceTangents = compact.vertexTangents;\n\t\t\t\t\tsourceUVs = compact.uvs;\n\n\t\t\t\t\tif (transforms) {\n\t\t\t\t\t\tvar particleGeometryTransform:ParticleGeometryTransform = transforms[i];\n\t\t\t\t\t\tvar vertexTransform:Matrix3D = particleGeometryTransform.vertexTransform;\n\t\t\t\t\t\tvar invVertexTransform:Matrix3D = particleGeometryTransform.invVertexTransform;\n\t\t\t\t\t\tvar UVTransform:Matrix = particleGeometryTransform.UVTransform;\n\n\t\t\t\t\t\tfor (k = 0; k < tempLen; k++) {\n\t\t\t\t\t\t\t/*\n\t\t\t\t\t\t\t * 0 - 2: vertex position X, Y, Z\n\t\t\t\t\t\t\t * 3 - 5: normal X, Y, Z\n\t\t\t\t\t\t\t * 6 - 8: tangent X, Y, Z\n\t\t\t\t\t\t\t * 9 - 10: U V\n\t\t\t\t\t\t\t * 11 - 12: Secondary U V*/\n\t\t\t\t\t\t\tproduct = k*3;\n\t\t\t\t\t\t\ttempVertex.x = sourcePositions[product];\n\t\t\t\t\t\t\ttempVertex.y = sourcePositions[product + 1];\n\t\t\t\t\t\t\ttempVertex.z = sourcePositions[product + 2];\n\t\t\t\t\t\t\ttempNormal.x = sourceNormals[product];\n\t\t\t\t\t\t\ttempNormal.y = sourceNormals[product + 1];\n\t\t\t\t\t\t\ttempNormal.z = sourceNormals[product + 2];\n\t\t\t\t\t\t\ttempTangents.x = sourceTangents[product];\n\t\t\t\t\t\t\ttempTangents.y = sourceTangents[product + 1];\n\t\t\t\t\t\t\ttempTangents.z = sourceTangents[product + 2];\n\t\t\t\t\t\t\ttempUV.x = sourceUVs[k*2];\n\t\t\t\t\t\t\ttempUV.y = sourceUVs[k*2 + 1];\n\t\t\t\t\t\t\tif (vertexTransform) {\n\t\t\t\t\t\t\t\ttempVertex = vertexTransform.transformVector(tempVertex);\n\t\t\t\t\t\t\t\ttempNormal = invVertexTransform.deltaTransformVector(tempNormal);\n\t\t\t\t\t\t\t\ttempTangents = invVertexTransform.deltaTransformVector(tempNormal);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (UVTransform)\n\t\t\t\t\t\t\t\ttempUV = UVTransform.transformPoint(tempUV);\n\t\t\t\t\t\t\t//this is faster than that only push one data\n\t\t\t\t\t\t\tsourcePositions.push(tempVertex.x, tempVertex.y, tempVertex.z);\n\t\t\t\t\t\t\tsourceNormals.push(tempNormal.x, tempNormal.y, tempNormal.z);\n\t\t\t\t\t\t\tsourceTangents.push(tempTangents.x, tempTangents.y, tempTangents.z);\n\t\t\t\t\t\t\tsourceUVs.push(tempUV.x, tempUV.y);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tfor (k = 0; k < tempLen; k++) {\n\t\t\t\t\t\t\tproduct = k*3;\n\t\t\t\t\t\t\t//this is faster than that only push one data\n\t\t\t\t\t\t\tpositions.push(sourcePositions[product], sourcePositions[product + 1], sourcePositions[product + 2]);\n\t\t\t\t\t\t\tnormals.push(sourceNormals[product], sourceNormals[product + 1], sourceNormals[product + 2]);\n\t\t\t\t\t\t\ttangents.push(sourceTangents[product], sourceTangents[product + 1], sourceTangents[product + 2]);\n\t\t\t\t\t\t\tuvs.push(sourceUVs[k*2], sourceUVs[k*2 + 1]);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t//Todo\n\t\t\t\t}\n\n\t\t\t\tvar sourceIndices:Array<number> /*uint*/ = sourceSubGeometry.indices;\n\t\t\t\ttempLen = sourceSubGeometry.numTriangles;\n\t\t\t\tfor (k = 0; k < tempLen; k++) {\n\t\t\t\t\tproduct = k*3;\n\t\t\t\t\tindices.push(sourceIndices[product] + vertexCounter, sourceIndices[product + 1] + vertexCounter, sourceIndices[product + 2] + vertexCounter);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tvar particleGeometry:ParticleGeometry = new ParticleGeometry();\n\t\tparticleGeometry.particles = particles;\n\t\tparticleGeometry.numParticles = numParticles;\n\n\t\tnumParticles = subGeometries.length;\n\t\tfor (i = 0; i < numParticles; i++) {\n\t\t\tsubGeometry = subGeometries[i];\n\t\t\tsubGeometry.autoDeriveNormals = false;\n\t\t\tsubGeometry.autoDeriveTangents = false;\n\t\t\tsubGeometry.updateIndices(indicesVector[i]);\n\t\t\tsubGeometry.updatePositions(positionsVector[i]);\n\t\t\tsubGeometry.updateVertexNormals(normalsVector[i]);\n\t\t\tsubGeometry.updateVertexTangents(tangentsVector[i]);\n\t\t\tsubGeometry.updateUVs(uvsVector[i]);\n\t\t\tparticleGeometry.addSubGeometry(subGeometry);\n\t\t}\n\n\t\treturn particleGeometry;\n\t}\n}\n\nexport = ParticleGeometryHelper;"]} \ No newline at end of file diff --git a/lib/tools/helpers/ParticleGeometryHelper.ts b/lib/tools/helpers/ParticleGeometryHelper.ts new file mode 100644 index 000000000..4ad4057c1 --- /dev/null +++ b/lib/tools/helpers/ParticleGeometryHelper.ts @@ -0,0 +1,203 @@ +import Geometry = require("awayjs-core/lib/core/base/Geometry"); +import TriangleSubGeometry = require("awayjs-core/lib/core/base/TriangleSubGeometry"); +import Matrix = require("awayjs-core/lib/core/geom/Matrix"); +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +import Point = require("awayjs-core/lib/core/geom/Point"); +import Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); + +import Mesh = require("awayjs-core/lib/entities/Mesh"); +import MaterialBase = require("awayjs-core/lib/materials/MaterialBase"); + +import ParticleData = require("awayjs-renderergl/lib/animators/data/ParticleData"); +import ParticleGeometry = require("awayjs-renderergl/lib/core/base/ParticleGeometry"); +import ParticleGeometryTransform = require("awayjs-renderergl/lib/tools/data/ParticleGeometryTransform"); + +/** + * ... + */ +class ParticleGeometryHelper +{ + public static MAX_VERTEX:number /*int*/ = 65535; + + public static generateGeometry(geometries:Array, transforms:Array = null):ParticleGeometry + { + var indicesVector:Array> /*uint*/ = new Array>() /*uint*/; + var positionsVector:Array> = new Array>(); + var normalsVector:Array> = new Array>(); + var tangentsVector:Array> = new Array>(); + var uvsVector:Array> = new Array>(); + var vertexCounters:Array /*uint*/ = new Array() /*uint*/; + var particles:Array = new Array(); + var subGeometries:Array = new Array(); + var numParticles:number /*uint*/ = geometries.length; + + var sourceSubGeometries:Array; + var sourceSubGeometry:TriangleSubGeometry; + var numSubGeometries:number /*uint*/; + var indices:Array /*uint*/; + var positions:Array; + var normals:Array; + var tangents:Array; + var uvs:Array; + var vertexCounter:number /*uint*/; + var subGeometry:TriangleSubGeometry; + var i:number /*int*/; + var j:number /*int*/; + var sub2SubMap:Array /*int*/ = new Array() /*int*/; + + var tempVertex:Vector3D = new Vector3D; + var tempNormal:Vector3D = new Vector3D; + var tempTangents:Vector3D = new Vector3D; + var tempUV:Point = new Point; + + for (i = 0; i < numParticles; i++) { + sourceSubGeometries = > geometries[i].subGeometries; + numSubGeometries = sourceSubGeometries.length; + for (var srcIndex:number /*int*/ = 0; srcIndex < numSubGeometries; srcIndex++) { + //create a different particle subgeometry group for each source subgeometry in a particle. + if (sub2SubMap.length <= srcIndex) { + sub2SubMap.push(subGeometries.length); + indicesVector.push(new Array() /*uint*/); + positionsVector.push(new Array()); + normalsVector.push(new Array()); + tangentsVector.push(new Array()); + uvsVector.push(new Array()); + subGeometries.push(new TriangleSubGeometry(true)); + vertexCounters.push(0); + } + + sourceSubGeometry = sourceSubGeometries[srcIndex]; + + //add a new particle subgeometry if this source subgeometry will take us over the maxvertex limit + if (sourceSubGeometry.numVertices + vertexCounters[sub2SubMap[srcIndex]] > ParticleGeometryHelper.MAX_VERTEX) { + //update submap and add new subgeom vectors + sub2SubMap[srcIndex] = subGeometries.length; + indicesVector.push(new Array() /*uint*/); + positionsVector.push(new Array()); + normalsVector.push(new Array()); + tangentsVector.push(new Array()); + uvsVector.push(new Array()); + subGeometries.push(new TriangleSubGeometry(true)); + vertexCounters.push(0); + } + + j = sub2SubMap[srcIndex]; + + //select the correct vector + indices = indicesVector[j]; + positions = positionsVector[j]; + normals = normalsVector[j]; + tangents = tangentsVector[j]; + uvs = uvsVector[j]; + vertexCounter = vertexCounters[j]; + subGeometry = subGeometries[j]; + + var particleData:ParticleData = new ParticleData(); + particleData.numVertices = sourceSubGeometry.numVertices; + particleData.startVertexIndex = vertexCounter; + particleData.particleIndex = i; + particleData.subGeometry = subGeometry; + particles.push(particleData); + + vertexCounters[j] += sourceSubGeometry.numVertices; + + var k:number /*int*/; + var tempLen:number /*int*/; + var compact:TriangleSubGeometry = sourceSubGeometry; + var product:number /*uint*/; + var sourcePositions:Array; + var sourceNormals:Array; + var sourceTangents:Array; + var sourceUVs:Array; + + if (compact) { + tempLen = compact.numVertices; + compact.numTriangles; + sourcePositions = compact.positions; + sourceNormals = compact.vertexNormals; + sourceTangents = compact.vertexTangents; + sourceUVs = compact.uvs; + + if (transforms) { + var particleGeometryTransform:ParticleGeometryTransform = transforms[i]; + var vertexTransform:Matrix3D = particleGeometryTransform.vertexTransform; + var invVertexTransform:Matrix3D = particleGeometryTransform.invVertexTransform; + var UVTransform:Matrix = particleGeometryTransform.UVTransform; + + for (k = 0; k < tempLen; k++) { + /* + * 0 - 2: vertex position X, Y, Z + * 3 - 5: normal X, Y, Z + * 6 - 8: tangent X, Y, Z + * 9 - 10: U V + * 11 - 12: Secondary U V*/ + product = k*3; + tempVertex.x = sourcePositions[product]; + tempVertex.y = sourcePositions[product + 1]; + tempVertex.z = sourcePositions[product + 2]; + tempNormal.x = sourceNormals[product]; + tempNormal.y = sourceNormals[product + 1]; + tempNormal.z = sourceNormals[product + 2]; + tempTangents.x = sourceTangents[product]; + tempTangents.y = sourceTangents[product + 1]; + tempTangents.z = sourceTangents[product + 2]; + tempUV.x = sourceUVs[k*2]; + tempUV.y = sourceUVs[k*2 + 1]; + if (vertexTransform) { + tempVertex = vertexTransform.transformVector(tempVertex); + tempNormal = invVertexTransform.deltaTransformVector(tempNormal); + tempTangents = invVertexTransform.deltaTransformVector(tempNormal); + } + if (UVTransform) + tempUV = UVTransform.transformPoint(tempUV); + //this is faster than that only push one data + sourcePositions.push(tempVertex.x, tempVertex.y, tempVertex.z); + sourceNormals.push(tempNormal.x, tempNormal.y, tempNormal.z); + sourceTangents.push(tempTangents.x, tempTangents.y, tempTangents.z); + sourceUVs.push(tempUV.x, tempUV.y); + } + } else { + for (k = 0; k < tempLen; k++) { + product = k*3; + //this is faster than that only push one data + positions.push(sourcePositions[product], sourcePositions[product + 1], sourcePositions[product + 2]); + normals.push(sourceNormals[product], sourceNormals[product + 1], sourceNormals[product + 2]); + tangents.push(sourceTangents[product], sourceTangents[product + 1], sourceTangents[product + 2]); + uvs.push(sourceUVs[k*2], sourceUVs[k*2 + 1]); + } + } + } else { + //Todo + } + + var sourceIndices:Array /*uint*/ = sourceSubGeometry.indices; + tempLen = sourceSubGeometry.numTriangles; + for (k = 0; k < tempLen; k++) { + product = k*3; + indices.push(sourceIndices[product] + vertexCounter, sourceIndices[product + 1] + vertexCounter, sourceIndices[product + 2] + vertexCounter); + } + } + } + + var particleGeometry:ParticleGeometry = new ParticleGeometry(); + particleGeometry.particles = particles; + particleGeometry.numParticles = numParticles; + + numParticles = subGeometries.length; + for (i = 0; i < numParticles; i++) { + subGeometry = subGeometries[i]; + subGeometry.autoDeriveNormals = false; + subGeometry.autoDeriveTangents = false; + subGeometry.updateIndices(indicesVector[i]); + subGeometry.updatePositions(positionsVector[i]); + subGeometry.updateVertexNormals(normalsVector[i]); + subGeometry.updateVertexTangents(tangentsVector[i]); + subGeometry.updateUVs(uvsVector[i]); + particleGeometry.addSubGeometry(subGeometry); + } + + return particleGeometry; + } +} + +export = ParticleGeometryHelper; \ No newline at end of file diff --git a/lib/utils/PerspectiveMatrix3D.js b/lib/utils/PerspectiveMatrix3D.js new file mode 100755 index 000000000..e39b0516d --- /dev/null +++ b/lib/utils/PerspectiveMatrix3D.js @@ -0,0 +1,26 @@ +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); +/** + * + */ +var PerspectiveMatrix3D = (function (_super) { + __extends(PerspectiveMatrix3D, _super); + function PerspectiveMatrix3D(v) { + if (v === void 0) { v = null; } + _super.call(this, v); + } + PerspectiveMatrix3D.prototype.perspectiveFieldOfViewLH = function (fieldOfViewY, aspectRatio, zNear, zFar) { + var yScale = 1 / Math.tan(fieldOfViewY / 2); + var xScale = yScale / aspectRatio; + this.copyRawDataFrom([xScale, 0.0, 0.0, 0.0, 0.0, yScale, 0.0, 0.0, 0.0, 0.0, zFar / (zFar - zNear), 1.0, 0.0, 0.0, (zNear * zFar) / (zNear - zFar), 0.0]); + }; + return PerspectiveMatrix3D; +})(Matrix3D); +module.exports = PerspectiveMatrix3D; + +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/utils/PerspectiveMatrix3D.ts b/lib/utils/PerspectiveMatrix3D.ts new file mode 100644 index 000000000..3a0b622b6 --- /dev/null +++ b/lib/utils/PerspectiveMatrix3D.ts @@ -0,0 +1,22 @@ +import Matrix3D = require("awayjs-core/lib/core/geom/Matrix3D"); + +/** + * + */ +class PerspectiveMatrix3D extends Matrix3D +{ + constructor(v:Array = null) + { + super(v); + } + + public perspectiveFieldOfViewLH(fieldOfViewY:number, aspectRatio:number, zNear:number, zFar:number) + { + var yScale:number = 1/Math.tan(fieldOfViewY/2); + var xScale:number = yScale/aspectRatio; + + this.copyRawDataFrom([xScale, 0.0, 0.0, 0.0, 0.0, yScale, 0.0, 0.0, 0.0, 0.0, zFar/(zFar - zNear), 1.0, 0.0, 0.0, (zNear*zFar)/(zNear - zFar), 0.0]); + } +} + +export = PerspectiveMatrix3D; \ No newline at end of file diff --git a/tests/AppHarness.js b/tests/AppHarness.js new file mode 100755 index 000000000..f8ca7b36c --- /dev/null +++ b/tests/AppHarness.js @@ -0,0 +1,343 @@ +var away; +(function (away) { + //--------------------------------------------------- + // Application Harness + var AppHarness = (function () { + //------------------------------------------------------------------------------ + function AppHarness() { + var _this = this; + //------------------------------------------------------------------------------ + this.tests = new Array(); + this.counter = 0; + this.sourceVisible = false; + this.loadDefault = true; + this.initFrameSet(); + this.initInterface(); + this.previousBtn.onclick = function () { return _this.nagigateBy(-1); }; + this.nextBtn.onclick = function () { return _this.nagigateBy(1); }; + this.sourceBtn.onclick = function () { return _this.toggleSource(); }; + this.dropDown.onchange = function (e) { return _this.dropDownChange(e); }; + } + //------------------------------------------------------------------------------ + /** + * + * Load a test + * + * @param classPath - Module and Class path of test + * @param js Path to JavaScript file + * @param ts Path to Typescript file ( not yet used - reserved for future show source ) + */ + AppHarness.prototype.load = function (classPath, js, ts) { + this.loadFromURL(); + if (this.loadDefault) { + window.history.pushState(js, js, '?test=' + js); + this.testIframe.src = 'frame.html?name=' + classPath + '&js=' + js; + this.srcIframe.src = "data:text/html;charset=utf-8," + this.createSourceViewHTML(ts); + } + }; + /** + * + * Add a test to the AppHarness + * + * @param name Name of test + * @param classPath - Module and Class path of test + * @param js Path to JavaScript file + * @param ts Path to Typescript file ( not yet used - reserved for future show source ) + */ + AppHarness.prototype.addTest = function (name, classpath, js, ts) { + this.tests.push(new TestData(name, classpath, js, ts)); + }; + /** + * + * Add a separator to the menu + * + * @param name + */ + AppHarness.prototype.addSeperator = function (name) { + if (name === void 0) { name = ''; } + this.tests.push(new TestData('-- ' + name, '', '', '')); + }; + /** + * + * Start the application harness + * + */ + AppHarness.prototype.start = function (slideshowMode) { + var _this = this; + if (slideshowMode === void 0) { slideshowMode = false; } + for (var c = 0; c < this.tests.length; c++) { + var option = new Option(this.tests[c].name, String(c)); + this.dropDown.add(option); + } + if (slideshowMode) { + setInterval(function () { return _this.nagigateBy(1); }, 15000); + } + }; + //------------------------------------------------------------------------------ + AppHarness.prototype.loadFromURL = function () { + var queryParams = Utils.getQueryParams(document.location.search); + if (queryParams.test != null) { + var l = this.tests.length; + for (var c = 0; c < l; c++) { + if (this.tests[c].js == queryParams.test) { + console.log('======>>>> LOAD TEST'); + this.navigateToSection(this.tests[c]); + this.loadDefault = false; + } + } + } + }; + /** + * + */ + AppHarness.prototype.initInterface = function () { + var testSelector = document.createElement('div'); + testSelector.style.cssFloat = 'none'; + testSelector.style.position = 'absolute'; + testSelector.style.bottom = '15px'; + testSelector.style.width = '600px'; + testSelector.style.left = '50%'; + testSelector.style.marginLeft = '-300px'; + testSelector.style.textAlign = 'center'; + this.dropDown = document.createElement('select'); + this.dropDown.name = "selectTestDropDown"; + this.dropDown.id = "selectTest"; + this.sourceBtn = document.createElement('button'); + this.sourceBtn.innerHTML = 'Show Source'; + this.sourceBtn.id = 'previous'; + this.previousBtn = document.createElement('button'); + this.previousBtn.innerHTML = '<<'; + this.previousBtn.id = 'previous'; + this.nextBtn = document.createElement('button'); + this.nextBtn.innerHTML = '>>'; + this.nextBtn.id = 'next'; + testSelector.appendChild(this.sourceBtn); + testSelector.appendChild(this.previousBtn); + testSelector.appendChild(this.dropDown); + testSelector.appendChild(this.nextBtn); + document.body.appendChild(testSelector); + }; + /** + * + */ + AppHarness.prototype.initFrameSet = function () { + var iframeContainer = document.createElement('div'); + iframeContainer.style.width = '100%'; + iframeContainer.style.height = '100%'; + this.testIframe = document.createElement('iframe'); + this.testIframe.id = 'testContainer'; + this.testIframe.style.backgroundColor = '#9e9e9e'; + this.testIframe.style.cssFloat = 'none'; + this.testIframe.style.position = 'absolute'; + this.testIframe.style.top = '0px'; + this.testIframe.style.left = '0px'; + this.testIframe.style.border = '0px'; + this.testIframe.style.width = '100%'; + this.testIframe.style.height = '100%'; + //bottom: 120px; + this.srcIframe = document.createElement('iframe'); + this.srcIframe.id = 'testSourceContainer'; + this.srcIframe.style.backgroundColor = '#9e9e9e'; + this.srcIframe.style.cssFloat = 'none'; + this.srcIframe.style.position = 'absolute'; + this.srcIframe.style.right = '0px'; + this.srcIframe.style.top = '0px'; + this.srcIframe.style.bottom = '0px'; + this.srcIframe.style.border = '0px'; + this.srcIframe.style.width = '0%'; + this.srcIframe.style.height = '100%'; + iframeContainer.appendChild(this.testIframe); + iframeContainer.appendChild(this.srcIframe); + document.body.appendChild(iframeContainer); + }; + /** + * + * Selectnext / previous menu item + * + * @param direction + */ + AppHarness.prototype.nagigateBy = function (direction) { + if (direction === void 0) { direction = 1; } + var l = this.tests.length; + var nextCounter = this.counter + direction; + if (nextCounter < 0) { + nextCounter = this.tests.length - 1; + } + else if (nextCounter > this.tests.length - 1) { + nextCounter = 0; + } + var testData = this.tests[nextCounter]; + if (testData.name.indexOf('--') != -1) { + this.counter = nextCounter; + this.nagigateBy(direction); + } + else { + this.navigateToSection(testData); + this.dropDown.selectedIndex = nextCounter; + this.counter = nextCounter; + } + }; + /** + * + * Navigate to a section + * + * @param testData + */ + AppHarness.prototype.navigateToSection = function (testData) { + window.history.pushState(testData.js, testData.js, '?test=' + testData.js); + this.srcIframe.src = "data:text/html;charset=utf-8," + this.createSourceViewHTML(testData.src); + this.testIframe.src = 'frame.html?name=' + testData.classpath + '&js=' + testData.js; + }; + AppHarness.prototype.toggleSource = function () { + if (this.sourceVisible) { + this.testIframe.style.width = '100%'; + this.srcIframe.style.width = '0%'; + this.sourceBtn.innerHTML = 'Show Source'; + } + else { + this.testIframe.style.width = '20%'; + this.srcIframe.style.width = '80%'; + this.sourceBtn.innerHTML = 'Hide Source'; + } + this.sourceVisible = !this.sourceVisible; + }; + AppHarness.prototype.createSourceViewHTML = function (url) { + var html = ''; + html += ''; + html += ''; + html += ' '; + html += ' '; + html += ' '; + html += ' '; + html += ''; + html += ''; + html += ''; + html += ''; + return html; + }; + //------------------------------------------------------------------------------ + // Utils + /** + * + * Util function - get Element by ID + * + * @param id + * @returns {HTMLElement} + */ + AppHarness.prototype.getId = function (id) { + return document.getElementById(id); + }; + //------------------------------------------------------------------------------ + // Events + /** + * + * Dropbox event handler + * + * @param e + */ + AppHarness.prototype.dropDownChange = function (e) { + this.dropDown.options[this.dropDown.selectedIndex].value; + this.counter = this.dropDown.selectedIndex; + var dataIndex = parseInt(this.dropDown.options[this.dropDown.selectedIndex].value); + if (!isNaN(dataIndex)) { + this.navigateToSection(this.tests[dataIndex]); + } + }; + return AppHarness; + })(); + away.AppHarness = AppHarness; + //--------------------------------------------------- + // Application Frame + var AppFrame = (function () { + function AppFrame() { + this.classPath = ''; + this.jsPath = ''; + var queryParams = Utils.getQueryParams(document.location.search); + if (queryParams.js != undefined && queryParams.name != undefined) { + this.jsPath = queryParams.js; + this.classPath = queryParams.name; + this.loadJS(this.jsPath); + } + } + /** + * + * Load a JavaScript file + * + * @param url - URL of JavaScript file + */ + AppFrame.prototype.loadJS = function (url) { + var _this = this; + var head = document.getElementsByTagName("head")[0]; + var script = document.createElement("script"); + script.type = "text/javascript"; + script.src = url; + script.onload = function () { return _this.jsLoaded(); }; + head.appendChild(script); + }; + /** + * + * Event Handler for loaded JavaScript files + * + */ + AppFrame.prototype.jsLoaded = function () { + var createPath = this.classPath.split('.'); // Split the classpath + var obj; + for (var c = 0; c < createPath.length; c++) { + if (obj == null) { + obj = window[createPath[c]]; // reference base module ( will be a child of the window ) + } + else { + obj = obj[createPath[c]]; // reference sub module / Class + } + } + if (obj != null) { + new obj(); // if Class has been found - start the test + } + }; + return AppFrame; + })(); + away.AppFrame = AppFrame; + //--------------------------------------------------- + // Common Utilities + var Utils = (function () { + function Utils() { + } + /** + * + * Utility function - Parse a Query formatted string + * + * @param qs + * @returns {{}} + */ + Utils.getQueryParams = function (qs) { + qs = qs.split("+").join(" "); + var params = {}, tokens, re = /[?&]?([^=]+)=([^&]*)/g; + while (tokens = re.exec(qs)) { + params[decodeURIComponent(tokens[1])] = decodeURIComponent(tokens[2]); + } + return params; + }; + return Utils; + })(); + away.Utils = Utils; + //--------------------------------------------------- + // Data + var TestData = (function () { + function TestData(name, classpath, js, src) { + this.js = js; + this.classpath = classpath; + this.src = src; + this.name = name; + } + return TestData; + })(); +})(away || (away = {})); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["appharness.ts"],"names":["away","away.AppHarness","away.AppHarness.constructor","away.AppHarness.load","away.AppHarness.addTest","away.AppHarness.addSeperator","away.AppHarness.start","away.AppHarness.loadFromURL","away.AppHarness.initInterface","away.AppHarness.initFrameSet","away.AppHarness.nagigateBy","away.AppHarness.navigateToSection","away.AppHarness.toggleSource","away.AppHarness.createSourceViewHTML","away.AppHarness.getId","away.AppHarness.dropDownChange","away.AppFrame","away.AppFrame.constructor","away.AppFrame.loadJS","away.AppFrame.jsLoaded","away.Utils","away.Utils.constructor","away.Utils.getQueryParams","away.TestData","away.TestData.constructor"],"mappings":"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","file":"AppHarness.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["module away\n{\n\n    //---------------------------------------------------\n    // Application Harness\n\n    export class AppHarness\n    {\n\n        //------------------------------------------------------------------------------\n\n        private tests           : Array<TestData> = new Array<TestData>();\n        private dropDown        : HTMLSelectElement;\n        private previousBtn     : HTMLButtonElement;\n        private nextBtn         : HTMLButtonElement;\n        private sourceBtn       : HTMLButtonElement;\n        private testIframe      : HTMLIFrameElement;\n        private srcIframe       : HTMLIFrameElement;\n        private counter         : number = 0;\n        private sourceVisible   : boolean = false;\n\t    private loadDefault     : boolean = true;\n\n        //------------------------------------------------------------------------------\n\n        constructor()\n        {\n\n            this.initFrameSet();\n            this.initInterface();\n\n\n            this.previousBtn.onclick   = () => this.nagigateBy( -1 );\n            this.nextBtn.onclick       = () => this.nagigateBy( 1 );\n            this.sourceBtn.onclick     = () => this.toggleSource();\n            this.dropDown.onchange      = ( e ) => this.dropDownChange( e );\n\n        }\n\n        //------------------------------------------------------------------------------\n\n        /**\n         *\n         * Load a test\n         *\n         * @param classPath - Module and Class path of test\n         * @param js Path to JavaScript file\n         * @param ts Path to Typescript file ( not yet used - reserved for future show source )\n         */\n        public load( classPath : string , js : string , ts : string ) : void\n        {\n\n\t        this.loadFromURL();\n\n\t        if ( this.loadDefault )\n\t        {\n\t            window.history.pushState(js, js, '?test=' + js);\n\t            this.testIframe.src = 'frame.html?name=' + classPath + '&js=' + js;\n                this.srcIframe.src = \"data:text/html;charset=utf-8,\" + this.createSourceViewHTML( ts );\n\n\t        }\n        }\n\n        /**\n         *\n         * Add a test to the AppHarness\n         *\n         * @param name Name of test\n         * @param classPath - Module and Class path of test\n         * @param js Path to JavaScript file\n         * @param ts Path to Typescript file ( not yet used - reserved for future show source )\n         */\n        public addTest( name : string , classpath : string , js : string , ts : string ) : void\n        {\n            this.tests.push ( new TestData( name , classpath , js , ts ) );\n        }\n\n        /**\n         *\n         * Add a separator to the menu\n         *\n         * @param name\n         */\n        public addSeperator( name : string = '' ) : void\n        {\n            this.tests.push ( new TestData( '-- ' + name , '' , '' , '') );\n        }\n\n        /**\n         *\n         * Start the application harness\n         *\n         */\n        public start( slideshowMode : boolean = false ) : void\n        {\n            for ( var c : number = 0 ; c < this.tests.length ; c ++  )\n            {\n                var option : HTMLOptionElement = <HTMLOptionElement> new Option( this.tests[c].name , String( c ) );\n                this.dropDown.add( option );\n            }\n\n            if ( slideshowMode )\n            {\n\n                setInterval( () => this.nagigateBy( 1 ) , 15000);\n            }\n        }\n\n        //------------------------------------------------------------------------------\n\n\t    private loadFromURL() : void\n\t    {\n\t\t    var queryParams : any = Utils.getQueryParams( document.location.search );\n\n\t\t    if ( queryParams.test != null )\n\t\t    {\n\t\t\t    var l : number =  this.tests.length;\n\n\t\t\t    for ( var c : number = 0 ; c < l ; c ++ )\n\t\t\t    {\n\t\t\t\t    if ( this.tests[c].js == queryParams.test )\n\t\t\t\t    {\n\t\t\t\t\t    console.log ( '======>>>> LOAD TEST');\n\n\t\t\t\t\t    this.navigateToSection( this.tests[c] );\n\t\t\t\t\t    this.loadDefault = false;\n\t\t\t\t    }\n\t\t\t    }\n\t\t    }\n\t    }\n        /**\n         *\n         */\n        private initInterface() : void\n        {\n\n            var testSelector : HTMLDivElement   = <HTMLDivElement> document.createElement( 'div' );\n                testSelector.style.cssFloat     = 'none';\n                testSelector.style.position     = 'absolute';\n                testSelector.style.bottom       = '15px';\n                testSelector.style.width        = '600px';\n                testSelector.style.left         = '50%';\n                testSelector.style.marginLeft   = '-300px'\n                testSelector.style.textAlign    = 'center';\n\n\n            this.dropDown                       = <HTMLSelectElement> document.createElement( 'select' );\n            this.dropDown.name                  = \"selectTestDropDown\"\n            this.dropDown.id                    = \"selectTest\"\n\n            this.sourceBtn                      = <HTMLButtonElement> document.createElement( 'button' );\n            this.sourceBtn.innerHTML            = 'Show Source';\n            this.sourceBtn.id                   = 'previous';\n\n            this.previousBtn                    = <HTMLButtonElement> document.createElement( 'button' );\n            this.previousBtn.innerHTML          = '<<';\n            this.previousBtn.id                 = 'previous';\n\n            this.nextBtn                        = <HTMLButtonElement> document.createElement( 'button' );\n            this.nextBtn.innerHTML              = '>>';\n            this.nextBtn.id                     = 'next';\n\n\n            testSelector.appendChild( this.sourceBtn );\n            testSelector.appendChild( this.previousBtn );\n            testSelector.appendChild( this.dropDown );\n            testSelector.appendChild( this.nextBtn );\n            document.body.appendChild( testSelector );\n        }\n        /**\n         *\n         */\n        private initFrameSet() : void\n        {\n\n            var iframeContainer : HTMLDivElement    = <HTMLDivElement> document.createElement( 'div' );\n                iframeContainer.style.width         = '100%';\n                iframeContainer.style.height        = '100%';\n\n            this.testIframe                      = <HTMLIFrameElement> document.createElement( 'iframe' );\n            this.testIframe.id                   = 'testContainer';\n            this.testIframe.style.backgroundColor = '#9e9e9e';\n            this.testIframe.style.cssFloat       = 'none';\n            this.testIframe.style.position       = 'absolute';\n            this.testIframe.style.top            = '0px';\n            this.testIframe.style.left           = '0px';\n            this.testIframe.style.border         = '0px';\n            this.testIframe.style.width          = '100%';\n            this.testIframe.style.height         = '100%';\n            //bottom: 120px;\n\n            this.srcIframe                          = <HTMLIFrameElement> document.createElement( 'iframe' );\n            this.srcIframe.id                       = 'testSourceContainer';\n            this.srcIframe.style.backgroundColor    = '#9e9e9e';\n            this.srcIframe.style.cssFloat           = 'none';\n            this.srcIframe.style.position           = 'absolute';\n            this.srcIframe.style.right              = '0px';\n            this.srcIframe.style.top                = '0px';\n            this.srcIframe.style.bottom             = '0px';\n            this.srcIframe.style.border             = '0px';\n            this.srcIframe.style.width              = '0%';\n            this.srcIframe.style.height             = '100%';\n\n            iframeContainer.appendChild( this.testIframe );\n            iframeContainer.appendChild( this.srcIframe );\n\n            document.body.appendChild( iframeContainer );\n\n        }\n\n        /**\n         *\n         * Selectnext / previous menu item\n         *\n         * @param direction\n         */\n        private nagigateBy( direction : number = 1 ) : void\n        {\n\n            var l : number  = this.tests.length;\n            var nextCounter = this.counter + direction;\n\n            if ( nextCounter < 0 )\n            {\n                nextCounter = this.tests.length - 1;\n            }\n            else if ( nextCounter > this.tests.length - 1 )\n            {\n                nextCounter = 0;\n            }\n\n            var testData : TestData = this.tests[nextCounter];\n\n            if ( testData.name.indexOf ('--') != -1 ) // skip section headers\n            {\n                this.counter = nextCounter;\n                this.nagigateBy( direction );\n            }\n            else\n            {\n                this.navigateToSection( testData );\n                this.dropDown.selectedIndex = nextCounter;\n                this.counter = nextCounter;\n            }\n\n        }\n\n        /**\n         *\n         * Navigate to a section\n         *\n         * @param testData\n         */\n        private navigateToSection ( testData : TestData ) : void\n        {\n\t        window.history.pushState(testData.js, testData.js, '?test=' + testData.js);\n            this.srcIframe.src = \"data:text/html;charset=utf-8,\" + this.createSourceViewHTML( testData.src );\n            this.testIframe.src = 'frame.html?name=' + testData.classpath + '&js=' + testData.js;\n        }\n\n        private toggleSource() : void\n        {\n\n            if ( this.sourceVisible )\n            {\n                this.testIframe.style.width         = '100%';\n                this.srcIframe.style.width          = '0%';\n                this.sourceBtn.innerHTML            = 'Show Source';\n            }\n            else\n            {\n                this.testIframe.style.width         = '20%';\n                this.srcIframe.style.width          = '80%';\n                this.sourceBtn.innerHTML            = 'Hide Source';\n            }\n\n            this.sourceVisible = !this.sourceVisible;\n\n        }\n\n        private createSourceViewHTML ( url : string ) : string\n        {\n\n            var html : string = '';\n\n            html += '<!DOCTYPE html>';\n            html += '<html>';\n            html += '   <head>';\n            html += '       <title></title>';\n            html += '       <style>';\n            html += '           html';\n            html += '           {';\n            html += '               height: 100%;';\n            html += '               border: 0px;';\n            html += '               padding: 0px;';\n            html += '          }';\n            html += '       </style>';\n\t        html += '   <script src=\"http://gist-it.appspot.com/github/awayjs/awayjs-core-ts/tree/master/tests/' + url + '?footer=no\"></script>';\n            html += '</head>';\n            html += '<body>';\n            html += '</body>';\n            html += '</html>';\n\n            return html;\n        }\n\n        //------------------------------------------------------------------------------\n        // Utils\n\n        /**\n         *\n         * Util function - get Element by ID\n         *\n         * @param id\n         * @returns {HTMLElement}\n         */\n        private getId(id : string ) : HTMLElement\n        {\n            return document.getElementById( id );\n        }\n\n        //------------------------------------------------------------------------------\n        // Events\n\n        /**\n         *\n         * Dropbox event handler\n         *\n         * @param e\n         */\n        private dropDownChange( e ) : void\n        {\n            this.dropDown.options[this.dropDown.selectedIndex].value\n            this.counter = this.dropDown.selectedIndex;\n            var dataIndex : number = parseInt( this.dropDown.options[this.dropDown.selectedIndex].value ) ;\n\n            if ( ! isNaN( dataIndex ) )\n            {\n                this.navigateToSection( this.tests[dataIndex] );\n            }\n        }\n\n    }\n\n    //---------------------------------------------------\n    // Application Frame\n\n    export class AppFrame\n    {\n\n        private classPath   : string = '';\n        private jsPath      : string = '';\n\n        constructor( )\n        {\n\n            var queryParams : any = Utils.getQueryParams( document.location.search );\n\n            if ( queryParams.js != undefined && queryParams.name != undefined )\n            {\n\n                this.jsPath     = queryParams.js;\n                this.classPath  = queryParams.name;\n                this.loadJS( this.jsPath );\n\n            }\n\n        }\n\n        /**\n         *\n         * Load a JavaScript file\n         *\n         * @param url - URL of JavaScript file\n         */\n        private loadJS(url : string )\n        {\n\n            var head : HTMLElement = <HTMLElement> document.getElementsByTagName(\"head\")[0];\n            var script : HTMLScriptElement = document.createElement(\"script\");\n            script.type     = \"text/javascript\";\n            script.src      = url;\n            script.onload   = () => this.jsLoaded();\n\n            head.appendChild(script);\n        }\n\n        /**\n         *\n         * Event Handler for loaded JavaScript files\n         *\n         */\n        private jsLoaded()\n        {\n\n            var createPath : Array<string> = this.classPath.split('.'); // Split the classpath\n            var obj         : any;\n\n            for ( var c : number = 0 ; c < createPath.length ; c++ )\n            {\n\n                if ( obj == null )\n                {\n                    obj = window[createPath[c]]; // reference base module ( will be a child of the window )\n                }\n                else\n                {\n                    obj = obj[createPath[c]]; // reference sub module / Class\n                }\n\n\n            }\n\n            if ( obj != null )\n            {\n                new obj(); // if Class has been found - start the test\n            }\n\n        }\n\n\n\n    }\n\n\t//---------------------------------------------------\n\t// Common Utilities\n\n\texport class Utils\n\t{\n\t\t/**\n\t\t *\n\t\t * Utility function - Parse a Query formatted string\n\t\t *\n\t\t * @param qs\n\t\t * @returns {{}}\n\t\t */\n\t\tstatic getQueryParams( qs ) : Object {\n\n\t\t\tqs = qs.split(\"+\").join(\" \");\n\n\t\t\tvar params = {}, tokens,\n\t\t\t\tre = /[?&]?([^=]+)=([^&]*)/g;\n\n\t\t\twhile (tokens = re.exec(qs)) {\n\t\t\t\tparams[decodeURIComponent(tokens[1])] = decodeURIComponent(tokens[2]);\n\t\t\t}\n\n\t\t\treturn params;\n\t\t}\n\t}\n\n    //---------------------------------------------------\n    // Data\n\n    class TestData\n    {\n        public js           : string;\n        public classpath    : string;\n        public src          : string;\n        public name         : string;\n\n        constructor( name : string , classpath : string , js : string , src : string )\n        {\n            this.js         = js;\n            this.classpath  = classpath;\n            this.src        = src;\n            this.name       = name;\n        }\n    }\n}"]} \ No newline at end of file diff --git a/tests/lights/LightsShadowTest.js b/tests/lights/LightsShadowTest.js new file mode 100755 index 000000000..41c1aaede --- /dev/null +++ b/tests/lights/LightsShadowTest.js @@ -0,0 +1,112 @@ +var View = require("awayjs-core/lib/containers/View"); +var HoverController = require("awayjs-core/lib/controllers/HoverController"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AssetLibrary = require("awayjs-core/lib/core/library/AssetLibrary"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var AssetEvent = require("awayjs-core/lib/events/AssetEvent"); +var LoaderEvent = require("awayjs-core/lib/events/LoaderEvent"); +var Debug = require("awayjs-core/lib/utils/Debug"); +var RequestAnimationFrame = require("awayjs-core/lib/utils/RequestAnimationFrame"); +var DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +var AWDParser = require("awayjs-renderergl/lib/parsers/AWDParser"); +var LightsShadowTest = (function () { + function LightsShadowTest() { + var _this = this; + this.lookAtPosition = new Vector3D(); + this._move = false; + Debug.LOG_PI_ERRORS = true; + Debug.THROW_ERRORS = false; + AssetLibrary.enableParser(AWDParser); + this._token = AssetLibrary.load(new URLRequest('assets/ShadowTest.awd')); + this._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this._token.addEventListener(AssetEvent.ASSET_COMPLETE, function (event) { return _this.onAssetComplete(event); }); + this._view = new View(new DefaultRenderer()); + this._view.camera.projection.far = 5000; + this._view.camera.y = 100; + this._timer = new RequestAnimationFrame(this.render, this); + this._cameraController = new HoverController(this._view.camera, null, 45, 20, 2000, 5); + document.onmousedown = function (event) { return _this.onMouseDown(event); }; + document.onmouseup = function (event) { return _this.onMouseUp(event); }; + document.onmousemove = function (event) { return _this.onMouseMove(event); }; + document.onmousewheel = function (event) { return _this.onMouseWheel(event); }; + window.onresize = function (event) { return _this.resize(event); }; + } + LightsShadowTest.prototype.resize = function (event) { + if (event === void 0) { event = null; } + this._view.y = 0; + this._view.x = 0; + this._view.width = window.innerWidth; + this._view.height = window.innerHeight; + }; + LightsShadowTest.prototype.render = function (dt) { + if (this._view.camera) + this._view.camera.lookAt(this.lookAtPosition); + if (this._awdMesh) + this._awdMesh.rotationY += 0.2; + this._view.render(); + }; + LightsShadowTest.prototype.onAssetComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name)); + console.log('------------------------------------------------------------------------------'); + }; + LightsShadowTest.prototype.onResourceComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('LoaderEvent.RESOURCE_COMPLETE', event); + console.log('------------------------------------------------------------------------------'); + var loader = event.target; + var numAssets = loader.baseDependency.assets.length; + for (var i = 0; i < numAssets; ++i) { + var asset = loader.baseDependency.assets[i]; + switch (asset.assetType) { + case AssetType.MESH: + this._awdMesh = asset; + this._view.scene.addChild(this._awdMesh); + this.resize(); + break; + case AssetType.LIGHT: + this._view.scene.addChild(asset); + break; + case AssetType.MATERIAL: + break; + } + } + this._timer.start(); + }; + /** + * Mouse down listener for navigation + */ + LightsShadowTest.prototype.onMouseDown = function (event) { + this._lastPanAngle = this._cameraController.panAngle; + this._lastTiltAngle = this._cameraController.tiltAngle; + this._lastMouseX = event.clientX; + this._lastMouseY = event.clientY; + this._move = true; + }; + /** + * Mouse up listener for navigation + */ + LightsShadowTest.prototype.onMouseUp = function (event) { + this._move = false; + }; + LightsShadowTest.prototype.onMouseMove = function (event) { + if (this._move) { + this._cameraController.panAngle = 0.3 * (event.clientX - this._lastMouseX) + this._lastPanAngle; + this._cameraController.tiltAngle = 0.3 * (event.clientY - this._lastMouseY) + this._lastTiltAngle; + } + }; + /** + * Mouse wheel listener for navigation + */ + LightsShadowTest.prototype.onMouseWheel = function (event) { + this._cameraController.distance -= event.wheelDelta * 2; + if (this._cameraController.distance < 100) + this._cameraController.distance = 100; + else if (this._cameraController.distance > 2000) + this._cameraController.distance = 2000; + }; + return LightsShadowTest; +})(); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["lights/lightsshadowtest.ts"],"names":["LightsShadowTest","LightsShadowTest.constructor","LightsShadowTest.resize","LightsShadowTest.render","LightsShadowTest.onAssetComplete","LightsShadowTest.onResourceComplete","LightsShadowTest.onMouseDown","LightsShadowTest.onMouseUp","LightsShadowTest.onMouseMove","LightsShadowTest.onMouseWheel"],"mappings":"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","file":"lights/LightsShadowTest.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import View\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport HoverController\t\t\t\t= require(\"awayjs-core/lib/controllers/HoverController\");\nimport LightBase\t\t\t\t\t= require(\"awayjs-core/lib/core/base/LightBase\");\nimport Vector3D\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetLibrary\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLibrary\");\nimport AssetLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoader\");\nimport AssetLoaderToken\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoaderToken\");\nimport AssetType\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLRequest\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport Mesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport AssetEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/AssetEvent\");\nimport LoaderEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/LoaderEvent\");\nimport Debug\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport RequestAnimationFrame\t\t= require(\"awayjs-core/lib/utils/RequestAnimationFrame\");\n\nimport DefaultRenderer\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\n\nimport AWDParser\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/AWDParser\");\n\nclass LightsShadowTest\n{\n\n\tprivate _view:View;\n\tprivate _token:AssetLoaderToken;\n\tprivate _timer:RequestAnimationFrame;\n\tprivate lookAtPosition:Vector3D = new Vector3D();\n\tprivate _awdMesh:Mesh;\n\tprivate _cameraController:HoverController;\n\tprivate _move:boolean = false;\n\tprivate _lastPanAngle:number;\n\tprivate _lastTiltAngle:number;\n\tprivate _lastMouseX:number;\n\tprivate _lastMouseY:number;\n\n\tconstructor()\n\t{\n\t\tDebug.LOG_PI_ERRORS = true;\n\t\tDebug.THROW_ERRORS = false;\n\n\t\tAssetLibrary.enableParser(AWDParser);\n\n\t\tthis._token = AssetLibrary.load(new URLRequest('assets/ShadowTest.awd'));\n\n\t\tthis._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\t\tthis._token.addEventListener(AssetEvent.ASSET_COMPLETE, (event:AssetEvent) => this.onAssetComplete(event));\n\n\t\tthis._view = new View(new DefaultRenderer());\n\t\tthis._view.camera.projection.far = 5000;\n\t\tthis._view.camera.y = 100;\n\n\t\tthis._timer = new RequestAnimationFrame(this.render, this);\n\n\t\tthis._cameraController = new HoverController(this._view.camera, null, 45, 20, 2000, 5);\n\n\t\tdocument.onmousedown = (event:MouseEvent) => this.onMouseDown(event);\n\t\tdocument.onmouseup = (event:MouseEvent) => this.onMouseUp(event);\n\t\tdocument.onmousemove = (event:MouseEvent) => this.onMouseMove(event);\n\t\tdocument.onmousewheel = (event:MouseWheelEvent) => this.onMouseWheel(event);\n\n\t\twindow.onresize = (event:UIEvent) => this.resize(event);\n\t}\n\n\tprivate resize(event:UIEvent = null)\n\t{\n\t\tthis._view.y = 0;\n\t\tthis._view.x = 0;\n\t\tthis._view.width = window.innerWidth;\n\t\tthis._view.height = window.innerHeight;\n\t}\n\n\tprivate render(dt:number) //animate based on dt for firefox\n\t{\n\t\tif (this._view.camera)\n\t\t\tthis._view.camera.lookAt(this.lookAtPosition);\n\n\t\tif (this._awdMesh)\n\t\t\tthis._awdMesh.rotationY += 0.2;\n\n\t\t this._view.render();\n\t}\n\n\tpublic onAssetComplete(event:AssetEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('AssetEvent.ASSET_COMPLETE' , AssetLibrary.getAsset(event.asset.name));\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t}\n\n\tpublic onResourceComplete(event:LoaderEvent)\n\t{\n\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('LoaderEvent.RESOURCE_COMPLETE' , event);\n\t\tconsole.log('------------------------------------------------------------------------------');\n\n\t\tvar loader:AssetLoader = <AssetLoader> event.target;\n\t\tvar numAssets:number = loader.baseDependency.assets.length;\n\n\t\tfor (var i:number = 0; i < numAssets; ++i) {\n\t\t\tvar asset:IAsset = loader.baseDependency.assets[ i ];\n\n\t\t\tswitch (asset.assetType) {\n\t\t\t\tcase AssetType.MESH:\n\t\t\t\t\tthis._awdMesh = <Mesh> asset;\n\t\t\t\t\tthis._view.scene.addChild(this._awdMesh);\n\t\t\t\t\tthis.resize();\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.LIGHT:\n\t\t\t\t\tthis._view.scene.addChild(<LightBase> asset);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.MATERIAL:\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\t\t}\n\n\t\tthis._timer.start();\n\t}\n\n\t/**\n\t * Mouse down listener for navigation\n\t */\n\tprivate onMouseDown(event):void\n\t{\n\t\tthis._lastPanAngle = this._cameraController.panAngle;\n\t\tthis._lastTiltAngle = this._cameraController.tiltAngle;\n\t\tthis._lastMouseX = event.clientX;\n\t\tthis._lastMouseY = event.clientY;\n\t\tthis._move = true;\n\t}\n\n\t/**\n\t * Mouse up listener for navigation\n\t */\n\tprivate onMouseUp(event):void\n\t{\n\t\tthis._move = false;\n\t}\n\n\tprivate onMouseMove(event)\n\t{\n\t\tif (this._move) {\n\t\t\tthis._cameraController.panAngle = 0.3*(event.clientX - this._lastMouseX) + this._lastPanAngle;\n\t\t\tthis._cameraController.tiltAngle = 0.3*(event.clientY - this._lastMouseY) + this._lastTiltAngle;\n\t\t}\n\t}\n\n\t/**\n\t * Mouse wheel listener for navigation\n\t */\n\tprivate onMouseWheel(event:MouseWheelEvent):void\n\t{\n\t\tthis._cameraController.distance -= event.wheelDelta * 2;\n\n\t\tif (this._cameraController.distance < 100)\n\t\t\tthis._cameraController.distance = 100;\n\t\telse if (this._cameraController.distance > 2000)\n\t\t\tthis._cameraController.distance = 2000;\n\t}\n}"]} \ No newline at end of file diff --git a/tests/materials/MaterialAlphaTest.js b/tests/materials/MaterialAlphaTest.js new file mode 100755 index 000000000..d042d2828 --- /dev/null +++ b/tests/materials/MaterialAlphaTest.js @@ -0,0 +1,153 @@ +var View = require("awayjs-core/lib/containers/View"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AssetLibrary = require("awayjs-core/lib/core/library/AssetLibrary"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +var LoaderEvent = require("awayjs-core/lib/events/LoaderEvent"); +var StaticLightPicker = require("awayjs-core/lib/materials/lightpickers/StaticLightPicker"); +var PrimitiveTorusPrefab = require("awayjs-core/lib/prefabs/PrimitiveTorusPrefab"); +var PrimitiveCubePrefab = require("awayjs-core/lib/prefabs/PrimitiveCubePrefab"); +var PrimitiveCapsulePrefab = require("awayjs-core/lib/prefabs/PrimitiveCapsulePrefab"); +var Debug = require("awayjs-core/lib/utils/Debug"); +var RequestAnimationFrame = require("awayjs-core/lib/utils/RequestAnimationFrame"); +var DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +var TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +var OBJParser = require("awayjs-renderergl/lib/parsers/OBJParser"); +var MaterialAlphaTest = (function () { + function MaterialAlphaTest() { + var _this = this; + this.height = 0; + this.meshes = new Array(); + this.aValues = Array(0, .1, .5, .8, .9, .99, 1); + this.aValuesP = 0; + Debug.LOG_PI_ERRORS = false; + Debug.THROW_ERRORS = false; + this.view = new View(new DefaultRenderer()); + this.raf = new RequestAnimationFrame(this.render, this); + this.onResize(); + this.light = new DirectionalLight(); + this.light.color = 0xFFFFFF; + this.light.direction = new Vector3D(1, 1, 0); + this.light.ambient = 0; + this.light.ambientColor = 0xFFFFFF; + this.light.diffuse = 1; + this.light.specular = 1; + this.lightB = new DirectionalLight(); + this.lightB.color = 0xFF0000; + this.lightB.direction = new Vector3D(-1, 0, 1); + this.lightB.ambient = 0; + this.lightB.ambientColor = 0xFFFFFF; + this.lightB.diffuse = 1; + this.lightB.specular = 1; + this.view.scene.addChild(this.light); + this.view.scene.addChild(this.lightB); + this.view.backgroundColor = 0x222222; + AssetLibrary.enableParser(OBJParser); + this.token = AssetLibrary.load(new URLRequest('assets/platonic.obj')); + this.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this.token = AssetLibrary.load(new URLRequest('assets/dots.png')); + this.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + window.onresize = function (event) { return _this.onResize(event); }; + document.onmousedown = function (event) { return _this.onMouseDown(event); }; + } + MaterialAlphaTest.prototype.onMouseDown = function (event) { + this.cubeColorMaterial.alpha = this.torusTextureMaterial.alpha = this.loadedMeshMaterial.alpha = this.aValues[this.aValuesP]; + alert('Alpha: ' + this.aValues[this.aValuesP]); + this.aValuesP++; + if (this.aValuesP > this.aValues.length - 1) + this.aValuesP = 0; + }; + MaterialAlphaTest.prototype.render = function (dt) { + if (this.meshes) + for (var c = 0; c < this.meshes.length; c++) + this.meshes[c].rotationY += .35; + this.view.render(); + }; + MaterialAlphaTest.prototype.onResourceComplete = function (event) { + var loader = event.target; + var l = loader.baseDependency.assets.length; + for (var c = 0; c < l; c++) { + var d = loader.baseDependency.assets[c]; + console.log(d.name); + switch (d.assetType) { + case AssetType.MESH: + var mesh = d; + this.loadedMesh = mesh; + if (d.name == 'Mesh_g0') { + this.loadedMesh = mesh; + mesh.y = -400; + mesh.transform.scale = new Vector3D(5, 5, 5); + } + else { + mesh.transform.scale = new Vector3D(3.5, 3.5, 3.5); + } + if (this.loadedMeshMaterial) + mesh.material = this.loadedMeshMaterial; + this.view.scene.addChild(mesh); + this.meshes.push(mesh); + this.raf.start(); + break; + case AssetType.TEXTURE: + // Loaded Texture + var tx = d; + // Light Picker + this.staticLightPicker = new StaticLightPicker([this.light, this.lightB]); + // Material for loaded mesh + this.loadedMeshMaterial = new TriangleMethodMaterial(tx, true, true, false); + this.loadedMeshMaterial.lightPicker = this.staticLightPicker; + this.loadedMeshMaterial.alpha = 1; + this.loadedMeshMaterial.bothSides = true; + if (this.loadedMesh) + this.loadedMesh.material = this.loadedMeshMaterial; + // Torus + var torus = new PrimitiveTorusPrefab(150, 50, 64, 64); + // Torus Texture Material + this.torusTextureMaterial = new TriangleMethodMaterial(tx, true, true, false); + this.torusTextureMaterial.lightPicker = this.staticLightPicker; + this.torusTextureMaterial.bothSides = true; + this.torusTextureMaterial.alpha = .8; + torus.material = this.torusTextureMaterial; + // Torus Mesh ( left ) + var torusMesh = torus.getNewObject(); + torusMesh.rotationX = 90; + torusMesh.x = 600; + this.meshes.push(torusMesh); + this.view.scene.addChild(torusMesh); + var cube = new PrimitiveCubePrefab(300, 300, 300, 20, 20, 20); + // Torus Color Material + this.cubeColorMaterial = new TriangleMethodMaterial(0x0090ff); + this.cubeColorMaterial.lightPicker = this.staticLightPicker; + this.cubeColorMaterial.alpha = .8; + this.cubeColorMaterial.bothSides = true; + cube.material = this.cubeColorMaterial; + // Torus Mesh ( right ) + var cubeMesh = cube.getNewObject(); + cubeMesh.rotationX = 90; + cubeMesh.x = -600; + this.meshes.push(cubeMesh); + this.view.scene.addChild(cubeMesh); + this.capsuleColorMaterial = new TriangleMethodMaterial(0x00ffff); + this.capsuleColorMaterial.lightPicker = this.staticLightPicker; + var capsule = new PrimitiveCapsulePrefab(100, 200); + capsule.material = this.capsuleColorMaterial; + // Torus Mesh ( right ) + var capsuleMesh = capsule.getNewObject(); + this.meshes.push(capsuleMesh); + this.view.scene.addChild(capsuleMesh); + this.cubeColorMaterial.alpha = this.torusTextureMaterial.alpha = this.loadedMeshMaterial.alpha = 1; + break; + } + } + }; + MaterialAlphaTest.prototype.onResize = function (event) { + if (event === void 0) { event = null; } + this.view.y = 0; + this.view.x = 0; + this.view.width = window.innerWidth; + this.view.height = window.innerHeight; + }; + return MaterialAlphaTest; +})(); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/materialalphatest.ts"],"names":["MaterialAlphaTest","MaterialAlphaTest.constructor","MaterialAlphaTest.onMouseDown","MaterialAlphaTest.render","MaterialAlphaTest.onResourceComplete","MaterialAlphaTest.onResize"],"mappings":"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","file":"materials/MaterialAlphaTest.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import Scene\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/Scene\");\nimport View\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport BlendMode\t\t\t\t\t= require(\"awayjs-core/lib/core/base/BlendMode\");\nimport Vector3D\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetLibrary\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLibrary\");\nimport AssetLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoader\");\nimport AssetLoaderToken\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoaderToken\");\nimport AssetType\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLLoader\");\nimport URLLoaderDataFormat\t\t\t= require(\"awayjs-core/lib/core/net/URLLoaderDataFormat\");\nimport URLRequest\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport DirectionalLight\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\nimport Mesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport LoaderEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/LoaderEvent\");\nimport StaticLightPicker\t\t\t= require(\"awayjs-core/lib/materials/lightpickers/StaticLightPicker\");\nimport PrimitiveTorusPrefab\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveTorusPrefab\");\nimport PrimitiveCubePrefab\t\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveCubePrefab\");\nimport PrimitiveCapsulePrefab\t\t= require(\"awayjs-core/lib/prefabs/PrimitiveCapsulePrefab\");\nimport PerspectiveProjection\t\t= require(\"awayjs-core/lib/projections/PerspectiveProjection\");\nimport ImageTexture\t\t\t\t\t= require(\"awayjs-core/lib/textures/ImageTexture\");\nimport Debug\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport RequestAnimationFrame\t\t= require(\"awayjs-core/lib/utils/RequestAnimationFrame\");\n\nimport DefaultRenderer\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\nimport TriangleMethodMaterial\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\n\nimport OBJParser\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/OBJParser\");\n\nclass MaterialAlphaTest\n{\n\n\tprivate height : number = 0;\n\n\tprivate token:AssetLoaderToken;\n\tprivate view:View;\n\tprivate raf:RequestAnimationFrame;\n\tprivate meshes  : Array<Mesh> = new Array<Mesh>();\n\tprivate loadedMeshMaterial:TriangleMethodMaterial;\n\tprivate light:DirectionalLight;\n\tprivate lightB:DirectionalLight;\n\tprivate loadedMesh:Mesh;\n\n\tprivate aValues:Array<number> = Array<number>(0, .1, .5, .8, .9, .99, 1);\n\tprivate aValuesP:number = 0;\n\n\tprivate torusTextureMaterial:TriangleMethodMaterial;\n\tprivate cubeColorMaterial:TriangleMethodMaterial;\n\tprivate capsuleColorMaterial:TriangleMethodMaterial;\n\tprivate staticLightPicker:StaticLightPicker;\n\n\tconstructor()\n\t{\n\t\tDebug.LOG_PI_ERRORS = false;\n\t\tDebug.THROW_ERRORS = false;\n\n\t\tthis.view = new View(new DefaultRenderer());\n\t\tthis.raf = new RequestAnimationFrame(this.render, this);\n\t\tthis.onResize();\n\n\t\tthis.light = new DirectionalLight();\n\t\tthis.light.color = 0xFFFFFF;\n\t\tthis.light.direction = new Vector3D(1, 1, 0);\n\t\tthis.light.ambient = 0;\n\t\tthis.light.ambientColor = 0xFFFFFF;\n\t\tthis.light.diffuse = 1;\n\t\tthis.light.specular = 1;\n\n\t\tthis.lightB = new DirectionalLight();\n\t\tthis.lightB.color= 0xFF0000;\n\t\tthis.lightB.direction = new Vector3D(-1, 0, 1);\n\t\tthis.lightB.ambient = 0;\n\t\tthis.lightB.ambientColor = 0xFFFFFF;\n\t\tthis.lightB.diffuse = 1;\n\t\tthis.lightB.specular = 1;\n\n\t\tthis.view.scene.addChild(this.light);\n\t\tthis.view.scene.addChild(this.lightB);\n\n\t\tthis.view.backgroundColor = 0x222222;\n\n\t\tAssetLibrary.enableParser(OBJParser);\n\n\t\tthis.token = AssetLibrary.load(new URLRequest('assets/platonic.obj'));\n\t\tthis.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE , (event:LoaderEvent) => this.onResourceComplete(event));\n\n\t\tthis.token = AssetLibrary.load(new URLRequest('assets/dots.png') );\n\t\tthis.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\n\t\twindow.onresize = (event:UIEvent) => this.onResize(event);\n\t\tdocument.onmousedown = (event:MouseEvent) => this.onMouseDown(event);\n\t}\n\n\tprivate onMouseDown(event:MouseEvent)\n\t{\n\t\tthis.cubeColorMaterial.alpha = this.torusTextureMaterial.alpha = this.loadedMeshMaterial.alpha = this.aValues[this.aValuesP];\n\n\t\talert( 'Alpha: ' + this.aValues[this.aValuesP]);\n\n\t\tthis.aValuesP++;\n\n\t\tif (this.aValuesP > this.aValues.length -1)\n\t\t\tthis.aValuesP  = 0;\n\t}\n\n\tprivate render(dt:number)\n\t{\n\t\tif (this.meshes)\n\t\t\tfor (var c:number = 0; c < this.meshes.length; c++)\n\t\t\t\tthis.meshes[c].rotationY += .35;\n\n\t\tthis.view.render();\n\t}\n\n\tpublic onResourceComplete(event:LoaderEvent)\n\t{\n\t\tvar loader:AssetLoader = <AssetLoader> event.target;\n\t\tvar l:number = loader.baseDependency.assets.length\n\n\t\tfor (var c:number = 0; c < l; c ++) {\n\n\t\t\tvar d:IAsset = loader.baseDependency.assets[c];\n\n\t\t\tconsole.log( d.name);\n\n\t\t\tswitch (d.assetType) {\n\t\t\t\tcase AssetType.MESH:\n\t\t\t\t\tvar mesh:Mesh = <Mesh> d;\n\n\t\t\t\t\tthis.loadedMesh = mesh;\n\n\t\t\t\t\tif (d.name == 'Mesh_g0') {\n\t\t\t\t\t\tthis.loadedMesh = mesh;\n\t\t\t\t\t\tmesh.y = -400;\n\t\t\t\t\t\tmesh.transform.scale = new Vector3D(5, 5, 5);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tmesh.transform.scale = new Vector3D(3.5, 3.5, 3.5);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (this.loadedMeshMaterial)\n\t\t\t\t\t\tmesh.material = this.loadedMeshMaterial;\n\n\t\t\t\t\tthis.view.scene.addChild(mesh);\n\t\t\t\t\tthis.meshes.push(mesh);\n\n\t\t\t\t\tthis.raf.start();\n\t\t\t\t\tbreak;\n\t\t\t\tcase AssetType.TEXTURE:\n\t\t\t\t\t// Loaded Texture\n\t\t\t\t\tvar tx:ImageTexture = <ImageTexture> d;\n\n\t\t\t\t\t// Light Picker\n\t\t\t\t\tthis.staticLightPicker = new StaticLightPicker( [this.light , this.lightB ] );\n\n\t\t\t\t\t// Material for loaded mesh\n\t\t\t\t\tthis.loadedMeshMaterial = new TriangleMethodMaterial( tx, true, true, false );\n\t\t\t\t\tthis.loadedMeshMaterial.lightPicker = this.staticLightPicker;\n\t\t\t\t\tthis.loadedMeshMaterial.alpha = 1;\n\t\t\t\t\tthis.loadedMeshMaterial.bothSides = true;\n\n\t\t\t\t\tif (this.loadedMesh)\n\t\t\t\t\t\tthis.loadedMesh.material = this.loadedMeshMaterial;\n\n\t\t\t\t\t// Torus\n\t\t\t\t\tvar torus:PrimitiveTorusPrefab = new PrimitiveTorusPrefab(150 , 50 , 64 , 64);\n\n\t\t\t\t\t// Torus Texture Material\n\t\t\t\t\tthis.torusTextureMaterial = new TriangleMethodMaterial(tx, true, true, false);\n\t\t\t\t\tthis.torusTextureMaterial.lightPicker = this.staticLightPicker ;\n\t\t\t\t\tthis.torusTextureMaterial.bothSides = true;\n\t\t\t\t\tthis.torusTextureMaterial.alpha = .8;\n\n\t\t\t\t\ttorus.material = this.torusTextureMaterial;\n\n\t\t\t\t\t// Torus Mesh ( left )\n\t\t\t\t\tvar torusMesh:Mesh = <Mesh> torus.getNewObject();\n\t\t\t\t\ttorusMesh.rotationX = 90;\n\t\t\t\t\ttorusMesh.x = 600;\n\t\t\t\t\tthis.meshes.push(torusMesh);\n\t\t\t\t\tthis.view.scene.addChild(torusMesh);\n\n\t\t\t\t\tvar cube:PrimitiveCubePrefab = new PrimitiveCubePrefab(300, 300, 300, 20, 20, 20);\n\n\t\t\t\t\t// Torus Color Material\n\t\t\t\t\tthis.cubeColorMaterial = new TriangleMethodMaterial(0x0090ff);\n\t\t\t\t\tthis.cubeColorMaterial.lightPicker = this.staticLightPicker ;\n\t\t\t\t\tthis.cubeColorMaterial.alpha = .8;\n\t\t\t\t\tthis.cubeColorMaterial.bothSides = true;\n\n\t\t\t\t\tcube.material = this.cubeColorMaterial;\n\n\t\t\t\t\t// Torus Mesh ( right )\n\t\t\t\t\tvar cubeMesh:Mesh = <Mesh> cube.getNewObject();\n\t\t\t\t\tcubeMesh.rotationX = 90;\n\t\t\t\t\tcubeMesh.x = -600;\n\t\t\t\t\tthis.meshes.push(cubeMesh);\n\t\t\t\t\tthis.view.scene.addChild(cubeMesh);\n\n\t\t\t\t\tthis.capsuleColorMaterial = new TriangleMethodMaterial(0x00ffff);\n\t\t\t\t\tthis.capsuleColorMaterial.lightPicker = this.staticLightPicker;\n\n\t\t\t\t\tvar capsule:PrimitiveCapsulePrefab = new PrimitiveCapsulePrefab(100, 200);\n\n\t\t\t\t\tcapsule.material = this.capsuleColorMaterial;\n\n\t\t\t\t\t// Torus Mesh ( right )\n\t\t\t\t\tvar capsuleMesh:Mesh = <Mesh> capsule.getNewObject();\n\t\t\t\t\tthis.meshes.push(capsuleMesh);\n\t\t\t\t\tthis.view.scene.addChild(capsuleMesh);\n\n\t\t\t\t\tthis.cubeColorMaterial.alpha = this.torusTextureMaterial.alpha = this.loadedMeshMaterial.alpha = 1;\n\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic onResize(event:UIEvent = null)\n\t{\n\t\tthis.view.y = 0;\n\t\tthis.view.x = 0;\n\n\t\tthis.view.width = window.innerWidth;\n\t\tthis.view.height = window.innerHeight;\n\t}\n}"]} \ No newline at end of file diff --git a/tests/materials/MaterialEnvMapTest.js b/tests/materials/MaterialEnvMapTest.js new file mode 100755 index 000000000..cc0ef05cf --- /dev/null +++ b/tests/materials/MaterialEnvMapTest.js @@ -0,0 +1,75 @@ +var View = require("awayjs-core/lib/containers/View"); +var AssetLibrary = require("awayjs-core/lib/core/library/AssetLibrary"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var AssetEvent = require("awayjs-core/lib/events/AssetEvent"); +var LoaderEvent = require("awayjs-core/lib/events/LoaderEvent"); +var Debug = require("awayjs-core/lib/utils/Debug"); +var RequestAnimationFrame = require("awayjs-core/lib/utils/RequestAnimationFrame"); +var DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +var AWDParser = require("awayjs-renderergl/lib/parsers/AWDParser"); +/** + * + */ +var MaterialEnvMapTest = (function () { + function MaterialEnvMapTest() { + var _this = this; + Debug.LOG_PI_ERRORS = true; + Debug.THROW_ERRORS = false; + AssetLibrary.enableParser(AWDParser); + this._token = AssetLibrary.load(new URLRequest('assets/EnvMapTest.awd')); + this._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this._token.addEventListener(AssetEvent.ASSET_COMPLETE, function (event) { return _this.onAssetComplete(event); }); + this._view = new View(new DefaultRenderer()); + this._timer = new RequestAnimationFrame(this.render, this); + window.onresize = function () { return _this.resize(); }; + this._timer.start(); + this.resize(); + } + MaterialEnvMapTest.prototype.resize = function (event) { + if (event === void 0) { event = null; } + this._view.y = 0; + this._view.x = 0; + this._view.width = window.innerWidth; + this._view.height = window.innerHeight; + }; + MaterialEnvMapTest.prototype.render = function (dt) { + if (this._torus) + this._torus.rotationY += 1; + this._view.render(); + this._view.camera.z = -2000; + }; + MaterialEnvMapTest.prototype.onAssetComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('away.events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name)); + console.log('------------------------------------------------------------------------------'); + }; + MaterialEnvMapTest.prototype.onResourceComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('away.events.LoaderEvent.RESOURCE_COMPLETE', event); + console.log('------------------------------------------------------------------------------'); + var loader = event.target; + var numAssets = loader.baseDependency.assets.length; + for (var i = 0; i < numAssets; ++i) { + var asset = loader.baseDependency.assets[i]; + console.log(asset.assetType); + switch (asset.assetType) { + case AssetType.SKYBOX: + var skybox = asset; + this._view.scene.addChild(skybox); + break; + case AssetType.MESH: + this._torus = asset; + this._view.scene.addChild(this._torus); + break; + case AssetType.GEOMETRY: + break; + case AssetType.MATERIAL: + break; + } + } + }; + return MaterialEnvMapTest; +})(); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["materials/materialenvmaptest.ts"],"names":["MaterialEnvMapTest","MaterialEnvMapTest.constructor","MaterialEnvMapTest.resize","MaterialEnvMapTest.render","MaterialEnvMapTest.onAssetComplete","MaterialEnvMapTest.onResourceComplete"],"mappings":"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","file":"materials/MaterialEnvMapTest.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import View\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport Vector3D\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetLibrary\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLibrary\");\nimport AssetLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoader\");\nimport AssetLoaderToken\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoaderToken\");\nimport AssetType\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLRequest\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport Mesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport Skybox\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Skybox\");\nimport AssetEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/AssetEvent\");\nimport LoaderEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/LoaderEvent\");\nimport Debug\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport RequestAnimationFrame\t\t= require(\"awayjs-core/lib/utils/RequestAnimationFrame\");\n\nimport DefaultRenderer\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\n\nimport AWDParser\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/AWDParser\");\n\n/**\n *\n */\nclass MaterialEnvMapTest\n{\n\tprivate _view:View;\n\tprivate _token:AssetLoaderToken;\n\tprivate _timer:RequestAnimationFrame;\n\tprivate _torus:Mesh;\n\n\tconstructor()\n\t{\n\t\tDebug.LOG_PI_ERRORS = true;\n\t\tDebug.THROW_ERRORS = false;\n\n\t\tAssetLibrary.enableParser(AWDParser) ;\n\n\t\tthis._token = AssetLibrary.load(new URLRequest('assets/EnvMapTest.awd'));\n\t\tthis._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\t\tthis._token.addEventListener(AssetEvent.ASSET_COMPLETE, (event:AssetEvent) => this.onAssetComplete(event));\n\n\t\tthis._view = new View(new DefaultRenderer());\n\t\tthis._timer = new RequestAnimationFrame(this.render, this);\n\n\t\twindow.onresize = () => this.resize();\n\n\t\tthis._timer.start();\n\t\tthis.resize();\n\t}\n\n\tprivate resize(event:UIEvent = null)\n\t{\n\t\tthis._view.y = 0;\n\t\tthis._view.x = 0;\n\t\tthis._view.width = window.innerWidth;\n\t\tthis._view.height = window.innerHeight;\n\t}\n\n\tprivate render(dt:number) //animate based on dt for firefox\n\t{\n\t\tif (this._torus)\n\t\t\tthis._torus.rotationY += 1;\n\n\t\tthis._view.render();\n\t\tthis._view.camera.z = -2000;\n\t}\n\n\tpublic onAssetComplete(event:AssetEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('away.events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name));\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t}\n\n\tpublic onResourceComplete(event:LoaderEvent)\n\t{\n\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('away.events.LoaderEvent.RESOURCE_COMPLETE', event);\n\t\tconsole.log('------------------------------------------------------------------------------');\n\n\t\tvar loader:AssetLoader = <AssetLoader> event.target;\n\t\tvar numAssets:number = loader.baseDependency.assets.length;\n\n\t\tfor (var i:number = 0; i < numAssets; ++i) {\n\t\t\tvar asset:IAsset = loader.baseDependency.assets[i];\n\n\t\t\tconsole.log(asset.assetType);\n\n\t\t\tswitch (asset.assetType) {\n\t\t\t\tcase AssetType.SKYBOX:\n\n\t\t\t\t\tvar skybox:Skybox = <Skybox> asset;\n\t\t\t\t\tthis._view.scene.addChild(skybox);\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.MESH:\n\n\t\t\t\t\tthis._torus = <Mesh> asset;\n\t\t\t\t\tthis._view.scene.addChild(this._torus);\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.GEOMETRY:\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.MATERIAL:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n}"]} \ No newline at end of file diff --git a/tests/parsers/AWDParserTest.js b/tests/parsers/AWDParserTest.js new file mode 100755 index 000000000..dbdfce80d --- /dev/null +++ b/tests/parsers/AWDParserTest.js @@ -0,0 +1,69 @@ +var View = require("awayjs-core/lib/containers/View"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AssetLibrary = require("awayjs-core/lib/core/library/AssetLibrary"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var AssetEvent = require("awayjs-core/lib/events/AssetEvent"); +var LoaderEvent = require("awayjs-core/lib/events/LoaderEvent"); +var Debug = require("awayjs-core/lib/utils/Debug"); +var RequestAnimationFrame = require("awayjs-core/lib/utils/RequestAnimationFrame"); +var DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +var AWDParser = require("awayjs-renderergl/lib/parsers/AWDParser"); +var AWDParserTest = (function () { + function AWDParserTest() { + var _this = this; + Debug.LOG_PI_ERRORS = true; + Debug.THROW_ERRORS = false; + AssetLibrary.enableParser(AWDParser); + this._token = AssetLibrary.load(new URLRequest('assets/suzanne.awd')); + this._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this._token.addEventListener(AssetEvent.ASSET_COMPLETE, function (event) { return _this.onAssetComplete(event); }); + this._view = new View(new DefaultRenderer()); + this._timer = new RequestAnimationFrame(this.render, this); + window.onresize = function (event) { return _this.resize(event); }; + this._timer.start(); + this.resize(); + } + AWDParserTest.prototype.resize = function (event) { + if (event === void 0) { event = null; } + this._view.y = 0; + this._view.x = 0; + this._view.width = window.innerWidth; + this._view.height = window.innerHeight; + }; + AWDParserTest.prototype.render = function (dt) { + if (this._suzanne) + this._suzanne.rotationY += 1; + this._view.render(); + this._view.camera.z = -2000; + }; + AWDParserTest.prototype.onAssetComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name)); + console.log('------------------------------------------------------------------------------'); + }; + AWDParserTest.prototype.onResourceComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('events.LoaderEvent.RESOURCE_COMPLETE', event); + console.log('------------------------------------------------------------------------------'); + var loader = event.target; + var numAssets = loader.baseDependency.assets.length; + for (var i = 0; i < numAssets; ++i) { + var asset = loader.baseDependency.assets[i]; + switch (asset.assetType) { + case AssetType.MESH: + this._suzanne = asset; + this._suzanne.transform.scale = new Vector3D(600, 600, 600); + this._view.scene.addChild(this._suzanne); + break; + case AssetType.GEOMETRY: + break; + case AssetType.MATERIAL: + break; + } + } + }; + return AWDParserTest; +})(); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/awdparsertest.ts"],"names":["AWDParserTest","AWDParserTest.constructor","AWDParserTest.resize","AWDParserTest.render","AWDParserTest.onAssetComplete","AWDParserTest.onResourceComplete"],"mappings":"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","file":"parsers/AWDParserTest.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import View\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport Vector3D\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetLibrary\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLibrary\");\nimport AssetLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoader\");\nimport AssetLoaderToken\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoaderToken\");\nimport AssetType\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLRequest\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport Mesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport AssetEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/AssetEvent\");\nimport LoaderEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/LoaderEvent\");\nimport Debug\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport RequestAnimationFrame\t\t= require(\"awayjs-core/lib/utils/RequestAnimationFrame\");\n\nimport DefaultRenderer\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\nimport TriangleMethodMaterial\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\n\nimport AWDParser\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/AWDParser\");\n\nclass AWDParserTest\n{\n\n\tprivate _view:View;\n\tprivate _token:AssetLoaderToken;\n\tprivate _timer:RequestAnimationFrame;\n\tprivate _suzanne:Mesh;\n\n\tconstructor()\n\t{\n\t\tDebug.LOG_PI_ERRORS = true;\n\t\tDebug.THROW_ERRORS = false;\n\n\t\tAssetLibrary.enableParser(AWDParser) ;\n\n\t\tthis._token = AssetLibrary.load(new URLRequest('assets/suzanne.awd'));\n\t\tthis._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\t\tthis._token.addEventListener(AssetEvent.ASSET_COMPLETE, (event:AssetEvent) => this.onAssetComplete(event));\n\n\t\tthis._view = new View(new DefaultRenderer());\n\t\tthis._timer = new RequestAnimationFrame(this.render, this);\n\n\t\twindow.onresize = (event:UIEvent) => this.resize(event);\n\n\t\tthis._timer.start();\n\t\tthis.resize();\n\t}\n\n\tprivate resize(event:UIEvent = null)\n\t{\n\t\tthis._view.y = 0;\n\t\tthis._view.x = 0;\n\t\tthis._view.width = window.innerWidth;\n\t\tthis._view.height = window.innerHeight;\n\t}\n\n\tprivate render(dt:number) //animate based on dt for firefox\n\t{\n\t\tif (this._suzanne)\n\t\t\tthis._suzanne.rotationY += 1;\n\n\t\tthis._view.render();\n\t\tthis._view.camera.z = -2000;\n\t}\n\n\tpublic onAssetComplete(event:AssetEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name));\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t}\n\n\tpublic onResourceComplete(event:LoaderEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('events.LoaderEvent.RESOURCE_COMPLETE' , event);\n\t\tconsole.log('------------------------------------------------------------------------------');\n\n\t\tvar loader:AssetLoader = <AssetLoader> event.target;\n\t\tvar numAssets:number = loader.baseDependency.assets.length;\n\n\t\tfor(var i:number = 0; i < numAssets; ++i) {\n\t\t\tvar asset:IAsset = loader.baseDependency.assets[i];\n\n\t\t\tswitch (asset.assetType) {\n\t\t\t\tcase AssetType.MESH:\n\n\t\t\t\t\tthis._suzanne = <Mesh> asset;\n\t\t\t\t\tthis._suzanne.transform.scale = new Vector3D(600, 600, 600);\n\n\t\t\t\t\tthis._view.scene.addChild(this._suzanne);\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.GEOMETRY:\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.MATERIAL:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n}"]} \ No newline at end of file diff --git a/tests/parsers/AWDSuzanne.js b/tests/parsers/AWDSuzanne.js new file mode 100755 index 000000000..8526aa1e6 --- /dev/null +++ b/tests/parsers/AWDSuzanne.js @@ -0,0 +1,103 @@ +var View = require("awayjs-core/lib/containers/View"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AssetLibrary = require("awayjs-core/lib/core/library/AssetLibrary"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +var AssetEvent = require("awayjs-core/lib/events/AssetEvent"); +var LoaderEvent = require("awayjs-core/lib/events/LoaderEvent"); +var StaticLightPicker = require("awayjs-core/lib/materials/lightpickers/StaticLightPicker"); +var Debug = require("awayjs-core/lib/utils/Debug"); +var RequestAnimationFrame = require("awayjs-core/lib/utils/RequestAnimationFrame"); +var DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +var AWDParser = require("awayjs-renderergl/lib/parsers/AWDParser"); +var AWDSuzanne = (function () { + function AWDSuzanne() { + var _this = this; + this.lookAtPosition = new Vector3D(); + this._cameraIncrement = 0; + Debug.LOG_PI_ERRORS = true; + Debug.THROW_ERRORS = false; + AssetLibrary.enableParser(AWDParser); + this._token = AssetLibrary.load(new URLRequest('assets/suzanne.awd')); + this._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this._token.addEventListener(AssetEvent.ASSET_COMPLETE, function (event) { return _this.onAssetComplete(event); }); + this._view = new View(new DefaultRenderer()); + this._view.camera.projection.far = 6000; + this._timer = new RequestAnimationFrame(this.render, this); + this._light = new DirectionalLight(); + this._light.color = 0x683019; //683019; + this._light.direction = new Vector3D(1, 0, 0); + this._light.ambient = 0.1; //0.05;//.4; + this._light.ambientColor = 0x85b2cd; //4F6877;//313D51; + this._light.diffuse = 2.8; + this._light.specular = 1.8; + this._view.scene.addChild(this._light); + this._lightPicker = new StaticLightPicker([this._light]); + window.onresize = function (event) { return _this.resize(event); }; + this._timer.start(); + this.resize(); + } + AWDSuzanne.prototype.resize = function (event) { + if (event === void 0) { event = null; } + this._view.y = 0; + this._view.x = 0; + this._view.width = window.innerWidth; + this._view.height = window.innerHeight; + }; + AWDSuzanne.prototype.render = function (dt) { + if (this._view.camera) { + this._view.camera.lookAt(this.lookAtPosition); + this._cameraIncrement += 0.01; + this._view.camera.x = Math.cos(this._cameraIncrement) * 1400; + this._view.camera.z = Math.sin(this._cameraIncrement) * 1400; + this._light.x = Math.cos(this._cameraIncrement) * 1400; + this._light.y = Math.sin(this._cameraIncrement) * 1400; + } + this._view.render(); + }; + AWDSuzanne.prototype.onAssetComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('away.events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name)); + console.log('------------------------------------------------------------------------------'); + }; + AWDSuzanne.prototype.onResourceComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('away.events.LoaderEvent.RESOURCE_COMPLETE', event); + console.log('------------------------------------------------------------------------------'); + var loader = event.target; + var numAssets = loader.baseDependency.assets.length; + for (var i = 0; i < numAssets; ++i) { + var asset = loader.baseDependency.assets[i]; + switch (asset.assetType) { + case AssetType.MESH: + this._suzanne = asset; + this._suzanne.material.lightPicker = this._lightPicker; + this._suzanne.y = -100; + for (var c = 0; c < 80; c++) { + var scale = this.getRandom(50, 200); + var clone = this._suzanne.clone(); + clone.x = this.getRandom(-2000, 2000); + clone.y = this.getRandom(-2000, 2000); + clone.z = this.getRandom(-2000, 2000); + clone.transform.scale = new Vector3D(scale, scale, scale); + clone.rotationY = this.getRandom(0, 360); + this._view.scene.addChild(clone); + } + this._suzanne.transform.scale = new Vector3D(500, 500, 500); + this._view.scene.addChild(this._suzanne); + break; + case AssetType.GEOMETRY: + break; + case AssetType.MATERIAL: + break; + } + } + }; + AWDSuzanne.prototype.getRandom = function (min, max) { + return Math.random() * (max - min) + min; + }; + return AWDSuzanne; +})(); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/awdsuzanne.ts"],"names":["AWDSuzanne","AWDSuzanne.constructor","AWDSuzanne.resize","AWDSuzanne.render","AWDSuzanne.onAssetComplete","AWDSuzanne.onResourceComplete","AWDSuzanne.getRandom"],"mappings":"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","file":"parsers/AWDSuzanne.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import View\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport Vector3D\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetLibrary\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLibrary\");\nimport AssetLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoader\");\nimport AssetLoaderToken\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoaderToken\");\nimport AssetType\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLRequest\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport DirectionalLight\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\nimport Mesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport AssetEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/AssetEvent\");\nimport LoaderEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/LoaderEvent\");\nimport StaticLightPicker\t\t\t= require(\"awayjs-core/lib/materials/lightpickers/StaticLightPicker\");\nimport Debug\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport RequestAnimationFrame\t\t= require(\"awayjs-core/lib/utils/RequestAnimationFrame\");\n\nimport DefaultRenderer\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\nimport TriangleMethodMaterial\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\n\nimport AWDParser\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/AWDParser\");\n\nclass AWDSuzanne\n{\n\tprivate _view:View;\n\tprivate _token:AssetLoaderToken;\n\tprivate _timer:RequestAnimationFrame;\n\tprivate _suzanne:Mesh;\n\tprivate _light:DirectionalLight;\n\tprivate _lightPicker:StaticLightPicker;\n\tprivate lookAtPosition:Vector3D = new Vector3D();\n\tprivate _cameraIncrement:number = 0;\n\n\tconstructor()\n\t{\n\t\tDebug.LOG_PI_ERRORS = true;\n\t\tDebug.THROW_ERRORS = false;\n\n\t\tAssetLibrary.enableParser(AWDParser) ;\n\n\t\tthis._token = AssetLibrary.load(new URLRequest('assets/suzanne.awd'));\n\t\tthis._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\t\tthis._token.addEventListener(AssetEvent.ASSET_COMPLETE, (event:AssetEvent) => this.onAssetComplete(event));\n\n\t\tthis._view = new View(new DefaultRenderer());\n\t\tthis._view.camera.projection.far  = 6000;\n\t\tthis._timer = new RequestAnimationFrame(this.render, this);\n\n\t\tthis._light = new DirectionalLight();\n\t\tthis._light.color = 0x683019;//683019;\n\t\tthis._light.direction = new Vector3D( 1 , 0 ,0 );\n\t\tthis._light.ambient = 0.1;//0.05;//.4;\n\t\tthis._light.ambientColor = 0x85b2cd;//4F6877;//313D51;\n\t\tthis._light.diffuse = 2.8;\n\t\tthis._light.specular = 1.8;\n\t\tthis._view.scene.addChild(this._light);\n\n\t\tthis._lightPicker = new StaticLightPicker([this._light]);\n\n\t\twindow.onresize = (event:UIEvent) => this.resize(event);\n\n\t\tthis._timer.start();\n\t\tthis.resize();\n\t}\n\n\tprivate resize(event:UIEvent = null)\n\t{\n\t\tthis._view.y = 0;\n\t\tthis._view.x = 0;\n\t\tthis._view.width = window.innerWidth;\n\t\tthis._view.height = window.innerHeight;\n\t}\n\n\tprivate render(dt:number) //animate based on dt for firefox\n\t{\n\t\tif (this._view.camera) {\n\t\t\tthis._view.camera.lookAt(this.lookAtPosition) ;\n\t\t\tthis._cameraIncrement += 0.01;\n\t\t\tthis._view.camera.x = Math.cos(this._cameraIncrement)*1400;\n\t\t\tthis._view.camera.z = Math.sin(this._cameraIncrement)*1400;\n\n\t\t\tthis._light.x = Math.cos(this._cameraIncrement)*1400;\n\t\t\tthis._light.y = Math.sin(this._cameraIncrement)*1400;\n\t\t}\n\n\t\tthis._view.render();\n\t}\n\n\tpublic onAssetComplete(event:AssetEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('away.events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name));\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t}\n\n\tpublic onResourceComplete(event:LoaderEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('away.events.LoaderEvent.RESOURCE_COMPLETE' , event);\n\t\tconsole.log('------------------------------------------------------------------------------');\n\n\t\tvar loader:AssetLoader = <AssetLoader> event.target;\n\t\tvar numAssets:number = loader.baseDependency.assets.length;\n\n\t\tfor(var i:number = 0; i < numAssets; ++i) {\n\t\t\tvar asset:IAsset = loader.baseDependency.assets[i];\n\n\t\t\tswitch (asset.assetType) {\n\t\t\t\tcase AssetType.MESH:\n\n\t\t\t\t\tthis._suzanne = <Mesh> asset;\n\n\t\t\t\t\t(<TriangleMethodMaterial> this._suzanne.material).lightPicker = this._lightPicker;\n\t\t\t\t\tthis._suzanne.y = -100;\n\n\n\t\t\t\t\tfor ( var c : number = 0 ; c < 80 ; c ++ )\n\t\t\t\t\t{\n\t\t\t\t\t\tvar scale:number = this.getRandom( 50 , 200 );\n\t\t\t\t\t\tvar clone:Mesh = <Mesh> this._suzanne.clone();\n\t\t\t\t\t\t\tclone.x = this.getRandom(-2000 , 2000);\n\t\t\t\t\t\t\tclone.y = this.getRandom(-2000 , 2000);\n\t\t\t\t\t\t\tclone.z = this.getRandom(-2000 , 2000);\n\t\t\t\t\t\t\tclone.transform.scale = new Vector3D(scale, scale, scale);\n\t\t\t\t\t\t\tclone.rotationY = this.getRandom(0 , 360);\n\t\t\t\t\t\tthis._view.scene.addChild( clone );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tthis._suzanne.transform.scale = new Vector3D(500, 500, 500);\n\n\t\t\t\t\tthis._view.scene.addChild(this._suzanne);\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.GEOMETRY:\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase AssetType.MATERIAL:\n\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getRandom(min:number, max:number):number\n\t{\n\t\treturn Math.random()*(max - min) + min;\n\t}\n}"]} \ No newline at end of file diff --git a/tests/parsers/ObjChiefTestDay.js b/tests/parsers/ObjChiefTestDay.js new file mode 100755 index 000000000..14969a683 --- /dev/null +++ b/tests/parsers/ObjChiefTestDay.js @@ -0,0 +1,119 @@ +var DisplayObjectContainer = require("awayjs-core/lib/containers/DisplayObjectContainer"); +var View = require("awayjs-core/lib/containers/View"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AssetLibrary = require("awayjs-core/lib/core/library/AssetLibrary"); +var AssetType = require("awayjs-core/lib/core/library/AssetType"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var DirectionalLight = require("awayjs-core/lib/entities/DirectionalLight"); +var LoaderEvent = require("awayjs-core/lib/events/LoaderEvent"); +var StaticLightPicker = require("awayjs-core/lib/materials/lightpickers/StaticLightPicker"); +var Debug = require("awayjs-core/lib/utils/Debug"); +var RequestAnimationFrame = require("awayjs-core/lib/utils/RequestAnimationFrame"); +var DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +var TriangleMethodMaterial = require("awayjs-stagegl/lib/materials/TriangleMethodMaterial"); +var OBJParser = require("awayjs-renderergl/lib/parsers/OBJParser"); +/** + * + */ +var ObjChiefTestDay = (function () { + function ObjChiefTestDay() { + var _this = this; + this.meshes = new Array(); + this.spartan = new DisplayObjectContainer(); + this.spartanFlag = false; + this.terrainObjFlag = false; + Debug.LOG_PI_ERRORS = false; + Debug.THROW_ERRORS = false; + this.view = new View(new DefaultRenderer()); + this.view.camera.z = -50; + this.view.camera.y = 20; + this.view.camera.projection.near = 0.1; + this.view.backgroundColor = 0xCEC8C6; + this.raf = new RequestAnimationFrame(this.render, this); + this.light = new DirectionalLight(); + this.light.color = 0xc1582d; + this.light.direction = new Vector3D(1, 0, 0); + this.light.ambient = 0.4; + this.light.ambientColor = 0x85b2cd; + this.light.diffuse = 2.8; + this.light.specular = 1.8; + this.spartan.transform.scale = new Vector3D(.25, .25, .25); + this.spartan.y = 0; + this.view.scene.addChild(this.light); + AssetLibrary.enableParser(OBJParser); + this.token = AssetLibrary.load(new URLRequest('assets/Halo_3_SPARTAN4.obj')); + this.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this.token = AssetLibrary.load(new URLRequest('assets/terrain.obj')); + this.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this.token = AssetLibrary.load(new URLRequest('assets/masterchief_base.png')); + this.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this.token = AssetLibrary.load(new URLRequest('assets/stone_tx.jpg')); + this.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + window.onresize = function (event) { return _this.onResize(); }; + this.raf.start(); + } + ObjChiefTestDay.prototype.render = function () { + if (this.terrain) + this.terrain.rotationY += 0.4; + this.spartan.rotationY += 0.4; + this.view.render(); + }; + ObjChiefTestDay.prototype.onResourceComplete = function (event) { + var loader = event.target; + var l = loader.baseDependency.assets.length; + console.log('------------------------------------------------------------------------------'); + console.log('events.LoaderEvent.RESOURCE_COMPLETE', event, l, loader); + console.log('------------------------------------------------------------------------------'); + var loader = event.target; + var l = loader.baseDependency.assets.length; + for (var c = 0; c < l; c++) { + var d = loader.baseDependency.assets[c]; + console.log(d.name, event.url); + switch (d.assetType) { + case AssetType.MESH: + if (event.url == 'assets/Halo_3_SPARTAN4.obj') { + var mesh = d; + this.spartan.addChild(mesh); + this.spartanFlag = true; + this.meshes.push(mesh); + } + else if (event.url == 'assets/terrain.obj') { + this.terrainObjFlag = true; + this.terrain = d; + this.terrain.y = 98; + this.view.scene.addChild(this.terrain); + } + break; + case AssetType.TEXTURE: + if (event.url == 'assets/masterchief_base.png') { + this.mat = new TriangleMethodMaterial(d, true, true, false); + this.mat.lightPicker = new StaticLightPicker([this.light]); + } + else if (event.url == 'assets/stone_tx.jpg') { + this.terrainMaterial = new TriangleMethodMaterial(d, true, true, false); + this.terrainMaterial.lightPicker = new StaticLightPicker([this.light]); + } + break; + } + } + if (this.terrainObjFlag && this.terrainMaterial) { + this.terrain.material = this.terrainMaterial; + this.terrain.geometry.scaleUV(20, 20); + } + if (this.mat && this.spartanFlag) + for (var c = 0; c < this.meshes.length; c++) + this.meshes[c].material = this.mat; + this.view.scene.addChild(this.spartan); + this.onResize(); + }; + ObjChiefTestDay.prototype.onResize = function (event) { + if (event === void 0) { event = null; } + this.view.y = 0; + this.view.x = 0; + this.view.width = window.innerWidth; + this.view.height = window.innerHeight; + }; + return ObjChiefTestDay; +})(); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/objchieftestday.ts"],"names":["ObjChiefTestDay","ObjChiefTestDay.constructor","ObjChiefTestDay.render","ObjChiefTestDay.onResourceComplete","ObjChiefTestDay.onResize"],"mappings":"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","file":"parsers/ObjChiefTestDay.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import DisplayObjectContainer\t\t= require(\"awayjs-core/lib/containers/DisplayObjectContainer\");\nimport View\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport Vector3D\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetLibrary\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLibrary\");\nimport AssetLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoader\");\nimport AssetLoaderToken\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoaderToken\");\nimport AssetType\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetType\");\nimport IAsset\t\t\t\t\t\t= require(\"awayjs-core/lib/core/library/IAsset\");\nimport URLRequest\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport DirectionalLight\t\t\t\t= require(\"awayjs-core/lib/entities/DirectionalLight\");\nimport Mesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport LoaderEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/LoaderEvent\");\nimport StaticLightPicker\t\t\t= require(\"awayjs-core/lib/materials/lightpickers/StaticLightPicker\");\nimport ImageTexture\t\t\t\t\t= require(\"awayjs-core/lib/textures/ImageTexture\");\nimport Debug\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport RequestAnimationFrame\t\t= require(\"awayjs-core/lib/utils/RequestAnimationFrame\");\n\nimport DefaultRenderer\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\nimport TriangleMethodMaterial\t\t= require(\"awayjs-stagegl/lib/materials/TriangleMethodMaterial\");\n\nimport OBJParser\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/OBJParser\");\n\n/**\n * \n */\nclass ObjChiefTestDay\n{\n\tprivate token:AssetLoaderToken;\n\tprivate view:View;\n\tprivate raf:RequestAnimationFrame;\n\tprivate meshes:Array<Mesh> = new Array<Mesh>();\n\tprivate mat:TriangleMethodMaterial;\n\n\tprivate terrainMaterial:TriangleMethodMaterial;\n\n\tprivate light:DirectionalLight;\n\n\tprivate spartan:DisplayObjectContainer = new DisplayObjectContainer();\n\tprivate terrain:Mesh;\n\n\tprivate spartanFlag:boolean = false;\n\tprivate terrainObjFlag:boolean = false;\n\n\tconstructor()\n\t{\n\t\tDebug.LOG_PI_ERRORS = false;\n\t\tDebug.THROW_ERRORS = false;\n\n\t\tthis.view = new View(new DefaultRenderer());\n\t\tthis.view.camera.z = -50;\n\t\tthis.view.camera.y = 20;\n\t\tthis.view.camera.projection.near = 0.1;\n\t\tthis.view.backgroundColor = 0xCEC8C6;\n\n\t\tthis.raf = new RequestAnimationFrame(this.render, this);\n\n\t\tthis.light = new DirectionalLight();\n\t\tthis.light.color = 0xc1582d;\n\t\tthis.light.direction = new Vector3D(1, 0, 0);\n\t\tthis.light.ambient = 0.4;\n\t\tthis.light.ambientColor = 0x85b2cd;\n\t\tthis.light.diffuse = 2.8;\n\t\tthis.light.specular = 1.8;\n\n\t\tthis.spartan.transform.scale = new Vector3D(.25, .25, .25);\n\t\tthis.spartan.y = 0;\n\n\t\tthis.view.scene.addChild(this.light);\n\n\t\tAssetLibrary.enableParser(OBJParser);\n\n\t\tthis.token = AssetLibrary.load(new URLRequest('assets/Halo_3_SPARTAN4.obj'));\n\t\tthis.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\n\t\tthis.token = AssetLibrary.load(new URLRequest('assets/terrain.obj'));\n\t\tthis.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\n\t\tthis.token = AssetLibrary.load(new URLRequest('assets/masterchief_base.png'));\n\t\tthis.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\n\t\tthis.token = AssetLibrary.load(new URLRequest('assets/stone_tx.jpg'));\n\t\tthis.token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\n\t\twindow.onresize = (event:UIEvent) => this.onResize();\n\n\t\tthis.raf.start();\n\t}\n\n\tprivate render()\n\t{\n\t\tif ( this.terrain)\n\t\t\tthis.terrain.rotationY += 0.4;\n\n\t\tthis.spartan.rotationY += 0.4;\n\t\tthis.view.render();\n\t}\n\n\tpublic onResourceComplete (event:LoaderEvent)\n\t{\n\t\tvar loader:AssetLoader = <AssetLoader> event.target;\n\t\tvar l:number = loader.baseDependency.assets.length;\n\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('events.LoaderEvent.RESOURCE_COMPLETE', event, l, loader);\n\t\tconsole.log('------------------------------------------------------------------------------');\n\n\t\tvar loader:AssetLoader = <AssetLoader> event.target;\n\t\tvar l:number = loader.baseDependency.assets.length;\n\n\t\tfor (var c:number = 0; c < l; c++) {\n\n\t\t\tvar d:IAsset = loader.baseDependency.assets[c];\n\n\t\t\tconsole.log( d.name , event.url);\n\n\t\t\tswitch (d.assetType) {\n\t\t\t\tcase AssetType.MESH:\n\t\t\t\t\tif (event.url =='assets/Halo_3_SPARTAN4.obj') {\n\t\t\t\t\t\tvar mesh:Mesh = <Mesh> d;\n\n\t\t\t\t\t\tthis.spartan.addChild(mesh);\n\t\t\t\t\t\tthis.spartanFlag = true;\n\t\t\t\t\t\tthis.meshes.push(mesh);\n\t\t\t\t\t} else if (event.url =='assets/terrain.obj') {\n\t\t\t\t\t\tthis.terrainObjFlag = true;\n\t\t\t\t\t\tthis.terrain = <Mesh> d;\n\t\t\t\t\t\tthis.terrain.y = 98;\n\t\t\t\t\t\tthis.view.scene.addChild(this.terrain);\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\tcase AssetType.TEXTURE :\n\t\t\t\t\tif (event.url == 'assets/masterchief_base.png' ) {\n\t\t\t\t\t\tthis.mat = new TriangleMethodMaterial( <ImageTexture> d, true, true, false );\n\t\t\t\t\t\tthis.mat.lightPicker = new StaticLightPicker([this.light]);\n\t\t\t\t\t} else if (event.url == 'assets/stone_tx.jpg') {\n\t\t\t\t\t\tthis.terrainMaterial = new TriangleMethodMaterial(<ImageTexture> d, true, true, false);\n\t\t\t\t\t\tthis.terrainMaterial.lightPicker = new StaticLightPicker([this.light]);\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (this.terrainObjFlag && this.terrainMaterial) {\n\t\t\tthis.terrain.material = this.terrainMaterial;\n\t\t\tthis.terrain.geometry.scaleUV(20, 20);\n\t\t}\n\n\t\tif (this.mat && this.spartanFlag)\n\t\t\tfor (var c:number = 0; c < this.meshes.length; c++)\n\t\t\t\tthis.meshes[c].material = this.mat;\n\n\t\tthis.view.scene.addChild(this.spartan);\n\t\tthis.onResize();\n\t}\n\n\tpublic onResize(event:UIEvent = null)\n\t{\n\t\tthis.view.y = 0;\n\t\tthis.view.x = 0;\n\n\t\tthis.view.width = window.innerWidth;\n\t\tthis.view.height = window.innerHeight;\n\t}\n}"]} \ No newline at end of file diff --git a/tests/parsers/ObjParserTest.js b/tests/parsers/ObjParserTest.js new file mode 100755 index 000000000..c63e91ff4 --- /dev/null +++ b/tests/parsers/ObjParserTest.js @@ -0,0 +1,59 @@ +var View = require("awayjs-core/lib/containers/View"); +var Vector3D = require("awayjs-core/lib/core/geom/Vector3D"); +var AssetLibrary = require("awayjs-core/lib/core/library/AssetLibrary"); +var URLRequest = require("awayjs-core/lib/core/net/URLRequest"); +var AssetEvent = require("awayjs-core/lib/events/AssetEvent"); +var LoaderEvent = require("awayjs-core/lib/events/LoaderEvent"); +var Debug = require("awayjs-core/lib/utils/Debug"); +var RequestAnimationFrame = require("awayjs-core/lib/utils/RequestAnimationFrame"); +var DefaultRenderer = require("awayjs-stagegl/lib/core/render/DefaultRenderer"); +var OBJParser = require("awayjs-renderergl/lib/parsers/OBJParser"); +/** + * + */ +var ObjParserTest = (function () { + function ObjParserTest() { + var _this = this; + Debug.LOG_PI_ERRORS = true; + Debug.THROW_ERRORS = false; + AssetLibrary.enableParser(OBJParser); + this._token = AssetLibrary.load(new URLRequest('assets/t800.obj')); + this._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, function (event) { return _this.onResourceComplete(event); }); + this._token.addEventListener(AssetEvent.ASSET_COMPLETE, function (event) { return _this.onAssetComplete(event); }); + this._view = new View(new DefaultRenderer()); + this._timer = new RequestAnimationFrame(this.render, this); + window.onresize = function (event) { return _this.resize(event); }; + this._timer.start(); + this.resize(); + } + ObjParserTest.prototype.resize = function (event) { + if (event === void 0) { event = null; } + this._view.y = 0; + this._view.x = 0; + this._view.width = window.innerWidth; + this._view.height = window.innerHeight; + }; + ObjParserTest.prototype.render = function (dt) { + if (this._t800) + this._t800.rotationY += 1; + this._view.render(); + }; + ObjParserTest.prototype.onAssetComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name)); + console.log('------------------------------------------------------------------------------'); + }; + ObjParserTest.prototype.onResourceComplete = function (event) { + console.log('------------------------------------------------------------------------------'); + console.log('events.LoaderEvent.RESOURCE_COMPLETE', event); + console.log('------------------------------------------------------------------------------'); + console.log(AssetLibrary.getAsset('Mesh_g0')); + this._t800 = AssetLibrary.getAsset('Mesh_g0'); + this._t800.y = -200; + this._t800.transform.scale = new Vector3D(4, 4, 4); + this._view.scene.addChild(this._t800); + }; + return ObjParserTest; +})(); + +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["parsers/objparsertest.ts"],"names":["ObjParserTest","ObjParserTest.constructor","ObjParserTest.resize","ObjParserTest.render","ObjParserTest.onAssetComplete","ObjParserTest.onResourceComplete"],"mappings":"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","file":"parsers/ObjParserTest.js","sourceRoot":"/Users/robbateman/WebstormProjects/awayjs-renderergl/","sourcesContent":["import View\t\t\t\t\t\t\t= require(\"awayjs-core/lib/containers/View\");\nimport Vector3D\t\t\t\t\t\t= require(\"awayjs-core/lib/core/geom/Vector3D\");\nimport AssetLibrary\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLibrary\");\nimport AssetLoader\t\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoader\");\nimport AssetLoaderToken\t\t\t\t= require(\"awayjs-core/lib/core/library/AssetLoaderToken\");\nimport URLRequest\t\t\t\t\t= require(\"awayjs-core/lib/core/net/URLRequest\");\nimport Mesh\t\t\t\t\t\t\t= require(\"awayjs-core/lib/entities/Mesh\");\nimport AssetEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/AssetEvent\");\nimport LoaderEvent\t\t\t\t\t= require(\"awayjs-core/lib/events/LoaderEvent\");\nimport Debug\t\t\t\t\t\t= require(\"awayjs-core/lib/utils/Debug\");\nimport RequestAnimationFrame\t\t= require(\"awayjs-core/lib/utils/RequestAnimationFrame\");\n\nimport DefaultRenderer\t\t\t\t= require(\"awayjs-stagegl/lib/core/render/DefaultRenderer\");\n\nimport OBJParser\t\t\t\t\t= require(\"awayjs-renderergl/lib/parsers/OBJParser\");\n\n/**\n *\n */\nclass ObjParserTest\n{\n\tprivate _view:View;\n\tprivate _token:AssetLoaderToken;\n\tprivate _timer:RequestAnimationFrame;\n\tprivate _t800:Mesh;\n\n\tconstructor()\n\t{\n\t\tDebug.LOG_PI_ERRORS = true;\n\t\tDebug.THROW_ERRORS = false;\n\n\t\tAssetLibrary.enableParser(OBJParser) ;\n\n\t\tthis._token = AssetLibrary.load(new URLRequest('assets/t800.obj'));\n\t\tthis._token.addEventListener(LoaderEvent.RESOURCE_COMPLETE, (event:LoaderEvent) => this.onResourceComplete(event));\n\t\tthis._token.addEventListener(AssetEvent.ASSET_COMPLETE, (event:AssetEvent) => this.onAssetComplete(event));\n\n\t\tthis._view = new View(new DefaultRenderer());\n\t\tthis._timer = new RequestAnimationFrame(this.render, this);\n\n\t\twindow.onresize = (event:UIEvent) => this.resize(event);\n\n\t\tthis._timer.start();\n\t\tthis.resize();\n\t}\n\n\tprivate resize(event:UIEvent = null)\n\t{\n\t\tthis._view.y = 0;\n\t\tthis._view.x = 0;\n\t\tthis._view.width = window.innerWidth;\n\t\tthis._view.height = window.innerHeight;\n\t}\n\n\tprivate render(dt:number) //animate based on dt for firefox\n\t{\n\t\tif (this._t800)\n\t\t\tthis._t800.rotationY += 1;\n\n\t\tthis._view.render();\n\t}\n\n\tpublic onAssetComplete(event:AssetEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('events.AssetEvent.ASSET_COMPLETE', AssetLibrary.getAsset(event.asset.name));\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t}\n\n\tpublic onResourceComplete(event:LoaderEvent)\n\t{\n\t\tconsole.log('------------------------------------------------------------------------------');\n\t\tconsole.log('events.LoaderEvent.RESOURCE_COMPLETE', event);\n\t\tconsole.log('------------------------------------------------------------------------------');\n\n\t\tconsole.log(AssetLibrary.getAsset('Mesh_g0'));\n\n\t\tthis._t800 = <Mesh> AssetLibrary.getAsset('Mesh_g0');\n\t\tthis._t800.y = -200;\n\t\tthis._t800.transform.scale = new Vector3D(4, 4, 4);\n\n\t\tthis._view.scene.addChild(this._t800);\n\t}\n}"]} \ No newline at end of file