reflection_probe.cpp

Go to the documentation of this file.

#include "reflection_probe.hpp"
#include <engine/meta/core/math/vector.hpp>
 
#include <serialization/associative_archive.h>
#include <serialization/binary_archive.h>
 
namespace unravel
{
REFLECT(reflection_probe)
{
    auto box_predicate_entt = entt::property_predicate<bool>(
        [](const entt::meta_any& obj)
        {
            auto data = obj.try_cast<reflection_probe>();
            return data->type == probe_type::box;
        });
    auto sphere_predicate_entt = entt::property_predicate<bool>(
        [](const entt::meta_any& obj)
        {
            auto data = obj.try_cast<reflection_probe>();
            return data->type == probe_type::sphere;
        });
    // EnTT meta registration mirroring RTTR
    entt::meta_factory<probe_type>{}
        .type("probe_type"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "probe_type"},  
            entt::attribute{"pretty_name", "Probe Type"},
        })
        .data<probe_type::box>("box"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "box"},
            entt::attribute{"pretty_name", "Box"} 
        })
        .data<probe_type::sphere>("sphere"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "sphere"},
            entt::attribute{"pretty_name", "Sphere"} 
        });
 
    entt::meta_factory<reflect_method>{}
        .type("reflect_method"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "reflect_method"},
            entt::attribute{"pretty_name", "Reflect Method"},
        })
        .data<reflect_method::environment>("environment"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "environment"},
            entt::attribute{"pretty_name", "Environment"} 
        })
        .data<reflect_method::static_only>("static_only"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "static_only"},
            entt::attribute{"pretty_name", "Static Only"} 
        });
 
    entt::meta_factory<probe_update_mode>{}
        .type("probe_update_mode"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "probe_update_mode"},
            entt::attribute{"pretty_name", "Update Mode"},
        })
        .data<probe_update_mode::on_demand>("on_demand"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "on_demand"},
            entt::attribute{"pretty_name", "On Demand"}
        })
        .data<probe_update_mode::once>("once"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "once"},
            entt::attribute{"pretty_name", "Once"}
        })
        .data<probe_update_mode::realtime>("realtime"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "realtime"},
            entt::attribute{"pretty_name", "Realtime"}
        });
 
    entt::meta_factory<probe_resolution>{}
        .type("probe_resolution"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "probe_resolution"},
            entt::attribute{"pretty_name", "Resolution"},
        })
        .data<probe_resolution::res_16>("res_16"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "res_16"},
            entt::attribute{"pretty_name", "16"},
        })
        .data<probe_resolution::res_32>("res_32"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "res_32"},
            entt::attribute{"pretty_name", "32"},
        })
        .data<probe_resolution::res_64>("res_64"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "res_64"},
            entt::attribute{"pretty_name", "64"},
        })
        .data<probe_resolution::res_128>("res_128"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "res_128"},
            entt::attribute{"pretty_name", "128"},
        })
        .data<probe_resolution::res_256>("res_256"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "res_256"},
            entt::attribute{"pretty_name", "256"},
        })
        .data<probe_resolution::res_512>("res_512"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "res_512"},
            entt::attribute{"pretty_name", "512"},
        });
 
    entt::meta_factory<reflection_probe::box>{}
        .type("box"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "box"},
            entt::attribute{"pretty_name", "Box"},
        })
        .data<&reflection_probe::box::extents>("extents"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "extents"},
            entt::attribute{"pretty_name", "Extents"} 
        })
        .data<&reflection_probe::box::transition_distance>("transition_distance"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "transition_distance"},
            entt::attribute{"pretty_name", "Transition Distance"},
            entt::attribute{"min", 0.0f},
        });
 
    entt::meta_factory<reflection_probe::sphere>{}
        .type("sphere"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "sphere"},
            entt::attribute{"pretty_name", "Sphere"},
        })
        .data<&reflection_probe::sphere::range>("range"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "range"},
            entt::attribute{"pretty_name", "Range"},
            entt::attribute{"min", 0.0f},
        });
 
    entt::meta_factory<reflection_probe>{}
        .type("reflection_probe"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "reflection_probe"},
            entt::attribute{"pretty_name", "Reflection Probe"},
        })
        .data<&reflection_probe::type>("type"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "type"},
            entt::attribute{"pretty_name", "Type"} 
        })
        .data<&reflection_probe::method>("method"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "method"},
            entt::attribute{"pretty_name", "Method"} 
        })
        .data<&reflection_probe::intensity>("intensity"_hs)
        .custom<entt::attributes>(entt::attributes{
            entt::attribute{"name", "intensity"},
            entt::attribute{"pretty_name", "Intensity"},
            entt::attribute{"min", 0.1f},
            entt::attribute{"max", 3.0f},
        })
        .data<&reflection_probe::box_data>("box_data"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "box_data"},
            entt::attribute{"pretty_name", "Box"},
            entt::attribute{"predicate", box_predicate_entt},
        })
        .data<&reflection_probe::sphere_data>("sphere_data"_hs)
        .custom<entt::attributes>(entt::attributes{ 
            entt::attribute{"name", "sphere_data"},
            entt::attribute{"pretty_name", "Sphere"},
            entt::attribute{"predicate", sphere_predicate_entt},
        });
}
 
SAVE(reflection_probe)
{
    try_save(ar, ser20::make_nvp("type", obj.type));
    try_save(ar, ser20::make_nvp("method", obj.method));
    try_save(ar, ser20::make_nvp("intensity", obj.intensity));
    if(obj.type == probe_type::box)
    {
        try_save(ar, ser20::make_nvp("extents", obj.box_data.extents));
        try_save(ar, ser20::make_nvp("transition_distance", obj.box_data.transition_distance));
    }
    else
    {
        try_save(ar, ser20::make_nvp("range", obj.sphere_data.range));
    }
}
SAVE_INSTANTIATE(reflection_probe, ser20::oarchive_associative_t);
SAVE_INSTANTIATE(reflection_probe, ser20::oarchive_binary_t);
 
LOAD(reflection_probe)
{
    try_load(ar, ser20::make_nvp("type", obj.type));
    try_load(ar, ser20::make_nvp("method", obj.method));
    try_load(ar, ser20::make_nvp("intensity", obj.intensity));
    if(obj.type == probe_type::box)
    {
        try_load(ar, ser20::make_nvp("extents", obj.box_data.extents));
        try_load(ar, ser20::make_nvp("transition_distance", obj.box_data.transition_distance));
    }
    else
    {
        try_load(ar, ser20::make_nvp("range", obj.sphere_data.range));
    }
}
LOAD_INSTANTIATE(reflection_probe, ser20::iarchive_associative_t);
LOAD_INSTANTIATE(reflection_probe, ser20::iarchive_binary_t);
} // namespace unravel