DtFxParticleSystemManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvFx/vrvFx.h>
#include <osg/MatrixTransform>

#include <vrvFx/DtFxParticleSystem.h>
#include <vrvOsg/DtParticleSystemManagerInterface.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <diguyParticleSystem.h>
#include <diguyParticleManager.h>
#include <tbb/parallel_for.h>

class bdiParticleDesc;
class diguyParticleSystem;

namespace osg
{
   class RenderInfo;
}

namespace makVrv
{
   class DtFxDebugDrawCallbackInterface;

   class DtFxApplyMTParticleUpdateFunction
   {
   public:
      DtFxApplyMTParticleUpdateFunction(DtFxParticleSystem** particle_array, float dt);
      void operator()(const tbb::blocked_range<size_t>& r) const;

   protected:
      DtFxParticleSystem** const m_particle_array;
      float m_dt;

   };

   class DtFxApplyMTParticleVboPrepFunction
   {
   public:
      DtFxApplyMTParticleVboPrepFunction(std::vector<DtFxParticleSystem*>& particle_array, const bdiFarPosition& eyePosition);

      void operator()(const tbb::blocked_range<size_t>& r) const;
   
    protected:
      std::vector <DtFxParticleSystem*>& m_particle_array;
      bdiFarPosition myEyePosition;
   };


   class DtFxOglParticleSystemRenderer;
   class DT_DLL_VRVFX DtFxParticleSystemManager : public diguyParticleManager, public DtParticleSystemManagerInterface
   {

   public:
      DtFxParticleSystemManager(makVrv::DtDe& de);
      virtual ~DtFxParticleSystemManager();

      virtual bool get_scenario_owns_particle_manager();

      virtual void initialize_renderer();
      
      virtual DtFxOglParticleSystemRenderer* renderer();

      virtual void draw() { ; }

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

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

      virtual void addImguiOverlay();
      
      virtual void addImguiStats();

      virtual diguyParticleSystem* create_particle_system(const char* desc_name);

      virtual void reinitialize(bool recreate_default_effect = true);

      virtual void update(float quantum);

      virtual void vrvUpdate(float quantum);

      virtual int load_entries(const char* fileName);

      virtual void add_desc(bdiParticleDesc *desc);
      virtual void remove_desc(bdiParticleDesc* desc, int delete_desc = 1);
      virtual void rename_desc(bdiParticleDesc* desc, const char* new_name);

      virtual DtFxParticleDesc* create_default_description();

      virtual int in_use(bdiParticleDesc* desc);

      virtual bdiParticleDescArray* get_descriptions();
      bdiParticleDesc* get_description(int index);
      bdiParticleDesc* find_description(const char * name);

      diguyParticleSystem* create(const char* desc_name);
      diguyParticleSystem* create_transient_system(const char* desc_name, float life_time_override = -1.0f);
      diguyParticleSystem* create_preview_system(const char* desc_name);

      diguyParticleSystem* find_system_with_character_pointer(diguyCharacter* character);

      virtual void remove_system(diguyParticleSystem* ps);

      virtual int get_number_of_systems();
      virtual int get_number_of_transient_systems();
      virtual diguyParticleSystem* get_system(int i);

      virtual bdiString get_unique_description_name(const char* prefix);

      virtual diguyParticleSystem* get_preview_system();
      virtual void destroy_preview_system();

      virtual void reset();

      virtual void process_data_queue();

      virtual void set_draw_debug_visuals(int val);
      virtual int  get_draw_debug_visuals() const;

      virtual void set_global_wind(const bdiVec3f& wind);
      virtual const bdiVec3f& get_global_wind() const;

      virtual void load_texture_map(bdiParticleDesc* desc);


      virtual int  get_enabled() const { return 1; }
      virtual void set_enabled(int val);
      virtual void start_emitting_for(diguyCharacter*, const bdiFarPosition& start_pos, const bdiVec3f& orient);
      virtual void stop_emitting_for(diguyCharacter*);
      virtual void stop_all_particles_for(diguyCharacter*);

      virtual void set_draw_placeholder(int draw) { }
      virtual int  get_draw_placeholder() const { return false; }
      virtual void set_draw_placeholder_master_switch(int draw) {  }
      virtual int  get_draw_placeholder_master_switch() const { return false; }
      virtual int  get_license_status() const { return 1; }
      virtual int  load_descs_library(bdiObjectLibrary* object_library);
      virtual void unload_descs_library(bdiObjectLibrary* object_library);

      virtual void clear_derived_update_flag_on_next_update();

      virtual int get_num_systems_drawn() const;
      virtual void increment_systems_drawn();


      //VRV Additions
      virtual bool isGeocentric();

      virtual void calcGeocentric(const bdiFarPosition & pos, bdiMat4f& mat, bdiMat4f* inversemat);
      virtual void setOsgDrawable(osg::ref_ptr<DtFxOsgParticleDrawable>& drawable);
      virtual osg::ref_ptr<DtFxOsgParticleDrawable>& osgDrawable();

      virtual void setWindSpeed(float metersPerSecond);
      virtual void setWindDirection(float radians);
      virtual void updateWind();

      virtual void setNumPreviewSystems(int value);
      virtual void restartPreview();
      virtual void setPreviewSystemsPosition(const bdiFarPosition& pos);

