[hdSt] Add support for camera exposure compensation.

Camera exposure is represented as a scalar multiplier on incoming radiance ("linear exposure scale"), calculated from an exponential "exposure" adjustment as well as potentially fStop/iso/etc in the case of UsdGeomCamera.  This change adds Storm support for exposure compensation, by multiplying the result of "surfaceShader" calls (calculating lit and shaded 3d pixels) by the exposure factor.  Note that exposure compensation is not applied to some other sources of color like "repr" color or selection highlight colors, which are considered non-physical colors.

Since exposure is only applied to the rendering process, exposure compensation of framebuffer contents that will be composited with hydra needs to be done as a separate process.

(Internal change: 2371431)

Author: tcauchois

pxr/imaging/hd/renderPassState.cpp

@@ -26,6 +26,7 @@ HdRenderPassState::HdRenderPassState()
     , _pointSize(3.0)
     , _lightingEnabled(true)
     , _clippingEnabled(true)
+    , _enableExposureCompensation(true)
 
     , _maskColor(1.0f, 0.0f, 0.0f, 1.0f)
     , _indicatorColor(0.0f, 1.0f, 0.0f, 1.0f)
@@ -282,6 +283,12 @@ HdRenderPassState::SetClippingEnabled(bool enabled)
     _clippingEnabled = enabled;
 }
 
+void
+HdRenderPassState::SetEnableExposureCompensation(bool enabled)
+{
+    _enableExposureCompensation = enabled;
+}
+
 void
 HdRenderPassState::SetAovBindings(
         HdRenderPassAovBindingVector const& aovBindings)

pxr/imaging/hd/renderPassState.h

@@ -192,6 +192,10 @@ class HdRenderPassState
     void SetClippingEnabled(bool enabled);
     bool GetClippingEnabled() const { return _clippingEnabled; }
 
+    HD_API
+    void SetEnableExposureCompensation(bool enableExposureCompensation);
+    bool GetEnableExposureCompensation() const { return _enableExposureCompensation; }
+
     // ---------------------------------------------------------------------- //
     /// \name Render pipeline state
     // ---------------------------------------------------------------------- //
@@ -357,6 +361,7 @@ class HdRenderPassState
     float _pointSize;
     bool _lightingEnabled;
     bool _clippingEnabled;
+    bool _enableExposureCompensation;
 
     GfVec4f _maskColor;
     GfVec4f _indicatorColor;

pxr/imaging/hd/tokens.h

@@ -207,6 +207,7 @@ PXR_NAMESPACE_OPEN_SCOPE
     (cullStyle)                                 \
     (drawRange)                                 \
     (environmentMap)                            \
+    (linearExposure)                            \
     (displacementShader)                        \
     (fragmentShader)                            \
     (geometryShader)                            \
@@ -435,6 +436,7 @@ TfToken HdAovTokensMakeShader(TfToken const& shader);
     (enableShadows)                                   \
     (enableSceneMaterials)                            \
     (enableSceneLights)                               \
+    (enableExposureCompensation)                      \
     (domeLightCameraVisibility)                       \
     /* Raytracer sampling settings */                 \
     (convergedVariance)                               \

pxr/imaging/hdSt/renderDelegate.cpp

@@ -205,6 +205,10 @@ HdStRenderDelegate::HdStRenderDelegate(HdRenderSettingsMap const& settingsMap)
         HdRenderSettingDescriptor{
             "Dome light camera visibility",
             HdRenderSettingsTokens->domeLightCameraVisibility,
+            VtValue(true) },
+        HdRenderSettingDescriptor{
+            "Enable exposure compensation",
+            HdRenderSettingsTokens->enableExposureCompensation,
             VtValue(true) }
     };
 

pxr/imaging/hdSt/renderPassState.cpp

