Bulk update: glTF animation pointers, volumetrics, and embedded GPU formats; nv_ktx 1.1.0; direct lighting PDFs; staging upload of > 4 GiB buffers; and more.

* Embedded .DDS/.KTX images inside .glb files can now be loaded.

* nv_ktx v1.1.0 adds a readFromMemory() API.

* Image loading inside nvvkgltf is now faster; embedded image loading is parallelized, and sorting the order so larger images are loaded first helps on files with lots of images.

* glTF KHR_animation_pointer support in nvvkgltf.

* singleLightContribution() now returns the PDF for light sampling (for direct lighting MIS). LightContrib::halfAngularSize has also been removed; none of our samples used this.

* Henyey-Greenstein volume scattering support in nvvkgltf and bsdf_functions.h.slang.

* nvvk::StagingUploader now supports nvvk::LargeBuffers, which use sparse binding for buffers larger than 4 GiB.

* In nvvk::GBuffer, depth textures are now created with VK_IMAGE_USAGE_STORAGE_BIT so ray-gen shaders can read/write them.

* Fixes the meshopt_decode*Version checks inside nvvkgltf/scene.cpp.

* Performance improvement for nvutils::loadFile() by avoiding an intermediate std::vector.

Co-authored-by: Martin-Karl Lefrancois <mlefrancois@nvidia.com>

Co-authored-by: Jean-Eudes Marvie <jmarvie@nvidia.com>

Script sync from SHA: f4e1a1c0ca9aeaba5ca1c18a041ac31a4be9a08e

Author: NBickford-NV

nvimageformats/nv_ktx.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2025, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2021-2026, NVIDIA CORPORATION.  All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -24,6 +24,7 @@
 #include <atomic>
 #include <cassert>  // Some functions produce assertion errors to assist with debugging when NDEBUG is false.
 #include <fstream>
+#include <limits>
 #include <mutex>
 #include <sstream>
 #include <string.h>  // memcpy
@@ -85,6 +86,99 @@ bool GetNumSubresources(size_t a, size_t b, size_t c, size_t& out)
 {
   return checked_math::mul3(std::max(a, size_t(1)), std::max(b, size_t(1)), std::max(c, size_t(1)), out);
 }
+
+// Supports an std::istream interface that operates on an in-memory array.
+// Same as in nv_dds.cpp.
+class MemoryStreamBuffer : public std::basic_streambuf<char>
+{
+  char*           m_data        = nullptr;
+  std::streamoff  m_nextIndex   = 0;  // Always in [0, m_sizeInBytes].
+  std::streamsize m_sizeInBytes = 0;
+
+public:
+  MemoryStreamBuffer(char* data, std::streamsize sizeInBytes)
+      : m_data(data)
+      , m_sizeInBytes(sizeInBytes)
+  {
+  }
+  pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override
+  {
+    const pos_type indicatesError = pos_type(static_cast<off_type>(-1));
+    switch(dir)
+    {
+      case std::ios_base::beg:
+        if(off < 0 || off > m_sizeInBytes)
+          return indicatesError;
+        m_nextIndex = off;
+        break;
+      case std::ios_base::cur:
+        if(((off < 0) && m_nextIndex + off < 0) || (off >= 0 && off > m_sizeInBytes - m_nextIndex))
+          return indicatesError;
+        m_nextIndex += off;
+        break;
+      case std::ios_base::end:
+        if(off > 0 || off < -m_sizeInBytes)
+          return indicatesError;
+        m_nextIndex = m_sizeInBytes + off;
+        break;
+      default:
+        return indicatesError;
+    }
+    return m_nextIndex;
+  }
+  pos_type seekpos(pos_type pos, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override
+  {
+    return seekoff(static_cast<off_type>(pos), std::ios_base::beg, which);
+  }
+  // Gets the number of characters certainly available.
+  std::streamsize showmanyc() override { return m_sizeInBytes - m_nextIndex; }
+  // Gets the next character advancing the read pointer; EOF on error.
+  int_type uflow() override
+  {
+    if(m_nextIndex < m_sizeInBytes)
+    {
+      return traits_type::to_int_type(m_data[m_nextIndex++]);
+    }
+    return traits_type::eof();
+  }
+  // Gets the next character without advancing the read pointer; EOF on error.
+  int_type underflow() override
+  {
+    if(m_nextIndex < m_sizeInBytes)
+    {
+      return traits_type::to_int_type(m_data[m_nextIndex]);
+    }
+    return traits_type::eof();
+  }
+  // Reads a given number of characters and stores them into s' character array.
+  // Returns the number of characters successfully read.
+  std::streamsize xsgetn(char_type* s, std::streamsize count) override
+  {
+    if(count < 0 || s == nullptr || m_nextIndex >= m_sizeInBytes)
+    {
+      return 0;
+    }
+    const std::streamsize readableChars = std::min(count, m_sizeInBytes - m_nextIndex);
+    memcpy(s, m_data + m_nextIndex, readableChars);
+    m_nextIndex += readableChars;
+    return readableChars;
+  }
+};
+
+// An std::istream interface for a constant, in-memory array.
+// Note that Clang emits a Wreorder-ctor warning unless the memory buffer
+// members are listed before the istream, so we use multiple inheritance
+// here to put them in the right order.
+class MemoryStream : private MemoryStreamBuffer, public std::istream
+{
+public:
+  MemoryStream(const char* data, std::streamsize sizeInBytes)
+      : MemoryStreamBuffer(const_cast<char*>(data), sizeInBytes)
+      , std::istream(this)
+  {
+    rdbuf(this);
+  }
+};
 }  // namespace
 
 ErrorWithText KTXImage::allocate(uint32_t _num_mips, uint32_t _num_layers, uint32_t _num_faces)
