Use subscription based events handling

examples/controls/drag.cpp

@@ -64,29 +64,37 @@ int main() {
     DragControls controls(objects, camera, canvas);
     controls.rotateSpeed = 2;
 
-    struct HoverListener: public EventListener {
-        void onEvent(Event& event) override {
+    struct HoverListener {
+        void hoverOn(Event& event) {
 
             auto target = static_cast<Object3D*>(event.target);
             auto& color = target->material()->as<MaterialWithColor>()->color;
 
-            if (event.type == "hoveron") {
-                prevColor = color;
-                color = Color::white;
-            } else if (event.type == "hoveroff") {
-                color = prevColor;
-            }
+            prevColor = color;
+            color = Color::white;
+        }
+
+        void hoverOff(Event& event) {
+            auto target = static_cast<Object3D*>(event.target);
+            auto& color = target->material()->as<MaterialWithColor>()->color;
+
+            color = prevColor;
         }
 
     private:
         Color prevColor;
 
     } hoverListener;
 
-    controls.addEventListener("hoveron", &hoverListener);
-    controls.addEventListener("hoveroff", &hoverListener);
+    controls.HoverOn.subscribeForever([&hoverListener](auto& evt) {
+        hoverListener.hoverOn(evt);
+    });
+    controls.HoverOff.subscribeForever([&hoverListener](auto& evt) {
+        hoverListener.hoverOff(evt);
+    });
 
-    KeyAdapter keyAdapter(KeyAdapter::Mode::KEY_PRESSED, [&](KeyEvent evt){
+
+    canvas.keys.Pressed.subscribeForever([&](KeyEvent evt) {
         if (evt.key == Key::M) {
             if (controls.mode == DragControls::Mode::Translate) {
                 controls.mode = DragControls::Mode::Rotate;
@@ -95,7 +103,7 @@ int main() {
             }
         }
     });
-    canvas.addKeyListener(keyAdapter);
+
 
     canvas.onWindowResize([&](WindowSize size) {
         camera.aspect = size.aspect();

examples/extras/physics/PxEngine.hpp

@@ -45,8 +45,7 @@ class PxEngine: public threepp::Object3D {
 
     explicit PxEngine(float timeStep = 1.f / 100)
         : timeStep(timeStep),
-          sceneDesc(physics->getTolerancesScale()),
-          onMeshRemovedListener(this) {
+          sceneDesc(physics->getTolerancesScale()) {
 
         sceneDesc.gravity = physx::PxVec3(0.0f, -9.81f, 0.0f);
         sceneDesc.flags |= physx::PxSceneFlag::eENABLE_PCM;
@@ -257,7 +256,15 @@ class PxEngine: public threepp::Object3D {
         }
 
         obj.matrixAutoUpdate = false;
-        obj.addEventListener("remove", &onMeshRemovedListener);
+
+        obj.OnRemove.subscribeOnce([this](threepp::Event& event) {
+            auto m = static_cast<threepp::Object3D*>(event.target);
+            if (bodies.count(m)) {
+                auto rb = bodies.at(m);
+                scene->removeActor(*rb.front());
+                bodies.erase(m);
+            }
+        });
     }
 
     physx::PxJoint* createJoint(const JointCreate& create, threepp::Object3D* o1, threepp::Object3D* o2, threepp::Vector3 anchor, threepp::Vector3 axis) {
@@ -551,28 +558,6 @@ class PxEngine: public threepp::Object3D {
             }
         }
     }
-
-    struct MeshRemovedListener: threepp::EventListener {
-
-        explicit MeshRemovedListener(PxEngine* scope): scope(scope) {}
-
-        void onEvent(threepp::Event& event) override {
-            if (event.type == "remove") {
-                auto m = static_cast<threepp::Object3D*>(event.target);
-                if (scope->bodies.count(m)) {
-                    auto rb = scope->bodies.at(m);
-                    scope->scene->removeActor(*rb.front());
-                    scope->bodies.erase(m);
-                }
-                m->removeEventListener("remove", this);
-            }
-        }
-
-    private:
-        PxEngine* scope;
-    };
-
-    MeshRemovedListener onMeshRemovedListener;
 };
 
 #endif//THREEPP_PXENGINE_HPP

examples/extras/physics/physx_demo.cpp

@@ -9,7 +9,7 @@ using namespace threepp;
 
 namespace {
 
-    struct KeyController: KeyListener {
+    struct KeyController {
 
         explicit KeyController(std::vector<physx::PxRevoluteJoint*> joints)
             : joints(std::move(joints)) {
@@ -19,8 +19,8 @@ namespace {
             }
         }
 
-        void onKeyPressed(KeyEvent evt) override;
-        void onKeyReleased(KeyEvent evt) override;
+        void onKeyPressed(KeyEvent evt);
+        void onKeyReleased(KeyEvent evt);
 
     private:
         float speed = 2;
@@ -211,14 +211,15 @@ int main() {
     auto* j3 = engine.getJoint<physx::PxRevoluteJoint>(*box3);
 
     KeyController keyListener({j1, j2, j3});
-    canvas.addKeyListener(keyListener);
+    canvas.keys.Pressed.subscribeForever([&](KeyEvent evt) { keyListener.onKeyPressed(evt); });
+    canvas.keys.Released.subscribeForever([&](KeyEvent evt) { keyListener.onKeyReleased(evt); });
 
     OrbitControls controls(camera, canvas);
 
     bool run = false;
-    KeyAdapter adapter(KeyAdapter::Mode::KEY_PRESSED | KeyAdapter::KEY_REPEAT, [&](KeyEvent evt) {
-        run = true;
+    canvas.keys.Pressed.subscribeOnce([&](KeyEvent) { run = true; });
 
+    auto keyController = [&](KeyEvent evt){
         if (evt.key == Key::SPACE) {
             auto obj = spawnObject();
             obj->position = camera.position;
@@ -236,8 +237,10 @@ int main() {
         } else if (evt.key == Key::D) {
             engine.debugVisualisation = !engine.debugVisualisation;
         }
-    });
-    canvas.addKeyListener(adapter);
+    };
+
+    canvas.keys.Pressed.subscribeForever(keyController);
+    canvas.keys.Repeat.subscribeForever(keyController);
 
     canvas.onWindowResize([&](WindowSize size) {
         camera.aspect = size.aspect();

examples/misc/lut.cpp

@@ -161,7 +161,7 @@ int main() {
     plane->add(wireframe);
     scene.add(plane);
 
-    KeyAdapter keyAdapter(KeyAdapter::Mode::KEY_PRESSED, [&](KeyEvent evt) {
+    canvas.keys.Pressed.subscribeForever([&](KeyEvent evt) {
         if (evt.key == Key::NUM_1) {
             applyFunc(*planeGeometry, rosenbrock);
             applyFunc(*planeGeometry2, rosenbrock);
@@ -194,7 +194,6 @@ int main() {
         normalizeAndApplyLut(*planeGeometry, 2);
         normalizeAndApplyLut(*planeGeometry2, 2);
     });
-    canvas.addKeyListener(keyAdapter);
 
     canvas.onWindowResize([&](WindowSize size) {
         camera.aspect = size.aspect();

examples/misc/morphtargets.cpp

@@ -107,15 +107,14 @@ int main() {
     });
 
     Vector2 mouse{-Infinity<float>, -Infinity<float>};
-    MouseMoveListener l([&](Vector2 pos) {
+    auto sub = canvas.mouse.Move.subscribe([&](MouseMoveEvent& evt) {
         // calculate mouse position in normalized device coordinates
         // (-1 to +1) for both components
 
         auto size = canvas.size();
-        mouse.x = (pos.x / static_cast<float>(size.width)) * 2 - 1;
-        mouse.y = -(pos.y / static_cast<float>(size.height)) * 2 + 1;
+        mouse.x = (evt.pos.x / static_cast<float>(size.width)) * 2 - 1;
+        mouse.y = -(evt.pos.y / static_cast<float>(size.height)) * 2 + 1;
     });
-    canvas.addMouseListener(l);
 
     Box3 box;
     auto helper = Box3Helper::create(box);

examples/misc/mouse_key_listener.cpp

@@ -7,49 +7,35 @@ using namespace threepp;
 
 namespace {
 
-    struct MyMouseListener: MouseListener {
+	void onMouseDown(MouseButtonEvent & e, double t) {
+		std::cout << "onMouseDown, button= " << e.button << ", pos=" << e.pos << " at t=" << t << std::endl;
+	}
 
-        float& t;
+	void onMouseUp(MouseButtonEvent & e, double t) {
+		std::cout << "onMouseUp, button= " << e.button << ", pos=" << e.pos << " at t=" << t << std::endl;
+	}
 
-        explicit MyMouseListener(float& t): t(t) {}
+	void onMouseMove(MouseMoveEvent &e, double t) {
+		std::cout << "onMouseMove, "
+				  << "pos=" << e.pos << " at t=" << t << std::endl;
+	}
 
-        void onMouseDown(int button, const Vector2& pos) override {
-            std::cout << "onMouseDown, button= " << button << ", pos=" << pos << " at t=" << t << std::endl;
-        }
-
-        void onMouseUp(int button, const Vector2& pos) override {
-            std::cout << "onMouseUp, button= " << button << ", pos=" << pos << " at t=" << t << std::endl;
-        }
-
-        void onMouseMove(const Vector2& pos) override {
-            std::cout << "onMouseMove, "
-                      << "pos=" << pos << " at t=" << t << std::endl;
-        }
-
-        void onMouseWheel(const Vector2& delta) override {
-            std::cout << "onMouseWheel, "
-                      << "delta=" << delta << " at t=" << t << std::endl;
-        }
-    };
+	void onMouseWheel(MouseWheelEvent &e, double t) {
+		std::cout << "onMouseWheel, "
+				  << "delta=" << e.offset << " at t=" << t << std::endl;
+	}
 
-    struct MyKeyListener: KeyListener {
+	void onKeyPressed(KeyEvent evt, double t) {
+		std::cout << "onKeyPressed at t=" << t << std::endl;
+	}
 
-        float& t;
+	void onKeyReleased(KeyEvent evt, double t) {
+		std::cout << "onKeyReleased at t=" << t << std::endl;
+	}
 
-        explicit MyKeyListener(float& t): t(t) {}
-
-        void onKeyPressed(KeyEvent evt) override {
-            std::cout << "onKeyPressed at t=" << t << std::endl;
-        }
-
-        void onKeyReleased(KeyEvent evt) override {
-            std::cout << "onKeyReleased at t=" << t << std::endl;
-        }
-
-        void onKeyRepeat(KeyEvent evt) override {
-            std::cout << "onKeyRepeat at t=" << t << std::endl;
-        }
-    };
+	void onKeyRepeat(KeyEvent evt, double t) {
+		std::cout << "onKeyRepeat at t=" << t << std::endl;
+	}
 
 }// namespace
 
@@ -58,22 +44,29 @@ int main() {
     Canvas canvas("Mouse and Key Listeners Demo");
     Clock clock;
 
-    MyMouseListener ml{clock.elapsedTime};
-    MyKeyListener kl{clock.elapsedTime};
-    canvas.addMouseListener(ml);
-    canvas.addKeyListener(kl);
+	Subscriptions subs_;
+    subs_ << canvas.mouse.Down.subscribe([&](auto& e) { onMouseDown(e, clock.elapsedTime); });
+    subs_ << canvas.mouse.Up.subscribe([&](auto& e) { onMouseUp(e, clock.elapsedTime); });
+    subs_ << canvas.mouse.Move.subscribe([&](auto& e) { onMouseMove(e, clock.elapsedTime); });
+    subs_ << canvas.mouse.Wheel.subscribe([&](auto& e) { onMouseWheel(e, clock.elapsedTime); });
+
+	Subscriptions key_subs_;
+	auto subscribe_keys = [&]() {
+		key_subs_ << canvas.keys.Pressed.subscribe([&](auto& e) {onKeyPressed(e, clock.elapsedTime); });
+		key_subs_ << canvas.keys.Released.subscribe([&](auto& e) {onKeyReleased(e, clock.elapsedTime); });
+		key_subs_ << canvas.keys.Repeat.subscribe([&](auto& e) {onKeyRepeat(e, clock.elapsedTime); });
+	};
 
     bool finish = false;
     canvas.animate([&]() {
         clock.getElapsedTime();
 
         if (clock.elapsedTime > 2 && clock.elapsedTime < 4) {
-            if (canvas.removeKeyListener(kl)) {
-                std::cout << "removed key listener" << std::endl;
-            }
+			key_subs_.clear();
+			std::cout << "removed key listener" << std::endl;
         } else if (!finish && clock.elapsedTime > 5) {
+			subscribe_keys();
             std::cout << "re-added key listener" << std::endl;
-            canvas.addKeyListener(kl);
             finish = true;
         }
     });

examples/misc/raycast.cpp

@@ -52,15 +52,14 @@ int main() {
     });
 
     Vector2 mouse{-Infinity<float>, -Infinity<float>};
-    MouseMoveListener l([&](Vector2 pos) {
+    auto sub = canvas.mouse.Move.subscribe([&](MouseMoveEvent& e) {
         // calculate mouse position in normalized device coordinates
         // (-1 to +1) for both components
 
         auto size = canvas.size();
-        mouse.x = (pos.x / static_cast<float>(size.width)) * 2 - 1;
-        mouse.y = -(pos.y / static_cast<float>(size.height)) * 2 + 1;
+        mouse.x = (e.pos.x / static_cast<float>(size.width)) * 2 - 1;
+        mouse.y = -(e.pos.y / static_cast<float>(size.height)) * 2 + 1;
     });
-    canvas.addMouseListener(l);
 
     Raycaster raycaster;
     raycaster.params.lineThreshold = 0.1f;

examples/objects/decal.cpp

@@ -30,12 +30,12 @@ namespace {
         return decalMaterial;
     }
 
-    class MyMouseListener: public MouseListener {
+    class MyMouseListener {
 
     public:
         Vector2 mouse{-Infinity<float>, -Infinity<float>};
 
-        explicit MyMouseListener(Canvas& canvas): canvas(canvas) {}
+        explicit MyMouseListener(PeripheralsEventSource& canvas): canvas(canvas) {}
 
         bool mouseClick() {
             if (mouseDown) {
@@ -46,18 +46,18 @@ namespace {
             }
         }
 
-        void onMouseDown(int button, const Vector2& pos) override {
-            if (button == 0) {// left mousebutton
+        void onMouseDown(MouseButtonEvent evt) {
+            if (evt.button == 0) {// left mousebutton
                 mouseDown = true;
             }
         }
 
-        void onMouseMove(const Vector2& pos) override {
-            updateMousePos(pos);
+        void onMouseMove(MouseMoveEvent evt) {
+            updateMousePos(evt.pos);
         }
 
     private:
-        Canvas& canvas;
+        PeripheralsEventSource& canvas;
         bool mouseDown = false;
 
         void updateMousePos(Vector2 pos) {
@@ -141,7 +141,8 @@ int main() {
     scene->add(line);
 
     MyMouseListener mouseListener(canvas);
-    canvas.addMouseListener(mouseListener);
+    canvas.mouse.Move.subscribeForever([&mouseListener](auto& evt) {mouseListener.onMouseMove(evt);});
+    canvas.mouse.Down.subscribeForever([&mouseListener](auto& evt) {mouseListener.onMouseDown(evt);});
 
     canvas.onWindowResize([&](WindowSize size) {
         camera->aspect = size.aspect();

examples/objects/instancing.cpp

@@ -111,12 +111,11 @@ int main() {
     });
 
     Vector2 mouse{-Infinity<float>, -Infinity<float>};
-    MouseMoveListener l([&](auto& pos) {
+    auto sub = canvas.mouse.Move.subscribe([&](auto& e) {
         auto size = canvas.size();
-        mouse.x = (pos.x / static_cast<float>(size.width)) * 2 - 1;
-        mouse.y = -(pos.y / static_cast<float>(size.height)) * 2 + 1;
+        mouse.x = (e.pos.x / static_cast<float>(size.width)) * 2 - 1;
+        mouse.y = -(e.pos.y / static_cast<float>(size.height)) * 2 + 1;
     });
-    canvas.addMouseListener(l);
 
 
     Clock clock;