DtTerrainPatch.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtTerrainLayer.h>
#include <vrvCore/DtOverlaySettings.h>
#include <vrvCore/DtSurfacesSettings.h>
#include <vrvCore/DtTerrainTreeSettings.h>
#include <vrvCore/DtTreeRecord.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <makArchives/DtTerrainPatchRecord.h>

#include <string>
#include <map>
#include <vector>
#include <list>

namespace makVrv
{   
   class DtTerrainPatchObject;
   class DtTerrainPatchObjectAgent;
   class DtSceneObjectAgent;
   class DtAgentManagerInterface;
   class DtModelAgent;
   class DtDe;
   class DtOceanLayer;
   class DtTerrainPatchCreator;

   class DT_DLL_VRVCORE DtTerrainPatch : public DtTerrainLayer
   {
   public:
      friend class DtTerrainPatchCreator;

      using DtPageableTerrainPatchRecord = makArchives::DtTerrainPatchRecord::DtPageableTerrainPatchRecord;

      enum GdbSurface {
         AsphaltOrOtherHardSurface=0,
         Boulder=1,
         Building=2,
         CultivatedFields=3,
         DeepBrook=4,
         DeepLake=5,
         DeepPond=6,
         DeepRiver=7,
         DeepStream=8,
         DirtRoad=9,
         DryGround=10,
         EuroRailRoad=11,
         Flimsy=12,
         Forest=13,
         Grass=14,
         GravelRoad=15,
         Icy=16,
         IcyGround=17,
         Moon=18,
         Mud=19,
         MuddyRoad=20,
         Ocean=21,
         Orchards=22,
         PavedRoad=23,
         Rock=24,
         Sand=25,
         ShallowBrook=26,
         ShallowLake=27,
         ShallowPond=28,
         ShallowRiver=29,
         ShallowStream=30,
         SnowGround=31,
         SoftSoil=32,
         Swamp=33,
         Tree=34,
         USRailRoad=35,
         UndefinedSoilType=36,
         Unspecified=37,
         UnspecifiedBodyOfWater=38,
         UnspecifiedCulturalFeature=39,
         UnspecifiedEnvStateGround=40,
         WetGround=41,
      };

      virtual ~DtTerrainPatch();


   private:
      //not copyable.
      DtTerrainPatch(const DtTerrainPatch& copy);
      DtTerrainPatch& operator=(const DtTerrainPatch& copy);

   public:



      virtual void getRecord(makArchives::DtTerrainPatchRecord& rec) const;

      virtual void setFromRecord(const makArchives::DtTerrainPatchRecord& rec);
      



      virtual const std::string& definition() const;

      virtual DtUniqueID uniqueID() const;

      virtual DtTerrainPatchObjectAgent* findObjectAgent();
      virtual const DtTerrainPatchObjectAgent* findObjectAgent() const;

      inline DtDe& de() { return myDe;}

      inline const DtDe& de() const { return myDe; }

      virtual void setIsMinimapOnly(bool onlyForMinimap);

      virtual bool isMinimapOnly() const;

      virtual void setIsPageable(bool isPageable);
      virtual bool isPageable() const;

      virtual void setPageOutDistance(double pageOutDistance);
      virtual double pageOutDistance() const;

      virtual DtOverlaySettings& overlaySettings();

      virtual const DtOverlaySettings& overlaySettings() const;

      virtual DtTerrainTreeSettings& terrainTreeSettings();

      virtual const DtTerrainTreeSettings& terrainTreeSettings() const;

      virtual const makArchives::DtTerrainPatchRecord::ExtractionOperations&
         extractionOperations() const;

      virtual const makArchives::DtTerrainPatchRecord::OceanExtractionOperations&
         oceanExtractionOperations() const;



      virtual void setSurfaceVisible(int surfaceId, bool state);

      virtual bool surfaceVisible(int surfaceId);

      virtual const DtSurfacesSettings::SurfaceIdList& surfaceIds();

      virtual void loadSurfacesSettings();




      virtual void setExtractedNodeAsPropModel( DtProp* prop , 
         bool setObjectPosition = false);

      virtual int countNodes(const std::string& rules) const;

      virtual void extractNodes(const std::string& rule, bool isRegEx);

      virtual void moveNode(DtSceneObjectAgent* objectDriver,
         DtModelAgent* model, const std::string& rule, unsigned int index);

      virtual void addExtractNodeOperation(std::string const& searchExp, 
         bool isRegEx, std::string const& propType, unsigned int count);


