vreMovementBasedTerrainPreloadController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreMovementBasedTerrainPreloadController.h
//! \ingroup vreVrfmodel
//! \brief Controller for preloading terrain based on entity movement
//!
//! This file defines the DtVreMovementBasedTerrainPreloadController class which
//! provides terrain preloading capabilities based on the current movement and
//! anticipated position of the entity. It predicts which areas of terrain will
//! be needed soon and ensures they are loaded in advance.
 
 
#pragma once
 
class DtBooleanInputPort;
 
#include "vreVrfmodel/export.h"
#include <vrfmodel/movementBasedTerrainPreloadController.h>
#include "vreVrfModel/vreSimComponent.h"
 
namespace makVre
{
//! \brief Type identifier for the VRE movement-based terrain preload controller component
const char DtVreMovementBasedTerrainPreloadControllerType[] = "vre-movement-based-terrain-preload-controller";
 
//! \brief Controller that preloads terrain based on entity movement prediction
//!
//! This controller is a provider to the DtVrfObjectTerrainPreloadManager.
//! It uses the current movement speed and direction of the entity to predict
//! the terrain area that will be needed in the near future by its host entity.
//! The controller adjusts preloading based on whether the entity is in a normal
//! movement state or is falling, which requires different terrain loading patterns.
//!
//! Uses Descriptor Type: DtVreMovementBasedTerrainPreloadControllerDescriptor
class VREVRFMODEL_DLL DtVreMovementBasedTerrainPreloadController
   : public DtVreSimComponent<DtMovementBasedTerrainPreloadController>
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreMovementBasedTerrainPreloadController();
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreMovementBasedTerrainPreloadController(const DtVreMovementBasedTerrainPreloadController& orig);
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   DtVreMovementBasedTerrainPreloadController& operator=(const DtVreMovementBasedTerrainPreloadController& orig);
 
public:
   //! \brief Constructor
   //! \param name The name of this component
   //! \param owner The local object that owns this component
   //! \param simManager The simulation services manager
   //! \param desc Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new movement-based terrain preload controller with the specified parameters.
   DtVreMovementBasedTerrainPreloadController(const DtString& name, DtLocalObject* owner,
      DtSimulationServices* simManager, DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the movement-based terrain preload controller component.
   virtual ~DtVreMovementBasedTerrainPreloadController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreMovementBasedTerrainPreloadControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Calculates the terrain area to preload
   //! \param args Arguments containing information for terrain preload calculation
   //!
   //! Overridden to check the falling port and adjust the preload shape
   //! accordingly. If the entity is falling, the preload shape is forced to
   //! be a chord, which provides a more appropriate preload area for falling entities.
   //! This ensures that terrain is properly loaded in the expected landing area.
   virtual void calculateTerrainPreLoad(DtVrfObjectTerrainPreloadArgs& args) override;
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Creates input and output ports for the component
   //! \return True if ports are successfully created, false otherwise
   //!
   //! Creates, initializes, and adds to the port group all the ports needed
   //! by this component, including the falling input port which influences
   //! terrain preloading behavior.
   virtual bool createPorts() override;
 
protected:
   //! \brief Input port for entity falling state
   //!
   //! Boolean input port that indicates whether the entity is in a falling state.
   //! When true, the terrain preloading shape is adjusted to better accommodate
   //! the trajectory of a falling entity.
   DtBooleanInputPort* myFallingInputPort;
};
 
} // namespace makVre