defaults.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include "engine/rendering/camera.h"
#include "engine/rendering/reflection_probe.h"
#include <base/basetypes.hpp>
#include <context/context.hpp>
#include <engine/ecs/ecs.h>
#include <engine/rendering/light.h>
#include <engine/rendering/material.h>
#include <engine/rendering/mesh.h>
#include <engine/rendering/model.h>
#include <engine/rendering/reflection_probe.h>
 
namespace unravel
{
 
struct defaults
{
    static auto init(rtti::context& ctx) -> bool;
 
    static auto deinit(rtti::context& ctx) -> bool;
 
    static auto init_assets(rtti::context& ctx) -> bool;
 
    static auto create_embedded_mesh_entity(rtti::context& ctx, scene& scn, const std::string& name) -> entt::handle;
 
    static auto create_prefab_at(rtti::context& ctx,
                                 scene& scn,
                                 const std::string& key,
                                 const camera& cam,
                                 math::vec2 pos) -> entt::handle;
 
    static auto create_prefab_at(rtti::context& ctx,
                                 scene& scn,
                                 const std::string& key,
                                 math::vec3 pos) -> entt::handle;
 
    static auto create_prefab_at(rtti::context& ctx,
                                 scene& scn,
                                 const std::string& key) -> entt::handle;
    static auto create_mesh_entity_at(rtti::context& ctx,
                                      scene& scn,
                                      const std::string& key,
                                      const camera& cam,
                                      math::vec2 pos) -> entt::handle;
 
    static auto create_mesh_entity_at(rtti::context& ctx,
                                      scene& scn,
                                      const std::string& key,
                                      math::vec3 pos = {0.0f, 0.0f, 0.0f}) -> entt::handle;
 
    static auto create_light_entity(rtti::context& ctx, scene& scn, light_type type, const std::string& name)
        -> entt::handle;
 
    static auto create_reflection_probe_entity(rtti::context& ctx, scene& scn, probe_type type, const std::string& name)
        -> entt::handle;
 
    static auto create_camera_entity(rtti::context& ctx, scene& scn, const std::string& name) -> entt::handle;
 
    static auto create_ui_document_entity(rtti::context& ctx, scene& scn, const std::string& name) -> entt::handle;
 
    static auto create_text_entity(rtti::context& ctx, scene& scn, const std::string& name) -> entt::handle;
 
    static void create_default_3d_scene(rtti::context& ctx, scene& scn);
 
    static void focus_camera_on_entities(entt::handle camera, const std::vector<entt::handle>& entities);
 
    static void focus_camera_on_entities(entt::handle camera, 
                                        const std::vector<entt::handle>& entities,
                                        float duration);
 
    static void focus_camera_on_bounds(entt::handle camera, 
                                      const math::bsphere& bounds,
                                      float duration);
 
    static void focus_camera_on_bounds(entt::handle camera, 
                                      const math::bbox& bounds,
                                      float duration);
 
    template<typename T>
    static void create_default_3d_scene_for_asset_preview(rtti::context& ctx,
                                                          scene& scn,
                                                          const asset_handle<T>& asset,
                                                          const usize32_t& size);
 
    static void create_default_3d_scene_for_editing(rtti::context& ctx, scene& scn);
 
    static auto calc_bounds_global(entt::handle entity, int depth = -1) -> math::bbox;
 
    static auto calc_bounds_sphere_global(entt::handle entity, bool use_bbox_diagonal = true) -> math::bsphere;
 
private:
    static auto create_default_3d_scene_for_preview(rtti::context& ctx, scene& scn, const usize32_t& size)
        -> entt::handle;
 
            // Internal helper for timed focus transitions (shared between bbox and bsphere variants)
    static void run_camera_focus_transition(entt::handle camera,
                                            const math::vec3& target_center,
                                            float radius,
                                            bool keep_rotation,
                                            float duration);
};
 
} // namespace unravel