pagedTerrainRequest.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    pagedTerrainRequest.h
//! \brief   Classes for handling terrain triangle data and requests for the Vortex physics engine.
//!
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <terrainInterface/terrainProcessPolygonsBox.h>
 
#include "vreUtil/coordConverter.h"
 
#include <vector>
#include <tbb/spin_mutex.h>
 
#include <chrono>
 
//! \brief High-resolution clock type used for timing operations
using HiResClock = std::chrono::high_resolution_clock;
 
namespace makVre
{
class DtSurfaceToVxMaterialMapper;
 
//! \brief Triangle structure optimized for Vortex physics engine
//!
//! A lightweight structure containing only the necessary data for physics calculations:
//! three vertex points and the surface type. Derived from DtTerrainTriangleStruct but
//! with reduced memory footprint.
struct VREVRFVORTEX_DLL DtVortexTriangleStructure
{
   //! \brief Default constructor
   //!
   //! Creates an empty triangle structure.
   DtVortexTriangleStructure() {}
 
   //! \brief Conversion constructor
   //!
   //! Creates a Vortex triangle structure from a terrain triangle structure.
   //!
   //! \param triStruct The source terrain triangle structure
   DtVortexTriangleStructure(const DtTerrainTriangleStruct& triStruct)
   {
      points[0] = triStruct.points[0];
      points[1] = triStruct.points[1];
      points[2] = triStruct.points[2];
      surface = triStruct.surface;
   }
 
   //! \brief Sets the triangle vertices and surface
   //!
   //! Initializes all properties of the triangle in one call.
   //!
   //! \param pt0 First vertex point
   //! \param pt1 Second vertex point
   //! \param pt2 Third vertex point
   //! \param surf Surface type identifier
   void set(DtPoint pt0, DtPoint pt1, DtPoint pt2, DtSurface surf)
   {
      points[0] = pt0;
      points[1] = pt1;
      points[2] = pt2;
      surface = surf;
   }
 
   DtPoint points[3]; //!< Array of three vertex points defining the triangle
   DtSurface surface; //!< Surface type identifier for material properties
};
 
//! \brief Interface for collecting and processing terrain triangles for Vortex
//!
//! This class extends DtTriangleOutputInterface to provide specialized handling of
//! terrain triangles for the Vortex physics engine. It collects triangles, filters them
//! based on surface type, handles coordinate conversions, and provides timing metrics
//! for performance analysis.
class VREVRFVORTEX_DLL DtVortexTriangleOutputInterface : public DtTriangleOutputInterface
{
public:
   //! \brief Type definition for a collection of triangles
   using TerrainTriangleStructList = std::vector<DtVortexTriangleStructure>;
 
   //! \brief Constructor with bounding box and capacity specification
   //!
   //! Initializes the triangle output interface with a given bounding box and
   //! pre-allocates memory for triangles to improve performance.
   //!
   //! \param bb Bounding box defining the terrain area to process
   //! \param reserveSize Number of triangles to pre-allocate memory for
   DtVortexTriangleOutputInterface(DtTerrainProcessPolygonsBox bb, const unsigned int reserveSize);
 
   //! \brief Destructor
   //!
   //! Cleans up resources by clearing the triangle list.
   virtual ~DtVortexTriangleOutputInterface();
 
   //! \brief Processes a terrain triangle and adds it to the collection
   //!
   //! Filters triangles based on surface type, performs coordinate conversion
   //! if needed, and adds valid triangles to the internal collection. This method
   //! is thread-safe.
   //!
   //! \param triangle The terrain triangle to process
   virtual void processTriangle(const DtTerrainTriangleStruct& triangle) override;
 
   //! \brief Checks if triangles should be processed
   //!
   //! \return True if triangle processing is enabled, false otherwise
   virtual bool processTriangles() const override;
 
   //! \brief Sets whether triangles should be processed
   //!
   //! \param value True to enable triangle processing, false to disable
   void setProcessTriangles(bool value);
 
   //! \brief Sets whether to force paging of terrain data
   //!
   //! \param page True to force paging, false otherwise
   void setForcePaging(bool page);
 
   //! \brief Checks if paging is forced
   //!
   //! \return True if paging is forced, false otherwise
   virtual bool forcePaging() const override;
 
   //! \brief Gets the request identifier
   //!
   //! \return The current request identifier
   int requestId() const;
 
   //! \brief Sets the request identifier
   //!
   //! \param id The new request identifier
   void setRequestId(int id);
 
   //! \brief Gets the source identifier
   //!
   //! \return The current source identifier
   int sourceId() const;
 
   //! \brief Sets the source identifier
   //!
   //! \param id The new source identifier
   void setSourceId(int id);
 
