Authoring motion cycles

Motion cycles play an important role in animation production and game development. However, creating motion cycles relies on general-purpose animation packages with complex interfaces that require expert training. Our work explores the specific challenges of motion cycle authoring and provides a system simple enough for novice animators while maintaining the flexibility of control demanded by experts. Due to their cyclic nature, we show that performance animation provides a natural interface for motion cycle specification. Our system allows the user to act several loops of motion using a variety of capture devices and automatically extracts a looping cycle from this potentially noisy input. Motion cycles for different character components can be authored in a layered fashion, or our method supports cycle extraction from higher-dimensional data for capture devices that deliver many degrees of freedom. After capture, a custom curve representation and manipulation tool allows the user to coordinate and control spatial and temporal transformations from a single viewport. Ground and other planar contacts are specified with a single sketched line that adjusts a curve's position and timing to establish non-slipping contact. We evaluate the effectiveness of our work through tests with both novice and expert users and show a variety of animated motion cycles created with our system.


INTRODUCTION
Motion cycles play an important role in animation and games. In animated lms and visual e ects, artists use walk cycles and other looping animations during character development to explore a character's particular movement style. During production, these cycles aide the animation work ow by providing a starting point for walking, running, and other cyclic movements. In games, motion cycles play an even more prominent role. Motion cycles for locomotion allow characters to move arbitrarily under the player's direction. Punching, kicking, ipping, and countless other cycles are created to enable game combat. Even idle game characters are animated with motion cycles for breathing and other subtle movements that give them life. In fact, motion cycles play such an important role that game engines have specialized animation components designed to play back and seamlessly blend between di erent motion cycles.
Although specialized components for using motion cycles are commonplace, little work has explored the speci c challenges of authoring them. Instead, the authoring process relies on generalpurpose animation packages such as Autodesk Maya, 3ds Max, or Blender. These packages, by design, accommodate a broad spectrum of animation tasks with support for features and work ows used in animated lms, visual e ects, and games. This generality comes at a tremendous cost. The learning curve for any commercial animation package is steep, and the animation process relies on complex mechanisms that require expert knowledge to master. As a consequence, although a motion cycle may only be a few frames of repeated animation, creating those frames with general-purpose animation software is di cult, time consuming, and restricted to expert users.
Our work explores the challenge of motion cycle authoring and provides a system simple enough for novice animators while maintaining the exibility of control demanded by experts. Our method relies on the core observation that the cyclic nature of motion cycles makes them especially appropriate for performance animation. Our system allows the user to act several loops of motion using a variety of capture devices ranging from the computer mouse to a full body motion-capture suit. Since these acted cycles will inevitably contain imprecisions, we propose an optimization algorithm to analyze and automatically extract a looping cycle from this potentially noisy input. By supporting multidimensional input, cycles can accommodate an arbitrary number of animation variables. We then introduce MoCurves, a representation and manipulation tool for motion cycles that encompasses translation, rotation, scale and time. MoCurves allow the user to control and coordinate spatial and temporal transformations from a single viewport. Motion cycles for di erent character components can be authored independently in a layered fashion and synchronized in time using an optimizationbased time-warping function built into the MoCurve interface. Finally, since contact with the ground or other surfaces is pervasive in motion cycles yet di cult to precisely control with a performancebased interface, we support a sketch based contact speci cation in which a single sketched contact line induces a spatio-temporal transformation that respects planar contacts without sliding.
Our work introduces an e ective system tailored to motion cycles authoring. Our core technical contributions include a generic motion cycle extraction algorithm, the MoCurve representation with support for coordinated spatial and temporal editing, and a contact speci cation method that uses a single sketched line to establish non-slipping planar contacts. We implemented our approach as an Autodesk Maya plugin that permits motion cycle authoring independent of Maya's more complex animation features. We evaluated the e ectiveness of our work through tests with both novice and expert users and showed motion cycles created with performance input from the mouse, Wacom Cintiq tablet, Leap Motion hand tracker, HTC Vive, as well as full-body motion capture. All these elements show that the creation process can be dramatically simpli ed using our software, allowing novice animators to author quality animations in minutes.

RELATED WORK
Keyframing. consists of specifying poses at speci c moments in time, and manipulating temporal curves that interpolate di erent rig parameters. Despite being the most common approach for authoring motions, keyframing is challenging as it requires continuously switching between three di erent interfaces: the viewport for character posing, the timeline for timing and the graph editor for manipulating curves. In contrast, our approach merges the different controls into a single curve interface (we call MoCurves) that allows one to synergistically control both space and time while remaining in the comfort of a single viewport.
To Pose or to Time? Many works speci cally aim to ease the posing process using 2D stick gures [Choi et al. 2012;Lin et al. 2010;, lines of action [Guay et al. 2013;Öztireli et al. 2013] or other sketch-based abstractions [Ciccone et al. 2016;Hahn et al. 2015] and others focused speci cally on improving the timing process through time warping [Coleman et al. 2008;Hsu et al. 2007;Witkin and Popovic 1995]. These methods, however, are only focused on either spatial or temporal editing, and do not help the coordination process. One way to improve coordination is through visualization of the motion. Recently, the de facto timeline visualization has been questioned and enhanced with editable pose-icons representing the motion over the timeline [Mukai and Kuriyama 2009] and deformable spatial planes rendered directly onto the viewport [Yoo et al. 2015]. In our work, the MoCurves interface allows the visualization of several aspects of the motion as well as their coordinate manipulation.
Performance animation. As humans have an instinctive sense of movement and timing, performance animation has been used as a natural way of specifying motions, either for the full character [Chai and Hodgins 2005;Igarashi et al. 2005;Kim et al. 2013;Tautges et al. 2011], or through a layered performance type of approach [Choi et al. 2008;Dontcheva et al. 2003;Jin et al. 2015;Martin and Ne 2012;Ne et al. 2007], with a few works focused on retiming existing motions using gestures [Terra and Metoyer 2007;Walther-Franks et al. 2012]. One problem with performance animation is that when gesturing cyclic motions, users are not accurate enough to perfectly close the loop. Instead, they must rely on manual tools to extract a clean loop. In our work, we make the important observation that performance animation for motion cycles is most natural when the motion is repeated several times. We then propose an algorithm to deliver a single closed loop from a sequence of loops performed by the user.
Cycli cation. One core contribution of our work is the automatic cycli cation of an acted motion. While some existing research [Ahmed et al. 2003;Mukai 2011;Rose et al. 1996] explores cycli cation, these methods operate under the single-cycle assumption and cannot accommodate cycli cation of repeated motions. They focus on matching boundaries of a single cycle and do not allow identifying a period in a longer sequence of an imprecisely repeated motion. In Rose et al. [1996], the user is even asked to manually specify the start and end points of a cycle. In our case, taking multiple loops as input is a technical challenge as it requires identifying a recurrent pattern over imprecise loops in space and time. The method in [Silva et al. 1999] can take as input multiple loops, but can only process 1-dimensional curves. In contrast, we solve for N dimensions, which allows us to nd the best period for the N-dimensional signal directly. Moreover, similar to their approach, we experimented with frequency domain decomposition and found that, for performance animation, the input is considerably noisy in the temporal dimension (i.e. all acted cycles do not have the same duration), which prevents us from using frequency analysis such as Fast Fourier Transform, and led to our feature-based solution.
Gesturing space-time curves. Close to our work is the concept of gesturing space-time curves for authoring [Guay et al. 2015] or editing existing motions [Choi et al. 2016]. Guay et al. [2015] are able to create a full character motion using a single stroke and re ne it using additional types of stroke edits. Unfortunately, their strokes are designed around speci c types of motions such as bouncing, rolling and waving, and their work only demonstrates a few simple characters (e.g. no bipeds nor quadrupeds). Choi et al. [2016] allow editing a wide range of motions using sketches, but their work is restricted to editing and cannot author new motions. Using screen-space strokes to de ne 3D deformations, these two papers end up with an underconstrained problem and thus need to make assumptions about the user's intentions. Our work strives to give the artist freedom over the animation process with minimal restrictions. We moreover retain a high degree of genericity so that motion cycles can be applied to any animation control, such as IK handles, bone transformations, or even vertices.
Animation tools for casual users. Many works seek to generate animations through simple interfaces. Motion data can be used to solve for underconstrained interfaces, such as abstract motion doodles [Thorne et al. 2004] or point trajectories [Jeon et al. 2010;Min et al. 2009;Yoo et al. 2014]. Another idea is to use simulated mechanics and to parameterize controllers w.r.t. to a direction [Coros et al. 2010;Hodgins et al. 1995;Laszlo et al. 2000;Yin et al. 2007]. By construction, these methods restrict the scope of possible movements with the range of preexisting motions (often humanoid motioncapture) or to speci c motions such as biped and quadruped locomotion. In contrast, our approach provides ne-scale control of the animation, making it possible to create arbitrary movements for any type of character.

OVERVIEW AND WORKFLOW
Our system is designed to create, represent and manipulate cyclic animations in a natural way. To create a motion cycle, the user performs the motion using any capture device, such as a mouse, Leap Motion, HTC Vive or full body motion capture suit (as shown in our Results Section 6). Depending on the device being used, the user may choose to perform the whole character motion or to animate parts of the character in a layered fashion. Also, since synchronizing several motions is a crucial element of animation, we play the animation of all previously created motions while the user performs for other items (or other transformations of the same items). For example, one would be able to act out the rotation of a foot while watching its displacement.
Because users like to author cycles by performing them several times -each time re ning the motion -we begin by extracting a single cyclic curve from the multiple performed cycles. Our solution is formulated as an optimization problem which takes a repetitive and nearly cyclic motion as input, and outputs a single clean cyclic motion (Section 4). This optimization is performed in the N -dimensional space, where N is the number of dimensions being captured -as shown in our examples, N can vary from 1 or 2 (mouse input, Fig. 8) to a few thousands (physical simulation, Fig. 10). The cycle extraction may be applied to any degree of freedom parameterizing the character's pose, such as rig controllers, skeletons, vertices, and any transformation such as translations, rotations, scales.
To allow the user to directly edit and re ne the cyclic motion from a single viewport, we introduce in Section 5 MoCurves, a curve editor that combines translations, rotations, scalings and timing into a single uni ed geometric interface. We then describe in Section 5.3 an additional edit to our curves that allows specifying planar contacts and solving sliding e ects with a single stroke.

CYCLE SPECIFICATION
In this section we describe how we automatically extract a single closed cycle from multiple nearly cyclic repetitions. The performed trajectory is a discrete function p which associates times t i to a vector of values θ θ θ . These values can represent any type of transformation (positions, orientations, scales, a mix of them, etc.). The performed trajectory p is supposed to be a periodic movement, but is imperfect in both space -noisy θ θ θ i -and timenoisy t i . Hence our goal is to identify points p i in the nearly cyclic motion that are geometrically similar across periods. We start by de ning a curve descriptor that allows us to estimate the most probable value for the period T . We then extract a set of nearly cyclic curves that we average in order to obtain the shape of the nal signal. We nally stitch the extremities together in order to obtain a perfectly looping cycle.

Figure 2:
Steps of the cycle extraction algorithm illustrated on a simple example -only one attribute θ is animated, so p is of dimension 2. a) Points with a similar neighboring shape are identi ed (red circles) using a new curve descriptor. This allows to compute the average period of the motion, and to partition p into several cycles. b) Correspondences between cycles are computed. c) Each curve is non-uniformly scaled in order to align the corresponding points. d) These curves are averaged to form the nal cycle.
Curve descriptor. The function p represents an N +1-dimensional curve, in which we seek to identify repetitive patterns. To measure the similarity between points in a curve, we devised a descriptor that characterizes the neighboring shape of a point on a curve. Our descriptor is similar to the one used by Mori et al. [Mori et al. 2005], which we extend to the n-dimensional case and make variant to rotations. Hence, we compute two descriptors h h h i and i that respectively measure shape and velocity variations: where we used k = 5, and we then de ne the similarity between two points as: Period evaluation. Considering the i-th point of the curve, p i , we de ne i as the set of all indices j that are a local minima of d D (i, j), while remaining under a threshold d m D . By construction, i contains points that are similar in shape and speed to p i . By conservatively choosing d m D high enough -thus favoring to select too many rather than too few points -we ensure that all the points corresponding to p i in other cycles are present in the set i . Then, we eliminate the outliers in i and divide the period T by computing the minimal period that satis es: Here, the threshold m T depicts the variation in time of the cycles in p; we used m T = T /8 , which we found reasonable in practice for cyclic motions performed by humans. In some particular cases, often when two parts of the motion are very similar in shape and velocity, the point i can be badly chosen resulting in an incorrect period. To eliminate this undesirable case, we perform this computation for ten random points and select the median period.
Average cycle. Given the set of indices i cleaned from outliers (i.e. i only contains points corresponding to p i in other cycles), we cut the curve p at the corresponding points and extract a set of cycles c 1 , c 2 , ..., c p (Fig. 2a). Similarly to the construction of i , we measure the similarity d D over evenly spaced points to nd correspondences between the cycles (Fig. 2b) We then non-uniformly scale the cycles such that t k i = t k j ∀i, j, k and the temporal length of each cycle is T (Fig. 2c). We nally compute the average cycle c c c (Fig. 2d) yielding: The curve c we averaged may contain a discontinuity at its extremities, i.e. d d d ex = c c c(0) − c c c(T ) may not be 0 0 0. In order to make it perfectly cyclic, we stitch the curve c as follows: Spline tting. In order to have a smoother representation of the motion, as well as a simpler editing, we t a cubic Bezier curve to each component of the cycle c -i.e. one for the translations (γ P ), one for the rotations (γ R ) and one for the scales (γ S ) of each moving item. Many B-Spline tting methods already exist; we chose to use the one implemented in the Autodesk Maya API.

