Equation for bouncing graph?

Question

I basically want my camera in 3D move automatically. Currently, I have linear movement which is rather dumb, so I'd like to do a bouncing movement.

However, what is a good equation for bouncing? I mean, for a circle you can do y = sqrt(1 - x^2), but if I were to have a bouncing graph, what would the corresponding formula be? I guess it's something with abs as it has to 'bounce'. Something like (I made this up with Paint):

What is a good equation that results in such a graph? The transformations I can do myself I guess, but I'm just looking for the kind of equation.

Answer 1

Using a graphical equation will not help you apply natural looking accelerations to the system. You may be surprised to find how easy it would be to simply use basic Newtonian equations here. Give the object a little mass and momentum and let the force of gravity and Newton handle the accelerations & position changes. It's far easier than you may think

Answer 2

Instead of providing a direct answer I want to point you in the right direction. If you google for AI for moving entities you will find algorithms using variables like speed, mass, velocity and accerelation. If you add the gravitational force into the equation you should get realistic behaviour.

As stated in one of the comments to your questions it is not that complicated.

I recommend Programming game AI by example which I found very helpful.

I also found this link explaining the forces involved for a bouncing ball.

Answer 3

If your movement should look a lot like your graph, you could make use of a bounce easing equation like this one (source):

// BOUNCE EASING: exponentially decaying parabolic bounce
easeOutBounce = function (t, b, c, d) {
    if ((t/=d) < (1/2.75)) {
        return c*(7.5625*t*t) + b;
    } else if (t < (2/2.75)) {
        return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
    } else if (t < (2.5/2.75)) {
        return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
    } else {
        return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
    }
};

easeInBounce = function (t, b, c, d) {
    return c - Math.easeOutBounce (d-t, 0, c, d) + b;
};

The movement would look in this graph (easeIn):

Answer 4

If you are looking for an equation closely but roughly describing a bounce, you can try:

y=(e^-x)*abs(4cos(5x))

where

• "4" is the coefficient for the height of the drop and subsequent bounces,
• "5" is the frequency of the bounces, and
• the "abs" part is to give a sharp trajectory to the lower part of the bounce.

Answer 5

If you want bouncing then look into the Coefficient of Restitution. It's a value between 0 and 1 that represents the "bounciness" of the camera. A value of 0 means that no bouncing will occur when the object collides with the ground, and 1 means that the camera will bounce back up to it's original height after it has collided with the ground (in this scenario anyway).

The easiest way to implement it is to give your camera an initial velocity vector (call it u) and you want to find the final velocity vector after the camera has collided (lets call this v). Lets call the CoR e.

e = v / u

So all you need to do is multiply your initial velocity by the coefficient, negate this velocity (for it to travel in the opposite direction) and voila, you have your final velocity and if you keep doing this for every time it collides, you have your bouncing motion. This is assuming you have a flat plane that you want to bounce against, if you have a complex mesh you're colliding against, then instead of negating the vector, simply multiply it by the normal of the polygon you collide with (which is essentially what negation does on a flat plane).

Use some sort of position update function (Euler, Verlet or even RK4 - see this link) and it will make this task a lot easier.

Hope that helps (and I hope my maths isn't too far off :P)