5 ms·

Fixed Timestep Without Interpolation

77 points by ibobev 2y ago

eru 2y ago
It's somewhat amusing, that someone smart working in a language like Go would come to the same conclusion that Haskell practically forces on you (unless you work to avoid it): by default, your state should be copy-on-write. > For this reason we duplicate the entire game state into a new, temporary render-only game state, and simulate the tick on this one. That way the fixed timestep game state stays untouched. Of course, because it's Go, they have to duplicate everything explicitly. A poor-man's copy-on-write. > Tangent: determinism and replay > You need to make sure entities are always updated in the same order. This means deterministic O(1) datastructures like pools are your friend. That's not actually required. But I guess Go makes this the least painful avenue forward?
- pixelpoet 2y ago
  Pretty sure that's Odin, not Go.
  - eru 2y ago
    Oh, I used my browser's `inspect` on the source code snipped posted, and they were using Go syntax highlighting, so I assumed the code is written in Go. Thanks for pointing this out. Well, I guess my original point applies to Odin instead of Go then.
- meheleventyone 2y ago
  > > Tangent: determinism and replay > > You need to make sure entities are always updated in the same order. This means deterministic O(1) datastructures like pools are your friend. > That's not actually required. But I guess Go makes this the least painful avenue forward? The formulation isn't complete but they're correct for what they're getting at. It should be: "You need to make sure entities are always updated in the same order iff the order matters to the end result." For example if you move entity A before entity B and collision check on move to make sure it's valid if A and B would intersect after moving without collision checking you will end up with different positions of A and B depending on which goes first. Your choices then are to make sure entity update order is deterministic or rework the problem so it doesn't have the ordering dependency. The latter can be quite hard to do and the conditions where there is an ordering dependency can be subtle and unintuitive making it hard to cover all cases.
- diggan 2y ago
  Maybe I misunderstand your comment, but seems like you're misunderstanding the contents of the article/the point? They're doing a duplicate of the state not because it's required in the language or whatever, but because they want to predict something without affecting the actual state. The only way of doing that is running the actual code against a new state duplicate from the existing, actual state. Not sure what the language has to do with it, you'd have to do the same in any language, explicitly or implicitly.
  - eru 2y ago
    In Haskell (and Erlang etc), all data structures 'want' to be copy-on-write by default. That means you don't need to do anything extra to act as if your code is running a against a duplicate: it's behaving like that anyway by default. Git and bcachefs work the same way, btw: you never really change to anything, you just make a new version (that shares most of its storage with the previous version), and then at the end update a pointer. Making a 'copy' in these systems is basically O(1), but making updates might cost you O(log n) (details depend on the data structure in question, some can do O(1)), and in general you want some form of garbage collection, or some type system that really cares about tracking these kinds of thing statically; think something like Rust's borrow checker on steroids. > Not sure what the language has to do with it, you'd have to do the same in any language, explicitly or implicitly. If instead your language or system encourages mutation, then making a complete O(n) copy of your state is the easiest way to get the desired behaviour.
    - meheleventyone 2y ago
      This isn't really trying to emulate copy-on-write though. It's intentionally making a copy temporarily to mutate it further whilst keeping the original ready to be mutated on the next tick. They share superficial similarity but that's about it. As a random tangent, whilst memcpy in the general case is going to be O(n) given that in this program the n is a fixed size the operation in context is always going to be O(1). Fundamentally though it's not a very good way to compare the performance profiles of the approaches to this problem on real hardware.
