moEffectParticlesSimple.h

Ir a la documentación de este archivo.

/*******************************************************************************

                              moEffectParticlesSimple.h

  ****************************************************************************
  *                                                                          *
  *   This source 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 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                          *
  *   This code 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.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa

  \brief Particles Effect Plugin, Simple Version
  \todo 1) ColorIn 2) ColorOut 3) BreakIn 4) BreakOut
  \todo 5) Script general
  \todo 6) Script por particula ( se ejecuta por cada particula ) ( acceso a eventos [tecla presionada...] )
  \todo *) movimiento y posicionamieno de particuclas....
  \todo 7) parametro desfazaje de movimiento??? que sea una opcion...
  \todo 8) Improve the orientation modes... they dont work correctly


*******************************************************************************/

#ifndef __MO_EFFECT_PARTICLES_H__
#define __MO_EFFECT_PARTICLES_H__

#include "moTypes.h"
#include "moTimer.h"
#include "moTempo.h"
#include "moPlugin.h"
#include "moTimeManager.h"
#include "moFilterManager.h"

#define MO_PARTICLES_TRANSLATE_X 0
#define MO_PARTICLES_TRANSLATE_Y 1
#define MO_PARTICLES_SCALE_X 2
#define MO_PARTICLES_SCALE_Y 3




enum moParticlesSimpleEmitterType {
  PARTICLES_EMITTERTYPE_GRID = 0,
  PARTICLES_EMITTERTYPE_SPHERE = 1,
  PARTICLES_EMITTERTYPE_TUBE = 2,
  PARTICLES_EMITTERTYPE_JET = 3,
  PARTICLES_EMITTERTYPE_POINT = 4,
  PARTICLES_EMITTERTYPE_TRACKER = 5,
  PARTICLES_EMITTERTYPE_TRACKER2 = 6,
  PARTICLES_EMITTERTYPE_SPIRAL = 7,
  PARTICLES_EMITTERTYPE_CIRCLE = 8
};


enum moParticlesSimpleFolderShotType {
  PARTICLES_SHOTTYPE_FOLDER_RANDOM = 0,
  PARTICLES_SHOTTYPE_FOLDER_SEQUENTIAL_BY_FILEDATE = 1,
  PARTICLES_SHOTTYPE_FOLDER_SEQUENTIAL_BY_FILENAME = 2
};

enum moParticlesSimpleAttractorType {
  PARTICLES_ATTRACTORTYPE_POINT = 0,
  PARTICLES_ATTRACTORTYPE_GRID = 1,
  PARTICLES_ATTRACTORTYPE_SPHERE = 2,
  PARTICLES_ATTRACTORTYPE_TUBE = 3,
  PARTICLES_ATTRACTORTYPE_JET = 4,
  PARTICLES_ATTRACTORTYPE_TRACKER = 5,
  PARTICLES_ATTRACTORTYPE_VERTEX = 6
};

enum moParticlesSimpleAttractorMode {
  PARTICLES_ATTRACTORMODE_ACCELERATION = 0,
  PARTICLES_ATTRACTORMODE_STICK = 1,
  PARTICLES_ATTRACTORMODE_BOUNCE = 2,
  PARTICLES_ATTRACTORMODE_BREAKS = 3,
  PARTICLES_ATTRACTORMODE_BRAKE = 4,
  PARTICLES_ATTRACTORMODE_LINEAR = 5
};

enum moParticlesSimpleBehaviourMode {
  PARTICLES_BEHAVIOUR_COHESION = 0,
  PARTICLES_BEHAVIOUR_SEPARATION = 1,
  PARTICLES_BEHAVIOUR_AVOIDANCE = 2,
  PARTICLES_BEHAVIOUR_ALIGNMENT = 3
};


enum moParticlesSimpleTextureMode {
    PARTICLES_TEXTUREMODE_UNIT = 0,
    PARTICLES_TEXTUREMODE_PATCH = 1,
    PARTICLES_TEXTUREMODE_MANY = 2,
    PARTICLES_TEXTUREMODE_MANY2PATCH = 3
};

static moTextArray TextureModeOptions;

enum moParticlesCreationMethod {
    PARTICLES_CREATIONMETHOD_LINEAR=0,
    PARTICLES_CREATIONMETHOD_PLANAR=1,
    PARTICLES_CREATIONMETHOD_VOLUMETRIC=2,
    PARTICLES_CREATIONMETHOD_CENTER=3
};

