Emitter.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
 
#pragma once
 
#include <agx/agxPhysics_export.h>
#include <agx/Physics/EmitterEntity.h>
#include <agxStream/Serializable.h>
#include <agx/Task.h>
#include <agxCollide/Geometry.h>
#include <agxCollide/Space.h>
#include <agx/Random.h>
#include <agx/SetVector.h>
#include <agx/BitState.h>
 
namespace agxSDK {
  class Simulation;
}
 
namespace agx
{
  AGX_DECLARE_POINTER_TYPES(Emitter);
  AGX_DECLARE_VECTOR_TYPES(Emitter);
  typedef agx::SetVector<ref_ptr<Emitter> >      EmitterRefSetVector;
 
 
  class CALLABLE AGXPHYSICS_EXPORT Emitter : public SerialTask, public agxStream::Serializable
  {
  public:
    enum Quantity
    {
      QUANTITY_COUNT,
      QUANTITY_VOLUME,
      QUANTITY_MASS
    };
 
    AGX_DECLARE_POINTER_TYPES(DistributionModel);
    AGX_DECLARE_VECTOR_TYPES(DistributionModel);
    AGX_DECLARE_POINTER_TYPES(DistributionTable);
    AGX_DECLARE_POINTER_TYPES(EmitterData);
 
  public:
 
    Emitter(Quantity quantity = QUANTITY_COUNT);
 
    void setGeometry(agxCollide::Geometry* geometry);
    agxCollide::Geometry* getGeometry();
 
 
    void setQuantity(Quantity quantity);
 
    Quantity getQuantity() const;
 
    void setRate(Real rate);
 
    Real getRate() const;
 
    void setVelocity(const Vec3& velocity);
 
    const Vec3& getVelocity() const;
 
    void setSeed(const agx::UInt32 seed);
 
    void setDistributionTable(DistributionTable *table);
 
    void setUseFixedPosition( bool enable, agx::Int axis = -1 );
 
    bool getUseFixedPosition( agx::Int axis = -1 ) const;
 
    void setUseFixedRotation( bool enable, agx::Int axis = -1 );
 
    bool getUseFixedRotation( agx::Int axis = -1 ) const;
 
    void setFixedPositionOffset( const agx::Vec3& fixedPositionOffset );
 
    void setFixedRotationOffset( const agx::Quat& fixedRotationOffset );
 
    agx::Vec3 getFixedPositionOffset() const;
 
    agx::Quat getFixedRotationOffset() const;
 
    DistributionTable *getDistributionTable();
    const DistributionTable *getDistributionTable() const;
 
    agx::UInt getNumEmitted() const;
 
    void setMaximumEmittedQuantity(const agx::Real max);
 
    agx::Real getEmittedQuantity() const;
 
    agx::Real getMaximumEmittedQuantity() const;
 
    void addCollisionGroup(agx::UInt32 id);
    void addCollisionGroup(const agx::Name& name);
 
    void removeCollisionGroup(agx::UInt32 id);
    void removeCollisionGroup(const agx::Name& name);
 
    bool hasCollisionGroup(agx::UInt32 id) const;
    bool hasCollisionGroup(agx::Name id) const;
 
    agx::Physics::CollisionGroupSetPtr getCollisionGroupSet() const;
 
    void setEnableOverrideRenderSettings(bool enable);
 
    bool getEnableOverrideRenderSettings() const;
 
    void setEnableRenderEmittedObjects(bool enable);
 
    bool getEnableRenderEmittedObjects() const;
 
    void setName(const agx::String& name);
 
    agx::String getName() const;
 
    DOXYGEN_START_INTERNAL_BLOCK()
 
    Physics::EmitterPtr getEntity() const;
 
    virtual void transfer(agxSDK::Simulation *simulation);
    void setSpace(agxCollide::Space* space);
 
    AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE(agx::Emitter);
    static agxStream::Serializable* create() { return nullptr; }
    static agxStream::Serializable* create(agxStream::InputArchive&) { return nullptr; }
 
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    virtual void run() override;
 
    virtual ~Emitter();
 
    virtual void emitBody(const Vec3& position,
                          const Quat& rotation,
                          const Vec3& velocity,
                          Emitter::DistributionModel *model) = 0;
    virtual bool preEmit() = 0;
    virtual void postEmit() = 0;
    virtual Real getDefaultElementQuantity(Quantity quantity);
 
    virtual void store( agxStream::OutputArchive& out ) const override;
    virtual void restore( agxStream::InputArchive& in ) override;
 
    void setEmittedQuantity(agx::Real quantity);
    void setEmittedCount(agx::UInt emittedCount);
 
    // Generates a random number from the generator in the emitter
    agx::Real generateRandomNumber();
 
    // State flags for emitter
    enum StateFlags : agx::UInt32
    {
      OVERRIDE_RENDER_SETTINGS = 1 << 0,
      SHOULD_RENDER_EMITTED_OBJECTS = 1 << 1,
      FIXED_POSITION_DEPRECATED = 1 << 2,
      FIXED_ROTATION_DEPRECATED = 1 << 3,
      FIXED_ROTATION_X = 1 << 4,
      FIXED_ROTATION_Y = 1 << 5,
      FIXED_ROTATION_Z = 1 << 6,
      FIXED_POSITION_X = 1 << 7,
      FIXED_POSITION_Y = 1 << 8,
      FIXED_POSITION_Z = 1 << 9,
    };
    using Flags = agx::BitState<StateFlags, agx::UInt32>;
 
