vortexConfigurationDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vortexConfigurationDescriptor.h
//! \brief Defines DtVortexConfigurationDescriptor for managing Vortex physics configuration parameters
//! \ingroup vreVrfVortexObjparam
 
#pragma once
 
#include "vreVrfVortexObjparam/export.h"
#include "vreVrfVortexObjparam/vortexConfigurationElementDescriptor.h"
 
namespace makVre
{
//! \brief Type identifier string for the DtVortexConfigurationDescriptor class
const char DtVortexConfigurationDescriptorType[] = "DtVortexConfigurationDescriptor";
 
//! \brief Descriptor for Vortex physics engine configurations
//!
//! DtVortexConfigurationDescriptor manages a collection of configuration parameters
//! for the Vortex physics engine. It stores a name for the configuration and a list
//! of configuration elements that define specific physics parameters. This class supports
//! serialization to and from XML and provides debugging options for parameters.
class VREVRFVORTEXOBJPARAM_DLL DtVortexConfigurationDescriptor : public DtReaderWriter
{
protected:
   //! \brief Protected default constructor
   //!
   //! Creates an empty configuration descriptor
   DtVortexConfigurationDescriptor();
 
public:
   //! \brief Constructor with configuration name and registry
   //! \param name Name of the configuration descriptor
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexConfigurationDescriptor(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Constructor with symbol configuration name and registry
   //! \param name Symbol string name of the configuration descriptor
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexConfigurationDescriptor(const DtSymbolString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig Original configuration descriptor to copy from
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexConfigurationDescriptor(
      const DtVortexConfigurationDescriptor& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Assignment operator
   //! \param orig Original configuration descriptor to copy from
   //! \return Reference to this configuration descriptor after assignment
   DtVortexConfigurationDescriptor& operator=(const DtVortexConfigurationDescriptor& orig);
 
   //! \brief Virtual destructor
   virtual ~DtVortexConfigurationDescriptor() override;
 
   //! \brief Sets the name of the Vortex configuration
   //! \param ConfigurationName The name to set for this configuration
   virtual void setVortexConfigurationName(const std::string& ConfigurationName);
 
   //! \brief Gets the name of the Vortex configuration
   //! \return The name of this configuration
   virtual std::string vortexConfigurationName() const;
 
   //! \brief Sets the list of configuration elements
   //! \param list The list of configuration elements to set
   virtual void setConfigurationList(const DtVortexConfigurationElementList& list);
 
   //! \brief Gets the list of configuration elements
   //! \return Constant reference to the list of configuration elements
   virtual const DtVortexConfigurationElementList& configurationList() const;
 
   //! \brief Enables or disables debug mode for parameters
   //! \param enable True to enable debug mode, false to disable
   virtual void setDebugParameters(const bool enable);
 
   //! \brief Checks if debug mode is enabled for parameters
   //! \return True if debug mode is enabled, false otherwise
   virtual const bool debugParameters() const;
 
   //! \brief Gets the type identifier for reader/writer operations
   //! \return Type identifier string
   virtual const char* readerWriterType() const override;
 
   //! \brief Gets the XML type identifier for serialization
   //! \return XML type identifier string used when archiving to an XML stream
   static const char* theXmlType();
 
   //! \brief Gets the XML type identifier for this instance
   //! \return XML type identifier string
   virtual const char* xmlType() const override { return theXmlType(); }
 
protected:
   //! \brief The name of this Vortex configuration
   DtRwString myConfigurationName;
 
   //! \brief Flag indicating if debug mode is enabled for parameters
   DtRwBoolean myDebugParameters;
 
   //! \brief List of configuration elements defining specific physics parameters
   DtVortexConfigurationElementList myConfigList;
};
} // namespace makVre