DtTerrainPatch.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2020 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 <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtTreeRecord.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;

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



      const std::string& definition() const;

      DtUniqueID uniqueID() const;

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

      inline DtDe& de() { return myDe;}

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

      void setIsMinimapOnly(bool onlyForMinimap);

      bool isMinimapOnly() const;


      DtOverlaySettings& overlaySettings();

      const DtOverlaySettings& overlaySettings() const;

      DtTerrainTreeSettings& terrainTreeSettings();

      const DtTerrainTreeSettings& terrainTreeSettings() const;

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

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



      void setSurfaceVisible(int surfaceId, bool state);

      bool surfaceVisible(int surfaceId);

      DtSurfacesSettings::SurfaceIdList const& surfaceIds();

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


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

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


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

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

      void onTerrainPatchObjectAvailable(DtUniqueID id);     

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

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

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

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

      void setPatchObjectTerrainTreeData( DtTerrainPatchObject& tpo );

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

   class DT_DLL_VRVCORE DtTerrainPatchSignaler : public DtVirtualBaseClass
   {
   public:

      static DtTerrainPatchSignaler& instance(DtDe& de);

      virtual ~DtTerrainPatchSignaler();

      boost::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);
   };
}