render_proxy.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include <hpp/small_vector.hpp>
#include <math/math.h>
 
#include <cstdint>
#include <vector>
 
namespace unravel
{
 
struct submesh_render_proxies
{
    hpp::small_vector<hpp::small_vector<math::bbox>> instance_bounds;
 
    std::vector<math::bbox> skinned_bounds;
 
    math::bbox animated_bounds;
 
    math::bbox instance_bounds_union;
 
    uint64_t version{0};
 
    void clear()
    {
        instance_bounds.clear();
        skinned_bounds.clear();
        animated_bounds = {};
        instance_bounds_union = {};
    }
 
    void begin_refresh(size_t submesh_count)
    {
        instance_bounds.clear();
        instance_bounds.resize(submesh_count);
        skinned_bounds.clear();
        animated_bounds = {};
        instance_bounds_union = {};
        version++;
    }
 
    void add_instance_bounds(uint32_t submesh_index, const math::bbox& world_bounds)
    {
        if(submesh_index >= instance_bounds.size())
        {
            instance_bounds.resize(submesh_index + 1);
        }
        instance_bounds[submesh_index].emplace_back(world_bounds);
        if(world_bounds.is_populated())
        {
            instance_bounds_union.add_point(world_bounds.min);
            instance_bounds_union.add_point(world_bounds.max);
        }
    }
 
    auto get_instance_bounds(uint32_t submesh_index, size_t instance_index) const -> const math::bbox*
    {
        if(submesh_index >= instance_bounds.size())
        {
            return nullptr;
        }
        const auto& bounds_list = instance_bounds[submesh_index];
        if(instance_index >= bounds_list.size())
        {
            return nullptr;
        }
        const auto& bounds = bounds_list[instance_index];
        return bounds.is_populated() ? &bounds : nullptr;
    }
 
    auto get_skinned_bounds(uint32_t submesh_index) const -> const math::bbox*
    {
        if(submesh_index >= skinned_bounds.size())
        {
            return nullptr;
        }
        const auto& bounds = skinned_bounds[submesh_index];
        return bounds.is_populated() ? &bounds : nullptr;
    }
 
    auto has_animated_bounds() const -> bool
    {
        return animated_bounds.is_populated();
    }
 
    auto has_instance_bounds() const -> bool
    {
        return instance_bounds_union.is_populated();
    }
 
    auto has_pose_bounds() const -> bool
    {
        return has_instance_bounds() || has_animated_bounds();
    }
};
 
} // namespace unravel