enum moParticlesRandomMethod {
    PARTICLES_RANDOMMETHOD_NOISY=0,
    PARTICLES_RANDOMMETHOD_COLINEAR=1,
    PARTICLES_RANDOMMETHOD_PERPENDICULAR=2
};

enum moParticlesOrientationMode {
    PARTICLES_ORIENTATIONMODE_FIXED=0,
    PARTICLES_ORIENTATIONMODE_CAMERA=1,
    PARTICLES_ORIENTATIONMODE_MOTION=2,
    PARTICLES_ORIENTATIONMODE_ACCELERATION=3
};

enum moParticlesOrderingMode {
    PARTICLES_ORDERING_MODE_NONE=0,
    PARTICLES_ORDERING_MODE_ZDEPTHTEST=1,
    PARTICLES_ORDERING_MODE_ZPOSITION=2,
    PARTICLES_ORDERING_MODE_COMPLETE=3
};


enum moParticlesSimpleParamIndex {
  PARTICLES_INLET,
  PARTICLES_OUTLET,
  PARTICLES_SCRIPT,
    PARTICLES_ALPHA,
    PARTICLES_COLOR,
    PARTICLES_SYNC,
    PARTICLES_PHASE,
    PARTICLES_PARTICLECOLOR,
    PARTICLES_FONT,
    PARTICLES_TEXT,
    PARTICLES_ORTHO,

    PARTICLES_TEXTURE,
    PARTICLES_FOLDERS,
    PARTICLES_TEXTUREMODE,
    PARTICLES_BLENDING,

    PARTICLES_WIDTH,
    PARTICLES_HEIGHT,
    PARTICLES_SIZEX,
    PARTICLES_SIZEY,
    PARTICLES_SIZEZ,

    PARTICLES_GRAVITY,
    PARTICLES_VISCOSITY,

    PARTICLES_MAXAGE,
    PARTICLES_EMITIONPERIOD,
    PARTICLES_EMITIONRATE,
    PARTICLES_DEATHPERIOD,
  PARTICLES_SCRIPT2,

    PARTICLES_FADEIN,
    PARTICLES_FADEOUT,
    PARTICLES_SIZEIN,
    PARTICLES_SIZEOUT,

    PARTICLES_RANDOMMETHOD,
    PARTICLES_CREATIONMETHOD,
    PARTICLES_ORIENTATIONMODE,

    PARTICLES_RANDOMPOSITION,
    PARTICLES_RANDOMPOSITION_X,
    PARTICLES_RANDOMPOSITION_Y,
    PARTICLES_RANDOMPOSITION_Z,

    PARTICLES_RANDOMVELOCITY,
    PARTICLES_RANDOMVELOCITY_X,
    PARTICLES_RANDOMVELOCITY_Y,
    PARTICLES_RANDOMVELOCITY_Z,

    PARTICLES_RANDOMMOTION,
    PARTICLES_RANDOMMOTION_X,
    PARTICLES_RANDOMMOTION_Y,
    PARTICLES_RANDOMMOTION_Z,


    PARTICLES_EMITTERTYPE,
    PARTICLES_EMITTERVECTOR_X,
    PARTICLES_EMITTERVECTOR_Y,
    PARTICLES_EMITTERVECTOR_Z,

    PARTICLES_ATTRACTORTYPE,
    PARTICLES_ATTRACTORMODE,
    PARTICLES_ATTRACTORVECTOR_X,
    PARTICLES_ATTRACTORVECTOR_Y,
    PARTICLES_ATTRACTORVECTOR_Z,

    PARTICLES_ROTATEX_PARTICLE,
    PARTICLES_ROTATEY_PARTICLE,
    PARTICLES_ROTATEZ_PARTICLE,
  PARTICLES_SCALEX_PARTICLE,
    PARTICLES_SCALEY_PARTICLE,
    PARTICLES_SCALEZ_PARTICLE,

    PARTICLES_TIMETOREVELATION,
    PARTICLES_TIMEOFREVELATION,
    PARTICLES_TIMETORESTORATION,
    PARTICLES_TIMEOFRESTORATION,
    PARTICLES_DRAWINGFEATURES,

