Mathematical Tools

• Distances
• Trigonometry
• Interpolation

Pythagorean Theorem

A*A + B*B = C*C

Cartesian Coordinates

Euclidean Distance

Distance between two points P0 (x0,y0) and P1 (x1,y1):

   A = x1 - x0
   B = y1 - y0

   (x1-x0)*(x1-x0) + (y1-y0)*(y1-y0) = C*C

   dist = C = sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0))

Distance between two 3D points P0 (x0,y0,z0) and P1 (x1,y1,z1):

   dist = Mathf.Sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0) + (z1-z0)*(z1-z0));

Comparing Distances

Sqrt is considered an expensive (i.e. slow) function

Avoid using it if you can
For example, to determine which of 2 points (P1 or P2) is closer to point P0:

  dist1 = (x1-x0)*(x1-x0) + (y1-y0)*(y1-y0) + (z1-z0)*(z1-z0)
  dist2 = (x2-x0)*(x2-x0) + (y2-y0)*(y2-y0) + (z2-z0)*(z2-z0)
  if (dist1 < dist2)
        P1 is closer
  else
        P2 is closer

Trigonometry

sin(A) = opposite / hypotenuse
cos(A) = adjacent / hypotenuse
tan(A) = opposite / adjacent

or

opposite = hypotenuse * sin(A)
adjacent = hypotenuse * cos(a)

Trigonometry

x = radius * cos(A)
y = radius * sin(A)

Radians

Standard math library functions use radians

360 degrees = 1 full circle = 2 π radians

(Circumference of unit circle = 2 π)

    radians = degrees / 360.0 * 2 * pi

or

    radians = degrees / 180.0 * pi

Making a Circle

    vertices = Array();
    for (var degrees=0; degrees < 360; degrees++)
        {
        angleInRadians = degrees * Mathf.Deg2Rad;
        x = Mathf.Cos(angleInRadians) * radius;
        y = Mathf.Sin(angleInRadians) * radius;
        vertices.push(Vector3(x,y,0));
        }

Driving

Vehicle has direction and speed of travel

Direction is orientation - rotation about Z

To move forward:

    distance = speed * time;

    dx = Mathf.Cos(direction) * distance;
    dy = Mathf.Sin(direction) * distance;

    x = x + dx;
    y = y + dy;

atan2

atan2 converts from (X,Y) coordinates back to angles

Note: it takes arguments in the order Y, X

 
    angle = Mathf.Atan2(y,x) * Mathf.Rad2Deg;

Interpolation

Deriving a value for something from two pre-defined values (extremes)

e.g. Moving object from one position to another, over time

Linear Interpolation

Interpolation expressed as fractional distance between the two extremes

Ranges from 0.0 to 1.0
0.0 = first point; 1.0 = second point

Linear Interpolation

For a single value, with extremes V0 & V1 and interpolation fraction A:

    V = (1 - A) * V0 + A * V1

For multiple values, such as XYZ position, use the same fraction A for all:

    X = (1 - A) * X0 + A * X1
    Y = (1 - A) * Y0 + A * Y1
    Z = (1 - A) * Z0 + A * Z1

Timing

To interpolate over time, compute interpolation fraction based on the amount of time that has passed.

Example:

    function startAnimation()
        {
        animating = true;
        startTime = Time.time;
        duration = 5;
        }

    function computeAnimation()
        {
        if (animating)
            {
            t = Time.time - startTime;
            if (t <= duration)
                a = t / duration;
            else
                {
                animating = false;
                a = 1;
                }
            x = (1-a)*startX + a*endX;
            y = (1-a)*startY + a*endY;
            z = (1-a)*startZ + a*endZ;
            }
        }

Timing

Linear	Slow-in Slow-out
X = t	X = -2*t*t*t + 3*t*t

A2 = -2*A*A*A + 3*A*A
V = (1-A2) * V0 + A2 * V1

Unity functions

• Mathf.Lerp(a, b, t)
• Vector3.Lerp(a, b, t)
  
  
  
• Mathf.LerpAngle(a, b, t)
  
  
  
• Mathf.LerpUnclamped(a, b, t)
• Vector3.LerpUnclamped(a, b, t)
  
  
  
• Mathf.SmoothStep(a, b, t)
  
  
  
• Vector3.Slerp(a, b, t)
• Vector3.SlerpUnclamped(a, b, t)

Numbers

• On the computer, a number is stored as a series of bits.
  
  
• Usually, only a fixed number of bits are used (32 or 64).
  
  
• This leads to certain limitations.

Integers

• 32 bits: can only range from 0 to ~4 billion, or -2 billion to 2 billion

Floating point

• "Simple" decimal numbers are not always "simple" in binary (eg: 0.1 + 0.2)
• Adding very large and very small numbers may lose precision
• In general, values are often not as exact as we'd like
  

      Mathf.Approximately(a,b)

  
  
  
• for more, see: "What Every Computer Scientist Should Know About Floating Point Arithmetic"

This document is by Dave Pape, and is released under a Creative Commons License.