297 lines
9.3 KiB
C++
297 lines
9.3 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield
|
|
*
|
|
* This library is open source and may be redistributed and/or modified under
|
|
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
|
* (at your option) any later version. The full license is in LICENSE file
|
|
* included with this distribution, and on the openscenegraph.org website.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* OpenSceneGraph Public License for more details.
|
|
*/
|
|
//osgParticle - Copyright (C) 2002 Marco Jez
|
|
|
|
#ifndef OSGPARTICLE_PARTICLEPROCESSOR_
|
|
#define OSGPARTICLE_PARTICLEPROCESSOR_ 1
|
|
|
|
#include <osgParticle/Export>
|
|
#include <osgParticle/ParticleSystem>
|
|
|
|
#include <osg/ref_ptr>
|
|
#include <osg/Object>
|
|
#include <osg/Transform>
|
|
#include <osg/NodeVisitor>
|
|
#include <osg/CopyOp>
|
|
#include <osg/Vec3>
|
|
#include <osg/Matrix>
|
|
|
|
namespace osgParticle
|
|
{
|
|
|
|
/** A common base interface for those classes which need to do something on particles. Such classes
|
|
are, for example, <CODE>Emitter</CODE> (particle generation) and <CODE>Program</CODE> (particle animation).
|
|
This class holds some properties, like a <I>reference frame</I> and a reference to a <CODE>ParticleSystem<CODE>;
|
|
descendant classes should process the particles taking into account the reference frame, computing the right
|
|
transformations when needed.
|
|
*/
|
|
class OSGPARTICLE_EXPORT ParticleProcessor: public osg::Node {
|
|
public:
|
|
|
|
enum ReferenceFrame {
|
|
RELATIVE_TO_PARENTS,
|
|
RELATIVE_TO_ABSOLUTE
|
|
};
|
|
|
|
ParticleProcessor();
|
|
ParticleProcessor(const ParticleProcessor ©, const osg::CopyOp ©op = osg::CopyOp::SHALLOW_COPY);
|
|
|
|
virtual const char *libraryName() const { return "osgParticle"; }
|
|
virtual const char *className() const { return "ParticleProcessor"; }
|
|
virtual bool isSameKindAs(const osg::Object *obj) const { return dynamic_cast<const ParticleProcessor*>(obj) != 0; }
|
|
virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } }
|
|
|
|
/// Get the reference frame.
|
|
inline ReferenceFrame getReferenceFrame() const;
|
|
|
|
/// Set the reference frame.
|
|
inline void setReferenceFrame(ReferenceFrame rf);
|
|
|
|
/// Get whether this processor is enabled or not.
|
|
inline bool isEnabled() const;
|
|
|
|
/// Set whether this processor is enabled or not.
|
|
inline void setEnabled(bool v);
|
|
|
|
/// Get a pointer to the destination particle system.
|
|
inline ParticleSystem *getParticleSystem();
|
|
|
|
/// Get a const pointer to the destination particle system.
|
|
inline const ParticleSystem *getParticleSystem() const;
|
|
|
|
/// Set the destination particle system.
|
|
inline void setParticleSystem(ParticleSystem *ps);
|
|
|
|
/// Set the endless flag of this processor.
|
|
inline void setEndless(bool type);
|
|
|
|
/// Check whether this processor is endless.
|
|
inline bool isEndless() const;
|
|
|
|
/// Set the lifetime of this processor.
|
|
inline void setLifeTime(double t);
|
|
|
|
/// Get the lifetime of this processor.
|
|
inline double getLifeTime() const;
|
|
|
|
/// Set the start time of this processor.
|
|
inline void setStartTime(double t);
|
|
|
|
/// Get the start time of this processor.
|
|
inline double getStartTime() const;
|
|
|
|
/// Set the current time of this processor.
|
|
inline void setCurrentTime(double t);
|
|
|
|
/// Get the current time of this processor.
|
|
inline double getCurrentTime() const;
|
|
|
|
/// Set the reset time of this processor. A value of 0 disables reset.
|
|
inline void setResetTime(double t);
|
|
|
|
/// Get the reset time of this processor.
|
|
inline double getResetTime() const;
|
|
|
|
void traverse(osg::NodeVisitor &nv);
|
|
|
|
/// Get the current local-to-world transformation matrix (valid only during cull traversal).
|
|
inline const osg::Matrix &getLocalToWorldMatrix();
|
|
|
|
/// Get the current world-to-local transformation matrix (valid only during cull traversal).
|
|
inline const osg::Matrix &getWorldToLocalMatrix();
|
|
|
|
/// Transform a point from local to world coordinates (valid only during cull traversal).
|
|
inline osg::Vec3 transformLocalToWorld(const osg::Vec3 &P);
|
|
|
|
/// Transform a vector from local to world coordinates, discarding translation (valid only during cull traversal).
|
|
inline osg::Vec3 rotateLocalToWorld(const osg::Vec3 &P);
|
|
|
|
/// Transform a point from world to local coordinates (valid only during cull traversal).
|
|
inline osg::Vec3 transformWorldToLocal(const osg::Vec3 &P);
|
|
|
|
/// Transform a vector from world to local coordinates, discarding translation (valid only during cull traversal).
|
|
inline osg::Vec3 rotateWorldToLocal(const osg::Vec3 &P);
|
|
|
|
protected:
|
|
virtual ~ParticleProcessor() {}
|
|
ParticleProcessor &operator=(const ParticleProcessor &) { return *this; }
|
|
|
|
inline bool computeBound() const;
|
|
|
|
virtual void process(double dt) = 0;
|
|
|
|
private:
|
|
ReferenceFrame rf_;
|
|
bool enabled_;
|
|
double t0_;
|
|
osg::ref_ptr<ParticleSystem> ps_;
|
|
bool need_ltw_matrix_;
|
|
bool need_wtl_matrix_;
|
|
osg::Matrix ltw_matrix_;
|
|
osg::Matrix wtl_matrix_;
|
|
osg::NodeVisitor *current_nodevisitor_;
|
|
|
|
bool endless_;
|
|
|
|
double lifeTime_;
|
|
double startTime_;
|
|
double currentTime_;
|
|
double resetTime_;
|
|
};
|
|
|
|
// INLINE FUNCTIONS
|
|
|
|
inline ParticleProcessor::ReferenceFrame ParticleProcessor::getReferenceFrame() const
|
|
{
|
|
return rf_;
|
|
}
|
|
|
|
inline void ParticleProcessor::setReferenceFrame(ReferenceFrame rf)
|
|
{
|
|
rf_ = rf;
|
|
}
|
|
|
|
inline bool ParticleProcessor::isEnabled() const
|
|
{
|
|
return enabled_;
|
|
}
|
|
|
|
inline void ParticleProcessor::setEnabled(bool v)
|
|
{
|
|
enabled_ = v;
|
|
if (enabled_) {
|
|
t0_ = -1;
|
|
currentTime_ = 0;
|
|
}
|
|
}
|
|
|
|
inline ParticleSystem *ParticleProcessor::getParticleSystem()
|
|
{
|
|
return ps_.get();
|
|
}
|
|
|
|
inline const ParticleSystem *ParticleProcessor::getParticleSystem() const
|
|
{
|
|
return ps_.get();
|
|
}
|
|
|
|
inline void ParticleProcessor::setParticleSystem(ParticleSystem *ps)
|
|
{
|
|
ps_ = ps;
|
|
}
|
|
|
|
inline void ParticleProcessor::setEndless(bool type)
|
|
{
|
|
endless_ = type;
|
|
}
|
|
|
|
inline bool ParticleProcessor::isEndless() const
|
|
{
|
|
return endless_;
|
|
}
|
|
|
|
inline void ParticleProcessor::setLifeTime(double t)
|
|
{
|
|
lifeTime_ = t;
|
|
}
|
|
|
|
inline double ParticleProcessor::getLifeTime() const
|
|
{
|
|
return lifeTime_;
|
|
}
|
|
|
|
inline void ParticleProcessor::setStartTime(double t)
|
|
{
|
|
startTime_ = t;
|
|
}
|
|
|
|
inline double ParticleProcessor::getStartTime() const
|
|
{
|
|
return startTime_;
|
|
}
|
|
inline void ParticleProcessor::setCurrentTime(double t)
|
|
{
|
|
currentTime_ = t;
|
|
}
|
|
|
|
inline double ParticleProcessor::getCurrentTime() const
|
|
{
|
|
return currentTime_;
|
|
}
|
|
|
|
inline void ParticleProcessor::setResetTime(double t)
|
|
{
|
|
resetTime_ = t;
|
|
}
|
|
|
|
inline double ParticleProcessor::getResetTime() const
|
|
{
|
|
return resetTime_;
|
|
}
|
|
|
|
inline bool ParticleProcessor::computeBound() const
|
|
{
|
|
_bsphere.init();
|
|
_bsphere_computed = true;
|
|
return true;
|
|
}
|
|
|
|
inline const osg::Matrix &ParticleProcessor::getLocalToWorldMatrix()
|
|
{
|
|
if (need_ltw_matrix_) {
|
|
ltw_matrix_ = osg::Matrix::identity();
|
|
//current_nodevisitor_->getLocalToWorldMatrix(ltw_matrix_, this);
|
|
ltw_matrix_ = osg::computeLocalToWorld(current_nodevisitor_->getNodePath());
|
|
need_ltw_matrix_ = false;
|
|
}
|
|
return ltw_matrix_;
|
|
}
|
|
|
|
inline const osg::Matrix &ParticleProcessor::getWorldToLocalMatrix()
|
|
{
|
|
if (need_wtl_matrix_) {
|
|
wtl_matrix_ = osg::Matrix::identity();
|
|
//current_nodevisitor_->getWorldToLocalMatrix(wtl_matrix_, this);
|
|
wtl_matrix_ = osg::computeWorldToLocal(current_nodevisitor_->getNodePath());
|
|
need_wtl_matrix_ = false;
|
|
}
|
|
return wtl_matrix_;
|
|
}
|
|
|
|
inline osg::Vec3 ParticleProcessor::transformLocalToWorld(const osg::Vec3 &P)
|
|
{
|
|
return getLocalToWorldMatrix().preMult(P);
|
|
}
|
|
|
|
inline osg::Vec3 ParticleProcessor::transformWorldToLocal(const osg::Vec3 &P)
|
|
{
|
|
return getWorldToLocalMatrix().preMult(P);
|
|
}
|
|
|
|
inline osg::Vec3 ParticleProcessor::rotateLocalToWorld(const osg::Vec3 &P)
|
|
{
|
|
return getLocalToWorldMatrix().preMult(P) -
|
|
getLocalToWorldMatrix().preMult(osg::Vec3(0, 0, 0));
|
|
}
|
|
|
|
inline osg::Vec3 ParticleProcessor::rotateWorldToLocal(const osg::Vec3 &P)
|
|
{
|
|
return getWorldToLocalMatrix().preMult(P) -
|
|
getWorldToLocalMatrix().preMult(osg::Vec3(0, 0, 0));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
#endif
|