DtOsgUtils.h

Go to the documentation of this file.

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


#pragma once

#include <osg/Quat>
#include <osg/Texture2DArray>
#include <osg/Depth>
#include <osg/Camera>
#include <osg/MatrixTransform>
#include <osg/Geometry>
#include <osg/BoundingBox>

#include <osgEarth/MapNode>
#include <osgEarth/DecalLayer>
#include <osgEarth/FeatureSource>

#include <vrvOsg/DtOsgShaderUtils.h>
#include <vrvOsg/DtDynamicTerrainRasterLibrary.h>
#include <vrvMath/DtCameraFwdDeclare.h>

#include <vrvUtil/DtDynamicTerrainLine.h>

#include <set>
#include <map>

class DtTaitBryan;

namespace osgEarth
{
   class MetadataNode;
}

namespace osg
{
   class TextureBuffer;
}

namespace makVrv
{

   // see the <mappings> for the decal coverage raster layer
#define COVERAGE_MAPPING_VALUE_CRATER 11
#define COVERAGE_MAPPING_VALUE_SCRAPE 11
#define COVERAGE_MAPPING_VALUE_DITCH  11

   class DtGlSimpleTexture;
   class DtDynamicTerrainGeometry;
   class DtDynamicTerrainChange;
   class DtDynamicTerrainSphere;
   class DtIntersector;

   class DtOsgDebugFrustum : public osg::Referenced
   {
   public:
       DtOsgDebugFrustum(const osg::Vec4 & color);
       void updateDebugFrustum(osg::Vec3d * frustumVertices);

       osg::ref_ptr<osg::MatrixTransform> myTransform;
       osg::ref_ptr<osg::Geometry> myGeometry;
   };

   class DT_DLL_VRVOSG DtOsgOverlayUtils
   {
   public:
      static osg::Camera* CreateTextureQuadOverlay(DtGlSimpleTexture* texture,
         float x, float y, float w, float h);

      static osg::Camera* CreateTextureQuadOverlay(osg::Texture* texture,
         float x, float y, float w, float h);

      static osg::Camera* CreateTextureQuadOverlay(const std::string& shader_root, osg::Texture2DArray* textureArray,
         float x, float y, float w, float h);
   };

   class DT_DLL_VRVOSG DtOsgUtils
   {
   public:

      // Get values for crater
      static const std::string CRATER_MAJOR_AXIS;
      static const std::string CRATER_MINOR_AXIS;
      static const std::string CRATER_HEADING;
      static const std::string CRATER_EFFECT_ENUM;
      static const std::string CRATER_SOIL_TYPE;
      static const std::string CRATER_DEPTH;
      static const std::string CRATER_TYPE;
      static const std::string MODELDEFINITION_PROPS;

      //   static const std::string CRATER_LAND_COVER = "crater-land-cover";
      static const std::string COMMAND_UID;
      // Deprecated, but still set (to the same value as CRATER_MAJOR_AXIS)
      static const std::string CRATER_RADIUS;

      static const std::string TerrainDamageName;
      static const std::string TerrainDamageSlight;
      static const std::string TerrainDamageModerate;
      static const std::string TerrainDamageDestroyed;

      // Get values for the tracks (others are in keyValuePairDefinitions.h)
      static const std::string TRACKS_LINE_WIDTH;
      static const std::string TRACKS_TERRAIN_TIME;

      static const std::string EffectMapTextureUniformName;
      static const std::string EffectMapTextureMatrixUniformName;
      static const std::string TrackModelDefinitionSchema;
      static const std::string TrackTypeParameterName;
      static const std::string TrackSoilTypeParameterName;
      static const std::string TrackDepthParameterName;
      static const std::string TrackPointAParameterName;
      static const std::string TrackPointBParameterName;
      static const std::string TrackTexureParameterName;
      static const std::string TrackSegmentSpacingParameterName;

      // Get values for other terrain deformation (ditch/berm/tank scrape,..)
      static const std::string TERRAIN_DEFORMATION_ENUM;
      static const std::string TERRAIN_DEFORMATION_LANDCOVER_OVERRIDE;
      static const std::string TERRAIN_DEFORMATION_WIDTH;
      static const std::string TERRAIN_DEFORMATION_HEIGHT;
      static const std::string TERRAIN_DEFORMATION_RESOLUTION;

      enum DtTerrainDeformation
      {
         DtTerrainDeformationNone = 0,
         DtTerrainDeformationBerm = 1,
         DtTerrainDeformationDitch = 2,
         DtTerrainDeformationTankScrape = 3,
         DtTerrainDeformationHill = 4
      };
      
