projectileFactory.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
#pragma once
 
//! \ingroup vreVrfobjcore
//! \brief Projectile factory class for VREngage
//!
//! This file defines the DtProjectileFactory class, which provides a factory for creating
//! DtProjectile objects in VREngage simulations. By default, the factory contains a single
//! entry for the base DtProjectile class, but additional projectile types can be registered.
 
class DtProjectile;
 
#include "vreVrfobjcore/export.h"
 
#include <vlutil/vlString.h>
 
#include <string>
#include <map>
 
class DtReaderWriterRegistry;
 
namespace makVre
{
class DtProjectile;
 
//! \brief Function pointer type for projectile creation functions
//!
//! Defines the signature for functions that create projectile instances.
//! Each registered projectile type must provide a creator function with this signature.
using DtProjectileCreatorFcn = DtProjectile* (*)(const DtString& name, DtReaderWriterRegistry* const parentRegistry);
 
//! \brief Factory for creating projectile objects
//!
//! This class provides a factory for creating DtProjectile objects based on a type string.
//! By default, the factory contains a single entry for the base DtProjectile class, but
//! additional projectile types can be registered using the addCreatorFcn method.
class VREVRFOBJCORE_DLL DtProjectileFactory
{
public:
   //! \brief Default constructor
   //!
   //! Creates a new projectile factory with no registered projectile types.
   DtProjectileFactory();
 
   //! \brief Copy constructor
   //! \param orig The source factory to copy from
   //!
   //! Creates a new projectile factory as a copy of the provided original,
   //! copying all registered projectile types.
   DtProjectileFactory(const DtProjectileFactory& orig);
 
   //! \brief Assignment operator
   //! \param orig The source factory to copy from
   //! \return Reference to this factory after assignment
   //!
   //! Assigns the contents of the provided factory to this one,
   //! copying all registered projectile types.
   const DtProjectileFactory& operator=(const DtProjectileFactory& orig);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the factory.
   virtual ~DtProjectileFactory();
 
   //! \brief Registers a projectile creation function with the factory
   //! \param type The string identifier for this projectile type
   //! \param fcn Function pointer to the creator function for this type
   //!
   //! Adds a creator function to the factory for a specific projectile type.
   //! When createProjectile is called with this type string, the registered
   //! function will be used to create the projectile instance.
   virtual void addCreatorFcn(const std::string& type, DtProjectileCreatorFcn fcn);
 
   //! \brief Creates a projectile instance of the specified type
   //! \param type The string identifier for the projectile type to create
   //! \param name The name to assign to the new projectile
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //! \return Pointer to the newly created projectile instance
   //!
   //! Creates and returns a new instance of a DtProjectile object of the specified type.
   //! The type must have been previously registered with addCreatorFcn.
   virtual DtProjectile* createProjectile(
      const char* type, const DtString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
protected:
   //! \brief Map of projectile types to their creator functions
   //!
   //! Stores the mapping between projectile type strings and their corresponding
   //! creator functions. When createProjectile is called, the type string is used
   //! to look up the appropriate creator function in this map.
   std::map<std::string, DtProjectileCreatorFcn> myProjectileCreatorMap;
};
} // namespace makVre