MOCURVES
To edit motion cycles in an intuitive manner, we combine spatial and temporal controls into a single geometric representation that allows the user to edit both aspects in a single viewport. This is particularly challenging for time as the user needs to precisely and intuitively edit temporal constraints using 3D spatial manipulations.
For this purpose, we introduce MoCurves. For each animated item (i.e. object, rig controller, bone, etc.), we de ne one MoCurve that represents its spatial (i.e. translation, rotation and scale) and temporal transformations. The following subsections describe how MoCurves allow the visualization and manipulation of diverse aspects of the motion, as well as permit the simple editing of planar contacts and automatic solving of sliding e ects. Note that to amplify the intuition of movement and timing, we provide the ability to make all manipulations in real-time, while the animation is played; a bene t of working with motion cycles is that they seamlessly loop, so this does not create a visual discomfort.

Spatial manipulations
As described in Section 4, an item's position, rotation and scale over time are described by cubic Bezier splines γ P , γ R and γ S . There is a direct correspondence between the parametrization of these curves and the time of the animation (e.g. at time t * , the item is at position γ P (s * P )). We note φ P , φ R and φ S the bijective functions giving t from the parametrization of each curve -i.e. t * = φ P (s * P ) = φ R (s * R ) = φ S (s * S ). This provides a uni ed correspondence between all aspects of the motion. The curve γ P is displayed in the viewport in order to represent the displacement (i.e. translations) over time. The user can directly edit the trajectory by manipulating control points of γ P (Fig. 3a). We represent the orientation (i.e. rotations) at each time frame by two orthogonal arrows centered at the corresponding position (Fig. 3b), and the scaling by the geometry of these same arrows (Fig. 3c).
Thus, by looking at a MoCurve, a user has a clear overview of the item's movement.
The orientation and scale of arrows can directly be manipulated in order to modify the rotations and scales of the curve over time.
The modi cation of one frame also modi es neighboring ones in order to smooth the motion, just like the editing of a curve's control point a ects a certain fraction of the curve. The range τ of a ected frames (red arrows in Fig. 3) is set by the user. When an attribute of arrow i is deformed by dθ i , we propagate the deformation on arrows j using a Gaussian radial basis function:

