DtTacticalSmokeEmitter.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2021 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtImprovedModularEmitter.h>
#include <osgParticle/range>

#include <osg/CopyOp>
#include <osg/Object>
#include <osg/Vec3>
#include <osg/Vec4>

#include <algorithm>
#include <vector>

namespace makVrv
{

   class DT_DLL_VRVOSG DtTacticalSmokeEmitter : public DtImprovedModularEmitter
   {
   public:
      DtTacticalSmokeEmitter();

      DtTacticalSmokeEmitter( const DtTacticalSmokeEmitter& copy,
         const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY );

      META_Object( osgParticle, DtTacticalSmokeEmitter );

      void setPosition( int puffIndex, const osg::Vec3d& pos );

      void setDensity( int puffIndex, float dens );

      void setOneSigma( int puffIndex, const osg::Vec3& sigmas );

      void setIntensityRange( float mn, float mx );

      void setParticleSizeRange( float isz, float fsz );

      void setParticleColorRange( const osg::Vec4& icl, const osg::Vec4& fcl );

      void setParticleAlphaMultiplier( float alpha );

   protected:
      virtual void emitParticles( double dt );

      virtual ~DtTacticalSmokeEmitter() {}

      DtTacticalSmokeEmitter& operator=( const DtTacticalSmokeEmitter& )
      { return *this; }

   private:
      struct PuffData
      {
         int index;
         osg::Vec3d position;
         osgParticle::rangef density;
         osg::Vec3f sigmas;

         PuffData( int idx = 0 )
            : index( idx )
            , position( 0.0, 0.f, 0.0 )
            , density( 1.0f, 0.0f )
            , sigmas( 1.0f, 1.0f, 1.0f )
         {}

         PuffData( const PuffData& other )
            : index( other.index )
            , position( other.position )
            , density( other.density )
            , sigmas( other.sigmas )
         {}

         void swap( PuffData& other )
         {
            std::swap( index, other.index );
            std::swap( position, other.position );
            std::swap( density, other.density );
            std::swap( sigmas, other.sigmas );
         }

         PuffData& operator=( PuffData other )
         {
            swap( other );
            return *this;
         }
      };

      typedef std::vector<PuffData> Puffs;

      PuffData& puffData( int puffIndex );

   private:
      Puffs myPuffs;
      osgParticle::rangef myParticlesPerSec;
      float myAlphaMultiplier;
   };

}