    PARTICLES_TRANSLATEX,
    PARTICLES_TRANSLATEY,
    PARTICLES_TRANSLATEZ,
  PARTICLES_SCALEX,
    PARTICLES_SCALEY,
    PARTICLES_SCALEZ,
    PARTICLES_ROTATEX,
    PARTICLES_ROTATEY,
    PARTICLES_ROTATEZ,
    PARTICLES_EYEX,
    PARTICLES_EYEY,
    PARTICLES_EYEZ,
    PARTICLES_VIEWX,
    PARTICLES_VIEWY,
    PARTICLES_VIEWZ,
  PARTICLES_ORDERING_MODE
};


class moParticlesSimple : public moAbstract {

  public:

    moParticlesSimple() {

      Pos3d = moVector3f(0.0,0.0,0.0);
      Destination = moVector3f(0.0,0.0,0.0);
      Velocity = moVector3f(0.0,0.0,0.0);
      Force = moVector3f(0.0,0.0,0.0);
      U = moVector3f(0.0,0.0,0.0);
      V = moVector3f(0.0,0.0,0.0);
      W = moVector3f(0.0,0.0,0.0);
      dpdt = moVector3f(0.0,0.0,0.0);
      dvdt = moVector3f(0.0,0.0,0.0);
      Rotation = moVector3f(0.0,0.0,0.0);


      Pos = moVector2f(0.0,0.0);
      TCoord = moVector2f(0.0,0.0);
      TCoord2 = moVector2f(0.0,0.0);
      Size = moVector2f(0.0,0.0);
      TSize = moVector2f(0.0,0.0);
      TSize2 = moVector2f(0.0,0.0);
      Color = moVector3f(1.0,1.0,1.0);

      Mass = 1.0;
      Alpha = 1.0;
      Scale = 1.0;
      ImageProportion = 1.0;

      Fixed = false;
      Visible = false;
      Captured = false;

      /* Graphics  */
      GLId = -1;
      GLId2 = -1;
      pTextureMemory = NULL;

      MOId = -1;

      ActualFrame = 0;
      FrameCount = 0;
      FramePS = 0;

      FrameForced = false;

      MaxAge = 0; //depends on Physics.MaxAge first....
      Age.Stop();

    }
    virtual ~moParticlesSimple() {}

    moVector3f  Pos3d;

    moVector3f  Destination;

    moVector3f  Velocity;

    moVector3f  Force;



    moVector2f  Pos;//relativo a una grilla

    moVector2f  TCoord;
    moVector2f  TCoord2;


    moVector2f  Size;

    moVector2f  TSize;
    moVector2f  TSize2;


    moVector3f  U,V,W;

    moVector3f  dpdt;
    moVector3f  dvdt;

    double      Mass;

    bool        Fixed;

    bool        Visible;


    bool        Captured;


    double      Alpha;

    double      Scale;

    moVector3f      Rotation;

    MOint       GLId;
    MOint       GLId2;
    moTextureMemory *pTextureMemory;

    bool        FrameForced;
    int         MOId;
    MOuint      ActualFrame;
    MOuint      FrameCount;
    MOuint      FramePS;

    float       ImageProportion;

    moVector3f  Color;

    moTimer     Age;
    long        MaxAge;
};

class moParticlesSimplePhysics : public moAbstract {

  public:

    moParticlesSimplePhysics() {
      m_GravityCenter = moVector3f(0.0,0.0,0.0);
      m_GravityVector = moVector3f(0.0,0.0,0.0);
      m_GravityDisc = moVector3f(0.0,0.0,0.0);

      m_Plane = moVector3f(0.0,0.0,0.0);

      m_MaxAge = 0;
      m_EmitionPeriod = 0;
      m_EmitionRate = 0;
      m_DeathPeriod = 0;

      m_CreationMethod = PARTICLES_CREATIONMETHOD_LINEAR;
      m_RandomMethod = PARTICLES_RANDOMMETHOD_NOISY;
      m_OrientationMode = PARTICLES_ORIENTATIONMODE_FIXED;
      m_OrderingMode = PARTICLES_ORDERING_MODE_NONE;

      m_FadeIn = 0.0;
      m_FadeOut = 0.0;
      m_SizeIn = 0.0;
      m_SizeOut = 0.0;

      m_EmitterType = PARTICLES_EMITTERTYPE_GRID;
      m_EmitterSize = moVector3f( 0.0, 0.0, 0.0 );
      m_EmitterVector = moVector3f( 0.0, 0.0, 0.0 );

      m_AttractorType = PARTICLES_ATTRACTORTYPE_POINT;
      m_AttractorMode = PARTICLES_ATTRACTORMODE_ACCELERATION;
      m_AttractorVector = moVector3f( 0.0, 0.0, 0.0 );

      m_EyeVector = moVector3f( 0.0, 0.0, 0.0 );

      m_RandomVelocity = 0.0;
      m_VelocityVector = moVector3f( 0.0, 0.0, 0.0 );

      m_RandomPosition = 0.0;
      m_PositionVector = moVector3f( 0.0, 0.0, 0.0 );

      m_RandomMotion = 0.0;
      m_MotionVector = moVector3f( 0.0, 0.0, 0.0 );

      gravitational = 0.0;
      viscousdrag = 0.0;

      EmitionTimer.Stop();

      m_ParticleScript = moText("");

      m_pLastBordParticle = NULL;


    }
    virtual ~moParticlesSimplePhysics() {}


