Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
560
OK, hopefully we’re still on speaking terms. Part of the reason this function is so long, with
a slew of temporary object arrays, is that I wanted to make all the processes as explicit as
possible. There are many ways of optimizing this code and reducing the number of lines;
however, that economy comes with a cost of potential confusion. (Again, Keith Peters’s
book discusses a bunch of these optimizations, so I encourage you to take a look at it for
a deeper discussion on this topic.)
I added a lot of comments directly within the code to help you decipher it. In addition, I’ll
provide a brief overview.
The code in the function combines a number of concepts we’ve looked at throughout this
chapter, including vectors, coordinate rotation, and of course the law of conservation of
momentum. I began the function by assigning the vector described by the distance between
the two balls to bVect. I used this vector to determine the angle of rotation between the
balls, as well as to define the reference point for rotation. Vectors, you’ll remember, tell us
about both direction and magnitude. I calculated the magnitude of bVect (assigned to
bVectMag) and used it to determine when the balls were colliding, since the vector
between the balls is also conveniently the distance between the balls.
By plugging the components of bVect into the atan2() function, I was able to find the
angle (in radians) of the vector’s rotation, which is precisely the value you need to rotate
the ball and velocity coordinates, allowing you to treat the 2D collision between the balls
as a 1D (orthogonal) collision.
When rotating the ball and velocity coordinates, you don’t want to rotate in reference to
the screen origin, but rather locally around the point of collision. I accomplished this by
using bVect (the vector describing the distance between the balls) as the reference point
of rotation. The two lines I’m referring to are the following (please note that I created a
bunch of temporary Ball and Vect2D arrays (including bTemp) in the function to try to
help clarify the different steps in the collision process):
bTemp[1].x = cosine * bVect.vx + sine * bVect.vy;
bTemp[1].y = cosine * bVect.vy - sine * bVect.vx;
b[1] will rotate around b[0], setting the vector between them perfectly horizontal. Thus,
b[0] will act, in a sense, as the origin for the rotation, so I don’t need to assign any value
to bTemp[0].x and bTemp[0].y, which were both automatically assigned 0.0 when
bTemp[0] was instantiated (since float values—which the x and y properties are—default
to 0.0 when declared).
Next, I rotated the velocities, which should be self-explanatory, using the good old long
form trig expressions.
The rotated velocities were assigned to the vTemp objects. Next, the ugly conservation of
momentum expressions come into play. Notice that I only used them to find the final
rotated velocities along the x-axis. The velocities along the y-axis were calculated previously,
so I simply assigned vTemp.vy to vFinal.vy (for both objects).