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 <graphics/graphics.h>
#include <math/math.h>
#include <reflection/registration.h>
#include <serialization/serialization.h>
 
#include <vector>
 
namespace unravel
{
 
struct pose_mat4
{
    std::vector<math::mat4> transforms;
};
 
struct pose_transform
{
    std::vector<math::transform> transforms;
};
class model : public crtp_meta_type<model>
{
public:
    SERIALIZABLE(model)
 
    
    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>>&;
 
    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_limits() const -> const std::vector<urange32_t>&;
 
    void set_lod_limits(const std::vector<urange32_t>& limits);
 
    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 pose_mat4& submesh_transforms,
                const pose_mat4& bone_transforms,
                const std::vector<pose_mat4>& skinning_matrices,
                unsigned int lod,
                const submit_callbacks& callbacks) const;
 
    static auto default_material() -> asset_handle<material>&;
 
    static auto fallback_material() -> asset_handle<material>&;
 
private:
    void recalulate_lod_limits();
 
    void resize_materials(const asset_handle<mesh>& mesh);
 
    std::vector<asset_handle<material>> materials_;
 
    std::vector<material::sptr> material_instances_;
 
    std::vector<asset_handle<mesh>> mesh_lods_;
    std::vector<urange32_t> lod_limits_;
};
 
} // namespace unravel