@@ -2911,7 +3005,7 @@ ErrorWithText KTXImage::writeKTX2Stream(std::ostream& output, const WriteSetting
   // Fill in the KTXwriter field if it's not already assigned.
   if(key_value_data.find("KTXwriter") == key_value_data.end())
   {
-    key_value_data["KTXwriter"] = StringToCharVector("nvpro-samples' nv_ktx version 1.0.1");
+    key_value_data["KTXwriter"] = StringToCharVector("nvpro-samples' nv_ktx version 1.1.0");
   }
 
   // We now know the offset of the key/value data.
@@ -3203,6 +3297,16 @@ ErrorWithText KTXImage::readFromFile(const char* filename, const ReadSettings& r
   return readFromStream(input_stream, readSettings);
 }
 
+ErrorWithText KTXImage::readFromMemory(const char* buffer, size_t bufferSize, const ReadSettings& readSettings)
+{
+  if(bufferSize > static_cast<size_t>(std::numeric_limits<std::streamsize>::max()))
+  {
+    return "The `bufferSize` parameter was too large to be stored in an std::streamsize.";
+  }
+  MemoryStream stream(buffer, static_cast<std::streamsize>(bufferSize));
+  return readFromStream(stream, readSettings);
+}
+
 }  // namespace nv_ktx
 
 //-----------------------------------------------------------------------------

