DtDiGuyOsgGraphicsLink.h

Go to the documentation of this file.

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


#pragma once

#include <vrvDiGuy/vrvDiGuy.h>

#include <diguyGraphicsLink.h>
#include <diguyGraphicsShape.h>

#include <vrvCore/DtUniqueID.h>

#include <osg/Group>
#include <osg/MatrixTransform>
#include <osgViewer/View>

#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>

#include <vrvMath/DtOctree.h>
#include <tbb/atomic.h>

// Enable to turn hard-coded instancing test.
//#define DIGUY_INSTANCING

class diguyGraphicsState;

namespace makVrv
{

   class DtDiGuyOsgGraphicsShaderProgram;
   class DtDiGuyOsgGraphicsShaderInstance;
   class DtDiGuyOsgGraphicsState;
   class DtDiGuyScenario;
   class DtDiGuyOsgGraphicsShape;
   class DtDiGuyOsgGraphicsLink;
   class DtDe;
   class DtDiGuyOsgRootNode;
   class DtDiGuyOsgGraphicsInstanceGroup;
   class DtDiGuyInstanceDrawable;

   struct diguyOsgGraphicsShapeGeodePair
   {
      diguyOsgGraphicsShapeGeodePair( diguyGraphicsShape* shape, osg::Geode* geode );

      diguyGraphicsShape* m_shape;
      osg::Geode* m_geode;
   };

   struct diguyOsgGraphicsShapeSwitchPair
   {
      diguyOsgGraphicsShapeSwitchPair( diguyGraphicsShape* shape, osg::Switch* switch_node );

      diguyGraphicsShape* m_shape;
      osg::Switch* m_switch;
      bool m_flash;
   };

   class DtCollisionBoxGeode : public osg::Geode
   {
   public:
      DtCollisionBoxGeode();

      DtCollisionBoxGeode( const DtCollisionBoxGeode& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY );

      META_Node( osg, DtCollisionBoxGeode );

      virtual void traverse( osg::NodeVisitor& nv );
   };

   struct DtDiGuyCharacterBoundingCallback : public osg::Node::ComputeBoundingSphereCallback
   {
      DtDiGuyCharacterBoundingCallback( DtDiGuyOsgRootNode& root );
      virtual osg::BoundingSphere computeBound( const osg::Node& node ) const;

      DtDiGuyOsgRootNode& myRoot;
   };

   class DtDiGuyOsgRootNode : public osg::MatrixTransform
   {
   public :

      DtDiGuyOsgRootNode( DtDiGuyOsgGraphicsLink* link );

      virtual ~DtDiGuyOsgRootNode();

      virtual void unbuild();

      virtual void traverse( osg::NodeVisitor& nv );

      void add_geode_for_fast_draw( diguyGraphicsShape* shape, osg::Geode* geode, int lod );
      void add_switch_for_fast_draw( diguyGraphicsShape* shape, osg::Switch* switch_node, int lod );
      void remove_shape( DtDiGuyOsgGraphicsShape* shape );

      virtual void setOctreeNode( DtOctreeNode<float64>* node );
      virtual DtOctreeNode<float64>* octreeNode() const;

      virtual void setScenario( DtDiGuyScenario* scenario );
      virtual DtDiGuyScenario* scenario();

      virtual void setPositionAndOrientation( const DtVector& pos, const DtTaitBryan& orient );

      virtual void setIsOccupant( bool occ ) { myOccupant = occ; }

      diguyCharacter* character();
      inline const DtVector& position() { return myWorldPosition; }
      inline const DtTaitBryan& orientation() { return myWorldOrientation; }
      inline const osg::Quat& quat() { return myQuat; }
      inline bool isOccupant() { return myOccupant; }

      inline void setLastTraversal(unsigned int lastTrav) { myLastTraversal = lastTrav; }
      inline unsigned int lastTraversal() { return myLastTraversal; }


   protected:
      std::vector<std::vector<diguyOsgGraphicsShapeSwitchPair> > m_switch_nodes;
      std::vector<std::vector<diguyOsgGraphicsShapeGeodePair> > m_lod_drawables;
      DtDiGuyOsgGraphicsLink* m_link;

      unsigned int myLastTraversal;
      float myMinDrawDistance;
      bool myOccupant;
      DtOctreeNode<float64>* myOctreeNode;
      DtDiGuyScenario* myScenario;

      DtVector myWorldPosition;
      DtTaitBryan myWorldOrientation;
      osg::Quat myQuat;

   };

   class DtDiGuyOsgGraphicsLink : public diguyGraphicsLink
   {
   public:

      DtDiGuyOsgGraphicsLink( void* internal_data );

      virtual ~DtDiGuyOsgGraphicsLink();

      virtual void build() override;

      virtual void unbuild() override;

      virtual void update() override;

      virtual void update_position();

      virtual void patch_tbo_data( const osg::Vec3d& camera_pos );

      virtual void attach_to_scene() override;

      virtual void detach_from_scene() override;

      virtual void attach_to_link( diguyGraphicsLink* link );

      virtual void detach_from_link();

      virtual void set_shader_instance( diguyGraphicsShaderInstance* shader_instance ) override;

      virtual void instancing_state_changed( int is_instanced ) override;

      virtual void fill_out_tbo_additional_data( diguyGraphicsShape* current_shape, float* tbo_data ) override;

      osg::MatrixTransform* getDofNode();

      DtDiGuyOsgRootNode* getRootNode();

      virtual void set_allow_motion_offsets(bool allow);
      virtual bool get_allow_motion_offsets() const;

      virtual void setPositionAndOrientation( const DtVector& pos, const DtTaitBryan& ori );

      virtual void setCollisionUniqueId( DtUniqueID id );

      virtual osg::Uniform* getOrCreateLinkMatrixUniform();

      osg::Geode* boundingSphereVisual();

      virtual void setHasLight( bool value );

   public:

      static void setDiGuySharedNodes(DtDiGuyScenario* scenario, osg::Group* diguy_attach_pt, osg::MatrixTransform* diguy_instancing_attach_pt,
         DtDiGuyInstanceDrawable* the_diguy_instancing_drawable);

      static osg::Group* getDiGuyAttachGroup();

      static osg::MatrixTransform* get_instancing_attach_node();

      static DtDiGuyInstanceDrawable* get_instancing_drawable();

   protected:

      osg::Geode* makeBoundingSphereVisual(osg::Vec3& center, float radius);

    protected:

      //osg::ref_ptr<osg::Texture2D> defaultVariationTexture();

      osg::ref_ptr<osg::MatrixTransform> m_dof_node;
      osg::ref_ptr<osg::Uniform> myUniformLinkMatrix;

      osg::ref_ptr<osg::Uniform> m_ufrm_emission_color;

      osg::ref_ptr<osg::Geode> myCollisionBoxGeode;
      osg::ref_ptr<osg::Geode> myBoundingSphereVisual;

      DtDiGuyOsgGraphicsShaderInstance* myShaderInstance;

      bool myAllowMotionOffsetsFlag;
      bool myHasLight;

      DtUniqueID myUniqueId;

   protected:

      static osg::Group* the_diguy_attach_group;
      static osg::MatrixTransform* the_diguy_instancing_attach_pt;
      static DtDiGuyInstanceDrawable* the_diguy_instancing_drawable;

   };


   diguyGraphicsLink* DtDiGuyOsgGraphicsLink_create_func(void* internal_data);

}