mesh.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
#include <engine/assets/asset_handle.h>
#include <engine/rendering/material.h>
#include <base/basetypes.hpp>
#include <graphics/graphics.h>
#include <hpp/span.hpp>
#include <hpp/uuid.hpp>
#include <math/math.h>
 
#include <map>
#include <memory>
#include <vector>
 
namespace gfx
{
struct vertex_buffer;
struct index_buffer;
} // namespace gfx
 
namespace unravel
{
class camera;
 
namespace triangle_flags
{
enum e
{
    none = 0,
    degenerate = 0x1,
};
} // namespace triangle_flags
 
enum class mesh_status
{
    not_prepared,
    preparing,
    prepared
};
 
enum class mesh_create_origin
{
    bottom,
    center,
    top
};
 
class skin_bind_data
{
public:
    struct vertex_influence
    {
        uint32_t vertex_index = 0;
        float weight = 0.0f;
    };
    using vertex_influence_array_t = std::vector<vertex_influence>;
 
    struct bone_influence
    {
        std::string bone_id;
        math::transform bind_pose_transform;
        vertex_influence_array_t influences;
        math::bbox bounds{};
    };
    using bone_influence_array_t = std::vector<bone_influence>;
 
    struct vertex_data
    {
        std::vector<int32_t> influences;
        std::vector<float> weights;
        int32_t palette;
        uint32_t original_vertex;
    };
    using vertex_data_array_t = std::vector<vertex_data>;
 
    void add_bone(const bone_influence& bone);
 
    void remove_empty_bones();
 
    void build_vertex_table(uint32_t vertex_count,
                            const std::vector<uint32_t>& vertex_remap,
                            vertex_data_array_t& table);
 
    void remap_vertices(const std::vector<uint32_t>& remap);
 
    auto get_bones() const -> const bone_influence_array_t&;
 
    auto get_bones() -> bone_influence_array_t&;
 
    auto has_bones() const -> bool;
 
    struct bone_query
    {
        const bone_influence* bone{};
        int index{-1};
    };
 
    auto find_bone_by_id(const std::string& id) const -> bone_query;
 
    void clear_vertex_influences();
 
    void clear();
 
private:
    bone_influence_array_t bones_; 
};
 
class bone_palette
{
public:
    using bone_index_map_t = std::map<uint32_t, uint32_t>;
 
    bone_palette(uint32_t paletteSize);
 
    auto get_skinning_matrices(const std::vector<math::transform>& node_transforms,
                               const skin_bind_data& bind_data) const -> const std::vector<math::mat4>&;
 
    auto get_skinning_matrices(const std::vector<math::mat4>& node_transforms, const skin_bind_data& bind_data) const
        -> const std::vector<math::mat4>&;
 
    void compute_palette_fit(bone_index_map_t& input,
                             int32_t& current_space,
                             int32_t& common_base,
                             int32_t& additional_bones);
 
    void assign_bones(bone_index_map_t& bones, std::vector<uint32_t>& faces);
    void assign_bones(std::vector<bool>& bones, std::vector<uint32_t>& faces);
 
    void assign_bones(const std::vector<uint32_t>& bones);
 
    auto translate_bone_to_palette(uint32_t bone_index) const -> uint32_t;
 
    auto get_maximum_blend_index() const -> int32_t;
 
    auto get_maximum_size() const -> uint32_t;
 
    auto get_data_group() const -> uint32_t;
 
    auto get_influenced_faces() -> std::vector<uint32_t>&;
 
    auto get_bones() const -> const std::vector<uint32_t>&;
 
    void set_maximum_blend_index(int index);
 
    void set_data_group(uint32_t group);
 
    void clear_influenced_faces();
 
protected:
    bone_index_map_t bones_lut_;
    std::vector<uint32_t> bones_;
    std::vector<uint32_t> faces_;
    uint32_t data_group_id_;
    uint32_t maximum_size_;
    int32_t maximum_blend_index_;
};
 
class mesh
{
public:
    struct submesh
    {
        uint32_t data_group_id{0};
        int32_t vertex_start{-1};
        uint32_t vertex_count{0};
        int32_t face_start{-1};
        uint32_t face_count{0};
 
        math::bbox bbox{};
 
        bool skinned{};
 
        uint32_t stable_id{0};
    };
 
    struct info
    {
        struct lod_info
        {
            uint32_t triangles = 0;
            float percent = 0.0f;
        };
 
        uint32_t vertices = 0;
        uint32_t triangles = 0;
        uint32_t submeshes = 0;
        uint32_t data_groups = 0;
        std::vector<lod_info> lods;
    };
 
    struct triangle
    {
        uint32_t data_group_id = 0;
        std::array<uint32_t, 3> indices = {0, 0, 0};
        uint8_t flags = 0;
    };
 
    using triangle_array_t = std::vector<triangle>;
    using submesh_array_t = std::vector<submesh*>;
    using bone_palette_array_t = std::vector<bone_palette>;
    using submesh_array_indices_t = std::vector<size_t>;
    using submesh_array_map_t = std::map<uint32_t, submesh_array_indices_t>;
 
    using data_group_submesh_map_t = std::map<uint32_t, submesh_array_t>;
    using byte_array_t = std::vector<uint8_t>;
 
    struct lod_level
    {
        uint32_t* system_ib_{nullptr};
        std::shared_ptr<void> hardware_ib_;
        uint32_t face_count_{0};
        submesh_array_t submeshes_;
        submesh_array_map_t skinned_submesh_indices_;
        submesh_array_map_t non_skinned_submesh_indices_;
        float simplification_error_{0.0f};
    };
 
    struct armature_node
    {
        std::string name;
        math::transform local_transform;
        std::vector<std::unique_ptr<armature_node>> children;
        std::vector<uint32_t> submeshes;
 
        int index{-1};
    };
 
    struct lod_load_data
    {
        std::vector<uint32_t> index_data;
        uint32_t face_count = 0;
        std::vector<mesh::submesh> submeshes;
        float simplification_error = 0.0f;
    };
 
    struct load_data
    {
        gfx::vertex_layout vertex_format;
        std::vector<uint8_t> vertex_data;
        uint32_t vertex_count = 0;
        triangle_array_t triangle_data;
        uint32_t triangle_count = 0;
        std::vector<mesh::submesh> submeshes;
        uint32_t material_count = 0;
        skin_bind_data skin_data;
        bool skin_is_prepared = false;
        std::vector<std::vector<uint32_t>> bone_palette_bones;
        std::unique_ptr<armature_node> root_node = nullptr;
 
        math::bbox bbox{};
 
        std::vector<lod_load_data> lods;
 
        std::vector<hpp::uuid> default_material_uids;
    };
 
    mesh();
 
    ~mesh();
 
    void dispose();
 
    auto get_info() const -> info;
    void bind_render_buffers_for_submesh(const submesh* submesh, uint32_t lod_index = 0);
 
    auto prepare_mesh(const gfx::vertex_layout& vertex_format) -> bool;
 
    auto set_vertex_source(void* source, uint32_t vertex_count, const gfx::vertex_layout& source_format) -> bool;
    auto set_vertex_source(byte_array_t&& source, uint32_t vertex_count, const gfx::vertex_layout& source_format)
        -> bool;
 
    auto set_bounding_box(const math::bbox& box) -> bool;
 
    auto set_submeshes(const std::vector<submesh>& submeshes) -> bool;
 
    auto set_primitives(triangle_array_t&& triangles) -> bool;
 
    auto bind_skin(const skin_bind_data& bind_data) -> bool;
 
    auto bind_armature(std::unique_ptr<armature_node>& root) -> bool;
 
    auto load_mesh(load_data&& data) -> bool;
 
    auto create_plane(const gfx::vertex_layout& format,
                      float width,
                      float height,
                      uint32_t width_segments,
                      uint32_t height_segments,
                      mesh_create_origin origin,
                      bool hardware_copy = true) -> bool;
 
    auto create_heightfield(const gfx::vertex_layout& format,
                          hpp::span<const float> heights,
                          uint32_t segments_x,
                          uint32_t segments_z,
                          float half_extent_x,
                          float half_extent_z,
                          float height_scale,
                          mesh_create_origin origin,
                          bool hardware_copy = true) -> bool;
 
    auto create_cube(const gfx::vertex_layout& format,
                     float width,
                     float height,
                     float depth,
                     uint32_t width_segments,
                     uint32_t height_segments,
                     uint32_t depth_segments,
                     mesh_create_origin origin,
                     bool hardware_copy = true) -> bool;
 
    auto create_rounded_cube(const gfx::vertex_layout& format,
                    float width,
                    float height,
                    float depth,
                    uint32_t width_segments,
                    uint32_t height_segments,
                    uint32_t depth_segments,
                    mesh_create_origin origin,
                    bool hardware_copy = true) -> bool;
 
    auto create_sphere(const gfx::vertex_layout& format,
                       float radius,
                       uint32_t stacks,
                       uint32_t slices,
                       mesh_create_origin origin,
                       bool hardware_copy = true) -> bool;
 
    auto create_cylinder(const gfx::vertex_layout& format,
                         float radius,
                         float height,
                         uint32_t stacks,
                         uint32_t slices,
                         mesh_create_origin origin,
                         bool hardware_copy = true) -> bool;
 
