SLParticleSystem Class Reference

SLParticleSystem creates a particle meshes from a point primitive buffer. More...

#include <SLParticleSystem.h>

Inheritance diagram for SLParticleSystem:

Public Member Functions
	SLParticleSystem (SLAssetManager *assetMgr, const SLint amount, const SLVec3f &velocityRandomStart, const SLVec3f &velocityRandomEnd, const SLfloat &timeToLive, SLGLTexture *texC, const SLstring &name="Particle System", SLGLTexture *texFlipbook=nullptr, SLTexColorLUT *texGradient=nullptr, const bool doInstancedDrawing=false)
	SLParticleSystem ctor with some initial values. The number of particles. More...
void	draw (SLSceneView *sv, SLNode *node, SLuint instances=1)
void	buildAABB (SLAABBox &aabb, const SLMat4f &wmNode)
void	generate ()
	Function which will generate the particles and attributes them to the VAO. More...
void	generateBernsteinPAlpha ()
void	generateBernsteinPSize ()
void	changeTexture ()
void	setNotVisibleInFrustum ()
void	pauseOrResume ()
void	calcNormals ()
	SLMesh::calcNormals recalculates vertex normals for triangle meshes. More...
SLVec3f	acceleration ()
SLfloat	accelerationConst ()
SLint	amount ()
SLfloat	angularVelocityConst ()
SLVec2f	angularVelocityRange ()
float *	bezierControlPointAlpha ()
float *	bezierStartEndPointAlpha ()
float *	bezierControlPointSize ()
float *	bezierStartEndPointSize ()
SLBillboardType	billboardType ()
SLCol4f	color ()
SLbool	doInstancedDrawing ()
SLbool	doAcc ()
SLbool	doAccDiffDir ()
SLbool	doAlphaOverLT ()
SLbool	doAlphaOverLTCurve ()
SLbool	doBlendBrightness ()
SLbool	doCounterGap ()
SLbool	doColor ()
SLbool	doColorOverLT ()
SLbool	doDirectionSpeed ()
SLbool	doGravity ()
SLbool	doFlipBookTexture ()
SLbool	doRotation ()
SLbool	doRotRange ()
SLbool	doSizeOverLT ()
SLbool	doSizeOverLTCurve ()
SLbool	doShape ()
SLbool	doShapeSurface ()
SLbool	doShapeOverride ()
SLbool	doShapeSpawnBase ()
SLbool	doSpeedRange ()
SLbool	doWorldSpace ()
SLVec3f	direction ()
AvgFloat &	drawTime ()
SLVec3f	emitterPos () const
SLVec3f	gravity ()
SLint	flipbookColumns ()
SLint	flipbookRows ()
int	frameRateFB ()
SLbool	isGenerated ()
SLbool	isPaused ()
SLfloat	radiusW ()
SLfloat	radiusH ()
SLfloat	scale ()
SLShapeType	shapeType ()
SLfloat	shapeAngle ()
SLfloat	shapeHeight ()
SLfloat	shapeRadius ()
SLVec3f	shapeScale ()
SLfloat	shapeWidth ()
SLfloat	speed ()
SLVec2f	speedRange ()
SLGLTexture *	texParticle ()
SLGLTexture *	texFlipbook ()
SLTexColorLUT *	texGradient ()
SLfloat	timeToLive ()
AvgFloat &	updateTime ()
SLint	velocityType ()
SLVec3f	velocityConst ()
SLVec3f	velocityRndMin ()
SLVec3f	velocityRndMax ()
void	doInstancedDrawing (bool instanced)
void	amount (SLint i)
void	accConst (SLfloat f)
void	acceleration (SLVec3f v)
void	acceleration (SLfloat vX, SLfloat vY, SLfloat vZ)
void	angularVelocityConst (SLfloat f)
void	angularVelocityRange (SLVec2f v)
void	angularVelocityRange (SLfloat vX, SLfloat vY)
void	billboardType (SLBillboardType bt)
void	bezierControlPointAlpha (float arrayPoint[4])
void	bezierStartEndPointAlpha (float arrayPoint[4])
void	bezierControlPointSize (float arrayPoint[4])
void	bezierStartEndPointSize (float arrayPoint[4])
void	color (SLCol4f c)
void	direction (SLVec3f v)
void	direction (SLfloat vX, SLfloat vY, SLfloat vZ)
void	doAcceleration (SLbool b)
void	doAlphaOverLT (SLbool b)
void	doAlphaOverLTCurve (SLbool b)
void	doAccDiffDir (SLbool b)
void	doBlendBrightness (SLbool b)
void	doColor (SLbool b)
void	doColorOverLT (SLbool b)
void	doCounterGap (SLbool b)
void	doDirectionSpeed (SLbool b)
void	doGravity (SLbool b)
void	doFlipBookTexture (SLbool b)
void	doRotation (SLbool b)
void	doRotRange (SLbool b)
void	doSpeedRange (SLbool b)
void	doShape (SLbool b)
void	doShapeSurface (SLbool b)
void	doShapeOverride (SLbool b)
void	doShapeSpawnBase (SLbool b)
void	doSizeOverLT (SLbool b)
void	doSizeOverLTCurve (SLbool b)
void	doWorldSpace (SLbool b)
void	emitterPos (SLVec3f p)
void	gravity (SLVec3f v)
void	gravity (SLfloat vX, SLfloat vY, SLfloat vZ)
void	flipbookColumns (SLint i)
void	flipbookRows (SLint i)
void	frameRateFB (int i)
void	isGenerated (SLbool b)
void	radiusW (SLfloat f)
void	radiusH (SLfloat f)
void	scale (SLfloat f)
void	speed (SLfloat f)
void	speedRange (SLVec2f v)
void	speedRange (SLfloat vX, SLfloat vY)
void	shapeType (SLShapeType st)
void	shapeAngle (SLfloat f)
void	shapeRadius (SLfloat r)
void	shapeScale (SLVec3f v)
void	shapeScale (SLfloat vX, SLfloat vY, SLfloat vZ)
void	shapeHeight (SLfloat f)
void	shapeWidth (SLfloat f)
void	timeToLive (SLfloat f)
void	texParticle (SLGLTexture *tp)
void	texFlipbook (SLGLTexture *tf)
void	texGradient (SLTexColorLUT *tg)
void	velocityType (SLint i)
void	velocityConst (SLVec3f v)
void	velocityConst (SLfloat vX, SLfloat vY, SLfloat vZ)
void	velocityRndMin (SLVec3f v)
void	velocityRndMin (SLfloat vX, SLfloat vY, SLfloat vZ)
void	velocityRndMax (SLVec3f v)
void	velocityRndMax (SLfloat vX, SLfloat vY, SLfloat vZ)
Public Member Functions inherited from SLMesh
	SLMesh (SLAssetManager *assetMgr, const SLstring &name="Mesh")
	Construct a new SLMesh::SLMesh object. More...
	~SLMesh () override
	The destructor deletes everything by calling deleteData. More...
virtual void	init (SLNode *node)
	SLMesh::shapeInit sets the transparency flag of the AABB. More...
void	drawIntoDepthBuffer (SLSceneView *sv, SLNode *node, SLMaterial *depthMat)
	Simplified drawing method for shadow map creation. More...
void	addStats (SLNodeStats &stats)
void	updateAccelStruct ()
SLbool	hit (SLRay *ray, SLNode *node)
virtual void	preShade (SLRay *ray)
virtual void	deleteData ()
	SLMesh::deleteData deletes all mesh data and vbo's. More...
virtual void	deleteDataGpu ()
void	deleteSelected (SLNode *node)
	Deletes the rectangle selected vertices and the dependent triangles. More...
void	deleteUnused ()
	Deletes unused vertices (= vertices that are not indexed in I16 or I32) More...
virtual void	calcMinMax ()
void	calcCenterRad (SLVec3f &center, SLfloat &radius)
SLbool	hitTriangleOS (SLRay *ray, SLNode *node, SLuint iT)
virtual void	generateVAO (SLGLVertexArray &vao)
	Generate the Vertex Array Object for a specific shader program. More...
void	computeHardEdgesIndices (float angleRAD, float epsilon)
	computes the hard edges and stores the vertex indexes separately More...
void	transformSkin (bool forceCPUSkinning, const std::function< void(SLMesh *)> &cbInformNodes)
	Transforms the vertex positions and normals with by joint weights. More...
void	deselectPartialSelection ()
SLMaterial *	mat () const
SLMaterial *	matOut () const
SLGLPrimitiveType	primitive () const
const SLAnimSkeleton *	skeleton () const
SLuint	numI () const
SLGLVertexArray &	vao ()
SLbool	isSelected () const
SLfloat	edgeAngleDEG () const
SLfloat	edgeWidth () const
SLCol4f	edgeColor () const
SLVec3f	finalP (SLuint i)
SLVec3f	finalN (SLuint i)
SLbool	accelStructIsOutOfDate ()
void	mat (SLMaterial *m)
void	matOut (SLMaterial *m)
void	primitive (SLGLPrimitiveType pt)
void	skeleton (SLAnimSkeleton *skel)
void	isSelected (bool isSelected)
void	edgeWidth (SLfloat ew)
void	edgeAngleDEG (SLfloat ea)
void	edgeColor (const SLCol4f &ec)
void	vertexPosEpsilon (SLfloat eps)
Public Member Functions inherited from SLObject
	SLObject (const SLstring &Name="", const SLstring &url="")
virtual	~SLObject ()
void	name (const SLstring &Name)
void	url (const SLstring &url)
const SLstring &	name () const
const SLstring &	url () const

Private Member Functions
SLVec3f	getPointInSphere (float radius, SLVec3f randomX)
	Function which return a position in a sphere. More...
SLVec3f	getPointOnSphere (float radius, SLVec3f randomX)
	Function which return a position on a sphere. More...
SLVec3f	getDirectionSphere (SLVec3f position)
	Function which return the direction towards the exterior of a sphere. More...
SLVec3f	getPointInBox (SLVec3f boxScale)
	Function which return a position in a box. More...
SLVec3f	getPointOnBox (SLVec3f boxScale)
	Function which return a position on a box. More...
SLVec3f	getDirectionBox (SLVec3f position)
	Function which return the direction towards the exterior of a box. More...
SLVec3f	getPointInCone ()
	Function which return a position in the cone define in the particle system. More...
SLVec3f	getPointOnCone ()
	Function which return a position on the cone define in the particle system. More...
SLVec3f	getDirectionCone (SLVec3f position)
	Function which return a direction following the cone shape. More...
SLVec3f	getPointInPyramid ()
	Function which returns a position in the pyramid that define the PS. More...
SLVec3f	getPointOnPyramid ()
	Function which return a position on the pyramid that defines the PS. More...
SLVec3f	getDirectionPyramid (SLVec3f position)
	Function which return a direction following the pyramid shape. More...

Private Attributes
SLAssetManager *	_assetManager
	pointer to the asset manager (the owner) if available More...
SLint	_amount
	Amount of a particle. More...
SLVec3f	_emitterPos
	Position of the particle emitter. More...
SLfloat	_timeToLive
	Time to live of a particle. More...
SLfloat	_radiusW = 0.4f
	width radius of a particle More...
SLfloat	_radiusH = 0.4f
	height radius of a particle More...
SLfloat	_scale = 1.0f
	Scale of a particle (Scale the radius) More...
SLVec4f	_bernsteinPYAlpha = SLVec4f(2.0f, -3.0f, 0.0f, 1.0f)
	Vector for bezier curve (default linear function) More...
float	_bezierControlPointAlpha [4] = {0.0f, 1.0f, 1.0f, 0.0f}
	Floats for bezier curve control points (P1: 01 ; P2: 23) More...
float	_bezierStartEndPointAlpha [4] = {0.0f, 1.0f, 1.0f, 0.0f}
	Floats for bezier curve end start points (Start: 01 ; End: 23) More...
SLVec4f	_bernsteinPYSize = SLVec4f(-1.4f, 1.8f, 0.6f, 0.0f)
	Vector for bezier curve (default linear function) More...
float	_bezierControlPointSize [4] = {0.0f, 0.0f, 1.0f, 1.0f}
	Floats for bezier curve control points (P1: 01 ; P2: 23) More...
float	_bezierStartEndPointSize [4] = {0.0f, 0.0f, 1.0f, 1.0f}
	Floats for bezier curve end start points (Start: 01 ; End: 23) More...
SLVec3f	_acceleration = SLVec3f(1, 1, 1)
	Vector for acceleration (different direction as the velocity) More...
SLfloat	_accelerationConst = 0.0f
	Acceleration constant (same direction as the velocity) More...
SLVec3f	_gravity = SLVec3f(0.0f, -9.81f, 0.0f)
	Vector for gravity (2nd. acceleration vector) More...
SLVec3f	_velocityConst = SLVec3f(0, 1, 0)
	Velocity constant (go in xyz direction) More...
SLVec3f	_velocityRndMin = SLVec3f(-1, -1, -1)
	Min. random velocity. More...
SLVec3f	_velocityRndMax = SLVec3f(1, 1, 1)
	Max. random velocity. More...
SLVec3f	_direction = SLVec3f(0, 0, 0)
	Direction of particle. More...
SLfloat	_speed = 1.0f
	Speed of particle. More...
SLVec2f	_speedRange = SLVec2f(1, 2)
	Speed random between two value. More...
SLCol4f	_color = SLCol4f(0.66f, 0.0f, 0.66f, 0.2f)
	Color for particle. More...
int	_drawBuf = 0
	Boolean to switch buffer. More...
int	_flipbookFPS = 16
	Number of update of flipbook by second. More...
float	_flipboookLastUpdate = 0.0f
	Last time flipbook was updated. More...
SLint	_flipbookColumns = 8
	Number of flipbook sub-textures by column. More...
SLint	_flipbookRows = 8
	Number of flipbook sub-textures by row. More...
AvgFloat	_updateTime
	Averaged time for updating in MS. More...
AvgFloat	_drawTime
	Averaged time for drawing in MS. More...
SLfloat	_startDrawTimeMS = 0.0f
	Time since start of draw in MS. More...
