model.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include <base/basetypes.hpp>
 
#include <engine/assets/asset_handle.h>
 
#include "gpu_program.h"
#include "material.h"
#include "mesh.h"
#include "render_proxy.h"
#include "batch_collector.h"
 
#include <hpp/small_vector.hpp>
 
#include <graphics/graphics.h>
#include <math/math.h>
#include <reflection/registration.h>
#include <serialization/serialization.h>
 
#include <chrono>
#include <vector>
 
namespace unravel
{
 
struct lod_data
{
    std::uint32_t current_lod_index = 0; 
    std::uint32_t target_lod_index = 0;  
    float current_time = 0.0f;           
    float transition_time = 0.0f;        
    float percent = 0.0f;                
    irect32_t rect;                      
    math::vec3 center;                   
    
    void calculate_screen_rect(const camera& cam);
};
 
struct per_camera_lod_state
{
    lod_data data;                       
    std::uint64_t last_access_frame = 0; 
};
 
struct submesh_pose_mat4
{
    std::vector<math::mat4> transforms;
    
    struct transform_index
    {
        uint32_t index{};
        bool active{};
        bool casts_shadow{true};
    };
    hpp::small_vector<hpp::small_vector<transform_index>> submesh_to_transform_indices;
    
    void clear()
    {
        transforms.clear();
        submesh_to_transform_indices.clear();
    }
    
    void reserve(size_t count)
    {
        submesh_to_transform_indices.resize(count);
    }
    
    template<typename SubmeshIndices>
    auto add_transform(const SubmeshIndices& submesh_indices, const math::mat4& transform, bool active) -> uint32_t
    {
        // Add the transform to the pool
        uint32_t trans_index = add_transform(transform);
 
        // Map all submesh indices to this transform
        for(uint32_t submesh_index : submesh_indices)
        {
            map_submesh(submesh_index, trans_index, active, true);
        }
        
        return trans_index;
    }
 
    auto add_transform(const math::mat4& transform) -> uint32_t
    {
        uint32_t trans_index = static_cast<uint32_t>(transforms.size());
        transforms.emplace_back(transform);
        return trans_index;
    }
 
    void map_submesh(uint32_t submesh_index, uint32_t trans_index, bool active, bool casts_shadow)
    {
        if(submesh_index >= submesh_to_transform_indices.size())
        {
            submesh_to_transform_indices.resize(submesh_index + 1);
        }
        submesh_to_transform_indices[submesh_index].emplace_back(transform_index{trans_index, active, casts_shadow});
    }
    
    auto get_transform_count(uint32_t submesh_index) const -> size_t
    {
        if(submesh_index < submesh_to_transform_indices.size())
        {
            return submesh_to_transform_indices[submesh_index].size();
        }
        return 0;
    }
    
    auto get_transform(uint32_t submesh_index, size_t instance_index) const -> const math::mat4*
    {
        if(submesh_index < submesh_to_transform_indices.size())
        {
            const auto& indices = submesh_to_transform_indices[submesh_index];
            if(instance_index < indices.size())
            {
                auto transform_index = indices[instance_index];
                if(transform_index.active && transform_index.index < transforms.size())
                {
                    return &transforms[transform_index.index];
                }
            }
        }
        return nullptr;
    }
    
    auto has_transforms(uint32_t submesh_index) const -> bool
    {
        return submesh_index < submesh_to_transform_indices.size() && 
               !submesh_to_transform_indices[submesh_index].empty();
    }
 
    auto get_transform_active(uint32_t submesh_index, size_t instance_index) const -> bool
    {
        if(submesh_index < submesh_to_transform_indices.size())
        {
            const auto& indices = submesh_to_transform_indices[submesh_index];
            if(instance_index < indices.size())
            {
                return indices[instance_index].active;
            }
        }
        return false;
    }
 
    auto get_transform_casts_shadow(uint32_t submesh_index, size_t instance_index) const -> bool
    {
        if(submesh_index < submesh_to_transform_indices.size())
        {
            const auto& indices = submesh_to_transform_indices[submesh_index];
            if(instance_index < indices.size())
            {
                return indices[instance_index].casts_shadow;
            }
        }
        return true;
    }
};
 
struct pose_mat4
{
    std::vector<math::mat4> transforms;
};
 
struct pose_transform
{
    std::vector<math::transform> transforms;
};
 
struct model_submit_extras
{
    const submesh_render_proxies* proxies{nullptr};
 
    const std::vector<material::sptr>* material_overrides{nullptr};
 
    bool shadow_pass{false};
};
class model : public crtp_meta_type<model>
{
public:
    SERIALIZABLE(model)
 
    using seconds_t = std::chrono::duration<float>;
 
    auto is_valid() const -> bool;
 
    auto get_lod(uint32_t lod) const -> asset_handle<mesh>;
 
    void set_lod(asset_handle<mesh> mesh, uint32_t lod);
 
    void set_material(asset_handle<material> material, uint32_t index);
    void set_material_instance(material::sptr material, uint32_t index);
 
    auto get_lods() const -> const std::vector<asset_handle<mesh>>&;
 
    auto get_lods_count() const -> uint32_t;
 
    void set_lods(const std::vector<asset_handle<mesh>>& lods);
 
    auto get_materials() const -> const std::vector<asset_handle<material>>&;
    auto get_material_instances() const -> const std::vector<material::sptr>&;
 
    void set_materials(const std::vector<asset_handle<material>>& materials);
    void set_material_instances(const std::vector<material::sptr>& materials);
 
