dynamic_mesh.h

#pragma once
 
#include <cgv/media/mesh/simple_mesh.h>
 
#include "../lib_begin.h"
 
namespace cgv {
    namespace media {
        namespace mesh {
 
template <typename T = float>
class CGV_API dynamic_mesh : public simple_mesh<T>
{
public:
    using typename simple_mesh_base::idx_type;
    using typename simple_mesh_base::idx2_type;
    using typename simple_mesh_base::idx3_type;
    using typename simple_mesh_base::idx4_type;
    using typename simple_mesh_base::mat_type;
    using typename simple_mesh<T>::vec2_type;
    using typename simple_mesh<T>::vec3_type;
    typedef typename cgv::math::fvec<T, 4> vec4_type;
    using typename simple_mesh<T>::mesh_type;
    using typename simple_mesh<T>::mat3_type;
    typedef typename cgv::math::fmat<T, 4, 4> mat4_type;
    
    enum class blend_shape_mode {
        direct,
        indexed,
        range_indexed
    };
 
  protected:
    std::vector<vec3_type> reference_positions;
    std::vector<vec3_type> intermediate_positions;
    std::vector<vec3_type> blend_shape_data;
    std::vector<uint32_t> blend_shape_indices;
    struct blend_shape
    {
        blend_shape_mode mode;
        idx2_type blend_shape_data_range;
        idx2_type blend_shape_index_range;
    };
    std::vector<blend_shape> blend_shapes;
 
public:
    enum class vertex_weight_mode {
        dense,
        sparse,
        fixed
    };
 
protected:
    vertex_weight_mode weight_mode;
    int32_t          max_nr_weights_per_vertex = -1;
    std::vector<int32_t>  joint_parents;
    std::vector<T>        vertex_weight_data;
    std::vector<uint32_t> vertex_weight_indices;
    std::vector<uint32_t> vertex_weight_index_begins;
public:
    void store_in_reference_positions();
    void store_in_intermediate_positions();
    const std::vector<vec3_type>& get_intermediate_positions() const;
    void recover_intermediate_positions();
 
    uint32_t add_blend_shape(blend_shape_mode mode, idx_type nr_data, idx_type nr_indices = 0);
    void add_blend_shape_data(const vec3_type& d);
    void add_blend_shape_index(idx_type i);
    bool has_blend_shape_vector(idx_type bi, idx_type vi) const;
    vec3_type get_blend_shape_vector(idx_type bi, idx_type vi) const;
    size_t get_nr_blend_shapes() const;
 
    void apply_blend_shapes(const std::vector<T>& weights, idx_type blend_shape_offset = 0, bool only_add = false, bool use_parallel_implementation = false);
 
    void set_vertex_weight_mode(vertex_weight_mode mode);
    void begin_vertex_weight_vertex();
    idx_type vertex_weight_begin(idx_type vi) const;
    idx_type vertex_weight_end(idx_type vi) const;
    T get_vertex_weight(idx_type vi, idx_type ji) const;
    void add_vertex_weight_data(T w);
    void add_vertex_weight_index(idx_type i);
    size_t get_nr_vertex_weights() const;
    size_t get_nr_vertex_weight_indices() const;
    idx_type get_nr_joints() const;
    std::vector<mat4_type> compute_joint_transformations(const std::vector<vec3_type>& reference_joint_locations,
        const vec3_type& translation, const std::vector<vec3_type>& target_spin_vectors) const;
    std::vector<mat4_type> compute_joint_transformations(const std::vector<vec3_type>& reference_joint_locations,
        const vec3_type& translation, const std::vector<mat3_type>& target_rotations) const;
    const std::vector<int32_t>& get_joint_parents() const;
    std::vector<int32_t>& ref_joint_parents();
    enum class lbs_source_mode {
        reference,
        position,
        intermediate };
 
    void lbs(const std::vector<mat4_type>& joint_matrices, lbs_source_mode mode);
};
        }
    }
}
 
#include <cgv/config/lib_end.h>