XCEngine/engine/src/Resources/BuiltinResources.cpp

#include <XCEngine/Resources/BuiltinResources.h>

#include <XCEngine/Core/Math/Bounds.h>
#include <XCEngine/Core/Math/Vector2.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Resources/Shader/Shader.h>
#include <XCEngine/Resources/Texture/Texture.h>

#include <algorithm>
#include <cmath>
#include <vector>

namespace XCEngine {
namespace Resources {

namespace {

constexpr const char* kBuiltinPrefix = "builtin://";
constexpr const char* kBuiltinMeshPrefix = "builtin://meshes/";
constexpr const char* kBuiltinMaterialPrefix = "builtin://materials/";
constexpr const char* kBuiltinShaderPrefix = "builtin://shaders/";
constexpr const char* kBuiltinTexturePrefix = "builtin://textures/";
constexpr const char* kBuiltinDefaultPrimitiveMaterialPath = "builtin://materials/default-primitive";
constexpr const char* kBuiltinForwardLitShaderPath = "builtin://shaders/forward-lit";
constexpr const char* kBuiltinDefaultPrimitiveTexturePath = "builtin://textures/default-primitive-albedo";
constexpr float kPi = 3.14159265358979323846f;

struct MeshBuffers {
    std::vector<StaticMeshVertex> vertices;
    std::vector<Core::uint32> indices;
};

const char kBuiltinForwardHlsl[] = R"(
Texture2D gBaseColorTexture : register(t1);
SamplerState gLinearSampler : register(s1);

cbuffer PerObjectConstants : register(b1) {
    float4x4 gProjectionMatrix;
    float4x4 gViewMatrix;
    float4x4 gModelMatrix;
    float4x4 gNormalMatrix;
    float4 gMainLightDirectionAndIntensity;
    float4 gMainLightColorAndFlags;
};

cbuffer MaterialConstants : register(b2) {
    float4 gBaseColorFactor;
};

struct VSInput {
    float3 position : POSITION;
    float3 normal : NORMAL;
    float2 texcoord : TEXCOORD0;
};

struct PSInput {
    float4 position : SV_POSITION;
    float3 normalWS : TEXCOORD0;
    float2 texcoord : TEXCOORD1;
};

PSInput MainVS(VSInput input) {
    PSInput output;
    float4 positionWS = mul(gModelMatrix, float4(input.position, 1.0f));
    float4 positionVS = mul(gViewMatrix, positionWS);
    output.position = mul(gProjectionMatrix, positionVS);
    output.normalWS = mul((float3x3)gNormalMatrix, input.normal);
    output.texcoord = input.texcoord;
    return output;
}

float4 MainPS(PSInput input) : SV_TARGET {
    float4 baseColor = gBaseColorTexture.Sample(gLinearSampler, input.texcoord) * gBaseColorFactor;
    if (gMainLightColorAndFlags.a < 0.5f) {
        return baseColor;
    }

    float3 normalWS = normalize(input.normalWS);
    float3 directionToLightWS = normalize(gMainLightDirectionAndIntensity.xyz);
    float diffuse = saturate(dot(normalWS, directionToLightWS));
    float3 lighting = float3(0.28f, 0.28f, 0.28f) +
        gMainLightColorAndFlags.rgb * (diffuse * gMainLightDirectionAndIntensity.w);
    return float4(baseColor.rgb * lighting, baseColor.a);
}
)";

const char kBuiltinForwardVertexShader[] = R"(#version 430
layout(location = 0) in vec3 aPosition;
layout(location = 1) in vec3 aNormal;
layout(location = 2) in vec2 aTexCoord;

layout(std140, binding = 1) uniform PerObjectConstants {
    mat4 gProjectionMatrix;
    mat4 gViewMatrix;
    mat4 gModelMatrix;
    mat4 gNormalMatrix;
    vec4 gMainLightDirectionAndIntensity;
    vec4 gMainLightColorAndFlags;
};

out vec3 vNormalWS;
out vec2 vTexCoord;

void main() {
    vec4 positionWS = gModelMatrix * vec4(aPosition, 1.0);
    vec4 positionVS = gViewMatrix * positionWS;
    gl_Position = gProjectionMatrix * positionVS;
    vNormalWS = mat3(gNormalMatrix) * aNormal;
    vTexCoord = aTexCoord;
}
)";

const char kBuiltinForwardFragmentShader[] = R"(#version 430
layout(binding = 1) uniform sampler2D uBaseColorTexture;

layout(std140, binding = 1) uniform PerObjectConstants {
    mat4 gProjectionMatrix;
    mat4 gViewMatrix;
    mat4 gModelMatrix;
    mat4 gNormalMatrix;
    vec4 gMainLightDirectionAndIntensity;
    vec4 gMainLightColorAndFlags;
};

layout(std140, binding = 2) uniform MaterialConstants {
    vec4 gBaseColorFactor;
};

in vec3 vNormalWS;
in vec2 vTexCoord;

layout(location = 0) out vec4 fragColor;

void main() {
    vec4 baseColor = texture(uBaseColorTexture, vTexCoord) * gBaseColorFactor;
    if (gMainLightColorAndFlags.w < 0.5) {
        fragColor = baseColor;
        return;
    }

    vec3 normalWS = normalize(vNormalWS);
    vec3 directionToLightWS = normalize(gMainLightDirectionAndIntensity.xyz);
    float diffuse = max(dot(normalWS, directionToLightWS), 0.0);
    vec3 lighting = vec3(0.28) +
        gMainLightColorAndFlags.rgb * (diffuse * gMainLightDirectionAndIntensity.w);
    fragColor = vec4(baseColor.rgb * lighting, baseColor.a);
}
)";

