Loading Models: Understanding glTF

void loadModel(const std::string& modelPath) {
    // Create a tinygltf loader
    tinygltf::Model gltfModel;
    tinygltf::TinyGLTF loader;
    std::string err, warn;

    // Detect file extension to determine which loader to use
    bool ret = false;
    std::string extension = modelPath.substr(modelPath.find_last_of(".") + 1);
    std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);

    if (extension == "glb") {
        ret = loader.LoadBinaryFromFile(&gltfModel, &err, &warn, modelPath);
    } else if (extension == "gltf") {
        ret = loader.LoadASCIIFromFile(&gltfModel, &err, &warn, modelPath);
    } else {
        err = "Unsupported file extension: " + extension + ". Expected .gltf or .glb";
    }

    // Handle errors and warnings
    if (!warn.empty()) {
        std::cout << "glTF warning: " << warn << std::endl;
    }
    if (!err.empty()) {
        std::cout << "glTF error: " << err << std::endl;
    }
    if (!ret) {
        throw std::runtime_error("Failed to load glTF model");
    }

    // Clear existing model data
    model = Model();

    // Process the loaded data (covered in the following sections)
}

// First, load all textures from the model
std::vector<Texture> textures;
for (size_t i = 0; i < gltfModel.textures.size(); i++) {
    const auto& texture = gltfModel.textures[i];
    const auto& image = gltfModel.images[texture.source];

    Texture tex;
    tex.name = image.name.empty() ? "texture_" + std::to_string(i) : image.name;

    // Check if the image is embedded as KTX2
    if (image.mimeType == "image/ktx2" && image.bufferView >= 0) {
        // Get the buffer view that contains the KTX2 data
        const auto& bufferView = gltfModel.bufferViews[image.bufferView];
        const auto& buffer = gltfModel.buffers[bufferView.buffer];

        // Extract the KTX2 data from the buffer
        const uint8_t* ktx2Data = buffer.data.data() + bufferView.byteOffset;
        size_t ktx2Size = bufferView.byteLength;

        // Load the KTX2 texture using KTX-Software library
        ktxTexture2* ktxTexture = nullptr;
        KTX_error_code result = ktxTexture2_CreateFromMemory(
            ktx2Data, ktx2Size,
            KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
            &ktxTexture
        );

        if (result != KTX_SUCCESS) {
            std::cerr << "Failed to load KTX2 texture: " << ktxErrorString(result) << std::endl;
            continue;
        }

        // If the texture uses Basis Universal compression, transcode it to a GPU-friendly format
        if (ktxTexture->isCompressed && ktxTexture2_NeedsTranscoding(ktxTexture)) {
            // Choose the appropriate format based on GPU capabilities
            ktx_transcode_fmt_e transcodeFmt = KTX_TTF_BC7_RGBA;

            // For devices that don't support BC7, use alternatives
            // if (!deviceSupportsBC7) {
            //     transcodeFmt = KTX_TTF_ASTC_4x4_RGBA;
            // }
            // if (!deviceSupportsASTC) {
            //     transcodeFmt = KTX_TTF_ETC2_RGBA;
            // }

            // Transcode the texture
            result = ktxTexture2_TranscodeBasis(ktxTexture, transcodeFmt, 0);
            if (result != KTX_SUCCESS) {
                std::cerr << "Failed to transcode KTX2 texture: " << ktxErrorString(result) << std::endl;
                ktxTexture2_Destroy(ktxTexture);
                continue;
            }
        }

        // Create Vulkan image, memory, and view
        vk::Format format = static_cast<vk::Format>(ktxTexture2_GetVkFormat(ktxTexture));
        vk::Extent3D extent{
            static_cast<uint32_t>(ktxTexture->baseWidth),
            static_cast<uint32_t>(ktxTexture->baseHeight),
            static_cast<uint32_t>(ktxTexture->baseDepth)
        };
        uint32_t mipLevels = ktxTexture->numLevels;

        // Create the Vulkan image
        vk::ImageCreateInfo imageCreateInfo{
            .imageType = vk::ImageType::e2D,
            .format = format,
            .extent = extent,
            .mipLevels = mipLevels,
            .arrayLayers = 1,
            .samples = vk::SampleCountFlagBits::e1,
            .tiling = vk::ImageTiling::eOptimal,
            .usage = vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eTransferDst,
            .sharingMode = vk::SharingMode::eExclusive,
            .initialLayout = vk::ImageLayout::eUndefined
        };

        // Create the image, allocate memory, and bind them
        // ... (code omitted for brevity)

        // Upload the texture data to the image
        ktxTexture2_VkUploadEx(ktxTexture, &ktxVulkanTexture, &vkDevice, &vkQueue,
                              &ktxVulkanDeviceMemory, &ktxVulkanImage,
                              &ktxVulkanImageView, &ktxVulkanImageLayout,
                              &ktxVulkanImageMemory);

        // Store the Vulkan resources in our texture object
        tex.image = ktxVulkanImage;
        tex.imageView = ktxVulkanImageView;
        tex.memory = ktxVulkanImageMemory;

        // Clean up KTX resources
        ktxTexture2_Destroy(ktxTexture);
    } else {
        // Handle other image formats or external references
        // ... (code omitted for brevity)
    }

    // Create a sampler for the texture
    VkSamplerCreateInfo samplerInfo = {};
    // ... (code omitted for brevity)

    textures.push_back(tex);
}

// Now load materials and associate them with textures
for (const auto& material : gltfModel.materials) {
    Material mat;

    // Base color
    if (material.pbrMetallicRoughness.baseColorFactor.size() == 4) {
        mat.baseColorFactor.r = material.pbrMetallicRoughness.baseColorFactor[0];
        mat.baseColorFactor.g = material.pbrMetallicRoughness.baseColorFactor[1];
        mat.baseColorFactor.b = material.pbrMetallicRoughness.baseColorFactor[2];
        mat.baseColorFactor.a = material.pbrMetallicRoughness.baseColorFactor[3];
    }

    // Metallic and roughness factors
    mat.metallicFactor = material.pbrMetallicRoughness.metallicFactor;
    mat.roughnessFactor = material.pbrMetallicRoughness.roughnessFactor;

    // Associate textures with the material
    if (material.pbrMetallicRoughness.baseColorTexture.index >= 0) {
        const auto& texture = gltfModel.textures[material.pbrMetallicRoughness.baseColorTexture.index];
        mat.baseColorTexture = &textures[texture.source];
    }

    if (material.pbrMetallicRoughness.metallicRoughnessTexture.index >= 0) {
        const auto& texture = gltfModel.textures[material.pbrMetallicRoughness.metallicRoughnessTexture.index];
        mat.metallicRoughnessTexture = &textures[texture.source];
    }

    if (material.normalTexture.index >= 0) {
        const auto& texture = gltfModel.textures[material.normalTexture.index];
        mat.normalTexture = &textures[texture.source];
    }

    if (material.occlusionTexture.index >= 0) {
        const auto& texture = gltfModel.textures[material.occlusionTexture.index];
        mat.occlusionTexture = &textures[texture.source];
    }

    if (material.emissiveTexture.index >= 0) {
        const auto& texture = gltfModel.textures[material.emissiveTexture.index];
        mat.emissiveTexture = &textures[texture.source];
    }

    model.materials.push_back(mat);
}