vrvIntersector.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file vrvIntersector.h
//! \brief Defines a VRV-based terrain and scene intersector
//!
//! The DtVrvIntersector class provides functionality for performing various types
//! of intersection tests with the 3D scene, including ray casting, terrain elevation
//! queries, and screen-space picking. It serves as a bridge between the VRE player
//! station and the VRV rendering engine's intersection capabilities.
 
#pragma once
 
#include "vrePlayerStation/export.h"
#include "vrePlayerStation/intersector.h"
#include <vrvCore/DtIntersector.h>
 
namespace makVrv
{
//! Forward declaration of the display engine class
class DtDe;
 
//! Forward declaration of the VRV intersector class
class DtIntersector;
} // namespace makVrv
 
namespace makVre
{
//! \brief VRV-based implementation of the intersector interface
//!
//! This class provides terrain intersection, ray casting, and screen picking
//! functionality using the VRV rendering engine. It handles coordinate
//! transformations between local and network (geocentric) coordinate systems
//! and supports various types of intersection queries against the 3D scene.
class PLAYERSTATION_DLL DtVrvIntersector : public DtIntersector
{
public:
   //! \brief Constructor that initializes with a reference to the display engine
   //! \param de Reference to the VRV display engine
   //!
   //! Creates a VRV intersector for the 3D model set and initializes internal state.
   DtVrvIntersector(makVrv::DtDe& de);
 
   //! \brief Virtual destructor to properly clean up resources
   //!
   //! Deletes the internal VRV intersector object.
   virtual ~DtVrvIntersector() override;
 
   //! \brief Gets the terrain elevation at a specific point
   //! \param point The point in geocentric coordinates to query (only lat/lon are used)
   //! \param result The resulting elevation in meters
   //! \return True if the elevation was successfully determined, false otherwise
   //!
   //! Determines the terrain elevation at the specified geocentric point by
   //! casting a ray downward from a high altitude and finding the intersection
   //! with the terrain. The result is returned as an altitude value in meters.
   virtual bool elevationAt(DtVector point, double& result) override;
 
   //! \brief Gets the terrain intersection point at a specific location
   //! \param point The point in geocentric coordinates to query (only lat/lon are used)
   //! \param result The resulting intersection point in geocentric coordinates
   //! \return True if an intersection was found, false otherwise
   //!
   //! Casts a ray downward from a high altitude at the specified lat/lon and
   //! returns the geocentric coordinates of the intersection with the terrain.
   virtual bool terrainIntersectionAt(DtVector point, DtVector& result) override;
 
   //! \brief Gets the first intersection between two points
   //! \param start The starting point in geocentric coordinates
   //! \param end The ending point in geocentric coordinates
   //! \param result The resulting intersection point in geocentric coordinates
   //! \param ignoreId Optional list of element IDs to ignore during intersection testing
   //! \return True if an intersection was found, false otherwise
   //!
   //! Tests for an intersection along the line segment between start and end,
   //! returning the first intersection point encountered with pickable nodes.
   virtual bool getIntersection(
      DtVector start, DtVector end, DtVector& result, std::vector<makVrv::DtElementID>* ignoreId = 0) override;
 
   //! \brief Gets the first intersection along a ray from a point in a direction
   //! \param start The starting point in geocentric coordinates
   //! \param ori The orientation defining the ray direction
   //! \param result The resulting intersection point in geocentric coordinates
   //! \param ignoreId Optional list of element IDs to ignore during intersection testing
   //! \return True if an intersection was found, false otherwise
   //!
   //! Tests for an intersection along a ray defined by a start point and orientation,
   //! returning the first intersection point encountered with pickable nodes.
   virtual bool getIntersection(
      DtVector start, DtTaitBryan ori, DtVector& result, std::vector<makVrv::DtElementID>* ignoreId = 0) override;
 
   //! \brief Performs a ray cast from screen coordinates
   //! \param x The normalized x screen coordinate (0.0 to 1.0, left to right)
   //! \param y The normalized y screen coordinate (0.0 to 1.0, top to bottom)
   //! \param result The resulting intersection point in geocentric coordinates
   //! \return True if an intersection was found, false otherwise
   //!
   //! Projects a ray from the camera through the specified screen coordinates
   //! and returns the first intersection with pickable nodes in the scene.
   virtual bool screenRayCast(float x, float y, DtVector& result) override;
 
   //! \brief Extended screen ray casting with additional control options
   //! \param x The normalized x screen coordinate (0.0 to 1.0, left to right)
   //! \param y The normalized y screen coordinate (0.0 to 1.0, top to bottom)
   //! \param result The resulting intersection point in geocentric coordinates
   //! \param id Output parameter that receives the element ID of the intersected object
   //! \param props Properties that control which types of nodes to test against
   //! \param ignoreId Optional list of element IDs to ignore during intersection testing
   //! \param window Optional window name to use for picking (defaults to current)
   //! \param channel Optional channel name to use for picking (defaults to current)
   //! \return True if an intersection was found, false otherwise
   //!
   //! Extended version of screenRayCast that provides additional control over
   //! the intersection test, including which types of nodes to test against,
   //! specific windows and channels to use, and retrieving the element ID
   //! of the intersected object.
   virtual bool screenRayCast(float x, float y, DtVector& result, makVrv::DtElementID& id,
      makVrv::DtIntersector::IntersectProperties props = makVrv::DtIntersector::SupportNodes,
      std::vector<makVrv::DtElementID>* ignoreId = 0, const std::string& window = "", const std::string& channel = "");
 
protected:
   //! \brief Reference to the VRV display engine
   makVrv::DtDe& myDe;
 
   //! \brief Pointer to the internal VRV intersector implementation
   makVrv::DtIntersector* myIntersector;
};
} // namespace makVre