0a9263d50e
1. Rewrite the reading/writing exception handlers to work like the ive plugin exceptions. 2. Write a header writing/checking function in ReaderWriterOSG2.cpp, which may help decide if the stream is ascii or binary. The readInputIterator() function will return null pointer if the input file is nither osgb nor osgt format, which indicates that the old .osg format could be used here, in case we've merged the two plugins together. 3. Add a new ForceReadingImage option in the InputStream, which will allocate an empty image object with the filename if specifed external image file is missed. It may be useful for format converting in some cases. 4. Add new osgParticle wrappers, as well as some modification to the osgParticle headers, for instance, change isEnabled() to getEnabled(). 5. Some fixes to the osg serialization wrappers."
266 lines
10 KiB
C++
266 lines
10 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 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.
|
|
*/
|
|
|
|
#ifndef OSGPARTICLE_PRECIPITATIONEFFECT
|
|
#define OSGPARTICLE_PRECIPITATIONEFFECT
|
|
|
|
#include <osg/Group>
|
|
#include <osg/BoundingBox>
|
|
#include <osg/Fog>
|
|
#include <osg/Geometry>
|
|
|
|
#include <osgUtil/CullVisitor>
|
|
|
|
#include <osgParticle/Export>
|
|
|
|
namespace osgParticle
|
|
{
|
|
class OSGPARTICLE_EXPORT PrecipitationEffect : public osg::Node
|
|
{
|
|
public:
|
|
|
|
PrecipitationEffect();
|
|
PrecipitationEffect(const PrecipitationEffect& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);
|
|
|
|
virtual const char* libraryName() const { return "osgParticle"; }
|
|
virtual const char* className() const { return "PrecipitationEffect"; }
|
|
virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const PrecipitationEffect*>(obj) != 0; }
|
|
virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } }
|
|
|
|
virtual void traverse(osg::NodeVisitor& nv);
|
|
|
|
|
|
/** Set all the parameters to create an rain effect of specified intensity.*/
|
|
void rain(float intensity);
|
|
|
|
/** Set all the parameters to create an snow effect of specified intensity.*/
|
|
void snow(float intensity);
|
|
|
|
void setMaximumParticleDensity(float density) { if (_maximumParticleDensity==density) return; _maximumParticleDensity = density; _dirty = true;}
|
|
float getMaximumParticleDensity() const { return _maximumParticleDensity; }
|
|
|
|
void setWind(const osg::Vec3& wind) { _wind = wind; }
|
|
const osg::Vec3& getWind() const { return _wind; }
|
|
|
|
void setPosition(const osg::Vec3& position) { _origin = position; }
|
|
const osg::Vec3& getPosition() const { return _origin; }
|
|
|
|
void setCellSize(const osg::Vec3& cellSize) { if (_cellSize==cellSize) return; _cellSize = cellSize; _dirty = true; }
|
|
const osg::Vec3& getCellSize() const { return _cellSize; }
|
|
|
|
void setParticleSpeed(float particleSpeed) { if (_particleSpeed==particleSpeed) return; _particleSpeed = particleSpeed; _dirty = true; }
|
|
float getParticleSpeed() const { return _particleSpeed; }
|
|
|
|
void setParticleSize(float particleSize) { if (_particleSize==particleSize) return; _particleSize = particleSize; _dirty = true;}
|
|
float getParticleSize() const { return _particleSize; }
|
|
|
|
void setParticleColor(const osg::Vec4& color) { if (_particleColor==color) return; _particleColor = color; _dirty = true;}
|
|
const osg::Vec4& getParticleColor() const { return _particleColor; }
|
|
|
|
void setNearTransition(float nearTransition) { _nearTransition = nearTransition; }
|
|
float getNearTransition() const { return _nearTransition; }
|
|
|
|
void setFarTransition(float farTransition) { _farTransition = farTransition; }
|
|
float getFarTransition() const { return _farTransition; }
|
|
|
|
void setUseFarLineSegments(bool useFarLineSegments) { _useFarLineSegments = useFarLineSegments; }
|
|
bool getUseFarLineSegments() const { return _useFarLineSegments; }
|
|
|
|
void setFog(osg::Fog* fog) { _fog = fog; }
|
|
osg::Fog* getFog() { return _fog.get(); }
|
|
const osg::Fog* getFog() const { return _fog.get(); }
|
|
|
|
osg::Geometry* getQuadGeometry() { return _quadGeometry.get(); }
|
|
osg::StateSet* getQuadStateSet() { return _quadStateSet.get(); }
|
|
|
|
osg::Geometry* getLineGeometry() { return _lineGeometry.get(); }
|
|
osg::StateSet* getLineStateSet() { return _lineStateSet.get(); }
|
|
|
|
osg::Geometry* getPointGeometry() { return _pointGeometry.get(); }
|
|
osg::StateSet* getPointStateSet() { return _pointStateSet.get(); }
|
|
|
|
/** Internal drawable used to render batches of cells.*/
|
|
class OSGPARTICLE_EXPORT PrecipitationDrawable : public osg::Drawable
|
|
{
|
|
public:
|
|
|
|
PrecipitationDrawable();
|
|
PrecipitationDrawable(const PrecipitationDrawable& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);
|
|
|
|
META_Object(osgParticle, PrecipitationDrawable);
|
|
|
|
virtual bool supports(const osg::PrimitiveFunctor&) const { return false; }
|
|
virtual void accept(osg::PrimitiveFunctor&) const {}
|
|
virtual bool supports(const osg::PrimitiveIndexFunctor&) const { return false; }
|
|
virtual void accept(osg::PrimitiveIndexFunctor&) const {}
|
|
|
|
void setRequiresPreviousMatrix(bool flag) { _requiresPreviousMatrix = flag; }
|
|
bool getRequiresPreviousMatrix() const { return _requiresPreviousMatrix; }
|
|
|
|
void setGeometry(osg::Geometry* geom) { _geometry = geom; }
|
|
osg::Geometry* getGeometry() { return _geometry.get(); }
|
|
const osg::Geometry* getGeometry() const { return _geometry.get(); }
|
|
|
|
void setDrawType(GLenum type) { _drawType = type; }
|
|
GLenum getDrawType() const { return _drawType; }
|
|
|
|
void setNumberOfVertices(unsigned int numVertices) { _numberOfVertices = numVertices; }
|
|
unsigned int getNumberOfVertices() const { return _numberOfVertices; }
|
|
|
|
virtual void drawImplementation(osg::RenderInfo& renderInfo) const;
|
|
|
|
struct Cell
|
|
{
|
|
Cell(int in_i, int in_j, int in_k):
|
|
i(in_i), j(in_j), k(in_k) {}
|
|
|
|
inline bool operator < (const Cell& rhs) const
|
|
{
|
|
if (i<rhs.i) return true;
|
|
if (i>rhs.i) return false;
|
|
if (j<rhs.j) return true;
|
|
if (j>rhs.j) return false;
|
|
if (k<rhs.k) return true;
|
|
if (k>rhs.k) return false;
|
|
return false;
|
|
}
|
|
|
|
int i;
|
|
int j;
|
|
int k;
|
|
};
|
|
|
|
struct DepthMatrixStartTime
|
|
{
|
|
inline bool operator < (const DepthMatrixStartTime& rhs) const
|
|
{
|
|
return depth < rhs.depth;
|
|
}
|
|
|
|
float depth;
|
|
float startTime;
|
|
osg::Matrix modelview;
|
|
};
|
|
|
|
typedef std::map< Cell, DepthMatrixStartTime > CellMatrixMap;
|
|
|
|
struct LessFunctor
|
|
{
|
|
inline bool operator () (const CellMatrixMap::value_type* lhs,const CellMatrixMap::value_type* rhs) const
|
|
{
|
|
return (*lhs).second<(*rhs).second;
|
|
}
|
|
};
|
|
|
|
|
|
CellMatrixMap& getCurrentCellMatrixMap() { return _currentCellMatrixMap; }
|
|
CellMatrixMap& getPreviousCellMatrixMap() { return _previousCellMatrixMap; }
|
|
|
|
inline void newFrame()
|
|
{
|
|
_previousCellMatrixMap.swap(_currentCellMatrixMap);
|
|
_currentCellMatrixMap.clear();
|
|
}
|
|
|
|
protected:
|
|
|
|
virtual ~PrecipitationDrawable() {}
|
|
|
|
bool _requiresPreviousMatrix;
|
|
|
|
osg::ref_ptr<osg::Geometry> _geometry;
|
|
|
|
mutable CellMatrixMap _currentCellMatrixMap;
|
|
mutable CellMatrixMap _previousCellMatrixMap;
|
|
|
|
GLenum _drawType;
|
|
unsigned int _numberOfVertices;
|
|
|
|
};
|
|
|
|
protected:
|
|
|
|
virtual ~PrecipitationEffect() {}
|
|
|
|
void compileGLObjects(osg::RenderInfo& renderInfo) const;
|
|
|
|
void update();
|
|
|
|
void createGeometry(unsigned int numParticles,
|
|
osg::Geometry* quad_geometry,
|
|
osg::Geometry* line_geometry,
|
|
osg::Geometry* point_geometry);
|
|
|
|
void setUpGeometries(unsigned int numParticles);
|
|
|
|
|
|
struct PrecipitationDrawableSet
|
|
{
|
|
osg::ref_ptr<PrecipitationDrawable> _quadPrecipitationDrawable;
|
|
osg::ref_ptr<PrecipitationDrawable> _linePrecipitationDrawable;
|
|
osg::ref_ptr<PrecipitationDrawable> _pointPrecipitationDrawable;
|
|
};
|
|
|
|
void cull(PrecipitationDrawableSet& pds, osgUtil::CullVisitor* cv) const;
|
|
bool build(const osg::Vec3 eyeLocal, int i, int j, int k, float startTime, PrecipitationDrawableSet& pds, osg::Polytope& frustum, osgUtil::CullVisitor* cv) const;
|
|
|
|
// parameters
|
|
bool _dirty;
|
|
osg::Vec3 _wind;
|
|
float _particleSpeed;
|
|
float _particleSize;
|
|
osg::Vec4 _particleColor;
|
|
float _maximumParticleDensity;
|
|
osg::Vec3 _cellSize;
|
|
float _nearTransition;
|
|
float _farTransition;
|
|
bool _useFarLineSegments;
|
|
osg::ref_ptr<osg::Fog> _fog;
|
|
|
|
osg::ref_ptr<osg::Uniform> _inversePeriodUniform;
|
|
osg::ref_ptr<osg::Uniform> _particleSizeUniform;
|
|
osg::ref_ptr<osg::Uniform> _particleColorUniform;
|
|
|
|
typedef std::pair< osg::NodeVisitor*, osg::NodePath > ViewIdentifier;
|
|
typedef std::map< ViewIdentifier, PrecipitationDrawableSet > ViewDrawableMap;
|
|
|
|
OpenThreads::Mutex _mutex;
|
|
ViewDrawableMap _viewDrawableMap;
|
|
|
|
osg::ref_ptr<osg::Geometry> _quadGeometry;
|
|
osg::ref_ptr<osg::StateSet> _quadStateSet;
|
|
|
|
osg::ref_ptr<osg::Geometry> _lineGeometry;
|
|
osg::ref_ptr<osg::StateSet> _lineStateSet;
|
|
|
|
osg::ref_ptr<osg::Geometry> _pointGeometry;
|
|
osg::ref_ptr<osg::StateSet> _pointStateSet;
|
|
|
|
// cache variables.
|
|
float _period;
|
|
osg::Vec3 _origin;
|
|
osg::Vec3 _du;
|
|
osg::Vec3 _dv;
|
|
osg::Vec3 _dw;
|
|
osg::Vec3 _inverse_du;
|
|
osg::Vec3 _inverse_dv;
|
|
osg::Vec3 _inverse_dw;
|
|
|
|
double _previousFrameTime;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|