Particle.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
 
#pragma once
#include "Graphics/Texture.h"
#include "Utility/Math/Bezier.h"
#include "Utility/Math/Vector4D.h"
 
 
namespace gfx
{
class Mesh;
class Shader;
class Texture;
}
struct Particle
{
    Vector4D position            = {0.f, 0.f, 0.f, 1.f};
    Vector4D velocity            = {0.f, 0.f, 0.f, 0.f};
    Vector4D velocityBegin       = {0.f, 0.f, 0.f, 0.f};
    Vector4D velocityEnd         = {0.f, 0.f, 0.f, 0.f};
    Vector4D scale               = {1.f, 1.f, 0.f, 0.f};
    Vector4D scaleBegin          = {1.f, 1.f, 0.f, 0.f};
    Vector4D scaleEnd            = {1.f, 1.f, 0.f, 0.f};
    float rotation               = 0.f;
    float rotationalVelocity     = 0.f;
    float rotationalAcceleration = 0.f;
    Vector4D color               = {1.f, 1.f, 1.f, 1.f};
    Vector4D colorBegin          = {1.f, 1.f, 1.f, 1.f};
    Vector4D colorEnd            = {1.f, 1.f, 1.f, 1.f};
    unsigned frame = 0u;
    float frameCountdown = 0.f;
    float lifetime = 1.f;
    float timeLeft = -1.f;
 
    // @warning:
    // All variable below this line are "special values" that aren't actually per particle
    // but still are a property of the particle in a logical sense. in practice this means
    // these are variables that are stored as a single value by the ParticleBlock , not in an 
    // array of values, per particle.

    float fps = 0.f;

    bool velocityChanges = false;
    th::Bezier velocityCurve;

    bool colorChanges = false;
    th::Bezier colorCurve;

    bool scaleChanges = false;
    th::Bezier scaleCurve;
 

    bool loopingSprite = true;
    gfx::Texture* texture = nullptr;
    gfx::Shader* shader = nullptr;
    gfx::Mesh* mesh = nullptr;
 
 
    friend auto to_json(json& j, const Particle& n) -> void
    {
        j = json{
                {"position", n.position},
                {"velocity", n.velocity},
                {"velocityBegin", n.velocityBegin},
                {"velocityEnd", n.velocityEnd},
                {"scale", n.scale},
                {"scaleBegin", n.scaleBegin},
                {"scaleEnd", n.scaleEnd},
                {"rotation", n.rotation},
                {"rotationalVelocity", n.rotationalVelocity},
                {"rotationalAcceleration", n.rotationalAcceleration},
                {"color", n.color},
                {"colorBegin", n.colorBegin},
                {"colorEnd", n.colorEnd},
                {"frame", n.frame},
                {"frameCountdown", n.frameCountdown},
                {"lifetime", n.lifetime},
                {"timeLeft", n.timeLeft},
 
                {"fps", n.fps},
                {"velocityChanges", n.velocityChanges},
                {"velocityCurve", n.velocityCurve},
                {"colorChanges", n.colorChanges},
                {"colorCurve", n.colorCurve},
                {"scaleChanges", n.scaleChanges},
                {"scaleCurve", n.scaleCurve},
                {"loopingSprite", n.loopingSprite},
        };
        if (n.texture)
        {
            j["texture"] = n.texture->name();
        }
        if (n.mesh)
        {
            j["mesh"] = n.mesh->name();
        }
        if (n.shader)
        {
            j["shader"] = n.shader->name();
        }
    }
 
    friend auto from_json(const json& j, Particle& n) -> void
    {
        j.at("position").get_to(n.position);
        j.at("velocity").get_to(n.velocity);
        j.at("velocityBegin").get_to(n.velocityBegin);
        j.at("velocityEnd").get_to(n.velocityEnd);
        j.at("scale").get_to(n.scale);
        j.at("scaleBegin").get_to(n.scaleBegin);
        j.at("scaleEnd").get_to(n.scaleEnd);
        j.at("rotation").get_to(n.rotation);
        j.at("rotationalVelocity").get_to(n.rotationalVelocity);
        j.at("rotationalAcceleration").get_to(n.rotationalAcceleration);
        j.at("color").get_to(n.color);
        j.at("colorBegin").get_to(n.colorBegin);
        j.at("colorEnd").get_to(n.colorEnd);
        j.at("frame").get_to(n.frame);
        j.at("frameCountdown").get_to(n.frameCountdown);
        j.at("lifetime").get_to(n.lifetime);
        j.at("timeLeft").get_to(n.timeLeft);
        j.at("fps").get_to(n.fps);
        j.at("velocityChanges").get_to(n.velocityChanges);
        j.at("velocityCurve").get_to(n.velocityCurve);
        j.at("colorChanges").get_to(n.colorChanges);
        j.at("colorCurve").get_to(n.colorCurve);
        j.at("scaleChanges").get_to(n.scaleChanges);
        j.at("scaleCurve").get_to(n.scaleCurve);
        j.at("loopingSprite").get_to(n.loopingSprite);
 
        if (j.contains("mesh"))
        {
            n.mesh = th::Library::get<gfx::Mesh>("Mesh/" + j.at("mesh").get<std::string>());
        }
        if (j.contains("texture"))
        {
            n.texture = th::Library::get<gfx::Texture>("Texture/" + j.at("texture").get<std::string>());
        }
        if (j.contains("shader"))
        {
            n.shader = th::Library::get<gfx::Shader>("Shader/" + j.at("shader").get<std::string>());
        }
    }
};