AssetLoader: expose GLTF texture sources from Document

Author: TheMostDiligent

AssetLoader/interface/GLTFLoader.hpp

@@ -769,6 +769,28 @@ struct DocumentLoadInfo
     bool DecodeImages = true;
 };
 
+/// Resolved texture source referenced by a GLTF texture.
+struct TextureSourceInfo
+{
+    /// Index in tinygltf::Model::textures.
+    Uint32 TextureIndex = 0;
+
+    /// Index in tinygltf::Model::images.
+    int ImageIndex = -1;
+
+    /// Index in tinygltf::Model::samplers.
+    int SamplerIndex = -1;
+
+    /// Resolved external image URI. Empty for embedded image data.
+    std::string URI;
+
+    /// Pointer to encoded image data for embedded buffer-view or data URI images.
+    const void* pData = nullptr;
+
+    /// Size of encoded image data in bytes.
+    Uint64 DataSize = 0;
+};
+
 /// Parsed GLTF document.
 class Document
 {
@@ -784,6 +806,16 @@ class Document
     const tinygltf::Model& GetModel() const noexcept;
     const std::string&     GetBaseDir() const noexcept;
 
+    /// Returns the number of textures in the document.
+    Uint32 GetTextureCount() const;
+
+    /// Resolves a GLTF texture to either an external URI or an embedded encoded-data span.
+    ///
+    /// Embedded buffer-view spans are owned by the document buffers. Embedded data URI
+    /// spans are owned by tinygltf::Image::image. In both cases the returned pointer
+    /// remains valid only while the document is alive and unchanged.
+    bool GetTextureSourceInfo(Uint32 TextureIndex, TextureSourceInfo& Source) const;
+
 private:
     std::string m_FileName;
     std::string m_BaseDir;

AssetLoader/src/GLTFLoader.cpp

@@ -905,6 +905,69 @@ int GetTextureImageIndex(const tinygltf::Model&   gltf_model,
     return DDSSource >= 0 ? DDSSource : gltf_tex.source;
 }
 
+Uint32 Document::GetTextureCount() const
+{
+    const tinygltf::Model& gltf_model = GetModel();
+    DEV_CHECK_ERR(gltf_model.textures.size() <= (std::numeric_limits<Uint32>::max)(),
+                  "Too many textures in GLTF document");
+    return static_cast<Uint32>(gltf_model.textures.size());
+}
+
+bool Document::GetTextureSourceInfo(Uint32 TextureIndex, TextureSourceInfo& Source) const
+{
+    const tinygltf::Model& gltf_model = GetModel();
+    if (TextureIndex >= gltf_model.textures.size())
+        return false;
+
+    const tinygltf::Texture& gltf_tex = gltf_model.textures[TextureIndex];
+    const int                ImageIdx = GetTextureImageIndex(gltf_model, gltf_tex);
+    if (ImageIdx < 0 || ImageIdx >= static_cast<int>(gltf_model.images.size()))
+        return false;
+
+    const tinygltf::Image& gltf_image = gltf_model.images[ImageIdx];
+
+    Source              = {};
+    Source.TextureIndex = TextureIndex;
+    Source.ImageIndex   = ImageIdx;
+    Source.SamplerIndex = gltf_tex.sampler;
+
+    if (gltf_image.bufferView >= 0)
+    {
+        if (gltf_image.bufferView >= static_cast<int>(gltf_model.bufferViews.size()))
+            return false;
+
+        const tinygltf::BufferView& BufferView = gltf_model.bufferViews[static_cast<size_t>(gltf_image.bufferView)];
+        if (BufferView.buffer < 0 || static_cast<size_t>(BufferView.buffer) >= gltf_model.buffers.size())
+            return false;
+
+        const tinygltf::Buffer& Buffer = gltf_model.buffers[static_cast<size_t>(BufferView.buffer)];
+        if (BufferView.byteOffset > Buffer.data.size() ||
+            BufferView.byteLength > Buffer.data.size() - BufferView.byteOffset)
+        {
+            return false;
+        }
+
+        Source.pData    = Buffer.data.data() + BufferView.byteOffset;
+        Source.DataSize = static_cast<Uint64>(BufferView.byteLength);
+        return true;
+    }
+
+    if (!gltf_image.image.empty())
+    {
+        Source.pData    = gltf_image.image.data();
+        Source.DataSize = static_cast<Uint64>(gltf_image.image.size());
+        return true;
+    }
+
+    if (!gltf_image.uri.empty())
+    {
+        Source.URI = GetImagePath(GetBaseDir(), gltf_image.uri);
+        return !Source.URI.empty();
+    }
+
+    return false;
+}
+
 struct GLTFTextureSource
 {
     Uint32 TextureIndex = 0;

Tests/DiligentToolsTest/src/GLTFLoaderTest.cpp

@@ -243,6 +243,17 @@ TEST(Tools_GLTFLoader, DocumentKeepsEmbeddedImageDataInBufferWhenDecodeImagesIsF
     EXPECT_EQ(std::vector<unsigned char>(BufferData.begin() + BufferView.byteOffset,
                                          BufferData.begin() + BufferView.byteOffset + BufferView.byteLength),
               (std::vector<unsigned char>{'D', 'D', 'S', ' '}));
+
+    EXPECT_EQ(Document.GetTextureCount(), 1u);
+
+    GLTF::TextureSourceInfo TextureSource;
+    ASSERT_TRUE(Document.GetTextureSourceInfo(0, TextureSource));
+    EXPECT_EQ(TextureSource.TextureIndex, 0u);
+    EXPECT_EQ(TextureSource.ImageIndex, 0);
+    EXPECT_EQ(TextureSource.SamplerIndex, -1);
+    EXPECT_TRUE(TextureSource.URI.empty());
+    EXPECT_EQ(TextureSource.pData, BufferData.data() + BufferView.byteOffset);
+    EXPECT_EQ(TextureSource.DataSize, BufferView.byteLength);
 }
 
 TEST(Tools_GLTFLoader, DocumentKeepsExternalImageUriWhenDecodeImagesIsFalse)
@@ -285,6 +296,17 @@ TEST(Tools_GLTFLoader, DocumentKeepsExternalImageUriWhenDecodeImagesIsFalse)
     EXPECT_EQ(Image.width, -1);
     EXPECT_EQ(Image.height, -1);
     EXPECT_FALSE(Files.WasRead("external.png"));
+
+    EXPECT_EQ(Document.GetTextureCount(), 1u);
+
+    GLTF::TextureSourceInfo TextureSource;
+    ASSERT_TRUE(Document.GetTextureSourceInfo(0, TextureSource));
+    EXPECT_EQ(TextureSource.TextureIndex, 0u);
+    EXPECT_EQ(TextureSource.ImageIndex, 0);
+    EXPECT_EQ(TextureSource.SamplerIndex, -1);
+    EXPECT_TRUE(HasSuffix(TextureSource.URI, "external.png"));
+    EXPECT_EQ(TextureSource.pData, nullptr);
+    EXPECT_EQ(TextureSource.DataSize, 0u);
 }
 
 TEST(Tools_GLTFLoader, DocumentCopiesDataUriImageBytesWhenDecodeImagesIsFalse)
@@ -326,6 +348,17 @@ TEST(Tools_GLTFLoader, DocumentCopiesDataUriImageBytesWhenDecodeImagesIsFalse)
     EXPECT_TRUE(Image.uri.empty());
     EXPECT_EQ(Image.image,
               (std::vector<unsigned char>{0x89u, 'P', 'N', 'G', '\r', '\n', 0x1Au, '\n'}));
+
+    EXPECT_EQ(Document.GetTextureCount(), 1u);
+
+    GLTF::TextureSourceInfo TextureSource;
+    ASSERT_TRUE(Document.GetTextureSourceInfo(0, TextureSource));
+    EXPECT_EQ(TextureSource.TextureIndex, 0u);
+    EXPECT_EQ(TextureSource.ImageIndex, 0);
+    EXPECT_EQ(TextureSource.SamplerIndex, -1);
+    EXPECT_TRUE(TextureSource.URI.empty());
+    EXPECT_EQ(TextureSource.pData, Image.image.data());
+    EXPECT_EQ(TextureSource.DataSize, Image.image.size());
 }
 
 } // namespace