/*
|
* 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 java.io.IOException;
|
import java.nio.FloatBuffer;
|
|
import com.jme.math.FastMath;
|
import com.jme.math.Quaternion;
|
import com.jme.math.Triangle;
|
import com.jme.math.Vector3f;
|
//import com.jme.renderer.Camera;
|
import com.jme.renderer.ColorRGBA;
|
import com.jme.util.export.InputCapsule;
|
import com.jme.util.export.JMEExporter;
|
import com.jme.util.export.JMEImporter;
|
import com.jme.util.export.OutputCapsule;
|
import com.jme.util.export.Savable;
|
import com.jme.util.geom.BufferUtils;
|
import com.jmex.effects.particles.ParticleSystem.ParticleType;
|
|
|
/**
|
* <code>Particle</code> defines a single Particle of a Particle system.
|
* Generally, you would not interact with this class directly.
|
*
|
* @author Joshua Slack
|
* @version $Id: Particle.java 4133 2009-03-19 20:40:11Z blaine.dev $
|
*/
|
public class Particle implements java.io.Serializable // Savable
|
{
|
static final long serialVersionUID = 0;
|
|
public enum Status0
|
{
|
|
/** Particle is dead -- not in play. */
|
Dead, // no longer used (kept only for loading old scenes)
|
/** Particle is currently active. */
|
Alive,
|
// /** Particle is available for spawning. */
|
// Available,
|
/** Particle is available for spawning. */
|
Hidden;
|
}
|
static final int VAL_CURRENT_SIZE = 0;
|
static final int VAL_CURRENT_SPIN = 1;
|
static final int VAL_CURRENT_MASS = 2;
|
static final int VAL_CURRENT_LIVE = 3;
|
private float[] values = new float[4];
|
|
private int startIndex;
|
private Vector3f position = new Vector3f();
|
private ColorRGBA currColor = ColorRGBA.black.clone();
|
// private com.jmex.effects.particles.Particle.Status status = com.jmex.effects.particles.Particle.Status.Available;
|
private Status0 status = Status0.Dead; // Available;
|
private float lifeSpan;
|
private float size;
|
private float currentAge;
|
private int currentTexIndex = -1;
|
private ParticleSystem parent;
|
private Vector3f velocity = new Vector3f();
|
private Vector3f bbX = new Vector3f(), bbY = new Vector3f();
|
|
// colors
|
private ParticleType type = com.jmex.effects.particles.ParticleSystem.ParticleType.Point; // Quad;
|
private Triangle triModel;
|
|
// static variable for use in calculations to eliminate object creation
|
private static Vector3f tempVec3 = new Vector3f();
|
private static Quaternion tempQuat = new Quaternion();
|
|
int uid;
|
|
/**
|
* Empty constructor - mostly for use with Savable interface
|
*/
|
// public Particle()
|
// {
|
// }
|
|
/**
|
* Normal use constructor. Sets up the parent and particle type for this
|
* particle.
|
*
|
* @param parent
|
* the particle collection this particle belongs to
|
*/
|
public Particle(ParticleSystem parent)
|
{
|
this.parent = parent;
|
this.type = parent.getParticleType();
|
}
|
|
/**
|
* Cause this particle to reset it's lifespan, velocity, color, age and size
|
* per the parent's settings. status is set to Status.Available and location
|
* is set to 0,0,0. Actual geometry data is not affected by this call, only
|
* particle params.
|
*/
|
public void init()
|
{
|
init(parent.getRandomVelocity(null), new Vector3f(), parent.getRandomLifeSpan());
|
}
|
|
/**
|
* Cause this particle to reset it's color, age and size per the parent's
|
* settings. status is set to Status.Available. Location, velocity and
|
* lifespan are set as given. Actual geometry data is not affected by this
|
* call, only particle params.
|
*
|
* @param velocity
|
* new initial particle velocity
|
* @param position
|
* new initial particle position
|
* @param lifeSpan
|
* new particle lifespan in ms
|
*/
|
public void init(Vector3f velocity, Vector3f position, float lifeSpan)
|
{
|
this.lifeSpan = lifeSpan;
|
// this.velocity = (Vector3f) velocity.clone();
|
// this.position = (Vector3f) position.clone();
|
this.velocity.set(velocity);
|
this.position.set(position);
|
|
currColor.set(parent.getStartColor());
|
currentAge = 0;
|
status = Particle.Status0.Dead; // Available;
|
values[VAL_CURRENT_SIZE] = parent.getStartSize();
|
}
|
|
/**
|
* Reset particle conditions. Besides the passed lifespan, we also reset
|
* color, size, and spin angle to their starting values (as given by
|
* parent.) Status is set to Status.Available.
|
*
|
* @param lifeSpan
|
* the recreated particle's new lifespan
|
*/
|
public void recreateParticle(float lifeSpan, float size)
|
{
|
uid = (int)(FastMath.nextRandomFloat() * 100000);
|
|
this.lifeSpan = lifeSpan;
|
|
int verts = ParticleSystem.getVertsForParticleType(type);
|
currColor.set(parent.getStartColor());
|
for (int x = 0; x < verts; x++)
|
{
|
//BufferUtils.setInBuffer(currColor, parent.getParticleGeometry().getColorBuffer(), startIndex + x);
|
parent.getParticleGeometry().getColorBuffer().set(startIndex + x, currColor);
|
}
|
|
this.size = size;
|
|
values[VAL_CURRENT_SIZE] = parent.getStartSize();
|
currentAge = 0;
|
values[VAL_CURRENT_MASS] = 1;
|
status = Particle.Status0.Hidden; // Available;
|
values[VAL_CURRENT_LIVE] = 0;
|
}
|
|
/**
|
* Update the vertices for this particle, taking size, spin and viewer into
|
* consideration. In the case of particle type ParticleType.GeomMesh, the
|
* original triangle normal is maintained rather than rotating it to face
|
* the camera or parent vectors.
|
*
|
* @param cam
|
* Camera to use in determining viewer aspect. If null, or if
|
* parent is not set to camera facing, parent's left and up
|
* vectors are used.
|
*/
|
public void updateVerts(Camera cam)
|
{
|
float orient = parent.getParticleOrientation() + values[VAL_CURRENT_SPIN];
|
float currSize = values[VAL_CURRENT_SIZE];
|
|
tempVec3.x = currSize * size;
|
tempVec3.y = values[VAL_CURRENT_LIVE];
|
tempVec3.z = uid; // values[VAL_CURRENT_SPIN];
|
|
if (type == com.jmex.effects.particles.ParticleSystem.ParticleType.GeomMesh || type == com.jmex.effects.particles.ParticleSystem.ParticleType.Point)
|
{
|
; // nothing to do
|
} else if (cam != null && parent.isCameraFacing())
|
{
|
// if (parent.isVelocityAligned())
|
// {
|
// bbX.set(velocity).normalizeLocal().multLocal(currSize);
|
// cam.getDirection().cross(bbX, bbY).normalizeLocal().multLocal(
|
// currSize);
|
// } else if (orient == 0)
|
// {
|
// bbX.set(cam.getLeft()).multLocal(currSize);
|
// bbY.set(cam.getUp()).multLocal(currSize);
|
// } else
|
// {
|
// float cA = FastMath.cos(orient) * currSize;
|
// float sA = FastMath.sin(orient) * currSize;
|
// bbX.set(cam.getLeft()).multLocal(cA).addLocal(
|
// cam.getUp().x * sA, cam.getUp().y * sA,
|
// cam.getUp().z * sA);
|
// bbY.set(cam.getLeft()).multLocal(-sA).addLocal(
|
// cam.getUp().x * cA, cam.getUp().y * cA,
|
// cam.getUp().z * cA);
|
// }
|
} else
|
{
|
bbX.set(parent.getLeftVector()).multLocal(currSize);
|
bbY.set(parent.getUpVector()).multLocal(currSize);
|
}
|
|
switch (type)
|
{
|
case Quad:
|
{
|
// position.add(bbX, tempVec3).subtractLocal(bbY);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex);
|
//
|
// position.add(bbX, tempVec3).addLocal(bbY);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex + 1);
|
//
|
// position.subtract(bbX, tempVec3).subtractLocal(bbY);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex + 2);
|
//
|
// position.subtract(bbX, tempVec3).addLocal(bbY);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex + 3);
|
break;
|
}
|
case GeomMesh:
|
{
|
// Vector3f norm = triModel.getNormal();
|
// if (orient != 0)
|
// {
|
// tempQuat.fromAngleNormalAxis(orient, norm);
|
// }
|
//
|
// for (int x = 0; x < 3; x++)
|
// {
|
// if (orient != 0)
|
// {
|
// tempQuat.mult(triModel.get(x), tempVec3);
|
// } else
|
// {
|
// tempVec3.set(triModel.get(x));
|
// }
|
// tempVec3.multLocal(currSize).addLocal(position);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(),
|
// startIndex + x);
|
// }
|
break;
|
}
|
case Triangle:
|
{
|
// position.add(bbX, tempVec3).subtractLocal(bbY);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex);
|
//
|
// position.add(bbX, tempVec3).addLocal(3 * bbY.x, 3 * bbY.y,
|
// 3 * bbY.z);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex + 1);
|
//
|
// position.subtract(bbX.multLocal(3), tempVec3).subtractLocal(bbY);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex + 2);
|
break;
|
}
|
case Line:
|
{
|
// position.subtract(bbX, tempVec3);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex);
|
//
|
// position.add(bbX, tempVec3);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex + 1);
|
break;
|
}
|
case Point:
|
{
|
// BufferUtils.setInBuffer(position, parent.getParticleGeometry().getVertexBuffer(), startIndex);
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getSizeBuffer(), startIndex);
|
parent.getParticleGeometry().getVertexBuffer().set(startIndex, position);
|
parent.getParticleGeometry().getSizeBuffer().set(startIndex, tempVec3);
|
break;
|
}
|
}
|
}
|
|
/**
|
* <p>
|
* update position (using current position and velocity), color
|
* (interpolating between start and end color), size (interpolating between
|
* start and end size), spin (using parent's spin speed) and current age of
|
* particle. If this particle's age is greater than its lifespan, it is set
|
* to status DEAD.
|
* </p>
|
* <p>
|
* Note that this only changes the parameters of the Particle, not the
|
* geometry the particle is associated with.
|
* </p>
|
*
|
* @param secondsPassed
|
* number of seconds passed since last update.
|
* @return true if this particle is not ALIVE (in other words, if it is
|
* ready to be reused.)
|
*/
|
public boolean updateAndCheck(float secondsPassed)
|
{
|
if (status != Particle.Status0.Alive &&
|
status != Particle.Status0.Hidden)
|
{
|
return true;
|
}
|
currentAge += secondsPassed; // * 1000; // add ms time to age
|
if (currentAge > lifeSpan)
|
{
|
killParticle();
|
values[VAL_CURRENT_LIVE] = 0;
|
return true;
|
}
|
|
// if (status == Particle.Status0.Hidden)
|
// return false;
|
|
position.scaleAdd(secondsPassed // * 1000f
|
, velocity, position);
|
|
// get interpolated values from appearance ramp:
|
parent.getRamp().getValuesAtAge(currentAge, lifeSpan, currColor, values, parent);
|
|
values[VAL_CURRENT_LIVE] = status == Status0.Alive ? 1 : 0;
|
|
// interpolate colors
|
int verts = ParticleSystem.getVertsForParticleType(type);
|
for (int x = 0; x < verts; x++)
|
{
|
//BufferUtils.setInBuffer(currColor, parent.getParticleGeometry().getColorBuffer(), startIndex + x);
|
parent.getParticleGeometry().getColorBuffer().set(startIndex + x, currColor);
|
}
|
|
// check for tex animation
|
int newTexIndex = 0; // parent.getTexAnimation().getTexIndexAtAge(currentAge, lifeSpan, parent);
|
// Update tex coords if applicable
|
if (currentTexIndex != newTexIndex)
|
{
|
// Only supported in Quad type for now.
|
if (ParticleType.Quad.equals(parent.getParticleType()))
|
{
|
// determine side
|
float side = FastMath.sqrt(parent.getTexQuantity());
|
int index = newTexIndex;
|
if (index >= parent.getTexQuantity())
|
{
|
index %= parent.getTexQuantity();
|
}
|
// figure row / col
|
float row = side - (int) (index / side) - 1;
|
float col = index % side;
|
// set texcoords
|
float sU = col / side, eU = (col + 1) / side;
|
float sV = row / side, eV = (row + 1) / side;
|
FloatBuffer texs = parent.getParticleGeometry().getTextureCoords(0).coords;
|
texs.position(startIndex * 2);
|
texs.put(sU).put(sV);
|
texs.put(sU).put(eV);
|
texs.put(eU).put(sV);
|
texs.put(eU).put(eV);
|
texs.clear();
|
}
|
}
|
|
return false;
|
}
|
|
public void killParticle()
|
{
|
setStatus(Particle.Status0.Dead);
|
|
currColor.a = 0;
|
|
//BufferUtils.populateFromBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex);
|
parent.getParticleGeometry().getVertexBuffer().get(startIndex, tempVec3);
|
int verts = ParticleSystem.getVertsForParticleType(type);
|
for (int x = 0; x < verts; x++)
|
{
|
// BufferUtils.setInBuffer(tempVec3, parent.getParticleGeometry().getVertexBuffer(), startIndex + x);
|
parent.getParticleGeometry().getVertexBuffer().set(startIndex+x, tempVec3);
|
// BufferUtils.setInBuffer(currColor, parent.getParticleGeometry().getColorBuffer(), startIndex + x);
|
parent.getParticleGeometry().getColorBuffer().set(startIndex+x, currColor);
|
}
|
|
}
|
|
/**
|
* Resets current age to 0
|
*/
|
public void resetAge()
|
{
|
currentAge = 0;
|
}
|
|
/**
|
* @return the current age of the particle in ms
|
*/
|
public float getCurrentAge()
|
{
|
return currentAge;
|
}
|
|
/**
|
* @return the current position of the particle in space
|
*/
|
public Vector3f getPosition()
|
{
|
return position;
|
}
|
|
/**
|
* Set the position of the particle in space.
|
*
|
* @param position
|
* the new position in world coordinates
|
*/
|
public void setPosition(Vector3f position)
|
{
|
this.position.set(position);
|
}
|
|
/**
|
* @return the current status of this particle.
|
* @see Status
|
*/
|
//public com.jmex.effects.particles.Particle.Status getStatus()
|
public Particle.Status0 getStatus()
|
{
|
return status;
|
}
|
|
/**
|
* Set the status of this particle.
|
*
|
* @param status
|
* new status of this particle
|
* @see Status
|
*/
|
public void setStatus(Particle.Status0 status)
|
{
|
this.status = status;
|
}
|
|
/**
|
* @return the current velocity of this particle
|
*/
|
public Vector3f getVelocity()
|
{
|
return velocity;
|
}
|
|
/**
|
* Set the current velocity of this particle
|
*
|
* @param velocity
|
* the new velocity
|
*/
|
public void setVelocity(Vector3f velocity)
|
{
|
this.velocity.set(velocity);
|
}
|
|
/**
|
* @return the current color applied to this particle
|
*/
|
public ColorRGBA getCurrentColor()
|
{
|
return currColor;
|
}
|
|
/**
|
* @return the start index of this particle in relation to where it exists
|
* in its parent's geometry data.
|
*/
|
public int getStartIndex()
|
{
|
return startIndex;
|
}
|
|
/**
|
* Set the starting index where this particle is represented in its parent's
|
* geometry data
|
*
|
* @param index
|
*/
|
public void setStartIndex(int index)
|
{
|
this.startIndex = index;
|
}
|
|
/**
|
* @return the mass of this particle. Only used by ParticleInfluences such
|
* as drag.
|
*/
|
public float getMass()
|
{
|
return values[VAL_CURRENT_MASS];
|
}
|
|
/**
|
* @return the inverse mass of this particle. Often useful for skipping
|
* constant division by mass calculations. If the mass is 0, the
|
* inverse mass is considered to be positive infinity. Conversely,
|
* if the mass is positive infinity, the inverse is 0. The inverse
|
* of negative infinity is considered to be -0.
|
*/
|
public float getInvMass()
|
{
|
float mass = values[VAL_CURRENT_MASS];
|
if (mass == 0)
|
{
|
return Float.POSITIVE_INFINITY;
|
} else if (mass == Float.POSITIVE_INFINITY)
|
{
|
return 0;
|
} else if (mass == Float.NEGATIVE_INFINITY)
|
{
|
return -0;
|
} else
|
{
|
return 1f / mass;
|
}
|
}
|
|
/**
|
* Sets a triangle model to use for particle calculations when using
|
* particle type ParticleType.GeomMesh. The particle will maintain the
|
* triangle's ratio and plane of orientation. It will spin (if applicable)
|
* around the triangle's normal axis. The triangle should already have its
|
* center and normal fields calculated before calling this method.
|
*
|
* @param t
|
* the triangle to model this particle after.
|
*/
|
public void setTriangleModel(Triangle t)
|
{
|
this.triModel = t;
|
}
|
|
/**
|
* @return the triangle model used by this particle
|
* @see #setTriangleModel(Triangle)
|
*/
|
public Triangle getTriangleModel()
|
{
|
return this.triModel;
|
}
|
|
// /////
|
// Savable interface methods
|
// /////
|
// public void write(JMEExporter e) throws IOException
|
// {
|
// OutputCapsule capsule = e.getCapsule(this);
|
// capsule.write(startIndex, "startIndex", 0);
|
// capsule.write(position, "position", Vector3f.ZERO);
|
// //-- capsule.write(status, "status", com.jmex.effects.particles.Particle.Status.Available);
|
// capsule.write(lifeSpan, "lifeSpan", 0);
|
// capsule.write(currentAge, "currentAge", 0);
|
// // capsule.write(parent, "parent", null);
|
// capsule.write(velocity, "velocity", Vector3f.UNIT_XYZ);
|
// //-- capsule.write(type, "type", ParticleSystem.ParticleType.Quad);
|
// }
|
//
|
// public void read(JMEImporter e) throws IOException
|
// {
|
// InputCapsule capsule = e.getCapsule(this);
|
// startIndex = capsule.readInt("startIndex", 0);
|
// position = (Vector3f) capsule.readSavable("position", Vector3f.ZERO.clone());
|
// //-- status = capsule.readEnum("status", com.jmex.effects.particles.Particle.Status.class, com.jmex.effects.particles.Particle.Status.Available);
|
// lifeSpan = capsule.readFloat("lifeSpan", 0);
|
// currentAge = capsule.readInt("currentAge", 0);
|
// parent = (ParticleSystem) capsule.readSavable("parent", null);
|
// velocity = (Vector3f) capsule.readSavable("velocity", Vector3f.UNIT_XYZ.clone());
|
// //-- type = capsule.readEnum("type", com.jmex.effects.particles.ParticleSystem.ParticleType.class,
|
// //-- com.jmex.effects.particles.ParticleSystem.ParticleType.Quad);
|
// }
|
|
public Class<? extends Particle> getClassTag()
|
{
|
return this.getClass();
|
}
|
}
|