  private:
    // Creates and initializes the parameters.
    void init();
 
    // Few helper functions for randomly selecting points in space.
    Vec3 randomPointInBox(const agxCollide::BoundingAABB* bound);
    Vec3 randomPointInSphere(agx::Real maxRadius);
    Vec3 randomPointInGeometry(agxCollide::Geometry* geometry, agxCollide::Geometry* proxySphere);
 
    void setCollisionGroupSet(agx::Physics::CollisionGroupSetPtr set);
 
  protected:
    Physics::EmitterPtr m_entity;
 
    DistributionTableRef m_distributionTable;
    agxCollide::GeometryRef m_geometry;
    agxCollide::GeometryRef m_proxySphere;
    agxCollide::SpaceRef m_space;
    ScalarParameterRef m_timestep;
 
    // Random number generator for body emitter
    UniformRealGenerator m_generator;
 
    agx::Vec3 m_fixedPositionOffset;
    agx::Quat m_fixedRotationOffset;
 
    Quantity m_quantity;
    Real m_rest;
    Flags m_state;
  };
 
 
  class AGXPHYSICS_EXPORT Emitter::DistributionModel : public Referenced, public virtual agxStream::Serializable
  {
  public:
    DistributionModel();
    DistributionModel(agx::Real probabilityWeight);
 
    void setProbabilityWeight(agx::Real weight);
 
    agx::Real getProbabilityWeight() const;
 
 
    agx::UInt getActivationCount() const;
 
    agx::Real getVolume() const;
    agx::Real getMass() const;
 
    DOXYGEN_START_INTERNAL_BLOCK()
 
    AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE(agx::Emitter::DistributionModel);
    static agxStream::Serializable* create() { return nullptr; }
    static agxStream::Serializable* create(agxStream::InputArchive&) { return nullptr; }
 
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    virtual ~DistributionModel();
    virtual agx::Real calculateVolume() = 0;
    virtual agx::Real calculateMass() = 0;
    virtual void store( agxStream::OutputArchive& out ) const override;
    virtual void restore( agxStream::InputArchive& in ) override;
 
  private:
    friend class DistributionTable;
    void setDistribution(DistributionTable *distribution);
 
    static bool rangeCompare(DistributionModel *model, agx::Real value);
 
  protected:
    DistributionTable *m_distribution;
    agx::Real          m_probabilityWeight;
    agx::UInt          m_activationCount;
    agx::RangeReal     m_range;
    agx::Real          m_volume;
    agx::Real          m_mass;
  };
 
  class AGXPHYSICS_EXPORT Emitter::DistributionTable : public Referenced, public virtual agxStream::Serializable
  {
  public:
    DistributionTable(Quantity quantity = QUANTITY_COUNT);
 
    void addModel(DistributionModel *model);
 
    const DistributionModelRefVector& getModels() const;
 
    DistributionModel *getRandomModel();
 
    void setSeed(agx::UInt32 seed);
 
    agx::Real calculateTotalWeight() const;
 
    void setProbabilityQuantity(Quantity quantity);
 
    Quantity getProbabilityQuantity() const;
 
    DOXYGEN_START_INTERNAL_BLOCK()
 
    AGXSTREAM_DECLARE_SERIALIZABLE(agx::Emitter::DistributionTable);
 
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    virtual ~DistributionTable();
 
  private:
    friend class DistributionModel;
    void rebuildProbabilityTable();
 
    agx::Real getQuantifiedProbabilityWeight(DistributionModel *model) const;
    agx::Real calculateTotalQuantifiedWeight() const;
 
 
  private:
    Quantity                              m_quantity;
    DistributionModelRefVector            m_models;
    UniformRealGenerator                  m_randomGenerator;
    agx::UInt32                           m_seed;
    bool                                  m_needRebuild;
  };
 
  /* Implementation */
  AGX_FORCE_INLINE agxCollide::Geometry* agx::Emitter::getGeometry() { return m_geometry; }
 
  inline agx::Physics::CollisionGroupSetPtr agx::Emitter::getCollisionGroupSet() const { return m_entity.collisionGroupSet(); }
 
  AGX_FORCE_INLINE bool agx::Emitter::hasCollisionGroup(agx::UInt32 id) const
  {
    return agxCollide::CollisionGroupManager::hasGroup(getCollisionGroupSet(), id);
  }
 
  AGX_FORCE_INLINE bool agx::Emitter::hasCollisionGroup(const agx::Name id) const
  {
    return agxCollide::CollisionGroupManager::hasGroup(getCollisionGroupSet(), id);
  }
 
  AGX_FORCE_INLINE void agx::Emitter::setCollisionGroupSet(agx::Physics::CollisionGroupSetPtr set)
  {
    m_entity.collisionGroupSet() = set;
  }
}