diguyParticleSystem.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2024 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;

};