const char kBuiltinForwardVulkanVertexShader[] = R"(#version 450
layout(location = 0) in vec3 aPosition;
layout(location = 1) in vec3 aNormal;
layout(location = 2) in vec2 aTexCoord;

layout(set = 1, binding = 0, std140) uniform PerObjectConstants {
    mat4 gProjectionMatrix;
    mat4 gViewMatrix;
    mat4 gModelMatrix;
    mat4 gNormalMatrix;
    vec4 gMainLightDirectionAndIntensity;
    vec4 gMainLightColorAndFlags;
};

layout(location = 0) out vec3 vNormalWS;
layout(location = 1) out vec2 vTexCoord;

void main() {
    vec4 positionWS = gModelMatrix * vec4(aPosition, 1.0);
    vec4 positionVS = gViewMatrix * positionWS;
    gl_Position = gProjectionMatrix * positionVS;
    vNormalWS = mat3(gNormalMatrix) * aNormal;
    vTexCoord = aTexCoord;
}
)";

const char kBuiltinForwardVulkanFragmentShader[] = R"(#version 450
layout(set = 3, binding = 0) uniform texture2D uBaseColorTexture;
layout(set = 4, binding = 0) uniform sampler uLinearSampler;

layout(set = 1, binding = 0, std140) uniform PerObjectConstants {
    mat4 gProjectionMatrix;
    mat4 gViewMatrix;
    mat4 gModelMatrix;
    mat4 gNormalMatrix;
    vec4 gMainLightDirectionAndIntensity;
    vec4 gMainLightColorAndFlags;
};

layout(set = 2, binding = 0, std140) uniform MaterialConstants {
    vec4 gBaseColorFactor;
};

layout(location = 0) in vec3 vNormalWS;
layout(location = 1) in vec2 vTexCoord;

layout(location = 0) out vec4 fragColor;

void main() {
    vec4 baseColor = texture(sampler2D(uBaseColorTexture, uLinearSampler), vTexCoord) * gBaseColorFactor;
    if (gMainLightColorAndFlags.w < 0.5) {
        fragColor = baseColor;
        return;
    }

    vec3 normalWS = normalize(vNormalWS);
    vec3 directionToLightWS = normalize(gMainLightDirectionAndIntensity.xyz);
    float diffuse = max(dot(normalWS, directionToLightWS), 0.0);
    vec3 lighting = vec3(0.28) +
        gMainLightColorAndFlags.rgb * (diffuse * gMainLightDirectionAndIntensity.w);
    fragColor = vec4(baseColor.rgb * lighting, baseColor.a);
}
)";

Math::Bounds ComputeBounds(const std::vector<StaticMeshVertex>& vertices) {
    if (vertices.empty()) {
        return Math::Bounds();
    }

    Math::Vector3 min = vertices.front().position;
    Math::Vector3 max = vertices.front().position;
    for (const StaticMeshVertex& vertex : vertices) {
        min.x = std::min(min.x, vertex.position.x);
        min.y = std::min(min.y, vertex.position.y);
        min.z = std::min(min.z, vertex.position.z);
        max.x = std::max(max.x, vertex.position.x);
        max.y = std::max(max.y, vertex.position.y);
        max.z = std::max(max.z, vertex.position.z);
    }

    Math::Bounds bounds;
    bounds.SetMinMax(min, max);
    return bounds;
}