    moVector3f      m_GravityCenter;//x,y,z,intensity
    moVector3f      m_GravityVector;//x,y,z,intensity
    moVector3f      m_GravityDisc;//normal x, normal y, normal z,intensity

    moVector3f      m_Plane;

    long            m_MaxAge;
    long            m_EmitionPeriod;
    long            m_EmitionRate;
    long            m_DeathPeriod;

    moParticlesCreationMethod   m_CreationMethod;
    moParticlesRandomMethod     m_RandomMethod;
    moParticlesOrientationMode  m_OrientationMode;
    moParticlesOrderingMode     m_OrderingMode;

    double          m_FadeIn;
    double            m_FadeOut;
    double            m_SizeIn;
    double            m_SizeOut;

    moParticlesSimpleEmitterType    m_EmitterType;
    moVector3f      m_EmitterVector;
    moVector3f      m_EmitterSize;

    moParticlesSimpleAttractorType    m_AttractorType;
    moParticlesSimpleAttractorMode    m_AttractorMode;
    moVector3f      m_AttractorVector;

    moVector3f      m_EyeVector;

    double          m_RandomVelocity;
    moVector3f      m_VelocityVector;

    double           m_RandomPosition;
    moVector3f      m_PositionVector;

    double          m_RandomMotion;
    moVector3f      m_MotionVector;

    double gravitational;
    double viscousdrag;

    moTimer EmitionTimer;

    moText  m_ParticleScript;

    moParticlesSimple*  m_pLastBordParticle;




};


enum enumRevelationStatus {

    PARTICLES_FULLRESTORED = 0,
    PARTICLES_REVEALING = 1,
    PARTICLES_REVEALINGALL = 2,
    PARTICLES_FULLREVEALED = 3,
    PARTICLES_RESTORING = 4,
    PARTICLES_RESTORINGALL = 5
};



moDeclareDynamicArray( moParticlesSimple*, moParticlesSimpleArray );

typedef std::map< double, moParticlesSimple* > TMapDepthToParticleSimple;



class moEffectParticlesSimple : public moEffect
{
    public:

        moEffectParticlesSimple();

        virtual ~moEffectParticlesSimple();

        MOboolean Init();

        void Draw(moTempo*, moEffectState* parentstate = NULL);

        MOboolean Finish();

        void ReInit();

        void Shot( moText source = moText(""), int shot_type = 0, int shot_file=0  );

        void Interaction( moIODeviceManager * );

        void Update( moEventList * p_eventlist);

        moConfigDefinition * GetDefinition( moConfigDefinition *p_configdefinition );

        int ScriptCalling(moLuaVirtualMachine& vm, int iFunctionNumber);

        void TrackParticle( int partid );

        void OrderParticles();

    private:

        void UpdateDt();

        void UpdateParameters();

        void ResetTimers();
        void RevealingAll();
        void RestoringAll();

        void InitParticlesSimple( int p_cols, int p_rows , bool p_forced = true  );

        void CalculateForces( bool tmparray = false );

        void CalculateDerivatives( bool tmparray = false, double dt = 0.0 );


        void UpdateParticles( double dt, int method );


        void Regenerate();

        double Solver1D( double h, double y0, int method, double (*fcn)(double) );

        void SetParticlePosition( moParticlesSimple* pParticle );


