Merge pull request #12624 from samcake/workload-bis

Workload: Better Freeze view mode in order to debug the Space and View behavior

interface/src/workload/GameWorkloadRenderer.cpp

@@ -18,6 +18,7 @@
 #include "render-utils/drawWorkloadProxy_vert.h"
 #include "render-utils/drawWorkloadView_vert.h"
 #include "render-utils/drawWorkloadProxy_frag.h"
+#include "render-utils/drawWorkloadView_frag.h"
 
 
 void GameSpaceToRender::configure(const Config& config) {
@@ -59,9 +60,7 @@ void GameSpaceToRender::run(const workload::WorkloadContextPointer& runContext,
     space->copyProxyValues(proxies.data(), (uint32_t)proxies.size());
 
     workload::Views views(space->getNumViews());
-    if (!freezeViews) {
-        space->copyViews(views);
-    }
+    space->copyViews(views);
 
     // Valid space, let's display its content
     if (!render::Item::isValidID(_spaceRenderItemID)) {
@@ -77,9 +76,7 @@ void GameSpaceToRender::run(const workload::WorkloadContextPointer& runContext,
         item.showProxies(showProxies);
         item.setAllProxies(proxies);
         item.showViews(showViews);
-        if (!freezeViews) {
-            item.setAllViews(views);
-        }
+        item.setAllViews(views);
     });
     
     scene->enqueueTransaction(transaction);
@@ -182,11 +179,12 @@ const gpu::PipelinePointer GameWorkloadRenderItem::getProxiesPipeline() {
 const gpu::PipelinePointer GameWorkloadRenderItem::getViewsPipeline() {
     if (!_drawAllViewsPipeline) {
         auto vs = drawWorkloadView_vert::getShader();
-        auto ps = drawWorkloadProxy_frag::getShader();
+        auto ps = drawWorkloadView_frag::getShader();
         gpu::ShaderPointer program = gpu::Shader::createProgram(vs, ps);
 
         gpu::Shader::BindingSet slotBindings;
         slotBindings.insert(gpu::Shader::Binding("workloadViewsBuffer", 1));
+        slotBindings.insert(gpu::Shader::Binding("drawMeshBuffer", 0));
         gpu::Shader::makeProgram(*program, slotBindings);
 
         auto state = std::make_shared<gpu::State>();
@@ -201,6 +199,32 @@ const gpu::PipelinePointer GameWorkloadRenderItem::getViewsPipeline() {
     }
     return _drawAllViewsPipeline;
 }
+
+const gpu::BufferPointer GameWorkloadRenderItem::getDrawViewBuffer() {
+    if (!_drawViewBuffer) {
+        int numSegments = 64;
+        float angleStep = (float)M_PI * 2.0f / (float)numSegments;
+
+        struct Vert {
+            glm::vec4 p;
+        };
+        std::vector<Vert> verts(numSegments + 1);
+        for (int i = 0; i < numSegments; i++) {
+            float angle = (float)i * angleStep;
+            verts[i].p.x = cos(angle);
+            verts[i].p.y = sin(angle);
+            verts[i].p.z = angle;
+            verts[i].p.w = 1.0f;
+        }
+        verts[numSegments] = verts[0];
+        verts[numSegments].p.w = 0.0f;
+
+        _drawViewBuffer = std::make_shared<gpu::Buffer>(verts.size() * sizeof(Vert), (const gpu::Byte*) verts.data());
+        _numDrawViewVerts = numSegments + 1;
+    }
+    return _drawViewBuffer;
+}
+
 void GameWorkloadRenderItem::render(RenderArgs* args) {
     gpu::Batch& batch = *(args->_batch);
 
@@ -221,8 +245,11 @@ void GameWorkloadRenderItem::render(RenderArgs* args) {
     if (_showViews) {
         batch.setPipeline(getViewsPipeline());
 
-        static const int NUM_VERTICES_PER_VIEW = 27;
-        batch.draw(gpu::TRIANGLES, NUM_VERTICES_PER_VIEW * _numAllViews, 0);
+        batch.setUniformBuffer(0, getDrawViewBuffer());
+        static const int NUM_VERTICES_PER_DRAWVIEWVERT = 2;
+        static const int NUM_REGIONS = 3;
+        batch.draw(gpu::TRIANGLE_STRIP, NUM_REGIONS * NUM_VERTICES_PER_DRAWVIEWVERT * _numDrawViewVerts, 0);
+
     }
 
     batch.setResourceBuffer(0, nullptr);

interface/src/workload/GameWorkloadRenderer.h

@@ -21,7 +21,7 @@ public:
 
     bool freezeViews{ false };
     bool showProxies{ false };
-    bool showViews{ false };
+    bool showViews{ true };
 signals:
     void dirty();
 
@@ -85,6 +85,10 @@ protected:
     gpu::PipelinePointer _drawAllViewsPipeline;
     const gpu::PipelinePointer getViewsPipeline();
 
+    uint32_t _numDrawViewVerts{ 0 };
+    gpu::BufferPointer _drawViewBuffer;
+    const gpu::BufferPointer getDrawViewBuffer();
+
     render::ItemKey _key;
     bool _showProxies{ true };
     bool _showViews{ true };

libraries/render-utils/src/drawWorkloadProxy.slf

@@ -17,10 +17,12 @@ in vec4 varColor;
 in vec3 varTexcoord;
 
 void main(void) {
-    float r = sqrt(dot(varTexcoord.xyz,varTexcoord.xyz));
-    float a = paintStripe(r * varColor.w, 0.0, 1.0 / varColor.w, 0.05 / varColor.w);
-    if (a <= 0.1 || r > 1.1) {
-        discard;
+    if (varColor.w > 0.0) {
+        float r = sqrt(dot(varTexcoord.xyz,varTexcoord.xyz));
+        float a = paintStripe(r * varColor.w, 0.0, 1.0 / varColor.w, 0.05 / varColor.w);
+        if (a <= 0.1 || r > 1.1) {
+            discard;
+        }
     }
 
     packDeferredFragmentUnlit(

libraries/render-utils/src/drawWorkloadView.slf

@@ -0,0 +1,32 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  drawItemBounds.frag
+//  fragment shader
+//
+//  Created by Sam Gateau on 6/29/15.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+<@include DeferredBufferWrite.slh@>
+<@include gpu/Paint.slh@>
+
+in vec4 varColor;
+in vec3 varTexcoord;
+
+void main(void) {
+    if (varColor.w > 0.0) {
+        float r = sqrt(dot(varTexcoord.xyz,varTexcoord.xyz));
+        float a = paintStripe(r * varColor.w, 0.0, 1.0 / varColor.w, 0.05 / varColor.w);
+        if (a <= 0.1 || r > 1.1) {
+            discard;
+        }
+    }
+
+    packDeferredFragmentUnlit(
+        vec3(0.0, 1.0, 0.0), 
+        1.0,
+        varColor.rgb);
+}

libraries/render-utils/src/drawWorkloadView.slv

@@ -49,73 +49,71 @@ WorkloadView getWorkloadView(int i) {
 
 
 
+
+
 out vec4 varColor;
 out vec3 varTexcoord;
 
-const int NUM_VERTICES_PER_VIEW = 27;
+const int NUM_VERTICES_PER_SEGMENT = 2;
+const int NUM_SEGMENT_PER_VIEW_REGION = 65;
+const int NUM_VERTICES_PER_VIEW_REGION = NUM_SEGMENT_PER_VIEW_REGION * NUM_VERTICES_PER_SEGMENT;
 const int NUM_REGIONS_PER_VIEW = 3;
-const int NUM_VERTICES_PER_VIEW_REGION = NUM_VERTICES_PER_VIEW / NUM_REGIONS_PER_VIEW;
+const int NUM_VERTICES_PER_VIEW = NUM_VERTICES_PER_VIEW_REGION * NUM_REGIONS_PER_VIEW;
+
+
+layout(std140) uniform drawMeshBuffer {
+    vec4 verts[NUM_SEGMENT_PER_VIEW_REGION];
+};
 
 void main(void) {
-    const vec4 UNIT_SPRITE[NUM_VERTICES_PER_VIEW_REGION] = vec4[NUM_VERTICES_PER_VIEW_REGION](
-        vec4(-1.0, -1.0, 0.0, 1.0),
-        vec4(3.0, -1.0, 0.0, 1.0),
-        vec4(-1.0, 3.0, 0.0, 1.0),
-
-        vec4(-1.0, 0.0, -1.0, 1.0),
-        vec4(3.0, 0.0, -1.0, 1.0),
-        vec4(-1.0, 0.0, 3.0, 1.0),
-
-        vec4(0.0, -1.0, -1.0, 1.0),
-        vec4(0.0, 3.0, -1.0, 1.0),
-        vec4(0.0, -1.0, 3.0, 1.0)
-    );
-     const int UNIT_SPRITE_INDICES[NUM_VERTICES_PER_VIEW_REGION] = int[NUM_VERTICES_PER_VIEW_REGION](
-        0, 1, 2, 3, 4, 5, 6, 7, 8
-    );
-
     int viewID = gl_VertexID / NUM_VERTICES_PER_VIEW;
     int viewVertexID = gl_VertexID - viewID * NUM_VERTICES_PER_VIEW;
 
     int regionID = viewVertexID / NUM_VERTICES_PER_VIEW_REGION;
     int regionVertexID = viewVertexID - regionID * NUM_VERTICES_PER_VIEW_REGION;
 
-    int vertexID = regionVertexID;
+    int segmentID = regionVertexID / NUM_VERTICES_PER_SEGMENT;
+    int segmentVertexID = regionVertexID - segmentID * NUM_VERTICES_PER_SEGMENT;
 
-    vec4 spriteVert = UNIT_SPRITE[UNIT_SPRITE_INDICES[vertexID]];
+    vec4 segment = verts[segmentID];
+
+    vec4 spriteVert = vec4(segment.y, 0.0, segment.x, 1.0);
+    vec3 spriteTan = vec3(segment.x, 0.0, -segment.y);
+
+    vec3 lateralDir = vec3(0.0,  -1.0 + 2.0 * float(segmentVertexID), 0.0);
 
     WorkloadView view = getWorkloadView(viewID);
-
     vec4 region = view.regions[regionID];
-
     vec4 proxyPosWorld = vec4(region.xyz, 1.0);
+    float regionRadius = region.w;
 
-    // standard transform, bring proxy in view space
+    // Define the sprite space
+    vec3 dirZ = -normalize(view.direction_far.xyz);
+    vec3 dirY = vec3(0.0, 1.0, 0.0);
+    vec3 dirX = normalize(cross(dirY, dirZ));
+    dirY = normalize(cross(dirZ, dirX));
+
+    spriteVert.xyz *= regionRadius; 
+    vec3 originSpaceVert = (dirX * spriteVert.x + dirY * spriteVert.y + dirZ * spriteVert.z);
+    vec4 pos = vec4(proxyPosWorld.xyz + originSpaceVert, 1.0);
+
+    vec3 originSpaceTan = normalize(dirX * spriteTan.x + dirY * spriteTan.y + dirZ * spriteTan.z);
+
+    // standard transform, bring pos in view space
     TransformCamera cam = getTransformCamera();
     TransformObject obj = getTransformObject();
-    vec4 proxyPosEye;
-    <$transformModelToEyePos(cam, obj, proxyPosWorld, proxyPosEye)$>
+    vec4 posEye;
+    <$transformModelToEyePos(cam, obj, pos, posEye)$>
+    vec3 tanEye;
+    <$transformModelToEyeDir(cam, obj, originSpaceTan, tanEye)$>
 
-    // Define the billboarded space
-    vec3 dirZ = vec3(0.0, 0.0, 1.0);
-    vec3 dirX = vec3(1.0, 0.0, 0.0);
-    vec3 dirY = vec3(0.0, 1.0, 0.0);
+    lateralDir = normalize(cross(vec3(0.0, 0.0, 1.0), normalize(tanEye)));
+    posEye.xyz += (0.05 * (regionID + 1)) * (-1.0 + 2.0 * float(segmentVertexID)) * lateralDir;
 
-    /*normalize(cross(vec3(0.0, 1.0, 0.0), dirZ));
-    if (dot(proxyPosEye.xyz, proxyPosEye.xyz) > 0.01) {
-        dirZ = -normalize(proxyPosEye.xyz);
-    }
-    vec3 dirX = normalize(cross(vec3(0.0, 1.0, 0.0), dirZ));
-    vec3 dirY = normalize(cross(dirZ, dirX));
-    */
-   float regionRadius = region.w;
+    <$transformEyeToClipPos(cam, posEye, gl_Position)$>
 
-    vec3 originSpaceVert =  dirY * (-0.02) + regionRadius * ( dirX * spriteVert.x + dirY * spriteVert.y + dirZ * spriteVert.z);
-
-    vec4 pos = vec4(proxyPosEye.xyz + originSpaceVert, 1.0);
     varTexcoord = spriteVert.xyz;
-    <$transformEyeToClipPos(cam, pos, gl_Position)$>
 
     // Convert region to color
-    varColor = vec4(colorWheel(float(regionID) / 4.0), regionRadius);
+    varColor = vec4(colorWheel(float(regionID) / 4.0), -1.0);
 }

libraries/workload/src/workload/ViewTask.cpp

@@ -18,12 +18,17 @@ void SetupViews::configure(const Config& config) {
 }
 
 void SetupViews::run(const WorkloadContextPointer& renderContext, const Input& inputs) {
-    
-    Views views = inputs;
-    for (auto& v : views) {
+    // If views are frozen don't use the input
+    if (!data.freezeViews) {
+        _views = inputs;
+    }
+
+    // Update regions based on the current config
+    for (auto& v : _views) {
         View::updateRegions(v, (float*) &data);
     }
 
-    renderContext->_space->setViews(views);
+    // Views are setup, assign to the Space
+    renderContext->_space->setViews(_views);
 }
 

libraries/workload/src/workload/ViewTask.h

@@ -16,14 +16,14 @@
 namespace workload {
     class SetupViewsConfig : public Job::Config{
         Q_OBJECT
-            Q_PROPERTY(float r1Front READ getR1Front WRITE setR1Front NOTIFY dirty)
-            Q_PROPERTY(float r1Back READ getR1Back WRITE setR1Back NOTIFY dirty)
-            Q_PROPERTY(float r2Front READ getR2Front WRITE setR2Front NOTIFY dirty)
-            Q_PROPERTY(float r2Back READ getR2Back WRITE setR2Back NOTIFY dirty)
-            Q_PROPERTY(float r3Front READ getR3Front WRITE setR3Front NOTIFY dirty)
-            Q_PROPERTY(float r3Back READ getR3Back WRITE setR3Back NOTIFY dirty)
+        Q_PROPERTY(float r1Front READ getR1Front WRITE setR1Front NOTIFY dirty)
+        Q_PROPERTY(float r1Back READ getR1Back WRITE setR1Back NOTIFY dirty)
+        Q_PROPERTY(float r2Front READ getR2Front WRITE setR2Front NOTIFY dirty)
+        Q_PROPERTY(float r2Back READ getR2Back WRITE setR2Back NOTIFY dirty)
+        Q_PROPERTY(float r3Front READ getR3Front WRITE setR3Front NOTIFY dirty)
+        Q_PROPERTY(float r3Back READ getR3Back WRITE setR3Back NOTIFY dirty)
+        Q_PROPERTY(bool freezeViews READ getFreezeView WRITE setFreezeView NOTIFY dirty)
     public:
-        SetupViewsConfig() : Job::Config(true) {}
 
 
         float getR1Front() const { return data.r1Front; }
@@ -40,6 +40,9 @@ namespace workload {
         void setR3Front(float d) { data.r3Front = d; emit dirty(); }
         void setR3Back(float d) { data.r3Back = d; emit dirty(); }
 
+        bool getFreezeView() const { return data.freezeViews; }
+        void setFreezeView(bool freeze) { data.freezeViews = freeze; emit dirty(); }
+
         struct Data {
             float r1Back { 2.0f };
             float r1Front { 10.0f };
@@ -49,6 +52,8 @@ namespace workload {
 
             float r3Back{ 10.0f };
             float r3Front{ 100.0f };
+
+            bool freezeViews{ false };
         } data;
 
     signals:
@@ -66,6 +71,7 @@ namespace workload {
 
     protected:
         Config::Data data;
+        Views _views;
     };
 
 } // namespace workload

scripts/developer/utilities/workload/workload.qml

@@ -37,8 +37,8 @@ Rectangle {
         HifiControls.CheckBox {
             boxSize: 20
             text: "Freeze Views"
-            checked: workload.spaceToRender["freezeViews"]
-            onCheckedChanged: { workload.spaceToRender["freezeViews"] = checked, workload.setupViews.enabled = !checked; }
+            checked: workload.setupViews["freezeViews"]
+            onCheckedChanged: { workload.spaceToRender["freezeViews"] = checked, workload.setupViews["freezeViews"] = checked; }
         }
 
         RowLayout {