ParticleBlock.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
#pragma once
#include "Utility/Math/Vector4D.h"
#include <ranges>
 
#include "Framework/Library.h"
#include "System/Editor.h"
#include "Utility/Math/Bezier.h"
 
namespace gfx
{
class Mesh;
class Shader;
class Texture;
}
 
struct Particle;

class ParticleBlock final
{
public:
    ParticleBlock() = default;

    auto addParticles(const std::vector<Particle>& particles) -> void;

    auto update(float dt) -> void;

    auto render() const -> void;

    auto showMenu() -> void;
    
    auto setTexture(gfx::Texture* texture) -> void;
 
    auto setShader(gfx::Shader* shader) -> void;
 
    auto setMesh(gfx::Mesh* mesh) -> void;
 
    auto setName(std::string newName) -> void;
 
    auto getName() const -> const std::string&;
 
    auto destroy() -> void;
    auto destroyed() const -> bool;
 
private:
    std::string name;

    bool isDestroyed = false;
 
    [[maybe_unused]] unsigned particleCount = 0u;
 
#pragma region shared_particle_values
 
    bool velocityChanges = false;
    bool colorChanges    = false;
    bool scaleChanges    = false;
 
    th::Bezier velocityCurve;
    th::Bezier colorCurve;
    th::Bezier scaleCurve;
 
 
    gfx::Texture* texture = th::Library::get<gfx::Texture>("Texture/The_House_Logo");
    gfx::Shader* shader   = th::Library::get<gfx::Shader>("texture_shader");
    gfx::Mesh* mesh       = th::Library::get<gfx::Mesh>("Mesh/1x1_mesh");
 
 
    unsigned totalFrames = texture->getFrames();
    float frameTime      = 0.f;
    bool loops           = false;
 
#pragma endregion
 
#pragma region struct_of_array_values
    // these are the arrays which hold the individual particles values
    // if these are updated often, we could pack them into a struct declared in Particle.h
 
    std::vector<Vector4D> position;
    std::vector<Vector4D> velocity;
    std::vector<Vector4D> velocityBegin;
    std::vector<Vector4D> velocityEnd;
    std::vector<Vector4D> scale;
    std::vector<Vector4D> scaleBegin;
    std::vector<Vector4D> scaleEnd;
    std::vector<float> rotation;
    std::vector<float> rotationalVelocity;
    std::vector<float> rotationalAcceleration;
    std::vector<Vector4D> color;
    std::vector<Vector4D> colorBegin;
    std::vector<Vector4D> colorEnd;
    std::vector<unsigned> frame;
    std::vector<float> frameCountdown;
    std::vector<float> lifetime;
    std::vector<float> timeLeft;
 
    // how long the particle has been alive, relative to it's total lifetime. range [0,1]
    std::vector<float> normalizedAge;
 
#pragma endregion
 
#pragma region helper_functions
    auto activeParticles() const
    {
        const auto active = [&](unsigned i)
        {
            return timeLeft[i] > 0;
        };
        return std::views::iota(0u, timeLeft.size()) | std::views::filter(active);
    }

    auto addParticleAtPosition(const Particle& particle, unsigned pos) -> void;
    auto pushBackParticle(const Particle& particle) -> void;

    auto updateAnimationForParticle(float dt, unsigned particlePosition) -> void;
 
#pragma endregion
};