ParticleSpawner.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
 
#pragma once
#include <random>
#include <vector>
#include <algorithm>
#include <utility>
#include <type_traits>
 
#include "Graphics/Particle.h"
#include "Utility/Math/Vector4D.h"
 
struct Particle;

class ParticleSpawner
{
    enum type
    {
        sphere                = 1,
        cone                  = 2,
        orbit                 = 3,
        singleLoopingParticle = 4,
    };
 
public:
    ParticleSpawner()          = default;
    virtual ~ParticleSpawner() = default;

    virtual auto activate(const AffineMatrix& parentTransform, const Vector4D& scale,
                          float rot) -> std::vector<Particle>;

    virtual auto particleSpawnMenu() -> void;

    auto particleUpdateMenu() -> void;
 
 
    friend auto to_json(json& j, const ParticleSpawner& n) -> void;
    friend auto from_json(const json& j, ParticleSpawner& n) -> void;
 
protected:
    Particle maxParticle;
    Particle minParticle;

    unsigned spawnCount = 1u;
 
    // bools for whether certain values of the particles should have random initial values
    // all randomization bools follow a naming convention to make macros for the editor work.
 
    bool positionRandomize               = false;
    bool velocityRandomize               = false;
    bool scaleRandomize                  = false;
    bool rotationRandomize               = false;
    bool rotationalVelocityRandomize     = false;
    bool rotationalAccelerationRandomize = false;
    bool colorRandomize                  = false;
    bool startFrameRandomize             = false;
    bool lifetimeRandomize               = false;
 
private:
    // random engine
    std::ranlux24_base randSeed{std::random_device()()};

    template <typename T>
    auto randIf(bool& isRandom, const T& min, const T& max) -> T
    {
        if (isRandom)
        {
            return randBetween(min, max);
        }
        return max;
    }

    template <typename T>
    auto randBetween(const T& lhs, const T& rhs) -> T
    {
        // we need to use a different distribution based on ints and floats
        if constexpr (std::is_integral_v<T>)
        {
            using std::max;
            using std::min;
            std::uniform_int_distribution<> range(T(0), max(lhs, rhs) - min(lhs, rhs));
            return range(randSeed) + min(lhs, rhs);
        }
        else
        {
            using std::max;
            using std::min;
            std::uniform_real_distribution<float> range{T(0), max(lhs, rhs) - min(lhs, rhs)};
            return range(randSeed) + min(lhs, rhs);
        }
    }

    template <>
    auto randBetween<Vector4D>(const Vector4D& lhs, const Vector4D& rhs) -> Vector4D
    {
        using std::max;
        using std::min;
        Vector4D result;
        std::uniform_real_distribution<float> rangeX(0.f, max(lhs.x(), rhs.x()) - min(lhs.x(), rhs.x()));
        std::uniform_real_distribution<float> rangeY(0.f, max(lhs.y(), rhs.y()) - min(lhs.y(), rhs.y()));
        std::uniform_real_distribution<float> rangeZ(0.f, max(lhs.z(), rhs.z()) - min(lhs.z(), rhs.z()));
        std::uniform_real_distribution<float> rangeW(0.f, max(lhs.w(), rhs.w()) - min(lhs.w(), rhs.w()));
 
        result.x() = rangeX(randSeed) + min(lhs.x(), rhs.x());
        result.y() = rangeY(randSeed) + min(lhs.y(), rhs.y());
        result.z() = rangeZ(randSeed) + min(lhs.z(), rhs.z());
        result.w() = rangeW(randSeed) + min(lhs.w(), rhs.w());
        return result;
    }
 
 
};