batch_instance.h

Go to the documentation of this file.

#pragma once
 
#include <math/math.h>
 
#include <vector>
 
namespace unravel
{
 
struct batch_instance
{
    const math::mat4* world_transform_ptr = nullptr;
    
    math::vec3 lod_params = math::vec3(0.0f, -1.0f, 0.0f);
    
    float padding = 0.0f;
    
    batch_instance() = default;
    
    explicit batch_instance(const math::mat4* world_transform_ptr);
    
    batch_instance(const math::mat4* world_transform_ptr, const math::vec3& lod_params);
    
    auto is_valid() const -> bool;
    
    auto to_string() const -> std::string;
};
 
struct instance_vertex_data
{
    static auto packed_size() -> size_t
    {
        return 64;
    }
    math::mat4 world_matrix;
    
    instance_vertex_data() = default;
    
    explicit instance_vertex_data(const batch_instance& instance);
    
    void set_lod_param(float lod_param);
    
    auto get_lod_param() const -> float;
    
    auto is_valid() const -> bool;
    
    auto to_string() const -> std::string;
};
 
class batch_instance_collection
{
public:
    using container_type = std::vector<batch_instance>;
    using iterator = container_type::iterator;
    using const_iterator = container_type::const_iterator;
    
    batch_instance_collection() = default;
    
    void reserve(size_t count);
    
    void add_instance(const batch_instance& instance);
    
    void add_instance(const math::mat4& world_transform);
    
    void clear();
    
    auto size() const -> size_t;
    
    auto empty() const -> bool;
    
    auto operator[](size_t index) -> batch_instance&;
    
    auto operator[](size_t index) const -> const batch_instance&;
    
    auto begin() -> iterator;
    
    auto end() -> iterator;
    
    auto begin() const -> const_iterator;
    
    auto end() const -> const_iterator;
    
    auto to_vertex_data() const -> std::vector<instance_vertex_data>;
    
    auto get_gpu_memory_size() const -> size_t;
 
private:
    container_type instances_;
};
 
// Utility functions
 
auto pack_instance_data(const batch_instance& instance) -> instance_vertex_data;
 
void unpack_instance_data(const instance_vertex_data& vertex_data, 
                         math::mat4& out_transform, 
                         math::vec3& out_lod_params);
 
auto pack_instances_bulk(const std::vector<batch_instance>& instances) -> std::vector<instance_vertex_data>;
 
auto validate_instance_data_layout() -> bool;
 
} // namespace unravel