mirror of
https://github.com/Doodle3D/Doodle3D-Slicer.git
synced 2024-08-23 13:50:43 +02:00
836 lines
17 KiB
JavaScript
Executable File
836 lines
17 KiB
JavaScript
Executable File
/*
|
|
* @author zz85 (http://github.com/zz85 http://www.lab4games.net/zz85/blog)
|
|
*
|
|
* a simple to use javascript 3d particles system inspired by FliNT and Stardust
|
|
* created with TWEEN.js and THREE.js
|
|
*
|
|
* for feature requests or bugs, please visit https://github.com/zz85/sparks.js
|
|
*
|
|
* licensed under the MIT license
|
|
*/
|
|
|
|
var SPARKS = {};
|
|
|
|
/********************************
|
|
* Emitter Class
|
|
*
|
|
* Creates and Manages Particles
|
|
*********************************/
|
|
|
|
SPARKS.Emitter = function (counter) {
|
|
|
|
this._counter = counter ? counter : new SPARKS.SteadyCounter(10); // provides number of particles to produce
|
|
|
|
this._particles = [];
|
|
|
|
|
|
this._initializers = []; // use for creation of particles
|
|
this._actions = []; // uses action to update particles
|
|
this._activities = []; // not supported yet
|
|
|
|
this._handlers = [];
|
|
|
|
this.callbacks = {};
|
|
};
|
|
|
|
|
|
SPARKS.Emitter.prototype = {
|
|
|
|
_TIMESTEP: 15,
|
|
_timer: null,
|
|
_lastTime: null,
|
|
_timerStep: 10,
|
|
_velocityVerlet: true,
|
|
|
|
// run its built in timer / stepping
|
|
start: function() {
|
|
this._lastTime = Date.now();
|
|
this._timer = setTimeout(this.step, this._timerStep, this);
|
|
this._isRunning = true;
|
|
},
|
|
|
|
stop: function() {
|
|
this._isRunning = false;
|
|
clearTimeout(this._timer);
|
|
},
|
|
|
|
isRunning: function() {
|
|
return this._isRunning & true;
|
|
},
|
|
|
|
// Step gets called upon by the engine
|
|
// but attempts to call update() on a regular basics
|
|
// This method is also described in http://gameclosure.com/2011/04/11/deterministic-delta-tee-in-js-games/
|
|
step: function(emitter) {
|
|
|
|
var time = Date.now();
|
|
var elapsed = time - emitter._lastTime;
|
|
|
|
if (!this._velocityVerlet) {
|
|
// if elapsed is way higher than time step, (usually after switching tabs, or excution cached in ff)
|
|
// we will drop cycles. perhaps set to a limit of 10 or something?
|
|
var maxBlock = emitter._TIMESTEP * 20;
|
|
|
|
if (elapsed >= maxBlock) {
|
|
//console.log('warning: sparks.js is fast fowarding engine, skipping steps', elapsed / emitter._TIMESTEP);
|
|
//emitter.update( (elapsed - maxBlock) / 1000);
|
|
elapsed = maxBlock;
|
|
}
|
|
|
|
while (elapsed >= emitter._TIMESTEP) {
|
|
emitter.update(emitter._TIMESTEP / 1000);
|
|
elapsed -= emitter._TIMESTEP;
|
|
}
|
|
emitter._lastTime = time - elapsed;
|
|
|
|
} else {
|
|
emitter.update(elapsed / 1000);
|
|
emitter._lastTime = time;
|
|
}
|
|
|
|
|
|
|
|
if (emitter._isRunning)
|
|
setTimeout(emitter.step, emitter._timerStep, emitter);
|
|
|
|
},
|
|
|
|
|
|
// Update particle engine in seconds, not milliseconds
|
|
update: function(time) {
|
|
|
|
var i, j;
|
|
var len = this._counter.updateEmitter( this, time );
|
|
|
|
// Create particles
|
|
for ( i = 0; i < len; i ++ ) {
|
|
this.createParticle();
|
|
}
|
|
|
|
// Update activities
|
|
len = this._activities.length;
|
|
for ( i = 0; i < len; i ++ )
|
|
{
|
|
this._activities[i].update( this, time );
|
|
}
|
|
|
|
|
|
len = this._actions.length;
|
|
|
|
var particle;
|
|
var action;
|
|
var len2 = this._particles.length;
|
|
|
|
for ( j = 0; j < len; j ++ )
|
|
{
|
|
action = this._actions[j];
|
|
for ( i = 0; i < len2; ++ i )
|
|
{
|
|
particle = this._particles[i];
|
|
action.update( this, particle, time );
|
|
}
|
|
}
|
|
|
|
|
|
// remove dead particles
|
|
for ( i = len2; i --; )
|
|
{
|
|
particle = this._particles[i];
|
|
if ( particle.isDead )
|
|
{
|
|
//particle =
|
|
this._particles.splice( i, 1 );
|
|
this.dispatchEvent("dead", particle);
|
|
SPARKS.VectorPool.release(particle.position); //
|
|
SPARKS.VectorPool.release(particle.velocity);
|
|
|
|
} else {
|
|
this.dispatchEvent("updated", particle);
|
|
}
|
|
}
|
|
|
|
this.dispatchEvent("loopUpdated");
|
|
|
|
},
|
|
|
|
createParticle: function() {
|
|
var particle = new SPARKS.Particle();
|
|
// In future, use a Particle Factory
|
|
var len = this._initializers.length, i;
|
|
|
|
for ( i = 0; i < len; i ++ ) {
|
|
this._initializers[i].initialize( this, particle );
|
|
}
|
|
|
|
this._particles.push( particle );
|
|
|
|
this.dispatchEvent("created", particle); // ParticleCreated
|
|
|
|
return particle;
|
|
},
|
|
|
|
addInitializer: function (initializer) {
|
|
this._initializers.push(initializer);
|
|
},
|
|
|
|
addAction: function (action) {
|
|
this._actions.push(action);
|
|
},
|
|
|
|
removeInitializer: function (initializer) {
|
|
var index = this._initializers.indexOf(initializer);
|
|
if (index > -1) {
|
|
this._initializers.splice( index, 1 );
|
|
}
|
|
},
|
|
|
|
removeAction: function (action) {
|
|
var index = this._actions.indexOf(action);
|
|
if (index > -1) {
|
|
this._actions.splice( index, 1 );
|
|
}
|
|
//console.log('removeAction', index, this._actions);
|
|
},
|
|
|
|
addCallback: function(name, callback) {
|
|
this.callbacks[name] = callback;
|
|
},
|
|
|
|
dispatchEvent: function(name, args) {
|
|
var callback = this.callbacks[name];
|
|
if (callback) {
|
|
callback(args);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
/*
|
|
* Constant Names for
|
|
* Events called by emitter.dispatchEvent()
|
|
*
|
|
*/
|
|
SPARKS.EVENT_PARTICLE_CREATED = "created"
|
|
SPARKS.EVENT_PARTICLE_UPDATED = "updated"
|
|
SPARKS.EVENT_PARTICLE_DEAD = "dead";
|
|
SPARKS.EVENT_LOOP_UPDATED = "loopUpdated";
|
|
|
|
|
|
|
|
/*
|
|
* Steady Counter attempts to produces a particle rate steadily
|
|
*
|
|
*/
|
|
|
|
// Number of particles per seconds
|
|
SPARKS.SteadyCounter = function(rate) {
|
|
this.rate = rate;
|
|
|
|
// we use a shortfall counter to make up for slow emitters
|
|
this.leftover = 0;
|
|
|
|
};
|
|
|
|
SPARKS.SteadyCounter.prototype.updateEmitter = function(emitter, time) {
|
|
|
|
var targetRelease = time * this.rate + this.leftover;
|
|
var actualRelease = Math.floor(targetRelease);
|
|
|
|
this.leftover = targetRelease - actualRelease;
|
|
|
|
return actualRelease;
|
|
};
|
|
|
|
|
|
/*
|
|
* Shot Counter produces specified particles
|
|
* on a single impluse or burst
|
|
*/
|
|
|
|
SPARKS.ShotCounter = function(particles) {
|
|
this.particles = particles;
|
|
this.used = false;
|
|
};
|
|
|
|
SPARKS.ShotCounter.prototype.updateEmitter = function(emitter, time) {
|
|
|
|
if (this.used) {
|
|
return 0;
|
|
} else {
|
|
this.used = true;
|
|
}
|
|
|
|
return this.particles;
|
|
};
|
|
|
|
|
|
/********************************
|
|
* Particle Class
|
|
*
|
|
* Represents a single particle
|
|
*********************************/
|
|
SPARKS.Particle = function() {
|
|
|
|
/**
|
|
* The lifetime of the particle, in seconds.
|
|
*/
|
|
this.lifetime = 0;
|
|
|
|
/**
|
|
* The age of the particle, in seconds.
|
|
*/
|
|
this.age = 0;
|
|
|
|
/**
|
|
* The energy of the particle.
|
|
*/
|
|
this.energy = 1;
|
|
|
|
/**
|
|
* Whether the particle is dead and should be removed from the stage.
|
|
*/
|
|
this.isDead = false;
|
|
|
|
this.target = null; // tag
|
|
|
|
/**
|
|
* For 3D
|
|
*/
|
|
|
|
this.position = SPARKS.VectorPool.get().set(0, 0, 0); //new THREE.Vector3( 0, 0, 0 );
|
|
this.velocity = SPARKS.VectorPool.get().set(0, 0, 0); //new THREE.Vector3( 0, 0, 0 );
|
|
this._oldvelocity = SPARKS.VectorPool.get().set(0, 0, 0);
|
|
// rotation vec3
|
|
// angVelocity vec3
|
|
// faceAxis vec3
|
|
|
|
};
|
|
|
|
|
|
/********************************
|
|
* Action Classes
|
|
*
|
|
* An abstract class which have
|
|
* update function
|
|
*********************************/
|
|
SPARKS.Action = function() {
|
|
this._priority = 0;
|
|
};
|
|
|
|
|
|
SPARKS.Age = function(easing) {
|
|
this._easing = (easing == null) ? TWEEN.Easing.Linear.None : easing;
|
|
};
|
|
|
|
SPARKS.Age.prototype.update = function (emitter, particle, time) {
|
|
particle.age += time;
|
|
if ( particle.age >= particle.lifetime )
|
|
{
|
|
particle.energy = 0;
|
|
particle.isDead = true;
|
|
}
|
|
else
|
|
{
|
|
var t = this._easing(particle.age / particle.lifetime);
|
|
particle.energy = -1 * t + 1;
|
|
}
|
|
};
|
|
|
|
/*
|
|
// Mark particle as dead when particle's < 0
|
|
|
|
SPARKS.Death = function(easing) {
|
|
this._easing = (easing == null) ? TWEEN.Linear.None : easing;
|
|
};
|
|
|
|
SPARKS.Death.prototype.update = function (emitter, particle, time) {
|
|
if (particle.life <= 0) {
|
|
particle.isDead = true;
|
|
}
|
|
};
|
|
*/
|
|
|
|
|
|
SPARKS.Move = function() {
|
|
|
|
};
|
|
|
|
SPARKS.Move.prototype.update = function(emitter, particle, time) {
|
|
// attempt verlet velocity updating.
|
|
var p = particle.position;
|
|
var v = particle.velocity;
|
|
var old = particle._oldvelocity;
|
|
|
|
if (this._velocityVerlet) {
|
|
p.x += (v.x + old.x) * 0.5 * time;
|
|
p.y += (v.y + old.y) * 0.5 * time;
|
|
p.z += (v.z + old.z) * 0.5 * time;
|
|
} else {
|
|
p.x += v.x * time;
|
|
p.y += v.y * time;
|
|
p.z += v.z * time;
|
|
}
|
|
|
|
// OldVel = Vel;
|
|
// Vel = Vel + Accel * dt;
|
|
// Pos = Pos + (vel + Vel + Accel * dt) * 0.5 * dt;
|
|
|
|
|
|
|
|
};
|
|
|
|
/* Marks particles found in specified zone dead */
|
|
SPARKS.DeathZone = function(zone) {
|
|
this.zone = zone;
|
|
};
|
|
|
|
SPARKS.DeathZone.prototype.update = function(emitter, particle, time) {
|
|
|
|
if (this.zone.contains(particle.position)) {
|
|
particle.isDead = true;
|
|
}
|
|
|
|
};
|
|
|
|
/*
|
|
* SPARKS.ActionZone applies an action when particle is found in zone
|
|
*/
|
|
SPARKS.ActionZone = function(action, zone) {
|
|
this.action = action;
|
|
this.zone = zone;
|
|
};
|
|
|
|
SPARKS.ActionZone.prototype.update = function(emitter, particle, time) {
|
|
|
|
if (this.zone.contains(particle.position)) {
|
|
this.action.update( emitter, particle, time );
|
|
}
|
|
|
|
};
|
|
|
|
/*
|
|
* Accelerate action affects velocity in specified 3d direction
|
|
*/
|
|
SPARKS.Accelerate = function(x,y,z) {
|
|
|
|
if (x instanceof THREE.Vector3) {
|
|
this.acceleration = x;
|
|
return;
|
|
}
|
|
|
|
this.acceleration = new THREE.Vector3(x,y,z);
|
|
|
|
};
|
|
|
|
SPARKS.Accelerate.prototype.update = function(emitter, particle, time) {
|
|
var acc = this.acceleration;
|
|
|
|
var v = particle.velocity;
|
|
|
|
particle._oldvelocity.set(v.x, v.y, v.z);
|
|
|
|
v.x += acc.x * time;
|
|
v.y += acc.y * time;
|
|
v.z += acc.z * time;
|
|
|
|
};
|
|
|
|
/*
|
|
* Accelerate Factor accelerate based on a factor of particle's velocity.
|
|
*/
|
|
SPARKS.AccelerateFactor = function(factor) {
|
|
this.factor = factor;
|
|
};
|
|
|
|
SPARKS.AccelerateFactor.prototype.update = function(emitter, particle, time) {
|
|
var factor = this.factor;
|
|
|
|
var v = particle.velocity;
|
|
var len = v.length();
|
|
var adjFactor;
|
|
if (len > 0) {
|
|
|
|
adjFactor = factor * time / len;
|
|
adjFactor += 1;
|
|
|
|
v.multiplyScalar(adjFactor);
|
|
// v.x *= adjFactor;
|
|
// v.y *= adjFactor;
|
|
// v.z *= adjFactor;
|
|
}
|
|
|
|
};
|
|
|
|
/*
|
|
AccelerateNormal
|
|
* AccelerateVelocity affects velocity based on its velocity direction
|
|
*/
|
|
SPARKS.AccelerateVelocity = function(factor) {
|
|
|
|
this.factor = factor;
|
|
|
|
};
|
|
|
|
SPARKS.AccelerateVelocity.prototype.update = function(emitter, particle, time) {
|
|
var factor = this.factor;
|
|
|
|
var v = particle.velocity;
|
|
|
|
|
|
v.z += - v.x * factor;
|
|
v.y += v.z * factor;
|
|
v.x += v.y * factor;
|
|
|
|
};
|
|
|
|
|
|
/* Set the max ammount of x,y,z drift movements in a second */
|
|
SPARKS.RandomDrift = function(x,y,z) {
|
|
if (x instanceof THREE.Vector3) {
|
|
this.drift = x;
|
|
return;
|
|
}
|
|
|
|
this.drift = new THREE.Vector3(x,y,z);
|
|
}
|
|
|
|
|
|
SPARKS.RandomDrift.prototype.update = function(emitter, particle, time) {
|
|
var drift = this.drift;
|
|
|
|
var v = particle.velocity;
|
|
|
|
v.x += ( Math.random() - 0.5 ) * drift.x * time;
|
|
v.y += ( Math.random() - 0.5 ) * drift.y * time;
|
|
v.z += ( Math.random() - 0.5 ) * drift.z * time;
|
|
|
|
};
|
|
|
|
/********************************
|
|
* Zone Classes
|
|
*
|
|
* An abstract classes which have
|
|
* getLocation() function
|
|
*********************************/
|
|
SPARKS.Zone = function() {
|
|
};
|
|
|
|
// TODO, contains() for Zone
|
|
|
|
SPARKS.PointZone = function(pos) {
|
|
this.pos = pos;
|
|
};
|
|
|
|
SPARKS.PointZone.prototype.getLocation = function() {
|
|
return this.pos;
|
|
};
|
|
|
|
SPARKS.PointZone = function(pos) {
|
|
this.pos = pos;
|
|
};
|
|
|
|
SPARKS.PointZone.prototype.getLocation = function() {
|
|
return this.pos;
|
|
};
|
|
|
|
SPARKS.LineZone = function(start, end) {
|
|
this.start = start;
|
|
this.end = end;
|
|
this._length = end.clone().sub( start );
|
|
};
|
|
|
|
SPARKS.LineZone.prototype.getLocation = function() {
|
|
var len = this._length.clone();
|
|
|
|
len.multiplyScalar( Math.random() );
|
|
return len.add( this.start );
|
|
|
|
};
|
|
|
|
// Basically a RectangleZone
|
|
SPARKS.ParallelogramZone = function(corner, side1, side2) {
|
|
this.corner = corner;
|
|
this.side1 = side1;
|
|
this.side2 = side2;
|
|
};
|
|
|
|
SPARKS.ParallelogramZone.prototype.getLocation = function() {
|
|
|
|
var d1 = this.side1.clone().multiplyScalar( Math.random() );
|
|
var d2 = this.side2.clone().multiplyScalar( Math.random() );
|
|
d1.add(d2);
|
|
return d1.add( this.corner );
|
|
|
|
};
|
|
|
|
SPARKS.CubeZone = function(position, x, y, z) {
|
|
this.position = position;
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
};
|
|
|
|
SPARKS.CubeZone.prototype.getLocation = function() {
|
|
//TODO use pool?
|
|
|
|
var location = this.position.clone();
|
|
location.x += Math.random() * this.x;
|
|
location.y += Math.random() * this.y;
|
|
location.z += Math.random() * this.z;
|
|
|
|
return location;
|
|
|
|
};
|
|
|
|
|
|
SPARKS.CubeZone.prototype.contains = function(position) {
|
|
|
|
var startX = this.position.x;
|
|
var startY = this.position.y;
|
|
var startZ = this.position.z;
|
|
var x = this.x; // width
|
|
var y = this.y; // depth
|
|
var z = this.z; // height
|
|
|
|
if (x < 0) {
|
|
startX += x;
|
|
x = Math.abs(x);
|
|
}
|
|
|
|
if (y < 0) {
|
|
startY += y;
|
|
y = Math.abs(y);
|
|
}
|
|
|
|
if (z < 0) {
|
|
startZ += z;
|
|
z = Math.abs(z);
|
|
}
|
|
|
|
var diffX = position.x - startX;
|
|
var diffY = position.y - startY;
|
|
var diffZ = position.z - startZ;
|
|
|
|
if ( (diffX > 0) && (diffX < x) &&
|
|
(diffY > 0) && (diffY < y) &&
|
|
(diffZ > 0) && (diffZ < z) ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* The constructor creates a DiscZone 3D zone.
|
|
*
|
|
* @param centre The point at the center of the disc.
|
|
* @param normal A vector normal to the disc.
|
|
* @param outerRadius The outer radius of the disc.
|
|
* @param innerRadius The inner radius of the disc. This defines the hole
|
|
* in the center of the disc. If set to zero, there is no hole.
|
|
*/
|
|
|
|
/*
|
|
// BUGGY!!
|
|
SPARKS.DiscZone = function(center, radiusNormal, outerRadius, innerRadius) {
|
|
this.center = center;
|
|
this.radiusNormal = radiusNormal;
|
|
this.outerRadius = (outerRadius==undefined) ? 0 : outerRadius;
|
|
this.innerRadius = (innerRadius==undefined) ? 0 : innerRadius;
|
|
|
|
};
|
|
|
|
SPARKS.DiscZone.prototype.getLocation = function() {
|
|
var rand = Math.random();
|
|
var _innerRadius = this.innerRadius;
|
|
var _outerRadius = this.outerRadius;
|
|
var center = this.center;
|
|
var _normal = this.radiusNormal;
|
|
|
|
_distToOrigin = _normal.dot( center );
|
|
|
|
var radius = _innerRadius + (1 - rand * rand ) * ( _outerRadius - _innerRadius );
|
|
var angle = Math.random() * SPARKS.Utils.TWOPI;
|
|
|
|
var _distToOrigin = _normal.dot( center );
|
|
var axes = SPARKS.Utils.getPerpendiculars( _normal.clone() );
|
|
var _planeAxis1 = axes[0];
|
|
var _planeAxis2 = axes[1];
|
|
|
|
var p = _planeAxis1.clone();
|
|
p.multiplyScalar( radius * Math.cos( angle ) );
|
|
var p2 = _planeAxis2.clone();
|
|
p2.multiplyScalar( radius * Math.sin( angle ) );
|
|
p.add( p2 );
|
|
return _center.add( p );
|
|
|
|
};
|
|
*/
|
|
|
|
SPARKS.SphereCapZone = function(x, y, z, minr, maxr, angle) {
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
this.minr = minr;
|
|
this.maxr = maxr;
|
|
this.angle = angle;
|
|
};
|
|
|
|
SPARKS.SphereCapZone.prototype.getLocation = function() {
|
|
var theta = Math.PI * 2 * SPARKS.Utils.random();
|
|
var r = SPARKS.Utils.random();
|
|
|
|
//new THREE.Vector3
|
|
var v = SPARKS.VectorPool.get().set(r * Math.cos(theta), -1 / Math.tan(this.angle * SPARKS.Utils.DEGREE_TO_RADIAN), r * Math.sin(theta));
|
|
|
|
//v.length = StardustMath.interpolate(0, _minRadius, 1, _maxRadius, Math.random());
|
|
|
|
var i = this.minr - ((this.minr - this.maxr) * Math.random() );
|
|
v.multiplyScalar(i);
|
|
|
|
v.__markedForReleased = true;
|
|
|
|
return v;
|
|
};
|
|
|
|
|
|
/********************************
|
|
* Initializer Classes
|
|
*
|
|
* Classes which initializes
|
|
* particles. Implements initialize( emitter:Emitter, particle:Particle )
|
|
*********************************/
|
|
|
|
// Specifies random life between max and min
|
|
SPARKS.Lifetime = function(min, max) {
|
|
this._min = min;
|
|
|
|
this._max = max ? max : min;
|
|
|
|
};
|
|
|
|
SPARKS.Lifetime.prototype.initialize = function( emitter/*Emitter*/, particle/*Particle*/ ) {
|
|
particle.lifetime = this._min + SPARKS.Utils.random() * ( this._max - this._min );
|
|
};
|
|
|
|
|
|
SPARKS.Position = function(zone) {
|
|
this.zone = zone;
|
|
};
|
|
|
|
SPARKS.Position.prototype.initialize = function( emitter/*Emitter*/, particle/*Particle*/ ) {
|
|
var pos = this.zone.getLocation();
|
|
particle.position.set(pos.x, pos.y, pos.z);
|
|
};
|
|
|
|
SPARKS.Velocity = function(zone) {
|
|
this.zone = zone;
|
|
};
|
|
|
|
SPARKS.Velocity.prototype.initialize = function( emitter/*Emitter*/, particle/*Particle*/ ) {
|
|
var pos = this.zone.getLocation();
|
|
particle.velocity.set(pos.x, pos.y, pos.z);
|
|
if (pos.__markedForReleased) {
|
|
//console.log("release");
|
|
SPARKS.VectorPool.release(pos);
|
|
pos.__markedForReleased = false;
|
|
}
|
|
};
|
|
|
|
SPARKS.Target = function(target, callback) {
|
|
this.target = target;
|
|
this.callback = callback;
|
|
};
|
|
|
|
SPARKS.Target.prototype.initialize = function( emitter, particle ) {
|
|
|
|
if (this.callback) {
|
|
particle.target = this.callback();
|
|
} else {
|
|
particle.target = this.target;
|
|
}
|
|
|
|
};
|
|
|
|
/********************************
|
|
* VectorPool
|
|
*
|
|
* Reuse much of Vectors if possible
|
|
*********************************/
|
|
|
|
SPARKS.VectorPool = {
|
|
__pools: [],
|
|
|
|
// Get a new Vector
|
|
get: function() {
|
|
if (this.__pools.length > 0) {
|
|
return this.__pools.pop();
|
|
}
|
|
|
|
return this._addToPool();
|
|
|
|
},
|
|
|
|
// Release a vector back into the pool
|
|
release: function(v) {
|
|
this.__pools.push(v);
|
|
},
|
|
|
|
// Create a bunch of vectors and add to the pool
|
|
_addToPool: function() {
|
|
//console.log("creating some pools");
|
|
|
|
for (var i = 0, size = 100; i < size; i ++) {
|
|
this.__pools.push(new THREE.Vector3());
|
|
}
|
|
|
|
return new THREE.Vector3();
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
/********************************
|
|
* Util Classes
|
|
*
|
|
* Classes which initializes
|
|
* particles. Implements initialize( emitter:Emitter, particle:Particle )
|
|
*********************************/
|
|
SPARKS.Utils = {
|
|
random: function() {
|
|
return Math.random();
|
|
},
|
|
DEGREE_TO_RADIAN: Math.PI / 180,
|
|
TWOPI: Math.PI * 2,
|
|
|
|
getPerpendiculars: function(normal) {
|
|
var p1 = this.getPerpendicular( normal );
|
|
var p2 = normal.cross( p1 );
|
|
p2.normalize();
|
|
return [ p1, p2 ];
|
|
},
|
|
|
|
getPerpendicular: function( v )
|
|
{
|
|
if ( v.x == 0 )
|
|
{
|
|
return new THREE.Vector3D( 1, 0, 0 );
|
|
}
|
|
else
|
|
{
|
|
var temp = new THREE.Vector3( v.y, -v.x, 0 );
|
|
return temp.normalize();
|
|
}
|
|
}
|
|
|
|
};
|