notifyLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
//! \file notifyLogic.h
//! \brief Example component demonstrating attribute monitoring and temporary notifications in VR-Engage
//!
//! This header defines the DtNotifyLogic component which shows how to monitor player
//! attribute store changes and display temporary overlay notifications. It demonstrates
//! the attribute callback system and temporary notification API.
 
#pragma once
 
#include "vrePlayerStation/playerComponent.h"
 
#include "vreUtil/attribute.h"
 
 
//! \brief Type identifier string for DtNotifyLogic component registration.
//!
//! This string is used when registering the component with the component factory
//! and must match the componentType value used in role configuration files.
constexpr auto DtNotifyLogicType = "DtNotifyLogic";
 
//! \brief Example component demonstrating player attribute monitoring and temporary notifications.
//!
//! This component shows how to use the VR-Engage player attribute store callback system
//! to monitor state changes and display temporary overlay notifications to the user.
//! It specifically monitors the "weaponIndex" attribute and displays a notification
//! when the player's active weapon changes.
//!
//! Key VR-Engage patterns demonstrated:
//! - Subscribing to attribute changes via attribute callbacks
//! - Accessing the player attribute store
//! - Creating temporary overlay notifications with duration
//! - Component lifecycle (initialize, tick, shutdown)
//! - Proper callback cleanup during shutdown
//!
//! This class inherits from DtPlayerComponent and is registered with the player
//! station's component factory for role-based instantiation.
class DtNotifyLogic : public makVre::DtPlayerComponent
{
public:
   //! \brief Default constructor.
   //!
   //! Initializes the notification logic component. The actual setup is performed
   //! in initialize() following the VR-Engage component lifecycle pattern.
   DtNotifyLogic();
 
   //! \brief Virtual destructor.
   //!
   //! Cleanup is performed in shutdown() rather than the destructor to ensure
   //! proper framework ordering during component destruction.
   virtual ~DtNotifyLogic() override;
 
   //! \brief Initializes the component with player station and configuration.
   //!
   //! This method demonstrates the VR-Engage pattern for component initialization:
   //! 1. Call base class initialize() first
   //! 2. Access player attribute store to find monitored attributes
   //! 3. Register attribute callbacks for state change notifications
   //! 4. Handle missing attributes gracefully with warnings
   //!
   //! The "weaponIndex" attribute is accessed from the player attribute store,
   //! which is a centralized repository for player-specific state. Callbacks
   //! are registered using the myAttributeCallbacks connection manager for
   //! automatic lifetime management.
   //!
   //! \param player The player station instance this component belongs to
   //! \param config Configuration table containing role parameters (not used in this example)
   //! \return true if initialization succeeds, false otherwise
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
 
   //! \brief Per-frame update callback.
   //!
   //! Called every frame by the player station framework. This example does not
   //! require per-frame processing, as it uses event-driven callbacks instead.
   //! The empty implementation demonstrates that tick() is optional for
   //! components that only respond to events.
   //!
   //! \param dt Delta time in seconds since last update
   virtual void tick(double dt) override;
 
   //! \brief Shutdown callback for cleanup.
   //!
   //! Performs cleanup before component destruction. This method demonstrates
   //! the VR-Engage pattern for proper callback cleanup:
   //! 1. Call base class shutdown() first
   //! 2. Disconnect all attribute callbacks to prevent dangling pointers
   //!
   //! The myAttributeCallbacks.disconnectAll() call ensures all registered
   //! callbacks are properly removed from the attribute store before the
   //! component is destroyed.
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier.
   //!
   //! This string is used by the component factory for instantiation and
   //! must match the registration in initPlayerStationModule().
   //!
   //! \return The component type string "DtNotifyLogic"
   virtual const char* type() const override;
 
protected:
   //! \brief Callback invoked when the weaponIndex attribute changes.
   //!
   //! This method demonstrates the VR-Engage pattern for attribute change callbacks.
   //! It is automatically called by the attribute store when the "weaponIndex"
   //! value changes, allowing the component to respond to state changes without
   //! polling.
   //!
   //! The callback creates a temporary notification message that displays for
   //! 3 seconds as an overlay in the VR-Engage UI. This is accessed via the
   //! player station app's tempNotification() service.
   //!
   //! PATTERN: Attribute callbacks provide an event-driven alternative to polling
   //! state in tick(). This is the recommended approach for responding to state
   //! changes as it's more efficient and maintains clear separation of concerns.
   //!
   //! \param index The new weapon index value (0-based index into weapon list)
   virtual void handleWeaponIndexChanged(int index);
};