Load single pixel textures

Author: Nelarius

src/common/gltf_model.cpp

@@ -1,7 +1,6 @@
 #include "assert.hpp"
 #include "gltf_model.hpp"
 #include "texture.hpp"
-#include "vector_set.hpp"
 
 #include <cgltf.h>
 #include <fmt/core.h>
@@ -12,6 +11,7 @@
 #include <stb_image.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <filesystem>
@@ -70,6 +70,195 @@ void traverseNodeHierarchy(
         }
     }
 }
+
+Texture textureFromGltfImage(const cgltf_image* const image, const fs::path& gltfPath)
+{
+    if (image->buffer_view)
+    {
+        const auto pixelData = [image]() -> std::span<const std::uint8_t> {
+            // NOTE: cgltf_buffer_view_data used as a reference for this function
+            const cgltf_buffer_view* const bufferView = image->buffer_view;
+            NLRS_ASSERT(bufferView != nullptr);
+            const std::size_t byteLength = bufferView->size;
+
+            // See cgltf_buffer_view::data comment, overrides buffer->data if
+            // present
+            if (bufferView->data != nullptr)
+            {
+                const std::uint8_t* const bufferPtr =
+                    static_cast<const std::uint8_t*>(bufferView->data);
+                return std::span(bufferPtr, byteLength);
+            }
+
+            NLRS_ASSERT(bufferView->buffer != nullptr);
+            const std::size_t         bufferOffset = bufferView->offset;
+            const std::uint8_t* const bufferPtr =
+                static_cast<const std::uint8_t*>(bufferView->buffer->data);
+
+            return std::span(bufferPtr + bufferOffset, byteLength);
+        }();
+        return Texture::fromMemory(pixelData);
+    }
+    else
+    {
+        NLRS_ASSERT(image->uri);
+        const fs::path imagePath = gltfPath.parent_path() / image->uri;
+        if (!fs::exists(imagePath))
+        {
+            throw std::runtime_error(
+                fmt::format("The image {} does not exist.", imagePath.string()));
+        }
+
+        const std::size_t fileSize = static_cast<std::size_t>(fs::file_size(imagePath));
+        NLRS_ASSERT(fileSize > 0);
+        std::ifstream file(imagePath, std::ios::binary);
+        NLRS_ASSERT(file.is_open());
+
+        std::vector<std::uint8_t> fileData(fileSize, 0);
+        file.read(reinterpret_cast<char*>(fileData.data()), fileSize);
+        return Texture::fromMemory(std::span<const std::uint8_t>(fileData));
+    }
+}
+
+std::uint32_t fnv1a(const void* data, std::size_t size)
+{
+    const std::uint32_t  fnvPrime = 16777619;
+    const std::uint32_t  fnvOffsetBasis = 2166136261;
+    const unsigned char* ptr = static_cast<const unsigned char*>(data);
+    std::uint32_t        hash = fnvOffsetBasis;
+    for (std::size_t i = 0; i < size; ++i)
+    {
+        hash ^= ptr[i];
+        hash *= fnvPrime;
+    }
+    return hash;
+}
+
+template<std::size_t N>
+std::uint32_t fnv1a(const float (&data)[N])
+{
+    return fnv1a(data, N * sizeof(float));
+}
+
+class BaseColorTextureBuilder
+{
+public:
+    BaseColorTextureBuilder(const fs::path gltfPath, const std::span<const cgltf_image> gltfImages)
+        : mGltfPath(gltfPath),
+          mImages(gltfImages),
+          mTextures(),
+          mImageLookups(),
+          mBaseColorFactorLookups(),
+          mMeshTextureIndices()
+    {
+    }
+    ~BaseColorTextureBuilder() = default;
+
+    BaseColorTextureBuilder(const BaseColorTextureBuilder&) = delete;
+    BaseColorTextureBuilder& operator=(const BaseColorTextureBuilder&) = delete;
+
+    BaseColorTextureBuilder(BaseColorTextureBuilder&&) = delete;
+    BaseColorTextureBuilder& operator=(BaseColorTextureBuilder&&) = delete;
+
+    std::tuple<std::vector<std::size_t>, std::vector<Texture>> build()
+    {
+        mImageLookups.clear();
+        mBaseColorFactorLookups.clear();
+        return std::make_tuple(std::move(mMeshTextureIndices), std::move(mTextures));
+    }
+
+    void addBaseColor(const cgltf_pbr_metallic_roughness& pbrMetallicRoughness)
+    {
+        NLRS_ASSERT(pbrMetallicRoughness.base_color_texture.texcoord == 0);
+        NLRS_ASSERT(pbrMetallicRoughness.base_color_texture.has_transform == false);
+
+        const std::size_t textureIdx = [&pbrMetallicRoughness, this]() -> std::size_t {
+            if (pbrMetallicRoughness.base_color_texture.texture != nullptr)
+            {
+                const cgltf_texture& baseColorTexture =
+                    *pbrMetallicRoughness.base_color_texture.texture;
+                // Look up OpenGL texture wrap modes:
+                // https://registry.khronos.org/OpenGL/api/GL/glcorearb.h
+                // GL_REPEAT: 10497
+                // GL_MIRRORED_REPEAT: 33648
+                // GL_CLAMP_TO_EDGE: 33071
+                // GL_CLAMP_TO_BORDER: 33069
+                NLRS_ASSERT(baseColorTexture.sampler->wrap_s == 10497);
+                NLRS_ASSERT(baseColorTexture.sampler->wrap_t == 10497);
+                NLRS_ASSERT(baseColorTexture.image);
+
+                const cgltf_image* const baseColorImage = baseColorTexture.image;
+                const auto               distance = std::distance(mImages.data(), baseColorImage);
+                NLRS_ASSERT(distance >= 0);
+                const std::size_t imageIndex = static_cast<std::size_t>(distance);
+                NLRS_ASSERT(imageIndex < mImages.size());
+                const auto imageLookup = std::find_if(
+                    mImageLookups.begin(),
+                    mImageLookups.end(),
+                    [imageIndex](const ImageLookup& lookup) -> bool {
+                        return lookup.gltfImageIndex == imageIndex;
+                    });
+                if (imageLookup == mImageLookups.end())
+                {
+                    const std::size_t textureIdx = mTextures.size();
+                    mImageLookups.push_back({imageIndex, textureIdx});
+                    mTextures.emplace_back(textureFromGltfImage(baseColorImage, mGltfPath));
+                    return textureIdx;
+                }
+                else
+                {
+                    return imageLookup->textureIndex;
+                }
+            }
+            else
+            {
+                const std::uint32_t hash = fnv1a(pbrMetallicRoughness.base_color_factor);
+                const auto          colorLookup = std::find_if(
+                    mBaseColorFactorLookups.begin(),
+                    mBaseColorFactorLookups.end(),
+                    [hash](const BaseColorFactorLookup& lookup) -> bool {
+                        return lookup.hash == hash;
+                    });
+                if (colorLookup == mBaseColorFactorLookups.end())
+                {
+                    const std::size_t textureIdx = mTextures.size();
+                    mBaseColorFactorLookups.push_back({hash, textureIdx});
+
+                    const float r = pbrMetallicRoughness.base_color_factor[0];
+                    const float g = pbrMetallicRoughness.base_color_factor[1];
+                    const float b = pbrMetallicRoughness.base_color_factor[2];
+                    const float a = pbrMetallicRoughness.base_color_factor[3];
+                    mTextures.emplace_back(Texture::fromPixel(r, g, b, a));
+                    return textureIdx;
+                }
+                else
+                {
+                    return colorLookup->textureIndex;
+                }
+            }
+        }();
+        mMeshTextureIndices.push_back(textureIdx);
+    }
+
+private:
+    struct ImageLookup
+    {
+        std::size_t gltfImageIndex;
+        std::size_t textureIndex;
+    };
+
+    struct BaseColorFactorLookup
+    {
+        std::uint32_t hash;
+        std::size_t   textureIndex;
+    };
+    fs::path                           mGltfPath;
+    std::span<const cgltf_image>       mImages;
+    std::vector<Texture>               mTextures;
+    std::vector<ImageLookup>           mImageLookups;
+    std::vector<BaseColorFactorLookup> mBaseColorFactorLookups;
+    std::vector<std::size_t>           mMeshTextureIndices;
+};
 } // namespace
 
 GltfModel::GltfModel(const fs::path gltfPath)