StaticMeshVertex MakeVertex(
    const Math::Vector3& position,
    const Math::Vector3& normal,
    const Math::Vector3& tangent,
    const Math::Vector2& uv) {
    StaticMeshVertex vertex;
    vertex.position = position;
    vertex.normal = normal.Normalized();
    vertex.tangent = tangent.Normalized();
    vertex.bitangent = Math::Vector3::Cross(vertex.normal, vertex.tangent).Normalized();
    vertex.uv0 = uv;
    return vertex;
}

void AppendQuad(
    MeshBuffers& buffers,
    const Math::Vector3& bottomLeft,
    const Math::Vector3& bottomRight,
    const Math::Vector3& topRight,
    const Math::Vector3& topLeft,
    const Math::Vector3& normal,
    const Math::Vector3& tangent) {
    const Core::uint32 baseIndex = static_cast<Core::uint32>(buffers.vertices.size());
    buffers.vertices.push_back(MakeVertex(bottomLeft, normal, tangent, Math::Vector2(0.0f, 0.0f)));
    buffers.vertices.push_back(MakeVertex(bottomRight, normal, tangent, Math::Vector2(1.0f, 0.0f)));
    buffers.vertices.push_back(MakeVertex(topRight, normal, tangent, Math::Vector2(1.0f, 1.0f)));
    buffers.vertices.push_back(MakeVertex(topLeft, normal, tangent, Math::Vector2(0.0f, 1.0f)));

    buffers.indices.push_back(baseIndex + 0);
    buffers.indices.push_back(baseIndex + 1);
    buffers.indices.push_back(baseIndex + 2);
    buffers.indices.push_back(baseIndex + 0);
    buffers.indices.push_back(baseIndex + 2);
    buffers.indices.push_back(baseIndex + 3);
}

void FlipTriangleWinding(MeshBuffers& buffers) {
    for (size_t index = 0; index + 2 < buffers.indices.size(); index += 3) {
        std::swap(buffers.indices[index + 1], buffers.indices[index + 2]);
    }
}

MeshBuffers CreateCubeMeshBuffers() {
    MeshBuffers buffers;
    const float half = 0.5f;

    AppendQuad(
        buffers,
        Math::Vector3(-half, -half, half),
        Math::Vector3(half, -half, half),
        Math::Vector3(half, half, half),
        Math::Vector3(-half, half, half),
        Math::Vector3::Forward(),
        Math::Vector3::Right());
    AppendQuad(
        buffers,
        Math::Vector3(half, -half, -half),
        Math::Vector3(-half, -half, -half),
        Math::Vector3(-half, half, -half),
        Math::Vector3(half, half, -half),
        Math::Vector3::Back(),
        Math::Vector3::Left());
    AppendQuad(
        buffers,
        Math::Vector3(-half, -half, -half),
        Math::Vector3(-half, -half, half),
        Math::Vector3(-half, half, half),
        Math::Vector3(-half, half, -half),
        Math::Vector3::Left(),
        Math::Vector3::Forward());
    AppendQuad(
        buffers,
        Math::Vector3(half, -half, half),
        Math::Vector3(half, -half, -half),
        Math::Vector3(half, half, -half),
        Math::Vector3(half, half, half),
        Math::Vector3::Right(),
        Math::Vector3::Back());
    AppendQuad(
        buffers,
        Math::Vector3(-half, half, half),
        Math::Vector3(half, half, half),
        Math::Vector3(half, half, -half),
        Math::Vector3(-half, half, -half),
        Math::Vector3::Up(),
        Math::Vector3::Right());
    AppendQuad(
        buffers,
        Math::Vector3(-half, -half, -half),
        Math::Vector3(half, -half, -half),
        Math::Vector3(half, -half, half),
        Math::Vector3(-half, -half, half),
        Math::Vector3::Down(),
        Math::Vector3::Right());

    return buffers;
}

MeshBuffers CreateQuadMeshBuffers() {
    MeshBuffers buffers;
    AppendQuad(
        buffers,
        Math::Vector3(-0.5f, -0.5f, 0.0f),
        Math::Vector3(0.5f, -0.5f, 0.0f),
        Math::Vector3(0.5f, 0.5f, 0.0f),
        Math::Vector3(-0.5f, 0.5f, 0.0f),
        Math::Vector3::Forward(),
        Math::Vector3::Right());
    return buffers;
}

