ParticleEmitter3D_UserData.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */
 
#ifndef HPL_PARTICLE_EMITTER_3D_USER_DATA_H
#define HPL_PARTICLE_EMITTER_3D_USER_DATA_H
 
#include "hpl1/engine/graphics/ParticleEmitter3D.h"
#include "hpl1/engine/graphics/Renderable.h"
#include "hpl1/engine/physics/PhysicsWorld.h"
#include "hpl1/engine/scene/Entity3D.h"
 
class TiXmlElement;
 
namespace hpl {
 
enum ePEStartPosType {
    ePEStartPosType_Box,
    ePEStartPosType_Sphere,
    ePEStartPosType_LastEnum,
};
 
enum ePEDeathType {
    ePEDeathType_Age,
    ePEDeathType_Color,
    ePEDeathType_LastEnum,
};
 
enum ePEGravityType {
    ePEGravityType_None,   // No gravity added
    ePEGravityType_Vector, // Vector is used.
    ePEGravityType_Center, // Y axis used. heading equals center.
    ePEGravityType_LastEnum,
};
 
enum ePESubDivType {
    ePESubDivType_Random,
    ePESubDivType_Animation,
    ePESubDivType_LastEnum,
};
 
enum ePEPartSpinType {
    ePEPartSpinType_Constant,
    ePEPartSpinType_Movement,
    ePEPartSpinType_LastEnum,
};
 
//------------------------------------
 
//------------------------------------
 
class cParticleEmitterData3D_UserData : public iParticleEmitterData, public iPhysicsRayCallback {
    friend class cParticleEmitter3D_UserData;
 
public:
    cParticleEmitterData3D_UserData(const tString &asName, cResources *apResources, cGraphics *apGraphics);
 
    iParticleEmitter *Create(tString asName, cVector3f avSize);
 
    void LoadFromElement(TiXmlElement *apElement);
 
    bool CheckCollision(const cVector3f &avStart, const cVector3f &avEnd,
                        iPhysicsWorld *apPhysicsWorld,
                        cVector3f *apNormalVec,
                        cVector3f *apPosVec);
 
private:
    bool OnIntersect(iPhysicsBody *pBody, cPhysicsRayParams *apParams);
    float mfShortestDist;
    bool mbIntersected;
    cVector3f *mpIntersectNormal;
    cVector3f *mpIntersectPos;
 
 
    // NEW
    ePEType mPEType;
    // ---
 
    int mlMaxParticleNum;
 
    bool mbRespawn;
 
    float mfParticlesPerSecond;
    float mfStartTimeOffset;
 
    float mfMinPauseLength;
    float mfMaxPauseLength;
 
    float mfMinPauseInterval;
    float mfMaxPauseInterval;
 
    cVector3f mvPosOffset;
    cVector3f mvAngleOffset;
 
    float mfFrameStep;
    float mfMaxFrameTime;
 
 
    cVector2l mvSubDiv;
    ePESubDivType mSubDivType;
 
    ePEStartPosType mStartPosType;
 
    cVector3f mvMinStartPos;
    cVector3f mvMaxStartPos;
 
    cVector2f mvMinStartAngles;
    cVector2f mvMaxStartAngles;
 
    float mfMinStartRadius;
    float mfMaxStartRadius;
 
    ePEStartPosType mStartVelType;
 
    cVector3f mvMinStartVel;
    cVector3f mvMaxStartVel;
 
    cVector2f mvMinStartVelAngles;
    cVector2f mvMaxStartVelAngles;
 
    float mfMinStartVelSpeed;
    float mfMaxStartVelSpeed;
 
    float mfMinSpeedMultiply;
    float mfMaxSpeedMultiply;
 
    cVector3f mvMinStartAcc;
    cVector3f mvMaxStartAcc;
 
    float mfMinVelMaximum;
    float mfMaxVelMaximum;
 
    bool mbUsesDirection;
    ePEGravityType mGravityType;
 
    cVector3f mvGravityAcc;
 
    eParticleEmitter3DCoordSystem mCoordSystem;
 
    // NEW
 
    bool mbUsePartSpin;
    ePEPartSpinType mPartSpinType;
    float mfMinSpinRange;
    float mfMaxSpinRange;
 
    bool mbUseRevolution;
    cVector3f mvMinRevVel;
    cVector3f mvMaxRevVel;
 
    //      iVertexBuffer *mVBMeshData;
    //      float *mpfMeshVtxData;
 
    // ---
 
    float mfMinLifeSpan;
    float mfMaxLifeSpan;
 
    ePEDeathType mDeathType;
 
    tString msDeathPS;
 
    eParticleEmitter3DType mDrawType;
 
    cVector2f mvMinStartSize;
    cVector2f mvMaxStartSize;
 
    float mfStartRelSize;
    float mfMiddleRelSize;
    float mfMiddleRelSizeTime;
    float mfMiddleRelSizeLength;
    float mfEndRelSize;
 
    bool mbMultiplyRGBWithAlpha;
 
 
    cColor mMinStartColor;
    cColor mMaxStartColor;
 
    cColor mStartRelColor;
    cColor mMiddleRelColor;
    float mfMiddleRelColorTime;
    float mfMiddleRelColorLength;
    cColor mEndRelColor;
 
    bool mbCollides;
 
    float mfMinBounceAmount;
    float mfMaxBounceAmount;
 
    int mlMinCollisionMax;
    int mlMaxCollisionMax;
 
    int mlCollisionUpdateRate;
 
    // NEW
 
    bool mbUseBeamNoise;
 
    int mlLowFreqPoints;
    Common::Array<unsigned int> mvLFIndices;
    cVector3f mvMinLowFreqNoise;
    cVector3f mvMaxLowFreqNoise;
 
    int mlHighFreqPoints;
    cVector3f mvMinHighFreqNoise;
    cVector3f mvMaxHighFreqNoise;
 
    Common::Array<tBeamNoisePoint> mvBeamNoisePoints;
 
    // ---
};
 
//----------------------------------------------------------
 
class cParticleEmitter3D_UserData : public iParticleEmitter3D {
public:
    cParticleEmitter3D_UserData(tString asName, tMaterialVec *avMaterials,
                                cVector3f avSize, cGraphics *apGraphics, cResources *apResources,
                                cParticleEmitterData3D_UserData *apData);
    ~cParticleEmitter3D_UserData(void);
 
    void Kill();
 
    bool IsDying();
 
private:
    void UpdateMotion(float afTimeStep);
    void SetParticleDefaults(cParticle *apParticle);
 
    cParticleEmitterData3D_UserData *mpData;
 
    float mfTime;
    float mfCreateCount;
 
    float mfCollideCount;
 
    float mfPauseCount;
    float mfPauseWaitCount;
    bool mbPaused;
 
    bool mbRespawn;
};
 
} // namespace hpl
 
#endif // HPL_PARTICLE_EMITTER_3D_USER_DATA_H