@@ -121,8 +310,9 @@ GltfModel::GltfModel(const fs::path gltfPath)
     std::vector<std::vector<glm::vec3>>     meshNormals;
     std::vector<std::vector<glm::vec2>>     meshTexCoords;
     std::vector<std::vector<std::uint32_t>> meshIndices;
-    std::vector<const cgltf_image*>         meshBaseColorImageAttributes;
-    VectorSet<const cgltf_image*>           uniqueBaseColorImages;
+
+    BaseColorTextureBuilder baseColorTextureBuilder{
+        gltfPath, std::span<const cgltf_image>(data->images, data->images_count)};
 
     const std::size_t meshCount = data->meshes_count;
     for (std::size_t meshIdx = 0; meshIdx < meshCount; ++meshIdx)
@@ -139,25 +329,7 @@ GltfModel::GltfModel(const fs::path gltfPath)
                 NLRS_ASSERT(primitive.material->has_pbr_metallic_roughness);
                 const cgltf_pbr_metallic_roughness& pbrMetallicRoughness =
                     primitive.material->pbr_metallic_roughness;
-
-                NLRS_ASSERT(pbrMetallicRoughness.base_color_texture.texcoord == 0);
-                NLRS_ASSERT(pbrMetallicRoughness.base_color_texture.scale == 1.f);
-                NLRS_ASSERT(pbrMetallicRoughness.base_color_texture.texture);
-
-                const cgltf_texture& baseColorTexture =
-                    *pbrMetallicRoughness.base_color_texture.texture;
-                // Look up OpenGL texture wrap modes:
-                // https://registry.khronos.org/OpenGL/api/GL/glcorearb.h
-                // GL_REPEAT: 10497
-                // GL_MIRRORED_REPEAT: 33648
-                // GL_CLAMP_TO_EDGE: 33071
-                // GL_CLAMP_TO_BORDER: 33069
-                NLRS_ASSERT(baseColorTexture.sampler->wrap_s == 10497);
-                NLRS_ASSERT(baseColorTexture.sampler->wrap_t == 10497);
-                NLRS_ASSERT(baseColorTexture.image);
-                const cgltf_image* const baseColorImage = baseColorTexture.image;
-                meshBaseColorImageAttributes.push_back(baseColorImage);
-                uniqueBaseColorImages.insert(baseColorImage);
+                baseColorTextureBuilder.addBaseColor(pbrMetallicRoughness);
             }
 
             // Indices