        void ParticlesSimpleInfluence( float posx, float posy, float velx, float vely, float veln );
        void ParticlesSimpleAnimation( moTempo* tempogral, moEffectState* parentstate );

        void DrawParticlesSimple( moTempo* tempogral, moEffectState* parentstate );
        void DrawTracker();

        void RegisterFunctions();

        int luaGetDelta(moLuaVirtualMachine& vm);
        int luaGetParticleCount(moLuaVirtualMachine& vm);
        int luaGetParticle(moLuaVirtualMachine& vm);
        int luaGetParticlePosition(moLuaVirtualMachine& vm);
        int luaGetParticleSize(moLuaVirtualMachine& vm);
        int luaGetParticleScale(moLuaVirtualMachine& vm);
        int luaGetParticleVelocity(moLuaVirtualMachine& vm);
        int luaGetParticleRotation(moLuaVirtualMachine& vm);
        int luaGetParticleGraphics(moLuaVirtualMachine& vm);

        int luaUpdateParticle( moLuaVirtualMachine& vm );
        int luaUpdateParticlePosition( moLuaVirtualMachine& vm );
        int luaUpdateParticleSize( moLuaVirtualMachine& vm );
        int luaUpdateParticleScale( moLuaVirtualMachine& vm );
        int luaUpdateParticleVelocity( moLuaVirtualMachine& vm );
        int luaUpdateParticleRotation( moLuaVirtualMachine& vm );
        int luaUpdateParticleGraphics( moLuaVirtualMachine& vm );

        int luaUpdateForce( moLuaVirtualMachine& vm );

        int luaShot(moLuaVirtualMachine& vm);
        int luaReInit(moLuaVirtualMachine& vm);

        int luaDrawPoint(moLuaVirtualMachine& vm);
        int luaGetParticleIntersection(moLuaVirtualMachine& vm);


        moInlet*                  m_pParticleTime;
        moInlet*                  m_pParticleIndex;

        moParticlesSimpleArray    m_ParticlesSimpleArray;
        moParticlesSimpleArray    m_ParticlesSimpleArrayTmp;
        moParticlesSimplePhysics    m_Physics;

        bool                    m_bTrackerInit;

        moTrackerSystemData*    m_pTrackerData;
        MOint                   m_InletTrackerSystemIndex;

        #ifdef USE_TUIO
        moTUIOSystemData*       m_pTUIOData;
        MOint                   m_InletTuioSystemIndex;
        #endif



        moVector2f              m_TrackerBarycenter;


        void setUpLighting();

        int m_rows,m_cols;
        float normalf; 

        long time_tofull_revelation;
        long time_tofull_restoration;
        long time_of_revelation;
        long time_of_restoration;
        long drawing_features; 
        long texture_mode;



        bool ortho;

        moTimer MotionTimer;

        moTimer TimerFullRevelation; 
        moTimer TimerFullRestoration;
        moTimer TimerOfRevelation; 
        moTimer TimerOfRestoration;

        moTimer FeatureActivity;
        moTimer MotionActivity;
        moTimer NoMotionActivity;

        enumRevelationStatus revelation_status; 

        long    m_Rate;

        long    last_tick;

        //special for script
        moTexture* pTextureDest;
        moTexture* pSubSample;
        MObyte* samplebuffer;

        int glidori;
        int glid;
        int frame;

        int original_width;
        int original_height;
        float original_proportion;

        float emiper;
        long emiperi;

        float midi_red, midi_green, midi_blue;
        float midi_maxage; //in millis
        float midi_emitionperiod;//in millisec
        float midi_emitionrate; // n per emitionperiod
        float midi_randomvelocity; //inicial vel
        float midi_randommotion; //motion dynamic

        float tx,ty,tz;
        float sx,sy,sz;
        float rx,ry,rz;

        TMapDepthToParticleSimple m_OrderedParticles;

        double dtrel;
        double dt;
        long gral_ticks;

};

class moEffectParticlesSimpleFactory : public moEffectFactory
{
public:
    moEffectParticlesSimpleFactory() {}
    virtual ~moEffectParticlesSimpleFactory() {}
    moEffect* Create();
    void Destroy(moEffect* fx);
};

extern "C"
{
MO_PLG_API moEffectFactory* CreateEffectFactory();
MO_PLG_API void DestroyEffectFactory();
}

#endif