Merge branch 'dev' into geo-threepp

markaren · Mar 16, 2024 · c1b4b46 · c1b4b46
2 parents 1c23002 + a804a5d
commit c1b4b46
Show file tree

Hide file tree

Showing 12 changed files with 103 additions and 42 deletions.
diff --git a/examples/extras/physics/physx_demo.cpp b/examples/extras/physics/physx_demo.cpp
@@ -229,7 +229,7 @@ int main() {
             camera.getWorldDirection(world);
             rb->addForce(toPxVector3(world * 10000));
 
-            canvas.invokeLater([&, obj] {
+            renderer.invokeLater([&, obj] {
                 scene.remove(*obj);
             },
                                2);// remove after 2 seconds

diff --git a/examples/geometries/heightmap.cpp b/examples/geometries/heightmap.cpp
@@ -121,7 +121,7 @@ int main() {
         TextureLoader tl;
         auto texture = tl.load("data/textures/terrain/aalesund_terrain.png");
 
-        canvas.invokeLater([&, texture, geometry] {
+        renderer.invokeLater([&, texture, geometry] {
 
             material->map = texture;
             material->needsUpdate();
@@ -130,7 +130,7 @@ int main() {
             hudText.setText("Terrain loaded..", opts);
         });
 
-        canvas.invokeLater([&] {
+        renderer.invokeLater([&] {
             hud.remove(hudText);
         },
                            2);

diff --git a/examples/projects/Crane3R/main.cpp b/examples/projects/Crane3R/main.cpp
@@ -147,7 +147,7 @@ int main() {
             m.castShadow = true;
         });
 
-        canvas.invokeLater([&, crane] {
+        renderer.invokeLater([&, crane] {
             hud.remove(handle);
             scene->add(crane);
             endEffectorHelper->visible = true;

diff --git a/examples/projects/Pathfinding/main.cpp b/examples/projects/Pathfinding/main.cpp
@@ -126,13 +126,13 @@ int main() {
                         auto obj = scene.getObjectByName(getMeshName(c));
                         obj->material()->as<MaterialWithColor>()->color.setHex(Color::green);
                     }
-                    canvas.invokeLater([&] {
+                    renderer.invokeLater([&] {
                         start = std::nullopt;
                         target = std::nullopt;
                         resetBlockColors(); }, 2);
                 } else {
                     std::cerr << "Unable to find path between " << *start << " and " << *target << std::endl;
-                    canvas.invokeLater([&] {
+                    renderer.invokeLater([&] {
                         start = std::nullopt;
                         target = std::nullopt;
                         resetBlockColors(); }, 1);

diff --git a/examples/projects/Youbot/youbot.cpp b/examples/projects/Youbot/youbot.cpp
@@ -47,7 +47,7 @@ int main() {
     std::shared_ptr<Youbot> youbot;
     auto future = std::async([&] {
         youbot = Youbot::create("data/models/collada/youbot.dae");
-        canvas.invokeLater([&] {
+        renderer.invokeLater([&] {
             canvas.addKeyListener(*youbot);
             scene->add(youbot);
             handle.setText("Use WASD keys to steer robot", opts);

diff --git a/examples/projects/Youbot/youbot_kine.cpp b/examples/projects/Youbot/youbot_kine.cpp
@@ -112,7 +112,7 @@ int main() {
         youbot->add(targetHelper);
         youbot->add(endEffectorHelper);
         endEffectorHelper->visible = true;
-        canvas.invokeLater([&] {
+        renderer.invokeLater([&] {
             canvas.addKeyListener(*youbot);
             scene->add(youbot);
             hud.remove(handle);

diff --git a/include/threepp/canvas/Canvas.hpp b/include/threepp/canvas/Canvas.hpp
@@ -44,8 +44,6 @@ namespace threepp {
         // returns false if application should quit, true otherwise
         bool animateOnce(const std::function<void()>& f);
 
-        void invokeLater(const std::function<void()>& f, float t = 0);
-
         void close();
 
         [[nodiscard]] void* windowPtr() const;

diff --git a/include/threepp/renderers/GLRenderer.hpp b/include/threepp/renderers/GLRenderer.hpp
@@ -17,6 +17,7 @@
 #include "threepp/renderers/gl/GLShadowMap.hpp"
 #include "threepp/renderers/gl/GLState.hpp"
 
+#include <functional>
 #include <memory>
 #include <vector>
 
@@ -152,6 +153,8 @@ namespace threepp {
 
         void resetState();
 
+        void invokeLater(const std::function<void()>& task, float delay = 0);
+
         [[nodiscard]] const gl::GLInfo& info() const;
 
         [[nodiscard]] std::optional<unsigned int> getGlTextureId(Texture& texture) const;

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -233,6 +233,7 @@ set(privateHeaders
         "threepp/renderers/gl/UniformUtils.hpp"
 
         "threepp/utils/RegexUtil.hpp"
+        "threepp/utils/TaskManager.hpp"
 
 )
 

diff --git a/src/threepp/canvas/Canvas.cpp b/src/threepp/canvas/Canvas.cpp
@@ -16,18 +16,11 @@
 
 #include <iostream>
 #include <optional>
-#include <queue>
 
 using namespace threepp;
 
 namespace {
 
-    typedef std::pair<std::function<void()>, float> Task;
-
-    struct CustomComparator {
-        bool operator()(const Task& l, const Task& r) const { return l.second > r.second; }
-    };
-
 #if EMSCRIPTEN
     struct FunctionWrapper {
         std::function<void()> loopFunction;
@@ -173,7 +166,6 @@ struct Canvas::Impl {
     bool close_{false};
     bool exitOnKeyEscape_;
 
-    std::priority_queue<Task, std::vector<Task>, CustomComparator> tasks_;
     std::optional<std::function<void(WindowSize)>> resizeListener;
 
     explicit Impl(Canvas& scope, const Canvas::Parameters& params)
@@ -248,26 +240,12 @@ struct Canvas::Impl {
         glfwSetWindowSize(window, size.width, size.height);
     }
 
-    inline void handleTasks() {
-        while (!tasks_.empty()) {
-            auto& task = tasks_.top();
-            if (task.second < glfwGetTime()) {
-                task.first();
-                tasks_.pop();
-            } else {
-                break;
-            }
-        }
-    }
-
     bool animateOnce(const std::function<void()>& f) {
 
         if (close_ || glfwWindowShouldClose(window)) {
             return false;
         }
 
-        handleTasks();
-
         f();
 
         glfwSwapBuffers(window);
@@ -289,10 +267,6 @@ struct Canvas::Impl {
         this->resizeListener = std::move(f);
     }
 
-    void invokeLater(const std::function<void()>& f, float t) {
-        tasks_.emplace(f, static_cast<float>(glfwGetTime()) + t);
-    }
-
     void close() {
 
         close_ = true;
@@ -416,11 +390,6 @@ void Canvas::onWindowResize(std::function<void(WindowSize)> f) {
     pimpl_->onWindowResize(std::move(f));
 }
 
-void Canvas::invokeLater(const std::function<void()>& f, float t) {
-
-    pimpl_->invokeLater(f, t);
-}
-
 void Canvas::close() {
 
     pimpl_->close();

diff --git a/src/threepp/renderers/GLRenderer.cpp b/src/threepp/renderers/GLRenderer.cpp
@@ -21,7 +21,6 @@
 #include "threepp/cameras/OrthographicCamera.hpp"
 #include "threepp/core/InstancedBufferGeometry.hpp"
 #include "threepp/materials/RawShaderMaterial.hpp"
-#include "threepp/math/Frustum.hpp"
 
 #include "threepp/objects/Group.hpp"
 #include "threepp/objects/InstancedMesh.hpp"
@@ -33,17 +32,31 @@
 #include "threepp/objects/SkinnedMesh.hpp"
 #include "threepp/objects/Sprite.hpp"
 
+#include "threepp/utils/TaskManager.hpp"
+
 #ifndef EMSCRIPTEN
 #include "threepp/utils/LoadGlad.hpp"
 #else
 #include <GLES3/gl32.h>
 #endif
 
+#include <chrono>
 #include <cmath>
 
 
 using namespace threepp;
 
+namespace {
+
+    double getCurrentTimeInSeconds() {
+        using Clock = std::chrono::high_resolution_clock;
+        const auto now = Clock::now();
+        const auto duration = now.time_since_epoch();
+        return std::chrono::duration<double>(duration).count();
+    }
+
+}// namespace
+
 
 struct GLRenderer::Impl {
 
@@ -140,6 +153,10 @@ struct GLRenderer::Impl {
 
     gl::GLShadowMap shadowMap;
 
+    // used for in-thread task execution
+    double previousTime{-1};
+    utils::TaskManager taskManager;
+
     Impl(GLRenderer& scope, WindowSize size, const GLRenderer::Parameters& parameters)
         : scope(scope), _size(size),
           cubemaps(scope),
@@ -163,6 +180,11 @@ struct GLRenderer::Impl {
         this->setScissor(0, 0, _size.width, _size.height);
     }
 
+    void invokeLater(const std::function<void()>& task, float delay) {
+
+        taskManager.invokeLater(task, delay);
+    }
+
     [[nodiscard]] std::optional<unsigned int> getGlTextureId(Texture& texture) const {
 
         return textures.getGlTexture(texture);
@@ -188,8 +210,23 @@ struct GLRenderer::Impl {
         }
     }
 
+    void handleTasks() {
+        // handle tasks to be invoked on the render thread
+        if (previousTime < 0) {
+            previousTime = getCurrentTimeInSeconds();// first invocation
+        }
+
+        const auto currentTime = getCurrentTimeInSeconds();
+        const auto deltaTime = currentTime - previousTime;
+        previousTime = currentTime;
+
+        taskManager.handleTasks(deltaTime);
+    }
+
     void render(Object3D* scene, Camera* camera) {
 
+        handleTasks();
+
         // update scene graph
 
         if (auto _scene = scene->as<Scene>()) {
@@ -1363,4 +1400,9 @@ std::optional<unsigned int> GLRenderer::getGlTextureId(Texture& texture) const {
     return pimpl_->getGlTextureId(texture);
 }
 
+void GLRenderer::invokeLater(const std::function<void()>& task, float tThen) {
+
+    return pimpl_->invokeLater(task, tThen);
+}
+
 GLRenderer::~GLRenderer() = default;
diff --git a/src/threepp/utils/TaskManager.hpp b/src/threepp/utils/TaskManager.hpp
@@ -0,0 +1,48 @@
+
+#ifndef THREEPP_TASKMANAGER_HPP
+#define THREEPP_TASKMANAGER_HPP
+
+#include <functional>
+#include <queue>
+#include <utility>
+
+namespace threepp::utils {
+
+    using Task = std::pair<std::function<void()>, double>;
+
+    class TaskManager {
+
+    public:
+        inline void handleTasks(double deltaTime) {
+
+            time += deltaTime;
+
+            while (!tasks_.empty()) {
+                auto& task = tasks_.top();
+                if (task.second < time) {
+                    task.first();
+                    tasks_.pop();
+                } else {
+                    break;
+                }
+            }
+        }
+
+        void invokeLater(const std::function<void()>& f, double delay = 0) {
+
+            tasks_.emplace(f, time + delay);
+        }
+
+    private:
+        struct CustomComparator {
+            bool operator()(const Task& l, const Task& r) const { return l.second > r.second; }
+        };
+
+        double time{};
+
+        std::priority_queue<Task, std::vector<Task>, CustomComparator> tasks_;
+    };
+
+}// namespace threepp::utils
+
+#endif//THREEPP_TASKMANAGER_HPP