render_resource_resolver_internal.h

#pragma once
 
#include "pixelbullet/assets/material.h"
#include "pixelbullet/filesystem/filesystem.h"
#include "pixelbullet/filesystem/virtual_path_serialization.h"
#include "pixelbullet/private/graphics/rendering/buffers/morph_mesh_resource.h"
#include "pixelbullet/private/graphics/rendering/buffers/skinned_mesh_resource.h"
#include "pixelbullet/private/graphics/rendering/buffers/skinned_morph_mesh_resource.h"
#include "pixelbullet/private/graphics/rendering/buffers/static_mesh_resource.h"
#include "pixelbullet/private/graphics/runtime_support/images/image_2d.h"
#include "pixelbullet/scene/scene_environment_settings.h"
#include "pixelbullet/serialization/node.h"
 
#include <optional>
#include <string>
#include <vector>
 
namespace pixelbullet::render_resource_resolver_internal
{
inline constexpr VkSamplerAddressMode k_cubemap_address_mode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
inline constexpr bool k_enable_anisotropic = true;
inline constexpr bool k_enable_mipmap = true;
inline constexpr std::string_view k_cubemap_file_suffix = ".png";
inline constexpr std::string_view k_cubemap_authored_mip_directory = "mips";
 
struct TextureSamplingOptions
{
    VkFilter mag_filter = VK_FILTER_LINEAR;
    VkFilter min_filter = VK_FILTER_LINEAR;
    VkSamplerMipmapMode mipmap_mode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
    VkSamplerAddressMode address_mode_u = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    VkSamplerAddressMode address_mode_v = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    VkSamplerAddressMode address_mode_w = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    bool anisotropic = true;
    bool mipmap = true;
};
 
inline std::string BuildLogicalPathKey(const VirtualPath& path)
{
    return std::string(path.LogicalPath());
}
 
inline std::string BuildTextureVariantKey(const VirtualPath& texture_path, const MaterialTextureSamplerSettings& sampler)
{
    std::string key = std::string(texture_path.LogicalPath());
    key += "|";
    key += ToString(sampler.wrap_u);
    key += "|";
    key += ToString(sampler.wrap_v);
    key += "|";
    key += ToString(sampler.mag_filter);
    key += "|";
    key += ToString(sampler.min_filter);
    return key;
}
 
inline VkSamplerAddressMode ToVulkanAddressMode(const MaterialTextureWrapMode wrap_mode) noexcept
{
    switch (wrap_mode)
    {
    case MaterialTextureWrapMode::ClampToEdge:
        return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
    case MaterialTextureWrapMode::MirroredRepeat:
        return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
    case MaterialTextureWrapMode::Repeat:
    default:
        return VK_SAMPLER_ADDRESS_MODE_REPEAT;
    }
}
 
inline VkFilter ToVulkanMagFilter(const MaterialTextureMagFilter filter) noexcept
{
    return filter == MaterialTextureMagFilter::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
}
 
inline TextureSamplingOptions BuildTextureSamplingOptions(const MaterialTextureSamplerSettings& sampler) noexcept
{
    TextureSamplingOptions options;
    options.mag_filter = ToVulkanMagFilter(sampler.mag_filter);
    options.address_mode_u = ToVulkanAddressMode(sampler.wrap_u);
    options.address_mode_v = ToVulkanAddressMode(sampler.wrap_v);
    options.address_mode_w = options.address_mode_v;
 
    switch (sampler.min_filter)
    {
    case MaterialTextureMinFilter::Nearest:
        options.min_filter = VK_FILTER_NEAREST;
        options.mipmap_mode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
        options.mipmap = false;
        break;
    case MaterialTextureMinFilter::Linear:
        options.min_filter = VK_FILTER_LINEAR;
        options.mipmap_mode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
        options.mipmap = false;
        break;
    case MaterialTextureMinFilter::NearestMipmapNearest:
        options.min_filter = VK_FILTER_NEAREST;
        options.mipmap_mode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
        options.mipmap = true;
        break;
    case MaterialTextureMinFilter::LinearMipmapNearest:
        options.min_filter = VK_FILTER_LINEAR;
        options.mipmap_mode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
        options.mipmap = true;
        break;
    case MaterialTextureMinFilter::NearestMipmapLinear:
        options.min_filter = VK_FILTER_NEAREST;
        options.mipmap_mode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
        options.mipmap = true;
        break;
    case MaterialTextureMinFilter::LinearMipmapLinear:
    default:
        options.min_filter = VK_FILTER_LINEAR;
        options.mipmap_mode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
        options.mipmap = true;
        break;
    }
 
    const bool fully_linear = options.mag_filter == VK_FILTER_LINEAR && options.min_filter == VK_FILTER_LINEAR &&
                              (!options.mipmap || options.mipmap_mode == VK_SAMPLER_MIPMAP_MODE_LINEAR);
    options.anisotropic = fully_linear;
    return options;
}
 
inline Node BuildTextureCacheKey(const VirtualPath& texture_path, const MaterialTextureSamplerSettings& sampler)
{
    const TextureSamplingOptions options = BuildTextureSamplingOptions(sampler);
    return Image2D::BuildCacheKey(texture_path, options.mag_filter, options.min_filter, options.mipmap_mode, options.address_mode_u,
                                  options.address_mode_v, options.address_mode_w, options.anisotropic, options.mipmap);
}
 
inline VirtualPath BuildCubemapMipFacePath(const VirtualPath& cubemap_root, const uint32_t mip_level, std::string_view face_name)
{
    return cubemap_root / std::string(k_cubemap_authored_mip_directory) / std::to_string(mip_level) /
           (std::string(face_name) + std::string(k_cubemap_file_suffix));
}
 
inline std::optional<uint32_t> DetectAuthoredCubemapMipCount(const Filesystem& filesystem, const VirtualPath& cubemap_root)
{
    std::optional<uint32_t> mip_count;
    for (uint32_t mip_level = 0u;; ++mip_level)
    {
        bool any_faces_found = false;
        bool all_faces_found = true;
        for (const std::string_view face_name : k_scene_environment_cubemap_faces)
        {
            const bool face_exists = filesystem.Exists(BuildCubemapMipFacePath(cubemap_root, mip_level, face_name));
            any_faces_found = any_faces_found || face_exists;
            all_faces_found = all_faces_found && face_exists;
        }
 
        if (!any_faces_found)
        {
            break;
        }
        if (!all_faces_found)
        {
            return std::nullopt;
        }
 
        mip_count = mip_level + 1u;
    }
 
    return mip_count;
}
 
inline Node BuildCubemapCacheKey(const VirtualPath& cubemap_root, const bool authored_mip_chain)
{
    Node node;
    node["assetPath"] << cubemap_root;
    node["fileSuffix"] << std::string(k_cubemap_file_suffix);
 
    std::vector<std::string> file_sides;
    file_sides.reserve(k_scene_environment_cubemap_faces.size());
    for (const std::string_view face_name : k_scene_environment_cubemap_faces)
    {
        file_sides.emplace_back(face_name);
    }
    node["fileSides"] << file_sides;
 
    node["filter"] << VK_FILTER_LINEAR;
    node["addressMode"] << k_cubemap_address_mode;
    node["anisotropic"] << k_enable_anisotropic;
    node["mipmap"] << k_enable_mipmap;
    node["authoredMipChain"] << authored_mip_chain;
    return node;
}
 
inline Node BuildStaticMeshCacheKey(const VirtualPath& mesh_path)
{
    return StaticMeshResource::BuildCacheKey(mesh_path);
}
 
inline Node BuildMorphMeshCacheKey(const VirtualPath& mesh_path)
{
    return MorphMeshResource::BuildCacheKey(mesh_path);
}
 
inline Node BuildSkinnedMeshCacheKey(const VirtualPath& mesh_path)
{
    return SkinnedMeshResource::BuildCacheKey(mesh_path);
}
 
inline Node BuildSkinnedMorphMeshCacheKey(const VirtualPath& mesh_path)
{
    return SkinnedMorphMeshResource::BuildCacheKey(mesh_path);
}
 
inline bool HasCompleteCubemap(const Filesystem& filesystem, const VirtualPath& cubemap_root)
{
    const std::optional<uint32_t> authored_mip_count = DetectAuthoredCubemapMipCount(filesystem, cubemap_root);
    if (authored_mip_count.has_value())
    {
        return *authored_mip_count > 0u;
    }
 
    for (const std::string_view face_name : k_scene_environment_cubemap_faces)
    {
        if (!filesystem.Exists(cubemap_root / (std::string(face_name) + std::string(k_cubemap_file_suffix))))
        {
            return false;
        }
    }
    return true;
}
} // namespace pixelbullet::render_resource_resolver_internal