@@ -265,81 +437,13 @@ GltfModel::GltfModel(const fs::path gltfPath)
         }
     }
 
-    // Mesh texture indices
-
-    NLRS_ASSERT(meshPositions.size() == meshBaseColorImageAttributes.size());
-    std::vector<std::uint32_t> meshBaseColorTextureIndices;
-    meshBaseColorTextureIndices.reserve(meshBaseColorImageAttributes.size());
-    std::transform(
-        meshBaseColorImageAttributes.begin(),
-        meshBaseColorImageAttributes.end(),
-        std::back_inserter(meshBaseColorTextureIndices),
-        [&](const cgltf_image* image) -> std::uint32_t {
-            const auto imageIter = uniqueBaseColorImages.find(image);
-            NLRS_ASSERT(imageIter != uniqueBaseColorImages.end());
-            const auto distance = std::distance(uniqueBaseColorImages.begin(), imageIter);
-            NLRS_ASSERT(distance >= 0);
-            const auto textureIdx = static_cast<std::uint32_t>(distance);
-            NLRS_ASSERT(textureIdx < meshBaseColorImageAttributes.size());
-            return textureIdx;
-        });
-
-    // Model textures
-
-    auto bufferViewData =
-        [](const cgltf_buffer_view* const bufferView) -> std::span<const std::uint8_t> {
-        // NOTE: cgltf_buffer_view_data used as a reference for this function
-        NLRS_ASSERT(bufferView != nullptr);
-        const std::size_t byteLength = bufferView->size;
-
-        // See cgltf_buffer_view::data comment, overrides buffer->data if present
-        if (bufferView->data != nullptr)
-        {
-            const std::uint8_t* const bufferPtr =
-                static_cast<const std::uint8_t*>(bufferView->data);
-            return std::span(bufferPtr, byteLength);
-        }
-
-        NLRS_ASSERT(bufferView->buffer != nullptr);
-        const std::size_t         bufferOffset = bufferView->offset;
-        const std::uint8_t* const bufferPtr =
-            static_cast<const std::uint8_t*>(bufferView->buffer->data);
-
-        return std::span(bufferPtr + bufferOffset, byteLength);
-    };
-
-    baseColorTextures.reserve(uniqueBaseColorImages.size());
-    std::transform(
-        uniqueBaseColorImages.begin(),
-        uniqueBaseColorImages.end(),
-        std::back_inserter(baseColorTextures),
-        [&](const cgltf_image* image) -> Texture {
-            if (image->buffer_view)
-            {
-                const auto pixelData = bufferViewData(image->buffer_view);
-                return Texture::fromMemory(pixelData);
-            }
-            else
-            {
-                NLRS_ASSERT(image->uri);
-                const fs::path imagePath = gltfPath.parent_path() / image->uri;
-                if (!fs::exists(imagePath))
-                {
-                    throw std::runtime_error(
-                        fmt::format("The image {} does not exist.", imagePath.string()));
-                }
-
-                const std::size_t fileSize = static_cast<std::size_t>(fs::file_size(imagePath));
-                NLRS_ASSERT(fileSize > 0);
-                std::ifstream file(imagePath, std::ios::binary);
-                NLRS_ASSERT(file.is_open());
-
-                std::vector<std::uint8_t> fileData(fileSize, 0);
-                file.read(reinterpret_cast<char*>(fileData.data()), fileSize);
-                return Texture::fromMemory(std::span(fileData));
-            }
-        });
+    auto [meshBaseColorTextureIndices, textures] = baseColorTextureBuilder.build();
+    baseColorTextures = std::move(textures);
 
