DtDiGuyOsgGraphicsLink.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2020 VT MAK
 * 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 <vrvGraphicsUtils/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();

      virtual void unbuild();

      virtual void update();

      virtual void update_position();

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

      virtual void attach_to_scene();

      virtual void detach_from_scene();

      virtual void attach_to_link(diguyGraphicsLink* link);

      virtual void detach_from_link();

      virtual void set_shader_instance(diguyGraphicsShaderInstance* shader_instance);

      virtual void instancing_state_changed(int is_instanced);

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

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

}