gltf_utils.h

#ifndef OE_SCENE_LOADER_GLTF_UTILS_H
#define OE_SCENE_LOADER_GLTF_UTILS_H
 
#include "gltf.h"
#include "../../render/mesh_skinned_renderer.h"
#include <OxygenEngine/render/texture_manager.h>

namespace oe::loader::gltf
{
    struct GenerateRenderMeshResults
    {
        std::vector<oe::render::MeshRenderer>& mesh_renderers;
        std::vector<oe::render::MeshSkinnedRenderer>& mesh_skinned_renderers;
    };

    inline void generateRenderMeshes(oe::scene::loader::Gltf::GltfSceneData& info, std::span<oe::scene::Material> materials, const oe::scene::Material& default_material, GenerateRenderMeshResults results)
    {
        auto& mesh_renderers = results.mesh_renderers;
        auto& mesh_skinned_renderers = results.mesh_skinned_renderers;
 
        for (const auto& it : info.render_mesh_nodes)
        {
            auto node = it.first;
            auto id_mesh = it.second;
 
            if (info.render_mesh_is_skinned[id_mesh])
            {
                const oe::scene::SkinnedMesh& skinned_mesh = info.skinned_meshes[id_mesh];
 
                const auto id_armature = info.skinned_meshes[id_mesh];
 
                mesh_skinned_renderers.reserve(mesh_skinned_renderers.size() + 1);
                mesh_skinned_renderers.emplace_back(node, skinned_mesh, info.skins[node]);
 
                auto& renderer = mesh_skinned_renderers.back();
 
                auto& mesh_materials = info.render_meshs_material_ids[id_mesh];
 
                renderer.materials.clear();
                renderer.materials.reserve(mesh_materials.size());
 
                for (const auto& id_material : mesh_materials)
                {
                    if (id_material != -1)
                    {
                        renderer.materials.push_back(materials[id_material]);
                    }
                    else
                    {
                        renderer.materials.push_back(default_material);
                    }
                }
 
                renderer.primitives_by_material = info.render_meshs_material_target[id_mesh];
            }
            else
            {
                const oe::scene::SolidMesh& solid_mesh = info.solid_meshes[id_mesh];
 
                mesh_renderers.reserve(mesh_renderers.size() + 1);
                mesh_renderers.emplace_back(node, solid_mesh);
 
                auto& renderer = mesh_renderers.back();
 
                auto& mesh_materials = info.render_meshs_material_ids[id_mesh];
 
                renderer.materials.clear();
                renderer.materials.reserve(mesh_materials.size());
 
                for (const auto& id_material : mesh_materials)
                {
                    if (id_material != -1)
                    {
                        renderer.materials.push_back(materials[id_material]);
                    }
                    else
                    {
                        renderer.materials.push_back(default_material);
                    }
                }
 
                renderer.primitives_by_material = info.render_meshs_material_target[id_mesh];
            }
        }
    }

    inline void generateDefaultTextures(oe::render::TextureManager& texture_manager)
    {
        texture_manager.registerTexture("default_gltf/white", 1, 1, [] (const uint32_t, const uint32_t)
        {
            return glm::vec4(1.0f);
        });
 
        texture_manager.registerTexture("default_gltf/normal_map", 1, 1, [] (const uint32_t, const uint32_t)
        {
            return glm::vec4(0.5f, 0.5f, 1.0f, 1.0f);
        });
    }

    inline void applyCommonCallbacks(oe::scene::loader::Gltf& loader, oe::render::ShaderBase* shader, oe::render::TextureManager& texture_manager)
    {
        loader.setMaterialFiller([shader, &texture_manager] (const oe::scene::loader::GltfPbrMaterial& gltf_material, oe::scene::Material& material)
        {
            material.setProperty<bool>("uUsePBR", gltf_material.use_pbr);
 
            material.setProperty<glm::vec4>("uAlbedoColor", gltf_material.albedoColor);
            material.setProperty<glm::vec3>("uEmissiveColor", gltf_material.emissiveColor);
            material.setProperty<glm::vec3>("uRouMetAoColor", gltf_material.rouMetAoColor);
 
            if (gltf_material.albedoTexture)
            {
                material.setTexture("uAlbedo", gltf_material.albedoTexture);
            }
            else
            {
                material.setTexture("uAlbedo", texture_manager.getTexture("default_gltf/white"));
            }
 
            if (gltf_material.normalTexture)
            {
                material.setTexture("uNormalmap", gltf_material.normalTexture);
            }
            else
            {
                material.setTexture("uNormalmap", texture_manager.getTexture("default_gltf/normal_map"));
            }
 
            if (gltf_material.emissiveTexture)
            {
                material.setTexture("uEmissive", gltf_material.emissiveTexture);
            }
            else
            {
                material.setTexture("uEmissive", texture_manager.getTexture("default_gltf/white"));
            }
 
            if (gltf_material.rouMetAoTexture)
            {
                material.setTexture("uRouMetAo", gltf_material.rouMetAoTexture);
            }
            else
            {
                material.setTexture("uRouMetAo", texture_manager.getTexture("default_gltf/white"));
            }
 
            material.shader = shader;
        });
    }

    constexpr const char* getShader()
    {
        return R"(
            uniform vec4 uAlbedoColor = vec4(1.0);
            uniform vec3 uEmissiveColor = vec3(0.0);
            uniform vec3 uRouMetAoColor = vec3(1.0);
            uniform bool uUsePBR = true;
 
            uniform sampler2D uAlbedo;
            uniform sampler2D uEmissive;
            uniform sampler2D uNormalmap;
            uniform sampler2D uRouMetAo;
 
            void depth(in SurfaceInput input, inout float result)
            {
                result = texture(uAlbedo, input.tex_coords_0).a;
            }
 
            void surface(in SurfaceInput input, inout SurfaceOutput result)
            {
                vec4 albedo = texture(uAlbedo, input.tex_coords_0);
                albedo.rgb = input.color * OE_CONVERT_SRGB_TO_LINEAR(albedo.rgb);
                result.albedo = vec4(uAlbedoColor.rgb * albedo.rgb, albedo.a);
 
                result.normal = OE_UNPACK_NORMAL_MAP(uNormalmap, input.tex_coords_0);
 
                vec4 emissive = texture(uEmissive, input.tex_coords_0);
                emissive.rgb = OE_CONVERT_SRGB_TO_LINEAR(emissive.rgb);
                result.emissive = uEmissiveColor * emissive.rgb;
 
                vec4 rou_met_ao = texture(uRouMetAo, input.tex_coords_0);
                rou_met_ao.rgb *= uRouMetAoColor;
 
                result.roughness = rou_met_ao.r;
                result.metalness = rou_met_ao.g;
                result.ao = rou_met_ao.b;
 
                result.use_pbr = uUsePBR;
            }
        )";
    }
}
 
#endif