From c44f1445b3bd1b6b24206cfd2fa64244f26de3a4 Mon Sep 17 00:00:00 2001 From: Luke Moody Date: Sun, 28 Jun 2020 13:02:42 +0100 Subject: [PATCH 1/5] Fixes #134. Switched from `BufferAttribute.dynamic` to `BufferAttribute.usage`. Replaced use of `texture` uniform with `tex`. Bumped package to `1.1.0`. --- build/SPE.js | 28 +- build/SPE.min.js | 14 +- package-lock.json | 1472 ++++++++++++++++++++++++++++ package.json | 7 +- src/core/SPE.Group.js | 6 +- src/helpers/SPE.ShaderAttribute.js | 14 +- src/shaders/SPE.shaderChunks.js | 4 +- 7 files changed, 1516 insertions(+), 29 deletions(-) create mode 100644 package-lock.json diff --git a/build/SPE.js b/build/SPE.js index 92ee19c..f8f2169 100644 --- a/build/SPE.js +++ b/build/SPE.js @@ -547,7 +547,9 @@ SPE.ShaderAttribute.prototype.resetUpdateRange = function() { SPE.ShaderAttribute.prototype.resetDynamic = function() { 'use strict'; - this.bufferAttribute.dynamic = this.dynamicBuffer; + this.bufferAttribute.usage = this.dynamicBuffer ? + THREE.DynamicDrawUsage : + THREE.StaticDrawUsage; }; /** @@ -571,7 +573,12 @@ SPE.ShaderAttribute.prototype.forceUpdateAll = function() { this.bufferAttribute.array = this.typedArray.array; this.bufferAttribute.updateRange.offset = 0; this.bufferAttribute.updateRange.count = -1; - this.bufferAttribute.dynamic = false; + // this.bufferAttribute.dynamic = false; + // this.bufferAttribute.usage = this.dynamicBuffer ? + // THREE.DynamicDrawUsage : + // THREE.StaticDrawUsage; + + this.bufferAttribute.usage = THREE.StaticDrawUsage; this.bufferAttribute.needsUpdate = true; }; @@ -640,7 +647,10 @@ SPE.ShaderAttribute.prototype._createBufferAttribute = function( size ) { } this.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize ); - this.bufferAttribute.dynamic = this.dynamicBuffer; + // this.bufferAttribute.dynamic = this.dynamicBuffer; + this.bufferAttribute.usage = this.dynamicBuffer ? + THREE.DynamicDrawUsage : + THREE.StaticDrawUsage; }; /** @@ -669,7 +679,7 @@ SPE.shaderChunks = { uniforms: [ 'uniform float deltaTime;', 'uniform float runTime;', - 'uniform sampler2D texture;', + 'uniform sampler2D tex;', 'uniform vec4 textureAnimation;', 'uniform float scale;', ].join( '\n' ), @@ -910,7 +920,7 @@ SPE.shaderChunks = { ' #endif', '', - ' vec4 rotatedTexture = texture2D( texture, vUv );', + ' vec4 rotatedTexture = texture2D( tex, vUv );', ].join( '\n' ) }; @@ -1952,7 +1962,7 @@ SPE.Group = function( options ) { // Map of uniforms to be applied to the ShaderMaterial instance. this.uniforms = { - texture: { + tex: { type: 't', value: this.texture }, @@ -1967,7 +1977,7 @@ SPE.Group = function( options ) { }, fogColor: { type: 'c', - value: null + value: this.fog ? new THREE.Color() : null }, fogNear: { type: 'f', @@ -2328,9 +2338,9 @@ SPE.Group.prototype.getFromPool = function() { } else if ( createNew ) { var emitter = new SPE.Emitter( this._poolCreationSettings ); - + this.addEmitter( emitter ); - + return emitter; } diff --git a/build/SPE.min.js b/build/SPE.min.js index dcc9d56..6cfdcc8 100644 --- a/build/SPE.min.js +++ b/build/SPE.min.js @@ -9,16 +9,16 @@ var SPE={distributions:{BOX:1,SPHERE:2,DISC:3,LINE:4},valueOverLifetimeLength:4} SPE.TypedArrayHelper.prototype.splice=function(a,b){"use strict";a*=this.componentSize,b*=this.componentSize;for(var c=[],d=this.array,e=d.length,f=0;f=b)&&c.push(d[f]);return this.setFromArray(0,c),this},SPE.TypedArrayHelper.prototype.setFromArray=function(a,b){"use strict";var c=b.length,d=a+c;return d>this.array.length?this.grow(d):d=81&&(this.bufferAttribute.count=this.bufferAttribute.array.length/this.bufferAttribute.itemSize),void(this.bufferAttribute.needsUpdate=!0);this.bufferAttribute=new THREE.BufferAttribute(this.typedArray.array,this.componentSize),this.bufferAttribute.dynamic=this.dynamicBuffer},SPE.ShaderAttribute.prototype.getLength=function(){"use strict";return null===this.typedArray?0:this.typedArray.array.length},SPE.shaderChunks={defines:["#define PACKED_COLOR_SIZE 256.0","#define PACKED_COLOR_DIVISOR 255.0"].join("\n"), -uniforms:["uniform float deltaTime;","uniform float runTime;","uniform sampler2D texture;","uniform vec4 textureAnimation;","uniform float scale;"].join("\n"),attributes:["attribute vec4 acceleration;","attribute vec3 velocity;","attribute vec4 rotation;","attribute vec3 rotationCenter;","attribute vec4 params;","attribute vec4 size;","attribute vec4 angle;","attribute vec4 color;","attribute vec4 opacity;"].join("\n"),varyings:["varying vec4 vColor;","#ifdef SHOULD_ROTATE_TEXTURE"," varying float vAngle;","#endif","#ifdef SHOULD_CALCULATE_SPRITE"," varying vec4 vSpriteSheet;","#endif"].join("\n"), +b.count=Math.min(this.updateMax-this.updateMin+this.componentSize,this.typedArray.array.length),a.needsUpdate=!0},SPE.ShaderAttribute.prototype.resetUpdateRange=function(){"use strict";this.updateMin=0,this.updateMax=0},SPE.ShaderAttribute.prototype.resetDynamic=function(){"use strict";this.bufferAttribute.usage=this.dynamicBuffer?THREE.DynamicDrawUsage:THREE.StaticDrawUsage},SPE.ShaderAttribute.prototype.splice=function(a,b){"use strict";this.typedArray.splice(a,b),this.forceUpdateAll()},SPE.ShaderAttribute.prototype.forceUpdateAll=function(){"use strict";this.bufferAttribute.array=this.typedArray.array,this.bufferAttribute.updateRange.offset=0,this.bufferAttribute.updateRange.count=-1,this.bufferAttribute.usage=THREE.StaticDrawUsage,this.bufferAttribute.needsUpdate=!0},SPE.ShaderAttribute.prototype._ensureTypedArray=function(a){"use strict" +;null!==this.typedArray&&this.typedArray.size===a*this.componentSize||(null!==this.typedArray&&this.typedArray.size!==a?this.typedArray.setSize(a):null===this.typedArray&&(this.typedArray=new SPE.TypedArrayHelper(this.arrayType,a,this.componentSize)))},SPE.ShaderAttribute.prototype._createBufferAttribute=function(a){"use strict";if(this._ensureTypedArray(a),null!==this.bufferAttribute)return this.bufferAttribute.array=this.typedArray.array,parseFloat(THREE.REVISION)>=81&&(this.bufferAttribute.count=this.bufferAttribute.array.length/this.bufferAttribute.itemSize),void(this.bufferAttribute.needsUpdate=!0);this.bufferAttribute=new THREE.BufferAttribute(this.typedArray.array,this.componentSize),this.bufferAttribute.usage=this.dynamicBuffer?THREE.DynamicDrawUsage:THREE.StaticDrawUsage},SPE.ShaderAttribute.prototype.getLength=function(){"use strict";return null===this.typedArray?0:this.typedArray.array.length},SPE.shaderChunks={ +defines:["#define PACKED_COLOR_SIZE 256.0","#define PACKED_COLOR_DIVISOR 255.0"].join("\n"),uniforms:["uniform float deltaTime;","uniform float runTime;","uniform sampler2D tex;","uniform vec4 textureAnimation;","uniform float scale;"].join("\n"),attributes:["attribute vec4 acceleration;","attribute vec3 velocity;","attribute vec4 rotation;","attribute vec3 rotationCenter;","attribute vec4 params;","attribute vec4 size;","attribute vec4 angle;","attribute vec4 color;","attribute vec4 opacity;"].join("\n"),varyings:["varying vec4 vColor;","#ifdef SHOULD_ROTATE_TEXTURE"," varying float vAngle;","#endif","#ifdef SHOULD_CALCULATE_SPRITE"," varying vec4 vSpriteSheet;","#endif"].join("\n"), branchAvoidanceFunctions:["float when_gt(float x, float y) {"," return max(sign(x - y), 0.0);","}","float when_lt(float x, float y) {"," return min( max(1.0 - sign(x - y), 0.0), 1.0 );","}","float when_eq( float x, float y ) {"," return 1.0 - abs( sign( x - y ) );","}","float when_ge(float x, float y) {"," return 1.0 - when_lt(x, y);","}","float when_le(float x, float y) {"," return 1.0 - when_gt(x, y);","}","float and(float a, float b) {"," return a * b;","}","float or(float a, float b) {"," return min(a + b, 1.0);","}"].join("\n"),unpackColor:["vec3 unpackColor( in float hex ) {"," vec3 c = vec3( 0.0 );"," float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float b = mod( hex, PACKED_COLOR_SIZE );"," c.r = r / PACKED_COLOR_DIVISOR;"," c.g = g / PACKED_COLOR_DIVISOR;"," c.b = b / PACKED_COLOR_DIVISOR;"," return c;","}"].join("\n"), unpackRotationAxis:["vec3 unpackRotationAxis( in float hex ) {"," vec3 c = vec3( 0.0 );"," float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float b = mod( hex, PACKED_COLOR_SIZE );"," c.r = r / PACKED_COLOR_DIVISOR;"," c.g = g / PACKED_COLOR_DIVISOR;"," c.b = b / PACKED_COLOR_DIVISOR;"," c *= vec3( 2.0 );"," c -= vec3( 1.0 );"," return c;","}"].join("\n"), floatOverLifetime:["float getFloatOverLifetime( in float positionInTime, in vec4 attr ) {"," highp float value = 0.0;"," float deltaAge = positionInTime * float( VALUE_OVER_LIFETIME_LENGTH - 1 );"," float fIndex = 0.0;"," float shouldApplyValue = 0.0;"," value += attr[ 0 ] * when_eq( deltaAge, 0.0 );",""," for( int i = 0; i < VALUE_OVER_LIFETIME_LENGTH - 1; ++i ) {"," fIndex = float( i );"," shouldApplyValue = and( when_gt( deltaAge, fIndex ), when_le( deltaAge, fIndex + 1.0 ) );"," value += shouldApplyValue * mix( attr[ i ], attr[ i + 1 ], deltaAge - fIndex );"," }",""," return value;","}"].join("\n"), colorOverLifetime:["vec3 getColorOverLifetime( in float positionInTime, in vec3 color1, in vec3 color2, in vec3 color3, in vec3 color4 ) {"," vec3 value = vec3( 0.0 );"," value.x = getFloatOverLifetime( positionInTime, vec4( color1.x, color2.x, color3.x, color4.x ) );"," value.y = getFloatOverLifetime( positionInTime, vec4( color1.y, color2.y, color3.y, color4.y ) );"," value.z = getFloatOverLifetime( positionInTime, vec4( color1.z, color2.z, color3.z, color4.z ) );"," return value;","}"].join("\n"),paramFetchingFunctions:["float getAlive() {"," return params.x;","}","float getAge() {"," return params.y;","}","float getMaxAge() {"," return params.z;","}","float getWiggle() {"," return params.w;","}"].join("\n"), forceFetchingFunctions:["vec4 getPosition( in float age ) {"," return modelViewMatrix * vec4( position, 1.0 );","}","vec3 getVelocity( in float age ) {"," return velocity * age;","}","vec3 getAcceleration( in float age ) {"," return acceleration.xyz * age;","}"].join("\n"), rotationFunctions:["#ifdef SHOULD_ROTATE_PARTICLES"," mat4 getRotationMatrix( in vec3 axis, in float angle) {"," axis = normalize(axis);"," float s = sin(angle);"," float c = cos(angle);"," float oc = 1.0 - c;",""," return mat4(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 0.0,"," oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 0.0,"," oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c, 0.0,"," 0.0, 0.0, 0.0, 1.0);"," }",""," vec3 getRotation( in vec3 pos, in float positionInTime ) {"," if( rotation.y == 0.0 ) {"," return pos;"," }",""," vec3 axis = unpackRotationAxis( rotation.x );"," vec3 center = rotationCenter;"," vec3 translated;"," mat4 rotationMatrix;"," float angle = 0.0;"," angle += when_eq( rotation.z, 0.0 ) * rotation.y;"," angle += when_gt( rotation.z, 0.0 ) * mix( 0.0, rotation.y, positionInTime );"," translated = rotationCenter - pos;"," rotationMatrix = getRotationMatrix( axis, angle );"," return center - vec3( rotationMatrix * vec4( translated, 0.0 ) );"," }","#endif"].join("\n"), -rotateTexture:[" vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );",""," #ifdef SHOULD_ROTATE_TEXTURE"," float x = gl_PointCoord.x - 0.5;"," float y = 1.0 - gl_PointCoord.y - 0.5;"," float c = cos( -vAngle );"," float s = sin( -vAngle );"," vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );"," #endif",""," #ifdef SHOULD_CALCULATE_SPRITE"," float framesX = vSpriteSheet.x;"," float framesY = vSpriteSheet.y;"," float columnNorm = vSpriteSheet.z;"," float rowNorm = vSpriteSheet.w;"," vUv.x = gl_PointCoord.x * framesX + columnNorm;"," vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);"," #endif",""," vec4 rotatedTexture = texture2D( texture, vUv );"].join("\n")},SPE.shaders={ +rotateTexture:[" vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );",""," #ifdef SHOULD_ROTATE_TEXTURE"," float x = gl_PointCoord.x - 0.5;"," float y = 1.0 - gl_PointCoord.y - 0.5;"," float c = cos( -vAngle );"," float s = sin( -vAngle );"," vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );"," #endif",""," #ifdef SHOULD_CALCULATE_SPRITE"," float framesX = vSpriteSheet.x;"," float framesY = vSpriteSheet.y;"," float columnNorm = vSpriteSheet.z;"," float rowNorm = vSpriteSheet.w;"," vUv.x = gl_PointCoord.x * framesX + columnNorm;"," vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);"," #endif",""," vec4 rotatedTexture = texture2D( tex, vUv );"].join("\n")},SPE.shaders={ vertex:[SPE.shaderChunks.defines,SPE.shaderChunks.uniforms,SPE.shaderChunks.attributes,SPE.shaderChunks.varyings,THREE.ShaderChunk.common,THREE.ShaderChunk.logdepthbuf_pars_vertex,THREE.ShaderChunk.fog_pars_vertex,SPE.shaderChunks.branchAvoidanceFunctions,SPE.shaderChunks.unpackColor,SPE.shaderChunks.unpackRotationAxis,SPE.shaderChunks.floatOverLifetime,SPE.shaderChunks.colorOverLifetime,SPE.shaderChunks.paramFetchingFunctions,SPE.shaderChunks.forceFetchingFunctions,SPE.shaderChunks.rotationFunctions,"void main() {"," highp float age = getAge();"," highp float alive = getAlive();"," highp float maxAge = getMaxAge();"," highp float positionInTime = (age / maxAge);"," highp float isAlive = when_gt( alive, 0.0 );"," #ifdef SHOULD_WIGGLE_PARTICLES"," float wiggleAmount = positionInTime * getWiggle();"," float wiggleSin = isAlive * sin( wiggleAmount );"," float wiggleCos = isAlive * cos( wiggleAmount );"," #endif"," vec3 vel = getVelocity( age );"," vec3 accel = getAcceleration( age );"," vec3 force = vec3( 0.0 );"," vec3 pos = vec3( position );"," float drag = 1.0 - (positionInTime * 0.5) * acceleration.w;"," force += vel;"," force *= drag;"," force += accel * age;"," pos += force;"," #ifdef SHOULD_WIGGLE_PARTICLES"," pos.x += wiggleSin;"," pos.y += wiggleCos;"," pos.z += wiggleSin;"," #endif"," #ifdef SHOULD_ROTATE_PARTICLES"," pos = getRotation( pos, positionInTime );"," #endif"," vec4 mvPosition = modelViewMatrix * vec4( pos, 1.0 );"," highp float pointSize = getFloatOverLifetime( positionInTime, size ) * isAlive;"," #ifdef HAS_PERSPECTIVE"," float perspective = scale / length( mvPosition.xyz );"," #else"," float perspective = 1.0;"," #endif"," float pointSizePerspective = pointSize * perspective;"," #ifdef COLORIZE"," vec3 c = isAlive * getColorOverLifetime("," positionInTime,"," unpackColor( color.x ),"," unpackColor( color.y ),"," unpackColor( color.z ),"," unpackColor( color.w )"," );"," #else"," vec3 c = vec3(1.0);"," #endif"," float o = isAlive * getFloatOverLifetime( positionInTime, opacity );"," vColor = vec4( c, o );"," #ifdef SHOULD_ROTATE_TEXTURE"," vAngle = isAlive * getFloatOverLifetime( positionInTime, angle );"," #endif"," #ifdef SHOULD_CALCULATE_SPRITE"," float framesX = textureAnimation.x;"," float framesY = textureAnimation.y;"," float loopCount = textureAnimation.w;"," float totalFrames = textureAnimation.z;"," float frameNumber = mod( (positionInTime * loopCount) * totalFrames, totalFrames );"," float column = floor(mod( frameNumber, framesX ));"," float row = floor( (frameNumber - column) / framesX );"," float columnNorm = column / framesX;"," float rowNorm = row / framesY;"," vSpriteSheet.x = 1.0 / framesX;"," vSpriteSheet.y = 1.0 / framesY;"," vSpriteSheet.z = columnNorm;"," vSpriteSheet.w = rowNorm;"," #endif"," gl_PointSize = pointSizePerspective;"," gl_Position = projectionMatrix * mvPosition;",THREE.ShaderChunk.logdepthbuf_vertex,THREE.ShaderChunk.fog_vertex,"}"].join("\n"), fragment:[SPE.shaderChunks.uniforms,THREE.ShaderChunk.common,THREE.ShaderChunk.fog_pars_fragment,THREE.ShaderChunk.logdepthbuf_pars_fragment,SPE.shaderChunks.varyings,SPE.shaderChunks.branchAvoidanceFunctions,"void main() {"," vec3 outgoingLight = vColor.xyz;"," "," #ifdef ALPHATEST"," if ( vColor.w < float(ALPHATEST) ) discard;"," #endif",SPE.shaderChunks.rotateTexture,THREE.ShaderChunk.logdepthbuf_fragment," outgoingLight = vColor.xyz * rotatedTexture.xyz;"," gl_FragColor = vec4( outgoingLight.xyz, rotatedTexture.w * vColor.w );",THREE.ShaderChunk.fog_fragment,"}"].join("\n")},SPE.utils={types:{BOOLEAN:"boolean",STRING:"string",NUMBER:"number",OBJECT:"object"},ensureTypedArg:function(a,b,c){"use strict";return typeof a===b?a:c},ensureArrayTypedArg:function(a,b,c){"use strict";if(Array.isArray(a)){for(var d=a.length-1;d>=0;--d)if(typeof a[d]!==b)return c;return a}return this.ensureTypedArg(a,b,c)},ensureInstanceOf:function(a,b,c){"use strict" ;return void 0!==b&&a instanceof b?a:c},ensureArrayInstanceOf:function(a,b,c){"use strict";if(Array.isArray(a)){for(var d=a.length-1;d>=0;--d)if(void 0!==b&&a[d]instanceof b==!1)return c;return a}return this.ensureInstanceOf(a,b,c)},ensureValueOverLifetimeCompliance:function(a,b,c){"use strict";b=b||3,c=c||3,!1===Array.isArray(a._value)&&(a._value=[a._value]),!1===Array.isArray(a._spread)&&(a._spread=[a._spread]);var d=this.clamp(a._value.length,b,c),e=this.clamp(a._spread.length,b,c),f=Math.max(d,e);a._value.length!==f&&(a._value=this.interpolateArray(a._value,f)),a._spread.length!==f&&(a._spread=this.interpolateArray(a._spread,f))},interpolateArray:function(a,b){"use strict";for(var c=a.length,d=["function"==typeof a[0].clone?a[0].clone():a[0]],e=(c-1)/(b-1),f=1;f1||this.textureFrames.y>1},this.attributes={position:new SPE.ShaderAttribute("v3",!0),acceleration:new SPE.ShaderAttribute("v4",!0),velocity:new SPE.ShaderAttribute("v3",!0),rotation:new SPE.ShaderAttribute("v4",!0),rotationCenter:new SPE.ShaderAttribute("v3",!0),params:new SPE.ShaderAttribute("v4",!0),size:new SPE.ShaderAttribute("v4",!0),angle:new SPE.ShaderAttribute("v4",!0),color:new SPE.ShaderAttribute("v4",!0),opacity:new SPE.ShaderAttribute("v4",!0)},this.attributeKeys=Object.keys(this.attributes),this.attributeCount=this.attributeKeys.length,this.material=new THREE.ShaderMaterial({uniforms:this.uniforms,vertexShader:SPE.shaders.vertex,fragmentShader:SPE.shaders.fragment,blending:this.blending,transparent:this.transparent,alphaTest:this.alphaTest,depthWrite:this.depthWrite,depthTest:this.depthTest,defines:this.defines,fog:this.fog}),this.geometry=new THREE.BufferGeometry, -this.mesh=new THREE.Points(this.geometry,this.material),null===this.maxParticleCount&&console.warn("SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.")},SPE.Group.constructor=SPE.Group,SPE.Group.prototype._updateDefines=function(){"use strict";var a,b=this.emitters,c=b.length-1,d=this.defines;for(c;c>=0;--c)a=b[c],d.SHOULD_CALCULATE_SPRITE||(d.SHOULD_ROTATE_TEXTURE=d.SHOULD_ROTATE_TEXTURE||!!Math.max(Math.max.apply(null,a.angle.value),Math.max.apply(null,a.angle.spread))),d.SHOULD_ROTATE_PARTICLES=d.SHOULD_ROTATE_PARTICLES||!!Math.max(a.rotation.angle,a.rotation.angleSpread),d.SHOULD_WIGGLE_PARTICLES=d.SHOULD_WIGGLE_PARTICLES||!!Math.max(a.wiggle.value,a.wiggle.spread);this.material.needsUpdate=!0},SPE.Group.prototype._applyAttributesToGeometry=function(){"use strict";var a,b,c=this.attributes,d=this.geometry,e=d.attributes;for(var f in c)c.hasOwnProperty(f)&&(a=c[f],b=e[f], +this.depthWrite=b.ensureTypedArg(a.depthWrite,c.BOOLEAN,!1),this.depthTest=b.ensureTypedArg(a.depthTest,c.BOOLEAN,!0),this.fog=b.ensureTypedArg(a.fog,c.BOOLEAN,!0),this.scale=b.ensureTypedArg(a.scale,c.NUMBER,300),this.emitters=[],this.emitterIDs=[],this._pool=[],this._poolCreationSettings=null,this._createNewWhenPoolEmpty=0,this._attributesNeedRefresh=!1,this._attributesNeedDynamicReset=!1,this.particleCount=0,this.uniforms={tex:{type:"t",value:this.texture},textureAnimation:{type:"v4",value:new THREE.Vector4(this.textureFrames.x,this.textureFrames.y,this.textureFrameCount,Math.max(Math.abs(this.textureLoop),1))},fogColor:{type:"c",value:this.fog?new THREE.Color:null},fogNear:{type:"f",value:10},fogFar:{type:"f",value:200},fogDensity:{type:"f",value:.5},deltaTime:{type:"f",value:0},runTime:{type:"f",value:0},scale:{type:"f",value:this.scale}},this.defines={HAS_PERSPECTIVE:this.hasPerspective,COLORIZE:this.colorize,VALUE_OVER_LIFETIME_LENGTH:SPE.valueOverLifetimeLength, +SHOULD_ROTATE_TEXTURE:!1,SHOULD_ROTATE_PARTICLES:!1,SHOULD_WIGGLE_PARTICLES:!1,SHOULD_CALCULATE_SPRITE:this.textureFrames.x>1||this.textureFrames.y>1},this.attributes={position:new SPE.ShaderAttribute("v3",!0),acceleration:new SPE.ShaderAttribute("v4",!0),velocity:new SPE.ShaderAttribute("v3",!0),rotation:new SPE.ShaderAttribute("v4",!0),rotationCenter:new SPE.ShaderAttribute("v3",!0),params:new SPE.ShaderAttribute("v4",!0),size:new SPE.ShaderAttribute("v4",!0),angle:new SPE.ShaderAttribute("v4",!0),color:new SPE.ShaderAttribute("v4",!0),opacity:new SPE.ShaderAttribute("v4",!0)},this.attributeKeys=Object.keys(this.attributes),this.attributeCount=this.attributeKeys.length,this.material=new THREE.ShaderMaterial({uniforms:this.uniforms,vertexShader:SPE.shaders.vertex,fragmentShader:SPE.shaders.fragment,blending:this.blending,transparent:this.transparent,alphaTest:this.alphaTest,depthWrite:this.depthWrite,depthTest:this.depthTest,defines:this.defines,fog:this.fog}), +this.geometry=new THREE.BufferGeometry,this.mesh=new THREE.Points(this.geometry,this.material),null===this.maxParticleCount&&console.warn("SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.")},SPE.Group.constructor=SPE.Group,SPE.Group.prototype._updateDefines=function(){"use strict";var a,b=this.emitters,c=b.length-1,d=this.defines;for(c;c>=0;--c)a=b[c],d.SHOULD_CALCULATE_SPRITE||(d.SHOULD_ROTATE_TEXTURE=d.SHOULD_ROTATE_TEXTURE||!!Math.max(Math.max.apply(null,a.angle.value),Math.max.apply(null,a.angle.spread))),d.SHOULD_ROTATE_PARTICLES=d.SHOULD_ROTATE_PARTICLES||!!Math.max(a.rotation.angle,a.rotation.angleSpread),d.SHOULD_WIGGLE_PARTICLES=d.SHOULD_WIGGLE_PARTICLES||!!Math.max(a.wiggle.value,a.wiggle.spread);this.material.needsUpdate=!0},SPE.Group.prototype._applyAttributesToGeometry=function(){"use strict";var a,b,c=this.attributes,d=this.geometry,e=d.attributes;for(var f in c)c.hasOwnProperty(f)&&(a=c[f],b=e[f], b?b.array=a.typedArray.array:d.addAttribute(f,a.bufferAttribute),a.bufferAttribute.needsUpdate=!0);this.geometry.setDrawRange(0,this.particleCount)},SPE.Group.prototype.addEmitter=function(a){"use strict";if(a instanceof SPE.Emitter==!1)return void console.error("`emitter` argument must be instance of SPE.Emitter. Was provided with:",a);if(this.emitterIDs.indexOf(a.uuid)>-1)return void console.error("Emitter already exists in this group. Will not add again.");if(null!==a.group)return void console.error("Emitter already belongs to another group. Will not add to requested group.");var b=this.attributes,c=this.particleCount,d=c+a.particleCount;this.particleCount=d,null!==this.maxParticleCount&&this.particleCount>this.maxParticleCount&&console.warn("SPE.Group: maxParticleCount exceeded. Requesting",this.particleCount,"particles, can support only",this.maxParticleCount),a._calculatePPSValue(a.maxAge._value+a.maxAge._spread),a._setBufferUpdateRanges(this.attributeKeys), a._setAttributeOffset(c),a.group=this,a.attributes=this.attributes;for(var e in b)b.hasOwnProperty(e)&&b[e]._createBufferAttribute(null!==this.maxParticleCount?this.maxParticleCount:this.particleCount);for(var f=c;f= 0.5.2", + "fs-extra": ">= 0.6.0", + "highlight.js": ">= 8.0.x", + "marked": ">= 0.2.7", + "underscore": ">= 1.0.0" + } + }, + "entities": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.0.3.tgz", + "integrity": "sha512-MyoZ0jgnLvB2X3Lg5HqpFmn1kybDiIfEQmKzTb5apr51Rb+T3KdmMiqa70T+bhGnyv7bQ6WMj2QMHpGMmlrUYQ==", + "dev": true + }, + "error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "requires": { + "is-arrayish": "^0.2.1" + } + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=", + "dev": true + }, + "esprima": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.0.4.tgz", + "integrity": "sha1-n1V+CPw7TSbs6d00+Pv0drYlha0=", + "dev": true + }, + "eventemitter2": { + "version": "0.4.14", + "resolved": "https://registry.npmjs.org/eventemitter2/-/eventemitter2-0.4.14.tgz", + "integrity": "sha1-j2G3XN4BKy6esoTUVFWDtWQ7Yas=", + "dev": true + }, + "exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=", + "dev": true + }, + "figures": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz", + "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=", + "dev": true, + "requires": { + "escape-string-regexp": "^1.0.5", + "object-assign": "^4.1.0" + } + }, + "find-up": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "dev": true, + "requires": { + "path-exists": "^2.0.0", + "pinkie-promise": "^2.0.0" + } + }, + "findup-sync": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-0.1.3.tgz", + "integrity": "sha1-fz56l7gjksZTvwZYm9hRkOk8NoM=", + "dev": true, + "requires": { + "glob": "~3.2.9", + "lodash": "~2.4.1" + }, + "dependencies": { + "glob": { + "version": "3.2.11", + "resolved": "https://registry.npmjs.org/glob/-/glob-3.2.11.tgz", + "integrity": "sha1-Spc/Y1uRkPcV0QmH1cAP0oFevj0=", + "dev": true, + "requires": { + "inherits": "2", + "minimatch": "0.3" + } + }, + "lodash": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-2.4.2.tgz", + "integrity": "sha1-+t2DS5aDBz2hebPq5tnA0VBT9z4=", + "dev": true + }, + "minimatch": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-0.3.0.tgz", + "integrity": "sha1-J12O2qxPG7MyZHIInnlJyDlGmd0=", + "dev": true, + "requires": { + "lru-cache": "2", + "sigmund": "~1.0.0" + } + } + } + }, + "fs-extra": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.0.1.tgz", + "integrity": "sha512-h2iAoN838FqAFJY2/qVpzFXy+EBxfVE220PalAqQLDVsFOHLJrZvut5puAbCdNv6WJk+B8ihI+k0c7JK5erwqQ==", + "dev": true, + "requires": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^1.0.0" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz", + "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==", + "dev": true + } + } + }, + "get-stdin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-4.0.1.tgz", + "integrity": "sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=", + "dev": true + }, + "getobject": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/getobject/-/getobject-0.1.0.tgz", + "integrity": "sha1-BHpEl4n6Fg0Bj1SG7ZEyC27HiFw=", + "dev": true + }, + "glob": { + "version": "3.1.21", + "resolved": "https://registry.npmjs.org/glob/-/glob-3.1.21.tgz", + "integrity": "sha1-0p4KBV3qUTj00H7UDomC6DwgZs0=", + "dev": true, + "requires": { + "graceful-fs": "~1.2.0", + "inherits": "1", + "minimatch": "~0.2.11" + }, + "dependencies": { + "inherits": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-1.0.2.tgz", + "integrity": "sha1-ykMJ2t7mtUzAuNJH6NfHoJdb3Js=", + "dev": true + } + } + }, + "graceful-fs": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-1.2.3.tgz", + "integrity": "sha1-FaSAaldUfLLS2/J/QuiajDRRs2Q=", + "dev": true + }, + "grunt": { + "version": "0.4.5", + "resolved": "https://registry.npmjs.org/grunt/-/grunt-0.4.5.tgz", + "integrity": "sha1-VpN81RlDJK3/bSB2MYMqnWuk5/A=", + "dev": true, + "requires": { + "async": "~0.1.22", + "coffee-script": "~1.3.3", + "colors": "~0.6.2", + "dateformat": "1.0.2-1.2.3", + "eventemitter2": "~0.4.13", + "exit": "~0.1.1", + "findup-sync": "~0.1.2", + "getobject": "~0.1.0", + "glob": "~3.1.21", + "grunt-legacy-log": "~0.1.0", + "grunt-legacy-util": "~0.2.0", + "hooker": "~0.2.3", + "iconv-lite": "~0.2.11", + "js-yaml": "~2.0.5", + "lodash": "~0.9.2", + "minimatch": "~0.2.12", + "nopt": "~1.0.10", + "rimraf": "~2.2.8", + "underscore.string": "~2.2.1", + "which": "~1.0.5" + } + }, + "grunt-contrib-concat": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/grunt-contrib-concat/-/grunt-contrib-concat-0.5.1.tgz", + "integrity": "sha1-lTxu/f39LBB6uchQd/LUsk0xzUk=", + "dev": true, + "requires": { + "chalk": "^0.5.1", + "source-map": "^0.3.0" + } + }, + "grunt-contrib-uglify": { + "version": "0.9.2", + "resolved": "https://registry.npmjs.org/grunt-contrib-uglify/-/grunt-contrib-uglify-0.9.2.tgz", + "integrity": "sha1-GmHG8hJBDkq7T3yJFTcXsQFWAmA=", + "dev": true, + "requires": { + "chalk": "^1.0.0", + "lodash": "^3.2.0", + "maxmin": "^1.0.0", + "uglify-js": "^2.4.24", + "uri-path": "0.0.2" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", + "dev": true + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=", + "dev": true + }, + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "^2.2.1", + "escape-string-regexp": "^1.0.2", + "has-ansi": "^2.0.0", + "strip-ansi": "^3.0.0", + "supports-color": "^2.0.0" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "dev": true, + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "lodash": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz", + "integrity": "sha1-W/Rejkm6QYnhfUgnid/RW9FAt7Y=", + "dev": true + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "dev": true, + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=", + "dev": true + } + } + }, + "grunt-docco2": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/grunt-docco2/-/grunt-docco2-0.2.1.tgz", + "integrity": "sha1-ZghyYavBkcjofI77/LeIEr/krMs=", + "dev": true, + "requires": { + "docco": "~0.6.3" + } + }, + "grunt-jsdoc": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/grunt-jsdoc/-/grunt-jsdoc-1.1.0.tgz", + "integrity": "sha1-S87+YFh6ZGpbcg/pq/lMxIh/6FQ=", + "dev": true, + "requires": { + "jsdoc": "^3.4.0" + } + }, + "grunt-legacy-log": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/grunt-legacy-log/-/grunt-legacy-log-0.1.3.tgz", + "integrity": "sha1-7ClCboAwIa9ZAp+H0vnNczWgVTE=", + "dev": true, + "requires": { + "colors": "~0.6.2", + "grunt-legacy-log-utils": "~0.1.1", + "hooker": "~0.2.3", + "lodash": "~2.4.1", + "underscore.string": "~2.3.3" + }, + "dependencies": { + "lodash": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-2.4.2.tgz", + "integrity": "sha1-+t2DS5aDBz2hebPq5tnA0VBT9z4=", + "dev": true + }, + "underscore.string": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.3.3.tgz", + "integrity": "sha1-ccCL9rQosRM/N+ePo6Icgvcymw0=", + "dev": true + } + } + }, + "grunt-legacy-log-utils": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/grunt-legacy-log-utils/-/grunt-legacy-log-utils-0.1.1.tgz", + "integrity": "sha1-wHBrndkGThFvNvI/5OawSGcsD34=", + "dev": true, + "requires": { + "colors": "~0.6.2", + "lodash": "~2.4.1", + "underscore.string": "~2.3.3" + }, + "dependencies": { + "lodash": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-2.4.2.tgz", + "integrity": "sha1-+t2DS5aDBz2hebPq5tnA0VBT9z4=", + "dev": true + }, + "underscore.string": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.3.3.tgz", + "integrity": "sha1-ccCL9rQosRM/N+ePo6Icgvcymw0=", + "dev": true + } + } + }, + "grunt-legacy-util": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/grunt-legacy-util/-/grunt-legacy-util-0.2.0.tgz", + "integrity": "sha1-kzJIhNv343qf98Am3/RR2UqeVUs=", + "dev": true, + "requires": { + "async": "~0.1.22", + "exit": "~0.1.1", + "getobject": "~0.1.0", + "hooker": "~0.2.3", + "lodash": "~0.9.2", + "underscore.string": "~2.2.1", + "which": "~1.0.5" + } + }, + "gzip-size": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/gzip-size/-/gzip-size-1.0.0.tgz", + "integrity": "sha1-Zs+LEBBHInuVus5uodoMF37Vwi8=", + "dev": true, + "requires": { + "browserify-zlib": "^0.1.4", + "concat-stream": "^1.4.1" + } + }, + "has-ansi": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-0.1.0.tgz", + "integrity": "sha1-hPJlqujA5qiKEtcCKJS3VoiUxi4=", + "dev": true, + "requires": { + "ansi-regex": "^0.2.0" + } + }, + "highlight.js": { + "version": "10.1.1", + "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-10.1.1.tgz", + "integrity": "sha512-b4L09127uVa+9vkMgPpdUQP78ickGbHEQTWeBrQFTJZ4/n2aihWOGS0ZoUqAwjVmfjhq/C76HRzkqwZhK4sBbg==", + "dev": true + }, + "hooker": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/hooker/-/hooker-0.2.3.tgz", + "integrity": "sha1-uDT3I8xKJCqmWWNFnfbZhMXT2Vk=", + "dev": true + }, + "hosted-git-info": { + "version": "2.8.8", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz", + "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==", + "dev": true + }, + "iconv-lite": { + "version": "0.2.11", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.2.11.tgz", + "integrity": "sha1-HOYKOleGSiktEyH/RgnKS7llrcg=", + "dev": true + }, + "indent-string": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz", + "integrity": "sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=", + "dev": true, + "requires": { + "repeating": "^2.0.0" + } + }, + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", + "dev": true + }, + "is-buffer": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", + "dev": true + }, + "is-finite": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.1.0.tgz", + "integrity": "sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==", + "dev": true + }, + "is-utf8": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", + "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=", + "dev": true + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "js-yaml": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-2.0.5.tgz", + "integrity": "sha1-olrmUJmZ6X3yeMZxnaEb0Gh3Q6g=", + "dev": true, + "requires": { + "argparse": "~ 0.1.11", + "esprima": "~ 1.0.2" + } + }, + "js2xmlparser": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-4.0.1.tgz", + "integrity": "sha512-KrPTolcw6RocpYjdC7pL7v62e55q7qOMHvLX1UCLc5AAS8qeJ6nukarEJAF2KL2PZxlbGueEbINqZR2bDe/gUw==", + "dev": true, + "requires": { + "xmlcreate": "^2.0.3" + } + }, + "jsdoc": { + "version": "3.6.4", + "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-3.6.4.tgz", + "integrity": "sha512-3G9d37VHv7MFdheviDCjUfQoIjdv4TC5zTTf5G9VODLtOnVS6La1eoYBDlbWfsRT3/Xo+j2MIqki2EV12BZfwA==", + "dev": true, + "requires": { + "@babel/parser": "^7.9.4", + "bluebird": "^3.7.2", + "catharsis": "^0.8.11", + "escape-string-regexp": "^2.0.0", + "js2xmlparser": "^4.0.1", + "klaw": "^3.0.0", + "markdown-it": "^10.0.0", + "markdown-it-anchor": "^5.2.7", + "marked": "^0.8.2", + "mkdirp": "^1.0.4", + "requizzle": "^0.2.3", + "strip-json-comments": "^3.1.0", + "taffydb": "2.6.2", + "underscore": "~1.10.2" + }, + "dependencies": { + "escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "dev": true + }, + "marked": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/marked/-/marked-0.8.2.tgz", + "integrity": "sha512-EGwzEeCcLniFX51DhTpmTom+dSA/MG/OBUDjnWtHbEnjAH180VzUeAw+oE4+Zv+CoYBWyRlYOTR0N8SO9R1PVw==", + "dev": true + }, + "underscore": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.10.2.tgz", + "integrity": "sha512-N4P+Q/BuyuEKFJ43B9gYuOj4TQUHXX+j2FqguVOpjkssLUUrnJofCcBccJSCoeturDoZU6GorDTHSvUDlSQbTg==", + "dev": true + } + } + }, + "jsonfile": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.0.1.tgz", + "integrity": "sha512-jR2b5v7d2vIOust+w3wtFKZIfpC2pnRmFAhAC/BuweZFQR8qZzxH1OyrQ10HmdVYiXWkYUqPVsz91cG7EL2FBg==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.6", + "universalify": "^1.0.0" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz", + "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==", + "dev": true, + "optional": true + } + } + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + }, + "klaw": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/klaw/-/klaw-3.0.0.tgz", + "integrity": "sha512-0Fo5oir+O9jnXu5EefYbVK+mHMBeEVEy2cmctR1O1NECcCkPRreJKrS6Qt/j3KC2C148Dfo9i3pCmCMsdqGr0g==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.9" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz", + "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==", + "dev": true + } + } + }, + "lazy-cache": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/lazy-cache/-/lazy-cache-1.0.4.tgz", + "integrity": "sha1-odePw6UEdMuAhF07O24dpJpEbo4=", + "dev": true + }, + "linkify-it": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-2.2.0.tgz", + "integrity": "sha512-GnAl/knGn+i1U/wjBz3akz2stz+HrHLsxMwHQGofCDfPvlf+gDKN58UtfmUquTY4/MXeE2x7k19KQmeoZi94Iw==", + "dev": true, + "requires": { + "uc.micro": "^1.0.1" + } + }, + "load-json-file": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", + "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "parse-json": "^2.2.0", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0", + "strip-bom": "^2.0.0" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz", + "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==", + "dev": true + } + } + }, + "lodash": { + "version": "0.9.2", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-0.9.2.tgz", + "integrity": "sha1-jzSZxSRdNG1oLlsNO0B2fgnxqSw=", + "dev": true + }, + "longest": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/longest/-/longest-1.0.1.tgz", + "integrity": "sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc=", + "dev": true + }, + "loud-rejection": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz", + "integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=", + "dev": true, + "requires": { + "currently-unhandled": "^0.4.1", + "signal-exit": "^3.0.0" + } + }, + "lru-cache": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.7.3.tgz", + "integrity": "sha1-bUUk6LlV+V1PW1iFHOId1y+06VI=", + "dev": true + }, + "map-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz", + "integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=", + "dev": true + }, + "markdown-it": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-10.0.0.tgz", + "integrity": "sha512-YWOP1j7UbDNz+TumYP1kpwnP0aEa711cJjrAQrzd0UXlbJfc5aAq0F/PZHjiioqDC1NKgvIMX+o+9Bk7yuM2dg==", + "dev": true, + "requires": { + "argparse": "^1.0.7", + "entities": "~2.0.0", + "linkify-it": "^2.0.0", + "mdurl": "^1.0.1", + "uc.micro": "^1.0.5" + }, + "dependencies": { + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "requires": { + "sprintf-js": "~1.0.2" + } + } + } + }, + "markdown-it-anchor": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/markdown-it-anchor/-/markdown-it-anchor-5.3.0.tgz", + "integrity": "sha512-/V1MnLL/rgJ3jkMWo84UR+K+jF1cxNG1a+KwqeXqTIJ+jtA8aWSHuigx8lTzauiIjBDbwF3NcWQMotd0Dm39jA==", + "dev": true + }, + "marked": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/marked/-/marked-1.1.0.tgz", + "integrity": "sha512-EkE7RW6KcXfMHy2PA7Jg0YJE1l8UPEZE8k45tylzmZM30/r1M1MUXWQfJlrSbsTeh7m/XTwHbWUENvAJZpp1YA==", + "dev": true + }, + "maxmin": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/maxmin/-/maxmin-1.1.0.tgz", + "integrity": "sha1-cTZehKmd2Piz99X94vANHn9zvmE=", + "dev": true, + "requires": { + "chalk": "^1.0.0", + "figures": "^1.0.1", + "gzip-size": "^1.0.0", + "pretty-bytes": "^1.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", + "dev": true + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=", + "dev": true + }, + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "^2.2.1", + "escape-string-regexp": "^1.0.2", + "has-ansi": "^2.0.0", + "strip-ansi": "^3.0.0", + "supports-color": "^2.0.0" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "dev": true, + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "dev": true, + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=", + "dev": true + } + } + }, + "mdurl": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz", + "integrity": "sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4=", + "dev": true + }, + "meow": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz", + "integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=", + "dev": true, + "requires": { + "camelcase-keys": "^2.0.0", + "decamelize": "^1.1.2", + "loud-rejection": "^1.0.0", + "map-obj": "^1.0.1", + "minimist": "^1.1.3", + "normalize-package-data": "^2.3.4", + "object-assign": "^4.0.1", + "read-pkg-up": "^1.0.1", + "redent": "^1.0.0", + "trim-newlines": "^1.0.0" + } + }, + "minimatch": { + "version": "0.2.14", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-0.2.14.tgz", + "integrity": "sha1-x054BXT2PG+aCQ6Q775u9TpqdWo=", + "dev": true, + "requires": { + "lru-cache": "2", + "sigmund": "~1.0.0" + } + }, + "minimist": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", + "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "dev": true + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true + }, + "nopt": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz", + "integrity": "sha1-bd0hvSoxQXuScn3Vhfim83YI6+4=", + "dev": true, + "requires": { + "abbrev": "1" + } + }, + "normalize-package-data": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", + "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", + "dev": true, + "requires": { + "hosted-git-info": "^2.1.4", + "resolve": "^1.10.0", + "semver": "2 || 3 || 4 || 5", + "validate-npm-package-license": "^3.0.1" + } + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", + "dev": true + }, + "pako": { + "version": "0.2.9", + "resolved": "https://registry.npmjs.org/pako/-/pako-0.2.9.tgz", + "integrity": "sha1-8/dSL073gjSNqBYbrZ7P1Rv4OnU=", + "dev": true + }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "dev": true, + "requires": { + "error-ex": "^1.2.0" + } + }, + "path-exists": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "dev": true, + "requires": { + "pinkie-promise": "^2.0.0" + } + }, + "path-parse": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", + "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", + "dev": true + }, + "path-type": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", + "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0" + }, + "dependencies": { + "graceful-fs": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.4.tgz", + "integrity": "sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw==", + "dev": true + } + } + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "pinkie": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=", + "dev": true + }, + "pinkie-promise": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", + "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", + "dev": true, + "requires": { + "pinkie": "^2.0.0" + } + }, + "pretty-bytes": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-1.0.4.tgz", + "integrity": "sha1-CiLoIQYJrTVUL4yNXSFZr/B1HIQ=", + "dev": true, + "requires": { + "get-stdin": "^4.0.1", + "meow": "^3.1.0" + } + }, + "process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "dev": true + }, + "read-pkg": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", + "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", + "dev": true, + "requires": { + "load-json-file": "^1.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^1.0.0" + } + }, + "read-pkg-up": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", + "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", + "dev": true, + "requires": { + "find-up": "^1.0.0", + "read-pkg": "^1.0.0" + } + }, + "readable-stream": { + "version": "2.3.7", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", + "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", + "dev": true, + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "redent": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/redent/-/redent-1.0.0.tgz", + "integrity": "sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=", + "dev": true, + "requires": { + "indent-string": "^2.1.0", + "strip-indent": "^1.0.1" + } + }, + "repeat-string": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", + "dev": true + }, + "repeating": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz", + "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", + "dev": true, + "requires": { + "is-finite": "^1.0.0" + } + }, + "requizzle": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.3.tgz", + "integrity": "sha512-YanoyJjykPxGHii0fZP0uUPEXpvqfBDxWV7s6GKAiiOsiqhX6vHNyW3Qzdmqp/iq/ExbhaGbVrjB4ruEVSM4GQ==", + "dev": true, + "requires": { + "lodash": "^4.17.14" + }, + "dependencies": { + "lodash": { + "version": "4.17.15", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz", + "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==", + "dev": true + } + } + }, + "resolve": { + "version": "1.17.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz", + "integrity": "sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==", + "dev": true, + "requires": { + "path-parse": "^1.0.6" + } + }, + "right-align": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/right-align/-/right-align-0.1.3.tgz", + "integrity": "sha1-YTObci/mo1FWiSENJOFMlhSGE+8=", + "dev": true, + "requires": { + "align-text": "^0.1.1" + } + }, + "rimraf": { + "version": "2.2.8", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.2.8.tgz", + "integrity": "sha1-5Dm+Kq7jJzIZUnMPmaiSnk/FBYI=", + "dev": true + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + }, + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true + }, + "sigmund": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz", + "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=", + "dev": true + }, + "signal-exit": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz", + "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==", + "dev": true + }, + "source-map": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.3.0.tgz", + "integrity": "sha1-hYb7mloAXltQHiHNGLbyG0V60fk=", + "dev": true, + "requires": { + "amdefine": ">=0.0.4" + } + }, + "spdx-correct": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz", + "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==", + "dev": true, + "requires": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-exceptions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz", + "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==", + "dev": true + }, + "spdx-expression-parse": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", + "dev": true, + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz", + "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==", + "dev": true + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", + "dev": true + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "requires": { + "safe-buffer": "~5.1.0" + } + }, + "strip-ansi": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-0.3.0.tgz", + "integrity": "sha1-JfSOoiynkYfzF0pNuHWTR7sSYiA=", + "dev": true, + "requires": { + "ansi-regex": "^0.2.1" + } + }, + "strip-bom": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", + "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", + "dev": true, + "requires": { + "is-utf8": "^0.2.0" + } + }, + "strip-indent": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-1.0.1.tgz", + "integrity": "sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=", + "dev": true, + "requires": { + "get-stdin": "^4.0.1" + } + }, + "strip-json-comments": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.0.tgz", + "integrity": "sha512-e6/d0eBu7gHtdCqFt0xJr642LdToM5/cN4Qb9DbHjVx1CP5RyeM+zH7pbecEmDv/lBqb0QH+6Uqq75rxFPkM0w==", + "dev": true + }, + "supports-color": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-0.2.0.tgz", + "integrity": "sha1-2S3iaU6z9nMjlz1649i1W0wiGQo=", + "dev": true + }, + "taffydb": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.6.2.tgz", + "integrity": "sha1-fLy2S1oUG2ou/CxdLGe04VCyomg=", + "dev": true + }, + "three": { + "version": "0.118.3", + "resolved": "https://registry.npmjs.org/three/-/three-0.118.3.tgz", + "integrity": "sha512-ijECXrNzDkHieoeh2H69kgawTGH8DiamhR4uBN8jEM7VHSKvfTdEvOoHsA8Aq7dh7PHAxhlqBsN5arBI3KixSw==" + }, + "trim-newlines": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz", + "integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM=", + "dev": true + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", + "dev": true + }, + "uc.micro": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-1.0.6.tgz", + "integrity": "sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA==", + "dev": true + }, + "uglify-js": { + "version": "2.8.29", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.29.tgz", + "integrity": "sha1-KcVzMUgFe7Th913zW3qcty5qWd0=", + "dev": true, + "requires": { + "source-map": "~0.5.1", + "uglify-to-browserify": "~1.0.0", + "yargs": "~3.10.0" + }, + "dependencies": { + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + } + } + }, + "uglify-to-browserify": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz", + "integrity": "sha1-bgkk1r2mta/jSeOabWMoUKD4grc=", + "dev": true, + "optional": true + }, + "underscore": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.7.0.tgz", + "integrity": "sha1-a7rwh3UA02vjTsqlhODbn+8DUgk=", + "dev": true + }, + "underscore.string": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.2.1.tgz", + "integrity": "sha1-18D6KvXVoaZ/QlPa7pgTLnM/Dxk=", + "dev": true + }, + "universalify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-1.0.0.tgz", + "integrity": "sha512-rb6X1W158d7pRQBg5gkR8uPaSfiids68LTJQYOtEUhoJUWBdaQHsuT/EUduxXYxcrt4r5PJ4fuHW1MHT6p0qug==", + "dev": true + }, + "uri-path": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/uri-path/-/uri-path-0.0.2.tgz", + "integrity": "sha1-gD6wHy/rF5J9zOD2GH5yt19T9VQ=", + "dev": true + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", + "dev": true + }, + "validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "dev": true, + "requires": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "which": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/which/-/which-1.0.9.tgz", + "integrity": "sha1-RgwdoPgQED0DIam2M6+eV15kSG8=", + "dev": true + }, + "window-size": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz", + "integrity": "sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0=", + "dev": true + }, + "wordwrap": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz", + "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=", + "dev": true + }, + "xmlcreate": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-2.0.3.tgz", + "integrity": "sha512-HgS+X6zAztGa9zIK3Y3LXuJes33Lz9x+YyTxgrkIdabu2vqcGOWwdfCpf1hWLRrd553wd4QCDf6BBO6FfdsRiQ==", + "dev": true + }, + "yargs": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz", + "integrity": "sha1-9+572FfdfB0tOMDnTvvWgdFDH9E=", + "dev": true, + "requires": { + "camelcase": "^1.0.2", + "cliui": "^2.1.0", + "decamelize": "^1.0.0", + "window-size": "0.1.0" + }, + "dependencies": { + "camelcase": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz", + "integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=", + "dev": true + } + } + } + } +} diff --git a/package.json b/package.json index 4e17e9e..d065c5e 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "shader-particle-engine", "description": "A GLSL-focused particle engine for THREE.js.", - "version": "1.0.6", + "version": "1.1.0", "author": "Luke Moody (https://github.com/squarefeet/)", "license": "MIT", "repository": { @@ -29,7 +29,8 @@ "grunt-jsdoc": "^1.0.0" }, "scripts": { - "test": "grunt" + "test": "grunt", + "build": "grunt" }, "main": "build/SPE.min.js", "directories": { @@ -37,6 +38,6 @@ "example": "examples" }, "dependencies": { - "three": "^0.84.0" + "three": "^0.118.3" } } diff --git a/src/core/SPE.Group.js b/src/core/SPE.Group.js index 06293a5..1e1d585 100644 --- a/src/core/SPE.Group.js +++ b/src/core/SPE.Group.js @@ -119,7 +119,7 @@ SPE.Group = function( options ) { // Map of uniforms to be applied to the ShaderMaterial instance. this.uniforms = { - texture: { + tex: { type: 't', value: this.texture }, @@ -495,9 +495,9 @@ SPE.Group.prototype.getFromPool = function() { } else if ( createNew ) { var emitter = new SPE.Emitter( this._poolCreationSettings ); - + this.addEmitter( emitter ); - + return emitter; } diff --git a/src/helpers/SPE.ShaderAttribute.js b/src/helpers/SPE.ShaderAttribute.js index d5ac9ad..95e1deb 100644 --- a/src/helpers/SPE.ShaderAttribute.js +++ b/src/helpers/SPE.ShaderAttribute.js @@ -99,8 +99,6 @@ SPE.ShaderAttribute.prototype.flagUpdate = function() { range.offset = this.updateMin; range.count = Math.min( ( this.updateMax - this.updateMin ) + this.componentSize, this.typedArray.array.length ); - // console.log( range.offset, range.count, this.typedArray.array.length ); - // console.log( 'flagUpdate:', range.offset, range.count ); attr.needsUpdate = true; }; @@ -118,7 +116,9 @@ SPE.ShaderAttribute.prototype.resetUpdateRange = function() { SPE.ShaderAttribute.prototype.resetDynamic = function() { 'use strict'; - this.bufferAttribute.dynamic = this.dynamicBuffer; + this.bufferAttribute.usage = this.dynamicBuffer ? + THREE.DynamicDrawUsage : + THREE.StaticDrawUsage; }; /** @@ -142,7 +142,8 @@ SPE.ShaderAttribute.prototype.forceUpdateAll = function() { this.bufferAttribute.array = this.typedArray.array; this.bufferAttribute.updateRange.offset = 0; this.bufferAttribute.updateRange.count = -1; - this.bufferAttribute.dynamic = false; + + this.bufferAttribute.usage = THREE.StaticDrawUsage; this.bufferAttribute.needsUpdate = true; }; @@ -211,7 +212,10 @@ SPE.ShaderAttribute.prototype._createBufferAttribute = function( size ) { } this.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize ); - this.bufferAttribute.dynamic = this.dynamicBuffer; + + this.bufferAttribute.usage = this.dynamicBuffer ? + THREE.DynamicDrawUsage : + THREE.StaticDrawUsage; }; /** diff --git a/src/shaders/SPE.shaderChunks.js b/src/shaders/SPE.shaderChunks.js index 2257739..2860b75 100644 --- a/src/shaders/SPE.shaderChunks.js +++ b/src/shaders/SPE.shaderChunks.js @@ -9,7 +9,7 @@ SPE.shaderChunks = { uniforms: [ 'uniform float deltaTime;', 'uniform float runTime;', - 'uniform sampler2D texture;', + 'uniform sampler2D tex;', 'uniform vec4 textureAnimation;', 'uniform float scale;', ].join( '\n' ), @@ -250,6 +250,6 @@ SPE.shaderChunks = { ' #endif', '', - ' vec4 rotatedTexture = texture2D( texture, vUv );', + ' vec4 rotatedTexture = texture2D( tex, vUv );', ].join( '\n' ) }; \ No newline at end of file From d4b1aa66ece0d13de5c1221d5ca333bf23bf2637 Mon Sep 17 00:00:00 2001 From: Luke Moody Date: Sun, 28 Jun 2020 15:23:58 +0100 Subject: [PATCH 2/5] Upgraded to webpack. Removed Grunt dependency. Bumped package to 2.0.0. --- .eslintrc.js | 186 + .jsbeautifyrc | 18 - .jshintrc | 64 - bower.json | 19 - build/SPE.js | 3598 ---------- build/SPE.min.js | 52 - dist/SPE.js | 12 + docs/api/Emitter.html | 213 - docs/api/SPE.Emitter.html | 848 --- docs/api/SPE.Group.html | 1497 ----- docs/api/SPE.ShaderAttribute.html | 1416 ---- docs/api/SPE.TypedArrayHelper.html | 3308 --------- docs/api/SPE.html | 427 -- docs/api/SPE.js.html | 132 - docs/api/constants_distributions.js.html | 88 + docs/api/constants_typeSizeMap.js.html | 100 + docs/api/constants_valueTypes.js.html | 77 + docs/api/core_Emitter.js.html | 1005 +++ docs/api/core_Group.js.html | 775 +++ docs/api/core_SPE.Emitter.js.html | 1041 --- docs/api/core_SPE.Group.js.html | 798 --- docs/api/core_SPE.utils.js.html | 755 --- docs/api/core_utils.js.html | 755 +++ docs/api/global.html | 5939 ++++++++++++++++- docs/api/helpers_SPE.ShaderAttribute.js.html | 269 - docs/api/helpers_SPE.TypedArrayHelper.js.html | 381 -- docs/api/helpers_ShaderAttribute.js.html | 223 + docs/api/helpers_TypedArrayHelper.js.html | 346 + docs/api/index.html | 4 +- .../{SPE.utils.html => module.html#.exports} | 1488 ++++- docs/api/scripts/linenumber.js | 18 +- docs/api/styles/jsdoc-default.css | 79 +- docs/source/SPE.html | 5342 --------------- docs/source/docco.css | 24 +- docs/source/public/fonts/novecento-bold.eot | Bin 18190 -> 0 bytes docs/source/public/fonts/novecento-bold.ttf | Bin 48136 -> 0 bytes docs/source/public/fonts/novecento-bold.woff | Bin 20576 -> 0 bytes docs/source/public/fonts/roboto-black.eot | Bin 0 -> 20702 bytes docs/source/public/fonts/roboto-black.ttf | Bin 0 -> 44828 bytes docs/source/public/fonts/roboto-black.woff | Bin 0 -> 24536 bytes docs/source/src/constants/distributions.html | 145 + docs/source/src/constants/globals.html | 110 + docs/source/src/constants/typeSizeMap.html | 155 + docs/source/src/constants/valueTypes.html | 133 + docs/source/src/core/Emitter.html | 1500 +++++ docs/source/src/core/Group.html | 1485 +++++ docs/source/src/core/utils.html | 1046 +++ docs/source/src/helpers/ShaderAttribute.html | 363 + docs/source/src/helpers/TypedArrayHelper.html | 416 ++ docs/source/src/shaders/shaderChunks.html | 508 ++ docs/source/src/shaders/shaders.html | 491 ++ examples/activeMultiplier.html | 4 +- examples/basic.html | 4 +- examples/clock.html | 4 +- examples/clouds.html | 4 +- examples/distributions.html | 4 +- examples/explosion.html | 4 +- examples/fog.html | 4 +- examples/js/THREE-r118.js | 1064 +++ examples/js/THREE-r84.js | 859 --- examples/mouseFollow.html | 4 +- examples/multipleEmitters.html | 8 +- examples/orbit.html | 8 +- examples/pool.html | 4 +- examples/rotation.html | 4 +- examples/runtimeChanging.html | 4 +- package-lock.json | 4596 ++++++++++++- package.json | 28 +- presets/README.md | 6 - presets/WheresTheFloor.js | 32 - src/SPE.js | 88 - src/constants/distributions.js | 38 + src/constants/globals.js | 3 + src/constants/typeSizeMap.js | 49 + src/constants/valueTypes.js | 26 + src/core/Emitter.js | 955 +++ src/core/Group.js | 724 ++ src/core/SPE.Emitter.js | 1001 --- src/core/SPE.Group.js | 752 --- src/core/SPE.utils.js | 732 -- src/core/utils.js | 704 ++ src/helpers/SPE.ShaderAttribute.js | 233 - src/helpers/SPE.TypedArrayHelper.js | 331 - src/helpers/ShaderAttribute.js | 172 + src/helpers/TypedArrayHelper.js | 296 + src/index.js | 8 + src/shaders/SPE.shaderChunks.js | 255 - src/shaders/shaderChunks.js | 255 + src/shaders/{SPE.shaders.js => shaders.js} | 45 +- webpack.config.js | 37 + 90 files changed, 26126 insertions(+), 24872 deletions(-) create mode 100644 .eslintrc.js delete mode 100644 .jsbeautifyrc delete mode 100644 .jshintrc delete mode 100644 bower.json delete mode 100644 build/SPE.js delete mode 100644 build/SPE.min.js create mode 100644 dist/SPE.js delete mode 100644 docs/api/Emitter.html delete mode 100644 docs/api/SPE.Emitter.html delete mode 100644 docs/api/SPE.Group.html delete mode 100644 docs/api/SPE.ShaderAttribute.html delete mode 100644 docs/api/SPE.TypedArrayHelper.html delete mode 100644 docs/api/SPE.html delete mode 100644 docs/api/SPE.js.html create mode 100644 docs/api/constants_distributions.js.html create mode 100644 docs/api/constants_typeSizeMap.js.html create mode 100644 docs/api/constants_valueTypes.js.html create mode 100644 docs/api/core_Emitter.js.html create mode 100644 docs/api/core_Group.js.html delete mode 100644 docs/api/core_SPE.Emitter.js.html delete mode 100644 docs/api/core_SPE.Group.js.html delete mode 100644 docs/api/core_SPE.utils.js.html create mode 100644 docs/api/core_utils.js.html delete mode 100644 docs/api/helpers_SPE.ShaderAttribute.js.html delete mode 100644 docs/api/helpers_SPE.TypedArrayHelper.js.html create mode 100644 docs/api/helpers_ShaderAttribute.js.html create mode 100644 docs/api/helpers_TypedArrayHelper.js.html rename docs/api/{SPE.utils.html => module.html#.exports} (71%) delete mode 100644 docs/source/SPE.html delete mode 100644 docs/source/public/fonts/novecento-bold.eot delete mode 100644 docs/source/public/fonts/novecento-bold.ttf delete mode 100644 docs/source/public/fonts/novecento-bold.woff create mode 100755 docs/source/public/fonts/roboto-black.eot create mode 100755 docs/source/public/fonts/roboto-black.ttf create mode 100755 docs/source/public/fonts/roboto-black.woff create mode 100644 docs/source/src/constants/distributions.html create mode 100644 docs/source/src/constants/globals.html create mode 100644 docs/source/src/constants/typeSizeMap.html create mode 100644 docs/source/src/constants/valueTypes.html create mode 100644 docs/source/src/core/Emitter.html create mode 100644 docs/source/src/core/Group.html create mode 100644 docs/source/src/core/utils.html create mode 100644 docs/source/src/helpers/ShaderAttribute.html create mode 100644 docs/source/src/helpers/TypedArrayHelper.html create mode 100644 docs/source/src/shaders/shaderChunks.html create mode 100644 docs/source/src/shaders/shaders.html create mode 100755 examples/js/THREE-r118.js delete mode 100755 examples/js/THREE-r84.js delete mode 100644 presets/README.md delete mode 100644 presets/WheresTheFloor.js delete mode 100644 src/SPE.js create mode 100644 src/constants/distributions.js create mode 100644 src/constants/globals.js create mode 100644 src/constants/typeSizeMap.js create mode 100644 src/constants/valueTypes.js create mode 100644 src/core/Emitter.js create mode 100644 src/core/Group.js delete mode 100644 src/core/SPE.Emitter.js delete mode 100644 src/core/SPE.Group.js delete mode 100644 src/core/SPE.utils.js create mode 100644 src/core/utils.js delete mode 100644 src/helpers/SPE.ShaderAttribute.js delete mode 100644 src/helpers/SPE.TypedArrayHelper.js create mode 100644 src/helpers/ShaderAttribute.js create mode 100644 src/helpers/TypedArrayHelper.js create mode 100644 src/index.js delete mode 100644 src/shaders/SPE.shaderChunks.js create mode 100644 src/shaders/shaderChunks.js rename src/shaders/{SPE.shaders.js => shaders.js} (87%) create mode 100644 webpack.config.js diff --git a/.eslintrc.js b/.eslintrc.js new file mode 100644 index 0000000..dd9fcbe --- /dev/null +++ b/.eslintrc.js @@ -0,0 +1,186 @@ +// https://eslint.org/docs/user-guide/configuring + +module.exports = { + root: true, + + parserOptions: { + parser: 'babel-eslint', + ecmaVersion: 2017, + sourceType: 'module', + }, + + env: { + browser: true, + }, + + extends: [ + 'eslint:recommended', + ], + + // required to lint *.vue files + plugins: [], + + globals: { + Promise: true, + Uint32Array: true, + Float32Array: true, + module: true, + require: true, + __dirname: true, + __filename: true, + process: true, + describe: true, + it: true, + before: true, + after: true, + beforeEach: true, + afterEach: true, + Buffer: true, + Set: true, + expect: true, + }, + + // add your custom rules here + rules: { + quotes: [ 'error', 'single' ], + + 'quote-props': [ 'error', 'as-needed' ], + + // allow debugger during development + 'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off', + + semi: 'error', + + 'comma-dangle': [ 'error', { + arrays: 'always-multiline', + objects: 'always-multiline', + imports: 'always-multiline', + exports: 'always-multiline', + functions: 'ignore', + } ], + + 'lines-around-comment': [ 'error', { + beforeLineComment: false, + beforeBlockComment: true, + } ], + + 'newline-per-chained-call': [ 'error', { + ignoreChainWithDepth: 2, + } ], + + 'arrow-parens': [ + 'error', + 'as-needed', + ], + + 'space-in-parens': [ + 'error', + 'always', + ], + + 'computed-property-spacing': [ + 'error', + 'always', + ], + + 'object-curly-spacing': [ + 'error', + 'always', + ], + + 'array-bracket-spacing': [ + 'error', + 'always', + ], + + 'no-cond-assign': 'error', + 'no-constant-condition': 'error', + 'no-dupe-args': 'error', + 'no-sparse-arrays': 'error', + 'no-unreachable': 'error', + 'valid-typeof': 'error', + curly: [ + 'error', + 'all', + ], + 'dot-notation': 'error', + 'guard-for-in': 'error', + 'no-caller': 'error', + 'no-eval': 'error', + 'no-lone-blocks': 'error', + 'no-new-func': 'error', + 'no-new-wrappers': 'error', + 'no-param-reassign': [ + 'error', { + props: false, + }, + ], + 'no-redeclare': 'error', + 'no-self-compare': 'error', + 'no-with': 'error', + radix: 'error', + 'vars-on-top': 'error', + 'wrap-iife': 'error', + yoda: [ + 'error', + 'never', + ], + 'no-shadow': 'error', + 'no-undef': 'error', + 'no-unused-vars': 'error', + 'brace-style': [ + 'error', + 'stroustrup', + ], + camelcase: [ + 'error', { + properties: 'always', + }, + ], + 'func-style': [ + 'error', + 'declaration', + ], + 'max-nested-callbacks': [ + 'error', + 7, + ], + 'no-array-constructor': 'error', + 'no-mixed-spaces-and-tabs': 'error', + 'no-nested-ternary': 'error', + 'no-var': 'off', + 'object-shorthand': [ + 'error', + 'always', + ], + 'prefer-const': 'error', + 'max-params': 'off', + 'space-before-function-paren': [ + 'error', { + anonymous: 'never', + named: 'never', + }, + ], + 'prefer-arrow-callback': 'off', + 'max-depth': [ + 'error', + 4, + ], + 'no-implicit-coercion': 'off', + complexity: 'off', + 'prefer-template': 'off', + 'babel/new-cap': 'off', + 'new-cap': [ + 'error', { + properties: false, + }, + ], + 'no-loop-func': 'off', + 'no-warning-comments': [ 'error', { + terms: [ 'fixme' ], + location: 'anywhere', + } ], + 'no-console': 'off', + indent: [ 'error', 'tab', { SwitchCase: 1 } ], + }, +}; diff --git a/.jsbeautifyrc b/.jsbeautifyrc deleted file mode 100644 index da12aa7..0000000 --- a/.jsbeautifyrc +++ /dev/null @@ -1,18 +0,0 @@ -{ - "indent_size": 4, - "indent_char": " ", - "indent_level": 0, - "indent_with_tabs": false, - "preserve_newlines": true, - "max_preserve_newlines": 10, - "jslint_happy": false, - "brace_style": "end-expand", - "keep_array_indentation": false, - "keep_function_indentation": false, - "space_before_conditional": true, - "break_chained_methods": false, - "eval_code": false, - "unescape_strings": false, - "wrap_line_length": 0, - "space_in_paren": true -} diff --git a/.jshintrc b/.jshintrc deleted file mode 100644 index 50940a0..0000000 --- a/.jshintrc +++ /dev/null @@ -1,64 +0,0 @@ -{ - // Settings - "passfail" : true, // Stop on first error. - "maxerr" : 100, // Maximum errors before stopping. - - // Predefined globals whom JSHint will ignore. - "browser" : true, // Standard browser globals e.g. `window`, `document`. - - "node" : false, - "rhino" : false, - "couch" : false, - - "jquery" : false, - "prototypejs" : false, - "mootools" : false, - "dojo" : false, - - "predef" : [ // Extra globals. - "SPE", - "THREE", - "define", - "module" - ], - - // Development. - "debug" : false, // Allow debugger statements e.g. browser breakpoints. - "devel" : true, // Allow development statements e.g. `console.log();`. - - // EcmaScript 5. - "strict" : true, // Require `use strict` pragma in every file. - "globalstrict" : false, // Allow global "use strict" (also enables 'strict'). - - // The Good Parts. - "asi" : false, // Tolerate Automatic Semicolon Insertion (no semicolons). - "laxbreak" : false, // Tolerate unsafe line breaks e.g. `return [\n] x` without semicolons. - "bitwise" : false, // Prohibit bitwise operators (&, |, ^, etc.). - "boss" : true, // Tolerate assignments inside if, for & while. Usually conditions & loops are for comparison, not assignments. - "curly" : true, // Require {} for every new block or scope. - "eqeqeq" : false, // Require triple equals i.e. `===`. - "eqnull" : false, // Tolerate use of `== null`. - "evil" : false, // Tolerate use of `eval`. - "expr" : true, // Tolerate `ExpressionStatement` as Programs. - "forin" : false, // Tolerate `for in` loops without `hasOwnPrototype`. - "immed" : true, // Require immediate invocations to be wrapped in parens e.g. `( function(){}() );` - "latedef" : true, // Prohibit variable use before definition. - "loopfunc" : true, // Allow functions to be defined within loops. - "noarg" : true, // Prohibit use of `arguments.caller` and `arguments.callee`. - "regexp" : false, // Prohibit `.` and `[^...]` in regular expressions. - "regexdash" : false, // Tolerate unescaped last dash i.e. `[-...]`. - "scripturl" : true, // Tolerate script-targeted URLs. - "shadow" : true, // Allows re-define variables later in code e.g. `var x=1; x=2;`. - "supernew" : false, // Tolerate `new function () { ... };` and `new Object;`. - "undef" : true, // Require all non-global variables be declared before they are used. - - // Persone styling prefrences. - "newcap" : true, // Require capitalization of all constructor functions e.g. `new F()`. - "noempty" : true, // Prohibit use of empty blocks. - "nonew" : true, // Prohibit use of constructors for side-effects. - "nomen" : false, // Prohibit use of initial or trailing underbars in names. - "onevar" : false, // Allow only one `var` statement per function. - "plusplus" : false, // Prohibit use of `++` & `--`. - "sub" : false, // Tolerate all forms of subscript notation besides dot notation e.g. `dict['key']` instead of `dict.key`. - "trailing" : true // Prohibit trailing whitespaces. -} diff --git a/bower.json b/bower.json deleted file mode 100644 index 00ff839..0000000 --- a/bower.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "name": "ShaderParticleEngine", - "version": "1.0.6", - "homepage": "http://squarefeet.github.io/ShaderParticleEngine/", - "authors": [ - "Luke Moody" - ], - "ignore": [ - "examples", - "presets", - "src", - "tests", - "docs" - ], - "description": "", - "main": "build/SPE.min.js", - "moduleType": [], - "license": "MIT" -} diff --git a/build/SPE.js b/build/SPE.js deleted file mode 100644 index f8f2169..0000000 --- a/build/SPE.js +++ /dev/null @@ -1,3598 +0,0 @@ -/* shader-particle-engine 1.0.6 - * - * (c) 2015 Luke Moody (http://www.github.com/squarefeet) - * Originally based on Lee Stemkoski's original work (https://github.com/stemkoski/stemkoski.github.com/blob/master/Three.js/js/ParticleEngine.js). - * - * shader-particle-engine may be freely distributed under the MIT license (See LICENSE at root of this repository.) - */ -/** - * @typedef {Number} distribution - * @property {Number} SPE.distributions.BOX Values will be distributed within a box. - * @property {Number} SPE.distributions.SPHERE Values will be distributed within a sphere. - * @property {Number} SPE.distributions.DISC Values will be distributed within a 2D disc. - */ - -/** - * Namespace for Shader Particle Engine. - * - * All SPE-related code sits under this namespace. - * - * @type {Object} - * @namespace - */ -var SPE = { - - /** - * A map of supported distribution types used - * by SPE.Emitter instances. - * - * These distribution types can be applied to - * an emitter globally, which will affect the - * `position`, `velocity`, and `acceleration` - * value calculations for an emitter, or they - * can be applied on a per-property basis. - * - * @enum {Number} - */ - distributions: { - /** - * Values will be distributed within a box. - * @type {Number} - */ - BOX: 1, - - /** - * Values will be distributed on a sphere. - * @type {Number} - */ - SPHERE: 2, - - /** - * Values will be distributed on a 2d-disc shape. - * @type {Number} - */ - DISC: 3, - - /** - * Values will be distributed along a line. - * @type {Number} - */ - LINE: 4 - }, - - - /** - * Set this value to however many 'steps' you - * want value-over-lifetime properties to have. - * - * It's adjustable to fix an interpolation problem: - * - * Assuming you specify an opacity value as [0, 1, 0] - * and the `valueOverLifetimeLength` is 4, then the - * opacity value array will be reinterpolated to - * be [0, 0.66, 0.66, 0]. - * This isn't ideal, as particles would never reach - * full opacity. - * - * NOTE: - * This property affects the length of ALL - * value-over-lifetime properties for ALL - * emitters and ALL groups. - * - * Only values >= 3 && <= 4 are allowed. - * - * @type {Number} - */ - valueOverLifetimeLength: 4 -}; - -// Module loader support: -if ( typeof define === 'function' && define.amd ) { - define( 'spe', SPE ); -} -else if ( typeof exports !== 'undefined' && typeof module !== 'undefined' ) { - module.exports = SPE; -} - - -/** - * A helper class for TypedArrays. - * - * Allows for easy resizing, assignment of various component-based - * types (Vector2s, Vector3s, Vector4s, Mat3s, Mat4s), - * as well as Colors (where components are `r`, `g`, `b`), - * Numbers, and setting from other TypedArrays. - * - * @author Luke Moody - * @constructor - * @param {Function} TypedArrayConstructor The constructor to use (Float32Array, Uint8Array, etc.) - * @param {Number} size The size of the array to create - * @param {Number} componentSize The number of components per-value (ie. 3 for a vec3, 9 for a Mat3, etc.) - * @param {Number} indexOffset The index in the array from which to start assigning values. Default `0` if none provided - */ -SPE.TypedArrayHelper = function( TypedArrayConstructor, size, componentSize, indexOffset ) { - 'use strict'; - - this.componentSize = componentSize || 1; - this.size = ( size || 1 ); - this.TypedArrayConstructor = TypedArrayConstructor || Float32Array; - this.array = new TypedArrayConstructor( size * this.componentSize ); - this.indexOffset = indexOffset || 0; -}; - -SPE.TypedArrayHelper.constructor = SPE.TypedArrayHelper; - -/** - * Sets the size of the internal array. - * - * Delegates to `this.shrink` or `this.grow` depending on size - * argument's relation to the current size of the internal array. - * - * Note that if the array is to be shrunk, data will be lost. - * - * @param {Number} size The new size of the array. - */ -SPE.TypedArrayHelper.prototype.setSize = function( size, noComponentMultiply ) { - 'use strict'; - - var currentArraySize = this.array.length; - - if ( !noComponentMultiply ) { - size = size * this.componentSize; - } - - if ( size < currentArraySize ) { - return this.shrink( size ); - } - else if ( size > currentArraySize ) { - return this.grow( size ); - } - else { - console.info( 'TypedArray is already of size:', size + '.', 'Will not resize.' ); - } -}; - -/** - * Shrinks the internal array. - * - * @param {Number} size The new size of the typed array. Must be smaller than `this.array.length`. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.shrink = function( size ) { - 'use strict'; - - this.array = this.array.subarray( 0, size ); - this.size = size; - return this; -}; - -/** - * Grows the internal array. - * @param {Number} size The new size of the typed array. Must be larger than `this.array.length`. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.grow = function( size ) { - 'use strict'; - - var existingArray = this.array, - newArray = new this.TypedArrayConstructor( size ); - - newArray.set( existingArray ); - this.array = newArray; - this.size = size; - - return this; -}; - - -/** - * Perform a splice operation on this array's buffer. - * @param {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute. - * @param {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute. - * @returns {Object} The SPE.TypedArrayHelper instance. - */ -SPE.TypedArrayHelper.prototype.splice = function( start, end ) { - 'use strict'; - start *= this.componentSize; - end *= this.componentSize; - - var data = [], - array = this.array, - size = array.length; - - for ( var i = 0; i < size; ++i ) { - if ( i < start || i >= end ) { - data.push( array[ i ] ); - } - // array[ i ] = 0; - } - - this.setFromArray( 0, data ); - - return this; -}; - - -/** - * Copies from the given TypedArray into this one, using the index argument - * as the start position. Alias for `TypedArray.set`. Will automatically resize - * if the given source array is of a larger size than the internal array. - * - * @param {Number} index The start position from which to copy into this array. - * @param {TypedArray} array The array from which to copy; the source array. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setFromArray = function( index, array ) { - 'use strict'; - - var sourceArraySize = array.length, - newSize = index + sourceArraySize; - - if ( newSize > this.array.length ) { - this.grow( newSize ); - } - else if ( newSize < this.array.length ) { - this.shrink( newSize ); - } - - this.array.set( array, this.indexOffset + index ); - - return this; -}; - -/** - * Set a Vector2 value at `index`. - * - * @param {Number} index The index at which to set the vec2 values from. - * @param {Vector2} vec2 Any object that has `x` and `y` properties. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setVec2 = function( index, vec2 ) { - 'use strict'; - - return this.setVec2Components( index, vec2.x, vec2.y ); -}; - -/** - * Set a Vector2 value using raw components. - * - * @param {Number} index The index at which to set the vec2 values from. - * @param {Number} x The Vec2's `x` component. - * @param {Number} y The Vec2's `y` component. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setVec2Components = function( index, x, y ) { - 'use strict'; - - var array = this.array, - i = this.indexOffset + ( index * this.componentSize ); - - array[ i ] = x; - array[ i + 1 ] = y; - return this; -}; - -/** - * Set a Vector3 value at `index`. - * - * @param {Number} index The index at which to set the vec3 values from. - * @param {Vector3} vec2 Any object that has `x`, `y`, and `z` properties. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setVec3 = function( index, vec3 ) { - 'use strict'; - - return this.setVec3Components( index, vec3.x, vec3.y, vec3.z ); -}; - -/** - * Set a Vector3 value using raw components. - * - * @param {Number} index The index at which to set the vec3 values from. - * @param {Number} x The Vec3's `x` component. - * @param {Number} y The Vec3's `y` component. - * @param {Number} z The Vec3's `z` component. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setVec3Components = function( index, x, y, z ) { - 'use strict'; - - var array = this.array, - i = this.indexOffset + ( index * this.componentSize ); - - array[ i ] = x; - array[ i + 1 ] = y; - array[ i + 2 ] = z; - return this; -}; - -/** - * Set a Vector4 value at `index`. - * - * @param {Number} index The index at which to set the vec4 values from. - * @param {Vector4} vec2 Any object that has `x`, `y`, `z`, and `w` properties. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setVec4 = function( index, vec4 ) { - 'use strict'; - - return this.setVec4Components( index, vec4.x, vec4.y, vec4.z, vec4.w ); -}; - -/** - * Set a Vector4 value using raw components. - * - * @param {Number} index The index at which to set the vec4 values from. - * @param {Number} x The Vec4's `x` component. - * @param {Number} y The Vec4's `y` component. - * @param {Number} z The Vec4's `z` component. - * @param {Number} w The Vec4's `w` component. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setVec4Components = function( index, x, y, z, w ) { - 'use strict'; - - var array = this.array, - i = this.indexOffset + ( index * this.componentSize ); - - array[ i ] = x; - array[ i + 1 ] = y; - array[ i + 2 ] = z; - array[ i + 3 ] = w; - return this; -}; - -/** - * Set a Matrix3 value at `index`. - * - * @param {Number} index The index at which to set the matrix values from. - * @param {Matrix3} mat3 The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setMat3 = function( index, mat3 ) { - 'use strict'; - - return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat3.elements ); -}; - -/** - * Set a Matrix4 value at `index`. - * - * @param {Number} index The index at which to set the matrix values from. - * @param {Matrix4} mat3 The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setMat4 = function( index, mat4 ) { - 'use strict'; - - return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat4.elements ); -}; - -/** - * Set a Color value at `index`. - * - * @param {Number} index The index at which to set the vec3 values from. - * @param {Color} color Any object that has `r`, `g`, and `b` properties. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setColor = function( index, color ) { - 'use strict'; - - return this.setVec3Components( index, color.r, color.g, color.b ); -}; - -/** - * Set a Number value at `index`. - * - * @param {Number} index The index at which to set the vec3 values from. - * @param {Number} numericValue The number to assign to this index in the array. - * @return {SPE.TypedArrayHelper} Instance of this class. - */ -SPE.TypedArrayHelper.prototype.setNumber = function( index, numericValue ) { - 'use strict'; - - this.array[ this.indexOffset + ( index * this.componentSize ) ] = numericValue; - return this; -}; - -/** - * Returns the value of the array at the given index, taking into account - * the `indexOffset` property of this class. - * - * Note that this function ignores the component size and will just return a - * single value. - * - * @param {Number} index The index in the array to fetch. - * @return {Number} The value at the given index. - */ -SPE.TypedArrayHelper.prototype.getValueAtIndex = function( index ) { - 'use strict'; - - return this.array[ this.indexOffset + index ]; -}; - -/** - * Returns the component value of the array at the given index, taking into account - * the `indexOffset` property of this class. - * - * If the componentSize is set to 3, then it will return a new TypedArray - * of length 3. - * - * @param {Number} index The index in the array to fetch. - * @return {TypedArray} The component value at the given index. - */ -SPE.TypedArrayHelper.prototype.getComponentValueAtIndex = function( index ) { - 'use strict'; - - return this.array.subarray( this.indexOffset + ( index * this.componentSize ) ); -}; - -/** - * A helper to handle creating and updating a THREE.BufferAttribute instance. - * - * @author Luke Moody - * @constructor - * @param {String} type The buffer attribute type. See SPE.ShaderAttribute.typeSizeMap for valid values. - * @param {Boolean=} dynamicBuffer Whether this buffer attribute should be marked as dynamic or not. - * @param {Function=} arrayType A reference to a TypedArray constructor. Defaults to Float32Array if none provided. - */ -SPE.ShaderAttribute = function( type, dynamicBuffer, arrayType ) { - 'use strict'; - - var typeMap = SPE.ShaderAttribute.typeSizeMap; - - this.type = typeof type === 'string' && typeMap.hasOwnProperty( type ) ? type : 'f'; - this.componentSize = typeMap[ this.type ]; - this.arrayType = arrayType || Float32Array; - this.typedArray = null; - this.bufferAttribute = null; - this.dynamicBuffer = !!dynamicBuffer; - - this.updateMin = 0; - this.updateMax = 0; -}; - -SPE.ShaderAttribute.constructor = SPE.ShaderAttribute; - -/** - * A map of uniform types to their component size. - * @enum {Number} - */ -SPE.ShaderAttribute.typeSizeMap = { - /** - * Float - * @type {Number} - */ - f: 1, - - /** - * Vec2 - * @type {Number} - */ - v2: 2, - - /** - * Vec3 - * @type {Number} - */ - v3: 3, - - /** - * Vec4 - * @type {Number} - */ - v4: 4, - - /** - * Color - * @type {Number} - */ - c: 3, - - /** - * Mat3 - * @type {Number} - */ - m3: 9, - - /** - * Mat4 - * @type {Number} - */ - m4: 16 -}; - -/** - * Calculate the minimum and maximum update range for this buffer attribute using - * component size independant min and max values. - * - * @param {Number} min The start of the range to mark as needing an update. - * @param {Number} max The end of the range to mark as needing an update. - */ -SPE.ShaderAttribute.prototype.setUpdateRange = function( min, max ) { - 'use strict'; - - this.updateMin = Math.min( min * this.componentSize, this.updateMin * this.componentSize ); - this.updateMax = Math.max( max * this.componentSize, this.updateMax * this.componentSize ); -}; - -/** - * Calculate the number of indices that this attribute should mark as needing - * updating. Also marks the attribute as needing an update. - */ -SPE.ShaderAttribute.prototype.flagUpdate = function() { - 'use strict'; - - var attr = this.bufferAttribute, - range = attr.updateRange; - - range.offset = this.updateMin; - range.count = Math.min( ( this.updateMax - this.updateMin ) + this.componentSize, this.typedArray.array.length ); - // console.log( range.offset, range.count, this.typedArray.array.length ); - // console.log( 'flagUpdate:', range.offset, range.count ); - attr.needsUpdate = true; -}; - - - -/** - * Reset the index update counts for this attribute - */ -SPE.ShaderAttribute.prototype.resetUpdateRange = function() { - 'use strict'; - - this.updateMin = 0; - this.updateMax = 0; -}; - -SPE.ShaderAttribute.prototype.resetDynamic = function() { - 'use strict'; - this.bufferAttribute.usage = this.dynamicBuffer ? - THREE.DynamicDrawUsage : - THREE.StaticDrawUsage; -}; - -/** - * Perform a splice operation on this attribute's buffer. - * @param {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute. - * @param {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute. - */ -SPE.ShaderAttribute.prototype.splice = function( start, end ) { - 'use strict'; - - this.typedArray.splice( start, end ); - - // Reset the reference to the attribute's typed array - // since it has probably changed. - this.forceUpdateAll(); -}; - -SPE.ShaderAttribute.prototype.forceUpdateAll = function() { - 'use strict'; - - this.bufferAttribute.array = this.typedArray.array; - this.bufferAttribute.updateRange.offset = 0; - this.bufferAttribute.updateRange.count = -1; - // this.bufferAttribute.dynamic = false; - // this.bufferAttribute.usage = this.dynamicBuffer ? - // THREE.DynamicDrawUsage : - // THREE.StaticDrawUsage; - - this.bufferAttribute.usage = THREE.StaticDrawUsage; - this.bufferAttribute.needsUpdate = true; -}; - -/** - * Make sure this attribute has a typed array associated with it. - * - * If it does, then it will ensure the typed array is of the correct size. - * - * If not, a new SPE.TypedArrayHelper instance will be created. - * - * @param {Number} size The size of the typed array to create or update to. - */ -SPE.ShaderAttribute.prototype._ensureTypedArray = function( size ) { - 'use strict'; - - // Condition that's most likely to be true at the top: no change. - if ( this.typedArray !== null && this.typedArray.size === size * this.componentSize ) { - return; - } - - // Resize the array if we need to, telling the TypedArrayHelper to - // ignore it's component size when evaluating size. - else if ( this.typedArray !== null && this.typedArray.size !== size ) { - this.typedArray.setSize( size ); - } - - // This condition should only occur once in an attribute's lifecycle. - else if ( this.typedArray === null ) { - this.typedArray = new SPE.TypedArrayHelper( this.arrayType, size, this.componentSize ); - } -}; - - -/** - * Creates a THREE.BufferAttribute instance if one doesn't exist already. - * - * Ensures a typed array is present by calling _ensureTypedArray() first. - * - * If a buffer attribute exists already, then it will be marked as needing an update. - * - * @param {Number} size The size of the typed array to create if one doesn't exist, or resize existing array to. - */ -SPE.ShaderAttribute.prototype._createBufferAttribute = function( size ) { - 'use strict'; - - // Make sure the typedArray is present and correct. - this._ensureTypedArray( size ); - - // Don't create it if it already exists, but do - // flag that it needs updating on the next render - // cycle. - if ( this.bufferAttribute !== null ) { - this.bufferAttribute.array = this.typedArray.array; - - // Since THREE.js version 81, dynamic count calculation was removed - // so I need to do it manually here. - // - // In the next minor release, I may well remove this check and force - // dependency on THREE r81+. - if ( parseFloat( THREE.REVISION ) >= 81 ) { - this.bufferAttribute.count = this.bufferAttribute.array.length / this.bufferAttribute.itemSize; - } - - this.bufferAttribute.needsUpdate = true; - return; - } - - this.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize ); - // this.bufferAttribute.dynamic = this.dynamicBuffer; - this.bufferAttribute.usage = this.dynamicBuffer ? - THREE.DynamicDrawUsage : - THREE.StaticDrawUsage; -}; - -/** - * Returns the length of the typed array associated with this attribute. - * @return {Number} The length of the typed array. Will be 0 if no typed array has been created yet. - */ -SPE.ShaderAttribute.prototype.getLength = function() { - 'use strict'; - - if ( this.typedArray === null ) { - return 0; - } - - return this.typedArray.array.length; -}; - - -SPE.shaderChunks = { - // Register color-packing define statements. - defines: [ - '#define PACKED_COLOR_SIZE 256.0', - '#define PACKED_COLOR_DIVISOR 255.0' - ].join( '\n' ), - - // All uniforms used by vertex / fragment shaders - uniforms: [ - 'uniform float deltaTime;', - 'uniform float runTime;', - 'uniform sampler2D tex;', - 'uniform vec4 textureAnimation;', - 'uniform float scale;', - ].join( '\n' ), - - // All attributes used by the vertex shader. - // - // Note that some attributes are squashed into other ones: - // - // * Drag is acceleration.w - attributes: [ - 'attribute vec4 acceleration;', - 'attribute vec3 velocity;', - 'attribute vec4 rotation;', - 'attribute vec3 rotationCenter;', - 'attribute vec4 params;', - 'attribute vec4 size;', - 'attribute vec4 angle;', - 'attribute vec4 color;', - 'attribute vec4 opacity;' - ].join( '\n' ), - - // - varyings: [ - 'varying vec4 vColor;', - '#ifdef SHOULD_ROTATE_TEXTURE', - ' varying float vAngle;', - '#endif', - - '#ifdef SHOULD_CALCULATE_SPRITE', - ' varying vec4 vSpriteSheet;', - '#endif' - ].join( '\n' ), - - - // Branch-avoiding comparison fns - // - http://theorangeduck.com/page/avoiding-shader-conditionals - branchAvoidanceFunctions: [ - 'float when_gt(float x, float y) {', - ' return max(sign(x - y), 0.0);', - '}', - - 'float when_lt(float x, float y) {', - ' return min( max(1.0 - sign(x - y), 0.0), 1.0 );', - '}', - - 'float when_eq( float x, float y ) {', - ' return 1.0 - abs( sign( x - y ) );', - '}', - - 'float when_ge(float x, float y) {', - ' return 1.0 - when_lt(x, y);', - '}', - - 'float when_le(float x, float y) {', - ' return 1.0 - when_gt(x, y);', - '}', - - // Branch-avoiding logical operators - // (to be used with above comparison fns) - 'float and(float a, float b) {', - ' return a * b;', - '}', - - 'float or(float a, float b) {', - ' return min(a + b, 1.0);', - '}', - ].join( '\n' ), - - - // From: - // - http://stackoverflow.com/a/12553149 - // - https://stackoverflow.com/questions/22895237/hexadecimal-to-rgb-values-in-webgl-shader - unpackColor: [ - 'vec3 unpackColor( in float hex ) {', - ' vec3 c = vec3( 0.0 );', - - ' float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );', - ' float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );', - ' float b = mod( hex, PACKED_COLOR_SIZE );', - - ' c.r = r / PACKED_COLOR_DIVISOR;', - ' c.g = g / PACKED_COLOR_DIVISOR;', - ' c.b = b / PACKED_COLOR_DIVISOR;', - - ' return c;', - '}', - ].join( '\n' ), - - unpackRotationAxis: [ - 'vec3 unpackRotationAxis( in float hex ) {', - ' vec3 c = vec3( 0.0 );', - - ' float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );', - ' float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );', - ' float b = mod( hex, PACKED_COLOR_SIZE );', - - ' c.r = r / PACKED_COLOR_DIVISOR;', - ' c.g = g / PACKED_COLOR_DIVISOR;', - ' c.b = b / PACKED_COLOR_DIVISOR;', - - ' c *= vec3( 2.0 );', - ' c -= vec3( 1.0 );', - - ' return c;', - '}', - ].join( '\n' ), - - floatOverLifetime: [ - 'float getFloatOverLifetime( in float positionInTime, in vec4 attr ) {', - ' highp float value = 0.0;', - ' float deltaAge = positionInTime * float( VALUE_OVER_LIFETIME_LENGTH - 1 );', - ' float fIndex = 0.0;', - ' float shouldApplyValue = 0.0;', - - // This might look a little odd, but it's faster in the testing I've done than using branches. - // Uses basic maths to avoid branching. - // - // Take a look at the branch-avoidance functions defined above, - // and be sure to check out The Orange Duck site where I got this - // from (link above). - - // Fix for static emitters (age is always zero). - ' value += attr[ 0 ] * when_eq( deltaAge, 0.0 );', - '', - ' for( int i = 0; i < VALUE_OVER_LIFETIME_LENGTH - 1; ++i ) {', - ' fIndex = float( i );', - ' shouldApplyValue = and( when_gt( deltaAge, fIndex ), when_le( deltaAge, fIndex + 1.0 ) );', - ' value += shouldApplyValue * mix( attr[ i ], attr[ i + 1 ], deltaAge - fIndex );', - ' }', - '', - ' return value;', - '}', - ].join( '\n' ), - - colorOverLifetime: [ - 'vec3 getColorOverLifetime( in float positionInTime, in vec3 color1, in vec3 color2, in vec3 color3, in vec3 color4 ) {', - ' vec3 value = vec3( 0.0 );', - ' value.x = getFloatOverLifetime( positionInTime, vec4( color1.x, color2.x, color3.x, color4.x ) );', - ' value.y = getFloatOverLifetime( positionInTime, vec4( color1.y, color2.y, color3.y, color4.y ) );', - ' value.z = getFloatOverLifetime( positionInTime, vec4( color1.z, color2.z, color3.z, color4.z ) );', - ' return value;', - '}', - ].join( '\n' ), - - paramFetchingFunctions: [ - 'float getAlive() {', - ' return params.x;', - '}', - - 'float getAge() {', - ' return params.y;', - '}', - - 'float getMaxAge() {', - ' return params.z;', - '}', - - 'float getWiggle() {', - ' return params.w;', - '}', - ].join( '\n' ), - - forceFetchingFunctions: [ - 'vec4 getPosition( in float age ) {', - ' return modelViewMatrix * vec4( position, 1.0 );', - '}', - - 'vec3 getVelocity( in float age ) {', - ' return velocity * age;', - '}', - - 'vec3 getAcceleration( in float age ) {', - ' return acceleration.xyz * age;', - '}', - ].join( '\n' ), - - - rotationFunctions: [ - // Huge thanks to: - // - http://www.neilmendoza.com/glsl-rotation-about-an-arbitrary-axis/ - '#ifdef SHOULD_ROTATE_PARTICLES', - ' mat4 getRotationMatrix( in vec3 axis, in float angle) {', - ' axis = normalize(axis);', - ' float s = sin(angle);', - ' float c = cos(angle);', - ' float oc = 1.0 - c;', - '', - ' return mat4(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 0.0,', - ' oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 0.0,', - ' oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c, 0.0,', - ' 0.0, 0.0, 0.0, 1.0);', - ' }', - '', - ' vec3 getRotation( in vec3 pos, in float positionInTime ) {', - ' if( rotation.y == 0.0 ) {', - ' return pos;', - ' }', - '', - ' vec3 axis = unpackRotationAxis( rotation.x );', - ' vec3 center = rotationCenter;', - ' vec3 translated;', - ' mat4 rotationMatrix;', - - ' float angle = 0.0;', - ' angle += when_eq( rotation.z, 0.0 ) * rotation.y;', - ' angle += when_gt( rotation.z, 0.0 ) * mix( 0.0, rotation.y, positionInTime );', - ' translated = rotationCenter - pos;', - ' rotationMatrix = getRotationMatrix( axis, angle );', - ' return center - vec3( rotationMatrix * vec4( translated, 0.0 ) );', - ' }', - '#endif' - ].join( '\n' ), - - - // Fragment chunks - rotateTexture: [ - ' vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );', - '', - ' #ifdef SHOULD_ROTATE_TEXTURE', - ' float x = gl_PointCoord.x - 0.5;', - ' float y = 1.0 - gl_PointCoord.y - 0.5;', - ' float c = cos( -vAngle );', - ' float s = sin( -vAngle );', - - ' vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );', - ' #endif', - '', - - // Spritesheets overwrite angle calculations. - ' #ifdef SHOULD_CALCULATE_SPRITE', - ' float framesX = vSpriteSheet.x;', - ' float framesY = vSpriteSheet.y;', - ' float columnNorm = vSpriteSheet.z;', - ' float rowNorm = vSpriteSheet.w;', - - ' vUv.x = gl_PointCoord.x * framesX + columnNorm;', - ' vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);', - ' #endif', - - '', - ' vec4 rotatedTexture = texture2D( tex, vUv );', - ].join( '\n' ) -}; - -SPE.shaders = { - vertex: [ - SPE.shaderChunks.defines, - SPE.shaderChunks.uniforms, - SPE.shaderChunks.attributes, - SPE.shaderChunks.varyings, - - THREE.ShaderChunk.common, - THREE.ShaderChunk.logdepthbuf_pars_vertex, - THREE.ShaderChunk.fog_pars_vertex, - - SPE.shaderChunks.branchAvoidanceFunctions, - SPE.shaderChunks.unpackColor, - SPE.shaderChunks.unpackRotationAxis, - SPE.shaderChunks.floatOverLifetime, - SPE.shaderChunks.colorOverLifetime, - SPE.shaderChunks.paramFetchingFunctions, - SPE.shaderChunks.forceFetchingFunctions, - SPE.shaderChunks.rotationFunctions, - - - 'void main() {', - - - // - // Setup... - // - ' highp float age = getAge();', - ' highp float alive = getAlive();', - ' highp float maxAge = getMaxAge();', - ' highp float positionInTime = (age / maxAge);', - ' highp float isAlive = when_gt( alive, 0.0 );', - - ' #ifdef SHOULD_WIGGLE_PARTICLES', - ' float wiggleAmount = positionInTime * getWiggle();', - ' float wiggleSin = isAlive * sin( wiggleAmount );', - ' float wiggleCos = isAlive * cos( wiggleAmount );', - ' #endif', - - // - // Forces - // - - // Get forces & position - ' vec3 vel = getVelocity( age );', - ' vec3 accel = getAcceleration( age );', - ' vec3 force = vec3( 0.0 );', - ' vec3 pos = vec3( position );', - - // Calculate the required drag to apply to the forces. - ' float drag = 1.0 - (positionInTime * 0.5) * acceleration.w;', - - // Integrate forces... - ' force += vel;', - ' force *= drag;', - ' force += accel * age;', - ' pos += force;', - - - // Wiggly wiggly wiggle! - ' #ifdef SHOULD_WIGGLE_PARTICLES', - ' pos.x += wiggleSin;', - ' pos.y += wiggleCos;', - ' pos.z += wiggleSin;', - ' #endif', - - - // Rotate the emitter around it's central point - ' #ifdef SHOULD_ROTATE_PARTICLES', - ' pos = getRotation( pos, positionInTime );', - ' #endif', - - // Convert pos to a world-space value - ' vec4 mvPosition = modelViewMatrix * vec4( pos, 1.0 );', - - // Determine point size. - ' highp float pointSize = getFloatOverLifetime( positionInTime, size ) * isAlive;', - - // Determine perspective - ' #ifdef HAS_PERSPECTIVE', - ' float perspective = scale / length( mvPosition.xyz );', - ' #else', - ' float perspective = 1.0;', - ' #endif', - - // Apply perpective to pointSize value - ' float pointSizePerspective = pointSize * perspective;', - - - // - // Appearance - // - - // Determine color and opacity for this particle - ' #ifdef COLORIZE', - ' vec3 c = isAlive * getColorOverLifetime(', - ' positionInTime,', - ' unpackColor( color.x ),', - ' unpackColor( color.y ),', - ' unpackColor( color.z ),', - ' unpackColor( color.w )', - ' );', - ' #else', - ' vec3 c = vec3(1.0);', - ' #endif', - - ' float o = isAlive * getFloatOverLifetime( positionInTime, opacity );', - - // Assign color to vColor varying. - ' vColor = vec4( c, o );', - - // Determine angle - ' #ifdef SHOULD_ROTATE_TEXTURE', - ' vAngle = isAlive * getFloatOverLifetime( positionInTime, angle );', - ' #endif', - - // If this particle is using a sprite-sheet as a texture, we'll have to figure out - // what frame of the texture the particle is using at it's current position in time. - ' #ifdef SHOULD_CALCULATE_SPRITE', - ' float framesX = textureAnimation.x;', - ' float framesY = textureAnimation.y;', - ' float loopCount = textureAnimation.w;', - ' float totalFrames = textureAnimation.z;', - ' float frameNumber = mod( (positionInTime * loopCount) * totalFrames, totalFrames );', - - ' float column = floor(mod( frameNumber, framesX ));', - ' float row = floor( (frameNumber - column) / framesX );', - - ' float columnNorm = column / framesX;', - ' float rowNorm = row / framesY;', - - ' vSpriteSheet.x = 1.0 / framesX;', - ' vSpriteSheet.y = 1.0 / framesY;', - ' vSpriteSheet.z = columnNorm;', - ' vSpriteSheet.w = rowNorm;', - ' #endif', - - // - // Write values - // - - // Set PointSize according to size at current point in time. - ' gl_PointSize = pointSizePerspective;', - ' gl_Position = projectionMatrix * mvPosition;', - - THREE.ShaderChunk.logdepthbuf_vertex, - THREE.ShaderChunk.fog_vertex, - - '}' - ].join( '\n' ), - - fragment: [ - SPE.shaderChunks.uniforms, - - THREE.ShaderChunk.common, - THREE.ShaderChunk.fog_pars_fragment, - THREE.ShaderChunk.logdepthbuf_pars_fragment, - - SPE.shaderChunks.varyings, - - SPE.shaderChunks.branchAvoidanceFunctions, - - 'void main() {', - ' vec3 outgoingLight = vColor.xyz;', - ' ', - ' #ifdef ALPHATEST', - ' if ( vColor.w < float(ALPHATEST) ) discard;', - ' #endif', - - SPE.shaderChunks.rotateTexture, - - THREE.ShaderChunk.logdepthbuf_fragment, - - ' outgoingLight = vColor.xyz * rotatedTexture.xyz;', - ' gl_FragColor = vec4( outgoingLight.xyz, rotatedTexture.w * vColor.w );', - - THREE.ShaderChunk.fog_fragment, - - '}' - ].join( '\n' ) -}; - - -/** - * A bunch of utility functions used throughout the library. - * @namespace - * @type {Object} - */ -SPE.utils = { - /** - * A map of types used by `SPE.utils.ensureTypedArg` and - * `SPE.utils.ensureArrayTypedArg` to compare types against. - * - * @enum {String} - */ - types: { - /** - * Boolean type. - * @type {String} - */ - BOOLEAN: 'boolean', - - /** - * String type. - * @type {String} - */ - STRING: 'string', - - /** - * Number type. - * @type {String} - */ - NUMBER: 'number', - - /** - * Object type. - * @type {String} - */ - OBJECT: 'object' - }, - - /** - * Given a value, a type, and a default value to fallback to, - * ensure the given argument adheres to the type requesting, - * returning the default value if type check is false. - * - * @param {(boolean|string|number|object)} arg The value to perform a type-check on. - * @param {String} type The type the `arg` argument should adhere to. - * @param {(boolean|string|number|object)} defaultValue A default value to fallback on if the type check fails. - * @return {(boolean|string|number|object)} The given value if type check passes, or the default value if it fails. - */ - ensureTypedArg: function( arg, type, defaultValue ) { - 'use strict'; - - if ( typeof arg === type ) { - return arg; - } - else { - return defaultValue; - } - }, - - /** - * Given an array of values, a type, and a default value, - * ensure the given array's contents ALL adhere to the provided type, - * returning the default value if type check fails. - * - * If the given value to check isn't an Array, delegates to SPE.utils.ensureTypedArg. - * - * @param {Array|boolean|string|number|object} arg The array of values to check type of. - * @param {String} type The type that should be adhered to. - * @param {(boolean|string|number|object)} defaultValue A default fallback value. - * @return {(boolean|string|number|object)} The given value if type check passes, or the default value if it fails. - */ - ensureArrayTypedArg: function( arg, type, defaultValue ) { - 'use strict'; - - // If the argument being checked is an array, loop through - // it and ensure all the values are of the correct type, - // falling back to the defaultValue if any aren't. - if ( Array.isArray( arg ) ) { - for ( var i = arg.length - 1; i >= 0; --i ) { - if ( typeof arg[ i ] !== type ) { - return defaultValue; - } - } - - return arg; - } - - // If the arg isn't an array then just fallback to - // checking the type. - return this.ensureTypedArg( arg, type, defaultValue ); - }, - - /** - * Ensures the given value is an instance of a constructor function. - * - * @param {Object} arg The value to check instance of. - * @param {Function} instance The constructor of the instance to check against. - * @param {Object} defaultValue A default fallback value if instance check fails - * @return {Object} The given value if type check passes, or the default value if it fails. - */ - ensureInstanceOf: function( arg, instance, defaultValue ) { - 'use strict'; - - if ( instance !== undefined && arg instanceof instance ) { - return arg; - } - else { - return defaultValue; - } - }, - - /** - * Given an array of values, ensure the instances of all items in the array - * matches the given instance constructor falling back to a default value if - * the check fails. - * - * If given value isn't an Array, delegates to `SPE.utils.ensureInstanceOf`. - * - * @param {Array|Object} arg The value to perform the instanceof check on. - * @param {Function} instance The constructor of the instance to check against. - * @param {Object} defaultValue A default fallback value if instance check fails - * @return {Object} The given value if type check passes, or the default value if it fails. - */ - ensureArrayInstanceOf: function( arg, instance, defaultValue ) { - 'use strict'; - - // If the argument being checked is an array, loop through - // it and ensure all the values are of the correct type, - // falling back to the defaultValue if any aren't. - if ( Array.isArray( arg ) ) { - for ( var i = arg.length - 1; i >= 0; --i ) { - if ( instance !== undefined && arg[ i ] instanceof instance === false ) { - return defaultValue; - } - } - - return arg; - } - - // If the arg isn't an array then just fallback to - // checking the type. - return this.ensureInstanceOf( arg, instance, defaultValue ); - }, - - /** - * Ensures that any "value-over-lifetime" properties of an emitter are - * of the correct length (as dictated by `SPE.valueOverLifetimeLength`). - * - * Delegates to `SPE.utils.interpolateArray` for array resizing. - * - * If properties aren't arrays, then property values are put into one. - * - * @param {Object} property The property of an SPE.Emitter instance to check compliance of. - * @param {Number} minLength The minimum length of the array to create. - * @param {Number} maxLength The maximum length of the array to create. - */ - ensureValueOverLifetimeCompliance: function( property, minLength, maxLength ) { - 'use strict'; - - minLength = minLength || 3; - maxLength = maxLength || 3; - - // First, ensure both properties are arrays. - if ( Array.isArray( property._value ) === false ) { - property._value = [ property._value ]; - } - - if ( Array.isArray( property._spread ) === false ) { - property._spread = [ property._spread ]; - } - - var valueLength = this.clamp( property._value.length, minLength, maxLength ), - spreadLength = this.clamp( property._spread.length, minLength, maxLength ), - desiredLength = Math.max( valueLength, spreadLength ); - - if ( property._value.length !== desiredLength ) { - property._value = this.interpolateArray( property._value, desiredLength ); - } - - if ( property._spread.length !== desiredLength ) { - property._spread = this.interpolateArray( property._spread, desiredLength ); - } - }, - - /** - * Performs linear interpolation (lerp) on an array. - * - * For example, lerping [1, 10], with a `newLength` of 10 will produce [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. - * - * Delegates to `SPE.utils.lerpTypeAgnostic` to perform the actual - * interpolation. - * - * @param {Array} srcArray The array to lerp. - * @param {Number} newLength The length the array should be interpolated to. - * @return {Array} The interpolated array. - */ - interpolateArray: function( srcArray, newLength ) { - 'use strict'; - - var sourceLength = srcArray.length, - newArray = [ typeof srcArray[ 0 ].clone === 'function' ? srcArray[ 0 ].clone() : srcArray[ 0 ] ], - factor = ( sourceLength - 1 ) / ( newLength - 1 ); - - - for ( var i = 1; i < newLength - 1; ++i ) { - var f = i * factor, - before = Math.floor( f ), - after = Math.ceil( f ), - delta = f - before; - - newArray[ i ] = this.lerpTypeAgnostic( srcArray[ before ], srcArray[ after ], delta ); - } - - newArray.push( - typeof srcArray[ sourceLength - 1 ].clone === 'function' ? - srcArray[ sourceLength - 1 ].clone() : - srcArray[ sourceLength - 1 ] - ); - - return newArray; - }, - - /** - * Clamp a number to between the given min and max values. - * @param {Number} value The number to clamp. - * @param {Number} min The minimum value. - * @param {Number} max The maximum value. - * @return {Number} The clamped number. - */ - clamp: function( value, min, max ) { - 'use strict'; - - return Math.max( min, Math.min( value, max ) ); - }, - - /** - * If the given value is less than the epsilon value, then return - * a randomised epsilon value if specified, or just the epsilon value if not. - * Works for negative numbers as well as positive. - * - * @param {Number} value The value to perform the operation on. - * @param {Boolean} randomise Whether the value should be randomised. - * @return {Number} The result of the operation. - */ - zeroToEpsilon: function( value, randomise ) { - 'use strict'; - - var epsilon = 0.00001, - result = value; - - result = randomise ? Math.random() * epsilon * 10 : epsilon; - - if ( value < 0 && value > -epsilon ) { - result = -result; - } - - // if ( value === 0 ) { - // result = randomise ? Math.random() * epsilon * 10 : epsilon; - // } - // else if ( value > 0 && value < epsilon ) { - // result = randomise ? Math.random() * epsilon * 10 : epsilon; - // } - // else if ( value < 0 && value > -epsilon ) { - // result = -( randomise ? Math.random() * epsilon * 10 : epsilon ); - // } - - return result; - }, - - /** - * Linearly interpolates two values of various types. The given values - * must be of the same type for the interpolation to work. - * @param {(number|Object)} start The start value of the lerp. - * @param {(number|object)} end The end value of the lerp. - * @param {Number} delta The delta posiiton of the lerp operation. Ideally between 0 and 1 (inclusive). - * @return {(number|object|undefined)} The result of the operation. Result will be undefined if - * the start and end arguments aren't a supported type, or - * if their types do not match. - */ - lerpTypeAgnostic: function( start, end, delta ) { - 'use strict'; - - var types = this.types, - out; - - if ( typeof start === types.NUMBER && typeof end === types.NUMBER ) { - return start + ( ( end - start ) * delta ); - } - else if ( start instanceof THREE.Vector2 && end instanceof THREE.Vector2 ) { - out = start.clone(); - out.x = this.lerp( start.x, end.x, delta ); - out.y = this.lerp( start.y, end.y, delta ); - return out; - } - else if ( start instanceof THREE.Vector3 && end instanceof THREE.Vector3 ) { - out = start.clone(); - out.x = this.lerp( start.x, end.x, delta ); - out.y = this.lerp( start.y, end.y, delta ); - out.z = this.lerp( start.z, end.z, delta ); - return out; - } - else if ( start instanceof THREE.Vector4 && end instanceof THREE.Vector4 ) { - out = start.clone(); - out.x = this.lerp( start.x, end.x, delta ); - out.y = this.lerp( start.y, end.y, delta ); - out.z = this.lerp( start.z, end.z, delta ); - out.w = this.lerp( start.w, end.w, delta ); - return out; - } - else if ( start instanceof THREE.Color && end instanceof THREE.Color ) { - out = start.clone(); - out.r = this.lerp( start.r, end.r, delta ); - out.g = this.lerp( start.g, end.g, delta ); - out.b = this.lerp( start.b, end.b, delta ); - return out; - } - else { - console.warn( 'Invalid argument types, or argument types do not match:', start, end ); - } - }, - - /** - * Perform a linear interpolation operation on two numbers. - * @param {Number} start The start value. - * @param {Number} end The end value. - * @param {Number} delta The position to interpolate to. - * @return {Number} The result of the lerp operation. - */ - lerp: function( start, end, delta ) { - 'use strict'; - return start + ( ( end - start ) * delta ); - }, - - /** - * Rounds a number to a nearest multiple. - * - * @param {Number} n The number to round. - * @param {Number} multiple The multiple to round to. - * @return {Number} The result of the round operation. - */ - roundToNearestMultiple: function( n, multiple ) { - 'use strict'; - - var remainder = 0; - - if ( multiple === 0 ) { - return n; - } - - remainder = Math.abs( n ) % multiple; - - if ( remainder === 0 ) { - return n; - } - - if ( n < 0 ) { - return -( Math.abs( n ) - remainder ); - } - - return n + multiple - remainder; - }, - - /** - * Check if all items in an array are equal. Uses strict equality. - * - * @param {Array} array The array of values to check equality of. - * @return {Boolean} Whether the array's values are all equal or not. - */ - arrayValuesAreEqual: function( array ) { - 'use strict'; - - for ( var i = 0; i < array.length - 1; ++i ) { - if ( array[ i ] !== array[ i + 1 ] ) { - return false; - } - } - - return true; - }, - - // colorsAreEqual: function() { - // var colors = Array.prototype.slice.call( arguments ), - // numColors = colors.length; - - // for ( var i = 0, color1, color2; i < numColors - 1; ++i ) { - // color1 = colors[ i ]; - // color2 = colors[ i + 1 ]; - - // if ( - // color1.r !== color2.r || - // color1.g !== color2.g || - // color1.b !== color2.b - // ) { - // return false - // } - // } - - // return true; - // }, - - - /** - * Given a start value and a spread value, create and return a random - * number. - * @param {Number} base The start value. - * @param {Number} spread The size of the random variance to apply. - * @return {Number} A randomised number. - */ - randomFloat: function( base, spread ) { - 'use strict'; - return base + spread * ( Math.random() - 0.5 ); - }, - - - - /** - * Given an SPE.ShaderAttribute instance, and various other settings, - * assign values to the attribute's array in a `vec3` format. - * - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Object} base THREE.Vector3 instance describing the start value. - * @param {Object} spread THREE.Vector3 instance describing the random variance to apply to the start value. - * @param {Object} spreadClamp THREE.Vector3 instance describing the multiples to clamp the randomness to. - */ - randomVector3: function( attribute, index, base, spread, spreadClamp ) { - 'use strict'; - - var x = base.x + ( Math.random() * spread.x - ( spread.x * 0.5 ) ), - y = base.y + ( Math.random() * spread.y - ( spread.y * 0.5 ) ), - z = base.z + ( Math.random() * spread.z - ( spread.z * 0.5 ) ); - - // var x = this.randomFloat( base.x, spread.x ), - // y = this.randomFloat( base.y, spread.y ), - // z = this.randomFloat( base.z, spread.z ); - - if ( spreadClamp ) { - x = -spreadClamp.x * 0.5 + this.roundToNearestMultiple( x, spreadClamp.x ); - y = -spreadClamp.y * 0.5 + this.roundToNearestMultiple( y, spreadClamp.y ); - z = -spreadClamp.z * 0.5 + this.roundToNearestMultiple( z, spreadClamp.z ); - } - - attribute.typedArray.setVec3Components( index, x, y, z ); - }, - - /** - * Given an SPE.Shader attribute instance, and various other settings, - * assign Color values to the attribute. - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Object} base THREE.Color instance describing the start color. - * @param {Object} spread THREE.Vector3 instance describing the random variance to apply to the start color. - */ - randomColor: function( attribute, index, base, spread ) { - 'use strict'; - - var r = base.r + ( Math.random() * spread.x ), - g = base.g + ( Math.random() * spread.y ), - b = base.b + ( Math.random() * spread.z ); - - r = this.clamp( r, 0, 1 ); - g = this.clamp( g, 0, 1 ); - b = this.clamp( b, 0, 1 ); - - - attribute.typedArray.setVec3Components( index, r, g, b ); - }, - - - randomColorAsHex: ( function() { - 'use strict'; - - var workingColor = new THREE.Color(); - - /** - * Assigns a random color value, encoded as a hex value in decimal - * format, to a SPE.ShaderAttribute instance. - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Object} base THREE.Color instance describing the start color. - * @param {Object} spread THREE.Vector3 instance describing the random variance to apply to the start color. - */ - return function( attribute, index, base, spread ) { - var numItems = base.length, - colors = []; - - for ( var i = 0; i < numItems; ++i ) { - var spreadVector = spread[ i ]; - - workingColor.copy( base[ i ] ); - - workingColor.r += ( Math.random() * spreadVector.x ) - ( spreadVector.x * 0.5 ); - workingColor.g += ( Math.random() * spreadVector.y ) - ( spreadVector.y * 0.5 ); - workingColor.b += ( Math.random() * spreadVector.z ) - ( spreadVector.z * 0.5 ); - - workingColor.r = this.clamp( workingColor.r, 0, 1 ); - workingColor.g = this.clamp( workingColor.g, 0, 1 ); - workingColor.b = this.clamp( workingColor.b, 0, 1 ); - - colors.push( workingColor.getHex() ); - } - - attribute.typedArray.setVec4Components( index, colors[ 0 ], colors[ 1 ], colors[ 2 ], colors[ 3 ] ); - }; - }() ), - - /** - * Given an SPE.ShaderAttribute instance, and various other settings, - * assign values to the attribute's array in a `vec3` format. - * - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Object} start THREE.Vector3 instance describing the start line position. - * @param {Object} end THREE.Vector3 instance describing the end line position. - */ - randomVector3OnLine: function( attribute, index, start, end ) { - 'use strict'; - var pos = start.clone(); - - pos.lerp( end, Math.random() ); - - attribute.typedArray.setVec3Components( index, pos.x, pos.y, pos.z ); - }, - - /** - * Given an SPE.Shader attribute instance, and various other settings, - * assign Color values to the attribute. - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Object} base THREE.Color instance describing the start color. - * @param {Object} spread THREE.Vector3 instance describing the random variance to apply to the start color. - */ - - /** - * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the - * given values onto a sphere. - * - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Object} base THREE.Vector3 instance describing the origin of the transform. - * @param {Number} radius The radius of the sphere to project onto. - * @param {Number} radiusSpread The amount of randomness to apply to the projection result - * @param {Object} radiusScale THREE.Vector3 instance describing the scale of each axis of the sphere. - * @param {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to. - */ - randomVector3OnSphere: function( - attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp, distributionClamp - ) { - 'use strict'; - - var depth = 2 * Math.random() - 1, - t = 6.2832 * Math.random(), - r = Math.sqrt( 1 - depth * depth ), - rand = this.randomFloat( radius, radiusSpread ), - x = 0, - y = 0, - z = 0; - - - if ( radiusSpreadClamp ) { - rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp; - } - - - - // Set position on sphere - x = r * Math.cos( t ) * rand; - y = r * Math.sin( t ) * rand; - z = depth * rand; - - // Apply radius scale to this position - x *= radiusScale.x; - y *= radiusScale.y; - z *= radiusScale.z; - - // Translate to the base position. - x += base.x; - y += base.y; - z += base.z; - - // Set the values in the typed array. - attribute.typedArray.setVec3Components( index, x, y, z ); - }, - - seededRandom: function( seed ) { - var x = Math.sin( seed ) * 10000; - return x - ( x | 0 ); - }, - - - - /** - * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the - * given values onto a 2d-disc. - * - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Object} base THREE.Vector3 instance describing the origin of the transform. - * @param {Number} radius The radius of the sphere to project onto. - * @param {Number} radiusSpread The amount of randomness to apply to the projection result - * @param {Object} radiusScale THREE.Vector3 instance describing the scale of each axis of the disc. The z-component is ignored. - * @param {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to. - */ - randomVector3OnDisc: function( attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp ) { - 'use strict'; - - var t = 6.2832 * Math.random(), - rand = Math.abs( this.randomFloat( radius, radiusSpread ) ), - x = 0, - y = 0, - z = 0; - - if ( radiusSpreadClamp ) { - rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp; - } - - // Set position on sphere - x = Math.cos( t ) * rand; - y = Math.sin( t ) * rand; - - // Apply radius scale to this position - x *= radiusScale.x; - y *= radiusScale.y; - - // Translate to the base position. - x += base.x; - y += base.y; - z += base.z; - - // Set the values in the typed array. - attribute.typedArray.setVec3Components( index, x, y, z ); - }, - - randomDirectionVector3OnSphere: ( function() { - 'use strict'; - - var v = new THREE.Vector3(); - - /** - * Given an SPE.ShaderAttribute instance, create a direction vector from the given - * position, using `speed` as the magnitude. Values are saved to the attribute. - * - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Number} posX The particle's x coordinate. - * @param {Number} posY The particle's y coordinate. - * @param {Number} posZ The particle's z coordinate. - * @param {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position. - * @param {Number} speed The magnitude to apply to the vector. - * @param {Number} speedSpread The amount of randomness to apply to the magnitude. - */ - return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) { - v.copy( emitterPosition ); - - v.x -= posX; - v.y -= posY; - v.z -= posZ; - - v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) ); - - attribute.typedArray.setVec3Components( index, v.x, v.y, v.z ); - }; - }() ), - - - randomDirectionVector3OnDisc: ( function() { - 'use strict'; - - var v = new THREE.Vector3(); - - /** - * Given an SPE.ShaderAttribute instance, create a direction vector from the given - * position, using `speed` as the magnitude. Values are saved to the attribute. - * - * @param {Object} attribute The instance of SPE.ShaderAttribute to save the result to. - * @param {Number} index The offset in the attribute's TypedArray to save the result from. - * @param {Number} posX The particle's x coordinate. - * @param {Number} posY The particle's y coordinate. - * @param {Number} posZ The particle's z coordinate. - * @param {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position. - * @param {Number} speed The magnitude to apply to the vector. - * @param {Number} speedSpread The amount of randomness to apply to the magnitude. - */ - return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) { - v.copy( emitterPosition ); - - v.x -= posX; - v.y -= posY; - v.z -= posZ; - - v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) ); - - attribute.typedArray.setVec3Components( index, v.x, v.y, 0 ); - }; - }() ), - - getPackedRotationAxis: ( function() { - 'use strict'; - - var v = new THREE.Vector3(), - vSpread = new THREE.Vector3(), - c = new THREE.Color(), - addOne = new THREE.Vector3( 1, 1, 1 ); - - /** - * Given a rotation axis, and a rotation axis spread vector, - * calculate a randomised rotation axis, and pack it into - * a hexadecimal value represented in decimal form. - * @param {Object} axis THREE.Vector3 instance describing the rotation axis. - * @param {Object} axisSpread THREE.Vector3 instance describing the amount of randomness to apply to the rotation axis. - * @return {Number} The packed rotation axis, with randomness. - */ - return function( axis, axisSpread ) { - v.copy( axis ).normalize(); - vSpread.copy( axisSpread ).normalize(); - - v.x += ( -axisSpread.x * 0.5 ) + ( Math.random() * axisSpread.x ); - v.y += ( -axisSpread.y * 0.5 ) + ( Math.random() * axisSpread.y ); - v.z += ( -axisSpread.z * 0.5 ) + ( Math.random() * axisSpread.z ); - - // v.x = Math.abs( v.x ); - // v.y = Math.abs( v.y ); - // v.z = Math.abs( v.z ); - - v.normalize().add( addOne ).multiplyScalar( 0.5 ); - - c.setRGB( v.x, v.y, v.z ); - - return c.getHex(); - }; - }() ) -}; - - -/** - * An SPE.Group instance. - * @typedef {Object} Group - * @see SPE.Group - */ - -/** - * A map of options to configure an SPE.Group instance. - * @typedef {Object} GroupOptions - * - * @property {Object} texture An object describing the texture used by the group. - * - * @property {Object} texture.value An instance of THREE.Texture. - * - * @property {Object=} texture.frames A THREE.Vector2 instance describing the number - * of frames on the x- and y-axis of the given texture. - * If not provided, the texture will NOT be treated as - * a sprite-sheet and as such will NOT be animated. - * - * @property {Number} [texture.frameCount=texture.frames.x * texture.frames.y] The total number of frames in the sprite-sheet. - * Allows for sprite-sheets that don't fill the entire - * texture. - * - * @property {Number} texture.loop The number of loops through the sprite-sheet that should - * be performed over the course of a single particle's lifetime. - * - * @property {Number} fixedTimeStep If no `dt` (or `deltaTime`) value is passed to this group's - * `tick()` function, this number will be used to move the particle - * simulation forward. Value in SECONDS. - * - * @property {Boolean} hasPerspective Whether the distance a particle is from the camera should affect - * the particle's size. - * - * @property {Boolean} colorize Whether the particles in this group should be rendered with color, or - * whether the only color of particles will come from the provided texture. - * - * @property {Number} blending One of Three.js's blending modes to apply to this group's `ShaderMaterial`. - * - * @property {Boolean} transparent Whether these particle's should be rendered with transparency. - * - * @property {Number} alphaTest Sets the alpha value to be used when running an alpha test on the `texture.value` property. Value between 0 and 1. - * - * @property {Boolean} depthWrite Whether rendering the group has any effect on the depth buffer. - * - * @property {Boolean} depthTest Whether to have depth test enabled when rendering this group. - * - * @property {Boolean} fog Whether this group's particles should be affected by their scene's fog. - * - * @property {Number} scale The scale factor to apply to this group's particle sizes. Useful for - * setting particle sizes to be relative to renderer size. - */ - - -/** - * The SPE.Group class. Creates a new group, containing a material, geometry, and mesh. - * - * @constructor - * @param {GroupOptions} options A map of options to configure the group instance. - */ -SPE.Group = function( options ) { - 'use strict'; - - var utils = SPE.utils, - types = utils.types; - - // Ensure we have a map of options to play with - options = utils.ensureTypedArg( options, types.OBJECT, {} ); - options.texture = utils.ensureTypedArg( options.texture, types.OBJECT, {} ); - - // Assign a UUID to this instance - this.uuid = THREE.Math.generateUUID(); - - // If no `deltaTime` value is passed to the `SPE.Group.tick` function, - // the value of this property will be used to advance the simulation. - this.fixedTimeStep = utils.ensureTypedArg( options.fixedTimeStep, types.NUMBER, 0.016 ); - - // Set properties used in the uniforms map, starting with the - // texture stuff. - this.texture = utils.ensureInstanceOf( options.texture.value, THREE.Texture, null ); - this.textureFrames = utils.ensureInstanceOf( options.texture.frames, THREE.Vector2, new THREE.Vector2( 1, 1 ) ); - this.textureFrameCount = utils.ensureTypedArg( options.texture.frameCount, types.NUMBER, this.textureFrames.x * this.textureFrames.y ); - this.textureLoop = utils.ensureTypedArg( options.texture.loop, types.NUMBER, 1 ); - this.textureFrames.max( new THREE.Vector2( 1, 1 ) ); - - this.hasPerspective = utils.ensureTypedArg( options.hasPerspective, types.BOOLEAN, true ); - this.colorize = utils.ensureTypedArg( options.colorize, types.BOOLEAN, true ); - - this.maxParticleCount = utils.ensureTypedArg( options.maxParticleCount, types.NUMBER, null ); - - - // Set properties used to define the ShaderMaterial's appearance. - this.blending = utils.ensureTypedArg( options.blending, types.NUMBER, THREE.AdditiveBlending ); - this.transparent = utils.ensureTypedArg( options.transparent, types.BOOLEAN, true ); - this.alphaTest = parseFloat( utils.ensureTypedArg( options.alphaTest, types.NUMBER, 0.0 ) ); - this.depthWrite = utils.ensureTypedArg( options.depthWrite, types.BOOLEAN, false ); - this.depthTest = utils.ensureTypedArg( options.depthTest, types.BOOLEAN, true ); - this.fog = utils.ensureTypedArg( options.fog, types.BOOLEAN, true ); - this.scale = utils.ensureTypedArg( options.scale, types.NUMBER, 300 ); - - // Where emitter's go to curl up in a warm blanket and live - // out their days. - this.emitters = []; - this.emitterIDs = []; - - // Create properties for use by the emitter pooling functions. - this._pool = []; - this._poolCreationSettings = null; - this._createNewWhenPoolEmpty = 0; - - // Whether all attributes should be forced to updated - // their entire buffer contents on the next tick. - // - // Used when an emitter is removed. - this._attributesNeedRefresh = false; - this._attributesNeedDynamicReset = false; - - this.particleCount = 0; - - - // Map of uniforms to be applied to the ShaderMaterial instance. - this.uniforms = { - tex: { - type: 't', - value: this.texture - }, - textureAnimation: { - type: 'v4', - value: new THREE.Vector4( - this.textureFrames.x, - this.textureFrames.y, - this.textureFrameCount, - Math.max( Math.abs( this.textureLoop ), 1.0 ) - ) - }, - fogColor: { - type: 'c', - value: this.fog ? new THREE.Color() : null - }, - fogNear: { - type: 'f', - value: 10 - }, - fogFar: { - type: 'f', - value: 200 - }, - fogDensity: { - type: 'f', - value: 0.5 - }, - deltaTime: { - type: 'f', - value: 0 - }, - runTime: { - type: 'f', - value: 0 - }, - scale: { - type: 'f', - value: this.scale - } - }; - - // Add some defines into the mix... - this.defines = { - HAS_PERSPECTIVE: this.hasPerspective, - COLORIZE: this.colorize, - VALUE_OVER_LIFETIME_LENGTH: SPE.valueOverLifetimeLength, - - SHOULD_ROTATE_TEXTURE: false, - SHOULD_ROTATE_PARTICLES: false, - SHOULD_WIGGLE_PARTICLES: false, - - SHOULD_CALCULATE_SPRITE: this.textureFrames.x > 1 || this.textureFrames.y > 1 - }; - - // Map of all attributes to be applied to the particles. - // - // See SPE.ShaderAttribute for a bit more info on this bit. - this.attributes = { - position: new SPE.ShaderAttribute( 'v3', true ), - acceleration: new SPE.ShaderAttribute( 'v4', true ), // w component is drag - velocity: new SPE.ShaderAttribute( 'v3', true ), - rotation: new SPE.ShaderAttribute( 'v4', true ), - rotationCenter: new SPE.ShaderAttribute( 'v3', true ), - params: new SPE.ShaderAttribute( 'v4', true ), // Holds (alive, age, delay, wiggle) - size: new SPE.ShaderAttribute( 'v4', true ), - angle: new SPE.ShaderAttribute( 'v4', true ), - color: new SPE.ShaderAttribute( 'v4', true ), - opacity: new SPE.ShaderAttribute( 'v4', true ) - }; - - this.attributeKeys = Object.keys( this.attributes ); - this.attributeCount = this.attributeKeys.length; - - // Create the ShaderMaterial instance that'll help render the - // particles. - this.material = new THREE.ShaderMaterial( { - uniforms: this.uniforms, - vertexShader: SPE.shaders.vertex, - fragmentShader: SPE.shaders.fragment, - blending: this.blending, - transparent: this.transparent, - alphaTest: this.alphaTest, - depthWrite: this.depthWrite, - depthTest: this.depthTest, - defines: this.defines, - fog: this.fog - } ); - - // Create the BufferGeometry and Points instances, ensuring - // the geometry and material are given to the latter. - this.geometry = new THREE.BufferGeometry(); - this.mesh = new THREE.Points( this.geometry, this.material ); - - if ( this.maxParticleCount === null ) { - console.warn( 'SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.' ); - } -}; - -SPE.Group.constructor = SPE.Group; - - -SPE.Group.prototype._updateDefines = function() { - 'use strict'; - - var emitters = this.emitters, - i = emitters.length - 1, - emitter, - defines = this.defines; - - for ( i; i >= 0; --i ) { - emitter = emitters[ i ]; - - // Only do angle calculation if there's no spritesheet defined. - // - // Saves calculations being done and then overwritten in the shaders. - if ( !defines.SHOULD_CALCULATE_SPRITE ) { - defines.SHOULD_ROTATE_TEXTURE = defines.SHOULD_ROTATE_TEXTURE || !!Math.max( - Math.max.apply( null, emitter.angle.value ), - Math.max.apply( null, emitter.angle.spread ) - ); - } - - defines.SHOULD_ROTATE_PARTICLES = defines.SHOULD_ROTATE_PARTICLES || !!Math.max( - emitter.rotation.angle, - emitter.rotation.angleSpread - ); - - defines.SHOULD_WIGGLE_PARTICLES = defines.SHOULD_WIGGLE_PARTICLES || !!Math.max( - emitter.wiggle.value, - emitter.wiggle.spread - ); - } - - this.material.needsUpdate = true; -}; - -SPE.Group.prototype._applyAttributesToGeometry = function() { - 'use strict'; - - var attributes = this.attributes, - geometry = this.geometry, - geometryAttributes = geometry.attributes, - attribute, - geometryAttribute; - - // Loop through all the shader attributes and assign (or re-assign) - // typed array buffers to each one. - for ( var attr in attributes ) { - if ( attributes.hasOwnProperty( attr ) ) { - attribute = attributes[ attr ]; - geometryAttribute = geometryAttributes[ attr ]; - - // Update the array if this attribute exists on the geometry. - // - // This needs to be done because the attribute's typed array might have - // been resized and reinstantiated, and might now be looking at a - // different ArrayBuffer, so reference needs updating. - if ( geometryAttribute ) { - geometryAttribute.array = attribute.typedArray.array; - } - - // // Add the attribute to the geometry if it doesn't already exist. - else { - geometry.addAttribute( attr, attribute.bufferAttribute ); - } - - // Mark the attribute as needing an update the next time a frame is rendered. - attribute.bufferAttribute.needsUpdate = true; - } - } - - // Mark the draw range on the geometry. This will ensure - // only the values in the attribute buffers that are - // associated with a particle will be used in THREE's - // render cycle. - this.geometry.setDrawRange( 0, this.particleCount ); -}; - -/** - * Adds an SPE.Emitter instance to this group, creating particle values and - * assigning them to this group's shader attributes. - * - * @param {Emitter} emitter The emitter to add to this group. - */ -SPE.Group.prototype.addEmitter = function( emitter ) { - 'use strict'; - - // Ensure an actual emitter instance is passed here. - // - // Decided not to throw here, just in case a scene's - // rendering would be paused. Logging an error instead - // of stopping execution if exceptions aren't caught. - if ( emitter instanceof SPE.Emitter === false ) { - console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter ); - return; - } - - // If the emitter already exists as a member of this group, then - // stop here, we don't want to add it again. - else if ( this.emitterIDs.indexOf( emitter.uuid ) > -1 ) { - console.error( 'Emitter already exists in this group. Will not add again.' ); - return; - } - - // And finally, if the emitter is a member of another group, - // don't add it to this group. - else if ( emitter.group !== null ) { - console.error( 'Emitter already belongs to another group. Will not add to requested group.' ); - return; - } - - var attributes = this.attributes, - start = this.particleCount, - end = start + emitter.particleCount; - - // Update this group's particle count. - this.particleCount = end; - - // Emit a warning if the emitter being added will exceed the buffer sizes specified. - if ( this.maxParticleCount !== null && this.particleCount > this.maxParticleCount ) { - console.warn( 'SPE.Group: maxParticleCount exceeded. Requesting', this.particleCount, 'particles, can support only', this.maxParticleCount ); - } - - - // Set the `particlesPerSecond` value (PPS) on the emitter. - // It's used to determine how many particles to release - // on a per-frame basis. - emitter._calculatePPSValue( emitter.maxAge._value + emitter.maxAge._spread ); - emitter._setBufferUpdateRanges( this.attributeKeys ); - - // Store the offset value in the TypedArray attributes for this emitter. - emitter._setAttributeOffset( start ); - - // Save a reference to this group on the emitter so it knows - // where it belongs. - emitter.group = this; - - // Store reference to the attributes on the emitter for - // easier access during the emitter's tick function. - emitter.attributes = this.attributes; - - - - // Ensure the attributes and their BufferAttributes exist, and their - // TypedArrays are of the correct size. - for ( var attr in attributes ) { - if ( attributes.hasOwnProperty( attr ) ) { - // When creating a buffer, pass through the maxParticle count - // if one is specified. - attributes[ attr ]._createBufferAttribute( - this.maxParticleCount !== null ? - this.maxParticleCount : - this.particleCount - ); - } - } - - // Loop through each particle this emitter wants to have, and create the attributes values, - // storing them in the TypedArrays that each attribute holds. - for ( var i = start; i < end; ++i ) { - emitter._assignPositionValue( i ); - emitter._assignForceValue( i, 'velocity' ); - emitter._assignForceValue( i, 'acceleration' ); - emitter._assignAbsLifetimeValue( i, 'opacity' ); - emitter._assignAbsLifetimeValue( i, 'size' ); - emitter._assignAngleValue( i ); - emitter._assignRotationValue( i ); - emitter._assignParamsValue( i ); - emitter._assignColorValue( i ); - } - - // Update the geometry and make sure the attributes are referencing - // the typed arrays properly. - this._applyAttributesToGeometry(); - - // Store this emitter in this group's emitter's store. - this.emitters.push( emitter ); - this.emitterIDs.push( emitter.uuid ); - - // Update certain flags to enable shader calculations only if they're necessary. - this._updateDefines( emitter ); - - // Update the material since defines might have changed - this.material.needsUpdate = true; - this.geometry.needsUpdate = true; - this._attributesNeedRefresh = true; - - // Return the group to enable chaining. - return this; -}; - -/** - * Removes an SPE.Emitter instance from this group. When called, - * all particle's belonging to the given emitter will be instantly - * removed from the scene. - * - * @param {Emitter} emitter The emitter to add to this group. - */ -SPE.Group.prototype.removeEmitter = function( emitter ) { - 'use strict'; - - var emitterIndex = this.emitterIDs.indexOf( emitter.uuid ); - - // Ensure an actual emitter instance is passed here. - // - // Decided not to throw here, just in case a scene's - // rendering would be paused. Logging an error instead - // of stopping execution if exceptions aren't caught. - if ( emitter instanceof SPE.Emitter === false ) { - console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter ); - return; - } - - // Issue an error if the emitter isn't a member of this group. - else if ( emitterIndex === -1 ) { - console.error( 'Emitter does not exist in this group. Will not remove.' ); - return; - } - - // Kill all particles by marking them as dead - // and their age as 0. - var start = emitter.attributeOffset, - end = start + emitter.particleCount, - params = this.attributes.params.typedArray; - - // Set alive and age to zero. - for ( var i = start; i < end; ++i ) { - params.array[ i * 4 ] = 0.0; - params.array[ i * 4 + 1 ] = 0.0; - } - - // Remove the emitter from this group's "store". - this.emitters.splice( emitterIndex, 1 ); - this.emitterIDs.splice( emitterIndex, 1 ); - - // Remove this emitter's attribute values from all shader attributes. - // The `.splice()` call here also marks each attribute's buffer - // as needing to update it's entire contents. - for ( var attr in this.attributes ) { - if ( this.attributes.hasOwnProperty( attr ) ) { - this.attributes[ attr ].splice( start, end ); - } - } - - // Ensure this group's particle count is correct. - this.particleCount -= emitter.particleCount; - - // Call the emitter's remove method. - emitter._onRemove(); - - // Set a flag to indicate that the attribute buffers should - // be updated in their entirety on the next frame. - this._attributesNeedRefresh = true; -}; - - -/** - * Fetch a single emitter instance from the pool. - * If there are no objects in the pool, a new emitter will be - * created if specified. - * - * @return {Emitter|null} - */ -SPE.Group.prototype.getFromPool = function() { - 'use strict'; - - var pool = this._pool, - createNew = this._createNewWhenPoolEmpty; - - if ( pool.length ) { - return pool.pop(); - } - else if ( createNew ) { - var emitter = new SPE.Emitter( this._poolCreationSettings ); - - this.addEmitter( emitter ); - - return emitter; - } - - return null; -}; - - -/** - * Release an emitter into the pool. - * - * @param {ShaderParticleEmitter} emitter - * @return {Group} This group instance. - */ -SPE.Group.prototype.releaseIntoPool = function( emitter ) { - 'use strict'; - - if ( emitter instanceof SPE.Emitter === false ) { - console.error( 'Argument is not instanceof SPE.Emitter:', emitter ); - return; - } - - emitter.reset(); - this._pool.unshift( emitter ); - - return this; -}; - - -/** - * Get the pool array - * - * @return {Array} - */ -SPE.Group.prototype.getPool = function() { - 'use strict'; - return this._pool; -}; - - -/** - * Add a pool of emitters to this particle group - * - * @param {Number} numEmitters The number of emitters to add to the pool. - * @param {EmitterOptions|Array} emitterOptions An object, or array of objects, describing the options to pass to each emitter. - * @param {Boolean} createNew Should a new emitter be created if the pool runs out? - * @return {Group} This group instance. - */ -SPE.Group.prototype.addPool = function( numEmitters, emitterOptions, createNew ) { - 'use strict'; - - var emitter; - - // Save relevant settings and flags. - this._poolCreationSettings = emitterOptions; - this._createNewWhenPoolEmpty = !!createNew; - - // Create the emitters, add them to this group and the pool. - for ( var i = 0; i < numEmitters; ++i ) { - if ( Array.isArray( emitterOptions ) ) { - emitter = new SPE.Emitter( emitterOptions[ i ] ); - } - else { - emitter = new SPE.Emitter( emitterOptions ); - } - this.addEmitter( emitter ); - this.releaseIntoPool( emitter ); - } - - return this; -}; - - - -SPE.Group.prototype._triggerSingleEmitter = function( pos ) { - 'use strict'; - - var emitter = this.getFromPool(), - self = this; - - if ( emitter === null ) { - console.log( 'SPE.Group pool ran out.' ); - return; - } - - // TODO: - // - Make sure buffers are update with thus new position. - if ( pos instanceof THREE.Vector3 ) { - emitter.position.value.copy( pos ); - - // Trigger the setter for this property to force an - // update to the emitter's position attribute. - emitter.position.value = emitter.position.value; - } - - emitter.enable(); - - setTimeout( function() { - emitter.disable(); - self.releaseIntoPool( emitter ); - }, ( Math.max( emitter.duration, ( emitter.maxAge.value + emitter.maxAge.spread ) ) ) * 1000 ); - - return this; -}; - - -/** - * Set a given number of emitters as alive, with an optional position - * vector3 to move them to. - * - * @param {Number} numEmitters The number of emitters to activate - * @param {Object} [position=undefined] A THREE.Vector3 instance describing the position to activate the emitter(s) at. - * @return {Group} This group instance. - */ -SPE.Group.prototype.triggerPoolEmitter = function( numEmitters, position ) { - 'use strict'; - - if ( typeof numEmitters === 'number' && numEmitters > 1 ) { - for ( var i = 0; i < numEmitters; ++i ) { - this._triggerSingleEmitter( position ); - } - } - else { - this._triggerSingleEmitter( position ); - } - - return this; -}; - - - -SPE.Group.prototype._updateUniforms = function( dt ) { - 'use strict'; - - this.uniforms.runTime.value += dt; - this.uniforms.deltaTime.value = dt; -}; - -SPE.Group.prototype._resetBufferRanges = function() { - 'use strict'; - - var keys = this.attributeKeys, - i = this.attributeCount - 1, - attrs = this.attributes; - - for ( i; i >= 0; --i ) { - attrs[ keys[ i ] ].resetUpdateRange(); - } -}; - - -SPE.Group.prototype._updateBuffers = function( emitter ) { - 'use strict'; - - var keys = this.attributeKeys, - i = this.attributeCount - 1, - attrs = this.attributes, - emitterRanges = emitter.bufferUpdateRanges, - key, - emitterAttr, - attr; - - for ( i; i >= 0; --i ) { - key = keys[ i ]; - emitterAttr = emitterRanges[ key ]; - attr = attrs[ key ]; - attr.setUpdateRange( emitterAttr.min, emitterAttr.max ); - attr.flagUpdate(); - } -}; - - -/** - * Simulate all the emitter's belonging to this group, updating - * attribute values along the way. - * @param {Number} [dt=Group's `fixedTimeStep` value] The number of seconds to simulate the group's emitters for (deltaTime) - */ -SPE.Group.prototype.tick = function( dt ) { - 'use strict'; - - var emitters = this.emitters, - numEmitters = emitters.length, - deltaTime = dt || this.fixedTimeStep, - keys = this.attributeKeys, - i, - attrs = this.attributes; - - // Update uniform values. - this._updateUniforms( deltaTime ); - - // Reset buffer update ranges on the shader attributes. - this._resetBufferRanges(); - - - // If nothing needs updating, then stop here. - if ( - numEmitters === 0 && - this._attributesNeedRefresh === false && - this._attributesNeedDynamicReset === false - ) { - return; - } - - // Loop through each emitter in this group and - // simulate it, then update the shader attribute - // buffers. - for ( var i = 0, emitter; i < numEmitters; ++i ) { - emitter = emitters[ i ]; - emitter.tick( deltaTime ); - this._updateBuffers( emitter ); - } - - // If the shader attributes have been refreshed, - // then the dynamic properties of each buffer - // attribute will need to be reset back to - // what they should be. - if ( this._attributesNeedDynamicReset === true ) { - i = this.attributeCount - 1; - - for ( i; i >= 0; --i ) { - attrs[ keys[ i ] ].resetDynamic(); - } - - this._attributesNeedDynamicReset = false; - } - - // If this group's shader attributes need a full refresh - // then mark each attribute's buffer attribute as - // needing so. - if ( this._attributesNeedRefresh === true ) { - i = this.attributeCount - 1; - - for ( i; i >= 0; --i ) { - attrs[ keys[ i ] ].forceUpdateAll(); - } - - this._attributesNeedRefresh = false; - this._attributesNeedDynamicReset = true; - } -}; - - -/** - * Dipose the geometry and material for the group. - * - * @return {Group} Group instance. - */ -SPE.Group.prototype.dispose = function() { - 'use strict'; - this.geometry.dispose(); - this.material.dispose(); - return this; -}; - - -/** - * An SPE.Emitter instance. - * @typedef {Object} Emitter - * @see SPE.Emitter - */ - -/** - * A map of options to configure an SPE.Emitter instance. - * - * @typedef {Object} EmitterOptions - * - * @property {distribution} [type=BOX] The default distribution this emitter should use to control - * its particle's spawn position and force behaviour. - * Must be an SPE.distributions.* value. - * - * - * @property {Number} [particleCount=100] The total number of particles this emitter will hold. NOTE: this is not the number - * of particles emitted in a second, or anything like that. The number of particles - * emitted per-second is calculated by particleCount / maxAge (approximately!) - * - * @property {Number|null} [duration=null] The duration in seconds that this emitter should live for. If not specified, the emitter - * will emit particles indefinitely. - * NOTE: When an emitter is older than a specified duration, the emitter is NOT removed from - * it's group, but rather is just marked as dead, allowing it to be reanimated at a later time - * using `SPE.Emitter.prototype.enable()`. - * - * @property {Boolean} [isStatic=false] Whether this emitter should be not be simulated (true). - * @property {Boolean} [activeMultiplier=1] A value between 0 and 1 describing what percentage of this emitter's particlesPerSecond should be - * emitted, where 0 is 0%, and 1 is 100%. - * For example, having an emitter with 100 particles, a maxAge of 2, yields a particlesPerSecond - * value of 50. Setting `activeMultiplier` to 0.5, then, will only emit 25 particles per second (0.5 = 50%). - * Values greater than 1 will emulate a burst of particles, causing the emitter to run out of particles - * before it's next activation cycle. - * - * @property {Boolean} [direction=1] The direction of the emitter. If value is `1`, emitter will start at beginning of particle's lifecycle. - * If value is `-1`, emitter will start at end of particle's lifecycle and work it's way backwards. - * - * @property {Object} [maxAge={}] An object describing the particle's maximum age in seconds. - * @property {Number} [maxAge.value=2] A number between 0 and 1 describing the amount of maxAge to apply to all particles. - * @property {Number} [maxAge.spread=0] A number describing the maxAge variance on a per-particle basis. - * - * - * @property {Object} [position={}] An object describing this emitter's position. - * @property {Object} [position.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base position. - * @property {Object} [position.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis. - * Note that when using a SPHERE or DISC distribution, only the x-component - * of this vector is used. - * When using a LINE distribution, this value is the endpoint of the LINE. - * @property {Object} [position.spreadClamp=new THREE.Vector3()] A THREE.Vector3 instance describing the numeric multiples the particle's should - * be spread out over. - * Note that when using a SPHERE or DISC distribution, only the x-component - * of this vector is used. - * When using a LINE distribution, this property is ignored. - * @property {Number} [position.radius=10] This emitter's base radius. - * @property {Object} [position.radiusScale=new THREE.Vector3()] A THREE.Vector3 instance describing the radius's scale in all three axes. Allows a SPHERE or DISC to be squashed or stretched. - * @property {distribution} [position.distribution=value of the `type` option.] A specific distribution to use when radiusing particles. Overrides the `type` option. - * @property {Boolean} [position.randomise=false] When a particle is re-spawned, whether it's position should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [velocity={}] An object describing this particle velocity. - * @property {Object} [velocity.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base velocity. - * @property {Object} [velocity.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's velocity variance on a per-particle basis. - * Note that when using a SPHERE or DISC distribution, only the x-component - * of this vector is used. - * @property {distribution} [velocity.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's velocity. Overrides the `type` option. - * @property {Boolean} [velocity.randomise=false] When a particle is re-spawned, whether it's velocity should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [acceleration={}] An object describing this particle's acceleration. - * @property {Object} [acceleration.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base acceleration. - * @property {Object} [acceleration.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's acceleration variance on a per-particle basis. - * Note that when using a SPHERE or DISC distribution, only the x-component - * of this vector is used. - * @property {distribution} [acceleration.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's acceleration. Overrides the `type` option. - * @property {Boolean} [acceleration.randomise=false] When a particle is re-spawned, whether it's acceleration should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [drag={}] An object describing this particle drag. Drag is applied to both velocity and acceleration values. - * @property {Number} [drag.value=0] A number between 0 and 1 describing the amount of drag to apply to all particles. - * @property {Number} [drag.spread=0] A number describing the drag variance on a per-particle basis. - * @property {Boolean} [drag.randomise=false] When a particle is re-spawned, whether it's drag should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [wiggle={}] This is quite a fun one! The values of this object will determine whether a particle will wiggle, or jiggle, or wave, - * or shimmy, or waggle, or... Well you get the idea. The wiggle is calculated over-time, meaning that a particle will - * start off with no wiggle, and end up wiggling about with the distance of the `value` specified by the time it dies. - * It's quite handy to simulate fire embers, or similar effects where the particle's position should slightly change over - * time, and such change isn't easily controlled by rotation, velocity, or acceleration. The wiggle is a combination of sin and cos calculations, so is circular in nature. - * @property {Number} [wiggle.value=0] A number describing the amount of wiggle to apply to all particles. It's measured in distance. - * @property {Number} [wiggle.spread=0] A number describing the wiggle variance on a per-particle basis. - * - * - * @property {Object} [rotation={}] An object describing this emitter's rotation. It can either be static, or set to rotate from 0radians to the value of `rotation.value` - * over a particle's lifetime. Rotation values affect both a particle's position and the forces applied to it. - * @property {Object} [rotation.axis=new THREE.Vector3(0, 1, 0)] A THREE.Vector3 instance describing this emitter's axis of rotation. - * @property {Object} [rotation.axisSpread=new THREE.Vector3()] A THREE.Vector3 instance describing the amount of variance to apply to the axis of rotation on - * a per-particle basis. - * @property {Number} [rotation.angle=0] The angle of rotation, given in radians. If `rotation.static` is true, the emitter will start off rotated at this angle, and stay as such. - * Otherwise, the particles will rotate from 0radians to this value over their lifetimes. - * @property {Number} [rotation.angleSpread=0] The amount of variance in each particle's rotation angle. - * @property {Boolean} [rotation.static=false] Whether the rotation should be static or not. - * @property {Object} [rotation.center=The value of `position.value`] A THREE.Vector3 instance describing the center point of rotation. - * @property {Boolean} [rotation.randomise=false] When a particle is re-spawned, whether it's rotation should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [color={}] An object describing a particle's color. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be - * given to describe specific value changes over a particle's lifetime. - * Depending on the value of SPE.valueOverLifetimeLength, if arrays of THREE.Color instances are given, then the array will be interpolated to - * have a length matching the value of SPE.valueOverLifetimeLength. - * @property {Object} [color.value=new THREE.Color()] Either a single THREE.Color instance, or an array of THREE.Color instances to describe the color of a particle over it's lifetime. - * @property {Object} [color.spread=new THREE.Vector3()] Either a single THREE.Vector3 instance, or an array of THREE.Vector3 instances to describe the color variance of a particle over it's lifetime. - * @property {Boolean} [color.randomise=false] When a particle is re-spawned, whether it's color should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [opacity={}] An object describing a particle's opacity. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be - * given to describe specific value changes over a particle's lifetime. - * Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to - * have a length matching the value of SPE.valueOverLifetimeLength. - * @property {Number} [opacity.value=1] Either a single number, or an array of numbers to describe the opacity of a particle over it's lifetime. - * @property {Number} [opacity.spread=0] Either a single number, or an array of numbers to describe the opacity variance of a particle over it's lifetime. - * @property {Boolean} [opacity.randomise=false] When a particle is re-spawned, whether it's opacity should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [size={}] An object describing a particle's size. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be - * given to describe specific value changes over a particle's lifetime. - * Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to - * have a length matching the value of SPE.valueOverLifetimeLength. - * @property {Number} [size.value=1] Either a single number, or an array of numbers to describe the size of a particle over it's lifetime. - * @property {Number} [size.spread=0] Either a single number, or an array of numbers to describe the size variance of a particle over it's lifetime. - * @property {Boolean} [size.randomise=false] When a particle is re-spawned, whether it's size should be re-randomised or not. Can incur a performance hit. - * - * - * @property {Object} [angle={}] An object describing a particle's angle. The angle is a 2d-rotation, measured in radians, applied to the particle's texture. - * NOTE: if a particle's texture is a sprite-sheet, this value IS IGNORED. - * This property is a "value-over-lifetime" property, meaning an array of values and spreads can be - * given to describe specific value changes over a particle's lifetime. - * Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to - * have a length matching the value of SPE.valueOverLifetimeLength. - * @property {Number} [angle.value=0] Either a single number, or an array of numbers to describe the angle of a particle over it's lifetime. - * @property {Number} [angle.spread=0] Either a single number, or an array of numbers to describe the angle variance of a particle over it's lifetime. - * @property {Boolean} [angle.randomise=false] When a particle is re-spawned, whether it's angle should be re-randomised or not. Can incur a performance hit. - * - */ - -/** - * The SPE.Emitter class. - * - * @constructor - * - * @param {EmitterOptions} options A map of options to configure the emitter. - */ -SPE.Emitter = function( options ) { - 'use strict'; - - var utils = SPE.utils, - types = utils.types, - lifetimeLength = SPE.valueOverLifetimeLength; - - // Ensure we have a map of options to play with, - // and that each option is in the correct format. - options = utils.ensureTypedArg( options, types.OBJECT, {} ); - options.position = utils.ensureTypedArg( options.position, types.OBJECT, {} ); - options.velocity = utils.ensureTypedArg( options.velocity, types.OBJECT, {} ); - options.acceleration = utils.ensureTypedArg( options.acceleration, types.OBJECT, {} ); - options.radius = utils.ensureTypedArg( options.radius, types.OBJECT, {} ); - options.drag = utils.ensureTypedArg( options.drag, types.OBJECT, {} ); - options.rotation = utils.ensureTypedArg( options.rotation, types.OBJECT, {} ); - options.color = utils.ensureTypedArg( options.color, types.OBJECT, {} ); - options.opacity = utils.ensureTypedArg( options.opacity, types.OBJECT, {} ); - options.size = utils.ensureTypedArg( options.size, types.OBJECT, {} ); - options.angle = utils.ensureTypedArg( options.angle, types.OBJECT, {} ); - options.wiggle = utils.ensureTypedArg( options.wiggle, types.OBJECT, {} ); - options.maxAge = utils.ensureTypedArg( options.maxAge, types.OBJECT, {} ); - - if ( options.onParticleSpawn ) { - console.warn( 'onParticleSpawn has been removed. Please set properties directly to alter values at runtime.' ); - } - - this.uuid = THREE.Math.generateUUID(); - - this.type = utils.ensureTypedArg( options.type, types.NUMBER, SPE.distributions.BOX ); - - // Start assigning properties...kicking it off with props that DON'T support values over - // lifetimes. - // - // Btw, values over lifetimes are just the new way of referring to *Start, *Middle, and *End. - this.position = { - _value: utils.ensureInstanceOf( options.position.value, THREE.Vector3, new THREE.Vector3() ), - _spread: utils.ensureInstanceOf( options.position.spread, THREE.Vector3, new THREE.Vector3() ), - _spreadClamp: utils.ensureInstanceOf( options.position.spreadClamp, THREE.Vector3, new THREE.Vector3() ), - _distribution: utils.ensureTypedArg( options.position.distribution, types.NUMBER, this.type ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ), - _radius: utils.ensureTypedArg( options.position.radius, types.NUMBER, 10 ), - _radiusScale: utils.ensureInstanceOf( options.position.radiusScale, THREE.Vector3, new THREE.Vector3( 1, 1, 1 ) ), - _distributionClamp: utils.ensureTypedArg( options.position.distributionClamp, types.NUMBER, 0 ), - }; - - this.velocity = { - _value: utils.ensureInstanceOf( options.velocity.value, THREE.Vector3, new THREE.Vector3() ), - _spread: utils.ensureInstanceOf( options.velocity.spread, THREE.Vector3, new THREE.Vector3() ), - _distribution: utils.ensureTypedArg( options.velocity.distribution, types.NUMBER, this.type ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - this.acceleration = { - _value: utils.ensureInstanceOf( options.acceleration.value, THREE.Vector3, new THREE.Vector3() ), - _spread: utils.ensureInstanceOf( options.acceleration.spread, THREE.Vector3, new THREE.Vector3() ), - _distribution: utils.ensureTypedArg( options.acceleration.distribution, types.NUMBER, this.type ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - this.drag = { - _value: utils.ensureTypedArg( options.drag.value, types.NUMBER, 0 ), - _spread: utils.ensureTypedArg( options.drag.spread, types.NUMBER, 0 ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - this.wiggle = { - _value: utils.ensureTypedArg( options.wiggle.value, types.NUMBER, 0 ), - _spread: utils.ensureTypedArg( options.wiggle.spread, types.NUMBER, 0 ) - }; - - this.rotation = { - _axis: utils.ensureInstanceOf( options.rotation.axis, THREE.Vector3, new THREE.Vector3( 0.0, 1.0, 0.0 ) ), - _axisSpread: utils.ensureInstanceOf( options.rotation.axisSpread, THREE.Vector3, new THREE.Vector3() ), - _angle: utils.ensureTypedArg( options.rotation.angle, types.NUMBER, 0 ), - _angleSpread: utils.ensureTypedArg( options.rotation.angleSpread, types.NUMBER, 0 ), - _static: utils.ensureTypedArg( options.rotation.static, types.BOOLEAN, false ), - _center: utils.ensureInstanceOf( options.rotation.center, THREE.Vector3, this.position._value.clone() ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - - this.maxAge = { - _value: utils.ensureTypedArg( options.maxAge.value, types.NUMBER, 2 ), - _spread: utils.ensureTypedArg( options.maxAge.spread, types.NUMBER, 0 ) - }; - - - - // The following properties can support either single values, or an array of values that change - // the property over a particle's lifetime (value over lifetime). - this.color = { - _value: utils.ensureArrayInstanceOf( options.color.value, THREE.Color, new THREE.Color() ), - _spread: utils.ensureArrayInstanceOf( options.color.spread, THREE.Vector3, new THREE.Vector3() ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - this.opacity = { - _value: utils.ensureArrayTypedArg( options.opacity.value, types.NUMBER, 1 ), - _spread: utils.ensureArrayTypedArg( options.opacity.spread, types.NUMBER, 0 ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - this.size = { - _value: utils.ensureArrayTypedArg( options.size.value, types.NUMBER, 1 ), - _spread: utils.ensureArrayTypedArg( options.size.spread, types.NUMBER, 0 ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - this.angle = { - _value: utils.ensureArrayTypedArg( options.angle.value, types.NUMBER, 0 ), - _spread: utils.ensureArrayTypedArg( options.angle.spread, types.NUMBER, 0 ), - _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) - }; - - - // Assign renaining option values. - this.particleCount = utils.ensureTypedArg( options.particleCount, types.NUMBER, 100 ); - this.duration = utils.ensureTypedArg( options.duration, types.NUMBER, null ); - this.isStatic = utils.ensureTypedArg( options.isStatic, types.BOOLEAN, false ); - this.activeMultiplier = utils.ensureTypedArg( options.activeMultiplier, types.NUMBER, 1 ); - this.direction = utils.ensureTypedArg( options.direction, types.NUMBER, 1 ); - - // Whether this emitter is alive or not. - this.alive = utils.ensureTypedArg( options.alive, types.BOOLEAN, true ); - - - // The following properties are set internally and are not - // user-controllable. - this.particlesPerSecond = 0; - - // The current particle index for which particles should - // be marked as active on the next update cycle. - this.activationIndex = 0; - - // The offset in the typed arrays this emitter's - // particle's values will start at - this.attributeOffset = 0; - - // The end of the range in the attribute buffers - this.attributeEnd = 0; - - - - // Holds the time the emitter has been alive for. - this.age = 0.0; - - // Holds the number of currently-alive particles - this.activeParticleCount = 0.0; - - // Holds a reference to this emitter's group once - // it's added to one. - this.group = null; - - // Holds a reference to this emitter's group's attributes object - // for easier access. - this.attributes = null; - - // Holds a reference to the params attribute's typed array - // for quicker access. - this.paramsArray = null; - - // A set of flags to determine whether particular properties - // should be re-randomised when a particle is reset. - // - // If a `randomise` property is given, this is preferred. - // Otherwise, it looks at whether a spread value has been - // given. - // - // It allows randomization to be turned off as desired. If - // all randomization is turned off, then I'd expect a performance - // boost as no attribute buffers (excluding the `params`) - // would have to be re-passed to the GPU each frame (since nothing - // except the `params` attribute would have changed). - this.resetFlags = { - // params: utils.ensureTypedArg( options.maxAge.randomise, types.BOOLEAN, !!options.maxAge.spread ) || - // utils.ensureTypedArg( options.wiggle.randomise, types.BOOLEAN, !!options.wiggle.spread ), - position: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) || - utils.ensureTypedArg( options.radius.randomise, types.BOOLEAN, false ), - velocity: utils.ensureTypedArg( options.velocity.randomise, types.BOOLEAN, false ), - acceleration: utils.ensureTypedArg( options.acceleration.randomise, types.BOOLEAN, false ) || - utils.ensureTypedArg( options.drag.randomise, types.BOOLEAN, false ), - rotation: utils.ensureTypedArg( options.rotation.randomise, types.BOOLEAN, false ), - rotationCenter: utils.ensureTypedArg( options.rotation.randomise, types.BOOLEAN, false ), - size: utils.ensureTypedArg( options.size.randomise, types.BOOLEAN, false ), - color: utils.ensureTypedArg( options.color.randomise, types.BOOLEAN, false ), - opacity: utils.ensureTypedArg( options.opacity.randomise, types.BOOLEAN, false ), - angle: utils.ensureTypedArg( options.angle.randomise, types.BOOLEAN, false ) - }; - - this.updateFlags = {}; - this.updateCounts = {}; - - // A map to indicate which emitter parameters should update - // which attribute. - this.updateMap = { - maxAge: 'params', - position: 'position', - velocity: 'velocity', - acceleration: 'acceleration', - drag: 'acceleration', - wiggle: 'params', - rotation: 'rotation', - size: 'size', - color: 'color', - opacity: 'opacity', - angle: 'angle' - }; - - for ( var i in this.updateMap ) { - if ( this.updateMap.hasOwnProperty( i ) ) { - this.updateCounts[ this.updateMap[ i ] ] = 0.0; - this.updateFlags[ this.updateMap[ i ] ] = false; - this._createGetterSetters( this[ i ], i ); - } - } - - this.bufferUpdateRanges = {}; - this.attributeKeys = null; - this.attributeCount = 0; - - - // Ensure that the value-over-lifetime property objects above - // have value and spread properties that are of the same length. - // - // Also, for now, make sure they have a length of 3 (min/max arguments here). - utils.ensureValueOverLifetimeCompliance( this.color, lifetimeLength, lifetimeLength ); - utils.ensureValueOverLifetimeCompliance( this.opacity, lifetimeLength, lifetimeLength ); - utils.ensureValueOverLifetimeCompliance( this.size, lifetimeLength, lifetimeLength ); - utils.ensureValueOverLifetimeCompliance( this.angle, lifetimeLength, lifetimeLength ); -}; - -SPE.Emitter.constructor = SPE.Emitter; - -SPE.Emitter.prototype._createGetterSetters = function( propObj, propName ) { - 'use strict'; - - var self = this; - - for ( var i in propObj ) { - if ( propObj.hasOwnProperty( i ) ) { - - var name = i.replace( '_', '' ); - - Object.defineProperty( propObj, name, { - get: ( function( prop ) { - return function() { - return this[ prop ]; - }; - }( i ) ), - - set: ( function( prop ) { - return function( value ) { - var mapName = self.updateMap[ propName ], - prevValue = this[ prop ], - length = SPE.valueOverLifetimeLength; - - if ( prop === '_rotationCenter' ) { - self.updateFlags.rotationCenter = true; - self.updateCounts.rotationCenter = 0.0; - } - else if ( prop === '_randomise' ) { - self.resetFlags[ mapName ] = value; - } - else { - self.updateFlags[ mapName ] = true; - self.updateCounts[ mapName ] = 0.0; - } - - self.group._updateDefines(); - - this[ prop ] = value; - - // If the previous value was an array, then make - // sure the provided value is interpolated correctly. - if ( Array.isArray( prevValue ) ) { - SPE.utils.ensureValueOverLifetimeCompliance( self[ propName ], length, length ); - } - }; - }( i ) ) - } ); - } - } -}; - -SPE.Emitter.prototype._setBufferUpdateRanges = function( keys ) { - 'use strict'; - - this.attributeKeys = keys; - this.attributeCount = keys.length; - - for ( var i = this.attributeCount - 1; i >= 0; --i ) { - this.bufferUpdateRanges[ keys[ i ] ] = { - min: Number.POSITIVE_INFINITY, - max: Number.NEGATIVE_INFINITY - }; - } -}; - -SPE.Emitter.prototype._calculatePPSValue = function( groupMaxAge ) { - 'use strict'; - - var particleCount = this.particleCount; - - - // Calculate the `particlesPerSecond` value for this emitter. It's used - // when determining which particles should die and which should live to - // see another day. Or be born, for that matter. The "God" property. - if ( this.duration ) { - this.particlesPerSecond = particleCount / ( groupMaxAge < this.duration ? groupMaxAge : this.duration ); - } - else { - this.particlesPerSecond = particleCount / groupMaxAge; - } -}; - -SPE.Emitter.prototype._setAttributeOffset = function( startIndex ) { - this.attributeOffset = startIndex; - this.activationIndex = startIndex; - this.activationEnd = startIndex + this.particleCount; -}; - - -SPE.Emitter.prototype._assignValue = function( prop, index ) { - 'use strict'; - - switch ( prop ) { - case 'position': - this._assignPositionValue( index ); - break; - - case 'velocity': - case 'acceleration': - this._assignForceValue( index, prop ); - break; - - case 'size': - case 'opacity': - this._assignAbsLifetimeValue( index, prop ); - break; - - case 'angle': - this._assignAngleValue( index ); - break; - - case 'params': - this._assignParamsValue( index ); - break; - - case 'rotation': - this._assignRotationValue( index ); - break; - - case 'color': - this._assignColorValue( index ); - break; - } -}; - -SPE.Emitter.prototype._assignPositionValue = function( index ) { - 'use strict'; - - var distributions = SPE.distributions, - utils = SPE.utils, - prop = this.position, - attr = this.attributes.position, - value = prop._value, - spread = prop._spread, - distribution = prop._distribution; - - switch ( distribution ) { - case distributions.BOX: - utils.randomVector3( attr, index, value, spread, prop._spreadClamp ); - break; - - case distributions.SPHERE: - utils.randomVector3OnSphere( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x, prop._distributionClamp || this.particleCount ); - break; - - case distributions.DISC: - utils.randomVector3OnDisc( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x ); - break; - - case distributions.LINE: - utils.randomVector3OnLine( attr, index, value, spread ); - break; - } -}; - -SPE.Emitter.prototype._assignForceValue = function( index, attrName ) { - 'use strict'; - - var distributions = SPE.distributions, - utils = SPE.utils, - prop = this[ attrName ], - value = prop._value, - spread = prop._spread, - distribution = prop._distribution, - pos, - positionX, - positionY, - positionZ, - i; - - switch ( distribution ) { - case distributions.BOX: - utils.randomVector3( this.attributes[ attrName ], index, value, spread ); - break; - - case distributions.SPHERE: - pos = this.attributes.position.typedArray.array; - i = index * 3; - - // Ensure position values aren't zero, otherwise no force will be - // applied. - // positionX = utils.zeroToEpsilon( pos[ i ], true ); - // positionY = utils.zeroToEpsilon( pos[ i + 1 ], true ); - // positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true ); - positionX = pos[ i ]; - positionY = pos[ i + 1 ]; - positionZ = pos[ i + 2 ]; - - utils.randomDirectionVector3OnSphere( - this.attributes[ attrName ], index, - positionX, positionY, positionZ, - this.position._value, - prop._value.x, - prop._spread.x - ); - break; - - case distributions.DISC: - pos = this.attributes.position.typedArray.array; - i = index * 3; - - // Ensure position values aren't zero, otherwise no force will be - // applied. - // positionX = utils.zeroToEpsilon( pos[ i ], true ); - // positionY = utils.zeroToEpsilon( pos[ i + 1 ], true ); - // positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true ); - positionX = pos[ i ]; - positionY = pos[ i + 1 ]; - positionZ = pos[ i + 2 ]; - - utils.randomDirectionVector3OnDisc( - this.attributes[ attrName ], index, - positionX, positionY, positionZ, - this.position._value, - prop._value.x, - prop._spread.x - ); - break; - - case distributions.LINE: - utils.randomVector3OnLine( this.attributes[ attrName ], index, value, spread ); - break; - } - - if ( attrName === 'acceleration' ) { - var drag = utils.clamp( utils.randomFloat( this.drag._value, this.drag._spread ), 0, 1 ); - this.attributes.acceleration.typedArray.array[ index * 4 + 3 ] = drag; - } -}; - -SPE.Emitter.prototype._assignAbsLifetimeValue = function( index, propName ) { - 'use strict'; - - var array = this.attributes[ propName ].typedArray, - prop = this[ propName ], - utils = SPE.utils, - value; - - if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) { - value = Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) ); - array.setVec4Components( index, value, value, value, value ); - } - else { - array.setVec4Components( index, - Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) ), - Math.abs( utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ) ), - Math.abs( utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ) ), - Math.abs( utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] ) ) - ); - } -}; - -SPE.Emitter.prototype._assignAngleValue = function( index ) { - 'use strict'; - - var array = this.attributes.angle.typedArray, - prop = this.angle, - utils = SPE.utils, - value; - - if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) { - value = utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ); - array.setVec4Components( index, value, value, value, value ); - } - else { - array.setVec4Components( index, - utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ), - utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ), - utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ), - utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] ) - ); - } -}; - -SPE.Emitter.prototype._assignParamsValue = function( index ) { - 'use strict'; - - this.attributes.params.typedArray.setVec4Components( index, - this.isStatic ? 1 : 0, - 0.0, - Math.abs( SPE.utils.randomFloat( this.maxAge._value, this.maxAge._spread ) ), - SPE.utils.randomFloat( this.wiggle._value, this.wiggle._spread ) - ); -}; - -SPE.Emitter.prototype._assignRotationValue = function( index ) { - 'use strict'; - - this.attributes.rotation.typedArray.setVec3Components( index, - SPE.utils.getPackedRotationAxis( this.rotation._axis, this.rotation._axisSpread ), - SPE.utils.randomFloat( this.rotation._angle, this.rotation._angleSpread ), - this.rotation._static ? 0 : 1 - ); - - this.attributes.rotationCenter.typedArray.setVec3( index, this.rotation._center ); -}; - -SPE.Emitter.prototype._assignColorValue = function( index ) { - 'use strict'; - SPE.utils.randomColorAsHex( this.attributes.color, index, this.color._value, this.color._spread ); -}; - -SPE.Emitter.prototype._resetParticle = function( index ) { - 'use strict'; - - var resetFlags = this.resetFlags, - updateFlags = this.updateFlags, - updateCounts = this.updateCounts, - keys = this.attributeKeys, - key, - updateFlag; - - for ( var i = this.attributeCount - 1; i >= 0; --i ) { - key = keys[ i ]; - updateFlag = updateFlags[ key ]; - - if ( resetFlags[ key ] === true || updateFlag === true ) { - this._assignValue( key, index ); - this._updateAttributeUpdateRange( key, index ); - - if ( updateFlag === true && updateCounts[ key ] === this.particleCount ) { - updateFlags[ key ] = false; - updateCounts[ key ] = 0.0; - } - else if ( updateFlag == true ) { - ++updateCounts[ key ]; - } - } - } -}; - -SPE.Emitter.prototype._updateAttributeUpdateRange = function( attr, i ) { - 'use strict'; - - var ranges = this.bufferUpdateRanges[ attr ]; - - ranges.min = Math.min( i, ranges.min ); - ranges.max = Math.max( i, ranges.max ); -}; - -SPE.Emitter.prototype._resetBufferRanges = function() { - 'use strict'; - - var ranges = this.bufferUpdateRanges, - keys = this.bufferUpdateKeys, - i = this.bufferUpdateCount - 1, - key; - - for ( i; i >= 0; --i ) { - key = keys[ i ]; - ranges[ key ].min = Number.POSITIVE_INFINITY; - ranges[ key ].max = Number.NEGATIVE_INFINITY; - } -}; - -SPE.Emitter.prototype._onRemove = function() { - 'use strict'; - // Reset any properties of the emitter that were set by - // a group when it was added. - this.particlesPerSecond = 0; - this.attributeOffset = 0; - this.activationIndex = 0; - this.activeParticleCount = 0; - this.group = null; - this.attributes = null; - this.paramsArray = null; - this.age = 0.0; -}; - -SPE.Emitter.prototype._decrementParticleCount = function() { - 'use strict'; - --this.activeParticleCount; - - // TODO: - // - Trigger event if count === 0. -}; - -SPE.Emitter.prototype._incrementParticleCount = function() { - 'use strict'; - ++this.activeParticleCount; - - // TODO: - // - Trigger event if count === this.particleCount. -}; - -SPE.Emitter.prototype._checkParticleAges = function( start, end, params, dt ) { - 'use strict'; - for ( var i = end - 1, index, maxAge, age, alive; i >= start; --i ) { - index = i * 4; - - alive = params[ index ]; - - if ( alive === 0.0 ) { - continue; - } - - // Increment age - age = params[ index + 1 ]; - maxAge = params[ index + 2 ]; - - if ( this.direction === 1 ) { - age += dt; - - if ( age >= maxAge ) { - age = 0.0; - alive = 0.0; - this._decrementParticleCount(); - } - } - else { - age -= dt; - - if ( age <= 0.0 ) { - age = maxAge; - alive = 0.0; - this._decrementParticleCount(); - } - } - - params[ index ] = alive; - params[ index + 1 ] = age; - - this._updateAttributeUpdateRange( 'params', i ); - } -}; - -SPE.Emitter.prototype._activateParticles = function( activationStart, activationEnd, params, dtPerParticle ) { - 'use strict'; - var direction = this.direction; - - for ( var i = activationStart, index, dtValue; i < activationEnd; ++i ) { - index = i * 4; - - // Don't re-activate particles that aren't dead yet. - // if ( params[ index ] !== 0.0 && ( this.particleCount !== 1 || this.activeMultiplier !== 1 ) ) { - // continue; - // } - - if ( params[ index ] != 0.0 && this.particleCount !== 1 ) { - continue; - } - - // Increment the active particle count. - this._incrementParticleCount(); - - // Mark the particle as alive. - params[ index ] = 1.0; - - // Reset the particle - this._resetParticle( i ); - - // Move each particle being activated to - // it's actual position in time. - // - // This stops particles being 'clumped' together - // when frame rates are on the lower side of 60fps - // or not constant (a very real possibility!) - dtValue = dtPerParticle * ( i - activationStart ) - params[ index + 1 ] = direction === -1 ? params[ index + 2 ] - dtValue : dtValue; - - this._updateAttributeUpdateRange( 'params', i ); - } -}; - -/** - * Simulates one frame's worth of particles, updating particles - * that are already alive, and marking ones that are currently dead - * but should be alive as alive. - * - * If the emitter is marked as static, then this function will do nothing. - * - * @param {Number} dt The number of seconds to simulate (deltaTime) - */ -SPE.Emitter.prototype.tick = function( dt ) { - 'use strict'; - - if ( this.isStatic ) { - return; - } - - if ( this.paramsArray === null ) { - this.paramsArray = this.attributes.params.typedArray.array; - } - - var start = this.attributeOffset, - end = start + this.particleCount, - params = this.paramsArray, // vec3( alive, age, maxAge, wiggle ) - ppsDt = this.particlesPerSecond * this.activeMultiplier * dt, - activationIndex = this.activationIndex; - - // Reset the buffer update indices. - this._resetBufferRanges(); - - // Increment age for those particles that are alive, - // and kill off any particles whose age is over the limit. - this._checkParticleAges( start, end, params, dt ); - - // If the emitter is dead, reset the age of the emitter to zero, - // ready to go again if required - if ( this.alive === false ) { - this.age = 0.0; - return; - } - - // If the emitter has a specified lifetime and we've exceeded it, - // mark the emitter as dead. - if ( this.duration !== null && this.age > this.duration ) { - this.alive = false; - this.age = 0.0; - return; - } - - - var activationStart = this.particleCount === 1 ? activationIndex : ( activationIndex | 0 ), - activationEnd = Math.min( activationStart + ppsDt, this.activationEnd ), - activationCount = activationEnd - this.activationIndex | 0, - dtPerParticle = activationCount > 0 ? dt / activationCount : 0; - - this._activateParticles( activationStart, activationEnd, params, dtPerParticle ); - - // Move the activation window forward, soldier. - this.activationIndex += ppsDt; - - if ( this.activationIndex > end ) { - this.activationIndex = start; - } - - - // Increment the age of the emitter. - this.age += dt; -}; - -/** - * Resets all the emitter's particles to their start positions - * and marks the particles as dead if the `force` argument is - * true. - * - * @param {Boolean} [force=undefined] If true, all particles will be marked as dead instantly. - * @return {Emitter} This emitter instance. - */ -SPE.Emitter.prototype.reset = function( force ) { - 'use strict'; - - this.age = 0.0; - this.alive = false; - - if ( force === true ) { - var start = this.attributeOffset, - end = start + this.particleCount, - array = this.paramsArray, - attr = this.attributes.params.bufferAttribute; - - for ( var i = end - 1, index; i >= start; --i ) { - index = i * 4; - - array[ index ] = 0.0; - array[ index + 1 ] = 0.0; - } - - attr.updateRange.offset = 0; - attr.updateRange.count = -1; - attr.needsUpdate = true; - } - - return this; -}; - -/** - * Enables the emitter. If not already enabled, the emitter - * will start emitting particles. - * - * @return {Emitter} This emitter instance. - */ -SPE.Emitter.prototype.enable = function() { - 'use strict'; - this.alive = true; - return this; -}; - -/** - * Disables th emitter, but does not instantly remove it's - * particles fromt the scene. When called, the emitter will be - * 'switched off' and just stop emitting. Any particle's alive will - * be allowed to finish their lifecycle. - * - * @return {Emitter} This emitter instance. - */ -SPE.Emitter.prototype.disable = function() { - 'use strict'; - - this.alive = false; - return this; -}; - -/** - * Remove this emitter from it's parent group (if it has been added to one). - * Delgates to SPE.group.prototype.removeEmitter(). - * - * When called, all particle's belonging to this emitter will be instantly - * removed from the scene. - * - * @return {Emitter} This emitter instance. - * - * @see SPE.Group.prototype.removeEmitter - */ -SPE.Emitter.prototype.remove = function() { - 'use strict'; - if ( this.group !== null ) { - this.group.removeEmitter( this ); - } - else { - console.error( 'Emitter does not belong to a group, cannot remove.' ); - } - - return this; -}; diff --git a/build/SPE.min.js b/build/SPE.min.js deleted file mode 100644 index 6cfdcc8..0000000 --- a/build/SPE.min.js +++ /dev/null @@ -1,52 +0,0 @@ -/* shader-particle-engine 1.0.6 - * - * (c) 2015 Luke Moody (http://www.github.com/squarefeet) - * Originally based on Lee Stemkoski's original work (https://github.com/stemkoski/stemkoski.github.com/blob/master/Three.js/js/ParticleEngine.js). - * - * shader-particle-engine may be freely distributed under the MIT license (See LICENSE at root of this repository.) - */ -var SPE={distributions:{BOX:1,SPHERE:2,DISC:3,LINE:4},valueOverLifetimeLength:4};"function"==typeof define&&define.amd?define("spe",SPE):"undefined"!=typeof exports&&"undefined"!=typeof module&&(module.exports=SPE),SPE.TypedArrayHelper=function(a,b,c,d){"use strict";this.componentSize=c||1,this.size=b||1,this.TypedArrayConstructor=a||Float32Array,this.array=new a(b*this.componentSize),this.indexOffset=d||0},SPE.TypedArrayHelper.constructor=SPE.TypedArrayHelper,SPE.TypedArrayHelper.prototype.setSize=function(a,b){"use strict";var c=this.array.length;return b||(a*=this.componentSize),ac?this.grow(a):void console.info("TypedArray is already of size:",a+".","Will not resize.")},SPE.TypedArrayHelper.prototype.shrink=function(a){"use strict";return this.array=this.array.subarray(0,a),this.size=a,this},SPE.TypedArrayHelper.prototype.grow=function(a){"use strict";var b=this.array,c=new this.TypedArrayConstructor(a);return c.set(b),this.array=c,this.size=a,this}, -SPE.TypedArrayHelper.prototype.splice=function(a,b){"use strict";a*=this.componentSize,b*=this.componentSize;for(var c=[],d=this.array,e=d.length,f=0;f=b)&&c.push(d[f]);return this.setFromArray(0,c),this},SPE.TypedArrayHelper.prototype.setFromArray=function(a,b){"use strict";var c=b.length,d=a+c;return d>this.array.length?this.grow(d):d=81&&(this.bufferAttribute.count=this.bufferAttribute.array.length/this.bufferAttribute.itemSize),void(this.bufferAttribute.needsUpdate=!0);this.bufferAttribute=new THREE.BufferAttribute(this.typedArray.array,this.componentSize),this.bufferAttribute.usage=this.dynamicBuffer?THREE.DynamicDrawUsage:THREE.StaticDrawUsage},SPE.ShaderAttribute.prototype.getLength=function(){"use strict";return null===this.typedArray?0:this.typedArray.array.length},SPE.shaderChunks={ -defines:["#define PACKED_COLOR_SIZE 256.0","#define PACKED_COLOR_DIVISOR 255.0"].join("\n"),uniforms:["uniform float deltaTime;","uniform float runTime;","uniform sampler2D tex;","uniform vec4 textureAnimation;","uniform float scale;"].join("\n"),attributes:["attribute vec4 acceleration;","attribute vec3 velocity;","attribute vec4 rotation;","attribute vec3 rotationCenter;","attribute vec4 params;","attribute vec4 size;","attribute vec4 angle;","attribute vec4 color;","attribute vec4 opacity;"].join("\n"),varyings:["varying vec4 vColor;","#ifdef SHOULD_ROTATE_TEXTURE"," varying float vAngle;","#endif","#ifdef SHOULD_CALCULATE_SPRITE"," varying vec4 vSpriteSheet;","#endif"].join("\n"), -branchAvoidanceFunctions:["float when_gt(float x, float y) {"," return max(sign(x - y), 0.0);","}","float when_lt(float x, float y) {"," return min( max(1.0 - sign(x - y), 0.0), 1.0 );","}","float when_eq( float x, float y ) {"," return 1.0 - abs( sign( x - y ) );","}","float when_ge(float x, float y) {"," return 1.0 - when_lt(x, y);","}","float when_le(float x, float y) {"," return 1.0 - when_gt(x, y);","}","float and(float a, float b) {"," return a * b;","}","float or(float a, float b) {"," return min(a + b, 1.0);","}"].join("\n"),unpackColor:["vec3 unpackColor( in float hex ) {"," vec3 c = vec3( 0.0 );"," float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float b = mod( hex, PACKED_COLOR_SIZE );"," c.r = r / PACKED_COLOR_DIVISOR;"," c.g = g / PACKED_COLOR_DIVISOR;"," c.b = b / PACKED_COLOR_DIVISOR;"," return c;","}"].join("\n"), -unpackRotationAxis:["vec3 unpackRotationAxis( in float hex ) {"," vec3 c = vec3( 0.0 );"," float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float b = mod( hex, PACKED_COLOR_SIZE );"," c.r = r / PACKED_COLOR_DIVISOR;"," c.g = g / PACKED_COLOR_DIVISOR;"," c.b = b / PACKED_COLOR_DIVISOR;"," c *= vec3( 2.0 );"," c -= vec3( 1.0 );"," return c;","}"].join("\n"), -floatOverLifetime:["float getFloatOverLifetime( in float positionInTime, in vec4 attr ) {"," highp float value = 0.0;"," float deltaAge = positionInTime * float( VALUE_OVER_LIFETIME_LENGTH - 1 );"," float fIndex = 0.0;"," float shouldApplyValue = 0.0;"," value += attr[ 0 ] * when_eq( deltaAge, 0.0 );",""," for( int i = 0; i < VALUE_OVER_LIFETIME_LENGTH - 1; ++i ) {"," fIndex = float( i );"," shouldApplyValue = and( when_gt( deltaAge, fIndex ), when_le( deltaAge, fIndex + 1.0 ) );"," value += shouldApplyValue * mix( attr[ i ], attr[ i + 1 ], deltaAge - fIndex );"," }",""," return value;","}"].join("\n"), -colorOverLifetime:["vec3 getColorOverLifetime( in float positionInTime, in vec3 color1, in vec3 color2, in vec3 color3, in vec3 color4 ) {"," vec3 value = vec3( 0.0 );"," value.x = getFloatOverLifetime( positionInTime, vec4( color1.x, color2.x, color3.x, color4.x ) );"," value.y = getFloatOverLifetime( positionInTime, vec4( color1.y, color2.y, color3.y, color4.y ) );"," value.z = getFloatOverLifetime( positionInTime, vec4( color1.z, color2.z, color3.z, color4.z ) );"," return value;","}"].join("\n"),paramFetchingFunctions:["float getAlive() {"," return params.x;","}","float getAge() {"," return params.y;","}","float getMaxAge() {"," return params.z;","}","float getWiggle() {"," return params.w;","}"].join("\n"), -forceFetchingFunctions:["vec4 getPosition( in float age ) {"," return modelViewMatrix * vec4( position, 1.0 );","}","vec3 getVelocity( in float age ) {"," return velocity * age;","}","vec3 getAcceleration( in float age ) {"," return acceleration.xyz * age;","}"].join("\n"), -rotationFunctions:["#ifdef SHOULD_ROTATE_PARTICLES"," mat4 getRotationMatrix( in vec3 axis, in float angle) {"," axis = normalize(axis);"," float s = sin(angle);"," float c = cos(angle);"," float oc = 1.0 - c;",""," return mat4(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 0.0,"," oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 0.0,"," oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c, 0.0,"," 0.0, 0.0, 0.0, 1.0);"," }",""," vec3 getRotation( in vec3 pos, in float positionInTime ) {"," if( rotation.y == 0.0 ) {"," return pos;"," }",""," vec3 axis = unpackRotationAxis( rotation.x );"," vec3 center = rotationCenter;"," vec3 translated;"," mat4 rotationMatrix;"," float angle = 0.0;"," angle += when_eq( rotation.z, 0.0 ) * rotation.y;"," angle += when_gt( rotation.z, 0.0 ) * mix( 0.0, rotation.y, positionInTime );"," translated = rotationCenter - pos;"," rotationMatrix = getRotationMatrix( axis, angle );"," return center - vec3( rotationMatrix * vec4( translated, 0.0 ) );"," }","#endif"].join("\n"), -rotateTexture:[" vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );",""," #ifdef SHOULD_ROTATE_TEXTURE"," float x = gl_PointCoord.x - 0.5;"," float y = 1.0 - gl_PointCoord.y - 0.5;"," float c = cos( -vAngle );"," float s = sin( -vAngle );"," vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );"," #endif",""," #ifdef SHOULD_CALCULATE_SPRITE"," float framesX = vSpriteSheet.x;"," float framesY = vSpriteSheet.y;"," float columnNorm = vSpriteSheet.z;"," float rowNorm = vSpriteSheet.w;"," vUv.x = gl_PointCoord.x * framesX + columnNorm;"," vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);"," #endif",""," vec4 rotatedTexture = texture2D( tex, vUv );"].join("\n")},SPE.shaders={ -vertex:[SPE.shaderChunks.defines,SPE.shaderChunks.uniforms,SPE.shaderChunks.attributes,SPE.shaderChunks.varyings,THREE.ShaderChunk.common,THREE.ShaderChunk.logdepthbuf_pars_vertex,THREE.ShaderChunk.fog_pars_vertex,SPE.shaderChunks.branchAvoidanceFunctions,SPE.shaderChunks.unpackColor,SPE.shaderChunks.unpackRotationAxis,SPE.shaderChunks.floatOverLifetime,SPE.shaderChunks.colorOverLifetime,SPE.shaderChunks.paramFetchingFunctions,SPE.shaderChunks.forceFetchingFunctions,SPE.shaderChunks.rotationFunctions,"void main() {"," highp float age = getAge();"," highp float alive = getAlive();"," highp float maxAge = getMaxAge();"," highp float positionInTime = (age / maxAge);"," highp float isAlive = when_gt( alive, 0.0 );"," #ifdef SHOULD_WIGGLE_PARTICLES"," float wiggleAmount = positionInTime * getWiggle();"," float wiggleSin = isAlive * sin( wiggleAmount );"," float wiggleCos = isAlive * cos( wiggleAmount );"," #endif"," vec3 vel = getVelocity( age );"," vec3 accel = getAcceleration( age );"," vec3 force = vec3( 0.0 );"," vec3 pos = vec3( position );"," float drag = 1.0 - (positionInTime * 0.5) * acceleration.w;"," force += vel;"," force *= drag;"," force += accel * age;"," pos += force;"," #ifdef SHOULD_WIGGLE_PARTICLES"," pos.x += wiggleSin;"," pos.y += wiggleCos;"," pos.z += wiggleSin;"," #endif"," #ifdef SHOULD_ROTATE_PARTICLES"," pos = getRotation( pos, positionInTime );"," #endif"," vec4 mvPosition = modelViewMatrix * vec4( pos, 1.0 );"," highp float pointSize = getFloatOverLifetime( positionInTime, size ) * isAlive;"," #ifdef HAS_PERSPECTIVE"," float perspective = scale / length( mvPosition.xyz );"," #else"," float perspective = 1.0;"," #endif"," float pointSizePerspective = pointSize * perspective;"," #ifdef COLORIZE"," vec3 c = isAlive * getColorOverLifetime("," positionInTime,"," unpackColor( color.x ),"," unpackColor( color.y ),"," unpackColor( color.z ),"," unpackColor( color.w )"," );"," #else"," vec3 c = vec3(1.0);"," #endif"," float o = isAlive * getFloatOverLifetime( positionInTime, opacity );"," vColor = vec4( c, o );"," #ifdef SHOULD_ROTATE_TEXTURE"," vAngle = isAlive * getFloatOverLifetime( positionInTime, angle );"," #endif"," #ifdef SHOULD_CALCULATE_SPRITE"," float framesX = textureAnimation.x;"," float framesY = textureAnimation.y;"," float loopCount = textureAnimation.w;"," float totalFrames = textureAnimation.z;"," float frameNumber = mod( (positionInTime * loopCount) * totalFrames, totalFrames );"," float column = floor(mod( frameNumber, framesX ));"," float row = floor( (frameNumber - column) / framesX );"," float columnNorm = column / framesX;"," float rowNorm = row / framesY;"," vSpriteSheet.x = 1.0 / framesX;"," vSpriteSheet.y = 1.0 / framesY;"," vSpriteSheet.z = columnNorm;"," vSpriteSheet.w = rowNorm;"," #endif"," gl_PointSize = pointSizePerspective;"," gl_Position = projectionMatrix * mvPosition;",THREE.ShaderChunk.logdepthbuf_vertex,THREE.ShaderChunk.fog_vertex,"}"].join("\n"), -fragment:[SPE.shaderChunks.uniforms,THREE.ShaderChunk.common,THREE.ShaderChunk.fog_pars_fragment,THREE.ShaderChunk.logdepthbuf_pars_fragment,SPE.shaderChunks.varyings,SPE.shaderChunks.branchAvoidanceFunctions,"void main() {"," vec3 outgoingLight = vColor.xyz;"," "," #ifdef ALPHATEST"," if ( vColor.w < float(ALPHATEST) ) discard;"," #endif",SPE.shaderChunks.rotateTexture,THREE.ShaderChunk.logdepthbuf_fragment," outgoingLight = vColor.xyz * rotatedTexture.xyz;"," gl_FragColor = vec4( outgoingLight.xyz, rotatedTexture.w * vColor.w );",THREE.ShaderChunk.fog_fragment,"}"].join("\n")},SPE.utils={types:{BOOLEAN:"boolean",STRING:"string",NUMBER:"number",OBJECT:"object"},ensureTypedArg:function(a,b,c){"use strict";return typeof a===b?a:c},ensureArrayTypedArg:function(a,b,c){"use strict";if(Array.isArray(a)){for(var d=a.length-1;d>=0;--d)if(typeof a[d]!==b)return c;return a}return this.ensureTypedArg(a,b,c)},ensureInstanceOf:function(a,b,c){"use strict" -;return void 0!==b&&a instanceof b?a:c},ensureArrayInstanceOf:function(a,b,c){"use strict";if(Array.isArray(a)){for(var d=a.length-1;d>=0;--d)if(void 0!==b&&a[d]instanceof b==!1)return c;return a}return this.ensureInstanceOf(a,b,c)},ensureValueOverLifetimeCompliance:function(a,b,c){"use strict";b=b||3,c=c||3,!1===Array.isArray(a._value)&&(a._value=[a._value]),!1===Array.isArray(a._spread)&&(a._spread=[a._spread]);var d=this.clamp(a._value.length,b,c),e=this.clamp(a._spread.length,b,c),f=Math.max(d,e);a._value.length!==f&&(a._value=this.interpolateArray(a._value,f)),a._spread.length!==f&&(a._spread=this.interpolateArray(a._spread,f))},interpolateArray:function(a,b){"use strict";for(var c=a.length,d=["function"==typeof a[0].clone?a[0].clone():a[0]],e=(c-1)/(b-1),f=1;f-c&&(d=-d),d},lerpTypeAgnostic:function(a,b,c){"use strict";var d,e=this.types;return typeof a===e.NUMBER&&typeof b===e.NUMBER?a+(b-a)*c:a instanceof THREE.Vector2&&b instanceof THREE.Vector2?(d=a.clone(),d.x=this.lerp(a.x,b.x,c),d.y=this.lerp(a.y,b.y,c),d):a instanceof THREE.Vector3&&b instanceof THREE.Vector3?(d=a.clone(),d.x=this.lerp(a.x,b.x,c),d.y=this.lerp(a.y,b.y,c),d.z=this.lerp(a.z,b.z,c),d):a instanceof THREE.Vector4&&b instanceof THREE.Vector4?(d=a.clone(),d.x=this.lerp(a.x,b.x,c),d.y=this.lerp(a.y,b.y,c),d.z=this.lerp(a.z,b.z,c),d.w=this.lerp(a.w,b.w,c),d):a instanceof THREE.Color&&b instanceof THREE.Color?(d=a.clone(),d.r=this.lerp(a.r,b.r,c),d.g=this.lerp(a.g,b.g,c),d.b=this.lerp(a.b,b.b,c),d):void console.warn("Invalid argument types, or argument types do not match:",a,b)},lerp:function(a,b,c){"use strict";return a+(b-a)*c}, -roundToNearestMultiple:function(a,b){"use strict";var c=0;return 0===b?a:(c=Math.abs(a)%b,0===c?a:a<0?-(Math.abs(a)-c):a+b-c)},arrayValuesAreEqual:function(a){"use strict";for(var b=0;b1||this.textureFrames.y>1},this.attributes={position:new SPE.ShaderAttribute("v3",!0),acceleration:new SPE.ShaderAttribute("v4",!0),velocity:new SPE.ShaderAttribute("v3",!0),rotation:new SPE.ShaderAttribute("v4",!0),rotationCenter:new SPE.ShaderAttribute("v3",!0),params:new SPE.ShaderAttribute("v4",!0),size:new SPE.ShaderAttribute("v4",!0),angle:new SPE.ShaderAttribute("v4",!0),color:new SPE.ShaderAttribute("v4",!0),opacity:new SPE.ShaderAttribute("v4",!0)},this.attributeKeys=Object.keys(this.attributes),this.attributeCount=this.attributeKeys.length,this.material=new THREE.ShaderMaterial({uniforms:this.uniforms,vertexShader:SPE.shaders.vertex,fragmentShader:SPE.shaders.fragment,blending:this.blending,transparent:this.transparent,alphaTest:this.alphaTest,depthWrite:this.depthWrite,depthTest:this.depthTest,defines:this.defines,fog:this.fog}), -this.geometry=new THREE.BufferGeometry,this.mesh=new THREE.Points(this.geometry,this.material),null===this.maxParticleCount&&console.warn("SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.")},SPE.Group.constructor=SPE.Group,SPE.Group.prototype._updateDefines=function(){"use strict";var a,b=this.emitters,c=b.length-1,d=this.defines;for(c;c>=0;--c)a=b[c],d.SHOULD_CALCULATE_SPRITE||(d.SHOULD_ROTATE_TEXTURE=d.SHOULD_ROTATE_TEXTURE||!!Math.max(Math.max.apply(null,a.angle.value),Math.max.apply(null,a.angle.spread))),d.SHOULD_ROTATE_PARTICLES=d.SHOULD_ROTATE_PARTICLES||!!Math.max(a.rotation.angle,a.rotation.angleSpread),d.SHOULD_WIGGLE_PARTICLES=d.SHOULD_WIGGLE_PARTICLES||!!Math.max(a.wiggle.value,a.wiggle.spread);this.material.needsUpdate=!0},SPE.Group.prototype._applyAttributesToGeometry=function(){"use strict";var a,b,c=this.attributes,d=this.geometry,e=d.attributes;for(var f in c)c.hasOwnProperty(f)&&(a=c[f],b=e[f], -b?b.array=a.typedArray.array:d.addAttribute(f,a.bufferAttribute),a.bufferAttribute.needsUpdate=!0);this.geometry.setDrawRange(0,this.particleCount)},SPE.Group.prototype.addEmitter=function(a){"use strict";if(a instanceof SPE.Emitter==!1)return void console.error("`emitter` argument must be instance of SPE.Emitter. Was provided with:",a);if(this.emitterIDs.indexOf(a.uuid)>-1)return void console.error("Emitter already exists in this group. Will not add again.");if(null!==a.group)return void console.error("Emitter already belongs to another group. Will not add to requested group.");var b=this.attributes,c=this.particleCount,d=c+a.particleCount;this.particleCount=d,null!==this.maxParticleCount&&this.particleCount>this.maxParticleCount&&console.warn("SPE.Group: maxParticleCount exceeded. Requesting",this.particleCount,"particles, can support only",this.maxParticleCount),a._calculatePPSValue(a.maxAge._value+a.maxAge._spread),a._setBufferUpdateRanges(this.attributeKeys), -a._setAttributeOffset(c),a.group=this,a.attributes=this.attributes;for(var e in b)b.hasOwnProperty(e)&&b[e]._createBufferAttribute(null!==this.maxParticleCount?this.maxParticleCount:this.particleCount);for(var f=c;f1)for(var c=0;c=0;--b)c[a[b]].resetUpdateRange()},SPE.Group.prototype._updateBuffers=function(a){"use strict";var b,c,d,e=this.attributeKeys,f=this.attributeCount-1,g=this.attributes,h=a.bufferUpdateRanges;for(f;f>=0;--f)b=e[f],c=h[b],d=g[b],d.setUpdateRange(c.min,c.max),d.flagUpdate()},SPE.Group.prototype.tick=function(a){"use strict";var b,c=this.emitters,d=c.length,e=a||this.fixedTimeStep,f=this.attributeKeys,g=this.attributes;if(this._updateUniforms(e),this._resetBufferRanges(),0!==d||!1!==this._attributesNeedRefresh||!1!==this._attributesNeedDynamicReset){for(var h,b=0;b=0;--b)g[f[b]].resetDynamic();this._attributesNeedDynamicReset=!1}if(!0===this._attributesNeedRefresh){for(b=this.attributeCount-1;b>=0;--b)g[f[b]].forceUpdateAll();this._attributesNeedRefresh=!1,this._attributesNeedDynamicReset=!0}}}, -SPE.Group.prototype.dispose=function(){"use strict";return this.geometry.dispose(),this.material.dispose(),this},SPE.Emitter=function(a){"use strict";var b=SPE.utils,c=b.types,d=SPE.valueOverLifetimeLength;a=b.ensureTypedArg(a,c.OBJECT,{}),a.position=b.ensureTypedArg(a.position,c.OBJECT,{}),a.velocity=b.ensureTypedArg(a.velocity,c.OBJECT,{}),a.acceleration=b.ensureTypedArg(a.acceleration,c.OBJECT,{}),a.radius=b.ensureTypedArg(a.radius,c.OBJECT,{}),a.drag=b.ensureTypedArg(a.drag,c.OBJECT,{}),a.rotation=b.ensureTypedArg(a.rotation,c.OBJECT,{}),a.color=b.ensureTypedArg(a.color,c.OBJECT,{}),a.opacity=b.ensureTypedArg(a.opacity,c.OBJECT,{}),a.size=b.ensureTypedArg(a.size,c.OBJECT,{}),a.angle=b.ensureTypedArg(a.angle,c.OBJECT,{}),a.wiggle=b.ensureTypedArg(a.wiggle,c.OBJECT,{}),a.maxAge=b.ensureTypedArg(a.maxAge,c.OBJECT,{}),a.onParticleSpawn&&console.warn("onParticleSpawn has been removed. Please set properties directly to alter values at runtime."),this.uuid=THREE.Math.generateUUID(), -this.type=b.ensureTypedArg(a.type,c.NUMBER,SPE.distributions.BOX),this.position={_value:b.ensureInstanceOf(a.position.value,THREE.Vector3,new THREE.Vector3),_spread:b.ensureInstanceOf(a.position.spread,THREE.Vector3,new THREE.Vector3),_spreadClamp:b.ensureInstanceOf(a.position.spreadClamp,THREE.Vector3,new THREE.Vector3),_distribution:b.ensureTypedArg(a.position.distribution,c.NUMBER,this.type),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1),_radius:b.ensureTypedArg(a.position.radius,c.NUMBER,10),_radiusScale:b.ensureInstanceOf(a.position.radiusScale,THREE.Vector3,new THREE.Vector3(1,1,1)),_distributionClamp:b.ensureTypedArg(a.position.distributionClamp,c.NUMBER,0)},this.velocity={_value:b.ensureInstanceOf(a.velocity.value,THREE.Vector3,new THREE.Vector3),_spread:b.ensureInstanceOf(a.velocity.spread,THREE.Vector3,new THREE.Vector3),_distribution:b.ensureTypedArg(a.velocity.distribution,c.NUMBER,this.type),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)}, -this.acceleration={_value:b.ensureInstanceOf(a.acceleration.value,THREE.Vector3,new THREE.Vector3),_spread:b.ensureInstanceOf(a.acceleration.spread,THREE.Vector3,new THREE.Vector3),_distribution:b.ensureTypedArg(a.acceleration.distribution,c.NUMBER,this.type),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)},this.drag={_value:b.ensureTypedArg(a.drag.value,c.NUMBER,0),_spread:b.ensureTypedArg(a.drag.spread,c.NUMBER,0),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)},this.wiggle={_value:b.ensureTypedArg(a.wiggle.value,c.NUMBER,0),_spread:b.ensureTypedArg(a.wiggle.spread,c.NUMBER,0)},this.rotation={_axis:b.ensureInstanceOf(a.rotation.axis,THREE.Vector3,new THREE.Vector3(0,1,0)),_axisSpread:b.ensureInstanceOf(a.rotation.axisSpread,THREE.Vector3,new THREE.Vector3),_angle:b.ensureTypedArg(a.rotation.angle,c.NUMBER,0),_angleSpread:b.ensureTypedArg(a.rotation.angleSpread,c.NUMBER,0),_static:b.ensureTypedArg(a.rotation.static,c.BOOLEAN,!1), -_center:b.ensureInstanceOf(a.rotation.center,THREE.Vector3,this.position._value.clone()),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)},this.maxAge={_value:b.ensureTypedArg(a.maxAge.value,c.NUMBER,2),_spread:b.ensureTypedArg(a.maxAge.spread,c.NUMBER,0)},this.color={_value:b.ensureArrayInstanceOf(a.color.value,THREE.Color,new THREE.Color),_spread:b.ensureArrayInstanceOf(a.color.spread,THREE.Vector3,new THREE.Vector3),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)},this.opacity={_value:b.ensureArrayTypedArg(a.opacity.value,c.NUMBER,1),_spread:b.ensureArrayTypedArg(a.opacity.spread,c.NUMBER,0),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)},this.size={_value:b.ensureArrayTypedArg(a.size.value,c.NUMBER,1),_spread:b.ensureArrayTypedArg(a.size.spread,c.NUMBER,0),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)},this.angle={_value:b.ensureArrayTypedArg(a.angle.value,c.NUMBER,0), -_spread:b.ensureArrayTypedArg(a.angle.spread,c.NUMBER,0),_randomise:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)},this.particleCount=b.ensureTypedArg(a.particleCount,c.NUMBER,100),this.duration=b.ensureTypedArg(a.duration,c.NUMBER,null),this.isStatic=b.ensureTypedArg(a.isStatic,c.BOOLEAN,!1),this.activeMultiplier=b.ensureTypedArg(a.activeMultiplier,c.NUMBER,1),this.direction=b.ensureTypedArg(a.direction,c.NUMBER,1),this.alive=b.ensureTypedArg(a.alive,c.BOOLEAN,!0),this.particlesPerSecond=0,this.activationIndex=0,this.attributeOffset=0,this.attributeEnd=0,this.age=0,this.activeParticleCount=0,this.group=null,this.attributes=null,this.paramsArray=null,this.resetFlags={position:b.ensureTypedArg(a.position.randomise,c.BOOLEAN,!1)||b.ensureTypedArg(a.radius.randomise,c.BOOLEAN,!1),velocity:b.ensureTypedArg(a.velocity.randomise,c.BOOLEAN,!1),acceleration:b.ensureTypedArg(a.acceleration.randomise,c.BOOLEAN,!1)||b.ensureTypedArg(a.drag.randomise,c.BOOLEAN,!1), -rotation:b.ensureTypedArg(a.rotation.randomise,c.BOOLEAN,!1),rotationCenter:b.ensureTypedArg(a.rotation.randomise,c.BOOLEAN,!1),size:b.ensureTypedArg(a.size.randomise,c.BOOLEAN,!1),color:b.ensureTypedArg(a.color.randomise,c.BOOLEAN,!1),opacity:b.ensureTypedArg(a.opacity.randomise,c.BOOLEAN,!1),angle:b.ensureTypedArg(a.angle.randomise,c.BOOLEAN,!1)},this.updateFlags={},this.updateCounts={},this.updateMap={maxAge:"params",position:"position",velocity:"velocity",acceleration:"acceleration",drag:"acceleration",wiggle:"params",rotation:"rotation",size:"size",color:"color",opacity:"opacity",angle:"angle"};for(var e in this.updateMap)this.updateMap.hasOwnProperty(e)&&(this.updateCounts[this.updateMap[e]]=0,this.updateFlags[this.updateMap[e]]=!1,this._createGetterSetters(this[e],e));this.bufferUpdateRanges={},this.attributeKeys=null,this.attributeCount=0,b.ensureValueOverLifetimeCompliance(this.color,d,d),b.ensureValueOverLifetimeCompliance(this.opacity,d,d), -b.ensureValueOverLifetimeCompliance(this.size,d,d),b.ensureValueOverLifetimeCompliance(this.angle,d,d)},SPE.Emitter.constructor=SPE.Emitter,SPE.Emitter.prototype._createGetterSetters=function(a,b){"use strict";var c=this;for(var d in a)if(a.hasOwnProperty(d)){var e=d.replace("_","");Object.defineProperty(a,e,{get:function(a){return function(){return this[a]}}(d),set:function(a){return function(d){var e=c.updateMap[b],f=this[a],g=SPE.valueOverLifetimeLength;"_rotationCenter"===a?(c.updateFlags.rotationCenter=!0,c.updateCounts.rotationCenter=0):"_randomise"===a?c.resetFlags[e]=d:(c.updateFlags[e]=!0,c.updateCounts[e]=0),c.group._updateDefines(),this[a]=d,Array.isArray(f)&&SPE.utils.ensureValueOverLifetimeCompliance(c[b],g,g)}}(d)})}},SPE.Emitter.prototype._setBufferUpdateRanges=function(a){"use strict";this.attributeKeys=a,this.attributeCount=a.length;for(var b=this.attributeCount-1;b>=0;--b)this.bufferUpdateRanges[a[b]]={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY}}, -SPE.Emitter.prototype._calculatePPSValue=function(a){"use strict";var b=this.particleCount;this.duration?this.particlesPerSecond=b/(a=0;--h)b=g[h],c=e[b],!0!==d[b]&&!0!==c||(this._assignValue(b,a),this._updateAttributeUpdateRange(b,a),!0===c&&f[b]===this.particleCount?(e[b]=!1,f[b]=0):1==c&&++f[b])},SPE.Emitter.prototype._updateAttributeUpdateRange=function(a,b){"use strict";var c=this.bufferUpdateRanges[a];c.min=Math.min(b,c.min),c.max=Math.max(b,c.max)},SPE.Emitter.prototype._resetBufferRanges=function(){"use strict";var a,b=this.bufferUpdateRanges,c=this.bufferUpdateKeys,d=this.bufferUpdateCount-1;for(d;d>=0;--d)a=c[d],b[a].min=Number.POSITIVE_INFINITY,b[a].max=Number.NEGATIVE_INFINITY},SPE.Emitter.prototype._onRemove=function(){"use strict";this.particlesPerSecond=0,this.attributeOffset=0,this.activationIndex=0,this.activeParticleCount=0, -this.group=null,this.attributes=null,this.paramsArray=null,this.age=0},SPE.Emitter.prototype._decrementParticleCount=function(){"use strict";--this.activeParticleCount},SPE.Emitter.prototype._incrementParticleCount=function(){"use strict";++this.activeParticleCount},SPE.Emitter.prototype._checkParticleAges=function(a,b,c,d){"use strict";for(var e,f,g,h,i=b-1;i>=a;--i)e=4*i,0!==(h=c[e])&&(g=c[e+1],f=c[e+2],1===this.direction?(g+=d)>=f&&(g=0,h=0,this._decrementParticleCount()):(g-=d)<=0&&(g=f,h=0,this._decrementParticleCount()),c[e]=h,c[e+1]=g,this._updateAttributeUpdateRange("params",i))},SPE.Emitter.prototype._activateParticles=function(a,b,c,d){"use strict";for(var e,f,g=this.direction,h=a;hthis.duration)return this.alive=!1,void(this.age=0);var g=1===this.particleCount?f:0|f,h=Math.min(g+e,this.activationEnd),i=h-this.activationIndex|0,j=i>0?a/i:0;this._activateParticles(g,h,d,j),this.activationIndex+=e,this.activationIndex>c&&(this.activationIndex=b),this.age+=a}},SPE.Emitter.prototype.reset=function(a){"use strict";if(this.age=0,this.alive=!1,!0===a){for(var b,c=this.attributeOffset,d=c+this.particleCount,e=this.paramsArray,f=this.attributes.params.bufferAttribute,g=d-1;g>=c;--g)b=4*g,e[b]=0,e[b+1]=0;f.updateRange.offset=0,f.updateRange.count=-1,f.needsUpdate=!0}return this}, -SPE.Emitter.prototype.enable=function(){"use strict";return this.alive=!0,this},SPE.Emitter.prototype.disable=function(){"use strict";return this.alive=!1,this},SPE.Emitter.prototype.remove=function(){"use strict";return null!==this.group?this.group.removeEmitter(this):console.error("Emitter does not belong to a group, cannot remove."),this}; \ No newline at end of file diff --git a/dist/SPE.js b/dist/SPE.js new file mode 100644 index 0000000..a9568c6 --- /dev/null +++ b/dist/SPE.js @@ -0,0 +1,12 @@ +/*! + * /* shader-particle-engine 2.0.0 + * * + * * (c) 2015 Luke Moody (http://www.github.com/squarefeet) + * * Originally based on Lee Stemkoski's original work (https://github.com/stemkoski/stemkoski.github.com/blob/master/Three.js/js/ParticleEngine.js). + * * + * * shader-particle-engine may be freely distributed under the MIT license (See LICENSE at root of this repository.) + * * / + * + */ +var SPE=function(e){var t={};function r(i){if(t[i])return t[i].exports;var a=t[i]={i:i,l:!1,exports:{}};return e[i].call(a.exports,a,a.exports,r),a.l=!0,a.exports}return r.m=e,r.c=t,r.d=function(e,t,i){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:i})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var i=Object.create(null);if(r.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var a in e)r.d(i,a,function(t){return e[t]}.bind(null,a));return i},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=1)}([function(e,t){e.exports=THREE},function(e,t,r){"use strict";r.r(t),r.d(t,"Group",(function(){return x})),r.d(t,"Emitter",(function(){return _})),r.d(t,"distributions",(function(){return y})),r.d(t,"globals",(function(){return u}));var i,a,s=r(0),o="boolean",n="number",l="object",u={valueOverLifetimeLength:4},c={ensureTypedArg:(e,t,r)=>typeof e===t?e:r,ensureArrayTypedArg(e,t,r){if(Array.isArray(e)){for(var i=e.length-1;i>=0;--i)if(typeof e[i]!==t)return r;return e}return this.ensureTypedArg(e,t,r)},ensureInstanceOf:(e,t,r)=>void 0!==t&&e instanceof t?e:r,ensureArrayInstanceOf(e,t,r){if(Array.isArray(e)){for(var i=e.length-1;i>=0;--i)if(void 0!==t&&e[i]instanceof t==!1)return r;return e}return this.ensureInstanceOf(e,t,r)},ensureValueOverLifetimeCompliance(e,t,r){t=t||3,r=r||3,!1===Array.isArray(e._value)&&(e._value=[e._value]),!1===Array.isArray(e._spread)&&(e._spread=[e._spread]);var i=this.clamp(e._value.length,t,r),a=this.clamp(e._spread.length,t,r),s=Math.max(i,a);e._value.length!==s&&(e._value=this.interpolateArray(e._value,s)),e._spread.length!==s&&(e._spread=this.interpolateArray(e._spread,s))},interpolateArray(e,t){for(var r=e.length,i=["function"==typeof e[0].clone?e[0].clone():e[0]],a=(r-1)/(t-1),s=1;sMath.max(t,Math.min(e,r)),zeroToEpsilon(e,t){var r=e;return r=t?1e-5*Math.random()*10:1e-5,e<0&&e>-1e-5&&(r=-r),r},lerpTypeAgnostic(e,t,r){var i;return typeof e===n&&typeof t===n?e+(t-e)*r:e instanceof s.Vector2&&t instanceof s.Vector2?((i=e.clone()).x=this.lerp(e.x,t.x,r),i.y=this.lerp(e.y,t.y,r),i):e instanceof s.Vector3&&t instanceof s.Vector3?((i=e.clone()).x=this.lerp(e.x,t.x,r),i.y=this.lerp(e.y,t.y,r),i.z=this.lerp(e.z,t.z,r),i):e instanceof s.Vector4&&t instanceof s.Vector4?((i=e.clone()).x=this.lerp(e.x,t.x,r),i.y=this.lerp(e.y,t.y,r),i.z=this.lerp(e.z,t.z,r),i.w=this.lerp(e.w,t.w,r),i):e instanceof s.Color&&t instanceof s.Color?((i=e.clone()).r=this.lerp(e.r,t.r,r),i.g=this.lerp(e.g,t.g,r),i.b=this.lerp(e.b,t.b,r),i):void console.warn("Invalid argument types, or argument types do not match:",e,t)},lerp:(e,t,r)=>e+(t-e)*r,roundToNearestMultiple(e,t){var r;return 0===t||0===(r=Math.abs(e)%t)?e:e<0?-(Math.abs(e)-r):e+t-r},arrayValuesAreEqual(e){for(var t=0;te+t*(Math.random()-.5),randomVector3(e,t,r,i,a){var s=r.x+(Math.random()*i.x-.5*i.x),o=r.y+(Math.random()*i.y-.5*i.y),n=r.z+(Math.random()*i.z-.5*i.z);a&&(s=.5*-a.x+this.roundToNearestMultiple(s,a.x),o=.5*-a.y+this.roundToNearestMultiple(o,a.y),n=.5*-a.z+this.roundToNearestMultiple(n,a.z)),e.typedArray.setVec3Components(t,s,o,n)},randomColor(e,t,r,i){var a=r.r+Math.random()*i.x,s=r.g+Math.random()*i.y,o=r.b+Math.random()*i.z;a=this.clamp(a,0,1),s=this.clamp(s,0,1),o=this.clamp(o,0,1),e.typedArray.setVec3Components(t,a,s,o)},randomColorAsHex:(a=new s.Color,function(e,t,r,i){for(var s=r.length,o=[],n=0;nr?this.grow(i):void console.info("TypedArray is already of size:",i+".","Will not resize.")}shrink(e){return this.array=this.array.subarray(0,e),this.size=e,this}grow(e){const t=new this.TypedArrayConstructor(e);return t.set(this.array),this.array=t,this.size=e,this}splice(e,t){const r=e*this.componentSize,i=t*this.componentSize,a=[],s=this.array,o=s.length;for(let e=0;e=i)&&a.push(s[e]);return this.setFromArray(0,a),this}setFromArray(e,t){const r=e+t.length;return r>this.array.length?this.grow(r):r=81&&(this.bufferAttribute.count=this.bufferAttribute.array.length/this.bufferAttribute.itemSize),void(this.bufferAttribute.needsUpdate=!0);this.bufferAttribute=new s.BufferAttribute(this.typedArray.array,this.componentSize),this.bufferAttribute.usage=this.dynamicBuffer?s.DynamicDrawUsage:s.StaticDrawUsage}getLength(){return null===this.typedArray?0:this.typedArray.array.length}}var m={defines:["#define PACKED_COLOR_SIZE 256.0","#define PACKED_COLOR_DIVISOR 255.0"].join("\n"),uniforms:["uniform float deltaTime;","uniform float runTime;","uniform sampler2D tex;","uniform vec4 textureAnimation;","uniform float scale;"].join("\n"),attributes:["attribute vec4 acceleration;","attribute vec3 velocity;","attribute vec4 rotation;","attribute vec3 rotationCenter;","attribute vec4 params;","attribute vec4 size;","attribute vec4 angle;","attribute vec4 color;","attribute vec4 opacity;"].join("\n"),varyings:["varying vec4 vColor;","#ifdef SHOULD_ROTATE_TEXTURE"," varying float vAngle;","#endif","#ifdef SHOULD_CALCULATE_SPRITE"," varying vec4 vSpriteSheet;","#endif"].join("\n"),branchAvoidanceFunctions:["float when_gt(float x, float y) {"," return max(sign(x - y), 0.0);","}","float when_lt(float x, float y) {"," return min( max(1.0 - sign(x - y), 0.0), 1.0 );","}","float when_eq( float x, float y ) {"," return 1.0 - abs( sign( x - y ) );","}","float when_ge(float x, float y) {"," return 1.0 - when_lt(x, y);","}","float when_le(float x, float y) {"," return 1.0 - when_gt(x, y);","}","float and(float a, float b) {"," return a * b;","}","float or(float a, float b) {"," return min(a + b, 1.0);","}"].join("\n"),unpackColor:["vec3 unpackColor( in float hex ) {"," vec3 c = vec3( 0.0 );"," float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float b = mod( hex, PACKED_COLOR_SIZE );"," c.r = r / PACKED_COLOR_DIVISOR;"," c.g = g / PACKED_COLOR_DIVISOR;"," c.b = b / PACKED_COLOR_DIVISOR;"," return c;","}"].join("\n"),unpackRotationAxis:["vec3 unpackRotationAxis( in float hex ) {"," vec3 c = vec3( 0.0 );"," float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );"," float b = mod( hex, PACKED_COLOR_SIZE );"," c.r = r / PACKED_COLOR_DIVISOR;"," c.g = g / PACKED_COLOR_DIVISOR;"," c.b = b / PACKED_COLOR_DIVISOR;"," c *= vec3( 2.0 );"," c -= vec3( 1.0 );"," return c;","}"].join("\n"),floatOverLifetime:["float getFloatOverLifetime( in float positionInTime, in vec4 attr ) {"," highp float value = 0.0;"," float deltaAge = positionInTime * float( VALUE_OVER_LIFETIME_LENGTH - 1 );"," float fIndex = 0.0;"," float shouldApplyValue = 0.0;"," value += attr[ 0 ] * when_eq( deltaAge, 0.0 );",""," for( int i = 0; i < VALUE_OVER_LIFETIME_LENGTH - 1; ++i ) {"," fIndex = float( i );"," shouldApplyValue = and( when_gt( deltaAge, fIndex ), when_le( deltaAge, fIndex + 1.0 ) );"," value += shouldApplyValue * mix( attr[ i ], attr[ i + 1 ], deltaAge - fIndex );"," }",""," return value;","}"].join("\n"),colorOverLifetime:["vec3 getColorOverLifetime( in float positionInTime, in vec3 color1, in vec3 color2, in vec3 color3, in vec3 color4 ) {"," vec3 value = vec3( 0.0 );"," value.x = getFloatOverLifetime( positionInTime, vec4( color1.x, color2.x, color3.x, color4.x ) );"," value.y = getFloatOverLifetime( positionInTime, vec4( color1.y, color2.y, color3.y, color4.y ) );"," value.z = getFloatOverLifetime( positionInTime, vec4( color1.z, color2.z, color3.z, color4.z ) );"," return value;","}"].join("\n"),paramFetchingFunctions:["float getAlive() {"," return params.x;","}","float getAge() {"," return params.y;","}","float getMaxAge() {"," return params.z;","}","float getWiggle() {"," return params.w;","}"].join("\n"),forceFetchingFunctions:["vec4 getPosition( in float age ) {"," return modelViewMatrix * vec4( position, 1.0 );","}","vec3 getVelocity( in float age ) {"," return velocity * age;","}","vec3 getAcceleration( in float age ) {"," return acceleration.xyz * age;","}"].join("\n"),rotationFunctions:["#ifdef SHOULD_ROTATE_PARTICLES"," mat4 getRotationMatrix( in vec3 axis, in float angle) {"," axis = normalize(axis);"," float s = sin(angle);"," float c = cos(angle);"," float oc = 1.0 - c;",""," return mat4(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 0.0,"," oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 0.0,"," oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c, 0.0,"," 0.0, 0.0, 0.0, 1.0);"," }",""," vec3 getRotation( in vec3 pos, in float positionInTime ) {"," if( rotation.y == 0.0 ) {"," return pos;"," }",""," vec3 axis = unpackRotationAxis( rotation.x );"," vec3 center = rotationCenter;"," vec3 translated;"," mat4 rotationMatrix;"," float angle = 0.0;"," angle += when_eq( rotation.z, 0.0 ) * rotation.y;"," angle += when_gt( rotation.z, 0.0 ) * mix( 0.0, rotation.y, positionInTime );"," translated = rotationCenter - pos;"," rotationMatrix = getRotationMatrix( axis, angle );"," return center - vec3( rotationMatrix * vec4( translated, 0.0 ) );"," }","#endif"].join("\n"),rotateTexture:[" vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );",""," #ifdef SHOULD_ROTATE_TEXTURE"," float x = gl_PointCoord.x - 0.5;"," float y = 1.0 - gl_PointCoord.y - 0.5;"," float c = cos( -vAngle );"," float s = sin( -vAngle );"," vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );"," #endif",""," #ifdef SHOULD_CALCULATE_SPRITE"," float framesX = vSpriteSheet.x;"," float framesY = vSpriteSheet.y;"," float columnNorm = vSpriteSheet.z;"," float rowNorm = vSpriteSheet.w;"," vUv.x = gl_PointCoord.x * framesX + columnNorm;"," vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);"," #endif",""," vec4 rotatedTexture = texture2D( tex, vUv );"].join("\n")},g={vertex:[m.defines,m.uniforms,m.attributes,m.varyings,s.ShaderChunk.common,s.ShaderChunk.logdepthbuf_pars_vertex,s.ShaderChunk.fog_pars_vertex,m.branchAvoidanceFunctions,m.unpackColor,m.unpackRotationAxis,m.floatOverLifetime,m.colorOverLifetime,m.paramFetchingFunctions,m.forceFetchingFunctions,m.rotationFunctions,"void main() {"," highp float age = getAge();"," highp float alive = getAlive();"," highp float maxAge = getMaxAge();"," highp float positionInTime = (age / maxAge);"," highp float isAlive = when_gt( alive, 0.0 );"," #ifdef SHOULD_WIGGLE_PARTICLES"," float wiggleAmount = positionInTime * getWiggle();"," float wiggleSin = isAlive * sin( wiggleAmount );"," float wiggleCos = isAlive * cos( wiggleAmount );"," #endif"," vec3 vel = getVelocity( age );"," vec3 accel = getAcceleration( age );"," vec3 force = vec3( 0.0 );"," vec3 pos = vec3( position );"," float drag = 1.0 - (positionInTime * 0.5) * acceleration.w;"," force += vel;"," force *= drag;"," force += accel * age;"," pos += force;"," #ifdef SHOULD_WIGGLE_PARTICLES"," pos.x += wiggleSin;"," pos.y += wiggleCos;"," pos.z += wiggleSin;"," #endif"," #ifdef SHOULD_ROTATE_PARTICLES"," pos = getRotation( pos, positionInTime );"," #endif"," vec4 mvPosition = modelViewMatrix * vec4( pos, 1.0 );"," highp float pointSize = getFloatOverLifetime( positionInTime, size ) * isAlive;"," #ifdef HAS_PERSPECTIVE"," float perspective = scale / length( mvPosition.xyz );"," #else"," float perspective = 1.0;"," #endif"," float pointSizePerspective = pointSize * perspective;"," #ifdef COLORIZE"," vec3 c = isAlive * getColorOverLifetime("," positionInTime,"," unpackColor( color.x ),"," unpackColor( color.y ),"," unpackColor( color.z ),"," unpackColor( color.w )"," );"," #else"," vec3 c = vec3(1.0);"," #endif"," float o = isAlive * getFloatOverLifetime( positionInTime, opacity );"," vColor = vec4( c, o );"," #ifdef SHOULD_ROTATE_TEXTURE"," vAngle = isAlive * getFloatOverLifetime( positionInTime, angle );"," #endif"," #ifdef SHOULD_CALCULATE_SPRITE"," float framesX = textureAnimation.x;"," float framesY = textureAnimation.y;"," float loopCount = textureAnimation.w;"," float totalFrames = textureAnimation.z;"," float frameNumber = mod( (positionInTime * loopCount) * totalFrames, totalFrames );"," float column = floor(mod( frameNumber, framesX ));"," float row = floor( (frameNumber - column) / framesX );"," float columnNorm = column / framesX;"," float rowNorm = row / framesY;"," vSpriteSheet.x = 1.0 / framesX;"," vSpriteSheet.y = 1.0 / framesY;"," vSpriteSheet.z = columnNorm;"," vSpriteSheet.w = rowNorm;"," #endif"," gl_PointSize = pointSizePerspective;"," gl_Position = projectionMatrix * mvPosition;",s.ShaderChunk.logdepthbuf_vertex,s.ShaderChunk.fog_vertex,"}"].join("\n"),fragment:[m.uniforms,s.ShaderChunk.common,s.ShaderChunk.fog_pars_fragment,s.ShaderChunk.logdepthbuf_pars_fragment,m.varyings,m.branchAvoidanceFunctions,"void main() {"," vec3 outgoingLight = vColor.xyz;"," "," #ifdef ALPHATEST"," if ( vColor.w < float(ALPHATEST) ) discard;"," #endif",m.rotateTexture,s.ShaderChunk.logdepthbuf_fragment," outgoingLight = vColor.xyz * rotatedTexture.xyz;"," gl_FragColor = vec4( outgoingLight.xyz, rotatedTexture.w * vColor.w );",s.ShaderChunk.fog_fragment,"}"].join("\n")},y={BOX:1,SPHERE:2,DISC:3,LINE:4};const v=Object.prototype.hasOwnProperty;class _{constructor(e){const t=c.ensureTypedArg(e,l,{});t.position=c.ensureTypedArg(t.position,l,{}),t.velocity=c.ensureTypedArg(t.velocity,l,{}),t.acceleration=c.ensureTypedArg(t.acceleration,l,{}),t.radius=c.ensureTypedArg(t.radius,l,{}),t.drag=c.ensureTypedArg(t.drag,l,{}),t.rotation=c.ensureTypedArg(t.rotation,l,{}),t.color=c.ensureTypedArg(t.color,l,{}),t.opacity=c.ensureTypedArg(t.opacity,l,{}),t.size=c.ensureTypedArg(t.size,l,{}),t.angle=c.ensureTypedArg(t.angle,l,{}),t.wiggle=c.ensureTypedArg(t.wiggle,l,{}),t.maxAge=c.ensureTypedArg(t.maxAge,l,{}),t.onParticleSpawn&&console.warn("onParticleSpawn has been removed. Please set properties directly to alter values at runtime."),this.uuid=s.Math.generateUUID(),this.type=c.ensureTypedArg(t.type,n,y.BOX),this.position={_value:c.ensureInstanceOf(t.position.value,s.Vector3,new s.Vector3),_spread:c.ensureInstanceOf(t.position.spread,s.Vector3,new s.Vector3),_spreadClamp:c.ensureInstanceOf(t.position.spreadClamp,s.Vector3,new s.Vector3),_distribution:c.ensureTypedArg(t.position.distribution,n,this.type),_randomise:c.ensureTypedArg(t.position.randomise,o,!1),_radius:c.ensureTypedArg(t.position.radius,n,10),_radiusScale:c.ensureInstanceOf(t.position.radiusScale,s.Vector3,new s.Vector3(1,1,1)),_distributionClamp:c.ensureTypedArg(t.position.distributionClamp,n,0)},this.velocity={_value:c.ensureInstanceOf(t.velocity.value,s.Vector3,new s.Vector3),_spread:c.ensureInstanceOf(t.velocity.spread,s.Vector3,new s.Vector3),_distribution:c.ensureTypedArg(t.velocity.distribution,n,this.type),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.acceleration={_value:c.ensureInstanceOf(t.acceleration.value,s.Vector3,new s.Vector3),_spread:c.ensureInstanceOf(t.acceleration.spread,s.Vector3,new s.Vector3),_distribution:c.ensureTypedArg(t.acceleration.distribution,n,this.type),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.drag={_value:c.ensureTypedArg(t.drag.value,n,0),_spread:c.ensureTypedArg(t.drag.spread,n,0),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.wiggle={_value:c.ensureTypedArg(t.wiggle.value,n,0),_spread:c.ensureTypedArg(t.wiggle.spread,n,0)},this.rotation={_axis:c.ensureInstanceOf(t.rotation.axis,s.Vector3,new s.Vector3(0,1,0)),_axisSpread:c.ensureInstanceOf(t.rotation.axisSpread,s.Vector3,new s.Vector3),_angle:c.ensureTypedArg(t.rotation.angle,n,0),_angleSpread:c.ensureTypedArg(t.rotation.angleSpread,n,0),_static:c.ensureTypedArg(t.rotation.static,o,!1),_center:c.ensureInstanceOf(t.rotation.center,s.Vector3,this.position._value.clone()),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.maxAge={_value:c.ensureTypedArg(t.maxAge.value,n,2),_spread:c.ensureTypedArg(t.maxAge.spread,n,0)},this.color={_value:c.ensureArrayInstanceOf(t.color.value,s.Color,new s.Color),_spread:c.ensureArrayInstanceOf(t.color.spread,s.Vector3,new s.Vector3),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.opacity={_value:c.ensureArrayTypedArg(t.opacity.value,n,1),_spread:c.ensureArrayTypedArg(t.opacity.spread,n,0),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.size={_value:c.ensureArrayTypedArg(t.size.value,n,1),_spread:c.ensureArrayTypedArg(t.size.spread,n,0),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.angle={_value:c.ensureArrayTypedArg(t.angle.value,n,0),_spread:c.ensureArrayTypedArg(t.angle.spread,n,0),_randomise:c.ensureTypedArg(t.position.randomise,o,!1)},this.particleCount=c.ensureTypedArg(t.particleCount,n,100),this.duration=c.ensureTypedArg(t.duration,n,null),this.isStatic=c.ensureTypedArg(t.isStatic,o,!1),this.activeMultiplier=c.ensureTypedArg(t.activeMultiplier,n,1),this.direction=c.ensureTypedArg(t.direction,n,1),this.alive=c.ensureTypedArg(t.alive,o,!0),this.particlesPerSecond=0,this.activationIndex=0,this.attributeOffset=0,this.attributeEnd=0,this.age=0,this.activeParticleCount=0,this.group=null,this.attributes=null,this.paramsArray=null,this.resetFlags={position:c.ensureTypedArg(t.position.randomise,o,!1)||c.ensureTypedArg(t.radius.randomise,o,!1),velocity:c.ensureTypedArg(t.velocity.randomise,o,!1),acceleration:c.ensureTypedArg(t.acceleration.randomise,o,!1)||c.ensureTypedArg(t.drag.randomise,o,!1),rotation:c.ensureTypedArg(t.rotation.randomise,o,!1),rotationCenter:c.ensureTypedArg(t.rotation.randomise,o,!1),size:c.ensureTypedArg(t.size.randomise,o,!1),color:c.ensureTypedArg(t.color.randomise,o,!1),opacity:c.ensureTypedArg(t.opacity.randomise,o,!1),angle:c.ensureTypedArg(t.angle.randomise,o,!1)},this.updateFlags={},this.updateCounts={},this.updateMap={maxAge:"params",position:"position",velocity:"velocity",acceleration:"acceleration",drag:"acceleration",wiggle:"params",rotation:"rotation",size:"size",color:"color",opacity:"opacity",angle:"angle"};for(const e in this.updateMap)v.call(this.updateMap,e)&&(this.updateCounts[this.updateMap[e]]=0,this.updateFlags[this.updateMap[e]]=!1,this._createGetterSetters(this[e],e));this.bufferUpdateRanges={},this.attributeKeys=null,this.attributeCount=0,c.ensureValueOverLifetimeCompliance(this.color,u.valueOverLifetimeLength,u.valueOverLifetimeLength),c.ensureValueOverLifetimeCompliance(this.opacity,u.valueOverLifetimeLength,u.valueOverLifetimeLength),c.ensureValueOverLifetimeCompliance(this.size,u.valueOverLifetimeLength,u.valueOverLifetimeLength),c.ensureValueOverLifetimeCompliance(this.angle,u.valueOverLifetimeLength,u.valueOverLifetimeLength)}_createGetterSetters(e,t){const r=this;for(const i in e)if(v.call(e,i)){const a=i.replace("_","");Object.defineProperty(e,a,{get:function(e){return function(){return this[e]}}(i),set:function(e){return function(i){const a=r.updateMap[t],s=this[e],o=u.valueOverLifetimeLength;"_rotationCenter"===e?(r.updateFlags.rotationCenter=!0,r.updateCounts.rotationCenter=0):"_randomise"===e?r.resetFlags[a]=i:(r.updateFlags[a]=!0,r.updateCounts[a]=0),r.group._updateDefines(),this[e]=i,Array.isArray(s)&&c.ensureValueOverLifetimeCompliance(r[t],o,o)}}(i)})}}_setBufferUpdateRanges(e){this.attributeKeys=e,this.attributeCount=e.length;for(let t=this.attributeCount-1;t>=0;--t)this.bufferUpdateRanges[e[t]]={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY}}_calculatePPSValue(e){const t=this.particleCount;this.duration?this.particlesPerSecond=t/(e=0;--n)s=a[n],o=r[s],!0!==t[s]&&!0!==o||(this._assignValue(s,e),this._updateAttributeUpdateRange(s,e),!0===o&&i[s]===this.particleCount?(r[s]=!1,i[s]=0):1==o&&++i[s])}_updateAttributeUpdateRange(e,t){var r=this.bufferUpdateRanges[e];r.min=Math.min(t,r.min),r.max=Math.max(t,r.max)}_resetBufferRanges(){const e=this.bufferUpdateRanges,t=this.bufferUpdateKeys;let r,i=this.bufferUpdateCount-1;for(;i>=0;--i)r=t[i],e[r].min=Number.POSITIVE_INFINITY,e[r].max=Number.NEGATIVE_INFINITY}_onRemove(){this.particlesPerSecond=0,this.attributeOffset=0,this.activationIndex=0,this.activeParticleCount=0,this.group=null,this.attributes=null,this.paramsArray=null,this.age=0}_decrementParticleCount(){--this.activeParticleCount}_incrementParticleCount(){++this.activeParticleCount}_checkParticleAges(e,t,r,i){for(let a,s,o,n,l=t-1;l>=e;--l)a=4*l,n=r[a],0!==n&&(o=r[a+1],s=r[a+2],1===this.direction?(o+=i,o>=s&&(o=0,n=0,this._decrementParticleCount())):(o-=i,o<=0&&(o=s,n=0,this._decrementParticleCount())),r[a]=n,r[a+1]=o,this._updateAttributeUpdateRange("params",l))}_activateParticles(e,t,r,i){const a=this.direction;for(let s,o,n=e;nthis.duration)return this.alive=!1,void(this.age=0);const o=1===this.particleCount?s:0|s,n=Math.min(o+a,this.activationEnd),l=n-this.activationIndex|0,u=l>0?e/l:0;this._activateParticles(o,n,i,u),this.activationIndex+=a,this.activationIndex>r&&(this.activationIndex=t),this.age+=e}reset(e){if(this.age=0,this.alive=!1,!0===e){const e=this.attributeOffset,t=e+this.particleCount,r=this.paramsArray,i=this.attributes.params.bufferAttribute;for(let i,a=t-1;a>=e;--a)i=4*a,r[i]=0,r[i+1]=0;i.updateRange.offset=0,i.updateRange.count=-1,i.needsUpdate=!0}return this}enable(){return this.alive=!0,this}disable(){return this.alive=!1,this}remove(){return null!==this.group?this.group.removeEmitter(this):console.error("Emitter does not belong to a group, cannot remove."),this}}const A=Object.prototype.hasOwnProperty;class x{constructor(e){const t=c.ensureTypedArg(e,l,{});t.texture=c.ensureTypedArg(t.texture,l,{}),this.uuid=s.Math.generateUUID(),this.fixedTimeStep=c.ensureTypedArg(t.fixedTimeStep,n,.016),this.texture=c.ensureInstanceOf(t.texture.value,s.Texture,null),this.textureFrames=c.ensureInstanceOf(t.texture.frames,s.Vector2,new s.Vector2(1,1)),this.textureFrameCount=c.ensureTypedArg(t.texture.frameCount,n,this.textureFrames.x*this.textureFrames.y),this.textureLoop=c.ensureTypedArg(t.texture.loop,n,1),this.textureFrames.max(new s.Vector2(1,1)),this.hasPerspective=c.ensureTypedArg(t.hasPerspective,o,!0),this.colorize=c.ensureTypedArg(t.colorize,o,!0),this.maxParticleCount=c.ensureTypedArg(t.maxParticleCount,n,null),this.blending=c.ensureTypedArg(t.blending,n,s.AdditiveBlending),this.transparent=c.ensureTypedArg(t.transparent,o,!0),this.alphaTest=parseFloat(c.ensureTypedArg(t.alphaTest,n,0)),this.depthWrite=c.ensureTypedArg(t.depthWrite,o,!1),this.depthTest=c.ensureTypedArg(t.depthTest,o,!0),this.fog=c.ensureTypedArg(t.fog,o,!0),this.scale=c.ensureTypedArg(t.scale,n,300),this.emitters=[],this.emitterIDs=[],this._pool=[],this._poolCreationSettings=null,this._createNewWhenPoolEmpty=0,this._attributesNeedRefresh=!1,this._attributesNeedDynamicReset=!1,this.particleCount=0,this.uniforms={tex:{type:"t",value:this.texture},textureAnimation:{type:"v4",value:new s.Vector4(this.textureFrames.x,this.textureFrames.y,this.textureFrameCount,Math.max(Math.abs(this.textureLoop),1))},fogColor:{type:"c",value:this.fog?new s.Color:null},fogNear:{type:"f",value:10},fogFar:{type:"f",value:200},fogDensity:{type:"f",value:.5},deltaTime:{type:"f",value:0},runTime:{type:"f",value:0},scale:{type:"f",value:this.scale}},this.defines={HAS_PERSPECTIVE:this.hasPerspective,COLORIZE:this.colorize,VALUE_OVER_LIFETIME_LENGTH:u.valueOverLifetimeLength,SHOULD_ROTATE_TEXTURE:!1,SHOULD_ROTATE_PARTICLES:!1,SHOULD_WIGGLE_PARTICLES:!1,SHOULD_CALCULATE_SPRITE:this.textureFrames.x>1||this.textureFrames.y>1},this.attributes={position:new f("v3",!0),acceleration:new f("v4",!0),velocity:new f("v3",!0),rotation:new f("v4",!0),rotationCenter:new f("v3",!0),params:new f("v4",!0),size:new f("v4",!0),angle:new f("v4",!0),color:new f("v4",!0),opacity:new f("v4",!0)},this.attributeKeys=Object.keys(this.attributes),this.attributeCount=this.attributeKeys.length,this.material=new s.ShaderMaterial({uniforms:this.uniforms,vertexShader:g.vertex,fragmentShader:g.fragment,blending:this.blending,transparent:this.transparent,alphaTest:this.alphaTest,depthWrite:this.depthWrite,depthTest:this.depthTest,defines:this.defines,fog:this.fog}),this.geometry=new s.BufferGeometry,this.mesh=new s.Points(this.geometry,this.material),null===this.maxParticleCount&&console.warn("SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.")}_updateDefines(){const e=this.emitters,t=this.defines;let r,i=e.length-1;for(;i>=0;--i)r=e[i],t.SHOULD_CALCULATE_SPRITE||(t.SHOULD_ROTATE_TEXTURE=t.SHOULD_ROTATE_TEXTURE||!!Math.max(Math.max.apply(null,r.angle.value),Math.max.apply(null,r.angle.spread))),t.SHOULD_ROTATE_PARTICLES=t.SHOULD_ROTATE_PARTICLES||!!Math.max(r.rotation.angle,r.rotation.angleSpread),t.SHOULD_WIGGLE_PARTICLES=t.SHOULD_WIGGLE_PARTICLES||!!Math.max(r.wiggle.value,r.wiggle.spread);this.material.needsUpdate=!0}_applyAttributesToGeometry(){const e=this.attributes,t=this.geometry,r=t.attributes;let i,a;for(const s in e)A.call(e,s)&&(i=e[s],a=r[s],a?a.array=i.typedArray.array:t.addAttribute(s,i.bufferAttribute),i.bufferAttribute.needsUpdate=!0);this.geometry.setDrawRange(0,this.particleCount)}addEmitter(e){if(e instanceof _==!1)return void console.error("`emitter` argument must be instance of Emitter. Was provided with:",e);if(this.emitterIDs.indexOf(e.uuid)>-1)return void console.error("Emitter already exists in this group. Will not add again.");if(null!==e.group)return void console.error("Emitter already belongs to another group. Will not add to requested group.");const t=this.attributes,r=this.particleCount,i=r+e.particleCount;this.particleCount=i,null!==this.maxParticleCount&&this.particleCount>this.maxParticleCount&&console.warn("SPE.Group: maxParticleCount exceeded. Requesting",this.particleCount,"particles, can support only",this.maxParticleCount),e._calculatePPSValue(e.maxAge._value+e.maxAge._spread),e._setBufferUpdateRanges(this.attributeKeys),e._setAttributeOffset(r),e.group=this,e.attributes=this.attributes;for(const e in t)A.call(t,e)&&t[e]._createBufferAttribute(null!==this.maxParticleCount?this.maxParticleCount:this.particleCount);for(let t=r;t{t.disable(),this.releaseIntoPool(t)},1e3*Math.max(t.duration,t.maxAge.value+t.maxAge.spread)),this;console.log("Group pool ran out.")}triggerPoolEmitter(e,t){if("number"==typeof e&&e>1)for(let r=0;r=0;--r)t[e[r]].resetUpdateRange()}_updateBuffers(e){const t=this.attributeKeys,r=this.attributes,i=e.bufferUpdateRanges;let a,s,o;for(let e=this.attributeCount-1;e>=0;--e)a=t[e],s=i[a],o=r[a],o.setUpdateRange(s.min,s.max),o.flagUpdate()}tick(e){const t=this.emitters,r=t.length,i=e||this.fixedTimeStep,a=this.attributeKeys,s=this.attributes;if(this._updateUniforms(i),this._resetBufferRanges(),0!==r||!1!==this._attributesNeedRefresh||!1!==this._attributesNeedDynamicReset){for(let e,a=0;a=0;--e)s[a[e]].resetDynamic();this._attributesNeedDynamicReset=!1}if(!0===this._attributesNeedRefresh){for(let e=this.attributeCount-1;e>=0;--e)s[a[e]].forceUpdateAll();this._attributesNeedRefresh=!1,this._attributesNeedDynamicReset=!0}}}dispose(){return this.geometry.dispose(),this.material.dispose(),this}}}]); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://SPE/webpack/bootstrap","webpack://SPE/external \"THREE\"","webpack://SPE/./src/core/utils.js","webpack://SPE/./src/constants/valueTypes.js","webpack://SPE/./src/constants/globals.js","webpack://SPE/./src/helpers/TypedArrayHelper.js","webpack://SPE/./src/constants/typeSizeMap.js","webpack://SPE/./src/helpers/ShaderAttribute.js","webpack://SPE/./src/shaders/shaderChunks.js","webpack://SPE/./src/shaders/shaders.js","webpack://SPE/./src/constants/distributions.js","webpack://SPE/./src/core/Emitter.js","webpack://SPE/./src/core/Group.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","THREE","v","workingColor","valueOverLifetimeLength","ensureTypedArg","arg","type","defaultValue","Array","isArray","length","this","ensureInstanceOf","instance","undefined","minLength","maxLength","_value","_spread","valueLength","clamp","spreadLength","desiredLength","Math","max","interpolateArray","srcArray","newLength","sourceLength","newArray","clone","factor","f","before","floor","after","ceil","delta","lerpTypeAgnostic","push","min","randomise","result","random","start","end","out","valueTypes","x","lerp","y","z","w","g","b","console","warn","multiple","remainder","abs","array","randomFloat","base","spread","attribute","index","spreadClamp","roundToNearestMultiple","typedArray","setVec3Components","randomColorAsHex","numItems","colors","spreadVector","copy","getHex","setVec4Components","pos","radius","radiusSpread","radiusScale","radiusSpreadClamp","distributionClamp","depth","sqrt","rand","round","cos","sin","seed","randomDirectionVector3OnSphere","posX","posY","posZ","emitterPosition","speed","speedSpread","normalize","multiplyScalar","randomDirectionVector3OnDisc","getPackedRotationAxis","vSpread","addOne","axis","axisSpread","add","setRGB","TypedArrayHelper","TypedArrayConstructor","size","componentSize","indexOffset","Float32Array","noComponentMultiply","currentArraySize","shrink","grow","info","subarray","set","_start","_end","data","setFromArray","newSize","vec2","setVec2Components","vec3","vec4","mat3","elements","mat4","color","numericValue","v2","v3","v4","m3","m4","HAS_OWN","dynamicBuffer","arrayType","typeSizeMap","bufferAttribute","updateMin","updateMax","attr","range","updateRange","offset","count","needsUpdate","usage","splice","forceUpdateAll","setSize","_ensureTypedArray","parseFloat","itemSize","defines","join","uniforms","attributes","varyings","branchAvoidanceFunctions","unpackColor","unpackRotationAxis","floatOverLifetime","colorOverLifetime","paramFetchingFunctions","forceFetchingFunctions","rotationFunctions","rotateTexture","vertex","shaderChunks","common","logdepthbuf_pars_vertex","fog_pars_vertex","logdepthbuf_vertex","fog_vertex","fragment","fog_pars_fragment","logdepthbuf_pars_fragment","logdepthbuf_fragment","fog_fragment","BOX","SPHERE","DISC","LINE","opts","options","utils","position","velocity","acceleration","drag","rotation","opacity","angle","wiggle","maxAge","onParticleSpawn","uuid","generateUUID","distributions","_spreadClamp","_distribution","distribution","_randomise","_radius","_radiusScale","_distributionClamp","_axis","_axisSpread","_angle","_angleSpread","angleSpread","_static","static","_center","center","ensureArrayInstanceOf","ensureArrayTypedArg","particleCount","duration","isStatic","activeMultiplier","direction","alive","particlesPerSecond","activationIndex","attributeOffset","attributeEnd","age","activeParticleCount","group","paramsArray","resetFlags","rotationCenter","updateFlags","updateCounts","updateMap","_createGetterSetters","bufferUpdateRanges","attributeKeys","attributeCount","ensureValueOverLifetimeCompliance","globals","propObj","propName","self","replace","prop","mapName","prevValue","_updateDefines","keys","Number","POSITIVE_INFINITY","NEGATIVE_INFINITY","groupMaxAge","startIndex","activationEnd","_assignPositionValue","_assignForceValue","_assignAbsLifetimeValue","_assignAngleValue","_assignParamsValue","_assignRotationValue","_assignColorValue","randomVector3","randomVector3OnSphere","randomVector3OnDisc","randomVector3OnLine","attrName","positionX","positionY","positionZ","arrayValuesAreEqual","params","setVec3","updateFlag","_assignValue","_updateAttributeUpdateRange","ranges","bufferUpdateKeys","bufferUpdateCount","dt","_decrementParticleCount","activationStart","dtPerParticle","dtValue","_incrementParticleCount","_resetParticle","ppsDt","_resetBufferRanges","_checkParticleAges","activationCount","_activateParticles","force","removeEmitter","error","texture","fixedTimeStep","textureFrames","frames","textureFrameCount","frameCount","textureLoop","loop","hasPerspective","colorize","maxParticleCount","blending","transparent","alphaTest","depthWrite","depthTest","fog","scale","emitters","emitterIDs","_pool","_poolCreationSettings","_createNewWhenPoolEmpty","_attributesNeedRefresh","_attributesNeedDynamicReset","tex","textureAnimation","fogColor","fogNear","fogFar","fogDensity","deltaTime","runTime","HAS_PERSPECTIVE","COLORIZE","VALUE_OVER_LIFETIME_LENGTH","SHOULD_ROTATE_TEXTURE","SHOULD_ROTATE_PARTICLES","SHOULD_WIGGLE_PARTICLES","SHOULD_CALCULATE_SPRITE","material","vertexShader","shaders","fragmentShader","geometry","mesh","emitter","apply","geometryAttributes","geometryAttribute","addAttribute","setDrawRange","indexOf","_calculatePPSValue","_setBufferUpdateRanges","_setAttributeOffset","_createBufferAttribute","_applyAttributesToGeometry","emitterIndex","_onRemove","pool","createNew","pop","addEmitter","reset","unshift","numEmitters","emitterOptions","args","releaseIntoPool","getFromPool","enable","setTimeout","disable","log","_triggerSingleEmitter","attrs","resetUpdateRange","emitterRanges","emitterAttr","setUpdateRange","flagUpdate","_updateUniforms","tick","_updateBuffers","resetDynamic","dispose"],"mappings":"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RW,kBAAmB,CAGlB,iCACA,6DACA,iCACA,+BACA,+BACA,6BACA,GACA,sIACA,sIACA,sIACA,uIACA,OACA,GACA,gEACA,kCACA,yBACA,UACA,GACA,sDACA,sCACA,yBACA,6BAEA,2BACA,0DACA,sFACA,2CACA,2DACA,0EACA,OACA,UACCX,KAAM,MAIRY,cAAe,CACd,iEACA,GACA,mCACA,0CACA,gDACA,mCACA,mCAEA,iEACA,aACA,GAGA,qCACA,0CACA,0CACA,6CACA,0CAEA,0DACA,+DACA,aAEA,GACA,oDACCZ,KAAM,OC1PM,GACda,OAAQ,CACPC,EAAaf,QACbe,EAAab,SACba,EAAaZ,WACbY,EAAaX,SAEb,cAAkBY,OAClB,cAAkBC,wBAClB,cAAkBC,gBAElBH,EAAaV,yBACbU,EAAaT,YACbS,EAAaR,mBACbQ,EAAaP,kBACbO,EAAaN,kBACbM,EAAaL,uBACbK,EAAaJ,uBACbI,EAAaH,kBAEb,gBAKA,kCACA,sCACA,wCACA,mDACA,mDAEA,qCACA,6DACA,2DACA,2DACA,aAOA,qCACA,2CACA,gCACA,mCAGA,kEAGA,oBACA,qBACA,4BACA,oBAIA,qCACA,8BACA,8BACA,8BACA,aAIA,qCACA,oDACA,aAGA,4DAGA,sFAGA,6BACA,gEACA,YACA,mCACA,aAGA,4DAQA,sBACA,kDACA,6BACA,qCACA,qCACA,qCACA,oCACA,YACA,YACA,6BACA,aAEA,2EAGA,6BAGA,mCACA,4EACA,aAIA,qCACA,8CACA,8CACA,gDACA,kDACA,8FAEA,6DACA,iEAEA,+CACA,yCAEA,0CACA,0CACA,uCACA,oCACA,aAOA,2CACA,mDAEA,cAAkBO,mBAClB,cAAkBC,WAElB,KACCnB,KAAM,MAERoB,SAAU,CACTN,EAAab,SAEb,cAAkBc,OAClB,cAAkBM,kBAClB,cAAkBC,0BAElBR,EAAaX,SAEbW,EAAaV,yBAEb,gBACA,uCACA,OACA,uBACA,qDACA,aAEAU,EAAaF,cAEb,cAAkBW,qBAElB,uDACA,6EAEA,cAAkBC,aAElB,KACCxB,KAAM,OCxKM,GAMdyB,IAAK,E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","file":"SPE.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 1);\n","module.exports = THREE;","import * as THREE from 'three';\nimport valueTypes from '@/constants/valueTypes';\n\n/**\n * A bunch of utility functions used throughout the library.\n * @namespace\n * @type {Object}\n */\nexport default {\n\n\t/**\n     * Given a value, a type, and a default value to fallback to,\n     * ensure the given argument adheres to the type requesting,\n     * returning the default value if type check is false.\n     *\n     * @param  {(boolean|string|number|object)} arg          The value to perform a type-check on.\n     * @param  {String} type         The type the `arg` argument should adhere to.\n     * @param  {(boolean|string|number|object)} defaultValue A default value to fallback on if the type check fails.\n     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.\n     */\n\tensureTypedArg( arg, type, defaultValue ) {\n\t\t'use strict';\n\n\t\tif ( typeof arg === type ) {\n\t\t\treturn arg;\n\t\t}\n\t\telse {\n\t\t\treturn defaultValue;\n\t\t}\n\t},\n\n\t/**\n     * Given an array of values, a type, and a default value,\n     * ensure the given array's contents ALL adhere to the provided type,\n     * returning the default value if type check fails.\n     *\n     * If the given value to check isn't an Array, delegates to SPE.utils.ensureTypedArg.\n     *\n     * @param  {Array|boolean|string|number|object} arg          The array of values to check type of.\n     * @param  {String} type         The type that should be adhered to.\n     * @param  {(boolean|string|number|object)} defaultValue A default fallback value.\n     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.\n     */\n\tensureArrayTypedArg( arg, type, defaultValue ) {\n\t\t'use strict';\n\n\t\t// If the argument being checked is an array, loop through\n\t\t// it and ensure all the values are of the correct type,\n\t\t// falling back to the defaultValue if any aren't.\n\t\tif ( Array.isArray( arg ) ) {\n\t\t\tfor ( var i = arg.length - 1; i >= 0; --i ) {\n\t\t\t\tif ( typeof arg[ i ] !== type ) {\n\t\t\t\t\treturn defaultValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn arg;\n\t\t}\n\n\t\t// If the arg isn't an array then just fallback to\n\t\t// checking the type.\n\t\treturn this.ensureTypedArg( arg, type, defaultValue );\n\t},\n\n\t/**\n     * Ensures the given value is an instance of a constructor function.\n     *\n     * @param  {Object} arg          The value to check instance of.\n     * @param  {Function} instance     The constructor of the instance to check against.\n     * @param  {Object} defaultValue A default fallback value if instance check fails\n     * @return {Object}              The given value if type check passes, or the default value if it fails.\n     */\n\tensureInstanceOf( arg, instance, defaultValue ) {\n\t\t'use strict';\n\n\t\tif ( instance !== undefined && arg instanceof instance ) {\n\t\t\treturn arg;\n\t\t}\n\t\telse {\n\t\t\treturn defaultValue;\n\t\t}\n\t},\n\n\t/**\n     * Given an array of values, ensure the instances of all items in the array\n     * matches the given instance constructor falling back to a default value if\n     * the check fails.\n     *\n     * If given value isn't an Array, delegates to `SPE.utils.ensureInstanceOf`.\n     *\n     * @param  {Array|Object} arg          The value to perform the instanceof check on.\n     * @param  {Function} instance     The constructor of the instance to check against.\n     * @param  {Object} defaultValue A default fallback value if instance check fails\n     * @return {Object}              The given value if type check passes, or the default value if it fails.\n     */\n\tensureArrayInstanceOf( arg, instance, defaultValue ) {\n\t\t'use strict';\n\n\t\t// If the argument being checked is an array, loop through\n\t\t// it and ensure all the values are of the correct type,\n\t\t// falling back to the defaultValue if any aren't.\n\t\tif ( Array.isArray( arg ) ) {\n\t\t\tfor ( var i = arg.length - 1; i >= 0; --i ) {\n\t\t\t\tif ( instance !== undefined && arg[ i ] instanceof instance === false ) {\n\t\t\t\t\treturn defaultValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn arg;\n\t\t}\n\n\t\t// If the arg isn't an array then just fallback to\n\t\t// checking the type.\n\t\treturn this.ensureInstanceOf( arg, instance, defaultValue );\n\t},\n\n\t/**\n     * Ensures that any \"value-over-lifetime\" properties of an emitter are\n     * of the correct length (as dictated by `SPE.valueOverLifetimeLength`).\n     *\n     * Delegates to `SPE.utils.interpolateArray` for array resizing.\n     *\n     * If properties aren't arrays, then property values are put into one.\n     *\n     * @param  {Object} property  The property of an SPE.Emitter instance to check compliance of.\n     * @param  {Number} minLength The minimum length of the array to create.\n     * @param  {Number} maxLength The maximum length of the array to create.\n     */\n\tensureValueOverLifetimeCompliance( property, minLength, maxLength ) {\n\t\t'use strict';\n\n\t\tminLength = minLength || 3;\n\t\tmaxLength = maxLength || 3;\n\n\t\t// First, ensure both properties are arrays.\n\t\tif ( Array.isArray( property._value ) === false ) {\n\t\t\tproperty._value = [ property._value ];\n\t\t}\n\n\t\tif ( Array.isArray( property._spread ) === false ) {\n\t\t\tproperty._spread = [ property._spread ];\n\t\t}\n\n\t\tvar valueLength = this.clamp( property._value.length, minLength, maxLength ),\n\t\t\tspreadLength = this.clamp( property._spread.length, minLength, maxLength ),\n\t\t\tdesiredLength = Math.max( valueLength, spreadLength );\n\n\t\tif ( property._value.length !== desiredLength ) {\n\t\t\tproperty._value = this.interpolateArray( property._value, desiredLength );\n\t\t}\n\n\t\tif ( property._spread.length !== desiredLength ) {\n\t\t\tproperty._spread = this.interpolateArray( property._spread, desiredLength );\n\t\t}\n\t},\n\n\t/**\n     * Performs linear interpolation (lerp) on an array.\n     *\n     * For example, lerping [1, 10], with a `newLength` of 10 will produce [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].\n     *\n     * Delegates to `SPE.utils.lerpTypeAgnostic` to perform the actual\n     * interpolation.\n     *\n     * @param  {Array} srcArray  The array to lerp.\n     * @param  {Number} newLength The length the array should be interpolated to.\n     * @return {Array}           The interpolated array.\n     */\n\tinterpolateArray( srcArray, newLength ) {\n\t\t'use strict';\n\n\t\tvar sourceLength = srcArray.length,\n\t\t\tnewArray = [ typeof srcArray[ 0 ].clone === 'function' ? srcArray[ 0 ].clone() : srcArray[ 0 ] ],\n\t\t\tfactor = ( sourceLength - 1 ) / ( newLength - 1 );\n\n\n\t\tfor ( var i = 1; i < newLength - 1; ++i ) {\n\t\t\tvar f = i * factor,\n\t\t\t\tbefore = Math.floor( f ),\n\t\t\t\tafter = Math.ceil( f ),\n\t\t\t\tdelta = f - before;\n\n\t\t\tnewArray[ i ] = this.lerpTypeAgnostic( srcArray[ before ], srcArray[ after ], delta );\n\t\t}\n\n\t\tnewArray.push(\n\t\t\ttypeof srcArray[ sourceLength - 1 ].clone === 'function' ?\n\t\t\t\tsrcArray[ sourceLength - 1 ].clone() :\n\t\t\t\tsrcArray[ sourceLength - 1 ]\n\t\t);\n\n\t\treturn newArray;\n\t},\n\n\t/**\n     * Clamp a number to between the given min and max values.\n     * @param  {Number} value The number to clamp.\n     * @param  {Number} min   The minimum value.\n     * @param  {Number} max   The maximum value.\n     * @return {Number}       The clamped number.\n     */\n\tclamp( value, min, max ) {\n\t\t'use strict';\n\n\t\treturn Math.max( min, Math.min( value, max ) );\n\t},\n\n\t/**\n     * If the given value is less than the epsilon value, then return\n     * a randomised epsilon value if specified, or just the epsilon value if not.\n     * Works for negative numbers as well as positive.\n     *\n     * @param  {Number} value     The value to perform the operation on.\n     * @param  {Boolean} randomise Whether the value should be randomised.\n     * @return {Number}           The result of the operation.\n     */\n\tzeroToEpsilon( value, randomise ) {\n\t\t'use strict';\n\n\t\tvar epsilon = 0.00001,\n\t\t\tresult = value;\n\n\t\tresult = randomise ? Math.random() * epsilon * 10 : epsilon;\n\n\t\tif ( value < 0 && value > -epsilon ) {\n\t\t\tresult = -result;\n\t\t}\n\n\t\t// if ( value === 0 ) {\n\t\t//     result = randomise ? Math.random() * epsilon * 10 : epsilon;\n\t\t// }\n\t\t// else if ( value > 0 && value < epsilon ) {\n\t\t//     result = randomise ? Math.random() * epsilon * 10 : epsilon;\n\t\t// }\n\t\t// else if ( value < 0 && value > -epsilon ) {\n\t\t//     result = -( randomise ? Math.random() * epsilon * 10 : epsilon );\n\t\t// }\n\n\t\treturn result;\n\t},\n\n\t/**\n     * Linearly interpolates two values of various valueTypes. The given values\n     * must be of the same type for the interpolation to work.\n     * @param  {(number|Object)} start The start value of the lerp.\n     * @param  {(number|object)} end   The end value of the lerp.\n     * @param  {Number} delta The delta posiiton of the lerp operation. Ideally between 0 and 1 (inclusive).\n     * @return {(number|object|undefined)}       The result of the operation. Result will be undefined if\n     *                                               the start and end arguments aren't a supported type, or\n     *                                               if their types do not match.\n     */\n\tlerpTypeAgnostic( start, end, delta ) {\n\t\t'use strict';\n\n\t\tvar out;\n\n\t\tif ( typeof start === valueTypes.NUMBER && typeof end === valueTypes.NUMBER ) {\n\t\t\treturn start + ( ( end - start ) * delta );\n\t\t}\n\t\telse if ( start instanceof THREE.Vector2 && end instanceof THREE.Vector2 ) {\n\t\t\tout = start.clone();\n\t\t\tout.x = this.lerp( start.x, end.x, delta );\n\t\t\tout.y = this.lerp( start.y, end.y, delta );\n\t\t\treturn out;\n\t\t}\n\t\telse if ( start instanceof THREE.Vector3 && end instanceof THREE.Vector3 ) {\n\t\t\tout = start.clone();\n\t\t\tout.x = this.lerp( start.x, end.x, delta );\n\t\t\tout.y = this.lerp( start.y, end.y, delta );\n\t\t\tout.z = this.lerp( start.z, end.z, delta );\n\t\t\treturn out;\n\t\t}\n\t\telse if ( start instanceof THREE.Vector4 && end instanceof THREE.Vector4 ) {\n\t\t\tout = start.clone();\n\t\t\tout.x = this.lerp( start.x, end.x, delta );\n\t\t\tout.y = this.lerp( start.y, end.y, delta );\n\t\t\tout.z = this.lerp( start.z, end.z, delta );\n\t\t\tout.w = this.lerp( start.w, end.w, delta );\n\t\t\treturn out;\n\t\t}\n\t\telse if ( start instanceof THREE.Color && end instanceof THREE.Color ) {\n\t\t\tout = start.clone();\n\t\t\tout.r = this.lerp( start.r, end.r, delta );\n\t\t\tout.g = this.lerp( start.g, end.g, delta );\n\t\t\tout.b = this.lerp( start.b, end.b, delta );\n\t\t\treturn out;\n\t\t}\n\t\telse {\n\t\t\tconsole.warn( 'Invalid argument types, or argument types do not match:', start, end );\n\t\t}\n\t},\n\n\t/**\n     * Perform a linear interpolation operation on two numbers.\n     * @param  {Number} start The start value.\n     * @param  {Number} end   The end value.\n     * @param  {Number} delta The position to interpolate to.\n     * @return {Number}       The result of the lerp operation.\n     */\n\tlerp( start, end, delta ) {\n\t\t'use strict';\n\t\treturn start + ( ( end - start ) * delta );\n\t},\n\n\t/**\n     * Rounds a number to a nearest multiple.\n     *\n     * @param  {Number} n        The number to round.\n     * @param  {Number} multiple The multiple to round to.\n     * @return {Number}          The result of the round operation.\n     */\n\troundToNearestMultiple( n, multiple ) {\n\t\t'use strict';\n\n\t\tvar remainder = 0;\n\n\t\tif ( multiple === 0 ) {\n\t\t\treturn n;\n\t\t}\n\n\t\tremainder = Math.abs( n ) % multiple;\n\n\t\tif ( remainder === 0 ) {\n\t\t\treturn n;\n\t\t}\n\n\t\tif ( n < 0 ) {\n\t\t\treturn -( Math.abs( n ) - remainder );\n\t\t}\n\n\t\treturn n + multiple - remainder;\n\t},\n\n\t/**\n     * Check if all items in an array are equal. Uses strict equality.\n     *\n     * @param  {Array} array The array of values to check equality of.\n     * @return {Boolean}       Whether the array's values are all equal or not.\n     */\n\tarrayValuesAreEqual( array ) {\n\t\t'use strict';\n\n\t\tfor ( var i = 0; i < array.length - 1; ++i ) {\n\t\t\tif ( array[ i ] !== array[ i + 1 ] ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t},\n\n\t// colorsAreEqual: function() {\n\t//     var colors = Array.prototype.slice.call( arguments ),\n\t//         numColors = colors.length;\n\n\t//     for ( var i = 0, color1, color2; i < numColors - 1; ++i ) {\n\t//         color1 = colors[ i ];\n\t//         color2 = colors[ i + 1 ];\n\n\t//         if (\n\t//             color1.r !== color2.r ||\n\t//             color1.g !== color2.g ||\n\t//             color1.b !== color2.b\n\t//         ) {\n\t//             return false\n\t//         }\n\t//     }\n\n\t//     return true;\n\t// },\n\n\n\t/**\n     * Given a start value and a spread value, create and return a random\n     * number.\n     * @param  {Number} base   The start value.\n     * @param  {Number} spread The size of the random variance to apply.\n     * @return {Number}        A randomised number.\n     */\n\trandomFloat( base, spread ) {\n\t\t'use strict';\n\t\treturn base + spread * ( Math.random() - 0.5 );\n\t},\n\n\n\n\t/**\n     * Given an SPE.ShaderAttribute instance, and various other settings,\n     * assign values to the attribute's array in a `vec3` format.\n     *\n     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.\n     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.\n     * @param  {Object} base        THREE.Vector3 instance describing the start value.\n     * @param  {Object} spread      THREE.Vector3 instance describing the random variance to apply to the start value.\n     * @param  {Object} spreadClamp THREE.Vector3 instance describing the multiples to clamp the randomness to.\n     */\n\trandomVector3( attribute, index, base, spread, spreadClamp ) {\n\t\t'use strict';\n\n\t\tvar x = base.x + ( Math.random() * spread.x - ( spread.x * 0.5 ) ),\n\t\t\ty = base.y + ( Math.random() * spread.y - ( spread.y * 0.5 ) ),\n\t\t\tz = base.z + ( Math.random() * spread.z - ( spread.z * 0.5 ) );\n\n\t\t// var x = this.randomFloat( base.x, spread.x ),\n\t\t// y = this.randomFloat( base.y, spread.y ),\n\t\t// z = this.randomFloat( base.z, spread.z );\n\n\t\tif ( spreadClamp ) {\n\t\t\tx = -spreadClamp.x * 0.5 + this.roundToNearestMultiple( x, spreadClamp.x );\n\t\t\ty = -spreadClamp.y * 0.5 + this.roundToNearestMultiple( y, spreadClamp.y );\n\t\t\tz = -spreadClamp.z * 0.5 + this.roundToNearestMultiple( z, spreadClamp.z );\n\t\t}\n\n\t\tattribute.typedArray.setVec3Components( index, x, y, z );\n\t},\n\n\t/**\n     * Given an SPE.Shader attribute instance, and various other settings,\n     * assign Color values to the attribute.\n     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.\n     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.\n     * @param  {Object} base      THREE.Color instance describing the start color.\n     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.\n     */\n\trandomColor( attribute, index, base, spread ) {\n\t\t'use strict';\n\n\t\tvar r = base.r + ( Math.random() * spread.x ),\n\t\t\tg = base.g + ( Math.random() * spread.y ),\n\t\t\tb = base.b + ( Math.random() * spread.z );\n\n\t\tr = this.clamp( r, 0, 1 );\n\t\tg = this.clamp( g, 0, 1 );\n\t\tb = this.clamp( b, 0, 1 );\n\n\n\t\tattribute.typedArray.setVec3Components( index, r, g, b );\n\t},\n\n\n\trandomColorAsHex: ( function() {\n\t\t'use strict';\n\n\t\tvar workingColor = new THREE.Color();\n\n\t\t/**\n         * Assigns a random color value, encoded as a hex value in decimal\n         * format, to a SPE.ShaderAttribute instance.\n         * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.\n         * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.\n         * @param  {Object} base      THREE.Color instance describing the start color.\n         * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.\n         */\n\t\treturn function( attribute, index, base, spread ) {\n\t\t\tvar numItems = base.length,\n\t\t\t\tcolors = [];\n\n\t\t\tfor ( var i = 0; i < numItems; ++i ) {\n\t\t\t\tvar spreadVector = spread[ i ];\n\n\t\t\t\tworkingColor.copy( base[ i ] );\n\n\t\t\t\tworkingColor.r += ( Math.random() * spreadVector.x ) - ( spreadVector.x * 0.5 );\n\t\t\t\tworkingColor.g += ( Math.random() * spreadVector.y ) - ( spreadVector.y * 0.5 );\n\t\t\t\tworkingColor.b += ( Math.random() * spreadVector.z ) - ( spreadVector.z * 0.5 );\n\n\t\t\t\tworkingColor.r = this.clamp( workingColor.r, 0, 1 );\n\t\t\t\tworkingColor.g = this.clamp( workingColor.g, 0, 1 );\n\t\t\t\tworkingColor.b = this.clamp( workingColor.b, 0, 1 );\n\n\t\t\t\tcolors.push( workingColor.getHex() );\n\t\t\t}\n\n\t\t\tattribute.typedArray.setVec4Components( index, colors[ 0 ], colors[ 1 ], colors[ 2 ], colors[ 3 ] );\n\t\t};\n\t}() ),\n\n\t/**\n     * Given an SPE.ShaderAttribute instance, and various other settings,\n     * assign values to the attribute's array in a `vec3` format.\n     *\n     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.\n     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.\n     * @param  {Object} start       THREE.Vector3 instance describing the start line position.\n     * @param  {Object} end         THREE.Vector3 instance describing the end line position.\n     */\n\trandomVector3OnLine( attribute, index, start, end ) {\n\t\t'use strict';\n\t\tvar pos = start.clone();\n\n\t\tpos.lerp( end, Math.random() );\n\n\t\tattribute.typedArray.setVec3Components( index, pos.x, pos.y, pos.z );\n\t},\n\n\t/**\n     * Given an SPE.Shader attribute instance, and various other settings,\n     * assign Color values to the attribute.\n     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.\n     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.\n     * @param  {Object} base      THREE.Color instance describing the start color.\n     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.\n     */\n\n\t/**\n     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the\n     * given values onto a sphere.\n     *\n     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.\n     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.\n     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.\n     * @param  {Number} radius            The radius of the sphere to project onto.\n     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result\n     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the sphere.\n     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.\n     */\n\trandomVector3OnSphere(\n\t\tattribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp, distributionClamp\n\t) {\n\t\t'use strict';\n\n\t\tvar depth = 2 * Math.random() - 1,\n\t\t\tt = 6.2832 * Math.random(),\n\t\t\tr = Math.sqrt( 1 - depth * depth ),\n\t\t\trand = this.randomFloat( radius, radiusSpread ),\n\t\t\tx = 0,\n\t\t\ty = 0,\n\t\t\tz = 0;\n\n\n\t\tif ( radiusSpreadClamp ) {\n\t\t\trand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;\n\t\t}\n\n\n\n\t\t// Set position on sphere\n\t\tx = r * Math.cos( t ) * rand;\n\t\ty = r * Math.sin( t ) * rand;\n\t\tz = depth * rand;\n\n\t\t// Apply radius scale to this position\n\t\tx *= radiusScale.x;\n\t\ty *= radiusScale.y;\n\t\tz *= radiusScale.z;\n\n\t\t// Translate to the base position.\n\t\tx += base.x;\n\t\ty += base.y;\n\t\tz += base.z;\n\n\t\t// Set the values in the typed array.\n\t\tattribute.typedArray.setVec3Components( index, x, y, z );\n\t},\n\n\tseededRandom( seed ) {\n\t\tvar x = Math.sin( seed ) * 10000;\n\t\treturn x - ( x | 0 );\n\t},\n\n\n\n\t/**\n     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the\n     * given values onto a 2d-disc.\n     *\n     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.\n     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.\n     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.\n     * @param  {Number} radius            The radius of the sphere to project onto.\n     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result\n     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the disc. The z-component is ignored.\n     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.\n     */\n\trandomVector3OnDisc( attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp ) {\n\t\t'use strict';\n\n\t\tvar t = 6.2832 * Math.random(),\n\t\t\trand = Math.abs( this.randomFloat( radius, radiusSpread ) ),\n\t\t\tx = 0,\n\t\t\ty = 0,\n\t\t\tz = 0;\n\n\t\tif ( radiusSpreadClamp ) {\n\t\t\trand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;\n\t\t}\n\n\t\t// Set position on sphere\n\t\tx = Math.cos( t ) * rand;\n\t\ty = Math.sin( t ) * rand;\n\n\t\t// Apply radius scale to this position\n\t\tx *= radiusScale.x;\n\t\ty *= radiusScale.y;\n\n\t\t// Translate to the base position.\n\t\tx += base.x;\n\t\ty += base.y;\n\t\tz += base.z;\n\n\t\t// Set the values in the typed array.\n\t\tattribute.typedArray.setVec3Components( index, x, y, z );\n\t},\n\n\trandomDirectionVector3OnSphere: ( function() {\n\t\t'use strict';\n\n\t\tvar v = new THREE.Vector3();\n\n\t\t/**\n         * Given an SPE.ShaderAttribute instance, create a direction vector from the given\n         * position, using `speed` as the magnitude. Values are saved to the attribute.\n         *\n         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.\n         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.\n         * @param  {Number} posX            The particle's x coordinate.\n         * @param  {Number} posY            The particle's y coordinate.\n         * @param  {Number} posZ            The particle's z coordinate.\n         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.\n         * @param  {Number} speed           The magnitude to apply to the vector.\n         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.\n         */\n\t\treturn function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {\n\t\t\tv.copy( emitterPosition );\n\n\t\t\tv.x -= posX;\n\t\t\tv.y -= posY;\n\t\t\tv.z -= posZ;\n\n\t\t\tv.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );\n\n\t\t\tattribute.typedArray.setVec3Components( index, v.x, v.y, v.z );\n\t\t};\n\t}() ),\n\n\n\trandomDirectionVector3OnDisc: ( function() {\n\t\t'use strict';\n\n\t\tvar v = new THREE.Vector3();\n\n\t\t/**\n         * Given an SPE.ShaderAttribute instance, create a direction vector from the given\n         * position, using `speed` as the magnitude. Values are saved to the attribute.\n         *\n         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.\n         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.\n         * @param  {Number} posX            The particle's x coordinate.\n         * @param  {Number} posY            The particle's y coordinate.\n         * @param  {Number} posZ            The particle's z coordinate.\n         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.\n         * @param  {Number} speed           The magnitude to apply to the vector.\n         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.\n         */\n\t\treturn function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {\n\t\t\tv.copy( emitterPosition );\n\n\t\t\tv.x -= posX;\n\t\t\tv.y -= posY;\n\t\t\tv.z -= posZ;\n\n\t\t\tv.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );\n\n\t\t\tattribute.typedArray.setVec3Components( index, v.x, v.y, 0 );\n\t\t};\n\t}() ),\n\n\tgetPackedRotationAxis: ( function() {\n\t\t'use strict';\n\n\t\tvar v = new THREE.Vector3(),\n\t\t\tvSpread = new THREE.Vector3(),\n\t\t\tc = new THREE.Color(),\n\t\t\taddOne = new THREE.Vector3( 1, 1, 1 );\n\n\t\t/**\n         * Given a rotation axis, and a rotation axis spread vector,\n         * calculate a randomised rotation axis, and pack it into\n         * a hexadecimal value represented in decimal form.\n         * @param  {Object} axis       THREE.Vector3 instance describing the rotation axis.\n         * @param  {Object} axisSpread THREE.Vector3 instance describing the amount of randomness to apply to the rotation axis.\n         * @return {Number}            The packed rotation axis, with randomness.\n         */\n\t\treturn function( axis, axisSpread ) {\n\t\t\tv.copy( axis ).normalize();\n\t\t\tvSpread.copy( axisSpread ).normalize();\n\n\t\t\tv.x += ( -axisSpread.x * 0.5 ) + ( Math.random() * axisSpread.x );\n\t\t\tv.y += ( -axisSpread.y * 0.5 ) + ( Math.random() * axisSpread.y );\n\t\t\tv.z += ( -axisSpread.z * 0.5 ) + ( Math.random() * axisSpread.z );\n\n\t\t\t// v.x = Math.abs( v.x );\n\t\t\t// v.y = Math.abs( v.y );\n\t\t\t// v.z = Math.abs( v.z );\n\n\t\t\tv.normalize().add( addOne )\n\t\t\t\t.multiplyScalar( 0.5 );\n\n\t\t\tc.setRGB( v.x, v.y, v.z );\n\n\t\t\treturn c.getHex();\n\t\t};\n\t}() ),\n};\n","export default {\n\n\t/**\n\t * Boolean type.\n\t * @type {String}\n\t */\n\tBOOLEAN: 'boolean',\n\n\t/**\n\t * String type.\n\t * @type {String}\n\t */\n\tSTRING: 'string',\n\n\t/**\n\t * Number type.\n\t * @type {String}\n\t */\n\tNUMBER: 'number',\n\n\t/**\n\t * Object type.\n\t * @type {String}\n\t */\n\tOBJECT: 'object',\n};\n","export default {\n\tvalueOverLifetimeLength: 4,\n};","/**\n * A helper class for TypedArrays.\n *\n * Allows for easy resizing, assignment of various component-based\n * types (Vector2s, Vector3s, Vector4s, Mat3s, Mat4s),\n * as well as Colors (where components are `r`, `g`, `b`),\n * Numbers, and setting from other TypedArrays.\n *\n * @author Luke Moody\n * @constructor\n * @param {Function} TypedArrayConstructor The constructor to use (Float32Array, Uint8Array, etc.)\n * @param {Number} size                 The size of the array to create\n * @param {Number} componentSize        The number of components per-value (ie. 3 for a vec3, 9 for a Mat3, etc.)\n * @param {Number} indexOffset          The index in the array from which to start assigning values. Default `0` if none provided\n */\nexport default class TypedArrayHelper {\n\tconstructor( TypedArrayConstructor, size, componentSize, indexOffset ) {\n\t\tthis.componentSize = componentSize || 1;\n\t\tthis.size = ( size || 1 );\n\t\tthis.TypedArrayConstructor = TypedArrayConstructor || Float32Array;\n\t\tthis.array = new TypedArrayConstructor( size * this.componentSize );\n\t\tthis.indexOffset = indexOffset || 0;\n\t}\n\n\t/**\n\t * Sets the size of the internal array.\n\t *\n\t * Delegates to `this.shrink` or `this.grow` depending on size\n\t * argument's relation to the current size of the internal array.\n\t *\n\t * Note that if the array is to be shrunk, data will be lost.\n\t *\n\t * @param {Number} size The new size of the array.\n\t */\n\tsetSize( s, noComponentMultiply ) {\n\t\tconst currentArraySize = this.array.length;\n\t\tlet size = s;\n\n\t\tif ( !noComponentMultiply ) {\n\t\t\tsize = size * this.componentSize;\n\t\t}\n\n\t\tif ( size < currentArraySize ) {\n\t\t\treturn this.shrink( size );\n\t\t}\n\t\telse if ( size > currentArraySize ) {\n\t\t\treturn this.grow( size );\n\t\t}\n\t\telse {\n\t\t\tconsole.info( 'TypedArray is already of size:', size + '.', 'Will not resize.' );\n\t\t}\n\t}\n\n\t/**\n\t * Shrinks the internal array.\n\t *\n\t * @param  {Number} size The new size of the typed array. Must be smaller than `this.array.length`.\n\t * @return {SPE.TypedArrayHelper}      Instance of this class.\n\t */\n\tshrink( size ) {\n\t\tthis.array = this.array.subarray( 0, size );\n\t\tthis.size = size;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Grows the internal array.\n\t * @param  {Number} size The new size of the typed array. Must be larger than `this.array.length`.\n\t * @return {SPE.TypedArrayHelper}      Instance of this class.\n\t */\n\tgrow( size ) {\n\t\tconst newArray = new this.TypedArrayConstructor( size );\n\n\t\tnewArray.set( this.array );\n\t\tthis.array = newArray;\n\t\tthis.size = size;\n\n\t\treturn this;\n\t}\n\n\n\t/**\n\t * Perform a splice operation on this array's buffer.\n\t * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.\n\t * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.\n\t * @returns {Object} The SPE.TypedArrayHelper instance.\n\t */\n\tsplice( start, end ) {\n\t\tconst _start = start * this.componentSize,\n\t\t\t_end = end * this.componentSize;\n\n\t\tconst data = [],\n\t\t\tarray = this.array,\n\t\t\tsize = array.length;\n\n\t\tfor ( let i = 0; i < size; ++i ) {\n\t\t\tif ( i < _start || i >= _end ) {\n\t\t\t\tdata.push( array[ i ] );\n\t\t\t}\n\t\t\t// array[ i ] = 0;\n\t\t}\n\n\t\tthis.setFromArray( 0, data );\n\n\t\treturn this;\n\t}\n\n\n\t/**\n\t * Copies from the given TypedArray into this one, using the index argument\n\t * as the start position. Alias for `TypedArray.set`. Will automatically resize\n\t * if the given source array is of a larger size than the internal array.\n\t *\n\t * @param {Number} index      The start position from which to copy into this array.\n\t * @param {TypedArray} array The array from which to copy; the source array.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetFromArray( index, array ) {\n\t\tconst sourceArraySize = array.length,\n\t\t\tnewSize = index + sourceArraySize;\n\n\t\tif ( newSize > this.array.length ) {\n\t\t\tthis.grow( newSize );\n\t\t}\n\t\telse if ( newSize < this.array.length ) {\n\t\t\tthis.shrink( newSize );\n\t\t}\n\n\t\tthis.array.set( array, this.indexOffset + index );\n\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set a Vector2 value at `index`.\n\t *\n\t * @param {Number} index The index at which to set the vec2 values from.\n\t * @param {Vector2} vec2  Any object that has `x` and `y` properties.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetVec2( index, vec2 ) {\n\t\treturn this.setVec2Components( index, vec2.x, vec2.y );\n\t}\n\n\t/**\n\t * Set a Vector2 value using raw components.\n\t *\n\t * @param {Number} index The index at which to set the vec2 values from.\n\t * @param {Number} x     The Vec2's `x` component.\n\t * @param {Number} y     The Vec2's `y` component.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetVec2Components( index, x, y ) {\n\t\tconst array = this.array,\n\t\t\ti = this.indexOffset + ( index * this.componentSize );\n\n\t\tarray[ i ] = x;\n\t\tarray[ i + 1 ] = y;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set a Vector3 value at `index`.\n\t *\n\t * @param {Number} index The index at which to set the vec3 values from.\n\t * @param {Vector3} vec2  Any object that has `x`, `y`, and `z` properties.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetVec3( index, vec3 ) {\n\t\treturn this.setVec3Components( index, vec3.x, vec3.y, vec3.z );\n\t}\n\n\t/**\n\t * Set a Vector3 value using raw components.\n\t *\n\t * @param {Number} index The index at which to set the vec3 values from.\n\t * @param {Number} x     The Vec3's `x` component.\n\t * @param {Number} y     The Vec3's `y` component.\n\t * @param {Number} z     The Vec3's `z` component.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetVec3Components( index, x, y, z ) {\n\t\tconst array = this.array,\n\t\t\ti = this.indexOffset + ( index * this.componentSize );\n\n\t\tarray[ i ] = x;\n\t\tarray[ i + 1 ] = y;\n\t\tarray[ i + 2 ] = z;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set a Vector4 value at `index`.\n\t *\n\t * @param {Number} index The index at which to set the vec4 values from.\n\t * @param {Vector4} vec2  Any object that has `x`, `y`, `z`, and `w` properties.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetVec4( index, vec4 ) {\n\t\treturn this.setVec4Components( index, vec4.x, vec4.y, vec4.z, vec4.w );\n\t}\n\n\t/**\n\t * Set a Vector4 value using raw components.\n\t *\n\t * @param {Number} index The index at which to set the vec4 values from.\n\t * @param {Number} x     The Vec4's `x` component.\n\t * @param {Number} y     The Vec4's `y` component.\n\t * @param {Number} z     The Vec4's `z` component.\n\t * @param {Number} w     The Vec4's `w` component.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetVec4Components( index, x, y, z, w ) {\n\t\tconst array = this.array,\n\t\t\ti = this.indexOffset + ( index * this.componentSize );\n\n\t\tarray[ i ] = x;\n\t\tarray[ i + 1 ] = y;\n\t\tarray[ i + 2 ] = z;\n\t\tarray[ i + 3 ] = w;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set a Matrix3 value at `index`.\n\t *\n\t * @param {Number} index The index at which to set the matrix values from.\n\t * @param {Matrix3} mat3 The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetMat3( index, mat3 ) {\n\t\treturn this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat3.elements );\n\t}\n\n\t/**\n\t * Set a Matrix4 value at `index`.\n\t *\n\t * @param {Number} index The index at which to set the matrix values from.\n\t * @param {Matrix4} mat3 The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetMat4( index, mat4 ) {\n\t\treturn this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat4.elements );\n\t}\n\n\t/**\n\t * Set a Color value at `index`.\n\t *\n\t * @param {Number} index The index at which to set the vec3 values from.\n\t * @param {Color} color  Any object that has `r`, `g`, and `b` properties.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetColor( index, color ) {\n\t\treturn this.setVec3Components( index, color.r, color.g, color.b );\n\t}\n\n\t/**\n\t * Set a Number value at `index`.\n\t *\n\t * @param {Number} index The index at which to set the vec3 values from.\n\t * @param {Number} numericValue  The number to assign to this index in the array.\n\t * @return {SPE.TypedArrayHelper} Instance of this class.\n\t */\n\tsetNumber( index, numericValue ) {\n\t\tthis.array[ this.indexOffset + ( index * this.componentSize ) ] = numericValue;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Returns the value of the array at the given index, taking into account\n\t * the `indexOffset` property of this class.\n\t *\n\t * Note that this function ignores the component size and will just return a\n\t * single value.\n\t *\n\t * @param  {Number} index The index in the array to fetch.\n\t * @return {Number}       The value at the given index.\n\t */\n\tgetValueAtIndex( index ) {\n\t\treturn this.array[ this.indexOffset + index ];\n\t}\n\n\t/**\n\t * Returns the component value of the array at the given index, taking into account\n\t * the `indexOffset` property of this class.\n\t *\n\t * If the componentSize is set to 3, then it will return a new TypedArray\n\t * of length 3.\n\t *\n\t * @param  {Number} index The index in the array to fetch.\n\t * @return {TypedArray}       The component value at the given index.\n\t */\n\tgetComponentValueAtIndex( index ) {\n\t\treturn this.array.subarray( this.indexOffset + ( index * this.componentSize ) );\n\t}\n}","/**\n * A map of uniform types to their component size.\n * @enum {Number}\n */\nexport default {\n\n\t/**\n\t * Float\n\t * @type {Number}\n\t */\n\tf: 1,\n\n\t/**\n\t * Vec2\n\t * @type {Number}\n\t */\n\tv2: 2,\n\n\t/**\n\t * Vec3\n\t * @type {Number}\n\t */\n\tv3: 3,\n\n\t/**\n\t * Vec4\n\t * @type {Number}\n\t */\n\tv4: 4,\n\n\t/**\n\t * Color\n\t * @type {Number}\n\t */\n\tc: 3,\n\n\t/**\n\t * Mat3\n\t * @type {Number}\n\t */\n\tm3: 9,\n\n\t/**\n\t * Mat4\n\t * @type {Number}\n\t */\n\tm4: 16,\n};\n\n","import * as THREE from 'three';\nimport TypedArrayHelper from './TypedArrayHelper';\nimport typeSizeMap from '@/constants/typeSizeMap';\n\nconst HAS_OWN = Object.prototype.hasOwnProperty;\n\n/**\n * A helper to handle creating and updating a THREE.BufferAttribute instance.\n *\n * @author  Luke Moody\n * @constructor\n * @param {String} type          The buffer attribute type. See `typeSizeMap`` for valid values.\n * @param {Boolean=} dynamicBuffer Whether this buffer attribute should be marked as dynamic or not.\n * @param {Function=} arrayType     A reference to a TypedArray constructor. Defaults to Float32Array if none provided.\n */\nexport default class ShaderAttribute {\n\tconstructor( type, dynamicBuffer, arrayType ) {\n\t\tthis.type = typeof type === 'string' && HAS_OWN.call( typeSizeMap, type ) ? type : 'f';\n\t\tthis.componentSize = typeSizeMap[ this.type ];\n\t\tthis.arrayType = arrayType || Float32Array;\n\t\tthis.typedArray = null;\n\t\tthis.bufferAttribute = null;\n\t\tthis.dynamicBuffer = !!dynamicBuffer;\n\n\t\tthis.updateMin = 0;\n\t\tthis.updateMax = 0;\n\t}\n\n\t/**\n\t * Calculate the minimum and maximum update range for this buffer attribute using\n\t * component size independant min and max values.\n\t *\n\t * @param {Number} min The start of the range to mark as needing an update.\n\t * @param {Number} max The end of the range to mark as needing an update.\n\t */\n\tsetUpdateRange( min, max ) {\n\t\tthis.updateMin = Math.min( min * this.componentSize, this.updateMin * this.componentSize );\n\t\tthis.updateMax = Math.max( max * this.componentSize, this.updateMax * this.componentSize );\n\t}\n\n\t/**\n\t * Calculate the number of indices that this attribute should mark as needing\n\t * updating. Also marks the attribute as needing an update.\n\t */\n\tflagUpdate() {\n\t\tconst attr = this.bufferAttribute,\n\t\t\trange = attr.updateRange;\n\n\t\trange.offset = this.updateMin;\n\t\trange.count = Math.min( ( this.updateMax - this.updateMin ) + this.componentSize, this.typedArray.array.length );\n\t\tattr.needsUpdate = true;\n\t}\n\n\n\n\t/**\n\t * Reset the index update counts for this attribute\n\t */\n\tresetUpdateRange() {\n\t\tthis.updateMin = 0;\n\t\tthis.updateMax = 0;\n\t}\n\n\tresetDynamic() {\n\t\tthis.bufferAttribute.usage = this.dynamicBuffer ?\n\t\t\tTHREE.DynamicDrawUsage :\n\t\t\tTHREE.StaticDrawUsage;\n\t}\n\n\t/**\n\t * Perform a splice operation on this attribute's buffer.\n\t * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.\n\t * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.\n\t */\n\tsplice( start, end ) {\n\t\tthis.typedArray.splice( start, end );\n\n\t\t// Reset the reference to the attribute's typed array\n\t\t// since it has probably changed.\n\t\tthis.forceUpdateAll();\n\t}\n\n\tforceUpdateAll() {\n\t\tthis.bufferAttribute.array = this.typedArray.array;\n\t\tthis.bufferAttribute.updateRange.offset = 0;\n\t\tthis.bufferAttribute.updateRange.count = -1;\n\n\t\tthis.bufferAttribute.usage = THREE.StaticDrawUsage;\n\t\tthis.bufferAttribute.needsUpdate = true;\n\t}\n\n\t/**\n\t * Make sure this attribute has a typed array associated with it.\n\t *\n\t * If it does, then it will ensure the typed array is of the correct size.\n\t *\n\t * If not, a new `TypedArrayHelper` instance will be created.\n\t *\n\t * @param  {Number} size The size of the typed array to create or update to.\n\t */\n\t_ensureTypedArray( size ) {\n\t\t// Condition that's most likely to be true at the top: no change.\n\t\tif ( this.typedArray !== null && this.typedArray.size === size * this.componentSize ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Resize the array if we need to, telling the TypedArrayHelper to\n\t\t// ignore it's component size when evaluating size.\n\t\telse if ( this.typedArray !== null && this.typedArray.size !== size ) {\n\t\t\tthis.typedArray.setSize( size );\n\t\t}\n\n\t\t// This condition should only occur once in an attribute's lifecycle.\n\t\telse if ( this.typedArray === null ) {\n\t\t\tthis.typedArray = new TypedArrayHelper( this.arrayType, size, this.componentSize );\n\t\t}\n\t}\n\n\n\t/**\n\t * Creates a THREE.BufferAttribute instance if one doesn't exist already.\n\t *\n\t * Ensures a typed array is present by calling _ensureTypedArray() first.\n\t *\n\t * If a buffer attribute exists already, then it will be marked as needing an update.\n\t *\n\t * @param  {Number} size The size of the typed array to create if one doesn't exist, or resize existing array to.\n\t */\n\t_createBufferAttribute( size ) {\n\t\t// Make sure the typedArray is present and correct.\n\t\tthis._ensureTypedArray( size );\n\n\t\t// Don't create it if it already exists, but do\n\t\t// flag that it needs updating on the next render\n\t\t// cycle.\n\t\tif ( this.bufferAttribute !== null ) {\n\t\t\tthis.bufferAttribute.array = this.typedArray.array;\n\n\t\t\t// Since THREE.js version 81, dynamic count calculation was removed\n\t\t\t// so I need to do it manually here.\n\t\t\t//\n\t\t\t// In the next minor release, I may well remove this check and force\n\t\t\t// dependency on THREE r81+.\n\t\t\tif ( parseFloat( THREE.REVISION ) >= 81 ) {\n\t\t\t\tthis.bufferAttribute.count = this.bufferAttribute.array.length / this.bufferAttribute.itemSize;\n\t\t\t}\n\n\t\t\tthis.bufferAttribute.needsUpdate = true;\n\t\t\treturn;\n\t\t}\n\n\t\tthis.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize );\n\n\t\tthis.bufferAttribute.usage = this.dynamicBuffer ?\n\t\t\tTHREE.DynamicDrawUsage :\n\t\t\tTHREE.StaticDrawUsage;\n\t}\n\n\t/**\n\t * Returns the length of the typed array associated with this attribute.\n\t * @return {Number} The length of the typed array. Will be 0 if no typed array has been created yet.\n\t */\n\tgetLength() {\n\t\tif ( this.typedArray === null ) {\n\t\t\treturn 0;\n\t\t}\n\n\t\treturn this.typedArray.array.length;\n\t}\n\n}\n\n","export default {\n\t// Register color-packing define statements.\n\tdefines: [\n\t\t'#define PACKED_COLOR_SIZE 256.0',\n\t\t'#define PACKED_COLOR_DIVISOR 255.0',\n\t].join( '\\n' ),\n\n\t// All uniforms used by vertex / fragment shaders\n\tuniforms: [\n\t\t'uniform float deltaTime;',\n\t\t'uniform float runTime;',\n\t\t'uniform sampler2D tex;',\n\t\t'uniform vec4 textureAnimation;',\n\t\t'uniform float scale;',\n\t].join( '\\n' ),\n\n\t// All attributes used by the vertex shader.\n\t//\n\t// Note that some attributes are squashed into other ones:\n\t//\n\t// * Drag is acceleration.w\n\tattributes: [\n\t\t'attribute vec4 acceleration;',\n\t\t'attribute vec3 velocity;',\n\t\t'attribute vec4 rotation;',\n\t\t'attribute vec3 rotationCenter;',\n\t\t'attribute vec4 params;',\n\t\t'attribute vec4 size;',\n\t\t'attribute vec4 angle;',\n\t\t'attribute vec4 color;',\n\t\t'attribute vec4 opacity;',\n\t].join( '\\n' ),\n\n\t//\n\tvaryings: [\n\t\t'varying vec4 vColor;',\n\t\t'#ifdef SHOULD_ROTATE_TEXTURE',\n\t\t'    varying float vAngle;',\n\t\t'#endif',\n\n\t\t'#ifdef SHOULD_CALCULATE_SPRITE',\n\t\t'    varying vec4 vSpriteSheet;',\n\t\t'#endif',\n\t].join( '\\n' ),\n\n\n\t// Branch-avoiding comparison fns\n\t// - http://theorangeduck.com/page/avoiding-shader-conditionals\n\tbranchAvoidanceFunctions: [\n\t\t'float when_gt(float x, float y) {',\n\t\t'    return max(sign(x - y), 0.0);',\n\t\t'}',\n\n\t\t'float when_lt(float x, float y) {',\n\t\t'    return min( max(1.0 - sign(x - y), 0.0), 1.0 );',\n\t\t'}',\n\n\t\t'float when_eq( float x, float y ) {',\n\t\t'    return 1.0 - abs( sign( x - y ) );',\n\t\t'}',\n\n\t\t'float when_ge(float x, float y) {',\n\t\t'  return 1.0 - when_lt(x, y);',\n\t\t'}',\n\n\t\t'float when_le(float x, float y) {',\n\t\t'  return 1.0 - when_gt(x, y);',\n\t\t'}',\n\n\t\t// Branch-avoiding logical operators\n\t\t// (to be used with above comparison fns)\n\t\t'float and(float a, float b) {',\n\t\t'    return a * b;',\n\t\t'}',\n\n\t\t'float or(float a, float b) {',\n\t\t'    return min(a + b, 1.0);',\n\t\t'}',\n\t].join( '\\n' ),\n\n\n\t// From:\n\t// - http://stackoverflow.com/a/12553149\n\t// - https://stackoverflow.com/questions/22895237/hexadecimal-to-rgb-values-in-webgl-shader\n\tunpackColor: [\n\t\t'vec3 unpackColor( in float hex ) {',\n\t\t'   vec3 c = vec3( 0.0 );',\n\n\t\t'   float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',\n\t\t'   float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',\n\t\t'   float b = mod( hex, PACKED_COLOR_SIZE );',\n\n\t\t'   c.r = r / PACKED_COLOR_DIVISOR;',\n\t\t'   c.g = g / PACKED_COLOR_DIVISOR;',\n\t\t'   c.b = b / PACKED_COLOR_DIVISOR;',\n\n\t\t'   return c;',\n\t\t'}',\n\t].join( '\\n' ),\n\n\tunpackRotationAxis: [\n\t\t'vec3 unpackRotationAxis( in float hex ) {',\n\t\t'   vec3 c = vec3( 0.0 );',\n\n\t\t'   float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',\n\t\t'   float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',\n\t\t'   float b = mod( hex, PACKED_COLOR_SIZE );',\n\n\t\t'   c.r = r / PACKED_COLOR_DIVISOR;',\n\t\t'   c.g = g / PACKED_COLOR_DIVISOR;',\n\t\t'   c.b = b / PACKED_COLOR_DIVISOR;',\n\n\t\t'   c *= vec3( 2.0 );',\n\t\t'   c -= vec3( 1.0 );',\n\n\t\t'   return c;',\n\t\t'}',\n\t].join( '\\n' ),\n\n\tfloatOverLifetime: [\n\t\t'float getFloatOverLifetime( in float positionInTime, in vec4 attr ) {',\n\t\t'    highp float value = 0.0;',\n\t\t'    float deltaAge = positionInTime * float( VALUE_OVER_LIFETIME_LENGTH - 1 );',\n\t\t'    float fIndex = 0.0;',\n\t\t'    float shouldApplyValue = 0.0;',\n\n\t\t// This might look a little odd, but it's faster in the testing I've done than using branches.\n\t\t// Uses basic maths to avoid branching.\n\t\t//\n\t\t// Take a look at the branch-avoidance functions defined above,\n\t\t// and be sure to check out The Orange Duck site where I got this\n\t\t// from (link above).\n\n\t\t// Fix for static emitters (age is always zero).\n\t\t'    value += attr[ 0 ] * when_eq( deltaAge, 0.0 );',\n\t\t'',\n\t\t'    for( int i = 0; i < VALUE_OVER_LIFETIME_LENGTH - 1; ++i ) {',\n\t\t'       fIndex = float( i );',\n\t\t'       shouldApplyValue = and( when_gt( deltaAge, fIndex ), when_le( deltaAge, fIndex + 1.0 ) );',\n\t\t'       value += shouldApplyValue * mix( attr[ i ], attr[ i + 1 ], deltaAge - fIndex );',\n\t\t'    }',\n\t\t'',\n\t\t'    return value;',\n\t\t'}',\n\t].join( '\\n' ),\n\n\tcolorOverLifetime: [\n\t\t'vec3 getColorOverLifetime( in float positionInTime, in vec3 color1, in vec3 color2, in vec3 color3, in vec3 color4 ) {',\n\t\t'    vec3 value = vec3( 0.0 );',\n\t\t'    value.x = getFloatOverLifetime( positionInTime, vec4( color1.x, color2.x, color3.x, color4.x ) );',\n\t\t'    value.y = getFloatOverLifetime( positionInTime, vec4( color1.y, color2.y, color3.y, color4.y ) );',\n\t\t'    value.z = getFloatOverLifetime( positionInTime, vec4( color1.z, color2.z, color3.z, color4.z ) );',\n\t\t'    return value;',\n\t\t'}',\n\t].join( '\\n' ),\n\n\tparamFetchingFunctions: [\n\t\t'float getAlive() {',\n\t\t'   return params.x;',\n\t\t'}',\n\n\t\t'float getAge() {',\n\t\t'   return params.y;',\n\t\t'}',\n\n\t\t'float getMaxAge() {',\n\t\t'   return params.z;',\n\t\t'}',\n\n\t\t'float getWiggle() {',\n\t\t'   return params.w;',\n\t\t'}',\n\t].join( '\\n' ),\n\n\tforceFetchingFunctions: [\n\t\t'vec4 getPosition( in float age ) {',\n\t\t'   return modelViewMatrix * vec4( position, 1.0 );',\n\t\t'}',\n\n\t\t'vec3 getVelocity( in float age ) {',\n\t\t'   return velocity * age;',\n\t\t'}',\n\n\t\t'vec3 getAcceleration( in float age ) {',\n\t\t'   return acceleration.xyz * age;',\n\t\t'}',\n\t].join( '\\n' ),\n\n\n\trotationFunctions: [\n\t\t// Huge thanks to:\n\t\t// - http://www.neilmendoza.com/glsl-rotation-about-an-arbitrary-axis/\n\t\t'#ifdef SHOULD_ROTATE_PARTICLES',\n\t\t'   mat4 getRotationMatrix( in vec3 axis, in float angle) {',\n\t\t'       axis = normalize(axis);',\n\t\t'       float s = sin(angle);',\n\t\t'       float c = cos(angle);',\n\t\t'       float oc = 1.0 - c;',\n\t\t'',\n\t\t'       return mat4(oc * axis.x * axis.x + c,           oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s,  0.0,',\n\t\t'                   oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s,  0.0,',\n\t\t'                   oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c,           0.0,',\n\t\t'                   0.0,                                0.0,                                0.0,                                1.0);',\n\t\t'   }',\n\t\t'',\n\t\t'   vec3 getRotation( in vec3 pos, in float positionInTime ) {',\n\t\t'      if( rotation.y == 0.0 ) {',\n\t\t'           return pos;',\n\t\t'      }',\n\t\t'',\n\t\t'      vec3 axis = unpackRotationAxis( rotation.x );',\n\t\t'      vec3 center = rotationCenter;',\n\t\t'      vec3 translated;',\n\t\t'      mat4 rotationMatrix;',\n\n\t\t'      float angle = 0.0;',\n\t\t'      angle += when_eq( rotation.z, 0.0 ) * rotation.y;',\n\t\t'      angle += when_gt( rotation.z, 0.0 ) * mix( 0.0, rotation.y, positionInTime );',\n\t\t'      translated = rotationCenter - pos;',\n\t\t'      rotationMatrix = getRotationMatrix( axis, angle );',\n\t\t'      return center - vec3( rotationMatrix * vec4( translated, 0.0 ) );',\n\t\t'   }',\n\t\t'#endif',\n\t].join( '\\n' ),\n\n\n\t// Fragment chunks\n\trotateTexture: [\n\t\t'    vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );',\n\t\t'',\n\t\t'    #ifdef SHOULD_ROTATE_TEXTURE',\n\t\t'       float x = gl_PointCoord.x - 0.5;',\n\t\t'       float y = 1.0 - gl_PointCoord.y - 0.5;',\n\t\t'       float c = cos( -vAngle );',\n\t\t'       float s = sin( -vAngle );',\n\n\t\t'       vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );',\n\t\t'    #endif',\n\t\t'',\n\n\t\t// Spritesheets overwrite angle calculations.\n\t\t'    #ifdef SHOULD_CALCULATE_SPRITE',\n\t\t'        float framesX = vSpriteSheet.x;',\n\t\t'        float framesY = vSpriteSheet.y;',\n\t\t'        float columnNorm = vSpriteSheet.z;',\n\t\t'        float rowNorm = vSpriteSheet.w;',\n\n\t\t'        vUv.x = gl_PointCoord.x * framesX + columnNorm;',\n\t\t'        vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);',\n\t\t'    #endif',\n\n\t\t'',\n\t\t'    vec4 rotatedTexture = texture2D( tex, vUv );',\n\t].join( '\\n' ),\n};","import * as THREE from 'three';\nimport shaderChunks from './shaderChunks';\n\nexport default {\n\tvertex: [\n\t\tshaderChunks.defines,\n\t\tshaderChunks.uniforms,\n\t\tshaderChunks.attributes,\n\t\tshaderChunks.varyings,\n\n\t\tTHREE.ShaderChunk.common,\n\t\tTHREE.ShaderChunk.logdepthbuf_pars_vertex,\n\t\tTHREE.ShaderChunk.fog_pars_vertex,\n\n\t\tshaderChunks.branchAvoidanceFunctions,\n\t\tshaderChunks.unpackColor,\n\t\tshaderChunks.unpackRotationAxis,\n\t\tshaderChunks.floatOverLifetime,\n\t\tshaderChunks.colorOverLifetime,\n\t\tshaderChunks.paramFetchingFunctions,\n\t\tshaderChunks.forceFetchingFunctions,\n\t\tshaderChunks.rotationFunctions,\n\n\t\t'void main() {',\n\n\t\t//\n\t\t// Setup...\n\t\t//\n\t\t'    highp float age = getAge();',\n\t\t'    highp float alive = getAlive();',\n\t\t'    highp float maxAge = getMaxAge();',\n\t\t'    highp float positionInTime = (age / maxAge);',\n\t\t'    highp float isAlive = when_gt( alive, 0.0 );',\n\n\t\t'    #ifdef SHOULD_WIGGLE_PARTICLES',\n\t\t'        float wiggleAmount = positionInTime * getWiggle();',\n\t\t'        float wiggleSin = isAlive * sin( wiggleAmount );',\n\t\t'        float wiggleCos = isAlive * cos( wiggleAmount );',\n\t\t'    #endif',\n\n\t\t//\n\t\t// Forces\n\t\t//\n\n\t\t// Get forces & position\n\t\t'    vec3 vel = getVelocity( age );',\n\t\t'    vec3 accel = getAcceleration( age );',\n\t\t'    vec3 force = vec3( 0.0 );',\n\t\t'    vec3 pos = vec3( position );',\n\n\t\t// Calculate the required drag to apply to the forces.\n\t\t'    float drag = 1.0 - (positionInTime * 0.5) * acceleration.w;',\n\n\t\t// Integrate forces...\n\t\t'    force += vel;',\n\t\t'    force *= drag;',\n\t\t'    force += accel * age;',\n\t\t'    pos += force;',\n\n\n\t\t// Wiggly wiggly wiggle!\n\t\t'    #ifdef SHOULD_WIGGLE_PARTICLES',\n\t\t'        pos.x += wiggleSin;',\n\t\t'        pos.y += wiggleCos;',\n\t\t'        pos.z += wiggleSin;',\n\t\t'    #endif',\n\n\n\t\t// Rotate the emitter around it's central point\n\t\t'    #ifdef SHOULD_ROTATE_PARTICLES',\n\t\t'        pos = getRotation( pos, positionInTime );',\n\t\t'    #endif',\n\n\t\t// Convert pos to a world-space value\n\t\t'    vec4 mvPosition = modelViewMatrix * vec4( pos, 1.0 );',\n\n\t\t// Determine point size.\n\t\t'    highp float pointSize = getFloatOverLifetime( positionInTime, size ) * isAlive;',\n\n\t\t// Determine perspective\n\t\t'    #ifdef HAS_PERSPECTIVE',\n\t\t'        float perspective = scale / length( mvPosition.xyz );',\n\t\t'    #else',\n\t\t'        float perspective = 1.0;',\n\t\t'    #endif',\n\n\t\t// Apply perpective to pointSize value\n\t\t'    float pointSizePerspective = pointSize * perspective;',\n\n\n\t\t//\n\t\t// Appearance\n\t\t//\n\n\t\t// Determine color and opacity for this particle\n\t\t'    #ifdef COLORIZE',\n\t\t'       vec3 c = isAlive * getColorOverLifetime(',\n\t\t'           positionInTime,',\n\t\t'           unpackColor( color.x ),',\n\t\t'           unpackColor( color.y ),',\n\t\t'           unpackColor( color.z ),',\n\t\t'           unpackColor( color.w )',\n\t\t'       );',\n\t\t'    #else',\n\t\t'       vec3 c = vec3(1.0);',\n\t\t'    #endif',\n\n\t\t'    float o = isAlive * getFloatOverLifetime( positionInTime, opacity );',\n\n\t\t// Assign color to vColor varying.\n\t\t'    vColor = vec4( c, o );',\n\n\t\t// Determine angle\n\t\t'    #ifdef SHOULD_ROTATE_TEXTURE',\n\t\t'        vAngle = isAlive * getFloatOverLifetime( positionInTime, angle );',\n\t\t'    #endif',\n\n\t\t// If this particle is using a sprite-sheet as a texture, we'll have to figure out\n\t\t// what frame of the texture the particle is using at it's current position in time.\n\t\t'    #ifdef SHOULD_CALCULATE_SPRITE',\n\t\t'        float framesX = textureAnimation.x;',\n\t\t'        float framesY = textureAnimation.y;',\n\t\t'        float loopCount = textureAnimation.w;',\n\t\t'        float totalFrames = textureAnimation.z;',\n\t\t'        float frameNumber = mod( (positionInTime * loopCount) * totalFrames, totalFrames );',\n\n\t\t'        float column = floor(mod( frameNumber, framesX ));',\n\t\t'        float row = floor( (frameNumber - column) / framesX );',\n\n\t\t'        float columnNorm = column / framesX;',\n\t\t'        float rowNorm = row / framesY;',\n\n\t\t'        vSpriteSheet.x = 1.0 / framesX;',\n\t\t'        vSpriteSheet.y = 1.0 / framesY;',\n\t\t'        vSpriteSheet.z = columnNorm;',\n\t\t'        vSpriteSheet.w = rowNorm;',\n\t\t'    #endif',\n\n\t\t//\n\t\t// Write values\n\t\t//\n\n\t\t// Set PointSize according to size at current point in time.\n\t\t'    gl_PointSize = pointSizePerspective;',\n\t\t'    gl_Position = projectionMatrix * mvPosition;',\n\n\t\tTHREE.ShaderChunk.logdepthbuf_vertex,\n\t\tTHREE.ShaderChunk.fog_vertex,\n\n\t\t'}',\n\t].join( '\\n' ),\n\n\tfragment: [\n\t\tshaderChunks.uniforms,\n\n\t\tTHREE.ShaderChunk.common,\n\t\tTHREE.ShaderChunk.fog_pars_fragment,\n\t\tTHREE.ShaderChunk.logdepthbuf_pars_fragment,\n\n\t\tshaderChunks.varyings,\n\n\t\tshaderChunks.branchAvoidanceFunctions,\n\n\t\t'void main() {',\n\t\t'    vec3 outgoingLight = vColor.xyz;',\n\t\t'    ',\n\t\t'    #ifdef ALPHATEST',\n\t\t'       if ( vColor.w < float(ALPHATEST) ) discard;',\n\t\t'    #endif',\n\n\t\tshaderChunks.rotateTexture,\n\n\t\tTHREE.ShaderChunk.logdepthbuf_fragment,\n\n\t\t'    outgoingLight = vColor.xyz * rotatedTexture.xyz;',\n\t\t'    gl_FragColor = vec4( outgoingLight.xyz, rotatedTexture.w * vColor.w );',\n\n\t\tTHREE.ShaderChunk.fog_fragment,\n\n\t\t'}',\n\t].join( '\\n' ),\n};\n","/**\n * A map of supported distribution types used\n * by SPE.Emitter instances.\n *\n * These distribution types can be applied to\n * an emitter globally, which will affect the\n * `position`, `velocity`, and `acceleration`\n * value calculations for an emitter, or they\n * can be applied on a per-property basis.\n *\n * @enum {Number}\n */\nexport default {\n\n\t/**\n\t * Values will be distributed within a box.\n\t * @type {Number}\n\t */\n\tBOX: 1,\n\n\t/**\n\t * Values will be distributed on a sphere.\n\t * @type {Number}\n\t */\n\tSPHERE: 2,\n\n\t/**\n\t * Values will be distributed on a 2d-disc shape.\n\t * @type {Number}\n\t */\n\tDISC: 3,\n\n\t/**\n\t * Values will be distributed along a line.\n\t * @type {Number}\n\t */\n\tLINE: 4,\n};","import * as THREE from 'three';\nimport valueTypes from '@/constants/valueTypes';\nimport distributions from '@/constants/distributions';\nimport globals from '@/constants/globals';\nimport utils from './utils';\n\nconst HAS_OWN = Object.prototype.hasOwnProperty;\n\n/**\n * An SPE.Emitter instance.\n * @typedef {Object} Emitter\n * @see SPE.Emitter\n */\n\n/**\n * A map of options to configure an SPE.Emitter instance.\n *\n * @typedef {Object} EmitterOptions\n *\n * @property {distribution} [type=BOX] The default distribution this emitter should use to control\n *                         its particle's spawn position and force behaviour.\n *                         Must be an distributions.* value.\n *\n *\n * @property {Number} [particleCount=100] The total number of particles this emitter will hold. NOTE: this is not the number\n *                                  of particles emitted in a second, or anything like that. The number of particles\n *                                  emitted per-second is calculated by particleCount / maxAge (approximately!)\n *\n * @property {Number|null} [duration=null] The duration in seconds that this emitter should live for. If not specified, the emitter\n *                                         will emit particles indefinitely.\n *                                         NOTE: When an emitter is older than a specified duration, the emitter is NOT removed from\n *                                         it's group, but rather is just marked as dead, allowing it to be reanimated at a later time\n *                                         using `SPE.Emitter.prototype.enable()`.\n *\n * @property {Boolean} [isStatic=false] Whether this emitter should be not be simulated (true).\n * @property {Boolean} [activeMultiplier=1] A value between 0 and 1 describing what percentage of this emitter's particlesPerSecond should be\n *                                          emitted, where 0 is 0%, and 1 is 100%.\n *                                          For example, having an emitter with 100 particles, a maxAge of 2, yields a particlesPerSecond\n *                                          value of 50. Setting `activeMultiplier` to 0.5, then, will only emit 25 particles per second (0.5 = 50%).\n *                                          Values greater than 1 will emulate a burst of particles, causing the emitter to run out of particles\n *                                          before it's next activation cycle.\n *\n * @property {Boolean} [direction=1] The direction of the emitter. If value is `1`, emitter will start at beginning of particle's lifecycle.\n *                                   If value is `-1`, emitter will start at end of particle's lifecycle and work it's way backwards.\n *\n * @property {Object} [maxAge={}] An object describing the particle's maximum age in seconds.\n * @property {Number} [maxAge.value=2] A number between 0 and 1 describing the amount of maxAge to apply to all particles.\n * @property {Number} [maxAge.spread=0] A number describing the maxAge variance on a per-particle basis.\n *\n *\n * @property {Object} [position={}] An object describing this emitter's position.\n * @property {Object} [position.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base position.\n * @property {Object} [position.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis.\n *                                                          Note that when using a SPHERE or DISC distribution, only the x-component\n *                                                          of this vector is used.\n *                                                          When using a LINE distribution, this value is the endpoint of the LINE.\n * @property {Object} [position.spreadClamp=new THREE.Vector3()] A THREE.Vector3 instance describing the numeric multiples the particle's should\n *                                                               be spread out over.\n *                                                               Note that when using a SPHERE or DISC distribution, only the x-component\n *                                                               of this vector is used.\n *                                                               When using a LINE distribution, this property is ignored.\n * @property {Number} [position.radius=10] This emitter's base radius.\n * @property {Object} [position.radiusScale=new THREE.Vector3()] A THREE.Vector3 instance describing the radius's scale in all three axes. Allows a SPHERE or DISC to be squashed or stretched.\n * @property {distribution} [position.distribution=value of the `type` option.] A specific distribution to use when radiusing particles. Overrides the `type` option.\n * @property {Boolean} [position.randomise=false] When a particle is re-spawned, whether it's position should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [velocity={}] An object describing this particle velocity.\n * @property {Object} [velocity.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base velocity.\n * @property {Object} [velocity.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's velocity variance on a per-particle basis.\n *                                                          Note that when using a SPHERE or DISC distribution, only the x-component\n *                                                          of this vector is used.\n * @property {distribution} [velocity.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's velocity. Overrides the `type` option.\n * @property {Boolean} [velocity.randomise=false] When a particle is re-spawned, whether it's velocity should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [acceleration={}] An object describing this particle's acceleration.\n * @property {Object} [acceleration.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base acceleration.\n * @property {Object} [acceleration.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's acceleration variance on a per-particle basis.\n *                           Note that when using a SPHERE or DISC distribution, only the x-component\n *                           of this vector is used.\n * @property {distribution} [acceleration.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's acceleration. Overrides the `type` option.\n * @property {Boolean} [acceleration.randomise=false] When a particle is re-spawned, whether it's acceleration should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [drag={}] An object describing this particle drag. Drag is applied to both velocity and acceleration values.\n * @property {Number} [drag.value=0] A number between 0 and 1 describing the amount of drag to apply to all particles.\n * @property {Number} [drag.spread=0] A number describing the drag variance on a per-particle basis.\n * @property {Boolean} [drag.randomise=false] When a particle is re-spawned, whether it's drag should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [wiggle={}] This is quite a fun one! The values of this object will determine whether a particle will wiggle, or jiggle, or wave,\n *                                or shimmy, or waggle, or... Well you get the idea. The wiggle is calculated over-time, meaning that a particle will\n *                                start off with no wiggle, and end up wiggling about with the distance of the `value` specified by the time it dies.\n *                                It's quite handy to simulate fire embers, or similar effects where the particle's position should slightly change over\n *                                time, and such change isn't easily controlled by rotation, velocity, or acceleration. The wiggle is a combination of sin and cos calculations, so is circular in nature.\n * @property {Number} [wiggle.value=0] A number describing the amount of wiggle to apply to all particles. It's measured in distance.\n * @property {Number} [wiggle.spread=0] A number describing the wiggle variance on a per-particle basis.\n *\n *\n * @property {Object} [rotation={}] An object describing this emitter's rotation. It can either be static, or set to rotate from 0radians to the value of `rotation.value`\n *                                  over a particle's lifetime. Rotation values affect both a particle's position and the forces applied to it.\n * @property {Object} [rotation.axis=new THREE.Vector3(0, 1, 0)] A THREE.Vector3 instance describing this emitter's axis of rotation.\n * @property {Object} [rotation.axisSpread=new THREE.Vector3()] A THREE.Vector3 instance describing the amount of variance to apply to the axis of rotation on\n *                                                              a per-particle basis.\n * @property {Number} [rotation.angle=0] The angle of rotation, given in radians. If `rotation.static` is true, the emitter will start off rotated at this angle, and stay as such.\n *                                       Otherwise, the particles will rotate from 0radians to this value over their lifetimes.\n * @property {Number} [rotation.angleSpread=0] The amount of variance in each particle's rotation angle.\n * @property {Boolean} [rotation.static=false] Whether the rotation should be static or not.\n * @property {Object} [rotation.center=The value of `position.value`] A THREE.Vector3 instance describing the center point of rotation.\n * @property {Boolean} [rotation.randomise=false] When a particle is re-spawned, whether it's rotation should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [color={}] An object describing a particle's color. This property is a \"value-over-lifetime\" property, meaning an array of values and spreads can be\n *                               given to describe specific value changes over a particle's lifetime.\n *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of THREE.Color instances are given, then the array will be interpolated to\n *                               have a length matching the value of SPE.valueOverLifetimeLength.\n * @property {Object} [color.value=new THREE.Color()] Either a single THREE.Color instance, or an array of THREE.Color instances to describe the color of a particle over it's lifetime.\n * @property {Object} [color.spread=new THREE.Vector3()] Either a single THREE.Vector3 instance, or an array of THREE.Vector3 instances to describe the color variance of a particle over it's lifetime.\n * @property {Boolean} [color.randomise=false] When a particle is re-spawned, whether it's color should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [opacity={}] An object describing a particle's opacity. This property is a \"value-over-lifetime\" property, meaning an array of values and spreads can be\n *                               given to describe specific value changes over a particle's lifetime.\n *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to\n *                               have a length matching the value of SPE.valueOverLifetimeLength.\n * @property {Number} [opacity.value=1] Either a single number, or an array of numbers to describe the opacity of a particle over it's lifetime.\n * @property {Number} [opacity.spread=0] Either a single number, or an array of numbers to describe the opacity variance of a particle over it's lifetime.\n * @property {Boolean} [opacity.randomise=false] When a particle is re-spawned, whether it's opacity should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [size={}] An object describing a particle's size. This property is a \"value-over-lifetime\" property, meaning an array of values and spreads can be\n *                               given to describe specific value changes over a particle's lifetime.\n *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to\n *                               have a length matching the value of SPE.valueOverLifetimeLength.\n * @property {Number} [size.value=1] Either a single number, or an array of numbers to describe the size of a particle over it's lifetime.\n * @property {Number} [size.spread=0] Either a single number, or an array of numbers to describe the size variance of a particle over it's lifetime.\n * @property {Boolean} [size.randomise=false] When a particle is re-spawned, whether it's size should be re-randomised or not. Can incur a performance hit.\n *\n *\n * @property {Object} [angle={}] An object describing a particle's angle. The angle is a 2d-rotation, measured in radians, applied to the particle's texture.\n *                               NOTE: if a particle's texture is a sprite-sheet, this value IS IGNORED.\n *                               This property is a \"value-over-lifetime\" property, meaning an array of values and spreads can be\n *                               given to describe specific value changes over a particle's lifetime.\n *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to\n *                               have a length matching the value of SPE.valueOverLifetimeLength.\n * @property {Number} [angle.value=0] Either a single number, or an array of numbers to describe the angle of a particle over it's lifetime.\n * @property {Number} [angle.spread=0] Either a single number, or an array of numbers to describe the angle variance of a particle over it's lifetime.\n * @property {Boolean} [angle.randomise=false] When a particle is re-spawned, whether it's angle should be re-randomised or not. Can incur a performance hit.\n *\n */\n\n/**\n * The SPE.Emitter class.\n *\n * @constructor\n *\n * @param {EmitterOptions} options A map of options to configure the emitter.\n */\nexport default class Emitter {\n\tconstructor( opts ) {\n\t\t// Ensure we have a map of options to play with,\n\t\t// and that each option is in the correct format.\n\t\tconst options = utils.ensureTypedArg( opts, valueTypes.OBJECT, {} );\n\t\toptions.position = utils.ensureTypedArg( options.position, valueTypes.OBJECT, {} );\n\t\toptions.velocity = utils.ensureTypedArg( options.velocity, valueTypes.OBJECT, {} );\n\t\toptions.acceleration = utils.ensureTypedArg( options.acceleration, valueTypes.OBJECT, {} );\n\t\toptions.radius = utils.ensureTypedArg( options.radius, valueTypes.OBJECT, {} );\n\t\toptions.drag = utils.ensureTypedArg( options.drag, valueTypes.OBJECT, {} );\n\t\toptions.rotation = utils.ensureTypedArg( options.rotation, valueTypes.OBJECT, {} );\n\t\toptions.color = utils.ensureTypedArg( options.color, valueTypes.OBJECT, {} );\n\t\toptions.opacity = utils.ensureTypedArg( options.opacity, valueTypes.OBJECT, {} );\n\t\toptions.size = utils.ensureTypedArg( options.size, valueTypes.OBJECT, {} );\n\t\toptions.angle = utils.ensureTypedArg( options.angle, valueTypes.OBJECT, {} );\n\t\toptions.wiggle = utils.ensureTypedArg( options.wiggle, valueTypes.OBJECT, {} );\n\t\toptions.maxAge = utils.ensureTypedArg( options.maxAge, valueTypes.OBJECT, {} );\n\n\t\tif ( options.onParticleSpawn ) {\n\t\t\tconsole.warn( 'onParticleSpawn has been removed. Please set properties directly to alter values at runtime.' );\n\t\t}\n\n\t\tthis.uuid = THREE.Math.generateUUID();\n\n\t\tthis.type = utils.ensureTypedArg( options.type, valueTypes.NUMBER, distributions.BOX );\n\n\t\t// Start assigning properties...kicking it off with props that DON'T support values over\n\t\t// lifetimes.\n\t\t//\n\t\t// Btw, values over lifetimes are just the new way of referring to *Start, *Middle, and *End.\n\t\tthis.position = {\n\t\t\t_value: utils.ensureInstanceOf( options.position.value, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_spread: utils.ensureInstanceOf( options.position.spread, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_spreadClamp: utils.ensureInstanceOf( options.position.spreadClamp, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_distribution: utils.ensureTypedArg( options.position.distribution, valueTypes.NUMBER, this.type ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t\t_radius: utils.ensureTypedArg( options.position.radius, valueTypes.NUMBER, 10 ),\n\t\t\t_radiusScale: utils.ensureInstanceOf( options.position.radiusScale, THREE.Vector3, new THREE.Vector3( 1, 1, 1 ) ),\n\t\t\t_distributionClamp: utils.ensureTypedArg( options.position.distributionClamp, valueTypes.NUMBER, 0 ),\n\t\t};\n\n\t\tthis.velocity = {\n\t\t\t_value: utils.ensureInstanceOf( options.velocity.value, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_spread: utils.ensureInstanceOf( options.velocity.spread, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_distribution: utils.ensureTypedArg( options.velocity.distribution, valueTypes.NUMBER, this.type ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\t\tthis.acceleration = {\n\t\t\t_value: utils.ensureInstanceOf( options.acceleration.value, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_spread: utils.ensureInstanceOf( options.acceleration.spread, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_distribution: utils.ensureTypedArg( options.acceleration.distribution, valueTypes.NUMBER, this.type ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\t\tthis.drag = {\n\t\t\t_value: utils.ensureTypedArg( options.drag.value, valueTypes.NUMBER, 0 ),\n\t\t\t_spread: utils.ensureTypedArg( options.drag.spread, valueTypes.NUMBER, 0 ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\t\tthis.wiggle = {\n\t\t\t_value: utils.ensureTypedArg( options.wiggle.value, valueTypes.NUMBER, 0 ),\n\t\t\t_spread: utils.ensureTypedArg( options.wiggle.spread, valueTypes.NUMBER, 0 ),\n\t\t};\n\n\t\tthis.rotation = {\n\t\t\t_axis: utils.ensureInstanceOf( options.rotation.axis, THREE.Vector3, new THREE.Vector3( 0.0, 1.0, 0.0 ) ),\n\t\t\t_axisSpread: utils.ensureInstanceOf( options.rotation.axisSpread, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_angle: utils.ensureTypedArg( options.rotation.angle, valueTypes.NUMBER, 0 ),\n\t\t\t_angleSpread: utils.ensureTypedArg( options.rotation.angleSpread, valueTypes.NUMBER, 0 ),\n\t\t\t_static: utils.ensureTypedArg( options.rotation.static, valueTypes.BOOLEAN, false ),\n\t\t\t_center: utils.ensureInstanceOf( options.rotation.center, THREE.Vector3, this.position._value.clone() ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\n\t\tthis.maxAge = {\n\t\t\t_value: utils.ensureTypedArg( options.maxAge.value, valueTypes.NUMBER, 2 ),\n\t\t\t_spread: utils.ensureTypedArg( options.maxAge.spread, valueTypes.NUMBER, 0 ),\n\t\t};\n\n\n\n\t\t// The following properties can support either single values, or an array of values that change\n\t\t// the property over a particle's lifetime (value over lifetime).\n\t\tthis.color = {\n\t\t\t_value: utils.ensureArrayInstanceOf( options.color.value, THREE.Color, new THREE.Color() ),\n\t\t\t_spread: utils.ensureArrayInstanceOf( options.color.spread, THREE.Vector3, new THREE.Vector3() ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\t\tthis.opacity = {\n\t\t\t_value: utils.ensureArrayTypedArg( options.opacity.value, valueTypes.NUMBER, 1 ),\n\t\t\t_spread: utils.ensureArrayTypedArg( options.opacity.spread, valueTypes.NUMBER, 0 ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\t\tthis.size = {\n\t\t\t_value: utils.ensureArrayTypedArg( options.size.value, valueTypes.NUMBER, 1 ),\n\t\t\t_spread: utils.ensureArrayTypedArg( options.size.spread, valueTypes.NUMBER, 0 ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\t\tthis.angle = {\n\t\t\t_value: utils.ensureArrayTypedArg( options.angle.value, valueTypes.NUMBER, 0 ),\n\t\t\t_spread: utils.ensureArrayTypedArg( options.angle.spread, valueTypes.NUMBER, 0 ),\n\t\t\t_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\n\t\t// Assign renaining option values.\n\t\tthis.particleCount = utils.ensureTypedArg( options.particleCount, valueTypes.NUMBER, 100 );\n\t\tthis.duration = utils.ensureTypedArg( options.duration, valueTypes.NUMBER, null );\n\t\tthis.isStatic = utils.ensureTypedArg( options.isStatic, valueTypes.BOOLEAN, false );\n\t\tthis.activeMultiplier = utils.ensureTypedArg( options.activeMultiplier, valueTypes.NUMBER, 1 );\n\t\tthis.direction = utils.ensureTypedArg( options.direction, valueTypes.NUMBER, 1 );\n\n\t\t// Whether this emitter is alive or not.\n\t\tthis.alive = utils.ensureTypedArg( options.alive, valueTypes.BOOLEAN, true );\n\n\n\t\t// The following properties are set internally and are not\n\t\t// user-controllable.\n\t\tthis.particlesPerSecond = 0;\n\n\t\t// The current particle index for which particles should\n\t\t// be marked as active on the next update cycle.\n\t\tthis.activationIndex = 0;\n\n\t\t// The offset in the typed arrays this emitter's\n\t\t// particle's values will start at\n\t\tthis.attributeOffset = 0;\n\n\t\t// The end of the range in the attribute buffers\n\t\tthis.attributeEnd = 0;\n\n\n\n\t\t// Holds the time the emitter has been alive for.\n\t\tthis.age = 0.0;\n\n\t\t// Holds the number of currently-alive particles\n\t\tthis.activeParticleCount = 0.0;\n\n\t\t// Holds a reference to this emitter's group once\n\t\t// it's added to one.\n\t\tthis.group = null;\n\n\t\t// Holds a reference to this emitter's group's attributes object\n\t\t// for easier access.\n\t\tthis.attributes = null;\n\n\t\t// Holds a reference to the params attribute's typed array\n\t\t// for quicker access.\n\t\tthis.paramsArray = null;\n\n\t\t// A set of flags to determine whether particular properties\n\t\t// should be re-randomised when a particle is reset.\n\t\t//\n\t\t// If a `randomise` property is given, this is preferred.\n\t\t// Otherwise, it looks at whether a spread value has been\n\t\t// given.\n\t\t//\n\t\t// It allows randomization to be turned off as desired. If\n\t\t// all randomization is turned off, then I'd expect a performance\n\t\t// boost as no attribute buffers (excluding the `params`)\n\t\t// would have to be re-passed to the GPU each frame (since nothing\n\t\t// except the `params` attribute would have changed).\n\t\tthis.resetFlags = {\n\t\t\t// params: utils.ensureTypedArg( options.maxAge.randomise, valueTypes.BOOLEAN, !!options.maxAge.spread ) ||\n\t\t\t//     utils.ensureTypedArg( options.wiggle.randomise, valueTypes.BOOLEAN, !!options.wiggle.spread ),\n\t\t\tposition: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ) ||\n\t\t\t\tutils.ensureTypedArg( options.radius.randomise, valueTypes.BOOLEAN, false ),\n\t\t\tvelocity: utils.ensureTypedArg( options.velocity.randomise, valueTypes.BOOLEAN, false ),\n\t\t\tacceleration: utils.ensureTypedArg( options.acceleration.randomise, valueTypes.BOOLEAN, false ) ||\n\t\t\t\tutils.ensureTypedArg( options.drag.randomise, valueTypes.BOOLEAN, false ),\n\t\t\trotation: utils.ensureTypedArg( options.rotation.randomise, valueTypes.BOOLEAN, false ),\n\t\t\trotationCenter: utils.ensureTypedArg( options.rotation.randomise, valueTypes.BOOLEAN, false ),\n\t\t\tsize: utils.ensureTypedArg( options.size.randomise, valueTypes.BOOLEAN, false ),\n\t\t\tcolor: utils.ensureTypedArg( options.color.randomise, valueTypes.BOOLEAN, false ),\n\t\t\topacity: utils.ensureTypedArg( options.opacity.randomise, valueTypes.BOOLEAN, false ),\n\t\t\tangle: utils.ensureTypedArg( options.angle.randomise, valueTypes.BOOLEAN, false ),\n\t\t};\n\n\t\tthis.updateFlags = {};\n\t\tthis.updateCounts = {};\n\n\t\t// A map to indicate which emitter parameters should update\n\t\t// which attribute.\n\t\tthis.updateMap = {\n\t\t\tmaxAge: 'params',\n\t\t\tposition: 'position',\n\t\t\tvelocity: 'velocity',\n\t\t\tacceleration: 'acceleration',\n\t\t\tdrag: 'acceleration',\n\t\t\twiggle: 'params',\n\t\t\trotation: 'rotation',\n\t\t\tsize: 'size',\n\t\t\tcolor: 'color',\n\t\t\topacity: 'opacity',\n\t\t\tangle: 'angle',\n\t\t};\n\n\t\tfor ( const i in this.updateMap ) {\n\t\t\tif ( HAS_OWN.call( this.updateMap, i ) ) {\n\t\t\t\tthis.updateCounts[ this.updateMap[ i ] ] = 0.0;\n\t\t\t\tthis.updateFlags[ this.updateMap[ i ] ] = false;\n\t\t\t\tthis._createGetterSetters( this[ i ], i );\n\t\t\t}\n\t\t}\n\n\t\tthis.bufferUpdateRanges = {};\n\t\tthis.attributeKeys = null;\n\t\tthis.attributeCount = 0;\n\n\n\t\t// Ensure that the value-over-lifetime property objects above\n\t\t// have value and spread properties that are of the same length.\n\t\t//\n\t\t// Also, for now, make sure they have a length of 3 (min/max arguments here).\n\t\tutils.ensureValueOverLifetimeCompliance( this.color, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );\n\t\tutils.ensureValueOverLifetimeCompliance( this.opacity, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );\n\t\tutils.ensureValueOverLifetimeCompliance( this.size, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );\n\t\tutils.ensureValueOverLifetimeCompliance( this.angle, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );\n\t}\n\n\t_createGetterSetters( propObj, propName ) {\n\t\tconst self = this;\n\n\t\tfor ( const i in propObj ) {\n\t\t\tif ( HAS_OWN.call( propObj, i ) ) {\n\n\t\t\t\tconst name = i.replace( '_', '' );\n\n\t\t\t\tObject.defineProperty( propObj, name, {\n\t\t\t\t\tget: ( function( prop ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\treturn this[ prop ];\n\t\t\t\t\t\t};\n\t\t\t\t\t}( i ) ),\n\n\t\t\t\t\tset: ( function( prop ) {\n\t\t\t\t\t\treturn function( value ) {\n\t\t\t\t\t\t\tconst mapName = self.updateMap[ propName ],\n\t\t\t\t\t\t\t\tprevValue = this[ prop ],\n\t\t\t\t\t\t\t\tlength = globals.valueOverLifetimeLength;\n\n\t\t\t\t\t\t\tif ( prop === '_rotationCenter' ) {\n\t\t\t\t\t\t\t\tself.updateFlags.rotationCenter = true;\n\t\t\t\t\t\t\t\tself.updateCounts.rotationCenter = 0.0;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\telse if ( prop === '_randomise' ) {\n\t\t\t\t\t\t\t\tself.resetFlags[ mapName ] = value;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\tself.updateFlags[ mapName ] = true;\n\t\t\t\t\t\t\t\tself.updateCounts[ mapName ] = 0.0;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tself.group._updateDefines();\n\n\t\t\t\t\t\t\tthis[ prop ] = value;\n\n\t\t\t\t\t\t\t// If the previous value was an array, then make\n\t\t\t\t\t\t\t// sure the provided value is interpolated correctly.\n\t\t\t\t\t\t\tif ( Array.isArray( prevValue ) ) {\n\t\t\t\t\t\t\t\tutils.ensureValueOverLifetimeCompliance( self[ propName ], length, length );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}( i ) ),\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t}\n\n\t_setBufferUpdateRanges( keys ) {\n\t\tthis.attributeKeys = keys;\n\t\tthis.attributeCount = keys.length;\n\n\t\tfor ( let i = this.attributeCount - 1; i >= 0; --i ) {\n\t\t\tthis.bufferUpdateRanges[ keys[ i ] ] = {\n\t\t\t\tmin: Number.POSITIVE_INFINITY,\n\t\t\t\tmax: Number.NEGATIVE_INFINITY,\n\t\t\t};\n\t\t}\n\t}\n\n\t_calculatePPSValue( groupMaxAge ) {\n\t\tconst particleCount = this.particleCount;\n\n\t\t// Calculate the `particlesPerSecond` value for this emitter. It's used\n\t\t// when determining which particles should die and which should live to\n\t\t// see another day. Or be born, for that matter. The \"God\" property.\n\t\tif ( this.duration ) {\n\t\t\tthis.particlesPerSecond = particleCount / ( groupMaxAge < this.duration ? groupMaxAge : this.duration );\n\t\t}\n\t\telse {\n\t\t\tthis.particlesPerSecond = particleCount / groupMaxAge;\n\t\t}\n\t}\n\n\t_setAttributeOffset( startIndex ) {\n\t\tthis.attributeOffset = startIndex;\n\t\tthis.activationIndex = startIndex;\n\t\tthis.activationEnd = startIndex + this.particleCount;\n\t}\n\n\n\t_assignValue( prop, index ) {\n\t\tswitch ( prop ) {\n\t\t\tcase 'position':\n\t\t\t\tthis._assignPositionValue( index );\n\t\t\t\tbreak;\n\n\t\t\tcase 'velocity':\n\t\t\tcase 'acceleration':\n\t\t\t\tthis._assignForceValue( index, prop );\n\t\t\t\tbreak;\n\n\t\t\tcase 'size':\n\t\t\tcase 'opacity':\n\t\t\t\tthis._assignAbsLifetimeValue( index, prop );\n\t\t\t\tbreak;\n\n\t\t\tcase 'angle':\n\t\t\t\tthis._assignAngleValue( index );\n\t\t\t\tbreak;\n\n\t\t\tcase 'params':\n\t\t\t\tthis._assignParamsValue( index );\n\t\t\t\tbreak;\n\n\t\t\tcase 'rotation':\n\t\t\t\tthis._assignRotationValue( index );\n\t\t\t\tbreak;\n\n\t\t\tcase 'color':\n\t\t\t\tthis._assignColorValue( index );\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\t_assignPositionValue( index ) {\n\t\tconst prop = this.position,\n\t\t\tattr = this.attributes.position,\n\t\t\tvalue = prop._value,\n\t\t\tspread = prop._spread,\n\t\t\tdistribution = prop._distribution;\n\n\t\tswitch ( distribution ) {\n\t\t\tcase distributions.BOX:\n\t\t\t\tutils.randomVector3( attr, index, value, spread, prop._spreadClamp );\n\t\t\t\tbreak;\n\n\t\t\tcase distributions.SPHERE:\n\t\t\t\tutils.randomVector3OnSphere( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x, prop._distributionClamp || this.particleCount );\n\t\t\t\tbreak;\n\n\t\t\tcase distributions.DISC:\n\t\t\t\tutils.randomVector3OnDisc( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x );\n\t\t\t\tbreak;\n\n\t\t\tcase distributions.LINE:\n\t\t\t\tutils.randomVector3OnLine( attr, index, value, spread );\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\t_assignForceValue( index, attrName ) {\n\t\tconst prop = this[ attrName ],\n\t\t\tvalue = prop._value,\n\t\t\tspread = prop._spread,\n\t\t\tdistribution = prop._distribution;\n\t\tlet pos,\n\t\t\tpositionX,\n\t\t\tpositionY,\n\t\t\tpositionZ,\n\t\t\ti;\n\n\t\tswitch ( distribution ) {\n\t\t\tcase distributions.BOX:\n\t\t\t\tutils.randomVector3( this.attributes[ attrName ], index, value, spread );\n\t\t\t\tbreak;\n\n\t\t\tcase distributions.SPHERE:\n\t\t\t\tpos = this.attributes.position.typedArray.array;\n\t\t\t\ti = index * 3;\n\n\t\t\t\t// Ensure position values aren't zero, otherwise no force will be\n\t\t\t\t// applied.\n\t\t\t\t// positionX = utils.zeroToEpsilon( pos[ i ], true );\n\t\t\t\t// positionY = utils.zeroToEpsilon( pos[ i + 1 ], true );\n\t\t\t\t// positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );\n\t\t\t\tpositionX = pos[ i ];\n\t\t\t\tpositionY = pos[ i + 1 ];\n\t\t\t\tpositionZ = pos[ i + 2 ];\n\n\t\t\t\tutils.randomDirectionVector3OnSphere(\n\t\t\t\t\tthis.attributes[ attrName ], index,\n\t\t\t\t\tpositionX, positionY, positionZ,\n\t\t\t\t\tthis.position._value,\n\t\t\t\t\tprop._value.x,\n\t\t\t\t\tprop._spread.x\n\t\t\t\t);\n\t\t\t\tbreak;\n\n\t\t\tcase distributions.DISC:\n\t\t\t\tpos = this.attributes.position.typedArray.array;\n\t\t\t\ti = index * 3;\n\n\t\t\t\t// Ensure position values aren't zero, otherwise no force will be\n\t\t\t\t// applied.\n\t\t\t\t// positionX = utils.zeroToEpsilon( pos[ i ], true );\n\t\t\t\t// positionY = utils.zeroToEpsilon( pos[ i + 1 ], true );\n\t\t\t\t// positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );\n\t\t\t\tpositionX = pos[ i ];\n\t\t\t\tpositionY = pos[ i + 1 ];\n\t\t\t\tpositionZ = pos[ i + 2 ];\n\n\t\t\t\tutils.randomDirectionVector3OnDisc(\n\t\t\t\t\tthis.attributes[ attrName ], index,\n\t\t\t\t\tpositionX, positionY, positionZ,\n\t\t\t\t\tthis.position._value,\n\t\t\t\t\tprop._value.x,\n\t\t\t\t\tprop._spread.x\n\t\t\t\t);\n\t\t\t\tbreak;\n\n\t\t\tcase distributions.LINE:\n\t\t\t\tutils.randomVector3OnLine( this.attributes[ attrName ], index, value, spread );\n\t\t\t\tbreak;\n\t\t}\n\n\t\tif ( attrName === 'acceleration' ) {\n\t\t\tconst drag = utils.clamp( utils.randomFloat( this.drag._value, this.drag._spread ), 0, 1 );\n\t\t\tthis.attributes.acceleration.typedArray.array[ index * 4 + 3 ] = drag;\n\t\t}\n\t}\n\n\t_assignAbsLifetimeValue( index, propName ) {\n\t\tconst array = this.attributes[ propName ].typedArray,\n\t\t\tprop = this[ propName ];\n\n\t\tif ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {\n\t\t\tconst value = Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) );\n\t\t\tarray.setVec4Components( index, value, value, value, value );\n\t\t}\n\t\telse {\n\t\t\tarray.setVec4Components( index,\n\t\t\t\tMath.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) ),\n\t\t\t\tMath.abs( utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ) ),\n\t\t\t\tMath.abs( utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ) ),\n\t\t\t\tMath.abs( utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] ) )\n\t\t\t);\n\t\t}\n\t}\n\n\t_assignAngleValue( index ) {\n\t\tconst array = this.attributes.angle.typedArray,\n\t\t\tprop = this.angle;\n\n\t\tif ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {\n\t\t\tconst value = utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] );\n\t\t\tarray.setVec4Components( index, value, value, value, value );\n\t\t}\n\t\telse {\n\t\t\tarray.setVec4Components( index,\n\t\t\t\tutils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ),\n\t\t\t\tutils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ),\n\t\t\t\tutils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ),\n\t\t\t\tutils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] )\n\t\t\t);\n\t\t}\n\t}\n\n\t_assignParamsValue( index ) {\n\t\tthis.attributes.params.typedArray.setVec4Components( index,\n\t\t\tthis.isStatic ? 1 : 0,\n\t\t\t0.0,\n\t\t\tMath.abs( utils.randomFloat( this.maxAge._value, this.maxAge._spread ) ),\n\t\t\tutils.randomFloat( this.wiggle._value, this.wiggle._spread )\n\t\t);\n\t}\n\n\t_assignRotationValue( index ) {\n\t\tthis.attributes.rotation.typedArray.setVec3Components( index,\n\t\t\tutils.getPackedRotationAxis( this.rotation._axis, this.rotation._axisSpread ),\n\t\t\tutils.randomFloat( this.rotation._angle, this.rotation._angleSpread ),\n\t\t\tthis.rotation._static ? 0 : 1\n\t\t);\n\n\t\tthis.attributes.rotationCenter.typedArray.setVec3( index, this.rotation._center );\n\t}\n\n\t_assignColorValue( index ) {\n\t\tutils.randomColorAsHex( this.attributes.color, index, this.color._value, this.color._spread );\n\t}\n\n\t_resetParticle( index ) {\n\t\tconst resetFlags = this.resetFlags,\n\t\t\tupdateFlags = this.updateFlags,\n\t\t\tupdateCounts = this.updateCounts,\n\t\t\tkeys = this.attributeKeys;\n\t\tlet key,\n\t\t\tupdateFlag;\n\n\t\tfor ( let i = this.attributeCount - 1; i >= 0; --i ) {\n\t\t\tkey = keys[ i ];\n\t\t\tupdateFlag = updateFlags[ key ];\n\n\t\t\tif ( resetFlags[ key ] === true || updateFlag === true ) {\n\t\t\t\tthis._assignValue( key, index );\n\t\t\t\tthis._updateAttributeUpdateRange( key, index );\n\n\t\t\t\tif ( updateFlag === true && updateCounts[ key ] === this.particleCount ) {\n\t\t\t\t\tupdateFlags[ key ] = false;\n\t\t\t\t\tupdateCounts[ key ] = 0.0;\n\t\t\t\t}\n\t\t\t\telse if ( updateFlag == true ) {\n\t\t\t\t\t++updateCounts[ key ];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t_updateAttributeUpdateRange( attr, i ) {\n\t\tvar ranges = this.bufferUpdateRanges[ attr ];\n\n\t\tranges.min = Math.min( i, ranges.min );\n\t\tranges.max = Math.max( i, ranges.max );\n\t}\n\n\t_resetBufferRanges() {\n\t\tconst ranges = this.bufferUpdateRanges,\n\t\t\tkeys = this.bufferUpdateKeys;\n\t\tlet i = this.bufferUpdateCount - 1,\n\t\t\tkey;\n\n\t\tfor ( i; i >= 0; --i ) {\n\t\t\tkey = keys[ i ];\n\t\t\tranges[ key ].min = Number.POSITIVE_INFINITY;\n\t\t\tranges[ key ].max = Number.NEGATIVE_INFINITY;\n\t\t}\n\t}\n\n\t_onRemove() {\n\t\t// Reset any properties of the emitter that were set by\n\t\t// a group when it was added.\n\t\tthis.particlesPerSecond = 0;\n\t\tthis.attributeOffset = 0;\n\t\tthis.activationIndex = 0;\n\t\tthis.activeParticleCount = 0;\n\t\tthis.group = null;\n\t\tthis.attributes = null;\n\t\tthis.paramsArray = null;\n\t\tthis.age = 0.0;\n\t}\n\n\t_decrementParticleCount() {\n\t\t--this.activeParticleCount;\n\n\t\t// TODO:\n\t\t//  - Trigger event if count === 0.\n\t}\n\n\t_incrementParticleCount() {\n\t\t'use strict';\n\t\t++this.activeParticleCount;\n\n\t\t// TODO:\n\t\t//  - Trigger event if count === this.particleCount.\n\t}\n\n\t_checkParticleAges( start, end, params, dt ) {\n\t\tfor ( let i = end - 1, index, maxAge, age, alive; i >= start; --i ) {\n\t\t\tindex = i * 4;\n\n\t\t\talive = params[ index ];\n\n\t\t\tif ( alive === 0.0 ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Increment age\n\t\t\tage = params[ index + 1 ];\n\t\t\tmaxAge = params[ index + 2 ];\n\n\t\t\tif ( this.direction === 1 ) {\n\t\t\t\tage += dt;\n\n\t\t\t\tif ( age >= maxAge ) {\n\t\t\t\t\tage = 0.0;\n\t\t\t\t\talive = 0.0;\n\t\t\t\t\tthis._decrementParticleCount();\n\t\t\t\t}\n\t\t\t}\n\t\t\telse {\n\t\t\t\tage -= dt;\n\n\t\t\t\tif ( age <= 0.0 ) {\n\t\t\t\t\tage = maxAge;\n\t\t\t\t\talive = 0.0;\n\t\t\t\t\tthis._decrementParticleCount();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tparams[ index ] = alive;\n\t\t\tparams[ index + 1 ] = age;\n\n\t\t\tthis._updateAttributeUpdateRange( 'params', i );\n\t\t}\n\t}\n\n\t_activateParticles( activationStart, activationEnd, params, dtPerParticle ) {\n\t\tconst direction = this.direction;\n\n\t\tfor ( let i = activationStart, index, dtValue; i < activationEnd; ++i ) {\n\t\t\tindex = i * 4;\n\n\t\t\t// Don't re-activate particles that aren't dead yet.\n\t\t\t// if ( params[ index ] !== 0.0 && ( this.particleCount !== 1 || this.activeMultiplier !== 1 ) ) {\n\t\t\t//     continue;\n\t\t\t// }\n\n\t\t\tif ( params[ index ] != 0.0 && this.particleCount !== 1 ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Increment the active particle count.\n\t\t\tthis._incrementParticleCount();\n\n\t\t\t// Mark the particle as alive.\n\t\t\tparams[ index ] = 1.0;\n\n\t\t\t// Reset the particle\n\t\t\tthis._resetParticle( i );\n\n\t\t\t// Move each particle being activated to\n\t\t\t// it's actual position in time.\n\t\t\t//\n\t\t\t// This stops particles being 'clumped' together\n\t\t\t// when frame rates are on the lower side of 60fps\n\t\t\t// or not constant (a very real possibility!)\n\t\t\tdtValue = dtPerParticle * ( i - activationStart );\n\t\t\tparams[ index + 1 ] = direction === -1 ? params[ index + 2 ] - dtValue : dtValue;\n\n\t\t\tthis._updateAttributeUpdateRange( 'params', i );\n\t\t}\n\t}\n\n\t/**\n\t * Simulates one frame's worth of particles, updating particles\n\t * that are already alive, and marking ones that are currently dead\n\t * but should be alive as alive.\n\t *\n\t * If the emitter is marked as static, then this function will do nothing.\n\t *\n\t * @param  {Number} dt The number of seconds to simulate (deltaTime)\n\t */\n\ttick( dt ) {\n\t\tif ( this.isStatic ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( this.paramsArray === null ) {\n\t\t\tthis.paramsArray = this.attributes.params.typedArray.array;\n\t\t}\n\n\t\tconst start = this.attributeOffset,\n\t\t\tend = start + this.particleCount,\n\t\t\tparams = this.paramsArray, // vec3( alive, age, maxAge, wiggle )\n\t\t\tppsDt = this.particlesPerSecond * this.activeMultiplier * dt,\n\t\t\tactivationIndex = this.activationIndex;\n\n\t\t// Reset the buffer update indices.\n\t\tthis._resetBufferRanges();\n\n\t\t// Increment age for those particles that are alive,\n\t\t// and kill off any particles whose age is over the limit.\n\t\tthis._checkParticleAges( start, end, params, dt );\n\n\t\t// If the emitter is dead, reset the age of the emitter to zero,\n\t\t// ready to go again if required\n\t\tif ( this.alive === false ) {\n\t\t\tthis.age = 0.0;\n\t\t\treturn;\n\t\t}\n\n\t\t// If the emitter has a specified lifetime and we've exceeded it,\n\t\t// mark the emitter as dead.\n\t\tif ( this.duration !== null && this.age > this.duration ) {\n\t\t\tthis.alive = false;\n\t\t\tthis.age = 0.0;\n\t\t\treturn;\n\t\t}\n\n\n\t\tconst activationStart = this.particleCount === 1 ? activationIndex : ( activationIndex | 0 ),\n\t\t\tactivationEnd = Math.min( activationStart + ppsDt, this.activationEnd ),\n\t\t\tactivationCount = activationEnd - this.activationIndex | 0,\n\t\t\tdtPerParticle = activationCount > 0 ? dt / activationCount : 0;\n\n\t\tthis._activateParticles( activationStart, activationEnd, params, dtPerParticle );\n\n\t\t// Move the activation window forward, soldier.\n\t\tthis.activationIndex += ppsDt;\n\n\t\tif ( this.activationIndex > end ) {\n\t\t\tthis.activationIndex = start;\n\t\t}\n\n\n\t\t// Increment the age of the emitter.\n\t\tthis.age += dt;\n\t}\n\n\t/**\n\t * Resets all the emitter's particles to their start positions\n\t * and marks the particles as dead if the `force` argument is\n\t * true.\n\t *\n\t * @param  {Boolean} [force=undefined] If true, all particles will be marked as dead instantly.\n\t * @return {Emitter}       This emitter instance.\n\t */\n\treset( force ) {\n\t\tthis.age = 0.0;\n\t\tthis.alive = false;\n\n\t\tif ( force === true ) {\n\t\t\tconst start = this.attributeOffset,\n\t\t\t\tend = start + this.particleCount,\n\t\t\t\tarray = this.paramsArray,\n\t\t\t\tattr = this.attributes.params.bufferAttribute;\n\n\t\t\tfor ( let i = end - 1, index; i >= start; --i ) {\n\t\t\t\tindex = i * 4;\n\n\t\t\t\tarray[ index ] = 0.0;\n\t\t\t\tarray[ index + 1 ] = 0.0;\n\t\t\t}\n\n\t\t\tattr.updateRange.offset = 0;\n\t\t\tattr.updateRange.count = -1;\n\t\t\tattr.needsUpdate = true;\n\t\t}\n\n\t\treturn this;\n\t}\n\n\t/**\n\t * Enables the emitter. If not already enabled, the emitter\n\t * will start emitting particles.\n\t *\n\t * @return {Emitter} This emitter instance.\n\t */\n\tenable() {\n\t\tthis.alive = true;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Disables th emitter, but does not instantly remove it's\n\t * particles fromt the scene. When called, the emitter will be\n\t * 'switched off' and just stop emitting. Any particle's alive will\n\t * be allowed to finish their lifecycle.\n\t *\n\t * @return {Emitter} This emitter instance.\n\t */\n\tdisable() {\n\t\tthis.alive = false;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Remove this emitter from it's parent group (if it has been added to one).\n\t * Delgates to Group.prototype.removeEmitter().\n\t *\n\t * When called, all particle's belonging to this emitter will be instantly\n\t * removed from the scene.\n\t *\n\t * @return {Emitter} This emitter instance.\n\t *\n\t * @see Group.prototype.removeEmitter\n\t */\n\tremove() {\n\t\tif ( this.group !== null ) {\n\t\t\tthis.group.removeEmitter( this );\n\t\t}\n\t\telse {\n\t\t\tconsole.error( 'Emitter does not belong to a group, cannot remove.' );\n\t\t}\n\n\t\treturn this;\n\t}\n}","import * as THREE from 'three';\nimport valueTypes from '@/constants/valueTypes';\nimport globals from '@/constants/globals';\nimport utils from './utils';\nimport ShaderAttribute from '@/helpers/ShaderAttribute';\nimport shaders from '@/shaders/shaders';\nimport Emitter from './Emitter';\n\nconst HAS_OWN = Object.prototype.hasOwnProperty;\n\n/**\n * An SPE.Group instance.\n * @typedef {Object} Group\n * @see SPE.Group\n */\n\n/**\n * A map of options to configure an SPE.Group instance.\n * @typedef {Object} GroupOptions\n *\n * @property {Object} texture An object describing the texture used by the group.\n *\n * @property {Object} texture.value An instance of THREE.Texture.\n *\n * @property {Object=} texture.frames A THREE.Vector2 instance describing the number\n *                                    of frames on the x- and y-axis of the given texture.\n *                                    If not provided, the texture will NOT be treated as\n *                                    a sprite-sheet and as such will NOT be animated.\n *\n * @property {Number} [texture.frameCount=texture.frames.x * texture.frames.y] The total number of frames in the sprite-sheet.\n *                                                                   Allows for sprite-sheets that don't fill the entire\n *                                                                   texture.\n *\n * @property {Number} texture.loop The number of loops through the sprite-sheet that should\n *                                 be performed over the course of a single particle's lifetime.\n *\n * @property {Number} fixedTimeStep If no `dt` (or `deltaTime`) value is passed to this group's\n *                                  `tick()` function, this number will be used to move the particle\n *                                  simulation forward. Value in SECONDS.\n *\n * @property {Boolean} hasPerspective Whether the distance a particle is from the camera should affect\n *                                    the particle's size.\n *\n * @property {Boolean} colorize Whether the particles in this group should be rendered with color, or\n *                              whether the only color of particles will come from the provided texture.\n *\n * @property {Number} blending One of Three.js's blending modes to apply to this group's `ShaderMaterial`.\n *\n * @property {Boolean} transparent Whether these particle's should be rendered with transparency.\n *\n * @property {Number} alphaTest Sets the alpha value to be used when running an alpha test on the `texture.value` property. Value between 0 and 1.\n *\n * @property {Boolean} depthWrite Whether rendering the group has any effect on the depth buffer.\n *\n * @property {Boolean} depthTest Whether to have depth test enabled when rendering this group.\n *\n * @property {Boolean} fog Whether this group's particles should be affected by their scene's fog.\n *\n * @property {Number} scale The scale factor to apply to this group's particle sizes. Useful for\n *                          setting particle sizes to be relative to renderer size.\n */\n\n\n/**\n * The SPE.Group class. Creates a new group, containing a material, geometry, and mesh.\n *\n * @constructor\n * @param {GroupOptions} options A map of options to configure the group instance.\n */\nexport default class Group {\n\tconstructor( opts ) {\n\t\t// Ensure we have a map of options to play with\n\t\tconst options = utils.ensureTypedArg( opts, valueTypes.OBJECT, {} );\n\t\toptions.texture = utils.ensureTypedArg( options.texture, valueTypes.OBJECT, {} );\n\n\t\t// Assign a UUID to this instance\n\t\tthis.uuid = THREE.Math.generateUUID();\n\n\t\t// If no `deltaTime` value is passed to the `SPE.Group.tick` function,\n\t\t// the value of this property will be used to advance the simulation.\n\t\tthis.fixedTimeStep = utils.ensureTypedArg( options.fixedTimeStep, valueTypes.NUMBER, 0.016 );\n\n\t\t// Set properties used in the uniforms map, starting with the\n\t\t// texture stuff.\n\t\tthis.texture = utils.ensureInstanceOf( options.texture.value, THREE.Texture, null );\n\t\tthis.textureFrames = utils.ensureInstanceOf( options.texture.frames, THREE.Vector2, new THREE.Vector2( 1, 1 ) );\n\t\tthis.textureFrameCount = utils.ensureTypedArg( options.texture.frameCount, valueTypes.NUMBER, this.textureFrames.x * this.textureFrames.y );\n\t\tthis.textureLoop = utils.ensureTypedArg( options.texture.loop, valueTypes.NUMBER, 1 );\n\t\tthis.textureFrames.max( new THREE.Vector2( 1, 1 ) );\n\n\t\tthis.hasPerspective = utils.ensureTypedArg( options.hasPerspective, valueTypes.BOOLEAN, true );\n\t\tthis.colorize = utils.ensureTypedArg( options.colorize, valueTypes.BOOLEAN, true );\n\n\t\tthis.maxParticleCount = utils.ensureTypedArg( options.maxParticleCount, valueTypes.NUMBER, null );\n\n\n\t\t// Set properties used to define the ShaderMaterial's appearance.\n\t\tthis.blending = utils.ensureTypedArg( options.blending, valueTypes.NUMBER, THREE.AdditiveBlending );\n\t\tthis.transparent = utils.ensureTypedArg( options.transparent, valueTypes.BOOLEAN, true );\n\t\tthis.alphaTest = parseFloat( utils.ensureTypedArg( options.alphaTest, valueTypes.NUMBER, 0.0 ) );\n\t\tthis.depthWrite = utils.ensureTypedArg( options.depthWrite, valueTypes.BOOLEAN, false );\n\t\tthis.depthTest = utils.ensureTypedArg( options.depthTest, valueTypes.BOOLEAN, true );\n\t\tthis.fog = utils.ensureTypedArg( options.fog, valueTypes.BOOLEAN, true );\n\t\tthis.scale = utils.ensureTypedArg( options.scale, valueTypes.NUMBER, 300 );\n\n\t\t// Where emitter's go to curl up in a warm blanket and live\n\t\t// out their days.\n\t\tthis.emitters = [];\n\t\tthis.emitterIDs = [];\n\n\t\t// Create properties for use by the emitter pooling functions.\n\t\tthis._pool = [];\n\t\tthis._poolCreationSettings = null;\n\t\tthis._createNewWhenPoolEmpty = 0;\n\n\t\t// Whether all attributes should be forced to updated\n\t\t// their entire buffer contents on the next tick.\n\t\t//\n\t\t// Used when an emitter is removed.\n\t\tthis._attributesNeedRefresh = false;\n\t\tthis._attributesNeedDynamicReset = false;\n\n\t\tthis.particleCount = 0;\n\n\n\t\t// Map of uniforms to be applied to the ShaderMaterial instance.\n\t\tthis.uniforms = {\n\t\t\ttex: {\n\t\t\t\ttype: 't',\n\t\t\t\tvalue: this.texture,\n\t\t\t},\n\t\t\ttextureAnimation: {\n\t\t\t\ttype: 'v4',\n\t\t\t\tvalue: new THREE.Vector4(\n\t\t\t\t\tthis.textureFrames.x,\n\t\t\t\t\tthis.textureFrames.y,\n\t\t\t\t\tthis.textureFrameCount,\n\t\t\t\t\tMath.max( Math.abs( this.textureLoop ), 1.0 )\n\t\t\t\t),\n\t\t\t},\n\t\t\tfogColor: {\n\t\t\t\ttype: 'c',\n\t\t\t\tvalue: this.fog ? new THREE.Color() : null,\n\t\t\t},\n\t\t\tfogNear: {\n\t\t\t\ttype: 'f',\n\t\t\t\tvalue: 10,\n\t\t\t},\n\t\t\tfogFar: {\n\t\t\t\ttype: 'f',\n\t\t\t\tvalue: 200,\n\t\t\t},\n\t\t\tfogDensity: {\n\t\t\t\ttype: 'f',\n\t\t\t\tvalue: 0.5,\n\t\t\t},\n\t\t\tdeltaTime: {\n\t\t\t\ttype: 'f',\n\t\t\t\tvalue: 0,\n\t\t\t},\n\t\t\trunTime: {\n\t\t\t\ttype: 'f',\n\t\t\t\tvalue: 0,\n\t\t\t},\n\t\t\tscale: {\n\t\t\t\ttype: 'f',\n\t\t\t\tvalue: this.scale,\n\t\t\t},\n\t\t};\n\n\t\t// Add some defines into the mix...\n\t\tthis.defines = {\n\t\t\tHAS_PERSPECTIVE: this.hasPerspective,\n\t\t\tCOLORIZE: this.colorize,\n\t\t\tVALUE_OVER_LIFETIME_LENGTH: globals.valueOverLifetimeLength,\n\n\t\t\tSHOULD_ROTATE_TEXTURE: false,\n\t\t\tSHOULD_ROTATE_PARTICLES: false,\n\t\t\tSHOULD_WIGGLE_PARTICLES: false,\n\n\t\t\tSHOULD_CALCULATE_SPRITE: this.textureFrames.x > 1 || this.textureFrames.y > 1,\n\t\t};\n\n\t\t// Map of all attributes to be applied to the particles.\n\t\t//\n\t\t// See `ShaderAttribute` for a bit more info on this.\n\t\tthis.attributes = {\n\t\t\tposition: new ShaderAttribute( 'v3', true ),\n\t\t\tacceleration: new ShaderAttribute( 'v4', true ), // w component is drag\n\t\t\tvelocity: new ShaderAttribute( 'v3', true ),\n\t\t\trotation: new ShaderAttribute( 'v4', true ),\n\t\t\trotationCenter: new ShaderAttribute( 'v3', true ),\n\t\t\tparams: new ShaderAttribute( 'v4', true ), // Holds (alive, age, delay, wiggle)\n\t\t\tsize: new ShaderAttribute( 'v4', true ),\n\t\t\tangle: new ShaderAttribute( 'v4', true ),\n\t\t\tcolor: new ShaderAttribute( 'v4', true ),\n\t\t\topacity: new ShaderAttribute( 'v4', true ),\n\t\t};\n\n\t\tthis.attributeKeys = Object.keys( this.attributes );\n\t\tthis.attributeCount = this.attributeKeys.length;\n\n\t\t// Create the ShaderMaterial instance that'll help render the\n\t\t// particles.\n\t\tthis.material = new THREE.ShaderMaterial( {\n\t\t\tuniforms: this.uniforms,\n\t\t\tvertexShader: shaders.vertex,\n\t\t\tfragmentShader: shaders.fragment,\n\t\t\tblending: this.blending,\n\t\t\ttransparent: this.transparent,\n\t\t\talphaTest: this.alphaTest,\n\t\t\tdepthWrite: this.depthWrite,\n\t\t\tdepthTest: this.depthTest,\n\t\t\tdefines: this.defines,\n\t\t\tfog: this.fog,\n\t\t} );\n\n\t\t// Create the BufferGeometry and Points instances, ensuring\n\t\t// the geometry and material are given to the latter.\n\t\tthis.geometry = new THREE.BufferGeometry();\n\t\tthis.mesh = new THREE.Points( this.geometry, this.material );\n\n\t\tif ( this.maxParticleCount === null ) {\n\t\t\tconsole.warn( 'SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.' );\n\t\t}\n\t}\n\n\t_updateDefines() {\n\t\tconst emitters = this.emitters,\n\t\t\tdefines = this.defines;\n\t\tlet emitter,\n\t\t\ti = emitters.length - 1;\n\n\t\tfor ( i; i >= 0; --i ) {\n\t\t\temitter = emitters[ i ];\n\n\t\t\t// Only do angle calculation if there's no spritesheet defined.\n\t\t\t//\n\t\t\t// Saves calculations being done and then overwritten in the shaders.\n\t\t\tif ( !defines.SHOULD_CALCULATE_SPRITE ) {\n\t\t\t\tdefines.SHOULD_ROTATE_TEXTURE = defines.SHOULD_ROTATE_TEXTURE || !!Math.max(\n\t\t\t\t\tMath.max.apply( null, emitter.angle.value ),\n\t\t\t\t\tMath.max.apply( null, emitter.angle.spread )\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tdefines.SHOULD_ROTATE_PARTICLES = defines.SHOULD_ROTATE_PARTICLES || !!Math.max(\n\t\t\t\temitter.rotation.angle,\n\t\t\t\temitter.rotation.angleSpread\n\t\t\t);\n\n\t\t\tdefines.SHOULD_WIGGLE_PARTICLES = defines.SHOULD_WIGGLE_PARTICLES || !!Math.max(\n\t\t\t\temitter.wiggle.value,\n\t\t\t\temitter.wiggle.spread\n\t\t\t);\n\t\t}\n\n\t\tthis.material.needsUpdate = true;\n\t}\n\n\t_applyAttributesToGeometry() {\n\t\tconst attributes = this.attributes,\n\t\t\tgeometry = this.geometry,\n\t\t\tgeometryAttributes = geometry.attributes;\n\t\tlet attribute,\n\t\t\tgeometryAttribute;\n\n\t\t// Loop through all the shader attributes and assign (or re-assign)\n\t\t// typed array buffers to each one.\n\t\tfor ( const attr in attributes ) {\n\t\t\tif ( HAS_OWN.call( attributes, attr ) ) {\n\t\t\t\tattribute = attributes[ attr ];\n\t\t\t\tgeometryAttribute = geometryAttributes[ attr ];\n\n\t\t\t\t// Update the array if this attribute exists on the geometry.\n\t\t\t\t//\n\t\t\t\t// This needs to be done because the attribute's typed array might have\n\t\t\t\t// been resized and reinstantiated, and might now be looking at a\n\t\t\t\t// different ArrayBuffer, so reference needs updating.\n\t\t\t\tif ( geometryAttribute ) {\n\t\t\t\t\tgeometryAttribute.array = attribute.typedArray.array;\n\t\t\t\t}\n\n\t\t\t\t// // Add the attribute to the geometry if it doesn't already exist.\n\t\t\t\telse {\n\t\t\t\t\tgeometry.addAttribute( attr, attribute.bufferAttribute );\n\t\t\t\t}\n\n\t\t\t\t// Mark the attribute as needing an update the next time a frame is rendered.\n\t\t\t\tattribute.bufferAttribute.needsUpdate = true;\n\t\t\t}\n\t\t}\n\n\t\t// Mark the draw range on the geometry. This will ensure\n\t\t// only the values in the attribute buffers that are\n\t\t// associated with a particle will be used in THREE's\n\t\t// render cycle.\n\t\tthis.geometry.setDrawRange( 0, this.particleCount );\n\t}\n\n\t/**\n     * Adds an SPE.Emitter instance to this group, creating particle values and\n     * assigning them to this group's shader attributes.\n     *\n     * @param {Emitter} emitter The emitter to add to this group.\n     */\n\taddEmitter( emitter ) {\n\t\t// Ensure an actual emitter instance is passed here.\n\t\t//\n\t\t// Decided not to throw here, just in case a scene's\n\t\t// rendering would be paused. Logging an error instead\n\t\t// of stopping execution if exceptions aren't caught.\n\t\tif ( emitter instanceof Emitter === false ) {\n\t\t\tconsole.error( '`emitter` argument must be instance of Emitter. Was provided with:', emitter );\n\t\t\treturn;\n\t\t}\n\n\t\t// If the emitter already exists as a member of this group, then\n\t\t// stop here, we don't want to add it again.\n\t\telse if ( this.emitterIDs.indexOf( emitter.uuid ) > -1 ) {\n\t\t\tconsole.error( 'Emitter already exists in this group. Will not add again.' );\n\t\t\treturn;\n\t\t}\n\n\t\t// And finally, if the emitter is a member of another group,\n\t\t// don't add it to this group.\n\t\telse if ( emitter.group !== null ) {\n\t\t\tconsole.error( 'Emitter already belongs to another group. Will not add to requested group.' );\n\t\t\treturn;\n\t\t}\n\n\t\tconst attributes = this.attributes,\n\t\t\tstart = this.particleCount,\n\t\t\tend = start + emitter.particleCount;\n\n\t\t// Update this group's particle count.\n\t\tthis.particleCount = end;\n\n\t\t// Emit a warning if the emitter being added will exceed the buffer sizes specified.\n\t\tif ( this.maxParticleCount !== null && this.particleCount > this.maxParticleCount ) {\n\t\t\tconsole.warn( 'SPE.Group: maxParticleCount exceeded. Requesting', this.particleCount, 'particles, can support only', this.maxParticleCount );\n\t\t}\n\n\n\t\t// Set the `particlesPerSecond` value (PPS) on the emitter.\n\t\t// It's used to determine how many particles to release\n\t\t// on a per-frame basis.\n\t\temitter._calculatePPSValue( emitter.maxAge._value + emitter.maxAge._spread );\n\t\temitter._setBufferUpdateRanges( this.attributeKeys );\n\n\t\t// Store the offset value in the TypedArray attributes for this emitter.\n\t\temitter._setAttributeOffset( start );\n\n\t\t// Save a reference to this group on the emitter so it knows\n\t\t// where it belongs.\n\t\temitter.group = this;\n\n\t\t// Store reference to the attributes on the emitter for\n\t\t// easier access during the emitter's tick function.\n\t\temitter.attributes = this.attributes;\n\n\n\n\t\t// Ensure the attributes and their BufferAttributes exist, and their\n\t\t// TypedArrays are of the correct size.\n\t\tfor ( const attr in attributes ) {\n\t\t\tif ( HAS_OWN.call( attributes, attr ) ) {\n\t\t\t\t// When creating a buffer, pass through the maxParticle count\n\t\t\t\t// if one is specified.\n\t\t\t\tattributes[ attr ]._createBufferAttribute(\n\t\t\t\t\tthis.maxParticleCount !== null ?\n\t\t\t\t\t\tthis.maxParticleCount :\n\t\t\t\t\t\tthis.particleCount\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\t// Loop through each particle this emitter wants to have, and create the attributes values,\n\t\t// storing them in the TypedArrays that each attribute holds.\n\t\tfor ( let i = start; i < end; ++i ) {\n\t\t\temitter._assignPositionValue( i );\n\t\t\temitter._assignForceValue( i, 'velocity' );\n\t\t\temitter._assignForceValue( i, 'acceleration' );\n\t\t\temitter._assignAbsLifetimeValue( i, 'opacity' );\n\t\t\temitter._assignAbsLifetimeValue( i, 'size' );\n\t\t\temitter._assignAngleValue( i );\n\t\t\temitter._assignRotationValue( i );\n\t\t\temitter._assignParamsValue( i );\n\t\t\temitter._assignColorValue( i );\n\t\t}\n\n\t\t// Update the geometry and make sure the attributes are referencing\n\t\t// the typed arrays properly.\n\t\tthis._applyAttributesToGeometry();\n\n\t\t// Store this emitter in this group's emitter's store.\n\t\tthis.emitters.push( emitter );\n\t\tthis.emitterIDs.push( emitter.uuid );\n\n\t\t// Update certain flags to enable shader calculations only if they're necessary.\n\t\tthis._updateDefines( emitter );\n\n\t\t// Update the material since defines might have changed\n\t\tthis.material.needsUpdate = true;\n\t\tthis.geometry.needsUpdate = true;\n\t\tthis._attributesNeedRefresh = true;\n\n\t\t// Return the group to enable chaining.\n\t\treturn this;\n\t}\n\n\t/**\n     * Removes an Emitter instance from this group. When called,\n     * all particle's belonging to the given emitter will be instantly\n     * removed from the scene.\n     *\n     * @param {Emitter} emitter The emitter to add to this group.\n     */\n\tremoveEmitter( emitter ) {\n\t\tconst emitterIndex = this.emitterIDs.indexOf( emitter.uuid );\n\n\t\t// Ensure an actual emitter instance is passed here.\n\t\t//\n\t\t// Decided not to throw here, just in case a scene's\n\t\t// rendering would be paused. Logging an error instead\n\t\t// of stopping execution if exceptions aren't caught.\n\t\tif ( emitter instanceof Emitter === false ) {\n\t\t\tconsole.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter );\n\t\t\treturn;\n\t\t}\n\n\t\t// Issue an error if the emitter isn't a member of this group.\n\t\telse if ( emitterIndex === -1 ) {\n\t\t\tconsole.error( 'Emitter does not exist in this group. Will not remove.' );\n\t\t\treturn;\n\t\t}\n\n\t\t// Kill all particles by marking them as dead\n\t\t// and their age as 0.\n\t\tconst start = emitter.attributeOffset,\n\t\t\tend = start + emitter.particleCount,\n\t\t\tparams = this.attributes.params.typedArray;\n\n\t\t// Set alive and age to zero.\n\t\tfor ( let i = start; i < end; ++i ) {\n\t\t\tparams.array[ i * 4 ] = 0.0;\n\t\t\tparams.array[ i * 4 + 1 ] = 0.0;\n\t\t}\n\n\t\t// Remove the emitter from this group's \"store\".\n\t\tthis.emitters.splice( emitterIndex, 1 );\n\t\tthis.emitterIDs.splice( emitterIndex, 1 );\n\n\t\t// Remove this emitter's attribute values from all shader attributes.\n\t\t// The `.splice()` call here also marks each attribute's buffer\n\t\t// as needing to update it's entire contents.\n\t\tfor ( const attr in this.attributes ) {\n\t\t\tif ( HAS_OWN.call( this.attributes, attr ) ) {\n\t\t\t\tthis.attributes[ attr ].splice( start, end );\n\t\t\t}\n\t\t}\n\n\t\t// Ensure this group's particle count is correct.\n\t\tthis.particleCount -= emitter.particleCount;\n\n\t\t// Call the emitter's remove method.\n\t\temitter._onRemove();\n\n\t\t// Set a flag to indicate that the attribute buffers should\n\t\t// be updated in their entirety on the next frame.\n\t\tthis._attributesNeedRefresh = true;\n\t}\n\n\n\t/**\n     * Fetch a single emitter instance from the pool.\n     * If there are no objects in the pool, a new emitter will be\n     * created if specified.\n     *\n     * @return {Emitter|null}\n     */\n\tgetFromPool() {\n\t\tconst pool = this._pool,\n\t\t\tcreateNew = this._createNewWhenPoolEmpty;\n\n\t\tif ( pool.length ) {\n\t\t\treturn pool.pop();\n\t\t}\n\t\telse if ( createNew ) {\n\t\t\tconst emitter = new Emitter( this._poolCreationSettings );\n\n\t\t\tthis.addEmitter( emitter );\n\n\t\t\treturn emitter;\n\t\t}\n\n\t\treturn null;\n\t}\n\n\n\t/**\n     * Release an emitter into the pool.\n     *\n     * @param  {ShaderParticleEmitter} emitter\n     * @return {Group} This group instance.\n     */\n\treleaseIntoPool( emitter ) {\n\t\tif ( emitter instanceof Emitter === false ) {\n\t\t\tconsole.error( 'Argument is not instanceof Emitter:', emitter );\n\t\t\treturn;\n\t\t}\n\n\t\temitter.reset();\n\t\tthis._pool.unshift( emitter );\n\n\t\treturn this;\n\t}\n\n\n\t/**\n     * Get the pool array\n     *\n     * @return {Array}\n     */\n\tgetPool() {\n\t\treturn this._pool;\n\t}\n\n\n\t/**\n     * Add a pool of emitters to this particle group\n     *\n     * @param {Number} numEmitters      The number of emitters to add to the pool.\n     * @param {EmitterOptions|Array} emitterOptions  An object, or array of objects, describing the options to pass to each emitter.\n     * @param {Boolean} createNew       Should a new emitter be created if the pool runs out?\n     * @return {Group} This group instance.\n     */\n\taddPool( numEmitters, emitterOptions, createNew ) {\n\t\t// Save relevant settings and flags.\n\t\tthis._poolCreationSettings = emitterOptions;\n\t\tthis._createNewWhenPoolEmpty = !!createNew;\n\n\t\t// Create the emitters, add them to this group and the pool.\n\t\tfor ( let i = 0; i < numEmitters; ++i ) {\n\t\t\tlet args;\n\n\t\t\tif ( Array.isArray( emitterOptions ) ) {\n\t\t\t\targs = emitterOptions[ i ];\n\t\t\t}\n\t\t\telse {\n\t\t\t\targs = emitterOptions;\n\t\t\t}\n\n\t\t\tconst emitter = new Emitter( args );\n\n\t\t\tthis.addEmitter( emitter );\n\t\t\tthis.releaseIntoPool( emitter );\n\t\t}\n\n\t\treturn this;\n\t}\n\n\n\n\t_triggerSingleEmitter( pos ) {\n\t\tconst emitter = this.getFromPool();\n\n\t\tif ( emitter === null ) {\n\t\t\tconsole.log( 'Group pool ran out.' );\n\t\t\treturn;\n\t\t}\n\n\t\t// TODO:\n\t\t// - Make sure buffers are update with the new position.\n\t\tif ( pos instanceof THREE.Vector3 ) {\n\t\t\temitter.position.value.copy( pos );\n\n\t\t\t// Trigger the setter for this property to force an\n\t\t\t// update to the emitter's position attribute.\n\t\t\temitter.position.value = emitter.position.value; // eslint-disable-line\n\t\t}\n\n\t\temitter.enable();\n\n\t\tsetTimeout( () => {\n\t\t\temitter.disable();\n\t\t\tthis.releaseIntoPool( emitter );\n\t\t}, ( Math.max( emitter.duration, ( emitter.maxAge.value + emitter.maxAge.spread ) ) ) * 1000 );\n\n\t\treturn this;\n\t}\n\n\n\t/**\n     * Set a given number of emitters as alive, with an optional position\n     * vector3 to move them to.\n     *\n     * @param  {Number} numEmitters The number of emitters to activate\n     * @param  {Object} [position=undefined] A THREE.Vector3 instance describing the position to activate the emitter(s) at.\n     * @return {Group} This group instance.\n     */\n\ttriggerPoolEmitter( numEmitters, position ) {\n\t\tif ( typeof numEmitters === 'number' && numEmitters > 1 ) {\n\t\t\tfor ( let i = 0; i < numEmitters; ++i ) {\n\t\t\t\tthis._triggerSingleEmitter( position );\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tthis._triggerSingleEmitter( position );\n\t\t}\n\n\t\treturn this;\n\t}\n\n\n\n\t_updateUniforms( dt ) {\n\t\tthis.uniforms.runTime.value += dt;\n\t\tthis.uniforms.deltaTime.value = dt;\n\t}\n\n\t_resetBufferRanges() {\n\t\tconst keys = this.attributeKeys,\n\t\t\tattrs = this.attributes;\n\t\tlet i = this.attributeCount - 1;\n\n\t\tfor ( i; i >= 0; --i ) {\n\t\t\tattrs[ keys[ i ] ].resetUpdateRange();\n\t\t}\n\t}\n\n\n\t_updateBuffers( emitter ) {\n\t\tconst keys = this.attributeKeys,\n\t\t\tattrs = this.attributes,\n\t\t\temitterRanges = emitter.bufferUpdateRanges;\n\t\tlet key,\n\t\t\temitterAttr,\n\t\t\tattr;\n\n\t\tfor ( let i = this.attributeCount - 1; i >= 0; --i ) {\n\t\t\tkey = keys[ i ];\n\t\t\temitterAttr = emitterRanges[ key ];\n\t\t\tattr = attrs[ key ];\n\t\t\tattr.setUpdateRange( emitterAttr.min, emitterAttr.max );\n\t\t\tattr.flagUpdate();\n\t\t}\n\t}\n\n\n\t/**\n     * Simulate all the emitter's belonging to this group, updating\n     * attribute values along the way.\n     * @param  {Number} [dt=Group's `fixedTimeStep` value] The number of seconds to simulate the group's emitters for (deltaTime)\n     */\n\ttick( dt ) {\n\t\tconst emitters = this.emitters,\n\t\t\tnumEmitters = emitters.length,\n\t\t\tdeltaTime = dt || this.fixedTimeStep,\n\t\t\tkeys = this.attributeKeys,\n\t\t\tattrs = this.attributes;\n\n\t\t// Update uniform values.\n\t\tthis._updateUniforms( deltaTime );\n\n\t\t// Reset buffer update ranges on the shader attributes.\n\t\tthis._resetBufferRanges();\n\n\n\t\t// If nothing needs updating, then stop here.\n\t\tif (\n\t\t\tnumEmitters === 0 &&\n            this._attributesNeedRefresh === false &&\n            this._attributesNeedDynamicReset === false\n\t\t) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Loop through each emitter in this group and\n\t\t// simulate it, then update the shader attribute\n\t\t// buffers.\n\t\tfor ( let i = 0, emitter; i < numEmitters; ++i ) {\n\t\t\temitter = emitters[ i ];\n\t\t\temitter.tick( deltaTime );\n\t\t\tthis._updateBuffers( emitter );\n\t\t}\n\n\t\t// If the shader attributes have been refreshed,\n\t\t// then the dynamic properties of each buffer\n\t\t// attribute will need to be reset back to\n\t\t// what they should be.\n\t\tif ( this._attributesNeedDynamicReset === true ) {\n\t\t\tfor ( let i = this.attributeCount - 1; i >= 0; --i ) {\n\t\t\t\tattrs[ keys[ i ] ].resetDynamic();\n\t\t\t}\n\n\t\t\tthis._attributesNeedDynamicReset = false;\n\t\t}\n\n\t\t// If this group's shader attributes need a full refresh\n\t\t// then mark each attribute's buffer attribute as\n\t\t// needing so.\n\t\tif ( this._attributesNeedRefresh === true ) {\n\t\t\tfor ( let i = this.attributeCount - 1; i >= 0; --i ) {\n\t\t\t\tattrs[ keys[ i ] ].forceUpdateAll();\n\t\t\t}\n\n\t\t\tthis._attributesNeedRefresh = false;\n\t\t\tthis._attributesNeedDynamicReset = true;\n\t\t}\n\t}\n\n\n\t/**\n     * Dipose the geometry and material for the group.\n     *\n     * @return {Group} Group instance.\n     */\n\tdispose() {\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\t\treturn this;\n\t}\n}\n"],"sourceRoot":""} \ No newline at end of file diff --git a/docs/api/Emitter.html b/docs/api/Emitter.html deleted file mode 100644 index 619633f..0000000 --- a/docs/api/Emitter.html +++ /dev/null @@ -1,213 +0,0 @@ - - - - - JSDoc: Class: Emitter - - - - - - - - - - -
- -

Class: Emitter

- - - - - - -
- -
- -

- Emitter -

- - -
- -
-
- - - - - -

new Emitter(options)

- - - - - -
- The SPE.Emitter class. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
options - - -EmitterOptions - - - - A map of options to configure the emitter.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - -
- -
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sun Oct 18 2015 22:34:14 GMT+0100 (BST) -
- - - - - \ No newline at end of file diff --git a/docs/api/SPE.Emitter.html b/docs/api/SPE.Emitter.html deleted file mode 100644 index b79414a..0000000 --- a/docs/api/SPE.Emitter.html +++ /dev/null @@ -1,848 +0,0 @@ - - - - - JSDoc: Class: Emitter - - - - - - - - - - -
- -

Class: Emitter

- - - - - - -
- -
- -

- SPE. - - Emitter -

- - -
- -
-
- - - - - -

new Emitter(options)

- - - - - -
- The SPE.Emitter class. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
options - - -EmitterOptions - - - - A map of options to configure the emitter.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -

Methods

- - - - - - -

disable() → {Emitter}

- - - - - -
- Disables th emitter, but does not instantly remove it's -particles fromt the scene. When called, the emitter will be -'switched off' and just stop emitting. Any particle's alive will -be allowed to finish their lifecycle. -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- This emitter instance. -
- - - -
-
- Type -
-
- -Emitter - - -
-
- - - - - - - - - - -

enable() → {Emitter}

- - - - - -
- Enables the emitter. If not already enabled, the emitter -will start emitting particles. -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- This emitter instance. -
- - - -
-
- Type -
-
- -Emitter - - -
-
- - - - - - - - - - -

remove() → {Emitter}

- - - - - -
- Remove this emitter from it's parent group (if it has been added to one). -Delgates to SPE.group.prototype.removeEmitter(). - -When called, all particle's belonging to this emitter will be instantly -removed from the scene. -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - -
See:
-
-
    -
  • SPE.Group.prototype.removeEmitter
    • -
-
- - - -
- - - - - - - - - - - - - -
Returns:
- - -
- This emitter instance. -
- - - -
-
- Type -
-
- -Emitter - - -
-
- - - - - - - - - - -

reset(forceopt) → {Emitter}

- - - - - -
- Resets all the emitter's particles to their start positions -and marks the particles as dead if the `force` argument is -true. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeAttributesDescription
force - - -Boolean - - - - - - <optional>
- - - - - - 		If true, all particles will be marked as dead instantly.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- This emitter instance. -
- - - -
-
- Type -
-
- -Emitter - - -
-
- - - - - - - - - - -

tick(dt)

- - - - - -
- Simulates one frame's worth of particles, updating particles -that are already alive, and marking ones that are currently dead -but should be alive as alive. - -If the emitter is marked as static, then this function will do nothing. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
dt - - -Number - - - - The number of seconds to simulate (deltaTime)
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - -
- -
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - \ No newline at end of file diff --git a/docs/api/SPE.Group.html b/docs/api/SPE.Group.html deleted file mode 100644 index 5351bc0..0000000 --- a/docs/api/SPE.Group.html +++ /dev/null @@ -1,1497 +0,0 @@ - - - - - JSDoc: Class: Group - - - - - - - - - - -
- -

Class: Group

- - - - - - -
- -
- -

- SPE. - - Group -

- - -
- -
-
- - - - - -

new Group(options)

- - - - - -
- The SPE.Group class. Creates a new group, containing a material, geometry, and mesh. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
options - - -GroupOptions - - - - A map of options to configure the group instance.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -

Methods

- - - - - - -

addEmitter(emitter)

- - - - - -
- Adds an SPE.Emitter instance to this group, creating particle values and -assigning them to this group's shader attributes. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
emitter - - -Emitter - - - - The emitter to add to this group.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

addPool(numEmitters, emitterOptions, createNew) → {Group}

- - - - - -
- Add a pool of emitters to this particle group -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
numEmitters - - -Number - - - - The number of emitters to add to the pool.
emitterOptions - - -EmitterOptions -| - -Array - - - - An object, or array of objects, describing the options to pass to each emitter.
createNew - - -Boolean - - - - Should a new emitter be created if the pool runs out?
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- This group instance. -
- - - -
-
- Type -
-
- -Group - - -
-
- - - - - - - - - - -

dispose() → {Group}

- - - - - -
- Dipose the geometry and material for the group. -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Group instance. -
- - - -
-
- Type -
-
- -Group - - -
-
- - - - - - - - - - -

getFromPool() → {Emitter|null}

- - - - - -
- Fetch a single emitter instance from the pool. -If there are no objects in the pool, a new emitter will be -created if specified. -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - - - -
-
- Type -
-
- -Emitter -| - -null - - -
-
- - - - - - - - - - -

getPool() → {Array}

- - - - - -
- Get the pool array -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - - - -
-
- Type -
-
- -Array - - -
-
- - - - - - - - - - -

releaseIntoPool(emitter) → {Group}

- - - - - -
- Release an emitter into the pool. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
emitter - - -ShaderParticleEmitter - - - -
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- This group instance. -
- - - -
-
- Type -
-
- -Group - - -
-
- - - - - - - - - - -

removeEmitter(emitter)

- - - - - -
- Removes an SPE.Emitter instance from this group. When called, -all particle's belonging to the given emitter will be instantly -removed from the scene. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
emitter - - -Emitter - - - - The emitter to add to this group.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

tick(dtopt)

- - - - - -
- Simulate all the emitter's belonging to this group, updating -attribute values along the way. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeAttributesDefaultDescription
dt - - -Number - - - - - - <optional>
- - - - - - 		- - Group's `fixedTimeStep` value - - The number of seconds to simulate the group's emitters for (deltaTime)
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

triggerPoolEmitter(numEmitters, positionopt) → {Group}

- - - - - -
- Set a given number of emitters as alive, with an optional position -vector3 to move them to. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeAttributesDescription
numEmitters - - -Number - - - - - - - - - - The number of emitters to activate
position - - -Object - - - - - - <optional>
- - - - - - 		A THREE.Vector3 instance describing the position to activate the emitter(s) at.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- This group instance. -
- - - -
-
- Type -
-
- -Group - - -
-
- - - - - - - - - - - -
- -
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - \ No newline at end of file diff --git a/docs/api/SPE.ShaderAttribute.html b/docs/api/SPE.ShaderAttribute.html deleted file mode 100644 index 593b636..0000000 --- a/docs/api/SPE.ShaderAttribute.html +++ /dev/null @@ -1,1416 +0,0 @@ - - - - - JSDoc: Class: ShaderAttribute - - - - - - - - - - -
- -

Class: ShaderAttribute

- - - - - - -
- -
- -

- SPE. - - ShaderAttribute -

- - -
- -
-
- - - - - -

new ShaderAttribute(type, dynamicBufferopt, arrayTypeopt)

- - - - - -
- A helper to handle creating and updating a THREE.BufferAttribute instance. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeAttributesDescription
type - - -String - - - - - - - - - - The buffer attribute type. See SPE.ShaderAttribute.typeSizeMap for valid values.
dynamicBuffer - - -Boolean - - - - - - <optional>
- - - - - - 		Whether this buffer attribute should be marked as dynamic or not.
arrayType - - -function - - - - - - <optional>
- - - - - - 		A reference to a TypedArray constructor. Defaults to Float32Array if none provided.
- - - - - - -
- - - - - - - - - - - - - - - - - - -
Author:
-
-
    -
  • Luke Moody
    • -
-
- - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - -

Members

- - - -

(static) typeSizeMap :Number

- - - - -
- A map of uniform types to their component size. -
- - - -
Type:
-
    -
  • - -Number - - -
    • -
- - - - - -
Properties:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
f - - -Number - - - - Float
v2 - - -Number - - - - Vec2
v3 - - -Number - - - - Vec3
v4 - - -Number - - - - Vec4
c - - -Number - - - - Color
m3 - - -Number - - - - Mat3
m4 - - -Number - - - - Mat4
- - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - -

Methods

- - - - - - -

_createBufferAttribute(size)

- - - - - -
- Creates a THREE.BufferAttribute instance if one doesn't exist already. - -Ensures a typed array is present by calling _ensureTypedArray() first. - -If a buffer attribute exists already, then it will be marked as needing an update. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
size - - -Number - - - - The size of the typed array to create if one doesn't exist, or resize existing array to.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

_ensureTypedArray(size)

- - - - - -
- Make sure this attribute has a typed array associated with it. - -If it does, then it will ensure the typed array is of the correct size. - -If not, a new SPE.TypedArrayHelper instance will be created. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
size - - -Number - - - - The size of the typed array to create or update to.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

flagUpdate()

- - - - - -
- Calculate the number of indices that this attribute should mark as needing -updating. Also marks the attribute as needing an update. -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

getLength() → {Number}

- - - - - -
- Returns the length of the typed array associated with this attribute. -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- The length of the typed array. Will be 0 if no typed array has been created yet. -
- - - -
-
- Type -
-
- -Number - - -
-
- - - - - - - - - - -

resetUpdateRange()

- - - - - -
- Reset the index update counts for this attribute -
- - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

setUpdateRange(min, max)

- - - - - -
- Calculate the minimum and maximum update range for this buffer attribute using -component size independant min and max values. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
min - - -Number - - - - The start of the range to mark as needing an update.
max - - -Number - - - - The end of the range to mark as needing an update.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

splice(start, end)

- - - - - -
- Perform a splice operation on this attribute's buffer. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
start - - -Number - - - - The start index of the splice. Will be multiplied by the number of components for this attribute.
end - - -Number - - - - The end index of the splice. Will be multiplied by the number of components for this attribute.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - -
- -
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - \ No newline at end of file diff --git a/docs/api/SPE.TypedArrayHelper.html b/docs/api/SPE.TypedArrayHelper.html deleted file mode 100644 index a1f3109..0000000 --- a/docs/api/SPE.TypedArrayHelper.html +++ /dev/null @@ -1,3308 +0,0 @@ - - - - - JSDoc: Class: TypedArrayHelper - - - - - - - - - - -
- -

Class: TypedArrayHelper

- - - - - - -
- -
- -

- SPE. - - TypedArrayHelper -

- - -
- -
-
- - - - - -

new TypedArrayHelper(TypedArrayConstructor, size, componentSize, indexOffset)

- - - - - -
- A helper class for TypedArrays. - -Allows for easy resizing, assignment of various component-based -types (Vector2s, Vector3s, Vector4s, Mat3s, Mat4s), -as well as Colors (where components are `r`, `g`, `b`), -Numbers, and setting from other TypedArrays. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
TypedArrayConstructor - - -function - - - - The constructor to use (Float32Array, Uint8Array, etc.)
size - - -Number - - - - The size of the array to create
componentSize - - -Number - - - - The number of components per-value (ie. 3 for a vec3, 9 for a Mat3, etc.)
indexOffset - - -Number - - - - The index in the array from which to start assigning values. Default `0` if none provided
- - - - - - -
- - - - - - - - - - - - - - - - - - -
Author:
-
-
    -
  • Luke Moody
    • -
-
- - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -

Methods

- - - - - - -

getComponentValueAtIndex(index) → {TypedArray}

- - - - - -
- Returns the component value of the array at the given index, taking into account -the `indexOffset` property of this class. - -If the componentSize is set to 3, then it will return a new TypedArray -of length 3. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index in the array to fetch.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- The component value at the given index. -
- - - -
-
- Type -
-
- -TypedArray - - -
-
- - - - - - - - - - -

getValueAtIndex(index) → {Number}

- - - - - -
- Returns the value of the array at the given index, taking into account -the `indexOffset` property of this class. - -Note that this function ignores the component size and will just return a -single value. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index in the array to fetch.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- The value at the given index. -
- - - -
-
- Type -
-
- -Number - - -
-
- - - - - - - - - - -

grow(size) → {SPE.TypedArrayHelper}

- - - - - -
- Grows the internal array. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
size - - -Number - - - - The new size of the typed array. Must be larger than `this.array.length`.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setColor(index, color) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Color value at `index`. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec3 values from.
color - - -Color - - - - Any object that has `r`, `g`, and `b` properties.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setFromArray(index, array) → {SPE.TypedArrayHelper}

- - - - - -
- Copies from the given TypedArray into this one, using the index argument -as the start position. Alias for `TypedArray.set`. Will automatically resize -if the given source array is of a larger size than the internal array. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The start position from which to copy into this array.
array - - -TypedArray - - - - The array from which to copy; the source array.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setMat3(index, mat3) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Matrix3 value at `index`. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the matrix values from.
mat3 - - -Matrix3 - - - - The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setMat4(index, mat3) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Matrix4 value at `index`. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the matrix values from.
mat3 - - -Matrix4 - - - - The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setNumber(index, numericValue) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Number value at `index`. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec3 values from.
numericValue - - -Number - - - - The number to assign to this index in the array.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setSize(size)

- - - - - -
- Sets the size of the internal array. - -Delegates to `this.shrink` or `this.grow` depending on size -argument's relation to the current size of the internal array. - -Note that if the array is to be shrunk, data will be lost. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
size - - -Number - - - - The new size of the array.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - - - - - - - - -

setVec2(index, vec2) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Vector2 value at `index`. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec2 values from.
vec2 - - -Vector2 - - - - Any object that has `x` and `y` properties.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setVec2Components(index, x, y) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Vector2 value using raw components. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec2 values from.
x - - -Number - - - - The Vec2's `x` component.
y - - -Number - - - - The Vec2's `y` component.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setVec3(index, vec2) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Vector3 value at `index`. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec3 values from.
vec2 - - -Vector3 - - - - Any object that has `x`, `y`, and `z` properties.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setVec3Components(index, x, y, z) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Vector3 value using raw components. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec3 values from.
x - - -Number - - - - The Vec3's `x` component.
y - - -Number - - - - The Vec3's `y` component.
z - - -Number - - - - The Vec3's `z` component.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setVec4(index, vec2) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Vector4 value at `index`. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec4 values from.
vec2 - - -Vector4 - - - - Any object that has `x`, `y`, `z`, and `w` properties.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

setVec4Components(index, x, y, z, w) → {SPE.TypedArrayHelper}

- - - - - -
- Set a Vector4 value using raw components. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
index - - -Number - - - - The index at which to set the vec4 values from.
x - - -Number - - - - The Vec4's `x` component.
y - - -Number - - - - The Vec4's `y` component.
z - - -Number - - - - The Vec4's `z` component.
w - - -Number - - - - The Vec4's `w` component.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

shrink(size) → {SPE.TypedArrayHelper}

- - - - - -
- Shrinks the internal array. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
size - - -Number - - - - The new size of the typed array. Must be smaller than `this.array.length`.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- Instance of this class. -
- - - -
-
- Type -
-
- -SPE.TypedArrayHelper - - -
-
- - - - - - - - - - -

splice(start, end) → {Object}

- - - - - -
- Perform a splice operation on this array's buffer. -
- - - - - - - - - -
Parameters:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
start - - -Number - - - - The start index of the splice. Will be multiplied by the number of components for this attribute.
end - - -Number - - - - The end index of the splice. Will be multiplied by the number of components for this attribute.
- - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - -
Returns:
- - -
- The SPE.TypedArrayHelper instance. -
- - - -
-
- Type -
-
- -Object - - -
-
- - - - - - - - - - - -
- -
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - \ No newline at end of file diff --git a/docs/api/SPE.html b/docs/api/SPE.html deleted file mode 100644 index 2098aee..0000000 --- a/docs/api/SPE.html +++ /dev/null @@ -1,427 +0,0 @@ - - - - - JSDoc: Namespace: SPE - - - - - - - - - - -
- -

Namespace: SPE

- - - - - - -
- -
- -

- SPE -

- - -
- -
-
- - -
Namespace for Shader Particle Engine. - -All SPE-related code sits under this namespace.
- - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - -
- - - - - - -

Classes

- -
-
Emitter
-
- -
Group
-
- -
ShaderAttribute
-
- -
TypedArrayHelper
-
-
- - - - - -

Namespaces

- -
-
utils
-
-
- - - -

Members

- - - -

(static) distributions :Number

- - - - -
- A map of supported distribution types used -by SPE.Emitter instances. - -These distribution types can be applied to -an emitter globally, which will affect the -`position`, `velocity`, and `acceleration` -value calculations for an emitter, or they -can be applied on a per-property basis. -
- - - -
Type:
-
    -
  • - -Number - - -
    • -
- - - - - -
Properties:
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameTypeDescription
BOX - - -Number - - - - Values will be distributed within a box.
SPHERE - - -Number - - - - Values will be distributed on a sphere.
DISC - - -Number - - - - Values will be distributed on a 2d-disc shape.
- - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - -

(static) valueOverLifetimeLength :Number

- - - - -
- Set this value to however many 'steps' you -want value-over-lifetime properties to have. - -It's adjustable to fix an interpolation problem: - -Assuming you specify an opacity value as [0, 1, 0] - and the `valueOverLifetimeLength` is 4, then the - opacity value array will be reinterpolated to - be [0, 0.66, 0.66, 0]. - This isn't ideal, as particles would never reach - full opacity. - -NOTE: - This property affects the length of ALL - value-over-lifetime properties for ALL - emitters and ALL groups. - - Only values >= 3 && <= 4 are allowed. -
- - - -
Type:
-
    -
  • - -Number - - -
    • -
- - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Source:
-
- - - - - - - -
- - - - - - - - - - - - - - -
- -
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - \ No newline at end of file diff --git a/docs/api/SPE.js.html b/docs/api/SPE.js.html deleted file mode 100644 index 1bafb2f..0000000 --- a/docs/api/SPE.js.html +++ /dev/null @@ -1,132 +0,0 @@ - - - - - JSDoc: Source: SPE.js - - - - - - - - - - -
- -

Source: SPE.js

- - - - - - -
-
- 
/**
- * @typedef {Number} distribution
- * @property {Number} SPE.distributions.BOX Values will be distributed within a box.
- * @property {Number} SPE.distributions.SPHERE Values will be distributed within a sphere.
- * @property {Number} SPE.distributions.DISC Values will be distributed within a 2D disc.
- */
-
-/**
- * Namespace for Shader Particle Engine.
- *
- * All SPE-related code sits under this namespace.
- *
- * @type {Object}
- * @namespace
- */
-var SPE = {
-
-    /**
-     * A map of supported distribution types used
-     * by SPE.Emitter instances.
-     *
-     * These distribution types can be applied to
-     * an emitter globally, which will affect the
-     * `position`, `velocity`, and `acceleration`
-     * value calculations for an emitter, or they
-     * can be applied on a per-property basis.
-     *
-     * @enum {Number}
-     */
-    distributions: {
-        /**
-         * Values will be distributed within a box.
-         * @type {Number}
-         */
-        BOX: 1,
-
-        /**
-         * Values will be distributed on a sphere.
-         * @type {Number}
-         */
-        SPHERE: 2,
-
-        /**
-         * Values will be distributed on a 2d-disc shape.
-         * @type {Number}
-         */
-        DISC: 3,
-    },
-
-
-    /**
-     * Set this value to however many 'steps' you
-     * want value-over-lifetime properties to have.
-     *
-     * It's adjustable to fix an interpolation problem:
-     *
-     * Assuming you specify an opacity value as [0, 1, 0]
-     *      and the `valueOverLifetimeLength` is 4, then the
-     *      opacity value array will be reinterpolated to
-     *      be [0, 0.66, 0.66, 0].
-     *   This isn't ideal, as particles would never reach
-     *   full opacity.
-     *
-     * NOTE:
-     *     This property affects the length of ALL
-     *       value-over-lifetime properties for ALL
-     *       emitters and ALL groups.
-     *
-     *     Only values >= 3 && <= 4 are allowed.
-     *
-     * @type {Number}
-     */
-    valueOverLifetimeLength: 4
-};
-
-// Module loader support:
-if ( typeof define === 'function' && define.amd ) {
-    define( 'spe', SPE );
-}
-else if ( typeof exports !== 'undefined' && typeof module !== 'undefined' ) {
-    module.exports = SPE;
-}
-
-
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - diff --git a/docs/api/constants_distributions.js.html b/docs/api/constants_distributions.js.html new file mode 100644 index 0000000..e0d684c --- /dev/null +++ b/docs/api/constants_distributions.js.html @@ -0,0 +1,88 @@ + + + + + JSDoc: Source: constants/distributions.js + + + + + + + + + + +
+ +

Source: constants/distributions.js

+ + + + + + +
+
+ 
/**
+ * A map of supported distribution types used
+ * by SPE.Emitter instances.
+ *
+ * These distribution types can be applied to
+ * an emitter globally, which will affect the
+ * `position`, `velocity`, and `acceleration`
+ * value calculations for an emitter, or they
+ * can be applied on a per-property basis.
+ *
+ * @enum {Number}
+ */
+export default {
+
+	/**
+	 * Values will be distributed within a box.
+	 * @type {Number}
+	 */
+	BOX: 1,
+
+	/**
+	 * Values will be distributed on a sphere.
+	 * @type {Number}
+	 */
+	SPHERE: 2,
+
+	/**
+	 * Values will be distributed on a 2d-disc shape.
+	 * @type {Number}
+	 */
+	DISC: 3,
+
+	/**
+	 * Values will be distributed along a line.
+	 * @type {Number}
+	 */
+	LINE: 4,
+};
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/constants_typeSizeMap.js.html b/docs/api/constants_typeSizeMap.js.html new file mode 100644 index 0000000..d8e1d3a --- /dev/null +++ b/docs/api/constants_typeSizeMap.js.html @@ -0,0 +1,100 @@ + + + + + JSDoc: Source: constants/typeSizeMap.js + + + + + + + + + + +
+ +

Source: constants/typeSizeMap.js

+ + + + + + +
+
+ 
/**
+ * A map of uniform types to their component size.
+ * @enum {Number}
+ */
+export default {
+
+	/**
+	 * Float
+	 * @type {Number}
+	 */
+	f: 1,
+
+	/**
+	 * Vec2
+	 * @type {Number}
+	 */
+	v2: 2,
+
+	/**
+	 * Vec3
+	 * @type {Number}
+	 */
+	v3: 3,
+
+	/**
+	 * Vec4
+	 * @type {Number}
+	 */
+	v4: 4,
+
+	/**
+	 * Color
+	 * @type {Number}
+	 */
+	c: 3,
+
+	/**
+	 * Mat3
+	 * @type {Number}
+	 */
+	m3: 9,
+
+	/**
+	 * Mat4
+	 * @type {Number}
+	 */
+	m4: 16,
+};
+
+
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/constants_valueTypes.js.html b/docs/api/constants_valueTypes.js.html new file mode 100644 index 0000000..4f9aaae --- /dev/null +++ b/docs/api/constants_valueTypes.js.html @@ -0,0 +1,77 @@ + + + + + JSDoc: Source: constants/valueTypes.js + + + + + + + + + + +
+ +

Source: constants/valueTypes.js

+ + + + + + +
+
+ 
export default {
+
+	/**
+	 * Boolean type.
+	 * @type {String}
+	 */
+	BOOLEAN: 'boolean',
+
+	/**
+	 * String type.
+	 * @type {String}
+	 */
+	STRING: 'string',
+
+	/**
+	 * Number type.
+	 * @type {String}
+	 */
+	NUMBER: 'number',
+
+	/**
+	 * Object type.
+	 * @type {String}
+	 */
+	OBJECT: 'object',
+};
+
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/core_Emitter.js.html b/docs/api/core_Emitter.js.html new file mode 100644 index 0000000..aa12c5d --- /dev/null +++ b/docs/api/core_Emitter.js.html @@ -0,0 +1,1005 @@ + + + + + JSDoc: Source: core/Emitter.js + + + + + + + + + + +
+ +

Source: core/Emitter.js

+ + + + + + +
+
+ 
import * as THREE from 'three';
+import valueTypes from '@/constants/valueTypes';
+import distributions from '@/constants/distributions';
+import globals from '@/constants/globals';
+import utils from './utils';
+
+const HAS_OWN = Object.prototype.hasOwnProperty;
+
+/**
+ * An SPE.Emitter instance.
+ * @typedef {Object} Emitter
+ * @see SPE.Emitter
+ */
+
+/**
+ * A map of options to configure an SPE.Emitter instance.
+ *
+ * @typedef {Object} EmitterOptions
+ *
+ * @property {distribution} [type=BOX] The default distribution this emitter should use to control
+ *                         its particle's spawn position and force behaviour.
+ *                         Must be an distributions.* value.
+ *
+ *
+ * @property {Number} [particleCount=100] The total number of particles this emitter will hold. NOTE: this is not the number
+ *                                  of particles emitted in a second, or anything like that. The number of particles
+ *                                  emitted per-second is calculated by particleCount / maxAge (approximately!)
+ *
+ * @property {Number|null} [duration=null] The duration in seconds that this emitter should live for. If not specified, the emitter
+ *                                         will emit particles indefinitely.
+ *                                         NOTE: When an emitter is older than a specified duration, the emitter is NOT removed from
+ *                                         it's group, but rather is just marked as dead, allowing it to be reanimated at a later time
+ *                                         using `SPE.Emitter.prototype.enable()`.
+ *
+ * @property {Boolean} [isStatic=false] Whether this emitter should be not be simulated (true).
+ * @property {Boolean} [activeMultiplier=1] A value between 0 and 1 describing what percentage of this emitter's particlesPerSecond should be
+ *                                          emitted, where 0 is 0%, and 1 is 100%.
+ *                                          For example, having an emitter with 100 particles, a maxAge of 2, yields a particlesPerSecond
+ *                                          value of 50. Setting `activeMultiplier` to 0.5, then, will only emit 25 particles per second (0.5 = 50%).
+ *                                          Values greater than 1 will emulate a burst of particles, causing the emitter to run out of particles
+ *                                          before it's next activation cycle.
+ *
+ * @property {Boolean} [direction=1] The direction of the emitter. If value is `1`, emitter will start at beginning of particle's lifecycle.
+ *                                   If value is `-1`, emitter will start at end of particle's lifecycle and work it's way backwards.
+ *
+ * @property {Object} [maxAge={}] An object describing the particle's maximum age in seconds.
+ * @property {Number} [maxAge.value=2] A number between 0 and 1 describing the amount of maxAge to apply to all particles.
+ * @property {Number} [maxAge.spread=0] A number describing the maxAge variance on a per-particle basis.
+ *
+ *
+ * @property {Object} [position={}] An object describing this emitter's position.
+ * @property {Object} [position.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base position.
+ * @property {Object} [position.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis.
+ *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
+ *                                                          of this vector is used.
+ *                                                          When using a LINE distribution, this value is the endpoint of the LINE.
+ * @property {Object} [position.spreadClamp=new THREE.Vector3()] A THREE.Vector3 instance describing the numeric multiples the particle's should
+ *                                                               be spread out over.
+ *                                                               Note that when using a SPHERE or DISC distribution, only the x-component
+ *                                                               of this vector is used.
+ *                                                               When using a LINE distribution, this property is ignored.
+ * @property {Number} [position.radius=10] This emitter's base radius.
+ * @property {Object} [position.radiusScale=new THREE.Vector3()] A THREE.Vector3 instance describing the radius's scale in all three axes. Allows a SPHERE or DISC to be squashed or stretched.
+ * @property {distribution} [position.distribution=value of the `type` option.] A specific distribution to use when radiusing particles. Overrides the `type` option.
+ * @property {Boolean} [position.randomise=false] When a particle is re-spawned, whether it's position should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [velocity={}] An object describing this particle velocity.
+ * @property {Object} [velocity.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base velocity.
+ * @property {Object} [velocity.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's velocity variance on a per-particle basis.
+ *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
+ *                                                          of this vector is used.
+ * @property {distribution} [velocity.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's velocity. Overrides the `type` option.
+ * @property {Boolean} [velocity.randomise=false] When a particle is re-spawned, whether it's velocity should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [acceleration={}] An object describing this particle's acceleration.
+ * @property {Object} [acceleration.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base acceleration.
+ * @property {Object} [acceleration.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's acceleration variance on a per-particle basis.
+ *                           Note that when using a SPHERE or DISC distribution, only the x-component
+ *                           of this vector is used.
+ * @property {distribution} [acceleration.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's acceleration. Overrides the `type` option.
+ * @property {Boolean} [acceleration.randomise=false] When a particle is re-spawned, whether it's acceleration should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [drag={}] An object describing this particle drag. Drag is applied to both velocity and acceleration values.
+ * @property {Number} [drag.value=0] A number between 0 and 1 describing the amount of drag to apply to all particles.
+ * @property {Number} [drag.spread=0] A number describing the drag variance on a per-particle basis.
+ * @property {Boolean} [drag.randomise=false] When a particle is re-spawned, whether it's drag should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [wiggle={}] This is quite a fun one! The values of this object will determine whether a particle will wiggle, or jiggle, or wave,
+ *                                or shimmy, or waggle, or... Well you get the idea. The wiggle is calculated over-time, meaning that a particle will
+ *                                start off with no wiggle, and end up wiggling about with the distance of the `value` specified by the time it dies.
+ *                                It's quite handy to simulate fire embers, or similar effects where the particle's position should slightly change over
+ *                                time, and such change isn't easily controlled by rotation, velocity, or acceleration. The wiggle is a combination of sin and cos calculations, so is circular in nature.
+ * @property {Number} [wiggle.value=0] A number describing the amount of wiggle to apply to all particles. It's measured in distance.
+ * @property {Number} [wiggle.spread=0] A number describing the wiggle variance on a per-particle basis.
+ *
+ *
+ * @property {Object} [rotation={}] An object describing this emitter's rotation. It can either be static, or set to rotate from 0radians to the value of `rotation.value`
+ *                                  over a particle's lifetime. Rotation values affect both a particle's position and the forces applied to it.
+ * @property {Object} [rotation.axis=new THREE.Vector3(0, 1, 0)] A THREE.Vector3 instance describing this emitter's axis of rotation.
+ * @property {Object} [rotation.axisSpread=new THREE.Vector3()] A THREE.Vector3 instance describing the amount of variance to apply to the axis of rotation on
+ *                                                              a per-particle basis.
+ * @property {Number} [rotation.angle=0] The angle of rotation, given in radians. If `rotation.static` is true, the emitter will start off rotated at this angle, and stay as such.
+ *                                       Otherwise, the particles will rotate from 0radians to this value over their lifetimes.
+ * @property {Number} [rotation.angleSpread=0] The amount of variance in each particle's rotation angle.
+ * @property {Boolean} [rotation.static=false] Whether the rotation should be static or not.
+ * @property {Object} [rotation.center=The value of `position.value`] A THREE.Vector3 instance describing the center point of rotation.
+ * @property {Boolean} [rotation.randomise=false] When a particle is re-spawned, whether it's rotation should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [color={}] An object describing a particle's color. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of THREE.Color instances are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Object} [color.value=new THREE.Color()] Either a single THREE.Color instance, or an array of THREE.Color instances to describe the color of a particle over it's lifetime.
+ * @property {Object} [color.spread=new THREE.Vector3()] Either a single THREE.Vector3 instance, or an array of THREE.Vector3 instances to describe the color variance of a particle over it's lifetime.
+ * @property {Boolean} [color.randomise=false] When a particle is re-spawned, whether it's color should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [opacity={}] An object describing a particle's opacity. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Number} [opacity.value=1] Either a single number, or an array of numbers to describe the opacity of a particle over it's lifetime.
+ * @property {Number} [opacity.spread=0] Either a single number, or an array of numbers to describe the opacity variance of a particle over it's lifetime.
+ * @property {Boolean} [opacity.randomise=false] When a particle is re-spawned, whether it's opacity should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [size={}] An object describing a particle's size. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Number} [size.value=1] Either a single number, or an array of numbers to describe the size of a particle over it's lifetime.
+ * @property {Number} [size.spread=0] Either a single number, or an array of numbers to describe the size variance of a particle over it's lifetime.
+ * @property {Boolean} [size.randomise=false] When a particle is re-spawned, whether it's size should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [angle={}] An object describing a particle's angle. The angle is a 2d-rotation, measured in radians, applied to the particle's texture.
+ *                               NOTE: if a particle's texture is a sprite-sheet, this value IS IGNORED.
+ *                               This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Number} [angle.value=0] Either a single number, or an array of numbers to describe the angle of a particle over it's lifetime.
+ * @property {Number} [angle.spread=0] Either a single number, or an array of numbers to describe the angle variance of a particle over it's lifetime.
+ * @property {Boolean} [angle.randomise=false] When a particle is re-spawned, whether it's angle should be re-randomised or not. Can incur a performance hit.
+ *
+ */
+
+/**
+ * The SPE.Emitter class.
+ *
+ * @constructor
+ *
+ * @param {EmitterOptions} options A map of options to configure the emitter.
+ */
+export default class Emitter {
+	constructor( opts ) {
+		// Ensure we have a map of options to play with,
+		// and that each option is in the correct format.
+		const options = utils.ensureTypedArg( opts, valueTypes.OBJECT, {} );
+		options.position = utils.ensureTypedArg( options.position, valueTypes.OBJECT, {} );
+		options.velocity = utils.ensureTypedArg( options.velocity, valueTypes.OBJECT, {} );
+		options.acceleration = utils.ensureTypedArg( options.acceleration, valueTypes.OBJECT, {} );
+		options.radius = utils.ensureTypedArg( options.radius, valueTypes.OBJECT, {} );
+		options.drag = utils.ensureTypedArg( options.drag, valueTypes.OBJECT, {} );
+		options.rotation = utils.ensureTypedArg( options.rotation, valueTypes.OBJECT, {} );
+		options.color = utils.ensureTypedArg( options.color, valueTypes.OBJECT, {} );
+		options.opacity = utils.ensureTypedArg( options.opacity, valueTypes.OBJECT, {} );
+		options.size = utils.ensureTypedArg( options.size, valueTypes.OBJECT, {} );
+		options.angle = utils.ensureTypedArg( options.angle, valueTypes.OBJECT, {} );
+		options.wiggle = utils.ensureTypedArg( options.wiggle, valueTypes.OBJECT, {} );
+		options.maxAge = utils.ensureTypedArg( options.maxAge, valueTypes.OBJECT, {} );
+
+		if ( options.onParticleSpawn ) {
+			console.warn( 'onParticleSpawn has been removed. Please set properties directly to alter values at runtime.' );
+		}
+
+		this.uuid = THREE.Math.generateUUID();
+
+		this.type = utils.ensureTypedArg( options.type, valueTypes.NUMBER, distributions.BOX );
+
+		// Start assigning properties...kicking it off with props that DON'T support values over
+		// lifetimes.
+		//
+		// Btw, values over lifetimes are just the new way of referring to *Start, *Middle, and *End.
+		this.position = {
+			_value: utils.ensureInstanceOf( options.position.value, THREE.Vector3, new THREE.Vector3() ),
+			_spread: utils.ensureInstanceOf( options.position.spread, THREE.Vector3, new THREE.Vector3() ),
+			_spreadClamp: utils.ensureInstanceOf( options.position.spreadClamp, THREE.Vector3, new THREE.Vector3() ),
+			_distribution: utils.ensureTypedArg( options.position.distribution, valueTypes.NUMBER, this.type ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+			_radius: utils.ensureTypedArg( options.position.radius, valueTypes.NUMBER, 10 ),
+			_radiusScale: utils.ensureInstanceOf( options.position.radiusScale, THREE.Vector3, new THREE.Vector3( 1, 1, 1 ) ),
+			_distributionClamp: utils.ensureTypedArg( options.position.distributionClamp, valueTypes.NUMBER, 0 ),
+		};
+
+		this.velocity = {
+			_value: utils.ensureInstanceOf( options.velocity.value, THREE.Vector3, new THREE.Vector3() ),
+			_spread: utils.ensureInstanceOf( options.velocity.spread, THREE.Vector3, new THREE.Vector3() ),
+			_distribution: utils.ensureTypedArg( options.velocity.distribution, valueTypes.NUMBER, this.type ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.acceleration = {
+			_value: utils.ensureInstanceOf( options.acceleration.value, THREE.Vector3, new THREE.Vector3() ),
+			_spread: utils.ensureInstanceOf( options.acceleration.spread, THREE.Vector3, new THREE.Vector3() ),
+			_distribution: utils.ensureTypedArg( options.acceleration.distribution, valueTypes.NUMBER, this.type ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.drag = {
+			_value: utils.ensureTypedArg( options.drag.value, valueTypes.NUMBER, 0 ),
+			_spread: utils.ensureTypedArg( options.drag.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.wiggle = {
+			_value: utils.ensureTypedArg( options.wiggle.value, valueTypes.NUMBER, 0 ),
+			_spread: utils.ensureTypedArg( options.wiggle.spread, valueTypes.NUMBER, 0 ),
+		};
+
+		this.rotation = {
+			_axis: utils.ensureInstanceOf( options.rotation.axis, THREE.Vector3, new THREE.Vector3( 0.0, 1.0, 0.0 ) ),
+			_axisSpread: utils.ensureInstanceOf( options.rotation.axisSpread, THREE.Vector3, new THREE.Vector3() ),
+			_angle: utils.ensureTypedArg( options.rotation.angle, valueTypes.NUMBER, 0 ),
+			_angleSpread: utils.ensureTypedArg( options.rotation.angleSpread, valueTypes.NUMBER, 0 ),
+			_static: utils.ensureTypedArg( options.rotation.static, valueTypes.BOOLEAN, false ),
+			_center: utils.ensureInstanceOf( options.rotation.center, THREE.Vector3, this.position._value.clone() ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+
+		this.maxAge = {
+			_value: utils.ensureTypedArg( options.maxAge.value, valueTypes.NUMBER, 2 ),
+			_spread: utils.ensureTypedArg( options.maxAge.spread, valueTypes.NUMBER, 0 ),
+		};
+
+
+
+		// The following properties can support either single values, or an array of values that change
+		// the property over a particle's lifetime (value over lifetime).
+		this.color = {
+			_value: utils.ensureArrayInstanceOf( options.color.value, THREE.Color, new THREE.Color() ),
+			_spread: utils.ensureArrayInstanceOf( options.color.spread, THREE.Vector3, new THREE.Vector3() ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.opacity = {
+			_value: utils.ensureArrayTypedArg( options.opacity.value, valueTypes.NUMBER, 1 ),
+			_spread: utils.ensureArrayTypedArg( options.opacity.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.size = {
+			_value: utils.ensureArrayTypedArg( options.size.value, valueTypes.NUMBER, 1 ),
+			_spread: utils.ensureArrayTypedArg( options.size.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.angle = {
+			_value: utils.ensureArrayTypedArg( options.angle.value, valueTypes.NUMBER, 0 ),
+			_spread: utils.ensureArrayTypedArg( options.angle.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+
+		// Assign renaining option values.
+		this.particleCount = utils.ensureTypedArg( options.particleCount, valueTypes.NUMBER, 100 );
+		this.duration = utils.ensureTypedArg( options.duration, valueTypes.NUMBER, null );
+		this.isStatic = utils.ensureTypedArg( options.isStatic, valueTypes.BOOLEAN, false );
+		this.activeMultiplier = utils.ensureTypedArg( options.activeMultiplier, valueTypes.NUMBER, 1 );
+		this.direction = utils.ensureTypedArg( options.direction, valueTypes.NUMBER, 1 );
+
+		// Whether this emitter is alive or not.
+		this.alive = utils.ensureTypedArg( options.alive, valueTypes.BOOLEAN, true );
+
+
+		// The following properties are set internally and are not
+		// user-controllable.
+		this.particlesPerSecond = 0;
+
+		// The current particle index for which particles should
+		// be marked as active on the next update cycle.
+		this.activationIndex = 0;
+
+		// The offset in the typed arrays this emitter's
+		// particle's values will start at
+		this.attributeOffset = 0;
+
+		// The end of the range in the attribute buffers
+		this.attributeEnd = 0;
+
+
+
+		// Holds the time the emitter has been alive for.
+		this.age = 0.0;
+
+		// Holds the number of currently-alive particles
+		this.activeParticleCount = 0.0;
+
+		// Holds a reference to this emitter's group once
+		// it's added to one.
+		this.group = null;
+
+		// Holds a reference to this emitter's group's attributes object
+		// for easier access.
+		this.attributes = null;
+
+		// Holds a reference to the params attribute's typed array
+		// for quicker access.
+		this.paramsArray = null;
+
+		// A set of flags to determine whether particular properties
+		// should be re-randomised when a particle is reset.
+		//
+		// If a `randomise` property is given, this is preferred.
+		// Otherwise, it looks at whether a spread value has been
+		// given.
+		//
+		// It allows randomization to be turned off as desired. If
+		// all randomization is turned off, then I'd expect a performance
+		// boost as no attribute buffers (excluding the `params`)
+		// would have to be re-passed to the GPU each frame (since nothing
+		// except the `params` attribute would have changed).
+		this.resetFlags = {
+			// params: utils.ensureTypedArg( options.maxAge.randomise, valueTypes.BOOLEAN, !!options.maxAge.spread ) ||
+			//     utils.ensureTypedArg( options.wiggle.randomise, valueTypes.BOOLEAN, !!options.wiggle.spread ),
+			position: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ) ||
+				utils.ensureTypedArg( options.radius.randomise, valueTypes.BOOLEAN, false ),
+			velocity: utils.ensureTypedArg( options.velocity.randomise, valueTypes.BOOLEAN, false ),
+			acceleration: utils.ensureTypedArg( options.acceleration.randomise, valueTypes.BOOLEAN, false ) ||
+				utils.ensureTypedArg( options.drag.randomise, valueTypes.BOOLEAN, false ),
+			rotation: utils.ensureTypedArg( options.rotation.randomise, valueTypes.BOOLEAN, false ),
+			rotationCenter: utils.ensureTypedArg( options.rotation.randomise, valueTypes.BOOLEAN, false ),
+			size: utils.ensureTypedArg( options.size.randomise, valueTypes.BOOLEAN, false ),
+			color: utils.ensureTypedArg( options.color.randomise, valueTypes.BOOLEAN, false ),
+			opacity: utils.ensureTypedArg( options.opacity.randomise, valueTypes.BOOLEAN, false ),
+			angle: utils.ensureTypedArg( options.angle.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.updateFlags = {};
+		this.updateCounts = {};
+
+		// A map to indicate which emitter parameters should update
+		// which attribute.
+		this.updateMap = {
+			maxAge: 'params',
+			position: 'position',
+			velocity: 'velocity',
+			acceleration: 'acceleration',
+			drag: 'acceleration',
+			wiggle: 'params',
+			rotation: 'rotation',
+			size: 'size',
+			color: 'color',
+			opacity: 'opacity',
+			angle: 'angle',
+		};
+
+		for ( const i in this.updateMap ) {
+			if ( HAS_OWN.call( this.updateMap, i ) ) {
+				this.updateCounts[ this.updateMap[ i ] ] = 0.0;
+				this.updateFlags[ this.updateMap[ i ] ] = false;
+				this._createGetterSetters( this[ i ], i );
+			}
+		}
+
+		this.bufferUpdateRanges = {};
+		this.attributeKeys = null;
+		this.attributeCount = 0;
+
+
+		// Ensure that the value-over-lifetime property objects above
+		// have value and spread properties that are of the same length.
+		//
+		// Also, for now, make sure they have a length of 3 (min/max arguments here).
+		utils.ensureValueOverLifetimeCompliance( this.color, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+		utils.ensureValueOverLifetimeCompliance( this.opacity, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+		utils.ensureValueOverLifetimeCompliance( this.size, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+		utils.ensureValueOverLifetimeCompliance( this.angle, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+	}
+
+	_createGetterSetters( propObj, propName ) {
+		const self = this;
+
+		for ( const i in propObj ) {
+			if ( HAS_OWN.call( propObj, i ) ) {
+
+				const name = i.replace( '_', '' );
+
+				Object.defineProperty( propObj, name, {
+					get: ( function( prop ) {
+						return function() {
+							return this[ prop ];
+						};
+					}( i ) ),
+
+					set: ( function( prop ) {
+						return function( value ) {
+							const mapName = self.updateMap[ propName ],
+								prevValue = this[ prop ],
+								length = globals.valueOverLifetimeLength;
+
+							if ( prop === '_rotationCenter' ) {
+								self.updateFlags.rotationCenter = true;
+								self.updateCounts.rotationCenter = 0.0;
+							}
+							else if ( prop === '_randomise' ) {
+								self.resetFlags[ mapName ] = value;
+							}
+							else {
+								self.updateFlags[ mapName ] = true;
+								self.updateCounts[ mapName ] = 0.0;
+							}
+
+							self.group._updateDefines();
+
+							this[ prop ] = value;
+
+							// If the previous value was an array, then make
+							// sure the provided value is interpolated correctly.
+							if ( Array.isArray( prevValue ) ) {
+								utils.ensureValueOverLifetimeCompliance( self[ propName ], length, length );
+							}
+						};
+					}( i ) ),
+				} );
+			}
+		}
+	}
+
+	_setBufferUpdateRanges( keys ) {
+		this.attributeKeys = keys;
+		this.attributeCount = keys.length;
+
+		for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+			this.bufferUpdateRanges[ keys[ i ] ] = {
+				min: Number.POSITIVE_INFINITY,
+				max: Number.NEGATIVE_INFINITY,
+			};
+		}
+	}
+
+	_calculatePPSValue( groupMaxAge ) {
+		const particleCount = this.particleCount;
+
+		// Calculate the `particlesPerSecond` value for this emitter. It's used
+		// when determining which particles should die and which should live to
+		// see another day. Or be born, for that matter. The "God" property.
+		if ( this.duration ) {
+			this.particlesPerSecond = particleCount / ( groupMaxAge < this.duration ? groupMaxAge : this.duration );
+		}
+		else {
+			this.particlesPerSecond = particleCount / groupMaxAge;
+		}
+	}
+
+	_setAttributeOffset( startIndex ) {
+		this.attributeOffset = startIndex;
+		this.activationIndex = startIndex;
+		this.activationEnd = startIndex + this.particleCount;
+	}
+
+
+	_assignValue( prop, index ) {
+		switch ( prop ) {
+			case 'position':
+				this._assignPositionValue( index );
+				break;
+
+			case 'velocity':
+			case 'acceleration':
+				this._assignForceValue( index, prop );
+				break;
+
+			case 'size':
+			case 'opacity':
+				this._assignAbsLifetimeValue( index, prop );
+				break;
+
+			case 'angle':
+				this._assignAngleValue( index );
+				break;
+
+			case 'params':
+				this._assignParamsValue( index );
+				break;
+
+			case 'rotation':
+				this._assignRotationValue( index );
+				break;
+
+			case 'color':
+				this._assignColorValue( index );
+				break;
+		}
+	}
+
+	_assignPositionValue( index ) {
+		const prop = this.position,
+			attr = this.attributes.position,
+			value = prop._value,
+			spread = prop._spread,
+			distribution = prop._distribution;
+
+		switch ( distribution ) {
+			case distributions.BOX:
+				utils.randomVector3( attr, index, value, spread, prop._spreadClamp );
+				break;
+
+			case distributions.SPHERE:
+				utils.randomVector3OnSphere( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x, prop._distributionClamp || this.particleCount );
+				break;
+
+			case distributions.DISC:
+				utils.randomVector3OnDisc( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x );
+				break;
+
+			case distributions.LINE:
+				utils.randomVector3OnLine( attr, index, value, spread );
+				break;
+		}
+	}
+
+	_assignForceValue( index, attrName ) {
+		const prop = this[ attrName ],
+			value = prop._value,
+			spread = prop._spread,
+			distribution = prop._distribution;
+		let pos,
+			positionX,
+			positionY,
+			positionZ,
+			i;
+
+		switch ( distribution ) {
+			case distributions.BOX:
+				utils.randomVector3( this.attributes[ attrName ], index, value, spread );
+				break;
+
+			case distributions.SPHERE:
+				pos = this.attributes.position.typedArray.array;
+				i = index * 3;
+
+				// Ensure position values aren't zero, otherwise no force will be
+				// applied.
+				// positionX = utils.zeroToEpsilon( pos[ i ], true );
+				// positionY = utils.zeroToEpsilon( pos[ i + 1 ], true );
+				// positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );
+				positionX = pos[ i ];
+				positionY = pos[ i + 1 ];
+				positionZ = pos[ i + 2 ];
+
+				utils.randomDirectionVector3OnSphere(
+					this.attributes[ attrName ], index,
+					positionX, positionY, positionZ,
+					this.position._value,
+					prop._value.x,
+					prop._spread.x
+				);
+				break;
+
+			case distributions.DISC:
+				pos = this.attributes.position.typedArray.array;
+				i = index * 3;
+
+				// Ensure position values aren't zero, otherwise no force will be
+				// applied.
+				// positionX = utils.zeroToEpsilon( pos[ i ], true );
+				// positionY = utils.zeroToEpsilon( pos[ i + 1 ], true );
+				// positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );
+				positionX = pos[ i ];
+				positionY = pos[ i + 1 ];
+				positionZ = pos[ i + 2 ];
+
+				utils.randomDirectionVector3OnDisc(
+					this.attributes[ attrName ], index,
+					positionX, positionY, positionZ,
+					this.position._value,
+					prop._value.x,
+					prop._spread.x
+				);
+				break;
+
+			case distributions.LINE:
+				utils.randomVector3OnLine( this.attributes[ attrName ], index, value, spread );
+				break;
+		}
+
+		if ( attrName === 'acceleration' ) {
+			const drag = utils.clamp( utils.randomFloat( this.drag._value, this.drag._spread ), 0, 1 );
+			this.attributes.acceleration.typedArray.array[ index * 4 + 3 ] = drag;
+		}
+	}
+
+	_assignAbsLifetimeValue( index, propName ) {
+		const array = this.attributes[ propName ].typedArray,
+			prop = this[ propName ];
+
+		if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
+			const value = Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) );
+			array.setVec4Components( index, value, value, value, value );
+		}
+		else {
+			array.setVec4Components( index,
+				Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) ),
+				Math.abs( utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ) ),
+				Math.abs( utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ) ),
+				Math.abs( utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] ) )
+			);
+		}
+	}
+
+	_assignAngleValue( index ) {
+		const array = this.attributes.angle.typedArray,
+			prop = this.angle;
+
+		if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
+			const value = utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] );
+			array.setVec4Components( index, value, value, value, value );
+		}
+		else {
+			array.setVec4Components( index,
+				utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ),
+				utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ),
+				utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ),
+				utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] )
+			);
+		}
+	}
+
+	_assignParamsValue( index ) {
+		this.attributes.params.typedArray.setVec4Components( index,
+			this.isStatic ? 1 : 0,
+			0.0,
+			Math.abs( utils.randomFloat( this.maxAge._value, this.maxAge._spread ) ),
+			utils.randomFloat( this.wiggle._value, this.wiggle._spread )
+		);
+	}
+
+	_assignRotationValue( index ) {
+		this.attributes.rotation.typedArray.setVec3Components( index,
+			utils.getPackedRotationAxis( this.rotation._axis, this.rotation._axisSpread ),
+			utils.randomFloat( this.rotation._angle, this.rotation._angleSpread ),
+			this.rotation._static ? 0 : 1
+		);
+
+		this.attributes.rotationCenter.typedArray.setVec3( index, this.rotation._center );
+	}
+
+	_assignColorValue( index ) {
+		utils.randomColorAsHex( this.attributes.color, index, this.color._value, this.color._spread );
+	}
+
+	_resetParticle( index ) {
+		const resetFlags = this.resetFlags,
+			updateFlags = this.updateFlags,
+			updateCounts = this.updateCounts,
+			keys = this.attributeKeys;
+		let key,
+			updateFlag;
+
+		for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+			key = keys[ i ];
+			updateFlag = updateFlags[ key ];
+
+			if ( resetFlags[ key ] === true || updateFlag === true ) {
+				this._assignValue( key, index );
+				this._updateAttributeUpdateRange( key, index );
+
+				if ( updateFlag === true && updateCounts[ key ] === this.particleCount ) {
+					updateFlags[ key ] = false;
+					updateCounts[ key ] = 0.0;
+				}
+				else if ( updateFlag == true ) {
+					++updateCounts[ key ];
+				}
+			}
+		}
+	}
+
+	_updateAttributeUpdateRange( attr, i ) {
+		var ranges = this.bufferUpdateRanges[ attr ];
+
+		ranges.min = Math.min( i, ranges.min );
+		ranges.max = Math.max( i, ranges.max );
+	}
+
+	_resetBufferRanges() {
+		const ranges = this.bufferUpdateRanges,
+			keys = this.bufferUpdateKeys;
+		let i = this.bufferUpdateCount - 1,
+			key;
+
+		for ( i; i >= 0; --i ) {
+			key = keys[ i ];
+			ranges[ key ].min = Number.POSITIVE_INFINITY;
+			ranges[ key ].max = Number.NEGATIVE_INFINITY;
+		}
+	}
+
+	_onRemove() {
+		// Reset any properties of the emitter that were set by
+		// a group when it was added.
+		this.particlesPerSecond = 0;
+		this.attributeOffset = 0;
+		this.activationIndex = 0;
+		this.activeParticleCount = 0;
+		this.group = null;
+		this.attributes = null;
+		this.paramsArray = null;
+		this.age = 0.0;
+	}
+
+	_decrementParticleCount() {
+		--this.activeParticleCount;
+
+		// TODO:
+		//  - Trigger event if count === 0.
+	}
+
+	_incrementParticleCount() {
+		'use strict';
+		++this.activeParticleCount;
+
+		// TODO:
+		//  - Trigger event if count === this.particleCount.
+	}
+
+	_checkParticleAges( start, end, params, dt ) {
+		for ( let i = end - 1, index, maxAge, age, alive; i >= start; --i ) {
+			index = i * 4;
+
+			alive = params[ index ];
+
+			if ( alive === 0.0 ) {
+				continue;
+			}
+
+			// Increment age
+			age = params[ index + 1 ];
+			maxAge = params[ index + 2 ];
+
+			if ( this.direction === 1 ) {
+				age += dt;
+
+				if ( age >= maxAge ) {
+					age = 0.0;
+					alive = 0.0;
+					this._decrementParticleCount();
+				}
+			}
+			else {
+				age -= dt;
+
+				if ( age <= 0.0 ) {
+					age = maxAge;
+					alive = 0.0;
+					this._decrementParticleCount();
+				}
+			}
+
+			params[ index ] = alive;
+			params[ index + 1 ] = age;
+
+			this._updateAttributeUpdateRange( 'params', i );
+		}
+	}
+
+	_activateParticles( activationStart, activationEnd, params, dtPerParticle ) {
+		const direction = this.direction;
+
+		for ( let i = activationStart, index, dtValue; i < activationEnd; ++i ) {
+			index = i * 4;
+
+			// Don't re-activate particles that aren't dead yet.
+			// if ( params[ index ] !== 0.0 && ( this.particleCount !== 1 || this.activeMultiplier !== 1 ) ) {
+			//     continue;
+			// }
+
+			if ( params[ index ] != 0.0 && this.particleCount !== 1 ) {
+				continue;
+			}
+
+			// Increment the active particle count.
+			this._incrementParticleCount();
+
+			// Mark the particle as alive.
+			params[ index ] = 1.0;
+
+			// Reset the particle
+			this._resetParticle( i );
+
+			// Move each particle being activated to
+			// it's actual position in time.
+			//
+			// This stops particles being 'clumped' together
+			// when frame rates are on the lower side of 60fps
+			// or not constant (a very real possibility!)
+			dtValue = dtPerParticle * ( i - activationStart );
+			params[ index + 1 ] = direction === -1 ? params[ index + 2 ] - dtValue : dtValue;
+
+			this._updateAttributeUpdateRange( 'params', i );
+		}
+	}
+
+	/**
+	 * Simulates one frame's worth of particles, updating particles
+	 * that are already alive, and marking ones that are currently dead
+	 * but should be alive as alive.
+	 *
+	 * If the emitter is marked as static, then this function will do nothing.
+	 *
+	 * @param  {Number} dt The number of seconds to simulate (deltaTime)
+	 */
+	tick( dt ) {
+		if ( this.isStatic ) {
+			return;
+		}
+
+		if ( this.paramsArray === null ) {
+			this.paramsArray = this.attributes.params.typedArray.array;
+		}
+
+		const start = this.attributeOffset,
+			end = start + this.particleCount,
+			params = this.paramsArray, // vec3( alive, age, maxAge, wiggle )
+			ppsDt = this.particlesPerSecond * this.activeMultiplier * dt,
+			activationIndex = this.activationIndex;
+
+		// Reset the buffer update indices.
+		this._resetBufferRanges();
+
+		// Increment age for those particles that are alive,
+		// and kill off any particles whose age is over the limit.
+		this._checkParticleAges( start, end, params, dt );
+
+		// If the emitter is dead, reset the age of the emitter to zero,
+		// ready to go again if required
+		if ( this.alive === false ) {
+			this.age = 0.0;
+			return;
+		}
+
+		// If the emitter has a specified lifetime and we've exceeded it,
+		// mark the emitter as dead.
+		if ( this.duration !== null && this.age > this.duration ) {
+			this.alive = false;
+			this.age = 0.0;
+			return;
+		}
+
+
+		const activationStart = this.particleCount === 1 ? activationIndex : ( activationIndex | 0 ),
+			activationEnd = Math.min( activationStart + ppsDt, this.activationEnd ),
+			activationCount = activationEnd - this.activationIndex | 0,
+			dtPerParticle = activationCount > 0 ? dt / activationCount : 0;
+
+		this._activateParticles( activationStart, activationEnd, params, dtPerParticle );
+
+		// Move the activation window forward, soldier.
+		this.activationIndex += ppsDt;
+
+		if ( this.activationIndex > end ) {
+			this.activationIndex = start;
+		}
+
+
+		// Increment the age of the emitter.
+		this.age += dt;
+	}
+
+	/**
+	 * Resets all the emitter's particles to their start positions
+	 * and marks the particles as dead if the `force` argument is
+	 * true.
+	 *
+	 * @param  {Boolean} [force=undefined] If true, all particles will be marked as dead instantly.
+	 * @return {Emitter}       This emitter instance.
+	 */
+	reset( force ) {
+		this.age = 0.0;
+		this.alive = false;
+
+		if ( force === true ) {
+			const start = this.attributeOffset,
+				end = start + this.particleCount,
+				array = this.paramsArray,
+				attr = this.attributes.params.bufferAttribute;
+
+			for ( let i = end - 1, index; i >= start; --i ) {
+				index = i * 4;
+
+				array[ index ] = 0.0;
+				array[ index + 1 ] = 0.0;
+			}
+
+			attr.updateRange.offset = 0;
+			attr.updateRange.count = -1;
+			attr.needsUpdate = true;
+		}
+
+		return this;
+	}
+
+	/**
+	 * Enables the emitter. If not already enabled, the emitter
+	 * will start emitting particles.
+	 *
+	 * @return {Emitter} This emitter instance.
+	 */
+	enable() {
+		this.alive = true;
+		return this;
+	}
+
+	/**
+	 * Disables th emitter, but does not instantly remove it's
+	 * particles fromt the scene. When called, the emitter will be
+	 * 'switched off' and just stop emitting. Any particle's alive will
+	 * be allowed to finish their lifecycle.
+	 *
+	 * @return {Emitter} This emitter instance.
+	 */
+	disable() {
+		this.alive = false;
+		return this;
+	}
+
+	/**
+	 * Remove this emitter from it's parent group (if it has been added to one).
+	 * Delgates to Group.prototype.removeEmitter().
+	 *
+	 * When called, all particle's belonging to this emitter will be instantly
+	 * removed from the scene.
+	 *
+	 * @return {Emitter} This emitter instance.
+	 *
+	 * @see Group.prototype.removeEmitter
+	 */
+	remove() {
+		if ( this.group !== null ) {
+			this.group.removeEmitter( this );
+		}
+		else {
+			console.error( 'Emitter does not belong to a group, cannot remove.' );
+		}
+
+		return this;
+	}
+}
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/core_Group.js.html b/docs/api/core_Group.js.html new file mode 100644 index 0000000..37b4d4f --- /dev/null +++ b/docs/api/core_Group.js.html @@ -0,0 +1,775 @@ + + + + + JSDoc: Source: core/Group.js + + + + + + + + + + +
+ +

Source: core/Group.js

+ + + + + + +
+
+ 
import * as THREE from 'three';
+import valueTypes from '@/constants/valueTypes';
+import globals from '@/constants/globals';
+import utils from './utils';
+import ShaderAttribute from '@/helpers/ShaderAttribute';
+import shaders from '@/shaders/shaders';
+import Emitter from './Emitter';
+
+const HAS_OWN = Object.prototype.hasOwnProperty;
+
+/**
+ * An SPE.Group instance.
+ * @typedef {Object} Group
+ * @see SPE.Group
+ */
+
+/**
+ * A map of options to configure an SPE.Group instance.
+ * @typedef {Object} GroupOptions
+ *
+ * @property {Object} texture An object describing the texture used by the group.
+ *
+ * @property {Object} texture.value An instance of THREE.Texture.
+ *
+ * @property {Object=} texture.frames A THREE.Vector2 instance describing the number
+ *                                    of frames on the x- and y-axis of the given texture.
+ *                                    If not provided, the texture will NOT be treated as
+ *                                    a sprite-sheet and as such will NOT be animated.
+ *
+ * @property {Number} [texture.frameCount=texture.frames.x * texture.frames.y] The total number of frames in the sprite-sheet.
+ *                                                                   Allows for sprite-sheets that don't fill the entire
+ *                                                                   texture.
+ *
+ * @property {Number} texture.loop The number of loops through the sprite-sheet that should
+ *                                 be performed over the course of a single particle's lifetime.
+ *
+ * @property {Number} fixedTimeStep If no `dt` (or `deltaTime`) value is passed to this group's
+ *                                  `tick()` function, this number will be used to move the particle
+ *                                  simulation forward. Value in SECONDS.
+ *
+ * @property {Boolean} hasPerspective Whether the distance a particle is from the camera should affect
+ *                                    the particle's size.
+ *
+ * @property {Boolean} colorize Whether the particles in this group should be rendered with color, or
+ *                              whether the only color of particles will come from the provided texture.
+ *
+ * @property {Number} blending One of Three.js's blending modes to apply to this group's `ShaderMaterial`.
+ *
+ * @property {Boolean} transparent Whether these particle's should be rendered with transparency.
+ *
+ * @property {Number} alphaTest Sets the alpha value to be used when running an alpha test on the `texture.value` property. Value between 0 and 1.
+ *
+ * @property {Boolean} depthWrite Whether rendering the group has any effect on the depth buffer.
+ *
+ * @property {Boolean} depthTest Whether to have depth test enabled when rendering this group.
+ *
+ * @property {Boolean} fog Whether this group's particles should be affected by their scene's fog.
+ *
+ * @property {Number} scale The scale factor to apply to this group's particle sizes. Useful for
+ *                          setting particle sizes to be relative to renderer size.
+ */
+
+
+/**
+ * The SPE.Group class. Creates a new group, containing a material, geometry, and mesh.
+ *
+ * @constructor
+ * @param {GroupOptions} options A map of options to configure the group instance.
+ */
+export default class Group {
+	constructor( opts ) {
+		// Ensure we have a map of options to play with
+		const options = utils.ensureTypedArg( opts, valueTypes.OBJECT, {} );
+		options.texture = utils.ensureTypedArg( options.texture, valueTypes.OBJECT, {} );
+
+		// Assign a UUID to this instance
+		this.uuid = THREE.Math.generateUUID();
+
+		// If no `deltaTime` value is passed to the `SPE.Group.tick` function,
+		// the value of this property will be used to advance the simulation.
+		this.fixedTimeStep = utils.ensureTypedArg( options.fixedTimeStep, valueTypes.NUMBER, 0.016 );
+
+		// Set properties used in the uniforms map, starting with the
+		// texture stuff.
+		this.texture = utils.ensureInstanceOf( options.texture.value, THREE.Texture, null );
+		this.textureFrames = utils.ensureInstanceOf( options.texture.frames, THREE.Vector2, new THREE.Vector2( 1, 1 ) );
+		this.textureFrameCount = utils.ensureTypedArg( options.texture.frameCount, valueTypes.NUMBER, this.textureFrames.x * this.textureFrames.y );
+		this.textureLoop = utils.ensureTypedArg( options.texture.loop, valueTypes.NUMBER, 1 );
+		this.textureFrames.max( new THREE.Vector2( 1, 1 ) );
+
+		this.hasPerspective = utils.ensureTypedArg( options.hasPerspective, valueTypes.BOOLEAN, true );
+		this.colorize = utils.ensureTypedArg( options.colorize, valueTypes.BOOLEAN, true );
+
+		this.maxParticleCount = utils.ensureTypedArg( options.maxParticleCount, valueTypes.NUMBER, null );
+
+
+		// Set properties used to define the ShaderMaterial's appearance.
+		this.blending = utils.ensureTypedArg( options.blending, valueTypes.NUMBER, THREE.AdditiveBlending );
+		this.transparent = utils.ensureTypedArg( options.transparent, valueTypes.BOOLEAN, true );
+		this.alphaTest = parseFloat( utils.ensureTypedArg( options.alphaTest, valueTypes.NUMBER, 0.0 ) );
+		this.depthWrite = utils.ensureTypedArg( options.depthWrite, valueTypes.BOOLEAN, false );
+		this.depthTest = utils.ensureTypedArg( options.depthTest, valueTypes.BOOLEAN, true );
+		this.fog = utils.ensureTypedArg( options.fog, valueTypes.BOOLEAN, true );
+		this.scale = utils.ensureTypedArg( options.scale, valueTypes.NUMBER, 300 );
+
+		// Where emitter's go to curl up in a warm blanket and live
+		// out their days.
+		this.emitters = [];
+		this.emitterIDs = [];
+
+		// Create properties for use by the emitter pooling functions.
+		this._pool = [];
+		this._poolCreationSettings = null;
+		this._createNewWhenPoolEmpty = 0;
+
+		// Whether all attributes should be forced to updated
+		// their entire buffer contents on the next tick.
+		//
+		// Used when an emitter is removed.
+		this._attributesNeedRefresh = false;
+		this._attributesNeedDynamicReset = false;
+
+		this.particleCount = 0;
+
+
+		// Map of uniforms to be applied to the ShaderMaterial instance.
+		this.uniforms = {
+			tex: {
+				type: 't',
+				value: this.texture,
+			},
+			textureAnimation: {
+				type: 'v4',
+				value: new THREE.Vector4(
+					this.textureFrames.x,
+					this.textureFrames.y,
+					this.textureFrameCount,
+					Math.max( Math.abs( this.textureLoop ), 1.0 )
+				),
+			},
+			fogColor: {
+				type: 'c',
+				value: this.fog ? new THREE.Color() : null,
+			},
+			fogNear: {
+				type: 'f',
+				value: 10,
+			},
+			fogFar: {
+				type: 'f',
+				value: 200,
+			},
+			fogDensity: {
+				type: 'f',
+				value: 0.5,
+			},
+			deltaTime: {
+				type: 'f',
+				value: 0,
+			},
+			runTime: {
+				type: 'f',
+				value: 0,
+			},
+			scale: {
+				type: 'f',
+				value: this.scale,
+			},
+		};
+
+		// Add some defines into the mix...
+		this.defines = {
+			HAS_PERSPECTIVE: this.hasPerspective,
+			COLORIZE: this.colorize,
+			VALUE_OVER_LIFETIME_LENGTH: globals.valueOverLifetimeLength,
+
+			SHOULD_ROTATE_TEXTURE: false,
+			SHOULD_ROTATE_PARTICLES: false,
+			SHOULD_WIGGLE_PARTICLES: false,
+
+			SHOULD_CALCULATE_SPRITE: this.textureFrames.x > 1 || this.textureFrames.y > 1,
+		};
+
+		// Map of all attributes to be applied to the particles.
+		//
+		// See `ShaderAttribute` for a bit more info on this.
+		this.attributes = {
+			position: new ShaderAttribute( 'v3', true ),
+			acceleration: new ShaderAttribute( 'v4', true ), // w component is drag
+			velocity: new ShaderAttribute( 'v3', true ),
+			rotation: new ShaderAttribute( 'v4', true ),
+			rotationCenter: new ShaderAttribute( 'v3', true ),
+			params: new ShaderAttribute( 'v4', true ), // Holds (alive, age, delay, wiggle)
+			size: new ShaderAttribute( 'v4', true ),
+			angle: new ShaderAttribute( 'v4', true ),
+			color: new ShaderAttribute( 'v4', true ),
+			opacity: new ShaderAttribute( 'v4', true ),
+		};
+
+		this.attributeKeys = Object.keys( this.attributes );
+		this.attributeCount = this.attributeKeys.length;
+
+		// Create the ShaderMaterial instance that'll help render the
+		// particles.
+		this.material = new THREE.ShaderMaterial( {
+			uniforms: this.uniforms,
+			vertexShader: shaders.vertex,
+			fragmentShader: shaders.fragment,
+			blending: this.blending,
+			transparent: this.transparent,
+			alphaTest: this.alphaTest,
+			depthWrite: this.depthWrite,
+			depthTest: this.depthTest,
+			defines: this.defines,
+			fog: this.fog,
+		} );
+
+		// Create the BufferGeometry and Points instances, ensuring
+		// the geometry and material are given to the latter.
+		this.geometry = new THREE.BufferGeometry();
+		this.mesh = new THREE.Points( this.geometry, this.material );
+
+		if ( this.maxParticleCount === null ) {
+			console.warn( 'SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.' );
+		}
+	}
+
+	_updateDefines() {
+		const emitters = this.emitters,
+			defines = this.defines;
+		let emitter,
+			i = emitters.length - 1;
+
+		for ( i; i >= 0; --i ) {
+			emitter = emitters[ i ];
+
+			// Only do angle calculation if there's no spritesheet defined.
+			//
+			// Saves calculations being done and then overwritten in the shaders.
+			if ( !defines.SHOULD_CALCULATE_SPRITE ) {
+				defines.SHOULD_ROTATE_TEXTURE = defines.SHOULD_ROTATE_TEXTURE || !!Math.max(
+					Math.max.apply( null, emitter.angle.value ),
+					Math.max.apply( null, emitter.angle.spread )
+				);
+			}
+
+			defines.SHOULD_ROTATE_PARTICLES = defines.SHOULD_ROTATE_PARTICLES || !!Math.max(
+				emitter.rotation.angle,
+				emitter.rotation.angleSpread
+			);
+
+			defines.SHOULD_WIGGLE_PARTICLES = defines.SHOULD_WIGGLE_PARTICLES || !!Math.max(
+				emitter.wiggle.value,
+				emitter.wiggle.spread
+			);
+		}
+
+		this.material.needsUpdate = true;
+	}
+
+	_applyAttributesToGeometry() {
+		const attributes = this.attributes,
+			geometry = this.geometry,
+			geometryAttributes = geometry.attributes;
+		let attribute,
+			geometryAttribute;
+
+		// Loop through all the shader attributes and assign (or re-assign)
+		// typed array buffers to each one.
+		for ( const attr in attributes ) {
+			if ( HAS_OWN.call( attributes, attr ) ) {
+				attribute = attributes[ attr ];
+				geometryAttribute = geometryAttributes[ attr ];
+
+				// Update the array if this attribute exists on the geometry.
+				//
+				// This needs to be done because the attribute's typed array might have
+				// been resized and reinstantiated, and might now be looking at a
+				// different ArrayBuffer, so reference needs updating.
+				if ( geometryAttribute ) {
+					geometryAttribute.array = attribute.typedArray.array;
+				}
+
+				// // Add the attribute to the geometry if it doesn't already exist.
+				else {
+					geometry.addAttribute( attr, attribute.bufferAttribute );
+				}
+
+				// Mark the attribute as needing an update the next time a frame is rendered.
+				attribute.bufferAttribute.needsUpdate = true;
+			}
+		}
+
+		// Mark the draw range on the geometry. This will ensure
+		// only the values in the attribute buffers that are
+		// associated with a particle will be used in THREE's
+		// render cycle.
+		this.geometry.setDrawRange( 0, this.particleCount );
+	}
+
+	/**
+     * Adds an SPE.Emitter instance to this group, creating particle values and
+     * assigning them to this group's shader attributes.
+     *
+     * @param {Emitter} emitter The emitter to add to this group.
+     */
+	addEmitter( emitter ) {
+		// Ensure an actual emitter instance is passed here.
+		//
+		// Decided not to throw here, just in case a scene's
+		// rendering would be paused. Logging an error instead
+		// of stopping execution if exceptions aren't caught.
+		if ( emitter instanceof Emitter === false ) {
+			console.error( '`emitter` argument must be instance of Emitter. Was provided with:', emitter );
+			return;
+		}
+
+		// If the emitter already exists as a member of this group, then
+		// stop here, we don't want to add it again.
+		else if ( this.emitterIDs.indexOf( emitter.uuid ) > -1 ) {
+			console.error( 'Emitter already exists in this group. Will not add again.' );
+			return;
+		}
+
+		// And finally, if the emitter is a member of another group,
+		// don't add it to this group.
+		else if ( emitter.group !== null ) {
+			console.error( 'Emitter already belongs to another group. Will not add to requested group.' );
+			return;
+		}
+
+		const attributes = this.attributes,
+			start = this.particleCount,
+			end = start + emitter.particleCount;
+
+		// Update this group's particle count.
+		this.particleCount = end;
+
+		// Emit a warning if the emitter being added will exceed the buffer sizes specified.
+		if ( this.maxParticleCount !== null && this.particleCount > this.maxParticleCount ) {
+			console.warn( 'SPE.Group: maxParticleCount exceeded. Requesting', this.particleCount, 'particles, can support only', this.maxParticleCount );
+		}
+
+
+		// Set the `particlesPerSecond` value (PPS) on the emitter.
+		// It's used to determine how many particles to release
+		// on a per-frame basis.
+		emitter._calculatePPSValue( emitter.maxAge._value + emitter.maxAge._spread );
+		emitter._setBufferUpdateRanges( this.attributeKeys );
+
+		// Store the offset value in the TypedArray attributes for this emitter.
+		emitter._setAttributeOffset( start );
+
+		// Save a reference to this group on the emitter so it knows
+		// where it belongs.
+		emitter.group = this;
+
+		// Store reference to the attributes on the emitter for
+		// easier access during the emitter's tick function.
+		emitter.attributes = this.attributes;
+
+
+
+		// Ensure the attributes and their BufferAttributes exist, and their
+		// TypedArrays are of the correct size.
+		for ( const attr in attributes ) {
+			if ( HAS_OWN.call( attributes, attr ) ) {
+				// When creating a buffer, pass through the maxParticle count
+				// if one is specified.
+				attributes[ attr ]._createBufferAttribute(
+					this.maxParticleCount !== null ?
+						this.maxParticleCount :
+						this.particleCount
+				);
+			}
+		}
+
+		// Loop through each particle this emitter wants to have, and create the attributes values,
+		// storing them in the TypedArrays that each attribute holds.
+		for ( let i = start; i < end; ++i ) {
+			emitter._assignPositionValue( i );
+			emitter._assignForceValue( i, 'velocity' );
+			emitter._assignForceValue( i, 'acceleration' );
+			emitter._assignAbsLifetimeValue( i, 'opacity' );
+			emitter._assignAbsLifetimeValue( i, 'size' );
+			emitter._assignAngleValue( i );
+			emitter._assignRotationValue( i );
+			emitter._assignParamsValue( i );
+			emitter._assignColorValue( i );
+		}
+
+		// Update the geometry and make sure the attributes are referencing
+		// the typed arrays properly.
+		this._applyAttributesToGeometry();
+
+		// Store this emitter in this group's emitter's store.
+		this.emitters.push( emitter );
+		this.emitterIDs.push( emitter.uuid );
+
+		// Update certain flags to enable shader calculations only if they're necessary.
+		this._updateDefines( emitter );
+
+		// Update the material since defines might have changed
+		this.material.needsUpdate = true;
+		this.geometry.needsUpdate = true;
+		this._attributesNeedRefresh = true;
+
+		// Return the group to enable chaining.
+		return this;
+	}
+
+	/**
+     * Removes an Emitter instance from this group. When called,
+     * all particle's belonging to the given emitter will be instantly
+     * removed from the scene.
+     *
+     * @param {Emitter} emitter The emitter to add to this group.
+     */
+	removeEmitter( emitter ) {
+		const emitterIndex = this.emitterIDs.indexOf( emitter.uuid );
+
+		// Ensure an actual emitter instance is passed here.
+		//
+		// Decided not to throw here, just in case a scene's
+		// rendering would be paused. Logging an error instead
+		// of stopping execution if exceptions aren't caught.
+		if ( emitter instanceof Emitter === false ) {
+			console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter );
+			return;
+		}
+
+		// Issue an error if the emitter isn't a member of this group.
+		else if ( emitterIndex === -1 ) {
+			console.error( 'Emitter does not exist in this group. Will not remove.' );
+			return;
+		}
+
+		// Kill all particles by marking them as dead
+		// and their age as 0.
+		const start = emitter.attributeOffset,
+			end = start + emitter.particleCount,
+			params = this.attributes.params.typedArray;
+
+		// Set alive and age to zero.
+		for ( let i = start; i < end; ++i ) {
+			params.array[ i * 4 ] = 0.0;
+			params.array[ i * 4 + 1 ] = 0.0;
+		}
+
+		// Remove the emitter from this group's "store".
+		this.emitters.splice( emitterIndex, 1 );
+		this.emitterIDs.splice( emitterIndex, 1 );
+
+		// Remove this emitter's attribute values from all shader attributes.
+		// The `.splice()` call here also marks each attribute's buffer
+		// as needing to update it's entire contents.
+		for ( const attr in this.attributes ) {
+			if ( HAS_OWN.call( this.attributes, attr ) ) {
+				this.attributes[ attr ].splice( start, end );
+			}
+		}
+
+		// Ensure this group's particle count is correct.
+		this.particleCount -= emitter.particleCount;
+
+		// Call the emitter's remove method.
+		emitter._onRemove();
+
+		// Set a flag to indicate that the attribute buffers should
+		// be updated in their entirety on the next frame.
+		this._attributesNeedRefresh = true;
+	}
+
+
+	/**
+     * Fetch a single emitter instance from the pool.
+     * If there are no objects in the pool, a new emitter will be
+     * created if specified.
+     *
+     * @return {Emitter|null}
+     */
+	getFromPool() {
+		const pool = this._pool,
+			createNew = this._createNewWhenPoolEmpty;
+
+		if ( pool.length ) {
+			return pool.pop();
+		}
+		else if ( createNew ) {
+			const emitter = new Emitter( this._poolCreationSettings );
+
+			this.addEmitter( emitter );
+
+			return emitter;
+		}
+
+		return null;
+	}
+
+
+	/**
+     * Release an emitter into the pool.
+     *
+     * @param  {ShaderParticleEmitter} emitter
+     * @return {Group} This group instance.
+     */
+	releaseIntoPool( emitter ) {
+		if ( emitter instanceof Emitter === false ) {
+			console.error( 'Argument is not instanceof Emitter:', emitter );
+			return;
+		}
+
+		emitter.reset();
+		this._pool.unshift( emitter );
+
+		return this;
+	}
+
+
+	/**
+     * Get the pool array
+     *
+     * @return {Array}
+     */
+	getPool() {
+		return this._pool;
+	}
+
+
+	/**
+     * Add a pool of emitters to this particle group
+     *
+     * @param {Number} numEmitters      The number of emitters to add to the pool.
+     * @param {EmitterOptions|Array} emitterOptions  An object, or array of objects, describing the options to pass to each emitter.
+     * @param {Boolean} createNew       Should a new emitter be created if the pool runs out?
+     * @return {Group} This group instance.
+     */
+	addPool( numEmitters, emitterOptions, createNew ) {
+		// Save relevant settings and flags.
+		this._poolCreationSettings = emitterOptions;
+		this._createNewWhenPoolEmpty = !!createNew;
+
+		// Create the emitters, add them to this group and the pool.
+		for ( let i = 0; i < numEmitters; ++i ) {
+			let args;
+
+			if ( Array.isArray( emitterOptions ) ) {
+				args = emitterOptions[ i ];
+			}
+			else {
+				args = emitterOptions;
+			}
+
+			const emitter = new Emitter( args );
+
+			this.addEmitter( emitter );
+			this.releaseIntoPool( emitter );
+		}
+
+		return this;
+	}
+
+
+
+	_triggerSingleEmitter( pos ) {
+		const emitter = this.getFromPool();
+
+		if ( emitter === null ) {
+			console.log( 'Group pool ran out.' );
+			return;
+		}
+
+		// TODO:
+		// - Make sure buffers are update with the new position.
+		if ( pos instanceof THREE.Vector3 ) {
+			emitter.position.value.copy( pos );
+
+			// Trigger the setter for this property to force an
+			// update to the emitter's position attribute.
+			emitter.position.value = emitter.position.value; // eslint-disable-line
+		}
+
+		emitter.enable();
+
+		setTimeout( () => {
+			emitter.disable();
+			this.releaseIntoPool( emitter );
+		}, ( Math.max( emitter.duration, ( emitter.maxAge.value + emitter.maxAge.spread ) ) ) * 1000 );
+
+		return this;
+	}
+
+
+	/**
+     * Set a given number of emitters as alive, with an optional position
+     * vector3 to move them to.
+     *
+     * @param  {Number} numEmitters The number of emitters to activate
+     * @param  {Object} [position=undefined] A THREE.Vector3 instance describing the position to activate the emitter(s) at.
+     * @return {Group} This group instance.
+     */
+	triggerPoolEmitter( numEmitters, position ) {
+		if ( typeof numEmitters === 'number' && numEmitters > 1 ) {
+			for ( let i = 0; i < numEmitters; ++i ) {
+				this._triggerSingleEmitter( position );
+			}
+		}
+		else {
+			this._triggerSingleEmitter( position );
+		}
+
+		return this;
+	}
+
+
+
+	_updateUniforms( dt ) {
+		this.uniforms.runTime.value += dt;
+		this.uniforms.deltaTime.value = dt;
+	}
+
+	_resetBufferRanges() {
+		const keys = this.attributeKeys,
+			attrs = this.attributes;
+		let i = this.attributeCount - 1;
+
+		for ( i; i >= 0; --i ) {
+			attrs[ keys[ i ] ].resetUpdateRange();
+		}
+	}
+
+
+	_updateBuffers( emitter ) {
+		const keys = this.attributeKeys,
+			attrs = this.attributes,
+			emitterRanges = emitter.bufferUpdateRanges;
+		let key,
+			emitterAttr,
+			attr;
+
+		for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+			key = keys[ i ];
+			emitterAttr = emitterRanges[ key ];
+			attr = attrs[ key ];
+			attr.setUpdateRange( emitterAttr.min, emitterAttr.max );
+			attr.flagUpdate();
+		}
+	}
+
+
+	/**
+     * Simulate all the emitter's belonging to this group, updating
+     * attribute values along the way.
+     * @param  {Number} [dt=Group's `fixedTimeStep` value] The number of seconds to simulate the group's emitters for (deltaTime)
+     */
+	tick( dt ) {
+		const emitters = this.emitters,
+			numEmitters = emitters.length,
+			deltaTime = dt || this.fixedTimeStep,
+			keys = this.attributeKeys,
+			attrs = this.attributes;
+
+		// Update uniform values.
+		this._updateUniforms( deltaTime );
+
+		// Reset buffer update ranges on the shader attributes.
+		this._resetBufferRanges();
+
+
+		// If nothing needs updating, then stop here.
+		if (
+			numEmitters === 0 &&
+            this._attributesNeedRefresh === false &&
+            this._attributesNeedDynamicReset === false
+		) {
+			return;
+		}
+
+		// Loop through each emitter in this group and
+		// simulate it, then update the shader attribute
+		// buffers.
+		for ( let i = 0, emitter; i < numEmitters; ++i ) {
+			emitter = emitters[ i ];
+			emitter.tick( deltaTime );
+			this._updateBuffers( emitter );
+		}
+
+		// If the shader attributes have been refreshed,
+		// then the dynamic properties of each buffer
+		// attribute will need to be reset back to
+		// what they should be.
+		if ( this._attributesNeedDynamicReset === true ) {
+			for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+				attrs[ keys[ i ] ].resetDynamic();
+			}
+
+			this._attributesNeedDynamicReset = false;
+		}
+
+		// If this group's shader attributes need a full refresh
+		// then mark each attribute's buffer attribute as
+		// needing so.
+		if ( this._attributesNeedRefresh === true ) {
+			for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+				attrs[ keys[ i ] ].forceUpdateAll();
+			}
+
+			this._attributesNeedRefresh = false;
+			this._attributesNeedDynamicReset = true;
+		}
+	}
+
+
+	/**
+     * Dipose the geometry and material for the group.
+     *
+     * @return {Group} Group instance.
+     */
+	dispose() {
+		this.geometry.dispose();
+		this.material.dispose();
+		return this;
+	}
+}
+
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/core_SPE.Emitter.js.html b/docs/api/core_SPE.Emitter.js.html deleted file mode 100644 index d677e2a..0000000 --- a/docs/api/core_SPE.Emitter.js.html +++ /dev/null @@ -1,1041 +0,0 @@ - - - - - JSDoc: Source: core/SPE.Emitter.js - - - - - - - - - - -
- -

Source: core/SPE.Emitter.js

- - - - - - -
-
- 
/**
- * An SPE.Emitter instance.
- * @typedef {Object} Emitter
- * @see SPE.Emitter
- */
-
-/**
- * A map of options to configure an SPE.Emitter instance.
- *
- * @typedef {Object} EmitterOptions
- *
- * @property {distribution} [type=BOX] The default distribution this emitter should use to control
- *                         its particle's spawn position and force behaviour.
- *                         Must be an SPE.distributions.* value.
- *
- *
- * @property {Number} [particleCount=100] The total number of particles this emitter will hold. NOTE: this is not the number
- *                                  of particles emitted in a second, or anything like that. The number of particles
- *                                  emitted per-second is calculated by particleCount / maxAge (approximately!)
- *
- * @property {Number|null} [duration=null] The duration in seconds that this emitter should live for. If not specified, the emitter
- *                                         will emit particles indefinitely.
- *                                         NOTE: When an emitter is older than a specified duration, the emitter is NOT removed from
- *                                         it's group, but rather is just marked as dead, allowing it to be reanimated at a later time
- *                                         using `SPE.Emitter.prototype.enable()`.
- *
- * @property {Boolean} [isStatic=false] Whether this emitter should be not be simulated (true).
- * @property {Boolean} [activeMultiplier=1] A value between 0 and 1 describing what percentage of this emitter's particlesPerSecond should be
- *                                          emitted, where 0 is 0%, and 1 is 100%.
- *                                          For example, having an emitter with 100 particles, a maxAge of 2, yields a particlesPerSecond
- *                                          value of 50. Setting `activeMultiplier` to 0.5, then, will only emit 25 particles per second (0.5 = 50%).
- *                                          Values greater than 1 will emulate a burst of particles, causing the emitter to run out of particles
- *                                          before it's next activation cycle.
- *
- * @property {Boolean} [direction=1] The direction of the emitter. If value is `1`, emitter will start at beginning of particle's lifecycle.
- *                                   If value is `-1`, emitter will start at end of particle's lifecycle and work it's way backwards.
- *
- * @property {Object} [maxAge={}] An object describing the particle's maximum age in seconds.
- * @property {Number} [maxAge.value=2] A number between 0 and 1 describing the amount of maxAge to apply to all particles.
- * @property {Number} [maxAge.spread=0] A number describing the maxAge variance on a per-particle basis.
- *
- *
- * @property {Object} [position={}] An object describing this emitter's position.
- * @property {Object} [position.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base position.
- * @property {Object} [position.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis.
- *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
- *                                                          of this vector is used.
- * @property {Object} [position.spreadClamp=new THREE.Vector3()] A THREE.Vector3 instance describing the numeric multiples the particle's should
- *                                                               be spread out over.
- *                                                               Note that when using a SPHERE or DISC distribution, only the x-component
- *                                                               of this vector is used.
- * @property {Number} [position.radius=10] This emitter's base radius.
- * @property {Object} [position.radiusScale=new THREE.Vector3()] A THREE.Vector3 instance describing the radius's scale in all three axes. Allows a SPHERE or DISC to be squashed or stretched.
- * @property {distribution} [position.distribution=value of the `type` option.] A specific distribution to use when radiusing particles. Overrides the `type` option.
- * @property {Boolean} [position.randomise=false] When a particle is re-spawned, whether it's position should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [velocity={}] An object describing this particle velocity.
- * @property {Object} [velocity.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base velocity.
- * @property {Object} [velocity.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's velocity variance on a per-particle basis.
- *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
- *                                                          of this vector is used.
- * @property {distribution} [velocity.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's velocity. Overrides the `type` option.
- * @property {Boolean} [velocity.randomise=false] When a particle is re-spawned, whether it's velocity should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [acceleration={}] An object describing this particle's acceleration.
- * @property {Object} [acceleration.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base acceleration.
- * @property {Object} [acceleration.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's acceleration variance on a per-particle basis.
- *                           Note that when using a SPHERE or DISC distribution, only the x-component
- *                           of this vector is used.
- * @property {distribution} [acceleration.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's acceleration. Overrides the `type` option.
- * @property {Boolean} [acceleration.randomise=false] When a particle is re-spawned, whether it's acceleration should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [drag={}] An object describing this particle drag. Drag is applied to both velocity and acceleration values.
- * @property {Number} [drag.value=0] A number between 0 and 1 describing the amount of drag to apply to all particles.
- * @property {Number} [drag.spread=0] A number describing the drag variance on a per-particle basis.
- * @property {Boolean} [drag.randomise=false] When a particle is re-spawned, whether it's drag should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [wiggle={}] This is quite a fun one! The values of this object will determine whether a particle will wiggle, or jiggle, or wave,
- *                                or shimmy, or waggle, or... Well you get the idea. The wiggle is calculated over-time, meaning that a particle will
- *                                start off with no wiggle, and end up wiggling about with the distance of the `value` specified by the time it dies.
- *                                It's quite handy to simulate fire embers, or similar effects where the particle's position should slightly change over
- *                                time, and such change isn't easily controlled by rotation, velocity, or acceleration. The wiggle is a combination of sin and cos calculations, so is circular in nature.
- * @property {Number} [wiggle.value=0] A number describing the amount of wiggle to apply to all particles. It's measured in distance.
- * @property {Number} [wiggle.spread=0] A number describing the wiggle variance on a per-particle basis.
- *
- *
- * @property {Object} [rotation={}] An object describing this emitter's rotation. It can either be static, or set to rotate from 0radians to the value of `rotation.value`
- *                                  over a particle's lifetime. Rotation values affect both a particle's position and the forces applied to it.
- * @property {Object} [rotation.axis=new THREE.Vector3(0, 1, 0)] A THREE.Vector3 instance describing this emitter's axis of rotation.
- * @property {Object} [rotation.axisSpread=new THREE.Vector3()] A THREE.Vector3 instance describing the amount of variance to apply to the axis of rotation on
- *                                                              a per-particle basis.
- * @property {Number} [rotation.angle=0] The angle of rotation, given in radians. If `rotation.static` is true, the emitter will start off rotated at this angle, and stay as such.
- *                                       Otherwise, the particles will rotate from 0radians to this value over their lifetimes.
- * @property {Number} [rotation.angleSpread=0] The amount of variance in each particle's rotation angle.
- * @property {Boolean} [rotation.static=false] Whether the rotation should be static or not.
- * @property {Object} [rotation.center=The value of `position.value`] A THREE.Vector3 instance describing the center point of rotation.
- * @property {Boolean} [rotation.randomise=false] When a particle is re-spawned, whether it's rotation should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [color={}] An object describing a particle's color. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of THREE.Color instances are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Object} [color.value=new THREE.Color()] Either a single THREE.Color instance, or an array of THREE.Color instances to describe the color of a particle over it's lifetime.
- * @property {Object} [color.spread=new THREE.Vector3()] Either a single THREE.Vector3 instance, or an array of THREE.Vector3 instances to describe the color variance of a particle over it's lifetime.
- * @property {Boolean} [color.randomise=false] When a particle is re-spawned, whether it's color should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [opacity={}] An object describing a particle's opacity. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Number} [opacity.value=1] Either a single number, or an array of numbers to describe the opacity of a particle over it's lifetime.
- * @property {Number} [opacity.spread=0] Either a single number, or an array of numbers to describe the opacity variance of a particle over it's lifetime.
- * @property {Boolean} [opacity.randomise=false] When a particle is re-spawned, whether it's opacity should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [size={}] An object describing a particle's size. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Number} [size.value=1] Either a single number, or an array of numbers to describe the size of a particle over it's lifetime.
- * @property {Number} [size.spread=0] Either a single number, or an array of numbers to describe the size variance of a particle over it's lifetime.
- * @property {Boolean} [size.randomise=false] When a particle is re-spawned, whether it's size should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [angle={}] An object describing a particle's angle. The angle is a 2d-rotation, measured in radians, applied to the particle's texture.
- *                               NOTE: if a particle's texture is a sprite-sheet, this value IS IGNORED.
- *                               This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Number} [angle.value=0] Either a single number, or an array of numbers to describe the angle of a particle over it's lifetime.
- * @property {Number} [angle.spread=0] Either a single number, or an array of numbers to describe the angle variance of a particle over it's lifetime.
- * @property {Boolean} [angle.randomise=false] When a particle is re-spawned, whether it's angle should be re-randomised or not. Can incur a performance hit.
- *
- */
-
-/**
- * The SPE.Emitter class.
- *
- * @constructor
- *
- * @param {EmitterOptions} options A map of options to configure the emitter.
- */
-SPE.Emitter = function( options ) {
-    'use strict';
-
-    var utils = SPE.utils,
-        types = utils.types,
-        lifetimeLength = SPE.valueOverLifetimeLength;
-
-    // Ensure we have a map of options to play with,
-    // and that each option is in the correct format.
-    options = utils.ensureTypedArg( options, types.OBJECT, {} );
-    options.position = utils.ensureTypedArg( options.position, types.OBJECT, {} );
-    options.velocity = utils.ensureTypedArg( options.velocity, types.OBJECT, {} );
-    options.acceleration = utils.ensureTypedArg( options.acceleration, types.OBJECT, {} );
-    options.radius = utils.ensureTypedArg( options.radius, types.OBJECT, {} );
-    options.drag = utils.ensureTypedArg( options.drag, types.OBJECT, {} );
-    options.rotation = utils.ensureTypedArg( options.rotation, types.OBJECT, {} );
-    options.color = utils.ensureTypedArg( options.color, types.OBJECT, {} );
-    options.opacity = utils.ensureTypedArg( options.opacity, types.OBJECT, {} );
-    options.size = utils.ensureTypedArg( options.size, types.OBJECT, {} );
-    options.angle = utils.ensureTypedArg( options.angle, types.OBJECT, {} );
-    options.wiggle = utils.ensureTypedArg( options.wiggle, types.OBJECT, {} );
-    options.maxAge = utils.ensureTypedArg( options.maxAge, types.OBJECT, {} );
-
-    if ( options.onParticleSpawn ) {
-        console.warn( 'onParticleSpawn has been removed. Please set properties directly to alter values at runtime.' );
-    }
-
-    this.uuid = THREE.Math.generateUUID();
-
-    this.type = utils.ensureTypedArg( options.type, types.NUMBER, SPE.distributions.BOX );
-
-    // Start assigning properties...kicking it off with props that DON'T support values over
-    // lifetimes.
-    //
-    // Btw, values over lifetimes are just the new way of referring to *Start, *Middle, and *End.
-    this.position = {
-        _value: utils.ensureInstanceOf( options.position.value, THREE.Vector3, new THREE.Vector3() ),
-        _spread: utils.ensureInstanceOf( options.position.spread, THREE.Vector3, new THREE.Vector3() ),
-        _spreadClamp: utils.ensureInstanceOf( options.position.spreadClamp, THREE.Vector3, new THREE.Vector3() ),
-        _distribution: utils.ensureTypedArg( options.position.distribution, types.NUMBER, this.type ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ),
-        _radius: utils.ensureTypedArg( options.position.radius, types.NUMBER, 10 ),
-        _radiusScale: utils.ensureInstanceOf( options.position.radiusScale, THREE.Vector3, new THREE.Vector3( 1, 1, 1 ) ),
-        _distributionClamp: utils.ensureTypedArg( options.position.distributionClamp, types.NUMBER, 0 ),
-    };
-
-    this.velocity = {
-        _value: utils.ensureInstanceOf( options.velocity.value, THREE.Vector3, new THREE.Vector3() ),
-        _spread: utils.ensureInstanceOf( options.velocity.spread, THREE.Vector3, new THREE.Vector3() ),
-        _distribution: utils.ensureTypedArg( options.velocity.distribution, types.NUMBER, this.type ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.acceleration = {
-        _value: utils.ensureInstanceOf( options.acceleration.value, THREE.Vector3, new THREE.Vector3() ),
-        _spread: utils.ensureInstanceOf( options.acceleration.spread, THREE.Vector3, new THREE.Vector3() ),
-        _distribution: utils.ensureTypedArg( options.acceleration.distribution, types.NUMBER, this.type ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.drag = {
-        _value: utils.ensureTypedArg( options.drag.value, types.NUMBER, 0 ),
-        _spread: utils.ensureTypedArg( options.drag.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.wiggle = {
-        _value: utils.ensureTypedArg( options.wiggle.value, types.NUMBER, 0 ),
-        _spread: utils.ensureTypedArg( options.wiggle.spread, types.NUMBER, 0 )
-    };
-
-    this.rotation = {
-        _axis: utils.ensureInstanceOf( options.rotation.axis, THREE.Vector3, new THREE.Vector3( 0.0, 1.0, 0.0 ) ),
-        _axisSpread: utils.ensureInstanceOf( options.rotation.axisSpread, THREE.Vector3, new THREE.Vector3() ),
-        _angle: utils.ensureTypedArg( options.rotation.angle, types.NUMBER, 0 ),
-        _angleSpread: utils.ensureTypedArg( options.rotation.angleSpread, types.NUMBER, 0 ),
-        _static: utils.ensureTypedArg( options.rotation.static, types.BOOLEAN, false ),
-        _center: utils.ensureInstanceOf( options.rotation.center, THREE.Vector3, this.position._value.clone() ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-
-    this.maxAge = {
-        _value: utils.ensureTypedArg( options.maxAge.value, types.NUMBER, 2 ),
-        _spread: utils.ensureTypedArg( options.maxAge.spread, types.NUMBER, 0 )
-    };
-
-
-
-    // The following properties can support either single values, or an array of values that change
-    // the property over a particle's lifetime (value over lifetime).
-    this.color = {
-        _value: utils.ensureArrayInstanceOf( options.color.value, THREE.Color, new THREE.Color() ),
-        _spread: utils.ensureArrayInstanceOf( options.color.spread, THREE.Vector3, new THREE.Vector3() ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.opacity = {
-        _value: utils.ensureArrayTypedArg( options.opacity.value, types.NUMBER, 1 ),
-        _spread: utils.ensureArrayTypedArg( options.opacity.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.size = {
-        _value: utils.ensureArrayTypedArg( options.size.value, types.NUMBER, 1 ),
-        _spread: utils.ensureArrayTypedArg( options.size.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.angle = {
-        _value: utils.ensureArrayTypedArg( options.angle.value, types.NUMBER, 0 ),
-        _spread: utils.ensureArrayTypedArg( options.angle.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-
-    // Assign renaining option values.
-    this.particleCount = utils.ensureTypedArg( options.particleCount, types.NUMBER, 100 );
-    this.duration = utils.ensureTypedArg( options.duration, types.NUMBER, null );
-    this.isStatic = utils.ensureTypedArg( options.isStatic, types.BOOLEAN, false );
-    this.activeMultiplier = utils.ensureTypedArg( options.activeMultiplier, types.NUMBER, 1 );
-    this.direction = utils.ensureTypedArg( options.direction, types.NUMBER, 1 );
-
-    // Whether this emitter is alive or not.
-    this.alive = utils.ensureTypedArg( options.alive, types.BOOLEAN, true );
-
-
-    // The following properties are set internally and are not
-    // user-controllable.
-    this.particlesPerSecond = 0;
-
-    // The current particle index for which particles should
-    // be marked as active on the next update cycle.
-    this.activationIndex = 0;
-
-    // The offset in the typed arrays this emitter's
-    // particle's values will start at
-    this.attributeOffset = 0;
-
-    // The end of the range in the attribute buffers
-    this.attributeEnd = 0;
-
-
-
-    // Holds the time the emitter has been alive for.
-    this.age = 0.0;
-
-    // Holds the number of currently-alive particles
-    this.activeParticleCount = 0.0;
-
-    // Holds a reference to this emitter's group once
-    // it's added to one.
-    this.group = null;
-
-    // Holds a reference to this emitter's group's attributes object
-    // for easier access.
-    this.attributes = null;
-
-    // Holds a reference to the params attribute's typed array
-    // for quicker access.
-    this.paramsArray = null;
-
-    // A set of flags to determine whether particular properties
-    // should be re-randomised when a particle is reset.
-    //
-    // If a `randomise` property is given, this is preferred.
-    // Otherwise, it looks at whether a spread value has been
-    // given.
-    //
-    // It allows randomization to be turned off as desired. If
-    // all randomization is turned off, then I'd expect a performance
-    // boost as no attribute buffers (excluding the `params`)
-    // would have to be re-passed to the GPU each frame (since nothing
-    // except the `params` attribute would have changed).
-    this.resetFlags = {
-        // params: utils.ensureTypedArg( options.maxAge.randomise, types.BOOLEAN, !!options.maxAge.spread ) ||
-        //     utils.ensureTypedArg( options.wiggle.randomise, types.BOOLEAN, !!options.wiggle.spread ),
-        position: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) ||
-            utils.ensureTypedArg( options.radius.randomise, types.BOOLEAN, false ),
-        velocity: utils.ensureTypedArg( options.velocity.randomise, types.BOOLEAN, false ),
-        acceleration: utils.ensureTypedArg( options.acceleration.randomise, types.BOOLEAN, false ) ||
-            utils.ensureTypedArg( options.drag.randomise, types.BOOLEAN, false ),
-        rotation: utils.ensureTypedArg( options.rotation.randomise, types.BOOLEAN, false ),
-        rotationCenter: utils.ensureTypedArg( options.rotation.randomise, types.BOOLEAN, false ),
-        size: utils.ensureTypedArg( options.size.randomise, types.BOOLEAN, false ),
-        color: utils.ensureTypedArg( options.color.randomise, types.BOOLEAN, false ),
-        opacity: utils.ensureTypedArg( options.opacity.randomise, types.BOOLEAN, false ),
-        angle: utils.ensureTypedArg( options.angle.randomise, types.BOOLEAN, false )
-    };
-
-    this.updateFlags = {};
-    this.updateCounts = {};
-
-    // A map to indicate which emitter parameters should update
-    // which attribute.
-    this.updateMap = {
-        maxAge: 'params',
-        position: 'position',
-        velocity: 'velocity',
-        acceleration: 'acceleration',
-        drag: 'acceleration',
-        wiggle: 'params',
-        rotation: 'rotation',
-        size: 'size',
-        color: 'color',
-        opacity: 'opacity',
-        angle: 'angle'
-    };
-
-    for ( var i in this.updateMap ) {
-        if ( this.updateMap.hasOwnProperty( i ) ) {
-            this.updateCounts[ this.updateMap[ i ] ] = 0.0;
-            this.updateFlags[ this.updateMap[ i ] ] = false;
-            this._createGetterSetters( this[ i ], i );
-        }
-    }
-
-    this.bufferUpdateRanges = {};
-    this.attributeKeys = null;
-    this.attributeCount = 0;
-
-
-    // Ensure that the value-over-lifetime property objects above
-    // have value and spread properties that are of the same length.
-    //
-    // Also, for now, make sure they have a length of 3 (min/max arguments here).
-    utils.ensureValueOverLifetimeCompliance( this.color, lifetimeLength, lifetimeLength );
-    utils.ensureValueOverLifetimeCompliance( this.opacity, lifetimeLength, lifetimeLength );
-    utils.ensureValueOverLifetimeCompliance( this.size, lifetimeLength, lifetimeLength );
-    utils.ensureValueOverLifetimeCompliance( this.angle, lifetimeLength, lifetimeLength );
-};
-
-SPE.Emitter.constructor = SPE.Emitter;
-
-SPE.Emitter.prototype._createGetterSetters = function( propObj, propName ) {
-    'use strict';
-
-    var self = this;
-
-    for ( var i in propObj ) {
-        if ( propObj.hasOwnProperty( i ) ) {
-
-            var name = i.replace( '_', '' );
-
-            Object.defineProperty( propObj, name, {
-                get: ( function( prop ) {
-                    return function() {
-                        return this[ prop ];
-                    };
-                }( i ) ),
-
-                set: ( function( prop ) {
-                    return function( value ) {
-                        var mapName = self.updateMap[ propName ],
-                            prevValue = this[ prop ],
-                            length = SPE.valueOverLifetimeLength;
-
-                        if ( prop === '_rotationCenter' ) {
-                            self.updateFlags.rotationCenter = true;
-                            self.updateCounts.rotationCenter = 0.0;
-                        }
-                        else if ( prop === '_randomise' ) {
-                            self.resetFlags[ mapName ] = value;
-                        }
-                        else {
-                            self.updateFlags[ mapName ] = true;
-                            self.updateCounts[ mapName ] = 0.0;
-                        }
-
-                        self.group._updateDefines();
-
-                        this[ prop ] = value;
-
-                        // If the previous value was an array, then make
-                        // sure the provided value is interpolated correctly.
-                        if ( Array.isArray( prevValue ) ) {
-                            SPE.utils.ensureValueOverLifetimeCompliance( self[ propName ], length, length );
-                        }
-                    };
-                }( i ) )
-            } );
-        }
-    }
-};
-
-SPE.Emitter.prototype._setBufferUpdateRanges = function( keys ) {
-    'use strict';
-
-    this.attributeKeys = keys;
-    this.attributeCount = keys.length;
-
-    for ( var i = this.attributeCount - 1; i >= 0; --i ) {
-        this.bufferUpdateRanges[ keys[ i ] ] = {
-            min: Number.POSITIVE_INFINITY,
-            max: Number.NEGATIVE_INFINITY
-        };
-    }
-};
-
-SPE.Emitter.prototype._calculatePPSValue = function( groupMaxAge ) {
-    'use strict';
-
-    var particleCount = this.particleCount;
-
-
-    // Calculate the `particlesPerSecond` value for this emitter. It's used
-    // when determining which particles should die and which should live to
-    // see another day. Or be born, for that matter. The "God" property.
-    if ( this.duration ) {
-        this.particlesPerSecond = particleCount / ( groupMaxAge < this.duration ? groupMaxAge : this.duration );
-    }
-    else {
-        this.particlesPerSecond = particleCount / groupMaxAge;
-    }
-};
-
-SPE.Emitter.prototype._setAttributeOffset = function( startIndex ) {
-    this.attributeOffset = startIndex;
-    this.activationIndex = startIndex;
-    this.activationEnd = startIndex + this.particleCount;
-};
-
-
-SPE.Emitter.prototype._assignValue = function( prop, index ) {
-    'use strict';
-
-    switch ( prop ) {
-        case 'position':
-            this._assignPositionValue( index );
-            break;
-
-        case 'velocity':
-        case 'acceleration':
-            this._assignForceValue( index, prop );
-            break;
-
-        case 'size':
-        case 'opacity':
-            this._assignAbsLifetimeValue( index, prop );
-            break;
-
-        case 'angle':
-            this._assignAngleValue( index );
-            break;
-
-        case 'params':
-            this._assignParamsValue( index );
-            break;
-
-        case 'rotation':
-            this._assignRotationValue( index );
-            break;
-
-        case 'color':
-            this._assignColorValue( index );
-            break;
-    }
-};
-
-SPE.Emitter.prototype._assignPositionValue = function( index ) {
-    'use strict';
-
-    var distributions = SPE.distributions,
-        utils = SPE.utils,
-        prop = this.position,
-        attr = this.attributes.position,
-        value = prop._value,
-        spread = prop._spread,
-        distribution = prop._distribution;
-
-    switch ( distribution ) {
-        case distributions.BOX:
-            utils.randomVector3( attr, index, value, spread, prop._spreadClamp );
-            break;
-
-        case distributions.SPHERE:
-            utils.randomVector3OnSphere( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x, prop._distributionClamp || this.particleCount );
-            break;
-
-        case distributions.DISC:
-            utils.randomVector3OnDisc( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x );
-            break;
-    }
-};
-
-SPE.Emitter.prototype._assignForceValue = function( index, attrName ) {
-    'use strict';
-
-    var distributions = SPE.distributions,
-        utils = SPE.utils,
-        prop = this[ attrName ],
-        value = prop._value,
-        spread = prop._spread,
-        distribution = prop._distribution,
-        pos,
-        positionX,
-        positionY,
-        positionZ,
-        i;
-
-    switch ( distribution ) {
-        case distributions.BOX:
-            utils.randomVector3( this.attributes[ attrName ], index, value, spread );
-            break;
-
-        case distributions.SPHERE:
-            pos = this.attributes.position.typedArray.array;
-            i = index * 3;
-
-            // Ensure position values aren't zero, otherwise no force will be
-            // applied.
-            // positionX = utils.zeroToEpsilon( pos[ i ], true );
-            // positionY = utils.zeroToEpsilon( pos[ i + 1 ], true );
-            // positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );
-            positionX = pos[ i ];
-            positionY = pos[ i + 1 ];
-            positionZ = pos[ i + 2 ];
-
-            utils.randomDirectionVector3OnSphere(
-                this.attributes[ attrName ], index,
-                positionX, positionY, positionZ,
-                this.position._value,
-                prop._value.x,
-                prop._spread.x
-            );
-            break;
-
-        case distributions.DISC:
-            pos = this.attributes.position.typedArray.array;
-            i = index * 3;
-
-            // Ensure position values aren't zero, otherwise no force will be
-            // applied.
-            // positionX = utils.zeroToEpsilon( pos[ i ], true );
-            // positionY = utils.zeroToEpsilon( pos[ i + 1 ], true );
-            // positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );
-            positionX = pos[ i ];
-            positionY = pos[ i + 1 ];
-            positionZ = pos[ i + 2 ];
-
-            utils.randomDirectionVector3OnDisc(
-                this.attributes[ attrName ], index,
-                positionX, positionY, positionZ,
-                this.position._value,
-                prop._value.x,
-                prop._spread.x
-            );
-            break;
-    }
-
-    if ( attrName === 'acceleration' ) {
-        var drag = utils.clamp( utils.randomFloat( this.drag._value, this.drag._spread ), 0, 1 );
-        this.attributes.acceleration.typedArray.array[ index * 4 + 3 ] = drag;
-    }
-};
-
-SPE.Emitter.prototype._assignAbsLifetimeValue = function( index, propName ) {
-    'use strict';
-
-    var array = this.attributes[ propName ].typedArray,
-        prop = this[ propName ],
-        utils = SPE.utils,
-        value;
-
-    if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
-        value = Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) );
-        array.setVec4Components( index, value, value, value, value );
-    }
-    else {
-        array.setVec4Components( index,
-            Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) ),
-            Math.abs( utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ) ),
-            Math.abs( utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ) ),
-            Math.abs( utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] ) )
-        );
-    }
-};
-
-SPE.Emitter.prototype._assignAngleValue = function( index ) {
-    'use strict';
-
-    var array = this.attributes.angle.typedArray,
-        prop = this.angle,
-        utils = SPE.utils,
-        value;
-
-    if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
-        value = utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] );
-        array.setVec4Components( index, value, value, value, value );
-    }
-    else {
-        array.setVec4Components( index,
-            utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ),
-            utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ),
-            utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ),
-            utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] )
-        );
-    }
-};
-
-SPE.Emitter.prototype._assignParamsValue = function( index ) {
-    'use strict';
-
-    this.attributes.params.typedArray.setVec4Components( index,
-        this.isStatic ? 1 : 0,
-        0.0,
-        Math.abs( SPE.utils.randomFloat( this.maxAge._value, this.maxAge._spread ) ),
-        SPE.utils.randomFloat( this.wiggle._value, this.wiggle._spread )
-    );
-};
-
-SPE.Emitter.prototype._assignRotationValue = function( index ) {
-    'use strict';
-
-    this.attributes.rotation.typedArray.setVec3Components( index,
-        SPE.utils.getPackedRotationAxis( this.rotation._axis, this.rotation._axisSpread ),
-        SPE.utils.randomFloat( this.rotation._angle, this.rotation._angleSpread ),
-        this.rotation._static ? 0 : 1
-    );
-
-    this.attributes.rotationCenter.typedArray.setVec3( index, this.rotation._center );
-};
-
-SPE.Emitter.prototype._assignColorValue = function( index ) {
-    'use strict';
-    SPE.utils.randomColorAsHex( this.attributes.color, index, this.color._value, this.color._spread );
-};
-
-SPE.Emitter.prototype._resetParticle = function( index ) {
-    'use strict';
-
-    var resetFlags = this.resetFlags,
-        updateFlags = this.updateFlags,
-        updateCounts = this.updateCounts,
-        keys = this.attributeKeys,
-        key,
-        updateFlag;
-
-    for ( var i = this.attributeCount - 1; i >= 0; --i ) {
-        key = keys[ i ];
-        updateFlag = updateFlags[ key ];
-
-        if ( resetFlags[ key ] === true || updateFlag === true ) {
-            this._assignValue( key, index );
-            this._updateAttributeUpdateRange( key, index );
-
-            if ( updateFlag === true && updateCounts[ key ] === this.particleCount ) {
-                updateFlags[ key ] = false;
-                updateCounts[ key ] = 0.0;
-            }
-            else if ( updateFlag == true ) {
-                ++updateCounts[ key ];
-            }
-        }
-    }
-};
-
-SPE.Emitter.prototype._updateAttributeUpdateRange = function( attr, i ) {
-    'use strict';
-
-    var ranges = this.bufferUpdateRanges[ attr ];
-
-    ranges.min = Math.min( i, ranges.min );
-    ranges.max = Math.max( i, ranges.max );
-};
-
-SPE.Emitter.prototype._resetBufferRanges = function() {
-    'use strict';
-
-    var ranges = this.bufferUpdateRanges,
-        keys = this.bufferUpdateKeys,
-        i = this.bufferUpdateCount - 1,
-        key;
-
-    for ( i; i >= 0; --i ) {
-        key = keys[ i ];
-        ranges[ key ].min = Number.POSITIVE_INFINITY;
-        ranges[ key ].max = Number.NEGATIVE_INFINITY;
-    }
-};
-
-SPE.Emitter.prototype._onRemove = function() {
-    'use strict';
-    // Reset any properties of the emitter that were set by
-    // a group when it was added.
-    this.particlesPerSecond = 0;
-    this.attributeOffset = 0;
-    this.activationIndex = 0;
-    this.activeParticleCount = 0;
-    this.group = null;
-    this.attributes = null;
-    this.paramsArray = null;
-    this.age = 0.0;
-};
-
-SPE.Emitter.prototype._decrementParticleCount = function() {
-    'use strict';
-    --this.activeParticleCount;
-
-    // TODO:
-    //  - Trigger event if count === 0.
-};
-
-SPE.Emitter.prototype._incrementParticleCount = function() {
-    'use strict';
-    ++this.activeParticleCount;
-
-    // TODO:
-    //  - Trigger event if count === this.particleCount.
-};
-
-SPE.Emitter.prototype._checkParticleAges = function( start, end, params, dt ) {
-    'use strict';
-    for ( var i = end - 1, index, maxAge, age, alive; i >= start; --i ) {
-        index = i * 4;
-
-        alive = params[ index ];
-
-        if ( alive === 0.0 ) {
-            continue;
-        }
-
-        // Increment age
-        age = params[ index + 1 ];
-        maxAge = params[ index + 2 ];
-
-        if ( this.direction === 1 ) {
-            age += dt;
-
-            if ( age >= maxAge ) {
-                age = 0.0;
-                alive = 0.0;
-                this._decrementParticleCount();
-            }
-        }
-        else {
-            age -= dt;
-
-            if ( age <= 0.0 ) {
-                age = maxAge;
-                alive = 0.0;
-                this._decrementParticleCount();
-            }
-        }
-
-        params[ index ] = alive;
-        params[ index + 1 ] = age;
-
-        this._updateAttributeUpdateRange( 'params', i );
-    }
-};
-
-SPE.Emitter.prototype._activateParticles = function( activationStart, activationEnd, params, dtPerParticle ) {
-    'use strict';
-    var direction = this.direction;
-
-    for ( var i = activationStart, index, dtValue; i < activationEnd; ++i ) {
-        index = i * 4;
-
-        // Don't re-activate particles that aren't dead yet.
-        // if ( params[ index ] !== 0.0 && ( this.particleCount !== 1 || this.activeMultiplier !== 1 ) ) {
-        //     continue;
-        // }
-
-        if ( params[ index ] != 0.0 && this.particleCount !== 1 ) {
-            continue;
-        }
-
-        // Increment the active particle count.
-        this._incrementParticleCount();
-
-        // Mark the particle as alive.
-        params[ index ] = 1.0;
-
-        // Reset the particle
-        this._resetParticle( i );
-
-        // Move each particle being activated to
-        // it's actual position in time.
-        //
-        // This stops particles being 'clumped' together
-        // when frame rates are on the lower side of 60fps
-        // or not constant (a very real possibility!)
-        dtValue = dtPerParticle * ( i - activationStart )
-        params[ index + 1 ] = direction === -1 ? params[ index + 2 ] - dtValue : dtValue;
-
-        this._updateAttributeUpdateRange( 'params', i );
-    }
-};
-
-/**
- * Simulates one frame's worth of particles, updating particles
- * that are already alive, and marking ones that are currently dead
- * but should be alive as alive.
- *
- * If the emitter is marked as static, then this function will do nothing.
- *
- * @param  {Number} dt The number of seconds to simulate (deltaTime)
- */
-SPE.Emitter.prototype.tick = function( dt ) {
-    'use strict';
-
-    if ( this.isStatic ) {
-        return;
-    }
-
-    if ( this.paramsArray === null ) {
-        this.paramsArray = this.attributes.params.typedArray.array;
-    }
-
-    var start = this.attributeOffset,
-        end = start + this.particleCount,
-        params = this.paramsArray, // vec3( alive, age, maxAge, wiggle )
-        ppsDt = this.particlesPerSecond * this.activeMultiplier * dt,
-        activationIndex = this.activationIndex;
-
-    // Reset the buffer update indices.
-    this._resetBufferRanges();
-
-    // Increment age for those particles that are alive,
-    // and kill off any particles whose age is over the limit.
-    this._checkParticleAges( start, end, params, dt );
-
-    // If the emitter is dead, reset the age of the emitter to zero,
-    // ready to go again if required
-    if ( this.alive === false ) {
-        this.age = 0.0;
-        return;
-    }
-
-    // If the emitter has a specified lifetime and we've exceeded it,
-    // mark the emitter as dead.
-    if ( this.duration !== null && this.age > this.duration ) {
-        this.alive = false;
-        this.age = 0.0;
-        return;
-    }
-
-
-    var activationStart = this.particleCount === 1 ? activationIndex : ( activationIndex | 0 ),
-        activationEnd = Math.min( activationStart + ppsDt, this.activationEnd ),
-        activationCount = activationEnd - this.activationIndex | 0,
-        dtPerParticle = activationCount > 0 ? dt / activationCount : 0;
-
-    this._activateParticles( activationStart, activationEnd, params, dtPerParticle );
-
-    // Move the activation window forward, soldier.
-    this.activationIndex += ppsDt;
-
-    if ( this.activationIndex > end ) {
-        this.activationIndex = start;
-    }
-
-
-    // Increment the age of the emitter.
-    this.age += dt;
-};
-
-/**
- * Resets all the emitter's particles to their start positions
- * and marks the particles as dead if the `force` argument is
- * true.
- *
- * @param  {Boolean} [force=undefined] If true, all particles will be marked as dead instantly.
- * @return {Emitter}       This emitter instance.
- */
-SPE.Emitter.prototype.reset = function( force ) {
-    'use strict';
-
-    this.age = 0.0;
-    this.alive = false;
-
-    if ( force === true ) {
-        var start = this.attributeOffset,
-            end = start + this.particleCount,
-            array = this.paramsArray,
-            attr = this.attributes.params.bufferAttribute;
-
-        for ( var i = end - 1, index; i >= start; --i ) {
-            index = i * 4;
-
-            array[ index ] = 0.0;
-            array[ index + 1 ] = 0.0;
-        }
-
-        attr.updateRange.offset = 0;
-        attr.updateRange.count = -1;
-        attr.needsUpdate = true;
-    }
-
-    return this;
-};
-
-/**
- * Enables the emitter. If not already enabled, the emitter
- * will start emitting particles.
- *
- * @return {Emitter} This emitter instance.
- */
-SPE.Emitter.prototype.enable = function() {
-    'use strict';
-    this.alive = true;
-    return this;
-};
-
-/**
- * Disables th emitter, but does not instantly remove it's
- * particles fromt the scene. When called, the emitter will be
- * 'switched off' and just stop emitting. Any particle's alive will
- * be allowed to finish their lifecycle.
- *
- * @return {Emitter} This emitter instance.
- */
-SPE.Emitter.prototype.disable = function() {
-    'use strict';
-
-    this.alive = false;
-    return this;
-};
-
-/**
- * Remove this emitter from it's parent group (if it has been added to one).
- * Delgates to SPE.group.prototype.removeEmitter().
- *
- * When called, all particle's belonging to this emitter will be instantly
- * removed from the scene.
- *
- * @return {Emitter} This emitter instance.
- *
- * @see SPE.Group.prototype.removeEmitter
- */
-SPE.Emitter.prototype.remove = function() {
-    'use strict';
-    if ( this.group !== null ) {
-        this.group.removeEmitter( this );
-    }
-    else {
-        console.error( 'Emitter does not belong to a group, cannot remove.' );
-    }
-
-    return this;
-};
-
-
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - diff --git a/docs/api/core_SPE.Group.js.html b/docs/api/core_SPE.Group.js.html deleted file mode 100644 index 21963dc..0000000 --- a/docs/api/core_SPE.Group.js.html +++ /dev/null @@ -1,798 +0,0 @@ - - - - - JSDoc: Source: core/SPE.Group.js - - - - - - - - - - -
- -

Source: core/SPE.Group.js

- - - - - - -
-
- 
/**
- * An SPE.Group instance.
- * @typedef {Object} Group
- * @see SPE.Group
- */
-
-/**
- * A map of options to configure an SPE.Group instance.
- * @typedef {Object} GroupOptions
- *
- * @property {Object} texture An object describing the texture used by the group.
- *
- * @property {Object} texture.value An instance of THREE.Texture.
- *
- * @property {Object=} texture.frames A THREE.Vector2 instance describing the number
- *                                    of frames on the x- and y-axis of the given texture.
- *                                    If not provided, the texture will NOT be treated as
- *                                    a sprite-sheet and as such will NOT be animated.
- *
- * @property {Number} [texture.frameCount=texture.frames.x * texture.frames.y] The total number of frames in the sprite-sheet.
- *                                                                   Allows for sprite-sheets that don't fill the entire
- *                                                                   texture.
- *
- * @property {Number} texture.loop The number of loops through the sprite-sheet that should
- *                                 be performed over the course of a single particle's lifetime.
- *
- * @property {Number} fixedTimeStep If no `dt` (or `deltaTime`) value is passed to this group's
- *                                  `tick()` function, this number will be used to move the particle
- *                                  simulation forward. Value in SECONDS.
- *
- * @property {Boolean} hasPerspective Whether the distance a particle is from the camera should affect
- *                                    the particle's size.
- *
- * @property {Boolean} colorize Whether the particles in this group should be rendered with color, or
- *                              whether the only color of particles will come from the provided texture.
- *
- * @property {Number} blending One of Three.js's blending modes to apply to this group's `ShaderMaterial`.
- *
- * @property {Boolean} transparent Whether these particle's should be rendered with transparency.
- *
- * @property {Number} alphaTest Sets the alpha value to be used when running an alpha test on the `texture.value` property. Value between 0 and 1.
- *
- * @property {Boolean} depthWrite Whether rendering the group has any effect on the depth buffer.
- *
- * @property {Boolean} depthTest Whether to have depth test enabled when rendering this group.
- *
- * @property {Boolean} fog Whether this group's particles should be affected by their scene's fog.
- *
- * @property {Number} scale The scale factor to apply to this group's particle sizes. Useful for
- *                          setting particle sizes to be relative to renderer size.
- */
-
-
-/**
- * The SPE.Group class. Creates a new group, containing a material, geometry, and mesh.
- *
- * @constructor
- * @param {GroupOptions} options A map of options to configure the group instance.
- */
-SPE.Group = function( options ) {
-    'use strict';
-
-    var utils = SPE.utils,
-        types = utils.types;
-
-    // Ensure we have a map of options to play with
-    options = utils.ensureTypedArg( options, types.OBJECT, {} );
-    options.texture = utils.ensureTypedArg( options.texture, types.OBJECT, {} );
-
-    // Assign a UUID to this instance
-    this.uuid = THREE.Math.generateUUID();
-
-    // If no `deltaTime` value is passed to the `SPE.Group.tick` function,
-    // the value of this property will be used to advance the simulation.
-    this.fixedTimeStep = utils.ensureTypedArg( options.fixedTimeStep, types.NUMBER, 0.016 );
-
-    // Set properties used in the uniforms map, starting with the
-    // texture stuff.
-    this.texture = utils.ensureInstanceOf( options.texture.value, THREE.Texture, null );
-    this.textureFrames = utils.ensureInstanceOf( options.texture.frames, THREE.Vector2, new THREE.Vector2( 1, 1 ) );
-    this.textureFrameCount = utils.ensureTypedArg( options.texture.frameCount, types.NUMBER, this.textureFrames.x * this.textureFrames.y );
-    this.textureLoop = utils.ensureTypedArg( options.texture.loop, types.NUMBER, 1 );
-    this.textureFrames.max( new THREE.Vector2( 1, 1 ) );
-
-    this.hasPerspective = utils.ensureTypedArg( options.hasPerspective, types.BOOLEAN, true );
-    this.colorize = utils.ensureTypedArg( options.colorize, types.BOOLEAN, true );
-
-    this.maxParticleCount = utils.ensureTypedArg( options.maxParticleCount, types.NUMBER, null );
-
-
-    // Set properties used to define the ShaderMaterial's appearance.
-    this.blending = utils.ensureTypedArg( options.blending, types.NUMBER, THREE.AdditiveBlending );
-    this.transparent = utils.ensureTypedArg( options.transparent, types.BOOLEAN, true );
-    this.alphaTest = parseFloat( utils.ensureTypedArg( options.alphaTest, types.NUMBER, 0.0 ) );
-    this.depthWrite = utils.ensureTypedArg( options.depthWrite, types.BOOLEAN, false );
-    this.depthTest = utils.ensureTypedArg( options.depthTest, types.BOOLEAN, true );
-    this.fog = utils.ensureTypedArg( options.fog, types.BOOLEAN, true );
-    this.scale = utils.ensureTypedArg( options.scale, types.NUMBER, 300 );
-
-    // Where emitter's go to curl up in a warm blanket and live
-    // out their days.
-    this.emitters = [];
-    this.emitterIDs = [];
-
-    // Create properties for use by the emitter pooling functions.
-    this._pool = [];
-    this._poolCreationSettings = null;
-    this._createNewWhenPoolEmpty = 0;
-
-    // Whether all attributes should be forced to updated
-    // their entire buffer contents on the next tick.
-    //
-    // Used when an emitter is removed.
-    this._attributesNeedRefresh = false;
-    this._attributesNeedDynamicReset = false;
-
-    this.particleCount = 0;
-
-
-    // Map of uniforms to be applied to the ShaderMaterial instance.
-    this.uniforms = {
-        texture: {
-            type: 't',
-            value: this.texture
-        },
-        textureAnimation: {
-            type: 'v4',
-            value: new THREE.Vector4(
-                this.textureFrames.x,
-                this.textureFrames.y,
-                this.textureFrameCount,
-                Math.max( Math.abs( this.textureLoop ), 1.0 )
-            )
-        },
-        fogColor: {
-            type: 'c',
-            value: null
-        },
-        fogNear: {
-            type: 'f',
-            value: 10
-        },
-        fogFar: {
-            type: 'f',
-            value: 200
-        },
-        fogDensity: {
-            type: 'f',
-            value: 0.5
-        },
-        deltaTime: {
-            type: 'f',
-            value: 0
-        },
-        runTime: {
-            type: 'f',
-            value: 0
-        },
-        scale: {
-            type: 'f',
-            value: this.scale
-        }
-    };
-
-    // Add some defines into the mix...
-    this.defines = {
-        HAS_PERSPECTIVE: this.hasPerspective,
-        COLORIZE: this.colorize,
-        VALUE_OVER_LIFETIME_LENGTH: SPE.valueOverLifetimeLength,
-
-        SHOULD_ROTATE_TEXTURE: false,
-        SHOULD_ROTATE_PARTICLES: false,
-        SHOULD_WIGGLE_PARTICLES: false,
-
-        SHOULD_CALCULATE_SPRITE: this.textureFrames.x > 1 || this.textureFrames.y > 1
-    };
-
-    // Map of all attributes to be applied to the particles.
-    //
-    // See SPE.ShaderAttribute for a bit more info on this bit.
-    this.attributes = {
-        position: new SPE.ShaderAttribute( 'v3', true ),
-        acceleration: new SPE.ShaderAttribute( 'v4', true ), // w component is drag
-        velocity: new SPE.ShaderAttribute( 'v3', true ),
-        rotation: new SPE.ShaderAttribute( 'v4', true ),
-        rotationCenter: new SPE.ShaderAttribute( 'v3', true ),
-        params: new SPE.ShaderAttribute( 'v4', true ), // Holds (alive, age, delay, wiggle)
-        size: new SPE.ShaderAttribute( 'v4', true ),
-        angle: new SPE.ShaderAttribute( 'v4', true ),
-        color: new SPE.ShaderAttribute( 'v4', true ),
-        opacity: new SPE.ShaderAttribute( 'v4', true )
-    };
-
-    this.attributeKeys = Object.keys( this.attributes );
-    this.attributeCount = this.attributeKeys.length;
-
-    // Create the ShaderMaterial instance that'll help render the
-    // particles.
-    this.material = new THREE.ShaderMaterial( {
-        uniforms: this.uniforms,
-        vertexShader: SPE.shaders.vertex,
-        fragmentShader: SPE.shaders.fragment,
-        blending: this.blending,
-        transparent: this.transparent,
-        alphaTest: this.alphaTest,
-        depthWrite: this.depthWrite,
-        depthTest: this.depthTest,
-        defines: this.defines,
-        fog: this.fog
-    } );
-
-    // Create the BufferGeometry and Points instances, ensuring
-    // the geometry and material are given to the latter.
-    this.geometry = new THREE.BufferGeometry();
-    this.mesh = new THREE.Points( this.geometry, this.material );
-
-    if ( this.maxParticleCount === null ) {
-        console.warn( 'SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.' );
-    }
-};
-
-SPE.Group.constructor = SPE.Group;
-
-
-SPE.Group.prototype._updateDefines = function() {
-    'use strict';
-
-    var emitters = this.emitters,
-        i = emitters.length - 1,
-        emitter,
-        defines = this.defines;
-
-    for ( i; i >= 0; --i ) {
-        emitter = emitters[ i ];
-
-        // Only do angle calculation if there's no spritesheet defined.
-        //
-        // Saves calculations being done and then overwritten in the shaders.
-        if ( !defines.SHOULD_CALCULATE_SPRITE ) {
-            defines.SHOULD_ROTATE_TEXTURE = defines.SHOULD_ROTATE_TEXTURE || !!Math.max(
-                Math.max.apply( null, emitter.angle.value ),
-                Math.max.apply( null, emitter.angle.spread )
-            );
-        }
-
-        defines.SHOULD_ROTATE_PARTICLES = defines.SHOULD_ROTATE_PARTICLES || !!Math.max(
-            emitter.rotation.angle,
-            emitter.rotation.angleSpread
-        );
-
-        defines.SHOULD_WIGGLE_PARTICLES = defines.SHOULD_WIGGLE_PARTICLES || !!Math.max(
-            emitter.wiggle.value,
-            emitter.wiggle.spread
-        );
-    }
-
-    this.material.needsUpdate = true;
-};
-
-SPE.Group.prototype._applyAttributesToGeometry = function() {
-    'use strict';
-
-    var attributes = this.attributes,
-        geometry = this.geometry,
-        geometryAttributes = geometry.attributes,
-        attribute,
-        geometryAttribute;
-
-    // Loop through all the shader attributes and assign (or re-assign)
-    // typed array buffers to each one.
-    for ( var attr in attributes ) {
-        if ( attributes.hasOwnProperty( attr ) ) {
-            attribute = attributes[ attr ];
-            geometryAttribute = geometryAttributes[ attr ];
-
-            // Update the array if this attribute exists on the geometry.
-            //
-            // This needs to be done because the attribute's typed array might have
-            // been resized and reinstantiated, and might now be looking at a
-            // different ArrayBuffer, so reference needs updating.
-            if ( geometryAttribute ) {
-                geometryAttribute.array = attribute.typedArray.array;
-            }
-
-            // // Add the attribute to the geometry if it doesn't already exist.
-            else {
-                geometry.addAttribute( attr, attribute.bufferAttribute );
-            }
-
-            // Mark the attribute as needing an update the next time a frame is rendered.
-            attribute.bufferAttribute.needsUpdate = true;
-        }
-    }
-
-    // Mark the draw range on the geometry. This will ensure
-    // only the values in the attribute buffers that are
-    // associated with a particle will be used in THREE's
-    // render cycle.
-    this.geometry.setDrawRange( 0, this.particleCount );
-};
-
-/**
- * Adds an SPE.Emitter instance to this group, creating particle values and
- * assigning them to this group's shader attributes.
- *
- * @param {Emitter} emitter The emitter to add to this group.
- */
-SPE.Group.prototype.addEmitter = function( emitter ) {
-    'use strict';
-
-    // Ensure an actual emitter instance is passed here.
-    //
-    // Decided not to throw here, just in case a scene's
-    // rendering would be paused. Logging an error instead
-    // of stopping execution if exceptions aren't caught.
-    if ( emitter instanceof SPE.Emitter === false ) {
-        console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter );
-        return;
-    }
-
-    // If the emitter already exists as a member of this group, then
-    // stop here, we don't want to add it again.
-    else if ( this.emitterIDs.indexOf( emitter.uuid ) > -1 ) {
-        console.error( 'Emitter already exists in this group. Will not add again.' );
-        return;
-    }
-
-    // And finally, if the emitter is a member of another group,
-    // don't add it to this group.
-    else if ( emitter.group !== null ) {
-        console.error( 'Emitter already belongs to another group. Will not add to requested group.' );
-        return;
-    }
-
-    var attributes = this.attributes,
-        start = this.particleCount,
-        end = start + emitter.particleCount;
-
-    // Update this group's particle count.
-    this.particleCount = end;
-
-    // Emit a warning if the emitter being added will exceed the buffer sizes specified.
-    if ( this.maxParticleCount !== null && this.particleCount > this.maxParticleCount ) {
-        console.warn( 'SPE.Group: maxParticleCount exceeded. Requesting', this.particleCount, 'particles, can support only', this.maxParticleCount );
-    }
-
-
-    // Set the `particlesPerSecond` value (PPS) on the emitter.
-    // It's used to determine how many particles to release
-    // on a per-frame basis.
-    emitter._calculatePPSValue( emitter.maxAge._value + emitter.maxAge._spread );
-    emitter._setBufferUpdateRanges( this.attributeKeys );
-
-    // Store the offset value in the TypedArray attributes for this emitter.
-    emitter._setAttributeOffset( start );
-
-    // Save a reference to this group on the emitter so it knows
-    // where it belongs.
-    emitter.group = this;
-
-    // Store reference to the attributes on the emitter for
-    // easier access during the emitter's tick function.
-    emitter.attributes = this.attributes;
-
-
-
-    // Ensure the attributes and their BufferAttributes exist, and their
-    // TypedArrays are of the correct size.
-    for ( var attr in attributes ) {
-        if ( attributes.hasOwnProperty( attr ) ) {
-            // When creating a buffer, pass through the maxParticle count
-            // if one is specified.
-            attributes[ attr ]._createBufferAttribute(
-                this.maxParticleCount !== null ?
-                this.maxParticleCount :
-                this.particleCount
-            );
-        }
-    }
-
-    // Loop through each particle this emitter wants to have, and create the attributes values,
-    // storing them in the TypedArrays that each attribute holds.
-    for ( var i = start; i < end; ++i ) {
-        emitter._assignPositionValue( i );
-        emitter._assignForceValue( i, 'velocity' );
-        emitter._assignForceValue( i, 'acceleration' );
-        emitter._assignAbsLifetimeValue( i, 'opacity' );
-        emitter._assignAbsLifetimeValue( i, 'size' );
-        emitter._assignAngleValue( i );
-        emitter._assignRotationValue( i );
-        emitter._assignParamsValue( i );
-        emitter._assignColorValue( i );
-    }
-
-    // Update the geometry and make sure the attributes are referencing
-    // the typed arrays properly.
-    this._applyAttributesToGeometry();
-
-    // Store this emitter in this group's emitter's store.
-    this.emitters.push( emitter );
-    this.emitterIDs.push( emitter.uuid );
-
-    // Update certain flags to enable shader calculations only if they're necessary.
-    this._updateDefines( emitter );
-
-    // Update the material since defines might have changed
-    this.material.needsUpdate = true;
-    this.geometry.needsUpdate = true;
-    this._attributesNeedRefresh = true;
-
-    // Return the group to enable chaining.
-    return this;
-};
-
-/**
- * Removes an SPE.Emitter instance from this group. When called,
- * all particle's belonging to the given emitter will be instantly
- * removed from the scene.
- *
- * @param {Emitter} emitter The emitter to add to this group.
- */
-SPE.Group.prototype.removeEmitter = function( emitter ) {
-    'use strict';
-
-    var emitterIndex = this.emitterIDs.indexOf( emitter.uuid );
-
-    // Ensure an actual emitter instance is passed here.
-    //
-    // Decided not to throw here, just in case a scene's
-    // rendering would be paused. Logging an error instead
-    // of stopping execution if exceptions aren't caught.
-    if ( emitter instanceof SPE.Emitter === false ) {
-        console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter );
-        return;
-    }
-
-    // Issue an error if the emitter isn't a member of this group.
-    else if ( emitterIndex === -1 ) {
-        console.error( 'Emitter does not exist in this group. Will not remove.' );
-        return;
-    }
-
-    // Kill all particles by marking them as dead
-    // and their age as 0.
-    var start = emitter.attributeOffset,
-        end = start + emitter.particleCount,
-        params = this.attributes.params.typedArray;
-
-    // Set alive and age to zero.
-    for ( var i = start; i < end; ++i ) {
-        params.array[ i * 4 ] = 0.0;
-        params.array[ i * 4 + 1 ] = 0.0;
-    }
-
-    // Remove the emitter from this group's "store".
-    this.emitters.splice( emitterIndex, 1 );
-    this.emitterIDs.splice( emitterIndex, 1 );
-
-    // Remove this emitter's attribute values from all shader attributes.
-    // The `.splice()` call here also marks each attribute's buffer
-    // as needing to update it's entire contents.
-    for ( var attr in this.attributes ) {
-        if ( this.attributes.hasOwnProperty( attr ) ) {
-            this.attributes[ attr ].splice( start, end );
-        }
-    }
-
-    // Ensure this group's particle count is correct.
-    this.particleCount -= emitter.particleCount;
-
-    // Call the emitter's remove method.
-    emitter._onRemove();
-
-    // Set a flag to indicate that the attribute buffers should
-    // be updated in their entirety on the next frame.
-    this._attributesNeedRefresh = true;
-};
-
-
-/**
- * Fetch a single emitter instance from the pool.
- * If there are no objects in the pool, a new emitter will be
- * created if specified.
- *
- * @return {Emitter|null}
- */
-SPE.Group.prototype.getFromPool = function() {
-    'use strict';
-
-    var pool = this._pool,
-        createNew = this._createNewWhenPoolEmpty;
-
-    if ( pool.length ) {
-        return pool.pop();
-    }
-    else if ( createNew ) {
-        return new SPE.Emitter( this._poolCreationSettings );
-    }
-
-    return null;
-};
-
-
-/**
- * Release an emitter into the pool.
- *
- * @param  {ShaderParticleEmitter} emitter
- * @return {Group} This group instance.
- */
-SPE.Group.prototype.releaseIntoPool = function( emitter ) {
-    'use strict';
-
-    if ( emitter instanceof SPE.Emitter === false ) {
-        console.error( 'Argument is not instanceof SPE.Emitter:', emitter );
-        return;
-    }
-
-    emitter.reset();
-    this._pool.unshift( emitter );
-
-    return this;
-};
-
-
-/**
- * Get the pool array
- *
- * @return {Array}
- */
-SPE.Group.prototype.getPool = function() {
-    'use strict';
-    return this._pool;
-};
-
-
-/**
- * Add a pool of emitters to this particle group
- *
- * @param {Number} numEmitters      The number of emitters to add to the pool.
- * @param {EmitterOptions|Array} emitterOptions  An object, or array of objects, describing the options to pass to each emitter.
- * @param {Boolean} createNew       Should a new emitter be created if the pool runs out?
- * @return {Group} This group instance.
- */
-SPE.Group.prototype.addPool = function( numEmitters, emitterOptions, createNew ) {
-    'use strict';
-
-    var emitter;
-
-    // Save relevant settings and flags.
-    this._poolCreationSettings = emitterOptions;
-    this._createNewWhenPoolEmpty = !!createNew;
-
-    // Create the emitters, add them to this group and the pool.
-    for ( var i = 0; i < numEmitters; ++i ) {
-        if ( Array.isArray( emitterOptions ) ) {
-            emitter = new SPE.Emitter( emitterOptions[ i ] );
-        }
-        else {
-            emitter = new SPE.Emitter( emitterOptions );
-        }
-        this.addEmitter( emitter );
-        this.releaseIntoPool( emitter );
-    }
-
-    return this;
-};
-
-
-
-SPE.Group.prototype._triggerSingleEmitter = function( pos ) {
-    'use strict';
-
-    var emitter = this.getFromPool(),
-        self = this;
-
-    if ( emitter === null ) {
-        console.log( 'SPE.Group pool ran out.' );
-        return;
-    }
-
-    // TODO:
-    // - Make sure buffers are update with thus new position.
-    if ( pos instanceof THREE.Vector3 ) {
-        emitter.position.value.copy( pos );
-
-        // Trigger the setter for this property to force an
-        // update to the emitter's position attribute.
-        emitter.position.value = emitter.position.value;
-    }
-
-    emitter.enable();
-
-    setTimeout( function() {
-        emitter.disable();
-        self.releaseIntoPool( emitter );
-    }, ( emitter.maxAge.value + emitter.maxAge.spread ) * 1000 );
-
-    return this;
-};
-
-
-/**
- * Set a given number of emitters as alive, with an optional position
- * vector3 to move them to.
- *
- * @param  {Number} numEmitters The number of emitters to activate
- * @param  {Object} [position=undefined] A THREE.Vector3 instance describing the position to activate the emitter(s) at.
- * @return {Group} This group instance.
- */
-SPE.Group.prototype.triggerPoolEmitter = function( numEmitters, position ) {
-    'use strict';
-
-    if ( typeof numEmitters === 'number' && numEmitters > 1 ) {
-        for ( var i = 0; i < numEmitters; ++i ) {
-            this._triggerSingleEmitter( position );
-        }
-    }
-    else {
-        this._triggerSingleEmitter( position );
-    }
-
-    return this;
-};
-
-
-
-SPE.Group.prototype._updateUniforms = function( dt ) {
-    'use strict';
-
-    this.uniforms.runTime.value += dt;
-    this.uniforms.deltaTime.value = dt;
-};
-
-SPE.Group.prototype._resetBufferRanges = function() {
-    'use strict';
-
-    var keys = this.attributeKeys,
-        i = this.attributeCount - 1,
-        attrs = this.attributes;
-
-    for ( i; i >= 0; --i ) {
-        attrs[ keys[ i ] ].resetUpdateRange();
-    }
-};
-
-
-SPE.Group.prototype._updateBuffers = function( emitter ) {
-    'use strict';
-
-    var keys = this.attributeKeys,
-        i = this.attributeCount - 1,
-        attrs = this.attributes,
-        emitterRanges = emitter.bufferUpdateRanges,
-        key,
-        emitterAttr,
-        attr;
-
-    for ( i; i >= 0; --i ) {
-        key = keys[ i ];
-        emitterAttr = emitterRanges[ key ];
-        attr = attrs[ key ];
-        attr.setUpdateRange( emitterAttr.min, emitterAttr.max );
-        attr.flagUpdate();
-    }
-};
-
-
-/**
- * Simulate all the emitter's belonging to this group, updating
- * attribute values along the way.
- * @param  {Number} [dt=Group's `fixedTimeStep` value] The number of seconds to simulate the group's emitters for (deltaTime)
- */
-SPE.Group.prototype.tick = function( dt ) {
-    'use strict';
-
-    var emitters = this.emitters,
-        numEmitters = emitters.length,
-        deltaTime = dt || this.fixedTimeStep,
-        keys = this.attributeKeys,
-        i,
-        attrs = this.attributes;
-
-    // Update uniform values.
-    this._updateUniforms( deltaTime );
-
-    // Reset buffer update ranges on the shader attributes.
-    this._resetBufferRanges();
-
-
-    // If nothing needs updating, then stop here.
-    if (
-        numEmitters === 0 &&
-        this._attributesNeedRefresh === false &&
-        this._attributesNeedDynamicReset === false
-    ) {
-        return;
-    }
-
-    // Loop through each emitter in this group and
-    // simulate it, then update the shader attribute
-    // buffers.
-    for ( var i = 0, emitter; i < numEmitters; ++i ) {
-        emitter = emitters[ i ];
-        emitter.tick( deltaTime );
-        this._updateBuffers( emitter );
-    }
-
-    // If the shader attributes have been refreshed,
-    // then the dynamic properties of each buffer
-    // attribute will need to be reset back to
-    // what they should be.
-    if ( this._attributesNeedDynamicReset === true ) {
-        i = this.attributeCount - 1;
-
-        for ( i; i >= 0; --i ) {
-            attrs[ keys[ i ] ].resetDynamic();
-        }
-
-        this._attributesNeedDynamicReset = false;
-    }
-
-    // If this group's shader attributes need a full refresh
-    // then mark each attribute's buffer attribute as
-    // needing so.
-    if ( this._attributesNeedRefresh === true ) {
-        i = this.attributeCount - 1;
-
-        for ( i; i >= 0; --i ) {
-            attrs[ keys[ i ] ].forceUpdateAll();
-        }
-
-        this._attributesNeedRefresh = false;
-        this._attributesNeedDynamicReset = true;
-    }
-};
-
-
-/**
- * Dipose the geometry and material for the group.
- *
- * @return {Group} Group instance.
- */
-SPE.Group.prototype.dispose = function() {
-    'use strict';
-    this.geometry.dispose();
-    this.material.dispose();
-    return this;
-};
-
-
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - diff --git a/docs/api/core_SPE.utils.js.html b/docs/api/core_SPE.utils.js.html deleted file mode 100644 index 42f94e9..0000000 --- a/docs/api/core_SPE.utils.js.html +++ /dev/null @@ -1,755 +0,0 @@ - - - - - JSDoc: Source: core/SPE.utils.js - - - - - - - - - - -
- -

Source: core/SPE.utils.js

- - - - - - -
-
- 
/**
- * A bunch of utility functions used throughout the library.
- * @namespace
- * @type {Object}
- */
-SPE.utils = {
-    /**
-     * A map of types used by `SPE.utils.ensureTypedArg` and
-     * `SPE.utils.ensureArrayTypedArg` to compare types against.
-     *
-     * @enum {String}
-     */
-    types: {
-        /**
-         * Boolean type.
-         * @type {String}
-         */
-        BOOLEAN: 'boolean',
-
-        /**
-         * String type.
-         * @type {String}
-         */
-        STRING: 'string',
-
-        /**
-         * Number type.
-         * @type {String}
-         */
-        NUMBER: 'number',
-
-        /**
-         * Object type.
-         * @type {String}
-         */
-        OBJECT: 'object'
-    },
-
-    /**
-     * Given a value, a type, and a default value to fallback to,
-     * ensure the given argument adheres to the type requesting,
-     * returning the default value if type check is false.
-     *
-     * @param  {(boolean|string|number|object)} arg          The value to perform a type-check on.
-     * @param  {String} type         The type the `arg` argument should adhere to.
-     * @param  {(boolean|string|number|object)} defaultValue A default value to fallback on if the type check fails.
-     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureTypedArg: function( arg, type, defaultValue ) {
-        'use strict';
-
-        if ( typeof arg === type ) {
-            return arg;
-        }
-        else {
-            return defaultValue;
-        }
-    },
-
-    /**
-     * Given an array of values, a type, and a default value,
-     * ensure the given array's contents ALL adhere to the provided type,
-     * returning the default value if type check fails.
-     *
-     * If the given value to check isn't an Array, delegates to SPE.utils.ensureTypedArg.
-     *
-     * @param  {Array|boolean|string|number|object} arg          The array of values to check type of.
-     * @param  {String} type         The type that should be adhered to.
-     * @param  {(boolean|string|number|object)} defaultValue A default fallback value.
-     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureArrayTypedArg: function( arg, type, defaultValue ) {
-        'use strict';
-
-        // If the argument being checked is an array, loop through
-        // it and ensure all the values are of the correct type,
-        // falling back to the defaultValue if any aren't.
-        if ( Array.isArray( arg ) ) {
-            for ( var i = arg.length - 1; i >= 0; --i ) {
-                if ( typeof arg[ i ] !== type ) {
-                    return defaultValue;
-                }
-            }
-
-            return arg;
-        }
-
-        // If the arg isn't an array then just fallback to
-        // checking the type.
-        return this.ensureTypedArg( arg, type, defaultValue );
-    },
-
-    /**
-     * Ensures the given value is an instance of a constructor function.
-     *
-     * @param  {Object} arg          The value to check instance of.
-     * @param  {Function} instance     The constructor of the instance to check against.
-     * @param  {Object} defaultValue A default fallback value if instance check fails
-     * @return {Object}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureInstanceOf: function( arg, instance, defaultValue ) {
-        'use strict';
-
-        if ( instance !== undefined && arg instanceof instance ) {
-            return arg;
-        }
-        else {
-            return defaultValue;
-        }
-    },
-
-    /**
-     * Given an array of values, ensure the instances of all items in the array
-     * matches the given instance constructor falling back to a default value if
-     * the check fails.
-     *
-     * If given value isn't an Array, delegates to `SPE.utils.ensureInstanceOf`.
-     *
-     * @param  {Array|Object} arg          The value to perform the instanceof check on.
-     * @param  {Function} instance     The constructor of the instance to check against.
-     * @param  {Object} defaultValue A default fallback value if instance check fails
-     * @return {Object}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureArrayInstanceOf: function( arg, instance, defaultValue ) {
-        'use strict';
-
-        // If the argument being checked is an array, loop through
-        // it and ensure all the values are of the correct type,
-        // falling back to the defaultValue if any aren't.
-        if ( Array.isArray( arg ) ) {
-            for ( var i = arg.length - 1; i >= 0; --i ) {
-                if ( instance !== undefined && arg[ i ] instanceof instance === false ) {
-                    return defaultValue;
-                }
-            }
-
-            return arg;
-        }
-
-        // If the arg isn't an array then just fallback to
-        // checking the type.
-        return this.ensureInstanceOf( arg, instance, defaultValue );
-    },
-
-    /**
-     * Ensures that any "value-over-lifetime" properties of an emitter are
-     * of the correct length (as dictated by `SPE.valueOverLifetimeLength`).
-     *
-     * Delegates to `SPE.utils.interpolateArray` for array resizing.
-     *
-     * If properties aren't arrays, then property values are put into one.
-     *
-     * @param  {Object} property  The property of an SPE.Emitter instance to check compliance of.
-     * @param  {Number} minLength The minimum length of the array to create.
-     * @param  {Number} maxLength The maximum length of the array to create.
-     */
-    ensureValueOverLifetimeCompliance: function( property, minLength, maxLength ) {
-        'use strict';
-
-        minLength = minLength || 3;
-        maxLength = maxLength || 3;
-
-        // First, ensure both properties are arrays.
-        if ( Array.isArray( property._value ) === false ) {
-            property._value = [ property._value ];
-        }
-
-        if ( Array.isArray( property._spread ) === false ) {
-            property._spread = [ property._spread ];
-        }
-
-        var valueLength = this.clamp( property._value.length, minLength, maxLength ),
-            spreadLength = this.clamp( property._spread.length, minLength, maxLength ),
-            desiredLength = Math.max( valueLength, spreadLength );
-
-        if ( property._value.length !== desiredLength ) {
-            property._value = this.interpolateArray( property._value, desiredLength );
-        }
-
-        if ( property._spread.length !== desiredLength ) {
-            property._spread = this.interpolateArray( property._spread, desiredLength );
-        }
-    },
-
-    /**
-     * Performs linear interpolation (lerp) on an array.
-     *
-     * For example, lerping [1, 10], with a `newLength` of 10 will produce [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
-     *
-     * Delegates to `SPE.utils.lerpTypeAgnostic` to perform the actual
-     * interpolation.
-     *
-     * @param  {Array} srcArray  The array to lerp.
-     * @param  {Number} newLength The length the array should be interpolated to.
-     * @return {Array}           The interpolated array.
-     */
-    interpolateArray: function( srcArray, newLength ) {
-        'use strict';
-
-        var sourceLength = srcArray.length,
-            newArray = [ typeof srcArray[ 0 ].clone === 'function' ? srcArray[ 0 ].clone() : srcArray[ 0 ] ],
-            factor = ( sourceLength - 1 ) / ( newLength - 1 );
-
-
-        for ( var i = 1; i < newLength - 1; ++i ) {
-            var f = i * factor,
-                before = Math.floor( f ),
-                after = Math.ceil( f ),
-                delta = f - before;
-
-            newArray[ i ] = this.lerpTypeAgnostic( srcArray[ before ], srcArray[ after ], delta );
-        }
-
-        newArray.push(
-            typeof srcArray[ sourceLength - 1 ].clone === 'function' ?
-            srcArray[ sourceLength - 1 ].clone() :
-            srcArray[ sourceLength - 1 ]
-        );
-
-        return newArray;
-    },
-
-    /**
-     * Clamp a number to between the given min and max values.
-     * @param  {Number} value The number to clamp.
-     * @param  {Number} min   The minimum value.
-     * @param  {Number} max   The maximum value.
-     * @return {Number}       The clamped number.
-     */
-    clamp: function( value, min, max ) {
-        'use strict';
-
-        return Math.max( min, Math.min( value, max ) );
-    },
-
-    /**
-     * If the given value is less than the epsilon value, then return
-     * a randomised epsilon value if specified, or just the epsilon value if not.
-     * Works for negative numbers as well as positive.
-     *
-     * @param  {Number} value     The value to perform the operation on.
-     * @param  {Boolean} randomise Whether the value should be randomised.
-     * @return {Number}           The result of the operation.
-     */
-    zeroToEpsilon: function( value, randomise ) {
-        'use strict';
-
-        var epsilon = 0.00001,
-            result = value;
-
-        result = randomise ? Math.random() * epsilon * 10 : epsilon;
-
-        if ( value < 0 && value > -epsilon ) {
-            result = -result;
-        }
-
-        // if ( value === 0 ) {
-        //     result = randomise ? Math.random() * epsilon * 10 : epsilon;
-        // }
-        // else if ( value > 0 && value < epsilon ) {
-        //     result = randomise ? Math.random() * epsilon * 10 : epsilon;
-        // }
-        // else if ( value < 0 && value > -epsilon ) {
-        //     result = -( randomise ? Math.random() * epsilon * 10 : epsilon );
-        // }
-
-        return result;
-    },
-
-    /**
-     * Linearly interpolates two values of various types. The given values
-     * must be of the same type for the interpolation to work.
-     * @param  {(number|Object)} start The start value of the lerp.
-     * @param  {(number|object)} end   The end value of the lerp.
-     * @param  {Number} delta The delta posiiton of the lerp operation. Ideally between 0 and 1 (inclusive).
-     * @return {(number|object|undefined)}       The result of the operation. Result will be undefined if
-     *                                               the start and end arguments aren't a supported type, or
-     *                                               if their types do not match.
-     */
-    lerpTypeAgnostic: function( start, end, delta ) {
-        'use strict';
-
-        var types = this.types,
-            out;
-
-        if ( typeof start === types.NUMBER && typeof end === types.NUMBER ) {
-            return start + ( ( end - start ) * delta );
-        }
-        else if ( start instanceof THREE.Vector2 && end instanceof THREE.Vector2 ) {
-            out = start.clone();
-            out.x = this.lerp( start.x, end.x, delta );
-            out.y = this.lerp( start.y, end.y, delta );
-            return out;
-        }
-        else if ( start instanceof THREE.Vector3 && end instanceof THREE.Vector3 ) {
-            out = start.clone();
-            out.x = this.lerp( start.x, end.x, delta );
-            out.y = this.lerp( start.y, end.y, delta );
-            out.z = this.lerp( start.z, end.z, delta );
-            return out;
-        }
-        else if ( start instanceof THREE.Vector4 && end instanceof THREE.Vector4 ) {
-            out = start.clone();
-            out.x = this.lerp( start.x, end.x, delta );
-            out.y = this.lerp( start.y, end.y, delta );
-            out.z = this.lerp( start.z, end.z, delta );
-            out.w = this.lerp( start.w, end.w, delta );
-            return out;
-        }
-        else if ( start instanceof THREE.Color && end instanceof THREE.Color ) {
-            out = start.clone();
-            out.r = this.lerp( start.r, end.r, delta );
-            out.g = this.lerp( start.g, end.g, delta );
-            out.b = this.lerp( start.b, end.b, delta );
-            return out;
-        }
-        else {
-            console.warn( 'Invalid argument types, or argument types do not match:', start, end );
-        }
-    },
-
-    /**
-     * Perform a linear interpolation operation on two numbers.
-     * @param  {Number} start The start value.
-     * @param  {Number} end   The end value.
-     * @param  {Number} delta The position to interpolate to.
-     * @return {Number}       The result of the lerp operation.
-     */
-    lerp: function( start, end, delta ) {
-        'use strict';
-        return start + ( ( end - start ) * delta );
-    },
-
-    /**
-     * Rounds a number to a nearest multiple.
-     *
-     * @param  {Number} n        The number to round.
-     * @param  {Number} multiple The multiple to round to.
-     * @return {Number}          The result of the round operation.
-     */
-    roundToNearestMultiple: function( n, multiple ) {
-        'use strict';
-
-        var remainder = 0;
-
-        if ( multiple === 0 ) {
-            return n;
-        }
-
-        remainder = Math.abs( n ) % multiple;
-
-        if ( remainder === 0 ) {
-            return n;
-        }
-
-        if ( n < 0 ) {
-            return -( Math.abs( n ) - remainder );
-        }
-
-        return n + multiple - remainder;
-    },
-
-    /**
-     * Check if all items in an array are equal. Uses strict equality.
-     *
-     * @param  {Array} array The array of values to check equality of.
-     * @return {Boolean}       Whether the array's values are all equal or not.
-     */
-    arrayValuesAreEqual: function( array ) {
-        'use strict';
-
-        for ( var i = 0; i < array.length - 1; ++i ) {
-            if ( array[ i ] !== array[ i + 1 ] ) {
-                return false;
-            }
-        }
-
-        return true;
-    },
-
-    // colorsAreEqual: function() {
-    //     var colors = Array.prototype.slice.call( arguments ),
-    //         numColors = colors.length;
-
-    //     for ( var i = 0, color1, color2; i < numColors - 1; ++i ) {
-    //         color1 = colors[ i ];
-    //         color2 = colors[ i + 1 ];
-
-    //         if (
-    //             color1.r !== color2.r ||
-    //             color1.g !== color2.g ||
-    //             color1.b !== color2.b
-    //         ) {
-    //             return false
-    //         }
-    //     }
-
-    //     return true;
-    // },
-
-
-    /**
-     * Given a start value and a spread value, create and return a random
-     * number.
-     * @param  {Number} base   The start value.
-     * @param  {Number} spread The size of the random variance to apply.
-     * @return {Number}        A randomised number.
-     */
-    randomFloat: function( base, spread ) {
-        'use strict';
-        return base + spread * ( Math.random() - 0.5 );
-    },
-
-
-
-    /**
-     * Given an SPE.ShaderAttribute instance, and various other settings,
-     * assign values to the attribute's array in a `vec3` format.
-     *
-     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base        THREE.Vector3 instance describing the start value.
-     * @param  {Object} spread      THREE.Vector3 instance describing the random variance to apply to the start value.
-     * @param  {Object} spreadClamp THREE.Vector3 instance describing the multiples to clamp the randomness to.
-     */
-    randomVector3: function( attribute, index, base, spread, spreadClamp ) {
-        'use strict';
-
-        var x = base.x + ( Math.random() * spread.x - ( spread.x * 0.5 ) ),
-            y = base.y + ( Math.random() * spread.y - ( spread.y * 0.5 ) ),
-            z = base.z + ( Math.random() * spread.z - ( spread.z * 0.5 ) );
-
-        // var x = this.randomFloat( base.x, spread.x ),
-        // y = this.randomFloat( base.y, spread.y ),
-        // z = this.randomFloat( base.z, spread.z );
-
-        if ( spreadClamp ) {
-            x = -spreadClamp.x * 0.5 + this.roundToNearestMultiple( x, spreadClamp.x );
-            y = -spreadClamp.y * 0.5 + this.roundToNearestMultiple( y, spreadClamp.y );
-            z = -spreadClamp.z * 0.5 + this.roundToNearestMultiple( z, spreadClamp.z );
-        }
-
-        attribute.typedArray.setVec3Components( index, x, y, z );
-    },
-
-    /**
-     * Given an SPE.Shader attribute instance, and various other settings,
-     * assign Color values to the attribute.
-     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base      THREE.Color instance describing the start color.
-     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
-     */
-    randomColor: function( attribute, index, base, spread ) {
-        'use strict';
-
-        var r = base.r + ( Math.random() * spread.x ),
-            g = base.g + ( Math.random() * spread.y ),
-            b = base.b + ( Math.random() * spread.z );
-
-        r = this.clamp( r, 0, 1 );
-        g = this.clamp( g, 0, 1 );
-        b = this.clamp( b, 0, 1 );
-
-
-        attribute.typedArray.setVec3Components( index, r, g, b );
-    },
-
-
-    randomColorAsHex: ( function() {
-        'use strict';
-
-        var workingColor = new THREE.Color();
-
-        /**
-         * Assigns a random color value, encoded as a hex value in decimal
-         * format, to a SPE.ShaderAttribute instance.
-         * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-         * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-         * @param  {Object} base      THREE.Color instance describing the start color.
-         * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
-         */
-        return function( attribute, index, base, spread ) {
-            var numItems = base.length,
-                colors = [];
-
-            for ( var i = 0; i < numItems; ++i ) {
-                var spreadVector = spread[ i ];
-
-                workingColor.copy( base[ i ] );
-
-                workingColor.r += ( Math.random() * spreadVector.x ) - ( spreadVector.x * 0.5 );
-                workingColor.g += ( Math.random() * spreadVector.y ) - ( spreadVector.y * 0.5 );
-                workingColor.b += ( Math.random() * spreadVector.z ) - ( spreadVector.z * 0.5 );
-
-                workingColor.r = this.clamp( workingColor.r, 0, 1 );
-                workingColor.g = this.clamp( workingColor.g, 0, 1 );
-                workingColor.b = this.clamp( workingColor.b, 0, 1 );
-
-                colors.push( workingColor.getHex() );
-            }
-
-            attribute.typedArray.setVec4Components( index, colors[ 0 ], colors[ 1 ], colors[ 2 ], colors[ 3 ] );
-        };
-    }() ),
-
-    /**
-     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
-     * given values onto a sphere.
-     *
-     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
-     * @param  {Number} radius            The radius of the sphere to project onto.
-     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
-     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the sphere.
-     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
-     */
-    randomVector3OnSphere: function(
-        attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp, distributionClamp
-    ) {
-        'use strict';
-
-        var depth = 2 * Math.random() - 1,
-            t = 6.2832 * Math.random(),
-            r = Math.sqrt( 1 - depth * depth ),
-            rand = this.randomFloat( radius, radiusSpread ),
-            x = 0,
-            y = 0,
-            z = 0;
-
-
-        if ( radiusSpreadClamp ) {
-            rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
-        }
-
-
-
-        // Set position on sphere
-        x = r * Math.cos( t ) * rand;
-        y = r * Math.sin( t ) * rand;
-        z = depth * rand;
-
-        // Apply radius scale to this position
-        x *= radiusScale.x;
-        y *= radiusScale.y;
-        z *= radiusScale.z;
-
-        // Translate to the base position.
-        x += base.x;
-        y += base.y;
-        z += base.z;
-
-        // Set the values in the typed array.
-        attribute.typedArray.setVec3Components( index, x, y, z );
-    },
-
-    seededRandom: function( seed ) {
-        var x = Math.sin( seed ) * 10000;
-        return x - ( x | 0 );
-    },
-
-
-
-    /**
-     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
-     * given values onto a 2d-disc.
-     *
-     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
-     * @param  {Number} radius            The radius of the sphere to project onto.
-     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
-     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the disc. The z-component is ignored.
-     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
-     */
-    randomVector3OnDisc: function( attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp ) {
-        'use strict';
-
-        var t = 6.2832 * Math.random(),
-            rand = Math.abs( this.randomFloat( radius, radiusSpread ) ),
-            x = 0,
-            y = 0,
-            z = 0;
-
-        if ( radiusSpreadClamp ) {
-            rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
-        }
-
-        // Set position on sphere
-        x = Math.cos( t ) * rand;
-        y = Math.sin( t ) * rand;
-
-        // Apply radius scale to this position
-        x *= radiusScale.x;
-        y *= radiusScale.y;
-
-        // Translate to the base position.
-        x += base.x;
-        y += base.y;
-        z += base.z;
-
-        // Set the values in the typed array.
-        attribute.typedArray.setVec3Components( index, x, y, z );
-    },
-
-    randomDirectionVector3OnSphere: ( function() {
-        'use strict';
-
-        var v = new THREE.Vector3();
-
-        /**
-         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
-         * position, using `speed` as the magnitude. Values are saved to the attribute.
-         *
-         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
-         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
-         * @param  {Number} posX            The particle's x coordinate.
-         * @param  {Number} posY            The particle's y coordinate.
-         * @param  {Number} posZ            The particle's z coordinate.
-         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
-         * @param  {Number} speed           The magnitude to apply to the vector.
-         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
-         */
-        return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
-            v.copy( emitterPosition );
-
-            v.x -= posX;
-            v.y -= posY;
-            v.z -= posZ;
-
-            v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
-
-            attribute.typedArray.setVec3Components( index, v.x, v.y, v.z );
-        };
-    }() ),
-
-
-    randomDirectionVector3OnDisc: ( function() {
-        'use strict';
-
-        var v = new THREE.Vector3();
-
-        /**
-         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
-         * position, using `speed` as the magnitude. Values are saved to the attribute.
-         *
-         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
-         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
-         * @param  {Number} posX            The particle's x coordinate.
-         * @param  {Number} posY            The particle's y coordinate.
-         * @param  {Number} posZ            The particle's z coordinate.
-         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
-         * @param  {Number} speed           The magnitude to apply to the vector.
-         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
-         */
-        return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
-            v.copy( emitterPosition );
-
-            v.x -= posX;
-            v.y -= posY;
-            v.z -= posZ;
-
-            v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
-
-            attribute.typedArray.setVec3Components( index, v.x, v.y, 0 );
-        };
-    }() ),
-
-    getPackedRotationAxis: ( function() {
-        'use strict';
-
-        var v = new THREE.Vector3(),
-            vSpread = new THREE.Vector3(),
-            c = new THREE.Color(),
-            addOne = new THREE.Vector3( 1, 1, 1 );
-
-        /**
-         * Given a rotation axis, and a rotation axis spread vector,
-         * calculate a randomised rotation axis, and pack it into
-         * a hexadecimal value represented in decimal form.
-         * @param  {Object} axis       THREE.Vector3 instance describing the rotation axis.
-         * @param  {Object} axisSpread THREE.Vector3 instance describing the amount of randomness to apply to the rotation axis.
-         * @return {Number}            The packed rotation axis, with randomness.
-         */
-        return function( axis, axisSpread ) {
-            v.copy( axis ).normalize();
-            vSpread.copy( axisSpread ).normalize();
-
-            v.x += ( -axisSpread.x * 0.5 ) + ( Math.random() * axisSpread.x );
-            v.y += ( -axisSpread.y * 0.5 ) + ( Math.random() * axisSpread.y );
-            v.z += ( -axisSpread.z * 0.5 ) + ( Math.random() * axisSpread.z );
-
-            // v.x = Math.abs( v.x );
-            // v.y = Math.abs( v.y );
-            // v.z = Math.abs( v.z );
-
-            v.normalize().add( addOne ).multiplyScalar( 0.5 );
-
-            c.setRGB( v.x, v.y, v.z );
-
-            return c.getHex();
-        };
-    }() )
-};
-
-
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - diff --git a/docs/api/core_utils.js.html b/docs/api/core_utils.js.html new file mode 100644 index 0000000..f072e86 --- /dev/null +++ b/docs/api/core_utils.js.html @@ -0,0 +1,755 @@ + + + + + JSDoc: Source: core/utils.js + + + + + + + + + + +
+ +

Source: core/utils.js

+ + + + + + +
+
+ 
import * as THREE from 'three';
+import valueTypes from '@/constants/valueTypes';
+
+/**
+ * A bunch of utility functions used throughout the library.
+ * @namespace
+ * @type {Object}
+ */
+export default {
+
+	/**
+     * Given a value, a type, and a default value to fallback to,
+     * ensure the given argument adheres to the type requesting,
+     * returning the default value if type check is false.
+     *
+     * @param  {(boolean|string|number|object)} arg          The value to perform a type-check on.
+     * @param  {String} type         The type the `arg` argument should adhere to.
+     * @param  {(boolean|string|number|object)} defaultValue A default value to fallback on if the type check fails.
+     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureTypedArg( arg, type, defaultValue ) {
+		'use strict';
+
+		if ( typeof arg === type ) {
+			return arg;
+		}
+		else {
+			return defaultValue;
+		}
+	},
+
+	/**
+     * Given an array of values, a type, and a default value,
+     * ensure the given array's contents ALL adhere to the provided type,
+     * returning the default value if type check fails.
+     *
+     * If the given value to check isn't an Array, delegates to SPE.utils.ensureTypedArg.
+     *
+     * @param  {Array|boolean|string|number|object} arg          The array of values to check type of.
+     * @param  {String} type         The type that should be adhered to.
+     * @param  {(boolean|string|number|object)} defaultValue A default fallback value.
+     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureArrayTypedArg( arg, type, defaultValue ) {
+		'use strict';
+
+		// If the argument being checked is an array, loop through
+		// it and ensure all the values are of the correct type,
+		// falling back to the defaultValue if any aren't.
+		if ( Array.isArray( arg ) ) {
+			for ( var i = arg.length - 1; i >= 0; --i ) {
+				if ( typeof arg[ i ] !== type ) {
+					return defaultValue;
+				}
+			}
+
+			return arg;
+		}
+
+		// If the arg isn't an array then just fallback to
+		// checking the type.
+		return this.ensureTypedArg( arg, type, defaultValue );
+	},
+
+	/**
+     * Ensures the given value is an instance of a constructor function.
+     *
+     * @param  {Object} arg          The value to check instance of.
+     * @param  {Function} instance     The constructor of the instance to check against.
+     * @param  {Object} defaultValue A default fallback value if instance check fails
+     * @return {Object}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureInstanceOf( arg, instance, defaultValue ) {
+		'use strict';
+
+		if ( instance !== undefined && arg instanceof instance ) {
+			return arg;
+		}
+		else {
+			return defaultValue;
+		}
+	},
+
+	/**
+     * Given an array of values, ensure the instances of all items in the array
+     * matches the given instance constructor falling back to a default value if
+     * the check fails.
+     *
+     * If given value isn't an Array, delegates to `SPE.utils.ensureInstanceOf`.
+     *
+     * @param  {Array|Object} arg          The value to perform the instanceof check on.
+     * @param  {Function} instance     The constructor of the instance to check against.
+     * @param  {Object} defaultValue A default fallback value if instance check fails
+     * @return {Object}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureArrayInstanceOf( arg, instance, defaultValue ) {
+		'use strict';
+
+		// If the argument being checked is an array, loop through
+		// it and ensure all the values are of the correct type,
+		// falling back to the defaultValue if any aren't.
+		if ( Array.isArray( arg ) ) {
+			for ( var i = arg.length - 1; i >= 0; --i ) {
+				if ( instance !== undefined && arg[ i ] instanceof instance === false ) {
+					return defaultValue;
+				}
+			}
+
+			return arg;
+		}
+
+		// If the arg isn't an array then just fallback to
+		// checking the type.
+		return this.ensureInstanceOf( arg, instance, defaultValue );
+	},
+
+	/**
+     * Ensures that any "value-over-lifetime" properties of an emitter are
+     * of the correct length (as dictated by `SPE.valueOverLifetimeLength`).
+     *
+     * Delegates to `SPE.utils.interpolateArray` for array resizing.
+     *
+     * If properties aren't arrays, then property values are put into one.
+     *
+     * @param  {Object} property  The property of an SPE.Emitter instance to check compliance of.
+     * @param  {Number} minLength The minimum length of the array to create.
+     * @param  {Number} maxLength The maximum length of the array to create.
+     */
+	ensureValueOverLifetimeCompliance( property, minLength, maxLength ) {
+		'use strict';
+
+		minLength = minLength || 3;
+		maxLength = maxLength || 3;
+
+		// First, ensure both properties are arrays.
+		if ( Array.isArray( property._value ) === false ) {
+			property._value = [ property._value ];
+		}
+
+		if ( Array.isArray( property._spread ) === false ) {
+			property._spread = [ property._spread ];
+		}
+
+		var valueLength = this.clamp( property._value.length, minLength, maxLength ),
+			spreadLength = this.clamp( property._spread.length, minLength, maxLength ),
+			desiredLength = Math.max( valueLength, spreadLength );
+
+		if ( property._value.length !== desiredLength ) {
+			property._value = this.interpolateArray( property._value, desiredLength );
+		}
+
+		if ( property._spread.length !== desiredLength ) {
+			property._spread = this.interpolateArray( property._spread, desiredLength );
+		}
+	},
+
+	/**
+     * Performs linear interpolation (lerp) on an array.
+     *
+     * For example, lerping [1, 10], with a `newLength` of 10 will produce [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
+     *
+     * Delegates to `SPE.utils.lerpTypeAgnostic` to perform the actual
+     * interpolation.
+     *
+     * @param  {Array} srcArray  The array to lerp.
+     * @param  {Number} newLength The length the array should be interpolated to.
+     * @return {Array}           The interpolated array.
+     */
+	interpolateArray( srcArray, newLength ) {
+		'use strict';
+
+		var sourceLength = srcArray.length,
+			newArray = [ typeof srcArray[ 0 ].clone === 'function' ? srcArray[ 0 ].clone() : srcArray[ 0 ] ],
+			factor = ( sourceLength - 1 ) / ( newLength - 1 );
+
+
+		for ( var i = 1; i < newLength - 1; ++i ) {
+			var f = i * factor,
+				before = Math.floor( f ),
+				after = Math.ceil( f ),
+				delta = f - before;
+
+			newArray[ i ] = this.lerpTypeAgnostic( srcArray[ before ], srcArray[ after ], delta );
+		}
+
+		newArray.push(
+			typeof srcArray[ sourceLength - 1 ].clone === 'function' ?
+				srcArray[ sourceLength - 1 ].clone() :
+				srcArray[ sourceLength - 1 ]
+		);
+
+		return newArray;
+	},
+
+	/**
+     * Clamp a number to between the given min and max values.
+     * @param  {Number} value The number to clamp.
+     * @param  {Number} min   The minimum value.
+     * @param  {Number} max   The maximum value.
+     * @return {Number}       The clamped number.
+     */
+	clamp( value, min, max ) {
+		'use strict';
+
+		return Math.max( min, Math.min( value, max ) );
+	},
+
+	/**
+     * If the given value is less than the epsilon value, then return
+     * a randomised epsilon value if specified, or just the epsilon value if not.
+     * Works for negative numbers as well as positive.
+     *
+     * @param  {Number} value     The value to perform the operation on.
+     * @param  {Boolean} randomise Whether the value should be randomised.
+     * @return {Number}           The result of the operation.
+     */
+	zeroToEpsilon( value, randomise ) {
+		'use strict';
+
+		var epsilon = 0.00001,
+			result = value;
+
+		result = randomise ? Math.random() * epsilon * 10 : epsilon;
+
+		if ( value < 0 && value > -epsilon ) {
+			result = -result;
+		}
+
+		// if ( value === 0 ) {
+		//     result = randomise ? Math.random() * epsilon * 10 : epsilon;
+		// }
+		// else if ( value > 0 && value < epsilon ) {
+		//     result = randomise ? Math.random() * epsilon * 10 : epsilon;
+		// }
+		// else if ( value < 0 && value > -epsilon ) {
+		//     result = -( randomise ? Math.random() * epsilon * 10 : epsilon );
+		// }
+
+		return result;
+	},
+
+	/**
+     * Linearly interpolates two values of various valueTypes. The given values
+     * must be of the same type for the interpolation to work.
+     * @param  {(number|Object)} start The start value of the lerp.
+     * @param  {(number|object)} end   The end value of the lerp.
+     * @param  {Number} delta The delta posiiton of the lerp operation. Ideally between 0 and 1 (inclusive).
+     * @return {(number|object|undefined)}       The result of the operation. Result will be undefined if
+     *                                               the start and end arguments aren't a supported type, or
+     *                                               if their types do not match.
+     */
+	lerpTypeAgnostic( start, end, delta ) {
+		'use strict';
+
+		var out;
+
+		if ( typeof start === valueTypes.NUMBER && typeof end === valueTypes.NUMBER ) {
+			return start + ( ( end - start ) * delta );
+		}
+		else if ( start instanceof THREE.Vector2 && end instanceof THREE.Vector2 ) {
+			out = start.clone();
+			out.x = this.lerp( start.x, end.x, delta );
+			out.y = this.lerp( start.y, end.y, delta );
+			return out;
+		}
+		else if ( start instanceof THREE.Vector3 && end instanceof THREE.Vector3 ) {
+			out = start.clone();
+			out.x = this.lerp( start.x, end.x, delta );
+			out.y = this.lerp( start.y, end.y, delta );
+			out.z = this.lerp( start.z, end.z, delta );
+			return out;
+		}
+		else if ( start instanceof THREE.Vector4 && end instanceof THREE.Vector4 ) {
+			out = start.clone();
+			out.x = this.lerp( start.x, end.x, delta );
+			out.y = this.lerp( start.y, end.y, delta );
+			out.z = this.lerp( start.z, end.z, delta );
+			out.w = this.lerp( start.w, end.w, delta );
+			return out;
+		}
+		else if ( start instanceof THREE.Color && end instanceof THREE.Color ) {
+			out = start.clone();
+			out.r = this.lerp( start.r, end.r, delta );
+			out.g = this.lerp( start.g, end.g, delta );
+			out.b = this.lerp( start.b, end.b, delta );
+			return out;
+		}
+		else {
+			console.warn( 'Invalid argument types, or argument types do not match:', start, end );
+		}
+	},
+
+	/**
+     * Perform a linear interpolation operation on two numbers.
+     * @param  {Number} start The start value.
+     * @param  {Number} end   The end value.
+     * @param  {Number} delta The position to interpolate to.
+     * @return {Number}       The result of the lerp operation.
+     */
+	lerp( start, end, delta ) {
+		'use strict';
+		return start + ( ( end - start ) * delta );
+	},
+
+	/**
+     * Rounds a number to a nearest multiple.
+     *
+     * @param  {Number} n        The number to round.
+     * @param  {Number} multiple The multiple to round to.
+     * @return {Number}          The result of the round operation.
+     */
+	roundToNearestMultiple( n, multiple ) {
+		'use strict';
+
+		var remainder = 0;
+
+		if ( multiple === 0 ) {
+			return n;
+		}
+
+		remainder = Math.abs( n ) % multiple;
+
+		if ( remainder === 0 ) {
+			return n;
+		}
+
+		if ( n < 0 ) {
+			return -( Math.abs( n ) - remainder );
+		}
+
+		return n + multiple - remainder;
+	},
+
+	/**
+     * Check if all items in an array are equal. Uses strict equality.
+     *
+     * @param  {Array} array The array of values to check equality of.
+     * @return {Boolean}       Whether the array's values are all equal or not.
+     */
+	arrayValuesAreEqual( array ) {
+		'use strict';
+
+		for ( var i = 0; i < array.length - 1; ++i ) {
+			if ( array[ i ] !== array[ i + 1 ] ) {
+				return false;
+			}
+		}
+
+		return true;
+	},
+
+	// colorsAreEqual: function() {
+	//     var colors = Array.prototype.slice.call( arguments ),
+	//         numColors = colors.length;
+
+	//     for ( var i = 0, color1, color2; i < numColors - 1; ++i ) {
+	//         color1 = colors[ i ];
+	//         color2 = colors[ i + 1 ];
+
+	//         if (
+	//             color1.r !== color2.r ||
+	//             color1.g !== color2.g ||
+	//             color1.b !== color2.b
+	//         ) {
+	//             return false
+	//         }
+	//     }
+
+	//     return true;
+	// },
+
+
+	/**
+     * Given a start value and a spread value, create and return a random
+     * number.
+     * @param  {Number} base   The start value.
+     * @param  {Number} spread The size of the random variance to apply.
+     * @return {Number}        A randomised number.
+     */
+	randomFloat( base, spread ) {
+		'use strict';
+		return base + spread * ( Math.random() - 0.5 );
+	},
+
+
+
+	/**
+     * Given an SPE.ShaderAttribute instance, and various other settings,
+     * assign values to the attribute's array in a `vec3` format.
+     *
+     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base        THREE.Vector3 instance describing the start value.
+     * @param  {Object} spread      THREE.Vector3 instance describing the random variance to apply to the start value.
+     * @param  {Object} spreadClamp THREE.Vector3 instance describing the multiples to clamp the randomness to.
+     */
+	randomVector3( attribute, index, base, spread, spreadClamp ) {
+		'use strict';
+
+		var x = base.x + ( Math.random() * spread.x - ( spread.x * 0.5 ) ),
+			y = base.y + ( Math.random() * spread.y - ( spread.y * 0.5 ) ),
+			z = base.z + ( Math.random() * spread.z - ( spread.z * 0.5 ) );
+
+		// var x = this.randomFloat( base.x, spread.x ),
+		// y = this.randomFloat( base.y, spread.y ),
+		// z = this.randomFloat( base.z, spread.z );
+
+		if ( spreadClamp ) {
+			x = -spreadClamp.x * 0.5 + this.roundToNearestMultiple( x, spreadClamp.x );
+			y = -spreadClamp.y * 0.5 + this.roundToNearestMultiple( y, spreadClamp.y );
+			z = -spreadClamp.z * 0.5 + this.roundToNearestMultiple( z, spreadClamp.z );
+		}
+
+		attribute.typedArray.setVec3Components( index, x, y, z );
+	},
+
+	/**
+     * Given an SPE.Shader attribute instance, and various other settings,
+     * assign Color values to the attribute.
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base      THREE.Color instance describing the start color.
+     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
+     */
+	randomColor( attribute, index, base, spread ) {
+		'use strict';
+
+		var r = base.r + ( Math.random() * spread.x ),
+			g = base.g + ( Math.random() * spread.y ),
+			b = base.b + ( Math.random() * spread.z );
+
+		r = this.clamp( r, 0, 1 );
+		g = this.clamp( g, 0, 1 );
+		b = this.clamp( b, 0, 1 );
+
+
+		attribute.typedArray.setVec3Components( index, r, g, b );
+	},
+
+
+	randomColorAsHex: ( function() {
+		'use strict';
+
+		var workingColor = new THREE.Color();
+
+		/**
+         * Assigns a random color value, encoded as a hex value in decimal
+         * format, to a SPE.ShaderAttribute instance.
+         * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+         * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+         * @param  {Object} base      THREE.Color instance describing the start color.
+         * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
+         */
+		return function( attribute, index, base, spread ) {
+			var numItems = base.length,
+				colors = [];
+
+			for ( var i = 0; i < numItems; ++i ) {
+				var spreadVector = spread[ i ];
+
+				workingColor.copy( base[ i ] );
+
+				workingColor.r += ( Math.random() * spreadVector.x ) - ( spreadVector.x * 0.5 );
+				workingColor.g += ( Math.random() * spreadVector.y ) - ( spreadVector.y * 0.5 );
+				workingColor.b += ( Math.random() * spreadVector.z ) - ( spreadVector.z * 0.5 );
+
+				workingColor.r = this.clamp( workingColor.r, 0, 1 );
+				workingColor.g = this.clamp( workingColor.g, 0, 1 );
+				workingColor.b = this.clamp( workingColor.b, 0, 1 );
+
+				colors.push( workingColor.getHex() );
+			}
+
+			attribute.typedArray.setVec4Components( index, colors[ 0 ], colors[ 1 ], colors[ 2 ], colors[ 3 ] );
+		};
+	}() ),
+
+	/**
+     * Given an SPE.ShaderAttribute instance, and various other settings,
+     * assign values to the attribute's array in a `vec3` format.
+     *
+     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} start       THREE.Vector3 instance describing the start line position.
+     * @param  {Object} end         THREE.Vector3 instance describing the end line position.
+     */
+	randomVector3OnLine( attribute, index, start, end ) {
+		'use strict';
+		var pos = start.clone();
+
+		pos.lerp( end, Math.random() );
+
+		attribute.typedArray.setVec3Components( index, pos.x, pos.y, pos.z );
+	},
+
+	/**
+     * Given an SPE.Shader attribute instance, and various other settings,
+     * assign Color values to the attribute.
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base      THREE.Color instance describing the start color.
+     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
+     */
+
+	/**
+     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
+     * given values onto a sphere.
+     *
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
+     * @param  {Number} radius            The radius of the sphere to project onto.
+     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
+     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the sphere.
+     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
+     */
+	randomVector3OnSphere(
+		attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp, distributionClamp
+	) {
+		'use strict';
+
+		var depth = 2 * Math.random() - 1,
+			t = 6.2832 * Math.random(),
+			r = Math.sqrt( 1 - depth * depth ),
+			rand = this.randomFloat( radius, radiusSpread ),
+			x = 0,
+			y = 0,
+			z = 0;
+
+
+		if ( radiusSpreadClamp ) {
+			rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
+		}
+
+
+
+		// Set position on sphere
+		x = r * Math.cos( t ) * rand;
+		y = r * Math.sin( t ) * rand;
+		z = depth * rand;
+
+		// Apply radius scale to this position
+		x *= radiusScale.x;
+		y *= radiusScale.y;
+		z *= radiusScale.z;
+
+		// Translate to the base position.
+		x += base.x;
+		y += base.y;
+		z += base.z;
+
+		// Set the values in the typed array.
+		attribute.typedArray.setVec3Components( index, x, y, z );
+	},
+
+	seededRandom( seed ) {
+		var x = Math.sin( seed ) * 10000;
+		return x - ( x | 0 );
+	},
+
+
+
+	/**
+     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
+     * given values onto a 2d-disc.
+     *
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
+     * @param  {Number} radius            The radius of the sphere to project onto.
+     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
+     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the disc. The z-component is ignored.
+     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
+     */
+	randomVector3OnDisc( attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp ) {
+		'use strict';
+
+		var t = 6.2832 * Math.random(),
+			rand = Math.abs( this.randomFloat( radius, radiusSpread ) ),
+			x = 0,
+			y = 0,
+			z = 0;
+
+		if ( radiusSpreadClamp ) {
+			rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
+		}
+
+		// Set position on sphere
+		x = Math.cos( t ) * rand;
+		y = Math.sin( t ) * rand;
+
+		// Apply radius scale to this position
+		x *= radiusScale.x;
+		y *= radiusScale.y;
+
+		// Translate to the base position.
+		x += base.x;
+		y += base.y;
+		z += base.z;
+
+		// Set the values in the typed array.
+		attribute.typedArray.setVec3Components( index, x, y, z );
+	},
+
+	randomDirectionVector3OnSphere: ( function() {
+		'use strict';
+
+		var v = new THREE.Vector3();
+
+		/**
+         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
+         * position, using `speed` as the magnitude. Values are saved to the attribute.
+         *
+         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
+         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
+         * @param  {Number} posX            The particle's x coordinate.
+         * @param  {Number} posY            The particle's y coordinate.
+         * @param  {Number} posZ            The particle's z coordinate.
+         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
+         * @param  {Number} speed           The magnitude to apply to the vector.
+         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
+         */
+		return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
+			v.copy( emitterPosition );
+
+			v.x -= posX;
+			v.y -= posY;
+			v.z -= posZ;
+
+			v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
+
+			attribute.typedArray.setVec3Components( index, v.x, v.y, v.z );
+		};
+	}() ),
+
+
+	randomDirectionVector3OnDisc: ( function() {
+		'use strict';
+
+		var v = new THREE.Vector3();
+
+		/**
+         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
+         * position, using `speed` as the magnitude. Values are saved to the attribute.
+         *
+         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
+         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
+         * @param  {Number} posX            The particle's x coordinate.
+         * @param  {Number} posY            The particle's y coordinate.
+         * @param  {Number} posZ            The particle's z coordinate.
+         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
+         * @param  {Number} speed           The magnitude to apply to the vector.
+         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
+         */
+		return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
+			v.copy( emitterPosition );
+
+			v.x -= posX;
+			v.y -= posY;
+			v.z -= posZ;
+
+			v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
+
+			attribute.typedArray.setVec3Components( index, v.x, v.y, 0 );
+		};
+	}() ),
+
+	getPackedRotationAxis: ( function() {
+		'use strict';
+
+		var v = new THREE.Vector3(),
+			vSpread = new THREE.Vector3(),
+			c = new THREE.Color(),
+			addOne = new THREE.Vector3( 1, 1, 1 );
+
+		/**
+         * Given a rotation axis, and a rotation axis spread vector,
+         * calculate a randomised rotation axis, and pack it into
+         * a hexadecimal value represented in decimal form.
+         * @param  {Object} axis       THREE.Vector3 instance describing the rotation axis.
+         * @param  {Object} axisSpread THREE.Vector3 instance describing the amount of randomness to apply to the rotation axis.
+         * @return {Number}            The packed rotation axis, with randomness.
+         */
+		return function( axis, axisSpread ) {
+			v.copy( axis ).normalize();
+			vSpread.copy( axisSpread ).normalize();
+
+			v.x += ( -axisSpread.x * 0.5 ) + ( Math.random() * axisSpread.x );
+			v.y += ( -axisSpread.y * 0.5 ) + ( Math.random() * axisSpread.y );
+			v.z += ( -axisSpread.z * 0.5 ) + ( Math.random() * axisSpread.z );
+
+			// v.x = Math.abs( v.x );
+			// v.y = Math.abs( v.y );
+			// v.z = Math.abs( v.z );
+
+			v.normalize().add( addOne )
+				.multiplyScalar( 0.5 );
+
+			c.setRGB( v.x, v.y, v.z );
+
+			return c.getHex();
+		};
+	}() ),
+};
+
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/global.html b/docs/api/global.html index 7d2320f..6a0e5da 100644 --- a/docs/api/global.html +++ b/docs/api/global.html @@ -28,19 +28,5645 @@

Global

-

+

- + +
+ +
+
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + +
+ + + + + + + + + + + + + + + + +

Methods

+ + + + + + + +

_createBufferAttribute(size)

+ + + + + + +
+ Creates a THREE.BufferAttribute instance if one doesn't exist already. + +Ensures a typed array is present by calling _ensureTypedArray() first. + +If a buffer attribute exists already, then it will be marked as needing an update. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
size + + +Number + + + + The size of the typed array to create if one doesn't exist, or resize existing array to.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

_ensureTypedArray(size)

+ + + + + + +
+ Make sure this attribute has a typed array associated with it. + +If it does, then it will ensure the typed array is of the correct size. + +If not, a new `TypedArrayHelper` instance will be created. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
size + + +Number + + + + The size of the typed array to create or update to.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

addEmitter(emitter)

+ + + + + + +
+ Adds an SPE.Emitter instance to this group, creating particle values and +assigning them to this group's shader attributes. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
emitter + + +Emitter + + + + The emitter to add to this group.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

addPool(numEmitters, emitterOptions, createNew) → {Group}

+ + + + + + +
+ Add a pool of emitters to this particle group +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
numEmitters + + +Number + + + + The number of emitters to add to the pool.
emitterOptions + + +EmitterOptions +| + +Array + + + + An object, or array of objects, describing the options to pass to each emitter.
createNew + + +Boolean + + + + Should a new emitter be created if the pool runs out?
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ This group instance. +
+ + + +
+
+ Type +
+
+ +Group + + +
+
+ + + + + + + + + + + + + +

disable() → {Emitter}

+ + + + + + +
+ Disables th emitter, but does not instantly remove it's +particles fromt the scene. When called, the emitter will be +'switched off' and just stop emitting. Any particle's alive will +be allowed to finish their lifecycle. +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ This emitter instance. +
+ + + +
+
+ Type +
+
+ +Emitter + + +
+
+ + + + + + + + + + + + + +

dispose() → {Group}

+ + + + + + +
+ Dipose the geometry and material for the group. +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Group instance. +
+ + + +
+
+ Type +
+
+ +Group + + +
+
+ + + + + + + + + + + + + +

enable() → {Emitter}

+ + + + + + +
+ Enables the emitter. If not already enabled, the emitter +will start emitting particles. +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ This emitter instance. +
+ + + +
+
+ Type +
+
+ +Emitter + + +
+
+ + + + + + + + + + + + + +

flagUpdate()

+ + + + + + +
+ Calculate the number of indices that this attribute should mark as needing +updating. Also marks the attribute as needing an update. +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

getComponentValueAtIndex(index) → {TypedArray}

+ + + + + + +
+ Returns the component value of the array at the given index, taking into account +the `indexOffset` property of this class. + +If the componentSize is set to 3, then it will return a new TypedArray +of length 3. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index in the array to fetch.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ The component value at the given index. +
+ + + +
+
+ Type +
+
+ +TypedArray + + +
+
+ + + + + + + + + + + + + +

getFromPool() → {Emitter|null}

+ + + + + + +
+ Fetch a single emitter instance from the pool. +If there are no objects in the pool, a new emitter will be +created if specified. +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +Emitter +| + +null + + +
+
+ + + + + + + + + + + + + +

getLength() → {Number}

+ + + + + + +
+ Returns the length of the typed array associated with this attribute. +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ The length of the typed array. Will be 0 if no typed array has been created yet. +
+ + + +
+
+ Type +
+
+ +Number + + +
+
+ + + + + + + + + + + + + +

getPool() → {Array}

+ + + + + + +
+ Get the pool array +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + + + +
+
+ Type +
+
+ +Array + + +
+
+ + + + + + + + + + + + + +

getValueAtIndex(index) → {Number}

+ + + + + + +
+ Returns the value of the array at the given index, taking into account +the `indexOffset` property of this class. + +Note that this function ignores the component size and will just return a +single value. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index in the array to fetch.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ The value at the given index. +
+ + + +
+
+ Type +
+
+ +Number + + +
+
+ + + + + + + + + + + + + +

grow(size) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Grows the internal array. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
size + + +Number + + + + The new size of the typed array. Must be larger than `this.array.length`.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

releaseIntoPool(emitter) → {Group}

+ + + + + + +
+ Release an emitter into the pool. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
emitter + + +ShaderParticleEmitter + + + +
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ This group instance. +
+ + + +
+
+ Type +
+
+ +Group + + +
+
+ + + + + + + + + + + + + +

remove() → {Emitter}

+ + + + + + +
+ Remove this emitter from it's parent group (if it has been added to one). +Delgates to Group.prototype.removeEmitter(). + +When called, all particle's belonging to this emitter will be instantly +removed from the scene. +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + +
See:
+
+
    +
  • Group.prototype.removeEmitter
    • +
+
+ + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ This emitter instance. +
+ + + +
+
+ Type +
+
+ +Emitter + + +
+
+ + + + + + + + + + + + + +

removeEmitter(emitter)

+ + + + + + +
+ Removes an Emitter instance from this group. When called, +all particle's belonging to the given emitter will be instantly +removed from the scene. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
emitter + + +Emitter + + + + The emitter to add to this group.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

reset(forceopt) → {Emitter}

+ + + + + + +
+ Resets all the emitter's particles to their start positions +and marks the particles as dead if the `force` argument is +true. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeAttributesDescription
force + + +Boolean + + + + + + <optional>
+ + + + + + 		If true, all particles will be marked as dead instantly.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ This emitter instance. +
+ + + +
+
+ Type +
+
+ +Emitter + + +
+
+ + + + + + + + + + + + + +

resetUpdateRange()

+ + + + + + +
+ Reset the index update counts for this attribute +
+ + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

setColor(index, color) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Color value at `index`. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec3 values from.
color + + +Color + + + + Any object that has `r`, `g`, and `b` properties.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setFromArray(index, array) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Copies from the given TypedArray into this one, using the index argument +as the start position. Alias for `TypedArray.set`. Will automatically resize +if the given source array is of a larger size than the internal array. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The start position from which to copy into this array.
array + + +TypedArray + + + + The array from which to copy; the source array.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setMat3(index, mat3) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Matrix3 value at `index`. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the matrix values from.
mat3 + + +Matrix3 + + + + The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setMat4(index, mat3) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Matrix4 value at `index`. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the matrix values from.
mat3 + + +Matrix4 + + + + The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setNumber(index, numericValue) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Number value at `index`. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec3 values from.
numericValue + + +Number + + + + The number to assign to this index in the array.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setSize(size)

+ + + + + + +
+ Sets the size of the internal array. + +Delegates to `this.shrink` or `this.grow` depending on size +argument's relation to the current size of the internal array. + +Note that if the array is to be shrunk, data will be lost. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
size + + +Number + + + + The new size of the array.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

setUpdateRange(min, max)

+ + + + + + +
+ Calculate the minimum and maximum update range for this buffer attribute using +component size independant min and max values. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
min + + +Number + + + + The start of the range to mark as needing an update.
max + + +Number + + + + The end of the range to mark as needing an update.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

setVec2(index, vec2) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Vector2 value at `index`. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec2 values from.
vec2 + + +Vector2 + + + + Any object that has `x` and `y` properties.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setVec2Components(index, x, y) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Vector2 value using raw components. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec2 values from.
x + + +Number + + + + The Vec2's `x` component.
y + + +Number + + + + The Vec2's `y` component.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setVec3(index, vec2) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Vector3 value at `index`. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec3 values from.
vec2 + + +Vector3 + + + + Any object that has `x`, `y`, and `z` properties.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setVec3Components(index, x, y, z) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Vector3 value using raw components. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec3 values from.
x + + +Number + + + + The Vec3's `x` component.
y + + +Number + + + + The Vec3's `y` component.
z + + +Number + + + + The Vec3's `z` component.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setVec4(index, vec2) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Vector4 value at `index`. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec4 values from.
vec2 + + +Vector4 + + + + Any object that has `x`, `y`, `z`, and `w` properties.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

setVec4Components(index, x, y, z, w) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Set a Vector4 value using raw components. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
index + + +Number + + + + The index at which to set the vec4 values from.
x + + +Number + + + + The Vec4's `x` component.
y + + +Number + + + + The Vec4's `y` component.
z + + +Number + + + + The Vec4's `z` component.
w + + +Number + + + + The Vec4's `w` component.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

shrink(size) → {SPE.TypedArrayHelper}

+ + + + + + +
+ Shrinks the internal array. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
size + + +Number + + + + The new size of the typed array. Must be smaller than `this.array.length`.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ Instance of this class. +
+ + + +
+
+ Type +
+
+ +SPE.TypedArrayHelper + + +
+
+ + + + + + + + + + + + + +

splice(start, end) → {Object}

+ + + + + + +
+ Perform a splice operation on this array's buffer. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
start + + +Number + + + + The start index of the splice. Will be multiplied by the number of components for this attribute.
end + + +Number + + + + The end index of the splice. Will be multiplied by the number of components for this attribute.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + +
Returns:
+ + +
+ The SPE.TypedArrayHelper instance. +
+ + + +
+
+ Type +
+
+ +Object + + +
+
+ + + + + + + + + - -
-
- +

splice(start, end)

+ + + + + + +
+ Perform a splice operation on this attribute's buffer. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
start + + +Number + + + + The start index of the splice. Will be multiplied by the number of components for this attribute.
end + + +Number + + + + The end index of the splice. Will be multiplied by the number of components for this attribute.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

tick(dt)

+ + + + + + +
+ Simulates one frame's worth of particles, updating particles +that are already alive, and marking ones that are currently dead +but should be alive as alive. + +If the emitter is marked as static, then this function will do nothing. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
dt + + +Number + + + + The number of seconds to simulate (deltaTime)
+ + + -
@@ -69,6 +5695,11 @@

+ +
Source:
+
@@ -79,55 +5710,54 @@

- - -
- - - - - - - - -

Type Definitions

- - -

distribution

-
Type:
-
    -
  • + + + + -Number + + + +

    tick(dtopt)

    + + + + + + +
    + Simulate all the emitter's belonging to this group, updating +attribute values along the way. +
    -
    • -
-
Properties:
+ + +
Parameters:
- +
@@ -137,8 +5767,12 @@
Properties:
+ + + + @@ -149,7 +5783,7 @@
Properties:
- + + + + + - + + +
TypeAttributesDefaultDescription
SPE.distributions.BOXdt @@ -162,17 +5796,150 @@
Properties:
 + + <optional>
+ + + + + + 		+ + Group's `fixedTimeStep` value + + Values will be distributed within a box.The number of seconds to simulate the group's emitters for (deltaTime)
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

triggerPoolEmitter(numEmitters, positionopt) → {Group}

+ + + + + + +
+ Set a given number of emitters as alive, with an optional position +vector3 to move them to. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + - + + + - + - + + + - + @@ -221,6 +6006,8 @@
Properties:
+ +
@@ -250,7 +6037,7 @@
Properties:
Source:
@@ -266,7 +6053,49 @@
Properties:
- + + + + + + + + + +
Returns:
+ + +
+ This group instance. +
+ + + +
+
+ Type +
+
+ +Group + + +
+
+ + + + + + + + + + + +

Type Definitions

+ +

Emitter

@@ -322,7 +6151,7 @@
Type:
Source:
@@ -332,7 +6161,7 @@
Type:
See:
@@ -408,7 +6237,7 @@
Properties:
+ Must be an distributions.* value. @@ -909,7 +6738,8 @@
Properties
+ of this vector is used. + When using a LINE distribution, this value is the endpoint of the LINE. @@ -949,7 +6779,8 @@
Properties
+ of this vector is used. + When using a LINE distribution, this property is ignored. @@ -1036,7 +6867,7 @@
Properties
NameTypeAttributesDescription
SPE.distributions.SPHEREnumEmitters @@ -185,33 +5952,51 @@
Properties:
 + + + + + + Values will be distributed within a sphere.The number of emitters to activate
SPE.distributions.DISCposition -Number +Object + + <optional>
+ + + + + + 		Values will be distributed within a 2D disc.A THREE.Vector3 instance describing the position to activate the emitter(s) at.
-distribution +distribution @@ -434,7 +6263,7 @@
Properties:
The default distribution this emitter should use to control its particle's spawn position and force behaviour. - Must be an SPE.distributions.* value.
A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis. Note that when using a SPHERE or DISC distribution, only the x-component - of this vector is used.
A THREE.Vector3 instance describing the numeric multiples the particle's should be spread out over. Note that when using a SPHERE or DISC distribution, only the x-component - of this vector is used.
-distribution +distribution @@ -1252,7 +7083,7 @@
Properties
 -distribution +distribution @@ -1468,7 +7299,7 @@
Properties
 -distribution +distribution @@ -2946,7 +8777,7 @@
Properties
Source:
@@ -3018,7 +8849,7 @@
Type:
Source:
@@ -3028,7 +8859,7 @@
Type:
See:
@@ -3557,7 +9388,7 @@
Properties
Source:
@@ -3587,13 +9418,13 @@
Properties

- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) + Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time)
diff --git a/docs/api/helpers_SPE.ShaderAttribute.js.html b/docs/api/helpers_SPE.ShaderAttribute.js.html deleted file mode 100644 index 43240a2..0000000 --- a/docs/api/helpers_SPE.ShaderAttribute.js.html +++ /dev/null @@ -1,269 +0,0 @@ - - - - - JSDoc: Source: helpers/SPE.ShaderAttribute.js - - - - - - - - - - -
- -

Source: helpers/SPE.ShaderAttribute.js

- - - - - - -
-
- 
/**
- * A helper to handle creating and updating a THREE.BufferAttribute instance.
- *
- * @author  Luke Moody
- * @constructor
- * @param {String} type          The buffer attribute type. See SPE.ShaderAttribute.typeSizeMap for valid values.
- * @param {Boolean=} dynamicBuffer Whether this buffer attribute should be marked as dynamic or not.
- * @param {Function=} arrayType     A reference to a TypedArray constructor. Defaults to Float32Array if none provided.
- */
-SPE.ShaderAttribute = function( type, dynamicBuffer, arrayType ) {
-    'use strict';
-
-    var typeMap = SPE.ShaderAttribute.typeSizeMap;
-
-    this.type = typeof type === 'string' && typeMap.hasOwnProperty( type ) ? type : 'f';
-    this.componentSize = typeMap[ this.type ];
-    this.arrayType = arrayType || Float32Array;
-    this.typedArray = null;
-    this.bufferAttribute = null;
-    this.dynamicBuffer = !!dynamicBuffer;
-
-    this.updateMin = 0;
-    this.updateMax = 0;
-};
-
-SPE.ShaderAttribute.constructor = SPE.ShaderAttribute;
-
-/**
- * A map of uniform types to their component size.
- * @enum {Number}
- */
-SPE.ShaderAttribute.typeSizeMap = {
-    /**
-     * Float
-     * @type {Number}
-     */
-    f: 1,
-
-    /**
-     * Vec2
-     * @type {Number}
-     */
-    v2: 2,
-
-    /**
-     * Vec3
-     * @type {Number}
-     */
-    v3: 3,
-
-    /**
-     * Vec4
-     * @type {Number}
-     */
-    v4: 4,
-
-    /**
-     * Color
-     * @type {Number}
-     */
-    c: 3,
-
-    /**
-     * Mat3
-     * @type {Number}
-     */
-    m3: 9,
-
-    /**
-     * Mat4
-     * @type {Number}
-     */
-    m4: 16
-};
-
-/**
- * Calculate the minimum and maximum update range for this buffer attribute using
- * component size independant min and max values.
- *
- * @param {Number} min The start of the range to mark as needing an update.
- * @param {Number} max The end of the range to mark as needing an update.
- */
-SPE.ShaderAttribute.prototype.setUpdateRange = function( min, max ) {
-    'use strict';
-
-    this.updateMin = Math.min( min * this.componentSize, this.updateMin * this.componentSize );
-    this.updateMax = Math.max( max * this.componentSize, this.updateMax * this.componentSize );
-};
-
-/**
- * Calculate the number of indices that this attribute should mark as needing
- * updating. Also marks the attribute as needing an update.
- */
-SPE.ShaderAttribute.prototype.flagUpdate = function() {
-    'use strict';
-
-    var attr = this.bufferAttribute,
-        range = attr.updateRange;
-
-    range.offset = this.updateMin;
-    range.count = Math.min( ( this.updateMax - this.updateMin ) + this.componentSize, this.typedArray.array.length );
-    // console.log( range.offset, range.count, this.typedArray.array.length );
-    // console.log( 'flagUpdate:', range.offset, range.count );
-    attr.needsUpdate = true;
-};
-
-
-
-/**
- * Reset the index update counts for this attribute
- */
-SPE.ShaderAttribute.prototype.resetUpdateRange = function() {
-    'use strict';
-
-    this.updateMin = 0;
-    this.updateMax = 0;
-};
-
-SPE.ShaderAttribute.prototype.resetDynamic = function() {
-    'use strict';
-    this.bufferAttribute.dynamic = this.dynamicBuffer;
-};
-
-/**
- * Perform a splice operation on this attribute's buffer.
- * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
- * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
- */
-SPE.ShaderAttribute.prototype.splice = function( start, end ) {
-    'use strict';
-
-    this.typedArray.splice( start, end );
-
-    // Reset the reference to the attribute's typed array
-    // since it has probably changed.
-    this.forceUpdateAll();
-};
-
-SPE.ShaderAttribute.prototype.forceUpdateAll = function() {
-    'use strict';
-
-    this.bufferAttribute.array = this.typedArray.array;
-    this.bufferAttribute.updateRange.offset = 0;
-    this.bufferAttribute.updateRange.count = -1;
-    this.bufferAttribute.dynamic = false;
-    this.bufferAttribute.needsUpdate = true;
-};
-
-/**
- * Make sure this attribute has a typed array associated with it.
- *
- * If it does, then it will ensure the typed array is of the correct size.
- *
- * If not, a new SPE.TypedArrayHelper instance will be created.
- *
- * @param  {Number} size The size of the typed array to create or update to.
- */
-SPE.ShaderAttribute.prototype._ensureTypedArray = function( size ) {
-    'use strict';
-
-    // Condition that's most likely to be true at the top: no change.
-    if ( this.typedArray !== null && this.typedArray.size === size * this.componentSize ) {
-        return;
-    }
-
-    // Resize the array if we need to, telling the TypedArrayHelper to
-    // ignore it's component size when evaluating size.
-    else if ( this.typedArray !== null && this.typedArray.size !== size ) {
-        this.typedArray.setSize( size );
-    }
-
-    // This condition should only occur once in an attribute's lifecycle.
-    else if ( this.typedArray === null ) {
-        this.typedArray = new SPE.TypedArrayHelper( this.arrayType, size, this.componentSize );
-    }
-};
-
-
-/**
- * Creates a THREE.BufferAttribute instance if one doesn't exist already.
- *
- * Ensures a typed array is present by calling _ensureTypedArray() first.
- *
- * If a buffer attribute exists already, then it will be marked as needing an update.
- *
- * @param  {Number} size The size of the typed array to create if one doesn't exist, or resize existing array to.
- */
-SPE.ShaderAttribute.prototype._createBufferAttribute = function( size ) {
-    'use strict';
-
-    // Make sure the typedArray is present and correct.
-    this._ensureTypedArray( size );
-
-    // Don't create it if it already exists, but do
-    // flag that it needs updating on the next render
-    // cycle.
-    if ( this.bufferAttribute !== null ) {
-        this.bufferAttribute.array = this.typedArray.array;
-        this.bufferAttribute.needsUpdate = true;
-        return;
-    }
-
-    this.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize );
-    this.bufferAttribute.dynamic = this.dynamicBuffer;
-};
-
-/**
- * Returns the length of the typed array associated with this attribute.
- * @return {Number} The length of the typed array. Will be 0 if no typed array has been created yet.
- */
-SPE.ShaderAttribute.prototype.getLength = function() {
-    'use strict';
-
-    if ( this.typedArray === null ) {
-        return 0;
-    }
-
-    return this.typedArray.array.length;
-};
-
-
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - diff --git a/docs/api/helpers_SPE.TypedArrayHelper.js.html b/docs/api/helpers_SPE.TypedArrayHelper.js.html deleted file mode 100644 index 641a187..0000000 --- a/docs/api/helpers_SPE.TypedArrayHelper.js.html +++ /dev/null @@ -1,381 +0,0 @@ - - - - - JSDoc: Source: helpers/SPE.TypedArrayHelper.js - - - - - - - - - - -
- -

Source: helpers/SPE.TypedArrayHelper.js

- - - - - - -
-
- 
/**
- * A helper class for TypedArrays.
- *
- * Allows for easy resizing, assignment of various component-based
- * types (Vector2s, Vector3s, Vector4s, Mat3s, Mat4s),
- * as well as Colors (where components are `r`, `g`, `b`),
- * Numbers, and setting from other TypedArrays.
- *
- * @author Luke Moody
- * @constructor
- * @param {Function} TypedArrayConstructor The constructor to use (Float32Array, Uint8Array, etc.)
- * @param {Number} size                 The size of the array to create
- * @param {Number} componentSize        The number of components per-value (ie. 3 for a vec3, 9 for a Mat3, etc.)
- * @param {Number} indexOffset          The index in the array from which to start assigning values. Default `0` if none provided
- */
-SPE.TypedArrayHelper = function( TypedArrayConstructor, size, componentSize, indexOffset ) {
-    'use strict';
-
-    this.componentSize = componentSize || 1;
-    this.size = ( size || 1 );
-    this.TypedArrayConstructor = TypedArrayConstructor || Float32Array;
-    this.array = new TypedArrayConstructor( size * this.componentSize );
-    this.indexOffset = indexOffset || 0;
-};
-
-SPE.TypedArrayHelper.constructor = SPE.TypedArrayHelper;
-
-/**
- * Sets the size of the internal array.
- *
- * Delegates to `this.shrink` or `this.grow` depending on size
- * argument's relation to the current size of the internal array.
- *
- * Note that if the array is to be shrunk, data will be lost.
- *
- * @param {Number} size The new size of the array.
- */
-SPE.TypedArrayHelper.prototype.setSize = function( size, noComponentMultiply ) {
-    'use strict';
-
-    var currentArraySize = this.array.length;
-
-    if ( !noComponentMultiply ) {
-        size = size * this.componentSize;
-    }
-
-    if ( size < currentArraySize ) {
-        return this.shrink( size );
-    }
-    else if ( size > currentArraySize ) {
-        return this.grow( size );
-    }
-    else {
-        console.info( 'TypedArray is already of size:', size + '.', 'Will not resize.' );
-    }
-};
-
-/**
- * Shrinks the internal array.
- *
- * @param  {Number} size The new size of the typed array. Must be smaller than `this.array.length`.
- * @return {SPE.TypedArrayHelper}      Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.shrink = function( size ) {
-    'use strict';
-
-    this.array = this.array.subarray( 0, size );
-    this.size = size;
-    return this;
-};
-
-/**
- * Grows the internal array.
- * @param  {Number} size The new size of the typed array. Must be larger than `this.array.length`.
- * @return {SPE.TypedArrayHelper}      Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.grow = function( size ) {
-    'use strict';
-
-    var existingArray = this.array,
-        newArray = new this.TypedArrayConstructor( size );
-
-    newArray.set( existingArray );
-    this.array = newArray;
-    this.size = size;
-
-    return this;
-};
-
-
-/**
- * Perform a splice operation on this array's buffer.
- * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
- * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
- * @returns {Object} The SPE.TypedArrayHelper instance.
- */
-SPE.TypedArrayHelper.prototype.splice = function( start, end ) {
-    'use strict';
-    start *= this.componentSize;
-    end *= this.componentSize;
-
-    var data = [],
-        array = this.array,
-        size = array.length;
-
-    for ( var i = 0; i < size; ++i ) {
-        if ( i < start || i >= end ) {
-            data.push( array[ i ] );
-        }
-        // array[ i ] = 0;
-    }
-
-    this.setFromArray( 0, data );
-
-    return this;
-};
-
-
-/**
- * Copies from the given TypedArray into this one, using the index argument
- * as the start position. Alias for `TypedArray.set`. Will automatically resize
- * if the given source array is of a larger size than the internal array.
- *
- * @param {Number} index      The start position from which to copy into this array.
- * @param {TypedArray} array The array from which to copy; the source array.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setFromArray = function( index, array ) {
-    'use strict';
-
-    var sourceArraySize = array.length,
-        newSize = index + sourceArraySize;
-
-    if ( newSize > this.array.length ) {
-        this.grow( newSize );
-    }
-    else if ( newSize < this.array.length ) {
-        this.shrink( newSize );
-    }
-
-    this.array.set( array, this.indexOffset + index );
-
-    return this;
-};
-
-/**
- * Set a Vector2 value at `index`.
- *
- * @param {Number} index The index at which to set the vec2 values from.
- * @param {Vector2} vec2  Any object that has `x` and `y` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec2 = function( index, vec2 ) {
-    'use strict';
-
-    return this.setVec2Components( index, vec2.x, vec2.y );
-};
-
-/**
- * Set a Vector2 value using raw components.
- *
- * @param {Number} index The index at which to set the vec2 values from.
- * @param {Number} x     The Vec2's `x` component.
- * @param {Number} y     The Vec2's `y` component.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec2Components = function( index, x, y ) {
-    'use strict';
-
-    var array = this.array,
-        i = this.indexOffset + ( index * this.componentSize );
-
-    array[ i ] = x;
-    array[ i + 1 ] = y;
-    return this;
-};
-
-/**
- * Set a Vector3 value at `index`.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Vector3} vec2  Any object that has `x`, `y`, and `z` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec3 = function( index, vec3 ) {
-    'use strict';
-
-    return this.setVec3Components( index, vec3.x, vec3.y, vec3.z );
-};
-
-/**
- * Set a Vector3 value using raw components.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Number} x     The Vec3's `x` component.
- * @param {Number} y     The Vec3's `y` component.
- * @param {Number} z     The Vec3's `z` component.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec3Components = function( index, x, y, z ) {
-    'use strict';
-
-    var array = this.array,
-        i = this.indexOffset + ( index * this.componentSize );
-
-    array[ i ] = x;
-    array[ i + 1 ] = y;
-    array[ i + 2 ] = z;
-    return this;
-};
-
-/**
- * Set a Vector4 value at `index`.
- *
- * @param {Number} index The index at which to set the vec4 values from.
- * @param {Vector4} vec2  Any object that has `x`, `y`, `z`, and `w` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec4 = function( index, vec4 ) {
-    'use strict';
-
-    return this.setVec4Components( index, vec4.x, vec4.y, vec4.z, vec4.w );
-};
-
-/**
- * Set a Vector4 value using raw components.
- *
- * @param {Number} index The index at which to set the vec4 values from.
- * @param {Number} x     The Vec4's `x` component.
- * @param {Number} y     The Vec4's `y` component.
- * @param {Number} z     The Vec4's `z` component.
- * @param {Number} w     The Vec4's `w` component.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec4Components = function( index, x, y, z, w ) {
-    'use strict';
-
-    var array = this.array,
-        i = this.indexOffset + ( index * this.componentSize );
-
-    array[ i ] = x;
-    array[ i + 1 ] = y;
-    array[ i + 2 ] = z;
-    array[ i + 3 ] = w;
-    return this;
-};
-
-/**
- * Set a Matrix3 value at `index`.
- *
- * @param {Number} index The index at which to set the matrix values from.
- * @param {Matrix3} mat3 The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setMat3 = function( index, mat3 ) {
-    'use strict';
-
-    return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat3.elements );
-};
-
-/**
- * Set a Matrix4 value at `index`.
- *
- * @param {Number} index The index at which to set the matrix values from.
- * @param {Matrix4} mat3 The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setMat4 = function( index, mat4 ) {
-    'use strict';
-
-    return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat4.elements );
-};
-
-/**
- * Set a Color value at `index`.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Color} color  Any object that has `r`, `g`, and `b` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setColor = function( index, color ) {
-    'use strict';
-
-    return this.setVec3Components( index, color.r, color.g, color.b );
-};
-
-/**
- * Set a Number value at `index`.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Number} numericValue  The number to assign to this index in the array.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setNumber = function( index, numericValue ) {
-    'use strict';
-
-    this.array[ this.indexOffset + ( index * this.componentSize ) ] = numericValue;
-    return this;
-};
-
-/**
- * Returns the value of the array at the given index, taking into account
- * the `indexOffset` property of this class.
- *
- * Note that this function ignores the component size and will just return a
- * single value.
- *
- * @param  {Number} index The index in the array to fetch.
- * @return {Number}       The value at the given index.
- */
-SPE.TypedArrayHelper.prototype.getValueAtIndex = function( index ) {
-    'use strict';
-
-    return this.array[ this.indexOffset + index ];
-};
-
-/**
- * Returns the component value of the array at the given index, taking into account
- * the `indexOffset` property of this class.
- *
- * If the componentSize is set to 3, then it will return a new TypedArray
- * of length 3.
- *
- * @param  {Number} index The index in the array to fetch.
- * @return {TypedArray}       The component value at the given index.
- */
-SPE.TypedArrayHelper.prototype.getComponentValueAtIndex = function( index ) {
-    'use strict';
-
-    return this.array.subarray( this.indexOffset + ( index * this.componentSize ) );
-};
-
-
- - - - -
- - - -
- -
- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) -
- - - - - diff --git a/docs/api/helpers_ShaderAttribute.js.html b/docs/api/helpers_ShaderAttribute.js.html new file mode 100644 index 0000000..43390b6 --- /dev/null +++ b/docs/api/helpers_ShaderAttribute.js.html @@ -0,0 +1,223 @@ + + + + + JSDoc: Source: helpers/ShaderAttribute.js + + + + + + + + + + +
+ +

Source: helpers/ShaderAttribute.js

+ + + + + + +
+
+ 
import * as THREE from 'three';
+import TypedArrayHelper from './TypedArrayHelper';
+import typeSizeMap from '@/constants/typeSizeMap';
+
+const HAS_OWN = Object.prototype.hasOwnProperty;
+
+/**
+ * A helper to handle creating and updating a THREE.BufferAttribute instance.
+ *
+ * @author  Luke Moody
+ * @constructor
+ * @param {String} type          The buffer attribute type. See `typeSizeMap`` for valid values.
+ * @param {Boolean=} dynamicBuffer Whether this buffer attribute should be marked as dynamic or not.
+ * @param {Function=} arrayType     A reference to a TypedArray constructor. Defaults to Float32Array if none provided.
+ */
+export default class ShaderAttribute {
+	constructor( type, dynamicBuffer, arrayType ) {
+		this.type = typeof type === 'string' && HAS_OWN.call( typeSizeMap, type ) ? type : 'f';
+		this.componentSize = typeSizeMap[ this.type ];
+		this.arrayType = arrayType || Float32Array;
+		this.typedArray = null;
+		this.bufferAttribute = null;
+		this.dynamicBuffer = !!dynamicBuffer;
+
+		this.updateMin = 0;
+		this.updateMax = 0;
+	}
+
+	/**
+	 * Calculate the minimum and maximum update range for this buffer attribute using
+	 * component size independant min and max values.
+	 *
+	 * @param {Number} min The start of the range to mark as needing an update.
+	 * @param {Number} max The end of the range to mark as needing an update.
+	 */
+	setUpdateRange( min, max ) {
+		this.updateMin = Math.min( min * this.componentSize, this.updateMin * this.componentSize );
+		this.updateMax = Math.max( max * this.componentSize, this.updateMax * this.componentSize );
+	}
+
+	/**
+	 * Calculate the number of indices that this attribute should mark as needing
+	 * updating. Also marks the attribute as needing an update.
+	 */
+	flagUpdate() {
+		const attr = this.bufferAttribute,
+			range = attr.updateRange;
+
+		range.offset = this.updateMin;
+		range.count = Math.min( ( this.updateMax - this.updateMin ) + this.componentSize, this.typedArray.array.length );
+		attr.needsUpdate = true;
+	}
+
+
+
+	/**
+	 * Reset the index update counts for this attribute
+	 */
+	resetUpdateRange() {
+		this.updateMin = 0;
+		this.updateMax = 0;
+	}
+
+	resetDynamic() {
+		this.bufferAttribute.usage = this.dynamicBuffer ?
+			THREE.DynamicDrawUsage :
+			THREE.StaticDrawUsage;
+	}
+
+	/**
+	 * Perform a splice operation on this attribute's buffer.
+	 * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
+	 * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
+	 */
+	splice( start, end ) {
+		this.typedArray.splice( start, end );
+
+		// Reset the reference to the attribute's typed array
+		// since it has probably changed.
+		this.forceUpdateAll();
+	}
+
+	forceUpdateAll() {
+		this.bufferAttribute.array = this.typedArray.array;
+		this.bufferAttribute.updateRange.offset = 0;
+		this.bufferAttribute.updateRange.count = -1;
+
+		this.bufferAttribute.usage = THREE.StaticDrawUsage;
+		this.bufferAttribute.needsUpdate = true;
+	}
+
+	/**
+	 * Make sure this attribute has a typed array associated with it.
+	 *
+	 * If it does, then it will ensure the typed array is of the correct size.
+	 *
+	 * If not, a new `TypedArrayHelper` instance will be created.
+	 *
+	 * @param  {Number} size The size of the typed array to create or update to.
+	 */
+	_ensureTypedArray( size ) {
+		// Condition that's most likely to be true at the top: no change.
+		if ( this.typedArray !== null && this.typedArray.size === size * this.componentSize ) {
+			return;
+		}
+
+		// Resize the array if we need to, telling the TypedArrayHelper to
+		// ignore it's component size when evaluating size.
+		else if ( this.typedArray !== null && this.typedArray.size !== size ) {
+			this.typedArray.setSize( size );
+		}
+
+		// This condition should only occur once in an attribute's lifecycle.
+		else if ( this.typedArray === null ) {
+			this.typedArray = new TypedArrayHelper( this.arrayType, size, this.componentSize );
+		}
+	}
+
+
+	/**
+	 * Creates a THREE.BufferAttribute instance if one doesn't exist already.
+	 *
+	 * Ensures a typed array is present by calling _ensureTypedArray() first.
+	 *
+	 * If a buffer attribute exists already, then it will be marked as needing an update.
+	 *
+	 * @param  {Number} size The size of the typed array to create if one doesn't exist, or resize existing array to.
+	 */
+	_createBufferAttribute( size ) {
+		// Make sure the typedArray is present and correct.
+		this._ensureTypedArray( size );
+
+		// Don't create it if it already exists, but do
+		// flag that it needs updating on the next render
+		// cycle.
+		if ( this.bufferAttribute !== null ) {
+			this.bufferAttribute.array = this.typedArray.array;
+
+			// Since THREE.js version 81, dynamic count calculation was removed
+			// so I need to do it manually here.
+			//
+			// In the next minor release, I may well remove this check and force
+			// dependency on THREE r81+.
+			if ( parseFloat( THREE.REVISION ) >= 81 ) {
+				this.bufferAttribute.count = this.bufferAttribute.array.length / this.bufferAttribute.itemSize;
+			}
+
+			this.bufferAttribute.needsUpdate = true;
+			return;
+		}
+
+		this.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize );
+
+		this.bufferAttribute.usage = this.dynamicBuffer ?
+			THREE.DynamicDrawUsage :
+			THREE.StaticDrawUsage;
+	}
+
+	/**
+	 * Returns the length of the typed array associated with this attribute.
+	 * @return {Number} The length of the typed array. Will be 0 if no typed array has been created yet.
+	 */
+	getLength() {
+		if ( this.typedArray === null ) {
+			return 0;
+		}
+
+		return this.typedArray.array.length;
+	}
+
+}
+
+
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/helpers_TypedArrayHelper.js.html b/docs/api/helpers_TypedArrayHelper.js.html new file mode 100644 index 0000000..230919e --- /dev/null +++ b/docs/api/helpers_TypedArrayHelper.js.html @@ -0,0 +1,346 @@ + + + + + JSDoc: Source: helpers/TypedArrayHelper.js + + + + + + + + + + +
+ +

Source: helpers/TypedArrayHelper.js

+ + + + + + +
+
+ 
/**
+ * A helper class for TypedArrays.
+ *
+ * Allows for easy resizing, assignment of various component-based
+ * types (Vector2s, Vector3s, Vector4s, Mat3s, Mat4s),
+ * as well as Colors (where components are `r`, `g`, `b`),
+ * Numbers, and setting from other TypedArrays.
+ *
+ * @author Luke Moody
+ * @constructor
+ * @param {Function} TypedArrayConstructor The constructor to use (Float32Array, Uint8Array, etc.)
+ * @param {Number} size                 The size of the array to create
+ * @param {Number} componentSize        The number of components per-value (ie. 3 for a vec3, 9 for a Mat3, etc.)
+ * @param {Number} indexOffset          The index in the array from which to start assigning values. Default `0` if none provided
+ */
+export default class TypedArrayHelper {
+	constructor( TypedArrayConstructor, size, componentSize, indexOffset ) {
+		this.componentSize = componentSize || 1;
+		this.size = ( size || 1 );
+		this.TypedArrayConstructor = TypedArrayConstructor || Float32Array;
+		this.array = new TypedArrayConstructor( size * this.componentSize );
+		this.indexOffset = indexOffset || 0;
+	}
+
+	/**
+	 * Sets the size of the internal array.
+	 *
+	 * Delegates to `this.shrink` or `this.grow` depending on size
+	 * argument's relation to the current size of the internal array.
+	 *
+	 * Note that if the array is to be shrunk, data will be lost.
+	 *
+	 * @param {Number} size The new size of the array.
+	 */
+	setSize( s, noComponentMultiply ) {
+		const currentArraySize = this.array.length;
+		let size = s;
+
+		if ( !noComponentMultiply ) {
+			size = size * this.componentSize;
+		}
+
+		if ( size < currentArraySize ) {
+			return this.shrink( size );
+		}
+		else if ( size > currentArraySize ) {
+			return this.grow( size );
+		}
+		else {
+			console.info( 'TypedArray is already of size:', size + '.', 'Will not resize.' );
+		}
+	}
+
+	/**
+	 * Shrinks the internal array.
+	 *
+	 * @param  {Number} size The new size of the typed array. Must be smaller than `this.array.length`.
+	 * @return {SPE.TypedArrayHelper}      Instance of this class.
+	 */
+	shrink( size ) {
+		this.array = this.array.subarray( 0, size );
+		this.size = size;
+		return this;
+	}
+
+	/**
+	 * Grows the internal array.
+	 * @param  {Number} size The new size of the typed array. Must be larger than `this.array.length`.
+	 * @return {SPE.TypedArrayHelper}      Instance of this class.
+	 */
+	grow( size ) {
+		const newArray = new this.TypedArrayConstructor( size );
+
+		newArray.set( this.array );
+		this.array = newArray;
+		this.size = size;
+
+		return this;
+	}
+
+
+	/**
+	 * Perform a splice operation on this array's buffer.
+	 * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
+	 * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
+	 * @returns {Object} The SPE.TypedArrayHelper instance.
+	 */
+	splice( start, end ) {
+		const _start = start * this.componentSize,
+			_end = end * this.componentSize;
+
+		const data = [],
+			array = this.array,
+			size = array.length;
+
+		for ( let i = 0; i < size; ++i ) {
+			if ( i < _start || i >= _end ) {
+				data.push( array[ i ] );
+			}
+			// array[ i ] = 0;
+		}
+
+		this.setFromArray( 0, data );
+
+		return this;
+	}
+
+
+	/**
+	 * Copies from the given TypedArray into this one, using the index argument
+	 * as the start position. Alias for `TypedArray.set`. Will automatically resize
+	 * if the given source array is of a larger size than the internal array.
+	 *
+	 * @param {Number} index      The start position from which to copy into this array.
+	 * @param {TypedArray} array The array from which to copy; the source array.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setFromArray( index, array ) {
+		const sourceArraySize = array.length,
+			newSize = index + sourceArraySize;
+
+		if ( newSize > this.array.length ) {
+			this.grow( newSize );
+		}
+		else if ( newSize < this.array.length ) {
+			this.shrink( newSize );
+		}
+
+		this.array.set( array, this.indexOffset + index );
+
+		return this;
+	}
+
+	/**
+	 * Set a Vector2 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec2 values from.
+	 * @param {Vector2} vec2  Any object that has `x` and `y` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec2( index, vec2 ) {
+		return this.setVec2Components( index, vec2.x, vec2.y );
+	}
+
+	/**
+	 * Set a Vector2 value using raw components.
+	 *
+	 * @param {Number} index The index at which to set the vec2 values from.
+	 * @param {Number} x     The Vec2's `x` component.
+	 * @param {Number} y     The Vec2's `y` component.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec2Components( index, x, y ) {
+		const array = this.array,
+			i = this.indexOffset + ( index * this.componentSize );
+
+		array[ i ] = x;
+		array[ i + 1 ] = y;
+		return this;
+	}
+
+	/**
+	 * Set a Vector3 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Vector3} vec2  Any object that has `x`, `y`, and `z` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec3( index, vec3 ) {
+		return this.setVec3Components( index, vec3.x, vec3.y, vec3.z );
+	}
+
+	/**
+	 * Set a Vector3 value using raw components.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Number} x     The Vec3's `x` component.
+	 * @param {Number} y     The Vec3's `y` component.
+	 * @param {Number} z     The Vec3's `z` component.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec3Components( index, x, y, z ) {
+		const array = this.array,
+			i = this.indexOffset + ( index * this.componentSize );
+
+		array[ i ] = x;
+		array[ i + 1 ] = y;
+		array[ i + 2 ] = z;
+		return this;
+	}
+
+	/**
+	 * Set a Vector4 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec4 values from.
+	 * @param {Vector4} vec2  Any object that has `x`, `y`, `z`, and `w` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec4( index, vec4 ) {
+		return this.setVec4Components( index, vec4.x, vec4.y, vec4.z, vec4.w );
+	}
+
+	/**
+	 * Set a Vector4 value using raw components.
+	 *
+	 * @param {Number} index The index at which to set the vec4 values from.
+	 * @param {Number} x     The Vec4's `x` component.
+	 * @param {Number} y     The Vec4's `y` component.
+	 * @param {Number} z     The Vec4's `z` component.
+	 * @param {Number} w     The Vec4's `w` component.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec4Components( index, x, y, z, w ) {
+		const array = this.array,
+			i = this.indexOffset + ( index * this.componentSize );
+
+		array[ i ] = x;
+		array[ i + 1 ] = y;
+		array[ i + 2 ] = z;
+		array[ i + 3 ] = w;
+		return this;
+	}
+
+	/**
+	 * Set a Matrix3 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the matrix values from.
+	 * @param {Matrix3} mat3 The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setMat3( index, mat3 ) {
+		return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat3.elements );
+	}
+
+	/**
+	 * Set a Matrix4 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the matrix values from.
+	 * @param {Matrix4} mat3 The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setMat4( index, mat4 ) {
+		return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat4.elements );
+	}
+
+	/**
+	 * Set a Color value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Color} color  Any object that has `r`, `g`, and `b` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setColor( index, color ) {
+		return this.setVec3Components( index, color.r, color.g, color.b );
+	}
+
+	/**
+	 * Set a Number value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Number} numericValue  The number to assign to this index in the array.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setNumber( index, numericValue ) {
+		this.array[ this.indexOffset + ( index * this.componentSize ) ] = numericValue;
+		return this;
+	}
+
+	/**
+	 * Returns the value of the array at the given index, taking into account
+	 * the `indexOffset` property of this class.
+	 *
+	 * Note that this function ignores the component size and will just return a
+	 * single value.
+	 *
+	 * @param  {Number} index The index in the array to fetch.
+	 * @return {Number}       The value at the given index.
+	 */
+	getValueAtIndex( index ) {
+		return this.array[ this.indexOffset + index ];
+	}
+
+	/**
+	 * Returns the component value of the array at the given index, taking into account
+	 * the `indexOffset` property of this class.
+	 *
+	 * If the componentSize is set to 3, then it will return a new TypedArray
+	 * of length 3.
+	 *
+	 * @param  {Number} index The index in the array to fetch.
+	 * @return {TypedArray}       The component value at the given index.
+	 */
+	getComponentValueAtIndex( index ) {
+		return this.array.subarray( this.indexOffset + ( index * this.componentSize ) );
+	}
+}
+
+
+ + + + +
+ + + +
+ +
+ Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) +
+ + + + + diff --git a/docs/api/index.html b/docs/api/index.html index df42ea5..1bb4a95 100644 --- a/docs/api/index.html +++ b/docs/api/index.html @@ -50,13 +50,13 @@


- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) + Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time)
diff --git a/docs/api/SPE.utils.html b/docs/api/module.html#.exports similarity index 71% rename from docs/api/SPE.utils.html rename to docs/api/module.html#.exports index 6fa6a09..87d654c 100644 --- a/docs/api/SPE.utils.html +++ b/docs/api/module.html#.exports @@ -2,7 +2,7 @@ - JSDoc: Namespace: utils + JSDoc: Namespace: exports @@ -17,7 +17,7 @@
-

Namespace: utils

+

Namespace: exports

@@ -28,23 +28,938 @@

Namespace: utils

-

- SPE. +

exports

- utils - + +
+ +
+
+ + +
A bunch of utility functions used throughout the library.
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + +
+ + + + + + + + + + + + + + +

Members

+ + + +

(static) BOOLEAN :String

+ + + + +
+ Boolean type. +
+ + + +
Type:
+
    +
  • + +String + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) BOX :Number

+ + + + +
+ Values will be distributed within a box. +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 1
    • +
+ + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) c :Number

+ + + + +
+ Color +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 3
    • +
+ + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) DISC :Number

+ + + + +
+ Values will be distributed on a 2d-disc shape. +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 3
    • +
+ + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) f :Number

+ + + + +
+ Float +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 1
    • +
+ + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) LINE :Number

+ + + + +
+ Values will be distributed along a line. +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 4
    • +
+ + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) m3 :Number

+ + + + +
+ Mat3 +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 9
    • +
+ + + +
Source:
+
+ + + + + + + +
+ + + + + + + +

(static) m4 :Number

+ + + + +
+ Mat4 +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 16
    • +
+ + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) NUMBER :String

+ + + + +
+ Number type. +
+ + + +
Type:
+
    +
  • + +String + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) OBJECT :String

+ + + + +
+ Object type. +
+ + + +
Type:
+
    +
  • + +String + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
+ + + + + + + +
+ + + + + + + + +

(static) SPHERE :Number

+ + + + +
+ Values will be distributed on a sphere. +
+ + + +
Type:
+
    +
  • + +Number + + +
    • +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
Default Value:
+
    +
  • 2
    • +
- -
+ + + + + + +

(static) STRING :String

+ + + + +
+ String type. +
+ + + +
Type:
+
    +
  • + +String + + +
    • +
+ + +
@@ -76,7 +991,7 @@

Source:
@@ -88,33 +1003,19 @@

- - -
- - - - - - - - - -

Members

-

(static) types :String

+

(static) v2 :Number

- A map of types used by `SPE.utils.ensureTypedArg` and -`SPE.utils.ensureArrayTypedArg` to compare types against. + Vec2
@@ -123,7 +1024,7 @@
Type:
  • -String +Number
    • @@ -133,123 +1034,156 @@
    Type:
    -
    Properties:
    +
    - - - - - - + - + - + - + - - - + - - - - - + - + - + +
    Default Value:
    +
      +
    • 2
      • +
    + - + +
    Source:
    +
    + - - + - - - - + + - + + + +

    (static) v3 :Number

    + + + + +
    + Vec3 +
    + + +
    Type:
    +
      +
    • +Number -
    - + + + + + + + + +
    -
    - - - + - + - + - + - - + - - - - + - + +
    Source:
    +
    + + + + + + + + + + + + + + +

    (static) v4 :Number

    + + + + +
    + Vec4 +
    + + +
    Type:
    +
      +
    • +Number -
    - - - -
    NameTypeDescription
    BOOLEAN - - -String + + - - Boolean type.
    STRING - - -String - - String type.
    NUMBER - - -String + + - - Number type.
    OBJECT - - -String + + +
    Default Value:
    +
      +
    • 3
      • +
    + - -     		Object type.
    + +
+ @@ -278,12 +1212,17 @@
Properties:
+ +
Default Value:
+
    +
  • 4
    • +
Source:
@@ -310,7 +1249,9 @@

Methods

+

(static) arrayValuesAreEqual(array) → {Boolean}

+ @@ -410,7 +1351,7 @@
Parameters:
Source:
@@ -433,6 +1374,8 @@
Parameters:
+ +
Returns:
@@ -458,12 +1401,16 @@
Returns:
+ + +

(static) clamp(value, min, max) → {Number}

+ @@ -609,7 +1556,7 @@
Parameters:
Source:
@@ -632,6 +1579,8 @@
Parameters:
+ +
Returns:
@@ -657,12 +1606,16 @@
Returns:
+ + +

(static) ensureArrayInstanceOf(arg, instance, defaultValue) → {Object}

+ @@ -815,7 +1768,7 @@
Parameters:
Source:
@@ -838,6 +1791,8 @@
Parameters:
+ +
Returns:
@@ -863,12 +1818,16 @@
Returns:
+ + +

(static) ensureArrayTypedArg(arg, type, defaultValue) → {boolean|string|number|object}

+ @@ -1039,7 +1998,7 @@
Parameters:
Source:
@@ -1062,6 +2021,8 @@
Parameters:
+ +
Returns:
@@ -1096,12 +2057,16 @@
Returns:
+ + +

(static) ensureInstanceOf(arg, instance, defaultValue) → {Object}

+ @@ -1247,7 +2212,7 @@
Parameters:
Source:
@@ -1270,6 +2235,8 @@
Parameters:
+ +
Returns:
@@ -1295,12 +2262,16 @@
Returns:
+ + +

(static) ensureTypedArg(arg, type, defaultValue) → {boolean|string|number|object}

+ @@ -1466,7 +2437,7 @@
Parameters:
Source:
@@ -1489,6 +2460,8 @@
Parameters:
+ +
Returns:
@@ -1523,12 +2496,16 @@
Returns:
+ + +

(static) ensureValueOverLifetimeCompliance(property, minLength, maxLength)

+ @@ -1679,7 +2656,7 @@
Parameters:
Source:
@@ -1705,12 +2682,18 @@
Parameters:
+ + + + +

(static) interpolateArray(srcArray, newLength) → {Array}

+ @@ -1838,7 +2821,7 @@
Parameters:
Source:
@@ -1861,6 +2844,8 @@
Parameters:
+ +
Returns:
@@ -1886,12 +2871,16 @@
Returns:
+ + +

(static) lerp(start, end, delta) → {Number}

+ @@ -2037,7 +3026,7 @@
Parameters:
Source:
@@ -2060,6 +3049,8 @@
Parameters:
+ +
Returns:
@@ -2085,19 +3076,23 @@
Returns:
+ + +

(static) lerpTypeAgnostic(start, end, delta) → {number|object|undefined}

+
- Linearly interpolates two values of various types. The given values + Linearly interpolates two values of various valueTypes. The given values must be of the same type for the interpolation to work.
@@ -2243,7 +3238,7 @@
Parameters:
Source:
@@ -2266,6 +3261,8 @@
Parameters:
+ +
Returns:
@@ -2299,12 +3296,16 @@
Returns:
+ + +

(static) randomColor(attribute, index, base, spread)

+ @@ -2474,7 +3475,7 @@
Parameters:
Source:
@@ -2500,12 +3501,18 @@
Parameters:
+ + + + +

(static) randomFloat(base, spread) → {Number}

+ @@ -2629,7 +3636,7 @@
Parameters:
Source:
@@ -2652,6 +3659,8 @@
Parameters:
+ +
Returns:
@@ -2677,12 +3686,16 @@
Returns:
+ + +

(static) randomVector3(attribute, index, base, spread, spreadClamp)

+ @@ -2875,7 +3888,7 @@
Parameters:
Source:
@@ -2901,12 +3914,18 @@
Parameters:
+ + + + +

(static) randomVector3OnDisc(attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp)

+ @@ -3145,7 +4164,214 @@
Parameters:
Source:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

(static) randomVector3OnLine(attribute, index, start, end)

+ + + + + + +
+ Given an SPE.ShaderAttribute instance, and various other settings, +assign values to the attribute's array in a `vec3` format. +
+ + + + + + + + + +
Parameters:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
attribute + + +Object + + + + The instance of SPE.ShaderAttribute to save the result to.
index + + +Number + + + + The offset in the attribute's TypedArray to save the result from.
start + + +Object + + + + THREE.Vector3 instance describing the start line position.
end + + +Object + + + + THREE.Vector3 instance describing the end line position.
+ + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Source:
+
@@ -3171,12 +4397,18 @@
Parameters:
+ + + + +

(static) randomVector3OnSphere(attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp)

+ @@ -3415,7 +4647,7 @@
Parameters:
Source:
@@ -3441,12 +4673,18 @@
Parameters:
+ + + + +

(static) roundToNearestMultiple(n, multiple) → {Number}

+ @@ -3569,7 +4807,7 @@
Parameters:
Source:
@@ -3592,6 +4830,8 @@
Parameters:
+ +
Returns:
@@ -3617,12 +4857,16 @@
Returns:
+ + +

(static) zeroToEpsilon(value, randomise) → {Number}

+ @@ -3747,7 +4991,7 @@
Parameters:
Source:
@@ -3770,6 +5014,8 @@
Parameters:
+ +
Returns:
@@ -3795,6 +5041,8 @@
Returns:
+ + @@ -3811,13 +5059,13 @@
Returns:

- Documentation generated by JSDoc 3.3.3 on Sat Nov 14 2015 15:30:50 GMT+0000 (GMT) + Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time)
diff --git a/docs/api/scripts/linenumber.js b/docs/api/scripts/linenumber.js index 8d52f7e..4354785 100644 --- a/docs/api/scripts/linenumber.js +++ b/docs/api/scripts/linenumber.js @@ -1,12 +1,12 @@ /*global document */ -(function() { - var source = document.getElementsByClassName('prettyprint source linenums'); - var i = 0; - var lineNumber = 0; - var lineId; - var lines; - var totalLines; - var anchorHash; +(() => { + const source = document.getElementsByClassName('prettyprint source linenums'); + let i = 0; + let lineNumber = 0; + let lineId; + let lines; + let totalLines; + let anchorHash; if (source && source[0]) { anchorHash = document.location.hash.substring(1); @@ -15,7 +15,7 @@ for (; i < totalLines; i++) { lineNumber++; - lineId = 'line' + lineNumber; + lineId = `line${lineNumber}`; lines[i].id = lineId; if (lineId === anchorHash) { lines[i].className += ' selected'; diff --git a/docs/api/styles/jsdoc-default.css b/docs/api/styles/jsdoc-default.css index 24aa20f..7d1729d 100644 --- a/docs/api/styles/jsdoc-default.css +++ b/docs/api/styles/jsdoc-default.css @@ -78,6 +78,10 @@ article dl { margin-bottom: 40px; } +article img { + max-width: 100%; +} + section { display: block; @@ -153,7 +157,7 @@ h1 margin: 12px 24px 20px; } -h2, h3 +h2, h3.subsection-title { font-size: 30px; font-weight: 700; @@ -161,6 +165,13 @@ h2, h3 margin-bottom: 12px; } +h3 +{ + font-size: 24px; + letter-spacing: -0.5px; + margin-bottom: 12px; +} + h4 { font-size: 18px; @@ -185,8 +196,34 @@ h6 font-style: italic; } -.ancestors { color: #999; } -.ancestors a +table +{ + border-spacing: 0; + border: 0; + border-collapse: collapse; +} + +td, th +{ + border: 1px solid #ddd; + margin: 0px; + text-align: left; + vertical-align: top; + padding: 4px 6px; + display: table-cell; +} + +thead tr +{ + background-color: #ddd; + font-weight: bold; +} + +th { border-right: 1px solid #aaa; } +tr > th:last-child { border-right: 1px solid #ddd; } + +.ancestors, .attribs { color: #999; } +.ancestors a, .attribs a { color: #999 !important; text-decoration: none; @@ -236,7 +273,7 @@ h6 margin: 0; } -.prettyprint +.source { border: 1px solid #ddd; width: 80%; @@ -247,7 +284,7 @@ h6 width: inherit; } -.prettyprint code +.source code { font-size: 100%; line-height: 18px; @@ -296,44 +333,12 @@ h6 user-select: text; } -.params, .props -{ - border-spacing: 0; - border: 0; - border-collapse: collapse; -} - .params .name, .props .name, .name code { color: #4D4E53; font-family: Consolas, Monaco, 'Andale Mono', monospace; font-size: 100%; } -.params td, .params th, .props td, .props th -{ - border: 1px solid #ddd; - margin: 0px; - text-align: left; - vertical-align: top; - padding: 4px 6px; - display: table-cell; -} - -.params thead tr, .props thead tr -{ - background-color: #ddd; - font-weight: bold; -} - -.params .params thead tr, .props .props thead tr -{ - background-color: #fff; - font-weight: bold; -} - -.params th, .props th { border-right: 1px solid #aaa; } -.params thead .last, .props thead .last { border-right: 1px solid #ddd; } - .params td.description > p:first-child, .props td.description > p:first-child { diff --git a/docs/source/SPE.html b/docs/source/SPE.html deleted file mode 100644 index 28e8803..0000000 --- a/docs/source/SPE.html +++ /dev/null @@ -1,5342 +0,0 @@ - - - - - SPE.js - - - - - -
-
- -
    - -
  • -
    -

    SPE.js

    -
    -
    • - - - -
  • -
    - -
    - -
    - -
    - - 
    /* shader-particle-engine 1.0.3
- * 
- * (c) 2015 Luke Moody (http://www.github.com/squarefeet)
- *     Originally based on Lee Stemkoski's original work (https://github.com/stemkoski/stemkoski.github.com/blob/master/Three.js/js/ParticleEngine.js).
- *
- * shader-particle-engine may be freely distributed under the MIT license (See LICENSE at root of this repository.)
- */
-/**
- * @typedef {Number} distribution
- * @property {Number} SPE.distributions.BOX Values will be distributed within a box.
- * @property {Number} SPE.distributions.SPHERE Values will be distributed within a sphere.
- * @property {Number} SPE.distributions.DISC Values will be distributed within a 2D disc.
- */
-
-/**
- * Namespace for Shader Particle Engine.
- *
- * All SPE-related code sits under this namespace.
- *
- * @type {Object}
- * @namespace
- */
-var SPE = {
-
-    /**
-     * A map of supported distribution types used
-     * by SPE.Emitter instances.
-     *
-     * These distribution types can be applied to
-     * an emitter globally, which will affect the
-     * `position`, `velocity`, and `acceleration`
-     * value calculations for an emitter, or they
-     * can be applied on a per-property basis.
-     *
-     * @enum {Number}
-     */
-    distributions: {
-        /**
-         * Values will be distributed within a box.
-         * @type {Number}
-         */
-        BOX: 1,
-
-        /**
-         * Values will be distributed on a sphere.
-         * @type {Number}
-         */
-        SPHERE: 2,
-
-        /**
-         * Values will be distributed on a 2d-disc shape.
-         * @type {Number}
-         */
-        DISC: 3,
-    },
-
-
-    /**
-     * Set this value to however many 'steps' you
-     * want value-over-lifetime properties to have.
-     *
-     * It's adjustable to fix an interpolation problem:
-     *
-     * Assuming you specify an opacity value as [0, 1, 0]
-     *      and the `valueOverLifetimeLength` is 4, then the
-     *      opacity value array will be reinterpolated to
-     *      be [0, 0.66, 0.66, 0].
-     *   This isn't ideal, as particles would never reach
-     *   full opacity.
-     *
-     * NOTE:
-     *     This property affects the length of ALL
-     *       value-over-lifetime properties for ALL
-     *       emitters and ALL groups.
-     *
-     *     Only values >= 3 && <= 4 are allowed.
-     *
-     * @type {Number}
-     */
-    valueOverLifetimeLength: 4
-};
    - -
    • - - -
  • -
    - -
    - -
    -

    Module loader support:

    - -
    - - 
    if ( typeof define === 'function' && define.amd ) {
-    define( 'spe', SPE );
-}
-else if ( typeof exports !== 'undefined' && typeof module !== 'undefined' ) {
-    module.exports = SPE;
-}
-
-/**
- * A helper class for TypedArrays.
- *
- * Allows for easy resizing, assignment of various component-based
- * types (Vector2s, Vector3s, Vector4s, Mat3s, Mat4s),
- * as well as Colors (where components are `r`, `g`, `b`),
- * Numbers, and setting from other TypedArrays.
- *
- * @author Luke Moody
- * @constructor
- * @param {Function} TypedArrayConstructor The constructor to use (Float32Array, Uint8Array, etc.)
- * @param {Number} size                 The size of the array to create
- * @param {Number} componentSize        The number of components per-value (ie. 3 for a vec3, 9 for a Mat3, etc.)
- * @param {Number} indexOffset          The index in the array from which to start assigning values. Default `0` if none provided
- */
-SPE.TypedArrayHelper = function( TypedArrayConstructor, size, componentSize, indexOffset ) {
-    'use strict';
-
-    this.componentSize = componentSize || 1;
-    this.size = ( size || 1 );
-    this.TypedArrayConstructor = TypedArrayConstructor || Float32Array;
-    this.array = new TypedArrayConstructor( size * this.componentSize );
-    this.indexOffset = indexOffset || 0;
-};
-
-SPE.TypedArrayHelper.constructor = SPE.TypedArrayHelper;
-
-/**
- * Sets the size of the internal array.
- *
- * Delegates to `this.shrink` or `this.grow` depending on size
- * argument's relation to the current size of the internal array.
- *
- * Note that if the array is to be shrunk, data will be lost.
- *
- * @param {Number} size The new size of the array.
- */
-SPE.TypedArrayHelper.prototype.setSize = function( size, noComponentMultiply ) {
-    'use strict';
-
-    var currentArraySize = this.array.length;
-
-    if ( !noComponentMultiply ) {
-        size = size * this.componentSize;
-    }
-
-    if ( size < currentArraySize ) {
-        return this.shrink( size );
-    }
-    else if ( size > currentArraySize ) {
-        return this.grow( size );
-    }
-    else {
-        console.info( 'TypedArray is already of size:', size + '.', 'Will not resize.' );
-    }
-};
-
-/**
- * Shrinks the internal array.
- *
- * @param  {Number} size The new size of the typed array. Must be smaller than `this.array.length`.
- * @return {SPE.TypedArrayHelper}      Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.shrink = function( size ) {
-    'use strict';
-
-    this.array = this.array.subarray( 0, size );
-    this.size = size;
-    return this;
-};
-
-/**
- * Grows the internal array.
- * @param  {Number} size The new size of the typed array. Must be larger than `this.array.length`.
- * @return {SPE.TypedArrayHelper}      Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.grow = function( size ) {
-    'use strict';
-
-    var existingArray = this.array,
-        newArray = new this.TypedArrayConstructor( size );
-
-    newArray.set( existingArray );
-    this.array = newArray;
-    this.size = size;
-
-    return this;
-};
-
-
-/**
- * Perform a splice operation on this array's buffer.
- * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
- * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
- * @returns {Object} The SPE.TypedArrayHelper instance.
- */
-SPE.TypedArrayHelper.prototype.splice = function( start, end ) {
-    'use strict';
-    start *= this.componentSize;
-    end *= this.componentSize;
-
-    var data = [],
-        array = this.array,
-        size = array.length;
-
-    for ( var i = 0; i < size; ++i ) {
-        if ( i < start || i >= end ) {
-            data.push( array[ i ] );
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    array[ i ] = 0;

    - -
    - - 
        }
-
-    this.setFromArray( 0, data );
-
-    return this;
-};
-
-
-/**
- * Copies from the given TypedArray into this one, using the index argument
- * as the start position. Alias for `TypedArray.set`. Will automatically resize
- * if the given source array is of a larger size than the internal array.
- *
- * @param {Number} index      The start position from which to copy into this array.
- * @param {TypedArray} array The array from which to copy; the source array.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setFromArray = function( index, array ) {
-    'use strict';
-
-    var sourceArraySize = array.length,
-        newSize = index + sourceArraySize;
-
-    if ( newSize > this.array.length ) {
-        this.grow( newSize );
-    }
-    else if ( newSize < this.array.length ) {
-        this.shrink( newSize );
-    }
-
-    this.array.set( array, this.indexOffset + index );
-
-    return this;
-};
-
-/**
- * Set a Vector2 value at `index`.
- *
- * @param {Number} index The index at which to set the vec2 values from.
- * @param {Vector2} vec2  Any object that has `x` and `y` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec2 = function( index, vec2 ) {
-    'use strict';
-
-    return this.setVec2Components( index, vec2.x, vec2.y );
-};
-
-/**
- * Set a Vector2 value using raw components.
- *
- * @param {Number} index The index at which to set the vec2 values from.
- * @param {Number} x     The Vec2's `x` component.
- * @param {Number} y     The Vec2's `y` component.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec2Components = function( index, x, y ) {
-    'use strict';
-
-    var array = this.array,
-        i = this.indexOffset + ( index * this.componentSize );
-
-    array[ i ] = x;
-    array[ i + 1 ] = y;
-    return this;
-};
-
-/**
- * Set a Vector3 value at `index`.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Vector3} vec2  Any object that has `x`, `y`, and `z` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec3 = function( index, vec3 ) {
-    'use strict';
-
-    return this.setVec3Components( index, vec3.x, vec3.y, vec3.z );
-};
-
-/**
- * Set a Vector3 value using raw components.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Number} x     The Vec3's `x` component.
- * @param {Number} y     The Vec3's `y` component.
- * @param {Number} z     The Vec3's `z` component.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec3Components = function( index, x, y, z ) {
-    'use strict';
-
-    var array = this.array,
-        i = this.indexOffset + ( index * this.componentSize );
-
-    array[ i ] = x;
-    array[ i + 1 ] = y;
-    array[ i + 2 ] = z;
-    return this;
-};
-
-/**
- * Set a Vector4 value at `index`.
- *
- * @param {Number} index The index at which to set the vec4 values from.
- * @param {Vector4} vec2  Any object that has `x`, `y`, `z`, and `w` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec4 = function( index, vec4 ) {
-    'use strict';
-
-    return this.setVec4Components( index, vec4.x, vec4.y, vec4.z, vec4.w );
-};
-
-/**
- * Set a Vector4 value using raw components.
- *
- * @param {Number} index The index at which to set the vec4 values from.
- * @param {Number} x     The Vec4's `x` component.
- * @param {Number} y     The Vec4's `y` component.
- * @param {Number} z     The Vec4's `z` component.
- * @param {Number} w     The Vec4's `w` component.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setVec4Components = function( index, x, y, z, w ) {
-    'use strict';
-
-    var array = this.array,
-        i = this.indexOffset + ( index * this.componentSize );
-
-    array[ i ] = x;
-    array[ i + 1 ] = y;
-    array[ i + 2 ] = z;
-    array[ i + 3 ] = w;
-    return this;
-};
-
-/**
- * Set a Matrix3 value at `index`.
- *
- * @param {Number} index The index at which to set the matrix values from.
- * @param {Matrix3} mat3 The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setMat3 = function( index, mat3 ) {
-    'use strict';
-
-    return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat3.elements );
-};
-
-/**
- * Set a Matrix4 value at `index`.
- *
- * @param {Number} index The index at which to set the matrix values from.
- * @param {Matrix4} mat3 The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setMat4 = function( index, mat4 ) {
-    'use strict';
-
-    return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat4.elements );
-};
-
-/**
- * Set a Color value at `index`.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Color} color  Any object that has `r`, `g`, and `b` properties.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setColor = function( index, color ) {
-    'use strict';
-
-    return this.setVec3Components( index, color.r, color.g, color.b );
-};
-
-/**
- * Set a Number value at `index`.
- *
- * @param {Number} index The index at which to set the vec3 values from.
- * @param {Number} numericValue  The number to assign to this index in the array.
- * @return {SPE.TypedArrayHelper} Instance of this class.
- */
-SPE.TypedArrayHelper.prototype.setNumber = function( index, numericValue ) {
-    'use strict';
-
-    this.array[ this.indexOffset + ( index * this.componentSize ) ] = numericValue;
-    return this;
-};
-
-/**
- * Returns the value of the array at the given index, taking into account
- * the `indexOffset` property of this class.
- *
- * Note that this function ignores the component size and will just return a
- * single value.
- *
- * @param  {Number} index The index in the array to fetch.
- * @return {Number}       The value at the given index.
- */
-SPE.TypedArrayHelper.prototype.getValueAtIndex = function( index ) {
-    'use strict';
-
-    return this.array[ this.indexOffset + index ];
-};
-
-/**
- * Returns the component value of the array at the given index, taking into account
- * the `indexOffset` property of this class.
- *
- * If the componentSize is set to 3, then it will return a new TypedArray
- * of length 3.
- *
- * @param  {Number} index The index in the array to fetch.
- * @return {TypedArray}       The component value at the given index.
- */
-SPE.TypedArrayHelper.prototype.getComponentValueAtIndex = function( index ) {
-    'use strict';
-
-    return this.array.subarray( this.indexOffset + ( index * this.componentSize ) );
-};
-
-/**
- * A helper to handle creating and updating a THREE.BufferAttribute instance.
- *
- * @author  Luke Moody
- * @constructor
- * @param {String} type          The buffer attribute type. See SPE.ShaderAttribute.typeSizeMap for valid values.
- * @param {Boolean=} dynamicBuffer Whether this buffer attribute should be marked as dynamic or not.
- * @param {Function=} arrayType     A reference to a TypedArray constructor. Defaults to Float32Array if none provided.
- */
-SPE.ShaderAttribute = function( type, dynamicBuffer, arrayType ) {
-    'use strict';
-
-    var typeMap = SPE.ShaderAttribute.typeSizeMap;
-
-    this.type = typeof type === 'string' && typeMap.hasOwnProperty( type ) ? type : 'f';
-    this.componentSize = typeMap[ this.type ];
-    this.arrayType = arrayType || Float32Array;
-    this.typedArray = null;
-    this.bufferAttribute = null;
-    this.dynamicBuffer = !!dynamicBuffer;
-
-    this.updateMin = 0;
-    this.updateMax = 0;
-};
-
-SPE.ShaderAttribute.constructor = SPE.ShaderAttribute;
-
-/**
- * A map of uniform types to their component size.
- * @enum {Number}
- */
-SPE.ShaderAttribute.typeSizeMap = {
-    /**
-     * Float
-     * @type {Number}
-     */
-    f: 1,
-
-    /**
-     * Vec2
-     * @type {Number}
-     */
-    v2: 2,
-
-    /**
-     * Vec3
-     * @type {Number}
-     */
-    v3: 3,
-
-    /**
-     * Vec4
-     * @type {Number}
-     */
-    v4: 4,
-
-    /**
-     * Color
-     * @type {Number}
-     */
-    c: 3,
-
-    /**
-     * Mat3
-     * @type {Number}
-     */
-    m3: 9,
-
-    /**
-     * Mat4
-     * @type {Number}
-     */
-    m4: 16
-};
-
-/**
- * Calculate the minimum and maximum update range for this buffer attribute using
- * component size independant min and max values.
- *
- * @param {Number} min The start of the range to mark as needing an update.
- * @param {Number} max The end of the range to mark as needing an update.
- */
-SPE.ShaderAttribute.prototype.setUpdateRange = function( min, max ) {
-    'use strict';
-
-    this.updateMin = Math.min( min * this.componentSize, this.updateMin * this.componentSize );
-    this.updateMax = Math.max( max * this.componentSize, this.updateMax * this.componentSize );
-};
-
-/**
- * Calculate the number of indices that this attribute should mark as needing
- * updating. Also marks the attribute as needing an update.
- */
-SPE.ShaderAttribute.prototype.flagUpdate = function() {
-    'use strict';
-
-    var attr = this.bufferAttribute,
-        range = attr.updateRange;
-
-    range.offset = this.updateMin;
-    range.count = Math.min( ( this.updateMax - this.updateMin ) + this.componentSize, this.typedArray.array.length );
    - -
    • - - -
  • -
    - -
    - -
    -

    console.log( range.offset, range.count, this.typedArray.array.length ); -console.log( ‘flagUpdate:’, range.offset, range.count );

    - -
    - - 
        attr.needsUpdate = true;
-};
-
-
-
-/**
- * Reset the index update counts for this attribute
- */
-SPE.ShaderAttribute.prototype.resetUpdateRange = function() {
-    'use strict';
-
-    this.updateMin = 0;
-    this.updateMax = 0;
-};
-
-SPE.ShaderAttribute.prototype.resetDynamic = function() {
-    'use strict';
-    this.bufferAttribute.dynamic = this.dynamicBuffer;
-};
-
-/**
- * Perform a splice operation on this attribute's buffer.
- * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
- * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
- */
-SPE.ShaderAttribute.prototype.splice = function( start, end ) {
-    'use strict';
-
-    this.typedArray.splice( start, end );
    - -
    • - - -
  • -
    - -
    - -
    -

    Reset the reference to the attribute’s typed array -since it has probably changed.

    - -
    - - 
        this.forceUpdateAll();
-};
-
-SPE.ShaderAttribute.prototype.forceUpdateAll = function() {
-    'use strict';
-
-    this.bufferAttribute.array = this.typedArray.array;
-    this.bufferAttribute.updateRange.offset = 0;
-    this.bufferAttribute.updateRange.count = -1;
-    this.bufferAttribute.dynamic = false;
-    this.bufferAttribute.needsUpdate = true;
-};
-
-/**
- * Make sure this attribute has a typed array associated with it.
- *
- * If it does, then it will ensure the typed array is of the correct size.
- *
- * If not, a new SPE.TypedArrayHelper instance will be created.
- *
- * @param  {Number} size The size of the typed array to create or update to.
- */
-SPE.ShaderAttribute.prototype._ensureTypedArray = function( size ) {
-    'use strict';
    - -
    • - - -
  • -
    - -
    - -
    -

    Condition that’s most likely to be true at the top: no change.

    - -
    - - 
        if ( this.typedArray !== null && this.typedArray.size === size * this.componentSize ) {
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Resize the array if we need to, telling the TypedArrayHelper to -ignore it’s component size when evaluating size.

    - -
    - - 
        else if ( this.typedArray !== null && this.typedArray.size !== size ) {
-        this.typedArray.setSize( size );
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    This condition should only occur once in an attribute’s lifecycle.

    - -
    - - 
        else if ( this.typedArray === null ) {
-        this.typedArray = new SPE.TypedArrayHelper( this.arrayType, size, this.componentSize );
-    }
-};
-
-
-/**
- * Creates a THREE.BufferAttribute instance if one doesn't exist already.
- *
- * Ensures a typed array is present by calling _ensureTypedArray() first.
- *
- * If a buffer attribute exists already, then it will be marked as needing an update.
- *
- * @param  {Number} size The size of the typed array to create if one doesn't exist, or resize existing array to.
- */
-SPE.ShaderAttribute.prototype._createBufferAttribute = function( size ) {
-    'use strict';
    - -
    • - - -
  • -
    - -
    - -
    -

    Make sure the typedArray is present and correct.

    - -
    - - 
        this._ensureTypedArray( size );
    - -
    • - - -
  • -
    - -
    - -
    -

    Don’t create it if it already exists, but do -flag that it needs updating on the next render -cycle.

    - -
    - - 
        if ( this.bufferAttribute !== null ) {
-        this.bufferAttribute.array = this.typedArray.array;
-        this.bufferAttribute.needsUpdate = true;
-        return;
-    }
-
-    this.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize );
-    this.bufferAttribute.dynamic = this.dynamicBuffer;
-};
-
-/**
- * Returns the length of the typed array associated with this attribute.
- * @return {Number} The length of the typed array. Will be 0 if no typed array has been created yet.
- */
-SPE.ShaderAttribute.prototype.getLength = function() {
-    'use strict';
-
-    if ( this.typedArray === null ) {
-        return 0;
-    }
-
-    return this.typedArray.array.length;
-};
-
-SPE.shaderChunks = {
    - -
    • - - -
  • -
    - -
    - -
    -

    Register color-packing define statements.

    - -
    - - 
        defines: [
-        '#define PACKED_COLOR_SIZE 256.0',
-        '#define PACKED_COLOR_DIVISOR 255.0'
-    ].join( '\n' ),
    - -
    • - - -
  • -
    - -
    - -
    -

    All uniforms used by vertex / fragment shaders

    - -
    - - 
        uniforms: [
-        'uniform float deltaTime;',
-        'uniform float runTime;',
-        'uniform sampler2D texture;',
-        'uniform vec4 textureAnimation;',
-        'uniform float scale;',
-    ].join( '\n' ),
    - -
    • - - -
  • -
    - -
    - -
    -

    All attributes used by the vertex shader.

    -

    Note that some attributes are squashed into other ones:

    -
      -
    • Drag is acceleration.w
      • -
    - -
    - - 
        attributes: [
-        'attribute vec4 acceleration;',
-        'attribute vec3 velocity;',
-        'attribute vec4 rotation;',
-        'attribute vec3 rotationCenter;',
-        'attribute vec4 params;',
-        'attribute vec4 size;',
-        'attribute vec4 angle;',
-        'attribute vec4 color;',
-        'attribute vec4 opacity;'
-    ].join( '\n' ),
    - -
    • - - -
  • -
    - -
    - -
    - -
    - - 
        varyings: [
-        'varying vec4 vColor;',
-        '#ifdef SHOULD_ROTATE_TEXTURE',
-        '    varying float vAngle;',
-        '#endif',
-
-        '#ifdef SHOULD_CALCULATE_SPRITE',
-        '    varying vec4 vSpriteSheet;',
-        '#endif'
-    ].join( '\n' ),
    - -
    • - - -
  • -
    - -
    - -
    -

    Branch-avoiding comparison fns

    - - -
    - - 
        branchAvoidanceFunctions: [
-        'float when_gt(float x, float y) {',
-        '    return max(sign(x - y), 0.0);',
-        '}',
-
-        'float when_lt(float x, float y) {',
-        '    return min( max(1.0 - sign(x - y), 0.0), 1.0 );',
-        '}',
-
-        'float when_eq( float x, float y ) {',
-        '    return 1.0 - abs( sign( x - y ) );',
-        '}',
-
-        'float when_ge(float x, float y) {',
-        '  return 1.0 - when_lt(x, y);',
-        '}',
-
-        'float when_le(float x, float y) {',
-        '  return 1.0 - when_gt(x, y);',
-        '}',
    - -
    • - - -
  • -
    - -
    - -
    -

    Branch-avoiding logical operators -(to be used with above comparison fns)

    - -
    - - 
            'float and(float a, float b) {',
-        '    return a * b;',
-        '}',
-
-        'float or(float a, float b) {',
-        '    return min(a + b, 1.0);',
-        '}',
-    ].join( '\n' ),
    - -
    • - - -
  • -
    - -
    - -
    -

    From:

    - - -
    - - 
        unpackColor: [
-        'vec3 unpackColor( in float hex ) {',
-        '   vec3 c = vec3( 0.0 );',
-
-        '   float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
-        '   float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
-        '   float b = mod( hex, PACKED_COLOR_SIZE );',
-
-        '   c.r = r / PACKED_COLOR_DIVISOR;',
-        '   c.g = g / PACKED_COLOR_DIVISOR;',
-        '   c.b = b / PACKED_COLOR_DIVISOR;',
-
-        '   return c;',
-        '}',
-    ].join( '\n' ),
-
-    unpackRotationAxis: [
-        'vec3 unpackRotationAxis( in float hex ) {',
-        '   vec3 c = vec3( 0.0 );',
-
-        '   float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
-        '   float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
-        '   float b = mod( hex, PACKED_COLOR_SIZE );',
-
-        '   c.r = r / PACKED_COLOR_DIVISOR;',
-        '   c.g = g / PACKED_COLOR_DIVISOR;',
-        '   c.b = b / PACKED_COLOR_DIVISOR;',
-
-        '   c *= vec3( 2.0 );',
-        '   c -= vec3( 1.0 );',
-
-        '   return c;',
-        '}',
-    ].join( '\n' ),
-
-    floatOverLifetime: [
-        'float getFloatOverLifetime( in float positionInTime, in vec4 attr ) {',
-        '    highp float value = 0.0;',
-        '    float deltaAge = positionInTime * float( VALUE_OVER_LIFETIME_LENGTH - 1 );',
-        '    float fIndex = 0.0;',
-        '    float shouldApplyValue = 0.0;',
    - -
    • - - -
  • -
    - -
    - -
    -

    This might look a little odd, but it’s faster in the testing I’ve done than using branches. -Uses basic maths to avoid branching.

    -

    Take a look at the branch-avoidance functions defined above, -and be sure to check out The Orange Duck site where I got this -from (link above).

    - -
    - -
    • - - -
  • -
    - -
    - -
    -

    Fix for static emitters (age is always zero).

    - -
    - - 
            '    value += attr[ 0 ] * when_eq( deltaAge, 0.0 );',
-        '',
-        '    for( int i = 0; i < VALUE_OVER_LIFETIME_LENGTH - 1; ++i ) {',
-        '       fIndex = float( i );',
-        '       shouldApplyValue = and( when_gt( deltaAge, fIndex ), when_le( deltaAge, fIndex + 1.0 ) );',
-        '       value += shouldApplyValue * mix( attr[ i ], attr[ i + 1 ], deltaAge - fIndex );',
-        '    }',
-        '',
-        '    return value;',
-        '}',
-    ].join( '\n' ),
-
-    colorOverLifetime: [
-        'vec3 getColorOverLifetime( in float positionInTime, in vec3 color1, in vec3 color2, in vec3 color3, in vec3 color4 ) {',
-        '    vec3 value = vec3( 0.0 );',
-        '    value.x = getFloatOverLifetime( positionInTime, vec4( color1.x, color2.x, color3.x, color4.x ) );',
-        '    value.y = getFloatOverLifetime( positionInTime, vec4( color1.y, color2.y, color3.y, color4.y ) );',
-        '    value.z = getFloatOverLifetime( positionInTime, vec4( color1.z, color2.z, color3.z, color4.z ) );',
-        '    return value;',
-        '}',
-    ].join( '\n' ),
-
-    paramFetchingFunctions: [
-        'float getAlive() {',
-        '   return params.x;',
-        '}',
-
-        'float getAge() {',
-        '   return params.y;',
-        '}',
-
-        'float getMaxAge() {',
-        '   return params.z;',
-        '}',
-
-        'float getWiggle() {',
-        '   return params.w;',
-        '}',
-    ].join( '\n' ),
-
-    forceFetchingFunctions: [
-        'vec4 getPosition( in float age ) {',
-        '   return modelViewMatrix * vec4( position, 1.0 );',
-        '}',
-
-        'vec3 getVelocity( in float age ) {',
-        '   return velocity * age;',
-        '}',
-
-        'vec3 getAcceleration( in float age ) {',
-        '   return acceleration.xyz * age;',
-        '}',
-    ].join( '\n' ),
-
-
-    rotationFunctions: [
    - -
    • - - -
  • -
    - -
    - -
    -

    Huge thanks to:

    - - -
    - - 
            '#ifdef SHOULD_ROTATE_PARTICLES',
-        '   mat4 getRotationMatrix( in vec3 axis, in float angle) {',
-        '       axis = normalize(axis);',
-        '       float s = sin(angle);',
-        '       float c = cos(angle);',
-        '       float oc = 1.0 - c;',
-        '',
-        '       return mat4(oc * axis.x * axis.x + c,           oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s,  0.0,',
-        '                   oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s,  0.0,',
-        '                   oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c,           0.0,',
-        '                   0.0,                                0.0,                                0.0,                                1.0);',
-        '   }',
-        '',
-        '   vec3 getRotation( in vec3 pos, in float positionInTime ) {',
-        '      if( rotation.y == 0.0 ) {',
-        '           return pos;',
-        '      }',
-        '',
-        '      vec3 axis = unpackRotationAxis( rotation.x );',
-        '      vec3 center = rotationCenter;',
-        '      vec3 translated;',
-        '      mat4 rotationMatrix;',
-
-        '      float angle = 0.0;',
-        '      angle += when_eq( rotation.z, 0.0 ) * rotation.y;',
-        '      angle += when_gt( rotation.z, 0.0 ) * mix( 0.0, rotation.y, positionInTime );',
-        '      translated = rotationCenter - pos;',
-        '      rotationMatrix = getRotationMatrix( axis, angle );',
-        '      return center - vec3( rotationMatrix * vec4( translated, 0.0 ) );',
-        '   }',
-        '#endif'
-    ].join( '\n' ),
    - -
    • - - -
  • -
    - -
    - -
    -

    Fragment chunks

    - -
    - - 
        rotateTexture: [
-        '    vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );',
-        '',
-        '    #ifdef SHOULD_ROTATE_TEXTURE',
-        '       float x = gl_PointCoord.x - 0.5;',
-        '       float y = 1.0 - gl_PointCoord.y - 0.5;',
-        '       float c = cos( -vAngle );',
-        '       float s = sin( -vAngle );',
-
-        '       vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );',
-        '    #endif',
-        '',
    - -
    • - - -
  • -
    - -
    - -
    -

    Spritesheets overwrite angle calculations.

    - -
    - - 
            '    #ifdef SHOULD_CALCULATE_SPRITE',
-        '        float framesX = vSpriteSheet.x;',
-        '        float framesY = vSpriteSheet.y;',
-        '        float columnNorm = vSpriteSheet.z;',
-        '        float rowNorm = vSpriteSheet.w;',
-
-        '        vUv.x = gl_PointCoord.x * framesX + columnNorm;',
-        '        vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);',
-        '    #endif',
-
-        '',
-        '    vec4 rotatedTexture = texture2D( texture, vUv );',
-    ].join( '\n' )
-};
-
-SPE.shaders = {
-    vertex: [
-        SPE.shaderChunks.defines,
-        SPE.shaderChunks.uniforms,
-        SPE.shaderChunks.attributes,
-        SPE.shaderChunks.varyings,
-
-        THREE.ShaderChunk.common,
-        THREE.ShaderChunk.logdepthbuf_pars_vertex,
-
-        SPE.shaderChunks.branchAvoidanceFunctions,
-        SPE.shaderChunks.unpackColor,
-        SPE.shaderChunks.unpackRotationAxis,
-        SPE.shaderChunks.floatOverLifetime,
-        SPE.shaderChunks.colorOverLifetime,
-        SPE.shaderChunks.paramFetchingFunctions,
-        SPE.shaderChunks.forceFetchingFunctions,
-        SPE.shaderChunks.rotationFunctions,
-
-
-        'void main() {',
    - -
    • - - -
  • -
    - -
    - -
    -

    Setup…

    - -
    - - 
            '    highp float age = getAge();',
-        '    highp float alive = getAlive();',
-        '    highp float maxAge = getMaxAge();',
-        '    highp float positionInTime = (age / maxAge);',
-        '    highp float isAlive = when_gt( alive, 0.0 );',
-
-        '    #ifdef SHOULD_WIGGLE_PARTICLES',
-        '        float wiggleAmount = positionInTime * getWiggle();',
-        '        float wiggleSin = isAlive * sin( wiggleAmount );',
-        '        float wiggleCos = isAlive * cos( wiggleAmount );',
-        '    #endif',
    - -
    • - - -
  • -
    - -
    - -
    -

    Forces

    - -
    - -
    • - - -
  • -
    - -
    - -
    -

    Get forces & position

    - -
    - - 
            '    vec3 vel = getVelocity( age );',
-        '    vec3 accel = getAcceleration( age );',
-        '    vec3 force = vec3( 0.0 );',
-        '    vec3 pos = vec3( position );',
    - -
    • - - -
  • -
    - -
    - -
    -

    Calculate the required drag to apply to the forces.

    - -
    - - 
            '    float drag = 1.0 - (positionInTime * 0.5) * acceleration.w;',
    - -
    • - - -
  • -
    - -
    - -
    -

    Integrate forces…

    - -
    - - 
            '    force += vel;',
-        '    force *= drag;',
-        '    force += accel * age;',
-        '    pos += force;',
    - -
    • - - -
  • -
    - -
    - -
    -

    Wiggly wiggly wiggle!

    - -
    - - 
            '    #ifdef SHOULD_WIGGLE_PARTICLES',
-        '        pos.x += wiggleSin;',
-        '        pos.y += wiggleCos;',
-        '        pos.z += wiggleSin;',
-        '    #endif',
    - -
    • - - -
  • -
    - -
    - -
    -

    Rotate the emitter around it’s central point

    - -
    - - 
            '    #ifdef SHOULD_ROTATE_PARTICLES',
-        '        pos = getRotation( pos, positionInTime );',
-        '    #endif',
    - -
    • - - -
  • -
    - -
    - -
    -

    Convert pos to a world-space value

    - -
    - - 
            '    vec4 mvPos = modelViewMatrix * vec4( pos, 1.0 );',
    - -
    • - - -
  • -
    - -
    - -
    -

    Determine point size.

    - -
    - - 
            '    highp float pointSize = getFloatOverLifetime( positionInTime, size ) * isAlive;',
    - -
    • - - -
  • -
    - -
    - -
    -

    Determine perspective

    - -
    - - 
            '    #ifdef HAS_PERSPECTIVE',
-        '        float perspective = scale / length( mvPos.xyz );',
-        '    #else',
-        '        float perspective = 1.0;',
-        '    #endif',
    - -
    • - - -
  • -
    - -
    - -
    -

    Apply perpective to pointSize value

    - -
    - - 
            '    float pointSizePerspective = pointSize * perspective;',
    - -
    • - - -
  • -
    - -
    - -
    -

    Appearance

    - -
    - -
    • - - -
  • -
    - -
    - -
    -

    Determine color and opacity for this particle

    - -
    - - 
            '    #ifdef COLORIZE',
-        '       vec3 c = isAlive * getColorOverLifetime(',
-        '           positionInTime,',
-        '           unpackColor( color.x ),',
-        '           unpackColor( color.y ),',
-        '           unpackColor( color.z ),',
-        '           unpackColor( color.w )',
-        '       );',
-        '    #else',
-        '       vec3 c = vec3(1.0);',
-        '    #endif',
-
-        '    float o = isAlive * getFloatOverLifetime( positionInTime, opacity );',
    - -
    • - - -
  • -
    - -
    - -
    -

    Assign color to vColor varying.

    - -
    - - 
            '    vColor = vec4( c, o );',
    - -
    • - - -
  • -
    - -
    - -
    -

    Determine angle

    - -
    - - 
            '    #ifdef SHOULD_ROTATE_TEXTURE',
-        '        vAngle = isAlive * getFloatOverLifetime( positionInTime, angle );',
-        '    #endif',
    - -
    • - - -
  • -
    - -
    - -
    -

    If this particle is using a sprite-sheet as a texture, we’ll have to figure out -what frame of the texture the particle is using at it’s current position in time.

    - -
    - - 
            '    #ifdef SHOULD_CALCULATE_SPRITE',
-        '        float framesX = textureAnimation.x;',
-        '        float framesY = textureAnimation.y;',
-        '        float loopCount = textureAnimation.w;',
-        '        float totalFrames = textureAnimation.z;',
-        '        float frameNumber = mod( (positionInTime * loopCount) * totalFrames, totalFrames );',
-
-        '        float column = floor(mod( frameNumber, framesX ));',
-        '        float row = floor( (frameNumber - column) / framesX );',
-
-        '        float columnNorm = column / framesX;',
-        '        float rowNorm = row / framesY;',
-
-        '        vSpriteSheet.x = 1.0 / framesX;',
-        '        vSpriteSheet.y = 1.0 / framesY;',
-        '        vSpriteSheet.z = columnNorm;',
-        '        vSpriteSheet.w = rowNorm;',
-        '    #endif',
    - -
    • - - -
  • -
    - -
    - -
    -

    Write values

    - -
    - -
    • - - -
  • -
    - -
    - -
    -

    Set PointSize according to size at current point in time.

    - -
    - - 
            '    gl_PointSize = pointSizePerspective;',
-        '    gl_Position = projectionMatrix * mvPos;',
-
-        THREE.ShaderChunk.logdepthbuf_vertex,
-
-        '}'
-    ].join( '\n' ),
-
-    fragment: [
-        SPE.shaderChunks.uniforms,
-
-        THREE.ShaderChunk.common,
-        THREE.ShaderChunk.fog_pars_fragment,
-        THREE.ShaderChunk.logdepthbuf_pars_fragment,
-
-        SPE.shaderChunks.varyings,
-
-        SPE.shaderChunks.branchAvoidanceFunctions,
-
-        'void main() {',
-        '    vec3 outgoingLight = vColor.xyz;',
-        '    ',
-        '    #ifdef ALPHATEST',
-        '       if ( vColor.w < float(ALPHATEST) ) discard;',
-        '    #endif',
-
-        SPE.shaderChunks.rotateTexture,
-
-        THREE.ShaderChunk.logdepthbuf_fragment,
-
-        '    outgoingLight = vColor.xyz * rotatedTexture.xyz;',
-
-        THREE.ShaderChunk.fog_fragment,
-
-        '    gl_FragColor = vec4( outgoingLight.xyz, rotatedTexture.w * vColor.w );',
-        '}'
-    ].join( '\n' )
-};
-
-/**
- * A bunch of utility functions used throughout the library.
- * @namespace
- * @type {Object}
- */
-SPE.utils = {
-    /**
-     * A map of types used by `SPE.utils.ensureTypedArg` and
-     * `SPE.utils.ensureArrayTypedArg` to compare types against.
-     *
-     * @enum {String}
-     */
-    types: {
-        /**
-         * Boolean type.
-         * @type {String}
-         */
-        BOOLEAN: 'boolean',
-
-        /**
-         * String type.
-         * @type {String}
-         */
-        STRING: 'string',
-
-        /**
-         * Number type.
-         * @type {String}
-         */
-        NUMBER: 'number',
-
-        /**
-         * Object type.
-         * @type {String}
-         */
-        OBJECT: 'object'
-    },
-
-    /**
-     * Given a value, a type, and a default value to fallback to,
-     * ensure the given argument adheres to the type requesting,
-     * returning the default value if type check is false.
-     *
-     * @param  {(boolean|string|number|object)} arg          The value to perform a type-check on.
-     * @param  {String} type         The type the `arg` argument should adhere to.
-     * @param  {(boolean|string|number|object)} defaultValue A default value to fallback on if the type check fails.
-     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureTypedArg: function( arg, type, defaultValue ) {
-        'use strict';
-
-        if ( typeof arg === type ) {
-            return arg;
-        }
-        else {
-            return defaultValue;
-        }
-    },
-
-    /**
-     * Given an array of values, a type, and a default value,
-     * ensure the given array's contents ALL adhere to the provided type,
-     * returning the default value if type check fails.
-     *
-     * If the given value to check isn't an Array, delegates to SPE.utils.ensureTypedArg.
-     *
-     * @param  {Array|boolean|string|number|object} arg          The array of values to check type of.
-     * @param  {String} type         The type that should be adhered to.
-     * @param  {(boolean|string|number|object)} defaultValue A default fallback value.
-     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureArrayTypedArg: function( arg, type, defaultValue ) {
-        'use strict';
    - -
    • - - -
  • -
    - -
    - -
    -

    If the argument being checked is an array, loop through -it and ensure all the values are of the correct type, -falling back to the defaultValue if any aren’t.

    - -
    - - 
            if ( Array.isArray( arg ) ) {
-            for ( var i = arg.length - 1; i >= 0; --i ) {
-                if ( typeof arg[ i ] !== type ) {
-                    return defaultValue;
-                }
-            }
-
-            return arg;
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    If the arg isn’t an array then just fallback to -checking the type.

    - -
    - - 
            return this.ensureTypedArg( arg, type, defaultValue );
-    },
-
-    /**
-     * Ensures the given value is an instance of a constructor function.
-     *
-     * @param  {Object} arg          The value to check instance of.
-     * @param  {Function} instance     The constructor of the instance to check against.
-     * @param  {Object} defaultValue A default fallback value if instance check fails
-     * @return {Object}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureInstanceOf: function( arg, instance, defaultValue ) {
-        'use strict';
-
-        if ( instance !== undefined && arg instanceof instance ) {
-            return arg;
-        }
-        else {
-            return defaultValue;
-        }
-    },
-
-    /**
-     * Given an array of values, ensure the instances of all items in the array
-     * matches the given instance constructor falling back to a default value if
-     * the check fails.
-     *
-     * If given value isn't an Array, delegates to `SPE.utils.ensureInstanceOf`.
-     *
-     * @param  {Array|Object} arg          The value to perform the instanceof check on.
-     * @param  {Function} instance     The constructor of the instance to check against.
-     * @param  {Object} defaultValue A default fallback value if instance check fails
-     * @return {Object}              The given value if type check passes, or the default value if it fails.
-     */
-    ensureArrayInstanceOf: function( arg, instance, defaultValue ) {
-        'use strict';
    - -
    • - - -
  • -
    - -
    - -
    -

    If the argument being checked is an array, loop through -it and ensure all the values are of the correct type, -falling back to the defaultValue if any aren’t.

    - -
    - - 
            if ( Array.isArray( arg ) ) {
-            for ( var i = arg.length - 1; i >= 0; --i ) {
-                if ( instance !== undefined && arg[ i ] instanceof instance === false ) {
-                    return defaultValue;
-                }
-            }
-
-            return arg;
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    If the arg isn’t an array then just fallback to -checking the type.

    - -
    - - 
            return this.ensureInstanceOf( arg, instance, defaultValue );
-    },
-
-    /**
-     * Ensures that any "value-over-lifetime" properties of an emitter are
-     * of the correct length (as dictated by `SPE.valueOverLifetimeLength`).
-     *
-     * Delegates to `SPE.utils.interpolateArray` for array resizing.
-     *
-     * If properties aren't arrays, then property values are put into one.
-     *
-     * @param  {Object} property  The property of an SPE.Emitter instance to check compliance of.
-     * @param  {Number} minLength The minimum length of the array to create.
-     * @param  {Number} maxLength The maximum length of the array to create.
-     */
-    ensureValueOverLifetimeCompliance: function( property, minLength, maxLength ) {
-        'use strict';
-
-        minLength = minLength || 3;
-        maxLength = maxLength || 3;
    - -
    • - - -
  • -
    - -
    - -
    -

    First, ensure both properties are arrays.

    - -
    - - 
            if ( Array.isArray( property._value ) === false ) {
-            property._value = [ property._value ];
-        }
-
-        if ( Array.isArray( property._spread ) === false ) {
-            property._spread = [ property._spread ];
-        }
-
-        var valueLength = this.clamp( property._value.length, minLength, maxLength ),
-            spreadLength = this.clamp( property._spread.length, minLength, maxLength ),
-            desiredLength = Math.max( valueLength, spreadLength );
-
-        if ( property._value.length !== desiredLength ) {
-            property._value = this.interpolateArray( property._value, desiredLength );
-        }
-
-        if ( property._spread.length !== desiredLength ) {
-            property._spread = this.interpolateArray( property._spread, desiredLength );
-        }
-    },
-
-    /**
-     * Performs linear interpolation (lerp) on an array.
-     *
-     * For example, lerping [1, 10], with a `newLength` of 10 will produce [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
-     *
-     * Delegates to `SPE.utils.lerpTypeAgnostic` to perform the actual
-     * interpolation.
-     *
-     * @param  {Array} srcArray  The array to lerp.
-     * @param  {Number} newLength The length the array should be interpolated to.
-     * @return {Array}           The interpolated array.
-     */
-    interpolateArray: function( srcArray, newLength ) {
-        'use strict';
-
-        var sourceLength = srcArray.length,
-            newArray = [ typeof srcArray[ 0 ].clone === 'function' ? srcArray[ 0 ].clone() : srcArray[ 0 ] ],
-            factor = ( sourceLength - 1 ) / ( newLength - 1 );
-
-
-        for ( var i = 1; i < newLength - 1; ++i ) {
-            var f = i * factor,
-                before = Math.floor( f ),
-                after = Math.ceil( f ),
-                delta = f - before;
-
-            newArray[ i ] = this.lerpTypeAgnostic( srcArray[ before ], srcArray[ after ], delta );
-        }
-
-        newArray.push(
-            typeof srcArray[ sourceLength - 1 ].clone === 'function' ?
-            srcArray[ sourceLength - 1 ].clone() :
-            srcArray[ sourceLength - 1 ]
-        );
-
-        return newArray;
-    },
-
-    /**
-     * Clamp a number to between the given min and max values.
-     * @param  {Number} value The number to clamp.
-     * @param  {Number} min   The minimum value.
-     * @param  {Number} max   The maximum value.
-     * @return {Number}       The clamped number.
-     */
-    clamp: function( value, min, max ) {
-        'use strict';
-
-        return Math.max( min, Math.min( value, max ) );
-    },
-
-    /**
-     * If the given value is less than the epsilon value, then return
-     * a randomised epsilon value if specified, or just the epsilon value if not.
-     * Works for negative numbers as well as positive.
-     *
-     * @param  {Number} value     The value to perform the operation on.
-     * @param  {Boolean} randomise Whether the value should be randomised.
-     * @return {Number}           The result of the operation.
-     */
-    zeroToEpsilon: function( value, randomise ) {
-        'use strict';
-
-        var epsilon = 0.00001,
-            result = value;
-
-        result = randomise ? Math.random() * epsilon * 10 : epsilon;
-
-        if ( value < 0 && value > -epsilon ) {
-            result = -result;
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    if ( value === 0 ) { - result = randomise ? Math.random() epsilon 10 : epsilon; -} -else if ( value > 0 && value < epsilon ) { - result = randomise ? Math.random() epsilon 10 : epsilon; -} -else if ( value < 0 && value > -epsilon ) { - result = -( randomise ? Math.random() epsilon 10 : epsilon ); -}

    - -
    - - 
    -        return result;
-    },
-
-    /**
-     * Linearly interpolates two values of various types. The given values
-     * must be of the same type for the interpolation to work.
-     * @param  {(number|Object)} start The start value of the lerp.
-     * @param  {(number|object)} end   The end value of the lerp.
-     * @param  {Number} delta The delta posiiton of the lerp operation. Ideally between 0 and 1 (inclusive).
-     * @return {(number|object|undefined)}       The result of the operation. Result will be undefined if
-     *                                               the start and end arguments aren't a supported type, or
-     *                                               if their types do not match.
-     */
-    lerpTypeAgnostic: function( start, end, delta ) {
-        'use strict';
-
-        var types = this.types,
-            out;
-
-        if ( typeof start === types.NUMBER && typeof end === types.NUMBER ) {
-            return start + ( ( end - start ) * delta );
-        }
-        else if ( start instanceof THREE.Vector2 && end instanceof THREE.Vector2 ) {
-            out = start.clone();
-            out.x = this.lerp( start.x, end.x, delta );
-            out.y = this.lerp( start.y, end.y, delta );
-            return out;
-        }
-        else if ( start instanceof THREE.Vector3 && end instanceof THREE.Vector3 ) {
-            out = start.clone();
-            out.x = this.lerp( start.x, end.x, delta );
-            out.y = this.lerp( start.y, end.y, delta );
-            out.z = this.lerp( start.z, end.z, delta );
-            return out;
-        }
-        else if ( start instanceof THREE.Vector4 && end instanceof THREE.Vector4 ) {
-            out = start.clone();
-            out.x = this.lerp( start.x, end.x, delta );
-            out.y = this.lerp( start.y, end.y, delta );
-            out.z = this.lerp( start.z, end.z, delta );
-            out.w = this.lerp( start.w, end.w, delta );
-            return out;
-        }
-        else if ( start instanceof THREE.Color && end instanceof THREE.Color ) {
-            out = start.clone();
-            out.r = this.lerp( start.r, end.r, delta );
-            out.g = this.lerp( start.g, end.g, delta );
-            out.b = this.lerp( start.b, end.b, delta );
-            return out;
-        }
-        else {
-            console.warn( 'Invalid argument types, or argument types do not match:', start, end );
-        }
-    },
-
-    /**
-     * Perform a linear interpolation operation on two numbers.
-     * @param  {Number} start The start value.
-     * @param  {Number} end   The end value.
-     * @param  {Number} delta The position to interpolate to.
-     * @return {Number}       The result of the lerp operation.
-     */
-    lerp: function( start, end, delta ) {
-        'use strict';
-        return start + ( ( end - start ) * delta );
-    },
-
-    /**
-     * Rounds a number to a nearest multiple.
-     *
-     * @param  {Number} n        The number to round.
-     * @param  {Number} multiple The multiple to round to.
-     * @return {Number}          The result of the round operation.
-     */
-    roundToNearestMultiple: function( n, multiple ) {
-        'use strict';
-
-        var remainder = 0;
-
-        if ( multiple === 0 ) {
-            return n;
-        }
-
-        remainder = Math.abs( n ) % multiple;
-
-        if ( remainder === 0 ) {
-            return n;
-        }
-
-        if ( n < 0 ) {
-            return -( Math.abs( n ) - remainder );
-        }
-
-        return n + multiple - remainder;
-    },
-
-    /**
-     * Check if all items in an array are equal. Uses strict equality.
-     *
-     * @param  {Array} array The array of values to check equality of.
-     * @return {Boolean}       Whether the array's values are all equal or not.
-     */
-    arrayValuesAreEqual: function( array ) {
-        'use strict';
-
-        for ( var i = 0; i < array.length - 1; ++i ) {
-            if ( array[ i ] !== array[ i + 1 ] ) {
-                return false;
-            }
-        }
-
-        return true;
-    },
    - -
    • - - -
  • -
    - -
    - -
    -

    colorsAreEqual: function() { - var colors = Array.prototype.slice.call( arguments ), - numColors = colors.length;

    - -
    - -
    • - - -
  • -
    - -
    - -
    - 
    for ( var i = 0, color1, color2; i < numColors - 1; ++i ) {
-    color1 = colors[ i ];
-    color2 = colors[ i + 1 ];
-
    -
    - -
    • - - -
  • -
    - -
    - -
    - 
        if (
-        color1.r !== color2.r ||
-        color1.g !== color2.g ||
-        color1.b !== color2.b
-    ) {
-        return false
-    }
-}
-
    -
    - -
    • - - -
  • -
    - -
    - -
    - 
    return true;
-

    },

    - -
    - - 
    -
-    /**
-     * Given a start value and a spread value, create and return a random
-     * number.
-     * @param  {Number} base   The start value.
-     * @param  {Number} spread The size of the random variance to apply.
-     * @return {Number}        A randomised number.
-     */
-    randomFloat: function( base, spread ) {
-        'use strict';
-        return base + spread * ( Math.random() - 0.5 );
-    },
-
-
-
-    /**
-     * Given an SPE.ShaderAttribute instance, and various other settings,
-     * assign values to the attribute's array in a `vec3` format.
-     *
-     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base        THREE.Vector3 instance describing the start value.
-     * @param  {Object} spread      THREE.Vector3 instance describing the random variance to apply to the start value.
-     * @param  {Object} spreadClamp THREE.Vector3 instance describing the multiples to clamp the randomness to.
-     */
-    randomVector3: function( attribute, index, base, spread, spreadClamp ) {
-        'use strict';
-
-        var x = base.x + ( Math.random() * spread.x - ( spread.x * 0.5 ) ),
-            y = base.y + ( Math.random() * spread.y - ( spread.y * 0.5 ) ),
-            z = base.z + ( Math.random() * spread.z - ( spread.z * 0.5 ) );
    - -
    • - - -
  • -
    - -
    - -
    -

    var x = this.randomFloat( base.x, spread.x ), -y = this.randomFloat( base.y, spread.y ), -z = this.randomFloat( base.z, spread.z );

    - -
    - - 
    -        if ( spreadClamp ) {
-            x = -spreadClamp.x * 0.5 + this.roundToNearestMultiple( x, spreadClamp.x );
-            y = -spreadClamp.y * 0.5 + this.roundToNearestMultiple( y, spreadClamp.y );
-            z = -spreadClamp.z * 0.5 + this.roundToNearestMultiple( z, spreadClamp.z );
-        }
-
-        attribute.typedArray.setVec3Components( index, x, y, z );
-    },
-
-    /**
-     * Given an SPE.Shader attribute instance, and various other settings,
-     * assign Color values to the attribute.
-     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base      THREE.Color instance describing the start color.
-     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
-     */
-    randomColor: function( attribute, index, base, spread ) {
-        'use strict';
-
-        var r = base.r + ( Math.random() * spread.x ),
-            g = base.g + ( Math.random() * spread.y ),
-            b = base.b + ( Math.random() * spread.z );
-
-        r = this.clamp( r, 0, 1 );
-        g = this.clamp( g, 0, 1 );
-        b = this.clamp( b, 0, 1 );
-
-
-        attribute.typedArray.setVec3Components( index, r, g, b );
-    },
-
-
-    randomColorAsHex: ( function() {
-        'use strict';
-
-        var workingColor = new THREE.Color();
-
-        /**
-         * Assigns a random color value, encoded as a hex value in decimal
-         * format, to a SPE.ShaderAttribute instance.
-         * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-         * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-         * @param  {Object} base      THREE.Color instance describing the start color.
-         * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
-         */
-        return function( attribute, index, base, spread ) {
-            var numItems = base.length,
-                colors = [];
-
-            for ( var i = 0; i < numItems; ++i ) {
-                var spreadVector = spread[ i ];
-
-                workingColor.copy( base[ i ] );
-
-                workingColor.r += ( Math.random() * spreadVector.x ) - ( spreadVector.x * 0.5 );
-                workingColor.g += ( Math.random() * spreadVector.y ) - ( spreadVector.y * 0.5 );
-                workingColor.b += ( Math.random() * spreadVector.z ) - ( spreadVector.z * 0.5 );
-
-                workingColor.r = this.clamp( workingColor.r, 0, 1 );
-                workingColor.g = this.clamp( workingColor.g, 0, 1 );
-                workingColor.b = this.clamp( workingColor.b, 0, 1 );
-
-                colors.push( workingColor.getHex() );
-            }
-
-            attribute.typedArray.setVec4Components( index, colors[ 0 ], colors[ 1 ], colors[ 2 ], colors[ 3 ] );
-        };
-    }() ),
-
-    /**
-     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
-     * given values onto a sphere.
-     *
-     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
-     * @param  {Number} radius            The radius of the sphere to project onto.
-     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
-     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the sphere.
-     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
-     */
-    randomVector3OnSphere: function(
-        attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp, distributionClamp
-    ) {
-        'use strict';
-
-        var depth = 2 * Math.random() - 1,
-            t = 6.2832 * Math.random(),
-            r = Math.sqrt( 1 - depth * depth ),
-            rand = this.randomFloat( radius, radiusSpread ),
-            x = 0,
-            y = 0,
-            z = 0;
-
-
-        if ( radiusSpreadClamp ) {
-            rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    Set position on sphere

    - -
    - - 
            x = r * Math.cos( t ) * rand;
-        y = r * Math.sin( t ) * rand;
-        z = depth * rand;
    - -
    • - - -
  • -
    - -
    - -
    -

    Apply radius scale to this position

    - -
    - - 
            x *= radiusScale.x;
-        y *= radiusScale.y;
-        z *= radiusScale.z;
    - -
    • - - -
  • -
    - -
    - -
    -

    Translate to the base position.

    - -
    - - 
            x += base.x;
-        y += base.y;
-        z += base.z;
    - -
    • - - -
  • -
    - -
    - -
    -

    Set the values in the typed array.

    - -
    - - 
            attribute.typedArray.setVec3Components( index, x, y, z );
-    },
-
-    seededRandom: function( seed ) {
-        var x = Math.sin( seed ) * 10000;
-        return x - ( x | 0 );
-    },
-
-
-
-    /**
-     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
-     * given values onto a 2d-disc.
-     *
-     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
-     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
-     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
-     * @param  {Number} radius            The radius of the sphere to project onto.
-     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
-     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the disc. The z-component is ignored.
-     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
-     */
-    randomVector3OnDisc: function( attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp ) {
-        'use strict';
-
-        var t = 6.2832 * Math.random(),
-            rand = Math.abs( this.randomFloat( radius, radiusSpread ) ),
-            x = 0,
-            y = 0,
-            z = 0;
-
-        if ( radiusSpreadClamp ) {
-            rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    Set position on sphere

    - -
    - - 
            x = Math.cos( t ) * rand;
-        y = Math.sin( t ) * rand;
    - -
    • - - -
  • -
    - -
    - -
    -

    Apply radius scale to this position

    - -
    - - 
            x *= radiusScale.x;
-        y *= radiusScale.y;
    - -
    • - - -
  • -
    - -
    - -
    -

    Translate to the base position.

    - -
    - - 
            x += base.x;
-        y += base.y;
-        z += base.z;
    - -
    • - - -
  • -
    - -
    - -
    -

    Set the values in the typed array.

    - -
    - - 
            attribute.typedArray.setVec3Components( index, x, y, z );
-    },
-
-    randomDirectionVector3OnSphere: ( function() {
-        'use strict';
-
-        var v = new THREE.Vector3();
-
-        /**
-         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
-         * position, using `speed` as the magnitude. Values are saved to the attribute.
-         *
-         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
-         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
-         * @param  {Number} posX            The particle's x coordinate.
-         * @param  {Number} posY            The particle's y coordinate.
-         * @param  {Number} posZ            The particle's z coordinate.
-         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
-         * @param  {Number} speed           The magnitude to apply to the vector.
-         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
-         */
-        return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
-            v.copy( emitterPosition );
-
-            v.x -= posX;
-            v.y -= posY;
-            v.z -= posZ;
-
-            v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
-
-            attribute.typedArray.setVec3Components( index, v.x, v.y, v.z );
-        };
-    }() ),
-
-
-    randomDirectionVector3OnDisc: ( function() {
-        'use strict';
-
-        var v = new THREE.Vector3();
-
-        /**
-         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
-         * position, using `speed` as the magnitude. Values are saved to the attribute.
-         *
-         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
-         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
-         * @param  {Number} posX            The particle's x coordinate.
-         * @param  {Number} posY            The particle's y coordinate.
-         * @param  {Number} posZ            The particle's z coordinate.
-         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
-         * @param  {Number} speed           The magnitude to apply to the vector.
-         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
-         */
-        return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
-            v.copy( emitterPosition );
-
-            v.x -= posX;
-            v.y -= posY;
-            v.z -= posZ;
-
-            v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
-
-            attribute.typedArray.setVec3Components( index, v.x, v.y, 0 );
-        };
-    }() ),
-
-    getPackedRotationAxis: ( function() {
-        'use strict';
-
-        var v = new THREE.Vector3(),
-            vSpread = new THREE.Vector3(),
-            c = new THREE.Color(),
-            addOne = new THREE.Vector3( 1, 1, 1 );
-
-        /**
-         * Given a rotation axis, and a rotation axis spread vector,
-         * calculate a randomised rotation axis, and pack it into
-         * a hexadecimal value represented in decimal form.
-         * @param  {Object} axis       THREE.Vector3 instance describing the rotation axis.
-         * @param  {Object} axisSpread THREE.Vector3 instance describing the amount of randomness to apply to the rotation axis.
-         * @return {Number}            The packed rotation axis, with randomness.
-         */
-        return function( axis, axisSpread ) {
-            v.copy( axis ).normalize();
-            vSpread.copy( axisSpread ).normalize();
-
-            v.x += ( -axisSpread.x * 0.5 ) + ( Math.random() * axisSpread.x );
-            v.y += ( -axisSpread.y * 0.5 ) + ( Math.random() * axisSpread.y );
-            v.z += ( -axisSpread.z * 0.5 ) + ( Math.random() * axisSpread.z );
    - -
    • - - -
  • -
    - -
    - -
    -

    v.x = Math.abs( v.x ); -v.y = Math.abs( v.y ); -v.z = Math.abs( v.z );

    - -
    - - 
    -            v.normalize().add( addOne ).multiplyScalar( 0.5 );
-
-            c.setRGB( v.x, v.y, v.z );
-
-            return c.getHex();
-        };
-    }() )
-};
-
-/**
- * An SPE.Group instance.
- * @typedef {Object} Group
- * @see SPE.Group
- */
-
-/**
- * A map of options to configure an SPE.Group instance.
- * @typedef {Object} GroupOptions
- *
- * @property {Object} texture An object describing the texture used by the group.
- *
- * @property {Object} texture.value An instance of THREE.Texture.
- *
- * @property {Object=} texture.frames A THREE.Vector2 instance describing the number
- *                                    of frames on the x- and y-axis of the given texture.
- *                                    If not provided, the texture will NOT be treated as
- *                                    a sprite-sheet and as such will NOT be animated.
- *
- * @property {Number} [texture.frameCount=texture.frames.x * texture.frames.y] The total number of frames in the sprite-sheet.
- *                                                                   Allows for sprite-sheets that don't fill the entire
- *                                                                   texture.
- *
- * @property {Number} texture.loop The number of loops through the sprite-sheet that should
- *                                 be performed over the course of a single particle's lifetime.
- *
- * @property {Number} fixedTimeStep If no `dt` (or `deltaTime`) value is passed to this group's
- *                                  `tick()` function, this number will be used to move the particle
- *                                  simulation forward. Value in SECONDS.
- *
- * @property {Boolean} hasPerspective Whether the distance a particle is from the camera should affect
- *                                    the particle's size.
- *
- * @property {Boolean} colorize Whether the particles in this group should be rendered with color, or
- *                              whether the only color of particles will come from the provided texture.
- *
- * @property {Number} blending One of Three.js's blending modes to apply to this group's `ShaderMaterial`.
- *
- * @property {Boolean} transparent Whether these particle's should be rendered with transparency.
- *
- * @property {Number} alphaTest Sets the alpha value to be used when running an alpha test on the `texture.value` property. Value between 0 and 1.
- *
- * @property {Boolean} depthWrite Whether rendering the group has any effect on the depth buffer.
- *
- * @property {Boolean} depthTest Whether to have depth test enabled when rendering this group.
- *
- * @property {Boolean} fog Whether this group's particles should be affected by their scene's fog.
- *
- * @property {Number} scale The scale factor to apply to this group's particle sizes. Useful for
- *                          setting particle sizes to be relative to renderer size.
- */
-
-
-/**
- * The SPE.Group class. Creates a new group, containing a material, geometry, and mesh.
- *
- * @constructor
- * @param {GroupOptions} options A map of options to configure the group instance.
- */
-SPE.Group = function( options ) {
-    'use strict';
-
-    var utils = SPE.utils,
-        types = utils.types;
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure we have a map of options to play with

    - -
    - - 
        options = utils.ensureTypedArg( options, types.OBJECT, {} );
-    options.texture = utils.ensureTypedArg( options.texture, types.OBJECT, {} );
    - -
    • - - -
  • -
    - -
    - -
    -

    Assign a UUID to this instance

    - -
    - - 
        this.uuid = THREE.Math.generateUUID();
    - -
    • - - -
  • -
    - -
    - -
    -

    If no deltaTime value is passed to the SPE.Group.tick function, -the value of this property will be used to advance the simulation.

    - -
    - - 
        this.fixedTimeStep = utils.ensureTypedArg( options.fixedTimeStep, types.NUMBER, 0.016 );
    - -
    • - - -
  • -
    - -
    - -
    -

    Set properties used in the uniforms map, starting with the -texture stuff.

    - -
    - - 
        this.texture = utils.ensureInstanceOf( options.texture.value, THREE.Texture, null );
-    this.textureFrames = utils.ensureInstanceOf( options.texture.frames, THREE.Vector2, new THREE.Vector2( 1, 1 ) );
-    this.textureFrameCount = utils.ensureTypedArg( options.texture.frameCount, types.NUMBER, this.textureFrames.x * this.textureFrames.y );
-    this.textureLoop = utils.ensureTypedArg( options.texture.loop, types.NUMBER, 1 );
-    this.textureFrames.max( new THREE.Vector2( 1, 1 ) );
-
-    this.hasPerspective = utils.ensureTypedArg( options.hasPerspective, types.BOOLEAN, true );
-    this.colorize = utils.ensureTypedArg( options.colorize, types.BOOLEAN, true );
-
-    this.maxParticleCount = utils.ensureTypedArg( options.maxParticleCount, types.NUMBER, null );
    - -
    • - - -
  • -
    - -
    - -
    -

    Set properties used to define the ShaderMaterial’s appearance.

    - -
    - - 
        this.blending = utils.ensureTypedArg( options.blending, types.NUMBER, THREE.AdditiveBlending );
-    this.transparent = utils.ensureTypedArg( options.transparent, types.BOOLEAN, true );
-    this.alphaTest = parseFloat( utils.ensureTypedArg( options.alphaTest, types.NUMBER, 0.0 ) );
-    this.depthWrite = utils.ensureTypedArg( options.depthWrite, types.BOOLEAN, false );
-    this.depthTest = utils.ensureTypedArg( options.depthTest, types.BOOLEAN, true );
-    this.fog = utils.ensureTypedArg( options.fog, types.BOOLEAN, true );
-    this.scale = utils.ensureTypedArg( options.scale, types.NUMBER, 300 );
    - -
    • - - -
  • -
    - -
    - -
    -

    Where emitter’s go to curl up in a warm blanket and live -out their days.

    - -
    - - 
        this.emitters = [];
-    this.emitterIDs = [];
    - -
    • - - -
  • -
    - -
    - -
    -

    Create properties for use by the emitter pooling functions.

    - -
    - - 
        this._pool = [];
-    this._poolCreationSettings = null;
-    this._createNewWhenPoolEmpty = 0;
    - -
    • - - -
  • -
    - -
    - -
    -

    Whether all attributes should be forced to updated -their entire buffer contents on the next tick.

    -

    Used when an emitter is removed.

    - -
    - - 
        this._attributesNeedRefresh = false;
-    this._attributesNeedDynamicReset = false;
-
-    this.particleCount = 0;
    - -
    • - - -
  • -
    - -
    - -
    -

    Map of uniforms to be applied to the ShaderMaterial instance.

    - -
    - - 
        this.uniforms = {
-        texture: {
-            type: 't',
-            value: this.texture
-        },
-        textureAnimation: {
-            type: 'v4',
-            value: new THREE.Vector4(
-                this.textureFrames.x,
-                this.textureFrames.y,
-                this.textureFrameCount,
-                Math.max( Math.abs( this.textureLoop ), 1.0 )
-            )
-        },
-        fogColor: {
-            type: 'c',
-            value: null
-        },
-        fogNear: {
-            type: 'f',
-            value: 10
-        },
-        fogFar: {
-            type: 'f',
-            value: 200
-        },
-        fogDensity: {
-            type: 'f',
-            value: 0.5
-        },
-        deltaTime: {
-            type: 'f',
-            value: 0
-        },
-        runTime: {
-            type: 'f',
-            value: 0
-        },
-        scale: {
-            type: 'f',
-            value: this.scale
-        }
-    };
    - -
    • - - -
  • -
    - -
    - -
    -

    Add some defines into the mix…

    - -
    - - 
        this.defines = {
-        HAS_PERSPECTIVE: this.hasPerspective,
-        COLORIZE: this.colorize,
-        VALUE_OVER_LIFETIME_LENGTH: SPE.valueOverLifetimeLength,
-
-        SHOULD_ROTATE_TEXTURE: false,
-        SHOULD_ROTATE_PARTICLES: false,
-        SHOULD_WIGGLE_PARTICLES: false,
-
-        SHOULD_CALCULATE_SPRITE: this.textureFrames.x > 1 || this.textureFrames.y > 1
-    };
    - -
    • - - -
  • -
    - -
    - -
    -

    Map of all attributes to be applied to the particles.

    -

    See SPE.ShaderAttribute for a bit more info on this bit.

    - -
    - - 
        this.attributes = {
-        position: new SPE.ShaderAttribute( 'v3', true ),
-        acceleration: new SPE.ShaderAttribute( 'v4', true ), // w component is drag
-        velocity: new SPE.ShaderAttribute( 'v3', true ),
-        rotation: new SPE.ShaderAttribute( 'v4', true ),
-        rotationCenter: new SPE.ShaderAttribute( 'v3', true ),
-        params: new SPE.ShaderAttribute( 'v4', true ), // Holds (alive, age, delay, wiggle)
-        size: new SPE.ShaderAttribute( 'v4', true ),
-        angle: new SPE.ShaderAttribute( 'v4', true ),
-        color: new SPE.ShaderAttribute( 'v4', true ),
-        opacity: new SPE.ShaderAttribute( 'v4', true )
-    };
-
-    this.attributeKeys = Object.keys( this.attributes );
-    this.attributeCount = this.attributeKeys.length;
    - -
    • - - -
  • -
    - -
    - -
    -

    Create the ShaderMaterial instance that’ll help render the -particles.

    - -
    - - 
        this.material = new THREE.ShaderMaterial( {
-        uniforms: this.uniforms,
-        vertexShader: SPE.shaders.vertex,
-        fragmentShader: SPE.shaders.fragment,
-        blending: this.blending,
-        transparent: this.transparent,
-        alphaTest: this.alphaTest,
-        depthWrite: this.depthWrite,
-        depthTest: this.depthTest,
-        defines: this.defines,
-        fog: this.fog
-    } );
    - -
    • - - -
  • -
    - -
    - -
    -

    Create the BufferGeometry and Points instances, ensuring -the geometry and material are given to the latter.

    - -
    - - 
        this.geometry = new THREE.BufferGeometry();
-    this.mesh = new THREE.Points( this.geometry, this.material );
-
-    if ( this.maxParticleCount === null ) {
-        console.warn( 'SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.' );
-    }
-};
-
-SPE.Group.constructor = SPE.Group;
-
-
-SPE.Group.prototype._updateDefines = function() {
-    'use strict';
-
-    var emitters = this.emitters,
-        i = emitters.length - 1,
-        emitter,
-        defines = this.defines;
-
-    for ( i; i >= 0; --i ) {
-        emitter = emitters[ i ];
    - -
    • - - -
  • -
    - -
    - -
    -

    Only do angle calculation if there’s no spritesheet defined.

    -

    Saves calculations being done and then overwritten in the shaders.

    - -
    - - 
            if ( !defines.SHOULD_CALCULATE_SPRITE ) {
-            defines.SHOULD_ROTATE_TEXTURE = defines.SHOULD_ROTATE_TEXTURE || !!Math.max(
-                Math.max.apply( null, emitter.angle.value ),
-                Math.max.apply( null, emitter.angle.spread )
-            );
-        }
-
-        defines.SHOULD_ROTATE_PARTICLES = defines.SHOULD_ROTATE_PARTICLES || !!Math.max(
-            emitter.rotation.angle,
-            emitter.rotation.angleSpread
-        );
-
-        defines.SHOULD_WIGGLE_PARTICLES = defines.SHOULD_WIGGLE_PARTICLES || !!Math.max(
-            emitter.wiggle.value,
-            emitter.wiggle.spread
-        );
-    }
-
-    this.material.needsUpdate = true;
-};
-
-SPE.Group.prototype._applyAttributesToGeometry = function() {
-    'use strict';
-
-    var attributes = this.attributes,
-        geometry = this.geometry,
-        geometryAttributes = geometry.attributes,
-        attribute,
-        geometryAttribute;
    - -
    • - - -
  • -
    - -
    - -
    -

    Loop through all the shader attributes and assign (or re-assign) -typed array buffers to each one.

    - -
    - - 
        for ( var attr in attributes ) {
-        if ( attributes.hasOwnProperty( attr ) ) {
-            attribute = attributes[ attr ];
-            geometryAttribute = geometryAttributes[ attr ];
    - -
    • - - -
  • -
    - -
    - -
    -

    Update the array if this attribute exists on the geometry.

    -

    This needs to be done because the attribute’s typed array might have -been resized and reinstantiated, and might now be looking at a -different ArrayBuffer, so reference needs updating.

    - -
    - - 
                if ( geometryAttribute ) {
-                geometryAttribute.array = attribute.typedArray.array;
-            }
    - -
    • - - -
  • -
    - -
    - -
    -

    // Add the attribute to the geometry if it doesn’t already exist.

    - -
    - - 
                else {
-                geometry.addAttribute( attr, attribute.bufferAttribute );
-            }
    - -
    • - - -
  • -
    - -
    - -
    -

    Mark the attribute as needing an update the next time a frame is rendered.

    - -
    - - 
                attribute.bufferAttribute.needsUpdate = true;
-        }
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Mark the draw range on the geometry. This will ensure -only the values in the attribute buffers that are -associated with a particle will be used in THREE’s -render cycle.

    - -
    - - 
        this.geometry.setDrawRange( 0, this.particleCount );
-};
-
-/**
- * Adds an SPE.Emitter instance to this group, creating particle values and
- * assigning them to this group's shader attributes.
- *
- * @param {Emitter} emitter The emitter to add to this group.
- */
-SPE.Group.prototype.addEmitter = function( emitter ) {
-    'use strict';
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure an actual emitter instance is passed here.

    -

    Decided not to throw here, just in case a scene’s -rendering would be paused. Logging an error instead -of stopping execution if exceptions aren’t caught.

    - -
    - - 
        if ( emitter instanceof SPE.Emitter === false ) {
-        console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter );
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    If the emitter already exists as a member of this group, then -stop here, we don’t want to add it again.

    - -
    - - 
        else if ( this.emitterIDs.indexOf( emitter.uuid ) > -1 ) {
-        console.error( 'Emitter already exists in this group. Will not add again.' );
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    And finally, if the emitter is a member of another group, -don’t add it to this group.

    - -
    - - 
        else if ( emitter.group !== null ) {
-        console.error( 'Emitter already belongs to another group. Will not add to requested group.' );
-        return;
-    }
-
-    var attributes = this.attributes,
-        start = this.particleCount,
-        end = start + emitter.particleCount;
    - -
    • - - -
  • -
    - -
    - -
    -

    Update this group’s particle count.

    - -
    - - 
        this.particleCount = end;
    - -
    • - - -
  • -
    - -
    - -
    -

    Emit a warning if the emitter being added will exceed the buffer sizes specified.

    - -
    - - 
        if ( this.maxParticleCount !== null && this.particleCount > this.maxParticleCount ) {
-        console.warn( 'SPE.Group: maxParticleCount exceeded. Requesting', this.particleCount, 'particles, can support only', this.maxParticleCount );
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Set the particlesPerSecond value (PPS) on the emitter. -It’s used to determine how many particles to release -on a per-frame basis.

    - -
    - - 
        emitter._calculatePPSValue( emitter.maxAge._value + emitter.maxAge._spread );
-    emitter._setBufferUpdateRanges( this.attributeKeys );
    - -
    • - - -
  • -
    - -
    - -
    -

    Store the offset value in the TypedArray attributes for this emitter.

    - -
    - - 
        emitter._setAttributeOffset( start );
    - -
    • - - -
  • -
    - -
    - -
    -

    Save a reference to this group on the emitter so it knows -where it belongs.

    - -
    - - 
        emitter.group = this;
    - -
    • - - -
  • -
    - -
    - -
    -

    Store reference to the attributes on the emitter for -easier access during the emitter’s tick function.

    - -
    - - 
        emitter.attributes = this.attributes;
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure the attributes and their BufferAttributes exist, and their -TypedArrays are of the correct size.

    - -
    - - 
        for ( var attr in attributes ) {
-        if ( attributes.hasOwnProperty( attr ) ) {
    - -
    • - - -
  • -
    - -
    - -
    -

    When creating a buffer, pass through the maxParticle count -if one is specified.

    - -
    - - 
                attributes[ attr ]._createBufferAttribute(
-                this.maxParticleCount !== null ?
-                this.maxParticleCount :
-                this.particleCount
-            );
-        }
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Loop through each particle this emitter wants to have, and create the attributes values, -storing them in the TypedArrays that each attribute holds.

    - -
    - - 
        for ( var i = start; i < end; ++i ) {
-        emitter._assignPositionValue( i );
-        emitter._assignForceValue( i, 'velocity' );
-        emitter._assignForceValue( i, 'acceleration' );
-        emitter._assignAbsLifetimeValue( i, 'opacity' );
-        emitter._assignAbsLifetimeValue( i, 'size' );
-        emitter._assignAngleValue( i );
-        emitter._assignRotationValue( i );
-        emitter._assignParamsValue( i );
-        emitter._assignColorValue( i );
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Update the geometry and make sure the attributes are referencing -the typed arrays properly.

    - -
    - - 
        this._applyAttributesToGeometry();
    - -
    • - - -
  • -
    - -
    - -
    -

    Store this emitter in this group’s emitter’s store.

    - -
    - - 
        this.emitters.push( emitter );
-    this.emitterIDs.push( emitter.uuid );
    - -
    • - - -
  • -
    - -
    - -
    -

    Update certain flags to enable shader calculations only if they’re necessary.

    - -
    - - 
        this._updateDefines( emitter );
    - -
    • - - -
  • -
    - -
    - -
    -

    Update the material since defines might have changed

    - -
    - - 
        this.material.needsUpdate = true;
-    this.geometry.needsUpdate = true;
-    this._attributesNeedRefresh = true;
    - -
    • - - -
  • -
    - -
    - -
    -

    Return the group to enable chaining.

    - -
    - - 
        return this;
-};
-
-/**
- * Removes an SPE.Emitter instance from this group. When called,
- * all particle's belonging to the given emitter will be instantly
- * removed from the scene.
- *
- * @param {Emitter} emitter The emitter to add to this group.
- */
-SPE.Group.prototype.removeEmitter = function( emitter ) {
-    'use strict';
-
-    var emitterIndex = this.emitterIDs.indexOf( emitter.uuid );
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure an actual emitter instance is passed here.

    -

    Decided not to throw here, just in case a scene’s -rendering would be paused. Logging an error instead -of stopping execution if exceptions aren’t caught.

    - -
    - - 
        if ( emitter instanceof SPE.Emitter === false ) {
-        console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter );
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Issue an error if the emitter isn’t a member of this group.

    - -
    - - 
        else if ( emitterIndex === -1 ) {
-        console.error( 'Emitter does not exist in this group. Will not remove.' );
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Kill all particles by marking them as dead -and their age as 0.

    - -
    - - 
        var start = emitter.attributeOffset,
-        end = start + emitter.particleCount,
-        params = this.attributes.params.typedArray;
    - -
    • - - -
  • -
    - -
    - -
    -

    Set alive and age to zero.

    - -
    - - 
        for ( var i = start; i < end; ++i ) {
-        params.array[ i * 4 ] = 0.0;
-        params.array[ i * 4 + 1 ] = 0.0;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Remove the emitter from this group’s “store”.

    - -
    - - 
        this.emitters.splice( emitterIndex, 1 );
-    this.emitterIDs.splice( emitterIndex, 1 );
    - -
    • - - -
  • -
    - -
    - -
    -

    Remove this emitter’s attribute values from all shader attributes. -The .splice() call here also marks each attribute’s buffer -as needing to update it’s entire contents.

    - -
    - - 
        for ( var attr in this.attributes ) {
-        if ( this.attributes.hasOwnProperty( attr ) ) {
-            this.attributes[ attr ].splice( start, end );
-        }
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure this group’s particle count is correct.

    - -
    - - 
        this.particleCount -= emitter.particleCount;
    - -
    • - - -
  • -
    - -
    - -
    -

    Call the emitter’s remove method.

    - -
    - - 
        emitter._onRemove();
    - -
    • - - -
  • -
    - -
    - -
    -

    Set a flag to indicate that the attribute buffers should -be updated in their entirety on the next frame.

    - -
    - - 
        this._attributesNeedRefresh = true;
-};
-
-
-/**
- * Fetch a single emitter instance from the pool.
- * If there are no objects in the pool, a new emitter will be
- * created if specified.
- *
- * @return {Emitter|null}
- */
-SPE.Group.prototype.getFromPool = function() {
-    'use strict';
-
-    var pool = this._pool,
-        createNew = this._createNewWhenPoolEmpty;
-
-    if ( pool.length ) {
-        return pool.pop();
-    }
-    else if ( createNew ) {
-        return new SPE.Emitter( this._poolCreationSettings );
-    }
-
-    return null;
-};
-
-
-/**
- * Release an emitter into the pool.
- *
- * @param  {ShaderParticleEmitter} emitter
- * @return {Group} This group instance.
- */
-SPE.Group.prototype.releaseIntoPool = function( emitter ) {
-    'use strict';
-
-    if ( emitter instanceof SPE.Emitter === false ) {
-        console.error( 'Argument is not instanceof SPE.Emitter:', emitter );
-        return;
-    }
-
-    emitter.reset();
-    this._pool.unshift( emitter );
-
-    return this;
-};
-
-
-/**
- * Get the pool array
- *
- * @return {Array}
- */
-SPE.Group.prototype.getPool = function() {
-    'use strict';
-    return this._pool;
-};
-
-
-/**
- * Add a pool of emitters to this particle group
- *
- * @param {Number} numEmitters      The number of emitters to add to the pool.
- * @param {EmitterOptions|Array} emitterOptions  An object, or array of objects, describing the options to pass to each emitter.
- * @param {Boolean} createNew       Should a new emitter be created if the pool runs out?
- * @return {Group} This group instance.
- */
-SPE.Group.prototype.addPool = function( numEmitters, emitterOptions, createNew ) {
-    'use strict';
-
-    var emitter;
    - -
    • - - -
  • -
    - -
    - -
    -

    Save relevant settings and flags.

    - -
    - - 
        this._poolCreationSettings = emitterOptions;
-    this._createNewWhenPoolEmpty = !!createNew;
    - -
    • - - -
  • -
    - -
    - -
    -

    Create the emitters, add them to this group and the pool.

    - -
    - - 
        for ( var i = 0; i < numEmitters; ++i ) {
-        if ( Array.isArray( emitterOptions ) ) {
-            emitter = new SPE.Emitter( emitterOptions[ i ] );
-        }
-        else {
-            emitter = new SPE.Emitter( emitterOptions );
-        }
-        this.addEmitter( emitter );
-        this.releaseIntoPool( emitter );
-    }
-
-    return this;
-};
-
-
-
-SPE.Group.prototype._triggerSingleEmitter = function( pos ) {
-    'use strict';
-
-    var emitter = this.getFromPool(),
-        self = this;
-
-    if ( emitter === null ) {
-        console.log( 'SPE.Group pool ran out.' );
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    TODO:

    -
      -
    • Make sure buffers are update with thus new position.
      • -
    - -
    - - 
        if ( pos instanceof THREE.Vector3 ) {
-        emitter.position.value.copy( pos );
    - -
    • - - -
  • -
    - -
    - -
    -

    Trigger the setter for this property to force an -update to the emitter’s position attribute.

    - -
    - - 
            emitter.position.value = emitter.position.value;
-    }
-
-    emitter.enable();
-
-    setTimeout( function() {
-        emitter.disable();
-        self.releaseIntoPool( emitter );
-    }, ( emitter.maxAge.value + emitter.maxAge.spread ) * 1000 );
-
-    return this;
-};
-
-
-/**
- * Set a given number of emitters as alive, with an optional position
- * vector3 to move them to.
- *
- * @param  {Number} numEmitters The number of emitters to activate
- * @param  {Object} [position=undefined] A THREE.Vector3 instance describing the position to activate the emitter(s) at.
- * @return {Group} This group instance.
- */
-SPE.Group.prototype.triggerPoolEmitter = function( numEmitters, position ) {
-    'use strict';
-
-    if ( typeof numEmitters === 'number' && numEmitters > 1 ) {
-        for ( var i = 0; i < numEmitters; ++i ) {
-            this._triggerSingleEmitter( position );
-        }
-    }
-    else {
-        this._triggerSingleEmitter( position );
-    }
-
-    return this;
-};
-
-
-
-SPE.Group.prototype._updateUniforms = function( dt ) {
-    'use strict';
-
-    this.uniforms.runTime.value += dt;
-    this.uniforms.deltaTime.value = dt;
-};
-
-SPE.Group.prototype._resetBufferRanges = function() {
-    'use strict';
-
-    var keys = this.attributeKeys,
-        i = this.attributeCount - 1,
-        attrs = this.attributes;
-
-    for ( i; i >= 0; --i ) {
-        attrs[ keys[ i ] ].resetUpdateRange();
-    }
-};
-
-
-SPE.Group.prototype._updateBuffers = function( emitter ) {
-    'use strict';
-
-    var keys = this.attributeKeys,
-        i = this.attributeCount - 1,
-        attrs = this.attributes,
-        emitterRanges = emitter.bufferUpdateRanges,
-        key,
-        emitterAttr,
-        attr;
-
-    for ( i; i >= 0; --i ) {
-        key = keys[ i ];
-        emitterAttr = emitterRanges[ key ];
-        attr = attrs[ key ];
-        attr.setUpdateRange( emitterAttr.min, emitterAttr.max );
-        attr.flagUpdate();
-    }
-};
-
-
-/**
- * Simulate all the emitter's belonging to this group, updating
- * attribute values along the way.
- * @param  {Number} [dt=Group's `fixedTimeStep` value] The number of seconds to simulate the group's emitters for (deltaTime)
- */
-SPE.Group.prototype.tick = function( dt ) {
-    'use strict';
-
-    var emitters = this.emitters,
-        numEmitters = emitters.length,
-        deltaTime = dt || this.fixedTimeStep,
-        keys = this.attributeKeys,
-        i,
-        attrs = this.attributes;
    - -
    • - - -
  • -
    - -
    - -
    -

    Update uniform values.

    - -
    - - 
        this._updateUniforms( deltaTime );
    - -
    • - - -
  • -
    - -
    - -
    -

    Reset buffer update ranges on the shader attributes.

    - -
    - - 
        this._resetBufferRanges();
    - -
    • - - -
  • -
    - -
    - -
    -

    If nothing needs updating, then stop here.

    - -
    - - 
        if (
-        numEmitters === 0 &&
-        this._attributesNeedRefresh === false &&
-        this._attributesNeedDynamicReset === false
-    ) {
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Loop through each emitter in this group and -simulate it, then update the shader attribute -buffers.

    - -
    - - 
        for ( var i = 0, emitter; i < numEmitters; ++i ) {
-        emitter = emitters[ i ];
-        emitter.tick( deltaTime );
-        this._updateBuffers( emitter );
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    If the shader attributes have been refreshed, -then the dynamic properties of each buffer -attribute will need to be reset back to -what they should be.

    - -
    - - 
        if ( this._attributesNeedDynamicReset === true ) {
-        i = this.attributeCount - 1;
-
-        for ( i; i >= 0; --i ) {
-            attrs[ keys[ i ] ].resetDynamic();
-        }
-
-        this._attributesNeedDynamicReset = false;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    If this group’s shader attributes need a full refresh -then mark each attribute’s buffer attribute as -needing so.

    - -
    - - 
        if ( this._attributesNeedRefresh === true ) {
-        i = this.attributeCount - 1;
-
-        for ( i; i >= 0; --i ) {
-            attrs[ keys[ i ] ].forceUpdateAll();
-        }
-
-        this._attributesNeedRefresh = false;
-        this._attributesNeedDynamicReset = true;
-    }
-};
-
-
-/**
- * Dipose the geometry and material for the group.
- *
- * @return {Group} Group instance.
- */
-SPE.Group.prototype.dispose = function() {
-    'use strict';
-    this.geometry.dispose();
-    this.material.dispose();
-    return this;
-};
-
-/**
- * An SPE.Emitter instance.
- * @typedef {Object} Emitter
- * @see SPE.Emitter
- */
-
-/**
- * A map of options to configure an SPE.Emitter instance.
- *
- * @typedef {Object} EmitterOptions
- *
- * @property {distribution} [type=BOX] The default distribution this emitter should use to control
- *                         its particle's spawn position and force behaviour.
- *                         Must be an SPE.distributions.* value.
- *
- *
- * @property {Number} [particleCount=100] The total number of particles this emitter will hold. NOTE: this is not the number
- *                                  of particles emitted in a second, or anything like that. The number of particles
- *                                  emitted per-second is calculated by particleCount / maxAge (approximately!)
- *
- * @property {Number|null} [duration=null] The duration in seconds that this emitter should live for. If not specified, the emitter
- *                                         will emit particles indefinitely.
- *                                         NOTE: When an emitter is older than a specified duration, the emitter is NOT removed from
- *                                         it's group, but rather is just marked as dead, allowing it to be reanimated at a later time
- *                                         using `SPE.Emitter.prototype.enable()`.
- *
- * @property {Boolean} [isStatic=false] Whether this emitter should be not be simulated (true).
- * @property {Boolean} [activeMultiplier=1] A value between 0 and 1 describing what percentage of this emitter's particlesPerSecond should be
- *                                          emitted, where 0 is 0%, and 1 is 100%.
- *                                          For example, having an emitter with 100 particles, a maxAge of 2, yields a particlesPerSecond
- *                                          value of 50. Setting `activeMultiplier` to 0.5, then, will only emit 25 particles per second (0.5 = 50%).
- *                                          Values greater than 1 will emulate a burst of particles, causing the emitter to run out of particles
- *                                          before it's next activation cycle.
- *
- * @property {Boolean} [direction=1] The direction of the emitter. If value is `1`, emitter will start at beginning of particle's lifecycle.
- *                                   If value is `-1`, emitter will start at end of particle's lifecycle and work it's way backwards.
- *
- * @property {Object} [maxAge={}] An object describing the particle's maximum age in seconds.
- * @property {Number} [maxAge.value=2] A number between 0 and 1 describing the amount of maxAge to apply to all particles.
- * @property {Number} [maxAge.spread=0] A number describing the maxAge variance on a per-particle basis.
- *
- *
- * @property {Object} [position={}] An object describing this emitter's position.
- * @property {Object} [position.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base position.
- * @property {Object} [position.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis.
- *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
- *                                                          of this vector is used.
- * @property {Object} [position.spreadClamp=new THREE.Vector3()] A THREE.Vector3 instance describing the numeric multiples the particle's should
- *                                                               be spread out over.
- *                                                               Note that when using a SPHERE or DISC distribution, only the x-component
- *                                                               of this vector is used.
- * @property {Number} [position.radius=10] This emitter's base radius.
- * @property {Object} [position.radiusScale=new THREE.Vector3()] A THREE.Vector3 instance describing the radius's scale in all three axes. Allows a SPHERE or DISC to be squashed or stretched.
- * @property {distribution} [position.distribution=value of the `type` option.] A specific distribution to use when radiusing particles. Overrides the `type` option.
- * @property {Boolean} [position.randomise=false] When a particle is re-spawned, whether it's position should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [velocity={}] An object describing this particle velocity.
- * @property {Object} [velocity.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base velocity.
- * @property {Object} [velocity.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's velocity variance on a per-particle basis.
- *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
- *                                                          of this vector is used.
- * @property {distribution} [velocity.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's velocity. Overrides the `type` option.
- * @property {Boolean} [velocity.randomise=false] When a particle is re-spawned, whether it's velocity should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [acceleration={}] An object describing this particle's acceleration.
- * @property {Object} [acceleration.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base acceleration.
- * @property {Object} [acceleration.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's acceleration variance on a per-particle basis.
- *                           Note that when using a SPHERE or DISC distribution, only the x-component
- *                           of this vector is used.
- * @property {distribution} [acceleration.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's acceleration. Overrides the `type` option.
- * @property {Boolean} [acceleration.randomise=false] When a particle is re-spawned, whether it's acceleration should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [drag={}] An object describing this particle drag. Drag is applied to both velocity and acceleration values.
- * @property {Number} [drag.value=0] A number between 0 and 1 describing the amount of drag to apply to all particles.
- * @property {Number} [drag.spread=0] A number describing the drag variance on a per-particle basis.
- * @property {Boolean} [drag.randomise=false] When a particle is re-spawned, whether it's drag should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [wiggle={}] This is quite a fun one! The values of this object will determine whether a particle will wiggle, or jiggle, or wave,
- *                                or shimmy, or waggle, or... Well you get the idea. The wiggle is calculated over-time, meaning that a particle will
- *                                start off with no wiggle, and end up wiggling about with the distance of the `value` specified by the time it dies.
- *                                It's quite handy to simulate fire embers, or similar effects where the particle's position should slightly change over
- *                                time, and such change isn't easily controlled by rotation, velocity, or acceleration. The wiggle is a combination of sin and cos calculations, so is circular in nature.
- * @property {Number} [wiggle.value=0] A number describing the amount of wiggle to apply to all particles. It's measured in distance.
- * @property {Number} [wiggle.spread=0] A number describing the wiggle variance on a per-particle basis.
- *
- *
- * @property {Object} [rotation={}] An object describing this emitter's rotation. It can either be static, or set to rotate from 0radians to the value of `rotation.value`
- *                                  over a particle's lifetime. Rotation values affect both a particle's position and the forces applied to it.
- * @property {Object} [rotation.axis=new THREE.Vector3(0, 1, 0)] A THREE.Vector3 instance describing this emitter's axis of rotation.
- * @property {Object} [rotation.axisSpread=new THREE.Vector3()] A THREE.Vector3 instance describing the amount of variance to apply to the axis of rotation on
- *                                                              a per-particle basis.
- * @property {Number} [rotation.angle=0] The angle of rotation, given in radians. If `rotation.static` is true, the emitter will start off rotated at this angle, and stay as such.
- *                                       Otherwise, the particles will rotate from 0radians to this value over their lifetimes.
- * @property {Number} [rotation.angleSpread=0] The amount of variance in each particle's rotation angle.
- * @property {Boolean} [rotation.static=false] Whether the rotation should be static or not.
- * @property {Object} [rotation.center=The value of `position.value`] A THREE.Vector3 instance describing the center point of rotation.
- * @property {Boolean} [rotation.randomise=false] When a particle is re-spawned, whether it's rotation should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [color={}] An object describing a particle's color. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of THREE.Color instances are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Object} [color.value=new THREE.Color()] Either a single THREE.Color instance, or an array of THREE.Color instances to describe the color of a particle over it's lifetime.
- * @property {Object} [color.spread=new THREE.Vector3()] Either a single THREE.Vector3 instance, or an array of THREE.Vector3 instances to describe the color variance of a particle over it's lifetime.
- * @property {Boolean} [color.randomise=false] When a particle is re-spawned, whether it's color should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [opacity={}] An object describing a particle's opacity. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Number} [opacity.value=1] Either a single number, or an array of numbers to describe the opacity of a particle over it's lifetime.
- * @property {Number} [opacity.spread=0] Either a single number, or an array of numbers to describe the opacity variance of a particle over it's lifetime.
- * @property {Boolean} [opacity.randomise=false] When a particle is re-spawned, whether it's opacity should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [size={}] An object describing a particle's size. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Number} [size.value=1] Either a single number, or an array of numbers to describe the size of a particle over it's lifetime.
- * @property {Number} [size.spread=0] Either a single number, or an array of numbers to describe the size variance of a particle over it's lifetime.
- * @property {Boolean} [size.randomise=false] When a particle is re-spawned, whether it's size should be re-randomised or not. Can incur a performance hit.
- *
- *
- * @property {Object} [angle={}] An object describing a particle's angle. The angle is a 2d-rotation, measured in radians, applied to the particle's texture.
- *                               NOTE: if a particle's texture is a sprite-sheet, this value IS IGNORED.
- *                               This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
- *                               given to describe specific value changes over a particle's lifetime.
- *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
- *                               have a length matching the value of SPE.valueOverLifetimeLength.
- * @property {Number} [angle.value=0] Either a single number, or an array of numbers to describe the angle of a particle over it's lifetime.
- * @property {Number} [angle.spread=0] Either a single number, or an array of numbers to describe the angle variance of a particle over it's lifetime.
- * @property {Boolean} [angle.randomise=false] When a particle is re-spawned, whether it's angle should be re-randomised or not. Can incur a performance hit.
- *
- */
-
-/**
- * The SPE.Emitter class.
- *
- * @constructor
- *
- * @param {EmitterOptions} options A map of options to configure the emitter.
- */
-SPE.Emitter = function( options ) {
-    'use strict';
-
-    var utils = SPE.utils,
-        types = utils.types,
-        lifetimeLength = SPE.valueOverLifetimeLength;
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure we have a map of options to play with, -and that each option is in the correct format.

    - -
    - - 
        options = utils.ensureTypedArg( options, types.OBJECT, {} );
-    options.position = utils.ensureTypedArg( options.position, types.OBJECT, {} );
-    options.velocity = utils.ensureTypedArg( options.velocity, types.OBJECT, {} );
-    options.acceleration = utils.ensureTypedArg( options.acceleration, types.OBJECT, {} );
-    options.radius = utils.ensureTypedArg( options.radius, types.OBJECT, {} );
-    options.drag = utils.ensureTypedArg( options.drag, types.OBJECT, {} );
-    options.rotation = utils.ensureTypedArg( options.rotation, types.OBJECT, {} );
-    options.color = utils.ensureTypedArg( options.color, types.OBJECT, {} );
-    options.opacity = utils.ensureTypedArg( options.opacity, types.OBJECT, {} );
-    options.size = utils.ensureTypedArg( options.size, types.OBJECT, {} );
-    options.angle = utils.ensureTypedArg( options.angle, types.OBJECT, {} );
-    options.wiggle = utils.ensureTypedArg( options.wiggle, types.OBJECT, {} );
-    options.maxAge = utils.ensureTypedArg( options.maxAge, types.OBJECT, {} );
-
-    if ( options.onParticleSpawn ) {
-        console.warn( 'onParticleSpawn has been removed. Please set properties directly to alter values at runtime.' );
-    }
-
-    this.uuid = THREE.Math.generateUUID();
-
-    this.type = utils.ensureTypedArg( options.type, types.NUMBER, SPE.distributions.BOX );
    - -
    • - - -
  • -
    - -
    - -
    -

    Start assigning properties…kicking it off with props that DON’T support values over -lifetimes.

    -

    Btw, values over lifetimes are just the new way of referring to Start, Middle, and *End.

    - -
    - - 
        this.position = {
-        _value: utils.ensureInstanceOf( options.position.value, THREE.Vector3, new THREE.Vector3() ),
-        _spread: utils.ensureInstanceOf( options.position.spread, THREE.Vector3, new THREE.Vector3() ),
-        _spreadClamp: utils.ensureInstanceOf( options.position.spreadClamp, THREE.Vector3, new THREE.Vector3() ),
-        _distribution: utils.ensureTypedArg( options.position.distribution, types.NUMBER, this.type ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ),
-        _radius: utils.ensureTypedArg( options.position.radius, types.NUMBER, 10 ),
-        _radiusScale: utils.ensureInstanceOf( options.position.radiusScale, THREE.Vector3, new THREE.Vector3( 1, 1, 1 ) ),
-        _distributionClamp: utils.ensureTypedArg( options.position.distributionClamp, types.NUMBER, 0 ),
-    };
-
-    this.velocity = {
-        _value: utils.ensureInstanceOf( options.velocity.value, THREE.Vector3, new THREE.Vector3() ),
-        _spread: utils.ensureInstanceOf( options.velocity.spread, THREE.Vector3, new THREE.Vector3() ),
-        _distribution: utils.ensureTypedArg( options.velocity.distribution, types.NUMBER, this.type ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.acceleration = {
-        _value: utils.ensureInstanceOf( options.acceleration.value, THREE.Vector3, new THREE.Vector3() ),
-        _spread: utils.ensureInstanceOf( options.acceleration.spread, THREE.Vector3, new THREE.Vector3() ),
-        _distribution: utils.ensureTypedArg( options.acceleration.distribution, types.NUMBER, this.type ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.drag = {
-        _value: utils.ensureTypedArg( options.drag.value, types.NUMBER, 0 ),
-        _spread: utils.ensureTypedArg( options.drag.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.wiggle = {
-        _value: utils.ensureTypedArg( options.wiggle.value, types.NUMBER, 0 ),
-        _spread: utils.ensureTypedArg( options.wiggle.spread, types.NUMBER, 0 )
-    };
-
-    this.rotation = {
-        _axis: utils.ensureInstanceOf( options.rotation.axis, THREE.Vector3, new THREE.Vector3( 0.0, 1.0, 0.0 ) ),
-        _axisSpread: utils.ensureInstanceOf( options.rotation.axisSpread, THREE.Vector3, new THREE.Vector3() ),
-        _angle: utils.ensureTypedArg( options.rotation.angle, types.NUMBER, 0 ),
-        _angleSpread: utils.ensureTypedArg( options.rotation.angleSpread, types.NUMBER, 0 ),
-        _static: utils.ensureTypedArg( options.rotation.static, types.BOOLEAN, false ),
-        _center: utils.ensureInstanceOf( options.rotation.center, THREE.Vector3, this.position._value.clone() ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-
-    this.maxAge = {
-        _value: utils.ensureTypedArg( options.maxAge.value, types.NUMBER, 2 ),
-        _spread: utils.ensureTypedArg( options.maxAge.spread, types.NUMBER, 0 )
-    };
    - -
    • - - -
  • -
    - -
    - -
    -

    The following properties can support either single values, or an array of values that change -the property over a particle’s lifetime (value over lifetime).

    - -
    - - 
        this.color = {
-        _value: utils.ensureArrayInstanceOf( options.color.value, THREE.Color, new THREE.Color() ),
-        _spread: utils.ensureArrayInstanceOf( options.color.spread, THREE.Vector3, new THREE.Vector3() ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.opacity = {
-        _value: utils.ensureArrayTypedArg( options.opacity.value, types.NUMBER, 1 ),
-        _spread: utils.ensureArrayTypedArg( options.opacity.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.size = {
-        _value: utils.ensureArrayTypedArg( options.size.value, types.NUMBER, 1 ),
-        _spread: utils.ensureArrayTypedArg( options.size.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
-
-    this.angle = {
-        _value: utils.ensureArrayTypedArg( options.angle.value, types.NUMBER, 0 ),
-        _spread: utils.ensureArrayTypedArg( options.angle.spread, types.NUMBER, 0 ),
-        _randomise: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false )
-    };
    - -
    • - - -
  • -
    - -
    - -
    -

    Assign renaining option values.

    - -
    - - 
        this.particleCount = utils.ensureTypedArg( options.particleCount, types.NUMBER, 100 );
-    this.duration = utils.ensureTypedArg( options.duration, types.NUMBER, null );
-    this.isStatic = utils.ensureTypedArg( options.isStatic, types.BOOLEAN, false );
-    this.activeMultiplier = utils.ensureTypedArg( options.activeMultiplier, types.NUMBER, 1 );
-    this.direction = utils.ensureTypedArg( options.direction, types.NUMBER, 1 );
    - -
    • - - -
  • -
    - -
    - -
    -

    Whether this emitter is alive or not.

    - -
    - - 
        this.alive = utils.ensureTypedArg( options.alive, types.BOOLEAN, true );
    - -
    • - - -
  • -
    - -
    - -
    -

    The following properties are set internally and are not -user-controllable.

    - -
    - - 
        this.particlesPerSecond = 0;
    - -
    • - - -
  • -
    - -
    - -
    -

    The current particle index for which particles should -be marked as active on the next update cycle.

    - -
    - - 
        this.activationIndex = 0;
    - -
    • - - -
  • -
    - -
    - -
    -

    The offset in the typed arrays this emitter’s -particle’s values will start at

    - -
    - - 
        this.attributeOffset = 0;
    - -
    • - - -
  • -
    - -
    - -
    -

    The end of the range in the attribute buffers

    - -
    - - 
        this.attributeEnd = 0;
    - -
    • - - -
  • -
    - -
    - -
    -

    Holds the time the emitter has been alive for.

    - -
    - - 
        this.age = 0.0;
    - -
    • - - -
  • -
    - -
    - -
    -

    Holds the number of currently-alive particles

    - -
    - - 
        this.activeParticleCount = 0.0;
    - -
    • - - -
  • -
    - -
    - -
    -

    Holds a reference to this emitter’s group once -it’s added to one.

    - -
    - - 
        this.group = null;
    - -
    • - - -
  • -
    - -
    - -
    -

    Holds a reference to this emitter’s group’s attributes object -for easier access.

    - -
    - - 
        this.attributes = null;
    - -
    • - - -
  • -
    - -
    - -
    -

    Holds a reference to the params attribute’s typed array -for quicker access.

    - -
    - - 
        this.paramsArray = null;
    - -
    • - - -
  • -
    - -
    - -
    -

    A set of flags to determine whether particular properties -should be re-randomised when a particle is reset.

    -

    If a randomise property is given, this is preferred. -Otherwise, it looks at whether a spread value has been -given.

    -

    It allows randomization to be turned off as desired. If -all randomization is turned off, then I’d expect a performance -boost as no attribute buffers (excluding the params) -would have to be re-passed to the GPU each frame (since nothing -except the params attribute would have changed).

    - -
    - - 
        this.resetFlags = {
    - -
    • - - -
  • -
    - -
    - -
    -

    params: utils.ensureTypedArg( options.maxAge.randomise, types.BOOLEAN, !!options.maxAge.spread ) || - utils.ensureTypedArg( options.wiggle.randomise, types.BOOLEAN, !!options.wiggle.spread ),

    - -
    - - 
            position: utils.ensureTypedArg( options.position.randomise, types.BOOLEAN, false ) ||
-            utils.ensureTypedArg( options.radius.randomise, types.BOOLEAN, false ),
-        velocity: utils.ensureTypedArg( options.velocity.randomise, types.BOOLEAN, false ),
-        acceleration: utils.ensureTypedArg( options.acceleration.randomise, types.BOOLEAN, false ) ||
-            utils.ensureTypedArg( options.drag.randomise, types.BOOLEAN, false ),
-        rotation: utils.ensureTypedArg( options.rotation.randomise, types.BOOLEAN, false ),
-        rotationCenter: utils.ensureTypedArg( options.rotation.randomise, types.BOOLEAN, false ),
-        size: utils.ensureTypedArg( options.size.randomise, types.BOOLEAN, false ),
-        color: utils.ensureTypedArg( options.color.randomise, types.BOOLEAN, false ),
-        opacity: utils.ensureTypedArg( options.opacity.randomise, types.BOOLEAN, false ),
-        angle: utils.ensureTypedArg( options.angle.randomise, types.BOOLEAN, false )
-    };
-
-    this.updateFlags = {};
-    this.updateCounts = {};
    - -
    • - - -
  • -
    - -
    - -
    -

    A map to indicate which emitter parameters should update -which attribute.

    - -
    - - 
        this.updateMap = {
-        maxAge: 'params',
-        position: 'position',
-        velocity: 'velocity',
-        acceleration: 'acceleration',
-        drag: 'acceleration',
-        wiggle: 'params',
-        rotation: 'rotation',
-        size: 'size',
-        color: 'color',
-        opacity: 'opacity',
-        angle: 'angle'
-    };
-
-    for ( var i in this.updateMap ) {
-        if ( this.updateMap.hasOwnProperty( i ) ) {
-            this.updateCounts[ this.updateMap[ i ] ] = 0.0;
-            this.updateFlags[ this.updateMap[ i ] ] = false;
-            this._createGetterSetters( this[ i ], i );
-        }
-    }
-
-    this.bufferUpdateRanges = {};
-    this.attributeKeys = null;
-    this.attributeCount = 0;
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure that the value-over-lifetime property objects above -have value and spread properties that are of the same length.

    -

    Also, for now, make sure they have a length of 3 (min/max arguments here).

    - -
    - - 
        utils.ensureValueOverLifetimeCompliance( this.color, lifetimeLength, lifetimeLength );
-    utils.ensureValueOverLifetimeCompliance( this.opacity, lifetimeLength, lifetimeLength );
-    utils.ensureValueOverLifetimeCompliance( this.size, lifetimeLength, lifetimeLength );
-    utils.ensureValueOverLifetimeCompliance( this.angle, lifetimeLength, lifetimeLength );
-};
-
-SPE.Emitter.constructor = SPE.Emitter;
-
-SPE.Emitter.prototype._createGetterSetters = function( propObj, propName ) {
-    'use strict';
-
-    var self = this;
-
-    for ( var i in propObj ) {
-        if ( propObj.hasOwnProperty( i ) ) {
-
-            var name = i.replace( '_', '' );
-
-            Object.defineProperty( propObj, name, {
-                get: ( function( prop ) {
-                    return function() {
-                        return this[ prop ];
-                    };
-                }( i ) ),
-
-                set: ( function( prop ) {
-                    return function( value ) {
-                        var mapName = self.updateMap[ propName ],
-                            prevValue = this[ prop ],
-                            length = SPE.valueOverLifetimeLength;
-
-                        if ( prop === '_rotationCenter' ) {
-                            self.updateFlags.rotationCenter = true;
-                            self.updateCounts.rotationCenter = 0.0;
-                        }
-                        else if ( prop === '_randomise' ) {
-                            self.resetFlags[ mapName ] = value;
-                        }
-                        else {
-                            self.updateFlags[ mapName ] = true;
-                            self.updateCounts[ mapName ] = 0.0;
-                        }
-
-                        self.group._updateDefines();
-
-                        this[ prop ] = value;
    - -
    • - - -
  • -
    - -
    - -
    -

    If the previous value was an array, then make -sure the provided value is interpolated correctly.

    - -
    - - 
                            if ( Array.isArray( prevValue ) ) {
-                            SPE.utils.ensureValueOverLifetimeCompliance( self[ propName ], length, length );
-                        }
-                    };
-                }( i ) )
-            } );
-        }
-    }
-};
-
-SPE.Emitter.prototype._setBufferUpdateRanges = function( keys ) {
-    'use strict';
-
-    this.attributeKeys = keys;
-    this.attributeCount = keys.length;
-
-    for ( var i = this.attributeCount - 1; i >= 0; --i ) {
-        this.bufferUpdateRanges[ keys[ i ] ] = {
-            min: Number.POSITIVE_INFINITY,
-            max: Number.NEGATIVE_INFINITY
-        };
-    }
-};
-
-SPE.Emitter.prototype._calculatePPSValue = function( groupMaxAge ) {
-    'use strict';
-
-    var particleCount = this.particleCount;
    - -
    • - - -
  • -
    - -
    - -
    -

    Calculate the particlesPerSecond value for this emitter. It’s used -when determining which particles should die and which should live to -see another day. Or be born, for that matter. The “God” property.

    - -
    - - 
        if ( this.duration ) {
-        this.particlesPerSecond = particleCount / ( groupMaxAge < this.duration ? groupMaxAge : this.duration );
-    }
-    else {
-        this.particlesPerSecond = particleCount / groupMaxAge;
-    }
-};
-
-SPE.Emitter.prototype._setAttributeOffset = function( startIndex ) {
-    this.attributeOffset = startIndex;
-    this.activationIndex = startIndex;
-    this.activationEnd = startIndex + this.particleCount;
-};
-
-
-SPE.Emitter.prototype._assignValue = function( prop, index ) {
-    'use strict';
-
-    switch ( prop ) {
-        case 'position':
-            this._assignPositionValue( index );
-            break;
-
-        case 'velocity':
-        case 'acceleration':
-            this._assignForceValue( index, prop );
-            break;
-
-        case 'size':
-        case 'opacity':
-            this._assignAbsLifetimeValue( index, prop );
-            break;
-
-        case 'angle':
-            this._assignAngleValue( index );
-            break;
-
-        case 'params':
-            this._assignParamsValue( index );
-            break;
-
-        case 'rotation':
-            this._assignRotationValue( index );
-            break;
-
-        case 'color':
-            this._assignColorValue( index );
-            break;
-    }
-};
-
-SPE.Emitter.prototype._assignPositionValue = function( index ) {
-    'use strict';
-
-    var distributions = SPE.distributions,
-        utils = SPE.utils,
-        prop = this.position,
-        attr = this.attributes.position,
-        value = prop._value,
-        spread = prop._spread,
-        distribution = prop._distribution;
-
-    switch ( distribution ) {
-        case distributions.BOX:
-            utils.randomVector3( attr, index, value, spread, prop._spreadClamp );
-            break;
-
-        case distributions.SPHERE:
-            utils.randomVector3OnSphere( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x, prop._distributionClamp || this.particleCount );
-            break;
-
-        case distributions.DISC:
-            utils.randomVector3OnDisc( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x );
-            break;
-    }
-};
-
-SPE.Emitter.prototype._assignForceValue = function( index, attrName ) {
-    'use strict';
-
-    var distributions = SPE.distributions,
-        utils = SPE.utils,
-        prop = this[ attrName ],
-        value = prop._value,
-        spread = prop._spread,
-        distribution = prop._distribution,
-        pos,
-        positionX,
-        positionY,
-        positionZ,
-        i;
-
-    switch ( distribution ) {
-        case distributions.BOX:
-            utils.randomVector3( this.attributes[ attrName ], index, value, spread );
-            break;
-
-        case distributions.SPHERE:
-            pos = this.attributes.position.typedArray.array;
-            i = index * 3;
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure position values aren’t zero, otherwise no force will be -applied. -positionX = utils.zeroToEpsilon( pos[ i ], true ); -positionY = utils.zeroToEpsilon( pos[ i + 1 ], true ); -positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );

    - -
    - - 
                positionX = pos[ i ];
-            positionY = pos[ i + 1 ];
-            positionZ = pos[ i + 2 ];
-
-            utils.randomDirectionVector3OnSphere(
-                this.attributes[ attrName ], index,
-                positionX, positionY, positionZ,
-                this.position._value,
-                prop._value.x,
-                prop._spread.x
-            );
-            break;
-
-        case distributions.DISC:
-            pos = this.attributes.position.typedArray.array;
-            i = index * 3;
    - -
    • - - -
  • -
    - -
    - -
    -

    Ensure position values aren’t zero, otherwise no force will be -applied. -positionX = utils.zeroToEpsilon( pos[ i ], true ); -positionY = utils.zeroToEpsilon( pos[ i + 1 ], true ); -positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );

    - -
    - - 
                positionX = pos[ i ];
-            positionY = pos[ i + 1 ];
-            positionZ = pos[ i + 2 ];
-
-            utils.randomDirectionVector3OnDisc(
-                this.attributes[ attrName ], index,
-                positionX, positionY, positionZ,
-                this.position._value,
-                prop._value.x,
-                prop._spread.x
-            );
-            break;
-    }
-
-    if ( attrName === 'acceleration' ) {
-        var drag = utils.clamp( utils.randomFloat( this.drag._value, this.drag._spread ), 0, 1 );
-        this.attributes.acceleration.typedArray.array[ index * 4 + 3 ] = drag;
-    }
-};
-
-SPE.Emitter.prototype._assignAbsLifetimeValue = function( index, propName ) {
-    'use strict';
-
-    var array = this.attributes[ propName ].typedArray,
-        prop = this[ propName ],
-        utils = SPE.utils,
-        value;
-
-    if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
-        value = Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) );
-        array.setVec4Components( index, value, value, value, value );
-    }
-    else {
-        array.setVec4Components( index,
-            Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) ),
-            Math.abs( utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ) ),
-            Math.abs( utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ) ),
-            Math.abs( utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] ) )
-        );
-    }
-};
-
-SPE.Emitter.prototype._assignAngleValue = function( index ) {
-    'use strict';
-
-    var array = this.attributes.angle.typedArray,
-        prop = this.angle,
-        utils = SPE.utils,
-        value;
-
-    if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
-        value = utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] );
-        array.setVec4Components( index, value, value, value, value );
-    }
-    else {
-        array.setVec4Components( index,
-            utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ),
-            utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ),
-            utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ),
-            utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] )
-        );
-    }
-};
-
-SPE.Emitter.prototype._assignParamsValue = function( index ) {
-    'use strict';
-
-    this.attributes.params.typedArray.setVec4Components( index,
-        this.isStatic ? 1 : 0,
-        0.0,
-        Math.abs( SPE.utils.randomFloat( this.maxAge._value, this.maxAge._spread ) ),
-        SPE.utils.randomFloat( this.wiggle._value, this.wiggle._spread )
-    );
-};
-
-SPE.Emitter.prototype._assignRotationValue = function( index ) {
-    'use strict';
-
-    this.attributes.rotation.typedArray.setVec3Components( index,
-        SPE.utils.getPackedRotationAxis( this.rotation._axis, this.rotation._axisSpread ),
-        SPE.utils.randomFloat( this.rotation._angle, this.rotation._angleSpread ),
-        this.rotation._static ? 0 : 1
-    );
-
-    this.attributes.rotationCenter.typedArray.setVec3( index, this.rotation._center );
-};
-
-SPE.Emitter.prototype._assignColorValue = function( index ) {
-    'use strict';
-    SPE.utils.randomColorAsHex( this.attributes.color, index, this.color._value, this.color._spread );
-};
-
-SPE.Emitter.prototype._resetParticle = function( index ) {
-    'use strict';
-
-    var resetFlags = this.resetFlags,
-        updateFlags = this.updateFlags,
-        updateCounts = this.updateCounts,
-        keys = this.attributeKeys,
-        key,
-        updateFlag;
-
-    for ( var i = this.attributeCount - 1; i >= 0; --i ) {
-        key = keys[ i ];
-        updateFlag = updateFlags[ key ];
-
-        if ( resetFlags[ key ] === true || updateFlag === true ) {
-            this._assignValue( key, index );
-            this._updateAttributeUpdateRange( key, index );
-
-            if ( updateFlag === true && updateCounts[ key ] === this.particleCount ) {
-                updateFlags[ key ] = false;
-                updateCounts[ key ] = 0.0;
-            }
-            else if ( updateFlag == true ) {
-                ++updateCounts[ key ];
-            }
-        }
-    }
-};
-
-SPE.Emitter.prototype._updateAttributeUpdateRange = function( attr, i ) {
-    'use strict';
-
-    var ranges = this.bufferUpdateRanges[ attr ];
-
-    ranges.min = Math.min( i, ranges.min );
-    ranges.max = Math.max( i, ranges.max );
-};
-
-SPE.Emitter.prototype._resetBufferRanges = function() {
-    'use strict';
-
-    var ranges = this.bufferUpdateRanges,
-        keys = this.bufferUpdateKeys,
-        i = this.bufferUpdateCount - 1,
-        key;
-
-    for ( i; i >= 0; --i ) {
-        key = keys[ i ];
-        ranges[ key ].min = Number.POSITIVE_INFINITY;
-        ranges[ key ].max = Number.NEGATIVE_INFINITY;
-    }
-};
-
-SPE.Emitter.prototype._onRemove = function() {
-    'use strict';
    - -
    • - - -
  • -
    - -
    - -
    -

    Reset any properties of the emitter that were set by -a group when it was added.

    - -
    - - 
        this.particlesPerSecond = 0;
-    this.attributeOffset = 0;
-    this.activationIndex = 0;
-    this.activeParticleCount = 0;
-    this.group = null;
-    this.attributes = null;
-    this.paramsArray = null;
-    this.age = 0.0;
-};
-
-SPE.Emitter.prototype._decrementParticleCount = function() {
-    'use strict';
-    --this.activeParticleCount;
    - -
    • - - -
  • -
    - -
    - -
    -

    TODO:

    -
      -
    • Trigger event if count === 0.
      • -
    - -
    - - 
    };
-
-SPE.Emitter.prototype._incrementParticleCount = function() {
-    'use strict';
-    ++this.activeParticleCount;
    - -
    • - - -
  • -
    - -
    - -
    -

    TODO:

    -
      -
    • Trigger event if count === this.particleCount.
      • -
    - -
    - - 
    };
-
-SPE.Emitter.prototype._checkParticleAges = function( start, end, params, dt ) {
-    'use strict';
-    for ( var i = end - 1, index, maxAge, age, alive; i >= start; --i ) {
-        index = i * 4;
-
-        alive = params[ index ];
-
-        if ( alive === 0.0 ) {
-            continue;
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    Increment age

    - -
    - - 
            age = params[ index + 1 ];
-        maxAge = params[ index + 2 ];
-
-        if ( this.direction === 1 ) {
-            age += dt;
-
-            if ( age >= maxAge ) {
-                age = 0.0;
-                alive = 0.0;
-                this._decrementParticleCount();
-            }
-        }
-        else {
-            age -= dt;
-
-            if ( age <= 0.0 ) {
-                age = maxAge;
-                alive = 0.0;
-                this._decrementParticleCount();
-            }
-        }
-
-        params[ index ] = alive;
-        params[ index + 1 ] = age;
-
-        this._updateAttributeUpdateRange( 'params', i );
-    }
-};
-
-SPE.Emitter.prototype._activateParticles = function( activationStart, activationEnd, params, dtPerParticle ) {
-    'use strict';
-    var direction = this.direction;
-
-    for ( var i = activationStart, index, dtValue; i < activationEnd; ++i ) {
-        index = i * 4;
    - -
    • - - -
  • -
    - -
    - -
    -

    Don’t re-activate particles that aren’t dead yet. -if ( params[ index ] !== 0.0 && ( this.particleCount !== 1 || this.activeMultiplier !== 1 ) ) { - continue; -}

    - -
    - - 
    -        if ( params[ index ] != 0.0 && this.particleCount !== 1 ) {
-            continue;
-        }
    - -
    • - - -
  • -
    - -
    - -
    -

    Increment the active particle count.

    - -
    - - 
            this._incrementParticleCount();
    - -
    • - - -
  • -
    - -
    - -
    -

    Mark the particle as alive.

    - -
    - - 
            params[ index ] = 1.0;
    - -
    • - - -
  • -
    - -
    - -
    -

    Reset the particle

    - -
    - - 
            this._resetParticle( i );
    - -
    • - - -
  • -
    - -
    - -
    -

    Move each particle being activated to -it’s actual position in time.

    -

    This stops particles being ‘clumped’ together -when frame rates are on the lower side of 60fps -or not constant (a very real possibility!)

    - -
    - - 
            dtValue = dtPerParticle * ( i - activationStart )
-        params[ index + 1 ] = direction === -1 ? params[ index + 2 ] - dtValue : dtValue;
-
-        this._updateAttributeUpdateRange( 'params', i );
-    }
-};
-
-/**
- * Simulates one frame's worth of particles, updating particles
- * that are already alive, and marking ones that are currently dead
- * but should be alive as alive.
- *
- * If the emitter is marked as static, then this function will do nothing.
- *
- * @param  {Number} dt The number of seconds to simulate (deltaTime)
- */
-SPE.Emitter.prototype.tick = function( dt ) {
-    'use strict';
-
-    if ( this.isStatic ) {
-        return;
-    }
-
-    if ( this.paramsArray === null ) {
-        this.paramsArray = this.attributes.params.typedArray.array;
-    }
-
-    var start = this.attributeOffset,
-        end = start + this.particleCount,
-        params = this.paramsArray, // vec3( alive, age, maxAge, wiggle )
-        ppsDt = this.particlesPerSecond * this.activeMultiplier * dt,
-        activationIndex = this.activationIndex;
    - -
    • - - -
  • -
    - -
    - -
    -

    Reset the buffer update indices.

    - -
    - - 
        this._resetBufferRanges();
    - -
    • - - -
  • -
    - -
    - -
    -

    Increment age for those particles that are alive, -and kill off any particles whose age is over the limit.

    - -
    - - 
        this._checkParticleAges( start, end, params, dt );
    - -
    • - - -
  • -
    - -
    - -
    -

    If the emitter is dead, reset the age of the emitter to zero, -ready to go again if required

    - -
    - - 
        if ( this.alive === false ) {
-        this.age = 0.0;
-        return;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    If the emitter has a specified lifetime and we’ve exceeded it, -mark the emitter as dead.

    - -
    - - 
        if ( this.duration !== null && this.age > this.duration ) {
-        this.alive = false;
-        this.age = 0.0;
-        return;
-    }
-
-
-    var activationStart = this.particleCount === 1 ? activationIndex : ( activationIndex | 0 ),
-        activationEnd = Math.min( activationStart + ppsDt, this.activationEnd ),
-        activationCount = activationEnd - this.activationIndex | 0,
-        dtPerParticle = activationCount > 0 ? dt / activationCount : 0;
-
-    this._activateParticles( activationStart, activationEnd, params, dtPerParticle );
    - -
    • - - -
  • -
    - -
    - -
    -

    Move the activation window forward, soldier.

    - -
    - - 
        this.activationIndex += ppsDt;
-
-    if ( this.activationIndex > end ) {
-        this.activationIndex = start;
-    }
    - -
    • - - -
  • -
    - -
    - -
    -

    Increment the age of the emitter.

    - -
    - - 
        this.age += dt;
-};
-
-/**
- * Resets all the emitter's particles to their start positions
- * and marks the particles as dead if the `force` argument is
- * true.
- *
- * @param  {Boolean} [force=undefined] If true, all particles will be marked as dead instantly.
- * @return {Emitter}       This emitter instance.
- */
-SPE.Emitter.prototype.reset = function( force ) {
-    'use strict';
-
-    this.age = 0.0;
-    this.alive = false;
-
-    if ( force === true ) {
-        var start = this.attributeOffset,
-            end = start + this.particleCount,
-            array = this.paramsArray,
-            attr = this.attributes.params.bufferAttribute;
-
-        for ( var i = end - 1, index; i >= start; --i ) {
-            index = i * 4;
-
-            array[ index ] = 0.0;
-            array[ index + 1 ] = 0.0;
-        }
-
-        attr.updateRange.offset = 0;
-        attr.updateRange.count = -1;
-        attr.needsUpdate = true;
-    }
-
-    return this;
-};
-
-/**
- * Enables the emitter. If not already enabled, the emitter
- * will start emitting particles.
- *
- * @return {Emitter} This emitter instance.
- */
-SPE.Emitter.prototype.enable = function() {
-    'use strict';
-    this.alive = true;
-    return this;
-};
-
-/**
- * Disables th emitter, but does not instantly remove it's
- * particles fromt the scene. When called, the emitter will be
- * 'switched off' and just stop emitting. Any particle's alive will
- * be allowed to finish their lifecycle.
- *
- * @return {Emitter} This emitter instance.
- */
-SPE.Emitter.prototype.disable = function() {
-    'use strict';
-
-    this.alive = false;
-    return this;
-};
-
-/**
- * Remove this emitter from it's parent group (if it has been added to one).
- * Delgates to SPE.group.prototype.removeEmitter().
- *
- * When called, all particle's belonging to this emitter will be instantly
- * removed from the scene.
- *
- * @return {Emitter} This emitter instance.
- *
- * @see SPE.Group.prototype.removeEmitter
- */
-SPE.Emitter.prototype.remove = function() {
-    'use strict';
-    if ( this.group !== null ) {
-        this.group.removeEmitter( this );
-    }
-    else {
-        console.error( 'Emitter does not belong to a group, cannot remove.' );
-    }
-
-    return this;
-};
    - -
    • - -
-
- - diff --git a/docs/source/docco.css b/docs/source/docco.css index a2899ac..b60f6fa 100644 --- a/docs/source/docco.css +++ b/docs/source/docco.css @@ -21,11 +21,11 @@ } @font-face { - font-family: 'novecento-bold'; - src: url('public/fonts/novecento-bold.eot'); - src: url('public/fonts/novecento-bold.eot?#iefix') format('embedded-opentype'), - url('public/fonts/novecento-bold.woff') format('woff'), - url('public/fonts/novecento-bold.ttf') format('truetype'); + font-family: 'roboto-black'; + src: url('public/fonts/roboto-black.eot'); + src: url('public/fonts/roboto-black.eot?#iefix') format('embedded-opentype'), + url('public/fonts/roboto-black.woff') format('woff'), + url('public/fonts/roboto-black.ttf') format('truetype'); font-weight: normal; font-style: normal; } @@ -67,7 +67,7 @@ h1, h2, h3, h4, h5, h6 { color: #112233; line-height: 1em; font-weight: normal; - font-family: "novecento-bold"; + font-family: "roboto-black"; text-transform: uppercase; margin: 30px 0 15px 0; } @@ -75,6 +75,9 @@ h1, h2, h3, h4, h5, h6 { h1 { margin-top: 40px; } +h2 { + font-size: 1.26em; +} hr { border: 0; @@ -180,9 +183,18 @@ ul.sections > li > div { display: block; } +#jump_page_wrapper{ + position: fixed; + right: 0; + top: 0; + bottom: 0; +} + #jump_page { padding: 5px 0 3px; margin: 0 0 25px 25px; + max-height: 100%; + overflow: auto; } #jump_page .source { diff --git a/docs/source/public/fonts/novecento-bold.eot b/docs/source/public/fonts/novecento-bold.eot deleted file mode 100644 index 98a9a7fbabb1083aca5143bc306e228886ff2eeb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 18190 zcma%iQ*>rQ)9xGF_8Z%_-q^Nnb7I@JJ(<|a#I`1$*q&H(=KKD${&gTYBy0H9w20095jAOZh*V4?my0Kfn};DCReyfV!H5dYh!0sz4OfO27!`Tr&V zSD*qY0-OMz01JTGzt<7q{tp2GUH}__`9BNY0q|M38TH$d~B))nCP z&(7(e7ZAV(U;?oGYpei%fHFYsAM+pd|FYKqEZzS_`H#KlKRxSzJ(vKT0Iq*N4giyX zQ7ryzWBE^G|8Hi~|Lf26Z)63q|LZyb#b){c%=mwD|DSvT05LTw<^Nsu{}mtrk<$Pc zF#wA+fb$rA<}7C1TUTqsTF*r`(3{Mx%ay^3LE@R}8A?243xBvR=IP-h4YpJyDj1uN z1zJ;*s-tD+EmX}k+@u4Rn{)guYN7*XE*>1dNx6ku$eWh^{C=XW};3JMXTV{Q7yfM@L@B)Q2;WvSJkv3)>OIuSq*i2bk<1uK zLl)<2(d4#?r2L+({C&5`Cso@R{G@Mk2G*G?oIq|+?LD(e|RLM zX$uRh)yw3hD7|Jp(9!3IB`O+=B2?$9ArFL&3*rtKju@MC^_3R)O}N@cCj^KXHpmev zL1|Sq6%ww$p+2letG%e6%qN6ZJqSa91-Z(seZeiZ$5vPp>n|pHWD+$W!#qBu6JXIz zaw10-oAFISeg3Gorho($QQGPTY5`qIgskq4# z&Q!K$ZiU8tz>HiS1UsKpcteNO+4l&`{6uM+Z!nie`HWVCyMw? zR+2GK{kEvcEgG>d*dct+-e@R4%u%&9+mzURSClFH%~fbWjRHO4(9x{w1uuUm(o#LF zCbX+b8j`hLcojS8Ip+*S?qgxzkT2*SD!wb8~MeNqg6 zHILiJ87CHfBTM+&S6ebd3+<`m)Uq7uP9Ph{p;DHnsQzHpo3ER7AP;K@3uY({JWIi` zFUHU-$G+<-*LgeJo1;xT+qOlPiWK%>gy(9T4L^EaGMg-ozALPxoNKSb)EAF53Gt`U;hmE=TP3o77+*i$s2Kd zU$C{&Aodq`e>XYI&I+2e-X9?-vfjz^%|~GxD%n*RPZwnv6n8V*W$Pkqu8AaB&wT~6 zWH`%l3^Ggtj-r+-aI(M!{}5C+x7L^2K*!9a zAO>=_1b_=JGGEf*OKD!GqCan;VIExgL$lH%1Yi(ldg}~<+q@t#vcaVUK`q{b+fxe5 ziZN8az0E|S=?Sz#;JkvET`EpaGKykZ|un!!k;-Z)6}Uuizp3O zrL7+V+0iDa{#F{qm7C)$gwN-_29Z4kq*pWjU2Js29y~q6)iNqtEQ#Cjj|$624PKqS zZwnLui)=v92s!HUwU>1VoVNHA!k(OYkCvc|&QT2ezXWj7Lq9IFkOg`^KSc8UYIMDh$< zQz1;c&RkJXv8^8qUCWIKxI+&Z0c9#Nj&Zah!q&$k%>uz(tTd>&?e9;#KBTTH~} zXfH-DqNro!i4d_(Dre^pIZF(C zxDC+SD(0yDPX&Ea!$j?N{&6>CQj_68n|Ba>&&a1IZIt}p54Yts{^Hgr5(Zqgen@3% z&Vty2RJ%BxrAOY_X;V+Gez8@=&KG%9Z1Bc{7kWi$BF5dcBBvg!&Qn&h)7jEATMiSq zuL)>zid}Hs_I4O)jDht$Czf(w?QTkUyAJV664@mhv}pLTqr$SY>}KcRCCxH6P=ofT zwv9{+Gl8;(spfV3xjos$L;RMlgLP?51ZFPTO4S3RkbkO?1OTxe-6yt)c^DqLWU9MS zvENV&lpQU=Q>&Q{yF!=s3x%z3YY;zN&2ng!^~E9tMKT17HU(`>5IgT(A(co{poZDO z(-q(#H4{-^Q#K=(m2rpb)Z2{0d;wr=t`x)7%nMf?V1DC7DN_} z8P_@{=Ci||B{S`dH_{NyVHLCZHqv?P#p+`-B=QV#{=w?I<1#*XF#^?K@E8R>*rxq= zoq;&9lFQPhBc-|E)z_Wp(h>FX60vDgDp~?TOy#N?HTnCs+cY_{7>fmRkb;brdQ5(H z`UE<+%v(u%B2>0HsU!_hRRq($=a?^OiPtt;zW4~p10}2&hz*5V=8`2wXnw}8jEO~U z8Oh@`saWf5op;1ekj5}2Dh*02jPMY8u|i_2Ha~aDuI%6)=m5X8Y!2t6psFxhJ)hc} zS!SPbeD*=R_cj%0iUZ$8Mv)C8Z?;+x-nk3U#Khm0%L4VSg#FkgD_X6?<%1|=48BJm zMsAnvzlNC9KblP>Ma8*xfv`bUcYef0^QpFEKfkAgJ`D9hs3T9u=oDk%OQu4pR1}S@ zZXgQjEN&$R6g&0!8JDvPO%AV<(Z755K3?fp=;+zVfQZvW)JIVRnqY!sGNl|~!1Is9yn*H|s?j{`c)o7_ORGsU=wGxtn5>c;4ds4iU+LJ+4H?do3=p!KZt{vvs!>V(@>$zGluz|z z%d_DQO;kI2wo}0o9YJH7p?RoV~E_0k5DJxq(+aAKqb`}Q+C$|rSR=HuJJ@AD=Ln0V0$UOXG50TBSB{KN!b zWqB7GX~}y)v}VR}*u=?rKs>lUXtDVvO8)>7qcWm(2s0DGdCA`a*~9I?!iUe+CzIZG zSSF7d+AZB1ss#$dy&pmohQqD@_|I_g&<&iws+g4q12wJ+PXRzn6v5Lx)4R6DWW*!q zMs%)#-AQBU@RH+CYCR5?&7>68prwCV6f^-Al*iM1B>wu`@``X4*E62V50APk1WjVT z%&1H(G}%~_OPp2K!rnlM&=b>X)K~8@@DdaRt>t)FR-Nh+TTb$s)qbzn8<@;WhGA;U zcfXGaGzc_1YOjb2I#X<`?Ct5CkGN$fhMXZ7)9Hi92jYP-2Mm>&t(*1WYh=U1sEDYh zdE+9(B0YmjJ_D*jLitlj$I|M+YlLtVTQaZRx!jjXQ15N_K5VWN1@E-Rqyw&Kiu(Zl z7u@#Pp2+>rq9z&}7Daq;#nWGYWnANjpL;lp#`&&FX~vnA+0J>*9$BILmr7VPufHJv z_L#9Bkx5Q7`_@fn@gpS3tTDw4D)`dLy{c=g(BRkn=}U2A4@%z>RToe6kwe zRW!zUjr2nji~7+tZ3ml2;sHiYB+f3SANabIq1n@RP@hI!ZG{D;dRagFCzyz1|Jadc z?t${0>K{J_^uw_RYeP7@45d=A&&_;eA~fJBAQU>$c?NZ=&E*0PpAYK@3_J3Tw(NAj zZCMwyqiEwEWbn-?@;Z^7BPW^M{m7qGIGyDBQ1q$tM-IFXs@u&g$2y(38&DdG@{cwV z@yA9Alz=t=@Xk_z_RXRFOFy2n^3JjSp6mwAO`*49Js%|i>S7#^f#LFrvq<`|1(3rr zW&PQBc6HH%l7q^4D3-oMDVR3=4tLP1tTi5l;rJ((WH&a8eH8Dy|C^ddH5+9%PxS3F zG}$Gf?kk4?;)D%Bf+5KM(4>?zo*h4*34u15xgrdF!i$jXC}F3fE{sA8Pb*p_YS_!4 zSbTMDCu&buv%jMF%y*cny@AiwkH(XTyJ#S+z$u7Mqw^0?mYgp?q}rtIM5~G;ieO<7 zN`ZL5`h^X3-9^kMbPU&eB}7;iI1ETYq_GQ29)Tc(j6cJQi)eV4do|L)ofd&r7L^Tk z!4XYF`%~ebM)D-66^68_m!l3a~V4OL5MZyl{bQ|k$`(t_ezwbfX>C3BOiYl>$l zxsQ^3HtP(UN!2ECN_Qfr|2c_OX`>AlHlwrCf(_veZ&mI<=7*|ZT9m!YAIvdp?ZX7E zr-*et(4#=fL4RQC4PKMMgU^<6B}KYmg3f8oS&8ZbCl(5rjK;590@lS|me|vMQ)5sK zuq0&ArE{n_k}LXb>WHzlpL91+e?4)wv3Rx$`9lsqYm78Pcdo2~i<|d}L|?IUj5#;u z34#xlXoM4cNk5O}hcnD&UrkY$y+md~>4Cmf4p^;F?emz@9pkIsnUhkOnlIE#eGnSU%7;-8Tusvt)VCM|GD}pxe>*1g9L+kfV34@UcSKps2 zB|4b90c3F~4sCqh3xmL&KL4aJY%(n&e9C-&0X+4dtNkyX$r5=fmTkENqVpd?!I8zk z_%I}Y9o>c~u_2a+dQk>PD&5;~D=zCM*2rWnJ^&;Yfjvqb1MKi%mz4cwZ^T=T@JXq& zY4m9n4D@%(%V$-?PG#f{u@IoD1IyGOX;KEEo9^tfa>Kqzzc3w4=qPpMImDHB9bx^l zcy%tL)?8)F@Pt(0H3i@YKP=G)E%5s{BbtmC~ zp$7Aag63SNtnJP=es;CjnwG^EufjYEw=FqdDglO}5!mLpa>8$*%JpR;! z$B!X$k%Or=a^-{YMEwyCP=G(;JJ-YZ+t!zLeekXD0(jt|ZJ5bZpJs-C8P|X#RfwFi z?x33)G$AtQ3$Y9=qamQ=5lMMyMmck`t&3|63ut}6^Qf0iyaG#2?rjB=K{UxlR9DlG=JdY*A;Wg^~A8%*>NN=J^gYV$jEEI(_62b+Jt$$HpLQ zI;Z(iHL|F9wUnHiZ6xQ7^VMvEGn%wTvC7zKO9tgK?hMI#!;$=VQ*+deLLidu+yxtN z0=nZ?#l`g`xlP+TSQN72fjE=`wQ*)-!3qwfY0X@ivR(z!{1Oo4O%8G$uXpy~cEnlu z0rxV@CR)m;QawO{uSJ)xnp4g#kRgQXIw@^5ARgj04A`9h%aQ^if*vSC!ExnHVLedd zhEPn{zx2)_VItw}axBi=^W&F{U6v#6x?u$V_qwRF--Buw>&^_;shiq1!mlAV9qk|u zJW9gwcAi@FX^&e3F=QEF%C!{|s+4hk5TO5M^31pCOKDBMai=B*NQCG)a0VOdP;>B zzVA1T)H(%_8h89KYf{8SlGo37(|)|y5Z|abKL(l#tFQV;At(x%`pHUYIQ>B8AR`(Y z7U>K@O-89PseSsx9VV7(`$Mgbk7o^x>0UlMRJnE{SW_Ke-;>Ih~Z-u z1>8qMhzL5K{mG14Z^0#p-(u)@WO%r1*WNmRppCXux+S9J^#6*`VA#sq|`@`UJ9#71y8c0RVY=)pM?S!7ptAHQSt8&fE zuKp7ZThp=L91??&&p4_W#`K-DhK$<2i4~`jm_s8tJS_-E($;fW>L#99FJwwHC(=Wk zZ=ypGay=GbG$=3vjKysaUupPUmX4+r_iernjJ>X0qQt@Y1*h%c|M2F_JL{|7e;d5da5P%4p3z$@89290Bi5!KjN_v642G zb5$c~_5=Om=1|QHUma`_2?d5aIbB|d1R`U70P5Nr8mO`lR|yl&gN#N=_9xXQ2!e~3 zv2(IXbq~Bq^rfcWytdzl-3DqDGh?!M`b`M2q3o!-@d8+ zW@)V~D>*xx2b{-slSnWIu+KN2Y<&kk(JZ!^(OR$xz$t?z4w>}>6o_(+OYa6}b!}3E z-dPO1<7NZ7ZcTASgA{tb-QX|SH@E7S3`R3DR=VW}*`M$^k|g1QX#m9XqZ~NC=_+3U zbRjGSU>TK80dJ)zsqn*W=;I+mt89GBjVz)o`L99~p!(1%jvjMpG>OOusBPV0MN=q6 zj_ELWiT1y}GC>`_MT_%tpD4kI78G zYWoY!2(~D3%v=2!(~jyaaoFy1x>2zM-?}yh>o4rdgM=(e9bjp+;!s3cBt%-wBAY zjnQOux^oD54oKtWyj1)TkKRTLVB9;`&z@l#cJ?ODK#w)sDT|LjBt|Yzk(ua1sthNBR8^@IhNqv# z22QzoixSc<)-!|9rv}>>00R$zh}<|Ulk53d;{h#vxhB7X1~uh`+EjFNw+Bw{EoV6M z%B^=Orx3M?6&^1(mf3bvy&d>qFG6U@|s(JUP@mM8h`vT|RmRM8Im`_Sd;~ni z+Mx;ZMF&WPj@}bpiMOR(%k9Ku>(z6SO}6m=V&@RR*o_CbsX*{i1#NP$FSm><3&N1Z}nwG$TT$3*59?y7*=_ z=G#B+DtOW|*O_ocILZaCNyW?0aYH$dX5%^K%Cf7|JqCB5x8WP#B53XPrSWn_K2>Q3 ze5-w*j(#V-Y81S&-mK9)QOq70V>_$D2>A|V=5 zD^<&mA&(!^#xU5H9jTdWKpMMBH7;H!7mLTI)n^vEF@pA+(t;-fm3}jZD?9|<-q5Cd z6<^{I?~(t&prS}0tQvkJ3z#K;KXV~&IQ^w^#FBig0{RS974$*crP3g!l@)_{EC@nz z9l9_lKf~b9o@L5Kppg*_>BTZcW&ob`)+rYIfqofGml8ywRWuIa5;{G6`PHlRZPq8j zagEcWO+`nYp=b$!Q3>!cqjl9cZ>6^fw%4O5e;8^8EJ`$60R_&}aDI;&XG}fU+rR?t z`SnIOlV%3ngiOSCv_jX>P6a}9EY>3;Fw|B)~zyy&l+XTCS zM1|Z*FoSCmQIQFm_{N;=lX9iX%UNG&N{30E0&(}F>qQxPe<}pvw{T9Bx?z|G5Wr?j zzezdfrwVnH%n&_|!1;1MAS!*Q3a_N*N?qD98F$GcSobD4syY(w*&7RVjzYp3TL1bU zzmOJvYt!aNRZFDpx$@jl<630G6y{2uy~`H2;#E^I%_BgrA%itBQ9@~n@8?E$=VH?v zKhLA9kT$MqO328`;0F|VQw+=+T5@@kgC+4(d+ zosPR52M@Q%R)nl9dY4f~L8Mq|vlY~sr)>ynee+N~c@Y;+IC%>jIq?MixmF3|@-%ER z#9|!`Myg@Q&)4eN<)x_arYDu;X4gvSc^uR~;ZwbZ*vYg!{K_fZ_A_uu6L)EBT7slJ z+2NUp`fC6ZU}ApJwAMsOjnX)4P`^6&J@K)kri!z+UEQVw$rG#)QoRRP?9Q-S#rfh* z7Zwz7P$$t{Iz5Y@wHr!qjTP*$-C8M z(Sk)LFgfF0IKc%JE@M*mT4^ZtYESb9Gg&gZdPqg9+>F__lY*U|Q2BfdU$%bj`<|Qj z)@Ii9CSl8~eseaqU#n(G5qOR82!wHCrcQ%xv%iW}Aqf_by{S}z`!{Vj!%@&tZKYM4zsGrNu0$WKtPCo80dRH9Zr08jgArYDmkw)8Z zGt`R^523757`ct*;P{$ZmyA?hTbP`+)sO+Wf)Oy-PzMJuk-(f9-hHa}$(;7LO3Kt9 z=`PB!U6xg)*@sDf;563~il`fCpZDfRVKO3x)?R&d@O`^uBNr0C3VF+nKX*>J81yhP z7Mdzu?ojs3F7bzw=7q3CzkfbWc8Am~WNl5YDBq)!62Qnpf#q`g9E40kI^c_Rwm&1t z#KH}#hGxn;DFopKoQHCdfkcB;9zao18;0uCV#_~KNNb-V=?H+8L5AW;*{oX~LO^*VkQ3$x-qp;l6CzAj z?ngib7%uvvyh_*+rs@^z&Y3)(vPOpyf-r!TLxtb|_s3Y+NKByw#%A6)k6**vi>+NK2)%7KXVpX86K`d}!Xb>~TE?=CX51Q*!bjTN#AD7kC(C7A z8K}HLe;VxheKFz(iS2^kG-nyb(mN)BanVkMl#*zynJ%kUz~E>LPPCvS$v9cTg&G-; zG6z82iDDrO0oRTCVrH{ z(LiD3UmRh{TcxD%ibMX|MI;NY*fGvt7BRVxkbX-^Oml%O9rV*LVIZTv^p=P2fcfO( zey*BqV-1h<@itS|W>1gs9B?R3h(d5(KmHhpd)SU>Q zV*g57+3ytM&ydzOf50ynEAEOIK4pRIDu)%&(Cpe#V2YvW@lrY7b)*Dn-(OA_*}mQ74BIU?Lbn?4Sm z@57P1WbwLya}*3iFAj$J;Fm_m*V2bs3fmUoMQ5Q`SgccL0PB?FfT{)5TMMFaBQe4K z$=&dx<7W%9>}qX}VDv7UMZaermgiPwWb0?65PsH(CYL3X4Flq(Yf!mwN(Iw?S=T=N zMW<*q*Rw&A&M}!WOywsMj7Tmoxt}N_2UTJ5BOJ?;@gOXs>wGo*`ZmHiSiqfb>mbyP!}4qgOjThAlntKo4TX9 zQ05p6U$76T!>fpQEa?ftTAzv1n-bnTwWoLsTjTSdke+@W^3HrO=c@$K_E&BdPdqf_ zooJyw2F(v+Ptgy*-RgFQ*vF}O>&L}*c9T}t?yn_`OY9!JkNri5rezSA-jbjn{O^mGMih1yE zZEbT4fm8KEG=_-QjVjPdGl?+UnKn)YvLEn^%BKD4&tnq6ngr?_juJL%OEc!q5Q2$V zr!tjdFay{N@vUV588bh7plJK*7V$Hkkd`DQ_;^AzHIMk#6) zKT61QJo0Iq{UEnkavYOs;2nbA04Y3 z+v`-v@uAaINI?kXmSVnn1!K~r!rV@;%)~4t#wz7RF^e^Wu_gRVESOVwilz=_Zj|97 zKm*Z&1T4gyfSr>jJ9kN@^>2_lBqEvGseG1==NMleVX6w@x;Yo4j2HC&RS%-z#!{v68H1q}(ktENJ{u>2GbYC%9xtL)yt(I1TVWO+N=I_2q(uGli_3^f49e6oaPp4K5K zY2b{Y0TjZ3G825CGlikJGURfL9$`x$#L(CVkN>WQWW+%8A)#qlHrfa2eNC)LM23O` z@Nwg~p^mmuoLqnE+}T8BQK*lhg{?J zKeoCBydrqN#WgO2>aLDKd5~4X?B>8BLJYZ-dL59~19~iH+$LxmHQxKhdD@+xzjzO6 z=1vo>V#vgdl@YI=&d?W{!^Ws}#fQ_dVZ;K@^wHXX(J_HikG(dusIH8Aiz_zJA{HIZ=_4p#co_{ISSHcVIu#?HSxg?Di z(P|!oZ_8F{W(0TJe9NVc?zHiR=t!}MNj250r@F+RI86@Zrlo`FLrGy7$CrkEtv$Wy zF=13quLyfEQR;D1&{{a$%r1sa(yD`Ia}2FeBd2&1Q<7bgNt&>fd!^Vt_=AK-QqVNH zPKDoRL?ReC_lHn(Z*;j>=u<5<2PK$Dw7j=%XYlg9*^rLgyfHVmIiYiU9S@rd>VA)L zxQS75kaTUw>)s-ZcDy}RZ&7cb+khpdr~yYXBd@TM>3;peo~;@r25m;pLDTduBM0hFqwXE3urif`R(Lh2t6}2Uwm4U+F+5C zdX89dr~r0eq64USI4~-n-6j3H-4*^~lugvgs@KPt{V4#l^jfr7X|naar@CZIz}2FI z)OwF8TlfY&2F`x-{pDvYT-_^`hdr|C>tGIwNWulfB}y6i>MA;gxkQN@oaq$5WajGZ z5d?A&SNw*Bxq@STQdT}@F8HAN{WX(#0-X~9_Xz@{}`JU#t2*Tz&B?0k&s)0dXnu@aSRr zK``eUId4&_E*S^%$!j#!U&`h?QUd8zxmRqa0tse~@v8yKxHQu@@^OM>80jQh?KPS5 z^^pu^5Haq-=zD*BSJ^F9(|?{fFcXxs5}{jO=8VC_*jEBkP8a>793LvGThy{{Upx$c zYwY(yejNINlkr1LEAd6llx*S6t(SSrb%pVQ{Wx>eeqv8y(Svi6l#rLB2~amt{|!A!>!jziBG_Y` zrAN0+;G^)Y2AJ0x2K%&f3Erd|Ch(DMSpstxT?2z;G4H>^>U0w*HKh%DN4^BaGywZA z)2rPCibKZ?om6p-3I1+AKFFgd$&$e)Czh(Qa5QE8bWG|*R_iL3quJU54`-6RmYsnn zk@72V!)k7*?|s9arvXmS@4)z4fD zxu@VaDq|1AYKpJR3iMY)0DrYYKHXKAouby{&jlZq4G2S5+vZ_ML*E0iDs@TO4e~Y8 z3=a*Yu2ZXd&9sO|MGZg9pEI>zNV-f~Q4FLfS|y~_kHo$vM`3L)92gL26}n%Y3}jKb zAi1LM=@YQtS!W$_8p?Y)M+A3;{T3`{f>Rs7p`9UaFQ%8p>> zHFz-!7EMnG-$;0=B3=n{(^!PSi zvg>w+34zMAu)Ykk$ia&KmovJ0kMQ-i6#Te<}kPy`x zrT+S3!L#Fvtp<;J2Ia0woaWl72C*OJsXvqn)2>^~MX0!W2_P6Z!KcyDq-$CBIqG%6Jf1P>CpGv1}6U5F?Pq$+AS znmbF8^|{BxpVGl%D2Hz^P)Ne6$aC*-!fJeS&+zosB)D$jk*a3+_YuEU8=MO8)j5F* zj^n8L?i3g;bJaPDPh!OipDIyl%d`9ZcF#BB9F75^kBC~^X1*uqqvRJ*u2fN! z;fq%nlWYB3CYGLz!dBOgPTQ#UV@Gi~#j|`LfiH)E&}QJ&_n5w+=EurS)*H?JvzdSA z`T=)9?cys39~7bM&p57TQH&t$(fSCr{2(BziGfCQ*&Jl8r^E+`+-G=^@O1z@Vuj94 zml-SNPij#~>%GsNe>Kawb);G7B>1ze)xW0qem{fq922-yWClQURAbnJXC(qco^?Tv zig`_K9chdLtsQ-ovj`kM63xPELi=={O{qeW105AJeak8(d_CF;8z|qS z!wti~QObXF4S#(wla@hU*ji>w8(%J=zNO}CH=|@+^ImHFjyH#|I%^bY40RuQDn*mVvpfAu`^wc^t@pQS6DducIaVh zZ)VHGNjP>9&gpI~u-8jKwMhJ4uy4&AQ(7mQvx-TtGr`5P^+mwwUOrE`!K;UF8_wr| zr{sTtA>zILJ$)Rk4pywk?&OR}KG(9*l)`{Mpbth|hTcpIdjCkYpOS9FG+7c1Lnx#3 zEAG+%Ha*am%KXK*dtsvYrip74z-1QOu2KJc^rvbg9y0|Z1mMH6Vz1+hvCq`D=Yf;f zN*lE(>Txm#FT6v3i@OPP0QdIxy9?iRCQHr_O_`9~w!v85pW(h@=8AYYX~ln1WT0Ii z__6h-&#F8eB3*tRB7XVhO}U2-E@>ZidptQs>%5}Hch!3M0K?6L7fSMe$BYCE4G^Eh zi^dlVzmpQJ{2c--7G6yn2BDv^C})WPn7LSy`#KZ~le*wYi+=GI#+yezK)^+6A+^Jr zlZLkJ=4#x+m&gz5W5UKT88ni^txR35RkTOt-`U59O7+Q?!byiu%;8Lw+M-CT{`h7B z4!-$rg{##}T0$4h902}{zOe}$+{gi4;y_aB$EX8Vo%p7}!)}WwrSajDvbAXj_832; zigzI)481>Hu0@7;?yto@CAIz_@F8stq{v~4u|_|hWi`wsiWV{vi=c!$Bea?`c$cp= zGz+ZAP16GWU~Cet{e(&mLvAu{GSY-V3m_8BTL9oSnr}YA5a)wq8e9?yf-9+j3NrzJ zUl9*|Fi9kWnoN{3q)A^Uh0WBUbf*#B)A|~*BS?0MqMHd=c=$j&R0r;_}68>*!ATNw(0he4@7Re=ssj9Rr$y#Yn!Qi_CB9FGm^-`AY=2q6p=^cr#q z8>O2-R!Q=ge+r|Ltj&aqNd~@aMcs#DT-rMce_wR)x{lNtwdb*Hd#k2GZi;gI1(#`+ znN(!95jIo9E7HMa)2*gVZU=MC@m%ck_8RFU4_HG)Ijj^Xidq*`e9ZPn7>#_ixGmi( z*f=LP(juDB8ECptCIt`oDzPabf}i$FUs&@NhCC2W?%E=o(bCe9)#FdM!=r^MqlRif zc1G8muyN*s?6~A>8d2XON#v*6SjJQh0KSks&ybymTtn(!|D0bfey5Xs{1^fPA*ZG9 znHEK1QDgG&UH(im?>e8$0r!vA_bpcf$g9AT-9WlQR^jnqI`t|EhP04_{1ymp>ioFd z6zHD9y@H`~`SFJa%j@1|fq#la$GWttWzUy( zuiMC=`2F$MV}I{%c`lLRXOpzs(#l$EBnH%C%l#%$+u=YkwsHKPEmdZpGMjPQ#Z0-g znWH5h^!q3(`T@5ze zm1iQ?F4l1?B!FWuo-(1{vw^(sM-bfMvgjNsOal|wkUiLJ5;SwJser=}Bn!M!Ez8}D zF4YHtjon{pl+p*{X_N*%UOB*TZq?b_h-eFmcQKgjoQ@7Z?Yr{BG35KZ6~W36s-G;d z*xCfteA-d^yDv83fe9A;>+W!N1#oG$bsz14FYtXZQf{@u>Fa*844pfcio;*m-QYS6 zpfKEJb@>FztUZ^`VMwpt(%^2L#|Jv&wPMQoQ8?Y&rKlYG=|LvR`?i#EVsNCFYOTSNX*7^z)MO(pl2-nQCv}@(5+Z_{Wx2aWA4h4YFidddRvT3F0~-a|<>cP8Pkv zU~V%=DLY4@CqZg>MY>qqlYQQNg2tPl-7L zTu=EK)d<7Le}E^?od|i@1!!MSzAj7$7n-KtGP^R!ny3X}x4^3S80-N!dk~XJMW5_$ zCy|l3S@c)?>+MY z1#H=li=ZI$cpl)~SHD;tpgX9}P-=pl@U(=6c&DKHC_NaELVi`zRx^s&+rsdg>j4-) zpA~DpRrxRmr5<&@EVfnj)dw(y=1qGbDcyku;7s0TM7t$YYHl|tqm8A#vPc=OVxFKB z2CU>RE(X-U1N-DtEs*dHzp}KjH?G{l34(zh>hi0~Dv?NQzmM!~N)f#Xl7o~^m}S%4 zdVJ(ztGS6C@4coc(Q%0M#=~>gPk80*=dcmw0ZcnKpq7DF(GzBmjNE(Bc$&J0d$#l& zh0+DQb@#(Zdsxd7{=U$~;Y~MKEC?*7gkC0`{6L8(4;hLFD}Bma8WeT3u2Cw8hWH>R z#44W=X9=?{WF4Ix^c}XX$iPSa@-DMu7`;zssigr&?-$`#KN)WQ9&$&)9}Z-hz^2{m=foMJcvPCQeg%(%>so~YQ zZxEwYQhGQd)Csn6mLa6XCd-phF2oUrM-ce5mwA|k{cMF4be=qZzb&RLS=L*g(JIqs zJh_>~(=48^-DDpwSonG*tW)eZ0pA66ez%K^nF|hn{4t&fX62hHz!Ok4yfD&X5c_I{q z{I>0A^h3KhxFmtFkRb&c)O`+4R16>;ET+x8KD&in{WMj$sqeiJI4al6ond*~`5y^? zh)Vc=Uu8qDj{p(IvR>G|(TV=?=g1k{a-&Xia~JqT&sYQT&KgH1D`z+TVT%dohyae( zM92&Wk|_StJUgTlpA=+kn(?K1u>o$@lBF7=w9!^h(Mi_meBBw)tG>*1mb^8o3uPfGzOCa^26_wKX1NWb9V%t4`YEFdD1ze$)Qs~X zo@=6U96IB18KPAR`vFn^@bFYfw9R)jq1)O< zuehzF{ehreTlWD(YNRgg4mThCfNc#6DrnjQHL3wY1 z?z=eN5v&&qL*Re-C@*YTO5hRQ2?CL%<71v1zde+-tRo^uP^?6RwSbpUaD0CvGAmmM zSm3v5Gjqn8Fg0X>9~$y>Z|8}bTsoak)cnQUvyez9Pa-IjC zcd`9)TyiSZ>9(43-1y9HpzX|~6rNno&EmC|l$Veuc%Ubc#S!UG8VN#jW!A3+)^l=+ zj)GD3tDKcl?ll4Bv${xCicCRlvMR{EzIb!YU%Mz82nO%yY?tjmp*jX=mkYz^P@7Wa zMbB7Rm9eZQ<)rPyjqi{|$F$5ZIo?UqV!tSXOie8uFRH*C{9&y#<8Kq0v)m}@zHI&! zv7p3X2%yb}X}FLKCOeWj?7h5{2RhS3rR0I%UJ1x)EM*jFKC-o;mZqjCAU?zu?RkCs zAmQvRB!;?0Q5)uihT#^dYq2a&G4SA%g|%Z?f09?x5sReGxY?dX53341N{!MfU?%yL zELq7L{p$Ad;jNyn_OL}+DJDb|^7qeknYdlS=j&ohfqy5-2pkaH&V|S2tdU8u#+L7g zA(vYlnmJ>Fwbiv8@3eY43)IOg<;5ZHq4x3&~j?SQFt8CpOOA!B(i~%#Dv#ELX%cGQVRh zf-O-#0a%cMM`~=t>1wPF&P(r@7X64g;>#aqjTZv3a#s&=G@wh6V2_p4%fB-MWDo-S zGkjY4GTH;FC&jpIQE`nHkN{cEz&iXxl)%jG^XdRk&aktC?c-K*9!Uh_e*f4;@#nd! zGJ149ya|BQ#ZBQ!wFhR&YJYe2V7zq2rwmHcQZ6Glxzs5STIN%L{Z>-cd`c+?d-)x4 zYk){@sfT-trFE~VL?AEVK!ZC6)}<+DgzQn6dO*R))8+;GT0l5#gF&j9%=jP&7naG( z2d`leoRE@aMg|Ze%W#VS?hi&%hvbOu0J}}(h(H;_T|S+oQA*W&k}i*w|Fwi;>%LVblPER`u^LagJSwO1y#!5i=q zf}xo>$nch!9tsWMvKYITVTqGQ7Q;N)@C^m~oTQF(;C&3r7!@q45qo#gQ!jX{xV}JF z`BRHr5_c0J?V8Jj<6%O!v)f>aTUcNZDU)!cehh*$#b7pDY(?*au|#GbNtDc6zYIt@+R`TtZNZcxK7~1kc!y!#@Fo1A|gj8BroA)$(}?R8FQ9a*ylA8 zl0rF!8$7DB0P%MU5Tf6AF=;rMoccQJGK6&TgZ65shc)CHL5rM5`wl7}qoXZSusEtP zJr>cS5tE~UgMAbPJ_!FwX$IYp`%w<6cENGo*&LGUu<+3Y@Ggx}M+$A5X8m_e{;#3|`0>Z9DX(nwjB~cws3qx_7NQ$8h z$VO=xK7xGY%8_Finsd{U`W*iMODs()#&0^L3J(dt^$VpI2q3mpojLEq34cstV@sqF z27z|_JK9rxZcT%$Ig&!uzuqf3f`kc982Aea9};LSW#(s{v(2eo(OB2ehfry+=v520c&`& zj}u89O1nrx6iJ9CFko3UfdSLOfC1ACCdL&z#<3kc zE*Lkt6Pu8GR|~-o?!6EP7aYgIhPcYHiC>DJgQctg@66qmRv<|7UcUGL@;!7ld;83p zGiS~@bLO16j5EfP@S|syW5!IGxUhahHDi1ju4axMHF^wp;11($IQNWgIeYSy(6*oA zd?RDl&&E!k+EhNWVk={|xws!bd$K>U;nt0l8B28GeC~n^=B+-epZ#N;ufscEF4(Zn zlXAav4`U8`KCpQ8k_#q>{g2@M7RIDSOXjUzjq7#*)P=oy$%;*j@7%t3En_ag@WaZb zi{>rlZ?j#D-8BgJYnI|d;$z0!alQiQc}p)?w{i8zahKv8W$J#sV%36qyMJgcV^ER%QIKPpx`@X{So|W@1ShVEZ+P^V&zm>6M+v-(o*Zp9(XEddAK*M=RMYd<54)Ch2teiD|)_V7qcL{ z4A(A4x&rA+q^pp&B3+GiH=b+9{ywDpksd&L5a}VLhmoGd{il(hL$WegPcy4SDMOHk zAiSMO!4cC8$PGtm~K)XAOYo_rRls7TYaa zhzkff?zRFN`fcdh%6_jN1%yrcTyJg{vMgrAQ}kpWQXR@1 zf;0@}j>7p29M43Wh4Upym*LvwNLL_TiF6gxR-~(u?#BIg?C(RmAL#+42az5^dKl?R z+k0O}hg`*9&+~Zd+nzY>j&?2jOV|3~>N^tmThV5WZAO_)J&GFd z(B48`kg@;ZUmR$q-yh+PT0#4Z<{3E)qJJ>ToiKK)QcxT5{>kl#JEHc{+)uq1Q1sQJ zn95bZ?aL9hJ%I|)HX39R*zpAL+wZAjQP)<&yLw~Kg<31(x#!UuC*($uoq+9r!1nB> z4bSWrErhah9HF_s2a$6Wn*QzB4-3cxEl7W-#ZClz(E>q&S-kO8&jCQ+hbfWIX@2@s zu4wzdw+Aj?t5>upRL|4oA9E`iL!E7w@qgdJO02mwly!M;h2+aC>(o6J2j+ z@i?NCF0Q0SuDb=-BTXs#myR5);EU1f*#~}fS0`_6pBsLsdJY?Z0lsFojm5sq>7P8Tb+Kk6B$w(`k zh|L69c@B<=@0uYkC*ybuHZz-w&B~@>OMnEOjuP9j8HFt6kf!IN#97!RHXB>6w8>I@%p+ z@tS!Hm~HL))oaoJBO@-n!SSXM@6jj>x+7qwk~ru^hhHa>4d>ePbZ6kJ5-_P_o7h^^ zi{r=zj3qOj{Nd0d`!Pqru5Q{eG?hIr2N?DFOwAzad50^V$guC^DWKka$uv3pWInUUw~VxH$c zf9?6W=eeF|d!Ff8*)zVoyZehHFCKa3$dgC*A9?)9-Xpt@JapvpBh?>0i&|)M?Y(X3RWy*6caw z&7H@t+Ir2kH{EvEeeL%@_`pMt{B-A|kNs@d?w>0iq43^4Pdxt1{p`Ypi_ZUG!@aAP z|9<^4cJ+3)hJonC--?Ub!}~5>AdWBC{JZ&=U3u#>&%XW6Z{C0R&@b52&#|K)euR4$ zz4u#o#kR|@`{DIB-1wuP+`?|&apxWE`4?8>7EC1KkJ_C#Nu#-odwDUh;MIH>Z{bsT z8#f{qqMh3K0=|T=WS_H91_y(RT_&@nv*ZaaZSwdHGi2s#NR^GHZNq1XYnROMyd(3Z ziqvwMmwA3GTT9DjsqC!Qw$Z*B-f~%2c7CcyZft4u%8fJ1WqldF>h*aqZabWDU`7U> zYwOPVdPauND;rAN&@^S+6FY>rE!35Y6LdGhsP4je4ay* z!hN2$vnFSFWj>>A8!9x;x6S9-Hg2159zjCYpPR-y%GdQRMbl^Op0sz!E#y4-- z+}N7Xt4U?3#I|b)ZQ~dEwwYv4OWUxFXK=?=*1;NiV^b49YoDDhVB(h^o(jl4+gjUv z^8vlDDFZw1YXasQTiZhD{UaANg}8@fCwmsiX^S!iq{z`-CgUpbf}e7tO>j|gjYM#y zQDCAA4O78|AcYmq{KG;feahDX#c255u#ir|Ayag8*+7>=CSz*Xun?!~L5J6o?{#=b zNgg$iZ&#NZrXGK6l;E2ZI1%IDf$veigCWrvD^<9zGh~ohsrcct*)Ow0vOb{b5<6vM zKrtnDDi&VK6a#lSWqn;`6_vn|+IgG06P=|=eTwhX{k|)k>VPtIhxNfo8N(QWVx_Vn z7zQVd)0ZM+aV2sZDNfNjI%S<*(eqNpZjJl?+p-l9Un%gbg}zF)+!tb^>?|k{X z7w&v=tGeSl^)Fl1JFeq@;f|ZsPHy9+JPRpJ{hX5euKF?3pSX<@-J^EL=vTkj*b2?* z3MLQshxG}}0%Ya-!)XF-Tps3^-G`L?q)s{Ct_NA1b?llJMTWsZ)=-* z+1SCEeotO%QKHLRJ^bvY!>{|Kc=z7Y=dPGJb8bVq%bSy&WzRLISGUak!Pt90FWM~^ zyi4tFfSuqx{rlY(E8d>9*)ArHfGkBhEj>F#g7h0VVAfXwpsFY z38i71IFtRJLymB^IOcM|FY`m;c)P%Uyj^kd(y&oGGuo9*oE2zi1$LzjXI^op1c7!( zyu;aH(WRslw#y1|lA4{Dh7+dvQyk7vMy3}iS6nt6Gj7CjWtG!j6AUB+mA>30SF*r) z0Z^R8gFJ8GTdp_mYk&Rq_WM&N)(@XBVR-$-Y`x*|_gzx?>nB{-weh82ei`ogg5NoD z`SOWpuejj*hYdT9FMjXD%c9RV_k3*FW!Q_+KovCP5aCcMF?EKlK%0_e>Yb`*ZlIrS|3++ld(2(Qk4CR!^m3B1dWLiL!xKwBXLF($1@>C$j zZp|wpYRhrRiG-RG++%fehC|WoK#@t#P@=^ykds7&SD~vOlot%>HR7{LZlKBQ@VQ+! z$(Ng#FOW8z$g=sq^`&iR2e|u>Z}KF+`cdAZ*%hPm919lc^1GU@{^Zubsc-R?i)U}S zOkH*Xe{{poosyxX`NENp|M9*3EsJMoRr*s$&rtueX-VkElfQqbdF}<97oUrM30}sJ z3SQ>dI9Y^m_2*%FVwuFlL^22lLd*+{OJiEVF=x%{M>@&41LNT&#^p5ejt$H;U3-2| zy{R?{vjff)U4=nv&aOIZ!u)d0TQ`z>|<5Otp;chc;;p5Rt0Ctv+Y`Y5)XltYT8x18FfdV>>P+f=AacG{)Z>3{(8e3gYUn5*RD$+)XM0>WXfIoT`V3W zLYYAa2`b#sDH{UlLPTRM&QcoUj1IZZg2JtSIqr}w1r&?DlVpu0j_z4Zcr4CBhj9#4 znb6xrnuPH>x_BLU@i6rz^<8N^Pvzs)z3Lb0UOrxfV;Y$Ce!OHy+W`(GUXM=T@GDL& zqk3LlTL?{ZP>tx#rfJnnva>73op<%DtqavZd4C!(>rIn}HO*PrGUqpEYq%S)Z_v$$ z98MAWp;A;aF6;e}vm}57{pju`VAL-JzBl)L4j77AJgjUX3-wSPBzN>cR2@`k1Qk-! zs#rUym%$WlK5t~x?Ac8t&%3s1&K&H{LmT2xUnuC?qiF*|B@omteqsQsg1Rgn=Ht5? zh>bwb6VF%=o?*vmwV8zy2qL#t(Qp?~r#Zj`^@arW zbEafMUZD*w5sv7r=bmitbh{+IFSmko7YU?A2l@mXz`9)r63=~?XRt0|C;*EjyKhxzqbB${^&;Kf)yRdLMsjn95!Q&<3oKD zVYv_K0kQT&I!dIzcE7AgUq*ic?^kqsAxo(}IH^5@>Om#BHlE0v`5(Sfcj|Rq;yFVy z8g#q(vEz%SQ0c{I<&Vf{q&8j#-2MdkDTZYu1SwytWav5-7nBdtQItY6P*mcV^U!Dz zk0F zTF7k357V-0p82cKcy4OWh>AJ>>fq*4lEvaJZx}tj?9bnSvVdQ`V9mnTTbuNSp~LF8 zuMS=^aZ2E<-2A*L<*1A#=_C$?E^RuWIep%|k@Lb-7qqqhe$=Iutze;Is*B#z8A=z@ z!Q2_P#uukU!?KcSC_^tjq!ggh?Iaqqk~%~7EUK5?ih7ZV$RbrF*GFw15B#Dl7ohEB zt3&bPB8h1Q;2*iWX3CtBO=0y{UmsAPuvuBx%og1pbcwcn5OwpB)(k^2s2q|$f!flp>kOw_auU#%snnKve%W|P$wX(! z2h^EHw3{uF+RdVaZpnDOHIrm{szY%nYno%P5@X6w0&g`@S4ja6%I2b(Dx_t6*pR#1 z)^3=3bAkHaMRqW}%a1 z*#-XHV2~xKkq;fL!{|seQ!U&M*@UVUcu-3>10gybXed#wLG@BC*k4M$QLBkjuqI9W z5M9pL?3;Mb2$&Sss#i)p!DLT#XWDN$vg#JKr~S_EJNT?i=P$fu%YucM@WZXQ-L`2u zU#03L9px(&$l&tW2BwJ$npdoHOMr$vBU#?^0 ze^wPB(h)SFL;pUizX|<22R*!&UCT7Zui6H-2cLQ`Q(cY;*tSV)i0w@O@9htsjDv3`d(q-aNK&wA%CyEYZ8M4X!2SfTT+BnX2c4@_`_WVDWP=^rQ>}W?o}FmVD-Z^P zlihYD1IRF=H|1jQM$5@o(tJDg@%98%n<=TVxhV-YAS2tMFtbK`#OzRMyAF+8h>=47 znit=~*?o7aJN~HdRyXk{q|C`1pV}~-Plytn?)9G>y$HkwZRT@zJ^xPfwQTE{cJ761 zHBv);gkGWB480-+R{vgwLU#L=L?X3Rs)1~U?E#f=iX91a$i!If!ZDDhaiYc{-5OOr zs9fk&M^UaFy||3Y>3+pU#bxSpO1HI9GF|4i-P#T%fD zjuN($^r+S*6gFySvtL+Ah=Xg^kuF_(*IZpYdLxbezoK7Kw>a#u$Mrk4^72ud1y@j% z#J5UW-5(#P($oZ1Oe1P?=tA_%EXW~f5wNgegaxgSG;JlF6bJ~N>_f6Wpm@RFYysJ8 zS5km6BQ!0NG~R6D59!p?(sRJ~`H)MC?knTe{3vVU|HsG2Y@9f&2!oZIdHfZ*Lu+l0>RD6gb(NDr z2>61|V9W>XBcZ#$$3hK&Jsi-+<oKPiVc?Atm29@qrf)?rNTIlin|?yhwfJKaQ!dUf*@s zsI{X58M<42XD@$bcDwrJi>sw7zM#H(o{nb+E7R&1NzcE>XFR{=W%cv>hOXPtHhBIh zsc!y}$DjD5Idi0H8$F&UeaA3D-}2F;m;0z_9oZ`laVS3#qh=4L z0z!$@1MJ35p@S(NSSHd^6QPGGX{4`c%+`*ckQR{bcEyFpwn7ulB57oZFkXWT4N8Jt z&(^#Adkc5_}-(7_muNlGu2x^dPCjyvUK2Hp8Ue;zoLF~hx!>$zwg5%_o|;6c7)ZAx9(B@@{7g1>FrR*hrkWmS^t!PVQj=I zZ2<&A-O)oQHE2|3AS%NMA83L>Lk#c5(BBeoDaDvy8|OzxzBF3%g0E3(*E_q%NWSjF z(o2RN>QjGE-|7a3B0Y=By$9u5SYu@T+gm2)6p6CUr1iuNP$tX`kpkm^3C${w;;^;r z)b5#*ts4Uf^(jc**Sq1qBF0dL577Q4Y_m2V6obN0A>rE@-$x1IwDdv)Q8bB_(kM~L ziFO5MWRi%P_RdgNCb7n>Gz=(Uhg7l>K`a)7Gp|rECx>h%hF=J&iCKSQY#3Zcb=i~Y z2-Uf%sSnpkV&$ec$(OdE?5 z$-F_-M8kbbn(2jdMvlVFf%jb)YjgtcMELq?Rt~be&^kbAwOZw$aC@5iOTiJ`yutCr(aX|^VXTygm&nPyFPwfJ-Gc>z3>|Lp*$D7EQC2m zwny-kpzS$SGlJSBkfU`(F%B>}sZfAV8uCyYKVsAZ6@#0oJ{Z?aJnOs$K8rux-7YOu zm#dRD8FqZRete`7!;%5as&9))ZqVF-Gwg(upppGk_8?3(?yV zs7YXO{(dKVnrM3?&D9jbYeTD3;)!)C5;>AdIX6JYWa2Z47^f9uUr4&LR43aVp*R{R z)A&J70EuhW#y~<;n`cYWS_9>SoDHC33>7eWL*gd|QW|&|$rH-!ZCuA~_2oPPVsN)f zk|aK4q;6-&PTj~Muz*M=^xTQ#mZzsLAICe6FXnS@*p`o1?CoY48> zq*SY|SpDsl>hlpDEe$-$0Syzq5-u7sHoOdyO4*`WoDiZ;yOIjf$%dDMeJbRWVl$8! z&42|@v0w}*6e1y}BBB6nBzBml$*DK^)K@pWsvf(8xCdYS&d+wg`|j?ay%P~qPpLnB z=U%n*`3u1|-q~~X=$^eF(agS(Q+kq97C<{b(vyXZazH|u;oD5yS{oZjB}806w%8TS zvMB~YEe6bSq?{P)6bUBC=xiqW@_T)0B<3~g?&D@&uD-2)_xcM9FT8N!3&7=Zb&&eK zI$Wop*^W^l!PBh%$r#1mbd1tTTmogX4QddXhx=iUU`RmwC-g^R0?h^)+?aL)8r?Wi ztk6GcHsnNf!h;O0U%+_GJW(GyF%h8d{G0mRfY?-zscUN0F3dUcA8~shN+YtL=4un* zXLD|ZdM!as^t*vpt4*NQN`g08Py$r~!wl2|wr_z}8g4iffX(h$STzXr1Z{Lzo!9@_m4e_Jir>6cth zE+8~V`mug5Xtf%CUZEgSsvZ^}n%z@!On|RO%#h|{hBQ~35Us?7Xf1%t)h0w`lVguQ zAvLF1%yw2fm5fY+GzTU~ngz|stke{(sLe4l`^kD|pZcagN$DDB-ji2<@*1xiG{C&4 z`r6+Pt1k~Y@A(+(IlOD;$&;QhegB!LH@vL$&?}*X4`CrV@${L2U}O{%=#V~8ZbJrP zJ~lux2^kHf9vI2qNOSkvsFXy!OaDuC0_@ge*8Y3!iIzEH8a_5$gfi^#+S9mzF`|FT zAP3_6G~E#ql{8ZiajZZ%3nDN>;6dMyl;TSE)DWXWm-4W!yzM6Lxe1)tpqK^#MK`<>OC`GZHZaDRlf0h_h6-2F0F4tR`C-^cV99n-ms&qbIjJEL${96rC`QF&=7pZFn_@cIW%3;yySGP z2st%clqQF`yHn;`UrhrUK?un;=}!zV`MQL;OXF;^*)GRFqvTuuCi|Xw;`yYn7HgNY z?Q-TbiVc??&pa_a;j7nhIUWypSj_QBr5$nf`^0lczBY^NHhV{+&4KH7`jxZo9a-6# zcwqR?j(s5>$hUXo<@=JzejHCuCO#urM4cR07s6#6h46aJb$eY18Q?l=w8h&p^I?F7 z7gtucFR!BCA3yzVxiOuC)q@$O7g7&l&?7sHCaXv5AKs)W=96L%xi-jy#n+_s7V}kd zVrBx`BQf9o5^Rp{yhNNNWF^Xcr8-G{@?BSsl}korj_X}@KXkTPbsKAIHw=|ByFVGa zp|{y=>c%<%H_&*ztR9qryKZ5HL>*Fd_Im*!n@1)?~v zGn7bt&_?1f7ZzJ8!-na0g*!Agg4avc!YWKmfJf(zFqOVpx-@xYnUt7VIk+*c`#`?05XX_x?rm%JJP|?~*XXq3MF*B;bzPH_=Ki;LnO`rFCXE-QLGhK&w zJWSU4!#v{oBZer^+GrybT`f16*YnQ##s@!Fk7I`JjIG9W##STD=l>gQHKVmYCHj-r zQ^`p5uQk}5vDdUi&YZE=oUzx4ZYH0x*POA}{MYR@XUB5v|KE%@XKXfSY&IwPs-Lmh zVBC4eW^=}7bH-+)86E%k*lh07U2ifXwskC%^ZiO5Y&P+JC5~)1e!pCFh@!u;VeYpF zLfJ)RPtMNAJbPR~sf0--y9l-r@>z?|gPF-xBqo3A^}{*rzK&d*l*P%*C6KMdLAEaF z@Gu9W4y3|%gR|V1$s2je&}mc3-C4QG219agmfKS`VQhtZNPQ-wpfEu?D49zeE}r-z z!fb2Qr`^LYo40Y&C8Nr1w(?PzOxiSQO=Cg4`ZTX$JugnYxS<3_ak9DeEakh6LD)}H zU?6BuBI~!oeWFTyY3~ zM8Z2eDWFuN*2W6dx)8NaCkvy|MYT?G1nS||0w2)^UI7H4mOe*s#dB?h0h`Ws``6pg zrn=b#0?yw4_3ag7Csui4F)(qgPknmI?Z5hgRx3jU2|xJN?NijJ;|oTtnRF5sQ17)8 zGYp3xT@GqNlQcQ-NVau$q{k(jF+l?t&P157B7tp6dNL}&>J$Sx9^1(P35TRWwgkr{ zsoG!@eyx}^mE3FNC#<+|NaJ-2&d)8X%ZTThmfG>NXO*}9{DzX^y3BZKQp={1-Xecd zYH?BWgvRqnRk#`(Qi}@3@(TmT8ET_-F-wNgdc-V9Q~HrOLz;glW1xbFc#2=sJSwgQWCAr9%LJ$8rL~Bv7mNOa%2Pbf4hPHlwcdhX{w zN3gH}{sJ}G5_uTGik|~VbZ<(s(Ig@aV5@AO9JENA=i04Te0s&$yY9O@UHvF~!<4h9 zm~H%Wb-QHB%a_dNtiqaMXBF^EcvIqx`8nLWYtwHo)k!674`0yIHdn7-JMl;AUtDLe z$?6R>ptdAG$5w;O;6z&%BJ!WSn{zCPbo48Fn%TpYOd8zK(Q27?;X50TE{!P}B@<1y zM{;p@N(MDmu0wI^(SGsHJw}ryA<-^sor8($Jqb3uD>;Q8%7?3cJRZ_x)=x5;E%YY3 zK`nWyryw*56YCV71V>v6QNpx)Z9nJYo!4Fc(}!>R(IeMSn|003Yqvdc-__Ub+&XL8 z;hUFT@RM6soc|O3vYpq>nswdI>#u&`p&Rf-+cez2>A`z{q<*mW#v9hH{_&3m-+^s~ z<_t2Z-IHiePyEEr8HC-*Ner!S3x?gAZ=^jCPEQlptif=)b}bIX01{6+q&P7H=u9FC zaN0ou@d5ZW(pi!lX9!9FwS#RDjT?ZYelrh2x7Q?mr5xUB`0G^%`_DtD&xX{!rF^}* zRDD!k&exWz`{d}ngz7(Be^~YNgV+K3J|1ksJWXsTN8^Dgi5F`Yf8xbj=N5sm+ojg- z-TE7(;oZ*@Joup)EKGES^ZNWi-G>kZs|-WNg(zc~nEI8+ z1e6+_1p*5EJ!$6dSlV+pXj62FcG>!j(wO`=dDJuD2^|TER?NWJ=vQvEcZ_Hph0`YS zJCc4wxDqqR)>J2ttP9~Knux=sXQL%?6jn>1#SePt*!Vyf#jM&e@|56k?NCgZRNJf1 z$}6jzD11ZGT zq16jL6V|UD{-CV>=Wm`=zvT%D*`Df>(J4z!4ts8LW!ezi;L+SRe#E(h3Y}T0Nv^~+ ziz6#oH+@jk^1O3y*w}IF+VPDeN}} zOK~M8S`th)9URn{)bpJ&U)N%4g-=HkBC=?z$Qe|0X81{fRy3bdV&6uh9=ifZJH?KM zCNI;%W5e|64I}u$>5UCDW;8S!H*c9SW6QK@;+J?0#X5W(@!KFz z%p0O!FE-5sFVeBXfifGM@FEV&VNZcL^F+uFssY@Ootncj{9@p+87|hmjf;iHHi2LxX#D04U)<1Ee;Owh8t3cuFW5jW31|Cw5fGpH6G z#9Fv;iiyMz1;PeuQ^-}X&kdy4tELN~D7$%z`sHulQ@^_PwHp>cR`g8ygr+4u?!$8h9AF99SIfsvMk9q`QBLy#C&=#y~9oIZ%QuW-6fVW~EmR>bHiX(~?h|7@|A0_h;%820I9%;&+SHHp_+c%k;&&X4X_U+2Mn+oK24K{aPT&*%A1sNU!i zXazc@^v}j=>if}GG3JCHKLv#ql?a+D66gvQl@PNoDgd+23WRe4;$BV!mBAC}4ZJ)` zZzTa4BnM$1&eaGI&M)xDi4x!-beUpAIS~O?I67=_Ed`y)xz3O~Pek3NIOKe^L*_fs;+$zsD8v-u8rJ1N*cC=G@mQY%N0tBrW`%xdgQ{l`TAu-7%@Oxg_+*Jl zEGt5ug&U9sZa^5Tg^VHykvxG&*Cq#58nI}y7YZKvM^}qbmA(LICxskKv!YSZzx*Y^ z2>&bH0cor8TZ|W*7{b@XDH;Zg`!I-6W5J>5dI?yc0^>xcq>##y2oE>8SOl?FXnd|7 z-gZPjMlFc7-Y}E{lG=K+h(SSQXL0gl8@4>MDZe~zNERGL+?fR>gVJYq?>=tGkIS~W zP4POvFS8^g-efqo->2oX@@u`W)$?=|&l=4)J3Q>ps z(hk(22+_Hrc+w=|v|1EIYXRLeoED)7#0?q`MZ-uE5knBp6x1PN2Sqewjz_RDI6xta zRXAG5JCqzO^dLLY!;;}(M%}2EeDzVUQeNE`#9A1^fYB#rt|7(>il0cnu(W1K`Pi{} zg95o#Lma%qx`p=-a>qgu(N#41g50GKq7h!m zujjk&gPc}Xbg~hV2sg8_vrlYsIf({TVVl;x6gFam5(Y;r22VE}*y?19Ly5OibLwh? z0W@YImWMIbfP^7}&7&V5>dE+E{u8C=ZXLUPRQJJ<-<^uU@U_y$1!pfS(dy*V9pFce zpTc|91I^ee3e;%@!ZTHbnkyV56Y`@&u(=Px=CCMek-sh;xbp)^uP2`yyU$&0I0y&( zFZc>~MP9bql3bjWPi0`eG|1?;;lpBqH&Pl~s;$cq?WuA8aJ)wC;D3$?ji(FIqE%eB ziIAD-+6@$~h$RJ`9g;aN9=#Uco;cB&tXi;Q3Or~PL&WR1#sf?kJq1F1$GE7vUgt$` zyrKT)b+>e@>YLoqIJtF1!(@Hy_E%one*4QWcmM6c0qLHR)2EFZJ$*WjANt8`3khw+ z$l&fU{TT~6iJG&6VlSKq*j)>!2I2q!bSI1tX(WJMb6V>$G2HjTn_ z#3(!`8LpQU`${Vagm^q$)M?F=P?9%5N7;yZh4F|fMIInA1w(R~J3_h&x;a4e>#!h9 zel>_9==QmN)rB-9hpRh{1gbRxv0)V4pG4C1dMpgXU*`AhoHFJ4os!XDcc)uhh=ME* z^PG6MNxzl5yFTX^fQYg*BKrO>W|yHG(T_~u8UAx!wHD2fu^GIRJkIcG@gL38pocbKaOl=Wumsg& z70fPel?AyvC{|ktl|WQ!KWQYioC2NU+J@pZ5N_2F5N@rwBnJbbhFYS<20x-E3v~2A zB%CrFA1BT<9>C?Z{c_@=DE5sc-68>#FtVUsZ!;A2c$T}$$=#(8GS5dM(lhc8jLKTcKYdJzTmli6J zO`MonQc^W#YEZon;k$_8GD4p+ngsui#0HX$rMWD4(a3WQI^Jf_d8(>OFQRz4w?h5x z!9S{h;A^mk+jV0$O`Kg^p_6V>zl}>;Q#@i=_3UZ$TAujrA9YuYcwQX|7{jyhPc%U) zr(o?@p`}tZC~jyz>7wh0jn=-9P>ca7R9xZF;axN&lsp(?TybN=LVe`eh>+=%fH6G*V_{mszg(vp5(j`u=uQK`bO3lF8GIT%+4}H=IR{8v;0gZS zU~_$;vpRU17M?1A*3W;!Z+hU^vGD`IbrCtE?tI~eu7+N8K|j#iuobY;N)HQ8-G)$6 zz*!L13+rM;YY1h=Q^(IVBk<84pJ^_Q=oKM*3SGA+k)$m1(-JSJ2;`bv5L*#a(rBKc zrrJw38xivCK1F2k*1gwPFRCA(T@>JPzqmfQpy8~XqQKArYU$jz7jqDSf^B;WD+>b! zkayAWVJz+==#}b9(M^R|Q}&b;>+G#9V)+V!N<8ZAg=H0nXUieQ2I~_vBMN%Tix{45 zSka<`n~YA9K3K{uqfX9)o}@P<;R0$8le3%}Q~N$!RZNZhMvSqf);zPZVcN8Y5kHTu z?h|c|4Q*`=jl^w^9*r2azVD3IRu^mE(&~K>x^6aNO;<%~4Ig>jD5XWKl2E%Mf7ld} z$p|rpa+9O6`W!ng^%5Bci_lVvj|p)H<_d)EJQLO$InEhMutR?#1qLJFJ^Hu=o|Y?k zQ5CJI8db>A#rubU>ta+xY52$%8XZq;8ZaQduy@3~qv*PGw(QxnrDa=5{}^%I=F+C7 zQvZk%sF{dWH{B0DOY4!Jr+MPbEQqCQIy-C@E9S!NV7kJuI|;LVIxGQcwi1zxsA4Q~ z;Sh^l(Aqs%H_YrHnl?)mj7&dcsP=^RLlo|}vyGM&qyF$6%2g$RcEh1K9pOZS!18jpw>&jVQ^W<0XQ!>K~X6S)|-AdawiC{rPw zGKhS#`rOOjnOloSPYbAGob$VLum1AUc>~0h|NKbOOpJJj%^Z}b4S?dETb=^ONv}tI zH)KaVS|<`ENe!bl$B7Z%=z|c4r-|^UmAMcF7_lO16NO^_0mw7l?1sG16J26eha_p!LN_S02Y-Y=w6T=S{t?kHaDcl4>Z1VDvV(<2n@EA zM6jAPG5vgcP+>igowP_p0(fnLUvXjwg93#XV%kr^nygr$6%C$9gQor!VZC;@zG;Bi zdQAgA6;lGg1`nkvftU)OFgYOg><1&s5HT30{wu`wUmzDN#6_0HRZL_j&=F8Vr9r!o zB8pSL;B6YM9rqK{M%zw6-jDtl^A@TJ@}3}Q$A-KG(M0p^k&*YirUS5bTPR{%L*e^Xuc)^To(ER z*@(0svZe`>8qMM)YqK~GG(9*g%tZ(r?Jy?9feUjqEj%qSrPGlpF1XOZP!hGt0L%+v zjZ|uC2UZjVY%!7(@b#T7jm-4OysftXT+iP=Ab2A(5_pGA%jgnvA(K`R5$hCUp)=to zprj&jfU^XwKqF^hZAnZz6S-n3jzqDFBrPS98VK1Fg@%)X(NChC4im|q8d+e30;0u= z9U>Ur0t&?l-T@AvtqX%?480CRbV&?13_H#1q_uZ&`^#7tLq5=bJ+$u(u`Q&h<=62q zVKp9T>Lvm?R+0tUW(D$QoTfD_B-&y%&4Fq&4P&R9A3XN;ZKrFHEzv=gdQzLTqE5w#cDy1| zr}Ai>f>7Wvo1pn@gbLi$(+ZsEf$8o7^gyrBxP6?%T0b9{g88{JsJNjfl!EVK`E6h#)79CLl*u3~$Wbfe z@&lZ7R9JFxu^1Pz9AO2-Mi59Urd6eFh8)esDIbfRowA$usS2^E=({=)oeYl*$0~dA zz#?O@0Xl&G3gKtawKIYT>APOP1I~`K@AUWR?}7fr;BC~q2=ehyzxw*KV_$vthc7?v z)P+C$^4MozAN%y{&QHJ8_}Gi^Rd^G0;#|gEM5ZU;zgbVcO_H zxI|(38d_*dI7D$*3MU5yu1#tcYDf!hpYZ2NKNsBYk?j-yG9kMUG%2~Oo;c9JU+q6JqaB9q{RuoTF1YfKhO#VhJ_-` z_P-4qt(4FK6OV8#jCas#F9X0v1BR1eWD+6fEn}=K!-QpjEllk(64yGA!t3)6tcz`NS@O?o;MN+eiBLa znPd6}5+_yfu$c{BAt_t!8UFWS;`5nQ!AX^DW%K z!#XTf4+DuYA%E$UZCCEuLwb4Yh1Kkko>vjAf$n;Q$E;Cv}q z`A?W|O2}@GrKSN>DR@AsotDwZ;yImSh3WKCvV)i$qMunEVyWd6;tSx0CE#{ucMfP< zj3afl76M%9Fpo=L6e!H^o2$oqn2{wD+6}>1-GMC0{21qBFMn>`1M1(#^D$$mpF3mW z%rA$HfZuDnw>U|x)^KIvg#sZ^CJhcwWE?_NtX_N=B@P}v$y)rYW^5I+Bjm1*kc-&Q)*uX~`^xAi zYodGY1AOW;S~S5N-G`9_vQ^Ri)*1Ue%}AVVV?JY_?_J;6aK=6#SuXmFeO`TZ%D=aL z9x+B@E~8a=0D0M(Q_W`3QY4k~;X|A;WW=L57DI4+| z>iN#}o#B2FL3F7$^NNrmT4NbLLYntbHfFHRfpA~{q~=vU*2=T@TT-9;S=a(vcZo?jWCZaigVI})|v-k zFya%_>-tCYafm7XO81ee6+Q@9BgqwwlMT6aM9?lc!gZK+E_k*iYMw1-;VWmxCz-?& z02KZK55oZ+Qp_=$a<9Y501jQTarlhpZQJ`kjQroZSFLyIXk~-QH<%G)%1LwVjU(5J zS|e492pBOpDOH;u{rm5j;$q*?Z9?!}NX&CQ?F)XfpO8i`3Ixpip)DK9i`0$C}!!7w6jItfiUYmJ+Ar8K9B~$d<;aQA%HXWPxx{?wSx~a z9OC1za*7t0l7-JlL*@QI0oX|mcp_jL-SIc2UAhlgJfamvY_=Y;*+hBb%WPqzo0k8G z?4n;7ATe1C)hnWurSj?Kr;hjqd{Ct4u*}|H5UlE6d&m<2b)avlX7%f33r zL4M%$$yoqW9mL1qs)IE#pS+=Up^UB+{L*LGBOe@Oh0V*B-gFkfE2JW0S zcjplJ_O#&>5f7`o2k)G_WOpTRo1t$1@K5R$XJK`yoSefS^7sS0r`3;c9d|gcB<}Fo zbIzSO?U_%w^+WIomyQ`IUfTq(kNYEEU$D3l)@sz#XCv?}4-f!3enc*4$B_!tCmP@i zf~6V^A~FiE)dHR1F#?aLaEcaAL!TutrByxR@Wm5+&$`2&=%sijIR)Q> z7M}@X6y};}k9?OLi`4iKp^uM}gJ0+HU@d)h8Lr*Z*Ys@fdBofxa*Es(yHBLA*eJ@461^tf&f4{F zv3Ao2R;%x1#ilssGVEf_(&gau1*{nRQ*>L^)*uT$;>3L}u+l)MpQ9g!SxlzB5H5*spooA5GSk{j3 zjy4+`P|ifa^C`}!;oOX}0H0wcU^xA*Kv8%)4nM%s>bdYYs7CwO8L zU^-6cq7A4WqKVo7bu>PJyiX`Mdj2mezw3166D^ppVa=52Sf}qfpil4lPWJ`%8_-5% zFWm{2{}-f*T7su9<5=bo9?y*0p*MwCyLlYi^`X9`{{iktlI|?jc{tll@9IFmlqg^0 zGT?0@aB>IoWLP0U+vc#F*?0T~X|VKy^rbFa*Q&cp_loWteVl%fzE!_V|9b;k&sbsn zv5A=mn|@`kF|RT2HNR#)X3<;b$Bl}+D(=hpn)r?J;rK7D%d8JuU$UwRjR{K=4%r6T zw%OiF9F(}tZnO`!Z?x}nY;zoP+MI39tDUzwpKu;=9#2Y7nwj*B%j%ls+U9!B-Q?cl zzQ=tiIW@U4d3TC6Wq!)8R9ou8)FWxmwAQq%(-)@8>0e|7GInHyGm|stV!Ju>FIgM2 zzR8}IeOb=BoZX)Bp8Gv7cs}&r;N9u{E_ZzHE?=f^nC~**PT!Y#nR!3RYtNsQ|6Rdn zh2slvDg3agtmyvY?BX58e<@j75-RB`9bdY?^vkl;vI%7mm&cX2SLiDiR{Y98-~VN$ zzH&?D8&#QAYpT8olm)f~js*t?uL%Bn(3nBbRo7Q?2DTAj9oOD9vOK;e za%^Vl{Qk(X1;_g%$8k<4kG>nvDwDp5T(`1ZS8C)qf$ee)i5%k#?yk=w$FHztw-h;k zl~uY^@%`^r@b29NOVRm=zgmj*Jw5EFNC7}th0Vj}u^?qt0Tm@CnlG*xVi?39LsO7XUbU4)Vs;@pFkt5#uKF7_*M zEr2&F1sp@s4%1NfD6Bboavsqf%6s2D`I&*r(MqI}rlI^bfc1QoPqmCKxdml=1RSwf zm*UBFs0Tg20r#r}tQD*pYYGfy7XUZQktaQ~7&>*W#&@-;S0+{fdq& z&?@xY3P4RXuk{z|Q5p?W*?l=LL5Zt?8G@U7>H@s)LG0uzQ48u(Yan;1wJ1-mWvO3N zZiI2_tpq96ZVfi7C*g*mjzT|QJV$3#KkBX2+oROdzm4dLXgSn(spl-gn_7;<6*Me+ z&{Bj|D(3=RCERF`5Vi;w!W6aQLR_czro5;o8ZE9DFi}ZV3ULgoVYD5!_tzo^I-;6W zS@abB5{z12^KoBmIVyo5BWU|-z80`)IHDZRXBUe%ss0nhlf)GX!y0{R`Fem|tye_3 z*F4;(Iudp@Oly!(|Dmh%kYcGN7H@rYPyoCTU9J#VxJclCg~%~VK~x*!SsFwdHzw+# zD@1`SkqBN5&r$lKeoK%M{SePSne&|3`z`{+lrQnIHON(KMdD8yE-7cCygodx#v5Ae zXxJZ$d(^fIPz$ZS2_stH7^ojsp>G6{`f{Wzh{C~@C=^sbYC9^6_`=##)J5w9^8g_| zN3v=@ehJzWse$^5Mm5Ak=n0K7i6#izB9x%<@nW1sdy9q}YIEWv^Tj(_?TT1q?-}tk zqL*Ui5r<9V%Pru?lhC(jFgo(EG58&U^Qqw0qlL5~PCXLWCgVH~ztnC~DO-*^#N!Bq zT2CYHK=-M4Q>ze-N8zL%K^!&q-V#9@#3d;Yf={DVq7Ul#1nDS1cs8PxJkVx{w@<}! ztAM4iuTZ;a5Y*v_Xm5$&%o>;N51ZCoG#Q}btWV!qiMNQiQ6HhVs8tE?)F)5oE5y%M z<390?XdbaGqj3u2mP9N6NRGt$2v1QC6m6|BsPPD3o7#f-7{PXds3}2898}}g1TD1z z^%1QOQ9XkCGC@F+Vv)e>WMGms3ToAVJto(pBn`&|fz~^yH7B4gN8&dQHKIBYb(}AL z`zWOacL)Q-PwDDH(RZTKfcOi&u>iShJa~at4Dkfx~NO5?`V=Ll0C@V-?7 z51LfoD6Ubzr2b5No-i1trzm!*_YyCo>za%v`qm_x#-}w2wgA^ODkgqFHJ*%(G*}N- zitylg1ZqD8*GHg^8aLNygYrHHiQrrpxkHeX^pE8RB+2MaYG03_E0Uumf9YMKG|DNK zCN)UL0o$uZ?nL2QKO>m?xRAz4CL`}nA}69VO?!#<`;|-3yI#2dX8# zO+9KIxKR|(L1&F5pRahiwqF4+FJVg2A|J_&&{zF(C_dkS1f+mW^;J*9RELrMS>=Z z#X{7sMxB=3oj(-@9MU)tD&M&6qA)$-9~ zFlpWWH8_pm&xEep3O(aQem_~%h$N~uf*?6VHPgyGQ5N^7HmoyOMTG)TfOtN!umb&}tIZ*hWL+odCUy`srwt zM%vF*@fJNhL1+)88EN^D9!R<}jaoE)iL@0>chpKDP49d$@}!(%sUm8tSc@7g1{6fy zl-Izc-KeE)I-ZCfziF1diO7S-Q4>WTWZxrQvJy7CA;QK-zr=eqJ82Ns-^jcjKF(6B znTJpK{RFmSOeezns)tS4h}l%E1qh8ao>}3oXM?}A9UcWv%(1)RGm;FymsG4!nhr1O zOstTZjWtF*%*%4&bC3s5hytuQQUrcif;rhTSko%NF-YGHU<5r#Kv>HLW9&Qx*2rOO zIICw37?+NKg>)pwcB3)o91Hu=IB4rP&Vnn}yW~ z=CJeFTs99rN)NEB*jDx=yN!LpuErNyu48wzpK=4+#(vALWIy3XZo&#!KV;9d54oA$ z!yaXSWq)DcV&?c~>{a$M+YM|lU_S;OybjF2!d_!c9riA$^AGH6b}haNa6Wj!1)#f?tR3xhq2Q6!AJ>5%E@EFom%SLYvYB0ik@h}z zAG?%oVVAMX*;nvhcmi6q!hXqq!`|l>9>?Q37MSEVp2+Ro!JRybySSStV^xC=wwL{a zy}-h34||ba!ye-)>?!s%KDm&_e#Fy_OIB=Jy|l`-e&zX}tiq zWizs5W9h6mChI(-WnJkgS??Jg(wQZEstqRwoail)6C+LxQzIuPoERG-CuW?ODkCQr zoS2IuCviBjcq1qAIEhP(oLD`hpJ4Ia!XoDhxM_7pPHZ?yaBC-APK-s zW&?n;YN+jH}O_g=(Z#6?_1eqEJcWOh|| zMR!+JX1mIZi2;BBKSeW zN5}sGArKM(R9rz``G-3I0Kmck0N5jyx`;AyWz}B*0EE?#jqeW{=!EHm<&_zjf4GYu zUH%7pE=g|6hSvIa001QKkAK7u&UQin#2LCc5dr{EBR@7j_5fy#eB?$GJ5%c)?&HU% z761S?R&HP@G1Yhc@r9}Rv4Q+=AevgaoBVJs0074@01(EQk=o>FW~^@n00{g2*s%V9 z9cUgwAFk^MW7P@K z?AH2jKmCd;{I@S5Fc46zjlQ+<5BI}^|6Ch7yy+9itDUW*696FF^W(SiGv?YypHg}| z2jd?b`OF{Rjvt;u0rk?~)!5)?%nIs19Qc1wZl=ihQ~%d2P4MMU|Fi*PS#JNikAO)- z%_FxpLp>usy&Vt(C~!nQ13l2bVZjODBPIX<9tH><0B~C?N|v=!QAHj8b~NR_&xCi< zH1iii1o2t0#RR1iMZr^eMZ`ozwLpm~BuA8hqj8#@LuaL?BrX%FDWYqeQACoI4YFuo zj4q2AYN3Sr{io)vZhE_u#k!<15qV4C+x>XcbF1|@+i{Dpz^|~hyitd|(PrOea-;ir z28ayRK)Z{9hahFO&c2^`a6W_MmWLaErTIA;BTw z%=EAwpd+w^aAFhuS!z(O5}u<%MH}e&$-k#kMmC}PuE7_a`Kwx}I`I9I2v1E3E{d&> zqy~z;AKeW#Tl8PFCl4NE0LBj5k*6L*lzG#4rdq8OT4e}B|DPK0rQZ4*=nMZ& zJ0u?pv|E;!)CK6PVB6ylSqq4L6goD>Ey&m&@)cOE9YwR>=KEXl)BW%(Q0+Tl>L>oa z$CWz5&}Q&TamTQKu@>~z3!#UQCGP)pykTA%Hh^X+ab}c&P0%{o#zdQxw*HMmHR-!D zBRvyJT17JXmuEgR-ty|_DbQoJc3L=VKHInp#1q1rpH}Q)eNc&p!-Z3%&|5yMX!)p_ zTZ32M2>4xVf>tR;VO$^70kd?Y4S|Dc86>WUViiJnQ#wg_Z@sa;>%IcSqmR*{S3mBB za1jjDod1|BRy4(;72X6~Qr=QlPS>-Ht;XbHTBePbUeKB@ZghMuM`vRDT)P$MArX6` z$X8sXDVCXHNv5h=w79U4FhE*l`q;s4R-iLuVm+%y+$y`?n1H=rw5g(A^`vC@?i44% ziX2Q%Jd^+Y&=qqY#6J_tT^8#kMR4ArS=QtzQkZ4tgcwfmUG^_=cKJxqP;Q#;mOyf8@MH&vZPWqN%dB4~%`s=^?^VrJg-NyF0w8Ucy<9 zKcn!B`n8y*Y*osFR~DXp8Cg{=JXE6_h3jnT+cQ9iz2wrg%E#tUL&%4j&C&Oop^xkh zBU~YehH^j1#fyxNW!SZ0+wVlpG(@gcEN^ZWpI9$~x+UuYn+7TR$b`ecX%`P04mwe* z{~FHW5u!DWno-LAHV$~lqby*fj9dmH)-BhDykCNJbH<51ye}-{)7upJT3Vxm+f5xU zV;8maf)#Ctj+uCR)jo~(QK~zh=|LpV9epNs-P@A9Vw=nQIOV&1Y;?icm^deKO@>AD zv%TTlu8Aw!@7}xk>BoUQ#so5-4quOVPGsz}p`KY81T?SYI{n^%C$uB0huPDUqt41q z7E5C$+3|;DChjcAtR#eVsr0QMijYjLYPfA)y*qqY?G=1Qbw|#7+*OnUka)um^zS4% zV|p}cM@g=-ZLdFD=A-3ls)SNf^n_d-eq+&8x}J-NE3dpF&BA8WUP!T=`WAgm0plxX z74VGg@E(9^j(iyG%yuW=T=5YWd-@;0X~-Y|rXL$q@xhVa)|C#7dkXr={-%J)#|EaV z`C&PACK+8rA-a4r2tsH_UoZBU!BG}t6sz0Qg_+~sXxm2BW;~8Gi4QeEiJT;9{k?2G zpQURivW3Xj0cE-bu$<)bXxx$^x^%J%a%@gUu=SjvDahzn32#C0zMTvC;JoN678>@< zuRkndZa%U)(A+$P^AE0R=$+K(Fs%=LM-h9&^Lh)#M$Z~Ekhp@#3!I2Q`~wJgcaB*h zFuq9&u&l#G`79G09Lj$VUIT70XDtn=4E=s+DYhTRKBl8rqhGo6%%1?>!qkwcqa09rrRF_wq~yx_*Pi(3%JQ&wJXy zPA|+r&%yp4N`Gful6KTEPG1iwg5~3Tx(Bon6AKhG71*l-4HGor!`q)U9#&aX(SR95 z*WO%+DG*XU2uKFl7<0vsdex7Y9GnOot_GGQ5DJ7P4i(sdzf=lxh< zN)U3=4g?GN`#%GLtgreC;$2{*S)gKKk_R5Bo7PSND?!7`0Q&FX$NuYldU_^)dRX9M z;D~O(2TTF4w6GL@4fuh;af1*>x6BJnl_o2FH#tnHwE?G?^LSwNU`Sw8U|e8iU~FLC zU^KyQ!E6yy2$)~r5E%n73$1?obp7l@gry$fU_f9{U|6Ld(xi`3-`!unAKx?If!_!p z)9=@h&)3@+2r>MeH+t8BdxJ@91v|35|lW-U%vsc z!02l1F7R^nHuyUHK0rc5`bdgQ_E3^k=2#kB?qH&1#%QW+&Tz7H)_8yTyg`IX3{jL> z9ATtsEOE4WJR!s>Ofi0QxFX0i*b?XpeEap}?!?X1+=Pvko}{j{yab7aBriQph0h<+ zYS);J?iG#yu2ygKxJ-9G=djsoFkWB!!{d6bPbnig+3|;6K;T``99?)FHiQ^F#3}6D zp&T>$vQ!?t-m&7El#NxM&+g_f35VmK&iYi%H)4Ok=d(Za;j%3gt23L6>%-IIvrKj$ zqxsTB8f<7RDxiqk4-;Ur8E)~Pl>k^eSUS)zU{N4cAR-_tAbKD+AYLE^AQd2WAn+eh z04e<(4S`I7Yyigq5iq3xtPB1qw##V=A#TDUfcOur5OS@d)~Ce{dFFvZ4J<|*81V!j zLYi|p{Ef5+A`tW!fm{2Bm77;6kpWJGA>s9lp9q=7GAy5!ho|0gDvd>Y>~Fd2spYit zF=<@iCio=#r<_D%J>a?U{5(3UArL~-%H(0p`TYw9JYzPI#{zK3XG?{ECClTl*--K| z`vD#D{y}ihgW143|FFOfbxH(!lwmI&c#SpLHjeNXu()f$$XJ+Kyhkrktn}5)dTcRX z)A)C`Baj8@b(B?5+0q&`{cC|}@!lR)I&QqUmOVAK?u!(qH+a-ZRk?BEWv%y5UHyq( zAoZj_#7e)KJ1jmt0y*kjGwB#D9MY3P#Q-Ey0xmSy;l}7!q2Q|o@=%AQ6wiK0BlytY z<(^!2`TB3(3|VViyuKF=++NpiENSkSk&rb^Bm*7;DnBTZUt+4SA=uNMwBQFy@6&>b zeuuZQzFCkBS1TgCDUHtXOlpuGKInP^CYc>Bf%|HO4?{5Ht+uEf!j2G%* zF6(xlJ`l@5#93biV0)dBQ^ zMyaH^w8>xI0v2ex3z2G8mPoB?)|L6oPqt|ByS`H#^`qpV7nhgc&)=J#{@YU%Q#McU zQ?FC5TgR~d%*vP{e7`vZcQHxka}mk8_)QN!a|%%dZ$fXmVuGc`c5j;enjOW2C9hv_ zd*98es8vOaPEeb)t4K2zVS-rT1$cwE`+MY>|G)}&p*GEItmmY35@1LZ?p zO-xMlX3kOKG>x^Apb|5UH6Vu)Lkc^He=Yu7U@6*#Zb#`dy z>E7Hs>K0ZeLUQC6_w))DOpYHxvFk(gn;kU8<49)d4QU=GnRUnCf(=Ho#2A)v2_xj@ z9Nsdyp%iwxWc?@&%#x^Z#!H!MRK35Q<{nd6_6nBi+4shU3uf|^N{m@*V^Mq&>p4<~ zU@==xA-lx@j>#vLh>=4{GO1yD5_8vyEEn-s%8ohhsIL46K7VDG^QUzOE!PbxlP$qt zb{)5k?XKGo74112g*L5{pXcO{)fpqY;Z7NA!nmYDziyyQ3HGGDmAw&ka!??;ZdlZj zi=R%Md{XiPv4*w#M-1cLx295oG|)!91c&Ee3NJQGR9Za`s1>n>>0)hnm8G7EfZKm-3rLHp9*v24ibQIH0% zByA#grMcQlsj|G)MxUMCYP8ofb1p!Z#nGWqbp*1_<$dHO&dXe2Qf9k$HoiXpU0k~E z(~z?<+j^s091TT2P9trRnQdm$mkC3@@i4rG*N)uXVY1s-uXV;Z8^%DYmMX<^3DeDX znT=rSGO}p9*9H@Hd}12H5EP0Dvu`MsMs0$651DYkUp_BPhI`itKQut$Kqj&D&_hJz zcCy*guRXfDE3!R0dgragFY_-vQ)rZ zJS=Xn14rqSz*>g;MKWFS?9zEBwe0=XbOcpzB5P&?bKmzx(rNWcBYfqUbr2BCKj!)! zzOmWlV7#8Gih=JgxZ>dUswHeY-^u!U;@Rh-kD&~=(vh9Vsd5&@$AyzCYmeh`XFMvE z!ABIT2f^h*nXR`xq`#aF10MpX zqO>wUHOvPLFe2R-|@AH9ePp%w-dRl9Pu}Dd?DXQYky7MZw*|(@mZtb6X$F1%H z8b*95{by?=+F7wK^Xshqwnx7A>)yfAiS&u7&L6Pi!5#dZYWyAbe)QrXdlnJ+nQnW4Bi&+`K-+4nGmiS~ z;W0L-i-+4nS$%SLla-R!R{itV`$fmBsTH^HV;R*`I9#{yjps1~ZUS{}MQoHR!L{cf zZ-dIWFcl`xTLc0UcH9yvz8-u^{NZkSrsvoMXAT(pm9-(xW5;kS)!h_`XbggvK>|1y zLgC$01Azm2pbgGc?2s!455hVYs`~f4fF>3ZbzlErwkCF>I1OL&%gMKBAHxmIX%|_K zkI53voOXxdw#Bg|uk#AJe;spoXQ}ViTV0>!?~P0zQ2pO=+f(Xk@M0$Mbxc)=dE)3w zHNkO1n2}gZ0lm_FY5I0rN=+9DtBD5ao(fB;bT4VEkh=A$w{v{})isDwjE`;UbU%#P z-?|FhMyBz|%*vZZUy_@mCKmUp5EE}uFC<8I(Dw?JyjH+eWi1T^7UXGG9sYodLailE z21g&x4aWV-b98I&-=Dm1^NHacQ~29$2OCdh-B|^@HssrVbYN|F^V=Y~H^GG}G6EZX zoLG1JTr5`#@T9K00Rix+#sKJn6mSC$|Z1rmuh@1ql4=td;m)9Mhs!bW`)PUNP;;cnLH z^m(Axj0KPm%A&wWgyB*E%HE4p#j#!7I6tVnfKI4EMZ^QN$~=wZuxb+}d~*7Kp@)WO za6xVgm~08NDlam+4?9S6Gws&5YLAU6SG;$GwNc%t0f*b>=C4zCbj|hV%;{ka|FoX# z-d2;B7jn8guF&pg4#$Ek+7J%aE|;GO`|X(gmc!rE#1&qNZXzVpwnN(x?tFsx%V-B5 z2}_@%Y{03@><}r^5sDp>zzb)_7!}Nb*{bUhAuTvYthnf%SwhU{ z80AtWNf<@IIdkDfjJcBieqp4_qfZGOXO12p zP;JF@4R1r#kfy52RHN(fPV%)XQRB(*xo0#sp(aw{M1&yKNIz38)|?PWgv7N|P=p}T z&w|_Kg+b;~DNUx>-6HA$XKhXRK7H}j%5A(ioC|)1>0Uq@6k$|?BuL)e91E{mW0(Q@Pj{+WhZR`m;U_=~w($tkn1Jx~vL%^#Ie~#m{GukA ztR*=~agT zC~!bfLs|8&4m;nH%Npq(k>!G=h5<)}oUOt~Z#%}fAm5s^>-Ha`Syk!jPKW(E$A6^n zJXbA-pI#2NWAy`LTA(1F&*&L9{Wf$Bw@mbakZ_01?p{+J!n=nnyEFXxHBIMhCSSCmRtzR zj#JYFaFTw_<+1hx@gv+d_kP9nz)v%CFsARN*aNhrsF~tg8YRihL+pnYRFXmbQzGvm zH+Cq^CMAu7!kQB;dMu#4()(gF4Pt=}RI&1?{2Zjt;D;=%!>mfAZ{7aJTNnZaq4IgC zobT}&LUT;CBj&xL;7hID2D$?=aaIf-Fe*mon{`pseWXC_JG)X^u;tS5+sxi4#eH7- zw=zZ>qD>h#?G9I^yV2V0uCQo+Px2X}t$Ov(7gg%3tgj{KblgwLYc4fKGuQN%d_6{B zEF;%F4cbm~*}hu2)t)Z3-jip~wIZ4$tPl()K^T$GWW!;E;JXcIV6Nn;8|?c(i4=BH ziee&WUZ5p0Z@kxJP{)Dm9~$9UbZvI1HYf|{iGUid;Q2+>6f%lS-@Lf+x zFPRmB-zanjtOGoPbIJ&2XpL-@?1{^g6hi&zf-QnC@+nY{gd1SYIb{t?hkCbk6!`44 zXUgFFT8J<9kfOBHRd_kIDXB7^MwO&$`|Z9Gk-@cBWeLeS@h<~*7wD?pE{GQ^lyQ8= z;tib`t4#$VxCd~LY!A0V#^ZtJw`B4|R|r=N15i~sYI4fZ@4#MRrkYb4{OGxZ-`J#J zG;tPV?XqM?iT{B`?CVrlJX=-6xR7Xm5$ylH(>3tBZ8G0iO|us?@XJ%L3x|8`bj1`` zzAP8Lx6j3G12v-qb%1OLW2}}1ZQw5#Ow0!c`bE(pkFG3*x{^UcCN4UNfXU)l9Gppy zE%v1l!BfQwJQ2ghDGZ_sYC|;@7SgehYCVB|Koh`-_p*LY$Rl1zZ)weOd)DL)cj3Tr&by`n=9mN9_O2yU z4R(2#Xp*uoH%h^3xxrBd#xA{8qOm`fc!6@ixVBvGP03b4GZF4pljTEGx_(+hB720x zs@367o$^XWydUJMEMiP9IdWL$CG*ZnPR({xtHC011gvBt_gA~!ONjrkg}Jy3N`iyU zGUkGih2O10(LxGv$1a^QcIsWkI2=Kfv^$IPydQffuG1(|8_%CGu^bpAsD%_#cm?GO zmPEqOQyI;^D(YzPSqSV5nCgtyh8&;fy7a|{46EW=f6=Z-*0knp9b`BCMg|to{>m5} z(j`~R_1K*4cJDVOi1+sNzbR!5U&BO?MH!yHoW_$2Dp;f5E1!wyJ#Gu3H*YTw*l1gRM2+t_os5?LF-3&QiG(TDnOS7Ad}5 z{;fUp{Wcd&*DoC_Hoy=NFC?Hnv&x}ipDK5v7kd*99j_-0jnaFLnxh3xlSVihcMl9F z>N$gzh{!J7D`JLnskktklL;~7wQv$|1y4Sk6mtRQ3bt0Wy*lwM+sCT2YvnrvQytXO z7cbb`5n2-Zs7+EXsg5#tD1#YlR`BiwZMl4vnF{9-WPMP;lcC~xH~=A&o9R#VE67=m zs6hdy(m+K+plyOro7FYqx~3v?|qTO_w!y9rI=vi zd+(Br1%v~6)5(NgutK&FozDS-KyJ90({|P zF>|ds&iTPRCeVMuyXYEbGX!}nZNEkMZXU+ZPznuq zA6x0Pt*TQY4SsO;V*}2 zRn5YXc7fWn$@1zoM~LqPbum1v+my08byn_XU$t}c$0g0NG>*-uxO;Ee@_u^hNdKtHKWAK<;( ze#&&xkjDcY;QTqLM;H55zb~fS)RT;j^59>*)h``{m8^-t+o^=U3zPK+vWw6v`Q&SVcMy z6r*MO=(YUEz;U6xyIaj$Zh02CCxLW^QU5nL`0LG>0(J1|!k->L?R=&D_Zwof!`2xb z!dy(c`@W(yDiek_N&q|ah*UA{p{m1>bV^qtej7|HgvM7!&ZXP^B%Z)~^ptqElJ8rF z=R)=|Jy6qaMivCZ)rRwqppe|Hu96NN6U$?kjB#Sn##&!4y55}CK5%nWp;3J)XX(uK zEUXC(HN~%lJ}Hpd35Ob?{93?i$`z9V@#7iJS<1hUvkhr_uIJx=Yo-N zu#s|)xBSlQzt0##2a7!<{$#0ohUbNQg@%DpE*c9ASzJb?a4DDQIBE)4V9Z!JDm1Jq z+`Lipx=c<0IJLPoXE*Ft%OZ8r1t-)I(IKe8$uBMe!MPcO`9>zJ-__%yN0a~8!akBm|GAo@RS;W zytgbwnuF$GM5H6+o?9<4+SSej6EQAmNN7$Gu`q9NER?2#*^?pZIOwA^)37TnHiHZI zVIJ&LLhvTmN5FU{O%v#n5sStrzbfncSoCpzuCbpEO)GeBMnHM++8u#FwLzHqv{Zp0 z7(aj=v>{BBo&|7A5GdF<0y`7Hyol?m?|Q1sR%7~H2RK}Kj&;i?aJ+7cVH1(|wK ze#CR`ena#m!#MlAp9&?|8g=*FR?boOl|i?(hqN%|R21Ve#|0j4Dmujytt8jNDyg=G zH+Z`7<-1K>i0FA4SVP_;JAd~n*`l>Nz2q{UZ?Vsi+x?&%`x}Bev=HDB=2skm_Q>Z+(s>R<_3XgL$K=FQt8wyn<)ex_95O+v^zxrSlrGJqsS{D$*@T;0iuC@Fo~a zfaihYEttBty^i`w?7Oz{W9SaY5L^#QwyuZ@qIs7Z!dJ&h*J`X6p$Cm+R^J)4LdGOg zIq}!7x^aK5@4*1UIEplsApArrYYb0NctOg78O`#O_|Nn9kt>~#wIVE+rd>Ftmg6;#Qj4^t7v{F5k^{)HR-8Xvy(rpW(c2~%{*!Lq zVF2qXaAN1msymActuwpP{A(SeZ?MLNh&<1cT5?~dPMC*eT(o+Ol2%F~AxBDK#y7&m zoE)Ty@|ftl9IMW`oeE!Uk5X#G0+dJJ>$C)EKJf-IUR2$gCYw928x7<>6t{tHCnn$szW+kNjwT$ufJoF$|{ zv~jC>5XJB3&MJP;iJLQ9uR!fZ&l+2lcA-d+J~xeW+l7-hjqoChW0CBgolcN0J+af$2LH}64tLOVrx;uorkQ7gkEX6FW94##$;n;2<0*+>1~rJ-Tc-lL@D@&r0n{Ct#RqY{{bUdgoAk$DdA&y-(_DJvBxD`>Ef z{YVzn2O8Yq@VPZXb#P7^=r4rrb=NL?KbruSB(v(iJl!HA{!?1jgKud5%j%UxlB!z4 zkin`fCG75B|Jy+d_GR$bzj^f>wGXE&}iM>nHOGgzu7n+vsejzOOyUQl$JS=8DEPhwI; zQxs{5mQVVRzcJNAQ^$fW<2ZsVdR*!Y6aUuq_p$lGO=#4sGUvYRP|10Wfsq|ZO<>7%I$T0 z0IutgE9QFq3<+2f)=kgbDeNaS`n zsgQ#Hzyk4Vv@zLNN|Do`eOo}uCxZGJN@oR+>=Az9!^D4B=(C{f%~VW4Ato)0oY^fa z>(%}+yX?u1cPT2)tC)}pIl3I}i9X^9bQe`OQJEQ=Hvh}Pt&&_yTv&QBk^LA-1fL#A zj!$oi<OazhLTN_G;^>L}OJ{OaBA}q?)D|5;!oi+VKXn4SJ%q z)u%i(ix87N9Q3oVCI~4Jy)YTv6$lY?;94Yw`X+uUBw3Rp0x=tn*ACy|P(vD}JA))pIZC znkkGpULf)Yz$`IORT?w4a~WI-6%Q07L+vR z#qaIue^yp!ffuY^p;9d%F?zYI;pGn>4>PDrO7*M-owp_E!;w3tkrUOY7F|uhMeCL7 zyZ`L+`IAZM4H-j_Vc52xw&n2Kt-IoPxNqg3H*ebQ$6j|{y;*0VPp*G=qG9-aLsWF# zdixAEWuViwnXgYSf4)#O_i%6@_Z~NI`cAtpG%s&>jIY`HJhu7?uH!W?!&>^n%e zbG_G8GJ~{N=8A(j+oVV-PQ1P8x5qT(Wg|IIR+1v=kS=1}MrrI3_SfCYFY}aBY~m}B zdGIEacL(2cTF+viIl^^Iq=?u|AeZxRu6p3aisfoiF8tTXKAMo>a3lT#j(QSqa*Ud> z$z-o|en9-kIyFN@7$-KFgUTPz3>3^7gPFyKUTlK0;$#AV!=*?09=~s9}1fK)|ae-Fi#% zk*;AAlb4ut$Qt7ai+sXGiqGy1bkSk0QN&%*8B)Au{@}%3Ap5imJ1ImkJopEbMkUM0 z46H$w_KIyKJ!e3@kJBgoe$gozeqG?pVyw@5^4skt!*<=rZo282X=77kBYmkm`%>pw z@@^)_b?LVp@%uK};aU4xRiVdoaMo#Y4A%Vd)KsQ7)=pLO!D>oS=ngaunA0^B--rye zypvC&$Tx_n5>%z8+MA;GG4i{5kjUkVAdG7p((^y*aKO1T6A5#2^TU0x4d z=!&ueR@H*q#&m9@CAP($O5rjuQc;1(lTsOkyyh7|=VDRZf#Aw9O#=>EAfz2DvYrG< z4|v(SA~r^8q0?bUQp4F4!>DQvvNIcIoZTx8)(0oqD4MQ#luh`OHl}@1hZ51*lXJrh z!I|oI`^A;+pVbCZ6%8!SJ2s=0XG@p$r0o{|il?q`{#8TfPW$|)480Yr%yR^wcUs0$(k~w#yElE3zRB zJvvs#2ZGGk%Z%zgenK_a70+mIWQhtqe-%GU9XQAR7A(w>ECYv*)5FF1!K=a=H892X z$X88J1~UTLmfrBYoc06HE6zX+g)4h^;MA6*>Hn-W@7E|8LuGV|(WFFyosU(D?asVD zZ`HeeMnuG^_-~Q+^$I+dX>IS395Gvl&mY$(FTb8kf1rj?tk403;pziMHO#R}z(t*b zplA5*f$*|52dwg<2Ex6G1F-oP(8`HO4ils88zPdxuPWn_!~0gjcqT9w%GK+;`kqE$ zQEP{sVKEI@9ikhh8)IMTC0S#ta@eaJoXQOr)K4+KAQ;}CV(CX@_`Xe-tJep&b9A`# ziFJHUy-8JA3?@pGe*f|Piek}l*}91AdbVy8`!2%;t}&D;G|d{rVMpo@wM9KE2xchN zHG)s5XVk1jnARLbdR*YC8PH)eyoO+sXI+wuKdI-)b#2|DXVPexg3lC*=1Nfye}!+T zLlZ&2_3GXHXR}_-UwZ;WFLmX1edFM>^*3|{3cJc$FXJJ-0UEplhO7GcMfB=wS895t z`CWPvk-^(@blC3DfczBAhFo~sZ-uxAq9=EZr{Qo=1r$QfM@!FMHpoNDxV})`x+PPa zJu84MYIwukumC~Wm1%xKd^jnkv-6>LAT6V~Ds!%xBjq8vhO{oE(`z*o&AIKL|GF?d z_7+5|!qki#1nh`8NZX^5W3YM#^xzRwxCd&(m@b0k<|q63{Yf{H;g+U8!|lUYc;y|t zN{Fn9ZdJR~yfrUj!8W2p&+&zfU#sBxxWY;qVMf&&+KqrDL`R}h2zbjyt~qA#7Myz3 z2|#~yGM!fK!XjW5b2D?c7>(wQtbyzyPTY`-UeKKlZF}%jN{5K;Usw6p6B>hOJ2p?J z@!lz3f~MRt4}15^-qBAw;MKduG``FE!RvkTPhj^OGtFAe{*P$vAJT#=_n?jvv5|R@ zl=aXNtB!nT%*%>nv(HM5nk-|Vp#yD+$z4`HOC5)1{2}^(_WGFZtjTic*!bxC%ZbYV z+5xmKGP4GG6nwxQvewiDOE#cNt#*am(6I_Myn8GZW|uVdmNDv`BRIrLQ+Tqwsw+i_ zZgI{FdX2RNG7f1HT-8KHOi_8`(|=jZ#(FjzIF6!?_srt!)p52`C(X9)YJ??8d+y(3 zAL2KS&YM~tbJmBjL1(orEQez!5dUlVp(hGTeqq)PG_!Gl0p$qxltfen_!F1gvIXIQ`07UmL5gnU!9uRkLb zL*fV>982gFB2K&xU3XFr5%O2Gelw{Jl^dUV_2l*0=8xxK?OfSnPAS8`$3+M)!GDc@ z^H8~3%Zwy`nx-tBnkish3B||Scv_sGh!ym*ffG#&;C^=E(O`X(7C{+uhnjT~esq$K z#JZEa7!M9(9gDxVHGa~a6B4uDp;tI^o#x5@#8pS~G9^u$aflT=q=|jZ%3wowFa@SW zKML+#w&6~Qj*07485zP>pASv+430}kG5eEl#RsEV_Gm4}Go$gpmyAk3+c%5m83qJ? zVyC@Xebc+!U2W*v7=rcB{ONOsm)KlGk}X4{bjGkydS2sSU$(}q`rS*$3XW_%rRQKw z>CIc5tsRscX}RT#YT=QCDw7FSVn#0OE_IGhGz-Aar9Qqf(?4c(Fc`XEn2jDXp^yC2 zMjD9pjd7fjm(AfV@>Vxm0)=~uN+KU^acGXl5YArOz5QPHW?Gl-6rUldvE9_txz$0l1HlP~r12XYf*BU#_~Zbt$)8oY1_*?8vq*0X zZ4Qw% zMPe^SYJ#DjT#;mA6C(u#+hW9x5&6)|Z9H?r!TUiI0RcCwW2*a~kkOxHv&V|9WPjSp zz71|Yo0U`j)!Sn=ozx6mS~IxTTr>`!86!ET$few}+}{Tx0@l}iVv=0M;dD9x#5hX_ zXC}hZLjBAvj&6U3bP3A?8$djh!s_M>W3t$&D#sc z{x1@-KxtcJwI$Nu0oemEHj}egz$elXxdb<=XhOVtOz8dm-n#?I?)RGHpBz;QGYG3csd7RpdasdcA|MnkkPRngnG|lh8-YQ*!VYENcfQWf+c>cx9C&m`px|%WaQc zm!QxNwp6&CXs#EVk?Pg)_fPerTRx(rT)c)@zpai{1gE>p?ZWvm?uXi2>~5WkB@KP z#}3!zYssW!6I|9`tO2RnsJF_66Z&+e-jA!CdHmFbhetOD@6F7OPq+A(-h?!;R;8%Y z$Weq5>t|nwQZoZEtht&` zOUc1t+295_av{A|MbLp5AJS24c@>@|4`pWFS7>e<%Xd7=P(M zBE-%ySNMa+*o4^g7u;g=*sU6;$4c*EEARXzsNEqL-$-SZc{G|fQeUrR_?l8MEkyTo`EIVUB!64*+DlCTuHhmtc< znxkK6kZ}Jp_%s>lHH~)X*D%G%@)S&V!P=ePG+ieDh-`FTiK=eRyRw*V8#k=&eF}W| zTN6iH84T{9nQH0&CfMv{|AdRA_gF}I?3jiCJR8fTx4IM3wCko&6`G8bBzWu)a>Tch ziGd46sEUcDL-V;hBtfm2G1|}%)FmBYOstvD5t%Gpfbo^Dmwpc*snzV?ns8_8IuuNpAvx|;IQ^gJb;4BRV13HhPrexgkL zE0!k(VF7$qqI$r=GN)lx+h=$FW{%JGKj}xC@I=~jKrihHU4NG|8E@ao z?~oYtPzrq=E6Hb}@3%qjpIMkps`)v=$sl*kQ7#E%4X3m?w#2=vG*PUC#5Xg(K#Ju`y)07P&l*Png zGODYLt8(~hY8`|$$YsB@PIF62*71x4SrcIkKLB!VI1^}g^=gHekT`-?dakEy$Wn($ zbc1Eo4!{ktrO<<=m@PcGO5`U;D)R0+&;(^hL~nt&VMW-UWi zC4!>ORj@jz62za5OlFQ*2&Fi%PZ7qRug_RbMAz)Tq-*k>nSa?kS^vdNBcHsSuvwt# z`-G#k#OW}cVUMT9l6=K|&Gsmds;`{PU+07nUVUoBgA4JN-AJ(U8VyExY^K9=!~6I4 z!Lh@TWxccCxas}j0a(K#URJ5OUsU-eMB2d>WSF0P_H)1SprEMVxEeo&za5?UANm_S|QGO_=4Z$f*Xs>f+^5Hu=q6DlMVXK{wYd_QKDjb&QqyxfZjf(7$i(B z!zV<&jqNUPao_(We0fQ)++CkhShT<03b8jC-6MDMBODA7ry2%uwY!BR-oL`NHEIl- zR~75aLFMiTgo%^k)bs(J)`Aa%rLeFK4_l*r# zfEysJ4*h!bPKomw&48{g4uwi{d1P4r`iY#9a~ZFFuwZ1i-xS;?s3(-MYMvLTeJ?N3 zTasUF`*5Da&iz9jbE7ZFo8utxF30{0#U1m+f)!x@x5ov{ zH`^=m>ly2k^)HII+0E}Tf=*Y?f{OE>wAk<1+X9Z$qm?jVVu@>k1M%Zjog?6{&^}a6 z8s#BY#?oWV*6cnI4PeOzX){$?d4ebdAnAdU#qKkCQ?4mPOOMv-F3V8bgd|B-Lk_v7QQ=cj2$?rQGRLu6w$0t78}d5vr}Qo<Svo=08 zC*s){TuD~VHjoD~^@RqyjD)w*xO*yn8tsg+v9iz$PIde#8$R^&vy`@vyrYUEVB7}a zi8yZiiS_Tfmm)iYD#A9Y{fj!D=ueNDJ#o(!90?s|YTMfOTX$RZgr%kA2h0A30IB@J zj2LDW6UHdBuKJUigbk z#M(?0;|*9o%#TlL3U~R8+8(3w_1Vo_=UdC+i9z=x@M1a57$QGX{`zg= zPCCcvJ$gVD$(}V{MR3)+aCTe?^rcDdGxfOr9@)=(n*L_c`ncf(?F;5|AlhRrugQ}_ zVJwbKU<7FuI8s}vB-y^8r$|bIh7aI|WKa#X9SG5j=m@@kqhLd|zZ~AN*YiPEUsA;; zzvX&9@p>$osT3>9Qmh1i`dZ z6Bu0JyuG-V8T*`lXvhG4)-g-8{+CL*wI^qxO?0h2d4|L-v^iLwDbz0K4FbLAOJi^x z?|D)fpTsyM$RP|VS7NcO9BWb}gZ{`_Y`v16Kw_D6V^RB5>MZ-Gopxs1yl4JMZ114{&1v=8Mkc}Br$2qc>`lY`d5SR;J~ds7 zG1D8`wGJ?LR2@NEHE4zF!#7n$S^+a8pU?ud3F_m^`?WA2CXFPptA{1tgwM0?7M)Ry z!^(b_;-xKT87y;kiu!ZOGf{6$ib+ID0~?BvbQYhwoR(r4?E&#l5{rXAT@fZB;$bh| zyN9SxuJTnFjjYjF;am0O^Z49&wmm&JJ%+_cFAZkVmH>F#V_;-pU|?c!yufR}IG*3; zD}y`-0|=Z=j(P^8|Ihe)k;9(-A_F4>2T&~#003Qd4LNw)V_;-pV88gcg@J*i{r`;r z%Q@^BfFda12>_&i2UB?3y^=jh98na7k8j@04ptUZrAX((lp10nVVA{l$AlZ?@}Jtb>aFo;&+szHD8v(b?!eY z^Sc@+HVZ4PPg!rGOB(Q7=$2A@??zQ4$C2d;>m8AADvKtF`AD9}%A=V5Aa$zv*=0Y% zKBgA_!WVej=6r+mO?U*)iS29a6nA*{KY4eqmzFagQyR{*{|pV)f``1pGn)8I;wt2R zQ?&kD{rBV|H<~bm>D$?_5Z_CUQFKFzz3~;L!9vlp-0oOu^o+Ben_6zA_~shwzWyFf zX8Q%`BdT*}b1oMxM~`k#iN%GdXfI6Rui2jWABcM-n}PLzAGcVn78^1%1Pj$004N}V_;y=fxlj`95Cb>Pk5y~bz4*Tr{<--N$QfK9+c zph94cV3*)EAwHo9p*EpuLc4?>2>lY45{?o+Ai^W!C(2eEbH zJmN{>Yb5w2QY0Qo3P}b@wn?Q(ZIF5)Z6rNQdW(#hOac&2lKCQAA^SltMy^4=M1Gxu zm%<{2BMSEv`xI9w{!sE#TB9tZY@^(uyh8bvii}E)$^unC)gNll)VOC_Ujy!9NZi_aKLE}OB^;ioN;*ODCB74nC7_6iNVRw zslw?D5I%5b1HuXy9v2A!-guCO000010002w08;=30000000IC300ICO000310XP5v z004N})mYtb6IT$P07c-o5~5I{su!!OLWyKTen=(YrWAq-3Xl>4g1fc7u`O(Gw7YQ# zLVb!}_NsT4deH~yb=AH=AED}F^qX(ytk-r(eNm7i%e&`y&Y5p!zB6Y<nFtUJr9X~|>GW!-~O};{JAK1KvOdYd>)*d7`eEuTd%d(2+ z+Dy8<9r?HSyg}~dBUEjjhmxjp*U4$B2gG1lvPdl#)a=5@Kd7FSYf3FKw; z+r;G;7{7~_Hriv9RL3UU6Y8PQCfX9}+`zj4(h1u~806f2>Y8^TsYlIBzh$}3kx{9k z?&6?=)ed)>Q7Q;^)IFZH?ajJj#meM^5y+#Yoz zR+N@idk~0QIon@Pm8E(+z(u$#an}8_DYZH zqgAo7otVUoNU0TDjFACl)#+m@ea~^|x(y3z80={CbH-xEz2!bCaV<<%gK^k#kJ7sC zcBFaEcr^x7Oc3I)S;Dn~?z(!2iohzd>zJ|Dbi5MAPfFX4drK9!ksn;f8VO^$ zPR{Bu8j^|!HJlf0N2z0G@^+|Um+KnNy^`xJ#tZKHa3&s)zI{e&L>|jZ+wN0($0ZM4 zbJJ+o{WqY0ld-CZb;dlXqT=H=_M7W`!aGHUo4FK>d6A0oD% zvlPi)Ja3`C4YpqAX`@Vi8*N*t*YHdz*-qIj=uwW#%SdZ`f0LeJ969psgf^}AwP|5x z$-Kg5iL{cnj4Ka&Cj1#8`f#}de+zcpK!nv8Lxpomko_IyD!PH^b8=Lb z4fG`Ikv(I2Y|L|1&)=x@n{l7Co!le;_ZWpC&RSzEWK6O}{xSRu&t5{@59C*BGLOET zT2=l1u$hNxsk39YFO)c|C%j^gXJ{IS^h+jhkUP6vVVbXFTE6Ew#wZ%97Fe0d0uPU{ zfcn(`h2lyD#g$`(;_6H&-g{3du2xW7Jw_;An+e7H?+L|g6%?->BNW$WLh<=~LUFBv z;@Yu5@rh?shT^8zv|V%5J)Vgf`ocMHCu{XqIGG>hTz`?7h@1(2$ z0;adn>i~G#ZO%z-jByyp@$b`4XWHq$FZQB#-uInOr$sT<8GG&f)>hk@q1u`nlv1L# zlZwQRpr;c18iE62-(m?4PCcNA13ik?{N4O6pZuQWdGZj#-~8?n2mebONQi_Iiit4H zSO_NqE0IJIO$@Qb5l;e%B#}%Csicuk2HogR4|>vz-t-}pzVxF%SqxwxgBZ*ZhBA!d zj6g%jz(zK9a&VAK9wQmWX!04uSjOR`fbkUK!p#IGGKtAdVJg!oVmdRJ$t-3whq=sS zJ_}gLA{MiRr7UAP#gvGN78+^dCWraN4i2!FBeY5wd-%Y14vAST>}MBu_$c8V5Z zq>5uyvxXY{)DmDV>sZehHn5R8HnEv{u5p|Owy>3LeC0dWImdZ!@Q(KqAy$c$D2bLB ziIq5smjp?aBuSPOE^v`6T;(p8xXe9va!OLU#cfHGboNPx*;83p=|qb)})SDYKP!WscIJ%vJuo=M1W=ySi?z@Oc9M^0JazZ*XL|gWBCD zSHNH0Ra~8a`~ed{lE`@4JN1Qg)r9yiLjOg8zC122VoZk7vW3^US2+#%WX#XvGiiX1mR~t za0uwN2-D!Dsa{k^WQdGrBjeA(;54u?NpK-Pj7*V9GcrS_t3NwP)f-vGQ F001ed(;ol; diff --git a/docs/source/public/fonts/roboto-black.eot b/docs/source/public/fonts/roboto-black.eot new file mode 100755 index 0000000000000000000000000000000000000000..571ed49125910cd6b6b5a9259134dd2e8d37766e GIT binary patch literal 20702 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
~sO?6glRGZi8n^KyFR=i1erVaJp>l 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

  • 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 X3&Ic#E%XNK++i8SYTo{GJ<-1bF1c8o literal 0 HcmV?d00001 diff --git a/docs/source/public/fonts/roboto-black.woff b/docs/source/public/fonts/roboto-black.woff new file mode 100755 index 0000000000000000000000000000000000000000..642e5b60f7c662ab5bcf67cfc1089f50bfdd7b00 GIT binary patch literal 24536 zcmY&;1CXXY)aBc@ZQC}dZQHhOPjlL~ZM%Egw(V)#+WvO`t*y;dr*d=Z+?!NxRgy{` zcX=@}01)7(=&u4${;O+o|4;ir`~NRuVk)u#08rTvi~Aq!IPTrVMMTAZxWS(`Lk9o=>L)%>*bmlc1U2%E-CPI(0O+D04f}sUcS8&|b1=94;WmFX^#A~{sd5uT zskx!^k1uT8j|TF8fM{;xY4*dV0RU2H065g{h&*PnUH+8m9l^LGp(eTl|ne z+~H4~@CT#_IpAa#wk|*8RR{fvZwCN?l+BxR#oE{#|L8Pbe)^sG!7`!ZSBI^k$4|f7 zg8$=72n+#KXJ=?@`okIgXeNJrw|O>G`yA|@fBbZ5f4Iw^m|Nb%(H9O*ra!*=|IKH^ z4^L{S<}>4NYVRw+fJt|8vj6JYr<_-hbz=h)1A|>4 zBQioWBLg!76A$RYnSi*6J+1+1!b~vQ0RTV=7qs7Fy*S0w22B-pxHo-8oS@iOx?CRG zs(?5zh}fbYa+q>?UpPq=w4aQgDI7CqF0IU;Fw>g24N)<&K_$fs77Qx9SSgy4xNOuY zv`t`L5izw_CbqY|+P1$1ayr$1yNl;}(|g+ey50Fua$M10m)2inY^e|}*XJBWc~Muh zX+mc2eR*bk%Y9QowEkv{Nt(a6$B7u{P*h51hnNo%f6iuV30c*u+Nuj{d!gdN%)8d3 zvYSpX`#F{1S^5*{OZQ7l;NTleQf$7C0i8}G$drUydw1kC_2Izo4`R-6WmEyRS|E63 zY8YiTvjzy?k+uv{wwb+U72d4J#z?QuyJG61EuIu9wx1&OQS z%jK{|vWA|z!L{>DrqX7my*cJu#jp8s$9`V~1V4wuYn@xiY;kWW~Nh;xQPV z*huVWSDxDMKOuOpMly6DPx{q&D;@Z0`%XwZ+1Cz5`K=QTZJDcN!Acr zj~u|N9K1}MP&RZO5I&&Y3_}8tfW;s&i3~yj=l|~uz+=tw9I3$JVF=A7iD*Qw398)V zae#aHm-@RFDzgN26V7^14^s>SQCH9fXbw!|#|ThGV&{5Es?E7L**+^|as4yB1b|z7 z?FhiroRlLd$Tzukh?&Lo!TQaB;*wZ$<|w=1GBqp1mrwDSl(WoYvVZR-#BfH|P$8pQ zLC)h=(1%~}?Cce)nfYmAlPb3~X7Z-aKGCvH4r5bKH_xO4w{yzLkh%2G8Pk>YX?Wz; zr?zgFIe4$O%w?K6cI5kQSVUj|ZpUBn*;=TDAN+iAOL9^b%#-ouzwluewzT%;ulczWg65nw<^a-Lm7OyFJ+9}!BO#kM6ZSQ{l`Dw(kC;RlOwb^RT@Lkw6 zV=kZB6YxJrCY;dg&=04-N(mtzmXrm;1VLJo&-|klJNTzC4V`K9#+ZfNbyOAbi1lOCI z0p~t={O2qoacH(b@7Hr%TnVt%Tj_|nWGCXy@d&*gI+pHmHl>}h)-xw5y!<5=2>7vT zS->0{m=2{|w&&$cFBdn}6XZ1ZM@3n(u^~qZ>7w)k@_XNInS;IqNC!#%2!^5)Pz%H5 z7d-%4!?QqSOuXMy~S2Ck&R>Jz!*?*PPNJxmEaCdk7x zVZ=fw%41ke*!>Pj(lU~;I*{K%NnwFLy6_zppr~c2S$UO$S}SMVS0w!r*kBz>p3(Wx z*bvaJB>&{#m;+BD@*tW=Wj_3YO%x+|gJ)*WxO_6<3Nk<%%B7F*c;)YJt6@nWJH~Gf zsVHZeRT!!xS3}-P zG9TcQV@_!iovqy5*N4iQrcd-hy*R;mc)*;qf^@Tj+U5FDvV%P3`t9WUA;*)E?~@59 z%F$gbT%9UJ*|1Gcz2d5I1UISD9H4U!QDr#65<4(ZTjrULA0kgp5uGcJIG66StdLkM z4GtA*%N8mVmrwbI5mco)yOF&J2AhyfxGwLSe(5tyYan>ZjWkul;4I1Tuq{mPOqG|b zS-r`PKvF*$RyD3!XU|zuR&v0CL2qqyja_CZDjFuqIldpUVqBgMawAPJwrq>AV;r3z zjVWM^71Jju?Q0ZT>vVIEzk2cMEh}Ay@ymYTl!uy+{Onu*ch53nG^jH+aB{qdGTfbz zq#ZMkGco{*Wcm1>0VIf?BegBDtg{e`c!4a^;1O#wSga6s3|BGv2U>0D21uh1T*am#a z6!c09%M;Lq9t<2eG}JetFmjX2lvW>fin)LXMh}JrMg_(NMh3>JiEoDOKU` z*ZA>`us8s-*ciYBS&T$6J9{r#=~E%4?4&%fV4xA*(I$IIcPKOf?q z;KIA^z5fpc4nD2_>_^|nSH3obX0Gs-7^#7Yae%df2{5wEKj;8GGecA3likDpQck zwHtMg_set}ZZUY55Iob>UFxlzr|$3Lc}ui`rX{DIfspBx?^g2Wq5bKQOI0ma>p2sXSFwC{lTXJ zwWvJ0od0r!9oI1&069_q zcN-No?7bsEsYGpmKny71zpX&-{ zL3$ly6;!si1&p^)(E8rkfW0Q0aX}Fe%{ZHr78I zvgvA7gg3R>6`n~A(#vmS^KK%tQ>}eEO4!}L!m4bZYU*8Yx@QC=2OnlY$hbdq=KV`5 z@Qs(YhSdTd^p_Wh*LOklS$Jg^27d#^LT|m+f2jrn0DXT05IokqeIa~QRG)4-Yh`mM zGZQ4`$rJGth*+Q`3G<)vh3)4-QDK1DZNkI1n(4n(6?D9P?U^Hg4oI#@>ZU7U1s65G zF&#BviZXXE)9ugQV?_ZMU%l7CJ0{yr&(mDbn+r3ZxHB=woPMFKQ7D`+>eWc}^Qf)i z>EDr74K8_9^fwNpmcTu9dmD~XSxalE6fb@C9p=YFl6&TH9pVGo_{mB%j9yCb8Z~EpnNg-G&INEw{C7Wwa4Ga)>&%^BO~^22 zfL9L!A0{7+jV33J_apVVySpWU z;!m)3!|)MV3<}R^W{59$a0{ScC@cnX0eXX`H>$P4!M|Cf-lz(6u{Qntx5qSs@Z$w8 z3a!@=$u`-lFL;$S>j8vLgnCIxQyu~4vn?J*Wjz-k{p*&QSD}&D)+c2MqHngB`73my zWsSMoA@0huv6RQhqlI0)4@&=Lwio*Ie5Cg!oA49U=tKIW;sr##ZpwU6}%&3Qv*9h1bRQLhuDRfT}fdI`N{zZEvZL84z zkEiFPz~djF+*92`J^W@A{M<|2y2QGk(G$aioskJPLzc4nW!18M1D$o3M1enY_g;au?0wjK-{rqH#(|x(F5;e?c}d+Weox_^Z1rdXc2kkjUGZemd{Ys9*=Cj(w-bYk z>}Rz3-_(uGlI+{T0dc0>xx!>IVYb*K|5EGFdpX zsk!0&!v?rsp1|Di4XRkbn{~K}D|?IOUW--k+x1!uH%S(VA^y*aBvUf%wmdr1>wIk|DW{JYPHzkYsceuCey)2@H` z!~7-ihpBY9#Z?&ig7NhF?0qgcT=8r8(UUyMc5lJy_K>e|m0HB@wq35fGc%6(-n@Nm z;oFmDvYkeZeDiZCXEz>1qps8bo-k@a^u5j$oIKax!@RSm&fDeq#Hp9x-xNRAyTDJ+ zX#NGE@B03N$vj#aGw^*rZ}>WeI&?R20!o*;((@TPtl@a9bb6ra+|H1h$sSsPIti+A z99R?DDsYmCvcPvc_L2;T8WI{acZ^fgS7Rxc*h!T9EBjVid+l?W-}w}QHDf~_^|(R* zHsJGl!XjD!wWgIYY*4drhv>VHk`n zx!gykvA8+d?9ax@k^rD-)R_En9zievn;pwwCcC!#9vN+em_nTw&Q`G&MqZ+IV0I;me# zU&J{l=y!PEc>a)XhD15yB*HxW;nZTR@a%EBC$x3jO2|FhFP?`y#HV<$e3{1QNV z8RYB5CP8@N>@*q0{{?4*+r~{u!i>!c3_0Vz9*&ZINH3P84+laGs#f?+zL-Wf3jwfm zY|SI6j?A7{{DpLBD+UXlW-7bH(Q;1MI`;uu%#hk|6ch0V04l4%i1L2t8N7eUD zeyJfG@56(tAjwe0gr6vcZxNcLF)mjDJZgw+*?zCCN>J_X87a~ydbBwZiKiVarZr{B z^6IysWWH@v{4eSgpabJ8)Kk@2-P0=R|=5RznL8|EDVZX z=*Sw_Pl4(*wzcbQ#-worls93uxN(aXP>RioQq9CwcKBt(7AE+8)ZKvm-%NNP+V`Zm zEJU~i09IOs88w5Z(<>6qc2IFbMaWE$I@;ng^%#&bapBJg_7UeCGvAWCINW4+PhIJa zX0kbj0z^I^<_WKl=juJ5!`cnoo&i4Hchf{H>N;J(hBbkYmOyDVZ7gjbSbu4O%9OB# ziID)*5dF_Emr$vVv=A<36U*BviYdlmq|_u8t_015sEcq0PJ_ulANl*BsNj9b$J#)_ z!ie{BP|FE4cA#LI;Nnt#3@8Q2MLc|YWl1ThOtf?s!r_FM5Vt1#<;o}7K5r53oAm~3 zo9QI#|K#tO$Gk7~Nl&^|&F$u%{q8%yxZBn6z5hmzQ7~L;u$xcrkICK@USIlqzWTI)m^8@mm!Tbq>goE@jAK_MZEv7W*|U zW9YWhI7D_XcKxpNeYC6p*exjjon?x_AaF9?4}xk)*!L-Bhs1Cu-s7kHedsJTq88vw zcJ!!pyo!9$G%mKcFCr9`VJ$#2RE=!kMJk zp$#HLjC{&euP)@QQNp)6?eVKS)b3MJeY?ke=yyb!JN~lt!ywyA960|c9Q-A#vKx3i zBgP)P<1Ijm3#ZIx;9LzTHYp64Jz_1>t$i2QZ@SOE- z3~~D3A~j0emJ0=d7zyB<923w*ReELj_=;- zggjY_?={kEQ*o(&ng8wW$lHm@@Za)847waFh=$uv~uM+k%wx`xBsE6zl*#`WkzRFBgu;nIE0=7FK zQ5i*X;rS0Aq}WA1&oO{o-#_})mnhcCKSvvUdDPlLFQUq|L9w4lj;n<^gA9 z$#iVl+PjLn$^^(fXQ5RN#HFdq);}66Ps*Mo7a|m0;Wdbm1`wL!V0DxelhXXgDZB&n zK*VrEWpi!e@C0>2OaJdMN{(6ryS_D*b|W$Ak&(e_|JXK@(_e=iMN>M_IMaMX51Pa?V_ZYy9@zV;*EZ_b#9Cmy za4|pUHtI+V;J1E~vTpV9i*6RRZ2r*sLBYx3Xij3@CZc zi6gpn$^uYK@LMtLDv@VZnNV+;gi79{d;=lc1n zenDtYk5l#<98d88Ywqy*T*WwpQIUr_E$f**{(FB=@5ArnlO-yYc$^#&Pl^oB)+ZiJ{r0AB=cN6rt6FRTb{PrpjR#|~Z?)>64AMA7w*5Z=a zuihya$g8E9Zf_+P?x8rJ;i@eU?IP90H|GWSp*#w%sS7A(3b@o)4Oa|}kE_N7Vj?5? z%|o(?F&CcP0B@tG@fe4Q>_bFkL-an1eOL44P^rgZ%v0VenzE>0vVdvCZ(qo5g!iw= zy?h7l5L$s+sgngR4YL}%8c=LBJ5{KXwC6-bjkch`CbGmjJPz-1bW?^*9gfR69XJKC zsS8OUIXbJR(Qbf^%UNav%BK^sA26OCWG9P=+#$;~zL#u*$0ad8+Gk3`VY?`>>~CW) zaFirk$#bpWYd65fL-v@Qs=lL|^S;{QzD==T)lNbC8JEjuJV(1au^=?<5B<)Ps%?8A z$M}1{$Hoe;G+0(D29~1h1of7$6pq6RUvvrt(!+vLsadoc*1gjz!s<0ZssmyGX)Pu^ znB1J0hZ~4zDq+qd0~IW52D#t@RUu6U0nF3Kn;Yww$UcQA|7vmy3%!2tQ3ni1O;a3H zm+rUBx6rqqe-eQlI5JIofxl-+Vr}shcx zeQwo+=IEE*jWX^qwO;#C(!uRhv&HRU>t&q6ax9+$2ogLpbx>g;x)}k|P zi39zI0k5oZ`7Pn9jU3iP5{jA9x4LZ`_OttoLfNien@Xj1&`lXS@$EQ;~Z6a^^ z1hfC*&1Tm20@vx9HNb!I#Rsox=*MXcjE9Cj{Kb{BRmR1#w>Cc|)~{!yf&t!46-C%| zoB$<4m`)19c^W(Z);Qg9wJsYaH~k%L|MUL%1ps zLB-FCp9j`%#b$S@Y+D5bNiJ$w-BME5mc@f%q9j@qsP4=7ySJt-iI+OJ%V5iDFE=|K z!o_#X(q0n|JEoxJO)yw&nKY)X89t7O$}lZiPQerENsPo4L}?W~h%;J6Q$8%Q^U>_C zxJTIk%`I=r&d*_`JUjR1ptIvy4MazpnXH=}(>rPy2{UFN_{d5~Y8c5#vY|G0@lU$N z*sSwd=AI68>n3OF5SDacme|j|Gh{M2c!ux_Duzn42P;pPajZgmOs^F_Aln&-kCk=(XH0R)?@WJ7E?mcd$KMbBr~0SQi77a>Z4Y5M zt$L1p0x-Ou6q>MiCxnoj1P?p$qJz!GGdXyJUhg@nt?m;a!GZ)l7Xk6ZS4>B~e~)(+ zST?*O{lrm={jn?bodsTSrCP_2`j+5ASt82qR&EyrOJEnjE8Jb(a$5X8Ewc&H{nwxA z{{b+*7k-usK7!pecTz%IFs)Yu1o@+V=y__3d1?e8$|ArE5TI9lg4qIX*dmyKbGSO3 z@}mm6iafF>F9_77^q<_#A4XpJG{@!O$a@*;78&j~_3JVL@6~z<&$&P>{hblKTZlix z@>H-7lfbziq5Y0Im?V~%5*g{Tk{J=0Xo}GdvtZE`n$bWGGbe?`!A*2x*dT5hszO=J zTxN$R$|Mw7MQx{7$G~d+fN;0T1(k$FG|W}e@#*cl$H~9YpH~f&3vzbfBjd_)0=M=F zZ%38pn`kt1EwnaWL_4{?#*3RvrLNsnA{bNY?$lcXC_?-_z~@Rswu}e%E%>(_U`!K% z&rYa53=|8?JR_+IV=#3xdi+kUiKXXD!N?yeEsVB){dccyGJSb9WHzeJ%R4fG%PZ%VS_W z)#YMJ0}!O}bZ#UJv-gqVqNNNF2Tdcwq?xd-&yfaZkW0@qAH+2%i;YWO81G?L0-{HY z@0xOq@#Aeq&6aXdOaBSM;PVp2#N`3NzC*!9R>7295FOsI=e>?XF?7VV9!CQ8dlyg+ z<8E9|R;w}WJ79AW&UX+QhSy>NwPuPNrEB4=M)Uf~#wFdqe0Gh!8HtKCeJ&SQQlJ_N z;nw0Cu>whmM1tzQ9$+9frJODs@cyKnn!d&4aqyQ_B26f+A;&Rgi3Xk*=hKSm0Ev1@ z$~Fz}7T~)na&%Lk!DV*hu?#xEVl04Ep>_2nmhLj`o)$Kcx9P zF%$3TrQ?4q{tEFa8aHVivU30ua(_GxgM_Z|sD!@+L$>vndc6!YdA_H36(w^X)H7A0 zwE{$ZX!r^0G`6ynP<`_e)N^-|``UYNe+G1?s_v>z^s4Ai=-auA9h%gmNP;hZO2hot z;DAe30d`OfEPvamH1sPXvIf1XTu_dTC>=Fn!Bx~B_Te4<>tp(qdxR!n#9?{(*D%J^I|t%RTC+ zyHE88;RVpHJax1ujcmP?8q08E-3wD=Yzedt_$1<*MWDnpIAln‚ZNmb*+jwao2 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 E0ADU%yZ`_I literal 0 HcmV?d00001 diff --git a/docs/source/src/constants/distributions.html b/docs/source/src/constants/distributions.html new file mode 100644 index 0000000..95ee096 --- /dev/null +++ b/docs/source/src/constants/distributions.html @@ -0,0 +1,145 @@ + + + + + distributions.js + + + + + +

    +
    + + + +
      + +
    • +
      +

      distributions.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      /**
+ * A map of supported distribution types used
+ * by SPE.Emitter instances.
+ *
+ * These distribution types can be applied to
+ * an emitter globally, which will affect the
+ * `position`, `velocity`, and `acceleration`
+ * value calculations for an emitter, or they
+ * can be applied on a per-property basis.
+ *
+ * @enum {Number}
+ */
+export default {
+
+	/**
+	 * Values will be distributed within a box.
+	 * @type {Number}
+	 */
+	BOX: 1,
+
+	/**
+	 * Values will be distributed on a sphere.
+	 * @type {Number}
+	 */
+	SPHERE: 2,
+
+	/**
+	 * Values will be distributed on a 2d-disc shape.
+	 * @type {Number}
+	 */
+	DISC: 3,
+
+	/**
+	 * Values will be distributed along a line.
+	 * @type {Number}
+	 */
+	LINE: 4,
+};
      + +
      • + +
    +
    + + diff --git a/docs/source/src/constants/globals.html b/docs/source/src/constants/globals.html new file mode 100644 index 0000000..3699de2 --- /dev/null +++ b/docs/source/src/constants/globals.html @@ -0,0 +1,110 @@ + + + + + globals.js + + + + + + + + diff --git a/docs/source/src/constants/typeSizeMap.html b/docs/source/src/constants/typeSizeMap.html new file mode 100644 index 0000000..065dd87 --- /dev/null +++ b/docs/source/src/constants/typeSizeMap.html @@ -0,0 +1,155 @@ + + + + + typeSizeMap.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      typeSizeMap.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      /**
+ * A map of uniform types to their component size.
+ * @enum {Number}
+ */
+export default {
+
+	/**
+	 * Float
+	 * @type {Number}
+	 */
+	f: 1,
+
+	/**
+	 * Vec2
+	 * @type {Number}
+	 */
+	v2: 2,
+
+	/**
+	 * Vec3
+	 * @type {Number}
+	 */
+	v3: 3,
+
+	/**
+	 * Vec4
+	 * @type {Number}
+	 */
+	v4: 4,
+
+	/**
+	 * Color
+	 * @type {Number}
+	 */
+	c: 3,
+
+	/**
+	 * Mat3
+	 * @type {Number}
+	 */
+	m3: 9,
+
+	/**
+	 * Mat4
+	 * @type {Number}
+	 */
+	m4: 16,
+};
      + +
      • + +
    +
    + + diff --git a/docs/source/src/constants/valueTypes.html b/docs/source/src/constants/valueTypes.html new file mode 100644 index 0000000..521aef5 --- /dev/null +++ b/docs/source/src/constants/valueTypes.html @@ -0,0 +1,133 @@ + + + + + valueTypes.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      valueTypes.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      export default {
+
+	/**
+	 * Boolean type.
+	 * @type {String}
+	 */
+	BOOLEAN: 'boolean',
+
+	/**
+	 * String type.
+	 * @type {String}
+	 */
+	STRING: 'string',
+
+	/**
+	 * Number type.
+	 * @type {String}
+	 */
+	NUMBER: 'number',
+
+	/**
+	 * Object type.
+	 * @type {String}
+	 */
+	OBJECT: 'object',
+};
      + +
      • + +
    +
    + + diff --git a/docs/source/src/core/Emitter.html b/docs/source/src/core/Emitter.html new file mode 100644 index 0000000..5d197d5 --- /dev/null +++ b/docs/source/src/core/Emitter.html @@ -0,0 +1,1500 @@ + + + + + Emitter.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      Emitter.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      import * as THREE from 'three';
+import valueTypes from '@/constants/valueTypes';
+import distributions from '@/constants/distributions';
+import globals from '@/constants/globals';
+import utils from './utils';
+
+const HAS_OWN = Object.prototype.hasOwnProperty;
+
+/**
+ * An SPE.Emitter instance.
+ * @typedef {Object} Emitter
+ * @see SPE.Emitter
+ */
+
+/**
+ * A map of options to configure an SPE.Emitter instance.
+ *
+ * @typedef {Object} EmitterOptions
+ *
+ * @property {distribution} [type=BOX] The default distribution this emitter should use to control
+ *                         its particle's spawn position and force behaviour.
+ *                         Must be an distributions.* value.
+ *
+ *
+ * @property {Number} [particleCount=100] The total number of particles this emitter will hold. NOTE: this is not the number
+ *                                  of particles emitted in a second, or anything like that. The number of particles
+ *                                  emitted per-second is calculated by particleCount / maxAge (approximately!)
+ *
+ * @property {Number|null} [duration=null] The duration in seconds that this emitter should live for. If not specified, the emitter
+ *                                         will emit particles indefinitely.
+ *                                         NOTE: When an emitter is older than a specified duration, the emitter is NOT removed from
+ *                                         it's group, but rather is just marked as dead, allowing it to be reanimated at a later time
+ *                                         using `SPE.Emitter.prototype.enable()`.
+ *
+ * @property {Boolean} [isStatic=false] Whether this emitter should be not be simulated (true).
+ * @property {Boolean} [activeMultiplier=1] A value between 0 and 1 describing what percentage of this emitter's particlesPerSecond should be
+ *                                          emitted, where 0 is 0%, and 1 is 100%.
+ *                                          For example, having an emitter with 100 particles, a maxAge of 2, yields a particlesPerSecond
+ *                                          value of 50. Setting `activeMultiplier` to 0.5, then, will only emit 25 particles per second (0.5 = 50%).
+ *                                          Values greater than 1 will emulate a burst of particles, causing the emitter to run out of particles
+ *                                          before it's next activation cycle.
+ *
+ * @property {Boolean} [direction=1] The direction of the emitter. If value is `1`, emitter will start at beginning of particle's lifecycle.
+ *                                   If value is `-1`, emitter will start at end of particle's lifecycle and work it's way backwards.
+ *
+ * @property {Object} [maxAge={}] An object describing the particle's maximum age in seconds.
+ * @property {Number} [maxAge.value=2] A number between 0 and 1 describing the amount of maxAge to apply to all particles.
+ * @property {Number} [maxAge.spread=0] A number describing the maxAge variance on a per-particle basis.
+ *
+ *
+ * @property {Object} [position={}] An object describing this emitter's position.
+ * @property {Object} [position.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base position.
+ * @property {Object} [position.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's position variance on a per-particle basis.
+ *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
+ *                                                          of this vector is used.
+ *                                                          When using a LINE distribution, this value is the endpoint of the LINE.
+ * @property {Object} [position.spreadClamp=new THREE.Vector3()] A THREE.Vector3 instance describing the numeric multiples the particle's should
+ *                                                               be spread out over.
+ *                                                               Note that when using a SPHERE or DISC distribution, only the x-component
+ *                                                               of this vector is used.
+ *                                                               When using a LINE distribution, this property is ignored.
+ * @property {Number} [position.radius=10] This emitter's base radius.
+ * @property {Object} [position.radiusScale=new THREE.Vector3()] A THREE.Vector3 instance describing the radius's scale in all three axes. Allows a SPHERE or DISC to be squashed or stretched.
+ * @property {distribution} [position.distribution=value of the `type` option.] A specific distribution to use when radiusing particles. Overrides the `type` option.
+ * @property {Boolean} [position.randomise=false] When a particle is re-spawned, whether it's position should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [velocity={}] An object describing this particle velocity.
+ * @property {Object} [velocity.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base velocity.
+ * @property {Object} [velocity.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's velocity variance on a per-particle basis.
+ *                                                          Note that when using a SPHERE or DISC distribution, only the x-component
+ *                                                          of this vector is used.
+ * @property {distribution} [velocity.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's velocity. Overrides the `type` option.
+ * @property {Boolean} [velocity.randomise=false] When a particle is re-spawned, whether it's velocity should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [acceleration={}] An object describing this particle's acceleration.
+ * @property {Object} [acceleration.value=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's base acceleration.
+ * @property {Object} [acceleration.spread=new THREE.Vector3()] A THREE.Vector3 instance describing this emitter's acceleration variance on a per-particle basis.
+ *                           Note that when using a SPHERE or DISC distribution, only the x-component
+ *                           of this vector is used.
+ * @property {distribution} [acceleration.distribution=value of the `type` option.] A specific distribution to use when calculating a particle's acceleration. Overrides the `type` option.
+ * @property {Boolean} [acceleration.randomise=false] When a particle is re-spawned, whether it's acceleration should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [drag={}] An object describing this particle drag. Drag is applied to both velocity and acceleration values.
+ * @property {Number} [drag.value=0] A number between 0 and 1 describing the amount of drag to apply to all particles.
+ * @property {Number} [drag.spread=0] A number describing the drag variance on a per-particle basis.
+ * @property {Boolean} [drag.randomise=false] When a particle is re-spawned, whether it's drag should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [wiggle={}] This is quite a fun one! The values of this object will determine whether a particle will wiggle, or jiggle, or wave,
+ *                                or shimmy, or waggle, or... Well you get the idea. The wiggle is calculated over-time, meaning that a particle will
+ *                                start off with no wiggle, and end up wiggling about with the distance of the `value` specified by the time it dies.
+ *                                It's quite handy to simulate fire embers, or similar effects where the particle's position should slightly change over
+ *                                time, and such change isn't easily controlled by rotation, velocity, or acceleration. The wiggle is a combination of sin and cos calculations, so is circular in nature.
+ * @property {Number} [wiggle.value=0] A number describing the amount of wiggle to apply to all particles. It's measured in distance.
+ * @property {Number} [wiggle.spread=0] A number describing the wiggle variance on a per-particle basis.
+ *
+ *
+ * @property {Object} [rotation={}] An object describing this emitter's rotation. It can either be static, or set to rotate from 0radians to the value of `rotation.value`
+ *                                  over a particle's lifetime. Rotation values affect both a particle's position and the forces applied to it.
+ * @property {Object} [rotation.axis=new THREE.Vector3(0, 1, 0)] A THREE.Vector3 instance describing this emitter's axis of rotation.
+ * @property {Object} [rotation.axisSpread=new THREE.Vector3()] A THREE.Vector3 instance describing the amount of variance to apply to the axis of rotation on
+ *                                                              a per-particle basis.
+ * @property {Number} [rotation.angle=0] The angle of rotation, given in radians. If `rotation.static` is true, the emitter will start off rotated at this angle, and stay as such.
+ *                                       Otherwise, the particles will rotate from 0radians to this value over their lifetimes.
+ * @property {Number} [rotation.angleSpread=0] The amount of variance in each particle's rotation angle.
+ * @property {Boolean} [rotation.static=false] Whether the rotation should be static or not.
+ * @property {Object} [rotation.center=The value of `position.value`] A THREE.Vector3 instance describing the center point of rotation.
+ * @property {Boolean} [rotation.randomise=false] When a particle is re-spawned, whether it's rotation should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [color={}] An object describing a particle's color. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of THREE.Color instances are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Object} [color.value=new THREE.Color()] Either a single THREE.Color instance, or an array of THREE.Color instances to describe the color of a particle over it's lifetime.
+ * @property {Object} [color.spread=new THREE.Vector3()] Either a single THREE.Vector3 instance, or an array of THREE.Vector3 instances to describe the color variance of a particle over it's lifetime.
+ * @property {Boolean} [color.randomise=false] When a particle is re-spawned, whether it's color should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [opacity={}] An object describing a particle's opacity. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Number} [opacity.value=1] Either a single number, or an array of numbers to describe the opacity of a particle over it's lifetime.
+ * @property {Number} [opacity.spread=0] Either a single number, or an array of numbers to describe the opacity variance of a particle over it's lifetime.
+ * @property {Boolean} [opacity.randomise=false] When a particle is re-spawned, whether it's opacity should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [size={}] An object describing a particle's size. This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Number} [size.value=1] Either a single number, or an array of numbers to describe the size of a particle over it's lifetime.
+ * @property {Number} [size.spread=0] Either a single number, or an array of numbers to describe the size variance of a particle over it's lifetime.
+ * @property {Boolean} [size.randomise=false] When a particle is re-spawned, whether it's size should be re-randomised or not. Can incur a performance hit.
+ *
+ *
+ * @property {Object} [angle={}] An object describing a particle's angle. The angle is a 2d-rotation, measured in radians, applied to the particle's texture.
+ *                               NOTE: if a particle's texture is a sprite-sheet, this value IS IGNORED.
+ *                               This property is a "value-over-lifetime" property, meaning an array of values and spreads can be
+ *                               given to describe specific value changes over a particle's lifetime.
+ *                               Depending on the value of SPE.valueOverLifetimeLength, if arrays of numbers are given, then the array will be interpolated to
+ *                               have a length matching the value of SPE.valueOverLifetimeLength.
+ * @property {Number} [angle.value=0] Either a single number, or an array of numbers to describe the angle of a particle over it's lifetime.
+ * @property {Number} [angle.spread=0] Either a single number, or an array of numbers to describe the angle variance of a particle over it's lifetime.
+ * @property {Boolean} [angle.randomise=false] When a particle is re-spawned, whether it's angle should be re-randomised or not. Can incur a performance hit.
+ *
+ */
+
+/**
+ * The SPE.Emitter class.
+ *
+ * @constructor
+ *
+ * @param {EmitterOptions} options A map of options to configure the emitter.
+ */
+export default class Emitter {
+	constructor( opts ) {
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure we have a map of options to play with, +and that each option is in the correct format.

      + +
      + + 
      		const options = utils.ensureTypedArg( opts, valueTypes.OBJECT, {} );
+		options.position = utils.ensureTypedArg( options.position, valueTypes.OBJECT, {} );
+		options.velocity = utils.ensureTypedArg( options.velocity, valueTypes.OBJECT, {} );
+		options.acceleration = utils.ensureTypedArg( options.acceleration, valueTypes.OBJECT, {} );
+		options.radius = utils.ensureTypedArg( options.radius, valueTypes.OBJECT, {} );
+		options.drag = utils.ensureTypedArg( options.drag, valueTypes.OBJECT, {} );
+		options.rotation = utils.ensureTypedArg( options.rotation, valueTypes.OBJECT, {} );
+		options.color = utils.ensureTypedArg( options.color, valueTypes.OBJECT, {} );
+		options.opacity = utils.ensureTypedArg( options.opacity, valueTypes.OBJECT, {} );
+		options.size = utils.ensureTypedArg( options.size, valueTypes.OBJECT, {} );
+		options.angle = utils.ensureTypedArg( options.angle, valueTypes.OBJECT, {} );
+		options.wiggle = utils.ensureTypedArg( options.wiggle, valueTypes.OBJECT, {} );
+		options.maxAge = utils.ensureTypedArg( options.maxAge, valueTypes.OBJECT, {} );
+
+		if ( options.onParticleSpawn ) {
+			console.warn( 'onParticleSpawn has been removed. Please set properties directly to alter values at runtime.' );
+		}
+
+		this.uuid = THREE.Math.generateUUID();
+
+		this.type = utils.ensureTypedArg( options.type, valueTypes.NUMBER, distributions.BOX );
      + +
      • + + +
    • +
      + +
      + +
      +

      Start assigning properties…kicking it off with props that DON’T support values over +lifetimes.

      +

      Btw, values over lifetimes are just the new way of referring to *Start, *Middle, and *End.

      + +
      + + 
      		this.position = {
+			_value: utils.ensureInstanceOf( options.position.value, THREE.Vector3, new THREE.Vector3() ),
+			_spread: utils.ensureInstanceOf( options.position.spread, THREE.Vector3, new THREE.Vector3() ),
+			_spreadClamp: utils.ensureInstanceOf( options.position.spreadClamp, THREE.Vector3, new THREE.Vector3() ),
+			_distribution: utils.ensureTypedArg( options.position.distribution, valueTypes.NUMBER, this.type ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+			_radius: utils.ensureTypedArg( options.position.radius, valueTypes.NUMBER, 10 ),
+			_radiusScale: utils.ensureInstanceOf( options.position.radiusScale, THREE.Vector3, new THREE.Vector3( 1, 1, 1 ) ),
+			_distributionClamp: utils.ensureTypedArg( options.position.distributionClamp, valueTypes.NUMBER, 0 ),
+		};
+
+		this.velocity = {
+			_value: utils.ensureInstanceOf( options.velocity.value, THREE.Vector3, new THREE.Vector3() ),
+			_spread: utils.ensureInstanceOf( options.velocity.spread, THREE.Vector3, new THREE.Vector3() ),
+			_distribution: utils.ensureTypedArg( options.velocity.distribution, valueTypes.NUMBER, this.type ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.acceleration = {
+			_value: utils.ensureInstanceOf( options.acceleration.value, THREE.Vector3, new THREE.Vector3() ),
+			_spread: utils.ensureInstanceOf( options.acceleration.spread, THREE.Vector3, new THREE.Vector3() ),
+			_distribution: utils.ensureTypedArg( options.acceleration.distribution, valueTypes.NUMBER, this.type ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.drag = {
+			_value: utils.ensureTypedArg( options.drag.value, valueTypes.NUMBER, 0 ),
+			_spread: utils.ensureTypedArg( options.drag.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.wiggle = {
+			_value: utils.ensureTypedArg( options.wiggle.value, valueTypes.NUMBER, 0 ),
+			_spread: utils.ensureTypedArg( options.wiggle.spread, valueTypes.NUMBER, 0 ),
+		};
+
+		this.rotation = {
+			_axis: utils.ensureInstanceOf( options.rotation.axis, THREE.Vector3, new THREE.Vector3( 0.0, 1.0, 0.0 ) ),
+			_axisSpread: utils.ensureInstanceOf( options.rotation.axisSpread, THREE.Vector3, new THREE.Vector3() ),
+			_angle: utils.ensureTypedArg( options.rotation.angle, valueTypes.NUMBER, 0 ),
+			_angleSpread: utils.ensureTypedArg( options.rotation.angleSpread, valueTypes.NUMBER, 0 ),
+			_static: utils.ensureTypedArg( options.rotation.static, valueTypes.BOOLEAN, false ),
+			_center: utils.ensureInstanceOf( options.rotation.center, THREE.Vector3, this.position._value.clone() ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+
+		this.maxAge = {
+			_value: utils.ensureTypedArg( options.maxAge.value, valueTypes.NUMBER, 2 ),
+			_spread: utils.ensureTypedArg( options.maxAge.spread, valueTypes.NUMBER, 0 ),
+		};
      + +
      • + + +
    • +
      + +
      + +
      +

      The following properties can support either single values, or an array of values that change +the property over a particle’s lifetime (value over lifetime).

      + +
      + + 
      		this.color = {
+			_value: utils.ensureArrayInstanceOf( options.color.value, THREE.Color, new THREE.Color() ),
+			_spread: utils.ensureArrayInstanceOf( options.color.spread, THREE.Vector3, new THREE.Vector3() ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.opacity = {
+			_value: utils.ensureArrayTypedArg( options.opacity.value, valueTypes.NUMBER, 1 ),
+			_spread: utils.ensureArrayTypedArg( options.opacity.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.size = {
+			_value: utils.ensureArrayTypedArg( options.size.value, valueTypes.NUMBER, 1 ),
+			_spread: utils.ensureArrayTypedArg( options.size.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.angle = {
+			_value: utils.ensureArrayTypedArg( options.angle.value, valueTypes.NUMBER, 0 ),
+			_spread: utils.ensureArrayTypedArg( options.angle.spread, valueTypes.NUMBER, 0 ),
+			_randomise: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ),
+		};
      + +
      • + + +
    • +
      + +
      + +
      +

      Assign renaining option values.

      + +
      + + 
      		this.particleCount = utils.ensureTypedArg( options.particleCount, valueTypes.NUMBER, 100 );
+		this.duration = utils.ensureTypedArg( options.duration, valueTypes.NUMBER, null );
+		this.isStatic = utils.ensureTypedArg( options.isStatic, valueTypes.BOOLEAN, false );
+		this.activeMultiplier = utils.ensureTypedArg( options.activeMultiplier, valueTypes.NUMBER, 1 );
+		this.direction = utils.ensureTypedArg( options.direction, valueTypes.NUMBER, 1 );
      + +
      • + + +
    • +
      + +
      + +
      +

      Whether this emitter is alive or not.

      + +
      + + 
      		this.alive = utils.ensureTypedArg( options.alive, valueTypes.BOOLEAN, true );
      + +
      • + + +
    • +
      + +
      + +
      +

      The following properties are set internally and are not +user-controllable.

      + +
      + + 
      		this.particlesPerSecond = 0;
      + +
      • + + +
    • +
      + +
      + +
      +

      The current particle index for which particles should +be marked as active on the next update cycle.

      + +
      + + 
      		this.activationIndex = 0;
      + +
      • + + +
    • +
      + +
      + +
      +

      The offset in the typed arrays this emitter’s +particle’s values will start at

      + +
      + + 
      		this.attributeOffset = 0;
      + +
      • + + +
    • +
      + +
      + +
      +

      The end of the range in the attribute buffers

      + +
      + + 
      		this.attributeEnd = 0;
      + +
      • + + +
    • +
      + +
      + +
      +

      Holds the time the emitter has been alive for.

      + +
      + + 
      		this.age = 0.0;
      + +
      • + + +
    • +
      + +
      + +
      +

      Holds the number of currently-alive particles

      + +
      + + 
      		this.activeParticleCount = 0.0;
      + +
      • + + +
    • +
      + +
      + +
      +

      Holds a reference to this emitter’s group once +it’s added to one.

      + +
      + + 
      		this.group = null;
      + +
      • + + +
    • +
      + +
      + +
      +

      Holds a reference to this emitter’s group’s attributes object +for easier access.

      + +
      + + 
      		this.attributes = null;
      + +
      • + + +
    • +
      + +
      + +
      +

      Holds a reference to the params attribute’s typed array +for quicker access.

      + +
      + + 
      		this.paramsArray = null;
      + +
      • + + +
    • +
      + +
      + +
      +

      A set of flags to determine whether particular properties +should be re-randomised when a particle is reset.

      +

      If a randomise property is given, this is preferred. +Otherwise, it looks at whether a spread value has been +given.

      +

      It allows randomization to be turned off as desired. If +all randomization is turned off, then I’d expect a performance +boost as no attribute buffers (excluding the params) +would have to be re-passed to the GPU each frame (since nothing +except the params attribute would have changed).

      + +
      + + 
      		this.resetFlags = {
      + +
      • + + +
    • +
      + +
      + +
      +

      params: utils.ensureTypedArg( options.maxAge.randomise, valueTypes.BOOLEAN, !!options.maxAge.spread ) || + utils.ensureTypedArg( options.wiggle.randomise, valueTypes.BOOLEAN, !!options.wiggle.spread ),

      + +
      + + 
      			position: utils.ensureTypedArg( options.position.randomise, valueTypes.BOOLEAN, false ) ||
+				utils.ensureTypedArg( options.radius.randomise, valueTypes.BOOLEAN, false ),
+			velocity: utils.ensureTypedArg( options.velocity.randomise, valueTypes.BOOLEAN, false ),
+			acceleration: utils.ensureTypedArg( options.acceleration.randomise, valueTypes.BOOLEAN, false ) ||
+				utils.ensureTypedArg( options.drag.randomise, valueTypes.BOOLEAN, false ),
+			rotation: utils.ensureTypedArg( options.rotation.randomise, valueTypes.BOOLEAN, false ),
+			rotationCenter: utils.ensureTypedArg( options.rotation.randomise, valueTypes.BOOLEAN, false ),
+			size: utils.ensureTypedArg( options.size.randomise, valueTypes.BOOLEAN, false ),
+			color: utils.ensureTypedArg( options.color.randomise, valueTypes.BOOLEAN, false ),
+			opacity: utils.ensureTypedArg( options.opacity.randomise, valueTypes.BOOLEAN, false ),
+			angle: utils.ensureTypedArg( options.angle.randomise, valueTypes.BOOLEAN, false ),
+		};
+
+		this.updateFlags = {};
+		this.updateCounts = {};
      + +
      • + + +
    • +
      + +
      + +
      +

      A map to indicate which emitter parameters should update +which attribute.

      + +
      + + 
      		this.updateMap = {
+			maxAge: 'params',
+			position: 'position',
+			velocity: 'velocity',
+			acceleration: 'acceleration',
+			drag: 'acceleration',
+			wiggle: 'params',
+			rotation: 'rotation',
+			size: 'size',
+			color: 'color',
+			opacity: 'opacity',
+			angle: 'angle',
+		};
+
+		for ( const i in this.updateMap ) {
+			if ( HAS_OWN.call( this.updateMap, i ) ) {
+				this.updateCounts[ this.updateMap[ i ] ] = 0.0;
+				this.updateFlags[ this.updateMap[ i ] ] = false;
+				this._createGetterSetters( this[ i ], i );
+			}
+		}
+
+		this.bufferUpdateRanges = {};
+		this.attributeKeys = null;
+		this.attributeCount = 0;
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure that the value-over-lifetime property objects above +have value and spread properties that are of the same length.

      +

      Also, for now, make sure they have a length of 3 (min/max arguments here).

      + +
      + + 
      		utils.ensureValueOverLifetimeCompliance( this.color, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+		utils.ensureValueOverLifetimeCompliance( this.opacity, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+		utils.ensureValueOverLifetimeCompliance( this.size, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+		utils.ensureValueOverLifetimeCompliance( this.angle, globals.valueOverLifetimeLength, globals.valueOverLifetimeLength );
+	}
+
+	_createGetterSetters( propObj, propName ) {
+		const self = this;
+
+		for ( const i in propObj ) {
+			if ( HAS_OWN.call( propObj, i ) ) {
+
+				const name = i.replace( '_', '' );
+
+				Object.defineProperty( propObj, name, {
+					get: ( function( prop ) {
+						return function() {
+							return this[ prop ];
+						};
+					}( i ) ),
+
+					set: ( function( prop ) {
+						return function( value ) {
+							const mapName = self.updateMap[ propName ],
+								prevValue = this[ prop ],
+								length = globals.valueOverLifetimeLength;
+
+							if ( prop === '_rotationCenter' ) {
+								self.updateFlags.rotationCenter = true;
+								self.updateCounts.rotationCenter = 0.0;
+							}
+							else if ( prop === '_randomise' ) {
+								self.resetFlags[ mapName ] = value;
+							}
+							else {
+								self.updateFlags[ mapName ] = true;
+								self.updateCounts[ mapName ] = 0.0;
+							}
+
+							self.group._updateDefines();
+
+							this[ prop ] = value;
      + +
      • + + +
    • +
      + +
      + +
      +

      If the previous value was an array, then make +sure the provided value is interpolated correctly.

      + +
      + + 
      							if ( Array.isArray( prevValue ) ) {
+								utils.ensureValueOverLifetimeCompliance( self[ propName ], length, length );
+							}
+						};
+					}( i ) ),
+				} );
+			}
+		}
+	}
+
+	_setBufferUpdateRanges( keys ) {
+		this.attributeKeys = keys;
+		this.attributeCount = keys.length;
+
+		for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+			this.bufferUpdateRanges[ keys[ i ] ] = {
+				min: Number.POSITIVE_INFINITY,
+				max: Number.NEGATIVE_INFINITY,
+			};
+		}
+	}
+
+	_calculatePPSValue( groupMaxAge ) {
+		const particleCount = this.particleCount;
      + +
      • + + +
    • +
      + +
      + +
      +

      Calculate the particlesPerSecond value for this emitter. It’s used +when determining which particles should die and which should live to +see another day. Or be born, for that matter. The “God” property.

      + +
      + + 
      		if ( this.duration ) {
+			this.particlesPerSecond = particleCount / ( groupMaxAge < this.duration ? groupMaxAge : this.duration );
+		}
+		else {
+			this.particlesPerSecond = particleCount / groupMaxAge;
+		}
+	}
+
+	_setAttributeOffset( startIndex ) {
+		this.attributeOffset = startIndex;
+		this.activationIndex = startIndex;
+		this.activationEnd = startIndex + this.particleCount;
+	}
+
+
+	_assignValue( prop, index ) {
+		switch ( prop ) {
+			case 'position':
+				this._assignPositionValue( index );
+				break;
+
+			case 'velocity':
+			case 'acceleration':
+				this._assignForceValue( index, prop );
+				break;
+
+			case 'size':
+			case 'opacity':
+				this._assignAbsLifetimeValue( index, prop );
+				break;
+
+			case 'angle':
+				this._assignAngleValue( index );
+				break;
+
+			case 'params':
+				this._assignParamsValue( index );
+				break;
+
+			case 'rotation':
+				this._assignRotationValue( index );
+				break;
+
+			case 'color':
+				this._assignColorValue( index );
+				break;
+		}
+	}
+
+	_assignPositionValue( index ) {
+		const prop = this.position,
+			attr = this.attributes.position,
+			value = prop._value,
+			spread = prop._spread,
+			distribution = prop._distribution;
+
+		switch ( distribution ) {
+			case distributions.BOX:
+				utils.randomVector3( attr, index, value, spread, prop._spreadClamp );
+				break;
+
+			case distributions.SPHERE:
+				utils.randomVector3OnSphere( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x, prop._distributionClamp || this.particleCount );
+				break;
+
+			case distributions.DISC:
+				utils.randomVector3OnDisc( attr, index, value, prop._radius, prop._spread.x, prop._radiusScale, prop._spreadClamp.x );
+				break;
+
+			case distributions.LINE:
+				utils.randomVector3OnLine( attr, index, value, spread );
+				break;
+		}
+	}
+
+	_assignForceValue( index, attrName ) {
+		const prop = this[ attrName ],
+			value = prop._value,
+			spread = prop._spread,
+			distribution = prop._distribution;
+		let pos,
+			positionX,
+			positionY,
+			positionZ,
+			i;
+
+		switch ( distribution ) {
+			case distributions.BOX:
+				utils.randomVector3( this.attributes[ attrName ], index, value, spread );
+				break;
+
+			case distributions.SPHERE:
+				pos = this.attributes.position.typedArray.array;
+				i = index * 3;
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure position values aren’t zero, otherwise no force will be +applied. +positionX = utils.zeroToEpsilon( pos[ i ], true ); +positionY = utils.zeroToEpsilon( pos[ i + 1 ], true ); +positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );

      + +
      + + 
      				positionX = pos[ i ];
+				positionY = pos[ i + 1 ];
+				positionZ = pos[ i + 2 ];
+
+				utils.randomDirectionVector3OnSphere(
+					this.attributes[ attrName ], index,
+					positionX, positionY, positionZ,
+					this.position._value,
+					prop._value.x,
+					prop._spread.x
+				);
+				break;
+
+			case distributions.DISC:
+				pos = this.attributes.position.typedArray.array;
+				i = index * 3;
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure position values aren’t zero, otherwise no force will be +applied. +positionX = utils.zeroToEpsilon( pos[ i ], true ); +positionY = utils.zeroToEpsilon( pos[ i + 1 ], true ); +positionZ = utils.zeroToEpsilon( pos[ i + 2 ], true );

      + +
      + + 
      				positionX = pos[ i ];
+				positionY = pos[ i + 1 ];
+				positionZ = pos[ i + 2 ];
+
+				utils.randomDirectionVector3OnDisc(
+					this.attributes[ attrName ], index,
+					positionX, positionY, positionZ,
+					this.position._value,
+					prop._value.x,
+					prop._spread.x
+				);
+				break;
+
+			case distributions.LINE:
+				utils.randomVector3OnLine( this.attributes[ attrName ], index, value, spread );
+				break;
+		}
+
+		if ( attrName === 'acceleration' ) {
+			const drag = utils.clamp( utils.randomFloat( this.drag._value, this.drag._spread ), 0, 1 );
+			this.attributes.acceleration.typedArray.array[ index * 4 + 3 ] = drag;
+		}
+	}
+
+	_assignAbsLifetimeValue( index, propName ) {
+		const array = this.attributes[ propName ].typedArray,
+			prop = this[ propName ];
+
+		if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
+			const value = Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) );
+			array.setVec4Components( index, value, value, value, value );
+		}
+		else {
+			array.setVec4Components( index,
+				Math.abs( utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ) ),
+				Math.abs( utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ) ),
+				Math.abs( utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ) ),
+				Math.abs( utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] ) )
+			);
+		}
+	}
+
+	_assignAngleValue( index ) {
+		const array = this.attributes.angle.typedArray,
+			prop = this.angle;
+
+		if ( utils.arrayValuesAreEqual( prop._value ) && utils.arrayValuesAreEqual( prop._spread ) ) {
+			const value = utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] );
+			array.setVec4Components( index, value, value, value, value );
+		}
+		else {
+			array.setVec4Components( index,
+				utils.randomFloat( prop._value[ 0 ], prop._spread[ 0 ] ),
+				utils.randomFloat( prop._value[ 1 ], prop._spread[ 1 ] ),
+				utils.randomFloat( prop._value[ 2 ], prop._spread[ 2 ] ),
+				utils.randomFloat( prop._value[ 3 ], prop._spread[ 3 ] )
+			);
+		}
+	}
+
+	_assignParamsValue( index ) {
+		this.attributes.params.typedArray.setVec4Components( index,
+			this.isStatic ? 1 : 0,
+			0.0,
+			Math.abs( utils.randomFloat( this.maxAge._value, this.maxAge._spread ) ),
+			utils.randomFloat( this.wiggle._value, this.wiggle._spread )
+		);
+	}
+
+	_assignRotationValue( index ) {
+		this.attributes.rotation.typedArray.setVec3Components( index,
+			utils.getPackedRotationAxis( this.rotation._axis, this.rotation._axisSpread ),
+			utils.randomFloat( this.rotation._angle, this.rotation._angleSpread ),
+			this.rotation._static ? 0 : 1
+		);
+
+		this.attributes.rotationCenter.typedArray.setVec3( index, this.rotation._center );
+	}
+
+	_assignColorValue( index ) {
+		utils.randomColorAsHex( this.attributes.color, index, this.color._value, this.color._spread );
+	}
+
+	_resetParticle( index ) {
+		const resetFlags = this.resetFlags,
+			updateFlags = this.updateFlags,
+			updateCounts = this.updateCounts,
+			keys = this.attributeKeys;
+		let key,
+			updateFlag;
+
+		for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+			key = keys[ i ];
+			updateFlag = updateFlags[ key ];
+
+			if ( resetFlags[ key ] === true || updateFlag === true ) {
+				this._assignValue( key, index );
+				this._updateAttributeUpdateRange( key, index );
+
+				if ( updateFlag === true && updateCounts[ key ] === this.particleCount ) {
+					updateFlags[ key ] = false;
+					updateCounts[ key ] = 0.0;
+				}
+				else if ( updateFlag == true ) {
+					++updateCounts[ key ];
+				}
+			}
+		}
+	}
+
+	_updateAttributeUpdateRange( attr, i ) {
+		var ranges = this.bufferUpdateRanges[ attr ];
+
+		ranges.min = Math.min( i, ranges.min );
+		ranges.max = Math.max( i, ranges.max );
+	}
+
+	_resetBufferRanges() {
+		const ranges = this.bufferUpdateRanges,
+			keys = this.bufferUpdateKeys;
+		let i = this.bufferUpdateCount - 1,
+			key;
+
+		for ( i; i >= 0; --i ) {
+			key = keys[ i ];
+			ranges[ key ].min = Number.POSITIVE_INFINITY;
+			ranges[ key ].max = Number.NEGATIVE_INFINITY;
+		}
+	}
+
+	_onRemove() {
      + +
      • + + +
    • +
      + +
      + +
      +

      Reset any properties of the emitter that were set by +a group when it was added.

      + +
      + + 
      		this.particlesPerSecond = 0;
+		this.attributeOffset = 0;
+		this.activationIndex = 0;
+		this.activeParticleCount = 0;
+		this.group = null;
+		this.attributes = null;
+		this.paramsArray = null;
+		this.age = 0.0;
+	}
+
+	_decrementParticleCount() {
+		--this.activeParticleCount;
      + +
      • + + +
    • +
      + +
      + +
      +

      TODO:

      +
        +
      • Trigger event if count === 0.
        • +
      + +
      + + 
      	}
+
+	_incrementParticleCount() {
+		'use strict';
+		++this.activeParticleCount;
      + +
      • + + +
    • +
      + +
      + +
      +

      TODO:

      +
        +
      • Trigger event if count === this.particleCount.
        • +
      + +
      + + 
      	}
+
+	_checkParticleAges( start, end, params, dt ) {
+		for ( let i = end - 1, index, maxAge, age, alive; i >= start; --i ) {
+			index = i * 4;
+
+			alive = params[ index ];
+
+			if ( alive === 0.0 ) {
+				continue;
+			}
      + +
      • + + +
    • +
      + +
      + +
      +

      Increment age

      + +
      + + 
      			age = params[ index + 1 ];
+			maxAge = params[ index + 2 ];
+
+			if ( this.direction === 1 ) {
+				age += dt;
+
+				if ( age >= maxAge ) {
+					age = 0.0;
+					alive = 0.0;
+					this._decrementParticleCount();
+				}
+			}
+			else {
+				age -= dt;
+
+				if ( age <= 0.0 ) {
+					age = maxAge;
+					alive = 0.0;
+					this._decrementParticleCount();
+				}
+			}
+
+			params[ index ] = alive;
+			params[ index + 1 ] = age;
+
+			this._updateAttributeUpdateRange( 'params', i );
+		}
+	}
+
+	_activateParticles( activationStart, activationEnd, params, dtPerParticle ) {
+		const direction = this.direction;
+
+		for ( let i = activationStart, index, dtValue; i < activationEnd; ++i ) {
+			index = i * 4;
      + +
      • + + +
    • +
      + +
      + +
      +

      Don’t re-activate particles that aren’t dead yet. +if ( params[ index ] !== 0.0 && ( this.particleCount !== 1 || this.activeMultiplier !== 1 ) ) { + continue; +}

      + +
      + + 
      +			if ( params[ index ] != 0.0 && this.particleCount !== 1 ) {
+				continue;
+			}
      + +
      • + + +
    • +
      + +
      + +
      +

      Increment the active particle count.

      + +
      + + 
      			this._incrementParticleCount();
      + +
      • + + +
    • +
      + +
      + +
      +

      Mark the particle as alive.

      + +
      + + 
      			params[ index ] = 1.0;
      + +
      • + + +
    • +
      + +
      + +
      +

      Reset the particle

      + +
      + + 
      			this._resetParticle( i );
      + +
      • + + +
    • +
      + +
      + +
      +

      Move each particle being activated to +it’s actual position in time.

      +

      This stops particles being ‘clumped’ together +when frame rates are on the lower side of 60fps +or not constant (a very real possibility!)

      + +
      + + 
      			dtValue = dtPerParticle * ( i - activationStart );
+			params[ index + 1 ] = direction === -1 ? params[ index + 2 ] - dtValue : dtValue;
+
+			this._updateAttributeUpdateRange( 'params', i );
+		}
+	}
+
+	/**
+	 * Simulates one frame's worth of particles, updating particles
+	 * that are already alive, and marking ones that are currently dead
+	 * but should be alive as alive.
+	 *
+	 * If the emitter is marked as static, then this function will do nothing.
+	 *
+	 * @param  {Number} dt The number of seconds to simulate (deltaTime)
+	 */
+	tick( dt ) {
+		if ( this.isStatic ) {
+			return;
+		}
+
+		if ( this.paramsArray === null ) {
+			this.paramsArray = this.attributes.params.typedArray.array;
+		}
+
+		const start = this.attributeOffset,
+			end = start + this.particleCount,
+			params = this.paramsArray, // vec3( alive, age, maxAge, wiggle )
+			ppsDt = this.particlesPerSecond * this.activeMultiplier * dt,
+			activationIndex = this.activationIndex;
      + +
      • + + +
    • +
      + +
      + +
      +

      Reset the buffer update indices.

      + +
      + + 
      		this._resetBufferRanges();
      + +
      • + + +
    • +
      + +
      + +
      +

      Increment age for those particles that are alive, +and kill off any particles whose age is over the limit.

      + +
      + + 
      		this._checkParticleAges( start, end, params, dt );
      + +
      • + + +
    • +
      + +
      + +
      +

      If the emitter is dead, reset the age of the emitter to zero, +ready to go again if required

      + +
      + + 
      		if ( this.alive === false ) {
+			this.age = 0.0;
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      If the emitter has a specified lifetime and we’ve exceeded it, +mark the emitter as dead.

      + +
      + + 
      		if ( this.duration !== null && this.age > this.duration ) {
+			this.alive = false;
+			this.age = 0.0;
+			return;
+		}
+
+
+		const activationStart = this.particleCount === 1 ? activationIndex : ( activationIndex | 0 ),
+			activationEnd = Math.min( activationStart + ppsDt, this.activationEnd ),
+			activationCount = activationEnd - this.activationIndex | 0,
+			dtPerParticle = activationCount > 0 ? dt / activationCount : 0;
+
+		this._activateParticles( activationStart, activationEnd, params, dtPerParticle );
      + +
      • + + +
    • +
      + +
      + +
      +

      Move the activation window forward, soldier.

      + +
      + + 
      		this.activationIndex += ppsDt;
+
+		if ( this.activationIndex > end ) {
+			this.activationIndex = start;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Increment the age of the emitter.

      + +
      + + 
      		this.age += dt;
+	}
+
+	/**
+	 * Resets all the emitter's particles to their start positions
+	 * and marks the particles as dead if the `force` argument is
+	 * true.
+	 *
+	 * @param  {Boolean} [force=undefined] If true, all particles will be marked as dead instantly.
+	 * @return {Emitter}       This emitter instance.
+	 */
+	reset( force ) {
+		this.age = 0.0;
+		this.alive = false;
+
+		if ( force === true ) {
+			const start = this.attributeOffset,
+				end = start + this.particleCount,
+				array = this.paramsArray,
+				attr = this.attributes.params.bufferAttribute;
+
+			for ( let i = end - 1, index; i >= start; --i ) {
+				index = i * 4;
+
+				array[ index ] = 0.0;
+				array[ index + 1 ] = 0.0;
+			}
+
+			attr.updateRange.offset = 0;
+			attr.updateRange.count = -1;
+			attr.needsUpdate = true;
+		}
+
+		return this;
+	}
+
+	/**
+	 * Enables the emitter. If not already enabled, the emitter
+	 * will start emitting particles.
+	 *
+	 * @return {Emitter} This emitter instance.
+	 */
+	enable() {
+		this.alive = true;
+		return this;
+	}
+
+	/**
+	 * Disables th emitter, but does not instantly remove it's
+	 * particles fromt the scene. When called, the emitter will be
+	 * 'switched off' and just stop emitting. Any particle's alive will
+	 * be allowed to finish their lifecycle.
+	 *
+	 * @return {Emitter} This emitter instance.
+	 */
+	disable() {
+		this.alive = false;
+		return this;
+	}
+
+	/**
+	 * Remove this emitter from it's parent group (if it has been added to one).
+	 * Delgates to Group.prototype.removeEmitter().
+	 *
+	 * When called, all particle's belonging to this emitter will be instantly
+	 * removed from the scene.
+	 *
+	 * @return {Emitter} This emitter instance.
+	 *
+	 * @see Group.prototype.removeEmitter
+	 */
+	remove() {
+		if ( this.group !== null ) {
+			this.group.removeEmitter( this );
+		}
+		else {
+			console.error( 'Emitter does not belong to a group, cannot remove.' );
+		}
+
+		return this;
+	}
+}
      + +
      • + +
    +
    + + diff --git a/docs/source/src/core/Group.html b/docs/source/src/core/Group.html new file mode 100644 index 0000000..6ddc3f4 --- /dev/null +++ b/docs/source/src/core/Group.html @@ -0,0 +1,1485 @@ + + + + + Group.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      Group.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      import * as THREE from 'three';
+import valueTypes from '@/constants/valueTypes';
+import globals from '@/constants/globals';
+import utils from './utils';
+import ShaderAttribute from '@/helpers/ShaderAttribute';
+import shaders from '@/shaders/shaders';
+import Emitter from './Emitter';
+
+const HAS_OWN = Object.prototype.hasOwnProperty;
+
+/**
+ * An SPE.Group instance.
+ * @typedef {Object} Group
+ * @see SPE.Group
+ */
+
+/**
+ * A map of options to configure an SPE.Group instance.
+ * @typedef {Object} GroupOptions
+ *
+ * @property {Object} texture An object describing the texture used by the group.
+ *
+ * @property {Object} texture.value An instance of THREE.Texture.
+ *
+ * @property {Object=} texture.frames A THREE.Vector2 instance describing the number
+ *                                    of frames on the x- and y-axis of the given texture.
+ *                                    If not provided, the texture will NOT be treated as
+ *                                    a sprite-sheet and as such will NOT be animated.
+ *
+ * @property {Number} [texture.frameCount=texture.frames.x * texture.frames.y] The total number of frames in the sprite-sheet.
+ *                                                                   Allows for sprite-sheets that don't fill the entire
+ *                                                                   texture.
+ *
+ * @property {Number} texture.loop The number of loops through the sprite-sheet that should
+ *                                 be performed over the course of a single particle's lifetime.
+ *
+ * @property {Number} fixedTimeStep If no `dt` (or `deltaTime`) value is passed to this group's
+ *                                  `tick()` function, this number will be used to move the particle
+ *                                  simulation forward. Value in SECONDS.
+ *
+ * @property {Boolean} hasPerspective Whether the distance a particle is from the camera should affect
+ *                                    the particle's size.
+ *
+ * @property {Boolean} colorize Whether the particles in this group should be rendered with color, or
+ *                              whether the only color of particles will come from the provided texture.
+ *
+ * @property {Number} blending One of Three.js's blending modes to apply to this group's `ShaderMaterial`.
+ *
+ * @property {Boolean} transparent Whether these particle's should be rendered with transparency.
+ *
+ * @property {Number} alphaTest Sets the alpha value to be used when running an alpha test on the `texture.value` property. Value between 0 and 1.
+ *
+ * @property {Boolean} depthWrite Whether rendering the group has any effect on the depth buffer.
+ *
+ * @property {Boolean} depthTest Whether to have depth test enabled when rendering this group.
+ *
+ * @property {Boolean} fog Whether this group's particles should be affected by their scene's fog.
+ *
+ * @property {Number} scale The scale factor to apply to this group's particle sizes. Useful for
+ *                          setting particle sizes to be relative to renderer size.
+ */
+
+
+/**
+ * The SPE.Group class. Creates a new group, containing a material, geometry, and mesh.
+ *
+ * @constructor
+ * @param {GroupOptions} options A map of options to configure the group instance.
+ */
+export default class Group {
+	constructor( opts ) {
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure we have a map of options to play with

      + +
      + + 
      		const options = utils.ensureTypedArg( opts, valueTypes.OBJECT, {} );
+		options.texture = utils.ensureTypedArg( options.texture, valueTypes.OBJECT, {} );
      + +
      • + + +
    • +
      + +
      + +
      +

      Assign a UUID to this instance

      + +
      + + 
      		this.uuid = THREE.Math.generateUUID();
      + +
      • + + +
    • +
      + +
      + +
      +

      If no deltaTime value is passed to the SPE.Group.tick function, +the value of this property will be used to advance the simulation.

      + +
      + + 
      		this.fixedTimeStep = utils.ensureTypedArg( options.fixedTimeStep, valueTypes.NUMBER, 0.016 );
      + +
      • + + +
    • +
      + +
      + +
      +

      Set properties used in the uniforms map, starting with the +texture stuff.

      + +
      + + 
      		this.texture = utils.ensureInstanceOf( options.texture.value, THREE.Texture, null );
+		this.textureFrames = utils.ensureInstanceOf( options.texture.frames, THREE.Vector2, new THREE.Vector2( 1, 1 ) );
+		this.textureFrameCount = utils.ensureTypedArg( options.texture.frameCount, valueTypes.NUMBER, this.textureFrames.x * this.textureFrames.y );
+		this.textureLoop = utils.ensureTypedArg( options.texture.loop, valueTypes.NUMBER, 1 );
+		this.textureFrames.max( new THREE.Vector2( 1, 1 ) );
+
+		this.hasPerspective = utils.ensureTypedArg( options.hasPerspective, valueTypes.BOOLEAN, true );
+		this.colorize = utils.ensureTypedArg( options.colorize, valueTypes.BOOLEAN, true );
+
+		this.maxParticleCount = utils.ensureTypedArg( options.maxParticleCount, valueTypes.NUMBER, null );
      + +
      • + + +
    • +
      + +
      + +
      +

      Set properties used to define the ShaderMaterial’s appearance.

      + +
      + + 
      		this.blending = utils.ensureTypedArg( options.blending, valueTypes.NUMBER, THREE.AdditiveBlending );
+		this.transparent = utils.ensureTypedArg( options.transparent, valueTypes.BOOLEAN, true );
+		this.alphaTest = parseFloat( utils.ensureTypedArg( options.alphaTest, valueTypes.NUMBER, 0.0 ) );
+		this.depthWrite = utils.ensureTypedArg( options.depthWrite, valueTypes.BOOLEAN, false );
+		this.depthTest = utils.ensureTypedArg( options.depthTest, valueTypes.BOOLEAN, true );
+		this.fog = utils.ensureTypedArg( options.fog, valueTypes.BOOLEAN, true );
+		this.scale = utils.ensureTypedArg( options.scale, valueTypes.NUMBER, 300 );
      + +
      • + + +
    • +
      + +
      + +
      +

      Where emitter’s go to curl up in a warm blanket and live +out their days.

      + +
      + + 
      		this.emitters = [];
+		this.emitterIDs = [];
      + +
      • + + +
    • +
      + +
      + +
      +

      Create properties for use by the emitter pooling functions.

      + +
      + + 
      		this._pool = [];
+		this._poolCreationSettings = null;
+		this._createNewWhenPoolEmpty = 0;
      + +
      • + + +
    • +
      + +
      + +
      +

      Whether all attributes should be forced to updated +their entire buffer contents on the next tick.

      +

      Used when an emitter is removed.

      + +
      + + 
      		this._attributesNeedRefresh = false;
+		this._attributesNeedDynamicReset = false;
+
+		this.particleCount = 0;
      + +
      • + + +
    • +
      + +
      + +
      +

      Map of uniforms to be applied to the ShaderMaterial instance.

      + +
      + + 
      		this.uniforms = {
+			tex: {
+				type: 't',
+				value: this.texture,
+			},
+			textureAnimation: {
+				type: 'v4',
+				value: new THREE.Vector4(
+					this.textureFrames.x,
+					this.textureFrames.y,
+					this.textureFrameCount,
+					Math.max( Math.abs( this.textureLoop ), 1.0 )
+				),
+			},
+			fogColor: {
+				type: 'c',
+				value: this.fog ? new THREE.Color() : null,
+			},
+			fogNear: {
+				type: 'f',
+				value: 10,
+			},
+			fogFar: {
+				type: 'f',
+				value: 200,
+			},
+			fogDensity: {
+				type: 'f',
+				value: 0.5,
+			},
+			deltaTime: {
+				type: 'f',
+				value: 0,
+			},
+			runTime: {
+				type: 'f',
+				value: 0,
+			},
+			scale: {
+				type: 'f',
+				value: this.scale,
+			},
+		};
      + +
      • + + +
    • +
      + +
      + +
      +

      Add some defines into the mix…

      + +
      + + 
      		this.defines = {
+			HAS_PERSPECTIVE: this.hasPerspective,
+			COLORIZE: this.colorize,
+			VALUE_OVER_LIFETIME_LENGTH: globals.valueOverLifetimeLength,
+
+			SHOULD_ROTATE_TEXTURE: false,
+			SHOULD_ROTATE_PARTICLES: false,
+			SHOULD_WIGGLE_PARTICLES: false,
+
+			SHOULD_CALCULATE_SPRITE: this.textureFrames.x > 1 || this.textureFrames.y > 1,
+		};
      + +
      • + + +
    • +
      + +
      + +
      +

      Map of all attributes to be applied to the particles.

      +

      See ShaderAttribute for a bit more info on this.

      + +
      + + 
      		this.attributes = {
+			position: new ShaderAttribute( 'v3', true ),
+			acceleration: new ShaderAttribute( 'v4', true ), // w component is drag
+			velocity: new ShaderAttribute( 'v3', true ),
+			rotation: new ShaderAttribute( 'v4', true ),
+			rotationCenter: new ShaderAttribute( 'v3', true ),
+			params: new ShaderAttribute( 'v4', true ), // Holds (alive, age, delay, wiggle)
+			size: new ShaderAttribute( 'v4', true ),
+			angle: new ShaderAttribute( 'v4', true ),
+			color: new ShaderAttribute( 'v4', true ),
+			opacity: new ShaderAttribute( 'v4', true ),
+		};
+
+		this.attributeKeys = Object.keys( this.attributes );
+		this.attributeCount = this.attributeKeys.length;
      + +
      • + + +
    • +
      + +
      + +
      +

      Create the ShaderMaterial instance that’ll help render the +particles.

      + +
      + + 
      		this.material = new THREE.ShaderMaterial( {
+			uniforms: this.uniforms,
+			vertexShader: shaders.vertex,
+			fragmentShader: shaders.fragment,
+			blending: this.blending,
+			transparent: this.transparent,
+			alphaTest: this.alphaTest,
+			depthWrite: this.depthWrite,
+			depthTest: this.depthTest,
+			defines: this.defines,
+			fog: this.fog,
+		} );
      + +
      • + + +
    • +
      + +
      + +
      +

      Create the BufferGeometry and Points instances, ensuring +the geometry and material are given to the latter.

      + +
      + + 
      		this.geometry = new THREE.BufferGeometry();
+		this.mesh = new THREE.Points( this.geometry, this.material );
+
+		if ( this.maxParticleCount === null ) {
+			console.warn( 'SPE.Group: No maxParticleCount specified. Adding emitters after rendering will probably cause errors.' );
+		}
+	}
+
+	_updateDefines() {
+		const emitters = this.emitters,
+			defines = this.defines;
+		let emitter,
+			i = emitters.length - 1;
+
+		for ( i; i >= 0; --i ) {
+			emitter = emitters[ i ];
      + +
      • + + +
    • +
      + +
      + +
      +

      Only do angle calculation if there’s no spritesheet defined.

      +

      Saves calculations being done and then overwritten in the shaders.

      + +
      + + 
      			if ( !defines.SHOULD_CALCULATE_SPRITE ) {
+				defines.SHOULD_ROTATE_TEXTURE = defines.SHOULD_ROTATE_TEXTURE || !!Math.max(
+					Math.max.apply( null, emitter.angle.value ),
+					Math.max.apply( null, emitter.angle.spread )
+				);
+			}
+
+			defines.SHOULD_ROTATE_PARTICLES = defines.SHOULD_ROTATE_PARTICLES || !!Math.max(
+				emitter.rotation.angle,
+				emitter.rotation.angleSpread
+			);
+
+			defines.SHOULD_WIGGLE_PARTICLES = defines.SHOULD_WIGGLE_PARTICLES || !!Math.max(
+				emitter.wiggle.value,
+				emitter.wiggle.spread
+			);
+		}
+
+		this.material.needsUpdate = true;
+	}
+
+	_applyAttributesToGeometry() {
+		const attributes = this.attributes,
+			geometry = this.geometry,
+			geometryAttributes = geometry.attributes;
+		let attribute,
+			geometryAttribute;
      + +
      • + + +
    • +
      + +
      + +
      +

      Loop through all the shader attributes and assign (or re-assign) +typed array buffers to each one.

      + +
      + + 
      		for ( const attr in attributes ) {
+			if ( HAS_OWN.call( attributes, attr ) ) {
+				attribute = attributes[ attr ];
+				geometryAttribute = geometryAttributes[ attr ];
      + +
      • + + +
    • +
      + +
      + +
      +

      Update the array if this attribute exists on the geometry.

      +

      This needs to be done because the attribute’s typed array might have +been resized and reinstantiated, and might now be looking at a +different ArrayBuffer, so reference needs updating.

      + +
      + + 
      				if ( geometryAttribute ) {
+					geometryAttribute.array = attribute.typedArray.array;
+				}
      + +
      • + + +
    • +
      + +
      + +
      +

      // Add the attribute to the geometry if it doesn’t already exist.

      + +
      + + 
      				else {
+					geometry.addAttribute( attr, attribute.bufferAttribute );
+				}
      + +
      • + + +
    • +
      + +
      + +
      +

      Mark the attribute as needing an update the next time a frame is rendered.

      + +
      + + 
      				attribute.bufferAttribute.needsUpdate = true;
+			}
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Mark the draw range on the geometry. This will ensure +only the values in the attribute buffers that are +associated with a particle will be used in THREE’s +render cycle.

      + +
      + + 
      		this.geometry.setDrawRange( 0, this.particleCount );
+	}
+
+	/**
+     * Adds an SPE.Emitter instance to this group, creating particle values and
+     * assigning them to this group's shader attributes.
+     *
+     * @param {Emitter} emitter The emitter to add to this group.
+     */
+	addEmitter( emitter ) {
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure an actual emitter instance is passed here.

      +

      Decided not to throw here, just in case a scene’s +rendering would be paused. Logging an error instead +of stopping execution if exceptions aren’t caught.

      + +
      + + 
      		if ( emitter instanceof Emitter === false ) {
+			console.error( '`emitter` argument must be instance of Emitter. Was provided with:', emitter );
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      If the emitter already exists as a member of this group, then +stop here, we don’t want to add it again.

      + +
      + + 
      		else if ( this.emitterIDs.indexOf( emitter.uuid ) > -1 ) {
+			console.error( 'Emitter already exists in this group. Will not add again.' );
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      And finally, if the emitter is a member of another group, +don’t add it to this group.

      + +
      + + 
      		else if ( emitter.group !== null ) {
+			console.error( 'Emitter already belongs to another group. Will not add to requested group.' );
+			return;
+		}
+
+		const attributes = this.attributes,
+			start = this.particleCount,
+			end = start + emitter.particleCount;
      + +
      • + + +
    • +
      + +
      + +
      +

      Update this group’s particle count.

      + +
      + + 
      		this.particleCount = end;
      + +
      • + + +
    • +
      + +
      + +
      +

      Emit a warning if the emitter being added will exceed the buffer sizes specified.

      + +
      + + 
      		if ( this.maxParticleCount !== null && this.particleCount > this.maxParticleCount ) {
+			console.warn( 'SPE.Group: maxParticleCount exceeded. Requesting', this.particleCount, 'particles, can support only', this.maxParticleCount );
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Set the particlesPerSecond value (PPS) on the emitter. +It’s used to determine how many particles to release +on a per-frame basis.

      + +
      + + 
      		emitter._calculatePPSValue( emitter.maxAge._value + emitter.maxAge._spread );
+		emitter._setBufferUpdateRanges( this.attributeKeys );
      + +
      • + + +
    • +
      + +
      + +
      +

      Store the offset value in the TypedArray attributes for this emitter.

      + +
      + + 
      		emitter._setAttributeOffset( start );
      + +
      • + + +
    • +
      + +
      + +
      +

      Save a reference to this group on the emitter so it knows +where it belongs.

      + +
      + + 
      		emitter.group = this;
      + +
      • + + +
    • +
      + +
      + +
      +

      Store reference to the attributes on the emitter for +easier access during the emitter’s tick function.

      + +
      + + 
      		emitter.attributes = this.attributes;
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure the attributes and their BufferAttributes exist, and their +TypedArrays are of the correct size.

      + +
      + + 
      		for ( const attr in attributes ) {
+			if ( HAS_OWN.call( attributes, attr ) ) {
      + +
      • + + +
    • +
      + +
      + +
      +

      When creating a buffer, pass through the maxParticle count +if one is specified.

      + +
      + + 
      				attributes[ attr ]._createBufferAttribute(
+					this.maxParticleCount !== null ?
+						this.maxParticleCount :
+						this.particleCount
+				);
+			}
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Loop through each particle this emitter wants to have, and create the attributes values, +storing them in the TypedArrays that each attribute holds.

      + +
      + + 
      		for ( let i = start; i < end; ++i ) {
+			emitter._assignPositionValue( i );
+			emitter._assignForceValue( i, 'velocity' );
+			emitter._assignForceValue( i, 'acceleration' );
+			emitter._assignAbsLifetimeValue( i, 'opacity' );
+			emitter._assignAbsLifetimeValue( i, 'size' );
+			emitter._assignAngleValue( i );
+			emitter._assignRotationValue( i );
+			emitter._assignParamsValue( i );
+			emitter._assignColorValue( i );
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Update the geometry and make sure the attributes are referencing +the typed arrays properly.

      + +
      + + 
      		this._applyAttributesToGeometry();
      + +
      • + + +
    • +
      + +
      + +
      +

      Store this emitter in this group’s emitter’s store.

      + +
      + + 
      		this.emitters.push( emitter );
+		this.emitterIDs.push( emitter.uuid );
      + +
      • + + +
    • +
      + +
      + +
      +

      Update certain flags to enable shader calculations only if they’re necessary.

      + +
      + + 
      		this._updateDefines( emitter );
      + +
      • + + +
    • +
      + +
      + +
      +

      Update the material since defines might have changed

      + +
      + + 
      		this.material.needsUpdate = true;
+		this.geometry.needsUpdate = true;
+		this._attributesNeedRefresh = true;
      + +
      • + + +
    • +
      + +
      + +
      +

      Return the group to enable chaining.

      + +
      + + 
      		return this;
+	}
+
+	/**
+     * Removes an Emitter instance from this group. When called,
+     * all particle's belonging to the given emitter will be instantly
+     * removed from the scene.
+     *
+     * @param {Emitter} emitter The emitter to add to this group.
+     */
+	removeEmitter( emitter ) {
+		const emitterIndex = this.emitterIDs.indexOf( emitter.uuid );
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure an actual emitter instance is passed here.

      +

      Decided not to throw here, just in case a scene’s +rendering would be paused. Logging an error instead +of stopping execution if exceptions aren’t caught.

      + +
      + + 
      		if ( emitter instanceof Emitter === false ) {
+			console.error( '`emitter` argument must be instance of SPE.Emitter. Was provided with:', emitter );
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Issue an error if the emitter isn’t a member of this group.

      + +
      + + 
      		else if ( emitterIndex === -1 ) {
+			console.error( 'Emitter does not exist in this group. Will not remove.' );
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Kill all particles by marking them as dead +and their age as 0.

      + +
      + + 
      		const start = emitter.attributeOffset,
+			end = start + emitter.particleCount,
+			params = this.attributes.params.typedArray;
      + +
      • + + +
    • +
      + +
      + +
      +

      Set alive and age to zero.

      + +
      + + 
      		for ( let i = start; i < end; ++i ) {
+			params.array[ i * 4 ] = 0.0;
+			params.array[ i * 4 + 1 ] = 0.0;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Remove the emitter from this group’s “store”.

      + +
      + + 
      		this.emitters.splice( emitterIndex, 1 );
+		this.emitterIDs.splice( emitterIndex, 1 );
      + +
      • + + +
    • +
      + +
      + +
      +

      Remove this emitter’s attribute values from all shader attributes. +The .splice() call here also marks each attribute’s buffer +as needing to update it’s entire contents.

      + +
      + + 
      		for ( const attr in this.attributes ) {
+			if ( HAS_OWN.call( this.attributes, attr ) ) {
+				this.attributes[ attr ].splice( start, end );
+			}
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Ensure this group’s particle count is correct.

      + +
      + + 
      		this.particleCount -= emitter.particleCount;
      + +
      • + + +
    • +
      + +
      + +
      +

      Call the emitter’s remove method.

      + +
      + + 
      		emitter._onRemove();
      + +
      • + + +
    • +
      + +
      + +
      +

      Set a flag to indicate that the attribute buffers should +be updated in their entirety on the next frame.

      + +
      + + 
      		this._attributesNeedRefresh = true;
+	}
+
+
+	/**
+     * Fetch a single emitter instance from the pool.
+     * If there are no objects in the pool, a new emitter will be
+     * created if specified.
+     *
+     * @return {Emitter|null}
+     */
+	getFromPool() {
+		const pool = this._pool,
+			createNew = this._createNewWhenPoolEmpty;
+
+		if ( pool.length ) {
+			return pool.pop();
+		}
+		else if ( createNew ) {
+			const emitter = new Emitter( this._poolCreationSettings );
+
+			this.addEmitter( emitter );
+
+			return emitter;
+		}
+
+		return null;
+	}
+
+
+	/**
+     * Release an emitter into the pool.
+     *
+     * @param  {ShaderParticleEmitter} emitter
+     * @return {Group} This group instance.
+     */
+	releaseIntoPool( emitter ) {
+		if ( emitter instanceof Emitter === false ) {
+			console.error( 'Argument is not instanceof Emitter:', emitter );
+			return;
+		}
+
+		emitter.reset();
+		this._pool.unshift( emitter );
+
+		return this;
+	}
+
+
+	/**
+     * Get the pool array
+     *
+     * @return {Array}
+     */
+	getPool() {
+		return this._pool;
+	}
+
+
+	/**
+     * Add a pool of emitters to this particle group
+     *
+     * @param {Number} numEmitters      The number of emitters to add to the pool.
+     * @param {EmitterOptions|Array} emitterOptions  An object, or array of objects, describing the options to pass to each emitter.
+     * @param {Boolean} createNew       Should a new emitter be created if the pool runs out?
+     * @return {Group} This group instance.
+     */
+	addPool( numEmitters, emitterOptions, createNew ) {
      + +
      • + + +
    • +
      + +
      + +
      +

      Save relevant settings and flags.

      + +
      + + 
      		this._poolCreationSettings = emitterOptions;
+		this._createNewWhenPoolEmpty = !!createNew;
      + +
      • + + +
    • +
      + +
      + +
      +

      Create the emitters, add them to this group and the pool.

      + +
      + + 
      		for ( let i = 0; i < numEmitters; ++i ) {
+			let args;
+
+			if ( Array.isArray( emitterOptions ) ) {
+				args = emitterOptions[ i ];
+			}
+			else {
+				args = emitterOptions;
+			}
+
+			const emitter = new Emitter( args );
+
+			this.addEmitter( emitter );
+			this.releaseIntoPool( emitter );
+		}
+
+		return this;
+	}
+
+
+
+	_triggerSingleEmitter( pos ) {
+		const emitter = this.getFromPool();
+
+		if ( emitter === null ) {
+			console.log( 'Group pool ran out.' );
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      TODO:

      +
        +
      • Make sure buffers are update with the new position.
        • +
      + +
      + + 
      		if ( pos instanceof THREE.Vector3 ) {
+			emitter.position.value.copy( pos );
      + +
      • + + +
    • +
      + +
      + +
      +

      Trigger the setter for this property to force an +update to the emitter’s position attribute.

      + +
      + + 
      			emitter.position.value = emitter.position.value; // eslint-disable-line
+		}
+
+		emitter.enable();
+
+		setTimeout( () => {
+			emitter.disable();
+			this.releaseIntoPool( emitter );
+		}, ( Math.max( emitter.duration, ( emitter.maxAge.value + emitter.maxAge.spread ) ) ) * 1000 );
+
+		return this;
+	}
+
+
+	/**
+     * Set a given number of emitters as alive, with an optional position
+     * vector3 to move them to.
+     *
+     * @param  {Number} numEmitters The number of emitters to activate
+     * @param  {Object} [position=undefined] A THREE.Vector3 instance describing the position to activate the emitter(s) at.
+     * @return {Group} This group instance.
+     */
+	triggerPoolEmitter( numEmitters, position ) {
+		if ( typeof numEmitters === 'number' && numEmitters > 1 ) {
+			for ( let i = 0; i < numEmitters; ++i ) {
+				this._triggerSingleEmitter( position );
+			}
+		}
+		else {
+			this._triggerSingleEmitter( position );
+		}
+
+		return this;
+	}
+
+
+
+	_updateUniforms( dt ) {
+		this.uniforms.runTime.value += dt;
+		this.uniforms.deltaTime.value = dt;
+	}
+
+	_resetBufferRanges() {
+		const keys = this.attributeKeys,
+			attrs = this.attributes;
+		let i = this.attributeCount - 1;
+
+		for ( i; i >= 0; --i ) {
+			attrs[ keys[ i ] ].resetUpdateRange();
+		}
+	}
+
+
+	_updateBuffers( emitter ) {
+		const keys = this.attributeKeys,
+			attrs = this.attributes,
+			emitterRanges = emitter.bufferUpdateRanges;
+		let key,
+			emitterAttr,
+			attr;
+
+		for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+			key = keys[ i ];
+			emitterAttr = emitterRanges[ key ];
+			attr = attrs[ key ];
+			attr.setUpdateRange( emitterAttr.min, emitterAttr.max );
+			attr.flagUpdate();
+		}
+	}
+
+
+	/**
+     * Simulate all the emitter's belonging to this group, updating
+     * attribute values along the way.
+     * @param  {Number} [dt=Group's `fixedTimeStep` value] The number of seconds to simulate the group's emitters for (deltaTime)
+     */
+	tick( dt ) {
+		const emitters = this.emitters,
+			numEmitters = emitters.length,
+			deltaTime = dt || this.fixedTimeStep,
+			keys = this.attributeKeys,
+			attrs = this.attributes;
      + +
      • + + +
    • +
      + +
      + +
      +

      Update uniform values.

      + +
      + + 
      		this._updateUniforms( deltaTime );
      + +
      • + + +
    • +
      + +
      + +
      +

      Reset buffer update ranges on the shader attributes.

      + +
      + + 
      		this._resetBufferRanges();
      + +
      • + + +
    • +
      + +
      + +
      +

      If nothing needs updating, then stop here.

      + +
      + + 
      		if (
+			numEmitters === 0 &&
+            this._attributesNeedRefresh === false &&
+            this._attributesNeedDynamicReset === false
+		) {
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Loop through each emitter in this group and +simulate it, then update the shader attribute +buffers.

      + +
      + + 
      		for ( let i = 0, emitter; i < numEmitters; ++i ) {
+			emitter = emitters[ i ];
+			emitter.tick( deltaTime );
+			this._updateBuffers( emitter );
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      If the shader attributes have been refreshed, +then the dynamic properties of each buffer +attribute will need to be reset back to +what they should be.

      + +
      + + 
      		if ( this._attributesNeedDynamicReset === true ) {
+			for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+				attrs[ keys[ i ] ].resetDynamic();
+			}
+
+			this._attributesNeedDynamicReset = false;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      If this group’s shader attributes need a full refresh +then mark each attribute’s buffer attribute as +needing so.

      + +
      + + 
      		if ( this._attributesNeedRefresh === true ) {
+			for ( let i = this.attributeCount - 1; i >= 0; --i ) {
+				attrs[ keys[ i ] ].forceUpdateAll();
+			}
+
+			this._attributesNeedRefresh = false;
+			this._attributesNeedDynamicReset = true;
+		}
+	}
+
+
+	/**
+     * Dipose the geometry and material for the group.
+     *
+     * @return {Group} Group instance.
+     */
+	dispose() {
+		this.geometry.dispose();
+		this.material.dispose();
+		return this;
+	}
+}
      + +
      • + +
    +
    + + diff --git a/docs/source/src/core/utils.html b/docs/source/src/core/utils.html new file mode 100644 index 0000000..e6ecc0d --- /dev/null +++ b/docs/source/src/core/utils.html @@ -0,0 +1,1046 @@ + + + + + utils.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      utils.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      import * as THREE from 'three';
+import valueTypes from '@/constants/valueTypes';
+
+/**
+ * A bunch of utility functions used throughout the library.
+ * @namespace
+ * @type {Object}
+ */
+export default {
+
+	/**
+     * Given a value, a type, and a default value to fallback to,
+     * ensure the given argument adheres to the type requesting,
+     * returning the default value if type check is false.
+     *
+     * @param  {(boolean|string|number|object)} arg          The value to perform a type-check on.
+     * @param  {String} type         The type the `arg` argument should adhere to.
+     * @param  {(boolean|string|number|object)} defaultValue A default value to fallback on if the type check fails.
+     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureTypedArg( arg, type, defaultValue ) {
+		'use strict';
+
+		if ( typeof arg === type ) {
+			return arg;
+		}
+		else {
+			return defaultValue;
+		}
+	},
+
+	/**
+     * Given an array of values, a type, and a default value,
+     * ensure the given array's contents ALL adhere to the provided type,
+     * returning the default value if type check fails.
+     *
+     * If the given value to check isn't an Array, delegates to SPE.utils.ensureTypedArg.
+     *
+     * @param  {Array|boolean|string|number|object} arg          The array of values to check type of.
+     * @param  {String} type         The type that should be adhered to.
+     * @param  {(boolean|string|number|object)} defaultValue A default fallback value.
+     * @return {(boolean|string|number|object)}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureArrayTypedArg( arg, type, defaultValue ) {
+		'use strict';
      + +
      • + + +
    • +
      + +
      + +
      +

      If the argument being checked is an array, loop through +it and ensure all the values are of the correct type, +falling back to the defaultValue if any aren’t.

      + +
      + + 
      		if ( Array.isArray( arg ) ) {
+			for ( var i = arg.length - 1; i >= 0; --i ) {
+				if ( typeof arg[ i ] !== type ) {
+					return defaultValue;
+				}
+			}
+
+			return arg;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      If the arg isn’t an array then just fallback to +checking the type.

      + +
      + + 
      		return this.ensureTypedArg( arg, type, defaultValue );
+	},
+
+	/**
+     * Ensures the given value is an instance of a constructor function.
+     *
+     * @param  {Object} arg          The value to check instance of.
+     * @param  {Function} instance     The constructor of the instance to check against.
+     * @param  {Object} defaultValue A default fallback value if instance check fails
+     * @return {Object}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureInstanceOf( arg, instance, defaultValue ) {
+		'use strict';
+
+		if ( instance !== undefined && arg instanceof instance ) {
+			return arg;
+		}
+		else {
+			return defaultValue;
+		}
+	},
+
+	/**
+     * Given an array of values, ensure the instances of all items in the array
+     * matches the given instance constructor falling back to a default value if
+     * the check fails.
+     *
+     * If given value isn't an Array, delegates to `SPE.utils.ensureInstanceOf`.
+     *
+     * @param  {Array|Object} arg          The value to perform the instanceof check on.
+     * @param  {Function} instance     The constructor of the instance to check against.
+     * @param  {Object} defaultValue A default fallback value if instance check fails
+     * @return {Object}              The given value if type check passes, or the default value if it fails.
+     */
+	ensureArrayInstanceOf( arg, instance, defaultValue ) {
+		'use strict';
      + +
      • + + +
    • +
      + +
      + +
      +

      If the argument being checked is an array, loop through +it and ensure all the values are of the correct type, +falling back to the defaultValue if any aren’t.

      + +
      + + 
      		if ( Array.isArray( arg ) ) {
+			for ( var i = arg.length - 1; i >= 0; --i ) {
+				if ( instance !== undefined && arg[ i ] instanceof instance === false ) {
+					return defaultValue;
+				}
+			}
+
+			return arg;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      If the arg isn’t an array then just fallback to +checking the type.

      + +
      + + 
      		return this.ensureInstanceOf( arg, instance, defaultValue );
+	},
+
+	/**
+     * Ensures that any "value-over-lifetime" properties of an emitter are
+     * of the correct length (as dictated by `SPE.valueOverLifetimeLength`).
+     *
+     * Delegates to `SPE.utils.interpolateArray` for array resizing.
+     *
+     * If properties aren't arrays, then property values are put into one.
+     *
+     * @param  {Object} property  The property of an SPE.Emitter instance to check compliance of.
+     * @param  {Number} minLength The minimum length of the array to create.
+     * @param  {Number} maxLength The maximum length of the array to create.
+     */
+	ensureValueOverLifetimeCompliance( property, minLength, maxLength ) {
+		'use strict';
+
+		minLength = minLength || 3;
+		maxLength = maxLength || 3;
      + +
      • + + +
    • +
      + +
      + +
      +

      First, ensure both properties are arrays.

      + +
      + + 
      		if ( Array.isArray( property._value ) === false ) {
+			property._value = [ property._value ];
+		}
+
+		if ( Array.isArray( property._spread ) === false ) {
+			property._spread = [ property._spread ];
+		}
+
+		var valueLength = this.clamp( property._value.length, minLength, maxLength ),
+			spreadLength = this.clamp( property._spread.length, minLength, maxLength ),
+			desiredLength = Math.max( valueLength, spreadLength );
+
+		if ( property._value.length !== desiredLength ) {
+			property._value = this.interpolateArray( property._value, desiredLength );
+		}
+
+		if ( property._spread.length !== desiredLength ) {
+			property._spread = this.interpolateArray( property._spread, desiredLength );
+		}
+	},
+
+	/**
+     * Performs linear interpolation (lerp) on an array.
+     *
+     * For example, lerping [1, 10], with a `newLength` of 10 will produce [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
+     *
+     * Delegates to `SPE.utils.lerpTypeAgnostic` to perform the actual
+     * interpolation.
+     *
+     * @param  {Array} srcArray  The array to lerp.
+     * @param  {Number} newLength The length the array should be interpolated to.
+     * @return {Array}           The interpolated array.
+     */
+	interpolateArray( srcArray, newLength ) {
+		'use strict';
+
+		var sourceLength = srcArray.length,
+			newArray = [ typeof srcArray[ 0 ].clone === 'function' ? srcArray[ 0 ].clone() : srcArray[ 0 ] ],
+			factor = ( sourceLength - 1 ) / ( newLength - 1 );
+
+
+		for ( var i = 1; i < newLength - 1; ++i ) {
+			var f = i * factor,
+				before = Math.floor( f ),
+				after = Math.ceil( f ),
+				delta = f - before;
+
+			newArray[ i ] = this.lerpTypeAgnostic( srcArray[ before ], srcArray[ after ], delta );
+		}
+
+		newArray.push(
+			typeof srcArray[ sourceLength - 1 ].clone === 'function' ?
+				srcArray[ sourceLength - 1 ].clone() :
+				srcArray[ sourceLength - 1 ]
+		);
+
+		return newArray;
+	},
+
+	/**
+     * Clamp a number to between the given min and max values.
+     * @param  {Number} value The number to clamp.
+     * @param  {Number} min   The minimum value.
+     * @param  {Number} max   The maximum value.
+     * @return {Number}       The clamped number.
+     */
+	clamp( value, min, max ) {
+		'use strict';
+
+		return Math.max( min, Math.min( value, max ) );
+	},
+
+	/**
+     * If the given value is less than the epsilon value, then return
+     * a randomised epsilon value if specified, or just the epsilon value if not.
+     * Works for negative numbers as well as positive.
+     *
+     * @param  {Number} value     The value to perform the operation on.
+     * @param  {Boolean} randomise Whether the value should be randomised.
+     * @return {Number}           The result of the operation.
+     */
+	zeroToEpsilon( value, randomise ) {
+		'use strict';
+
+		var epsilon = 0.00001,
+			result = value;
+
+		result = randomise ? Math.random() * epsilon * 10 : epsilon;
+
+		if ( value < 0 && value > -epsilon ) {
+			result = -result;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      if ( value === 0 ) { + result = randomise ? Math.random() * epsilon * 10 : epsilon; +} +else if ( value > 0 && value < epsilon ) { + result = randomise ? Math.random() * epsilon * 10 : epsilon; +} +else if ( value < 0 && value > -epsilon ) { + result = -( randomise ? Math.random() * epsilon * 10 : epsilon ); +}

      + +
      + + 
      +		return result;
+	},
+
+	/**
+     * Linearly interpolates two values of various valueTypes. The given values
+     * must be of the same type for the interpolation to work.
+     * @param  {(number|Object)} start The start value of the lerp.
+     * @param  {(number|object)} end   The end value of the lerp.
+     * @param  {Number} delta The delta posiiton of the lerp operation. Ideally between 0 and 1 (inclusive).
+     * @return {(number|object|undefined)}       The result of the operation. Result will be undefined if
+     *                                               the start and end arguments aren't a supported type, or
+     *                                               if their types do not match.
+     */
+	lerpTypeAgnostic( start, end, delta ) {
+		'use strict';
+
+		var out;
+
+		if ( typeof start === valueTypes.NUMBER && typeof end === valueTypes.NUMBER ) {
+			return start + ( ( end - start ) * delta );
+		}
+		else if ( start instanceof THREE.Vector2 && end instanceof THREE.Vector2 ) {
+			out = start.clone();
+			out.x = this.lerp( start.x, end.x, delta );
+			out.y = this.lerp( start.y, end.y, delta );
+			return out;
+		}
+		else if ( start instanceof THREE.Vector3 && end instanceof THREE.Vector3 ) {
+			out = start.clone();
+			out.x = this.lerp( start.x, end.x, delta );
+			out.y = this.lerp( start.y, end.y, delta );
+			out.z = this.lerp( start.z, end.z, delta );
+			return out;
+		}
+		else if ( start instanceof THREE.Vector4 && end instanceof THREE.Vector4 ) {
+			out = start.clone();
+			out.x = this.lerp( start.x, end.x, delta );
+			out.y = this.lerp( start.y, end.y, delta );
+			out.z = this.lerp( start.z, end.z, delta );
+			out.w = this.lerp( start.w, end.w, delta );
+			return out;
+		}
+		else if ( start instanceof THREE.Color && end instanceof THREE.Color ) {
+			out = start.clone();
+			out.r = this.lerp( start.r, end.r, delta );
+			out.g = this.lerp( start.g, end.g, delta );
+			out.b = this.lerp( start.b, end.b, delta );
+			return out;
+		}
+		else {
+			console.warn( 'Invalid argument types, or argument types do not match:', start, end );
+		}
+	},
+
+	/**
+     * Perform a linear interpolation operation on two numbers.
+     * @param  {Number} start The start value.
+     * @param  {Number} end   The end value.
+     * @param  {Number} delta The position to interpolate to.
+     * @return {Number}       The result of the lerp operation.
+     */
+	lerp( start, end, delta ) {
+		'use strict';
+		return start + ( ( end - start ) * delta );
+	},
+
+	/**
+     * Rounds a number to a nearest multiple.
+     *
+     * @param  {Number} n        The number to round.
+     * @param  {Number} multiple The multiple to round to.
+     * @return {Number}          The result of the round operation.
+     */
+	roundToNearestMultiple( n, multiple ) {
+		'use strict';
+
+		var remainder = 0;
+
+		if ( multiple === 0 ) {
+			return n;
+		}
+
+		remainder = Math.abs( n ) % multiple;
+
+		if ( remainder === 0 ) {
+			return n;
+		}
+
+		if ( n < 0 ) {
+			return -( Math.abs( n ) - remainder );
+		}
+
+		return n + multiple - remainder;
+	},
+
+	/**
+     * Check if all items in an array are equal. Uses strict equality.
+     *
+     * @param  {Array} array The array of values to check equality of.
+     * @return {Boolean}       Whether the array's values are all equal or not.
+     */
+	arrayValuesAreEqual( array ) {
+		'use strict';
+
+		for ( var i = 0; i < array.length - 1; ++i ) {
+			if ( array[ i ] !== array[ i + 1 ] ) {
+				return false;
+			}
+		}
+
+		return true;
+	},
      + +
      • + + +
    • +
      + +
      + +
      +

      colorsAreEqual: function() { + var colors = Array.prototype.slice.call( arguments ), + numColors = colors.length;

      + +
      + +
      • + + +
    • +
      + +
      + +
      + 
      for ( var i = 0, color1, color2; i < numColors - 1; ++i ) {
+    color1 = colors[ i ];
+    color2 = colors[ i + 1 ];
      + +
      + +
      • + + +
    • +
      + +
      + +
      + 
          if (
+        color1.r !== color2.r ||
+        color1.g !== color2.g ||
+        color1.b !== color2.b
+    ) {
+        return false
+    }
+}
      + +
      + +
      • + + +
    • +
      + +
      + +
      + 
      return true;
      +

      },

      + +
      + + 
      +
+	/**
+     * Given a start value and a spread value, create and return a random
+     * number.
+     * @param  {Number} base   The start value.
+     * @param  {Number} spread The size of the random variance to apply.
+     * @return {Number}        A randomised number.
+     */
+	randomFloat( base, spread ) {
+		'use strict';
+		return base + spread * ( Math.random() - 0.5 );
+	},
+
+
+
+	/**
+     * Given an SPE.ShaderAttribute instance, and various other settings,
+     * assign values to the attribute's array in a `vec3` format.
+     *
+     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base        THREE.Vector3 instance describing the start value.
+     * @param  {Object} spread      THREE.Vector3 instance describing the random variance to apply to the start value.
+     * @param  {Object} spreadClamp THREE.Vector3 instance describing the multiples to clamp the randomness to.
+     */
+	randomVector3( attribute, index, base, spread, spreadClamp ) {
+		'use strict';
+
+		var x = base.x + ( Math.random() * spread.x - ( spread.x * 0.5 ) ),
+			y = base.y + ( Math.random() * spread.y - ( spread.y * 0.5 ) ),
+			z = base.z + ( Math.random() * spread.z - ( spread.z * 0.5 ) );
      + +
      • + + +
    • +
      + +
      + +
      +

      var x = this.randomFloat( base.x, spread.x ), +y = this.randomFloat( base.y, spread.y ), +z = this.randomFloat( base.z, spread.z );

      + +
      + + 
      +		if ( spreadClamp ) {
+			x = -spreadClamp.x * 0.5 + this.roundToNearestMultiple( x, spreadClamp.x );
+			y = -spreadClamp.y * 0.5 + this.roundToNearestMultiple( y, spreadClamp.y );
+			z = -spreadClamp.z * 0.5 + this.roundToNearestMultiple( z, spreadClamp.z );
+		}
+
+		attribute.typedArray.setVec3Components( index, x, y, z );
+	},
+
+	/**
+     * Given an SPE.Shader attribute instance, and various other settings,
+     * assign Color values to the attribute.
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base      THREE.Color instance describing the start color.
+     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
+     */
+	randomColor( attribute, index, base, spread ) {
+		'use strict';
+
+		var r = base.r + ( Math.random() * spread.x ),
+			g = base.g + ( Math.random() * spread.y ),
+			b = base.b + ( Math.random() * spread.z );
+
+		r = this.clamp( r, 0, 1 );
+		g = this.clamp( g, 0, 1 );
+		b = this.clamp( b, 0, 1 );
+
+
+		attribute.typedArray.setVec3Components( index, r, g, b );
+	},
+
+
+	randomColorAsHex: ( function() {
+		'use strict';
+
+		var workingColor = new THREE.Color();
+
+		/**
+         * Assigns a random color value, encoded as a hex value in decimal
+         * format, to a SPE.ShaderAttribute instance.
+         * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+         * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+         * @param  {Object} base      THREE.Color instance describing the start color.
+         * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
+         */
+		return function( attribute, index, base, spread ) {
+			var numItems = base.length,
+				colors = [];
+
+			for ( var i = 0; i < numItems; ++i ) {
+				var spreadVector = spread[ i ];
+
+				workingColor.copy( base[ i ] );
+
+				workingColor.r += ( Math.random() * spreadVector.x ) - ( spreadVector.x * 0.5 );
+				workingColor.g += ( Math.random() * spreadVector.y ) - ( spreadVector.y * 0.5 );
+				workingColor.b += ( Math.random() * spreadVector.z ) - ( spreadVector.z * 0.5 );
+
+				workingColor.r = this.clamp( workingColor.r, 0, 1 );
+				workingColor.g = this.clamp( workingColor.g, 0, 1 );
+				workingColor.b = this.clamp( workingColor.b, 0, 1 );
+
+				colors.push( workingColor.getHex() );
+			}
+
+			attribute.typedArray.setVec4Components( index, colors[ 0 ], colors[ 1 ], colors[ 2 ], colors[ 3 ] );
+		};
+	}() ),
+
+	/**
+     * Given an SPE.ShaderAttribute instance, and various other settings,
+     * assign values to the attribute's array in a `vec3` format.
+     *
+     * @param  {Object} attribute   The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index       The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} start       THREE.Vector3 instance describing the start line position.
+     * @param  {Object} end         THREE.Vector3 instance describing the end line position.
+     */
+	randomVector3OnLine( attribute, index, start, end ) {
+		'use strict';
+		var pos = start.clone();
+
+		pos.lerp( end, Math.random() );
+
+		attribute.typedArray.setVec3Components( index, pos.x, pos.y, pos.z );
+	},
+
+	/**
+     * Given an SPE.Shader attribute instance, and various other settings,
+     * assign Color values to the attribute.
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base      THREE.Color instance describing the start color.
+     * @param  {Object} spread    THREE.Vector3 instance describing the random variance to apply to the start color.
+     */
+
+	/**
+     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
+     * given values onto a sphere.
+     *
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
+     * @param  {Number} radius            The radius of the sphere to project onto.
+     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
+     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the sphere.
+     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
+     */
+	randomVector3OnSphere(
+		attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp, distributionClamp
+	) {
+		'use strict';
+
+		var depth = 2 * Math.random() - 1,
+			t = 6.2832 * Math.random(),
+			r = Math.sqrt( 1 - depth * depth ),
+			rand = this.randomFloat( radius, radiusSpread ),
+			x = 0,
+			y = 0,
+			z = 0;
+
+
+		if ( radiusSpreadClamp ) {
+			rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Set position on sphere

      + +
      + + 
      		x = r * Math.cos( t ) * rand;
+		y = r * Math.sin( t ) * rand;
+		z = depth * rand;
      + +
      • + + +
    • +
      + +
      + +
      +

      Apply radius scale to this position

      + +
      + + 
      		x *= radiusScale.x;
+		y *= radiusScale.y;
+		z *= radiusScale.z;
      + +
      • + + +
    • +
      + +
      + +
      +

      Translate to the base position.

      + +
      + + 
      		x += base.x;
+		y += base.y;
+		z += base.z;
      + +
      • + + +
    • +
      + +
      + +
      +

      Set the values in the typed array.

      + +
      + + 
      		attribute.typedArray.setVec3Components( index, x, y, z );
+	},
+
+	seededRandom( seed ) {
+		var x = Math.sin( seed ) * 10000;
+		return x - ( x | 0 );
+	},
+
+
+
+	/**
+     * Assigns a random vector 3 value to an SPE.ShaderAttribute instance, projecting the
+     * given values onto a 2d-disc.
+     *
+     * @param  {Object} attribute The instance of SPE.ShaderAttribute to save the result to.
+     * @param  {Number} index     The offset in the attribute's TypedArray to save the result from.
+     * @param  {Object} base              THREE.Vector3 instance describing the origin of the transform.
+     * @param  {Number} radius            The radius of the sphere to project onto.
+     * @param  {Number} radiusSpread      The amount of randomness to apply to the projection result
+     * @param  {Object} radiusScale       THREE.Vector3 instance describing the scale of each axis of the disc. The z-component is ignored.
+     * @param  {Number} radiusSpreadClamp What numeric multiple the projected value should be clamped to.
+     */
+	randomVector3OnDisc( attribute, index, base, radius, radiusSpread, radiusScale, radiusSpreadClamp ) {
+		'use strict';
+
+		var t = 6.2832 * Math.random(),
+			rand = Math.abs( this.randomFloat( radius, radiusSpread ) ),
+			x = 0,
+			y = 0,
+			z = 0;
+
+		if ( radiusSpreadClamp ) {
+			rand = Math.round( rand / radiusSpreadClamp ) * radiusSpreadClamp;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Set position on sphere

      + +
      + + 
      		x = Math.cos( t ) * rand;
+		y = Math.sin( t ) * rand;
      + +
      • + + +
    • +
      + +
      + +
      +

      Apply radius scale to this position

      + +
      + + 
      		x *= radiusScale.x;
+		y *= radiusScale.y;
      + +
      • + + +
    • +
      + +
      + +
      +

      Translate to the base position.

      + +
      + + 
      		x += base.x;
+		y += base.y;
+		z += base.z;
      + +
      • + + +
    • +
      + +
      + +
      +

      Set the values in the typed array.

      + +
      + + 
      		attribute.typedArray.setVec3Components( index, x, y, z );
+	},
+
+	randomDirectionVector3OnSphere: ( function() {
+		'use strict';
+
+		var v = new THREE.Vector3();
+
+		/**
+         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
+         * position, using `speed` as the magnitude. Values are saved to the attribute.
+         *
+         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
+         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
+         * @param  {Number} posX            The particle's x coordinate.
+         * @param  {Number} posY            The particle's y coordinate.
+         * @param  {Number} posZ            The particle's z coordinate.
+         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
+         * @param  {Number} speed           The magnitude to apply to the vector.
+         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
+         */
+		return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
+			v.copy( emitterPosition );
+
+			v.x -= posX;
+			v.y -= posY;
+			v.z -= posZ;
+
+			v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
+
+			attribute.typedArray.setVec3Components( index, v.x, v.y, v.z );
+		};
+	}() ),
+
+
+	randomDirectionVector3OnDisc: ( function() {
+		'use strict';
+
+		var v = new THREE.Vector3();
+
+		/**
+         * Given an SPE.ShaderAttribute instance, create a direction vector from the given
+         * position, using `speed` as the magnitude. Values are saved to the attribute.
+         *
+         * @param  {Object} attribute       The instance of SPE.ShaderAttribute to save the result to.
+         * @param  {Number} index           The offset in the attribute's TypedArray to save the result from.
+         * @param  {Number} posX            The particle's x coordinate.
+         * @param  {Number} posY            The particle's y coordinate.
+         * @param  {Number} posZ            The particle's z coordinate.
+         * @param  {Object} emitterPosition THREE.Vector3 instance describing the emitter's base position.
+         * @param  {Number} speed           The magnitude to apply to the vector.
+         * @param  {Number} speedSpread     The amount of randomness to apply to the magnitude.
+         */
+		return function( attribute, index, posX, posY, posZ, emitterPosition, speed, speedSpread ) {
+			v.copy( emitterPosition );
+
+			v.x -= posX;
+			v.y -= posY;
+			v.z -= posZ;
+
+			v.normalize().multiplyScalar( -this.randomFloat( speed, speedSpread ) );
+
+			attribute.typedArray.setVec3Components( index, v.x, v.y, 0 );
+		};
+	}() ),
+
+	getPackedRotationAxis: ( function() {
+		'use strict';
+
+		var v = new THREE.Vector3(),
+			vSpread = new THREE.Vector3(),
+			c = new THREE.Color(),
+			addOne = new THREE.Vector3( 1, 1, 1 );
+
+		/**
+         * Given a rotation axis, and a rotation axis spread vector,
+         * calculate a randomised rotation axis, and pack it into
+         * a hexadecimal value represented in decimal form.
+         * @param  {Object} axis       THREE.Vector3 instance describing the rotation axis.
+         * @param  {Object} axisSpread THREE.Vector3 instance describing the amount of randomness to apply to the rotation axis.
+         * @return {Number}            The packed rotation axis, with randomness.
+         */
+		return function( axis, axisSpread ) {
+			v.copy( axis ).normalize();
+			vSpread.copy( axisSpread ).normalize();
+
+			v.x += ( -axisSpread.x * 0.5 ) + ( Math.random() * axisSpread.x );
+			v.y += ( -axisSpread.y * 0.5 ) + ( Math.random() * axisSpread.y );
+			v.z += ( -axisSpread.z * 0.5 ) + ( Math.random() * axisSpread.z );
      + +
      • + + +
    • +
      + +
      + +
      +

      v.x = Math.abs( v.x ); +v.y = Math.abs( v.y ); +v.z = Math.abs( v.z );

      + +
      + + 
      +			v.normalize().add( addOne )
+				.multiplyScalar( 0.5 );
+
+			c.setRGB( v.x, v.y, v.z );
+
+			return c.getHex();
+		};
+	}() ),
+};
      + +
      • + +
    +
    + + diff --git a/docs/source/src/helpers/ShaderAttribute.html b/docs/source/src/helpers/ShaderAttribute.html new file mode 100644 index 0000000..4f0df50 --- /dev/null +++ b/docs/source/src/helpers/ShaderAttribute.html @@ -0,0 +1,363 @@ + + + + + ShaderAttribute.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      ShaderAttribute.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      import * as THREE from 'three';
+import TypedArrayHelper from './TypedArrayHelper';
+import typeSizeMap from '@/constants/typeSizeMap';
+
+const HAS_OWN = Object.prototype.hasOwnProperty;
+
+/**
+ * A helper to handle creating and updating a THREE.BufferAttribute instance.
+ *
+ * @author  Luke Moody
+ * @constructor
+ * @param {String} type          The buffer attribute type. See `typeSizeMap`` for valid values.
+ * @param {Boolean=} dynamicBuffer Whether this buffer attribute should be marked as dynamic or not.
+ * @param {Function=} arrayType     A reference to a TypedArray constructor. Defaults to Float32Array if none provided.
+ */
+export default class ShaderAttribute {
+	constructor( type, dynamicBuffer, arrayType ) {
+		this.type = typeof type === 'string' && HAS_OWN.call( typeSizeMap, type ) ? type : 'f';
+		this.componentSize = typeSizeMap[ this.type ];
+		this.arrayType = arrayType || Float32Array;
+		this.typedArray = null;
+		this.bufferAttribute = null;
+		this.dynamicBuffer = !!dynamicBuffer;
+
+		this.updateMin = 0;
+		this.updateMax = 0;
+	}
+
+	/**
+	 * Calculate the minimum and maximum update range for this buffer attribute using
+	 * component size independant min and max values.
+	 *
+	 * @param {Number} min The start of the range to mark as needing an update.
+	 * @param {Number} max The end of the range to mark as needing an update.
+	 */
+	setUpdateRange( min, max ) {
+		this.updateMin = Math.min( min * this.componentSize, this.updateMin * this.componentSize );
+		this.updateMax = Math.max( max * this.componentSize, this.updateMax * this.componentSize );
+	}
+
+	/**
+	 * Calculate the number of indices that this attribute should mark as needing
+	 * updating. Also marks the attribute as needing an update.
+	 */
+	flagUpdate() {
+		const attr = this.bufferAttribute,
+			range = attr.updateRange;
+
+		range.offset = this.updateMin;
+		range.count = Math.min( ( this.updateMax - this.updateMin ) + this.componentSize, this.typedArray.array.length );
+		attr.needsUpdate = true;
+	}
+
+
+
+	/**
+	 * Reset the index update counts for this attribute
+	 */
+	resetUpdateRange() {
+		this.updateMin = 0;
+		this.updateMax = 0;
+	}
+
+	resetDynamic() {
+		this.bufferAttribute.usage = this.dynamicBuffer ?
+			THREE.DynamicDrawUsage :
+			THREE.StaticDrawUsage;
+	}
+
+	/**
+	 * Perform a splice operation on this attribute's buffer.
+	 * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
+	 * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
+	 */
+	splice( start, end ) {
+		this.typedArray.splice( start, end );
      + +
      • + + +
    • +
      + +
      + +
      +

      Reset the reference to the attribute’s typed array +since it has probably changed.

      + +
      + + 
      		this.forceUpdateAll();
+	}
+
+	forceUpdateAll() {
+		this.bufferAttribute.array = this.typedArray.array;
+		this.bufferAttribute.updateRange.offset = 0;
+		this.bufferAttribute.updateRange.count = -1;
+
+		this.bufferAttribute.usage = THREE.StaticDrawUsage;
+		this.bufferAttribute.needsUpdate = true;
+	}
+
+	/**
+	 * Make sure this attribute has a typed array associated with it.
+	 *
+	 * If it does, then it will ensure the typed array is of the correct size.
+	 *
+	 * If not, a new `TypedArrayHelper` instance will be created.
+	 *
+	 * @param  {Number} size The size of the typed array to create or update to.
+	 */
+	_ensureTypedArray( size ) {
      + +
      • + + +
    • +
      + +
      + +
      +

      Condition that’s most likely to be true at the top: no change.

      + +
      + + 
      		if ( this.typedArray !== null && this.typedArray.size === size * this.componentSize ) {
+			return;
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      Resize the array if we need to, telling the TypedArrayHelper to +ignore it’s component size when evaluating size.

      + +
      + + 
      		else if ( this.typedArray !== null && this.typedArray.size !== size ) {
+			this.typedArray.setSize( size );
+		}
      + +
      • + + +
    • +
      + +
      + +
      +

      This condition should only occur once in an attribute’s lifecycle.

      + +
      + + 
      		else if ( this.typedArray === null ) {
+			this.typedArray = new TypedArrayHelper( this.arrayType, size, this.componentSize );
+		}
+	}
+
+
+	/**
+	 * Creates a THREE.BufferAttribute instance if one doesn't exist already.
+	 *
+	 * Ensures a typed array is present by calling _ensureTypedArray() first.
+	 *
+	 * If a buffer attribute exists already, then it will be marked as needing an update.
+	 *
+	 * @param  {Number} size The size of the typed array to create if one doesn't exist, or resize existing array to.
+	 */
+	_createBufferAttribute( size ) {
      + +
      • + + +
    • +
      + +
      + +
      +

      Make sure the typedArray is present and correct.

      + +
      + + 
      		this._ensureTypedArray( size );
      + +
      • + + +
    • +
      + +
      + +
      +

      Don’t create it if it already exists, but do +flag that it needs updating on the next render +cycle.

      + +
      + + 
      		if ( this.bufferAttribute !== null ) {
+			this.bufferAttribute.array = this.typedArray.array;
      + +
      • + + +
    • +
      + +
      + +
      +

      Since THREE.js version 81, dynamic count calculation was removed +so I need to do it manually here.

      +

      In the next minor release, I may well remove this check and force +dependency on THREE r81+.

      + +
      + + 
      			if ( parseFloat( THREE.REVISION ) >= 81 ) {
+				this.bufferAttribute.count = this.bufferAttribute.array.length / this.bufferAttribute.itemSize;
+			}
+
+			this.bufferAttribute.needsUpdate = true;
+			return;
+		}
+
+		this.bufferAttribute = new THREE.BufferAttribute( this.typedArray.array, this.componentSize );
+
+		this.bufferAttribute.usage = this.dynamicBuffer ?
+			THREE.DynamicDrawUsage :
+			THREE.StaticDrawUsage;
+	}
+
+	/**
+	 * Returns the length of the typed array associated with this attribute.
+	 * @return {Number} The length of the typed array. Will be 0 if no typed array has been created yet.
+	 */
+	getLength() {
+		if ( this.typedArray === null ) {
+			return 0;
+		}
+
+		return this.typedArray.array.length;
+	}
+
+}
      + +
      • + +
    +
    + + diff --git a/docs/source/src/helpers/TypedArrayHelper.html b/docs/source/src/helpers/TypedArrayHelper.html new file mode 100644 index 0000000..f083e88 --- /dev/null +++ b/docs/source/src/helpers/TypedArrayHelper.html @@ -0,0 +1,416 @@ + + + + + TypedArrayHelper.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      TypedArrayHelper.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      /**
+ * A helper class for TypedArrays.
+ *
+ * Allows for easy resizing, assignment of various component-based
+ * types (Vector2s, Vector3s, Vector4s, Mat3s, Mat4s),
+ * as well as Colors (where components are `r`, `g`, `b`),
+ * Numbers, and setting from other TypedArrays.
+ *
+ * @author Luke Moody
+ * @constructor
+ * @param {Function} TypedArrayConstructor The constructor to use (Float32Array, Uint8Array, etc.)
+ * @param {Number} size                 The size of the array to create
+ * @param {Number} componentSize        The number of components per-value (ie. 3 for a vec3, 9 for a Mat3, etc.)
+ * @param {Number} indexOffset          The index in the array from which to start assigning values. Default `0` if none provided
+ */
+export default class TypedArrayHelper {
+	constructor( TypedArrayConstructor, size, componentSize, indexOffset ) {
+		this.componentSize = componentSize || 1;
+		this.size = ( size || 1 );
+		this.TypedArrayConstructor = TypedArrayConstructor || Float32Array;
+		this.array = new TypedArrayConstructor( size * this.componentSize );
+		this.indexOffset = indexOffset || 0;
+	}
+
+	/**
+	 * Sets the size of the internal array.
+	 *
+	 * Delegates to `this.shrink` or `this.grow` depending on size
+	 * argument's relation to the current size of the internal array.
+	 *
+	 * Note that if the array is to be shrunk, data will be lost.
+	 *
+	 * @param {Number} size The new size of the array.
+	 */
+	setSize( s, noComponentMultiply ) {
+		const currentArraySize = this.array.length;
+		let size = s;
+
+		if ( !noComponentMultiply ) {
+			size = size * this.componentSize;
+		}
+
+		if ( size < currentArraySize ) {
+			return this.shrink( size );
+		}
+		else if ( size > currentArraySize ) {
+			return this.grow( size );
+		}
+		else {
+			console.info( 'TypedArray is already of size:', size + '.', 'Will not resize.' );
+		}
+	}
+
+	/**
+	 * Shrinks the internal array.
+	 *
+	 * @param  {Number} size The new size of the typed array. Must be smaller than `this.array.length`.
+	 * @return {SPE.TypedArrayHelper}      Instance of this class.
+	 */
+	shrink( size ) {
+		this.array = this.array.subarray( 0, size );
+		this.size = size;
+		return this;
+	}
+
+	/**
+	 * Grows the internal array.
+	 * @param  {Number} size The new size of the typed array. Must be larger than `this.array.length`.
+	 * @return {SPE.TypedArrayHelper}      Instance of this class.
+	 */
+	grow( size ) {
+		const newArray = new this.TypedArrayConstructor( size );
+
+		newArray.set( this.array );
+		this.array = newArray;
+		this.size = size;
+
+		return this;
+	}
+
+
+	/**
+	 * Perform a splice operation on this array's buffer.
+	 * @param  {Number} start The start index of the splice. Will be multiplied by the number of components for this attribute.
+	 * @param  {Number} end The end index of the splice. Will be multiplied by the number of components for this attribute.
+	 * @returns {Object} The SPE.TypedArrayHelper instance.
+	 */
+	splice( start, end ) {
+		const _start = start * this.componentSize,
+			_end = end * this.componentSize;
+
+		const data = [],
+			array = this.array,
+			size = array.length;
+
+		for ( let i = 0; i < size; ++i ) {
+			if ( i < _start || i >= _end ) {
+				data.push( array[ i ] );
+			}
      + +
      • + + +
    • +
      + +
      + +
      +

      array[ i ] = 0;

      + +
      + + 
      		}
+
+		this.setFromArray( 0, data );
+
+		return this;
+	}
+
+
+	/**
+	 * Copies from the given TypedArray into this one, using the index argument
+	 * as the start position. Alias for `TypedArray.set`. Will automatically resize
+	 * if the given source array is of a larger size than the internal array.
+	 *
+	 * @param {Number} index      The start position from which to copy into this array.
+	 * @param {TypedArray} array The array from which to copy; the source array.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setFromArray( index, array ) {
+		const sourceArraySize = array.length,
+			newSize = index + sourceArraySize;
+
+		if ( newSize > this.array.length ) {
+			this.grow( newSize );
+		}
+		else if ( newSize < this.array.length ) {
+			this.shrink( newSize );
+		}
+
+		this.array.set( array, this.indexOffset + index );
+
+		return this;
+	}
+
+	/**
+	 * Set a Vector2 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec2 values from.
+	 * @param {Vector2} vec2  Any object that has `x` and `y` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec2( index, vec2 ) {
+		return this.setVec2Components( index, vec2.x, vec2.y );
+	}
+
+	/**
+	 * Set a Vector2 value using raw components.
+	 *
+	 * @param {Number} index The index at which to set the vec2 values from.
+	 * @param {Number} x     The Vec2's `x` component.
+	 * @param {Number} y     The Vec2's `y` component.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec2Components( index, x, y ) {
+		const array = this.array,
+			i = this.indexOffset + ( index * this.componentSize );
+
+		array[ i ] = x;
+		array[ i + 1 ] = y;
+		return this;
+	}
+
+	/**
+	 * Set a Vector3 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Vector3} vec2  Any object that has `x`, `y`, and `z` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec3( index, vec3 ) {
+		return this.setVec3Components( index, vec3.x, vec3.y, vec3.z );
+	}
+
+	/**
+	 * Set a Vector3 value using raw components.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Number} x     The Vec3's `x` component.
+	 * @param {Number} y     The Vec3's `y` component.
+	 * @param {Number} z     The Vec3's `z` component.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec3Components( index, x, y, z ) {
+		const array = this.array,
+			i = this.indexOffset + ( index * this.componentSize );
+
+		array[ i ] = x;
+		array[ i + 1 ] = y;
+		array[ i + 2 ] = z;
+		return this;
+	}
+
+	/**
+	 * Set a Vector4 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec4 values from.
+	 * @param {Vector4} vec2  Any object that has `x`, `y`, `z`, and `w` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec4( index, vec4 ) {
+		return this.setVec4Components( index, vec4.x, vec4.y, vec4.z, vec4.w );
+	}
+
+	/**
+	 * Set a Vector4 value using raw components.
+	 *
+	 * @param {Number} index The index at which to set the vec4 values from.
+	 * @param {Number} x     The Vec4's `x` component.
+	 * @param {Number} y     The Vec4's `y` component.
+	 * @param {Number} z     The Vec4's `z` component.
+	 * @param {Number} w     The Vec4's `w` component.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setVec4Components( index, x, y, z, w ) {
+		const array = this.array,
+			i = this.indexOffset + ( index * this.componentSize );
+
+		array[ i ] = x;
+		array[ i + 1 ] = y;
+		array[ i + 2 ] = z;
+		array[ i + 3 ] = w;
+		return this;
+	}
+
+	/**
+	 * Set a Matrix3 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the matrix values from.
+	 * @param {Matrix3} mat3 The 3x3 matrix to set from. Must have a TypedArray property named `elements` to copy from.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setMat3( index, mat3 ) {
+		return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat3.elements );
+	}
+
+	/**
+	 * Set a Matrix4 value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the matrix values from.
+	 * @param {Matrix4} mat3 The 4x4 matrix to set from. Must have a TypedArray property named `elements` to copy from.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setMat4( index, mat4 ) {
+		return this.setFromArray( this.indexOffset + ( index * this.componentSize ), mat4.elements );
+	}
+
+	/**
+	 * Set a Color value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Color} color  Any object that has `r`, `g`, and `b` properties.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setColor( index, color ) {
+		return this.setVec3Components( index, color.r, color.g, color.b );
+	}
+
+	/**
+	 * Set a Number value at `index`.
+	 *
+	 * @param {Number} index The index at which to set the vec3 values from.
+	 * @param {Number} numericValue  The number to assign to this index in the array.
+	 * @return {SPE.TypedArrayHelper} Instance of this class.
+	 */
+	setNumber( index, numericValue ) {
+		this.array[ this.indexOffset + ( index * this.componentSize ) ] = numericValue;
+		return this;
+	}
+
+	/**
+	 * Returns the value of the array at the given index, taking into account
+	 * the `indexOffset` property of this class.
+	 *
+	 * Note that this function ignores the component size and will just return a
+	 * single value.
+	 *
+	 * @param  {Number} index The index in the array to fetch.
+	 * @return {Number}       The value at the given index.
+	 */
+	getValueAtIndex( index ) {
+		return this.array[ this.indexOffset + index ];
+	}
+
+	/**
+	 * Returns the component value of the array at the given index, taking into account
+	 * the `indexOffset` property of this class.
+	 *
+	 * If the componentSize is set to 3, then it will return a new TypedArray
+	 * of length 3.
+	 *
+	 * @param  {Number} index The index in the array to fetch.
+	 * @return {TypedArray}       The component value at the given index.
+	 */
+	getComponentValueAtIndex( index ) {
+		return this.array.subarray( this.indexOffset + ( index * this.componentSize ) );
+	}
+}
      + +
      • + +
    +
    + + diff --git a/docs/source/src/shaders/shaderChunks.html b/docs/source/src/shaders/shaderChunks.html new file mode 100644 index 0000000..b9939e7 --- /dev/null +++ b/docs/source/src/shaders/shaderChunks.html @@ -0,0 +1,508 @@ + + + + + shaderChunks.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      shaderChunks.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      export default {
      + +
      • + + +
    • +
      + +
      + +
      +

      Register color-packing define statements.

      + +
      + + 
      	defines: [
+		'#define PACKED_COLOR_SIZE 256.0',
+		'#define PACKED_COLOR_DIVISOR 255.0',
+	].join( '\n' ),
      + +
      • + + +
    • +
      + +
      + +
      +

      All uniforms used by vertex / fragment shaders

      + +
      + + 
      	uniforms: [
+		'uniform float deltaTime;',
+		'uniform float runTime;',
+		'uniform sampler2D tex;',
+		'uniform vec4 textureAnimation;',
+		'uniform float scale;',
+	].join( '\n' ),
      + +
      • + + +
    • +
      + +
      + +
      +

      All attributes used by the vertex shader.

      +

      Note that some attributes are squashed into other ones:

      +
        +
      • Drag is acceleration.w
        • +
      + +
      + + 
      	attributes: [
+		'attribute vec4 acceleration;',
+		'attribute vec3 velocity;',
+		'attribute vec4 rotation;',
+		'attribute vec3 rotationCenter;',
+		'attribute vec4 params;',
+		'attribute vec4 size;',
+		'attribute vec4 angle;',
+		'attribute vec4 color;',
+		'attribute vec4 opacity;',
+	].join( '\n' ),
      + +
      • + + +
    • +
      + +
      + +
      + +
      + + 
      	varyings: [
+		'varying vec4 vColor;',
+		'#ifdef SHOULD_ROTATE_TEXTURE',
+		'    varying float vAngle;',
+		'#endif',
+
+		'#ifdef SHOULD_CALCULATE_SPRITE',
+		'    varying vec4 vSpriteSheet;',
+		'#endif',
+	].join( '\n' ),
      + +
      • + + +
    • +
      + +
      + +
      +

      Branch-avoiding comparison fns

      + + +
      + + 
      	branchAvoidanceFunctions: [
+		'float when_gt(float x, float y) {',
+		'    return max(sign(x - y), 0.0);',
+		'}',
+
+		'float when_lt(float x, float y) {',
+		'    return min( max(1.0 - sign(x - y), 0.0), 1.0 );',
+		'}',
+
+		'float when_eq( float x, float y ) {',
+		'    return 1.0 - abs( sign( x - y ) );',
+		'}',
+
+		'float when_ge(float x, float y) {',
+		'  return 1.0 - when_lt(x, y);',
+		'}',
+
+		'float when_le(float x, float y) {',
+		'  return 1.0 - when_gt(x, y);',
+		'}',
      + +
      • + + +
    • +
      + +
      + +
      +

      Branch-avoiding logical operators +(to be used with above comparison fns)

      + +
      + + 
      		'float and(float a, float b) {',
+		'    return a * b;',
+		'}',
+
+		'float or(float a, float b) {',
+		'    return min(a + b, 1.0);',
+		'}',
+	].join( '\n' ),
      + +
      • + + +
    • +
      + +
      + +
      +

      From:

      + + +
      + + 
      	unpackColor: [
+		'vec3 unpackColor( in float hex ) {',
+		'   vec3 c = vec3( 0.0 );',
+
+		'   float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
+		'   float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
+		'   float b = mod( hex, PACKED_COLOR_SIZE );',
+
+		'   c.r = r / PACKED_COLOR_DIVISOR;',
+		'   c.g = g / PACKED_COLOR_DIVISOR;',
+		'   c.b = b / PACKED_COLOR_DIVISOR;',
+
+		'   return c;',
+		'}',
+	].join( '\n' ),
+
+	unpackRotationAxis: [
+		'vec3 unpackRotationAxis( in float hex ) {',
+		'   vec3 c = vec3( 0.0 );',
+
+		'   float r = mod( (hex / PACKED_COLOR_SIZE / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
+		'   float g = mod( (hex / PACKED_COLOR_SIZE), PACKED_COLOR_SIZE );',
+		'   float b = mod( hex, PACKED_COLOR_SIZE );',
+
+		'   c.r = r / PACKED_COLOR_DIVISOR;',
+		'   c.g = g / PACKED_COLOR_DIVISOR;',
+		'   c.b = b / PACKED_COLOR_DIVISOR;',
+
+		'   c *= vec3( 2.0 );',
+		'   c -= vec3( 1.0 );',
+
+		'   return c;',
+		'}',
+	].join( '\n' ),
+
+	floatOverLifetime: [
+		'float getFloatOverLifetime( in float positionInTime, in vec4 attr ) {',
+		'    highp float value = 0.0;',
+		'    float deltaAge = positionInTime * float( VALUE_OVER_LIFETIME_LENGTH - 1 );',
+		'    float fIndex = 0.0;',
+		'    float shouldApplyValue = 0.0;',
      + +
      • + + +
    • +
      + +
      + +
      +

      This might look a little odd, but it’s faster in the testing I’ve done than using branches. +Uses basic maths to avoid branching.

      +

      Take a look at the branch-avoidance functions defined above, +and be sure to check out The Orange Duck site where I got this +from (link above).

      + +
      + +
      • + + +
    • +
      + +
      + +
      +

      Fix for static emitters (age is always zero).

      + +
      + + 
      		'    value += attr[ 0 ] * when_eq( deltaAge, 0.0 );',
+		'',
+		'    for( int i = 0; i < VALUE_OVER_LIFETIME_LENGTH - 1; ++i ) {',
+		'       fIndex = float( i );',
+		'       shouldApplyValue = and( when_gt( deltaAge, fIndex ), when_le( deltaAge, fIndex + 1.0 ) );',
+		'       value += shouldApplyValue * mix( attr[ i ], attr[ i + 1 ], deltaAge - fIndex );',
+		'    }',
+		'',
+		'    return value;',
+		'}',
+	].join( '\n' ),
+
+	colorOverLifetime: [
+		'vec3 getColorOverLifetime( in float positionInTime, in vec3 color1, in vec3 color2, in vec3 color3, in vec3 color4 ) {',
+		'    vec3 value = vec3( 0.0 );',
+		'    value.x = getFloatOverLifetime( positionInTime, vec4( color1.x, color2.x, color3.x, color4.x ) );',
+		'    value.y = getFloatOverLifetime( positionInTime, vec4( color1.y, color2.y, color3.y, color4.y ) );',
+		'    value.z = getFloatOverLifetime( positionInTime, vec4( color1.z, color2.z, color3.z, color4.z ) );',
+		'    return value;',
+		'}',
+	].join( '\n' ),
+
+	paramFetchingFunctions: [
+		'float getAlive() {',
+		'   return params.x;',
+		'}',
+
+		'float getAge() {',
+		'   return params.y;',
+		'}',
+
+		'float getMaxAge() {',
+		'   return params.z;',
+		'}',
+
+		'float getWiggle() {',
+		'   return params.w;',
+		'}',
+	].join( '\n' ),
+
+	forceFetchingFunctions: [
+		'vec4 getPosition( in float age ) {',
+		'   return modelViewMatrix * vec4( position, 1.0 );',
+		'}',
+
+		'vec3 getVelocity( in float age ) {',
+		'   return velocity * age;',
+		'}',
+
+		'vec3 getAcceleration( in float age ) {',
+		'   return acceleration.xyz * age;',
+		'}',
+	].join( '\n' ),
+
+
+	rotationFunctions: [
      + +
      • + + +
    • +
      + +
      + +
      +

      Huge thanks to:

      + + +
      + + 
      		'#ifdef SHOULD_ROTATE_PARTICLES',
+		'   mat4 getRotationMatrix( in vec3 axis, in float angle) {',
+		'       axis = normalize(axis);',
+		'       float s = sin(angle);',
+		'       float c = cos(angle);',
+		'       float oc = 1.0 - c;',
+		'',
+		'       return mat4(oc * axis.x * axis.x + c,           oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s,  0.0,',
+		'                   oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s,  0.0,',
+		'                   oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c,           0.0,',
+		'                   0.0,                                0.0,                                0.0,                                1.0);',
+		'   }',
+		'',
+		'   vec3 getRotation( in vec3 pos, in float positionInTime ) {',
+		'      if( rotation.y == 0.0 ) {',
+		'           return pos;',
+		'      }',
+		'',
+		'      vec3 axis = unpackRotationAxis( rotation.x );',
+		'      vec3 center = rotationCenter;',
+		'      vec3 translated;',
+		'      mat4 rotationMatrix;',
+
+		'      float angle = 0.0;',
+		'      angle += when_eq( rotation.z, 0.0 ) * rotation.y;',
+		'      angle += when_gt( rotation.z, 0.0 ) * mix( 0.0, rotation.y, positionInTime );',
+		'      translated = rotationCenter - pos;',
+		'      rotationMatrix = getRotationMatrix( axis, angle );',
+		'      return center - vec3( rotationMatrix * vec4( translated, 0.0 ) );',
+		'   }',
+		'#endif',
+	].join( '\n' ),
      + +
      • + + +
    • +
      + +
      + +
      +

      Fragment chunks

      + +
      + + 
      	rotateTexture: [
+		'    vec2 vUv = vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y );',
+		'',
+		'    #ifdef SHOULD_ROTATE_TEXTURE',
+		'       float x = gl_PointCoord.x - 0.5;',
+		'       float y = 1.0 - gl_PointCoord.y - 0.5;',
+		'       float c = cos( -vAngle );',
+		'       float s = sin( -vAngle );',
+
+		'       vUv = vec2( c * x + s * y + 0.5, c * y - s * x + 0.5 );',
+		'    #endif',
+		'',
      + +
      • + + +
    • +
      + +
      + +
      +

      Spritesheets overwrite angle calculations.

      + +
      + + 
      		'    #ifdef SHOULD_CALCULATE_SPRITE',
+		'        float framesX = vSpriteSheet.x;',
+		'        float framesY = vSpriteSheet.y;',
+		'        float columnNorm = vSpriteSheet.z;',
+		'        float rowNorm = vSpriteSheet.w;',
+
+		'        vUv.x = gl_PointCoord.x * framesX + columnNorm;',
+		'        vUv.y = 1.0 - (gl_PointCoord.y * framesY + rowNorm);',
+		'    #endif',
+
+		'',
+		'    vec4 rotatedTexture = texture2D( tex, vUv );',
+	].join( '\n' ),
+};
      + +
      • + +
    +
    + + diff --git a/docs/source/src/shaders/shaders.html b/docs/source/src/shaders/shaders.html new file mode 100644 index 0000000..226f42f --- /dev/null +++ b/docs/source/src/shaders/shaders.html @@ -0,0 +1,491 @@ + + + + + shaders.js + + + + + +
    +
    + + + +
      + +
    • +
      +

      shaders.js

      +
      +
      • + + + +
    • +
      + +
      + +
      + +
      + + 
      import * as THREE from 'three';
+import shaderChunks from './shaderChunks';
+
+export default {
+	vertex: [
+		shaderChunks.defines,
+		shaderChunks.uniforms,
+		shaderChunks.attributes,
+		shaderChunks.varyings,
+
+		THREE.ShaderChunk.common,
+		THREE.ShaderChunk.logdepthbuf_pars_vertex,
+		THREE.ShaderChunk.fog_pars_vertex,
+
+		shaderChunks.branchAvoidanceFunctions,
+		shaderChunks.unpackColor,
+		shaderChunks.unpackRotationAxis,
+		shaderChunks.floatOverLifetime,
+		shaderChunks.colorOverLifetime,
+		shaderChunks.paramFetchingFunctions,
+		shaderChunks.forceFetchingFunctions,
+		shaderChunks.rotationFunctions,
+
+		'void main() {',
      + +
      • + + +
    • +
      + +
      + +
      +

      Setup…

      + +
      + + 
      		'    highp float age = getAge();',
+		'    highp float alive = getAlive();',
+		'    highp float maxAge = getMaxAge();',
+		'    highp float positionInTime = (age / maxAge);',
+		'    highp float isAlive = when_gt( alive, 0.0 );',
+
+		'    #ifdef SHOULD_WIGGLE_PARTICLES',
+		'        float wiggleAmount = positionInTime * getWiggle();',
+		'        float wiggleSin = isAlive * sin( wiggleAmount );',
+		'        float wiggleCos = isAlive * cos( wiggleAmount );',
+		'    #endif',
      + +
      • + + +
    • +
      + +
      + +
      +

      Forces

      + +
      + +
      • + + +
    • +
      + +
      + +
      +

      Get forces & position

      + +
      + + 
      		'    vec3 vel = getVelocity( age );',
+		'    vec3 accel = getAcceleration( age );',
+		'    vec3 force = vec3( 0.0 );',
+		'    vec3 pos = vec3( position );',
      + +
      • + + +
    • +
      + +
      + +
      +

      Calculate the required drag to apply to the forces.

      + +
      + + 
      		'    float drag = 1.0 - (positionInTime * 0.5) * acceleration.w;',
      + +
      • + + +
    • +
      + +
      + +
      +

      Integrate forces…

      + +
      + + 
      		'    force += vel;',
+		'    force *= drag;',
+		'    force += accel * age;',
+		'    pos += force;',
      + +
      • + + +
    • +
      + +
      + +
      +

      Wiggly wiggly wiggle!

      + +
      + + 
      		'    #ifdef SHOULD_WIGGLE_PARTICLES',
+		'        pos.x += wiggleSin;',
+		'        pos.y += wiggleCos;',
+		'        pos.z += wiggleSin;',
+		'    #endif',
      + +
      • + + +
    • +
      + +
      + +
      +

      Rotate the emitter around it’s central point

      + +
      + + 
      		'    #ifdef SHOULD_ROTATE_PARTICLES',
+		'        pos = getRotation( pos, positionInTime );',
+		'    #endif',
      + +
      • + + +
    • +
      + +
      + +
      +

      Convert pos to a world-space value

      + +
      + + 
      		'    vec4 mvPosition = modelViewMatrix * vec4( pos, 1.0 );',
      + +
      • + + +
    • +
      + +
      + +
      +

      Determine point size.

      + +
      + + 
      		'    highp float pointSize = getFloatOverLifetime( positionInTime, size ) * isAlive;',
      + +
      • + + +
    • +
      + +
      + +
      +

      Determine perspective

      + +
      + + 
      		'    #ifdef HAS_PERSPECTIVE',
+		'        float perspective = scale / length( mvPosition.xyz );',
+		'    #else',
+		'        float perspective = 1.0;',
+		'    #endif',
      + +
      • + + +
    • +
      + +
      + +
      +

      Apply perpective to pointSize value

      + +
      + + 
      		'    float pointSizePerspective = pointSize * perspective;',
      + +
      • + + +
    • +
      + +
      + +
      +

      Appearance

      + +
      + +
      • + + +
    • +
      + +
      + +
      +

      Determine color and opacity for this particle

      + +
      + + 
      		'    #ifdef COLORIZE',
+		'       vec3 c = isAlive * getColorOverLifetime(',
+		'           positionInTime,',
+		'           unpackColor( color.x ),',
+		'           unpackColor( color.y ),',
+		'           unpackColor( color.z ),',
+		'           unpackColor( color.w )',
+		'       );',
+		'    #else',
+		'       vec3 c = vec3(1.0);',
+		'    #endif',
+
+		'    float o = isAlive * getFloatOverLifetime( positionInTime, opacity );',
      + +
      • + + +
    • +
      + +
      + +
      +

      Assign color to vColor varying.

      + +
      + + 
      		'    vColor = vec4( c, o );',
      + +
      • + + +
    • +
      + +
      + +
      +

      Determine angle

      + +
      + + 
      		'    #ifdef SHOULD_ROTATE_TEXTURE',
+		'        vAngle = isAlive * getFloatOverLifetime( positionInTime, angle );',
+		'    #endif',
      + +
      • + + +
    • +
      + +
      + +
      +

      If this particle is using a sprite-sheet as a texture, we’ll have to figure out +what frame of the texture the particle is using at it’s current position in time.

      + +
      + + 
      		'    #ifdef SHOULD_CALCULATE_SPRITE',
+		'        float framesX = textureAnimation.x;',
+		'        float framesY = textureAnimation.y;',
+		'        float loopCount = textureAnimation.w;',
+		'        float totalFrames = textureAnimation.z;',
+		'        float frameNumber = mod( (positionInTime * loopCount) * totalFrames, totalFrames );',
+
+		'        float column = floor(mod( frameNumber, framesX ));',
+		'        float row = floor( (frameNumber - column) / framesX );',
+
+		'        float columnNorm = column / framesX;',
+		'        float rowNorm = row / framesY;',
+
+		'        vSpriteSheet.x = 1.0 / framesX;',
+		'        vSpriteSheet.y = 1.0 / framesY;',
+		'        vSpriteSheet.z = columnNorm;',
+		'        vSpriteSheet.w = rowNorm;',
+		'    #endif',
      + +
      • + + +
    • +
      + +
      + +
      +

      Write values

      + +
      + +
      • + + +
    • +
      + +
      + +
      +

      Set PointSize according to size at current point in time.

      + +
      + + 
      		'    gl_PointSize = pointSizePerspective;',
+		'    gl_Position = projectionMatrix * mvPosition;',
+
+		THREE.ShaderChunk.logdepthbuf_vertex,
+		THREE.ShaderChunk.fog_vertex,
+
+		'}',
+	].join( '\n' ),
+
+	fragment: [
+		shaderChunks.uniforms,
+
+		THREE.ShaderChunk.common,
+		THREE.ShaderChunk.fog_pars_fragment,
+		THREE.ShaderChunk.logdepthbuf_pars_fragment,
+
+		shaderChunks.varyings,
+
+		shaderChunks.branchAvoidanceFunctions,
+
+		'void main() {',
+		'    vec3 outgoingLight = vColor.xyz;',
+		'    ',
+		'    #ifdef ALPHATEST',
+		'       if ( vColor.w < float(ALPHATEST) ) discard;',
+		'    #endif',
+
+		shaderChunks.rotateTexture,
+
+		THREE.ShaderChunk.logdepthbuf_fragment,
+
+		'    outgoingLight = vColor.xyz * rotatedTexture.xyz;',
+		'    gl_FragColor = vec4( outgoingLight.xyz, rotatedTexture.w * vColor.w );',
+
+		THREE.ShaderChunk.fog_fragment,
+
+		'}',
+	].join( '\n' ),
+};
      + +
      • + +
    +
    + + diff --git a/examples/activeMultiplier.html b/examples/activeMultiplier.html index f0722b6..8e929b3 100644 --- a/examples/activeMultiplier.html +++ b/examples/activeMultiplier.html @@ -13,9 +13,9 @@ - + - + + - + + - + + - + + - + + - + + - + + - + + - + + - + + - + + - + - + - + diff --git a/docs/api/constants_typeSizeMap.js.html b/docs/api/constants_typeSizeMap.js.html index d8e1d3a..d75f91f 100644 --- a/docs/api/constants_typeSizeMap.js.html +++ b/docs/api/constants_typeSizeMap.js.html @@ -91,7 +91,7 @@

    Home

    Namespaces

    • diff --git a/docs/api/constants_valueTypes.js.html b/docs/api/constants_valueTypes.js.html index 4f9aaae..f388594 100644 --- a/docs/api/constants_valueTypes.js.html +++ b/docs/api/constants_valueTypes.js.html @@ -68,7 +68,7 @@

      Home

      Namespaces

      • diff --git a/docs/api/core_Emitter.js.html b/docs/api/core_Emitter.js.html index aa12c5d..df6b6c5 100644 --- a/docs/api/core_Emitter.js.html +++ b/docs/api/core_Emitter.js.html @@ -996,7 +996,7 @@

        Home

        Namespaces

        • diff --git a/docs/api/core_Group.js.html b/docs/api/core_Group.js.html index 37b4d4f..82f9402 100644 --- a/docs/api/core_Group.js.html +++ b/docs/api/core_Group.js.html @@ -766,7 +766,7 @@

          Home

          Namespaces

          • diff --git a/docs/api/core_utils.js.html b/docs/api/core_utils.js.html index f072e86..6aad58f 100644 --- a/docs/api/core_utils.js.html +++ b/docs/api/core_utils.js.html @@ -746,7 +746,7 @@

            Home

            Namespaces

            • diff --git a/docs/api/global.html b/docs/api/global.html index 6a0e5da..4ac78c4 100644 --- a/docs/api/global.html +++ b/docs/api/global.html @@ -9424,7 +9424,7 @@

              Home

              Namespaces

              • diff --git a/docs/api/helpers_ShaderAttribute.js.html b/docs/api/helpers_ShaderAttribute.js.html index 43390b6..791d230 100644 --- a/docs/api/helpers_ShaderAttribute.js.html +++ b/docs/api/helpers_ShaderAttribute.js.html @@ -214,7 +214,7 @@

                Home

                Namespaces

                • diff --git a/docs/api/helpers_TypedArrayHelper.js.html b/docs/api/helpers_TypedArrayHelper.js.html index 230919e..3e56912 100644 --- a/docs/api/helpers_TypedArrayHelper.js.html +++ b/docs/api/helpers_TypedArrayHelper.js.html @@ -337,7 +337,7 @@

                  Home

                  Namespaces

                  • diff --git a/docs/api/index.html b/docs/api/index.html index 1bb4a95..acae45a 100644 --- a/docs/api/index.html +++ b/docs/api/index.html @@ -56,7 +56,7 @@

                    Home

                    Namespaces

                    • diff --git a/docs/api/module.html#.exports b/docs/api/module.html#.exports index 87d654c..541a8b5 100644 --- a/docs/api/module.html#.exports +++ b/docs/api/module.html#.exports @@ -5065,7 +5065,7 @@ Works for negative numbers as well as positive.
                      - Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:22:31 GMT+0100 (British Summer Time) + Documentation generated by JSDoc 3.6.4 on Sun Jun 28 2020 15:31:45 GMT+0100 (British Summer Time)
                      diff --git a/webpack.config.js b/webpack.config.js index 1d5ca5c..48b04ee 100644 --- a/webpack.config.js +++ b/webpack.config.js @@ -4,7 +4,7 @@ const packageJSON = require( './package.json' ); const licenseBanner = '/* ' + packageJSON.name + ' ' + packageJSON.version + '\n' + ' * ' + '\n' + - ' * (c) 2015 Luke Moody (http://www.github.com/squarefeet)' + '\n' + + ' * (c) 2020 Luke Moody (http://www.github.com/squarefeet)' + '\n' + ' * Originally based on Lee Stemkoski\'s original work (https://github.com/stemkoski/stemkoski.github.com/blob/master/Three.js/js/ParticleEngine.js).' + '\n' + ' *' + '\n' + ' * ' + packageJSON.name + ' may be freely distributed under the MIT license (See LICENSE at root of this repository.)' + '\n */\n';