Add target memory for the dome light textures

To improve the loading time of dome light in Storm, this change adds a new render setting
("domeLightTexturesTargetMemory") to adjust the size of the computed cubemap and
pre-processed textures of dome light.

(based on github pull request #3383)

Closes #3383

(Internal change: 2383587)

Author: klucknav

pxr/imaging/hdSt/domeLightComputations.cpp

@@ -204,12 +204,14 @@ HdSt_DomeLightComputationGPU::HdSt_DomeLightComputationGPU(
     const TfToken & shaderToken,
     const bool useCubemapAsSourceTexture,
     HdStSimpleLightingShaderPtr const &lightingShader,
+    const unsigned int computedCubeMapDim,
     const unsigned int numLevels,
     const unsigned int level,
     const float roughness)
   : _shaderToken(shaderToken),
     _useCubemapAsSourceTexture(useCubemapAsSourceTexture),
     _lightingShader(lightingShader),
+    _computedCubeMapDim(computedCubeMapDim),
     _numLevels(numLevels),
     _level(level),
     _roughness(roughness)
@@ -328,7 +330,7 @@ HdSt_DomeLightComputationGPU::Execute(
         // We are either generating a cubemap with 6 equal-sized faces from the
         // latlong texture, or a single 2D lookup texture that will
         // be the size of one face of the cubemap.
-        width = HdSt_ComputeDomeLightCubemapDimensions(srcDim)[0];
+        width = _computedCubeMapDim;
         height = width;
     }
 
@@ -475,11 +477,29 @@ void HdSt_DomeLightMipmapComputationGPU::Execute(
     srcTextureObject->GenerateMipmaps();
 }
 
-GfVec3i HdSt_ComputeDomeLightCubemapDimensions(
-    const GfVec3i& srcDim)
+int HdSt_ComputeDomeLightCubemapWidth(
+    const std::string& domeLightFilePath,
+    const HgiTextureDesc& domelightTextureDesc,
+    const unsigned int cubemapTargetMemoryMB)
 {
-    const int width = std::max(srcDim[0] / 4, 1);
-    return { width, width, 1 };
+    // Standard cubemap width calculation
+    const int cubemapWidth = std::max(domelightTextureDesc.dimensions[0] / 4, 1);
+ 
+    if (cubemapTargetMemoryMB == 0) {
+        return cubemapWidth;
+    }
+    
+    // Cubemap width calculation based on the target memory
+    const size_t MB = 1048576;
+    size_t blockWidth, blockHeight;
+    const size_t bytesPerTexel = HgiGetDataSizeOfFormat(
+        domelightTextureDesc.format, &blockWidth, &blockHeight);
+    const size_t bytesPerPixel = bytesPerTexel / (blockHeight * blockWidth);
+    // The 0.75 factor is to account for all lower mipmaps
+    const int targetMemoryWidth =
+        sqrt((0.75 * cubemapTargetMemoryMB * MB) / (6 * bytesPerPixel));
+
+    return std::min(targetMemoryWidth, cubemapWidth);
 }
 
 PXR_NAMESPACE_CLOSE_SCOPE

pxr/imaging/hdSt/domeLightComputations.h

@@ -22,6 +22,7 @@ PXR_NAMESPACE_OPEN_SCOPE
 
 using HdStSimpleLightingShaderPtr =
     std::weak_ptr<class HdStSimpleLightingShader>;
+struct HgiTextureDesc;
 
 ////
 //// \class HdSt_DomeLightComputationGPU
@@ -46,6 +47,9 @@ class HdSt_DomeLightComputationGPU : public HdStComputation
         bool useCubemapAsSourceTexture,
         // Lighting shader for accessing any referenced textures.
         HdStSimpleLightingShaderPtr const &lightingShader,
+        // Dimension of the dome light cubemap texture. NOTE: this is only used  
+        // when the latlong texture is input for the compuation.  
+        unsigned int computedCubeMapDim,
         // Number of mip levels.
         unsigned int numLevels = 1,
         // Level to be filled (0 means also to allocate texture).
@@ -69,6 +73,7 @@ class HdSt_DomeLightComputationGPU : public HdStComputation
     const TfToken _shaderToken;
     const bool _useCubemapAsSourceTexture;
     const HdStSimpleLightingShaderPtr _lightingShader;
+    const unsigned int _computedCubeMapDim;
     const unsigned int _numLevels;
     const unsigned int _level;
     const float _roughness;
@@ -100,11 +105,13 @@ class HdSt_DomeLightMipmapComputationGPU : public HdStComputation
     const HdStSimpleLightingShaderPtr _lightingShader;
 };
 