MeshBuffers CreatePlaneMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kSegments = 10;
    constexpr float kSize = 10.0f;
    const float halfSize = kSize * 0.5f;
    const float step = kSize / static_cast<float>(kSegments);

    for (int z = 0; z <= kSegments; ++z) {
        for (int x = 0; x <= kSegments; ++x) {
            const float px = -halfSize + static_cast<float>(x) * step;
            const float pz = -halfSize + static_cast<float>(z) * step;
            const float u = static_cast<float>(x) / static_cast<float>(kSegments);
            const float v = static_cast<float>(z) / static_cast<float>(kSegments);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(px, 0.0f, pz),
                Math::Vector3::Up(),
                Math::Vector3::Right(),
                Math::Vector2(u, v)));
        }
    }

    const int rowStride = kSegments + 1;
    for (int z = 0; z < kSegments; ++z) {
        for (int x = 0; x < kSegments; ++x) {
            const Core::uint32 i0 = static_cast<Core::uint32>(z * rowStride + x);
            const Core::uint32 i1 = i0 + 1;
            const Core::uint32 i2 = i0 + static_cast<Core::uint32>(rowStride);
            const Core::uint32 i3 = i2 + 1;

            buffers.indices.push_back(i0);
            buffers.indices.push_back(i3);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i0);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i3);
        }
    }

    return buffers;
}

MeshBuffers CreateUvSphereMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kLongitudeSegments = 24;
    constexpr int kLatitudeSegments = 16;
    constexpr float kRadius = 0.5f;

    for (int latitude = 0; latitude <= kLatitudeSegments; ++latitude) {
        const float v = static_cast<float>(latitude) / static_cast<float>(kLatitudeSegments);
        const float theta = v * kPi;
        const float sinTheta = std::sin(theta);
        const float cosTheta = std::cos(theta);

        for (int longitude = 0; longitude <= kLongitudeSegments; ++longitude) {
            const float u = static_cast<float>(longitude) / static_cast<float>(kLongitudeSegments);
            const float phi = u * (2.0f * kPi);
            const float sinPhi = std::sin(phi);
            const float cosPhi = std::cos(phi);

            const Math::Vector3 normal(cosPhi * sinTheta, cosTheta, sinPhi * sinTheta);
            Math::Vector3 tangent(-sinPhi, 0.0f, cosPhi);
            if (tangent.SqrMagnitude() <= 0.000001f) {
                tangent = Math::Vector3::Right();
            }

            buffers.vertices.push_back(MakeVertex(
                normal * kRadius,
                normal,
                tangent,
                Math::Vector2(u, 1.0f - v)));
        }
    }

    const int stride = kLongitudeSegments + 1;
    for (int latitude = 0; latitude < kLatitudeSegments; ++latitude) {
        for (int longitude = 0; longitude < kLongitudeSegments; ++longitude) {
            const Core::uint32 i0 = static_cast<Core::uint32>(latitude * stride + longitude);
            const Core::uint32 i1 = i0 + 1;
            const Core::uint32 i2 = i0 + static_cast<Core::uint32>(stride);
            const Core::uint32 i3 = i2 + 1;

            buffers.indices.push_back(i0);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i3);
        }
    }

    return buffers;
}