      virtual void extractNodesToProps(const std::string& exp, bool isRegEx,
         const std::string& type, const std::string& modelDefinition);

      virtual void extractNodesToSpeedTrees(const std::string& exp, bool isRegEx
        , const std::string& modelDefinition);


      virtual void executeExtractionOperation( const
         makArchives::DtExtractionOperationRecord& extractionRec);



      virtual void requestOceanExtraction(const std::string& rule, bool isRegEx);

      virtual void extractOceanNodes(const std::string& rule, bool isRegEx);

      virtual void addOceanExtractNodeOperation(std::string const& searchExp,
         bool isRegEx);

      virtual void addOceanExtractNodeOperationIfExtracted(std::string const& searchExp, bool isRegEx);

      virtual void executeOceanExtractionOperation( const
         makArchives::DtOceanExtractionOperationRecord& extractionRec);





      virtual void extractSpeedTreeNodes(const std::string& rule, const bool isRegEx, const std::string& stModelDefinition);

      void executeSpeedTreeExtractionOperation(const
         makArchives::DtSpeedTreeExtractionOperationRecord& extractionRec);

      virtual void addSpeedTreeExtractOperation(std::string const& searchExp,
         bool isRegEx, const std::string& modelDefinition);


    
      void extractNodesToTrees(std::string const& searchExp, bool isRegEx,
         std::string const& treeSpecies);


   protected:

      DtTerrainPatch(DtDe& de, DtAgentManagerInterface& sceneInterface, const std::string& terrainDefinition, 
         bool minimapOnly=false, const DtPageableTerrainPatchRecord& isPageable=DtPageableTerrainPatchRecord());

      virtual void onTerrainPatchObjectAvailable(DtUniqueID id);

      virtual void onTerrainPatchObjectCreated(DtTerrainPatchObject& terrainPatchObject);

      virtual void executeExtractionOperations( const
         makArchives::DtTerrainPatchRecord::ExtractionOperations& ops );

      virtual void executeOceanExtractionOperations( const
         makArchives::DtTerrainPatchRecord::OceanExtractionOperations& ops );

      virtual void executeSpeedTreeExtractionOperations(const
         makArchives::DtTerrainPatchRecord::SpeedTreeExtractionOperations& ops);

      virtual void createPropsFromRecord(const
         makArchives::DtPropSettingsRecord& propSettings);
     
      virtual void getPropSettingsRecord(
         makArchives::DtPropSettingsRecord& record) const;

      virtual void createPropsFromExtraction( DtTerrainPatchObject& tpo,
         makArchives::DtPropRecord* protoTypeRecord, 
         const std::string& exp, bool isRegEx, const std::vector<std::string>& matches);//unsigned int numProps);

      virtual void slot_oceanNodesExtracted(DtTerrainPatchObject& tpo, bool extracted, std::string const& searchExp, bool isRegEx);

   protected:      

      std::string myDefinition;
      
      DtTerrainPatchObjectAgent* myTerrainAgent;
      
      DtOverlaySettings myOverlaySettings;
      DtSurfacesSettings mySurfacesSettings;
      // Randomization, scale of trees on the terrain patch
      DtTerrainTreeSettings myTerrainTreeSettings;

      makArchives::DtTerrainPatchRecord::ExtractionOperations myExtractionHistory;
      makArchives::DtTerrainPatchRecord::OceanExtractionOperations myOceanExtractionHistory;
      makArchives::DtTerrainPatchRecord::SpeedTreeExtractionOperations mySpeedTreeExtrationHistory;

      bool myIsMinimapOnly;

      DtSignalConnectionManager myConnections;

      DtPageableTerrainPatchRecord myPageableTerrainPatchRecord;
   };

   class DT_DLL_VRVCORE DtTerrainPatchSignaler : public DtVirtualBaseClass
   {
   public:

      static DtTerrainPatchSignaler& instance(DtDe& de);

      virtual ~DtTerrainPatchSignaler();

      boost::signalslib::signal<void (DtTerrainPatch&,int surfaceId, bool state)>
         signal_surfaceVisibilityChanged;

   protected:
      DtTerrainPatchSignaler();

   };

   class DT_DLL_VRVCORE DtTerrainPatchCreator : public DtVirtualBaseClass
   {

   public:
      static DtTerrainPatchCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtTerrainPatchCreator* instance);

      virtual DtTerrainPatch* create(DtDe& de, DtAgentManagerInterface& sceneInterface,
         const std::string& terrainDefinition, bool minimapOnly, const DtTerrainPatch::DtPageableTerrainPatchRecord& pageableRecord);
   };
}