networkConnectedState.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file networkConnectedState.h
//! \brief Defines the connected state for networked simulation in VR-Engage
//!
//! This file contains the DtNetworkConnectedState class which manages the
//! application state when VR-Engage is connected to a networked simulation.
//! It handles loading resources, processing network events, and transitioning
//! between role selection and engagement states.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include "vrePlayerStation/playerStationState.h"
 
#include "vreMessageManager/vreMessage.h"
 
namespace makVre
{
//! \brief Forward declaration of the loading page class
class DtVreLoadingPage;
 
//! \brief Application state for network-connected operation
//!
//! DtNetworkConnectedState represents the application state when VR-Engage
//! is connected to a networked simulation. It manages resource loading,
//! network communications, and transitions between sub-states like role
//! selection and entity engagement. This state contains most of the active
//! gameplay functionality of the application.
class PLAYERSTATION_DLL DtNetworkConnectedState : virtual public DtPlayerStationState
{
public:
   //! \brief Constructor
   //! \param app Reference to the player station application
   //!
   //! Creates a new network connected state associated with the given application.
   //! This state is typically entered after a successful network connection.
   DtNetworkConnectedState(DtPlayerStationApp& app);
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of network connected state resources.
   virtual ~DtNetworkConnectedState() override;
 
   //! \brief Called when the state is entered
   //!
   //! Initializes network-related resources, registers message handlers,
   //! and begins loading simulation resources like model sets and entity
   //! definitions. This is called when a network connection is established.
   virtual void onEnter() override;
 
   //! \brief Called when the state is exited
   //!
   //! Cleans up resources, disconnects from the network, and unregisters
   //! message handlers. This is called when disconnecting from the network
   //! or shutting down the application.
   virtual void onExit() override;
 
   //! \brief Called when another state is pushed on top of this one
   //!
   //! Handles adjustments needed when this state is covered by another state
   //! on the stack, such as pausing certain network operations or UI updates.
   virtual void onStacked() override;
 
   //! \brief Called when the state becomes the topmost state again
   //!
   //! Restores functionality when this state is exposed after another state
   //! has been popped from the stack, resuming network operations and updates.
   virtual void onExposed() override;
 
   //! \brief Updates the state each frame
   //! \param dt Time in seconds since the last update
   //!
   //! Handles per-frame processing in the connected state, including
   //! monitoring resource loading progress, processing network events,
   //! and updating UI elements as needed.
   virtual void tick(double dt) override;
 
   //! \brief Invokes Vortex debug callbacks
   //!
   //! Used for debugging physics simulation (Vortex) related functionality.
   //! This is typically only called during development and testing.
   virtual void debugVortexCallback();
 
protected:
   //! \brief Message handlers
   //! @{
 
   //! \brief Handles messages requesting to stop the network connection
   //! \param msg Pointer to the stop connection message
   //! \return Message handling result
   //!
   //! Processes requests to voluntarily disconnect from the network,
   //! typically initiated by the user or another part of the application.
   virtual DtVreMessageResult handleStopConnection(DtVreMessage* msg);
 
   //! \brief Handles network disconnection messages
   //! \param msg Pointer to the network disconnected message
   //! \return Message handling result
   //!
   //! Processes notifications that the network connection has been lost,
   //! transitioning to an appropriate state to handle the disconnection.
   virtual DtVreMessageResult handleNetworkDisconnected(DtVreMessage* msg);
 
   //! \brief Handles SMS load completion messages
   //! \param msg Pointer to the SMS load complete message
   //! \return Message handling result
   //!
   //! Processes notifications that Simulation Model Sets (SMS) have finished
   //! loading, updating the application state accordingly.
   virtual DtVreMessageResult handleSmsLoadComplete(DtVreMessage* msg);
 
   //! \brief Handles visual model definitions loaded messages
   //! \param msg Pointer to the visual model definitions loaded message
   //! \return Message handling result
   //!
   //! Processes notifications that visual model definitions have finished
   //! loading, which is a prerequisite for proper entity visualization.
   virtual DtVreMessageResult handleVisualModelDefinitionsLoaded(DtVreMessage* msg);
   //! @}
 
   //! \brief Name of the network driver being used
   //!
   //! Identifies which network protocol driver (e.g., DIS, HLA) is currently active.
   std::string myDriverName;
 
   //! \brief Shared pointer to the loading page UI
   //!
   //! Provides the user interface for displaying loading progress
   //! while resources are being loaded in the background.
   std::shared_ptr<DtVreLoadingPage> myLoadingPage;
 
   //! \brief Bitmask tracking the status of SMS resource loading
   //!
   //! Used to track which specific resource types have completed loading,
   //! allowing the application to determine when all required resources are ready.
   int mySmsLoadStatusBits;
};
 
} // namespace makVre