-/// Given the dimensions of a 2D dome light texture, compute the resulting
-/// dimensions of the cubemap.
+// For the given 2D dome light texture, compute the resulting dimensions of 
+// the cubemap.
 HDST_API
-GfVec3i HdSt_ComputeDomeLightCubemapDimensions(
-    const GfVec3i& srcDim);
+int HdSt_ComputeDomeLightCubemapWidth(
+    const std::string& domeLightFilePath,
+    const HgiTextureDesc& domelightTextureDesc,
+    const unsigned int cubemapTargetMemoryMB);
 
 PXR_NAMESPACE_CLOSE_SCOPE
 

pxr/imaging/hdSt/renderDelegate.cpp

@@ -54,6 +54,10 @@ TF_DEFINE_ENV_SETTING(HD_ENABLE_GPU_TINY_PRIM_CULLING, false,
 TF_DEFINE_ENV_SETTING(HDST_MAX_LIGHTS, 16,
                       "Maximum number of lights to render with");
 
+TF_DEFINE_ENV_SETTING(HDST_DOME_LIGHT_CUBEMAP_TARGET_MEMORY_MB, 0,
+                      "Maximum memory target in MB for the cubemap computed "
+                      "from the latlong texture for the dome light.");
+
 const TfTokenVector HdStRenderDelegate::SUPPORTED_RPRIM_TYPES =
 {
     HdPrimTypeTokens->mesh,
@@ -206,6 +210,12 @@ HdStRenderDelegate::HdStRenderDelegate(HdRenderSettingsMap const& settingsMap)
             "Dome light camera visibility",
             HdRenderSettingsTokens->domeLightCameraVisibility,
             VtValue(true) },
+        HdRenderSettingDescriptor{
+            "Maximum memory target, in MB, of calculated cubemap texture for "
+            "dome light",
+            HdStRenderSettingsTokens->domeLightCubemapTargetMemory,
+            VtValue(static_cast<unsigned int>(
+                TfGetEnvSetting(HDST_DOME_LIGHT_CUBEMAP_TARGET_MEMORY_MB))) },
         HdRenderSettingDescriptor{
             "Enable exposure compensation",
             HdRenderSettingsTokens->enableExposureCompensation,

pxr/imaging/hdSt/simpleLightingShader.cpp

@@ -47,6 +47,7 @@ HdStSimpleLightingShader::HdStSimpleLightingShader()
     : _lightingContext(GlfSimpleLightingContext::New())
     , _useLighting(true)
     , _glslfx(std::make_unique<HioGlslfx>(HdStPackageSimpleLightingShader()))
+    , _domeLightCubemapTargetMemoryMB(0)
     , _shadowTextureHandle(
         NamedTextureHandle{ 
             HdStTokens->shadowCompareTextures,
@@ -596,8 +597,12 @@ HdStSimpleLightingShader::AddResourcesFromTextures(ResourceContext &ctx) const
             srcTextureObject->GetTextureIdentifier().GetFilePath().GetText());
         return;
     }
-    const GfVec3i srcDim = srcTexture->GetDescriptor().dimensions;
-    const int cubemapDim = HdSt_ComputeDomeLightCubemapDimensions(srcDim)[0];
+
+    const int cubemapDim =
+        HdSt_ComputeDomeLightCubemapWidth(
+            srcTextureObject->GetTextureIdentifier().GetFilePath().GetString(),
+            srcTextureObject->GetTexture()->GetDescriptor(),
+            _domeLightCubemapTargetMemoryMB);
     const auto numCubemapLevels = (unsigned int)(std::log2(cubemapDim) + 1);
 
     // Cubemap generation from latlong texture.
@@ -607,6 +612,7 @@ HdStSimpleLightingShader::AddResourcesFromTextures(ResourceContext &ctx) const
             _tokens->domeLightCubemap,
             /*useCubemapAsSourceTexture =*/false,
             thisShader,
+            cubemapDim,
             numCubemapLevels),
         HdStComputeQueueZero
     );
