qmlui: finally figured out how to render forward selection boxes

Basically this turns the pipeline into: - stage geometries -> GBuffer FBO: color/position/normal/depth ("geometry" pass) - selection boxes -> another FBO: color + gBuffer depth ("geometry" pass) - lights -> screen quad ("lights" pass) - selection boxes -> screen quad ("forward" pass)
mcallegari · Aug 27, 2017 · 2361009 · 2361009
1 parent 571ee1a
commit 2361009
Show file tree

Hide file tree

Showing 6 changed files with 181 additions and 239 deletions.
diff --git a/qmlui/qml/fixturesfunctions/3DView/3DView.qml b/qmlui/qml/fixturesfunctions/3DView/3DView.qml
@@ -90,27 +90,21 @@ Rectangle
                 depthAttachment: gBufferTarget.depth
             }
 
-            GBufferDebugger { id: debugEntity }
+            //GBufferDebugger { id: debugEntity }
 
             components : [
-                RenderSettings
+                DeferredRenderer
                 {
-                    pickingSettings.pickMethod: PickingSettings.TrianglePicking
-                    activeFrameGraph:
-                        DeferredRenderer
-                        {
-                            id: frameGraph
-                            camera : sceneEntity.camera
-                            gBuffer: gBufferTarget
-                            forward: forwardTarget
-                            sceneDeferredLayer: sceneEntity.deferredLayer
-                            sceneSelectionLayer: sceneEntity.selectionLayer
-                            screenQuadLayer: screenQuadEntity.layer
-                            windowWidth: scene3d.width
-                            windowHeight: scene3d.height
-                            debugLayer: debugEntity.layer
-                        }
-                    renderPolicy: RenderSettings.Always
+                    id: frameGraph
+                    camera : sceneEntity.camera
+                    gBuffer: gBufferTarget
+                    forward: forwardTarget
+                    sceneDeferredLayer: sceneEntity.deferredLayer
+                    sceneSelectionLayer: sceneEntity.selectionLayer
+                    screenQuadLayer: screenQuadEntity.layer
+                    windowWidth: scene3d.width
+                    windowHeight: scene3d.height
+                    //debugLayer: debugEntity.layer
                 },
                 InputSettings {}
             ]

diff --git a/qmlui/qml/fixturesfunctions/3DView/DeferredRenderer.qml b/qmlui/qml/fixturesfunctions/3DView/DeferredRenderer.qml
@@ -20,128 +20,172 @@
 import Qt3D.Core 2.0
 import Qt3D.Render 2.0
 
