DtDynamicTerrainObject.h

Go to the documentation of this file.

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


#pragma once

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

#include <matrix/vlVector.h>

#include <utility> // std::pair
#include <string>
#include <vector>

namespace makVrv
{
   class DtDe;

   class DT_DLL_VRVCORE DtDynamicTerrainObject : public DtTickable
   {
   protected:

      class DynamicTerrainItem
      {
      public:
         DynamicTerrainItem()
         : myIsDirty(false)
         , myPriority(0)
         , myChangeId((DtUniqueID)-1)
         {
         }
         virtual ~DynamicTerrainItem() {}

         std::list< std::pair<std::string, std::string> > myData;
         // Sent with the dynamic terrain change but not currently used
         double myPriority;
         // Handle to the dynamic terrain world change request for this item. May be 'empty'
         std::vector<DtDynamicTerrainWorld::RequestHandle> myRequestHandles; 
         // keep track so we don't get processed multiple times
         bool myIsDirty; 
         // Since these dynamic terrain items may represent items added to the terrain,
         // such as craters or persistent tracks, an id is generated to support removal
         DtUniqueID myChangeId;  
         
      };

      class DynamicTerrainSphereItem : public DynamicTerrainItem
      {
         public:
            DynamicTerrainSphereItem()
               : DynamicTerrainItem()
               , myRadius(1)

            {
            }

            DtVector myLocation;
            double myRadius;
      };

      class DynamicTerrainLineItem : public DynamicTerrainItem
      {
      public:
         DynamicTerrainLineItem()
            :DynamicTerrainItem()
         {
         }
         std::vector<DtVector> myVertices;
      };

      typedef std::vector<DynamicTerrainItem*> DynamicTerrainVector;

   public:

      DtDynamicTerrainObject( DtDe& de, DtUniqueID id );

      //Not copyable
      DtDynamicTerrainObject(const DtDynamicTerrainObject& copy);

      //Not assignable
      DtDynamicTerrainObject& operator =(const DtDynamicTerrainObject& copy);

   private:
      DtDynamicTerrainObject();

   public:
      virtual ~DtDynamicTerrainObject();

      virtual void update( DtTime tNow );

      virtual bool needsUpdate( DtTime tNow );

      inline DtUniqueID uniqueId() const
      {
         return myUniqueId;
      }

      virtual void addSphericalGeometry( int index, const DtVector& location, double radius, double priority );

      virtual void addLinearGeometry(int index, int vtx, const DtVector& location, double priority, int vertexCount);
      
      virtual void changeSphericalGeometry( int index,  const DtVector& location, double radius, double priority );

      virtual void changeLinearGeometry(int index, int vtx, const DtVector& location, double priority, int vertexCount);

      virtual void clearData( int index );

      virtual void removeItem( int index );

      virtual void addData( int index, const std::string& key, const std::string& value, double priority );

 
   protected:

      virtual void makeDirty( DynamicTerrainItem* item, int index );

      virtual DynamicTerrainItem* getDynamicTerrainItem( int index );

   protected:

      DtDe& myDe;

      DtUniqueID myUniqueId;

      DynamicTerrainVector myDynamicTerrainVector;
      typedef std::list<int> DirtyList;
      DirtyList myDirtyList;
   };
}