@@ -617,7 +623,8 @@ HdStSimpleLightingShader::AddResourcesFromTextures(ResourceContext &ctx) const
         std::make_shared<HdSt_DomeLightComputationGPU>(
             _tokens->domeLightBRDF,
             /*useCubemapAsSourceTexture =*/false,
-            thisShader),
+            thisShader,
+            cubemapDim),
         HdStComputeQueueZero
     );
 
@@ -635,7 +642,8 @@ HdStSimpleLightingShader::AddResourcesFromTextures(ResourceContext &ctx) const
         std::make_shared<HdSt_DomeLightComputationGPU>(
             _tokens->domeLightIrradiance,
             /*useCubemapAsSourceTexture =*/true,
-            thisShader),
+            thisShader,
+            cubemapDim),
         HdStComputeQueueTwo
     );
 
@@ -654,6 +662,7 @@ HdStSimpleLightingShader::AddResourcesFromTextures(ResourceContext &ctx) const
                 _tokens->domeLightPrefilter,
                 /*useCubemapAsSourceTexture =*/true,
                 thisShader,
+                cubemapDim,
                 numPrefilterLevels,
                 mipLevel,
                 roughness),
@@ -668,5 +677,16 @@ HdStSimpleLightingShader::GetNamedTextureHandles() const
     return _namedTextureHandles;
 }
 
+void 
+HdStSimpleLightingShader::SetDomeLightCubemapTargetMemory(
+    unsigned int targetMemoryMB)
+{
+    if (_domeLightCubemapTargetMemoryMB != targetMemoryMB) {
+        _domeLightCubemapTargetMemoryMB = targetMemoryMB;
+        _domeLightEnvironmentTextureHandle = nullptr;
+        _domeLightTextureHandles.clear();
+    }
+}
+
 PXR_NAMESPACE_CLOSE_SCOPE
 

pxr/imaging/hdSt/simpleLightingShader.h

@@ -129,6 +129,9 @@ class HdStSimpleLightingShader : public HdStLightingShader
         return _shadowAovBindings;
     }
 
+    HDST_API
+    void SetDomeLightCubemapTargetMemory(unsigned int targetMemoryMB);
+
 private:
     void _AllocateShadowTextures(
         HdStResourceRegistry* const resourceRegistry,
@@ -152,6 +155,10 @@ class HdStSimpleLightingShader : public HdStLightingShader
     NamedTextureHandleVector _namedTextureHandles;
 
     NamedTextureHandleVector _domeLightTextureHandles;
+
+    // Maximum target memory of computed dome light cubemap texture (in MB)
+    unsigned int _domeLightCubemapTargetMemoryMB;
+    
     NamedTextureHandle _shadowTextureHandle;
 
     HdSt_MaterialParamVector _lightTextureParams;

pxr/imaging/hdSt/tokens.h

@@ -87,7 +87,8 @@ PXR_NAMESPACE_OPEN_SCOPE
     (volumeRaymarchingStepSize)                 \
     (volumeRaymarchingStepSizeLighting)         \
     (volumeMaxTextureMemoryPerField)            \
-    (maxLights)
+    (maxLights)                                 \
+    (domeLightCubemapTargetMemory)
 
 // Material tags help bucket prims into different queues for draw submission.
 // The tags supported by Storm are:

pxr/imaging/hdx/simpleLightTask.cpp

@@ -155,6 +155,13 @@ HdxSimpleLightTask::Sync(HdSceneDelegate* delegate,
         _maxLights = size_t(
             renderIndex.GetRenderDelegate()->GetRenderSetting<int>(
                 HdStRenderSettingsTokens->maxLights, 16));
+
+        // Update dome light textures max resolution.
+        _lightingShader->SetDomeLightCubemapTargetMemory(
+            static_cast<unsigned int>(
+                renderIndex.GetRenderDelegate()->GetRenderSetting<unsigned int>(
+                    HdStRenderSettingsTokens->domeLightCubemapTargetMemory, 0)));
+
         _settingsVersion = renderDelegate->GetRenderSettingsVersion();
         verifyNumLights = true;
     }