      // Used to map from vrfVrlinkExt enum DtTerrainCraterEffectEnum32 which is what's provided
      // in string form in CRATER_EFFECT_ENUM
      enum DtCraterEffect
      {
         DtTerrainCraterNoEffect = 0,
         DtTerrainCraterElevationEffect = 1,
         DtTerrainCraterSoilEffect = 2,
         DtTerrainCraterElevAndSoilEffect = 3,
         DtTerrainCraterAerodromeEffect = 4
      };

       static void makeRotate(osg::Quat& q, const double& angle, const double& x, const double& y, const double& z);

       static osg::Matrixf toOsgRotation(const DtTaitBryan& orientation);

       static void quatMult(osg::Quat& lhs, const osg::Quat& rhs);

       static osg::MatrixTransform * create_axis_primitive();


       static osg::Matrix getOrthoMatrix(bool useReverseZ, double left, double right, 
          double bottom, double top, double zNear, double zFar);

       static osg::Matrix getProjMatrix(bool useReverseZ, double left, double right,
          double bottom, double top, double zNear, double zFar);

       static osg::Matrixd getRevZOrthoMatrix(double left, double right, double bottom,
          double top, double zNear, double zFar);

       static bool getRevZPerspectiveMatrixAsFrustum(const osg::Matrix& mat, double& left,
          double& right, double& bottom, double& top, double& zNear, double& zFar);

       static bool getRevZOrthoMatrixAsFrustum(const osg::Matrix& orthoMat, double& left,
          double& right, double& bottom, double& top, double& zNear, double& zFar);

       static bool getRevZPerspective(const osg::Matrix& mat, double& fovy,
          double& aspectRatio, double& zNear, double& zFar);

       static osg::Matrix makeRevZPerspective(double fovy, double aspectRatio,
          double zNear, double zFar);

       static void getYPR(const osg::Matrix& m, double& yaw, double& pitch, double& roll);

       static void osgPolytopeToFrustum(Frustum_64& frustum, const osg::Polytope& polytope, bool hasNearFar);
       
       static void debugDumpShaderState(osg::State* state);

       static void debugDumpUniformState(const osg::Node* node);


       static osg::Vec2 rotateVec2( const osg::Vec2& v, double rad );

       static osg::Vec2 translateVec2( const osg::Vec2& v, const osg::Vec2& translation );

       static osg::Vec2 scaleVec2( const osg::Vec2& v, double s );

       static osg::Vec2 scaleVec2( const osg::Vec2& v, double xScale, double yScale );

       static bool clipLine( double xMin, double xMax, double yMin, double yMax,
          double x0src, double y0src, double x1src, double y1src,
          double &x0clip, double &y0clip, double &x1clip, double &y1clip );

       static void clipPolygon( double xMin, double xMax, double yMin, double yMax, 
          std::vector<osg::Vec2>& vertices );

       // Adapted from VR-Link DtModPerLo [matrix/modper.cxx]
       template <class VecType> static VecType DtModPerLoVec3( const VecType& in, double min, double max )
       {
          VecType result;
          double per = max - min;

          for( int i = 0; i < 3; ++i )
          {
             if( min <= in[i] && in[i] < max )
             {
                result[i] = in[i];
             }
             else
             {
                result[i] = fmod( in[i] - min, per );

                if( result[i] < 0.0 )
                {
                   result[i] += per;
                }

                result[i] += min;
             }
          }
          return result;
       }
      
      static bool insideTriangulate( const std::vector<osg::Vec2>& contour, std::vector<int>& results );

      static osg::Matrixd calculateRevZProjectionMatrix(double left, double right
         , double bottom, double top
         , double zNear, double zFar);

      static osg::Matrixd calculateOrthoMatrix(double left, double right
         , double bottom, double top
         , double zNear, double zFar);

      static osg::Matrixd calculateRevZProjectionMatrixWithRevZAsNegativeOneForRttCamera(double left, double right
         , double bottom, double top
         , double zNear, double zFar);

      static void dynamicTerrainLineToFeature(const DtDynamicTerrainLine* line, osgEarth::Feature* feature,
         osg::ref_ptr<const osgEarth::SpatialReference> srs);
   
      static void dumpCommandValues(const DtDynamicTerrainChange& command);
      
      class OSMBuildingInfo
      {
      public:
         OSMBuildingInfo(osgEarth::MetadataNode* metadataNode, const std::set<int>& objectIndexList) :
            myMetadataNode(metadataNode),
            myObjectIndexList(objectIndexList)
         {
         }

         osgEarth::MetadataNode* myMetadataNode;
         std::set<int> myObjectIndexList;
      };