MeshBuffers CreateCylinderMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kRadialSegments = 24;
    constexpr float kRadius = 0.5f;
    constexpr float kHalfHeight = 1.0f;

    for (int ring = 0; ring <= 1; ++ring) {
        const float y = ring == 0 ? -kHalfHeight : kHalfHeight;
        const float v = static_cast<float>(ring);
        for (int segment = 0; segment <= kRadialSegments; ++segment) {
            const float u = static_cast<float>(segment) / static_cast<float>(kRadialSegments);
            const float angle = u * (2.0f * kPi);
            const float cosAngle = std::cos(angle);
            const float sinAngle = std::sin(angle);
            const Math::Vector3 normal(cosAngle, 0.0f, sinAngle);
            const Math::Vector3 tangent(-sinAngle, 0.0f, cosAngle);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(cosAngle * kRadius, y, sinAngle * kRadius),
                normal,
                tangent,
                Math::Vector2(u, v)));
        }
    }

    const int sideStride = kRadialSegments + 1;
    for (int segment = 0; segment < kRadialSegments; ++segment) {
        const Core::uint32 i0 = static_cast<Core::uint32>(segment);
        const Core::uint32 i1 = i0 + 1;
        const Core::uint32 i2 = i0 + static_cast<Core::uint32>(sideStride);
        const Core::uint32 i3 = i2 + 1;

        buffers.indices.push_back(i0);
        buffers.indices.push_back(i2);
        buffers.indices.push_back(i1);
        buffers.indices.push_back(i1);
        buffers.indices.push_back(i2);
        buffers.indices.push_back(i3);
    }

    const auto appendCap = [&](bool topCap) {
        const float y = topCap ? kHalfHeight : -kHalfHeight;
        const Math::Vector3 normal = topCap ? Math::Vector3::Up() : Math::Vector3::Down();
        const Core::uint32 centerIndex = static_cast<Core::uint32>(buffers.vertices.size());
        buffers.vertices.push_back(MakeVertex(
            Math::Vector3(0.0f, y, 0.0f),
            normal,
            Math::Vector3::Right(),
            Math::Vector2(0.5f, 0.5f)));

        for (int segment = 0; segment <= kRadialSegments; ++segment) {
            const float u = static_cast<float>(segment) / static_cast<float>(kRadialSegments);
            const float angle = u * (2.0f * kPi);
            const float cosAngle = std::cos(angle);
            const float sinAngle = std::sin(angle);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(cosAngle * kRadius, y, sinAngle * kRadius),
                normal,
                Math::Vector3::Right(),
                Math::Vector2(cosAngle * 0.5f + 0.5f, sinAngle * 0.5f + 0.5f)));
        }

        for (int segment = 0; segment < kRadialSegments; ++segment) {
            const Core::uint32 rim0 = centerIndex + 1 + static_cast<Core::uint32>(segment);
            const Core::uint32 rim1 = rim0 + 1;
            if (topCap) {
                buffers.indices.push_back(centerIndex);
                buffers.indices.push_back(rim0);
                buffers.indices.push_back(rim1);
            } else {
                buffers.indices.push_back(centerIndex);
                buffers.indices.push_back(rim1);
                buffers.indices.push_back(rim0);
            }
        }
    };

    appendCap(true);
    appendCap(false);
    return buffers;
}

MeshBuffers CreateCapsuleMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kRadialSegments = 24;
    constexpr int kHemisphereSegments = 8;
    constexpr float kRadius = 0.5f;
    constexpr float kHalfCylinderHeight = 0.5f;

    struct RingDefinition {
        float y = 0.0f;
        float radius = 0.0f;
        Math::Vector3 normalBase = Math::Vector3::Zero();
    };

    std::vector<RingDefinition> rings;
    rings.reserve(static_cast<size_t>(kHemisphereSegments * 2 + 2));

    for (int step = 0; step <= kHemisphereSegments; ++step) {
        const float t = static_cast<float>(step) / static_cast<float>(kHemisphereSegments);
        const float angle = -0.5f * kPi + t * (0.5f * kPi);
        const float ringRadius = std::cos(angle) * kRadius;
        const float y = std::sin(angle) * kRadius - kHalfCylinderHeight;
        const Math::Vector3 normalBase(0.0f, std::sin(angle), 0.0f);
        rings.push_back({ y, ringRadius, normalBase });
    }

    for (int step = 0; step <= kHemisphereSegments; ++step) {
        const float t = static_cast<float>(step) / static_cast<float>(kHemisphereSegments);
        const float angle = t * (0.5f * kPi);
        const float ringRadius = std::cos(angle) * kRadius;
        const float y = std::sin(angle) * kRadius + kHalfCylinderHeight;
        const Math::Vector3 normalBase(0.0f, std::sin(angle), 0.0f);
        rings.push_back({ y, ringRadius, normalBase });
    }

    for (size_t ringIndex = 0; ringIndex < rings.size(); ++ringIndex) {
        const float v = rings.size() > 1
            ? static_cast<float>(ringIndex) / static_cast<float>(rings.size() - 1)
            : 0.0f;
        for (int segment = 0; segment <= kRadialSegments; ++segment) {
            const float u = static_cast<float>(segment) / static_cast<float>(kRadialSegments);
            const float angle = u * (2.0f * kPi);
            const float cosAngle = std::cos(angle);
            const float sinAngle = std::sin(angle);
            const Math::Vector3 radial(cosAngle, 0.0f, sinAngle);

            Math::Vector3 normal(
                radial.x * rings[ringIndex].radius,
                rings[ringIndex].normalBase.y * kRadius,
                radial.z * rings[ringIndex].radius);
            normal = normal.Normalized();
            if (normal.SqrMagnitude() <= 0.000001f) {
                normal = rings[ringIndex].y >= 0.0f ? Math::Vector3::Up() : Math::Vector3::Down();
            }

            const Math::Vector3 tangent(-sinAngle, 0.0f, cosAngle);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(radial.x * rings[ringIndex].radius, rings[ringIndex].y, radial.z * rings[ringIndex].radius),
                normal,
                tangent,
                Math::Vector2(u, 1.0f - v)));
        }
    }

    const int stride = kRadialSegments + 1;
    for (size_t ringIndex = 0; ringIndex + 1 < rings.size(); ++ringIndex) {
        for (int segment = 0; segment < kRadialSegments; ++segment) {
            const Core::uint32 i0 = static_cast<Core::uint32>(ringIndex * stride + static_cast<size_t>(segment));
            const Core::uint32 i1 = i0 + 1;
            const Core::uint32 i2 = i0 + static_cast<Core::uint32>(stride);
            const Core::uint32 i3 = i2 + 1;

            buffers.indices.push_back(i0);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i3);
        }
    }

    return buffers;
}

