kinetic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file kinetic.h
//! \brief Defines the DtKinetic class for representing entity kinetic state
//!
//! This file contains the DtKinetic class which encapsulates the complete
//! kinetic state of a simulation entity, including position, orientation,
//! linear and angular velocities, and acceleration. This information is used
//! for dead reckoning, physics calculations, and visualization.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
 
namespace makVre
{
//! \brief Class representing the complete kinetic state of an entity
//!
//! DtKinetic encapsulates all kinetic information about a simulation entity,
//! including its position, orientation, velocities, and acceleration. This data
//! is used for various simulation purposes such as:
//! - Dead reckoning to estimate entity positions between network updates
//! - Physics calculations for collision detection and response
//! - Visual representation for accurate entity placement and movement
//!
//! The class provides comparison operators to detect when kinetic state changes.
class PLAYERSTATION_DLL DtKinetic
{
public:
   //! \brief Default constructor
   //!
   //! Creates a new kinetic state with default values (zero for all vectors).
   DtKinetic();
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of derived kinetic classes if any.
   virtual ~DtKinetic();
 
   //! \brief Unique identifier for this entity
   //!
   //! Integer ID that uniquely identifies this entity within the simulation.
   int myId;
 
   //! \brief Identifier of the parent entity
   //!
   //! If this entity is attached to a parent (e.g., a component of a larger entity),
   //! this field contains the parent's ID. Zero or negative values indicate no parent.
   int myParentId;
 
   //! \brief Current position vector
   //!
   //! The entity's position in 3D space, typically expressed in geocentric coordinates.
   DtVector myPosition;
 
   //! \brief Current velocity vector
   //!
   //! The entity's linear velocity in meters per second.
   DtVector32 myVelocity;
 
   //! \brief Current acceleration vector
   //!
   //! The entity's linear acceleration in meters per second squared.
   DtVector32 myAcceleration;
 
   //! \brief Current orientation
   //!
   //! The entity's orientation in 3D space, represented as Tait-Bryan angles
   //! (roll, pitch, yaw).
   DtTaitBryan myOrientation;
 
   //! \brief Current rotational velocity
   //!
   //! The entity's angular velocity in radians per second around each axis.
   DtVector32 myRotationVelocity;
 
   //! \brief Equality comparison operator
   //! \param other The other kinetic state to compare with
   //! \return True if all kinetic properties are equal, false otherwise
   //!
   //! Compares this kinetic state with another and returns true only if
   //! all properties (position, velocity, etc.) are equal. This is used to
   //! detect when an entity's state has changed.
   bool operator==(const DtKinetic& other) const;
 
   //! \brief Inequality comparison operator
   //! \param other The other kinetic state to compare with
   //! \return True if any kinetic property differs, false if all are equal
   //!
   //! Compares this kinetic state with another and returns true if any
   //! property differs. This is the logical inverse of the equality operator.
   bool operator!=(const DtKinetic& other) const;
};
 
} // namespace makVre