defaults.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include "engine/rendering/camera.h"
#include "engine/rendering/ecs/components/volume_component.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>
 
#include <hpp/string_view.hpp>
 
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,
                                 bool align_to_surface = false) -> 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,
                                      bool align_to_surface = false) -> 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_terrain(rtti::context& ctx, scene& scn, 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_volume_entity(rtti::context& ctx, scene& scn, const std::string& name, volume_mode mode = volume_mode::local) -> 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 auto create_particle_emitter_entity(rtti::context& ctx, scene& scn, const std::string& name) -> entt::handle;
 
    static auto create_audio_source_entity(rtti::context& ctx, scene& scn, const std::string& name) -> entt::handle;
 
    enum class scene_preset
    {
        low,
        medium,
        high,
        showcase
    };
 
    static auto parse_scene_preset(hpp::string_view value, scene_preset& out) -> bool;
 
    static auto scene_preset_to_string(scene_preset preset) -> const char*;
 
    static void create_default_3d_scene(rtti::context& ctx, scene& scn);
 
    static void create_scene_from_preset(rtti::context& ctx, scene& scn, scene_preset preset);
 
 
    static void focus_camera_on_entities(entt::handle camera, 
                                        hpp::span<const entt::handle> entities,
                                        float duration = 0.0f);
 
    static void focus_camera_on_bounds(entt::handle camera, 
                                      const math::bsphere& bounds,
                                      float duration = 0.0f);
 
    static void focus_camera_on_bounds(entt::handle camera, 
                                      const math::bbox& bounds,
                                      float duration = 0.0f);
 
    struct asset_preview_result
    {
        entt::handle object;
        entt::handle camera;
    };
    template<typename T>
    static auto create_default_3d_scene_for_asset_preview(rtti::context& ctx,
                                                          scene& scn,
                                                          const asset_handle<T>& asset,
                                                          const usize32_t& size, bool focus_camera = true) -> asset_preview_result;
 
 
    template<typename T>
    static void focus_camera_on_3d_scene_for_asset_preview(rtti::context& ctx,
        const asset_preview_result& result);
 
    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;
 
    static auto create_default_volume_entity_for_preview(rtti::context& ctx, scene& scn, const std::string& name, volume_mode mode) -> entt::handle;
 
};
 
} // namespace unravel