thegeomaster 2y ago
One important approach is missing: extrapolation. Usually, your entities all have velocities, which you can use to extrapolate from the last simulated state to the current one (after <dt time has passed). For things like visual effects, you'd have to have a custom extrapolate implementation, which is not really different than a custom interpolate implementation that you need for interpolation. This eliminates the lag issue, and at anywhere close to 60FPS, looks perfectly fine. It will look strange at very low framerates, but at that point, you can just automatically switch it off. You do need a way to extrapolate game state, which is slightly painful, but the author's proposed solution has big drawbacks (which he hints at). Since it touches all game state each frame (even though it's "just" a memcpy), it completely changes the performance characteristics of your main loop. Without this, the complexity of your game step is linear in the number of updated or rendered entities, so you can add large amounts of additional state at any time, as long as only a small part of it will be visible/relevant to update each frame. With the author's approach, your step complexity is linear in the state size. You basically have an additional write for all state, which gives you a very restrictive upper limit. It's not just AAA games - as soon as you add a particle system, you've created a great many entities which you now need to memcpy every frame. The scalable solution to this complication is copy-on-write, which is more complexity... or, bite the bullet, write that extrapolation function, and enjoy your freedom to introduce crazy particles, physics, MMO world state, or whatever you want! At real-world framerates, it will look no different.
- jakubtomsu 2y ago
  Extrapolation has some very serious drawbacks in action games which make it unusable though. You cannot just move entities forward in time by velocity*delta, because that ignores all collisions with the world. So you end up with a lot of weird jitter and ugly effects like that. And once you start adding support for things like collision while extrapolating, why not just tick the entire game;)
  - jakubtomsu 2y ago
    (collisions are by far not the only issue here, it's just the first one you run into)
meheleventyone 2y ago
There's a third way here so rather than: * Interpolate between the previous state and the new state by the remaining time which leaves the action delayed in the past. * Simulate an extra variable delta tick with the extra issues you can get from going off cadence. You can simulate a temporary tick a full fixed tick ahead and then interpolate between the current tick and the future tick. Typically the cost of ticking a new frame doesn't depend hugely on the length of time it's simulating so the cost is largely the same as the method presented. This has some advantages in terms of keeping the time delta consistent, meaning you don't need to worry about it throughout the simulation code.
- jakubtomsu 2y ago
  that's a cool idea! However it does mean I would still have to write the interpolation code which is not fun. But it's a good way to solve the latency issue for sure. Thanks for the idea, I'll add a note to mention it somewhere in the post.
  - meheleventyone 2y ago
    Thanks, like most engineering things it's all about picking the set of tradeoffs that you can live with. :D
- modeless 2y ago
  This runs the risk of showing events that don't occur, as you're rewinding and replaying part of a time step every frame. For example, the player might die in the temporary time step and you'd show the first frame of death animation but then a jump input comes in later that frame and when you redo the time step for real the player doesn't die.
  - jayd16 2y ago
    Yes but rollback and replay still looks good in practice and is considered state of the art in latency dependent games (like fighting games).
davexunit 2y ago
It's an interesting approach because the one frame of lag introduced by the typical interpolation strategy is not ideal, but I don't think many games can make use of it. As the article states, game state needs to be in a relatively small contiguous chunk of memory with no pointers to chase. That's a very serious constraint.
dyarosla 2y ago
The main reason to prefer interpolation is that your fixed time step function does not need to operate on variable time ever- removing a complicated dependency. For instance, modifying character accelerations based on a fixed time step constant is far more straightforward than the methods required to work with variable time deltas (due to floating point accumulated error). This is why any action-based deterministic game (think platformers, shooters, physics based games) will opt for this. IMO it is much more straightforward to have a render method that pre-allocates some extra memory, interpolates a handful of values and renders them vs the nondeterminism introduced in a game logic method that has to take into account variable time (especially if also networking multiplayer state). And for this you trade off a frame of visual-only latency - a choice I’d take any day.
- rkangel 2y ago
  > modifying character accelerations based on a fixed frame constant is far more straightforward than the methods required to work with variable time deltas For those who don't know - the reason this is hard is because of the different amounts of maths error that can accumulate between the two approaches (usually FP precision error). Doing some maths in 10 increments a tenth of the size will likely end up with a slightly different value than doing it once in a full size increment. This is particularly important in multiplayer games where multiple players need to be able to do the same calculations and get the identical result. It is not good if the world begins to diverge just because you've got different frame rates!
Mathnerd314 2y ago
For reference, SuperTux's code: https://github.com/SuperTux/supertux/blob/8d79ac7ce4db5e42258c6fbd7e93bfb5a11f2f82/src/supertux/screen_manager.cpp#L564-L653 https://github.com/SuperTux/supertux/blob/8d79ac7ce4db5e4225... (disclosure: not code I wrote, but I've tweaked it here and there) The idea is similarly to just simulate one logical step at a time, with the fixed timestep (this is important because SuperTux uses simple Euler integration which is timestep-sensitive). But there is tracking code that sleeps / adds extra logical steps between frames so the rate of logical frames ends up corresponding closely to the rate of rendered frames. And as with the final solution here there's no interpolation in rendering, you just display the latest game state without storing the previous.
brid 2y ago
"Note: This method probably won’t work very well in cases when game_tick can take a very significant amount of time, or the game state is gigantic, e.g. in a big AAA game which needs to run the physics engine and whatnot."
akira2501 2y ago
// Bitwise OR the bit flags tick_input.actions[action] += flags Why?
aappleby 2y ago
There's another another way to do this, which I have used successfully for years - The fixed time step simulation is the ground truth "goal", and the "render simulation" is "pulled" towards the goal using an exponential moving average interpolation. I find that moving the render simulation 90% of the way to the goal every 80 milliseconds feels good for UI interactions. That means that the rendered version is 99% of the way to the goal after 160 msec, 99.9% after 240 msec, etcetera. This also has the nice property that the render sim is always smooth regardless of tick rate and it never overshoots the goal sim.

