REfreshing the antialiasing qml na dconfig of the Jitter Job

libraries/render-utils/src/AntialiasingEffect.cpp

@@ -298,29 +298,33 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const
     });
 }
 
-
 void JitterSampleConfig::setIndex(int current) {
     _index = (current) % JitterSample::SEQUENCE_LENGTH;    
     emit dirty();
 }
 
-int JitterSampleConfig::cycleStopPauseRun() {
+void JitterSampleConfig::setState(int state) {
-    _state = (_state + 1) % 3;
+    _state = (state) % 3;
     switch (_state) {
-        case 0: {
+    case 0: {
-            return none();
+        none();
-            break;
+        break;
-        }
-        case 1: {
-            return pause();
-            break;
-        }
-        case 2:
-        default: {
-            return play();
-            break;
-        }
     }
+    case 1: {
+        pause();
+        break;
+    }
+    case 2:
+    default: {
+        play();
+        break;
+    }
+    }
+    emit dirty();
+}
+
+int JitterSampleConfig::cycleStopPauseRun() {
+    setState((_state + 1) % 3);
     return _state;
 }
 

libraries/render-utils/src/AntialiasingEffect.h

@@ -25,6 +25,7 @@ class JitterSampleConfig : public render::Job::Config {
         Q_PROPERTY(bool freeze MEMBER freeze NOTIFY dirty)
         Q_PROPERTY(bool stop MEMBER stop NOTIFY dirty)
         Q_PROPERTY(int index READ getIndex NOTIFY dirty)
+        Q_PROPERTY(int state READ getState WRITE setState NOTIFY dirty)
 public:
     JitterSampleConfig() : render::Job::Config(true) {}
 
@@ -33,6 +34,7 @@ public:
     bool freeze{ false };
 
     void setIndex(int current);
+    void setState(int state);
 
 public slots:
     int cycleStopPauseRun();
@@ -58,7 +60,7 @@ class JitterSample {
 public:
 
     enum {
-        SEQUENCE_LENGTH = 64 
+        SEQUENCE_LENGTH = 32 
     };
 
     using Config = JitterSampleConfig;

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -150,8 +150,6 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     // Prepare deferred, generate the shared Deferred Frame Transform. Only valid with the scaled frame buffer
     const auto deferredFrameTransform = task.addJob<GenerateDeferredFrameTransform>("DeferredFrameTransform", jitter);
 
-    const auto opaqueRangeTimer = task.addJob<BeginGPURangeTimer>("BeginOpaqueRangeTimer", "DrawOpaques");
-
     const auto prepareDeferredInputs = PrepareDeferred::Inputs(scaledPrimaryFramebuffer, lightingModel).asVarying();
     const auto prepareDeferredOutputs = task.addJob<PrepareDeferred>("PrepareDeferred", prepareDeferredInputs);
     const auto deferredFramebuffer = prepareDeferredOutputs.getN<PrepareDeferred::Outputs>(0);
@@ -164,8 +162,6 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     const auto opaqueInputs = DrawStateSortDeferred::Inputs(opaques, lightingModel, jitter).asVarying();
     task.addJob<DrawStateSortDeferred>("DrawOpaqueDeferred", opaqueInputs, shapePlumber);
 
-    task.addJob<EndGPURangeTimer>("OpaqueRangeTimer", opaqueRangeTimer);
-
     // Opaque all rendered
 
     // Linear Depth Pass
@@ -216,13 +212,10 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     const auto transparentsInputs = RenderTransparentDeferred::Inputs(transparents, hazeFrame, lightFrame, lightingModel, lightClusters, shadowFrame, jitter).asVarying();
     task.addJob<RenderTransparentDeferred>("DrawTransparentDeferred", transparentsInputs, shapePlumber);
 
-    const auto outlineRangeTimer = task.addJob<BeginGPURangeTimer>("BeginHighlightRangeTimer", "Highlight");
+    // Highlight 
-
     const auto outlineInputs = DrawHighlightTask::Inputs(items, deferredFramebuffer, lightingFramebuffer, deferredFrameTransform, jitter).asVarying();
     task.addJob<DrawHighlightTask>("DrawHighlight", outlineInputs);
 
-    task.addJob<EndGPURangeTimer>("HighlightRangeTimer", outlineRangeTimer);
-
     // Layered Over (in front)
     const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, lightingModel, hazeFrame, jitter).asVarying();
     const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, lightingModel, hazeFrame, jitter).asVarying();

scripts/developer/utilities/render/luci/Antialiasing.qml

@@ -22,15 +22,12 @@ import "../../lib/prop" as Prop
 
     
 Column{
-    HifiConstants { id: hifi; }
+    id: antialiasing
 
-            id: antialiasing
-    padding: 10
     anchors.left: parent.left
     anchors.right: parent.right 
 
-    spacing: 10
+    Prop.PropScalar {
-     Prop.PropScalar {
         label: "MSAA"
         object: Render.getConfig("RenderMainView.PreparePrimaryBufferForward")
         property: "numSamples"
@@ -38,49 +35,58 @@ Column{
         max: 32
         integral: true
     }
-    Row {
+
-        spacing: 10
+    Prop.PropEnum {
-        id: fxaaOnOff
+        label: "Deferred AA Method"
-        property bool debugFXAA: false
+        enums: [
-        HifiControls.Button {
+            "Off",
-            function getTheText() {
+            "TAA",
-                    if (Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff) {
+            "FXAA",
-                        return "FXAA"
+                ]
-                    } else {
+
-                        return "TAA"
+        valueVarSetter: function (mode) { setAAMode(mode) }
-                    }
+        valueVarGetter: function () { return Render.getConfig("RenderMainView.JitterCam").state +
-                }
+                                             Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff * 2 }
-            text: getTheText()
+
-            onClicked: {
+        function setAAMode(mode) {
-                var onOff = !Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff;
+            console.log("Deferred AA mode is " + mode)
-                    if (onOff) {
+            
-                    Render.getConfig("RenderMainView.JitterCam").none();
+            if (mode == 0) {
-                    Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff = true;
+                Render.getConfig("RenderMainView.JitterCam").state = 0;
-                    } else {
+                Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff = false;
-                    Render.getConfig("RenderMainView.JitterCam").play();
+            } else if (mode == 1) {
-                    Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff = false;
+                Render.getConfig("RenderMainView.JitterCam").state = 1;
-                    }
+                Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff = false;
-                    
+            } else {
+                Render.getConfig("RenderMainView.JitterCam").state = 0;
+                Render.getConfig("RenderMainView.Antialiasing").fxaaOnOff = true;
             }
         }
     }
     Separator {}          
+    Prop.PropEnum {
+        label: "Jitter"
+        object: Render.getConfig("RenderMainView.JitterCam")
+        property: "state"
+
+        enums: [
+            "Off",
+            "On",
+            "Paused",
+                ]
+    }
+    Prop.PropScalar {
+        label: "Sample Index"
+        object: Render.getConfig("RenderMainView.JitterCam")
+        property: "index"
+      //  min: -1
+      //  max: 32
+        readOnly: true
+        integral: true
+    }
     Row {
         spacing: 10
-        
+
-        HifiControls.Button {
-            text: {
-                var state = 2 - (Render.getConfig("RenderMainView.JitterCam").freeze * 1 - Render.getConfig("RenderMainView.JitterCam").stop * 2); 
-                if (state === 2) {
-                    return "Jitter"
-                } else if  (state === 1) {
-                    return "Paused at " + Render.getConfig("RenderMainView.JitterCam").index + ""
-                } else {
-                    return "No Jitter"
-                }
-                }
-            onClicked: { Render.getConfig("RenderMainView.JitterCam").cycleStopPauseRun(); }
-        }
         HifiControls.Button {
             text: "<"
             onClicked: { Render.getConfig("RenderMainView.JitterCam").prev(); }
@@ -90,96 +96,75 @@ Column{
             onClicked: { Render.getConfig("RenderMainView.JitterCam").next(); }
         }
     }
-    Separator {}          
+    Separator {}
-    HifiControls.CheckBox {
+    Prop.PropBool {
-        boxSize: 20
+        label: "Constrain color"
-        text: "Constrain color"
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        checked: Render.getConfig("RenderMainView.Antialiasing")["constrainColor"]
+        property: "constrainColor"
-        onCheckedChanged: { Render.getConfig("RenderMainView.Antialiasing")["constrainColor"] = checked }
+    }         
-    }
+    Prop.PropScalar {
-    ConfigSlider {
+        label: "Covariance gamma"
-        label: qsTr("Covariance gamma")
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        integral: false
-        config: Render.getConfig("RenderMainView.Antialiasing")
         property: "covarianceGamma"
         max: 1.5
         min: 0.5
-        height: 38
+    }                       
-    }                          
+    Separator {}
-    Separator {}          
+    Prop.PropBool {
-    HifiControls.CheckBox {
+        label: "Feedback history color"
-        boxSize: 20
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        text: "Feedback history color"
+        property: "feedbackColor"
-        checked: Render.getConfig("RenderMainView.Antialiasing")["feedbackColor"]
+    }           
-        onCheckedChanged: { Render.getConfig("RenderMainView.Antialiasing")["feedbackColor"] = checked }
+    Prop.PropScalar {
-    }
+        label: "Source blend"
-
+        object: Render.getConfig("RenderMainView.Antialiasing")
-    ConfigSlider {
-        label: qsTr("Source blend")
-        integral: false
-        config: Render.getConfig("RenderMainView.Antialiasing")
         property: "blend"
         max: 1.0
         min: 0.0
-        height: 38
     }
-
+    Prop.PropScalar {
-    ConfigSlider {
+        label: "Post sharpen"
-        label: qsTr("Post sharpen")
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        integral: false
-        config: Render.getConfig("RenderMainView.Antialiasing")
         property: "sharpen"
         max: 1.0
         min: 0.0
     }
-    Separator {}                      
+    Separator {}
-    Row {
+    Prop.PropBool {
-
+        label: "Debug"
-        spacing: 10
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        HifiControls.CheckBox {
+        property: "debug"
-            boxSize: 20
+    }   
-            text: "Debug"
+    Prop.PropBool {
-            checked: Render.getConfig("RenderMainView.Antialiasing")["debug"]
+        label: "Show Debug Cursor"
-            onCheckedChanged: { Render.getConfig("RenderMainView.Antialiasing")["debug"] = checked }
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        }
+        property: "showCursorPixel"
-        HifiControls.CheckBox {
+    }                         
-            boxSize: 20
+    Prop.PropScalar {
-            text: "Show Debug Cursor"
+        label: "Debug Region <"
-            checked: Render.getConfig("RenderMainView.Antialiasing")["showCursorPixel"]
+        object: Render.getConfig("RenderMainView.Antialiasing")
-            onCheckedChanged: { Render.getConfig("RenderMainView.Antialiasing")["showCursorPixel"] = checked }
-        }
-    }
-    ConfigSlider {
-        label: qsTr("Debug Region <")
-        integral: false
-        config: Render.getConfig("RenderMainView.Antialiasing")
         property: "debugX"
         max: 1.0
         min: 0.0
     }
-    HifiControls.CheckBox {
+    Prop.PropBool {
-        boxSize: 20
+        label: "Closest Fragment"
-        text: "Closest Fragment"
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        checked: Render.getConfig("RenderMainView.Antialiasing")["showClosestFragment"]
+        property: "showClosestFragment"
-        onCheckedChanged: { Render.getConfig("RenderMainView.Antialiasing")["showClosestFragment"] = checked }
+    }
-    }           
+    Prop.PropScalar {
-    ConfigSlider {
+        label: "Debug Velocity Threshold [pix]"
-        label: qsTr("Debug Velocity Threshold [pix]")
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        integral: false
-        config: Render.getConfig("RenderMainView.Antialiasing")
         property: "debugShowVelocityThreshold"
         max: 50
         min: 0.0
-        height: 38
     }
-    ConfigSlider {
+    Prop.PropScalar {
-        label: qsTr("Debug Orb Zoom")
+        label: "Debug Orb Zoom"
-        integral: false
+        object: Render.getConfig("RenderMainView.Antialiasing")
-        config: Render.getConfig("RenderMainView.Antialiasing")
         property: "debugOrbZoom"
         max: 32.0
         min: 1.0
-        height: 38
+    } 
-    }    
 }
 

scripts/developer/utilities/render/luci/Bloom.qml

@@ -37,6 +37,12 @@ Column {
                 ]
 
         valueVarSetter: function (mode) { bloom.setDebugMode(mode) }
+    }
+
+    Prop.PropBool {
+        label: "Debug Bloom Buffer"
+        object: Render.getConfig("RenderMainView.Bloom")
+        property: "enabled"
     } 
 }
 

scripts/developer/utilities/render/luci/ShadingModel.qml

@@ -35,7 +35,8 @@ Column {
                         "Emissive:LightingModel:enableEmissive", 
                         "Lightmap:LightingModel:enableLightmap",
                         "Background:LightingModel:enableBackground",      
-                        "Haze:LightingModel:enableHaze",                        
+                        "Haze:LightingModel:enableHaze", 
+                        "Bloom:LightingModel:enableBloom", 
                         "AO:LightingModel:enableAmbientOcclusion",
                         "Textures:LightingModel:enableMaterialTexturing"                     
                 ]