+    NLRS_ASSERT(meshPositions.size() == meshNormals.size());
+    NLRS_ASSERT(meshPositions.size() == meshTexCoords.size());
+    NLRS_ASSERT(meshPositions.size() == meshIndices.size());
+    NLRS_ASSERT(meshPositions.size() == meshBaseColorTextureIndices.size());
     meshes.reserve(meshPositions.size());
     for (std::size_t i = 0; i < meshPositions.size(); ++i)
     {

src/common/texture.cpp

@@ -52,4 +52,15 @@ Texture Texture::fromMemory(std::span<const std::uint8_t> data)
         std::move(pixels),
         Dimensions{static_cast<std::uint32_t>(width), static_cast<std::uint32_t>(height)});
 }
+
+Texture Texture::fromPixel(float r, float g, float b, float a)
+{
+    const std::uint32_t r8 = static_cast<std::uint32_t>(r * 255.0f);
+    const std::uint32_t g8 = static_cast<std::uint32_t>(g * 255.0f);
+    const std::uint32_t b8 = static_cast<std::uint32_t>(b * 255.0f);
+    const std::uint32_t a8 = static_cast<std::uint32_t>(a * 255.0f);
+
+    return Texture(
+        std::vector<BgraPixel>{b8 | (g8 << 8) | (r8 << 16) | (a8 << 24)}, Dimensions{1, 1});
+}
 } // namespace nlrs

src/common/texture.hpp

@@ -39,6 +39,7 @@ class Texture
 
     // `data` is expected to be in RGBA or RGB format, with each component 8 bits.
     static Texture fromMemory(std::span<const std::uint8_t> data);
+    static Texture fromPixel(float r, float g, float b, float a);
 
 private:
     std::vector<BgraPixel> mPixels;