t3ssel8r did the math to define three coefficients which alter animation predictably.

Now we can make changes to our three scalars and see directly how the system’s step response changes. (Somewhat unpredictably, as it turns out.) It’s just hard to adjust these numbers with any sense of competence or agency.

Game Feel by Steve Swink

delay time for an echoed sound effect

notes on a musical scale

Volume of left/right stereo channels

Color or brightness of one or more neopixel LEDs

Pixel coordinates on a neopixel LED strip

Abstract Space or Values

position of a solenoid or linear actuator

1D Coordinate or Position

The concepts explored in this space should be applicable to all of these types of movement, and more!

Direction and speed of a DC motor

rotation of a pixel around a ring

voltage applied to a transistor

rotation of a continuous rotation servo motor

Brightness of an LED

Position of a stepper motor

volume of a buzzer or other sound

Rotation or Angle

Vibration strength of a haptic motor

Strength or Intensity

A servo motor is an obvious choice, but many other options can be explored

But in the end, whatever sensor system we use will eventually spit out a control parameter, and the knob on the arduino breadboard is a useful substitute for that parameter.

accelerometers and gyroscopes

There are many other types of sensors. Interpreting and filtering sensor input is a subject worth study.

We can animate anything which can be controlled with a range between one number and another

analog microphone (returns sound volume)

Ultrasonic rangefinders

The potentiometer in the example is a stand-in for some kind of sensor or interpreted control value

Other types of sensors

Sidenote: other types of movers

acts very like drag or friction, by dampening the velocities

describes how the system’s position settles at its target input

Multiplying different constants by vel_position, acc_position, and vel_input results in different characteristics of movement

spring forces, friction, and other types of forces can directly modify our velocity variables

And for some types of mechanical motion, we will want to directly modify the velocity of our position and our inputs

So we want to modify --or scale-- acc_position

How much velocity changes over time is called acceleration.

we scale acceleration and velocity by multiplying them by constants. Which we call scalars.

That is, we want to change the velocity of position. (AKA vel_position)

scalar_vi * vel_input

scalar_ap * acc_position

scalar_vp * vel_position

We want to alter the character of the movement of our position

OK! So...

r

negative r = initial response moves the opposite direction first

r > 1 is like the movement overshoots

see how the point of the response curve is sharp here and curved above? That.

because(?) one thing r controls is, how much does the relative velocity of our input affect our movement?

when r is 0, the system has more inertia, and is slower to respond

speed and direction of initial movement, and amount of overshoot past the input

How do we learn to use these scalars effectively?

Now there are three new numbers we can play around with, and changing them will alter the dynamic movement of our system.

frequency of vibration in Hz

“the first task is mapping input signals to motion. The expressive potential is in the relationships.”

“With the right relationships between input and response, controlling something in a game can achieve a kind of lyric beauty.”

How do we do that?

Don’t worry about trying to implement this yet, let’s just understand the pieces. the position of our mover moves according to its velocity, which changes according to its acceleration and that sum total of its position and movement is equal to the position and velocity of our controlling input.

This gives us a smooth trajectory which moves position toward input, just as we wanted

But wait! Wasn’t this about moving with some kind of intentional control of the character of the movement?

The movement shown here demonstrates a kind of “personality” to the animation

these step response graphs show how the same springy movement changes scale, but not shape, when f is changed.

doesn’t change the shape of the movement curve.

speed of reaction

being predictable gives us creative agency over how the animation feels

And they behave predictably in ways that we can understand and compare

These parameters are what gives our movement the character we are looking for.

think of them as control knobs - we could easily connect them to sliders and play with dfifferent values

Three values to tune movement

This gives us three different numeric constants, which have predictable effects on the movement animation.

Let’s visualize how the system responds to a single, sudden change in the input

scalar_vp scalar_ap and scalar_vi are noted in video as k1, k2, and k3

vel_position etc. are noted in the video as y-dot, y-dotdot, and x-dot

Naming Things - come up with better and more understandable names for k1-3, and the velocity, acceleration, input acceleration terms

deltaTime is the amount of time we wait between updates

the velocity of input

the acceleration of position

the velocity of position

the position of our mover

Just as the position of the ball in the animation accelerates toward the position of the mouse, position must accelerate toward input in this model.

And if input stays the same for a long time, our position will eventually settle at the same value as input.

That is our goal here.

The way position moves toward input is what we are hoping to learn to control.

position is changing over time, and settling at the value of input

Note that the position value is following the changes to the input parameter

So if you see x or y that is why; they are the input and position respectively

The only reason for this aside is because there will be screengrabs and gifs from the video

Q diff between this and PID

We will be using input and position instead.

In the video, he calls the input x and the position y, which is very confusing.

TODO: go over non blocking delay substitutes

add context and animation for three different values

All the graphs are screenshots from the video linked above. Credit to t3ssel8r

change over time

Both systems have the same key components

deltaTime value since last loop (using delay or (preferably) non-blocking timing function)

overlapping action / inertia

Angle of rotation for servo motor

Sets of Movement Values

Servo Position (Angle)

Analog value read from potentiometer pin (0 to 2048)

comments with the useful ranges

have sets of f, z, r which work well for this type of movement

deltaTime value since last frame

Our Robotics Example System

Angle of rotation for enemy mob turret

Distance vector magnitude from player to enemy mob

Position Vector

Input Parameter

Game Animation System

to do so, let’s look at the model of a game animation, and compare it to the model of a simple, single-servo Arduino sketch

I would like to try and translate the techniques outlined in this video to animatronics, robotics, and other physical animation and motion

Note how the tilt of the turret reacts to the direction of its movement, as though it has mass and inertia

rather than using interpolation curves between keyframes, a type of motion is mapped to a controlling parameter It is very similar to how we often control animatronics or robots, by modifying a control parameter for various actuators or types of physical motion

this video is about procedural animation in games