intersector.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file intersector.h
//! \brief Defines the DtIntersector interface for ray casting and intersection testing
//!
//! This file contains the DtIntersector abstract base class which provides an interface
//! for performing ray intersection tests with the 3D environment. This includes tests
//! against terrain, entities, and other scene elements. The interface supports various
//! forms of intersection testing needed for player interaction, targeting, and navigation.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include <vrvCore/DtUniqueID.h>
 
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
 
namespace makVre
{
//! \brief Abstract base class for performing intersection tests in 3D space
//!
//! DtIntersector provides an interface for performing various types of intersection
//! tests within the 3D environment. This includes ray casting against terrain and
//! entities, elevation queries, and screen-to-world coordinate conversion. These
//! capabilities are essential for features like targeting, navigation, and object
//! selection through clicking or pointing.
//!
//! Concrete implementations of this interface are typically provided by display
//! systems like OpenSceneGraph that have access to the full scene graph and can
//! perform efficient intersection tests.
class PLAYERSTATION_DLL DtIntersector
{
public:
   //! \brief Constructor
   //!
   //! Creates a new intersector instance with default values.
   DtIntersector();
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of derived intersector classes.
   virtual ~DtIntersector();
 
   //! \brief Gets the elevation at a specific point
   //! \param point 3D position to query for elevation
   //! \param result Output parameter to receive the elevation value
   //! \return True if the elevation was successfully determined, false otherwise
   //!
   //! Determines the terrain elevation at the specified horizontal position.
   //! The result is the height above mean sea level in meters. This is useful
   //! for determining the ground level for placement of objects.
   virtual bool elevationAt(DtVector point, double& result) = 0;
 
   //! \brief Gets the terrain intersection point at a specific location
   //! \param point 3D position to project onto the terrain
   //! \param result Output parameter to receive the intersection point
   //! \return True if the intersection was successfully determined, false otherwise
   //!
   //! Projects the given point onto the terrain surface along the vertical axis.
   //! The result is the 3D position on the terrain surface. This differs from
   //! elevationAt by returning a complete 3D point rather than just the height.
   virtual bool terrainIntersectionAt(DtVector point, DtVector& result) = 0;
 
   //! \brief Performs a ray intersection test between two points
   //! \param start Starting point of the ray
   //! \param end Ending point of the ray
   //! \param result Output parameter to receive the intersection point
   //! \param ignoreId Optional list of entity IDs to ignore in the test
   //! \return True if an intersection was found, false otherwise
   //!
   //! Tests for intersection of a finite ray from start to end with any objects
   //! in the scene. If an intersection is found, the result parameter is set to
   //! the intersection point. The optional ignoreId parameter allows specific
   //! entities to be excluded from the test.
   virtual bool getIntersection(
      DtVector start, DtVector end, DtVector& result, std::vector<makVrv::DtElementID>* ignoreId = 0) = 0;
 
   //! \brief Performs a ray intersection test from a point in a direction
   //! \param start Starting point of the ray
   //! \param ori Orientation defining the ray direction
   //! \param result Output parameter to receive the intersection point
   //! \param ignoreId Optional list of entity IDs to ignore in the test
   //! \return True if an intersection was found, false otherwise
   //!
   //! Tests for intersection of a ray starting at the specified point and
   //! extending in the direction defined by the orientation. If an intersection
   //! is found, the result parameter is set to the intersection point. The optional
   //! ignoreId parameter allows specific entities to be excluded from the test.
   virtual bool getIntersection(
      DtVector start, DtTaitBryan ori, DtVector& result, std::vector<makVrv::DtElementID>* ignoreId = 0) = 0;
 
   //! \brief Performs a ray cast from screen coordinates
   //! \param x Horizontal screen coordinate (in pixels)
   //! \param y Vertical screen coordinate (in pixels)
   //! \param result Output parameter to receive the intersection point
   //! \return True if an intersection was found, false otherwise
   //!
   //! Projects a ray from the camera through the specified screen coordinates
   //! and finds the first intersection with objects in the scene. This is typically
   //! used for mouse picking operations, converting a 2D screen click to a 3D
   //! position in the world.
   virtual bool screenRayCast(float x, float y, DtVector& result) = 0;
 
protected:
};
} // namespace makVre