mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-04 17:24:47 +00:00
868 lines
31 KiB
C++
868 lines
31 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program 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
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#ifndef NL_PS_PARTICLE_BASIC_H
|
|
#define NL_PS_PARTICLE_BASIC_H
|
|
|
|
#include "nel/misc/types_nl.h"
|
|
#include "nel/misc/vector_2f.h"
|
|
#include "nel/misc/stream.h"
|
|
#include "nel/3d/ps_located.h"
|
|
#include "nel/3d/ps_plane_basis.h"
|
|
#include "nel/3d/material.h"
|
|
#include "nel/3d/ps_attrib_maker.h"
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
|
|
////////////////////////////////
|
|
// class forward declarations //
|
|
////////////////////////////////
|
|
|
|
class CTextureGrouped;
|
|
|
|
/**
|
|
* This is the base class for all particles.
|
|
* A deriver must provide a drawing method for his particle.
|
|
* Not sharable accross systems.
|
|
* \author Nicolas Vizerie
|
|
* \author Nevrax France
|
|
* \date 2001
|
|
*/
|
|
class CPSParticle : public CPSLocatedBindable
|
|
{
|
|
public:
|
|
|
|
/// Constructor
|
|
CPSParticle();
|
|
|
|
/// return this bindable type
|
|
uint32 getType(void) const { return PSParticle; }
|
|
|
|
/// return priority
|
|
virtual uint32 getPriority(void) const { return 1000; }
|
|
|
|
/// return true if this located bindable derived class holds alive particles
|
|
virtual bool hasParticles(void) const { nlassert(_Owner); return _Owner->getSize() != 0; }
|
|
|
|
/**
|
|
* process one pass for the particles. The default behaviour shows the particles
|
|
*/
|
|
virtual void step(TPSProcessPass pass)
|
|
{
|
|
if (
|
|
(pass == PSBlendRender && hasTransparentFaces())
|
|
|| (pass == PSSolidRender && hasOpaqueFaces())
|
|
)
|
|
{
|
|
draw(pass == PSSolidRender);
|
|
}
|
|
else
|
|
if (pass == PSToolRender) // edition mode only
|
|
{
|
|
showTool();
|
|
}
|
|
}
|
|
|
|
/// return true if there are transparent faces in the object
|
|
virtual bool hasTransparentFaces(void) = 0;
|
|
|
|
/// return true if there are Opaque faces in the object
|
|
virtual bool hasOpaqueFaces(void) = 0;
|
|
|
|
/** Returns true if there are lightable faces in the object
|
|
*/
|
|
virtual bool hasLightableFaces() = 0;
|
|
|
|
/** Returns true if the object can use global lighting color. (example : 'lookat' particle do not have
|
|
* normals, so they use global lighting color instead
|
|
*/
|
|
bool usesGlobalColorLighting() { return _UsesGlobalColorLighting; }
|
|
// active / deactive global color lighting
|
|
void enableGlobalColorLighting(bool enabled) { _UsesGlobalColorLighting = enabled; }
|
|
// is global color lighting supported ?
|
|
virtual bool supportGlobalColorLighting() const = 0;
|
|
|
|
/// derivers draw the particles here
|
|
virtual void draw(bool opaque) {}
|
|
|
|
/// draw the particles for edition mode. The default behaviour just draw a wireframe model
|
|
virtual void showTool();
|
|
|
|
/// return the max number of faces needed for display. This is needed for LOD balancing
|
|
virtual uint32 getNumWantedTris() const = 0;
|
|
|
|
/// serialisation. Derivers must override this, and call their parent version
|
|
virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
|
|
{
|
|
/// version 3 : global color lighting
|
|
/// version 2 : auto-lod saved
|
|
sint ver = f.serialVersion(3);
|
|
CPSLocatedBindable::serial(f);
|
|
if (ver >= 3)
|
|
{
|
|
f.serial(_UsesGlobalColorLighting);
|
|
}
|
|
if (ver >= 2)
|
|
{
|
|
f.serial(_DisableAutoLOD);
|
|
}
|
|
}
|
|
|
|
|
|
/// Force the Auto-LOD to be disbaled. When set to false, the default behaviour set in the system is used
|
|
void disableAutoLOD(bool disable = true) { _DisableAutoLOD = disable; }
|
|
|
|
/// Test whether Auto-LOD is disabled.
|
|
bool isAutoLODDisabled() const { return _DisableAutoLOD; }
|
|
|
|
// Change z-bias of material. this must be redefined for all renderable particles
|
|
virtual void setZBias(float value) = 0;
|
|
virtual float getZBias() const = 0;
|
|
|
|
protected:
|
|
|
|
/** Shortcut to notify that the max number of faces has changed
|
|
* This must be called when a geometric property of the particle has been modified
|
|
* This needn't to be called during CPSParticle::resize overrides
|
|
*/
|
|
/*
|
|
void notifyOwnerMaxNumFacesChanged(void) const
|
|
{
|
|
if (_Owner)
|
|
{
|
|
_Owner->notifyMaxNumFacesChanged();
|
|
}
|
|
}*/
|
|
|
|
/** Generate a new element for this bindable. They are generated according to the properties of the class
|
|
*/
|
|
virtual void newElement(const CPSEmitterInfo &info) = 0;
|
|
|
|
/** Delete an element given its index
|
|
* Attributes of the located that hold this bindable are still accessible for the index given
|
|
* index out of range -> nl_assert
|
|
*/
|
|
virtual void deleteElement(uint32 index) = 0;
|
|
|
|
/** Resize the bindable attributes containers. Size is the max number of element to be contained. DERIVERS MUST CALL THEIR PARENT VERSION
|
|
* should not be called directly. Call CPSLocated::resize instead
|
|
*/
|
|
virtual void resize(uint32 size) = 0;
|
|
|
|
|
|
/** System may have hand-tuned LOD, or auto LOD.
|
|
* This compute the number of particles that must really be displayed, and the src step
|
|
* that allow to go through the whole collection. The step in the source is in a fixed point 16:16 format
|
|
*/
|
|
void computeSrcStep(uint32 &step, uint &numToProcess);
|
|
|
|
private:
|
|
/// Disable Auto-LOD flag
|
|
bool _DisableAutoLOD;
|
|
bool _UsesGlobalColorLighting;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// this class adds tunable color to a particle. Can be added using public multiple inheritance
|
|
class CPSColoredParticle
|
|
{
|
|
public:
|
|
|
|
/** Set an attribute maker that produce a color
|
|
* It must have been allocated by new
|
|
* It will be deleted by this object
|
|
*/
|
|
void setColorScheme(CPSAttribMaker<CRGBA> *col);
|
|
|
|
/// get the color scheme (NULL if none)
|
|
CPSAttribMaker<CRGBA> *getColorScheme(void) { return _ColorScheme; }
|
|
|
|
/// get the color scheme (NULL if none) const version
|
|
const CPSAttribMaker<CRGBA> *getColorScheme(void) const { return _ColorScheme; }
|
|
|
|
/// Set a constant color for the particles. remove any previous scheme
|
|
void setColor(NLMISC::CRGBA col);
|
|
|
|
/// Get the color
|
|
NLMISC::CRGBA getColor(void) const { return _Color; }
|
|
|
|
/// ctor : default are white particles (constant color)
|
|
CPSColoredParticle();
|
|
|
|
/// dtor
|
|
virtual ~CPSColoredParticle();
|
|
|
|
/// serialization.
|
|
void serialColorScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
|
|
|
|
protected:
|
|
|
|
/// deriver must return their owner there
|
|
virtual CPSLocated *getColorOwner(void) = 0;
|
|
CRGBA _Color;
|
|
|
|
CPSAttribMaker<CRGBA> *_ColorScheme;
|
|
|
|
/// Update the material and the vb and the like so that they match the color scheme
|
|
virtual void updateMatAndVbForColor(void) = 0;
|
|
|
|
void newColorElement(const CPSEmitterInfo &info)
|
|
{
|
|
if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->newElement(info);
|
|
}
|
|
void deleteColorElement(uint32 index)
|
|
{
|
|
if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->deleteElement(index);
|
|
}
|
|
void resizeColor(uint32 size)
|
|
{
|
|
nlassert(size < (1 << 16));
|
|
if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->resize(size, getColorOwner()->getSize());
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// this class adds tunable size to a particle. Can be added using public multiple inheritance
|
|
class CPSSizedParticle
|
|
{
|
|
public:
|
|
|
|
/** Set an attribute maker that produce a size
|
|
* It must have been allocated by new
|
|
* It will be deleted by this object
|
|
*/
|
|
void setSizeScheme(CPSAttribMaker<float> *size);
|
|
|
|
|
|
|
|
/// get the size scheme (NULL if none)
|
|
CPSAttribMaker<float> *getSizeScheme(void) { return _SizeScheme; }
|
|
|
|
/// get the size scheme (NULL if none) const version
|
|
const CPSAttribMaker<float> *getSizeScheme(void) const { return _SizeScheme; }
|
|
|
|
/// Set a constant size for the particles
|
|
void setSize(float size);
|
|
|
|
/// get the constant size
|
|
float getSize(void) const { return _ParticleSize; }
|
|
|
|
/// ctor : default are 0.1f sized particles
|
|
CPSSizedParticle();
|
|
|
|
/// dtor
|
|
virtual ~CPSSizedParticle();
|
|
|
|
/// serialization. We choose a different name because of multiple-inheritance
|
|
void serialSizeScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
|
|
|
|
protected:
|
|
|
|
/// deriver must return their owner there
|
|
virtual CPSLocated *getSizeOwner(void) = 0;
|
|
float _ParticleSize;
|
|
CPSAttribMaker<float> *_SizeScheme;
|
|
void newSizeElement(const CPSEmitterInfo &info)
|
|
{
|
|
if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->newElement(info);
|
|
}
|
|
void deleteSizeElement(uint32 index)
|
|
{
|
|
if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->deleteElement(index);
|
|
}
|
|
void resizeSize(uint32 size)
|
|
{
|
|
nlassert(size < (1 << 16));
|
|
if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->resize(size, getSizeOwner()->getSize());
|
|
}
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// this class adds tunable 2D rotation to a particle, it can be used by public multiple inheritance
|
|
class CPSRotated2DParticle
|
|
{
|
|
public:
|
|
|
|
/** Set an attribute maker that produce a float
|
|
* It must have been allocated by new
|
|
* It will be deleted by this object
|
|
* Output angles must range from 0.0f to 256.0f
|
|
*/
|
|
void setAngle2DScheme(CPSAttribMaker<float> *scheme);
|
|
|
|
/// get the angle 2D scheme (NULL if none)
|
|
CPSAttribMaker<float> *getAngle2DScheme(void) { return _Angle2DScheme; }
|
|
|
|
/// get the angle 2D scheme (NULL if none) const version
|
|
const CPSAttribMaker<float> *getAngle2DScheme(void) const { return _Angle2DScheme; }
|
|
|
|
|
|
/** Set a constant angle for the particle. Angles range from 0.0f to 256.0f (2 pi)
|
|
* This discrad any previous scheme
|
|
* \see setAngle2DScheme()
|
|
*/
|
|
void setAngle2D(float angle);
|
|
|
|
/// get the constant
|
|
float getAngle2D(void) const { return _Angle2D; }
|
|
|
|
/// ctor : default are unrotated particles (angle = 0.0f)
|
|
CPSRotated2DParticle();
|
|
|
|
/// dtor
|
|
virtual ~CPSRotated2DParticle();
|
|
|
|
/// serialization. We choose a different name because of multiple-inheritance
|
|
void serialAngle2DScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
|
|
|
|
|
|
|
|
/** this return a float table used to speed up rotations of face look at and the like
|
|
* for each angle, there are 4 float : 2 couple of float : a1, b1, a2, b2
|
|
* a1 * I + b1 * K = up left corner, a2 * I + b2 * K = up right corner,
|
|
* This table must have been initialized with initRotTable
|
|
*/
|
|
static inline const float *getRotTable(void)
|
|
{
|
|
nlassert(_InitializedRotTab); // must have called initRotTable at the start of the apply
|
|
return _RotTable;
|
|
}
|
|
|
|
/// init the rotation table
|
|
static void initRotTable(void);
|
|
|
|
protected:
|
|
/// deriver must return their owner there
|
|
virtual CPSLocated *getAngle2DOwner(void) = 0;
|
|
|
|
float _Angle2D;
|
|
CPSAttribMaker<float> *_Angle2DScheme;
|
|
static float _RotTable[4 * 256];
|
|
|
|
//#ifdef NL_DEBUG
|
|
/// it is true if the table has been initialized, for debug purposes
|
|
static bool _InitializedRotTab;
|
|
//#endif
|
|
|
|
void newAngle2DElement(const CPSEmitterInfo &info)
|
|
{
|
|
if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->newElement(info);
|
|
}
|
|
void deleteAngle2DElement(uint32 index)
|
|
{
|
|
if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->deleteElement(index);
|
|
}
|
|
void resizeAngle2D(uint32 size)
|
|
{
|
|
nlassert(size < (1 << 16));
|
|
if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->resize(size, getAngle2DOwner()->getSize());
|
|
}
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// this class is an interface for particles that have unanimated textures
|
|
struct CPSTexturedParticleNoAnim
|
|
{
|
|
virtual ~CPSTexturedParticleNoAnim() {}
|
|
/// set the texture for this particle
|
|
virtual void setTexture(CSmartPtr<ITexture> tex) = 0;
|
|
/// get the texture used for this particle
|
|
virtual ITexture *getTexture(void) = 0;
|
|
virtual const ITexture *getTexture(void) const = 0;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/** this class adds a texture to a particle. The texture can be animated or not. it can be used by public multiple inheritance.
|
|
* The frame animation are all stored in the same texture for optimisation so it's not suited for large anim...
|
|
*/
|
|
class CPSTexturedParticle
|
|
{
|
|
public:
|
|
|
|
/** Set an attribute maker that produce a sint32
|
|
* It must have been allocated by new
|
|
* It will be deleted by this object
|
|
* a texture group must have been set before this, an assertion occurs otherwise
|
|
* The integer is used as an index in a grouped texture. It tells which frame to use
|
|
*/
|
|
void setTextureIndexScheme(CPSAttribMaker<sint32> *animOrder);
|
|
|
|
/// get the texture scheme (null if none)
|
|
CPSAttribMaker<sint32> *getTextureIndexScheme(void) { return _TextureIndexScheme; }
|
|
|
|
/// get the texture scheme (null if none) const version
|
|
const CPSAttribMaker<sint32> *getTextureIndexScheme(void) const { return _TextureIndexScheme; }
|
|
|
|
/// set a constant index for the current texture. not very useful, but available...
|
|
void setTextureIndex(sint32 index);
|
|
|
|
/// get the animated texture index. MeaningFul only if a texture group was set
|
|
sint32 getTextureIndex(void) const { return _TextureIndex; }
|
|
|
|
/// set the texture group being used. It toggles animation on
|
|
virtual void setTextureGroup(NLMISC::CSmartPtr<CTextureGrouped> texGroup);
|
|
|
|
/// get the texture group used. it discard any previous single texture. (if null, there's no texture animation)
|
|
CTextureGrouped *getTextureGroup(void) { return _TexGroup; }
|
|
|
|
/// get the texture group used if there's a texture scheme, const version. (if null, there's no texture animation)
|
|
const CTextureGrouped *getTextureGroup(void) const { return _TexGroup; }
|
|
|
|
/** Set a constant texture for the particle
|
|
* This discard any previous scheme
|
|
* \see setTextureScheme()
|
|
*/
|
|
virtual void setTexture(CSmartPtr<ITexture> tex);
|
|
|
|
/// get the constant texture
|
|
ITexture *getTexture(void) { return _Tex; }
|
|
// get the texture (const version)
|
|
const ITexture *getTexture(void) const { return _Tex; }
|
|
|
|
/// ctor : default have no texture. You must set it, otherwise you'll get an assertion when it's drawn
|
|
CPSTexturedParticle();
|
|
|
|
/// dtor
|
|
virtual ~CPSTexturedParticle();
|
|
|
|
/// serialization. We choose a different name because of multiple-inheritance
|
|
void serialTextureScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
|
|
|
|
void enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest);
|
|
|
|
|
|
protected:
|
|
/// deriver must return their owner there
|
|
virtual CPSLocated *getTextureIndexOwner(void) = 0;
|
|
|
|
// a single texture
|
|
CSmartPtr<ITexture> _Tex;
|
|
|
|
// a grouped texture
|
|
CSmartPtr<CTextureGrouped> _TexGroup;
|
|
|
|
CPSAttribMaker<sint32> *_TextureIndexScheme;
|
|
|
|
// a texture index. Most of the time, a scheme of index will be used instead of that
|
|
sint32 _TextureIndex;
|
|
|
|
/// Update the material so that it match the texture scheme
|
|
virtual void updateMatAndVbForTexture(void) = 0;
|
|
|
|
void newTextureIndexElement(const CPSEmitterInfo &info)
|
|
{
|
|
if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->newElement(info);
|
|
}
|
|
void deleteTextureIndexElement(uint32 index)
|
|
{
|
|
if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->deleteElement(index);
|
|
}
|
|
void resizeTextureIndex(uint32 size)
|
|
{
|
|
nlassert(size < (1 << 16));
|
|
if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->resize(size, getTextureIndexOwner()->getSize() );
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/** This class add multitexturing support to particles. It doesn't support texture animation however.
|
|
* It adds a second texture that is combined with the main texture by using a given operation.
|
|
* An alternate mode must be provided, for gfx boards that doesn't support the op.
|
|
* For now, 2 stages only are supported.
|
|
*/
|
|
class CPSMultiTexturedParticle
|
|
{
|
|
public:
|
|
/// ctor
|
|
CPSMultiTexturedParticle();
|
|
virtual ~CPSMultiTexturedParticle() {}
|
|
|
|
/// we only use a useful set of operations
|
|
enum TOperator { Add = 0, Modulate, Decal, EnvBumpMap, Last = 0xff };
|
|
|
|
/// when set to false, this discard the textures that have been set
|
|
void enableMultiTexture(bool enabled = true);
|
|
bool isMultiTextureEnabled() const { return (_MultiTexState & (uint8) MultiTextureEnabled) != 0; }
|
|
|
|
/// Set the main texture for multitexturing. Convert the texture to / from a bumpmap if needed (so you just provide its heightmap)
|
|
void setTexture2(ITexture *tex);
|
|
|
|
/// Get the main texture for multitexturing
|
|
const ITexture *getTexture2() const { return _Texture2; }
|
|
ITexture *getTexture2() { return _Texture2; }
|
|
|
|
/** Set the operation for the main texture. When EnvBumpMap is used, setTexture2 must be called with a bump map,
|
|
* and the primary texture must be convertible to rgba. Convert the texture to / from a bumpmap if needed
|
|
*/
|
|
void setMainTexOp(TOperator op);
|
|
|
|
TOperator getMainTexOp() const { return _MainOp; }
|
|
|
|
// Enable the use of an alternate texture for multitexturing. When disabled, this discard the textures that may have been set.
|
|
void enableAlternateTex(bool enabled = true);
|
|
bool isAlternateTexEnabled() const { return (_MultiTexState & (uint8) AlternateTextureEnabled) != 0; }
|
|
|
|
/// Set the alternate texture for multitexturing. It is used when the main operator is not supported by the gfx board.
|
|
// Convert the texture to / from a bumpmap if needed. (so you just provide its heightmap)
|
|
void setTexture2Alternate(ITexture *tex);
|
|
|
|
/// Get the alternate texture for multitexturing.
|
|
const ITexture *getTexture2Alternate() const { return _AlternateTexture2; }
|
|
ITexture *getTexture2Alternate() { return _AlternateTexture2; }
|
|
|
|
/// Set the operation for the alternate texture. Convert the texture to / from a bumpmap if needed.
|
|
void setAlternateTexOp(TOperator op);
|
|
|
|
TOperator getAlternateTexOp() const
|
|
{
|
|
return _AlternateOp;
|
|
}
|
|
|
|
/** set the scroll speed for tex 1 & 2 when the main op is used
|
|
* \param stage can be set to 0 or one
|
|
*/
|
|
void setScrollSpeed(uint stage, const NLMISC::CVector2f &sp)
|
|
{
|
|
nlassert(stage < 2);
|
|
_TexScroll[stage] = sp;
|
|
}
|
|
const NLMISC::CVector2f &getScrollSpeed(uint stage) const
|
|
{
|
|
nlassert(stage < 2);
|
|
return _TexScroll[stage];
|
|
}
|
|
|
|
/** set the scroll speed for tex 1 & 2 when the alternate op is used
|
|
* \param stage can be set to 0 or one
|
|
*/
|
|
void setAlternateScrollSpeed(uint stage, const NLMISC::CVector2f &sp)
|
|
{
|
|
nlassert(stage < 2);
|
|
_TexScrollAlternate[stage] = sp;
|
|
}
|
|
const NLMISC::CVector2f &getAlternateScrollSpeed(uint stage) const
|
|
{
|
|
nlassert(stage < 2);
|
|
return _TexScrollAlternate[stage];
|
|
}
|
|
|
|
/// serial this object
|
|
void serialMultiTex(NLMISC::IStream &f) throw(NLMISC::EStream);
|
|
|
|
/** setup a material from this object and a primary texture
|
|
* drv is used to check the device caps.
|
|
* Must be called before display when multitextureing is used
|
|
* vb is needed because uv routing may be changed because of embm
|
|
*/
|
|
void setupMaterial(ITexture *primary, IDriver *drv, CMaterial &mat, CVertexBuffer &vb);
|
|
|
|
/** this act as if the system had the most basic caps supported (no EMBM for example...)
|
|
* Should be used only in edition mode for test
|
|
*/
|
|
static void forceBasicCaps(bool force = true) { _ForceBasicCaps = force; }
|
|
|
|
/// test whether basic caps are forced
|
|
static bool areBasicCapsForced() { return _ForceBasicCaps; }
|
|
|
|
/// Use the particle age rather than the global time to compute textures coordinates.
|
|
void setUseLocalDate(bool use);
|
|
bool getUseLocalDate() { return (_MultiTexState & ScrollUseLocalDate) != 0; }
|
|
|
|
/// Use the particle age rather than the global time to compute textures coordinates. (when alternate texture is used)
|
|
void setUseLocalDateAlt(bool use);
|
|
bool getUseLocalDateAlt() { return (_MultiTexState & ScrollUseLocalDateAlternate) != 0; }
|
|
|
|
/// Set a bump factor (when embm is used)
|
|
void setBumpFactor(float bumpFactor) { _BumpFactor = bumpFactor; touch(); }
|
|
float getBumpFactor() const { return _BumpFactor; }
|
|
|
|
void enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest, IDriver &drv);
|
|
|
|
|
|
protected:
|
|
void setupMultiTexEnv(TOperator op, ITexture *tex1, ITexture *tex2, CMaterial &mat, IDriver &drv);
|
|
TOperator _MainOp, _AlternateOp;
|
|
NLMISC::CSmartPtr<ITexture> _Texture2;
|
|
NLMISC::CSmartPtr<ITexture> _AlternateTexture2;
|
|
|
|
/// texture scrolling
|
|
NLMISC::CVector2f _TexScroll[2];
|
|
/// alternate texture scrollMultiTextureEnabled
|
|
NLMISC::CVector2f _TexScrollAlternate[2];
|
|
|
|
enum TMultiTexState { TouchFlag = 0x01, MultiTextureEnabled = 0x02, AlternateTextureEnabled = 0x04, AlternateTextureUsed = 0x08, EnvBumpMapUsed = 0x10, BasicCapsForced = 0x20,
|
|
ScrollUseLocalDate = 0x40, ScrollUseLocalDateAlternate = 0x80
|
|
};
|
|
uint8 _MultiTexState;
|
|
|
|
/// test whether the alternate texture is used
|
|
bool isAlternateTextureUsed(IDriver &driver) const;
|
|
bool isEnvBumpMapUsed() const { return (_MultiTexState & EnvBumpMapUsed) != 0; }
|
|
|
|
|
|
// update wrap mode for all textures
|
|
virtual void updateTexWrapMode(IDriver &drv) = 0;
|
|
void touch() { _MultiTexState |= (uint8) TouchFlag; }
|
|
void unTouch() { _MultiTexState &= ~ (uint8) TouchFlag; }
|
|
bool isTouched() const { return (_MultiTexState & TouchFlag) != 0; }
|
|
bool areBasicCapsForcedLocal() const { return (_MultiTexState & BasicCapsForced) != 0; }
|
|
void forceBasicCapsLocal(bool force)
|
|
{
|
|
if (force) _MultiTexState |= BasicCapsForced;
|
|
else _MultiTexState &= ~BasicCapsForced;
|
|
}
|
|
float _BumpFactor;
|
|
static bool _ForceBasicCaps;
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/** this class adds tunable 3D rotation to a PLANE particle, it can be used by public multiple inheritance
|
|
* It must just produce 2 vectors that give the x and y vector of the local basis.
|
|
*/
|
|
class CPSRotated3DPlaneParticle
|
|
{
|
|
public:
|
|
|
|
/** Set an attribute maker that produce a basis
|
|
* It must have been allocated by new
|
|
* It will be deleted by this object
|
|
*/
|
|
void setPlaneBasisScheme(CPSAttribMaker<CPlaneBasis> *basisMaker);
|
|
|
|
/** Set a constant basis for all particles
|
|
* \see setPlaneBasisSchemeScheme()
|
|
*/
|
|
|
|
/// get the plane basis scheme, (NULL if none)
|
|
CPSAttribMaker<CPlaneBasis> *getPlaneBasisScheme(void) { return _PlaneBasisScheme; }
|
|
|
|
/// get the plane basis scheme, (NULL if none) const version
|
|
const CPSAttribMaker<CPlaneBasis> *getPlaneBasisScheme(void) const { return _PlaneBasisScheme; }
|
|
|
|
void setPlaneBasis(const CPlaneBasis &basis);
|
|
|
|
/// get the constant basis
|
|
CPlaneBasis getPlaneBasis(void) const { return _PlaneBasis; }
|
|
|
|
/// ctor : default have constant basis that map to the I & J vector (e.g identity)
|
|
CPSRotated3DPlaneParticle();
|
|
|
|
/// dtor
|
|
virtual ~CPSRotated3DPlaneParticle();
|
|
|
|
/// serialization. We choose a different name because of multiple-inheritance
|
|
void serialPlaneBasisScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
|
|
|
|
protected:
|
|
/// if this is false, constant size will be used instead of a scheme
|
|
|
|
/// deriver must return their owner there
|
|
virtual CPSLocated *getPlaneBasisOwner(void) = 0;
|
|
|
|
CPSAttribMaker<CPlaneBasis> *_PlaneBasisScheme;
|
|
|
|
CPlaneBasis _PlaneBasis; // constant basis..
|
|
|
|
void newPlaneBasisElement(const CPSEmitterInfo &info)
|
|
{
|
|
if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->newElement(info);
|
|
}
|
|
void deletePlaneBasisElement(uint32 index)
|
|
{
|
|
if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->deleteElement(index);
|
|
}
|
|
void resizePlaneBasis(uint32 size)
|
|
{
|
|
nlassert(size < (1 << 16));
|
|
if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->resize(size, getPlaneBasisOwner()->getSize());
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/** This add a hint to rotated particle : only a few one are rotated, and the other are duplcated
|
|
*
|
|
*/
|
|
|
|
struct CPSHintParticleRotateTheSame
|
|
{
|
|
virtual ~CPSHintParticleRotateTheSame() {}
|
|
|
|
/** Tells that all particles are turning in the same manner, and only have a rotationnal bias
|
|
* This is faster then other method. Any previous set scheme for 3d rotation is kept.
|
|
* \param: the number of rotation configuration we have. The more high it is, the slower it'll be
|
|
* If this is too low, a lot of particles will have the same orientation
|
|
* If it is 0, then the hint is disabled
|
|
* \param minAngularVelocity : the maximum angular velocity for particle rotation
|
|
* \param maxAngularVelocity : the maximum angular velocity for particle rotation
|
|
* \see CPSRotated3dPlaneParticle
|
|
*/
|
|
virtual void hintRotateTheSame(uint32 nbConfiguration
|
|
, float minAngularVelocity = NLMISC::Pi
|
|
, float maxAngularVelocity = NLMISC::Pi
|
|
) = 0;
|
|
|
|
/** disable the hint 'hintRotateTheSame'
|
|
* The previous set scheme for roation is used
|
|
* \see hintRotateTheSame(), CPSRotated3dPlaneParticle
|
|
*/
|
|
virtual void disableHintRotateTheSame(void) = 0;
|
|
|
|
|
|
/** check whether a call to hintRotateTheSame was performed
|
|
* \return 0 if the hint is disabled, the number of configurations else
|
|
* \see hintRotateTheSame(), CPSRotated3dPlaneParticle
|
|
*/
|
|
virtual uint32 checkHintRotateTheSame(float &minAngularVelocity, float &maxAngularVelocity) const = 0;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// base struct for particle that have a tail
|
|
struct CPSTailParticle
|
|
{
|
|
virtual ~CPSTailParticle() {}
|
|
|
|
/** (de)activate color fading
|
|
* when its done, colors fades to black along the tail
|
|
*/
|
|
virtual void setColorFading(bool onOff = true) = 0;
|
|
|
|
/// test whether color fading is activated
|
|
virtual bool getColorFading(void) const = 0;
|
|
|
|
|
|
/// there may be a maximum with some particles
|
|
virtual void setTailNbSeg(uint32 nbSeg) = 0;
|
|
|
|
// get the number of segments in the tail
|
|
virtual uint32 getTailNbSeg(void) const = 0;
|
|
|
|
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// base struct for particles that can have a shape (e.g mesh...)
|
|
struct CPSShapeParticle
|
|
{
|
|
virtual ~CPSShapeParticle() {}
|
|
|
|
/// set a new shape
|
|
virtual void setShape(const std::string &shape) = 0;
|
|
|
|
/// get the shape used for those particles
|
|
virtual std::string getShape(void) const = 0;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/** this contains material of a particle, this doesn't initiliaze anything, this just give the abylity to
|
|
* change the blending mode
|
|
*/
|
|
class CPSMaterial
|
|
{
|
|
public:
|
|
/// ctor : the default is additive blending
|
|
CPSMaterial();
|
|
|
|
/// this enum summarize the useful modes for blending to the framebuffer
|
|
enum TBlendingMode { add, modulate, alphaBlend, alphaTest };
|
|
|
|
/// serialization (not named 'serial' because it will be used via multiple-inheritance)
|
|
void serialMaterial(NLMISC::IStream &f) throw(NLMISC::EStream);
|
|
|
|
/// set the blending mode. The default is ass
|
|
void setBlendingMode(CPSMaterial::TBlendingMode mode);
|
|
|
|
/// return the blending mode currently used
|
|
CPSMaterial::TBlendingMode getBlendingMode(void) const;
|
|
|
|
|
|
/** Force the material to have one texture that is modulated by diffuse, and a constant color
|
|
* and its diffuse color. This is not compatible with multitextureing, however.
|
|
* \param force true to force constant color modulation
|
|
*/
|
|
void forceModulateConstantColor(bool force, const NLMISC::CRGBA &col = NLMISC::CRGBA::White);
|
|
|
|
/** This setup n stage of a material with at least texture.
|
|
* - If a texture was present for a given stage it still is
|
|
* - If a texture wasn't present, it create a dummy white texture there
|
|
* - Above numStages, textures are disabled.
|
|
* It can be used to do extra math with stages that have no textures (required by the driver)
|
|
*/
|
|
void forceTexturedMaterialStages(uint numStages);
|
|
|
|
// enable / disable z-test (default is enabled)
|
|
void enableZTest(bool enabled);
|
|
// test if z test is enabled
|
|
bool isZTestEnabled() const;
|
|
|
|
// set z-bias
|
|
void setZBias(float value) { _Mat.setZBias(value); }
|
|
float getZBias() const { return _Mat.getZBias(); }
|
|
|
|
|
|
|
|
protected:
|
|
CMaterial _Mat;
|
|
};
|
|
|
|
|
|
//==========================================================================
|
|
/// setup a stage as modulate, by specifying the source and destination
|
|
inline void SetupModulatedStage(CMaterial &m, uint stage, CMaterial::TTexSource src1, CMaterial::TTexSource src2)
|
|
{
|
|
m.texEnvOpRGB(stage, CMaterial::Modulate);
|
|
m.texEnvOpAlpha(stage, CMaterial::Modulate);
|
|
m.texEnvArg0RGB(stage, src1, CMaterial::SrcColor);
|
|
m.texEnvArg1RGB(stage, src2, CMaterial::SrcColor);
|
|
m.texEnvArg0Alpha(stage, src1, CMaterial::SrcAlpha);
|
|
m.texEnvArg1Alpha(stage, src2, CMaterial::SrcAlpha);
|
|
}
|
|
|
|
|
|
|
|
|
|
} // NL3D
|
|
|
|
|
|
#endif // NL_PS_PARTICLE_BASIC_H
|
|
|
|
/* End of ps_particle_basic.h */
|