DtSceneObject.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvUtil/signalslib.h>

#include <boost/unordered_map.hpp>

namespace makVrv
{
   class DtDe;
   class DtModel;
   class DtQuat;
   class DtSceneObjectUpdater;

   class DT_DLL_VRVCORE DtSceneObject
   {

   public:

      struct ObjectTransform
      {
         DtVector position;
         DtTaitBryan orientation;
      };

      typedef std::vector<ObjectTransform> TransformList;

      // A record which stores a model and it's visibility.
      struct ModelRecord
      {
         DtModel* model;
         bool origVisibility;
      };

      // Utility functor object for using std::find_if with the ModelList.
      struct FindModelFunctor
      {
         FindModelFunctor(DtModel* aKey = 0) : myKey(aKey) {}
         FindModelFunctor(const FindModelFunctor& fm) : myKey(fm.myKey) {}

         bool operator() (const DtSceneObject::ModelRecord& rec) const
         {
            return myKey == rec.model;
         }

         DtModel* myKey;
      };

      typedef std::vector<ModelRecord> ModelList;

      enum ModelSet
      {
         ModelSet_Unspecified = -1,
         ModelSet_3D = 0,
         ModelSet_3DColorized = 1,
         ModelSet_2DIcons = 5
      };

      DtSceneObject( DtDe& de, DtUniqueID id );

      virtual ~DtSceneObject();

      void addModel(DtModel* model, int visualizerType );

      void removeModel(DtModel* model );

      void removeModels();

      void setPosition( int vtx, const DtVector& position );

      void addPosition( int vtx, const DtVector& position );

      void getPosition( int vtx, DtVector& position ) const;

      void setOffset( const DtVector& offset );

      void getOffset( DtVector& offset ) const;

      void setOrientation( int vtx, const DtTaitBryan& orientation );
      
      void setPositionAndOrientation(int vtx, const DtVector& position, const DtTaitBryan& orientation);

      // topographic coordinate system (x north, y east, z down)
      void setTopographicOrientation( int vtx, 
         const DtTaitBryan& topoOrientation );

      void getOrientation( int vtx, DtTaitBryan& orientation ) const;

      // topographic coordinate system (x north, y east, z down)
      void getTopographicOrientation( int vtx, DtTaitBryan& orientation ) const;

      void getOrientation( int vtx, DtQuat& orientation ) const;

      virtual void transformToSceneObjectCoord(const DtVector& dbCoord, DtVector& soCoord);

      virtual void transformToDatabaseCoord(const DtVector& soCoord, DtVector& dbCoord);

      void setColor(float r, float g, float b, float a);

      void setModelSet( int modelSet );

      int modelSet() const;

      void setIsProp( bool isProp );

      bool isProp() const;

      void setIsSupportObject( bool b );

      bool isSupportObject();

      void setSolid( bool b );

      bool isSolid() const;

      DtElementID elementID() const;

      void setElementID( DtElementID elementID );

      DtUniqueID uniqueId() const;

      const ModelList& models() const;

      ModelList& models();

      const TransformList& transforms() const;

      virtual void removePosition(int);

      void setBoundingBoxSize(double minX, double maxX,
         double minY, double maxY, double minZ, double maxZ);

      const DtVector& boundingBoxExtents() const;

      void getBoundingBoxExtents(double& x, double& y, double& z) const;

      const DtVector& boundingBoxCenter() const;

      void getBoundingBoxCenter(double& x, double& y, double& z) const;

      double boundingRadius() const;

      void setVisible( bool visible );

      bool isVisible() const;

      //{@
      virtual void setBeingObserved(bool observed);
      virtual bool beingObserved() const;

      void setUpdater(DtSceneObjectUpdater* updater);

      DtSceneObjectUpdater* findUpdater();
      const DtSceneObjectUpdater* findUpdater() const;

      virtual float getAndResetMinModelDistance();


      boost::signal<void (DtModel*)> signal_modelAdded;

      boost::signal<void (DtModel*)> signal_modelRemoved;

      boost::signal< void (const DtUniqueID&) > signal_sceneObjectToBeDeleted;

      boost::signal<void (DtSceneObject*)> signal_boundingVolumeChanged;


   protected:

      void initializeModel( DtModel* modelInstanceOwner );

      void modelChanged( DtModel* model );

      // are not.  I highly doubt that this works at all, so please ignore.
      bool modelVisibilityRequested( DtModel* model, bool visible);

      void resetModelTransforms();

      void updateBoundingBoxViaContents();

      void calculateBoundingRadius();

      virtual void addModelConnections( DtModel* model );

      virtual void removeModelConnections( DtModel* model );


   protected:

      DtDe& myDe;
      DtUniqueID myUniqueId;
      TransformList myTransforms;
      DtElementID myElementID;
      DtSceneObjectUpdater* myUpdater;

      int myModelSet;
      bool myIsProp;
      bool myGroundClampTo;
      bool myIsDrawnSolid;
      ModelList myModels;
      bool myVisibleFlag;
      bool myCalculateBoundingBoxFlag;
      DtVector myBoundingBoxCenter;
      DtVector myBoundingBoxExtents;
      double myBoundingRadius;
      DtVector myOffset;
      bool myBeingObserved;

      struct ModelConnections
      {
         boost::signalslib::connection modelDestroyedConnection;
         boost::signalslib::connection modelChangedConnection;
         boost::signalslib::connection modelVisibilityConnection;
      };
      typedef std::pair<DtModel*, ModelConnections>  ModelConnectionsPair;
      typedef boost::unordered_map<DtModel*, ModelConnections> ModelConnectionsMap;
      ModelConnectionsMap myModelConnections;
   };
}