      DtDe& de();

      virtual void set_particle_module_disabled(int dis) { ; }
      virtual void set_water_height(const float& water_height);
      virtual float get_water_height() const;
      virtual void sync_spawn_system_data(bdiParticleDesc* desc);


      virtual osg::Node* getOrCreateSensorNode(int diguyMat);

      virtual DtFxCollisionVolumeInterface* addCollisionVolume();

      virtual void destroyCollisionVolume(DtFxCollisionVolumeInterface* volume);

      virtual DtFxForceInterface* addGlobalForce();

      virtual void destroyGlobalForce(DtFxForceInterface* volume);


      DtFxParticleVertex* get_vertbuffer();

      virtual bool revertItem(DtFxParticleDesc* item);
      virtual void saveItem(DtFxParticleDesc* item);
      virtual std::string saveFiles();

      virtual void createDescBackups();

      static DtFxParticleSystemManager* instance(DtDe& de);

      virtual diguyParticleManager* getDiguyParticleManager();

      virtual void initSystem();
      
      virtual void createParticleDrawable();

      virtual bool hasDescription(const std::string& name);
      virtual void slot_reloadShaders();

      virtual void setWireFrameMode(bool wireframeMode);

      virtual void setTextureMode(bool textureMode);

      virtual DtFxParticleSystem* createSystem(const std::string& name);
      virtual void destroySystem(DtFxParticleSystem* system);

      virtual void updateParticles(double simTime);

      bool getTerrainOrPropIntersection(const osg::Vec3d& startPos, const osg::Vec3d& endPos,
         osg::Vec3d& result) const;

      virtual void addGlobalForce(DtFxForce* force);

      virtual void removeGlobalForce(DtFxForce* force);

      const DtFxForceArray& globalForces() const;

      DtFxForceArray& globalForces();

      const DtFxCollisionObjectArray& collisionObjects() const;

      DtFxCollisionObjectArray* collisionObjectsPtr();

      virtual void addDescToTextureLoad(bdiParticleDesc* desc);

      tbb::mutex& systemDataMutex();

      tbb::mutex& lightMutex();

      const std::set<std::string>& fileNamesList();

      DtFxParticleSystemArray& previewArray();

      DtFxParticleSystemArray& systemArray();

      DtFxParticleSystemHolderArray& testHolderArray();

      virtual bool* previewAutoMovePtr();
      virtual float* previewAutoMoveSpeedPtr();
      virtual bdiVec3f* previewAutoMoveRadiusPtr();

      virtual void recompileScripts();

      virtual void addDebugDrawer(DtFxDebugDrawCallbackInterface* drawer);


   protected:

      virtual diguyParticleSystem* create_transient_system(DtFxParticleDesc* desc, float life_time_override = -1.0f);
      virtual diguyParticleSystem* create_preview_system(DtFxParticleDesc* desc);
      virtual DtFxParticleSystem* shared_creation(DtFxParticleDesc* desc);
      virtual void update_preview(const float quantum);
      virtual void cull(DtFxParticleSystemArray& input, osg::Polytope& polytope, bool shadow_pass, std::vector< DtFxParticleSystem*>& results);

      virtual osg::ref_ptr<osg::Texture2D> loadTexture(const char* txName);


   protected:
      mutable tbb::mutex m_mutex_critical_data;

      mutable tbb::mutex m_mutex_texture_data;

      // this seems to be needs to protect the light manager
      mutable tbb::mutex m_mutex_light_objects;

      bdiParticleDescArray m_descs;
      bdiParticleDescArray m_backup_descs;

      bdiParticleDescArray m_init_texture_queue;

      DtFxParticleSystemArray m_psystems;

      DtFxParticleSystemArray m_trans_systems;

      DtFxParticleSystemArray m_preview_array;

      DtFxParticleSystemHolderArray m_test_holder_array;

      DtFxForceArray m_global_forces;

      DtFxParticleDesc* m_preview_desc;

      int m_draw_debug_visuals;
      float m_water_height;
      int m_clear_derived_update_flag_on_next_update;

      // pointer from the gpu
      DtFxParticleVertex* m_vertbuffer;

      float myWindSpeed;
      float myWindDirection;

      int myNumPreviewSystems;
      bdiFarPosition myPreviewCenter;
      std::set<std::string> myFileNamesList;
      std::vector< DtFxParticleSystem*> myAllSystems;

      DtSignalConnectionManager myConnections;

      DtDe& myDe;
      osg::ref_ptr<DtFxOsgParticleDrawable> myOsgDrawable;
      std::map<int, osg::ref_ptr<osg::Node> > mySensorMap;
      bdiFarPosition myEyePosition;

      DtFxCollisionObjectArray myCollisionObjects;

      // stats tracking
      float myStatsUpdateTime;
      float myStatsDrawTime;
      float myStatsDrawLastTime;
      int myTotalVertCount;
      int myTotalPrimCount;
      int myNumSystemsDrawn;

      osg::ref_ptr<osg::MatrixTransform> myParticleRendererGroup;
      double myLastUpdateTime;

      bool myPreviewAutoMove;
      float myPreviewAutoMoveSpeed;
      bdiVec3f myPreviewAutoMoveRadius;

      std::vector<DtFxDebugDrawCallbackInterface*> myExtraDebugDrawObjects;
   };


}