dl_particle_config.h

浏览该文件的文档.

#pragma once
 
#include <array>
#include <vector>
#include <string>
#include <map>
 
#include <json.hpp>
using json = nlohmann::json;
 
#define LUA_USE_APICHECK
#include <lua.hpp>
#include <LuaBridge/LuaBridge.h>
 
namespace JsonAuto
{
template<typename T>
bool Get(const json& j, const std::string& name, T& t)
{
    auto iter = j.find(name);
    if (iter == j.end())
    {
        dl::log_warn0(std::string("未加载到配置：") + name);
        return false;
    }
    try
    {
        json v = *iter;
        if (v.find("value") != v.end())
            t = (v["value"]).get<T>();
        else
            t = v.get<T>();
        return true;
    }
    catch (nlohmann::detail::exception& e)
    {
        dl::log_warn0(std::string("配置取值失败：") + name + " " + e.what());
    }
    return false;
}
}
 
namespace dl
{
struct ParticleConfig
{
    struct Node
    {
        std::array<float, 2> alpha = { 1, 0 };
        std::array<float, 2> angle = { 0, 360 };
        std::array<float, 3> color_beg = { 1, 1, 1 };
        std::array<float, 2> rotate_speed = { 0, 0 };
        std::array<float, 3> color_end = { 1, 1, 1 };
        std::array<float, 2> lifetime = { 1, 2 };
        bool rotate_to_dir = false;
        std::array<float, 2> rotate_angle = { 0, 0 };
        std::array<float, 2> scale_x_beg = { 1, 1 };
        std::array<float, 2> scale_x_end = { 1, 1 };
        std::array<float, 2> scale_y_beg = { 1, 1 };
        std::array<float, 2> scale_y_end = { 1, 1 };
        std::array<float, 2> speed = { 100, 200 };
    }node;

    struct Emitter
    {
        std::array<float, 2> offset = { 0, 0 };
        std::array<float, 2> offset1 = { 0, 0 };
        unsigned rate = 20;
        std::string shape = "circle";
        std::array<float, 2> size = { 100, 100 };
    }emitter;

    struct System
    {
        float delay = 0;
        std::array<float, 2> gravity = { 0, 0 };
        float duration = 0;
        unsigned max_num = 1024;
    }system;
    bool Load(json& j_root)
    {
        {
            json j;
            JsonAuto::Get(j_root, "emitter", j);
            JsonAuto::Get(j, "offset", emitter.offset);
            JsonAuto::Get(j, "offset1", emitter.offset1);
            JsonAuto::Get(j, "rate", emitter.rate);
            JsonAuto::Get(j, "shape", emitter.shape);
            JsonAuto::Get(j, "size", emitter.size);
        }
        {
            json j;
            JsonAuto::Get(j_root, "node", j);
            JsonAuto::Get(j, "alpha", node.alpha);
            JsonAuto::Get(j, "angle", node.angle);
            JsonAuto::Get(j, "color_beg", node.color_beg);
            JsonAuto::Get(j, "rotate_speed", node.rotate_speed);
            JsonAuto::Get(j, "color_end", node.color_end);
            JsonAuto::Get(j, "lifetime", node.lifetime);
            JsonAuto::Get(j, "rotate_to_dir", node.rotate_to_dir);
            JsonAuto::Get(j, "rotate_angle", node.rotate_angle);
            JsonAuto::Get(j, "scale_x_beg", node.scale_x_beg);
            JsonAuto::Get(j, "scale_x_end", node.scale_x_end);
            JsonAuto::Get(j, "scale_y_beg", node.scale_y_beg);
            JsonAuto::Get(j, "scale_y_end", node.scale_y_end);
            JsonAuto::Get(j, "speed", node.speed);
        }
        {
            json j;
            JsonAuto::Get(j_root, "system", j);
            JsonAuto::Get(j, "delay", system.delay);
            JsonAuto::Get(j, "gravity", system.gravity);
            JsonAuto::Get(j, "duration", system.duration);
            JsonAuto::Get(j, "max_num", system.max_num);
        }
        return true;
    }
    json Save()
    {
        json j;
        {
            json& j_emitter = j["emitter"];
            j_emitter["offset"] = emitter.offset;
            j_emitter["offset1"] = emitter.offset1;
            j_emitter["rate"] = emitter.rate;
            j_emitter["shape"] = emitter.shape;
            j_emitter["size"] = emitter.size;
        }
        {
            json& j_node = j["node"];
            j_node["alpha"] = node.alpha;
            j_node["angle"] = node.angle;
            j_node["color_beg"] = node.color_beg;
            j_node["rotate_speed"] = node.rotate_speed;
            j_node["color_end"] = node.color_end;
            j_node["lifetime"] = node.lifetime;
            j_node["rotate_to_dir"] = node.rotate_to_dir;
            j_node["rotate_angle"] = node.rotate_angle;
            j_node["scale_x_beg"] = node.scale_x_beg;
            j_node["scale_x_end"] = node.scale_x_end;
            j_node["scale_y_beg"] = node.scale_y_beg;
            j_node["scale_y_end"] = node.scale_y_end;
            j_node["speed"] = node.speed;
        }
        {
            json& j_system = j["system"];
            j_system["delay"] = system.delay;
            j_system["gravity"] = system.gravity;
            j_system["duration"] = system.duration;
            j_system["max_num"] = system.max_num;
        }
        return j;
    }
    void RegisterLua(lua_State* L, const std::string& lua_name)
    {
        luabridge::getGlobalNamespace(L)
            .beginClass<Emitter>("emitter")
            .addConstructor<void(*)()>()
            .addProperty("offset", &Emitter::offset)
            .addProperty("offset1", &Emitter::offset1)
            .addProperty("rate", &Emitter::rate)
            .addProperty("shape", &Emitter::shape)
            .addProperty("size", &Emitter::size)
            .endClass();
            
        luabridge::getGlobalNamespace(L)
            .beginClass<Node>("node")
            .addConstructor<void(*)()>()
            .addProperty("alpha", &Node::alpha)
            .addProperty("angle", &Node::angle)
            .addProperty("color_beg", &Node::color_beg)
            .addProperty("rotate_speed", &Node::rotate_speed)
            .addProperty("color_end", &Node::color_end)
            .addProperty("lifetime", &Node::lifetime)
            .addProperty("rotate_to_dir", &Node::rotate_to_dir)
            .addProperty("rotate_angle", &Node::rotate_angle)
            .addProperty("scale_x_beg", &Node::scale_x_beg)
            .addProperty("scale_x_end", &Node::scale_x_end)
            .addProperty("scale_y_beg", &Node::scale_y_beg)
            .addProperty("scale_y_end", &Node::scale_y_end)
            .addProperty("speed", &Node::speed)
            .endClass();
            
        luabridge::getGlobalNamespace(L)
            .beginClass<System>("system")
            .addConstructor<void(*)()>()
            .addProperty("delay", &System::delay)
            .addProperty("gravity", &System::gravity)
            .addProperty("duration", &System::duration)
            .addProperty("max_num", &System::max_num)
            .endClass();
            
        luabridge::getGlobalNamespace(L)
            .beginClass<ParticleConfig>(lua_name.c_str())
            .addConstructor<void(*)()>()
            .addProperty("emitter", &ParticleConfig::emitter)
            .addProperty("node", &ParticleConfig::node)
            .addProperty("system", &ParticleConfig::system)
            .endClass();
            
        auto result = luabridge::push(L, this);
        lua_setglobal(L, lua_name.c_str());
    }
};
 
}