77 points by ibobev 2y ago

eru 2y ago

It's somewhat amusing, that someone smart working in a language like Go would come to the same conclusion that Haskell practically forces on you (unless you work to avoid it): by default, your state should be copy-on-write. > For this reason we duplicate the entire game state into a new, temporary render-only game state, and simulate the tick on this one. That way the fixed timestep game state stays untouched. Of course, because it's Go, they have to duplicate everything explicitly. A poor-man's copy-on-write. > Tangent: determinism and replay > You need to make sure entities are always updated in the same order. This means deterministic O(1) datastructures like pools are your friend. That's not actually required. But I guess Go makes this the least painful avenue forward?

pixelpoet 2y ago
Pretty sure that's Odin, not Go.
- eru 2y ago
  Oh, I used my browser's `inspect` on the source code snipped posted, and they were using Go syntax highlighting, so I assumed the code is written in Go. Thanks for pointing this out. Well, I guess my original point applies to Odin instead of Go then.
meheleventyone 2y ago
> > Tangent: determinism and replay > > You need to make sure entities are always updated in the same order. This means deterministic O(1) datastructures like pools are your friend. > That's not actually required. But I guess Go makes this the least painful avenue forward? The formulation isn't complete but they're correct for what they're getting at. It should be: "You need to make sure entities are always updated in the same order iff the order matters to the end result." For example if you move entity A before entity B and collision check on move to make sure it's valid if A and B would intersect after moving without collision checking you will end up with different positions of A and B depending on which goes first. Your choices then are to make sure entity update order is deterministic or rework the problem so it doesn't have the ordering dependency. The latter can be quite hard to do and the conditions where there is an ordering dependency can be subtle and unintuitive making it hard to cover all cases.
diggan 2y ago
Maybe I misunderstand your comment, but seems like you're misunderstanding the contents of the article/the point? They're doing a duplicate of the state not because it's required in the language or whatever, but because they want to predict something without affecting the actual state. The only way of doing that is running the actual code against a new state duplicate from the existing, actual state. Not sure what the language has to do with it, you'd have to do the same in any language, explicitly or implicitly.
- eru 2y ago
  In Haskell (and Erlang etc), all data structures 'want' to be copy-on-write by default. That means you don't need to do anything extra to act as if your code is running a against a duplicate: it's behaving like that anyway by default. Git and bcachefs work the same way, btw: you never really change to anything, you just make a new version (that shares most of its storage with the previous version), and then at the end update a pointer. Making a 'copy' in these systems is basically O(1), but making updates might cost you O(log n) (details depend on the data structure in question, some can do O(1)), and in general you want some form of garbage collection, or some type system that really cares about tracking these kinds of thing statically; think something like Rust's borrow checker on steroids. > Not sure what the language has to do with it, you'd have to do the same in any language, explicitly or implicitly. If instead your language or system encourages mutation, then making a complete O(n) copy of your state is the easiest way to get the desired behaviour.
  - meheleventyone 2y ago
    This isn't really trying to emulate copy-on-write though. It's intentionally making a copy temporarily to mutate it further whilst keeping the original ready to be mutated on the next tick. They share superficial similarity but that's about it. As a random tangent, whilst memcpy in the general case is going to be O(n) given that in this program the n is a fixed size the operation in context is always going to be O(1). Fundamentally though it's not a very good way to compare the performance profiles of the approaches to this problem on real hardware.

thegeomaster 2y ago

