Muto::ParticleSystem Class Reference

A simple particle system for stress testing the renderer. This is a temporary starter particle system and will be replaced with a more robust implementation in the future. More...

#include <ParticleSystem.h>

Public Member Functions
void	Emit (const ParticleProps &particleProps)
void	OnRender ()
void	OnUpdate (Timestep ts)
	ParticleSystem ()
	ParticleSystem (uint32_t maxParticles)
void	ResetParticle (Particle &particle, const ParticleProps &particleProps)
void	ResetSystem ()
void	SetParticleProps (const ParticleProps &particleProps)

Public Attributes
int	m_EmitRate = 100
bool	m_IsEmitting = true
bool	m_Loop = true
ParticleProps	m_Props
float	m_TimeSinceLastEmit = 0.0f

Private Attributes
int	m_activeParticleCount = 0
std::vector< Particle >	m_ParticlePool
uint32_t	m_PoolIndex = 999

Detailed Description

A simple particle system for stress testing the renderer. This is a temporary starter particle system and will be replaced with a more robust implementation in the future.

Note

Temporary implementation is not optimized for performance and is intended for testing purposes only. It uses a simple pool of particles and updates them each frame. The particle properties can be set using the ParticleProps struct, which allows for variation in velocity, size, rotation, and lifetime.

Constructor & Destructor Documentation

ParticleSystem() [1/2]

Muto::ParticleSystem::ParticleSystem

(

)

    {
        m_PoolIndex = 999;
        m_ParticlePool.resize(1000);
        m_activeParticleCount = 0;
    }

References m_activeParticleCount, and m_PoolIndex.

ParticleSystem() [2/2]

Muto::ParticleSystem::ParticleSystem

(

uint32_t

maxParticles

)

        : m_PoolIndex(maxParticles - 1), m_activeParticleCount(0)
    {
        m_ParticlePool.resize(maxParticles);
    }

References m_activeParticleCount, and m_PoolIndex.

Member Function Documentation

Emit()

void Muto::ParticleSystem::Emit

(

const ParticleProps &

particleProps

)

    {
        Particle& particle = m_ParticlePool[m_PoolIndex];
        particle.Active = true;
        particle.Position = particleProps.Position + particleProps.PositionVariation * (Muto::Random::Float3() - glm::vec3(0.5f));
        particle.Rotation = particleProps.Rotation + particleProps.RotationVariation * (Muto::Random::Float1() - 0.5f);
 
        particle.Velocity = particleProps.Velocity;
        particle.Velocity.x += particleProps.VelocityVariation.x * (Muto::Random::Float1() - 0.5f);
        particle.Velocity.y += particleProps.VelocityVariation.y * (Muto::Random::Float1() - 0.5f);
 
        particle.ColorBegin = particleProps.ColorBegin;
        particle.ColorEnd = particleProps.ColorEnd;
 
        particle.SizeBegin = particleProps.SizeBegin + particleProps.SizeVariation * (Muto::Random::Float1() - 0.5f);
        particle.SizeEnd = particleProps.SizeEnd;
 
        particle.Lifetime = particleProps.Lifetime + particleProps.LifetimeVariation * (Muto::Random::Float1() - 0.5f);
        particle.LifeRemaining = particle.Lifetime;
 
        uint32_t poolSize = static_cast<uint32_t>(m_ParticlePool.size());
        m_PoolIndex = (m_PoolIndex == 0) ? (poolSize - 1) : (m_PoolIndex - 1);
    }

References Muto::Particle::Active, Muto::Random::Float1(), Muto::Particle::LifeRemaining, Muto::ParticleProps::Lifetime, Muto::Particle::Lifetime, Muto::ParticleProps::LifetimeVariation, m_PoolIndex, Muto::ParticleProps::Rotation, Muto::Particle::Rotation, Muto::ParticleProps::RotationVariation, Muto::ParticleProps::SizeBegin, Muto::Particle::SizeBegin, Muto::ParticleProps::SizeEnd, Muto::Particle::SizeEnd, and Muto::ParticleProps::SizeVariation.

Referenced by Muto::SceneHierarchyPanel::DrawComponents().

OnRender()

void Muto::ParticleSystem::OnRender

(

)

    {
        for (auto& particle : m_ParticlePool)
        {
            if (!particle.Active)
                continue;
 
            float life = particle.LifeRemaining / particle.Lifetime;
            glm::vec4 color = glm::lerp(particle.ColorEnd, particle.ColorBegin, life);
            float size = glm::lerp(particle.SizeEnd, particle.SizeBegin, life);
 
            Muto::Renderer2D::DrawRotatedQuad(
                { particle.Position },
                { size, size },
                Muto::Renderer2D::GetWhiteTexture(),
                particle.Rotation, 1.0f, color);
 
        }
    }

OnUpdate()

void Muto::ParticleSystem::OnUpdate