-Viewport
+RenderSettings
 {
-    id: root
-    normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
+    pickingSettings.pickMethod: PickingSettings.TrianglePicking
+    renderPolicy: RenderSettings.Always
 
     property GBuffer gBuffer
     property ForwardTarget forward
     property alias camera: sceneCameraSelector.camera
     property alias sceneDeferredLayer: sceneDeferredLayerFilter.layers
     property alias sceneSelectionLayer: sceneSelectionLayerFilter.layers
-    property alias screenQuadLayer: screenQuadLayerFilter.layers
-    property alias debugLayer: debugLayerFilter.layers
+    property Layer screenQuadLayer
+    //property alias debugLayer: debugLayerFilter.layers
 
     property real windowWidth: 0
     property real windowHeight: 0
 
-    RenderSurfaceSelector
-    {
-        id: surfaceSelector
-
-        CameraSelector
+    activeFrameGraph:
+        Viewport
         {
-            id: sceneCameraSelector
+            id: root
+            normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
 
-            // Fill G-Buffer
-            LayerFilter
+            RenderSurfaceSelector
             {
-                id: sceneDeferredLayerFilter
-                RenderTargetSelector
+                id: surfaceSelector
+
+                CameraSelector
                 {
-                    id: gBufferTargetSelector
-                    target: gBuffer
+                    id: sceneCameraSelector
 
-                    ClearBuffers
+                    // Fill G-Buffer
+                    LayerFilter
                     {
-                        buffers: ClearBuffers.ColorDepthBuffer
-
-                        RenderPassFilter
+                        id: sceneDeferredLayerFilter
+                        RenderTargetSelector
                         {
-                            id: geometryPass
-                            matchAny: FilterKey { name: "pass"; value: "geometry" }
-                        }
-                    }
-                }
-            }
-
-            // Fill selection FBO
-            LayerFilter
-            {
-                id: sceneSelectionLayerFilter
-                RenderTargetSelector
-                {
-                    id: selectionTargetSelector
-                    target: forward
-                }
+                            id: gBufferTargetSelector
+                            target: gBuffer
 
-                ClearBuffers
-                {
-                    buffers: ClearBuffers.ColorBuffer
+                            ClearBuffers
+                            {
+                                buffers: ClearBuffers.ColorDepthBuffer
 
-                    RenderPassFilter
-                    {
-                        id: selectionPass
-                        matchAny: FilterKey { name: "pass"; value: "geometry" }
+                                RenderPassFilter
+                                {
+                                    id: geometryPass
+                                    matchAny: FilterKey { name: "pass"; value: "geometry" }
+                                }
+                            }
+                        }
                     }
-                }
-            }
 
-
-            TechniqueFilter
-            {
-                parameters: [
-                    Parameter { name: "color"; value: gBuffer.color },
-                    Parameter { name: "position"; value: gBuffer.position },
-                    Parameter { name: "normal"; value: gBuffer.normal },
-                    Parameter { name: "depth"; value: gBuffer.depth },
-                    Parameter { name: "winSize"; value: Qt.size(windowWidth, windowHeight) }
-                ]
-
-                RenderStateSet
-                {
-                    // Render FullScreen Quad
-                    renderStates: [
-                        BlendEquation { blendFunction: BlendEquation.Add },
-                        BlendEquationArguments
-                        {
-                            sourceRgb: BlendEquationArguments.SourceAlpha
-                            destinationRgb: BlendEquationArguments.DestinationColor
-                        }
-                    ]
+                    // Fill selection FBO
                     LayerFilter
                     {
-                        id: screenQuadLayerFilter
-                        ClearBuffers
+                        id: sceneSelectionLayerFilter
+                        RenderTargetSelector
                         {
-                            buffers: ClearBuffers.ColorDepthBuffer
-                            RenderPassFilter
+                            id: selectionTargetSelector
+                            target: forward
+
+                            ClearBuffers
                             {
-                                matchAny: FilterKey { name: "pass"; value: "final" }
-                                parameters: Parameter { name: "winSize"; value: Qt.size(windowWidth, windowHeight) }
+                                buffers: ClearBuffers.ColorBuffer
 
+                                RenderPassFilter
+                                {
+                                    id: selectionPass
+                                    matchAny: FilterKey { name: "pass"; value: "geometry" }
+                                }
                             }
                         }
                     }
 
-                    // RenderDebug layer
-                    LayerFilter
+                    // Lights pass technique
+                    TechniqueFilter
                     {
-                        id: debugLayerFilter
-                        Viewport
+                        parameters: [
+                            Parameter { name: "color"; value: gBuffer.color },
+                            Parameter { name: "position"; value: gBuffer.position },
+                            Parameter { name: "normal"; value: gBuffer.normal },
+                            Parameter { name: "depth"; value: gBuffer.depth },
+                            Parameter { name: "winSize"; value: Qt.size(windowWidth, windowHeight) }
+                        ]
+
+                        RenderStateSet
                         {
-                            normalizedRect: Qt.rect(0.5, 0.5, 0.5, 0.5)
-                            RenderPassFilter
+                            // Render FullScreen Quad
+                            renderStates: [
+                                BlendEquation { blendFunction: BlendEquation.Add },
+                                BlendEquationArguments
+                                {
+                                    sourceRgb: BlendEquationArguments.SourceAlpha
+                                    destinationRgb: BlendEquationArguments.DestinationColor
+                                }
+                            ]
+                            LayerFilter
                             {
-                                matchAny: FilterKey { name: "pass"; value: "final" }
-                                parameters: Parameter { name: "winSize"; value: Qt.size(windowWidth * 0.5, windowHeight * 0.5) }
+                                //id: screenQuadLayerFilter
+                                layers: screenQuadLayer
+
+                                ClearBuffers
+                                {
+                                    buffers: ClearBuffers.ColorDepthBuffer
+                                    RenderPassFilter
+                                    {
+                                        matchAny: FilterKey { name: "pass"; value: "lights" }
+                                        parameters: Parameter { name: "winSize"; value: Qt.size(windowWidth, windowHeight) }
+
+                                    }
+                                }
                             }
+/*
+                            // RenderDebug layer
+                            LayerFilter
+                            {
+                                id: debugLayerFilter
+                                Viewport
+                                {
+                                    normalizedRect: Qt.rect(0.5, 0.5, 0.5, 0.5)
+                                    RenderPassFilter
+                                    {
+                                        matchAny: FilterKey { name: "pass"; value: "lights" }
+                                        parameters: Parameter { name: "winSize"; value: Qt.size(windowWidth * 0.5, windowHeight * 0.5) }
+                                    }
+                                }
+                            }
+*/
                         }
-                    }
+                    } // TechniqueFilter
+
+                    // Mesh selection boxes forward pass technique
+                    TechniqueFilter
+                    {
+                        parameters: [
+                            Parameter { name: "color"; value: forward.color },
+                            Parameter { name: "depth"; value: gBuffer.depth },
+                            Parameter { name: "winSize"; value: Qt.size(windowWidth, windowHeight) }
+                        ]
+
+                        RenderStateSet
+                        {
+                            // Add to FullScreen Quad
+                            renderStates: [
+                                BlendEquation { blendFunction: BlendEquation.Add },
+                                BlendEquationArguments
+                                {
+                                    sourceRgb: BlendEquationArguments.SourceAlpha
+                                    destinationRgb: BlendEquationArguments.DestinationColor
+                                }
+                            ]
+                            LayerFilter
+                            {
+                                layers: screenQuadLayer
+
+                                RenderPassFilter
+                                {
+                                    matchAny: FilterKey { name: "pass"; value: "forward" }
+                                    parameters: Parameter { name: "winSize"; value: Qt.size(windowWidth, windowHeight) }
+
+                                }
+                            }
+                        }
+                    } // TechniqueFilter
 
-                }
-            }
-        }
-    }
+                } // CameraSelector
+            } // RenderSurfaceSelector
+        } // Viewport
 }