   //! \brief Sets the material mapper for surface filtering
   //!
   //! \param mapper The material mapper to use for filtering triangles
   void setMaterialMap(std::shared_ptr<DtSurfaceToVxMaterialMapper> mapper);
 
   //! \brief Sets the coordinate conversion object
   //!
   //! \param coordConv The coordinate converter to use for geocentric conversions
   void setCoordinateConversion(DtCoordinateConvert* coordConv);
 
   //! \brief Sets whether the terrain is in geocentric coordinates
   //!
   //! \param isGeo True if terrain is in geocentric coordinates, false if it's in local coordinates
   void setGeocentricTerrain(bool isGeo);
 
   //! \brief Sets whether this represents dynamic terrain
   //!
   //! \param dynamic True if this represents dynamic terrain, false for static terrain
   void setIsDynamicTerrain(bool dynamic = false);
 
   //! \brief Checks if this represents dynamic terrain
   //!
   //! \return True if this represents dynamic terrain, false for static terrain
   bool isDynamicTerrain() const;
 
   //! \brief Gets the bounding box
   //!
   //! \return The bounding box defining the terrain area
   DtTerrainProcessPolygonsBox boundingBox() const;
 
   //! \brief Starts timing the triangle collection process
   void startGetTrianglesProcessTime();
 
   //! \brief Ends timing the triangle collection process
   void endGetTrianglesProcessTime();
 
   //! \brief Gets the time taken to collect triangles in milliseconds
   //!
   //! \return The time taken to collect triangles in milliseconds
   double getTrianglesTime() const;
 
   //! \brief Starts timing the collision geometry generation process
   void startCollisionGeometryProcessTime();
 
   //! \brief Ends timing the collision geometry generation process
   void endCollisionGeometryProcessTime();
 
   //! \brief Gets the time taken to generate collision geometry in milliseconds
   //!
   //! \return The time taken to generate collision geometry in milliseconds
   double collisionGeometryTime() const;
 
   //! \brief Starts timing the triangle mesh generation process
   void startTriangleMeshProcessTime();
 
   //! \brief Ends timing the triangle mesh generation process
   void endTriangleMeshProcessTime();
 
   //! \brief Gets the time taken to generate triangle mesh in milliseconds
   //!
   //! \return The time taken to generate triangle mesh in milliseconds
   double triangleMeshTime() const;
 
   //! \brief Gets the collected triangles
   //!
   //! \return Constant reference to the list of collected triangles
   virtual const TerrainTriangleStructList& triangles() const;
 
   //! \brief Gets the number of collected triangles
   //!
   //! \return The number of triangles collected
   virtual unsigned triangleCount() const;
 
   //! \brief Clears the triangle list
   //!
   //! Removes all collected triangles from memory.
   virtual void clearTriangleList();
 
protected:
   bool myIsDynamicTerrain;                             //!< Flag indicating if this represents dynamic terrain
   bool myIsGeocentric;                                 //!< Flag indicating if terrain is in geocentric coordinates
   bool myRequestFinished;                              //!< Flag indicating if the request has been completed
   bool myForcePaging;                                  //!< Flag indicating if paging should be forced
   bool myProcessTriangles;                             //!< Flag indicating if triangles should be processed
 
   HiResClock::time_point myGetTrianglesStartTime;      //!< Start time for triangle collection
   HiResClock::time_point myGetTrianglesEndTime;        //!< End time for triangle collection
 
   HiResClock::time_point myCollisionGeometryStartTime; //!< Start time for collision geometry generation
   HiResClock::time_point myCollisionGeometryEndTime;   //!< End time for collision geometry generation
 
   HiResClock::time_point myTriangleMeshStartTime;      //!< Start time for triangle mesh generation
   HiResClock::time_point myTriangleMeshEndTime;        //!< End time for triangle mesh generation
 
   int myRequestId;                                     //!< Identifier for this request
   int mySourceId;                                      //!< Source identifier for this terrain data
 
   DtTerrainProcessPolygonsBox myBoundingBox;           //!< Bounding box defining the terrain area
 
   DtCoordinateConvert* myCoordConvert;                 //!< Converter for geocentric coordinates
 
   std::shared_ptr<DtSurfaceToVxMaterialMapper> myMaterialMapper; //!< Mapper for filtering surfaces
 
   unsigned int myTriangleCount;                                  //!< Number of triangles collected
   TerrainTriangleStructList myTriangleList;                      //!< List of collected triangles
   tbb::spin_mutex myProcessTriangleMutex;                        //!< Mutex for thread-safe triangle processing
};
} // namespace makVre