Proposing a more flexible design for the engine

interface/src/workload/GameWorkload.cpp

@@ -11,13 +11,14 @@
 #include "GameWorkloadRenderer.h"
 #include <ViewFrustum.h>
 #include <workload/RegionTracker.h>
+#include <workload/SpaceClassifier.h>
 
 #include "PhysicsBoundary.h"
 
 GameWorkloadContext::GameWorkloadContext(const workload::SpacePointer& space,
         const render::ScenePointer& scene,
-        const PhysicalEntitySimulationPointer& simulation)
+        const PhysicalEntitySimulationPointer& simulation): WorkloadContext(space),
-:   WorkloadContext(space), _scene(scene), _simulation(simulation)
+    _scene(scene), _simulation(simulation)
 {
 }
 
@@ -25,7 +26,9 @@ GameWorkloadContext::~GameWorkloadContext() {
 }
 
 
-GameWorkload::GameWorkload() {
+GameWorkload::GameWorkload() :
+    _engine(std::make_shared<workload::Engine>(std::make_shared<workload::Task>(workload::SpaceClassifierTask::JobModel::create("Engine"))))
+{
 }
 
 GameWorkload::~GameWorkload() {
@@ -37,11 +40,11 @@ void GameWorkload::startup(const workload::SpacePointer& space,
         const PhysicalEntitySimulationPointer& simulation) {
     _engine->reset(std::make_shared<GameWorkloadContext>(space, scene, simulation));
 
-    auto output = _engine->getOutput();
+    auto output = _engine->_task->getOutput();
-    _engine->addJob<GameSpaceToRender>("SpaceToRender");
+    _engine->_task->addJob<GameSpaceToRender>("SpaceToRender");
 
-    const auto regionChanges = _engine->getOutput();
+    const auto regionChanges = _engine->_task->getOutput();
-    _engine->addJob<PhysicsBoundary>("PhysicsBoundary", regionChanges);
+    _engine->_task->addJob<PhysicsBoundary>("PhysicsBoundary", regionChanges);
 }
 
 void GameWorkload::shutdown() {
@@ -52,6 +55,9 @@ void GameWorkload::updateViews(const ViewFrustum& frustum, const glm::vec3& head
     workload::Views views;
     views.emplace_back(workload::View::evalFromFrustum(frustum, headPosition - frustum.getPosition()));
     views.emplace_back(workload::View::evalFromFrustum(frustum));
-    _engine->feedInput(views);
+    _engine->_task->feedInput(views);
 }
 
+void GameWorkload::updateSimulationTiming(const workload::Timings& timings) {
+  //  _engine->_task->feedInput(timings);
+}

interface/src/workload/GameWorkload.h

@@ -38,8 +38,9 @@ public:
     void shutdown();
 
     void updateViews(const ViewFrustum& frustum, const glm::vec3& headPosition);
+    void updateSimulationTimings(const workload::Timings& timings);
 
-    workload::EnginePointer _engine { std::make_shared<workload::Engine>() };
+    workload::EnginePointer _engine;
 };
 
 #endif // hifi_GameWorkload_h

libraries/workload/src/workload/Engine.cpp

@@ -13,43 +13,11 @@
 
 #include <iostream>
 
-#include "ViewTask.h"
-#include "RegionTracker.h"
-#include "RegionState.h"
-
 namespace workload {
     WorkloadContext::WorkloadContext(const SpacePointer& space) : task::JobContext(trace_workload()), _space(space) {}
 
-    class EngineBuilder {
-    public:
-        using Inputs = Views;
-        using Outputs = RegionTracker::Outputs;
-        using JobModel = Task::ModelIO<EngineBuilder, Inputs, Outputs>;
-        void build(JobModel& model, const Varying& in, Varying& out) {
-            model.addJob<SetupViews>("setupViews", in);
-            model.addJob<PerformSpaceTransaction>("updateSpace");
-            const auto regionTrackerOut = model.addJob<RegionTracker>("regionTracker");
-            const auto regionChanges = regionTrackerOut.getN<RegionTracker::Outputs>(1);
-            model.addJob<RegionState>("regionState", regionChanges);
-            out = regionTrackerOut;
-        }
-    };
-
-    Engine::Engine() : Task(EngineBuilder::JobModel::create("Engine")),
-            _context(nullptr) {
-    }
-
     void Engine::reset(const WorkloadContextPointer& context) {
         _context = context;
     }
-
-    void PerformSpaceTransaction::configure(const Config& config) {
-
-    }
-    void PerformSpaceTransaction::run(const WorkloadContextPointer& context) {
-        context->_space->enqueueFrame();
-        context->_space->processTransactionQueue();
-    }
-
 } // namespace workload
 

libraries/workload/src/workload/Engine.h

@@ -23,7 +23,6 @@
 #include "Space.h"
 
 namespace workload {
-
     class WorkloadContext : public task::JobContext {
     public:
         WorkloadContext(const SpacePointer& space);
@@ -35,41 +34,26 @@ namespace workload {
     using WorkloadContextPointer = std::shared_ptr<WorkloadContext>;
     Task_DeclareTypeAliases(WorkloadContext)
 
-    class Engine : public Task {
+    class Engine {
     public:
-        Engine();
+        Engine(const std::shared_ptr<Task>& task) : _task(task), _context(nullptr) {
+        }
         ~Engine() = default;
 
         void reset(const WorkloadContextPointer& context);
 
-        void run() { if (_context) { run(_context); } }
+        void run() { if (_context) { _task->run(_context); } }
+
+        std::shared_ptr<TaskConfig> getConfiguration() { return _task->getConfiguration(); }
+
+        std::shared_ptr<Task> _task;
 
     protected:
-        void run(const WorkloadContextPointer& context) override { assert(_context); Task::run(_context); }
 
     private:
         WorkloadContextPointer _context;
     };
     using EnginePointer = std::shared_ptr<Engine>;
-
-    class PerformSpaceTransactionConfig : public Job::Config {
-        Q_OBJECT
-    public:
-    signals :
-         void dirty();
-
-    protected:
-    };
-
-    class PerformSpaceTransaction {
-    public:
-        using Config = PerformSpaceTransactionConfig;
-        using JobModel = Job::Model<PerformSpaceTransaction, Config>;
-
-        void configure(const Config& config);
-        void run(const WorkloadContextPointer& context);
-    protected:
-    };
 } // namespace workload
 
 #endif // hifi_workload_Space_h

libraries/workload/src/workload/RegionTracker.h

@@ -39,7 +39,6 @@ namespace workload {
 
     protected:
     };
-
 } // namespace workload
 
 #endif // hifi_workload_RegionTracker_h

libraries/workload/src/workload/Space.h

@@ -70,6 +70,7 @@ private:
 using SpacePointer = std::shared_ptr<Space>;
 using Changes = std::vector<Space::Change>;
 using IndexVectors = std::vector<IndexVector>;
+using Timings = std::vector<float>;
 
 } // namespace workload
 

libraries/workload/src/workload/SpaceClassifier.cpp

@@ -0,0 +1,34 @@
+//
+//  SpaceClassifier.cpp
+//  libraries/workload/src/workload
+//
+//  Created by Andrew Meadows 2018.02.21
+//  Copyright 2018 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 "SpaceClassifier.h"
+
+#include "ViewTask.h"
+#include "RegionState.h"
+
+using namespace workload;
+
+void PerformSpaceTransaction::configure(const Config& config) {
+
+}
+void PerformSpaceTransaction::run(const WorkloadContextPointer& context) {
+    context->_space->enqueueFrame();
+    context->_space->processTransactionQueue();
+}
+
+void SpaceClassifierTask::build(JobModel& model, const Varying& in, Varying& out) {
+    model.addJob<SetupViews>("setupViews", in);
+    model.addJob<PerformSpaceTransaction>("updateSpace");
+    const auto regionTrackerOut = model.addJob<RegionTracker>("regionTracker");
+    const auto regionChanges = regionTrackerOut.getN<RegionTracker::Outputs>(1);
+    model.addJob<RegionState>("regionState", regionChanges);
+    out = regionTrackerOut;
+}
+

libraries/workload/src/workload/SpaceClassifier.h

@@ -0,0 +1,47 @@
+//
+//  SpaceClassifier.h
+//  libraries/workload/src/workload
+//
+//  Created by Andrew Meadows 2018.02.21
+//  Copyright 2018 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
+//
+#ifndef hifi_workload_SpaceClassifier_h
+#define hifi_workload_SpaceClassifier_h
+
+#include "ViewTask.h"
+#include "RegionTracker.h"
+
+namespace workload {
+    class SpaceClassifierTask {
+    public:
+        using Inputs = Views;
+        using Outputs = RegionTracker::Outputs;
+        using JobModel = Task::ModelIO<SpaceClassifierTask, Inputs, Outputs>;
+        void build(JobModel& model, const Varying& in, Varying& out);
+    };
+
+
+    class PerformSpaceTransactionConfig : public Job::Config {
+        Q_OBJECT
+    public:
+        signals :
+                void dirty();
+
+    protected:
+    };
+
+    class PerformSpaceTransaction {
+    public:
+        using Config = PerformSpaceTransactionConfig;
+        using JobModel = Job::Model<PerformSpaceTransaction, Config>;
+
+        void configure(const Config& config);
+        void run(const WorkloadContextPointer& context);
+    protected:
+    };
+} // namespace workload
+
+#endif // hifi_workload_SpaceClassifier_h

scripts/developer/utilities/workload/workloadInspector.qml

@@ -170,8 +170,17 @@ Rectangle {
         }
         Separator {} 
         HifiControls.Label {
-            text: "Numbers: R2= " + Workload.getConfig("regionState")["numR2"];     
+            text: "Numbers:";     
-        }  
+        }
+        HifiControls.Label {
+            text: "R1= " + Workload.getConfig("regionState")["numR1"];     
+        } 
+        HifiControls.Label {
+            text: "R2= " + Workload.getConfig("regionState")["numR2"];     
+        } 
+        HifiControls.Label {
+            text: "R3= " + Workload.getConfig("regionState")["numR3"];     
+        }   
         Separator {}
         HifiControls.Label {
             text: "Display"