createNewEntityEventProcessor.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file createNewEntityEventProcessor.h
//! \brief Defines the event processor for entity creation interactions
//!
//! This file contains the DtCreateNewEntityEventProcessor class which handles
//! user interactions during entity creation and placement, including mouse
//! and keyboard events for positioning and configuring new entities.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include <vrvCore/DtChannel.h>
 
#include <vrvCore/DtBasicEditingEventProcessor.h>
 
#include <boost/signals2/signal.hpp>
 
namespace makVre
{
//! \brief Forward declaration of the player station application class
class DtPlayerStationApp;
 
//! \brief Event processor for entity creation and placement
//!
//! DtCreateNewEntityEventProcessor handles user interactions during entity
//! creation and placement operations. It processes mouse and keyboard events
//! to allow users to position, rotate, and configure new entities being added
//! to the simulation. This processor is typically active during the entity
//! creation workflow in the choose role state.
class PLAYERSTATION_DLL DtCreateNewEntityEventProcessor : public makVrv::DtBasicEditingEventProcessor
{
public:
   //! \brief Constructor
   //! \param de Reference to the display engine
   //! \param app Reference to the player station application
   //!
   //! Creates a new entity creation event processor associated with the
   //! specified display engine and player station application.
   DtCreateNewEntityEventProcessor(makVrv::DtDe& de, DtPlayerStationApp& app);
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of processor resources.
   virtual ~DtCreateNewEntityEventProcessor() override;
 
   //! \brief Gets the class name of this processor
   //! \return Reference to the class name string
   //!
   //! Returns the name of this event processor class.
   //! Used for identification and debugging purposes.
   virtual const std::string& className() override;
 
   //! \brief Enables or disables the event processor
   //! \param enabled True to enable processing, false to disable
   //!
   //! Controls whether this processor is active and handling events.
   //! When disabled, it will ignore events and pass them to the next handler
   //! in the processing chain. This allows the processor to be temporarily
   //! deactivated without removing it from the processing chain.
   virtual void setEnabled(bool enabled) override;
 
   //! \brief Signal emitted when creation is canceled
   //! \param escPressed Boolean indicating if cancellation was via Escape key
   //!
   //! This signal is emitted when entity creation is canceled, either by
   //! user action (right-click or Escape key) or programmatically.
   //! The boolean parameter indicates whether the cancellation was triggered
   //! by the Escape key (true) or by another method (false).
   boost::signalslib::signal<void(bool)> signal_cancel;
 
   //! Derived to use this class's myElementsToIgnore list.
   virtual bool pick(makVrv::DtChannel& channel,
      double x,
      double y,
      makVrv::DtIntersectorResult& result,
      makVrv::DtIntersector::IntersectProperties props) const override;
 
   virtual void setElementsToIgnore(const std::vector<makVrv::DtElementID>& ids);
 
protected:
   //! \brief Processes mouse events during entity creation
   //! \param ev Mouse event to process
   //! \param channel Display channel receiving the event
   //! \return True if the event was handled, false to allow further processing
   //!
   //! Handles mouse events like movement, clicks, and drags during entity creation.
   //! These events are used to position and orient the entity being placed.
   virtual bool processMouseEvent(const makVrv::DtMouseEvent& ev, makVrv::DtChannel& channel) override;
 
   //! \brief Processes keyboard events during entity creation
   //! \param ev Keyboard event to process
   //! \param channel Display channel receiving the event
   //! \return True if the event was handled, false to allow further processing
   //!
   //! Handles keyboard events during entity creation, such as escape to cancel
   //! or other keys that might modify the creation process.
   virtual bool processKeyboardEvent(const makVrv::DtKeyEvent& ev, makVrv::DtChannel& channel) override;
 
   //! \brief Cancels the entity creation process
   //! \param escPressed True if cancellation was via Escape key
   //!
   //! Cancels the current entity creation operation, emitting the signal_cancel
   //! signal with the escPressed parameter. This is typically called when the
   //! user presses Escape or performs another cancellation action.
   virtual void cancel(bool escPressed);
 
   //! \brief Cancels the entity creation process
   //!
   //! Convenience method that calls cancel(false), indicating that
   //! cancellation was not via the Escape key.
   virtual void cancel() override;
 
   //! \brief Manager for signal connections
   //!
   //! Manages connections to various signals that need to be tracked
   //! for proper disconnection when the processor is destroyed.
   makVrv::DtSignalConnectionManager myConnections;
 
   //! \brief Last recorded X position of the mouse
   //!
   //! Used to track mouse movement for entity positioning and rotation.
   int myMouseLastX;
 
   //! \brief Last recorded Y position of the mouse
   //!
   //! Used to track mouse movement for entity positioning and rotation.
   int myMouseLastY;
 
   //! \brief Distance the mouse has traveled during a drag operation
   //!
   //! Used to detect small movements versus significant drags.
   int myMouseDownTravel;
 
   //! \brief Set of objects that were selected before entity creation began
   //!
   //! Stored to restore selection state if entity creation is canceled.
   makVrv::DtSelectionManager::IdSet mySavedSelection;
 
   //! \brief Reference to the player station application
   //!
   //! Provides access to application services and state during entity creation.
   DtPlayerStationApp& myApp;
 
   std::vector<makVrv::DtElementID> myElementsToIgnore;
};
} // namespace makVre