Temporal manipulations
Animators often draw time bars at a constant temporal interval to convey the timing of a hand-drawn motion. Inspired by this representation, we render on top of the Mocurve γ P keypoints at each time frame of the animation. A keypoint can either be represented by a point or by arrows that also give information about orientation and scale (see Subsection 5.1). Hence, if keypoints are close to each other it means that the motion is slow, while if they are very distant it means that the motion is very fast. Once again, the visual representation also serves as a manipulation tool: the user can directly edit the position of keypoints in order to edit the timing of the cycle, as shown in Fig. 4. We formulate the deformation as shape preserving deformation, similarly to [Kim et al. 2009], but here applied to the case of periodic curves. Figure 4: Two keypoints are moved upwards on the curve, setting new timing constraints (red points). A smooth time warping is applied, resulting in a motion that is slower at the top. Note that the motion is consequently faster on the rest of the curve in order to conserve the cycle period.
By moving keypoints, the user de nes a set of spatial constraints: γ P (s * i ) = γ P (s c i ), ∀i ∈ C. We thus seek a new distribution of keypoints along the curve s * = (s * 0 , ..., s * m ) satisfying s * i = s c i , ∀i ∈ C. This is equivalent to computing a new temporal distribution To do so, we solve a quadratic optimization problem containing four energy terms.
Constraints E C (t * ). We penalize the distance between the constrained points and their desired position: Period E T (t * ). A crucial constraint is that cycles must conserve the period: Velocity E V (t * ). We regularize velocities by penalizing deviations from the ones on the original curve. In other words, the temporal spacing between consecutive t * i should be stable: Speed variation E S (t * ). The time warping must not introduce points where the motion is accelerated or decelerated abruptly. That means that two consecutive segments have to stay close in size: The new time distribution is thus obtained by minimizing the total energy, while ensuring that t * increases: .., m − 1} We solve this constrained quadratic programming problem using a qp solver, where we choose the weights w 1 and w 2 to be 10 4 times bigger than w 3 and w 4 because they act as strong constraints. Finally, we recover the positions, orientations and scales at each time step using γ P (φ −1

Contacts
While contacts are present in most cyclic character motions such as locomotion, they can hardly be acted out accurately as they involve sharp corners in the trajectory. To edit a MoCurve as to exhibit sharp corners and straight lines, we introduce a stroke-based editor that cuts the curve with a straight line. This line, extruded along the viewing direction, de nes a plane on which all points from a section of the curve are projected (Fig. 5). This solves contacts in terms of space, but not in terms of time. Indeed, two points simultaneously touching the ground can introduce a sliding e ect if they are not coordinated. In other words, we need to ensure that at every frame of the animation, two items being in contact with the ground have the same velocity -note that velocities are expressed with respect to the character's root. The earlier projection step gives us information about which items are in contact and at which time. This allows us to construct a graph of the velocities of items in contact over time, as shown in Fig. 6. We t a spline λ minimizing the distance to these curves, using a method similar to Section 4. λ de nes the desired velocity of all items in contact with the ground over time.
We now spatially modify the curve γ P of each colliding item in order to satisfy the contact velocity λ. First, we transform the part of γ P being in contact, which we de ne as γ C P ⊂ γ P , such that: γ C P (φ −1 (t + dt)) = γ C P (φ −1 (t)) + λ(t) · dt, ∀t Figure 6: This graph represents the velocity over time of four items touching the ground (one per color). To unify them, we t a spline λ (red dashed curve) that averages the contacts velocity. Note that here we illustrate for only one dimension, but the velocity is usually 3D.
This may change the length of γ C P by a scale factor s l . In order to keep a smooth connection between γ C P and the rest of the curve, we also scale γ P \γ C P by s l in the direction of the contact. Finally, in order to ensure consistent contacts -i.e. contact points are xed in world space -we move the root of the character with the velocity -λ(t) in world space coordinates. This way, by simply specifying a contact surface, the user is able to make a character move inside the environment in a consistent way, without sliding e ect.

RESULTS
We apply our system to four di erent characters with diverse shapes and rig complexities. In this section, we present a number of compelling motion cycles that both novice and expert users were able to author using a variety of input devices. Table 1 gives statistics about the number of elements and transformations that were animated in each case -note that diverse full-body motion capture suits were used for the Mocap motions of Fig. 9, which is why the numbers vary at the bottom of the table. All the resulting animations, as well as some steps of the authoring process, are shown in the accompanying video. To evaluate the accessibility of our system, we invited ve novice users, who never animated any character before, and gave them a limit of one hour to author a motion cycle using our tool. The resulting animations, presented in Fig. 7 and in the accompanying video, are particularly convincing considering the inexperience of the creators. This study was also a social success as users were enchanted to be able to animate a character, several of them concluding: "this was the most enjoyable user study of my life". For comparison, we also asked two of these novice users to create a similar motion cycle using Autodesk Maya, without our plugin. After one hour of struggle (which was their time limit), no exploitable content was created. This result con rms our belief that general purpose animation packages such as Maya require signi cant training before even simple animations can be created.
Additionally, our tool was used by a professional artist in order to evaluate how well our system is integrable into an expert's pipeline. The artist used a Wacom pen and tablet and authored the three motion cycles presented in Fig. 8: the eating dragon was animated in approximately 20 minutes, the ying dragon in approximately 15 minutes and the juggling human in approximately 35 minutes. The last example exhibits how much our system enables a ne control over the spatial and temporal aspects of the motion, allowing the composition of complex synchronizations. As a feedback, the artist shared how delighted he was to be able to directly perform the motion he had in mind without having to be super precise, and how important the MoCurves were in order to maintain a full control over the nal result. He claimed that this is a tool he would like to use regularly for the motion cycles he needs to create.
A large variety of devices can be used to practice performance animation: these range from a computer mouse to full body motioncapture suits and include Leap Motion, Kinect [Wang et al. 2012], tactile surfaces [Chung et al. 2015;Lockwood and Singh 2012] and other dedicated devices [Glauser et al. 2016;Oore et al. 2002;Shiratori et al. 2013;Slyper and Hodgins 2008]. Our method is generic enough to work with any type and dimensionality of data as input. Most of our results were generated using the most familiar devices -a mouse or a digital pen -but we also demonstrate in Fig. 9 and in the accompanying video proper functioning with Leap Motion, HTC Vive and full body motion-capture suits.
In terms of performances, the system is responsive enough to permit an interactive utilization. The cycle extraction algorithm takes less than one second to be executed, even in high-dimensional cases (such as motion-capture, Fig. 9) where the curve being analyzed can have several hundreds of dimensions. As for the MoCurves manipulations, as speci ed in Section 5, they are executed in real-time, while the animation is being played.

LIMITATIONS AND FUTURE WORK
When extracting a cycle from a performed motion, our algorithm requires rough consistency in the input cycles, both in shape (same overall displacement) and timing (cycles of similar duration). If the recorded performance cycles vary widely, the algorithm will fail to nd a period or the extracted loop will be of poor quality. However, in our experiments, even inexperienced users were able to perform loops consistent enough to deliver quality results.
MoCurves allow the visualization and editing of the most widely used attributes in animation. However, artists sometimes customize their rigs with additional attributes, such as roll and lean for a foot. In our results, we supplanted them with the translation or rotation of additional rig elements, but it would be interesting to explore Figure 7: Five novice users, who never created a character animation before, used our system. In less than one hour, they were respectively able to create these motion cycles. From left to right: a walk, a punch, a swim and two dance cycles. Figure 8: A professional artist used our system to author these three motion cycles. From left to right: a dragon eating, a dragon ying and a human juggling a ball. They were respectively created in about 20 minutes, 15 minutes and 35 minutes.
Figure 9: Our system supports a variety of performance capture devices. Here we show a jump cycle created using the Leap Motion hand tracker (left), a kick cycle created using the HTC Vive (middle), and a punch, a walk and a samba cycles created using a full body motion-capture suit (right). In these last examples, the overlapped blue and yellow mannequins show the spatial di erence of cycles in the imperfect performed motion, while the green mannequin shows the looping cycle extracted by our algorithm. Note that in each case, we solve for a single multidimensional curve representing the whole motion (dimension 127 for the punch cycle, 254 for the walk cycle and 160 for the samba cycle).
Figure 10: Handles of these two physics simulations (i.e. translating top of cloth and rotating basis of hair) move periodically. Though, the simulated motions are not periodic, as shown in red with frames spaced by the period T . Our algorithm extracts looping motions, in green, from these simulations. The dimensionality of the cycli ed curves is respectively 7804 and 2611.
mechanisms that would enhance MoCurves for the representation and manipulation of supplementary attributes. As well, we provide a way to easily edit planar contacts, but the intuitive authoring of more complex interactions, such as non-planar or dynamic contacts, remains an open and challenging problem. Our algorithm can nd cycles even in structured physical simulations such as cloth, as shown in Fig. 10. However, it does not conserve the physical correctness of the original simulation. In the future, we would like to integrate mechanical constraints into our algorithm in order to create physically-accurate cyclic simulations.

CONCLUSION
In this work, we introduced an authoring tool tailored to cyclic motion design. Our tool enables a user to repeatedly act out a periodic movement and automatically extract a single closed cyclic motion. In order to conserve a ne level of control required by artists, we then introduced MoCurves, a curve editor that combines both space and time into a single geometric entity that allows coordinated editing in a single viewport. By removing a thick layer of expert knowledge required by general purpose animation tools, we allowed both professional artists and novice users to create compelling animations.