    auto get_material(uint32_t index) const -> asset_handle<material>;
    auto get_material_instance(uint32_t index) const -> material::sptr;
    auto get_or_emplace_material_instance(uint32_t index) -> material::sptr;
 
    auto get_lod_override_enabled() const -> bool;
 
    void set_lod_override_enabled(bool enabled);
 
    auto get_lod_override_level() const -> uint32_t;
 
    void set_lod_override_level(uint32_t level);
 
    auto get_lod_selection_bias() const -> float;
 
    void set_lod_selection_bias(float bias);
 
    auto get_lod_hysteresis() const -> float;
 
    void set_lod_hysteresis(float hysteresis);
 
    auto get_lod_transition_time() const -> seconds_t;
 
    void set_lod_transition_time(seconds_t time);
 
    auto calculate_lod_data(lod_data& data, const math::bbox& world_bounds, const camera& cam, float dt) const -> bool;
 
    auto calculate_submesh_lod(const mesh& m,
                               uint32_t submesh_index,
                               uint32_t base_lod,
                               const math::mat4& world_matrix,
                               const camera& cam) const -> uint32_t;
 
    auto calculate_submesh_lod_from_world_bounds(const mesh& m,
                                                 uint32_t submesh_index,
                                                 uint32_t base_lod,
                                                 const math::bbox& world_bounds,
                                                 const camera& cam) const -> uint32_t;
 
    auto compute_lod_index(const math::bbox& world_bounds, const camera& cam, float extra_bias = 0.0f) const
        -> uint32_t;
 
 
    auto get_lod_screen_size_min() const -> float;
 
    void set_lod_screen_size_min(float value);
 
    auto get_lod_auto_screen_size_power_base() const -> float;
 
    void set_lod_auto_screen_size_power_base(float value);
 
    auto get_lod_screen_sizes() const -> const std::vector<float>&;
 
    void set_lod_screen_sizes(const std::vector<float>& sizes);
 
    void recalulate_lod_screen_size_limits(uint32_t lod_count);
 
    struct submit_callbacks
    {
        struct params
        {
            bool skinned{};
            bool preserve_state{};
        };
 
        std::function<void(const params& info)> setup_begin;
        std::function<void(const params& info)> setup_params_per_instance;
        std::function<void(const params& info, const material&)> setup_params_per_submesh;
        std::function<void(const params& info)> setup_end;
    };
 
    void submit(const math::mat4& world_transform,
                const submesh_pose_mat4& submesh_transforms,
                const pose_mat4& bone_transforms,
                const std::vector<pose_mat4>& skinning_transforms,
                unsigned int lod,
                const submit_callbacks& callbacks,
                const math::frustum* frustum = nullptr,
                const camera* view = nullptr,
                const model_submit_extras& extras = {}) const;
 
    struct submit_vertex_pulling_callbacks
    {
        struct params
        {
            bool skinned{};                    
            bool preserve_state{};             
            uint32_t submesh_index{};          
            uint32_t index_start{};            
            uint32_t index_count{};            
            uint32_t vertex_stride_floats{};   
            uint32_t position_offset_floats{}; 
            uint32_t weight_offset_floats{};   
            uint32_t indices_offset_floats{};  
        };
 
        std::function<void(const params& info)> setup_begin;
        std::function<void(const params& info)> setup_params_per_instance;
        std::function<void(const params& info)> setup_params_per_submesh;
        std::function<void(const params& info)> setup_end;
    };
 
    void submit_for_vertex_pulling(const math::mat4& world_transform,
                                   const submesh_pose_mat4& submesh_transforms,
                                   const std::vector<pose_mat4>& skinning_transforms,
                                   unsigned int lod,
                                   const submit_vertex_pulling_callbacks& callbacks,
                                   const math::frustum* frustum = nullptr,
                                   const camera* view = nullptr,
                                   const model_submit_extras& extras = {}) const;
 
    void submit_for_batching(batch_collector& collector,
                            const math::mat4& world_transform,
                            const submesh_pose_mat4& submesh_transforms,
                            uint32_t lod_index,
                            float lod_param = 0.0f,
                            const math::frustum* frustum = nullptr,
                            const camera* view = nullptr,
                            const model_submit_extras& extras = {}) const;
 
 
    auto submit_for_shadow_batching_cascaded(std::vector<shadow_batch_collector>& collectors,
                                             uint8_t cascade_count,
                                             const math::mat4& world_transform,
                                             const submesh_pose_mat4& submesh_transforms,
                                             uint32_t lod_index,
                                             float lod_param,
                                             const math::frustum* frustums,
                                             bool nested_cascades,
                                             const model_submit_extras& extras = {}) const -> bool;
 
    static auto default_material() -> asset_handle<material>&;
 
    static auto fallback_material() -> asset_handle<material>&;
 
private:
 
    void resize_materials(const asset_handle<mesh>& mesh);
 
    auto select_submesh_lod_for_sphere(const mesh& m,
                                       uint32_t submesh_index,
                                       uint32_t base_lod,
                                       const math::bsphere& world_sphere,
                                       const camera& cam) const -> uint32_t;
 
    std::vector<asset_handle<material>> materials_;
 
    std::vector<material::sptr> material_instances_;
 
    std::vector<asset_handle<mesh>> mesh_lods_;
 
    bool lod_override_enabled_{false};
    uint32_t lod_override_level_{0};
    float lod_selection_bias_{0.0f};
    float lod_hysteresis_{0.02f};
    seconds_t lod_transition_time_{0.0f};
 
    std::vector<float> lod_screen_sizes_;
};
 
} // namespace unravel