One important approach is missing: extrapolation. Usually, your entities all have velocities, which you can use to extrapolate from the last simulated state to the current one (after <dt time has passed). For things like visual effects, you'd have to have a custom extrapolate implementation, which is not really different than a custom interpolate implementation that you need for interpolation. This eliminates the lag issue, and at anywhere close to 60FPS, looks perfectly fine. It will look strange at very low framerates, but at that point, you can just automatically switch it off. You do need a way to extrapolate game state, which is slightly painful, but the author's proposed solution has big drawbacks (which he hints at). Since it touches all game state each frame (even though it's "just" a memcpy), it completely changes the performance characteristics of your main loop. Without this, the complexity of your game step is linear in the number of updated or rendered entities, so you can add large amounts of additional state at any time, as long as only a small part of it will be visible/relevant to update each frame. With the author's approach, your step complexity is linear in the state size. You basically have an additional write for all state, which gives you a very restrictive upper limit. It's not just AAA games - as soon as you add a particle system, you've created a great many entities which you now need to memcpy every frame. The scalable solution to this complication is copy-on-write, which is more complexity... or, bite the bullet, write that extrapolation function, and enjoy your freedom to introduce crazy particles, physics, MMO world state, or whatever you want! At real-world framerates, it will look no different.

jakubtomsu 2y ago
Extrapolation has some very serious drawbacks in action games which make it unusable though. You cannot just move entities forward in time by velocity*delta, because that ignores all collisions with the world. So you end up with a lot of weird jitter and ugly effects like that. And once you start adding support for things like collision while extrapolating, why not just tick the entire game;)
- jakubtomsu 2y ago
  (collisions are by far not the only issue here, it's just the first one you run into)

meheleventyone 2y ago

There's a third way here so rather than: * Interpolate between the previous state and the new state by the remaining time which leaves the action delayed in the past. * Simulate an extra variable delta tick with the extra issues you can get from going off cadence. You can simulate a temporary tick a full fixed tick ahead and then interpolate between the current tick and the future tick. Typically the cost of ticking a new frame doesn't depend hugely on the length of time it's simulating so the cost is largely the same as the method presented. This has some advantages in terms of keeping the time delta consistent, meaning you don't need to worry about it throughout the simulation code.

jakubtomsu 2y ago
that's a cool idea! However it does mean I would still have to write the interpolation code which is not fun. But it's a good way to solve the latency issue for sure. Thanks for the idea, I'll add a note to mention it somewhere in the post.
- meheleventyone 2y ago
  Thanks, like most engineering things it's all about picking the set of tradeoffs that you can live with. :D
modeless 2y ago
This runs the risk of showing events that don't occur, as you're rewinding and replaying part of a time step every frame. For example, the player might die in the temporary time step and you'd show the first frame of death animation but then a jump input comes in later that frame and when you redo the time step for real the player doesn't die.
- jayd16 2y ago
  Yes but rollback and replay still looks good in practice and is considered state of the art in latency dependent games (like fighting games).

davexunit 2y ago

It's an interesting approach because the one frame of lag introduced by the typical interpolation strategy is not ideal, but I don't think many games can make use of it. As the article states, game state needs to be in a relatively small contiguous chunk of memory with no pointers to chase. That's a very serious constraint.

dyarosla 2y ago

The main reason to prefer interpolation is that your fixed time step function does not need to operate on variable time ever- removing a complicated dependency. For instance, modifying character accelerations based on a fixed time step constant is far more straightforward than the methods required to work with variable time deltas (due to floating point accumulated error). This is why any action-based deterministic game (think platformers, shooters, physics based games) will opt for this. IMO it is much more straightforward to have a render method that pre-allocates some extra memory, interpolates a handful of values and renders them vs the nondeterminism introduced in a game logic method that has to take into account variable time (especially if also networking multiplayer state). And for this you trade off a frame of visual-only latency - a choice I’d take any day.

rkangel 2y ago
> modifying character accelerations based on a fixed frame constant is far more straightforward than the methods required to work with variable time deltas For those who don't know - the reason this is hard is because of the different amounts of maths error that can accumulate between the two approaches (usually FP precision error). Doing some maths in 10 increments a tenth of the size will likely end up with a slightly different value than doing it once in a full size increment. This is particularly important in multiplayer games where multiple players need to be able to do the same calculations and get the identical result. It is not good if the world begins to diverge just because you've got different frame rates!

Mathnerd314 2y ago

For reference, SuperTux's code: https://github.com/SuperTux/supertux/blob/8d79ac7ce4db5e42258c6fbd7e93bfb5a11f2f82/src/supertux/screen_manager.cpp#L564-L653 https://github.com/SuperTux/supertux/blob/8d79ac7ce4db5e4225... (disclosure: not code I wrote, but I've tweaked it here and there) The idea is similarly to just simulate one logical step at a time, with the fixed timestep (this is important because SuperTux uses simple Euler integration which is timestep-sensitive). But there is tracking code that sleeps / adds extra logical steps between frames so the rate of logical frames ends up corresponding closely to the rate of rendered frames. And as with the final solution here there's no interpolation in rendering, you just display the latest game state without storing the previous.

brid 2y ago

"Note: This method probably won’t work very well in cases when game_tick can take a very significant amount of time, or the game state is gigantic, e.g. in a big AAA game which needs to run the physics engine and whatnot."

akira2501 2y ago

// Bitwise OR the bit flags tick_input.actions[action] += flags Why?

aappleby 2y ago

There's another another way to do this, which I have used successfully for years - The fixed time step simulation is the ground truth "goal", and the "render simulation" is "pulled" towards the goal using an exponential moving average interpolation. I find that moving the render simulation 90% of the way to the goal every 80 milliseconds feels good for UI interactions. That means that the rendered version is 99% of the way to the goal after 160 msec, 99.9% after 240 msec, etcetera. This also has the nice property that the render sim is always smooth regardless of tick rate and it never overshoots the goal sim.