    auto create_capsule(const gfx::vertex_layout& format,
                        float radius,
                        float height,
                        uint32_t stacks,
                        uint32_t slices,
                        mesh_create_origin origin,
                        bool hardware_copy = true) -> bool;
 
    auto create_cone(const gfx::vertex_layout& format,
                     float radius,
                     float radius_tip,
                     float height,
                     uint32_t stacks,
                     uint32_t slices,
                     mesh_create_origin origin,
                     bool hardware_copy = true) -> bool;
 
    auto create_torus(const gfx::vertex_layout& format,
                      float outer_radius,
                      float inner_radius,
                      uint32_t bands,
                      uint32_t sides,
                      mesh_create_origin origin,
                      bool hardware_copy = true) -> bool;
 
    auto create_teapot(const gfx::vertex_layout& format, bool hardware_copy = true) -> bool;
 
    auto create_icosahedron(const gfx::vertex_layout& format, bool hardware_copy = true) -> bool;
 
    auto create_dodecahedron(const gfx::vertex_layout& format, bool hardware_copy = true) -> bool;
 
    auto create_icosphere(const gfx::vertex_layout& format, int tesselation_level, bool hardware_copy = true) -> bool;
 
    auto end_prepare(bool hardware_copy = true, bool build_buffers = true, bool weld = false, bool optimize = false)
        -> bool;
 
    void build_vb(bool hardware_copy = true);
 
    void build_ib(bool hardware_copy = true);
 
    auto generate_adjacency(std::vector<uint32_t>& adjacency) -> bool;
 
    auto get_face_count() const -> uint32_t;
 
    auto get_vertex_count() const -> uint32_t;
 
    auto get_system_vb() -> uint8_t*;
 
    auto get_system_ib() -> uint32_t*;
 
    auto get_vertex_format() const -> const gfx::vertex_layout&;
 
    auto get_hardware_vb() const -> std::shared_ptr<gfx::vertex_buffer>;
 
    auto get_hardware_ib(uint32_t lod_index = 0) const -> std::shared_ptr<gfx::index_buffer>;
 
    auto get_skin_bind_data() const -> const skin_bind_data&;
 
    auto get_bone_palettes() const -> const bone_palette_array_t&;
 
    auto get_armature() const -> const std::unique_ptr<armature_node>&;
 
    auto get_submesh_node_transforms(uint32_t lod_index = 0) const -> std::vector<math::transform>;
 
    auto calculate_screen_rect(const math::transform& world, const camera& cam) const -> irect32_t;
 
    auto calculate_screen_rect_precise(const math::transform& world, const camera& cam) const -> irect32_t;
 
    auto get_submeshes(uint32_t lod_index = 0) const -> const submesh_array_t&;
    auto get_submesh(uint32_t submesh_index = 0, uint32_t lod_index = 0) const -> const submesh*;
    auto get_bounds() const -> const math::bbox&;
 
    auto get_status() const -> mesh_status;
 
    auto get_data_groups_count() const -> size_t;
 
    auto get_default_material_uids() const -> const std::vector<hpp::uuid>&;
 
     auto get_imported_materials() const -> std::vector<asset_handle<material>>;
    auto get_submeshes_count(uint32_t lod_index = 0) const -> size_t;
 
    auto find_submesh_index_by_stable_id(uint32_t stable_id, uint32_t lod_index = 0) const -> int;
 
    auto get_skinned_submeshes_count(uint32_t lod_index = 0) const -> size_t;
    auto get_skinned_submeshes_indices(uint32_t data_group_id, uint32_t lod_index = 0) const -> const submesh_array_indices_t&;
 
    auto get_non_skinned_submeshes_count(uint32_t lod_index = 0) const -> size_t;
    auto get_non_skinned_submeshes_indices(uint32_t data_group_id, uint32_t lod_index = 0) const -> const submesh_array_indices_t&;
 
    auto get_submesh_index(const submesh* s, uint32_t lod_index = 0) const -> int;
 
    auto get_lod_count() const -> uint32_t;
 
    auto get_lod_submeshes(uint32_t lod_index) const -> const submesh_array_t*;
 
    auto get_lod_face_count(uint32_t lod_index) const -> uint32_t;
 
    auto get_lod_index_data(uint32_t lod_index, std::vector<uint32_t>& out_indices, float& out_error) const -> bool;
 
 
    static auto get_max_lod_count() -> uint32_t;
    static auto get_max_generated_lod_count() -> uint32_t;
    static auto generate_default_lod_configs(const load_data& data, float target_error = 0.01f) -> std::vector<std::pair<size_t, float>>;
 
    static auto apply_skin_to_load_data(load_data& data) -> bool;
 
