When animating a 3D model, we want the surface of the model to remain continuous (such that, for instance, the limbs do not seem to slide on the torso, but stay attached at their position).

In a triangle-based mesh, this is easy since the edges of mesh preserve where a limb gets attached to torso. In fact, preserving the volumetric properties becomes the tricky part, to ensure that faces don't end up intersecting each other, etc.

However, in an SDF, while the volumetric properties get preserved automatically, the surface properties do not. Instead of the character looking like a creature with stretchable skin than holds their muscles and bones inside, it looks like a cloud whose various volumes can slide in, out or around upon movement.

What are the ways that skeletal animation can be applied to Signed Distance Fields, if any? If there are none, what alternative to skeletal animation might be used to achieve same effect?

  • \$\begingroup\$ I'm not sure I've ever seen a signed distance field model animated in a game, beyond things like procedural destruction/sculpting where you're modifying the underlying volume directly. Can you show any examples of this kind of animation being done? \$\endgroup\$
    – DMGregory
    Commented Jun 2, 2023 at 13:11
  • \$\begingroup\$ @DMGregory I can't, that is the problem. I am unable to find any information about this in open source, but am not sure if that is due to my lack of google-fu or if this kind of thing hasn't been done in the past. For instance, I tried finding ot how Dreams on PS4 handles skeletal animation, but couldn't find much. Hence, the question. \$\endgroup\$ Commented Jun 2, 2023 at 18:36
  • \$\begingroup\$ Dreams does not render SDFs natively. It marches the SDF to produce a polygonal representation of the surface, then renders that. So they probably use regular skeletal animation with polygon meshes. The answer to your question might be "SDFs don't lend themselves to this, so nobody uses them for things that need skeletal animation" — but proving the "nobody" would be difficult. \$\endgroup\$
    – DMGregory
    Commented Jun 2, 2023 at 19:00
  • \$\begingroup\$ Hmm, that's a shame. Do you know of any other representation that preserves both the volumetric and surface properties? I am writing a experimental renderer, and really would prefer NOT doing it the old school way (i.e., separate renderer for separate class of scene element). \$\endgroup\$ Commented Jun 3, 2023 at 2:19

1 Answer 1


I've thought about this a lot myself and think the following problems make certain kinds of animation more difficult with sdfs than polygons:

  • smoothing between sdf primitives has a lot to do with the nice features of sdf modelling, but this means that a model might start smoothing with itself undesirably as you animate it. consider a hand and fingers, all made with a series of smoothed primitives. As fingers get closer together, like a folded hand, a fist, etc, the fingers will all blend in with each other to create a new whole rather than individual fingers.

  • the old "squash and stretch" traditional animation exercise. With polygons, it is trivial to elongate a ball, for example, and have it stretch easily in one direction while narrowing in another dimension to maintain volume. If you have an sdf sphere as your ball, this can be more complicated. perhaps you use non-uniform scaling to stretch the ball.. that is already undesirable as most sdf renderers stick to uniform scale (though non-uniform can be done) for mathematical reasons. the other option then is to use multiple smoothed spheres to create your stretched oval-like ball, but now you need to carefully tweak their placement and alter their sizes so the volume seems visually preserved. it's just not so useful; very hard to animate something like with all the changes you have to make at every frame compared to a basic polygonal skeleton.

  • arbitrary scenes of many complex objects are hard to optimize with sdfs. With polygons, you have tried-and-true bounding hierarchies that can be automatically created at the triangle level and bounced off to a renderer, and many GPUs now handle these natively, some even create the bounding chains for you. With sdfs, if you want a rendering application to automatically handle a large number of primitive operations, the methods for doing this are not particularly obvious. demo scenes can hard-code in the bounding volumes as an optimization, but if you want to work with arbitrarily complex scenes, you can't expect someone to program this directly for every scene, especially as they start animating (nor would this be a reasonable thing to expect artists to do either). there are plenty of ways to optimize sdfs but each has its own drawbacks and can be exceptionally computationally expensive as a pre-render step in some cases (like voxel discretization) hence why marching cubes back to polygons is a clearer path to rendering efficiency, especially once sdfs start animating around.

I'd be curious what other things you've considered as ways to solve this problem?

  • \$\begingroup\$ One promising direction I found was this (but haven't actually implemented it): par.nsf.gov/servlets/purl/10172295 \$\endgroup\$ Commented Jul 9, 2023 at 21:02
  • \$\begingroup\$ Alternatively, the question boils down to preserving surface properties in a volumetric representation. While our muscles are volumetric, our skin is a surface, which preserves its joining point, surface area, etc., and prevent muscles from behaving in any which way. A triangle mesh doesn't have volumetric properties (only surface), but a skilled animator can make it appear as if it does. An SDF has volumetric properties, but doesn't preserve its surface at all. In this way, it becomes a somewhat general problem whose solution could also help in simulating surface tension, etc. \$\endgroup\$ Commented Jul 10, 2023 at 2:52

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .