DtFxParticleSystem.h

Go to the documentation of this file.

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

#pragma once


#include <tbb/mutex.h>

#include <osg/Texture2D>

#include <vrvUtil/DtRandomNumberGenerator.h>
#include <vrvOsg/DtParticleSystemManagerInterface.h>

#include <vrvFx/vrvFx.h>

// diguy internal headers
#include <bdiKeyFrames.h> 
#include <declspec_bdiutil.h>
#include <libvecmat_float.h>
#include <bdiFarPosition.h>
#include <bdiOctTreeBoundingBox.h>
#include <bdi_vector_arrays.h>

#include <bdiString.h>
#include <diguy_constants.h>
#include <bdi_simple_templates.h>
#include <bdiParticleDesc.h>

#include <diguyMaterialType.h>
#include <diguyParticleSystem.h>

// speed tree support for float16
#include <vrvFx/vrv_float16.h>

#include <vrvFx/DtFxCollisionObject.h>
#include <vrvFx/DtFxForce.h>
#include <vrvFx/DtFxScriptData.h>


#undef LIBBDIOBJECT_ARRAY_TYPE
#undef LIBBDIOBJECT_ARRAY_CLASS_NAME
#define LIBBDIOBJECT_ARRAY_TYPE bdiVec3f
#define LIBBDIOBJECT_ARRAY_CLASS_NAME bdiVec3fPtrArray

#include "libbdiobject_array_declaration_template.h"

#undef LIBBDIOBJECT_ARRAY_TYPE
#undef LIBBDIOBJECT_ARRAY_CLASS_NAME

class bdiVec3fArray;
class bdiVec4fArray;

namespace makVrv
{

   class DT_DLL_VRVFX DtFxChildSystem
   {
   public:
      bdiString m_name;
      bdiVec3f m_offset;
      float m_time_offset;
      DtFxChildSystem() :m_time_offset(0) { ; }
   };

}


#define LIBBDIOBJECT_ARRAY_TYPE makVrv::DtFxChildSystem
#define LIBBDIOBJECT_ARRAY_CLASS_NAME DtFxChildSystemArray
#define LIBBDIOBJECT_ARRAY_INLINE
#define LIBBDIOBJECT_ARRAY_DISABLE_BOUNDS_CHECKING

#include "libbdiobject_array_declaration_template.h"
#include "libbdiobject_array_definition_template.h"

#undef LIBBDIOBJECT_ARRAY_DISABLE_BOUNDS_CHECKING
#undef LIBBDIOBJECT_ARRAY_INLINE
#undef LIBBDIOBJECT_ARRAY_TYPE
#undef LIBBDIOBJECT_ARRAY_CLASS_NAME

namespace makVrv
{
   enum ExtendedNoiseType
   {
      CIRCLE_EDGE = NUM_NOISE_TYPES,
      IN_TORUS,
      CONE,
      HEMISPHERE,
      NONE,
      OUT_FROM_EMITTER,
      NUM_EXTENDED_NOISE_TYPES
   };

   class DtFxOsgParticleDrawable;
   struct DtFxParticleVertex;
   class DtDe;
   class DtLight;
   class DtFxParticleSystemManager;
   class DtOsgArticulatedModel;
 

   class DT_DLL_VRVFX DtFxParticleDesc : public bdiParticleDesc
   {
   public:
      DtFxParticleDesc();

      virtual ~DtFxParticleDesc();

      DtFxParticleDesc(const DtFxParticleDesc& rhs);

      DtFxParticleDesc& operator=(const DtFxParticleDesc& orig);

      virtual void reset();

      virtual int read_cfg_entries(bdiCfgEntry* cfg_entry);

      virtual int write_cfg_entries(bdiCfgReader* cfg_reader);

      virtual bdiCfgEntry* create_cfg_entry();
      
      virtual void set_texture_name(const char* chTexFile);
      
      virtual void set_normal_texture_name(const char* chTexFile);

      virtual void setFileSouce(const char* file_source);

      virtual void setEdited(bool edited);

      virtual bool edited();

      virtual void setDiffuseTexture(osg::Texture2D* osg_diffuse_texture);

      virtual void setNormalTexture(osg::Texture2D* osg_normal_texture);

      inline float emissivityFactor() { return m_emissivity_factor; }

      inline float materialSpecularity() { return m_material_specularity; }

      inline float meterialMetallicness() { return m_material_metallicness; }

      inline float hdrGain() { return m_hdr_gain; }

      inline float translucency() { return m_translucency; }

      inline float softness() { return m_softness; }

      inline bool useLighting() { return m_use_lighting; }
      
      inline osg::Texture2D* diffuseTexture() {return myOsgDiffuseTexture.get();}
      
      inline osg::Texture2D* normalTexture() { return myOsgNormalTexture.get(); }

      inline const bdiString& fileSouce() { return myFileSouce; }

      inline const DtFxChildSystemArray& childSystems() { return m_child_system_descs; }

      static float smooth_interpolate_keys(FloatKeyFrameArray& array, char* prev_keyframe, float time);
      static bdiVec4f smooth_interpolate_keys(ColorKeyFrameArray& array, char* prev_keyframe, float time);

      static float smooth_interpolate_keys(FloatKeyFrameArray& array, float speed);
      static bdiVec4f smooth_interpolate_keys(ColorKeyFrameArray& array, float speed);

  public:
      // matching base class behavior where these are public
      bool m_looked_up_normal_texture;
      bdiString m_normal_map_file_name;

   protected:
      friend class DtFxParticleSystem;
      friend class bdiQWidgetParticleSystem;

      bdiVec3f m_position_offset;
      bdiVec3fPtrArray m_additional_offsets;

      float m_hdr_gain;
      float m_emissivity_factor;

      float m_material_specularity;

      float m_material_metallicness;
      bool m_use_lighting;

      float m_translucency;

      float m_softness;

      float m_particle_mass;

      float m_air_resistance_factor;

      float m_rotation_variation;

      float m_initial_rotation_variation;

      float m_initial_velocity_scale;

      bool m_normalized_animation_time;

      bool m_color_by_age;
      bool m_size_by_age;

      float m_color_speed_scale;
      float m_size_speed_scale;

      int m_num_to_release_var;

      float m_release_frequency_var;

      bool m_normalize_light_time;

      float m_light_in_fade_time;

      bool m_emit_from_parent_particles;

      bool m_emit_from_random_particle_index;

      bdiString myFileSouce;

      bool m_edited;

      osg::ref_ptr<osg::Texture2D> myOsgDiffuseTexture;

      osg::ref_ptr<osg::Texture2D> myOsgNormalTexture;

      DtFxCollisionObjectArray m_collision_objects;

      DtFxChildSystemArray m_child_system_descs;

      DtFxForceArray m_additional_forces;

      // debugging aid allows the editor to feed back to the renderer
      int myArtPartOverride;
      bdiVec3f myArtPartOverrideOffset;


      bdiString mySizeScript;
      bdiString myLifeTimeScript;
      bdiString myReleaseRateScript;
      bdiString myStreakScript;
      bdiString myColorScript;
      bdiString myRotationSpeedScript;
      bdiString myVelocityScript; 
  };


   struct DtFxParticleDrawDesc : public diguyParticleDrawDesc
   {
      DtFxParticleDrawDesc();
      DtFxParticleDesc* m_desc;
      DtFxParticleVertex* m_data;
   };

   struct DT_DLL_VRVFX DtFxParticle
   {
   public:
      DtFxParticle();
      void clear_values();

   public:
      bdiFarPosition m_cur_pos;    // Current position of particle
      bdiFarPosition m_prev_pos;    // previous position of particle
      bdiVec3f m_cur_vel;    // Current velocity of particle
      bdiVec4f m_cur_color;
      bdiVec4f m_prev_color;
      bdiVec4f m_color_var;   // color variation

      float m_age;            // age of the particle
      float m_fSize;          // size of the particle
      float m_size_var;       // random additional size
      float m_fStreakSize;    // current streak size
      float m_life_time;      // lifetime variation
      float m_rotation_amount;
      float m_rotation_speed;
      char m_color_index;        // current color keyframe index
      char m_size_index;         // current size keyframe index
      char m_streak_index;       // current streak keyframe index
      char m_velocity_index;     // current velocity keyframe index
      char m_velocity_var_index; // current velocity variation index
      char m_subtexture_index;   // current frame index
      bool m_stuck;

   };

   struct DT_DLL_VRVFX DtFxParticleVertex
   {
   public:
      bdiVec3f m_vertex;
      unsigned char m_color[4];
      vrv_float16 m_size;
//      vrv_float16 m_age; // not currently used
      vrv_float16 m_rotation;
      vrv_float16 m_velocity[3];
      unsigned char m_frame;

      DtFxParticleVertex() : m_frame(0)
      {
         m_vertex[0] = m_vertex[1] = m_vertex[2] = 0.0f;
         m_color[0] = m_color[1] = m_color[2] = m_color[3] = 0;
      }
   };

   /* unused currently
   struct bdiParticleSpawnEvent
   {
      DtParticleDesc* m_desc;
      bdiFarPosition m_origin;
      bdiVec3f m_direction;
      bdiVec3f m_spawn_velocity_factor;
   };
   */


   class DT_DLL_VRVFX DtFxParticleSystem : public diguyParticleSystem
   {
   public:
      enum DebugFlags
      {
         Lights         = 0x00000001,
         Forces         = 0x00000010,
         Force3DVectors = 0x00000100,
         Force2DVectors = 0x00001000,
         BoundingBoxes  = 0x00010000,
         Objects        = 0x00100000,
         Velocities     = 0x01000000,

         All = Lights | Forces | Force2DVectors | BoundingBoxes | Objects | Velocities,
      };

      // class to help store sorted data
      struct ParticleSortLocation 
      {
         ParticleSortLocation() : index(0), distance(0) {}
         ParticleSortLocation(unsigned short _index, float _distance) : index(_index), distance(_distance) { ; }
         unsigned short index;
         float distance;
      };

      DtFxParticleSystem(DtFxParticleSystemManager* manager, DtFxParticleDesc* desc);

      virtual ~DtFxParticleSystem(void);

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

      virtual void set_position(int subemitter, double x, double y, double z);

      virtual void set_position(const bdiFarPosition& pos);
      virtual const bdiFarPosition& get_position(void);

      virtual void reset_prev_position_next_update();

      virtual void set_rotation(float angle, float x, float y, float z);

      virtual void set_orientation_dir(const bdiVec3f& orient);
      virtual void set_orientation(float* orientation);

      virtual void set_orientation(const bdiMat4f& orientationMat);

      virtual int update(float fElapsedTime);

      float get_age();

      virtual void prep_vbo_for_rendering();
      virtual void render_debug_visuals(osg::RenderInfo& renderInfo, int flags);

      virtual void render_collision_objects(osg::RenderInfo& renderInfo);

      virtual void sort_system(const bdiFarPosition& eyePos);

      virtual void restart_particle_system(void);

      virtual void set_desc(bdiParticleDesc* desc);
      virtual bdiParticleDesc* get_desc();

      virtual void stop_emitting();
      virtual void start_emitting();
      virtual void pause_emitting() { ; }

      virtual int get_emitting();
      virtual int get_active_count();
      virtual void stop_all_particles();
      virtual bool isEmitTimeInfinite() const;

      const bdiOctTreeBoundingBox& get_bounding_box();


      bool is_visible();
      bool is_visible(const bdiCameraFrustum* frustum);

      virtual void set_scale(float scale);
      virtual void set_scale(float scale_x, float scale_y, float scale_z);
      virtual void set_scale(const bdiVec3f& scale);
      virtual const bdiVec3f& get_scale();

      virtual void set_time_scale(float t);
      virtual void setIntensity(float intensity);
      virtual float intensity() const;

      virtual void setIsRotorWash(bool scaleVortexLift);
      virtual bool isRotorWash() const;

      virtual void setRotorDiameter(double diameter);
      virtual double rotorDiameter() const;

      virtual void setRotorWindSpeed(double speed);
      virtual double rotorWindSpeed() const;

      virtual void set_name(const char*name);
      virtual const char* get_name();
      virtual bdiLight* get_light_object();

      virtual void setRandomSeed(unsigned int value);

      virtual void setCameraDistance(float distance);
      virtual float cameraDistance();

      virtual void addChildSystem(DtFxParticleSystem* child, float time_offset);
      virtual void removeChildSystem(DtFxParticleSystem* child);
      virtual void clearParent();

      virtual void set_vbo_start_index(int index);
      virtual int get_vbo_start_index();
      virtual bool get_sort_system();

      virtual const bdiVec3f& get_velocity();

      virtual void set_wind(const bdiVec3f& wind);

      virtual void addGlobalForces();
      virtual void removeGlobalForces();

      virtual int artPartOverride();
      virtual const bdiVec3f& artPartOffset();

      virtual void pauseUpdate();
      virtual void resumeUpdate();
      virtual bool paused();

      virtual void restart_merged_system();

      virtual void setAttachedModel(DtOsgArticulatedModel* model);
      
      virtual int getNumGlobalForces();

      virtual DtFxForceInterface* getGlobalForce(int index);

      inline void setIsPreviewSystem() { m_is_preview_system = true; }

      inline void setSortParticles(bool sort) { m_sort_particles = sort; }


      inline bdiFarPosition* positionPtr() { return &m_position; }
      inline float* systemScalePtr() { return &m_system_scale; }
      inline float* systemIntensityPtr() { return &mySystemIntensity; }
      inline const DtOsgArticulatedModel* attachedModel() const { return myAttachedModel; }
      inline std::vector<DtFxParticleSystem*>& getChildSystems() { return m_child_systems; }
      inline DtFxParticleDesc* desc() { return m_desc; }
      inline DtFxParticleDrawDesc& currentDrawDesc() { return myCurrentDrawDesc; }
      inline const bdiMat4f& geocentricMat() const { return myGeocentricMat; }
      inline const bdiMat4f& geocentricMatInv() const { return myGeocentricMatInv; }
      
      virtual void recompileScripts();

      exprtk::symbol_table<float>& symbolTable() { return mySymbolTable; }

   protected:
      virtual void emit_particles(float quantum);

      virtual void update_appearance(int start_index);
      virtual void update_physics(float quantum, int start_index);

      virtual void render_emitter(bdiVec3fArray& verts, bdiVec4fArray& colors, const bdiVec3f& emitter_pos);

      virtual void prepCurrentForcesAndObjects();

      void add_force_visual(const bdiFarPosition& camPos, bool has_geo, const bdiVec3f& upVec, 
         DtFxParticle &particle, bdiVec3fArray &verts, bdiVec4fArray &colors);

   protected:
      std::string m_name;
      DtFxParticleDesc*    m_desc;
      std::vector<DtFxParticle>  m_active_list;
      std::vector<ParticleSortLocation> m_sorted_list;
      int                m_active_count;
      int                m_active_count_at_stop;
      bool               m_emitting;
      float              m_auto_start_time;
      float              m_time_since_stopping;
      float              m_time_since_update;
      float              m_time_scale;
      float              m_next_release_time;
      float              m_last_release_time;
      float              m_next_release_freq;
      bdiFarPosition     m_position;
      bdiFarPosition     m_prev_position;
      bdiFarPosition     m_last_geocentric_postion;
      bdiVec3f           m_velocity;
      bdiMat4f           myGeocentricMat;
      bdiMat4f           myGeocentricMatInv;
      float              mySystemIntensity;
      bool               myIsRotorWash;
      float              myRotorDiameter;
      float              myRotorWindSpeed;
      int                m_restart_count;
      bool               m_restarted_system;
      int                m_last_particle_index_used_for_emission;

      bool               m_reset_prev_position_next_update;
      bdiVec3f           m_scale;
      int                m_rotate_system;
      bdiMat4f           m_orientation;
      bdiVec3f           m_spawn_velocity_factor;
      bdiMat4f           m_current_orientation;
      float              m_system_scale;
      bdiVec3f           m_wind;

      // per frame scratch objects
      float              m_max_size;
      bdiOctTreeBoundingBox  m_bounding_box;
      std::vector<const DtFxForce*> myCurrentForces;
      std::vector<bdiFarPosition> myCurrentForcePositions;
      std::vector<const DtFxCollisionObject*> myCurrentCollisionObjects;
      std::vector<bdiVec3f> myCurrentPlaneNormals;
      std::vector<bdiFarPosition> myEmitterPositions;

      bdiLight* m_light_object;
      float m_camera_distance;
      bool m_add_light;
      bool m_sort_particles;
      bool m_has_valid_position;
      bool m_is_preview_system;
      int m_vbo_start_index;

      DtFxParticleSystem* m_parent_system;
      std::vector<DtFxParticleSystem*> m_child_systems;
      DtFxParticleDrawDesc myCurrentDrawDesc;

      // VRV custom data
      bool myPaused;
      DtLight* myVrvLight;
      DtRandomNumberGenerator myRandomNumberGen;
      DtOsgArticulatedModel* myAttachedModel;
      DtFxForceArray m_global_forces;

      DtFxScriptData mySizeScript;
      DtFxScriptData myLifetimeScript;
      DtFxScriptData myReleaseRateScript;
      DtFxScriptData myStreakScript;
      DtFxScriptData myColorScript;
      DtFxScriptData myRotationSpeedScript;
      DtFxScriptData myVelocityScript;

      bool myActiveScripts;
      bool mySlavedPositions;
      exprtk::symbol_table<float> mySymbolTable;
      float myScriptNumParticles;
      float myScriptParticleSpeed;
      float myScriptParticleIndex;
      float myScriptParticleAge;
      float myScriptParticleNormalizedAge;
      float myScriptSystemSpeed;
      float myScriptSystemForceReceived;
      float myScriptSystemWindSpeed;
      float myScriptInputValue;
      float myScriptCurrentValue;
      bdiVec4f myScriptRGBA;
      bdiVec3f myScriptXYZ;

   };

}

// declare array for importing from diguy code base!
#define LIBBDIOBJECT_NAMED_ARRAY_TYPE makVrv::DtFxParticleSystem
#define LIBBDIOBJECT_NAMED_ARRAY_CLASS_NAME DtFxParticleSystemArray
#undef LIBBDIOBJECT_NAMED_ARRAY_DECLSPEC_bdiutil
#define LIBBDIOBJECT_NAMED_ARRAY_INLINE

#ifdef _WIN32
#  ifdef vrvFx_EXPORTS
#     define BDI_DECLSPEC_custom __declspec ( dllexport )
#  else
#     define BDI_DECLSPEC_custom __declspec ( dllimport )
#  endif
#endif

#include "libbdiobject_named_array_declaration_template.h"
#include "libbdiobject_named_array_definition_template.h"

#undef LIBBDIOBJECT_NAMED_ARRAY_INLINE
#undef LIBBDIOBJECT_NAMED_ARRAY_TYPE
#undef LIBBDIOBJECT_NAMED_ARRAY_CLASS_NAME
#undef  LIBBDIOBJECT_NAMED_ARRAY_DECLSPEC_bdiutil

namespace makVrv
{
   class DtFxParticleSystemHolder
   {
   public:
      DtFxParticleSystemHolder() : m_system(NULL) { ; } 
      DtFxParticleSystemHolder(const DtFxParticleSystemHolder& rhs) : m_name(rhs.m_name), m_system(NULL) { ; }
      const char* get_name() { return m_name.get_name(); }

   private:
      DtFxParticleSystemHolder& operator=(const DtFxParticleSystemHolder&);

   public:

      bdiString m_name;
      DtFxParticleSystem* m_system;
   };
}

// declare array for importing from diguy code base!
#define LIBBDIOBJECT_NAMED_ARRAY_TYPE makVrv::DtFxParticleSystemHolder
#define LIBBDIOBJECT_NAMED_ARRAY_CLASS_NAME DtFxParticleSystemHolderArray
#undef LIBBDIOBJECT_NAMED_ARRAY_DECLSPEC_bdiutil
#define LIBBDIOBJECT_NAMED_ARRAY_INLINE

#ifdef _WIN32
#  ifdef vrvFx_EXPORTS
#     define BDI_DECLSPEC_custom __declspec ( dllexport )
#  else
#     define BDI_DECLSPEC_custom __declspec ( dllimport )
#  endif
#endif

#include "libbdiobject_named_array_declaration_template.h"
#include "libbdiobject_named_array_definition_template.h"

#undef LIBBDIOBJECT_NAMED_ARRAY_INLINE
#undef LIBBDIOBJECT_NAMED_ARRAY_TYPE
#undef LIBBDIOBJECT_NAMED_ARRAY_CLASS_NAME
#undef  LIBBDIOBJECT_NAMED_ARRAY_DECLSPEC_bdiutil