diff --git a/qmlui/qml/fixturesfunctions/3DView/GBufferDebugger.qml b/qmlui/qml/fixturesfunctions/3DView/GBufferDebugger.qml
@@ -46,7 +46,7 @@ Entity
                     Technique {
                         graphicsApiFilter { api: GraphicsApiFilter.OpenGL; profile: GraphicsApiFilter.NoProfile; majorVersion: 2; minorVersion: 0 }
                         renderPasses: RenderPass {
-                            filterKeys: FilterKey { name: "pass"; value: "final" }
+                            filterKeys: FilterKey { name: "pass"; value: "lights" }
                             shaderProgram: ShaderProgram {
                                 vertexShaderCode:
                                     "#version 110
@@ -93,7 +93,7 @@ Entity
                     Technique {
                         graphicsApiFilter { api: GraphicsApiFilter.OpenGL; profile: GraphicsApiFilter.CoreProfile; majorVersion: 3; minorVersion: 2 }
                         renderPasses: RenderPass {
-                            filterKeys: FilterKey { name: "pass"; value: "final" }
+                            filterKeys: FilterKey { name: "pass"; value: "lights" }
                             shaderProgram: ShaderProgram {
                                 vertexShaderCode:
                                     "#version 150

diff --git a/qmlui/qml/fixturesfunctions/3DView/LightPassEffect.qml b/qmlui/qml/fixturesfunctions/3DView/LightPassEffect.qml
@@ -24,28 +24,60 @@ Effect
 {
     techniques:
     [
-        // OpenGL 3.1
+        // Light pass - OpenGL 3.1
         Technique
         {
             graphicsApiFilter { api: GraphicsApiFilter.OpenGL; profile: GraphicsApiFilter.CoreProfile; majorVersion: 3; minorVersion: 1 }
             renderPasses:
+            [
                 RenderPass
                 {
-                    filterKeys: FilterKey { name : "pass"; value : "final" }
+                    filterKeys: FilterKey { name : "pass"; value : "lights" }
                     shaderProgram: ShaderProgram {
                         vertexShaderCode: loadSource("qrc:/lights_gl3.vert")
                         fragmentShaderCode: loadSource("qrc:/lights_gl3.frag")
                     }
+                },
+                RenderPass
+                {
+                    filterKeys : FilterKey { name : "pass"; value : "forward" }
+                    shaderProgram : ShaderProgram {
+                        id : sceneShaderGL3
+                        vertexShaderCode:
+                            "#version 140
+
+                            in vec4 vertexPosition;
+                            uniform mat4 modelMatrix;
+
+                            void main()
+                            {
+                                gl_Position = modelMatrix * vertexPosition;
+                            }"
+                        fragmentShaderCode:
+                            "#version 140
+
+                            uniform sampler2D color;
+                            uniform vec2 winSize;
+
+                            out vec4 fragColor;
+
+                            void main()
+                            {
+                                vec2 texCoord = gl_FragCoord.xy / winSize;
+                                fragColor = texture(color, texCoord);
+                            }"
+                    }
                 }
+            ]
         },
-        // OpenGL 2.0 with FBO extension
+        // Light pass - OpenGL 2.0 with FBO extension
         Technique
         {
             graphicsApiFilter { api: GraphicsApiFilter.OpenGL; profile: GraphicsApiFilter.NoProfile; majorVersion: 2; minorVersion: 0 }
             renderPasses:
                 RenderPass
                 {
-                    filterKeys: FilterKey { name: "pass"; value: "final" }
+                    filterKeys: FilterKey { name: "pass"; value: "lights" }
                     shaderProgram: ShaderProgram {
                         vertexShaderCode: loadSource("qrc:/lights_es2.vert")
                         fragmentShaderCode: loadSource("qrc:/lights_es2.frag")