/*
|
* 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.
|
*/
|
|
//import com.jmex.effects.particles.*;
|
import com.jmex.effects.particles.ParticleInfluence;
|
import com.jmex.effects.particles.ParticleControllerListener;
|
|
import java.io.IOException;
|
import java.util.ArrayList;
|
|
import com.jme.math.FastMath;
|
//import com.jme.renderer.Camera;
|
//import com.jme.renderer.Camera.FrustumIntersect;
|
//import com.jme.scene.Controller;
|
//import com.jme.scene.Spatial;
|
import com.jme.system.DisplaySystem;
|
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.math.Vector3f;
|
|
/**
|
* <code>ParticleController</code> controls and maintains the parameters of a
|
* ParticleGeometry particle system over time.
|
*
|
* @author Joshua Slack
|
* @version $Id: ParticleController.java 4133 2009-03-19 20:40:11Z blaine.dev $
|
*/
|
public class ParticleController extends Controller
|
{
|
|
private static final long serialVersionUID = 1L;
|
private ParticleSystem particles;
|
private int particlesToCreate = 0;
|
private float releaseVariance;
|
private float currentTime;
|
private float prevTime;
|
private float releaseParticles;
|
private float timePassed;
|
private float precision;
|
private boolean controlFlow;
|
private boolean updateOnlyInView;
|
private Camera viewCamera;
|
private int iterations;
|
private ArrayList<ParticleInfluence> influences;
|
protected ArrayList<ParticleControllerListener> listeners;
|
|
public ParticleController()
|
{
|
}
|
|
/**
|
* ParticleManager constructor
|
*
|
* @param system
|
* Target ParticleGeometry to act upon.
|
*/
|
public ParticleController(ParticleSystem system)
|
{
|
this.particles = system;
|
|
setMinTime(0);
|
setMaxTime(Float.MAX_VALUE);
|
setRepeatType(Controller.RT_WRAP);
|
setTimeStep(1.0f);
|
|
releaseVariance = 0;
|
controlFlow = false;
|
updateOnlyInView = false;
|
precision = .01f; // 10ms
|
|
system.updateRotationMatrix();
|
warmUp(60);
|
}
|
|
//private
|
Vector3f gvector = new Vector3f(0,-0.3f,0);
|
static Vector3f gvectorTMP = new Vector3f();
|
|
float lastcreation = 0;
|
|
void Recreate(int i)
|
{
|
// no recreation if too early
|
{
|
if (currentTime - lastcreation < particles.creationdelay)
|
{
|
return;
|
}
|
|
lastcreation = currentTime;
|
}
|
|
Particle p = particles.particles[i];
|
p.recreateParticle(particles.getRandomLifeSpan(), particles.getRandomSize());
|
if (FastMath.nextRandomFloat() < particles.density)
|
p.setStatus(Particle.Status0.Alive);
|
else
|
p.setStatus(Particle.Status0.Dead);
|
particles.initParticleLocation(i);
|
particles.resetParticleVelocity(i);
|
p.updateVerts(null);
|
}
|
|
static cVector tempgravity = new cVector();
|
|
/**
|
* Update the particles managed by this manager. If any particles are "dead"
|
* recreate them at the origin position (which may be a point, line or
|
* rectangle.) See com.jme.scene.Controller.update(float)
|
*
|
* @param secondsPassed
|
* float
|
*/
|
public void update(float secondsPassed)
|
{
|
|
// If instructed, check to see if our last frustum check passed
|
if (isUpdateOnlyInView())
|
{
|
// Camera cam = viewCamera != null ? viewCamera : DisplaySystem.getDisplaySystem().getRenderer().getCamera();
|
// int state = cam.getPlaneState();
|
// boolean out = false; // cam.contains(particles.getWorldBound()).equals(FrustumIntersect.Outside);
|
// cam.setPlaneState(state);
|
// if (out)
|
// {
|
// return;
|
// }
|
}
|
|
// Add time and unless we have more than precision time passed
|
// since last real update, do nothing
|
currentTime += secondsPassed * getTimeStep();
|
|
// Check precision passes
|
timePassed = currentTime - prevTime;
|
// if (timePassed < precision * getSpeed())
|
// {
|
// return;
|
// }
|
|
// We are actually going to do a real update,
|
// so this is our new previous time
|
prevTime = currentTime;
|
|
// Update the current rotation matrix if needed.
|
particles.updateRotationMatrix();
|
|
// If we are in the time window where this controller is active
|
// (defaults to 0 to Float.MAX_VALUE for ParticleController)
|
if (currentTime >= getMinTime() && currentTime <= getMaxTime())
|
{
|
|
// If we are controlling the flow (ie the rate of particle spawning.)
|
if (controlFlow)
|
{
|
// Release a number of particles based on release rate,
|
// timePassed (already scaled for speed) and variance. This
|
// is added to any current value Note this is a float value,
|
// so we will keep adding up partial particles
|
|
releaseParticles += (particles.getReleaseRate() *
|
timePassed * (1.0f + releaseVariance *
|
(FastMath.nextRandomFloat() - 0.5f)));
|
|
// Try to create all "whole" particles we have added up
|
particlesToCreate = (int) releaseParticles;
|
|
// If we have any whole particles, then subtract them from
|
// releaseParticles
|
if (particlesToCreate > 0)
|
{
|
releaseParticles -= particlesToCreate;
|
} // Make sure particlesToCreate is not negative
|
else
|
{
|
particlesToCreate = 0;
|
}
|
}
|
|
particles.updateInvScale();
|
|
// If we have any influences, prepare them all
|
if (influences != null)
|
{
|
for (ParticleInfluence influence : influences)
|
{
|
// influence.prepare(particles);
|
}
|
}
|
|
// Track particle index
|
int i = 0;
|
|
// Track whether the whole set of particles is "dead" - if any
|
// particles are still alive, this will be set to false
|
boolean dead = true;
|
|
// opposite of above boolean, but tracked seperately
|
boolean anyAlive = false;
|
|
// i is index through all particles
|
while (i < particles.particles.length) // aout 2013 getNumParticles())
|
{
|
// Current particle
|
Particle p = particles.getParticle(i);
|
|
// If we have influences and particle is alive
|
if (influences != null && p.getStatus() == Particle.Status0.Alive)
|
{
|
// Apply each enabled influence to the current particle
|
for (int x = 0; x < influences.size(); x++)
|
{
|
ParticleInfluence inf = influences.get(x);
|
if (inf.isEnabled())
|
{
|
// inf.apply(timePassed, p, i);
|
}
|
}
|
}
|
|
// Gravity
|
tempgravity.x = gvector.x;
|
tempgravity.y = gvector.y;
|
tempgravity.z = gvector.z;
|
|
LA.xformDir(tempgravity, particles.GlobalTransform(), tempgravity);
|
|
gvectorTMP.x = (float)tempgravity.x;
|
gvectorTMP.y = (float)tempgravity.y;
|
gvectorTMP.z = (float)tempgravity.z;
|
|
p.getVelocity().scaleAdd(secondsPassed, gvectorTMP, p.getVelocity());
|
|
// Update and check the particle.
|
// If this returns true, indicating particle is ready to be
|
// reused, we may reuse it. Do so if we are not using
|
// control flow, OR we intend to create particles based on
|
// control flow count calculated above
|
boolean reuse = p.updateAndCheck(timePassed);
|
if (reuse && (!controlFlow || particlesToCreate > 0))
|
{
|
|
// // Don't recreate the particle if it is dead, and we are clamped
|
// if (p.getStatus() == Particle.Status0.Dead && getRepeatType() == RT_CLAMP)
|
// {
|
// ;
|
//
|
// // We plan to reuse the particle
|
// } else
|
{
|
// Not all particles are dead (this one will be reused)
|
dead = false;
|
|
// If we are doing flow control, decrement
|
// particlesToCreate, since we are about to create
|
// one
|
if (controlFlow)
|
{
|
particlesToCreate--;
|
}
|
|
if (particles.rewind)
|
{
|
// Recreate the particle
|
Recreate(i);
|
}
|
}
|
|
} else if (!reuse || (controlFlow && particles.getReleaseRate() > 0))
|
{
|
// The particle wasn't dead, or we expect more particles
|
// later, so we're not dead!
|
dead = false;
|
}
|
|
// Check for living particles so we know when to update our boundings.
|
if (p.getStatus() == Particle.Status0.Alive)
|
{
|
anyAlive = true;
|
}
|
|
// Next particle
|
i++;
|
}
|
|
// If we are dead, deactivate and tell our listeners
|
if (dead)
|
{
|
setActive(false);
|
if (listeners != null && listeners.size() > 0)
|
{
|
for (ParticleControllerListener listener : listeners)
|
{
|
// listener.onDead(particles);
|
}
|
}
|
}
|
|
// If we have a bound and any live particles, update it
|
if (particles.getParticleGeometry().getModelBound() != null && anyAlive)
|
{
|
// particles.updateModelBound();
|
particles.updateWorldBoundManually();
|
}
|
}
|
}
|
|
/**
|
* Get how soon after the last update the manager will send updates to the
|
* particles.
|
*
|
* @return The precision.
|
*/
|
public float getPrecision()
|
{
|
return precision;
|
}
|
|
/**
|
* Set how soon after the last update the manager will send updates to the
|
* particles. Defaults to .01f (10ms)<br>
|
* <br>
|
* This means that if an update is called every 2ms (e.g. running at 500
|
* FPS) the particles position and stats will be updated every fifth frame
|
* with the elapsed time (in this case, 10ms) since previous update.
|
*
|
* @param precision
|
* in seconds
|
*/
|
public void setPrecision(float precision)
|
{
|
this.precision = precision;
|
}
|
|
/**
|
* Get the variance possible on the release rate. 0.0f = no variance 0.5f =
|
* between releaseRate / 2f and 1.5f * releaseRate
|
*
|
* @return release variance as a percent.
|
*/
|
public float getReleaseVariance()
|
{
|
return releaseVariance;
|
}
|
|
/**
|
* Set the variance possible on the release rate.
|
*
|
* @param variance
|
* release rate +/- variance as a percent (eg. .5 = 50%)
|
*/
|
public void setReleaseVariance(float variance)
|
{
|
this.releaseVariance = variance;
|
}
|
|
/**
|
* Does this manager regulate the particle flow?
|
*
|
* @return true if this manager regulates how many particles per sec are
|
* emitted.
|
*/
|
public boolean isControlFlow()
|
{
|
return controlFlow;
|
}
|
|
/**
|
* Set the regulate flow property on the manager.
|
*
|
* @param regulate
|
* regulate particle flow.
|
*/
|
public void setControlFlow(boolean regulate)
|
{
|
this.controlFlow = regulate;
|
}
|
|
/**
|
* Does this manager use the particle's bounding volume to limit updates?
|
*
|
* @return true if this manager only updates the particles when they are in view.
|
*/
|
public boolean isUpdateOnlyInView()
|
{
|
return updateOnlyInView;
|
}
|
|
/**
|
* Set the updateOnlyInView property on the manager.
|
*
|
* @param updateOnlyInView
|
* use the particle's bounding volume to limit updates.
|
*/
|
public void setUpdateOnlyInView(boolean updateOnlyInView)
|
{
|
this.updateOnlyInView = updateOnlyInView;
|
}
|
|
/**
|
* @return the camera to be used in updateOnlyInView situations. If null,
|
* the current displaySystem's renderer camera is used.
|
*/
|
public Camera getViewCamera()
|
{
|
return viewCamera;
|
}
|
|
/**
|
* @param viewCamera
|
* sets the camera to be used in updateOnlyInView situations. If
|
* null, the current displaySystem's renderer camera is used.
|
*/
|
public void setViewCamera(Camera viewCamera)
|
{
|
this.viewCamera = viewCamera;
|
}
|
|
/**
|
* Get the Spatial that holds all of the particle information for display.
|
*
|
* @return Spatial holding particle information.
|
*/
|
// public Spatial getParticles()
|
// {
|
// return particles;
|
// }
|
|
/**
|
* Return the number this manager has warmed up
|
*
|
* @return int
|
*/
|
public int getIterations()
|
{
|
return iterations;
|
}
|
|
/**
|
* Sets the iterations for the warmup and calls warmUp with the number of
|
* iterations as the argument
|
*
|
* @param iterations
|
*/
|
public void setIterations(int iterations)
|
{
|
this.iterations = iterations;
|
}
|
|
/**
|
* Add an external influence to this particle controller.
|
*
|
* @param influence
|
* ParticleInfluence
|
*/
|
public void addInfluence(ParticleInfluence influence)
|
{
|
if (influences == null)
|
{
|
influences = new ArrayList<ParticleInfluence>(1);
|
}
|
influences.add(influence);
|
}
|
|
/**
|
* Remove an influence from this particle controller.
|
*
|
* @param influence
|
* ParticleInfluence
|
* @return true if found and removed.
|
*/
|
public boolean removeInfluence(ParticleInfluence influence)
|
{
|
if (influences == null)
|
{
|
return false;
|
}
|
return influences.remove(influence);
|
}
|
|
/**
|
* Returns the list of influences acting on this particle controller.
|
*
|
* @return ArrayList
|
*/
|
public ArrayList<ParticleInfluence> getInfluences()
|
{
|
return influences;
|
}
|
|
public void clearInfluences()
|
{
|
if (influences != null)
|
{
|
influences.clear();
|
}
|
}
|
|
/**
|
* Subscribe a listener to receive mouse events. Enable event generation.
|
*
|
* @param listener to be subscribed
|
*/
|
public void addListener(ParticleControllerListener listener)
|
{
|
if (listeners == null)
|
{
|
listeners = new ArrayList<ParticleControllerListener>();
|
}
|
|
listeners.add(listener);
|
}
|
|
/**
|
* Unsubscribe a listener. Disable event generation if no more listeners.
|
*
|
* @param listener to be unsuscribed
|
* @see #addListener(ParticleControllerListener)
|
*/
|
public void removeListener(ParticleControllerListener listener)
|
{
|
if (listeners != null)
|
{
|
listeners.remove(listener);
|
}
|
}
|
|
/**
|
* Remove all listeners and disable event generation.
|
*/
|
public void removeListeners()
|
{
|
if (listeners != null)
|
{
|
listeners.clear();
|
}
|
}
|
|
/**
|
* Check if a listener is allready added to this ParticleController
|
* @param listener listener to check for
|
* @return true if listener is contained in the listenerlist
|
*/
|
public boolean containsListener(ParticleControllerListener listener)
|
{
|
if (listeners != null)
|
{
|
return listeners.contains(listener);
|
}
|
return false;
|
}
|
|
/**
|
* Get all added ParticleController listeners
|
* @return ArrayList of listeners added to this ParticleController
|
*/
|
public ArrayList<ParticleControllerListener> getListeners()
|
{
|
return listeners;
|
}
|
|
/**
|
* Runs the update method of this particle manager for iteration seconds
|
* with an update every .1 seconds (IE <code>iterations</code> * 10
|
* update(.1f) calls). This is used to "warm up" and get the particle
|
* manager going.
|
*
|
* @param iterations
|
* The number of iterations to warm up.
|
*/
|
public void warmUp(int iterations)
|
{
|
// first set the initial positions of all the verts
|
particles.initAllParticlesLocation();
|
|
iterations *= 0; // 10;
|
for (int i = iterations; --i >= 0;)
|
{
|
update(.1f);
|
}
|
}
|
|
public void write(JMEExporter e) throws IOException
|
{
|
super.write(e);
|
OutputCapsule capsule = e.getCapsule(this);
|
// capsule.write(particles, "particleMesh", null);
|
capsule.write(releaseVariance, "releaseVariance", 0);
|
capsule.write(precision, "precision", 0);
|
capsule.write(controlFlow, "controlFlow", false);
|
capsule.write(updateOnlyInView, "updateOnlyInView", false);
|
capsule.write(iterations, "iterations", 0);
|
capsule.writeSavableArrayList(influences, "influences", null);
|
}
|
|
@SuppressWarnings("unchecked")
|
public void read(JMEImporter e) throws IOException
|
{
|
super.read(e);
|
InputCapsule capsule = e.getCapsule(this);
|
particles = (ParticleSystem) capsule.readSavable("particleMesh", null);
|
releaseVariance = capsule.readFloat("releaseVariance", 0);
|
precision = capsule.readFloat("precision", 0);
|
controlFlow = capsule.readBoolean("controlFlow", false);
|
updateOnlyInView = capsule.readBoolean("updateOnlyInView", false);
|
iterations = capsule.readInt("iterations", 0);
|
influences = capsule.readSavableArrayList("influences", null);
|
}
|
}
|