Mesh* BuildMeshResource(
    const Containers::String& path,
    const char* displayName,
    MeshBuffers&& buffers) {
    if (buffers.vertices.empty() || buffers.indices.empty()) {
        return nullptr;
    }

    auto* mesh = new Mesh();
    IResource::ConstructParams params;
    params.name = Containers::String(displayName);
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    params.memorySize = 0;
    mesh->Initialize(params);

    mesh->SetVertexData(
        buffers.vertices.data(),
        buffers.vertices.size() * sizeof(StaticMeshVertex),
        static_cast<Core::uint32>(buffers.vertices.size()),
        sizeof(StaticMeshVertex),
        VertexAttribute::Position |
            VertexAttribute::Normal |
            VertexAttribute::Tangent |
            VertexAttribute::Bitangent |
            VertexAttribute::UV0);

    if (buffers.vertices.size() > 65535u) {
        mesh->SetIndexData(
            buffers.indices.data(),
            buffers.indices.size() * sizeof(Core::uint32),
            static_cast<Core::uint32>(buffers.indices.size()),
            true);
    } else {
        std::vector<Core::uint16> compactIndices;
        compactIndices.reserve(buffers.indices.size());
        for (Core::uint32 index : buffers.indices) {
            compactIndices.push_back(static_cast<Core::uint16>(index));
        }

        mesh->SetIndexData(
            compactIndices.data(),
            compactIndices.size() * sizeof(Core::uint16),
            static_cast<Core::uint32>(compactIndices.size()),
            false);
    }

    const Math::Bounds bounds = ComputeBounds(buffers.vertices);
    mesh->SetBounds(bounds);

    MeshSection section = {};
    section.baseVertex = 0;
    section.vertexCount = static_cast<Core::uint32>(buffers.vertices.size());
    section.startIndex = 0;
    section.indexCount = static_cast<Core::uint32>(buffers.indices.size());
    section.materialID = 0;
    section.bounds = bounds;
    mesh->AddSection(section);

    return mesh;
}

void AddBuiltinShaderStageVariant(
    Shader& shader,
    const Containers::String& passName,
    ShaderType stage,
    ShaderLanguage language,
    ShaderBackend backend,
    const char* sourceCode,
    const char* entryPoint,
    const char* profile) {
    ShaderStageVariant variant = {};
    variant.stage = stage;
    variant.language = language;
    variant.backend = backend;
    variant.sourceCode = Containers::String(sourceCode);
    variant.entryPoint = Containers::String(entryPoint);
    variant.profile = Containers::String(profile);
    shader.AddPassVariant(passName, variant);
}

size_t CalculateBuiltinShaderMemorySize(const Shader& shader) {
    size_t memorySize = sizeof(Shader) + shader.GetName().Length() + shader.GetPath().Length();
    for (const ShaderPass& pass : shader.GetPasses()) {
        memorySize += pass.name.Length();
        for (const ShaderPassTagEntry& tag : pass.tags) {
            memorySize += tag.name.Length();
            memorySize += tag.value.Length();
        }
        for (const ShaderStageVariant& variant : pass.variants) {
            memorySize += variant.entryPoint.Length();
            memorySize += variant.profile.Length();
            memorySize += variant.sourceCode.Length();
            memorySize += variant.compiledBinary.Size();
        }
    }

    return memorySize;
}

