revamped timers

demos/timers/main.py

@@ -15,8 +15,8 @@ class TtlNode(BodyNode):
 
     def __init__(self, **kwargs):
         ttl = kwargs.pop('ttl')
-        self.ttl_timer = Timer(self.delete, ttl)
-        self.ttl_timer.start()
+        self.ttl_timer = Timer(lambda c: self.delete())
+        self.ttl_timer.start_global(ttl)
         super().__init__(**kwargs)
 
 
@@ -28,23 +28,25 @@ def __init__(self):
             SpaceNode(position=Vector(0, 0))
         )
         self.python_image = Sprite(PYTHON_IMAGE_PATH)
-        self.timer = Timer(self.spawn, 200, single_shot=False)
-        self.timer.start()
+        self.timer = Timer(self.spawn)
+        self.timer.start(0.2, self)
         self.spawn()
 
-    def spawn(self):
+    def spawn(self, context=None):
         angles = list(range(0, 360, 10))
         for angle in angles:
             self.space.add_child(
                 TtlNode(
                     mass=1e10,
                     sprite=self.python_image,
                     angular_velocity=1,
-                    ttl=random.randrange(3000, 6000),
+                    ttl=random.uniform(2, 6),
                     shape=Polygon.from_box(Vector(20, 20)),
                     velocity=Vector.from_angle_degrees(angle) * 50
                 )
             )
+        if context:
+            return context.interval
 
     def update(self, dt):
         for event in self.input.events():
@@ -55,7 +57,7 @@ def update(self, dt):
                     if self.timer.is_running:
                         self.timer.stop()
                     else:
-                        self.timer.start()
+                        self.timer.start(0.2, self)
 
 
 if __name__ == '__main__':

src/kaa/CMakeLists.txt

@@ -52,6 +52,7 @@ set(CYTHON_FILES
     kaacore/hashing.pxd
     kaacore/easings.pxd
     kaacore/spatial_index.pxd
+    kaacore/clock.pxd
 
     extra/include/pythonic_callback.h
     extra/include/python_exceptions_wrapper.h

src/kaa/custom_transitions.pxi

@@ -55,8 +55,8 @@ cdef cppclass CPyNodeCustomTransition(CNodeTransitionCustomizable):
              const CEasing easing):
         this.prepare_func = prepare_func
         this.evaluate_func = evaluate_func
-        this.duration = duration * warping.duration_factor()
-        this.internal_duration = duration
+        this.duration = CSeconds(duration * warping.duration_factor())
+        this.internal_duration = CSeconds(duration)
         this.warping = warping
         this._easing = easing
 

src/kaa/extra/include/pythonic_callback.h

@@ -156,7 +156,6 @@ class PythonicCallbackResult {
 typedef PythonicCallbackResult<int> (*CythonCollisionHandler)(const PythonicCallbackWrapper&, Arbiter,
                                      CollisionPair, CollisionPair);
 
-
 CollisionHandlerFunc bind_cython_collision_handler(
     const CythonCollisionHandler cy_handler, PythonicCallbackWrapper callback
 )
@@ -168,14 +167,14 @@ CollisionHandlerFunc bind_cython_collision_handler(
 }
 
 
-typedef PythonicCallbackResult<void> (*CythonTimerCallback)(const PythonicCallbackWrapper&);
+typedef PythonicCallbackResult<Seconds> (*CythonTimerCallback)(const PythonicCallbackWrapper&, TimerContext);
 
 TimerCallback bind_cython_timer_callback(
-    const CythonTimerCallback cy_handler, PythonicCallbackWrapper callback
+    const CythonTimerCallback cy_handler, const PythonicCallbackWrapper callback
 )
 {
-    return [cy_handler, callback{std::move(callback)}]() {
-        std::move(cy_handler(callback)).unwrap_result();
+    return [cy_handler, callback{std::move(callback)}](TimerContext context) -> Seconds {
+        return cy_handler(callback, context).unwrap_result();
     };
 }
 

src/kaa/kaacore/clock.pxd

@@ -0,0 +1,10 @@
+cdef extern from "<chrono>" namespace "std::chrono" nogil:
+    cdef cppclass duration[Repr, Period=*]:
+        duration()
+        duration(Repr) except +
+
+        Repr count()
+
+
+cdef extern from "kaacore/clock.h" nogil:
+    ctypedef duration[long double] CSeconds "kaacore::Seconds"

src/kaa/kaacore/custom_transitions.pxd

@@ -2,6 +2,7 @@ from libcpp.memory cimport unique_ptr
 from libcpp.functional cimport function
 
 from .nodes cimport CNodePtr
+from .clock cimport CSeconds
 from .transitions cimport CTransitionStateBase, CTransitionWarping
 from .easings cimport CEasing
 from .glue cimport CPythonicCallbackWrapper, CPythonicCallbackResult
@@ -10,20 +11,20 @@ from .exceptions cimport raise_py_error
 
 cdef extern from "kaacore/transitions.h":
     cdef cppclass CNodeTransitionCustomizable "kaacore::NodeTransitionCustomizable":
-        double duration
-        double internal_duration
+        CSeconds duration
+        CSeconds internal_duration
         CTransitionWarping warping
         CEasing _easing
 
         CNodeTransitionCustomizable() \
             except +raise_py_error
-        CNodeTransitionCustomizable(const double duration, const CTransitionWarping& warping) \
+        CNodeTransitionCustomizable(const CSeconds duration, const CTransitionWarping& warping) \
             except +raise_py_error
 
         unique_ptr[CTransitionStateBase] prepare_state(CNodePtr node) nogil const
         void evaluate(CTransitionStateBase* state, CNodePtr node, const double t) nogil const
 
-    ctypedef function[void(CNodePtr)] CNodeTransitionCallbackFunc "kaacore::NodeTransitionCallbackFunc";
+    ctypedef function[void(CNodePtr)] CNodeTransitionCallbackFunc "kaacore::NodeTransitionCallbackFunc"
 
 
 cdef extern from "extra/include/pythonic_callback.h":

src/kaa/kaacore/nodes.pxd

@@ -11,6 +11,7 @@ from .geometry cimport CAlignment, CTransformation, CBoundingBox
 from .physics cimport CSpaceNode, CBodyNode, CHitboxNode
 from .fonts cimport CTextNode
 from .shapes cimport CShape
+from .clock cimport CSeconds
 from .sprites cimport CSprite
 from .scenes cimport CScene
 from .transitions cimport CNodeTransitionHandle, CNodeTransitionsManager
@@ -95,8 +96,8 @@ cdef extern from "kaacore/nodes.h" nogil:
         CAlignment origin_alignment() except +raise_py_error
         void origin_alignment(const CAlignment& alignment) except +raise_py_error
 
-        uint32_t lifetime() except +raise_py_error
-        void lifetime(const uint32_t& lifetime) except +raise_py_error
+        CSeconds lifetime() except +raise_py_error
+        void lifetime(const CSeconds& lifetime) except +raise_py_error
 
         CNodeTransitionHandle transition() except +raise_py_error
         void transition(const CNodeTransitionHandle& transition) except +raise_py_error

src/kaa/kaacore/scenes.pxd

@@ -1,6 +1,5 @@
-from libc.stdint cimport uint32_t
-
 from .nodes cimport CNode
+from .clock cimport CSeconds
 from .camera cimport CCamera
 from .views cimport CViewsManager
 from .spatial_index cimport CSpatialIndex
@@ -14,10 +13,8 @@ cdef extern from "kaacore/scenes.h" nogil:
         CSpatialIndex spatial_index
 
         CCamera& camera()
-        void process_frame(uint32_t dt)
         void on_attach()
         void on_enter()
-        void update(uint32_t dt)
+        void update(CSeconds dt)
         void on_exit()
         void on_detach()
-        void process_nodes(uint32_t dt)

src/kaa/kaacore/timers.pxd

@@ -1,31 +1,32 @@
 from libcpp cimport bool
-from libc.stdint cimport uint32_t
 from libcpp.functional cimport function
 
+from .scenes cimport CScene
+from .clock cimport CSeconds
 from .exceptions cimport raise_py_error
 from .glue cimport CPythonicCallbackWrapper, CPythonicCallbackResult
 
 
 cdef extern from "kaacore/timers.h" nogil:
-    ctypedef function[void()] CTimerCallback "kaacore::TimerCallback"
+    cdef cppclass CTimerContext "kaacore::TimerContext":
+        CSeconds interval
+        CScene* scene
+
+    cdef cppclass CTimerCallback "kaacore::TimerCallback":
+        pass
 
     cdef cppclass CTimer "kaacore::Timer":
         CTimer()
-        CTimer(const CTimerCallback callback, const uint32_t interval,
-            const bool single_shot
-        )
+        CTimer(const CTimerCallback callback)
 
-        void start() except +raise_py_error
+        void start_global(const CSeconds seconds) except +raise_py_error
+        void start(const CSeconds seconds, CScene* const scene) except +raise_py_error
         bool is_running()
         void stop()
-        uint32_t interval()
-        void interval(uint32_t) except +raise_py_error
-        bool single_shot()
-        void single_shot(bool) except +raise_py_error
 
 cdef extern from "extra/include/pythonic_callback.h":
-    ctypedef CPythonicCallbackResult[void] (*CythonTimerCallback)(const CPythonicCallbackWrapper&)
-    CythonTimerCallback bind_cython_timer_callback(
+    ctypedef CPythonicCallbackResult[CSeconds] (*CythonTimerCallback)(const CPythonicCallbackWrapper&, CTimerContext)
+    CTimerCallback bind_cython_timer_callback(
         const CythonTimerCallback cy_handler,
         const CPythonicCallbackWrapper callback
     )

src/kaa/nodes.pxi

@@ -10,6 +10,7 @@ from cymove cimport cymove as cmove
 from .extra.optional cimport optional, nullopt
 
 from .kaacore.shapes cimport CShape
+from .kaacore.clock cimport CSeconds
 from .kaacore.sprites cimport CSprite
 from .kaacore.nodes cimport (
     CNodeType, CNode, CNodePtr, CNodeOwnerPtr, CForeignNodeWrapper,
@@ -306,11 +307,11 @@ cdef class NodeBase:
 
     @property
     def lifetime(self):
-        return self._get_c_node().lifetime()
+        return self._get_c_node().lifetime().count()
 
     @lifetime.setter
-    def lifetime(self, uint32_t new_lifetime):
-        self._get_c_node().lifetime(new_lifetime)
+    def lifetime(self, double new_lifetime):
+        self._get_c_node().lifetime(CSeconds(new_lifetime))
 
     @property
     def transition(self):

src/kaa/scenes.pxi

@@ -1,11 +1,12 @@
 from libc.stdint cimport uint32_t
 from libcpp.memory cimport unique_ptr
-from cpython.ref cimport PyObject, Py_INCREF, Py_DECREF
 from cpython.weakref cimport PyWeakref_NewRef
+from cpython.ref cimport PyObject, Py_INCREF, Py_DECREF
 
-from .kaacore.glue cimport CPythonicCallbackResult
-from .kaacore.nodes cimport CNodePtr
 from .kaacore.scenes cimport CScene
+from .kaacore.clock cimport CSeconds
+from .kaacore.nodes cimport CNodePtr
+from .kaacore.glue cimport CPythonicCallbackResult
 from .kaacore.engine cimport is_c_engine_initialized
 from .kaacore.log cimport c_emit_log_dynamic, CLogLevel, _log_category_wrapper
 from .kaacore.views cimport views_default_z_index
@@ -32,7 +33,7 @@ cdef cppclass CPyScene(CScene):
     void on_enter() nogil:
         this._call_py_on_enter().unwrap_result()
 
-    void update(uint32_t dt) nogil:
+    void update(CSeconds dt) nogil:
         this._call_py_update(dt).unwrap_result()
 
     void on_exit() nogil:
@@ -42,9 +43,9 @@ cdef cppclass CPyScene(CScene):
         with gil:
             Py_DECREF(this.get_py_scene())
 
-    CPythonicCallbackResult[void] _call_py_update(uint32_t dt) with gil:
+    CPythonicCallbackResult[void] _call_py_update(CSeconds dt) with gil:
         try:
-            this.get_py_scene().update(dt)
+            this.get_py_scene().update(dt.count())
         except BaseException as exc:
             return CPythonicCallbackResult[void](<PyObject*>exc)
         return CPythonicCallbackResult[void]()
@@ -86,12 +87,12 @@ cdef class Scene:
         assert c_scene != NULL
         self._c_scene = unique_ptr[CPyScene](c_scene)
 
+        self.input_ = InputManager()
         self.views = _ViewsManager.create(self)
         self.spatial_index = _SpatialIndexManager.create(self)
         self._root_node_wrapper = get_node_wrapper(
             CNodePtr(&self._c_scene.get().root_node)
         )
-        self.input_ = InputManager()
 
     def on_enter(self):
         pass