    static auto generate_lods_for_load_data(load_data& data, const std::vector<std::pair<size_t, float>>& lod_configs) -> bool;
 
    auto restore_lods_from_load_data(const load_data& data) -> bool;
 
    struct preparation_data
    {
        enum flags
        {
            source_contains_normal = 0x1,
            source_contains_binormal = 0x2,
            source_contains_tangent = 0x4
        };
 
        uint8_t* vertex_source{nullptr};
        bool owns_source{false};
        gfx::vertex_layout source_format;
        std::vector<uint32_t> vertex_records;
        byte_array_t vertex_data;
        byte_array_t vertex_flags;
        triangle_array_t triangle_data;
        uint32_t triangle_count{0};
        uint32_t vertex_count{0};
        std::vector<submesh> submeshes;
        bool compute_normals{false};
        bool compute_binormals{false};
        bool compute_tangents{false};
        bool compute_barycentric{false};
 
        bool check_for_degenerates{false};
 
        bool compute_per_triangle_material_data{false};
    };
 
protected:
    struct optimizer_vertex_info
    {
        int32_t cache_position{-1};
        float vertex_score{0.0f};
        uint32_t unused_triangle_references{0};
        std::vector<uint32_t> triangle_references;
    };
 
    struct optimizer_triangle_info
    {
        float triangle_score{0.0f};
        bool added{false};
    };
 
    struct adjacent_edge_key
    {
        const math::vec3* vertex1{nullptr};
        const math::vec3* vertex2{nullptr};
    };
 
    struct mesh_submesh_key
    {
        uint32_t data_group_id{0};
    };
 
    using submesh_key_map_t = std::map<mesh_submesh_key, submesh*>;
    using submesh_key_array_t = std::vector<mesh_submesh_key>;
 
    struct weld_key
    {
        uint8_t* vertex{nullptr};
        gfx::vertex_layout format;
        float tolerance{};
    };
 
    struct face_influences
    {
        bone_palette::bone_index_map_t bones;
    };
 
    struct bone_combination_key
    {
        face_influences* influences{nullptr};
        uint32_t data_group_id{0};
    };
 
    using bone_combination_map_t = std::map<bone_combination_key, std::vector<uint32_t>*>;
 
    friend auto operator<(const adjacent_edge_key& key1, const adjacent_edge_key& key2) -> bool;
    friend auto operator<(const mesh_submesh_key& key1, const mesh_submesh_key& key2) -> bool;
    friend auto operator<(const weld_key& key1, const weld_key& key2) -> bool;
    friend auto operator<(const bone_combination_key& key1, const bone_combination_key& key2) -> bool;
 
    void check_for_degenerates();
 
    auto generate_vertex_components(bool weld) -> bool;
 
    auto generate_vertex_normals(uint32_t* adjacency_ptr, std::vector<uint32_t>* remap_array_ptr = nullptr) -> bool;
 
    auto generate_vertex_barycentrics(uint32_t* adjacency) -> bool;
 
    auto generate_vertex_tangents() -> bool;
 
    auto weld_vertices(float tolerance = 0.000001f, std::vector<uint32_t>* vertex_remap_ptr = nullptr) -> bool;
 
    auto sort_mesh_data() -> bool;
 
 
protected:
    bool force_tangent_generation_ = false;
    bool force_normal_generation_ = false;
    bool force_barycentric_generation_ = false;
    bool disable_final_sort_ = false;
 
    uint8_t* system_vb_ = nullptr;
    gfx::vertex_layout vertex_format_;
    uint32_t* system_ib_ = nullptr;
    submesh_key_array_t triangle_data_;
    std::shared_ptr<void> hardware_vb_;
    std::shared_ptr<void> hardware_ib_;
 
    std::vector<lod_level> lods_;
    uint32_t lod_count_ = 1;
 
    submesh_array_t mesh_submeshes_;
 
    submesh_array_map_t skinned_submesh_indices_;
    size_t skinned_submesh_count_{};
 
    submesh_array_map_t non_skinned_submesh_indices_;
    size_t non_skinned_submesh_count_{};
 
    data_group_submesh_map_t data_groups_;
 
    bool hardware_mesh_ = true;
    bool optimize_mesh_ = false;
    math::bbox bbox_;
    uint32_t face_count_ = 0;
    uint32_t vertex_count_ = 0;
 
    mesh_status prepare_status_ = mesh_status::not_prepared;
    preparation_data preparation_data_;
 
    skin_bind_data skin_bind_data_;
    bone_palette_array_t bone_palettes_;
    std::unique_ptr<armature_node> root_ = nullptr;
 
    std::vector<hpp::uuid> default_material_uids_;
};
 
} // namespace unravel