Shader* BuildBuiltinForwardLitShader(const Containers::String& path) {
    auto* shader = new Shader();
    IResource::ConstructParams params;
    params.name = Containers::String("Builtin Forward Lit");
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    params.memorySize = 0;
    shader->Initialize(params);

    const Containers::String passName("ForwardLit");
    shader->SetPassTag(passName, "LightMode", "ForwardBase");

    AddBuiltinShaderStageVariant(
        *shader,
        passName,
        ShaderType::Vertex,
        ShaderLanguage::HLSL,
        ShaderBackend::D3D12,
        kBuiltinForwardHlsl,
        "MainVS",
        "vs_5_0");
    AddBuiltinShaderStageVariant(
        *shader,
        passName,
        ShaderType::Fragment,
        ShaderLanguage::HLSL,
        ShaderBackend::D3D12,
        kBuiltinForwardHlsl,
        "MainPS",
        "ps_5_0");

    AddBuiltinShaderStageVariant(
        *shader,
        passName,
        ShaderType::Vertex,
        ShaderLanguage::GLSL,
        ShaderBackend::OpenGL,
        kBuiltinForwardVertexShader,
        "main",
        "vs_4_30");
    AddBuiltinShaderStageVariant(
        *shader,
        passName,
        ShaderType::Fragment,
        ShaderLanguage::GLSL,
        ShaderBackend::OpenGL,
        kBuiltinForwardFragmentShader,
        "main",
        "fs_4_30");

    AddBuiltinShaderStageVariant(
        *shader,
        passName,
        ShaderType::Vertex,
        ShaderLanguage::GLSL,
        ShaderBackend::Vulkan,
        kBuiltinForwardVulkanVertexShader,
        "main",
        "vs_4_50");
    AddBuiltinShaderStageVariant(
        *shader,
        passName,
        ShaderType::Fragment,
        ShaderLanguage::GLSL,
        ShaderBackend::Vulkan,
        kBuiltinForwardVulkanFragmentShader,
        "main",
        "fs_4_50");

    shader->m_memorySize = CalculateBuiltinShaderMemorySize(*shader);
    return shader;
}

Material* BuildDefaultPrimitiveMaterial(const Containers::String& path) {
    auto* material = new Material();
    IResource::ConstructParams params;
    params.name = Containers::String("Default Primitive Material");
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    params.memorySize = 0;
    material->Initialize(params);

    MaterialRenderState renderState = {};
    renderState.cullMode = MaterialCullMode::Back;
    material->SetRenderState(renderState);
    material->SetRenderQueue(MaterialRenderQueue::Geometry);
    material->SetShader(ResourceManager::Get().Load<Shader>(GetBuiltinForwardLitShaderPath()));
    material->SetTexture(
        Containers::String("baseColorTexture"),
        ResourceManager::Get().Load<Texture>(GetBuiltinDefaultPrimitiveTexturePath()));
    material->RecalculateMemorySize();
    return material;
}

Texture* BuildDefaultPrimitiveTexture(const Containers::String& path) {
    static const unsigned char kTexturePixels[4] = { 214, 214, 214, 255 };

    auto* texture = new Texture();
    IResource::ConstructParams params;
    params.name = Containers::String("Default Primitive Albedo");
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    params.memorySize = 0;
    texture->Initialize(params);

    if (!texture->Create(
            1,
            1,
            1,
            1,
            TextureType::Texture2D,
            TextureFormat::RGBA8_UNORM,
            kTexturePixels,
            sizeof(kTexturePixels))) {
        delete texture;
        return nullptr;
    }

    return texture;
}

} // namespace

bool IsBuiltinResourcePath(const Containers::String& path) {
    return path.StartsWith(kBuiltinPrefix);
}

bool IsBuiltinMeshPath(const Containers::String& path) {
    return path.StartsWith(kBuiltinMeshPrefix);
}

bool IsBuiltinMaterialPath(const Containers::String& path) {
    return path.StartsWith(kBuiltinMaterialPrefix);
}

bool IsBuiltinShaderPath(const Containers::String& path) {
    return path.StartsWith(kBuiltinShaderPrefix);
}

bool IsBuiltinTexturePath(const Containers::String& path) {
    return path.StartsWith(kBuiltinTexturePrefix);
}

const char* GetBuiltinPrimitiveDisplayName(BuiltinPrimitiveType primitiveType) {
    switch (primitiveType) {
        case BuiltinPrimitiveType::Cube: return "Cube";
        case BuiltinPrimitiveType::Sphere: return "Sphere";
        case BuiltinPrimitiveType::Capsule: return "Capsule";
        case BuiltinPrimitiveType::Cylinder: return "Cylinder";
        case BuiltinPrimitiveType::Plane: return "Plane";
        case BuiltinPrimitiveType::Quad: return "Quad";
        default: return "Primitive";
    }
}