(

Muto::Timestep

ts

)

    {
        if (m_Loop && m_activeParticleCount == 0)
        {
            ResetSystem();
        }
        else if (!m_Loop && m_activeParticleCount == 0)
        {
            m_IsEmitting = false;
        }
        else if (!m_Loop && m_activeParticleCount > 0)
        {
            m_IsEmitting = false;
        }
        else if (m_Loop) {
 
            //m_IsEmitting = true;
            if (m_activeParticleCount < m_ParticlePool.size() && m_IsEmitting)
            {
                int particlesToEmit = static_cast<int>(m_EmitRate * m_TimeSinceLastEmit);
                for (int i = 0; i < particlesToEmit; i++)
                {
                    Emit(m_Props);
                }
                if (particlesToEmit > 0 && m_EmitRate > 0.0f)
                    m_TimeSinceLastEmit -= static_cast<float>(particlesToEmit) / m_EmitRate;
            }
        }
 
 
 
        m_activeParticleCount = 0;
        for (auto& particle : m_ParticlePool)
        {
            if (!particle.Active) {
                continue;
            }
 
            particle.LifeRemaining -= ts;
            if (particle.LifeRemaining <= 0.0f)
            {
                particle.Active = false;
                continue;
            }
 
            particle.Position += particle.Velocity * (float)ts;
            particle.Rotation += 0.01f * ts;
            m_activeParticleCount++;
        }
        m_TimeSinceLastEmit += ts;
    }

References m_activeParticleCount, m_EmitRate, m_IsEmitting, m_Loop, m_TimeSinceLastEmit, and ResetSystem().

ResetParticle()

void Muto::ParticleSystem::ResetParticle	(	Particle &	particle,
		const ParticleProps &	particleProps
	)

    {
        particle.Active = true;
        particle.Position = particleProps.Position;
        particle.Rotation = particleProps.Rotation + particleProps.RotationVariation * (Muto::Random::Float1() - 0.5f);
        particle.Velocity = particleProps.Velocity;
        particle.Velocity.x += particleProps.VelocityVariation.x * (Muto::Random::Float1() - 0.5f);
        particle.Velocity.y += particleProps.VelocityVariation.y * (Muto::Random::Float1() - 0.5f);
        particle.ColorBegin = particleProps.ColorBegin;
        particle.ColorEnd = particleProps.ColorEnd;
        particle.SizeBegin = particleProps.SizeBegin + particleProps.SizeVariation * (Muto::Random::Float1() - 0.5f);
        particle.SizeEnd = particleProps.SizeEnd;
        particle.Lifetime = particleProps.Lifetime + particleProps.LifetimeVariation * (Muto::Random::Float1() - 0.5f);
        particle.LifeRemaining = particle.Lifetime;
    }

References Muto::Particle::Active, Muto::Random::Float1(), Muto::Particle::LifeRemaining, Muto::ParticleProps::Lifetime, Muto::Particle::Lifetime, Muto::ParticleProps::LifetimeVariation, Muto::ParticleProps::Rotation, Muto::Particle::Rotation, Muto::ParticleProps::RotationVariation, Muto::ParticleProps::SizeBegin, Muto::Particle::SizeBegin, Muto::ParticleProps::SizeEnd, Muto::Particle::SizeEnd, and Muto::ParticleProps::SizeVariation.

ResetSystem()

void Muto::ParticleSystem::ResetSystem ( )

inline

{ m_PoolIndex = m_ParticlePool.size() - 1; m_TimeSinceLastEmit = 0.0f; m_IsEmitting = true; }

References m_IsEmitting, and m_TimeSinceLastEmit.

Referenced by Muto::SceneHierarchyPanel::DrawComponents(), and OnUpdate().

SetParticleProps()

void Muto::ParticleSystem::SetParticleProps ( const ParticleProps &  particleProps )

inline

{ m_Props = particleProps; }

Member Data Documentation

m_activeParticleCount

int Muto::ParticleSystem::m_activeParticleCount = 0

private

Referenced by OnUpdate(), ParticleSystem(), and ParticleSystem().

m_EmitRate

int Muto::ParticleSystem::m_EmitRate = 100

Referenced by OnUpdate().

m_IsEmitting

bool Muto::ParticleSystem::m_IsEmitting = true

Referenced by OnUpdate(), and ResetSystem().

m_Loop

bool Muto::ParticleSystem::m_Loop = true

Referenced by OnUpdate().

m_ParticlePool

std::vector<Particle> Muto::ParticleSystem::m_ParticlePool

private

m_PoolIndex

uint32_t Muto::ParticleSystem::m_PoolIndex = 999

private

Referenced by Emit(), ParticleSystem(), and ParticleSystem().

m_Props

ParticleProps Muto::ParticleSystem::m_Props

m_TimeSinceLastEmit

float Muto::ParticleSystem::m_TimeSinceLastEmit = 0.0f

Referenced by OnUpdate(), and ResetSystem().

---

The documentation for this class was generated from the following files:

• Muto/src/ParticleSystem/ParticleSystem.h
• Muto/src/ParticleSystem/ParticleSystem.cpp