17: geometry & physics

geometry

notation

scalar
- a single field value representing quantity (SFInt, SFFloat)
- ex: distance, speed, intensity
vector
- a multi-field value representing quantity and direction (SFVec2f, SFVec3f)
- ex: velocity, acceleration, force
- the individual fields of a vector are scalar components (x, y, z)

vector operations

computing scalar length	`SFVec3f.length()`	gives the magnitude of the vector. Handy for distance comparisions, normalization.

normalization	`SFVec3f.normalize()`	scales the vector to have a magnitude of `1`, turning it into a directional indicator. Handy for surface normals, character headings, etc.

negation / inversion	`SFVec3f.negate()`	multiplies each component of the vector by `-1`. Handy for reversing direction or influence.

addition & subtraction	`SFVec3f.add(v)`, `SFVec3f.subtract(v)`	computes the result of multiple vector influences. Handy for adjusting positions and accumulating forces.

scalar multiplication & division	`SFVec3f.multiply(n)`, `SFVec3f.divide(n)`	adjusts the magnitude of the vector. Used to increase / decrease the effect of vectors, and for normalization.

dot product	`SFVec3f.dot(v)`	`V1.dot(V2)` results in a scalar value equal to `V1.length * V2.length * cos(a)`, where `a` is the angle between `V1` and `V2`. For any two non-zero vectors `V1` and `V2`, if `V1.dot(V2) == 0`, they are perpendicular. If `V1.dot(V2) == 1`, they are colinear (parallel) in the same direction. If `V1.dot(V2) == -1`, they are colinear in oppposite directions. `V1.dot(V1) == V1.length() * V1.length()`. If V2 is a unit vector (has been normalized), `V1.dot(V2)` gives the contribution (magnitude) of `V1` in the direction of `V2`. This is also called projecting `V1` onto `V2`.

cross product	`SFVec3f.cross(v)`	`V1.cross(V2)` results in a new vector perpendicular to `V1` and `V2`. `V1.cross(V2) = V1.length * V2.length * sin(a) * N`, where `a` is the angle between `V1` and `V2`, and `N` is a unit vector perpendicular to `V1` and `V2`. For any two non-zero vectors `V1` and `V2`, if `V1.cross(V2) == 0`, they are parallel. Torque is the cross product of a lever vector, and a force operating at the end of the lever.

distance calculations

distance between two points :

var span = P1.subtract(P2);
var distance = span.length();
var distanceSq = span.dot(span);

distance between a point and a line [»]
distance between a point and a plane [»]

intersection (collision) detection

intersecting spheres :

var span = center1.subtract(center2);
var distanceSq = span.dot(span);
var radii = radius1 + radius2;
var intersect = (distanceSq <= radii * radii)

intersecting lines (2d) [»]
intersection of a line and a plane [»]
ray reflection [»]
ray intersections [»]
more [»]

physics

terminology

mass : a scalar measure of the amount of matter in an object
velocity : a vector measurement of the rate and direction of motion. the absolute value of the length of velocity is the scalar quantity speed.
force : a vector representing an instantaneous change of velocity
- collision
- friction
acceleration : a vector representing the change of velocity of an object over time
- gravity
- wind

rules

newton's laws of motion
1. inertia : in the absence of force, an object will maintain constant velocity (which may be 0, if at rest)
2. force (F = ma, a = F/m) : force introduces acceleration inversely proportional to mass, acceleration is equivalent to the force vector divide by mass
3. reaction : every force in one direction results in an equal force in the opposite direction
applying newton's laws
1. inertia : when updating the position of an object over time, start with the object's velocity from the last update. next, combine all the forces acting on it at this point in time, and apply rule 2.
2. force : compute acceleration by dividing the combined force vector acting on the object by the object's mass. add this acceleration to the current velocity to find the new velocity. multiply the new velocity by the change in time since the last update, and add the result to the last position.
3. reaction : if one object should collide with another, each will receive new forces in directions opposite the incoming velocity

simulation

physical simulators perform the process outlined in steps one and two of applying newton's laws above. given a set of bodies and some external forces, a simulators takes care of updating the positions and orientation of all the bodies over time, resulting in realistic physical animation. actually, the realism is usually directly proportional to the complexity of the simulator, and the processing power of the computer running it.

euler integrators
verlet integration & constraints

particles

projectile [»]
simulation examples:
- springing [»]
- orbiting [»]
- exploding [»]

collision response

rigid bodies
- reflection
- asymetric recoil
simulation examples:
- billiards [»]