/*
|
* Copyright (c) 2003-2009 jMonkeyEngine
|
* All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are
|
* met:
|
*
|
* * Redistributions of source code must retain the above copyright
|
* notice, this list of conditions and the following disclaimer.
|
*
|
* * Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
*
|
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
|
* may be used to endorse or promote products derived from this software
|
* without specific prior written permission.
|
*
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*/
|
//package com.jmex.effects.particles;
|
//import com.jmex.effects.particles.ParticleAppearanceRamp;
|
import com.jmex.effects.particles.ParticleInfluence;
|
//import com.jmex.effects.particles.TexAnimation;
|
|
import java.io.IOException;
|
//import java.nio.FloatBuffer;
|
import java.util.ArrayList;
|
import java.util.logging.Logger;
|
|
import com.jme.math.FastMath;
|
import com.jme.math.Line;
|
import com.jme.math.Matrix3f;
|
import com.jme.math.Rectangle;
|
import com.jme.math.Ring;
|
import com.jme.math.TransformMatrix;
|
import com.jme.math.Triangle;
|
import com.jme.math.Vector2f;
|
import com.jme.math.Vector3f;
|
import com.jme.renderer.ColorRGBA;
|
//import com.jme.scene.Controller;
|
//import com.jme.scene.Geometry;
|
//import com.jme.scene.Node;
|
//import com.jme.scene.TriMesh;
|
import com.jme.util.export.InputCapsule;
|
import com.jme.util.export.JMEExporter;
|
import com.jme.util.export.JMEImporter;
|
import com.jme.util.export.OutputCapsule;
|
|
/**
|
* ParticleGeometry is an abstract class representing a particle system. A
|
* ParticleController must be attached for the effect to be complete.
|
*
|
* @author Joshua Slack
|
* @version $Id: ParticleSystem.java 4133 2009-03-19 20:40:11Z blaine.dev $
|
*/
|
public abstract class ParticleSystem extends Object3D // Node
|
{
|
static final long serialVersionUID = 0;
|
|
private static final Logger logger = Logger.getLogger(ParticleSystem.class.getName());
|
// protected static final long serialVersionUID = 2L;
|
|
public enum EmitType
|
{
|
|
Point, Line, Rectangle, Ring, Geometry;
|
}
|
|
public enum ParticleType
|
{
|
|
Quad, Triangle, Point, Line, GeomMesh;
|
}
|
protected static final float DEFAULT_END_SIZE = 4f;
|
protected static final float DEFAULT_START_SIZE = 20f;
|
protected static final float DEFAULT_MAX_ANGLE = 0.7853982f;
|
protected static final float DEFAULT_MAX_LIFE = 10; // 3.000f;
|
protected static final float DEFAULT_MIN_LIFE = 1.000f;
|
protected static final ColorRGBA DEFAULT_START_COLOR = new ColorRGBA(1.0f,
|
0.0f, 0.0f, 1.0f);
|
protected static final ColorRGBA DEFAULT_END_COLOR = new ColorRGBA(1.0f,
|
1.0f, 0.0f, 0.0f);
|
protected com.jmex.effects.particles.ParticleSystem.ParticleType particleType;
|
protected EmitType emitType = EmitType.Point;
|
protected Line psLine;
|
protected Rectangle psRect;
|
protected Geometry psGeom;
|
protected Ring psRing;
|
protected boolean cameraFacing = true;
|
protected boolean velocityAligned = false;
|
protected boolean particlesInWorldCoords = true;
|
protected float startSize, endSize;
|
protected ColorRGBA startColor;
|
protected ColorRGBA endColor;
|
protected ParticleAppearanceRamp ramp = new ParticleAppearanceRamp();
|
//protected TexAnimation texAnimation = new TexAnimation();
|
protected float initialVelocity;
|
protected float minimumLifeTime, maximumLifeTime;
|
float density = 1;
|
float standby = 0;
|
float creationdelay = 0;
|
protected float minimumAngle, maximumAngle;
|
protected float minimumSize = 1, maximumSize = 2;
|
protected float startSpin, endSpin = (float)Math.PI;
|
protected float startMass, endMass;
|
protected int startTexIndex, texQuantity;
|
protected Vector3f emissionDirection;
|
protected TransformMatrix emitterTransform = new TransformMatrix();
|
protected Vector3f worldEmit = new Vector3f();
|
protected int numParticles;
|
protected boolean rotateWithScene = false;
|
protected Matrix3f rotMatrix;
|
protected float particleOrientation;
|
protected FloatBuffer geometryCoordinates;
|
protected FloatBuffer appearanceColors;
|
protected FloatBuffer sizesBuffer;
|
|
// vectors to prevent repeated object creation:
|
protected Vector3f upXemit, absUpVector, abUpMinUp;
|
protected Vector3f upVector;
|
protected Vector3f leftVector;
|
protected Vector3f invScale;
|
protected Particle[] particles;
|
|
// protected Vector3f particleSpeed;
|
protected int releaseRate; // particles per second
|
protected Vector3f originOffset;
|
protected Vector3f originCenter;
|
protected static Vector2f workVect2 = new Vector2f();
|
protected static Vector3f workVect3 = new Vector3f();
|
protected Geometry particleGeom;
|
protected ParticleController controller;
|
|
/////////
|
/** Spatial's world absolute scale. */
|
protected Vector3f worldScale = new Vector3f(1, 1, 1);
|
//////
|
public ParticleSystem()
|
{
|
}
|
|
public ParticleSystem(String name, int numParticles)
|
{
|
this(name, numParticles, com.jmex.effects.particles.ParticleSystem.ParticleType.Point); // Quad);
|
}
|
|
public ParticleSystem(String name, int numParticles,
|
com.jmex.effects.particles.ParticleSystem.ParticleType particleType)
|
{
|
super(name);
|
this.numParticles = numParticles;
|
this.particleType = particleType;
|
emissionDirection = new Vector3f(0.0f, 1.0f, 0.0f);
|
minimumLifeTime = DEFAULT_MIN_LIFE;
|
maximumLifeTime = DEFAULT_MAX_LIFE;
|
maximumAngle = DEFAULT_MAX_ANGLE;
|
startSize = DEFAULT_START_SIZE;
|
endSize = DEFAULT_END_SIZE;
|
startColor = DEFAULT_START_COLOR.clone();
|
endColor = DEFAULT_END_COLOR.clone();
|
upVector = Vector3f.UNIT_Y.clone();
|
leftVector = new Vector3f(-1, 0, 0);
|
originCenter = new Vector3f();
|
originOffset = new Vector3f();
|
startSpin = 0;
|
endSpin = 0;
|
startMass = 1;
|
endMass = 1;
|
startTexIndex = 0;
|
texQuantity = 1;
|
releaseRate = numParticles;
|
// init working vectors.. used to prevent additional object creation.
|
upXemit = new Vector3f();
|
absUpVector = new Vector3f();
|
abUpMinUp = new Vector3f();
|
initialVelocity = 1.0f;
|
|
rotMatrix = new Matrix3f();
|
initializeParticles(numParticles);
|
}
|
|
protected abstract void initializeParticles(int numParticles);
|
|
public static int getVertsForParticleType(com.jmex.effects.particles.ParticleSystem.ParticleType type)
|
{
|
switch (type)
|
{
|
case Triangle:
|
case GeomMesh:
|
return 3;
|
case Point:
|
return 1;
|
case Line:
|
return 2;
|
case Quad:
|
return 4;
|
}
|
if (type == null)
|
{
|
throw new NullPointerException("type is null");
|
}
|
throw new IllegalArgumentException("Invalid ParticleType: " + type);
|
}
|
|
public void forceRespawn()
|
{
|
for (int i = particles.length; --i >= 0;)
|
{
|
//particles[i].recreateParticle(getRandomLifeSpan(), getRandomSize());
|
controller.Recreate(i);
|
// particles[i].setStatus(Particle.Status0.Alive);
|
// particles[i].updateAndCheck(1);
|
// particles[i].setStatus(Particle.Status0.Available);
|
}
|
|
if (controller != null)
|
{
|
controller.setActive(true);
|
}
|
}
|
|
public boolean isAllParticleInactive()
|
{
|
for (int i = particles.length; --i >= 0;)
|
{
|
if (particles[i].getStatus() == Particle.Status0.Alive)
|
return false;
|
}
|
|
return true;
|
}
|
|
/**
|
* Setup the rotation matrix used to determine initial particle velocity
|
* based on emission angle and emission direction. called automatically by
|
* the set* methods for those parameters.
|
*/
|
protected Vector3f oldEmit = new Vector3f(Float.NaN, Float.NaN, Float.NaN);
|
protected float matData[][] = new float[3][3];
|
|
public void updateRotationMatrix()
|
{
|
if (oldEmit.equals(worldEmit))
|
{
|
return;
|
}
|
|
float upDotEmit = upVector.dot(worldEmit);
|
if (FastMath.abs(upDotEmit) > 1.0d - FastMath.DBL_EPSILON)
|
{
|
absUpVector.x = upVector.x <= 0.0f ? -upVector.x : upVector.x;
|
absUpVector.y = upVector.y <= 0.0f ? -upVector.y : upVector.y;
|
absUpVector.z = upVector.z <= 0.0f ? -upVector.z : upVector.z;
|
if (absUpVector.x < absUpVector.y)
|
{
|
if (absUpVector.x < absUpVector.z)
|
{
|
absUpVector.x = 1.0f;
|
absUpVector.y = absUpVector.z = 0.0f;
|
} else
|
{
|
absUpVector.z = 1.0f;
|
absUpVector.x = absUpVector.y = 0.0f;
|
}
|
} else if (absUpVector.y < absUpVector.z)
|
{
|
absUpVector.y = 1.0f;
|
absUpVector.x = absUpVector.z = 0.0f;
|
} else
|
{
|
absUpVector.z = 1.0f;
|
absUpVector.x = absUpVector.y = 0.0f;
|
}
|
absUpVector.subtract(upVector, abUpMinUp);
|
absUpVector.subtract(worldEmit, upXemit);
|
float f4 = 2.0f / abUpMinUp.dot(abUpMinUp);
|
float f6 = 2.0f / upXemit.dot(upXemit);
|
float f8 = f4 * f6 * abUpMinUp.dot(upXemit);
|
float af1[] = {abUpMinUp.x, abUpMinUp.y, abUpMinUp.z};
|
float af2[] = {upXemit.x, upXemit.y, upXemit.z};
|
for (int i = 0; i < 3; i++)
|
{
|
for (int j = 0; j < 3; j++)
|
{
|
matData[i][j] = (-f4 * af1[i] * af1[j] - f6 * af2[i] * af2[j]) + f8 * af2[i] * af1[j];
|
|
}
|
matData[i][i]++;
|
}
|
|
} else
|
{
|
upVector.cross(worldEmit, upXemit);
|
float f2 = 1.0f / (1.0f + upDotEmit);
|
float f5 = f2 * upXemit.x;
|
float f7 = f2 * upXemit.z;
|
float f9 = f5 * upXemit.y;
|
float f10 = f5 * upXemit.z;
|
float f11 = f7 * upXemit.y;
|
matData[0][0] = upDotEmit + f5 * upXemit.x;
|
matData[0][1] = f9 - upXemit.z;
|
matData[0][2] = f10 + upXemit.y;
|
matData[1][0] = f9 + upXemit.z;
|
matData[1][1] = upDotEmit + f2 * upXemit.y * upXemit.y;
|
matData[1][2] = f11 - upXemit.x;
|
matData[2][0] = f10 - upXemit.y;
|
matData[2][1] = f11 + upXemit.x;
|
matData[2][2] = upDotEmit + f7 * upXemit.z;
|
}
|
rotMatrix.set(matData);
|
oldEmit.set(worldEmit);
|
}
|
|
public /*abstract*/ Geometry getParticleGeometry()
|
{
|
return particleGeom;
|
}
|
|
public ParticleController getParticleController()
|
{
|
return controller;
|
}
|
|
public void addController(Controller c)
|
{
|
// super.addController(c);
|
if (c instanceof ParticleController)
|
{
|
this.controller = (ParticleController) c;
|
}
|
}
|
|
public Vector3f getEmissionDirection()
|
{
|
return emissionDirection;
|
}
|
|
public void setEmissionDirection(Vector3f emissionDirection)
|
{
|
this.emissionDirection = emissionDirection;
|
this.worldEmit.set(emissionDirection);
|
}
|
|
public float getEndSize()
|
{
|
return endSize;
|
}
|
|
public void setEndSize(float size)
|
{
|
endSize = size >= 0.0f ? size : 0.0f;
|
}
|
|
public float getStartSize()
|
{
|
return startSize;
|
}
|
|
public void setStartSize(float size)
|
{
|
startSize = size >= 0.0f ? size : 0.0f;
|
}
|
|
/**
|
* Set the start color for particles. This is the base color of the quad.
|
*
|
* @param color
|
* The start color.
|
*/
|
public void setStartColor(ColorRGBA color)
|
{
|
this.startColor = color;
|
}
|
|
/**
|
* <code>getStartColor</code> returns the starting color.
|
*
|
* @return ColorRGBA The begining color.
|
*/
|
public ColorRGBA getStartColor()
|
{
|
return startColor;
|
}
|
|
/**
|
* Set the end color for particles. The base color of the quad will linearly
|
* approach this color from the start color over the lifetime of the
|
* particle.
|
*
|
* @param color
|
* ColorRGBA The ending color.
|
*/
|
public void setEndColor(ColorRGBA color)
|
{
|
this.endColor = color;
|
}
|
|
/**
|
* getEndColor returns the ending color.
|
*
|
* @return The ending color
|
*/
|
public ColorRGBA getEndColor()
|
{
|
return endColor;
|
}
|
|
/**
|
* Set the start and end spinSpeed of particles managed by this manager.
|
* Setting it to 0 means no spin.
|
*
|
* @param speed
|
* float
|
*/
|
public void setParticleSpinSpeed(float speed)
|
{
|
startSpin = speed;
|
endSpin = speed;
|
}
|
|
public Vector3f getInvScale()
|
{
|
return invScale;
|
}
|
|
public void setInvScale(Vector3f invScale)
|
{
|
this.invScale = invScale;
|
}
|
|
public void updateInvScale()
|
{
|
invScale.set(worldScale);
|
invScale.set(1f / invScale.x, 1f / invScale.y, 1f / invScale.z);
|
}
|
|
/**
|
* Add an external influence to the particle controller for this mesh.
|
*
|
* @param influence
|
* ParticleInfluence
|
*/
|
public void addInfluence(ParticleInfluence influence)
|
{
|
controller.addInfluence(influence);
|
}
|
|
/**
|
* Remove an influence from the particle controller for this mesh.
|
*
|
* @param influence
|
* ParticleInfluence
|
* @return true if found and removed.
|
*/
|
public boolean removeInfluence(ParticleInfluence influence)
|
{
|
return controller.removeInfluence(influence);
|
}
|
|
/**
|
* Returns the list of influences acting on this particle controller.
|
*
|
* @return ArrayList
|
*/
|
public ArrayList<ParticleInfluence> getInfluences()
|
{
|
return controller.getInfluences();
|
}
|
|
public void clearInfluences()
|
{
|
controller.clearInfluences();
|
}
|
|
public void setParticleMass(float mass)
|
{
|
startMass = endMass = mass;
|
}
|
|
/**
|
* Set the minimum angle (in radians) that particles can be emitted away
|
* from the emission direction. Any angle less than 0 is trimmed to 0.
|
*
|
* @param f
|
* The new emission minimum angle.
|
*/
|
public void setMinimumAngle(float f)
|
{
|
minimumAngle = f >= 0.0f ? f : 0.0f;
|
}
|
|
/**
|
* getEmissionMinimumAngle returns the minimum emission angle.
|
*
|
* @return The minimum emission angle.
|
*/
|
public float getMinimumAngle()
|
{
|
return minimumAngle;
|
}
|
|
/**
|
* Set the maximum angle (in radians) that particles can be emitted away
|
* from the emission direction. Any angle less than 0 is trimmed to 0.
|
*
|
* @param f
|
* The new emission maximum angle.
|
*/
|
public void setMaximumAngle(float f)
|
{
|
maximumAngle = f >= 0.0f ? f : 0.0f;
|
}
|
|
/**
|
* getEmissionMaximumAngle returns the maximum emission angle.
|
*
|
* @return The maximum emission angle.
|
*/
|
public float getMaximumAngle()
|
{
|
return maximumAngle;
|
}
|
|
public void setMaximumSize(float f)
|
{
|
maximumSize = f >= 0.0f ? f : 0.0f;
|
}
|
|
public float getMaximumSize()
|
{
|
return maximumSize;
|
}
|
|
public void setMinimumSize(float f)
|
{
|
minimumSize = f >= 0.0f ? f : 0.0f;
|
}
|
|
public float getMinimumSize()
|
{
|
return minimumSize;
|
}
|
|
/**
|
* Set the minimum lifespan of new particles (or recreated) managed by this
|
* manager. if a value less than zero is given, 1.0f is used.
|
*
|
* @param lifeSpan
|
* in ms
|
*/
|
public void setMinimumLifeTime(float lifeSpan)
|
{
|
minimumLifeTime = lifeSpan >= 0.0f ? lifeSpan : 0; // 1.0f;
|
}
|
|
/**
|
* getParticlesMinimumLifeTime returns the minimum life time of a particle.
|
*
|
* @return The current minimum life time in ms.
|
*/
|
public float getMinimumLifeTime()
|
{
|
return minimumLifeTime;
|
}
|
|
/**
|
* Set the maximum lifespan of new particles (or recreated) managed by this
|
* manager. if a value less than zero is given, 1.0f is used.
|
*
|
* @param lifeSpan
|
* in ms
|
*/
|
public void setMaximumLifeTime(float lifeSpan)
|
{
|
maximumLifeTime = lifeSpan >= 0.0f ? lifeSpan : 1.0f;
|
}
|
|
/**
|
* getParticlesMaximumLifeTime returns the maximum life time of a particle.
|
*
|
* @return The current maximum life time in ms.
|
*/
|
public float getMaximumLifeTime()
|
{
|
return maximumLifeTime;
|
}
|
|
public Matrix3f getRotMatrix()
|
{
|
return rotMatrix;
|
}
|
|
public void setRotMatrix(Matrix3f rotMatrix)
|
{
|
this.rotMatrix = rotMatrix;
|
}
|
|
public TransformMatrix getEmitterTransform()
|
{
|
return emitterTransform;
|
}
|
|
public void setEmitterTransform(TransformMatrix emitterTransform)
|
{
|
this.emitterTransform = emitterTransform;
|
}
|
|
public float getParticleOrientation()
|
{
|
return particleOrientation;
|
}
|
|
public void setParticleOrientation(float orient)
|
{
|
this.particleOrientation = orient;
|
}
|
|
/**
|
* Set the acceleration for any new particles created (or recreated) by this
|
* manager.
|
*
|
* @param velocity
|
* particle v0
|
*/
|
public void setInitialVelocity(float velocity)
|
{
|
this.initialVelocity = velocity;
|
}
|
|
/**
|
* Get the acceleration set in this manager.
|
*
|
* @return The initialVelocity
|
*/
|
public float getInitialVelocity()
|
{
|
return initialVelocity;
|
}
|
|
/**
|
* Set the offset for any new particles created (or recreated) by this
|
* manager. This is applicable only to managers generating from a point (not
|
* a line, rectangle, etc..)
|
*
|
* @param offset
|
* new offset position
|
*/
|
public void setOriginOffset(Vector3f offset)
|
{
|
originOffset.set(offset);
|
}
|
|
/**
|
* Get the offset point set in this manager.
|
*
|
* @return origin
|
*/
|
public Vector3f getOriginOffset()
|
{
|
return originOffset;
|
}
|
|
public Vector3f getWorldEmit()
|
{
|
return worldEmit;
|
}
|
|
public void setWorldEmit(Vector3f worldEmit)
|
{
|
this.worldEmit = worldEmit;
|
}
|
|
/**
|
* Get the number of particles the manager should release per second.
|
*
|
* @return The number of particles that should be released per second.
|
*/
|
public int getReleaseRate()
|
{
|
return releaseRate;
|
}
|
|
/**
|
* Set the number of particles the manager should release per second.
|
*
|
* @param particlesPerSecond
|
* number of particles per second
|
*/
|
public void setReleaseRate(int particlesPerSecond)
|
{
|
int oldRate = releaseRate;
|
this.releaseRate = particlesPerSecond;
|
if (controller != null && !controller.isActive() && controller.isControlFlow() && oldRate == 0)
|
{
|
controller.setActive(true);
|
}
|
}
|
|
public float getEndMass()
|
{
|
return endMass;
|
}
|
|
public void setEndMass(float endMass)
|
{
|
this.endMass = endMass;
|
}
|
|
public float getEndSpin()
|
{
|
return endSpin;
|
}
|
|
public void setEndSpin(float endSpin)
|
{
|
this.endSpin = endSpin;
|
}
|
|
public float getStartMass()
|
{
|
return startMass;
|
}
|
|
public void setStartMass(float startMass)
|
{
|
this.startMass = startMass;
|
}
|
|
public float getStartSpin()
|
{
|
return startSpin;
|
}
|
|
public void setStartSpin(float startSpin)
|
{
|
this.startSpin = startSpin;
|
}
|
|
public int getTexQuantity()
|
{
|
return texQuantity;
|
}
|
|
public void setTexQuantity(int quantity)
|
{
|
this.texQuantity = quantity;
|
}
|
|
public int getStartTexIndex()
|
{
|
return startTexIndex;
|
}
|
|
public void setStartTexIndex(int startTexIndex)
|
{
|
this.startTexIndex = startTexIndex;
|
}
|
|
/**
|
* Get which emittype method is being used by the underlying system. One of
|
* EmitType.Point, EmitType.Line, EmitType.Rectangle, EmitType.Ring,
|
* EmitType.GeomMesh
|
*
|
* @return An int representing the current geometry method being used.
|
*/
|
public EmitType getEmitType()
|
{
|
return emitType;
|
}
|
|
/**
|
* Set which emittype method is being used by the underlying system. This is
|
* already done by setGeometry(Line) and setGeometry(Rectangle) You should
|
* not need to use this method unless you are switching between geometry
|
* already set by those methods.
|
*
|
* @param type
|
* emit type to use
|
*/
|
public void setEmitType(EmitType type)
|
{
|
emitType = type;
|
}
|
|
/**
|
* Get which emittype method is being used by the underlying system. One of
|
* ParticleType.Quad, ParticleType.Triangle, ParticleType.Point,
|
* ParticleType.Line, ParticleType.GeomMesh
|
*
|
* @return An int representing the type of particle we are emitting.
|
*/
|
public com.jmex.effects.particles.ParticleSystem.ParticleType getParticleType()
|
{
|
return particleType;
|
}
|
|
/**
|
* Set what type of particle to emit from this sytem. Does not have an
|
* effect unless recreate is called.
|
*
|
* @param type
|
* particle type to use, should be one of ParticleType.Quad,
|
* ParticleType.Triangle, ParticleType.Point, ParticleType.Line,
|
* ParticleType.GeomMesh
|
*/
|
public void setParticleType(com.jmex.effects.particles.ParticleSystem.ParticleType type)
|
{
|
particleType = type;
|
}
|
|
/**
|
* Set a line segment to be used as the "emittor".
|
*
|
* @param line
|
* New emittor line segment.
|
*/
|
public void setGeometry(Line line)
|
{
|
psLine = line;
|
emitType = EmitType.Line;
|
}
|
|
/**
|
* Set a rectangular patch to be used as the "emittor".
|
*
|
* @param rect
|
* New rectangular patch.
|
*/
|
public void setGeometry(Rectangle rect)
|
{
|
psRect = rect;
|
emitType = EmitType.Rectangle;
|
}
|
|
/**
|
* Set a ring or disk to be used as the "emittor".
|
*
|
* @param ring
|
* The new ring area.
|
*/
|
public void setGeometry(Ring ring)
|
{
|
psRing = ring;
|
emitType = EmitType.Ring;
|
}
|
|
/**
|
* Set a Geometry's verts to be the random emission points
|
*
|
* @param geom
|
* The new geometry random verts.
|
*/
|
public void setGeometry(Geometry geom)
|
{
|
psGeom = geom;
|
emitType = EmitType.Geometry;
|
}
|
|
/**
|
* getLine returns the currently set line segment.
|
*
|
* @return current line segment.
|
*/
|
public Line getLine()
|
{
|
return psLine;
|
}
|
|
/**
|
* getRectangle returns the currently set rectangle segment.
|
*
|
* @return current rectangle segment.
|
*/
|
public Rectangle getRectangle()
|
{
|
return psRect;
|
}
|
|
/**
|
* getRing returns the currently set ring emission area.
|
*
|
* @return current ring.
|
*/
|
public Ring getRing()
|
{
|
return psRing;
|
}
|
|
/**
|
* getGeometry returns the currently set Geometry emitter.
|
*
|
* @return current Geometry emitter.
|
*/
|
public Geometry getGeometry()
|
{
|
return psGeom;
|
}
|
|
public void initAllParticlesLocation()
|
{
|
for (int i = particles.length; --i >= 0;)
|
{
|
initParticleLocation(i);
|
particles[i].updateVerts(null);
|
}
|
}
|
|
public void initParticleLocation(int index)
|
{
|
Particle p = particles[index];
|
if (particleType == com.jmex.effects.particles.ParticleSystem.ParticleType.GeomMesh)
|
{
|
// Update the triangle model on each new particle creation.
|
Vector3f[] vertices = new Vector3f[3];
|
((TriMesh) psGeom).getTriangle(index, vertices);
|
Triangle t = p.getTriangleModel();
|
if (t == null)
|
{
|
t = new Triangle(vertices[0], vertices[1], vertices[2]);
|
} else
|
{
|
for (int x = 0; x < 3; x++)
|
{
|
t.set(x, vertices[x]);
|
}
|
}
|
t.calculateCenter();
|
t.calculateNormal();
|
// turn the triangle corners into vector offsets from center
|
for (int x = 0; x < 3; x++)
|
{
|
vertices[x].subtract(t.getCenter(), vertices[x]);
|
t.set(x, vertices[x]);
|
}
|
p.setTriangleModel(t);
|
// psGeom.localToWorld(t.getCenter(), p.getPosition());
|
p.getPosition().multLocal(getInvScale());
|
|
} else if (getEmitType() == EmitType.Geometry)
|
{
|
if (getGeometry() != null && getGeometry() instanceof TriMesh)
|
{
|
((TriMesh) getGeometry()).randomPointOnTriangles(p.getPosition(), workVect3);
|
} else if (getGeometry() != null)
|
{
|
getGeometry().randomVertex(p.getPosition());
|
}
|
p.getPosition().multLocal(getInvScale());
|
|
} else
|
{
|
switch (getEmitType())
|
{
|
case Line:
|
getLine().random(p.getPosition());
|
break;
|
case Rectangle:
|
getRectangle().random(p.getPosition());
|
break;
|
case Ring:
|
getRing().random(p.getPosition());
|
break;
|
case Point:
|
default:
|
p.getPosition().set(originOffset);
|
break;
|
}
|
emitterTransform.multPoint(p.getPosition());
|
}
|
}
|
|
public boolean isCameraFacing()
|
{
|
return cameraFacing;
|
}
|
|
public void setCameraFacing(boolean cameraFacing)
|
{
|
this.cameraFacing = cameraFacing;
|
}
|
|
public boolean isVelocityAligned()
|
{
|
return velocityAligned;
|
}
|
|
public void setVelocityAligned(boolean velocityAligned)
|
{
|
this.velocityAligned = velocityAligned;
|
}
|
|
public Particle getParticle(int i)
|
{
|
return particles[i];
|
}
|
|
public boolean isActive()
|
{
|
return controller.isActive();
|
}
|
|
public void setSpeed(float f)
|
{
|
controller.setTimeStep(f);
|
}
|
|
public void setRepeatType(int type)
|
{
|
controller.setRepeatType(type);
|
}
|
|
public void setControlFlow(boolean b)
|
{
|
controller.setControlFlow(b);
|
}
|
|
public Vector3f getOriginCenter()
|
{
|
return originCenter;
|
}
|
|
public Vector3f getUpVector()
|
{
|
return upVector;
|
}
|
|
public void setUpVector(Vector3f upVector)
|
{
|
this.upVector = upVector;
|
}
|
|
public Vector3f getLeftVector()
|
{
|
return leftVector;
|
}
|
|
public void setLeftVector(Vector3f leftVector)
|
{
|
this.leftVector = leftVector;
|
}
|
|
public boolean isRotateWithScene()
|
{
|
return rotateWithScene;
|
}
|
|
public void setRotateWithScene(boolean rotate)
|
{
|
this.rotateWithScene = rotate;
|
}
|
|
public void resetParticleVelocity(int i)
|
{
|
getRandomVelocity(particles[i].getVelocity());
|
}
|
|
/**
|
* Returns a random angle between the min and max angles.
|
*
|
* @return the random angle.
|
*/
|
public float getRandomAngle()
|
{
|
return getMinimumAngle() + FastMath.nextRandomFloat() * (getMaximumAngle() - getMinimumAngle());
|
}
|
|
/**
|
* generate a random lifespan between the min and max lifespan of the
|
* particle system.
|
*
|
* @return the generated lifespan value
|
*/
|
public float getRandomLifeSpan()
|
{
|
return getMinimumLifeTime() + ((getMaximumLifeTime() - getMinimumLifeTime()) * FastMath.nextRandomFloat());
|
}
|
|
public float getRandomSize()
|
{
|
return getMinimumSize() + ((getMaximumSize() - getMinimumSize()) * FastMath.nextRandomFloat());
|
}
|
|
/**
|
* Generate a random velocity within the parameters of max angle and the
|
* rotation matrix.
|
*
|
* @param pSpeed
|
* a vector to store the results in.
|
*/
|
protected Vector3f getRandomVelocity(Vector3f pSpeed)
|
{
|
float randDir = FastMath.TWO_PI * FastMath.nextRandomFloat();
|
float randAngle = getRandomAngle();
|
if (pSpeed == null)
|
{
|
pSpeed = new Vector3f();
|
}
|
pSpeed.x = FastMath.cos(randDir) * FastMath.sin(randAngle);
|
pSpeed.y = FastMath.cos(randAngle);
|
pSpeed.z = FastMath.sin(randDir) * FastMath.sin(randAngle);
|
rotateVectorSpeed(pSpeed);
|
pSpeed.normalize();
|
float factor = getInitialVelocity();
|
if (!speedup) // uniform speed
|
factor *= 1 + FastMath.nextRandomFloat();
|
pSpeed.multLocal(factor);
|
return pSpeed;
|
}
|
|
/**
|
* Apply the rotation matrix to a given vector representing a particle
|
* velocity.
|
*
|
* @param pSpeed
|
* the velocity vector to be modified.
|
*/
|
protected void rotateVectorSpeed(Vector3f pSpeed)
|
{
|
float x = pSpeed.x, y = pSpeed.y, z = pSpeed.z;
|
|
pSpeed.x = -1 * ((rotMatrix.m00 * x) + (rotMatrix.m10 * y) + (rotMatrix.m20 * z));
|
|
pSpeed.y = (getRotMatrix().m01 * x) + (rotMatrix.m11 * y) + (rotMatrix.m21 * z);
|
|
pSpeed.z = -1 * ((rotMatrix.m02 * x) + (rotMatrix.m12 * y) + (rotMatrix.m22 * z));
|
}
|
|
public void warmUp(int iterations)
|
{
|
if (controller != null)
|
{
|
controller.warmUp(iterations);
|
}
|
}
|
|
public int getNumParticles()
|
{
|
return numParticles;
|
}
|
|
public void setNumParticles(int numParticles)
|
{
|
this.numParticles = numParticles;
|
}
|
|
public float getReleaseVariance()
|
{
|
if (controller != null)
|
{
|
return controller.getReleaseVariance();
|
}
|
return 0;
|
}
|
|
public void setReleaseVariance(float var)
|
{
|
if (controller != null)
|
{
|
controller.setReleaseVariance(var);
|
}
|
}
|
|
public ParticleAppearanceRamp getRamp()
|
{
|
return ramp;
|
}
|
|
public void setRamp(ParticleAppearanceRamp ramp)
|
{
|
if (ramp == null)
|
{
|
logger.warning("Can not set a null ParticleAppearanceRamp.");
|
return;
|
}
|
this.ramp = ramp;
|
}
|
|
// public TexAnimation getTexAnimation()
|
// {
|
// return texAnimation;
|
// }
|
//
|
// public void setTexAnimation(TexAnimation texAnimation)
|
// {
|
// if (texAnimation == null)
|
// {
|
// logger.warning("Can not set a null TexAnimation.");
|
// return;
|
// }
|
// this.texAnimation = texAnimation;
|
// }
|
|
/**
|
* @return true if the particles are already in world coordinate space
|
* (default). When true, scene-graph transforms will only affect the
|
* emission of particles, not particles that are already living.
|
*/
|
public boolean isParticlesInWorldCoords()
|
{
|
return particlesInWorldCoords;
|
}
|
|
public void setParticlesInWorldCoords(boolean particlesInWorldCoords)
|
{
|
this.particlesInWorldCoords = particlesInWorldCoords;
|
}
|
|
/**
|
* Changes the number of particles in this particle mesh.
|
*
|
* @param count
|
* the desired number of particles to change to.
|
*/
|
// public void recreate(int count)
|
// {
|
// numParticles = count;
|
// initializeParticles(numParticles);
|
// }
|
|
// @Override
|
public void updateWorldBound()
|
{
|
; // ignore this since we want it to happen only when we say it can
|
// happen due to world vectors not being used
|
}
|
|
public void updateWorldBoundManually()
|
{
|
//super.updateWorldBound();
|
}
|
|
public void updateGeometricState(float time, boolean initiator)
|
{
|
assert(false);
|
/*
|
super.updateGeometricState(time, initiator);
|
if (isRotateWithScene())
|
{
|
if (emitType == EmitType.Geometry && getGeometry() != null)
|
{
|
getGeometry().getWorldRotation().mult(emissionDirection,
|
worldEmit);
|
} else
|
{
|
worldRotation.mult(emissionDirection, worldEmit);
|
}
|
} else
|
{
|
worldEmit.set(emissionDirection);
|
}
|
|
if (particlesInWorldCoords)
|
{
|
emitterTransform.set(worldRotation, worldTranslation.divide(worldScale));
|
|
originCenter.set(worldTranslation).addLocal(originOffset);
|
|
getWorldTranslation().set(0, 0, 0);
|
getWorldRotation().set(0, 0, 0, 1);
|
} else
|
{
|
originCenter.set(originOffset);
|
}
|
*/
|
}
|
|
public void write(JMEExporter e) throws IOException
|
{
|
assert(false);
|
/*
|
detachAllChildren();
|
super.write(e);
|
OutputCapsule capsule = e.getCapsule(this);
|
capsule.write(emitType, "emitType", EmitType.Point);
|
capsule.write(particleType, "particleType", ParticleType.Quad);
|
capsule.write(psLine, "psLine", null);
|
capsule.write(psRect, "psRect", null);
|
capsule.write(psRing, "psRing", null);
|
capsule.write(psGeom, "psGeom", null);
|
capsule.write(startSize, "startSize", DEFAULT_START_SIZE);
|
capsule.write(endSize, "endSize", DEFAULT_END_SIZE);
|
capsule.write(startColor, "startColor", DEFAULT_START_COLOR);
|
capsule.write(endColor, "endColor", DEFAULT_END_COLOR);
|
capsule.write(startSpin, "startSpin", 0);
|
capsule.write(endSpin, "endSpin", 0);
|
capsule.write(startMass, "startMass", 0);
|
capsule.write(endMass, "endMass", 0);
|
capsule.write(startTexIndex, "startTexIndex", 0);
|
capsule.write(texQuantity, "texQuantity", 1);
|
capsule.write(initialVelocity, "initialVelocity", 1);
|
capsule.write(minimumLifeTime, "minimumLifeTime", DEFAULT_MIN_LIFE);
|
capsule.write(maximumLifeTime, "maximumLifeTime", DEFAULT_MAX_LIFE);
|
capsule.write(minimumAngle, "minimumAngle", 0);
|
capsule.write(maximumAngle, "maximumAngle", DEFAULT_MAX_ANGLE);
|
capsule.write(emissionDirection, "emissionDirection", Vector3f.UNIT_Y);
|
capsule.write(worldEmit, "worldEmit", Vector3f.ZERO);
|
capsule.write(upVector, "upVector", Vector3f.UNIT_Y);
|
capsule.write(leftVector, "leftVector", new Vector3f(-1, 0, 0));
|
capsule.write(numParticles, "numParticles", 0);
|
capsule.write(particleOrientation, "particleOrientation", 0);
|
capsule.write(rotateWithScene, "rotateWithScene", false);
|
capsule.write(geometryCoordinates, "geometryCoordinates", null);
|
capsule.write(appearanceColors, "appearanceColors", null);
|
capsule.write(releaseRate, "releaseRate", numParticles);
|
capsule.write(originCenter, "originCenter", Vector3f.ZERO);
|
capsule.write(originOffset, "originOffset", Vector3f.ZERO);
|
capsule.write(controller, "controller", null);
|
capsule.write(cameraFacing, "cameraFacing", true);
|
capsule.write(velocityAligned, "velocityAligned", false);
|
capsule.write(particlesInWorldCoords, "particlesInWorldCoords", true);
|
capsule.write(ramp, "ramp", new ParticleAppearanceRamp());
|
capsule.write(texAnimation, "texAnimation", new TexAnimation());
|
*/
|
}
|
|
public void read(JMEImporter e) throws IOException
|
{
|
assert(false);
|
/*
|
detachAllChildren();
|
super.read(e);
|
InputCapsule capsule = e.getCapsule(this);
|
emitType = capsule.readEnum("emitType", EmitType.class, EmitType.Point);
|
particleType = capsule.readEnum("particleType", ParticleType.class,
|
ParticleType.Quad);
|
psLine = (Line) capsule.readSavable("psLine", null);
|
psRect = (Rectangle) capsule.readSavable("psRect", null);
|
psRing = (Ring) capsule.readSavable("psRing", null);
|
psGeom = (Geometry) capsule.readSavable("psGeom", null);
|
startSize = capsule.readFloat("startSize", DEFAULT_START_SIZE);
|
endSize = capsule.readFloat("endSize", DEFAULT_END_SIZE);
|
startColor = (ColorRGBA) capsule.readSavable("startColor",
|
DEFAULT_START_COLOR.clone());
|
endColor = (ColorRGBA) capsule.readSavable("endColor",
|
DEFAULT_END_COLOR.clone());
|
startSpin = capsule.readFloat("startSpin", 0);
|
endSpin = capsule.readFloat("endSpin", 0);
|
startMass = capsule.readFloat("startMass", 0);
|
endMass = capsule.readFloat("endMass", 0);
|
startTexIndex = capsule.readInt("startTexIndex", 0);
|
texQuantity = capsule.readInt("texQuantity", 1);
|
initialVelocity = capsule.readFloat("initialVelocity", 1);
|
minimumLifeTime = capsule.readFloat("minimumLifeTime", DEFAULT_MIN_LIFE);
|
maximumLifeTime = capsule.readFloat("maximumLifeTime", DEFAULT_MAX_LIFE);
|
minimumAngle = capsule.readFloat("minimumAngle", 0);
|
maximumAngle = capsule.readFloat("maximumAngle", DEFAULT_MAX_ANGLE);
|
emissionDirection = (Vector3f) capsule.readSavable("emissionDirection",
|
Vector3f.UNIT_Y.clone());
|
worldEmit = (Vector3f) capsule.readSavable("worldEmit", Vector3f.ZERO.clone());
|
upVector = (Vector3f) capsule.readSavable("upVector", Vector3f.UNIT_Y.clone());
|
leftVector = (Vector3f) capsule.readSavable("leftVector", new Vector3f(
|
-1, 0, 0));
|
numParticles = capsule.readInt("numParticles", 0);
|
rotateWithScene = capsule.readBoolean("rotateWithScene", false);
|
geometryCoordinates = capsule.readFloatBuffer("geometryCoordinates",
|
null);
|
appearanceColors = capsule.readFloatBuffer("appearanceColors", null);
|
|
releaseRate = capsule.readInt("releaseRate", numParticles);
|
particleOrientation = capsule.readFloat("particleOrientation", 0);
|
originCenter = (Vector3f) capsule.readSavable("originCenter",
|
new Vector3f());
|
originOffset = (Vector3f) capsule.readSavable("originOffset",
|
new Vector3f());
|
controller = (ParticleController) capsule.readSavable("controller",
|
null);
|
cameraFacing = capsule.readBoolean("cameraFacing", true);
|
velocityAligned = capsule.readBoolean("velocityAligned", false);
|
particlesInWorldCoords = capsule.readBoolean("particlesInWorldCoords", true);
|
ramp = (ParticleAppearanceRamp) capsule.readSavable("ramp",
|
new ParticleAppearanceRamp());
|
texAnimation = (TexAnimation) capsule.readSavable("texAnimation",
|
new TexAnimation());
|
|
invScale = new Vector3f();
|
upXemit = new Vector3f();
|
absUpVector = new Vector3f();
|
abUpMinUp = new Vector3f();
|
rotMatrix = new Matrix3f();
|
initializeParticles(numParticles);
|
*/
|
}
|
|
void createEditWindow(GroupEditor callee, boolean newWindow)
|
{
|
//editWindow = (new SphereEditor(this, deepCopy(), callee)).GetEditor();
|
if (newWindow)
|
{
|
objectUI = new ParticleEditor(this, deepCopy(), callee);
|
} else
|
{
|
objectUI = new ParticleEditor(this, callee);
|
}
|
editWindow = objectUI.GetEditor();
|
}
|
|
}
|