SLfloat	_startUpdateTimeMS = 0.0f
	Time since start for updating in MS. More...
SLfloat	_startUpdateTimeS = 0.0f
	Time since start for updating in S. More...
SLfloat	_deltaTimeUpdateS = 0.0f
	Delta time in between two frames S. More...
SLfloat	_notVisibleTimeS = 0.0f
	Time since start when node not visible in S. More...
SLfloat	_lastTimeBeforePauseS = 0.0f
	Time since the particle system is paused. More...
SLfloat	_shapeRadius = 1.0f
	Radius of sphere and cone shape. More...
SLVec3f	_shapeScale = SLVec3f(1.0f)
	Scale of box shape. More...
SLfloat	_shapeHeight = 3.0f
	Height of cone and pyramid shapes. More...
SLfloat	_shapeAngle = 10.0f
	Angle of cone and pyramid shapes. More...
SLfloat	_shapeWidth = 2.0f
	Width of pyramid shape. More...
SLfloat	_angularVelocityConst = 30.0f
	Rotation rate const (change in angular rotation divide by change in time) More...
SLVec2f	_angularVelocityRange = SLVec2f(-30.0f, 30.0f)
	Rotation rate range (change in angular rotation divide by change in time) More...
SLBillboardType	_billboardType = BT_Camera
	Billboard type (BT_Camera, BT_Vertical, BT_Horizontal. More...
SLShapeType	_shapeType = ST_Sphere
	Shape type (ST_) More...
SLint	_velocityType = 0
	Velocity type. More...
SLGLTexture *	_texParticle
	Main texture of PS (non flipbook) More...
SLGLTexture *	_texFlipbook
	Flipbook texture with e.g. multiple flames at subsequent frames. More...
SLTexColorLUT *	_texGradient
	Color gradient texture. More...
SLGLVertexArray	_vao1
SLGLVertexArray	_vao2
SLGLVertexArray	_instanceVao1
SLGLVertexArray	_instanceVao2
SLbool	_isVisibleInFrustum = true
	Boolean to set time since node not visible. More...
SLbool	_isPaused = false
	Boolean to stop updating. More...
SLbool	_isGenerated = false
	Boolean to generate particle system and load it on the GPU. More...
SLbool	_doBlendBrightness = false
	Boolean for glow/brightness on pixel with many particle. More...
SLbool	_doDirectionSpeed = false
	Boolean for direction and speed (override velocity) More...
SLbool	_doSpeedRange = false
	Boolean for speed range. More...
SLbool	_doCounterGap = true
	Boolean for counter lag/gap, can create flickering with few particle (explained in documentation) when enable. More...
SLbool	_doAcceleration = false
	Boolean for acceleration. More...
SLbool	_doAccDiffDir = false
	Boolean for acceleration (different direction) More...
SLbool	_doRotation = true
	Boolean for rotation. More...
SLbool	_doRotRange = false
	Boolean for rotation range (random value between range) More...
SLbool	_doColor = true
	Boolean for color. More...
SLbool	_doShape = false
	Boolean for shape feature. More...
SLbool	_doShapeSurface = false
	Boolean for shape surface (particle will be spawned on surface) More...
SLbool	_doShapeOverride = false
	Boolean for override direction for shape direction. More...
SLbool	_doShapeSpawnBase = false
	Boolean for spawn at base of shape (for cone and pyramid) More...
SLbool	_doWorldSpace = false
	Boolean for world space position. More...
SLbool	_doGravity = false
	Boolean for gravity. More...
SLbool	_doAlphaOverLT = true
	Boolean for alpha over life time. More...
SLbool	_doColorOverLT = false
	Boolean for color over life time. More...
SLbool	_doAlphaOverLTCurve = false
	Boolean for alpha over life time curve. More...
SLbool	_doSizeOverLT = true
	Boolean for size over life time. More...
SLbool	_doSizeOverLTCurve = false
	Boolean for size over life time curve. More...
SLbool	_doFlipBookTexture = false
	Boolean for flipbook texture. More...
SLbool	_doInstancedDrawing = false
	Boolean for instanced rendering. More...

Additional Inherited Members
Static Public Member Functions inherited from SLMesh
static void	calcTex3DMatrix (SLNode *node)
Public Attributes inherited from SLMesh
SLVVec3f	P
	Vector for vertex positions layout (location = 0) More...
SLVVec3f	N
	Vector for vertex normals (opt.) layout (location = 1) More...
SLVVec2f	UV [2]
	Array of 2 Vectors for tex. coords. (opt.) layout (location = 2) More...
SLVCol4f	C
	Vector of vertex colors (opt.) layout (location = 4) More...
SLVVec4f	T
	Vector of vertex tangents (opt.) layout (location = 5) More...
SLVVuchar	Ji
	2D Vector of per vertex joint ids (opt.) layout (location = 6) More...
SLVVfloat	Jw
	2D Vector of per vertex joint weights (opt.) layout (location = 7) More...
SLVVec3f	skinnedP
	temp. vector for CPU skinned vertex positions More...
SLVVec3f	skinnedN
	temp. vector for CPU skinned vertex normals More...
SLVushort	I16
	Vector of vertex indices 16 bit. More...
SLVuint	I32
	Vector of vertex indices 32 bit. More...
SLVuint	IS32
	Vector of rectangle selected vertex indices 32 bit. More...
SLVushort	IE16
	Vector of hard edges vertex indices 16 bit (see computeHardEdgesIndices) More...
SLVuint	IE32
	Vector of hard edges vertex indices 32 bit (see computeHardEdgesIndices) More...
SLVec3f	minP
	min. vertex in OS More...
SLVec3f	maxP
	max. vertex in OS More...
Protected Attributes inherited from SLMesh
SLGLPrimitiveType	_primitive
	Primitive type (default triangles) More...
SLMaterial *	_mat
	Pointer to the inside material. More...
SLMaterial *	_matOut
	Pointer to the outside material. More...
SLGLVertexArray	_vao
	Main OpenGL Vertex Array Object for drawing. More...
SLGLVertexArrayExt	_vaoN
	OpenGL VAO for optional normal drawing. More...
SLGLVertexArrayExt	_vaoT
	OpenGL VAO for optional tangent drawing. More...
SLGLVertexArrayExt	_vaoS
	OpenGL VAO for optional selection drawing. More...
SLbool	_isSelected
	Flag if mesh is partially of fully selected. More...
SLfloat	_edgeAngleDEG
	Edge crease angle in degrees between face normals (30 deg. default) More...
SLfloat	_edgeWidth
	Line width for hard edge drawing. More...
SLCol4f	_edgeColor
	Color for hard edge drawing. More...
SLfloat	_vertexPosEpsilon
	Vertex position epsilon used in computeHardEdgesIndices. More...
SLbool	_isVolume
	Flag for RT if mesh is a closed volume. More...
SLAccelStruct *	_accelStruct
	KD-tree or uniform grid. More...
SLbool	_accelStructIsOutOfDate
	Flag if accel. struct needs update. More...
SLAnimSkeleton *	_skeleton
	The skeleton this mesh is bound to. More...
SLVMat4f	_jointMatrices
	Joint matrix vector for this mesh. More...
SLbool	_isCPUSkinned
	Flag if mesh has been skinned on CPU during update. More...
SLVVec3f *	_finalP
	Pointer to final vertex position vector. More...
SLVVec3f *	_finalN
	pointer to final vertex normal vector More...
Protected Attributes inherited from SLObject
SLstring	_name
	name of an object More...
SLstring	_url
	uniform resource locator More...

Detailed Description

SLParticleSystem creates a particle meshes from a point primitive buffer.

The SLParticleSystem mesh object of which the vertices are drawn as points. An OpenGL transform feedback buffer is used to update the particle positions on the GPU and a geometry shader is used the create two triangles per particle vertex and orient them as a billboard to the viewer. Geometry shaders are only supported under OpenGL >= 4.0 and OpenGLES >= 3.2. This is the case on most desktop systems and on Android SDK > 24 but not on iOS which has only OpenGL ES 3.0
. For all systems that don't support geometry shaders we use an alternative with instanced drawing (mainly for iOS and Emscripten with WebGL)
. The particle system supports many options of which many can be turned on the do* methods. All options can also be modified in the UI when the mesh is selected. See the different demo scenes in the app_demo_slproject under the demo scene group Particle Systems.

Remarks

It is important that during instantiation NO OpenGL functions (gl*) get called because this constructor will be most probably called in a parallel thread from within an SLScene::registerAssetsToLoad or SLScene::assemble function. All objects that get rendered have to do their OpenGL initialization when they are used the first time during rendering in the main thread. For this mesh it means that the objects for OpenGL drawing (_vao, _vaoP, _vaoN, _vaoT and _vaoS) remain unused until the first frame is rendered.

Definition at line 43 of file SLParticleSystem.h.

Constructor & Destructor Documentation

SLParticleSystem()

SLParticleSystem::SLParticleSystem	(	SLAssetManager *	assetMgr,
		const SLint	amount,
		const SLVec3f &	velocityRandomStart,
		const SLVec3f &	velocityRandomEnd,
		const SLfloat &	timeToLive,
		SLGLTexture *	texC,
		const SLstring &	name = "Particle System",
		SLGLTexture *	texFlipbook = nullptr,
		SLTexColorLUT *	texGradient = nullptr,
		const bool	doInstancedDrawing = false
	)

SLParticleSystem ctor with some initial values. The number of particles.

The particle emitter position, the start and end random value range The time to live of the particle (lifetime). A texture, a name and a flipbook texture.

Definition at line 25 of file SLParticleSystem.cpp.

                                                                       : SLMesh(assetMgr, name)
{
    assert(!name.empty());
 
    _assetManager       = assetMgr;
    _doInstancedDrawing = !SLGLState::instance()->glHasGeometryShaders() || doInstancedDrawing;
    _primitive          = PT_points;
 
    // Trick SL project because it wants the mesh to have vertex
    P.push_back(SLVec3f(0, 0, 0));
    I32.push_back(0);
 
    if (amount > UINT_MAX) // Need to change for number of floats
        SL_EXIT_MSG("SLParticleSystem supports max. 2^32 vertices.");
 
    _timeToLive     = timeToLive;
    _amount         = amount;
    _velocityRndMin = velocityRandomStart;
    _velocityRndMax = velocityRandomEnd;
 
    _texParticle = texC;
    _texFlipbook = texFlipbook;
    if (texGradient)
        _texGradient = texGradient;
    else
        _texGradient = new SLTexColorLUT(assetMgr, CLUT_WYR, 256);
 
    _updateTime.init(60, 0.0f);
    _drawTime.init(60, 0.0f);
}

Member Function Documentation

accConst()

void SLParticleSystem::accConst ( SLfloat  f )

inline

Definition at line 136 of file SLParticleSystem.h.

{ _accelerationConst = f; }

acceleration() [1/3]

SLVec3f SLParticleSystem::acceleration ( )

inline

Definition at line 68 of file SLParticleSystem.h.

{ return _acceleration; }

acceleration() [2/3]

void SLParticleSystem::acceleration ( SLfloat  vX, SLfloat  vY, SLfloat  vZ  )

inline

Definition at line 138 of file SLParticleSystem.h.

    {
        _acceleration.x = vX;
        _acceleration.y = vY;
        _acceleration.z = vZ;
    }

acceleration() [3/3]

void SLParticleSystem::acceleration ( SLVec3f  v )

inline

Definition at line 137 of file SLParticleSystem.h.

{ _acceleration = v; }

accelerationConst()

SLfloat SLParticleSystem::accelerationConst ( )

inline

Definition at line 69 of file SLParticleSystem.h.

{ return _accelerationConst; }

amount() [1/2]

SLint SLParticleSystem::amount ( )

inline

Definition at line 70 of file SLParticleSystem.h.

{ return _amount; }

amount() [2/2]

void SLParticleSystem::amount ( SLint  i )

inline

Definition at line 135 of file SLParticleSystem.h.

{ _amount = i; }

angularVelocityConst() [1/2]

SLfloat SLParticleSystem::angularVelocityConst ( )

inline

Definition at line 71 of file SLParticleSystem.h.

{ return _angularVelocityConst; }

angularVelocityConst() [2/2]

void SLParticleSystem::angularVelocityConst ( SLfloat  f )

inline

Definition at line 144 of file SLParticleSystem.h.

{ _angularVelocityConst = f; }

angularVelocityRange() [1/3]

SLVec2f SLParticleSystem::angularVelocityRange ( )

inline

Definition at line 72 of file SLParticleSystem.h.

{ return _angularVelocityRange; }

angularVelocityRange() [2/3]

void SLParticleSystem::angularVelocityRange ( SLfloat  vX, SLfloat  vY  )

inline

Definition at line 146 of file SLParticleSystem.h.

    {
        _angularVelocityRange.x = vX;
        _angularVelocityRange.y = vY;
    }

angularVelocityRange() [3/3]

void SLParticleSystem::angularVelocityRange ( SLVec2f  v )

inline

Definition at line 145 of file SLParticleSystem.h.

{ _angularVelocityRange = v; }

bezierControlPointAlpha() [1/2]

float* SLParticleSystem::bezierControlPointAlpha ( )

inline

Definition at line 73 of file SLParticleSystem.h.

{ return _bezierControlPointAlpha; }

bezierControlPointAlpha() [2/2]

void SLParticleSystem::bezierControlPointAlpha ( float  arrayPoint[4] )

inline

Definition at line 152 of file SLParticleSystem.h.

    {
        _bezierControlPointAlpha[0] = arrayPoint[0];
        _bezierControlPointAlpha[1] = arrayPoint[1];
        _bezierControlPointAlpha[2] = arrayPoint[2];
        _bezierControlPointAlpha[3] = arrayPoint[3];
    }

bezierControlPointSize() [1/2]

float* SLParticleSystem::bezierControlPointSize ( )

inline

Definition at line 75 of file SLParticleSystem.h.

{ return _bezierControlPointSize; }

bezierControlPointSize() [2/2]

void SLParticleSystem::bezierControlPointSize ( float  arrayPoint[4] )

inline

Definition at line 166 of file SLParticleSystem.h.

    {
        _bezierControlPointSize[0] = arrayPoint[0];
        _bezierControlPointSize[1] = arrayPoint[1];
        _bezierControlPointSize[2] = arrayPoint[2];
        _bezierControlPointSize[3] = arrayPoint[3];
    }

bezierStartEndPointAlpha() [1/2]

float* SLParticleSystem::bezierStartEndPointAlpha ( )

inline

Definition at line 74 of file SLParticleSystem.h.

{ return _bezierStartEndPointAlpha; }

bezierStartEndPointAlpha() [2/2]

void SLParticleSystem::bezierStartEndPointAlpha ( float  arrayPoint[4] )

inline

Definition at line 159 of file SLParticleSystem.h.

    {
        _bezierStartEndPointAlpha[0] = arrayPoint[0];
        _bezierStartEndPointAlpha[1] = arrayPoint[1];
        _bezierStartEndPointAlpha[2] = arrayPoint[2];
        _bezierStartEndPointAlpha[3] = arrayPoint[3];
    }

bezierStartEndPointSize() [1/2]

float* SLParticleSystem::bezierStartEndPointSize ( )

inline

Definition at line 76 of file SLParticleSystem.h.

{ return _bezierStartEndPointSize; }

bezierStartEndPointSize() [2/2]

void SLParticleSystem::bezierStartEndPointSize ( float  arrayPoint[4] )

inline

Definition at line 173 of file SLParticleSystem.h.

    {
        _bezierStartEndPointSize[0] = arrayPoint[0];
        _bezierStartEndPointSize[1] = arrayPoint[1];
        _bezierStartEndPointSize[2] = arrayPoint[2];
        _bezierStartEndPointSize[3] = arrayPoint[3];
    }

billboardType() [1/2]

SLBillboardType SLParticleSystem::billboardType ( )

inline

Definition at line 77 of file SLParticleSystem.h.

{ return _billboardType; }

billboardType() [2/2]

void SLParticleSystem::billboardType ( SLBillboardType  bt )

inline

Definition at line 151 of file SLParticleSystem.h.

{ _billboardType = bt; }

buildAABB()

void SLParticleSystem::buildAABB ( SLAABBox &  aabb, const SLMat4f &  wmNode  )

virtual

SLParticleSystem::buildAABB builds the passed axis-aligned bounding box in OS and updates the min & max points in WS with the passed WM of the node. Take into account features like acceleration, gravity, shape, velocity. SLMesh::buildAABB builds the passed axis-aligned bounding box in OS and updates the min& max points in WS with the passed WM of the node. Todo: Can ben enhance furthermore the acceleration doesn't work well for the moment. The negative value for the acceleration are not take into account and also acceleration which goes against the velocity. To adapt the acceleration to exactly the same as the gravity not enough time to do it. Need to adapt more accurately when direction speed is negative (for shape override example with Cone)

Reimplemented from SLMesh.

Definition at line 997 of file SLParticleSystem.cpp.

{
    // Radius of particle
    float rW = _radiusW * _scale;
    float rH = _radiusH * _scale;
 
    // Speed for direction if used
    float tempSpeed = _doSpeedRange ? max(_speedRange.x, _speedRange.y) : _speed;
 
    // Empty point
    minP = SLVec3f();
    maxP = SLVec3f();
 
    // Empty velocity
    SLVec3f minV = SLVec3f();
    SLVec3f maxV = SLVec3f();
 
    // Shape
    if (_doShape)
    {
        if (_shapeType == ST_Sphere)
        {
            float radius = cbrt(_shapeRadius);
            minP         = SLVec3f(-radius, -radius, -radius);
            maxP         = SLVec3f(radius, radius, radius);
            // Override direction
            if (_doDirectionSpeed && _doShapeOverride)
            {
                minV += SLVec3f(-radius, -radius, -radius) * tempSpeed;
                maxV += SLVec3f(radius, radius, radius) * tempSpeed;
            }
        }
        else if (_shapeType == ST_Box)
        {
            minP = SLVec3f(-_shapeScale.x, -_shapeScale.y, -_shapeScale.z);
            maxP = _shapeScale;
            if (_doDirectionSpeed && _doShapeOverride)
            {
                minV += SLVec3f(-_shapeScale.x, -_shapeScale.y, -_shapeScale.z) * tempSpeed;
                maxV += _shapeScale * tempSpeed;
            }
        }
        else if (_shapeType == ST_Cone)
        {
            float radius = _shapeRadius + tan(_shapeAngle * DEG2RAD) * _shapeHeight;
            minP         = SLVec3f(-radius, -0.0, -radius);
            if (!_doShapeSpawnBase) // Spawn inside volume
                maxP = SLVec3f(radius, _shapeHeight, radius);
            else // Spawn base volume
                maxP = SLVec3f(radius, 0.0f, radius);
            if (_doDirectionSpeed && _doShapeOverride)
            {
                SLVec3f temp = getDirectionCone(SLVec3f(-radius, -0.0, -radius)) * tempSpeed;
                temp.y       = 0.0;
                minV += temp;
                maxV += getDirectionCone(SLVec3f(radius, _shapeHeight, radius)) * tempSpeed;
            }
        }
        else if (_shapeType == ST_Pyramid)
        {
            float radius = _shapeWidth + tan(_shapeAngle * DEG2RAD) * _shapeHeight;
            minP         = SLVec3f(-radius, -0.0, -radius);
            if (!_doShapeSpawnBase) // Spawn inside volume
                maxP = SLVec3f(radius, _shapeHeight, radius);
            else // Spawn base volume
                maxP = SLVec3f(radius, 0.0f, radius);
 
            if (_doDirectionSpeed && _doShapeOverride)
            {
                SLVec3f temp = getDirectionPyramid(SLVec3f(-radius, -0.0, -radius)) * tempSpeed;
                temp.y       = 0.0;
                minV += temp;
                maxV += getDirectionPyramid(SLVec3f(radius, _shapeHeight, radius)) * tempSpeed;
            }
        }
    }
 
    if (_doAcceleration || _doGravity) // If acceleration or gravity is enabled
    {
        if (!_doDirectionSpeed) // If direction is not enable
        {
            if (_velocityType == 0)
            {
                SLVec3f minVTemp = SLVec3f(min(_velocityRndMax.x, _velocityRndMin.x),
                                           min(_velocityRndMax.y, _velocityRndMin.y),
                                           min(_velocityRndMax.z, _velocityRndMin.z)); // Apply velocity distance after time
                SLVec3f maxVTemp = SLVec3f(max(_velocityRndMax.x, _velocityRndMin.x),
                                           max(_velocityRndMax.y, _velocityRndMin.y),
                                           max(_velocityRndMax.z, _velocityRndMin.z)); // Apply velocity distance after time
 
                if (minVTemp.x > 0 && maxVTemp.x > 0) minVTemp.x = 0.0;
                if (minVTemp.y > 0 && maxVTemp.y > 0) minVTemp.y = 0.0;
                if (minVTemp.z > 0 && maxVTemp.z > 0) minVTemp.z = 0.0;
 
                if (minVTemp.x < 0 && maxVTemp.x < 0) maxVTemp.x = 0.0;
                if (minVTemp.y < 0 && maxVTemp.y < 0) maxVTemp.y = 0.0;
                if (minVTemp.z < 0 && maxVTemp.z < 0) maxVTemp.z = 0.0;
 
                minV += minVTemp;
                maxV += maxVTemp;
            }
            else // Constant acceleration
            {
                minV = SLVec3f(_velocityConst.x, 0.0, 0.0);
                maxV = SLVec3f(0.0, _velocityConst.y, _velocityConst.z);
            }
        }
        // Direction and speed, but no shape override, because I want a constant direction in one way I don't want the direction to be overridden
        else if (_doDirectionSpeed && !_doShapeOverride)
        {
            if (_doSpeedRange)
                tempSpeed = max(_speedRange.x, _speedRange.y);
            else
                tempSpeed = _speed;
 
            minV = SLVec3f(_direction.x, 0.0, 0.0) * tempSpeed;
            maxV = SLVec3f(0.0, _direction.y, _direction.z) * tempSpeed;
            if (_direction.x > 0.0)
            {
                maxV.x = minV.x;
                minV.x = 0.0;
            }
            if (_direction.y < 0.0)
            {
                minV.y = maxV.y;
                maxV.y = 0.0;
            }
            if (_direction.z < 0.0)
            {
                minV.z = maxV.z;
                maxV.z = 0.0;
            }
        }
 
        // Apply time to velocity
        minP += minV * _timeToLive;
        maxP += maxV * _timeToLive;
 
        // GRAVITY
        if (_doGravity)
        {
            float timeForXGrav = 0.0f;
            float timeForYGrav = 0.0f;
            float timeForZGrav = 0.0f;
            // Time to have a velocity of 0
            if (_gravity.x != 0.0f) timeForXGrav = maxV.x / _gravity.x;
            if (_gravity.y != 0.0f) timeForYGrav = maxV.y / _gravity.y;
            if (_gravity.z != 0.0f) timeForZGrav = maxV.z / _gravity.z;
 
            if (timeForXGrav < 0.0f)                             // If the gravity go against the velocity
                maxP.x -= maxV.x * (_timeToLive + timeForXGrav); // I remove the position  with the velocity that it will not do because it go against the velocity (becareful! here timeForXGrav is negative)
            else if (timeForXGrav > 0.0f)                        // If the gravity go with the velocity
                maxP.x += 0.5f * _gravity.x * (_timeToLive * _timeToLive);
            if (timeForYGrav < 0.0f) // If the gravity go against the velocity
                maxP.y -= maxV.y * (_timeToLive + timeForYGrav);
            else if (timeForYGrav > 0.0f) // If the gravity go with the velocity
                maxP.y += 0.5f * _gravity.y * (_timeToLive * _timeToLive);
            if (timeForZGrav < 0.0f) // If the gravity go against the velocity
                maxP.z -= maxV.z * (_timeToLive + timeForZGrav);
            else if (timeForZGrav > 0.0f) // If the gravity go with the velocity
                maxP.z += 0.5f * _gravity.z * (_timeToLive * _timeToLive);
 
            // Time remaining after the gravity has nullified the velocity for the particle to die (for each axes)
            float xTimeRemaining = _timeToLive - abs(timeForXGrav);
            float yTimeRemaining = _timeToLive - abs(timeForYGrav);
            float zTimeRemaining = _timeToLive - abs(timeForZGrav);
 
            if (timeForXGrav < 0.0f)                                             // If the gravity go against the velocity
                minP.x += 0.5f * _gravity.x * (xTimeRemaining * xTimeRemaining); // We move down pour min point (becareful! here gravity is negative)
            if (timeForYGrav < 0.0f)
                minP.y += 0.5f * _gravity.y * (yTimeRemaining * yTimeRemaining);
            if (timeForZGrav < 0.0f)
                minP.z += 0.5f * _gravity.z * (zTimeRemaining * zTimeRemaining);
        }
 
        // ACCELERATION (Need to rework to work like gravity)
        if (_doAcceleration && _doAccDiffDir) // Need to be rework ( for negative value)
        {
            maxP += 0.5f * _acceleration * (_timeToLive * _timeToLive); // Apply acceleration after time
        }
        else if (_doAcceleration && !_doAccDiffDir) // Need to be rework
        {
            // minP += 0.5f * _accelerationConst * (_timeToLive * _timeToLive); //Apply constant acceleration
            maxP += 0.5f * _accelerationConst * maxV * (_timeToLive * _timeToLive); // Apply constant acceleration //Not good
        }
    }
    else // If acceleration and gravity is not enable
    {
        if (!_doDirectionSpeed)
        {
            if (_velocityType == 0)
            {
                SLVec3f minVTemp = SLVec3f(min(_velocityRndMax.x, _velocityRndMin.x), min(_velocityRndMax.y, _velocityRndMin.y), min(_velocityRndMax.z, _velocityRndMin.z)); // Apply velocity distance after time
                SLVec3f maxVTemp = SLVec3f(max(_velocityRndMax.x, _velocityRndMin.x), max(_velocityRndMax.y, _velocityRndMin.y), max(_velocityRndMax.z, _velocityRndMin.z)); // Apply velocity distance after time
 
                if (minVTemp.x > 0 && maxVTemp.x > 0) minVTemp.x = 0.0;
                if (minVTemp.y > 0 && maxVTemp.y > 0) minVTemp.y = 0.0;
                if (minVTemp.z > 0 && maxVTemp.z > 0) minVTemp.z = 0.0;
 
                if (minVTemp.x < 0 && maxVTemp.x < 0) maxVTemp.x = 0.0;
                if (minVTemp.y < 0 && maxVTemp.y < 0) maxVTemp.y = 0.0;
                if (minVTemp.z < 0 && maxVTemp.z < 0) maxVTemp.z = 0.0;
 
                minV += minVTemp;
                maxV += maxVTemp;
            }
            else
            {
                minV += SLVec3f(_velocityConst.x, 0.0, _velocityConst.z); // Apply velocity distance after time
                maxV += SLVec3f(0.0, _velocityConst.y, 0.0);              // Apply velocity distance after time
            }
        }
        else if (_doDirectionSpeed && !_doShapeOverride)
        {
            tempSpeed = 0.0f;
            if (_doSpeedRange)
                tempSpeed = Utils::random(_speedRange.x, _speedRange.y);
            else
                tempSpeed = _speed;
 
            minV += SLVec3f(_direction.x, 0.0, 0.0) * tempSpeed;
            maxV += SLVec3f(0.0, _direction.y, _direction.z) * tempSpeed;
 
            if (_direction.x > 0.0)
            {
                maxV.x = minV.x;
                minV.x = 0.0;
            }
            if (_direction.y < 0.0)
            {
                minV.y = maxV.y;
                maxV.y = 0.0;
            }
            if (_direction.z < 0.0)
            {
                minV.z = maxV.z;
                maxV.z = 0.0;
            }
        }
        // Apply time to velocity
        minP += minV * _timeToLive;
        maxP += maxV * _timeToLive;
    }
 
    // Add size particle
    minP.x += minP.x < maxP.x ? -rW : rW; // Add size of particle
    minP.y += minP.y < maxP.y ? -rH : rH; // Add size of particle if we don't have size over life
    minP.z += minP.z < maxP.z ? -rW : rW; // Add size of particle
 
    maxP.x += maxP.x > minP.x ? rW : -rW; // Add size of particle
    maxP.y += maxP.y > minP.y ? rH : -rH; // Add size of particle
    maxP.z += maxP.z > minP.z ? rW : -rW; // Add size of particle
 
    // Apply world matrix
    aabb.fromOStoWS(minP, maxP, wmNode);
}

calcNormals()

void SLParticleSystem::calcNormals ( )

inlinevirtual

SLMesh::calcNormals recalculates vertex normals for triangle meshes.

SLMesh::calcNormals recalculates the normals only from the vertices. This algorithms doesn't know anything about smoothgroups. It just loops over the triangle of the material faces and sums up the normal for each of its vertices. Note that the face normals are not normalized. The cross product of 2 vectors is proportional to the area of the triangle. Like this the normal of big triangles are more weighted than small triangles and we get a better normal quality. At the end all vertex normals are normalized.

Reimplemented from SLMesh.

Definition at line 65 of file SLParticleSystem.h.

{ N.push_back(SLVec3f(0, 1, 0)); };

changeTexture()

void SLParticleSystem::changeTexture

(

)

Change the current use texture, this will switch between the normal texture and the flipbook texture (and vice versa)

Definition at line 972 of file SLParticleSystem.cpp.

{
    if (_doFlipBookTexture)
    {
        mat()->removeTextureType(TT_diffuse);
        mat()->addTexture(_texFlipbook);
    }
    else
    {
        mat()->removeTextureType(TT_diffuse);
        mat()->addTexture(_texParticle);
    }
}

color() [1/2]

SLCol4f SLParticleSystem::color ( )

inline

Definition at line 78 of file SLParticleSystem.h.

{ return _color; }

color() [2/2]

void SLParticleSystem::color ( SLCol4f  c )

inline

Definition at line 180 of file SLParticleSystem.h.

{ _color = c; }

direction() [1/3]

SLVec3f SLParticleSystem::direction ( )

inline

Definition at line 103 of file SLParticleSystem.h.

{ return _direction; }

direction() [2/3]

void SLParticleSystem::direction ( SLfloat  vX, SLfloat  vY, SLfloat  vZ  )

inline

Definition at line 182 of file SLParticleSystem.h.

    {
        _direction.x = vX;
        _direction.y = vY;
        _direction.z = vZ;
    }

direction() [3/3]

void SLParticleSystem::direction ( SLVec3f  v )

inline

Definition at line 181 of file SLParticleSystem.h.

{ _direction = v; }

doAcc()

SLbool SLParticleSystem::doAcc ( )

inline

Definition at line 81 of file SLParticleSystem.h.

{ return _doAcceleration; }

doAccDiffDir() [1/2]

SLbool SLParticleSystem::doAccDiffDir ( )

inline

Definition at line 82 of file SLParticleSystem.h.

{ return _doAccDiffDir; }

doAccDiffDir() [2/2]

void SLParticleSystem::doAccDiffDir ( SLbool  b )

inline

Definition at line 191 of file SLParticleSystem.h.

{ _doAccDiffDir = b; }

doAcceleration()

void SLParticleSystem::doAcceleration ( SLbool  b )

inline

Definition at line 188 of file SLParticleSystem.h.

{ _doAcceleration = b; }

doAlphaOverLT() [1/2]

SLbool SLParticleSystem::doAlphaOverLT ( )

inline

Definition at line 83 of file SLParticleSystem.h.

{ return _doAlphaOverLT; }

doAlphaOverLT() [2/2]

void SLParticleSystem::doAlphaOverLT ( SLbool  b )

inline

Definition at line 189 of file SLParticleSystem.h.

{ _doAlphaOverLT = b; }

doAlphaOverLTCurve() [1/2]

SLbool SLParticleSystem::doAlphaOverLTCurve ( )

inline

Definition at line 84 of file SLParticleSystem.h.

{ return _doAlphaOverLTCurve; }

doAlphaOverLTCurve() [2/2]

void SLParticleSystem::doAlphaOverLTCurve ( SLbool  b )

inline

Definition at line 190 of file SLParticleSystem.h.

{ _doAlphaOverLTCurve = b; }

doBlendBrightness() [1/2]

SLbool SLParticleSystem::doBlendBrightness ( )

inline

Definition at line 85 of file SLParticleSystem.h.

{ return _doBlendBrightness; }

doBlendBrightness() [2/2]

void SLParticleSystem::doBlendBrightness ( SLbool  b )

inline

Definition at line 192 of file SLParticleSystem.h.

{ _doBlendBrightness = b; }

doColor() [1/2]

SLbool SLParticleSystem::doColor ( )

inline

Definition at line 87 of file SLParticleSystem.h.

{ return _doColor; }

doColor() [2/2]

void SLParticleSystem::doColor ( SLbool  b )

inline

Definition at line 193 of file SLParticleSystem.h.

{ _doColor = b; }

doColorOverLT() [1/2]

SLbool SLParticleSystem::doColorOverLT ( )

inline

Definition at line 88 of file SLParticleSystem.h.

{ return _doColorOverLT; }

doColorOverLT() [2/2]

void SLParticleSystem::doColorOverLT ( SLbool  b )

inline

Definition at line 194 of file SLParticleSystem.h.

{ _doColorOverLT = b; }

doCounterGap() [1/2]

SLbool SLParticleSystem::doCounterGap ( )

inline

Definition at line 86 of file SLParticleSystem.h.

{ return _doCounterGap; }

doCounterGap() [2/2]

void SLParticleSystem::doCounterGap ( SLbool  b )

inline

Definition at line 195 of file SLParticleSystem.h.

{ _doCounterGap = b; }

doDirectionSpeed() [1/2]

SLbool SLParticleSystem::doDirectionSpeed ( )

inline

Definition at line 89 of file SLParticleSystem.h.

{ return _doDirectionSpeed; }

doDirectionSpeed() [2/2]

void SLParticleSystem::doDirectionSpeed ( SLbool  b )

inline

Definition at line 196 of file SLParticleSystem.h.

{ _doDirectionSpeed = b; }

doFlipBookTexture() [1/2]

SLbool SLParticleSystem::doFlipBookTexture ( )

inline

Definition at line 91 of file SLParticleSystem.h.

{ return _doFlipBookTexture; }

doFlipBookTexture() [2/2]

void SLParticleSystem::doFlipBookTexture ( SLbool  b )

inline

Definition at line 198 of file SLParticleSystem.h.

{ _doFlipBookTexture = b; }

doGravity() [1/2]

SLbool SLParticleSystem::doGravity ( )

inline

Definition at line 90 of file SLParticleSystem.h.

{ return _doGravity; }

doGravity() [2/2]

void SLParticleSystem::doGravity ( SLbool  b )

inline

Definition at line 197 of file SLParticleSystem.h.

{ _doGravity = b; }

doInstancedDrawing() [1/2]

SLbool SLParticleSystem::doInstancedDrawing ( )

inline

Definition at line 80 of file SLParticleSystem.h.

{ return _doInstancedDrawing; }

doInstancedDrawing() [2/2]

void SLParticleSystem::doInstancedDrawing ( bool  instanced )

inline

Definition at line 134 of file SLParticleSystem.h.

{ _doInstancedDrawing = instanced; }

doRotation() [1/2]

SLbool SLParticleSystem::doRotation ( )

inline

Definition at line 92 of file SLParticleSystem.h.

{ return _doRotation; }

doRotation() [2/2]

void SLParticleSystem::doRotation ( SLbool  b )

inline

Definition at line 199 of file SLParticleSystem.h.

{ _doRotation = b; }

doRotRange() [1/2]

SLbool SLParticleSystem::doRotRange ( )

inline

Definition at line 93 of file SLParticleSystem.h.

{ return _doRotRange; }

doRotRange() [2/2]

void SLParticleSystem::doRotRange ( SLbool  b )

inline

Definition at line 200 of file SLParticleSystem.h.

{ _doRotRange = b; }

doShape() [1/2]

SLbool SLParticleSystem::doShape ( )

inline

Definition at line 96 of file SLParticleSystem.h.

{ return _doShape; }

doShape() [2/2]

void SLParticleSystem::doShape ( SLbool  b )

inline

Definition at line 202 of file SLParticleSystem.h.

{ _doShape = b; }

doShapeOverride() [1/2]

SLbool SLParticleSystem::doShapeOverride ( )

inline

Definition at line 98 of file SLParticleSystem.h.

{ return _doShapeOverride; }

doShapeOverride() [2/2]

void SLParticleSystem::doShapeOverride ( SLbool  b )

inline

Definition at line 204 of file SLParticleSystem.h.

{ _doShapeOverride = b; }

doShapeSpawnBase() [1/2]

SLbool SLParticleSystem::doShapeSpawnBase ( )

inline

Definition at line 99 of file SLParticleSystem.h.

{ return _doShapeSpawnBase; }

doShapeSpawnBase() [2/2]

void SLParticleSystem::doShapeSpawnBase ( SLbool  b )

inline

Definition at line 205 of file SLParticleSystem.h.

{ _doShapeSpawnBase = b; }

doShapeSurface() [1/2]

SLbool SLParticleSystem::doShapeSurface ( )

inline

Definition at line 97 of file SLParticleSystem.h.

{ return _doShapeSurface; }

doShapeSurface() [2/2]

void SLParticleSystem::doShapeSurface ( SLbool  b )

inline

Definition at line 203 of file SLParticleSystem.h.

{ _doShapeSurface = b; }

doSizeOverLT() [1/2]

SLbool SLParticleSystem::doSizeOverLT ( )

inline

Definition at line 94 of file SLParticleSystem.h.

{ return _doSizeOverLT; }

doSizeOverLT() [2/2]

void SLParticleSystem::doSizeOverLT ( SLbool  b )

inline

Definition at line 206 of file SLParticleSystem.h.

{ _doSizeOverLT = b; }

doSizeOverLTCurve() [1/2]

SLbool SLParticleSystem::doSizeOverLTCurve ( )

inline

Definition at line 95 of file SLParticleSystem.h.

{ return _doSizeOverLTCurve; }

doSizeOverLTCurve() [2/2]

void SLParticleSystem::doSizeOverLTCurve ( SLbool  b )

inline

Definition at line 207 of file SLParticleSystem.h.

{ _doSizeOverLTCurve = b; }

doSpeedRange() [1/2]

SLbool SLParticleSystem::doSpeedRange ( )

inline

Definition at line 100 of file SLParticleSystem.h.

{ return _doSpeedRange; }

doSpeedRange() [2/2]

void SLParticleSystem::doSpeedRange ( SLbool  b )

inline

Definition at line 201 of file SLParticleSystem.h.

{ _doSpeedRange = b; }

doWorldSpace() [1/2]

SLbool SLParticleSystem::doWorldSpace ( )

inline

Definition at line 101 of file SLParticleSystem.h.

{ return _doWorldSpace; }

doWorldSpace() [2/2]

void SLParticleSystem::doWorldSpace ( SLbool  b )

inline

Definition at line 208 of file SLParticleSystem.h.

{ _doWorldSpace = b; }

draw()

void SLParticleSystem::draw ( SLSceneView *  sv, SLNode *  node, SLuint  instances = 1  )

virtual

Draw function override from SLMesh. In this function I start by generate the particle and programs if they are not, then I check if the particle have been culled by the frustum culling or if they have been resumed by the user. After I update the particle in the update pass, then and finally I draw them.

Todo:

The assignment of TF buffer to a rendering buffer causes most probably a warning on Emscripten-WebGL

Reimplemented from SLMesh.

Definition at line 601 of file SLParticleSystem.cpp.

{
    ////////////////////////////////////////
    // Init particles vector and init VAO //
    ////////////////////////////////////////
 
    if (!_isGenerated)
        generate();
 
    ///////////////////////
    // Generate programs //
    ///////////////////////
 
    if (!_mat->program() || !_mat->programTF())
        _mat->generateProgramPS(_doInstancedDrawing);
 
    ///////////////////////////////////////////////////
    // Calculate time and paused and frustum culling //
    ///////////////////////////////////////////////////
 
    float difTime   = 0.0f;
    float deltaTime = GlobalTimer::timeS() - _startUpdateTimeS; // Actual delta time
 
    // Calculate time difference for frustum culling and paused
    // If particle system was not visible, and was resumed when it was not visible
    if (!_isVisibleInFrustum && !_isPaused && _lastTimeBeforePauseS != 0.0f)
    {
        _isVisibleInFrustum = true;
 
        // Paused was set before not visible (will take _lastTimeBeforePauseS),
        // if set after (will take _notVisibleTimeS)
        difTime = GlobalTimer::timeS() - min(_lastTimeBeforePauseS, _notVisibleTimeS);
 
        // maybe add later average delta time
        // (because maybe bug when fast not visible long time, visible, not visible, visible
        // Last delta time, because when culled draw is not called therefore
        // the actual delta time will be too big
        deltaTime = _deltaTimeUpdateS;
 
        // No more culling, the difference time has been applied, no further need
        _notVisibleTimeS = 0.0f;
 
        // No more paused, the difference time has been applied, no further need
        _lastTimeBeforePauseS = 0.0f;
    }
 
    // If particle system was not visible, this one is called just once when the
    // particle is draw again (Do nothing if paused, because update call is not done)
    else if (!_isVisibleInFrustum)
    {
        _isVisibleInFrustum = true;
 
        // Use time since the particle system was not visible
        difTime = GlobalTimer::timeS() - _notVisibleTimeS;
 
        // maybe add later average delta time (because maybe bug when
        // fast not visible long time, visible, not visible, visible
        // Last delta time, because when culled draw is not called
        // therefore the actual delta time will be too big
        deltaTime = _deltaTimeUpdateS;
 
        // If was paused when not visible. Need to take _notVisibleTimeS because
        // it's since this value that the particle system is not drew.
        if (_lastTimeBeforePauseS > _notVisibleTimeS)
            // Get the value of since the particle system is not drew
            _lastTimeBeforePauseS = _notVisibleTimeS;
 
        // No more culling, the difference time has been applied, no further need
        _notVisibleTimeS = 0.0f;
    }
 
    // If particle system was resumed
    else if (!_isPaused && _lastTimeBeforePauseS != 0.0f)
    {
        // Use time since the particle system was paused
        difTime = GlobalTimer::timeS() - _lastTimeBeforePauseS;
 
        // No more paused, the difference time has been applied, no further need
        _lastTimeBeforePauseS = 0.0f;
 
        // Take default delta time, because when just paused no need to
        // take last delta time, the draw call continue to be called
    }
 
    // Calculate the elapsed time for the updating, need to change to
    // use a real profiler (can't measure time like this on the GPU)
    _startUpdateTimeMS = GlobalTimer::timeMS();
 
    // MS above, S below
    _deltaTimeUpdateS = GlobalTimer::timeS() - _startUpdateTimeS;
    _startUpdateTimeS = GlobalTimer::timeS();
 
    if (!_isPaused) // The updating is paused, therefore no need to send uniforms
    {
        ///////////
        // UPDATING
        ///////////
 
        // Now use the updating program
        SLGLProgram* spTF = _mat->programTF();
        spTF->useProgram();
 
        //////////////////////////
        // Apply Uniform Variables
        //////////////////////////
 
        // Time difference, between when the particle system was culled or paused or both
        spTF->uniform1f("u_difTime", difTime);
 
        // Time between each draw call, take delta time from last draw called after frustum culling
        spTF->uniform1f("u_deltaTime", deltaTime);
 
        // Time since process start
        spTF->uniform1f("u_time", _startUpdateTimeS);
 
        if (_doAcceleration)
        {
            if (_doAccDiffDir)
                spTF->uniform3f("u_acceleration",
                                _acceleration.x,
                                _acceleration.y,
                                _acceleration.z);
            else
                spTF->uniform1f("u_accConst",
                                _accelerationConst);
        }
 
        if (_doGravity)
            spTF->uniform3f("u_gravity",
                            _gravity.x,
                            _gravity.y,
                            _gravity.z);
 
        spTF->uniform1f("u_tTL", _timeToLive);
 
        emitterPos(node->translationWS());
 
        // Worldspace
        if (_doWorldSpace)
            spTF->uniform3f("u_pGPosition",
                            _emitterPos.x,
                            _emitterPos.y,
                            _emitterPos.z);
        else
            spTF->uniform3f("u_pGPosition",
                            0.0f,
                            0.0f,
                            0.0f);
 
        // Flipbook
        if (_doFlipBookTexture)
        {
            spTF->uniform1i("u_col", _flipbookColumns);
            spTF->uniform1i("u_row", _flipbookRows);
            _flipboookLastUpdate += _deltaTimeUpdateS;
 
            if (_flipboookLastUpdate > (1.0f / (float)_flipbookFPS))
            {
                // Last time FB was updated is bigger than the time needed for each update
                spTF->uniform1i("u_condFB", 1);
                _flipboookLastUpdate = 0.0f;
            }
            else
                spTF->uniform1i("u_condFB", 0);
        }
 
        // Rotation
        if (_doRotation && !_doRotRange)
            spTF->uniform1f("u_angularVelo",
                            _angularVelocityConst * DEG2RAD);
 
        /////////////////////////
        // Draw call to update //
        /////////////////////////
 
        if (_drawBuf == 0)
        {
            _vao1.beginTF(_vao2.tfoID());
            _vao1.drawArrayAs(PT_points);
            _vao1.endTF();
 
            // @todo The assignment of TF buffer to a rendering buffer causes most probably a warning on Emscripten-WebGL
            _vao = _doInstancedDrawing ? _instanceVao2 : _vao2;
        }
        else
        {
            _vao2.beginTF(_vao1.tfoID());
            _vao2.drawArrayAs(PT_points);
            _vao2.endTF();
 
            // @todo The assignment of TF buffer to a rendering buffer causes most probably a warning on Emscripten-WebGL
            _vao = _doInstancedDrawing ? _instanceVao1 : _vao1;
        }
        _updateTime.set(GlobalTimer::timeMS() - _startUpdateTimeMS);
    }
 
    /////////////
    // DRAWING //
    /////////////
 
    // Give uniform for drawing and find for linking vao vbo
    SLGLProgram* spD = _mat->program();
    spD->useProgram();
 
    SLGLState* stateGL = SLGLState::instance();
 
    // Start calculation of the elapsed time for the drawing, need to change
    // to use a real profiler (can't measure time like this on the GPU)
    _startDrawTimeMS = GlobalTimer::timeMS();
 
    // Billboard type
    // World space
    if (_doWorldSpace)
    {
        if (_billboardType == BT_Vertical)
        {
            // Just view matrix because world space is enabled
            SLMat4f vMat = stateGL->viewMatrix;
 
            vMat.m(0, 1.0f);
            vMat.m(1, 0.0f);
            vMat.m(2, 0.0f);
 
            vMat.m(8, 0.0f);
            vMat.m(9, 0.0f);
            vMat.m(10, 1.0f);
 
            spD->uniformMatrix4fv("u_vYawPMatrix",
                                  1,
                                  (SLfloat*)&vMat);
        }
        else
        {
            // Just view matrix because world space is enabled
            SLMat4f vMat = stateGL->viewMatrix;
            std::cout << "vMat" << std::endl;
            vMat.m(0, 1.0f);
            vMat.m(1, 0.0f);
            vMat.m(2, 0.0f);
 
            vMat.m(3, 1.0f);
            vMat.m(4, 0.0f);
            vMat.m(5, 0.0f);
 
            vMat.m(6, 0.0f);
            vMat.m(7, 0.0f);
            vMat.m(8, 1.0f);
 
            spD->uniformMatrix4fv("u_vOmvMatrix",
                                  1,
                                  (SLfloat*)&vMat);
        }
    }
    else
    {
        // Build Model-View Matrix
        SLMat4f mvMat = stateGL->viewMatrix * stateGL->modelMatrix;
 
        if (_billboardType == BT_Vertical)
        {
            mvMat.m(0, 1.0f);
            mvMat.m(1, 0.0f);
            mvMat.m(2, 0.0f);
 
            mvMat.m(8, 0.0f);
            mvMat.m(9, 0.0f);
            mvMat.m(10, 1.0f);
 
            spD->uniformMatrix4fv("u_vYawPMatrix",
                                  1,
                                  (SLfloat*)&mvMat);
        }
        else
        {
            spD->uniformMatrix4fv("u_vOmvMatrix",
                                  1,
                                  (SLfloat*)&mvMat);
        }
    }
 
    // Alpha over life Bézier curve
    if (_doAlphaOverLTCurve)
    {
        spD->uniform4f("u_al_bernstein",
                       _bernsteinPYAlpha.x,
                       _bernsteinPYAlpha.y,
                       _bernsteinPYAlpha.z,
                       _bernsteinPYAlpha.w);
    }
 
    // Size over life Bézier curve
    if (_doSizeOverLTCurve)
    {
        spD->uniform4f("u_si_bernstein",
                       _bernsteinPYSize.x,
                       _bernsteinPYSize.y,
                       _bernsteinPYSize.z,
                       _bernsteinPYSize.w);
    }
 
    // Color over life by gradient color editor
    if (_doColorOverLT)
    {
        spD->uniform1fv("u_colorArr",
                        _texGradient->length() * 3,
                        (float*)&_texGradient->allColors()[0]);
        /*
        spD->uniform1fv("u_colorArr",
                        256 * 3,
                        _colorArr);
                        */
    }
    else
    {
        spD->uniform4f("u_color",
                       _color.x,
                       _color.y,
                       _color.z,
                       _color.w);
    }
 
    // Flipbook
    if (_doFlipBookTexture)
    {
        spD->uniform1i("u_col", _flipbookColumns);
        spD->uniform1i("u_row", _flipbookRows);
    }
 
    if (_isPaused) // Take time when pause was enable
        spD->uniform1f("u_time", _lastTimeBeforePauseS);
    else
        spD->uniform1f("u_time", GlobalTimer::timeS());
 
    spD->uniform1f("u_tTL", _timeToLive);
    spD->uniform1f("u_scale", _scale);
    spD->uniform1f("u_radiusW", _radiusW);
    spD->uniform1f("u_radiusH", _radiusH);
    spD->uniform1f("u_oneOverGamma", 1.0f);
 
    // Check wireframe
    if (sv->drawBits()->get(SL_DB_MESHWIRED) ||
        node->drawBits()->get(SL_DB_MESHWIRED))
        spD->uniform1i("u_doWireFrame", 1);
    else
        spD->uniform1i("u_doWireFrame", 0);
 
    if (_doColor && _doBlendBrightness)
        stateGL->blendFunc(GL_SRC_ALPHA, GL_ONE);
 
    ///////////////////////////
    if (_doInstancedDrawing)
        SLMesh::draw(sv, node, 2 * _amount); // 2 triangles per particle
    else
        SLMesh::draw(sv, node);
    ///////////////////////////
 
    if (_doColor && _doBlendBrightness)
        stateGL->blendFunc(GL_SRC_ALPHA,
                           GL_ONE_MINUS_SRC_ALPHA);
 
    // End calculation of the elapsed time for the drawing
    _drawTime.set(GlobalTimer::timeMS() - _startDrawTimeMS);
 
    // Swap buffer
    _drawBuf = 1 - _drawBuf;
}

drawTime()

AvgFloat& SLParticleSystem::drawTime ( )

inline

Definition at line 104 of file SLParticleSystem.h.

{ return _drawTime; }

emitterPos() [1/2]

SLVec3f SLParticleSystem::emitterPos ( ) const

inline

Definition at line 105 of file SLParticleSystem.h.

{ return _emitterPos; }

emitterPos() [2/2]

void SLParticleSystem::emitterPos ( SLVec3f  p )

inline

Definition at line 209 of file SLParticleSystem.h.

{ _emitterPos = p; }

flipbookColumns() [1/2]

SLint SLParticleSystem::flipbookColumns ( )

inline

Definition at line 107 of file SLParticleSystem.h.

{ return _flipbookColumns; }

flipbookColumns() [2/2]

void SLParticleSystem::flipbookColumns ( SLint  i )

inline

Definition at line 217 of file SLParticleSystem.h.

{ _flipbookColumns = i; }

flipbookRows() [1/2]

SLint SLParticleSystem::flipbookRows ( )

inline

Definition at line 108 of file SLParticleSystem.h.

{ return _flipbookRows; }

flipbookRows() [2/2]

void SLParticleSystem::flipbookRows ( SLint  i )

inline

Definition at line 218 of file SLParticleSystem.h.

{ _flipbookRows = i; }

frameRateFB() [1/2]

int SLParticleSystem::frameRateFB ( )

inline

Definition at line 109 of file SLParticleSystem.h.

{ return _flipbookFPS; }

frameRateFB() [2/2]

void SLParticleSystem::frameRateFB ( int  i )

inline

Definition at line 219 of file SLParticleSystem.h.

{ _flipbookFPS = i; }

generate()

void SLParticleSystem::generate

(

)

Function which will generate the particles and attributes them to the VAO.

Definition at line 292 of file SLParticleSystem.cpp.

{
    SLuint                     seed = (SLuint)chrono::system_clock::now().time_since_epoch().count();
    default_random_engine      generator(seed);
    normal_distribution<float> distribution(0.0f, 1.0f);
 
    SLVVec3f tempP, tempV, tempInitV;
    SLVfloat tempR, tempST, tempAngulareVelo;
    SLVuint  tempTexNum;
    SLVVec3f tempInitP;
 
    if (_doInstancedDrawing)
        _primitive = PT_triangles;
    else
        _primitive = PT_points;
 
    SLMesh::deleteDataGpu();
 
    // Initialize the drawing:
    if (_doFlipBookTexture)
    {
        SLMaterial* mDraw = new SLMaterial(_assetManager,
                                           "Drawing-Material",
                                           this,
                                           _texFlipbook);
        mDraw->addTexture(_texGradient);
        mat(mDraw);
    }
    else
    {
        SLMaterial* mDraw = new SLMaterial(_assetManager,
                                           "Drawing-Material",
                                           this,
                                           _texParticle);
        mDraw->addTexture(_texGradient);
        mat(mDraw);
    }
 
    tempP.resize(_amount);
    tempV.resize(_amount);
    tempST.resize(_amount);
 
    if (_doAcceleration || _doGravity)
        tempInitV.resize(_amount);
    if (_doRotation)
        tempR.resize(_amount);
    if (_doRotation && _doRotRange)
        tempAngulareVelo.resize(_amount);
    if (_doFlipBookTexture)
        tempTexNum.resize(_amount);
    if (_doShape)
        tempInitP.resize(_amount);
 
    // Normal generation
    for (SLint i = 0; i < _amount; i++)
    {
        if (_doShape && _shapeType == ST_Sphere) // Position in or on sphere
        {
            if (!_doShapeSurface) // In volume
                tempP[i] = getPointInSphere(_shapeRadius,
                                            SLVec3f(distribution(generator),
                                                    distribution(generator),
                                                    distribution(generator)));
            else // On surface
                tempP[i] = getPointOnSphere(_shapeRadius,
                                            SLVec3f(distribution(generator),
                                                    distribution(generator),
                                                    distribution(generator)));
        }
        else if (_doShape && _shapeType == ST_Box) // Position in or on box
            if (!_doShapeSurface)
                tempP[i] = getPointInBox(_shapeScale);
            else
                tempP[i] = getPointOnBox(_shapeScale);
        else if (_doShape && _shapeType == ST_Cone) // Position in or on cone
            if (!_doShapeSurface)
                tempP[i] = getPointInCone();
            else
                tempP[i] = getPointOnCone();
        else if (_doShape && _shapeType == ST_Pyramid) // Position in or on pyramid
            if (!_doShapeSurface)
                tempP[i] = getPointInPyramid();
            else
                tempP[i] = getPointOnPyramid();
        else // Position is not a volume, spawn from start point (particle emitter position)
            tempP[i] = SLVec3f(0, 0, 0);
 
        if (!_doDirectionSpeed) // Use normal velocity
        {
            if (_velocityType == 0) // Random value
            {
                tempV[i].x = Utils::random(_velocityRndMin.x, _velocityRndMax.x); // Random value for x velocity
                tempV[i].y = Utils::random(_velocityRndMin.y, _velocityRndMax.y); // Random value for y velocity
                tempV[i].z = Utils::random(_velocityRndMin.z, _velocityRndMax.z); // Random value for z velocity
            }
            else if (_velocityType == 1) // Constant
            {
                tempV[i].x = _velocityConst.x; // Constant value for x velocity
                tempV[i].y = _velocityConst.y; // Constant value for y velocity
                tempV[i].z = _velocityConst.z; // Constant value for z velocity
            }
        }
        else // DO direction and speed
        {
            SLVec3f tempDirection;
            if (_doShapeOverride) // Direction for shape
            {
                if (_doShape && _shapeType == ST_Sphere)
                    tempDirection = getDirectionSphere(tempP[i]);
                else if (_doShape && _shapeType == ST_Box)
                    tempDirection = getDirectionBox(tempP[i]);
                else if (_doShape && _shapeType == ST_Cone)
                    tempDirection = getDirectionCone(tempP[i]);
                else if (_doShape && _shapeType == ST_Pyramid)
                    tempDirection = getDirectionPyramid(tempP[i]);
            }
            else // Normal direction
                tempDirection = _direction;
 
            if (_doSpeedRange) // Apply speed
                tempV[i] = tempDirection * Utils::random(_speedRange.x, _speedRange.y);
            else
                tempV[i] = tempDirection * _speed;
        }
 
        // When the first particle dies the last one begin to live
        tempST[i] = GlobalTimer::timeS() + ((float)i * (_timeToLive / (float)_amount)); // Time to start
 
        if (_doAcceleration || _doGravity) // Acceleration
            tempInitV[i] = tempV[i];
        if (_doRotation)                                                // Rotation (constant angular velocity)
            tempR[i] = Utils::random(0.0f * DEG2RAD, 360.0f * DEG2RAD); // Start rotation of the particle
        if (_doRotation && _doRotRange)                                 // Random angular velocity for each particle
            tempAngulareVelo[i] = Utils::random(_angularVelocityRange.x * DEG2RAD,
                                                _angularVelocityRange.y * DEG2RAD); // Start rotation of the particle
        if (_doFlipBookTexture)                                                     // Flipbook texture
            tempTexNum[i] = Utils::random(0,
                                          _flipbookRows * _flipbookColumns - 1);
        if (_doShape) // Shape feature
            tempInitP[i] = tempP[i];
    }
 
    // Need to have two VAO for transform feedback swapping
    // Configure first VAO
    _vao1.deleteGL();
    _vao1.setAttrib(AT_position, AT_position, &tempP);
    _vao1.setAttrib(AT_velocity, AT_velocity, &tempV);
    _vao1.setAttrib(AT_startTime, AT_startTime, &tempST);
 
    if (_doAcceleration || _doGravity)
        _vao1.setAttrib(AT_initialVelocity,
                        AT_initialVelocity,
                        &tempInitV);
    if (_doRotation)
        _vao1.setAttrib(AT_rotation,
                        AT_rotation,
                        &tempR);
    if (_doRotation && _doRotRange)
        _vao1.setAttrib(AT_angularVelo,
                        AT_angularVelo,
                        &tempAngulareVelo);
    if (_doFlipBookTexture)
        _vao1.setAttrib(AT_texNum,
                        AT_texNum,
                        &tempTexNum);
    if (_doShape)
        _vao1.setAttrib(AT_initialPosition,
                        AT_initialPosition,
                        &tempInitP);
    _vao1.generateTF((SLuint)tempP.size());
 
    // Configure second VAO
    _vao2.deleteGL();
    _vao2.setAttrib(AT_position, AT_position, &tempP);
    _vao2.setAttrib(AT_velocity, AT_velocity, &tempV);
    _vao2.setAttrib(AT_startTime, AT_startTime, &tempST);
 
    if (_doAcceleration || _doGravity)
        _vao2.setAttrib(AT_initialVelocity,
                        AT_initialVelocity,
                        &tempInitV);
    if (_doRotation)
        _vao2.setAttrib(AT_rotation,
                        AT_rotation,
                        &tempR);
    if (_doRotation && _doRotRange)
        _vao2.setAttrib(AT_angularVelo,
                        AT_angularVelo,
                        &tempAngulareVelo);
    if (_doFlipBookTexture)
        _vao2.setAttrib(AT_texNum,
                        AT_texNum,
                        &tempTexNum);
    if (_doShape)
        _vao2.setAttrib(AT_initialPosition,
                        AT_initialPosition,
                        &tempInitP);
    _vao2.generateTF((SLuint)tempP.size());
 
    if (_doInstancedDrawing)
    {
        P.clear();
        I32.clear();
 
        // Generate for billboard (for drawing instanced without geometry shader)
        P.push_back(SLVec3f(-1, -1, 0));
        P.push_back(SLVec3f(1, -1, 0));
        P.push_back(SLVec3f(1, 1, 0));
        P.push_back(SLVec3f(-1, 1, 0));
 
        I32.push_back(0);
        I32.push_back(1);
        I32.push_back(2);
        I32.push_back(2);
        I32.push_back(3);
        I32.push_back(0);
 
        _instanceVao1.deleteGL();
        _instanceVao1.setAttrib(AT_custom0, AT_instancePosition, &P);
        _instanceVao1.setIndices(&I32);
        _instanceVao1.setInstanceVBO(_vao1.vbo(), 2);
        _instanceVao1.generate((SLuint)P.size());
 
        _instanceVao2.deleteGL();
        _instanceVao2.setAttrib(AT_custom0, AT_instancePosition, &P);
        _instanceVao2.setIndices(&I32);
        _instanceVao2.setInstanceVBO(_vao2.vbo(), 2);
        _instanceVao2.generate((SLuint)P.size());
    }
 
    _isGenerated = true;
}

generateBernsteinPAlpha()

void SLParticleSystem::generateBernsteinPAlpha

(

)

Generate Bernstein Polynomial with 4 controls points for alpha over life. ContP contains 2 and 3 controls points StatEnd contains 1 and 4 controls points

Definition at line 530 of file SLParticleSystem.cpp.

{
    float* ContP  = _bezierControlPointAlpha;
    float* StaEnd = _bezierStartEndPointAlpha;
    // For Y bezier curve
    // T^3
    _bernsteinPYAlpha.x = -StaEnd[1] + ContP[1] * 3 - ContP[3] * 3 + StaEnd[3];
    // T^2
    _bernsteinPYAlpha.y = StaEnd[1] * 3 - ContP[1] * 6 + ContP[3] * 3;
    // T
    _bernsteinPYAlpha.z = -StaEnd[1] * 3 + ContP[1] * 3;
    // 1
    _bernsteinPYAlpha.w = StaEnd[1];
}

generateBernsteinPSize()

void SLParticleSystem::generateBernsteinPSize

(

)

Generate Bernstein Polynomial with 4 controls points for size over life. ContP contains 2 and 3 controls points StatEnd contains 1 and 4 controls points

Definition at line 550 of file SLParticleSystem.cpp.

{
    // For Y bezier curve
    // T^3
    float* ContP       = _bezierControlPointSize;
    float* StaEnd      = _bezierStartEndPointSize;
    _bernsteinPYSize.x = -StaEnd[1] + ContP[1] * 3 - ContP[3] * 3 + StaEnd[3];
    // T^2
    _bernsteinPYSize.y = StaEnd[1] * 3 - ContP[1] * 6 + ContP[3] * 3;
    // T
    _bernsteinPYSize.z = -StaEnd[1] * 3 + ContP[1] * 3;
    // 1
    _bernsteinPYSize.w = StaEnd[1];
}

getDirectionBox()

SLVec3f SLParticleSystem::getDirectionBox ( SLVec3f  position )

private

Function which return the direction towards the exterior of a box.

Definition at line 165 of file SLParticleSystem.cpp.

{
    // return a unit vector from center to position
    return (position - SLVec3f(0.0f, 0.0f, 0.0f)).normalized();
}

getDirectionCone()

SLVec3f SLParticleSystem::getDirectionCone ( SLVec3f  position )

private

Function which return a direction following the cone shape.

Definition at line 210 of file SLParticleSystem.cpp.

{
    float maxRadius = _shapeRadius + tan(_shapeAngle * DEG2RAD) * _shapeHeight;
 
    // Calculate at which percent our x is, to know how much we need to adapt our angle
    float percentX = position.x / maxRadius;
    // Calculate at which percent our z is, to know how much we need to adapt our angle
    float percentZ = position.z / maxRadius;
    float newX     = position.x + tan(_shapeAngle * percentX * DEG2RAD) * _shapeHeight;
    float newZ     = position.z + tan(_shapeAngle * percentZ * DEG2RAD) * _shapeHeight;
    return SLVec3f(newX, _shapeHeight, newZ).normalize();
}

getDirectionPyramid()

SLVec3f SLParticleSystem::getDirectionPyramid ( SLVec3f  position )

private

Function which return a direction following the pyramid shape.

Definition at line 278 of file SLParticleSystem.cpp.

{
    float maxRadius = _shapeWidth +
                      tan(_shapeAngle * DEG2RAD) * _shapeHeight;
 
    // Calculate at which percent our x & z is to know how much we need to adapt our angle
    float percentX = position.x / maxRadius;
    float percentZ = position.z / maxRadius;
    float newX     = position.x + tan(_shapeAngle * percentX * DEG2RAD) * _shapeHeight;
    float newZ     = position.z + tan(_shapeAngle * percentZ * DEG2RAD) * _shapeHeight;
    return SLVec3f(newX, _shapeHeight, newZ).normalize();
}

getDirectionSphere()

SLVec3f SLParticleSystem::getDirectionSphere ( SLVec3f  position )

private

Function which return the direction towards the exterior of a sphere.

Definition at line 101 of file SLParticleSystem.cpp.

{
    // return a unit vector from center to position
    return (position - SLVec3f(0.0f, 0.0f, 0.0f)).normalized();
}

getPointInBox()

SLVec3f SLParticleSystem::getPointInBox ( SLVec3f  boxScale )

private

Function which return a position in a box.

Definition at line 108 of file SLParticleSystem.cpp.

{
    float x = Utils::random(-boxScale.x, boxScale.x);
    float y = Utils::random(-boxScale.y, boxScale.y);
    float z = Utils::random(-boxScale.z, boxScale.z);
 
    return SLVec3f(x, y, z);
}

getPointInCone()

SLVec3f SLParticleSystem::getPointInCone ( )

private

Function which return a position in the cone define in the particle system.

Definition at line 172 of file SLParticleSystem.cpp.

{
    float y      = 0.0f;
    float radius = _shapeRadius;
    if (!_doShapeSpawnBase) // Spawn inside volume
    {
        // NEED TO HAVE MORE value near 1 when we have smaller base that top
        y      = Utils::random(0.0f, _shapeHeight);
        radius = _shapeRadius + tan(_shapeAngle * DEG2RAD) * y;
    }
    float r     = radius * sqrt(random(0.0f, 1.0f));
    float theta = Utils::random(0.0f, 1.0f) * 2 * PI;
    float x     = r * cos(theta);
    float z     = r * sin(theta);
 
    return SLVec3f(x, y, z);
}

getPointInPyramid()

SLVec3f SLParticleSystem::getPointInPyramid ( )

private

Function which returns a position in the pyramid that define the PS.

Definition at line 224 of file SLParticleSystem.cpp.

{
    float y      = 0.0f;
    float radius = _shapeWidth;
    if (!_doShapeSpawnBase) // Spawn inside volume
    {
        y      = Utils::random(0.0f, _shapeHeight);
        radius = _shapeWidth + tan(_shapeAngle * DEG2RAD) * y;
    }
    float x = Utils::random(-radius, radius);
    float z = Utils::random(-radius, radius);
 
    return SLVec3f(x, y, z);
}

getPointInSphere()

SLVec3f SLParticleSystem::getPointInSphere ( float  radius, SLVec3f  randomX  )

private

Function which return a position in a sphere.

Definition at line 66 of file SLParticleSystem.cpp.

{
    float u  = Utils::random(0.0f, radius);
    float x1 = randomXs.x;
    float x2 = randomXs.y;
    float x3 = randomXs.z;
 
    float mag = sqrt(x1 * x1 + x2 * x2 + x3 * x3);
    x1 /= mag;
    x2 /= mag;
    x3 /= mag;
 
    float c = cbrt(u);
 
    return SLVec3f(x1 * c, x2 * c, x3 * c);
}

getPointOnBox()

SLVec3f SLParticleSystem::getPointOnBox ( SLVec3f  boxScale )

private

Function which return a position on a box.

Definition at line 118 of file SLParticleSystem.cpp.

{
    int   temp = Utils::random(0, 5);
    float x    = 0.0f;
    float y    = 0.0f;
    float z    = 0.0f;
    if (temp == 0)
    { // LEFT side
        x = -boxScale.x;
        y = Utils::random(-boxScale.y, boxScale.y);
        z = Utils::random(-boxScale.z, boxScale.z);
    }
    else if (temp == 1) // RIGHT side
    {
        x = boxScale.x;
        y = Utils::random(-boxScale.y, boxScale.y);
        z = Utils::random(-boxScale.z, boxScale.z);
    }
    else if (temp == 2) // FRONT side
    {
        x = Utils::random(-boxScale.x, boxScale.x);
        y = Utils::random(-boxScale.y, boxScale.y);
        z = boxScale.z;
    }
    else if (temp == 3) // BACK side
    {
        x = Utils::random(-boxScale.x, boxScale.x);
        y = Utils::random(-boxScale.y, boxScale.y);
        z = -boxScale.z;
    }
    else if (temp == 4) // TOP side
    {
        x = Utils::random(-boxScale.x, boxScale.x);
        y = boxScale.y;
        z = Utils::random(-boxScale.z, boxScale.z);
    }
    else if (temp == 5) // BOTTOM side
    {
        x = Utils::random(-boxScale.x, boxScale.x);
        y = -boxScale.y;
        z = Utils::random(-boxScale.z, boxScale.z);
    }
 
    return SLVec3f(x, y, z);
}

getPointOnCone()

SLVec3f SLParticleSystem::getPointOnCone ( )

private

Function which return a position on the cone define in the particle system.

Definition at line 191 of file SLParticleSystem.cpp.

{
    float y      = 0.0f;
    float radius = _shapeRadius;
    if (!_doShapeSpawnBase) // Spawn inside volume
    {
        // NEED TO HAVE MORE value near 1 when we have smaller base that top
        y      = Utils::random(0.0f, _shapeHeight);
        radius = _shapeRadius + tan(_shapeAngle * DEG2RAD) * y;
    }
    float r     = radius;
    float theta = Utils::random(0.0f, 1.0f) * 2 * PI;
    float x     = r * cos(theta);
    float z     = r * sin(theta);
 
    return SLVec3f(x, y, z);
}

getPointOnPyramid()

SLVec3f SLParticleSystem::getPointOnPyramid ( )

private

Function which return a position on the pyramid that defines the PS.

Definition at line 240 of file SLParticleSystem.cpp.

{
    float y      = 0.0f;
    float radius = _shapeWidth;
    if (!_doShapeSpawnBase) // Spawn inside volume
    {
        y      = Utils::random(0.0f, _shapeHeight);
        radius = _shapeWidth + tan(_shapeAngle * DEG2RAD) * y;
    }
 
    int   temp = Utils::random(0, 3);
    float x = 0.0f, z = 0.0f;
 
    if (temp == 0) // LEFT
    {
        x = -radius;
        z = Utils::random(-radius, radius);
    }
    else if (temp == 1) // RIGHT
    {
        x = radius;
        z = Utils::random(-radius, radius);
    }
    else if (temp == 2) // FRONT
    {
        x = Utils::random(-radius, radius);
        z = radius;
    }
    else if (temp == 3) // BACK
    {
        x = Utils::random(-radius, radius);
        z = -radius;
    }
 
    return SLVec3f(x, y, z);
}

getPointOnSphere()

SLVec3f SLParticleSystem::getPointOnSphere ( float  radius, SLVec3f  randomX  )

private

Function which return a position on a sphere.

Definition at line 84 of file SLParticleSystem.cpp.

{
    float x1 = randomXs.x;
    float x2 = randomXs.y;
    float x3 = randomXs.z;
 
    float mag = sqrt(x1 * x1 + x2 * x2 + x3 * x3);
    x1 /= mag;
    x2 /= mag;
    x3 /= mag;
 
    float c = cbrt(radius);
 
    return SLVec3f(x1 * c, x2 * c, x3 * c);
}

gravity() [1/3]

SLVec3f SLParticleSystem::gravity ( )

inline

Definition at line 106 of file SLParticleSystem.h.

{ return _gravity; }

gravity() [2/3]

void SLParticleSystem::gravity ( SLfloat  vX, SLfloat  vY, SLfloat  vZ  )

inline

Definition at line 211 of file SLParticleSystem.h.

    {
        _gravity.x = vX;
        _gravity.y = vY;
        _gravity.z = vZ;
    }

gravity() [3/3]

void SLParticleSystem::gravity ( SLVec3f  v )

inline

Definition at line 210 of file SLParticleSystem.h.

{ _gravity = v; }

isGenerated() [1/2]

SLbool SLParticleSystem::isGenerated ( )

inline

Definition at line 110 of file SLParticleSystem.h.

{ return _isGenerated; }

isGenerated() [2/2]

void SLParticleSystem::isGenerated ( SLbool  b )

inline

Definition at line 220 of file SLParticleSystem.h.

{ _isGenerated = b; }

isPaused()

SLbool SLParticleSystem::isPaused ( )

inline

Definition at line 111 of file SLParticleSystem.h.

{ return _isPaused; }

pauseOrResume()

void SLParticleSystem::pauseOrResume

(

)

Function called by the user to pause or resume the particle system. This will freeze the particle system there won't be any updating, only the drawing

Definition at line 582 of file SLParticleSystem.cpp.

{
    if (!_isPaused)
    {
        _isPaused             = true;
        _lastTimeBeforePauseS = GlobalTimer::timeS();
    }
    else
        _isPaused = false;
}

radiusH() [1/2]

SLfloat SLParticleSystem::radiusH ( )

inline

Definition at line 113 of file SLParticleSystem.h.

{ return _radiusH; }

radiusH() [2/2]

void SLParticleSystem::radiusH ( SLfloat  f )

inline

Definition at line 222 of file SLParticleSystem.h.

{ _radiusH = f; }

radiusW() [1/2]

SLfloat SLParticleSystem::radiusW ( )

inline

Definition at line 112 of file SLParticleSystem.h.

{ return _radiusW; }

radiusW() [2/2]

void SLParticleSystem::radiusW ( SLfloat  f )

inline

Definition at line 221 of file SLParticleSystem.h.

{ _radiusW = f; }

scale() [1/2]

SLfloat SLParticleSystem::scale ( )

inline

Definition at line 114 of file SLParticleSystem.h.

{ return _scale; }

scale() [2/2]

void SLParticleSystem::scale ( SLfloat  f )

inline

Definition at line 223 of file SLParticleSystem.h.

{ _scale = f; }

setNotVisibleInFrustum()

void SLParticleSystem::setNotVisibleInFrustum

(

)

Function called inside SLNode cull3DRec(..) which flags the particle system to be not visible in the view frustum. This is needed to correct later the start time of the PS when it reappears again.

Definition at line 569 of file SLParticleSystem.cpp.

{
    if (_isVisibleInFrustum)
    {
        _isVisibleInFrustum = false;
        _notVisibleTimeS    = GlobalTimer::timeS();
    }
}

shapeAngle() [1/2]

SLfloat SLParticleSystem::shapeAngle ( )

inline

Definition at line 116 of file SLParticleSystem.h.

{ return _shapeAngle; }

shapeAngle() [2/2]

void SLParticleSystem::shapeAngle ( SLfloat  f )

inline

Definition at line 232 of file SLParticleSystem.h.

{ _shapeAngle = f; }

shapeHeight() [1/2]

SLfloat SLParticleSystem::shapeHeight ( )

inline

Definition at line 117 of file SLParticleSystem.h.

{ return _shapeHeight; }

shapeHeight() [2/2]

void SLParticleSystem::shapeHeight ( SLfloat  f )

inline

Definition at line 241 of file SLParticleSystem.h.

{ _shapeHeight = f; }

shapeRadius() [1/2]

SLfloat SLParticleSystem::shapeRadius ( )

inline

Definition at line 118 of file SLParticleSystem.h.

{ return _shapeRadius; }

shapeRadius() [2/2]

void SLParticleSystem::shapeRadius ( SLfloat  r )

inline

Definition at line 233 of file SLParticleSystem.h.

{ _shapeRadius = r; }

shapeScale() [1/3]

SLVec3f SLParticleSystem::shapeScale ( )

inline

Definition at line 119 of file SLParticleSystem.h.

{ return _shapeScale; }

shapeScale() [2/3]

void SLParticleSystem::shapeScale ( SLfloat  vX, SLfloat  vY, SLfloat  vZ  )

inline

Definition at line 235 of file SLParticleSystem.h.

    {
        _shapeScale.x = vX;
        _shapeScale.y = vY;
        _shapeScale.z = vZ;
    }

shapeScale() [3/3]

void SLParticleSystem::shapeScale ( SLVec3f  v )

inline

Definition at line 234 of file SLParticleSystem.h.

{ _shapeScale = v; }

shapeType() [1/2]

SLShapeType SLParticleSystem::shapeType ( )

inline

Definition at line 115 of file SLParticleSystem.h.

{ return _shapeType; }

shapeType() [2/2]

void SLParticleSystem::shapeType ( SLShapeType  st )

inline

Definition at line 231 of file SLParticleSystem.h.

{ _shapeType = st; }

shapeWidth() [1/2]

SLfloat SLParticleSystem::shapeWidth ( )

inline

Definition at line 120 of file SLParticleSystem.h.

{ return _shapeWidth; }

shapeWidth() [2/2]

void SLParticleSystem::shapeWidth ( SLfloat  f )

inline

Definition at line 242 of file SLParticleSystem.h.

{ _shapeWidth = f; }

speed() [1/2]

SLfloat SLParticleSystem::speed ( )

inline

Definition at line 121 of file SLParticleSystem.h.

{ return _speed; }

speed() [2/2]

void SLParticleSystem::speed ( SLfloat  f )

inline

Definition at line 224 of file SLParticleSystem.h.

{ _speed = f; }

speedRange() [1/3]

SLVec2f SLParticleSystem::speedRange ( )

inline

Definition at line 122 of file SLParticleSystem.h.

{ return _speedRange; }

speedRange() [2/3]

void SLParticleSystem::speedRange ( SLfloat  vX, SLfloat  vY  )

inline

Definition at line 226 of file SLParticleSystem.h.

    {
        _speedRange.x = vX;
        _speedRange.y = vY;
    }

speedRange() [3/3]

void SLParticleSystem::speedRange ( SLVec2f  v )

inline

Definition at line 225 of file SLParticleSystem.h.

{ _speedRange = v; }

texFlipbook() [1/2]

SLGLTexture* SLParticleSystem::texFlipbook ( )

inline

Definition at line 124 of file SLParticleSystem.h.

{ return _texFlipbook; }

texFlipbook() [2/2]

void SLParticleSystem::texFlipbook ( SLGLTexture *  tf )

inline

Definition at line 245 of file SLParticleSystem.h.

{ _texFlipbook = tf; }

texGradient() [1/2]

SLTexColorLUT* SLParticleSystem::texGradient ( )

inline

Definition at line 125 of file SLParticleSystem.h.

{ return _texGradient; }

texGradient() [2/2]

void SLParticleSystem::texGradient ( SLTexColorLUT *  tg )

inline

Definition at line 246 of file SLParticleSystem.h.

{ _texGradient = tg; }

texParticle() [1/2]

SLGLTexture* SLParticleSystem::texParticle ( )

inline

Definition at line 123 of file SLParticleSystem.h.

{ return _texParticle; }

texParticle() [2/2]

void SLParticleSystem::texParticle ( SLGLTexture *  tp )

inline

Definition at line 244 of file SLParticleSystem.h.

{ _texParticle = tp; }

timeToLive() [1/2]

SLfloat SLParticleSystem::timeToLive ( )

inline

Definition at line 126 of file SLParticleSystem.h.

{ return _timeToLive; }

timeToLive() [2/2]

void SLParticleSystem::timeToLive ( SLfloat  f )

inline

Definition at line 243 of file SLParticleSystem.h.

{ _timeToLive = f; }

updateTime()

AvgFloat& SLParticleSystem::updateTime ( )

inline

Definition at line 127 of file SLParticleSystem.h.

{ return _updateTime; }

velocityConst() [1/3]

SLVec3f SLParticleSystem::velocityConst ( )

inline

Definition at line 129 of file SLParticleSystem.h.

{ return _velocityConst; }

velocityConst() [2/3]

void SLParticleSystem::velocityConst ( SLfloat  vX, SLfloat  vY, SLfloat  vZ  )

inline

Definition at line 249 of file SLParticleSystem.h.

    {
        _velocityConst.x = vX;
        _velocityConst.y = vY;
        _velocityConst.z = vZ;
    }

velocityConst() [3/3]

void SLParticleSystem::velocityConst ( SLVec3f  v )

inline

Definition at line 248 of file SLParticleSystem.h.

{ _velocityConst = v; }

velocityRndMax() [1/3]

SLVec3f SLParticleSystem::velocityRndMax ( )

inline

Definition at line 131 of file SLParticleSystem.h.

{ return _velocityRndMax; }

velocityRndMax() [2/3]

void SLParticleSystem::velocityRndMax ( SLfloat  vX, SLfloat  vY, SLfloat  vZ  )

inline

Definition at line 263 of file SLParticleSystem.h.

    {
        _velocityRndMax.x = vX;
        _velocityRndMax.y = vY;
        _velocityRndMax.z = vZ;
    }

velocityRndMax() [3/3]

void SLParticleSystem::velocityRndMax ( SLVec3f  v )

inline

Definition at line 262 of file SLParticleSystem.h.

{ _velocityRndMax = v; }

velocityRndMin() [1/3]

SLVec3f SLParticleSystem::velocityRndMin ( )

inline

Definition at line 130 of file SLParticleSystem.h.

{ return _velocityRndMin; }

velocityRndMin() [2/3]

void SLParticleSystem::velocityRndMin ( SLfloat  vX, SLfloat  vY, SLfloat  vZ  )

inline

Definition at line 256 of file SLParticleSystem.h.

    {
        _velocityRndMin.x = vX;
        _velocityRndMin.y = vY;
        _velocityRndMin.z = vZ;
    }

velocityRndMin() [3/3]

void SLParticleSystem::velocityRndMin ( SLVec3f  v )

inline

Definition at line 255 of file SLParticleSystem.h.

{ _velocityRndMin = v; }

velocityType() [1/2]

SLint SLParticleSystem::velocityType ( )

inline

Definition at line 128 of file SLParticleSystem.h.

{ return _velocityType; }

velocityType() [2/2]

void SLParticleSystem::velocityType ( SLint  i )

inline

Definition at line 247 of file SLParticleSystem.h.

{ _velocityType = i; }

Member Data Documentation

_acceleration

SLVec3f SLParticleSystem::_acceleration = SLVec3f(1, 1, 1)

private

Vector for acceleration (different direction as the velocity)

Definition at line 305 of file SLParticleSystem.h.

_accelerationConst

SLfloat SLParticleSystem::_accelerationConst = 0.0f

private

Acceleration constant (same direction as the velocity)

Definition at line 306 of file SLParticleSystem.h.

_amount

SLint SLParticleSystem::_amount

private

Amount of a particle.

Definition at line 289 of file SLParticleSystem.h.

_angularVelocityConst

SLfloat SLParticleSystem::_angularVelocityConst = 30.0f

private

Rotation rate const (change in angular rotation divide by change in time)

Definition at line 353 of file SLParticleSystem.h.

_angularVelocityRange

SLVec2f SLParticleSystem::_angularVelocityRange = SLVec2f(-30.0f, 30.0f)

private

Rotation rate range (change in angular rotation divide by change in time)

Definition at line 354 of file SLParticleSystem.h.

_assetManager

SLAssetManager* SLParticleSystem::_assetManager

private

pointer to the asset manager (the owner) if available

Definition at line 286 of file SLParticleSystem.h.

_bernsteinPYAlpha

SLVec4f SLParticleSystem::_bernsteinPYAlpha = SLVec4f(2.0f, -3.0f, 0.0f, 1.0f)

private

Vector for bezier curve (default linear function)

Definition at line 297 of file SLParticleSystem.h.

_bernsteinPYSize

SLVec4f SLParticleSystem::_bernsteinPYSize = SLVec4f(-1.4f, 1.8f, 0.6f, 0.0f)

private

Vector for bezier curve (default linear function)

Definition at line 300 of file SLParticleSystem.h.

_bezierControlPointAlpha

float SLParticleSystem::_bezierControlPointAlpha[4] = {0.0f, 1.0f, 1.0f, 0.0f}

private

Floats for bezier curve control points (P1: 01 ; P2: 23)

Definition at line 298 of file SLParticleSystem.h.

_bezierControlPointSize

float SLParticleSystem::_bezierControlPointSize[4] = {0.0f, 0.0f, 1.0f, 1.0f}

private

Floats for bezier curve control points (P1: 01 ; P2: 23)

Definition at line 301 of file SLParticleSystem.h.

_bezierStartEndPointAlpha

float SLParticleSystem::_bezierStartEndPointAlpha[4] = {0.0f, 1.0f, 1.0f, 0.0f}

private

Floats for bezier curve end start points (Start: 01 ; End: 23)

Definition at line 299 of file SLParticleSystem.h.

_bezierStartEndPointSize

float SLParticleSystem::_bezierStartEndPointSize[4] = {0.0f, 0.0f, 1.0f, 1.0f}

private

Floats for bezier curve end start points (Start: 01 ; End: 23)

Definition at line 302 of file SLParticleSystem.h.

_billboardType

SLBillboardType SLParticleSystem::_billboardType = BT_Camera

private

Billboard type (BT_Camera, BT_Vertical, BT_Horizontal.

Definition at line 357 of file SLParticleSystem.h.

_color

SLCol4f SLParticleSystem::_color = SLCol4f(0.66f, 0.0f, 0.66f, 0.2f)

private

Color for particle.

Definition at line 320 of file SLParticleSystem.h.

_deltaTimeUpdateS

SLfloat SLParticleSystem::_deltaTimeUpdateS = 0.0f

private

Delta time in between two frames S.

Definition at line 337 of file SLParticleSystem.h.

_direction

SLVec3f SLParticleSystem::_direction = SLVec3f(0, 0, 0)

private

Direction of particle.

Definition at line 315 of file SLParticleSystem.h.

_doAccDiffDir

SLbool SLParticleSystem::_doAccDiffDir = false

private

Boolean for acceleration (different direction)

Definition at line 383 of file SLParticleSystem.h.

_doAcceleration

SLbool SLParticleSystem::_doAcceleration = false

private

Boolean for acceleration.

Definition at line 382 of file SLParticleSystem.h.

_doAlphaOverLT

SLbool SLParticleSystem::_doAlphaOverLT = true

private

Boolean for alpha over life time.

Definition at line 393 of file SLParticleSystem.h.

_doAlphaOverLTCurve

SLbool SLParticleSystem::_doAlphaOverLTCurve = false

private

Boolean for alpha over life time curve.

Definition at line 395 of file SLParticleSystem.h.

_doBlendBrightness

SLbool SLParticleSystem::_doBlendBrightness = false

private

Boolean for glow/brightness on pixel with many particle.

Definition at line 378 of file SLParticleSystem.h.

_doColor

SLbool SLParticleSystem::_doColor = true

private

Boolean for color.

Definition at line 386 of file SLParticleSystem.h.

_doColorOverLT

SLbool SLParticleSystem::_doColorOverLT = false

private

Boolean for color over life time.

Definition at line 394 of file SLParticleSystem.h.

_doCounterGap

SLbool SLParticleSystem::_doCounterGap = true

private

Boolean for counter lag/gap, can create flickering with few particle (explained in documentation) when enable.

Definition at line 381 of file SLParticleSystem.h.

_doDirectionSpeed

SLbool SLParticleSystem::_doDirectionSpeed = false

private

Boolean for direction and speed (override velocity)

Definition at line 379 of file SLParticleSystem.h.

_doFlipBookTexture

SLbool SLParticleSystem::_doFlipBookTexture = false

private

Boolean for flipbook texture.

Definition at line 398 of file SLParticleSystem.h.

_doGravity

SLbool SLParticleSystem::_doGravity = false

private

Boolean for gravity.

Definition at line 392 of file SLParticleSystem.h.

_doInstancedDrawing

SLbool SLParticleSystem::_doInstancedDrawing = false

private

Boolean for instanced rendering.

Definition at line 399 of file SLParticleSystem.h.

_doRotation

SLbool SLParticleSystem::_doRotation = true

private

Boolean for rotation.

Definition at line 384 of file SLParticleSystem.h.

_doRotRange

SLbool SLParticleSystem::_doRotRange = false

private

Boolean for rotation range (random value between range)

Definition at line 385 of file SLParticleSystem.h.

_doShape

SLbool SLParticleSystem::_doShape = false

private

Boolean for shape feature.

Definition at line 387 of file SLParticleSystem.h.

_doShapeOverride

SLbool SLParticleSystem::_doShapeOverride = false

private

Boolean for override direction for shape direction.

Definition at line 389 of file SLParticleSystem.h.

_doShapeSpawnBase

SLbool SLParticleSystem::_doShapeSpawnBase = false

private

Boolean for spawn at base of shape (for cone and pyramid)

Definition at line 390 of file SLParticleSystem.h.

_doShapeSurface

SLbool SLParticleSystem::_doShapeSurface = false

private

Boolean for shape surface (particle will be spawned on surface)

Definition at line 388 of file SLParticleSystem.h.

_doSizeOverLT

SLbool SLParticleSystem::_doSizeOverLT = true

private

Boolean for size over life time.

Definition at line 396 of file SLParticleSystem.h.

_doSizeOverLTCurve

SLbool SLParticleSystem::_doSizeOverLTCurve = false

private

Boolean for size over life time curve.

Definition at line 397 of file SLParticleSystem.h.

_doSpeedRange

SLbool SLParticleSystem::_doSpeedRange = false

private

Boolean for speed range.

Definition at line 380 of file SLParticleSystem.h.

_doWorldSpace

SLbool SLParticleSystem::_doWorldSpace = false

private

Boolean for world space position.

Definition at line 391 of file SLParticleSystem.h.

_drawBuf

int SLParticleSystem::_drawBuf = 0

private

Boolean to switch buffer.

Definition at line 323 of file SLParticleSystem.h.

_drawTime

AvgFloat SLParticleSystem::_drawTime

private

Averaged time for drawing in MS.

Definition at line 333 of file SLParticleSystem.h.

_emitterPos

SLVec3f SLParticleSystem::_emitterPos

private

Position of the particle emitter.

Definition at line 290 of file SLParticleSystem.h.

_flipbookColumns

SLint SLParticleSystem::_flipbookColumns = 8

private

Number of flipbook sub-textures by column.

Definition at line 328 of file SLParticleSystem.h.

_flipbookFPS

int SLParticleSystem::_flipbookFPS = 16

private

Number of update of flipbook by second.

Definition at line 326 of file SLParticleSystem.h.

_flipbookRows

SLint SLParticleSystem::_flipbookRows = 8

private

Number of flipbook sub-textures by row.

Definition at line 329 of file SLParticleSystem.h.

_flipboookLastUpdate

float SLParticleSystem::_flipboookLastUpdate = 0.0f

private

Last time flipbook was updated.

Definition at line 327 of file SLParticleSystem.h.

_gravity

SLVec3f SLParticleSystem::_gravity = SLVec3f(0.0f, -9.81f, 0.0f)

private

Vector for gravity (2nd. acceleration vector)

Definition at line 307 of file SLParticleSystem.h.

_instanceVao1

SLGLVertexArray SLParticleSystem::_instanceVao1

private

1. VAO for instanced rendering with vao1

Definition at line 369 of file SLParticleSystem.h.

_instanceVao2

SLGLVertexArray SLParticleSystem::_instanceVao2

private

1. VAO for instanced rendering with vao2

Definition at line 370 of file SLParticleSystem.h.

_isGenerated

SLbool SLParticleSystem::_isGenerated = false

private

Boolean to generate particle system and load it on the GPU.

Definition at line 375 of file SLParticleSystem.h.

_isPaused

SLbool SLParticleSystem::_isPaused = false

private

Boolean to stop updating.

Definition at line 374 of file SLParticleSystem.h.

_isVisibleInFrustum

SLbool SLParticleSystem::_isVisibleInFrustum = true

private

Boolean to set time since node not visible.

Definition at line 373 of file SLParticleSystem.h.

_lastTimeBeforePauseS

SLfloat SLParticleSystem::_lastTimeBeforePauseS = 0.0f

private

Time since the particle system is paused.

Definition at line 343 of file SLParticleSystem.h.

_notVisibleTimeS

SLfloat SLParticleSystem::_notVisibleTimeS = 0.0f

private

Time since start when node not visible in S.

Definition at line 340 of file SLParticleSystem.h.

_radiusH

SLfloat SLParticleSystem::_radiusH = 0.4f

private

height radius of a particle

Definition at line 293 of file SLParticleSystem.h.

_radiusW

SLfloat SLParticleSystem::_radiusW = 0.4f

private

width radius of a particle

Definition at line 292 of file SLParticleSystem.h.

_scale

SLfloat SLParticleSystem::_scale = 1.0f

private

Scale of a particle (Scale the radius)

Definition at line 294 of file SLParticleSystem.h.

_shapeAngle

SLfloat SLParticleSystem::_shapeAngle = 10.0f

private

Angle of cone and pyramid shapes.

Definition at line 349 of file SLParticleSystem.h.

_shapeHeight

SLfloat SLParticleSystem::_shapeHeight = 3.0f

private

Height of cone and pyramid shapes.

Definition at line 348 of file SLParticleSystem.h.

_shapeRadius

SLfloat SLParticleSystem::_shapeRadius = 1.0f

private

Radius of sphere and cone shape.

Definition at line 346 of file SLParticleSystem.h.

_shapeScale

SLVec3f SLParticleSystem::_shapeScale = SLVec3f(1.0f)

private

Scale of box shape.

Definition at line 347 of file SLParticleSystem.h.

_shapeType

SLShapeType SLParticleSystem::_shapeType = ST_Sphere

private

Shape type (ST_)

Definition at line 358 of file SLParticleSystem.h.

_shapeWidth

SLfloat SLParticleSystem::_shapeWidth = 2.0f

private

Width of pyramid shape.

Definition at line 350 of file SLParticleSystem.h.

_speed

SLfloat SLParticleSystem::_speed = 1.0f

private

Speed of particle.

Definition at line 316 of file SLParticleSystem.h.

_speedRange

SLVec2f SLParticleSystem::_speedRange = SLVec2f(1, 2)

private

Speed random between two value.

Definition at line 317 of file SLParticleSystem.h.

_startDrawTimeMS

SLfloat SLParticleSystem::_startDrawTimeMS = 0.0f

private

Time since start of draw in MS.

Definition at line 334 of file SLParticleSystem.h.

_startUpdateTimeMS

SLfloat SLParticleSystem::_startUpdateTimeMS = 0.0f

private

Time since start for updating in MS.

Definition at line 335 of file SLParticleSystem.h.

_startUpdateTimeS

SLfloat SLParticleSystem::_startUpdateTimeS = 0.0f

private

Time since start for updating in S.

Definition at line 336 of file SLParticleSystem.h.

_texFlipbook

SLGLTexture* SLParticleSystem::_texFlipbook

private

Flipbook texture with e.g. multiple flames at subsequent frames.

Definition at line 363 of file SLParticleSystem.h.

_texGradient

SLTexColorLUT* SLParticleSystem::_texGradient

private

Color gradient texture.

Definition at line 364 of file SLParticleSystem.h.

_texParticle

SLGLTexture* SLParticleSystem::_texParticle

private

Main texture of PS (non flipbook)

Definition at line 362 of file SLParticleSystem.h.

_timeToLive

SLfloat SLParticleSystem::_timeToLive

private

Time to live of a particle.

Definition at line 291 of file SLParticleSystem.h.

_updateTime

AvgFloat SLParticleSystem::_updateTime

private

Averaged time for updating in MS.

Definition at line 332 of file SLParticleSystem.h.

_vao1

SLGLVertexArray SLParticleSystem::_vao1

private

1. VAO for swapping between updating/drawing

Definition at line 367 of file SLParticleSystem.h.

_vao2

SLGLVertexArray SLParticleSystem::_vao2

private

1. VAO for swapping between updating/drawing

Definition at line 368 of file SLParticleSystem.h.

_velocityConst

SLVec3f SLParticleSystem::_velocityConst = SLVec3f(0, 1, 0)

private

Velocity constant (go in xyz direction)

Definition at line 310 of file SLParticleSystem.h.

_velocityRndMax

SLVec3f SLParticleSystem::_velocityRndMax = SLVec3f(1, 1, 1)

private

Max. random velocity.

Definition at line 312 of file SLParticleSystem.h.

_velocityRndMin

SLVec3f SLParticleSystem::_velocityRndMin = SLVec3f(-1, -1, -1)

private

Min. random velocity.

Definition at line 311 of file SLParticleSystem.h.

_velocityType

SLint SLParticleSystem::_velocityType = 0

private

Velocity type.

Definition at line 359 of file SLParticleSystem.h.

---

The documentation for this class was generated from the following files:

• SLParticleSystem.h
• SLParticleSystem.cpp