diguyParticleSystem.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2022 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/

/*********************************************************************/
#pragma once

#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;
class bdiVec3f;
struct diguyParticleDrawDesc;

#endif

#include <declspec_diguy.h>

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

public:
        diguyParticleSystem(const char * effect_name);
        virtual ~diguyParticleSystem() { ; }
        virtual const char * get_name() = 0;
        virtual void set_name(const char * name) = 0;

        virtual int update(float dt);

        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;

   // optional
   virtual void pause_update() { ; }
   virtual void resume_update() { ; }

        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; }

        // optional
        virtual void add_collision_plane(const bdiVec3f & vPlaneNormal, const bdiVec3f & vPoint,
                float fBounceFactor = 1.0f, int nCollisionResult = 0) {
                ;
        }

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 BDI_DECLSPEC_diguy diguyParticleSystemRenderer
{
public:
        diguyParticleSystemRenderer();
        virtual ~diguyParticleSystemRenderer() { ; }

        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;

public:
        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),
                m_particle_offset_for_colors(0), m_particle_offset_for_verts(0), m_particle_offset_for_normals(0), m_particle_offset_for_textures(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;

};