batch_key.h

Go to the documentation of this file.

#pragma once
 
#include <engine/assets/asset_handle.h>
 
#include <graphics/texture.h>
#include <math/math.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
 
#include "material.h"
 
namespace unravel
{
class mesh;
class material;
 
struct batch_key
{
    std::shared_ptr<mesh> mesh_ptr;
    
    std::shared_ptr<material> material_ptr;
    
    uint32_t lod_index = 0;
    
    uint32_t submesh_index = 0;
    
    batch_key() = default;
    
    batch_key(std::shared_ptr<mesh> mesh_ptr,
              std::shared_ptr<material> material_ptr,
              uint32_t lod_index,
              uint32_t submesh_index);
    
    batch_key(const asset_handle<mesh>& mesh_handle,
              const asset_handle<material>& material_handle,
              uint32_t lod_index,
              uint32_t submesh_index);
    
    auto operator<=>(const batch_key& other) const = default;
    
    auto operator==(const batch_key& other) const -> bool = default;
    
    auto hash() const noexcept -> size_t;
    
    auto is_valid() const -> bool;
    
    auto to_string() const -> std::string;
};
 
struct shadow_cutout_state
{
    std::shared_ptr<gfx::texture> color_map;
    float alpha_test_value = 1.0f;
    math::color base_color{};
    math::vec2 tiling{1.0f, 1.0f};
};
 
struct shadow_batch_key
{
    std::shared_ptr<mesh> mesh_ptr;
    uint32_t lod_index = 0;
    uint32_t submesh_index = 0;
    cull_type cull = cull_type::counter_clockwise;
    std::optional<shadow_cutout_state> cutout;
 
    shadow_batch_key() = default;
 
    shadow_batch_key(std::shared_ptr<mesh> mesh,
                     uint32_t lod,
                     uint32_t submesh,
                     cull_type cull_type,
                     std::optional<shadow_cutout_state> cutout_state = std::nullopt);
 
    auto operator<=>(const shadow_batch_key& other) const -> std::strong_ordering;
    auto operator==(const shadow_batch_key& other) const -> bool;
 
    [[nodiscard]] auto hash() const noexcept -> size_t;
    [[nodiscard]] auto is_valid() const -> bool;
    [[nodiscard]] auto uses_alpha_cutout() const -> bool;
    [[nodiscard]] auto to_string() const -> std::string;
};
 
auto make_shadow_batch_key(const std::shared_ptr<mesh>& mesh_ptr,
                           uint32_t lod_index,
                           uint32_t submesh_index,
                           const std::shared_ptr<material>& material_ptr) -> shadow_batch_key;
 
} // namespace unravel
 
namespace std
{
template<>
struct hash<unravel::batch_key>
{
    auto operator()(const unravel::batch_key& key) const noexcept -> size_t
    {
        return key.hash();
    }
};
 
template<>
struct hash<unravel::shadow_batch_key>
{
    auto operator()(const unravel::shadow_batch_key& key) const noexcept -> size_t
    {
        return key.hash();
    }
};
}