DtModel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <boost/signal.hpp>

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


namespace makVrv
{
   class DtDe;
   class DtModelInstance;
   class DtModelDefinition;
   struct DtLoaderHandle;

   // Struct which performances a boolean OR on all slot return values.
   struct SlotReturnOR
   {
      typedef bool result_type;
      template<typename InputIterator>
      bool operator()(InputIterator first, InputIterator last) const
      {
         bool result = false;
         while (first != last)
         {
            result |= *first++;
         }
         return result;
      }
   };

   class DT_DLL_VRVCORE DtModel 
   {
   public:

      DtModel(DtDe& de, DtUniqueID id);

      virtual ~DtModel();

      DtModelInstance* createModelInstance(const std::string& modelDefName, bool realize = true);

      virtual void setModelDefinition(const std::string& str);
      virtual const std::string & modelDefinitionName() { return myModelDefinitionName; }

      //Save the model's loaded notes to a file.
      virtual void saveModelToFile(const std::string& filename);

      virtual std::string className() const;


      virtual DtModelInstance* modelInstance();
      virtual const DtModelInstance* modelInstance() const;


      unsigned int transformSize() const;

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

      virtual void removePosition( int vtx );

      const DtVector& position(int vtx = 0) const;

      const DtTaitBryan& orientation(int vtx = 0) const;

      virtual void setOrientation( int vtx, const DtTaitBryan& orientation );
      
      virtual void enableColorBlending( bool b );

      virtual void setBlendColor( float r, float g, float b, float a );

      virtual void getBlendColor( float& r, float& g, float& b, float& a);

      virtual bool colorBlendingEnabled() const;

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

      virtual void enableLighting( bool l );

      virtual int modelSet() const;

      const DtVector& boundingBoxExtents() const;

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

      const DtVector& boundingBoxCenter() const;

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

      virtual void getBoundingBoxComponents( DtVector& minimum, DtVector& maximum );

      void setContributesToBound( bool trueOrFalse );

      bool contributesToBound() const;




      int visualizerType() const;

      inline DtDe& de() { return myDe;}

      virtual void setModelInstance(DtModelInstance* modelInstance );

      virtual void promoteBackgroundModelInstance(DtModelDefinition& defintion);

      virtual void setVisible(bool isVisible);

      virtual bool visible() const;

      DtUniqueID parentSceneObjectID() const;

      virtual void addedToSceneObjectAsProp( const DtUniqueID& sceneObj );

      virtual void addedToSceneObject( const DtUniqueID& sceneObj, int modelSet,
         int visualizerType );

      virtual void setElementId(DtUniqueID id);

      virtual void removedFromSceneObject();

      virtual void setIsSupportModel(bool isSupport) = 0;

      virtual void setSolid(bool isSolid);

      virtual bool isProp();

      boost::signal<void (DtModel*)> signal_modelToBeDestroyed;
      boost::signal<void (DtModel*)> signal_modelChanged;

      boost::signal<bool (DtModel*,bool ), SlotReturnOR> signal_visibilityChangeRequested;

      boost::signal<void (DtModelInstance*, DtModel*)> signal_modelInstanceCreated;

      boost::signal<void (DtModelInstance*, DtModel*)> signal_modelInstanceToBeDestroyed;



      virtual bool supportsMultithreadedLoad() { return false; }

      virtual void backgroundLoad() { ; }

      virtual void foregroundLoad() { ; }

      virtual bool isActivelyBackgroundLoading();

      virtual DtLoaderHandle * findLoadQueueHandle();

   protected:

      virtual void addToScene( const DtUniqueID& sceneObjectId,
         int modelSet, int visualizerType ) = 0;

      virtual void addToSceneAsProp( const DtUniqueID& sceneObjectId ) {}

      virtual void removeFromScene() = 0;

      virtual void initializeModelInstance();

      void  slot_modelInstanceChanged( DtModelInstance* instance );


   protected:
      virtual void waitAndClearLoadHandle();
      virtual void removedFromLoadQueue();
      virtual void setDoneBackgroundLoading();
      virtual void setActivelyBackgroundLoading();

      friend class DtBackgroundLoader;
      friend class DtBackgroundLoadAsyncTask;
      DtLoaderHandle * myInLoadQueueHandle;

   protected:
      struct ObjectTransform
      {
         DtVector position;
         DtTaitBryan orientation;
      };

      typedef std::vector<ObjectTransform> TransformList;

      DtDe& myDe;

      const DtUniqueID myUniqueId;

      bool myColorBlendingEnabled;

      DtModelInstance* myBackgroundModelInstance;
     
   private:
      void deleteModelInstance();

   private:

      TransformList myTransforms;
      DtModelInstance* myModelInstance;
      int myModelSet;
      int myVisualizerType;
      bool myContributesToBound;
      DtUniqueID myParentSceneObjectID;
      bool myIsPropFlag;
      float myBlendColor[4];
      bool myVisibleFlag;
     
   protected:
      std::string myModelDefinitionName;
   };

   class DT_DLL_VRVCORE DtModelSignaler : public DtVirtualBaseClass
   {
   public:
      static DtModelSignaler& instance(DtDe&);

      virtual ~DtModelSignaler();

      boost::signal<void (DtModelInstance&)> signal_modelCreated;

      boost::signal<void (DtModelInstance&)> signal_modelChanged;

      boost::signal<void (DtModelInstance&)> signal_modelToBeDestroyed;

   protected:

      DtModelSignaler();

   private: 
      DtModelSignaler(const DtModelSignaler&);
      DtModelSignaler& operator=(const DtModelSignaler&);
   };
}