@@ -305,6 +305,9 @@ HdStRenderPassState::Prepare(
         bufferSpecs.emplace_back(
             HdShaderTokens->lightingBlendAmount,
             HdTupleType{HdTypeFloat, 1});
+        bufferSpecs.emplace_back(
+            HdShaderTokens->linearExposure,
+            HdTupleType{HdTypeFloat, 1});
         bufferSpecs.emplace_back(
             HdShaderTokens->stepSize,
             HdTupleType{HdTypeFloat, 1});
@@ -361,6 +364,11 @@ HdStRenderPassState::Prepare(
     // only using the feature to turn lighting on and off.
     float lightingBlendAmount = (_lightingEnabled ? 1.0f : 0.0f);
 
+    // Camera exposure (linear-encoded)
+    float linearExposure =
+        ((_camera && _enableExposureCompensation)
+         ? _camera->GetLinearExposureScale() : 1.0f);
+
     GfMatrix4d const& worldToViewMatrix = GetWorldToViewMatrix();
     GfMatrix4d projMatrix = GetProjectionMatrix();
 
@@ -426,6 +434,9 @@ HdStRenderPassState::Prepare(
         std::make_shared<HdVtBufferSource>(
             HdShaderTokens->lightingBlendAmount,
             VtValue(lightingBlendAmount)),
+        std::make_shared<HdVtBufferSource>(
+            HdShaderTokens->linearExposure,
+            VtValue(linearExposure)),
         std::make_shared<HdVtBufferSource>(
             HdShaderTokens->stepSize,
             VtValue(_stepSize)),

pxr/imaging/hdSt/shaders/renderPass.glslfx

@@ -66,6 +66,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();

pxr/imaging/hdSt/shaders/terminals.glslfx

@@ -100,6 +100,9 @@ vec4 ShadingTerminal(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
                                          Neye,
                                          shadingColor);
 #endif
+
+        // Modify the shaded color by camera exposure.
+        shadingColor.rgb *= GetLinearExposure();
 
         reprColor.rgb = reprStyle.useSurfaceShaderColor ? 
                         shadingColor.rgb :

pxr/imaging/hdSt/testenv/testHdStCodeGen_GL/baseline/codegen_curves_indirect.out

@@ -316,6 +316,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -1024,6 +1031,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -1597,6 +1611,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -2345,6 +2366,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -2632,6 +2660,9 @@ vec4 ShadingTerminal(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
                                          shadingColor);
 #endif
 
+        // Modify the shaded color by camera exposure.
+        shadingColor.rgb *= GetLinearExposure();
+
         reprColor.rgb = reprStyle.useSurfaceShaderColor ?
                         shadingColor.rgb :
                         reprColor.rgb;

pxr/imaging/hdSt/testenv/testHdStCodeGen_GL/baseline/codegen_mesh_edgeonly.out

@@ -317,6 +317,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -1083,6 +1090,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -1846,6 +1860,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -2456,6 +2477,9 @@ vec4 ShadingTerminal(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
                                          shadingColor);
 #endif
 
+        // Modify the shaded color by camera exposure.
+        shadingColor.rgb *= GetLinearExposure();
+
         reprColor.rgb = reprStyle.useSurfaceShaderColor ?
                         shadingColor.rgb :
                         reprColor.rgb;
@@ -3055,6 +3079,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -3821,6 +3852,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -4613,6 +4651,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -5223,6 +5268,9 @@ vec4 ShadingTerminal(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
                                          shadingColor);
 #endif
 
+        // Modify the shaded color by camera exposure.
+        shadingColor.rgb *= GetLinearExposure();
+
         reprColor.rgb = reprStyle.useSurfaceShaderColor ?
                         shadingColor.rgb :
                         reprColor.rgb;

pxr/imaging/hdSt/testenv/testHdStCodeGen_GL/baseline/codegen_mesh_edgeonly_blendwireframe.out

@@ -317,6 +317,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -1083,6 +1090,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -1846,6 +1860,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -2462,6 +2483,9 @@ vec4 ShadingTerminal(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
                                          shadingColor);
 #endif
 
+        // Modify the shaded color by camera exposure.
+        shadingColor.rgb *= GetLinearExposure();
+
         reprColor.rgb = reprStyle.useSurfaceShaderColor ?
                         shadingColor.rgb :
                         reprColor.rgb;
@@ -3061,6 +3085,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -3827,6 +3858,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -4619,6 +4657,13 @@ float GetLightingBlendAmount() {
     return 1;
 #endif
 }
+float GetLinearExposure() {
+#if defined(HD_HAS_linearExposure)
+    return HdGet_linearExposure();
+#else
+    return 1;
+#endif
+}
 vec4  GetViewport() {
 #if defined(HD_HAS_viewport)
     return HdGet_viewport();
@@ -5235,6 +5280,9 @@ vec4 ShadingTerminal(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
                                          shadingColor);
 #endif
 
+        // Modify the shaded color by camera exposure.
+        shadingColor.rgb *= GetLinearExposure();
+
         reprColor.rgb = reprStyle.useSurfaceShaderColor ?
                         shadingColor.rgb :
                         reprColor.rgb;