joinedSessionState.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file joinedSessionState.h
//! \brief Defines the state for a joined simulation session in VR-Engage
//!
//! This file contains the DtJoinedSessionState class which manages the application
//! state when the user has joined an existing simulation session. It handles
//! session status monitoring, UI updates, and transitions to other states.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include "vrePlayerStation/playerStationState.h"
#include "vreMessageManager/vreMessage.h"
 
// #include <memory>
 
namespace makVre
{
//! \brief Forward declaration of the session load data message class
class SessionLoadDataMessage;
 
//! \brief Enumeration of session types in VR-Engage
//!
//! Defines the different types of sessions that can be active in the application,
//! indicating how the session was created or accessed.
enum class DtSessionType
{
   HOSTED_SESSION = 1,   //!< Session created and hosted by this instance
   UNHOSTED_SESSION,     //!< Local session not accessible by other users
   JOINED_SESSION,       //!< Session joined from another host
   UNKNOWN_SESSION = 100 //!< Session type could not be determined
};
 
//! \brief Application state for an active joined simulation session
//!
//! DtJoinedSessionState represents the application state when the user has
//! successfully joined an existing simulation session. It manages the connection
//! to the session, monitors session status, and provides UI controls for session
//! management. This state is typically entered after connecting to a network
//! and selecting a session to join.
class PLAYERSTATION_DLL DtJoinedSessionState : virtual public DtPlayerStationState
{
public:
   //! \brief Constructor
   //! \param app Reference to the player station application
   //!
   //! Creates a new joined session state associated with the given application.
   //! This state is entered when a user successfully joins a simulation session.
   DtJoinedSessionState(DtPlayerStationApp& app);
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of resources used by the joined session state.
   virtual ~DtJoinedSessionState() override;
 
   //! \brief Called when the state is entered
   //! \param args Pointer to arguments from the previous state
   //!
   //! Sets up the joined session, registers message handlers, and initializes
   //! the UI. This is called when the user first joins a simulation session.
   virtual void onEnter(const DtPlayerStationStateArgs* args) override;
 
   //! \brief Called when the state is exited
   //!
   //! Cleans up resources, unregisters message handlers, and performs any
   //! necessary session disconnection operations.
   virtual void onExit() override;
 
   //! \brief Updates the state each frame
   //! \param dt Time in seconds since the last update
   //!
   //! Handles per-frame updates for the joined session, including monitoring
   //! session status and updating UI elements.
   virtual void tick(double dt) override;
 
   //! \brief Gets the current session type
   //! \return Type of the current session
   //!
   //! Retrieves the type of the current session (e.g., hosted, unhosted, joined).
   //! This can be used to determine appropriate behavior based on session type.
   virtual DtSessionType getSessionType();
 
protected:
   //! \brief Message handlers
   //! @{
 
   //! \brief Handles session status messages
   //! \param msg Pointer to the session status message
   //! \return Message handling result
   //!
   //! Processes messages about changes to the VRF session status,
   //! updating the application state accordingly.
   virtual DtVreMessageResult handleVrfSessionStatus(DtVreMessage* msg);
 
   //! \brief Handles choose session button click messages
   //! \param msg Pointer to the button click message
   //! \return Message handling result
   //!
   //! Processes messages generated when the user clicks the button
   //! to choose a different session, typically exiting the current session.
   virtual DtVreMessageResult handleChooseSessionButtonClicked(DtVreMessage* msg);
 
   //! \brief Handles application mode update messages
   //! \param msg Pointer to the app mode update message
   //! \return Message handling result
   //!
   //! Processes messages about changes to the application mode,
   //! adjusting the session state accordingly.
   virtual DtVreMessageResult handleAppModeUpdated(DtVreMessage* msg);
   //! @}
 
   //! \brief Updates UI cutout controls based on a specific context
   //! \param context Context identifier to determine which controls to show/hide
   //!
   //! Adjusts the visibility and state of UI controls in the cutout area
   //! based on the specified context. This allows for dynamic UI adjustments
   //! appropriate to the current session state and user activity.
   virtual void updateUICutoutControls(const std::string& context);
 
   //! \brief Session load data message
   //!
   //! Contains information about the session that was loaded,
   //! including configuration settings and connection details.
   std::shared_ptr<SessionLoadDataMessage> myLoadData;
 
   //! \brief Type of the current session
   //!
   //! Identifies whether this is a hosted, unhosted, or joined session.
   DtSessionType mySessionType;
};
 
} // namespace makVre