Containers::String GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType primitiveType) {
    switch (primitiveType) {
        case BuiltinPrimitiveType::Cube: return Containers::String("builtin://meshes/cube");
        case BuiltinPrimitiveType::Sphere: return Containers::String("builtin://meshes/sphere");
        case BuiltinPrimitiveType::Capsule: return Containers::String("builtin://meshes/capsule");
        case BuiltinPrimitiveType::Cylinder: return Containers::String("builtin://meshes/cylinder");
        case BuiltinPrimitiveType::Plane: return Containers::String("builtin://meshes/plane");
        case BuiltinPrimitiveType::Quad: return Containers::String("builtin://meshes/quad");
        default: return Containers::String();
    }
}

Containers::String GetBuiltinDefaultPrimitiveMaterialPath() {
    return Containers::String(kBuiltinDefaultPrimitiveMaterialPath);
}

Containers::String GetBuiltinForwardLitShaderPath() {
    return Containers::String(kBuiltinForwardLitShaderPath);
}

Containers::String GetBuiltinDefaultPrimitiveTexturePath() {
    return Containers::String(kBuiltinDefaultPrimitiveTexturePath);
}

bool TryParseBuiltinPrimitiveType(const Containers::String& path, BuiltinPrimitiveType& outPrimitiveType) {
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Cube)) {
        outPrimitiveType = BuiltinPrimitiveType::Cube;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Sphere)) {
        outPrimitiveType = BuiltinPrimitiveType::Sphere;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Capsule)) {
        outPrimitiveType = BuiltinPrimitiveType::Capsule;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Cylinder)) {
        outPrimitiveType = BuiltinPrimitiveType::Cylinder;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Plane)) {
        outPrimitiveType = BuiltinPrimitiveType::Plane;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Quad)) {
        outPrimitiveType = BuiltinPrimitiveType::Quad;
        return true;
    }

    return false;
}

LoadResult CreateBuiltinMeshResource(const Containers::String& path) {
    BuiltinPrimitiveType primitiveType = BuiltinPrimitiveType::Cube;
    if (!TryParseBuiltinPrimitiveType(path, primitiveType)) {
        return LoadResult(Containers::String("Unknown builtin mesh: ") + path);
    }

    MeshBuffers buffers;
    switch (primitiveType) {
        case BuiltinPrimitiveType::Cube:
            buffers = CreateCubeMeshBuffers();
            break;
        case BuiltinPrimitiveType::Sphere:
            buffers = CreateUvSphereMeshBuffers();
            break;
        case BuiltinPrimitiveType::Capsule:
            buffers = CreateCapsuleMeshBuffers();
            break;
        case BuiltinPrimitiveType::Cylinder:
            buffers = CreateCylinderMeshBuffers();
            break;
        case BuiltinPrimitiveType::Plane:
            buffers = CreatePlaneMeshBuffers();
            break;
        case BuiltinPrimitiveType::Quad:
            buffers = CreateQuadMeshBuffers();
            break;
        default:
            return LoadResult(Containers::String("Unsupported builtin mesh: ") + path);
    }

    FlipTriangleWinding(buffers);

    Mesh* mesh = BuildMeshResource(path, GetBuiltinPrimitiveDisplayName(primitiveType), std::move(buffers));
    if (mesh == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin mesh: ") + path);
    }

    return LoadResult(mesh);
}

LoadResult CreateBuiltinMaterialResource(const Containers::String& path) {
    if (path != GetBuiltinDefaultPrimitiveMaterialPath()) {
        return LoadResult(Containers::String("Unknown builtin material: ") + path);
    }

    Material* material = BuildDefaultPrimitiveMaterial(path);
    if (material == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin material: ") + path);
    }

    return LoadResult(material);
}

LoadResult CreateBuiltinShaderResource(const Containers::String& path) {
    if (path != GetBuiltinForwardLitShaderPath()) {
        return LoadResult(Containers::String("Unknown builtin shader: ") + path);
    }

    Shader* shader = BuildBuiltinForwardLitShader(path);
    if (shader == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin shader: ") + path);
    }

    return LoadResult(shader);
}

LoadResult CreateBuiltinTextureResource(const Containers::String& path) {
    if (path != GetBuiltinDefaultPrimitiveTexturePath()) {
        return LoadResult(Containers::String("Unknown builtin texture: ") + path);
    }

    Texture* texture = BuildDefaultPrimitiveTexture(path);
    if (texture == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin texture: ") + path);
    }

    return LoadResult(texture);
}

} // namespace Resources
} // namespace XCEngine