Particle.h

Go to the documentation of this file.

#ifndef PARTICLE_H_
#define PARTICLE_H_

#include <memory>
#include <string>
#include "imodel.h"
#include "texturelib.h"
#include "renderable.h"
#include "math/Vector2.h"
#include "math/Vector3.h"
#include "math/Vector4.h"
#include <time.h>
#include "../common/ScriptValues.h"

#define     MAX_PTLDEFS     256
#define     MAX_PTLCMDS     (MAX_PTLDEFS * 32)
#define     MAX_PCMD_DATA   (MAX_PTLCMDS * 8)
#define     MAX_STACK_DEPTH 8
#define     MAX_STACK_DATA  512

#define RADR(x)     ((x < 0) ? (byte*)p - x : (byte*) pcmdData + x)
#define RSTACK      -0xFFF0
#define F(x)        (1<<x)
#define V_VECS      (F(V_FLOAT) | F(V_POS) | F(V_VECTOR) | F(V_COLOR))
#define PTL_ONLY_ONE_TYPE       (1<<31)
#define V_UNTYPED   0x7FFF

namespace scripts
{
    class Particle;
    class ParticleCommand;
    class ParticleDefinition;

    // Smart pointer typedef
    typedef std::auto_ptr<scripts::Particle> IParticlePtr;
    typedef std::auto_ptr<scripts::ParticleCommand> IParticleCommandPtr;
    typedef std::auto_ptr<scripts::ParticleDefinition> IParticleDefinitionPtr;

    class ParticleCommand
    {
        public:
            unsigned char cmd;
            unsigned char type;
            int ref;
    };

    class ParticleDefinition
    {
        public:
            std::string name;
            IParticleCommandPtr init;
            IParticleCommandPtr run;
            IParticleCommandPtr think;
            IParticleCommandPtr round;
            IParticleCommandPtr physics;
    };

    namespace
    {

        static IParticleDefinitionPtr ptlDef[MAX_PTLDEFS];
        static IParticleCommandPtr ptlCmd[MAX_PTLCMDS];

        enum
        {
            V_FLOAT, V_POS, V_COLOR, V_STRING, V_INT, V_BOOL, V_NUM_TYPES, V_VECTOR
        };

        static const char * vt_names[V_NUM_TYPES] = {"float", "pos", "color", "string", "int", "bool"};

        typedef enum pc_s
        {
            PC_END,

            PC_PUSH,
            PC_POP,
            PC_KPOP,
            PC_ADD,
            PC_SUB,
            PC_MUL,
            PC_DIV,
            PC_SIN,
            PC_COS,
            PC_TAN,
            PC_RAND,
            PC_CRAND,
            PC_V2,
            PC_V3,
            PC_V4,

            PC_KILL,
            PC_SPAWN,
            PC_NSPAWN,
            PC_CHILD,

            PC_NUM_PTLCMDS
        } pc_t;

        static const char *pc_strings[PC_NUM_PTLCMDS] = { "end",

        "push", "pop", "kpop", "add", "sub", "mul", "div", "sin", "cos", "tan", "rand", "crand", "v2", "v3", "v4",

        "kill", "spawn", "nspawn", "child" };

        static const int pc_types[PC_NUM_PTLCMDS] = { 0,

        V_UNTYPED, V_UNTYPED, V_UNTYPED, V_VECS, V_VECS, V_VECS, V_VECS, PTL_ONLY_ONE_TYPE | V_FLOAT, PTL_ONLY_ONE_TYPE
                | V_FLOAT, PTL_ONLY_ONE_TYPE | V_FLOAT, V_VECS, V_VECS, 0, 0, 0,

        0, PTL_ONLY_ONE_TYPE | V_STRING, PTL_ONLY_ONE_TYPE | V_STRING, PTL_ONLY_ONE_TYPE | V_STRING };

        typedef struct value_s
        {
                const char *string;
                const int type;
                const size_t ofs;
        } value_t;

#if 0
    static int numPtlDefs;
    static int numPtlCmds;

    static unsigned char pcmdData[MAX_PCMD_DATA];
    static unsigned char *pcmdPos;

    static unsigned char cmdStack[MAX_STACK_DATA];
    static void *stackPtr[MAX_STACK_DEPTH];
    static unsigned char stackType[MAX_STACK_DEPTH];
#endif
    }

    struct ParticleData
    {
            time_t msec;
            time_t frametime;

            model::IModelPtr modelPtr;
            qtexture_t *imagePtr;

            std::string model;
            std::string image;

            int blend;
            int style;
            Vector2 size;
            Vector3 scale;
            Vector4 color;
            Vector3 s; 
            Vector3 origin; 
            Vector3 offset;
            Vector3 angles;
            Vector3 lightColor;
            float lightIntensity;
            float lightSustain;
            int levelFlags;

            int skin; 
            IParticlePtr children; 
            IParticlePtr next; 
            IParticlePtr parent; 
            ParticleDefinition ctrl;
            int startTime;
            int frame, endFrame;
            float fps; 
            float lastFrame; 
            float tps; 
            float lastThink;
            unsigned char thinkFade, frameFade;
            float t; 
            float dt; 
            float life; 
            int rounds; 
            int roundsCnt;
            float scrollS;
            float scrollT;
            Vector3 a; 
            Vector3 v; 
            Vector3 omega; 
            bool physics; 
            bool autohide; 
            bool stayalive; 
            bool weather; 
    };

    class Particle: public Renderable
    {
        private:

            ParticleData _data;

        public:
            Particle ();

            virtual ~Particle ();

            std::string toString ();

            void render ();

            void renderSolid (Renderer& renderer, const VolumeTest& volume) const;

            void renderWireframe (Renderer& renderer, const VolumeTest& volume) const;

            void renderComponents (Renderer&, const VolumeTest&);

    };
    scripts::IParticlePtr loadParticle (const std::string& particleID);
}

#endif /* PARTICLE_H_ */