Fade object params are now passed through uniform buffer

libraries/render-utils/src/Fade.slh

@@ -15,19 +15,20 @@
 #define CATEGORY_COUNT    5
 
 <@include Fade_shared.slh@>
+<@include FadeObjectParams.shared.slh@>
 
 layout(std140) uniform fadeParametersBuffer {
     FadeParameters fadeParameters[CATEGORY_COUNT];
 };
 uniform sampler2D fadeMaskMap;
 
-struct FadeObjectParams {
+vec3 getNoiseInverseSize(int category) {
-    int category;
+    return fadeParameters[category]._noiseInvSizeAndLevel.xyz;
-    float threshold;
+}
-    vec3 noiseOffset;
+
-    vec3 baseOffset;
+float getNoiseLevel(int category) {
-    vec3 baseInvSize;
+    return fadeParameters[category]._noiseInvSizeAndLevel.w;
-};
+}
 
 vec2 hash2D(vec3 position) {
     return position.xy* vec2(0.1677,  0.221765) + position.z*0.561;
@@ -40,7 +41,7 @@ float noise3D(vec3 position) {
 
 float evalFadeNoiseGradient(FadeObjectParams params, vec3 position) {
     // Do tri-linear interpolation
-    vec3    noisePosition = position * fadeParameters[params.category]._noiseInvSizeAndLevel.xyz + params.noiseOffset;
+    vec3    noisePosition = position * getNoiseInverseSize(params.category) + params.noiseOffset.xyz;
     vec3    noisePositionFloored = floor(noisePosition);
     vec3    noisePositionFraction = fract(noisePosition);
 
@@ -61,11 +62,11 @@ float evalFadeNoiseGradient(FadeObjectParams params, vec3 position) {
 
     float noise = mix(maskY.x, maskY.y, noisePositionFraction.y);
     noise -= 0.5;   // Center on value 0
-    return noise * fadeParameters[params.category]._noiseInvSizeAndLevel.w;
+    return noise * getNoiseLevel(params.category);
 }
 
 float evalFadeBaseGradient(FadeObjectParams params, vec3 position) {
-    float gradient = length((position - params.baseOffset) * params.baseInvSize.xyz);
+    float gradient = length((position - params.baseOffset.xyz) * params.baseInvSize.xyz);
     gradient = gradient-0.5;  // Center on value 0.5
     gradient *= fadeParameters[params.category]._baseLevel;
     return gradient;
@@ -112,20 +113,14 @@ void applyFade(FadeObjectParams params, vec3 position, out vec3 emissive) {
 
 <@func declareFadeFragmentUniform()@>
 
-uniform int fadeCategory;
+layout(std140) uniform fadeObjectParametersBuffer {
-uniform vec3 fadeNoiseOffset;
+    FadeObjectParams fadeObjectParams;
-uniform vec3 fadeBaseOffset;
+};
-uniform vec3 fadeBaseInvSize;
-uniform float fadeThreshold;
 
 <@endfunc@>
 
 <@func fetchFadeObjectParams(fadeParams)@>
-    <$fadeParams$>.category = fadeCategory;
+    <$fadeParams$> = fadeObjectParams;
-    <$fadeParams$>.threshold = fadeThreshold;
-    <$fadeParams$>.noiseOffset = fadeNoiseOffset;
-    <$fadeParams$>.baseOffset = fadeBaseOffset;
-    <$fadeParams$>.baseInvSize = fadeBaseInvSize;
 <@endfunc@>
 
 <@func declareFadeFragmentVertexInput()@>
@@ -139,9 +134,9 @@ in vec4 _fadeData3;
 <@func fetchFadeObjectParamsInstanced(fadeParams)@>
     <$fadeParams$>.category = int(_fadeData1.w);
     <$fadeParams$>.threshold = _fadeData2.w;
-    <$fadeParams$>.noiseOffset = _fadeData1.xyz;
+    <$fadeParams$>.noiseOffset = _fadeData1;
-    <$fadeParams$>.baseOffset = _fadeData2.xyz;
+    <$fadeParams$>.baseOffset = _fadeData2;
-    <$fadeParams$>.baseInvSize = _fadeData3.xyz;
+    <$fadeParams$>.baseInvSize = _fadeData3;
 <@endfunc@>
 
 <@func declareFadeFragment()@>

libraries/render-utils/src/FadeEffect.cpp

@@ -13,6 +13,8 @@
 
 #include "render/TransitionStage.h"
 
+#include "FadeObjectParams.shared.slh"
+
 #include <PathUtils.h>
 
 FadeEffect::FadeEffect() {
@@ -51,21 +53,31 @@ render::ShapePipeline::ItemSetter FadeEffect::getItemUniformSetter() const {
             auto transitionStage = scene->getStage<render::TransitionStage>(render::TransitionStage::getName());
             auto& transitionState = transitionStage->getTransition(item.getTransitionId());
             auto program = shapePipeline.pipeline->getProgram();
-            auto& uniforms = program->getUniforms();
+            auto objectParamBufferLocation = program->getUniformBuffers().findLocation("fadeObjectParametersBuffer");
-            auto fadeNoiseOffsetLocation = uniforms.findLocation("fadeNoiseOffset");
+
-            auto fadeBaseOffsetLocation = uniforms.findLocation("fadeBaseOffset");
+            if (objectParamBufferLocation >= 0) {
-            auto fadeBaseInvSizeLocation = uniforms.findLocation("fadeBaseInvSize");
+                if (transitionState.paramsBuffer._size == 0) {
-            auto fadeThresholdLocation = uniforms.findLocation("fadeThreshold");
+                    static_assert(sizeof(transitionState.paramsBuffer) == sizeof(gpu::StructBuffer<FadeObjectParams>), "Assuming gpu::StructBuffer is a helper class for gpu::BufferView");
-            auto fadeCategoryLocation = uniforms.findLocation("fadeCategory");
+                    transitionState.paramsBuffer = gpu::StructBuffer<FadeObjectParams>();
+                }
 
-            if (fadeNoiseOffsetLocation >= 0 || fadeBaseInvSizeLocation >= 0 || fadeBaseOffsetLocation >= 0 || fadeThresholdLocation >= 0 || fadeCategoryLocation >= 0) {
                 const auto fadeCategory = FadeJob::transitionToCategory[transitionState.eventType];
+                auto& paramsConst = static_cast<gpu::StructBuffer<FadeObjectParams>&>(transitionState.paramsBuffer).get();
 
-                batch->_glUniform1i(fadeCategoryLocation, fadeCategory);
+                if (paramsConst.category != fadeCategory
-                batch->_glUniform1f(fadeThresholdLocation, transitionState.threshold);
+                    || paramsConst.threshold != transitionState.threshold
-                batch->_glUniform3f(fadeNoiseOffsetLocation, transitionState.noiseOffset.x, transitionState.noiseOffset.y, transitionState.noiseOffset.z);
+                    || glm::vec3(paramsConst.baseOffset) != transitionState.baseOffset
-                batch->_glUniform3f(fadeBaseOffsetLocation, transitionState.baseOffset.x, transitionState.baseOffset.y, transitionState.baseOffset.z);
+                    || glm::vec3(paramsConst.noiseOffset) != transitionState.noiseOffset
-                batch->_glUniform3f(fadeBaseInvSizeLocation, transitionState.baseInvSize.x, transitionState.baseInvSize.y, transitionState.baseInvSize.z);
+                    || glm::vec3(paramsConst.baseInvSize) != transitionState.baseInvSize) {
+                    auto& params = static_cast<gpu::StructBuffer<FadeObjectParams>&>(transitionState.paramsBuffer).edit();
+
+                    params.category = fadeCategory;
+                    params.threshold = transitionState.threshold;
+                    params.baseInvSize = glm::vec4(transitionState.baseInvSize, 0.0f);
+                    params.noiseOffset = glm::vec4(transitionState.noiseOffset, 0.0f);
+                    params.baseOffset = glm::vec4(transitionState.baseOffset, 0.0f);
+                }
+                batch->setUniformBuffer(objectParamBufferLocation, transitionState.paramsBuffer);
             }
         }
     };

libraries/render-utils/src/FadeObjectParams.shared.slh

@@ -0,0 +1,25 @@
+// glsl / C++ compatible source as interface for FadeObjectParams
+#ifdef __cplusplus
+#   define FOP_VEC4 glm::vec4
+#   define FOP_VEC2 glm::vec2
+#   define FOP_FLOAT32 glm::float32
+#   define FOP_INT32 glm::int32
+#else
+#   define FOP_VEC4 vec4
+#   define FOP_VEC2 vec2
+#   define FOP_FLOAT32 float
+#   define FOP_INT32 int
+#endif
+
+struct FadeObjectParams {
+    FOP_VEC4 noiseOffset;
+    FOP_VEC4 baseOffset;
+    FOP_VEC4 baseInvSize;
+    FOP_INT32 category;
+    FOP_FLOAT32 threshold;
+};
+
+    // <@if 1@>
+    // Trigger Scribe include 
+    // <@endif@> <!def that !> 
+//

libraries/render/src/render/Transition.h

@@ -42,6 +42,8 @@ namespace render {
         glm::vec3 baseInvSize{ 1.f, 1.f, 1.f };
         float threshold{ 0.f };
         uint8_t isFinished{ 0 };
+
+        mutable gpu::BufferView paramsBuffer;
     };
 
     typedef std::shared_ptr<Transition> TransitionPointer;