Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
538
I suspect this function needs some going over. The initial lines in the function
// get difference between orb and ground
float deltaX = orb.x - ground.x;
float deltaY = orb.y - ground.y;
calculate the difference between the orb and the center point of the line defining the
ground plane. These values, assigned to deltaX and deltaY, will be fed into the long form
of the trig expressions I discussed earlier. Remember, the long form trig expressions rotate
existing coordinates (represented by deltaX and deltaY) by adding to their current rotation.
The current rotation we’re interested in is calculated in the Ground class’s constructor,
which defines the amount that the ground edge is rotated from being perfectly
horizontal (orthogonal).
Next in the function, the values for cosine and sine are calculated using the current rotation
value (accessible through the property ground.rot):
float cosine = cos(ground.rot);
float sine = sin(ground.rot);
These two lines may look odd and even unnecessary. In truth, they are unnecessary, as you
could call the individual trig functions in all the rotation expressions following in the code.
However, there is a processing cost every time a trig function is called; and more importantly,
each frame, all the trig-based expressions (eight in total) will use the same trig
values. (Remember, by default, Processing runs your sketches at 60 frames per second.) As
such, precalculated trig values make the program more efficient.
Now the fun begins. The following lines perform the rotation of the ground and the orb’s
velocity:
/* rotate ground and velocity to allow
orthogonal collision calculations */
float groundXTemp = cosine * deltaX + sine * deltaY;
float groundYTemp = cosine * deltaY - sine * deltaX;
float velocityXTemp = cosine * velocity.vx + sine * velocity.vy;
float velocityYTemp = cosine * velocity.vy - sine * velocity.vx;
These expressions hopefully look familiar. The ground and orb’s velocity are rotated the
same amount, so that the ground surface is perfectly horizontal. This is only a temporary
calculation, allowing you to perform a simpler reflection calculation (following shortly).
The ground and velocity are not actually rotated. In fact, notice that the values returned
from the four expressions are returned to four temporary variables: groundXTemp,
groundYTemp, velocityXTemp, and velocityYTemp. Remember also that the signs in
the four trig expressions relate to the direction of rotation. When I eventually rotate the
ground and velocity back, I’ll use the same long form trig expressions with the signs
reversed.
Now that you have some values based on an orthogonal collision, you can handle the collision
nearly the same way you did for the walls: