Use fixed time points in animation.

4 files changed, 42 insertions, 12 deletions

diff --git a/Spear/App.hs b/Spear/App.hs
index f8afc9e..ac5f7a5 100644
--- a/Spear/App.hs
+++ b/Spear/App.hs
@@ -59,50 +59,55 @@ loop app window = do
   resizeApp app (ResizeEvent width height)
   renderApp app
 
-  let ddt          = fpsToDdt .       maxFPS . options $ app -- Desired frame delta time.
+  let ddt          = fpsToDdt .       maxFPS . options $ app -- Desired render time step.
   let animationDdt = fpsToDdt . animationFPS . options $ app -- Desired animation time step.
 
   timer <- gameIO newTimer
   gameIO $ Timer.start timer
-  loop' window ddt animationDdt 0 timer app
+  let lastAnimationTime = lastTick timer
+  loop' window ddt animationDdt lastAnimationTime timer app
 
 loop' ::
   Window ->
   TimeDelta -> -- Desired frame time delta.
   TimeDelta -> -- Desired animation time delta.
-  TimeDelta -> -- Time budget.
+  TimePoint -> -- Time point of last animation update.
   Timer ->
   App s ->
   Game s ()
-loop' window ddt animationDdt timeBudget inputTimer app = do
+loop' window ddt animationDdt lastAnimationTime inputTimer app = do
   timer        <- gameIO $ tick inputTimer
   windowEvents <- gameIO $ pollWindowEvents window
   close        <- gameIO $ shouldWindowClose window
 
-  (continue, timeBudgetNextFrame) <- case animationDdt of
+  (continue, lastAnimationTimeNextFrame) <- case animationDdt of
     0 -> do
       -- Variable time step game animation.
       let t  = timeDeltaToSec $ runningTime timer
       let dt = timeDeltaToSec $ deltaTime   timer
       inputEvents <- gameIO $ pollInputEvents window
       continue <- stepApp app t dt inputEvents
-      return (continue, 0) -- budget unused.
+      return (continue, lastAnimationTime)
 
     _ -> do
       -- Fixed time step animation.
-      let elapsed = runningTime timer
+      {- let elapsed = runningTime timer
       let dt = timeDeltaToSec ddt
       let timeBudgetThisFrame = timeBudget + deltaTime timer
       let timeBudgetNextFrame = timeBudgetThisFrame `mod` ddt
+      let steps = timeBudgetThisFrame `div` ddt -}
+      --gameIO . print $ "Steps: " ++ show steps ++ ", Budget: " ++ show timeBudgetThisFrame ++ ", ddt: " ++ show ddt
+      let elapsed = runningTime timer
+      let dt = timeDeltaToSec ddt
+      let timeBudgetThisFrame = timeDiff lastAnimationTime (lastTick timer)
       let steps = timeBudgetThisFrame `div` ddt
-      gameIO . print $ steps
-
+      let lastAnimationTimeNextFrame = timeAdd lastAnimationTime (timeBudgetThisFrame `mod` ddt)
+      --gameIO . print $ "Steps: " ++ show steps ++ ", Budget: " ++ show timeBudgetThisFrame ++ ", ddt: " ++ show ddt
       continue <- and <$> forM [1..steps] (\i -> do
         inputEvents <- gameIO $ pollInputEvents window
         let t = timeDeltaToSec $ elapsed + i * ddt
         stepApp app t dt inputEvents)
-
-      return (continue, timeBudgetNextFrame)
+      return (continue, lastAnimationTimeNextFrame)
 
   -- Process window events.
   resized <- or <$> forM windowEvents (\event -> case event of
@@ -121,4 +126,4 @@ loop' window ddt animationDdt timeBudget inputTimer app = do
       gameIO $ Timer.sleep (ddt - frameTime)
 
   when (continue && not close) $ do
-    loop' window ddt animationDdt timeBudgetNextFrame timer app
+    loop' window ddt animationDdt lastAnimationTimeNextFrame timer app
diff --git a/Spear/Sys/Timer.hsc b/Spear/Sys/Timer.hsc
index 98b88d6..fb18521 100644
--- a/Spear/Sys/Timer.hsc
+++ b/Spear/Sys/Timer.hsc
@@ -14,6 +14,7 @@ module Spear.Sys.Timer
 ,   timeDeltaToSec

 ,   secToTimeDelta

 ,   timePointToNs

+,   timeAdd

 ,   sleep

 )

 where

@@ -115,6 +116,9 @@ foreign import ccall safe "timer.h sec_to_time_delta"
 foreign import ccall safe "timer.h time_point_to_ns"

      c_time_point_to_ns :: Ptr TimePoint -> Word64

 

+foreign import ccall safe "timer.h time_add"

+     c_time_add :: Ptr TimePoint -> TimeDelta -> Ptr TimePoint -> IO ()

+

 foreign import ccall "timer.h time_sleep"

      c_time_sleep :: TimeDelta -> IO ()

 

@@ -172,6 +176,15 @@ timePointToNs t = unsafeDupablePerformIO $ alloca $ \ptr -> do
      poke ptr t

      return $ c_time_point_to_ns ptr

 

+-- | Add a time delta to a timestamp.

+timeAdd :: TimePoint -> TimeDelta -> TimePoint

+timeAdd t dt = unsafeDupablePerformIO $

+     alloca $ \tPtr ->

+     alloca $ \ptr -> do

+          poke tPtr t

+          c_time_add tPtr dt ptr

+          peek ptr

+

 -- | Put the caller thread to sleep for the given amount of time.

 sleep :: TimeDelta -> IO ()

 sleep = c_time_sleep

diff --git a/Spear/Sys/Timer/timer.c b/Spear/Sys/Timer/timer.c
index 707cd63..4a2fb2b 100644
--- a/Spear/Sys/Timer/timer.c
+++ b/Spear/Sys/Timer/timer.c
@@ -87,6 +87,15 @@ uint64_t time_point_to_ns(time_point* t) {
 #endif

 }

 

+void time_add(const time_point* t, time_delta dt, time_point* out) {

+#ifdef _WIN32

+  *out = *t + dt;

+#else

+  out->tv_sec  = t->tv_sec + (dt / nanoseconds);

+  out->tv_nsec = t->tv_nsec + (dt % nanoseconds);

+#endif

+}

+

 void time_sleep(time_delta dt) {

 #ifdef _WIN32

   const int64_t ms = dt / microseconds;

diff --git a/Spear/Sys/Timer/timer.h b/Spear/Sys/Timer/timer.h
index e426135..da4e7c7 100644
--- a/Spear/Sys/Timer/timer.h
+++ b/Spear/Sys/Timer/timer.h
@@ -53,6 +53,9 @@ time_delta sec_to_time_delta(double seconds);
 /// Convert the time point to nanoseconds.
 uint64_t time_point_to_ns(time_point*);
 
+/// Add a time delta to a timestamp.
+void time_add(const time_point*, time_delta, time_point* out);
+
 /// Put the caller thread to sleep for the given amount of time.
 void time_sleep(time_delta dt);