model_component.h

Go to the documentation of this file.

#pragma once
#include <engine/animation/animation_pose.h>
#include <engine/ecs/components/basic_component.h>
#include <engine/rendering/model.h>
#include <engine/rendering/render_proxy.h>
#include <unordered_map>
namespace unravel
{
class material;
 
class model_component : public component_crtp<model_component, owned_component>
{
public:
 
    static void on_create_component(entt::registry& r, entt::entity e);
 
    static void on_destroy_component(entt::registry& r, entt::entity e);
 
    void set_enabled(bool enabled);
    void set_casts_shadow(bool cast_shadow);
 
    void set_static(bool is_static);
 
    auto is_enabled() const -> bool;
 
    auto casts_shadow() const -> bool;
 
    auto is_static() const -> bool;
 
    auto get_model() const -> const model&;
 
    void set_model(const model& model);
 
    auto get_bone_transforms() const -> const pose_mat4&;
 
    auto get_submesh_transforms() const -> const submesh_pose_mat4&;
 
    auto get_armature_entities() const -> const std::vector<entt::handle>&;
    auto get_armature_by_index(size_t index) const -> entt::handle;
    
    auto get_armature_index_by_name_cached(const std::string& node_name) const -> int;
    
    auto get_skinning_transforms() const -> const std::vector<pose_mat4>&;
 
    auto init_armature(bool force) -> bool;
 
    auto update_armature() -> bool;
 
    void mark_pose_dirty() noexcept;
 
    void set_armature_entities(const std::vector<entt::handle>& submesh_entities);
 
    auto get_world_bounds() const -> const math::bbox&;
    auto get_world_bounds_transform() const -> const math::transform&;
 
    void update_world_bounds(const math::transform& world_transform);
 
    auto get_local_bounds(uint32_t lod_index) const -> const math::bbox&;
 
    auto get_render_proxies() const -> const submesh_render_proxies&;
 
    auto get_submesh_material_overrides() const -> const std::vector<material::sptr>&;
 
    auto get_submit_extras(bool shadow_pass = false) const -> model_submit_extras;
 
    void set_last_render_frame(uint64_t frame);
    auto is_newly_created() const noexcept -> bool;
    auto get_last_render_frame() const noexcept -> uint64_t;
    auto was_used_last_frame() const noexcept -> bool;
 
    auto is_skinned() const -> bool;
    auto get_bind_pose() const -> const animation_pose&;
 
    auto get_armature_root_entity() const -> entt::handle;
 
    auto get_facing_adjustment_rotation() const -> math::quat;
 
    auto get_lod_data_for_camera(const camera* cam, uint64_t current_frame) -> lod_data&;
    
    void cleanup_stale_lod_data(uint64_t current_frame, uint64_t max_frames_inactive = 120);
 
private:
    auto create_armature(bool force) -> bool;
    
    void rebuild_armature_cache();
 
    bool enabled_ = true;
 
    bool static_ = true;
 
    bool casts_shadow_ = true;
 
    model model_;
 
    std::vector<entt::handle> armature_entities_;
    
    std::unordered_map<std::string, size_t> armature_name_to_index_;
 
    animation_pose bind_pose_;
    pose_mat4 bone_pose_;
 
    submesh_pose_mat4 submesh_pose_;
 
    std::vector<pose_mat4> skinning_pose_;
 
    submesh_render_proxies render_proxies_;
 
    std::vector<material::sptr> submesh_material_overrides_;
 
    math::bbox world_bounds_;
 
    math::transform world_bounds_transform_;
 
    math::bbox pose_local_bounds_;
 
    math::bbox culling_bounds_local_;
 
    entt::handle bounds_anchor_;
 
    uint64_t captured_proxies_version_{~0ULL};
 
    bool render_proxies_stale_{false};
 
    uint64_t last_render_frame_{};
 
    bool pose_dirty_{true};
 
    std::unordered_map<uintptr_t, per_camera_lod_state> per_camera_lod_data_;
};
 
struct bone_component : public component_crtp<bone_component>
{
    uint32_t bone_index{};
};
 
struct submesh_entry
{
    uint32_t submesh_index{0};
 
    uint32_t stable_id{0};
 
    asset_handle<material> material_override{};
 
    bool casts_shadow{true};
 
    bool enabled{true};
};
 
struct submesh_component : public component_crtp<submesh_component>
{
    std::vector<submesh_entry> entries{};
 
    void migrate_legacy_indices(const std::vector<uint32_t>& legacy_indices)
    {
        if(!entries.empty() || legacy_indices.empty())
        {
            return;
        }
 
        entries.reserve(legacy_indices.size());
        for(uint32_t index : legacy_indices)
        {
            submesh_entry entry;
            entry.submesh_index = index;
            entries.emplace_back(entry);
        }
    }
};
 
} // namespace unravel