nvimageformats/nv_ktx.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2025, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2021-2026, NVIDIA CORPORATION.  All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
 /*-----------------------------------------------------------------------------
  
-nv_ktx 1.0.1
+nv_ktx 1.1.0
 
 This is a mostly self-contained reader and writer for KTX2 files and reader
 for KTX1 files. It only relies on Vulkan (for KTX2), GL (for KTX1), and the
@@ -209,6 +209,11 @@ struct KTXImage
   ErrorWithText readFromFile(const char*         filename,       // The .ktx or .ktx2 file to read from.
                              const ReadSettings& readSettings);  // Settings for the reader
 
+  // Wrapper for readFromStream for a buffer in memory.
+  ErrorWithText readFromMemory(const char*         buffer,         // The buffer in memory.
+                               size_t              bufferSize,     // Its length in bytes.
+                               const ReadSettings& readSettings);  // Settings for the reader.
+
   // Writes this structure in KTX2 format to a stream.
   ErrorWithText writeKTX2Stream(std::ostream&        output,  // The output stream, at the point to start writing
                                 const WriteSettings& writeSettings);  // Settings for the writer

nvshaders/bsdf_functions.h.slang

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2025, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2019-2026, NVIDIA CORPORATION.  All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -117,6 +117,80 @@ float3 absorptionCoefficient(PbrMaterial mat)
   return -log(max(mat.attenuationColor, float3(0.001))) / max(mat.attenuationDistance, 0.001);
 }
 
+/*-------------------------------------------------------------------------------------------------
+# Function `henyeyGreenstein`
+> Henyey-Greenstein phase function for volumetric scattering.
+
+Parameters:
+- cosTheta: cosine of the angle between incident and scattered directions
+- g: anisotropy parameter in (-1, 1). g > 0 = forward scatter, g < 0 = back scatter, g = 0 = isotropic
+Returns the phase function value (probability density).
+Ref: https://www.pbr-book.org/4ed/Volume_Scattering/Phase_Functions#TheHenyeyndashGreensteinPhaseFunction
+-------------------------------------------------------------------------------------------------*/
+float henyeyGreenstein(float cosTheta, float g)
+{
+  float g2    = g * g;
+  float denom = 1.0 + g2 - 2.0 * g * cosTheta;
+  return M_1_PI * 0.25 * (1.0 - g2) / (denom * sqrt(denom));
+}
+
+/*-------------------------------------------------------------------------------------------------
+# Function `sampleHenyeyGreenstein`
+> Samples a direction from the Henyey-Greenstein phase function distribution.
+
+Parameters:
+- xi: two random numbers in [0,1]
+- g: anisotropy parameter in (-1, 1)
+- wi: normalized incident direction (the direction light/ray is traveling)
+
+Returns the sampled scattered direction.
+For forward scattering (g > 0), result tends to align with wi (continue forward).
+For back scattering (g < 0), result tends to point opposite to wi (bounce back).
+Ref: https://www.pbr-book.org/4ed/Volume_Scattering/Phase_Functions#TheHenyeyndashGreensteinPhaseFunction
+-------------------------------------------------------------------------------------------------*/
+float3 sampleHenyeyGreenstein(float2 xi, float g, float3 wi)
+{
+  float cosTheta;
+  if(abs(g) < 0.001)
+  {
+    // Isotropic scattering
+    cosTheta = 1.0 - 2.0 * xi.x;
+  }
+  else
+  {
+    float t  = (1.0 - g * g) / (1.0 - g + 2.0 * g * xi.x);
+    cosTheta = (1.0 + g * g - t * t) / (2.0 * g);
+  }
+
+  float sinTheta = sqrt(max(0.0, 1.0 - cosTheta * cosTheta));
+  float phi      = 2.0 * M_PI * xi.y;
+
+  // Build orthonormal basis around wi (the direction light is traveling)
+  // For forward scattering (g > 0), result will be close to wi
+  float3 u, v;
+  orthonormalBasis(wi, u, v);
+
+  // Convert spherical to Cartesian in the local frame
+  return sinTheta * cos(phi) * u + sinTheta * sin(phi) * v + cosTheta * wi;
+}
+
+/*-------------------------------------------------------------------------------------------------
+# Function `henyeyGreensteinPdf`
+> Returns the PDF for sampling a direction using the Henyey-Greenstein phase function.
+
+This is the same as henyeyGreenstein() since sampleHenyeyGreenstein() does perfect sampling and 
+henyeyGreenstein() is already normalized.
+-------------------------------------------------------------------------------------------------*/
+float henyeyGreensteinPdf(float cosTheta, float g)
+{
+  float pdf = henyeyGreenstein(cosTheta, g);
+  // Near |g| = 1, HG approaches a delta distribution; 
+  // catch numerical edge cases (0, NaN, inf) to avoid division by zero or NaN.
+  if(pdf == 0.0f || isnan(pdf) || isinf(pdf))
+     pdf = DIRAC;
+  return pdf;
+}
+
 /*-------------------------------------------------------------------------------------------------
 # `LOBE_*` Defines
 > Indices for lobe weights returned by `computeLobeWeights()`.

nvshaders/gltf_scene_io.h.slang

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2025, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2022-2026, NVIDIA CORPORATION.  All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -150,31 +150,34 @@ struct GltfShadeMaterial
   float3 diffuseTransmissionColor;   // offset 192  - 12 bytes
   float  diffuseTransmissionFactor;  // offset 204  - 4 bytes
 
-  int doubleSided;  // offset 208  - 4 bytes
+  float3 multiscatterColor;   // offset 208  - 12 bytes  // KHR_materials_volume_scatter
+  float  scatterAnisotropy;   // offset 220  - 4 bytes   // KHR_materials_volume_scatter
+
+  int doubleSided;  // offset 224  - 4 bytes
   // Texture infos (uint16_t, 2 bytes each)
-  uint16_t pbrBaseColorTexture;              // offset 212  - 2 bytes
-  uint16_t normalTexture;                    // offset 214  - 2 bytes
-  uint16_t pbrMetallicRoughnessTexture;      // offset 216  - 2 bytes
-  uint16_t emissiveTexture;                  // offset 218  - 2 bytes
-  uint16_t transmissionTexture;              // offset 220  - 2 bytes
-  uint16_t thicknessTexture;                 // offset 222  - 2 bytes
-  uint16_t clearcoatTexture;                 // offset 224  - 2 bytes
-  uint16_t clearcoatRoughnessTexture;        // offset 226  - 2 bytes
-  uint16_t clearcoatNormalTexture;           // offset 228  - 2 bytes
-  uint16_t specularTexture;                  // offset 230  - 2 bytes
-  uint16_t specularColorTexture;             // offset 232  - 2 bytes
-  uint16_t iridescenceTexture;               // offset 234  - 2 bytes
-  uint16_t iridescenceThicknessTexture;      // offset 236  - 2 bytes
-  uint16_t anisotropyTexture;                // offset 238  - 2 bytes
-  uint16_t sheenColorTexture;                // offset 240  - 2 bytes
-  uint16_t sheenRoughnessTexture;            // offset 242  - 2 bytes
-  uint16_t occlusionTexture;                 // offset 244  - 2 bytes
-  uint16_t pbrDiffuseTexture;                // offset 246  - 2 bytes
-  uint16_t pbrSpecularGlossinessTexture;     // offset 248  - 2 bytes
-  uint16_t diffuseTransmissionTexture;       // offset 250  - 2 bytes
-  uint16_t diffuseTransmissionColorTexture;  // offset 252  - 2 bytes
-  uint16_t _pad1;                            // offset 254  - 2 bytes
-  // Total size: 256 bytes
+  uint16_t pbrBaseColorTexture;              // offset 228  - 2 bytes
+  uint16_t normalTexture;                    // offset 230  - 2 bytes
+  uint16_t pbrMetallicRoughnessTexture;      // offset 232  - 2 bytes
+  uint16_t emissiveTexture;                  // offset 234  - 2 bytes
+  uint16_t transmissionTexture;              // offset 236  - 2 bytes
+  uint16_t thicknessTexture;                 // offset 238  - 2 bytes
+  uint16_t clearcoatTexture;                 // offset 240  - 2 bytes
+  uint16_t clearcoatRoughnessTexture;        // offset 242  - 2 bytes
+  uint16_t clearcoatNormalTexture;           // offset 244  - 2 bytes
+  uint16_t specularTexture;                  // offset 246  - 2 bytes
+  uint16_t specularColorTexture;             // offset 248  - 2 bytes
+  uint16_t iridescenceTexture;               // offset 250  - 2 bytes
+  uint16_t iridescenceThicknessTexture;      // offset 252  - 2 bytes
+  uint16_t anisotropyTexture;                // offset 254  - 2 bytes
+  uint16_t sheenColorTexture;                // offset 256  - 2 bytes
+  uint16_t sheenRoughnessTexture;            // offset 258  - 2 bytes
+  uint16_t occlusionTexture;                 // offset 260  - 2 bytes
+  uint16_t pbrDiffuseTexture;                // offset 262  - 2 bytes
+  uint16_t pbrSpecularGlossinessTexture;     // offset 264  - 2 bytes
+  uint16_t diffuseTransmissionTexture;       // offset 266  - 2 bytes
+  uint16_t diffuseTransmissionColorTexture;  // offset 268  - 2 bytes
+  uint16_t _pad1;                            // offset 270  - 2 bytes
+  // Total size: 272 bytes
 };
 
 inline GltfTextureInfo defaultGltfTextureInfo()
@@ -222,6 +225,8 @@ inline GltfShadeMaterial defaultGltfMaterial()
   m.pbrGlossinessFactor         = 1;
   m.diffuseTransmissionColor    = float3(1, 1, 1);
   m.diffuseTransmissionFactor   = 0;
+  m.multiscatterColor           = float3(0, 0, 0);
+  m.scatterAnisotropy           = 0;
   m.doubleSided                 = 0;
 
   m.pbrBaseColorTexture             = -1;