      typedef std::map<osgEarth::MetadataNode*, DtOsgUtils::OSMBuildingInfo> MetadaNodeMap;
      
      typedef std::map<std::string, DtOsgUtils::MetadaNodeMap> ChangeIdMetadaNodeMap;

      class FidMetadataNode
      {
      public:
         FidMetadataNode(long long FID, osgEarth::MetadataNode* metadataNode, int objectIndex):
            myFID(FID),
            myMetadataNode(metadataNode),
            myObjectIndex(objectIndex)
         {
         }
         long long myFID;
         osgEarth::MetadataNode* myMetadataNode;
         int myObjectIndex;
      };
 
      typedef std::map<long long, osg::BoundingBoxd> Fid2DebrisMapType;

      struct DebrisPositionStruct
      {
         DebrisPositionStruct(const DtVector& position, const std::string& modelDefinition):
            myPosition(position),
            myModelDefinition(modelDefinition)
         {
         }

         DtVector myPosition;
         std::string myModelDefinition;
      };

      typedef std::vector<DebrisPositionStruct> DebrisPositionListType;

      static void getGeometriesFID(osg::ref_ptr<osgEarth::MapNode> mapNode, const makVrv::DtDynamicTerrainSphere* sphere, std::set<long long>& OsmFidList, DtOsgUtils::Fid2DebrisMapType* fid2DebrisMap);

      static void hideGeometries(osg::ref_ptr<osgEarth::MapNode> mapNode, osg::BoundingSphere bs, const std::set<long long>& FidList, std::vector<DtOsgUtils::FidMetadataNode>& dataList);

      static void showGeometries(osg::ref_ptr<osgEarth::MapNode> mapNode, osg::BoundingSphere bs, const std::set<long long>& FidList);

      static void getDebrisModels(DtDe* de, const DtOsgUtils::Fid2DebrisMapType& fid2DebrisMap, DtOsgUtils::DebrisPositionListType& debrisPositionList, DtIntersector* intersector = nullptr);

      static bool addCraterState(
          const DtDynamicTerrainChange& command,
          osg::ref_ptr<osgEarth::MapNode> mapNode,
          DtDynamicTerrainRasterLibrary* rasterLibrary,
          osg::ref_ptr<osgEarth::LandCoverDictionary> landCoverDictionary_Splat,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalImageLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalElevationLayer> decalElevLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalLandCoverLayer> decalLandCoverLayer_Splat,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalLifeMapLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalCoverageRasterLayer,
          unsigned coverageMappingValue,
          std::string& info,
          std::string& warn,
          osgEarth::GeoExtent& out_feature_extent,
          std::string& craterModelDefinition,
          int minInvalidateLod = -1);

      static bool addLinearStateDeformation(
          const DtDynamicTerrainChange& command,
          osg::ref_ptr<osgEarth::MapNode> mapNode,
          DtDynamicTerrainRasterLibrary* rasterLibrary,
          osg::ref_ptr<osgEarth::LandCoverDictionary> landCoverDictionary_Splat,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalImageLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalElevationLayer> decalElevLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalLandCoverLayer> decalLandCoverLayer_Splat,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalLifeMapLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalCoverageRasterLayer,
          unsigned coverageMappingValue,
          std::string& info,
          std::string& warn,
          osgEarth::GeoExtent& out_feature_extent);

      static bool addTankScrapeState(
          const DtDynamicTerrainChange& command,
          osg::ref_ptr<osgEarth::MapNode> mapNode,
          DtDynamicTerrainRasterLibrary* rasterLibrary,
          osg::ref_ptr<osgEarth::LandCoverDictionary> landCoverDictionary_Splat,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalImageLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalElevationLayer> decalElevLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalLandCoverLayer> decalLandCoverLayer_Splat,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalLifeMapLayer,
          osg::ref_ptr<osgEarth::Contrib::DecalImageLayer> decalCoverageRasterLayer,
          unsigned coverageMappingValue,
          std::string& info,
          std::string& warn,
          osgEarth::GeoExtent& out_feature_extent,
          double start_angle = 0.0,
          int minInvalidateLod = -1);

      static std::string osmFidStringFromList(std::set<long long>& osmFidList);

      static void osmFidStringToList(const std::string& osmFidString, std::set<long long>& osmFidList);

      static int getObjectID(unsigned int instance, osg::TextureBuffer* tbo);

   protected:
      static bool snipTriangle( const std::vector<osg::Vec2>& contour, int u, int v, int w, int n, int *V );
      static bool insideTriangle( float Ax, float Ay, float Bx, float By, float Cx, float Cy, float Px, float Py );
      static float triangulateAreaSize( const std::vector<osg::Vec2> &contour );


   };
}