source/graphics/ParticleEmitter.h

   1 /* Copyright (C) 2023 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef INCLUDED_PARTICLEEMITTER
  19 #define INCLUDED_PARTICLEEMITTER
  20
  21 #include "graphics/ModelAbstract.h"
  22 #include "graphics/ParticleEmitterType.h"
  23 #include "maths/Quaternion.h"
  24 #include "renderer/backend/IDeviceCommandContext.h"
  25 #include "renderer/backend/IShaderProgram.h"
  26 #include "renderer/VertexArray.h"
  27
  28 #include <map>
  29
  30 /**
  31  * Simulation state for a single particle.
  32  */
  33 struct SParticle
  34 {
  35         CVector3D pos;
  36         CVector3D velocity;
  37         float angle;
  38         float angleSpeed;
  39         float size;
  40         float sizeGrowthRate;
  41         SColor4ub color;
  42         float age;
  43         float maxAge;
  44 };
  45
  46 typedef std::shared_ptr<CParticleEmitter> CParticleEmitterPtr;
  47
  48 /**
  49  * Particle emitter.
  50  *
  51  * Emitters store particle data in two forms:
  52  *  * m_Particles contains the raw data used for the CPU particle simulation.
  53  *  * m_VertexArray contains the data required for rendering.
  54  * Particles are rendered as billboard quads, so the vertex array contains four vertices
  55  * per particle with different UV coordinates. The billboard position computation is
  56  * performed by a vertex shader.
  57  *
  58  * The number of particles is a constant for the entire life of the emitter,
  59  * to simplify the updating and rendering.
  60  * m_Particles acts like a ring buffer, so we don't have to worry about dynamically
  61  * allocating particles. If particles have variable lifetimes, they'll exist in the
  62  * array with alpha=0 until they're overwritten by a new particle after the maximum
  63  * lifetime.
  64  *
  65  * (It's quite likely this could be made more efficient, if the overhead of any added
  66  * complexity is not high.)
  67  */
  68 class CParticleEmitter
  69 {
  70 public:
  71         CParticleEmitter(const CParticleEmitterTypePtr& type);
  72
  73         /**
  74          * Set the position to be used for emission of new particles.
  75          */
  76         void SetPosition(const CVector3D& pos)
  77         {
  78                 m_Pos = pos;
  79         }
  80
  81         CVector3D GetPosition() const
  82         {
  83                 return m_Pos;
  84         }
  85
  86         /**
  87          * Set the rotation to be used for emission of new particles (note: depends on particles).
  88          */
  89         void SetRotation(const CQuaternion& rot)
  90         {
  91                 m_Rot = rot;
  92         }
  93
  94         const CQuaternion& GetRotation() const
  95         {
  96                 return m_Rot;
  97         }
  98
  99         /**
 100          * Get the bounding box of the center points of particles at their current positions.
 101          */
 102         const CBoundingBoxAligned& GetParticleBounds() const { return m_ParticleBounds; }
 103
 104         /**
 105          * Push a new particle onto the ring buffer. (May overwrite an old particle.)
 106          */
 107         void AddParticle(const SParticle& particle);
 108
 109         /**
 110          * Update particle and vertex array data. Must be called before RenderArray.
 111          *
 112          * If frameNumber is the same as the previous call to UpdateArrayData,
 113          * then the function will do no work and return immediately.
 114          */
 115         void UpdateArrayData(int frameNumber);
 116
 117         /**
 118          * Make the vertex data available for subsequent binding and rendering.
 119          */
 120         void PrepareForRendering();
 121
 122         /**
 123          * Upload the vertex data to the backend.
 124          */
 125         void UploadData(
 126                 Renderer::Backend::IDeviceCommandContext* deviceCommandContext);
 127
 128         /**
 129          * Bind rendering state (textures and blend modes).
 130          */
 131         void Bind(
 132                 Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
 133                 Renderer::Backend::IShaderProgram* shader);
 134
 135         /**
 136          * Draw the vertex array.
 137          */
 138         void RenderArray(
 139                 Renderer::Backend::IDeviceCommandContext* deviceCommandContext);
 140
 141         /**
 142          * Stop this emitter emitting new particles, and pass responsibility for rendering
 143          * to the CParticleManager. This should be called before dropping the last std::shared_ptr
 144          * to this object so that it will carry on rendering (until all particles have dissipated)
 145          * even when it's no longer attached to a model.
 146          * @param self the std::shared_ptr you're about to drop
 147          */
 148         void Unattach(const CParticleEmitterPtr& self);
 149
 150         void SetEntityVariable(const std::string& name, float value);
 151
 152         CParticleEmitterTypePtr m_Type;
 153
 154         /// Whether this emitter is still emitting new particles
 155         bool m_Active;
 156
 157         CVector3D m_Pos;
 158         CQuaternion m_Rot;
 159
 160         std::map<std::string, float> m_EntityVariables;
 161
 162         std::vector<SParticle> m_Particles;
 163         size_t m_NextParticleIdx;
 164
 165         float m_LastUpdateTime;
 166         float m_EmissionRoundingError;
 167
 168 private:
 169         /// Bounding box of the current particle center points
 170         CBoundingBoxAligned m_ParticleBounds;
 171
 172         VertexIndexArray m_IndexArray;
 173
 174         VertexArray m_VertexArray;
 175         VertexArray::Attribute m_AttributePos;
 176         VertexArray::Attribute m_AttributeAxis;
 177         VertexArray::Attribute m_AttributeUV;
 178         VertexArray::Attribute m_AttributeColor;
 179
 180         Renderer::Backend::IVertexInputLayout* m_VertexInputLayout = nullptr;
 181
 182         int m_LastFrameNumber;
 183 };
 184
 185 /**
 186  * Particle emitter model, for attaching emitters as props on other models.
 187  */
 188 class CModelParticleEmitter : public CModelAbstract
 189 {
 190 public:
 191         CModelParticleEmitter(const CParticleEmitterTypePtr& type);
 192         ~CModelParticleEmitter();
 193
 194         /// Dynamic cast
 195         virtual CModelParticleEmitter* ToCModelParticleEmitter()
 196         {
 197                 return this;
 198         }
 199
 200         virtual std::unique_ptr<CModelAbstract> Clone() const;
 201
 202         virtual void SetTerrainDirty(ssize_t UNUSED(i0), ssize_t UNUSED(j0), ssize_t UNUSED(i1), ssize_t UNUSED(j1))
 203         {
 204         }
 205
 206         virtual void SetEntityVariable(const std::string& name, float value);
 207
 208         virtual void CalcBounds();
 209         virtual void ValidatePosition();
 210         virtual void InvalidatePosition();
 211         virtual void SetTransform(const CMatrix3D& transform);
 212
 213         CParticleEmitterTypePtr m_Type;
 214         CParticleEmitterPtr m_Emitter;
 215 };
 216
 217 #endif // INCLUDED_PARTICLEEMITTER