diguyParticleSystem.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2019 VT MAK
** All rights reserved.
*********************************************************************/

/*********************************************************************/
#ifndef __diguyParticleSystem_H
#define __diguyParticleSystem_H

#ifdef SWIG
%module diguyParticleSystem
#else
#define CPLUSPLUS_ONLY
#endif

#ifdef CPLUSPLUS_ONLY
#include <diguy_constants.h>
#include <stdlib.h>
#include <memory.h>

class diguyCharacter;
class diguyParticleManager;
class diguyParticleSystemRenderer;
class diguyGraphicsShaderProgram;
class diguyGraphicsTexture;
class diguyViewCamera;
struct diguyParticleDrawDesc;

#endif

#include <declspec_diguy.h>

//------------------------------------------------------------------------------        
class BDI_DECLSPEC_diguy diguyParticleSystem
{

public:
        diguyParticleSystem(const char * effect_name) : m_particle_manager(NULL), m_renderer(NULL),
                m_character(NULL), m_system_life_time_override(-1.0f), m_age(0.0f), m_visible(1), m_ready_for_garbage_collection(0),
                m_spawned_system(0)
        {
                ;
        }
        virtual ~diguyParticleSystem(){ ; }
        virtual const char * get_name() = 0;
        virtual void set_name(const char * name) = 0;

        virtual int update(float dt)
        {
                m_age += dt;
                if (m_system_life_time_override > 0.0 && m_age > m_system_life_time_override){
                        m_ready_for_garbage_collection = 1;
                        return 0;
                }
                return 1;
        }

        virtual void start_emitting() = 0;
        virtual void stop_emitting() = 0;
        virtual void pause_emitting() = 0;
        virtual void stop_all_particles() = 0;
        virtual void restart_particle_system() = 0;

        virtual int get_emitting() = 0;
        virtual int get_active_count() = 0;

        virtual void set_position(double x, double y, double z) = 0;
        virtual void get_position(double *x, double *y, double *z) = 0;

        virtual int set_visible(int visible){ m_visible = visible; return 0; }
        virtual int get_visible(){ return m_visible; }

        virtual void set_orientation(float * matrix) = 0;
        virtual void set_scale(float scale) = 0;
        virtual void set_scale(float scale_x, float scale_y, float scale_z) = 0;
        virtual void set_time_scale(float t) = 0;

        virtual void reset_prev_position_next_update() = 0;

        //internally defined
        diguyCharacter * get_character() { return m_character; }
        void set_character(diguyCharacter * character) { m_character = character; }
        void set_particle_manager(diguyParticleManager * manager){ m_particle_manager = manager; }
        diguyParticleManager * get_particle_manager() { return m_particle_manager; }

        virtual void render(diguyGraphicsShaderProgram * shader){ ; }

        void set_particle_renderer(diguyParticleSystemRenderer* renderer){
                m_renderer = renderer;
        }
        diguyParticleSystemRenderer* get_particle_renderer(){ return m_renderer; }

        virtual int get_ready_for_garbage_collection(){ return m_ready_for_garbage_collection; }
        virtual void set_ready_for_garbage_collection(int value){ m_ready_for_garbage_collection = value; }
        virtual float get_system_life_time_override(){ return m_system_life_time_override; }
        virtual void set_system_life_time_override(float value){ m_system_life_time_override = value; }

        virtual int get_spawned_system(){ return m_spawned_system; }
        virtual void set_spawned_system(int value){ m_spawned_system = value; }

protected:
        diguyParticleManager * m_particle_manager;
        diguyParticleSystemRenderer * m_renderer;
        diguyCharacter * m_character;
        int m_visible;
        float m_age;
        float m_system_life_time_override;
        int m_ready_for_garbage_collection;
        int m_spawned_system;
};


//------------------------------------------------------------------------------        
class diguyParticleSystemRenderer
{
public:
        diguyParticleSystemRenderer() {
                memset(m_camera_matrix, 0, 16 * sizeof(float));
                memset(m_world_rotation_matrix, 0, 16 * sizeof(float));

                m_camera_matrix[0] = m_camera_matrix[5] = m_camera_matrix[10] = m_camera_matrix[15] = 1.0f;
                m_world_rotation_matrix[0] = m_world_rotation_matrix[5] = m_world_rotation_matrix[10] = m_world_rotation_matrix[15] = 1.0f;
        }

        virtual void setup_particle_rendering(int render_pass_flags) = 0;

        virtual void end_particle_rendering(int render_pass_flags) = 0;

        virtual void draw_particle_buffer(const diguyParticleDrawDesc * draw_desc, void * particle_data) = 0;

        float m_camera_matrix[16];
        float m_world_rotation_matrix[16];
};


//------------------------------------------------------------------------------        
struct diguyParticleDrawDesc
{
        diguyParticleDrawDesc() : m_shader(NULL), m_texture(NULL), m_system(NULL), m_camera(NULL),
                m_depth_write(0), m_world_space(1), m_scale_x(1.0f), m_scale_y(1.0f), m_scale_z(1.0f), m_blend(0),
                m_src_blend_func(0), m_dst_blend_func(0), m_alpha_thresh(.1f), m_particle_data_size(48), m_num_verts_per_primitive(4),
                m_active_count(0), m_brightness_multiplier(1.0f), m_render_pass_flags(0){
                ;
        }

        diguyGraphicsShaderProgram * m_shader;

        diguyGraphicsTexture * m_texture;

        diguyParticleSystem * m_system;

        diguyViewCamera * m_camera;

        int m_depth_write;

        int m_world_space;

        float m_scale_x, m_scale_y, m_scale_z;

        int m_blend;

        int m_src_blend_func;

        int m_dst_blend_func;

        float m_alpha_thresh;

        int m_particle_data_size;

        int m_particle_offset_for_colors;
        int m_particle_offset_for_verts;
        int m_particle_offset_for_normals;
        int m_particle_offset_for_textures;

        int m_num_verts_per_primitive;

        int m_active_count;

        float m_brightness_multiplier;

        int m_render_pass_flags;

};



#endif