vk955: переводы

→Surprisingly, we did not cover a single new OpenGL function call in this entire chapter. Yes, this
was the math chapter, and you might not have even noticed if you think math is just about formulas and
calculations. Vectors, matrices, and the application thereof are absolutely crucial to being able to use
OpenGL to render 3D objects and worlds. However, it’s important to note that OpenGL doesn’t
impose any particular math convention upon you and does not itself provide any math functionality.
Even if you use a different 3D math library, or even roll your own, you will still find yourself
following the patterns laid out in this chapter for manipulating your geometry and 3D worlds. Now,
go ahead and start making some!

→Finally, we introduced the use of the vmath library that accompanies this book. This library is
written entirely in portable C++ and provides you with a handy toolkit of miscellaneous math and
helper routines that can be used along with OpenGL.

→Summary
In this chapter, you learned some mathematical concepts crucial to using OpenGL for the creation
of 3D scenes. Even if you can’t juggle matrices in your head, you now know what matrices are and
how they are used to perform the various transformations. You also learned how to construct and
manipulate the matrices that represent the viewer and viewport properties. You should now
understand how to place your objects in the scene and determine how they are viewed on-screen.
This chapter also introduced the powerful concept of a frame of reference, and you saw how easy it is
to manipulate frames and convert them into transformations.

→Thus, you should be able to see that given the positions and velocities at the welds of a cubic B-
spline, we can dispense with all of the other control points and compute them on the fly as we
evaluate each of the control points. A cubic B-spline that is represented this way (as a set of weld
positions and velocities) is known as a cubic Hermite spline, or sometimes simply a cspline. The
cspline is an extremely useful tool for producing smooth and natural animations.

→Likewise, if represents the velocity at A, B can be calculated as

→This should make sense if you take another look at Figure 4.16 — there are no kinks, and the curve
is nice and smooth through the welds (points D and G). Now look at the control points on either side
of the welds. For example, take points C and E, which surround D. C and E form a straight line, and
D lies right in the middle of it. In fact, we can call the line segment from D to E the velocity at D, or
. Given the position of point D (the weld) and velocity of the curve at D, then C and E can be
calculated as

→A function that has a continuous first derivative is known as C1 continuous, and likewise a curve
that has a continuous second derivative is known as C2 continuous. Bйzier curve segments are both C1
and C2 continuous, but to ensure that we maintain continuity over the welds of a spline, we need to
ensure that each segment starts off where the previous ended in position, direction of movement, and
rate of change. Well, a rate of travel in a particular direction is simply a velocity. So, rather than
assigning arbitrary control points to our spline, we can assign a velocity at each weld. If the same
velocity of the curve at each weld is used in the computation of the curve segments on either side of
that weld, then we will have a spline function that is both C1 and C2 continuous.

→If we use a spline to determine the position or orientation of an object, we will find that we must
be very careful about our choice of control point locations in order to keep motion smooth and fluid.
The rate of change in the value of our interpolated point P (i.e., its velocity) is the differential of the
equation of the curve with respect to t. If this function is discontinuous, then P will suddenly change
direction and our objects will appear to jump around. Furthermore, the rate of change of P’s velocity
(its acceleration) is the second-order derivative of the spline equation with respect to t. If the
acceleration is not smooth, then P will appear to suddenly speed up or slow down.

→Click here to view code image
vec4 cubic_bspline_10(vec4 CP[10], float t)
{
float f = t * 3.0;
int i = int(floor(f));
float s = fract(t);
if (t <= 0.0)
return CP[0];
if (t >= 1.0)
return CP[9];
vec4 A = CP[i * 3];
vec4 B = CP[i * 3 + 1];
vec4 C = CP[i * 3 + 2];
vec4 D = CP[i * 3 + 3];
return cubic_bezier(A, B, C, D, s);
}

→Thus, the integer part of t determines the curve segment along which we are interpolating, and the
fractional part of t is used to interpolate along that segment. Of course, we can scale t as we wish.
For example, if we take a value between 0.0 and 1.0 and multiply it by the number of segments in the
curve, we can continue to use our original range of values for t regardless of the number of control
points in a curve.
The following code will interpolate a vector along a cubic Bйzier spline with ten control points
(and thus three segments):

→In Figure 4.16, the curve is defined by ten control points, A through J, which form three cubic
Bйzier curves. The first is defined by A, B, C, and D; the second shares D and further uses E, F, and
G; with the third sharing G and adding H, I, and J. This type of spline is known as a cubic Bйzier
spline because it is constructed from a sequence of cubic Bйzier curves. This is also known as a
cubic B-spline — a term that may be familiar to anyone who has read much about graphics in the
past.
To interpolate point P along the spline, we simply divide it into three regions, allowing t to range
from 0.0 to 3.0. Between 0.0 and 1.0, we interpolate along the first curve, moving from A to D.
Between 1.0 and 2.0, we interpolate along the second curve, moving from D to G, and when t is
between 2.0 and 3.0, we interpolate along the final curve between G and J.

→Figure 4.16: A cubic Bйzier spline

→Splines
A spline is effectively a long curve made up of several smaller curves (such as Bйziers) that
locally define their shape. At least the control points representing the ends of the curves are shared
between segments,4 and often one or more of the interior control points are either shared or linked in
some way between adjacent segments. Any number of curves can be joined together in this way
allowing arbitrarily long paths to be formed. Take a look at the curve shown in Figure 4.16.
4. This is what sticks the curves together to form a spline. These control points are known as welds, and the control points in
between are sometimes referred to as knots.

→This layering could theoretically be applied over and over for any number of control points.
However, in practice, curves with more than four control points are not commonly used. Rather, we
use splines.

→Click here to view code image
vec4 quintic_bezier(vec4 A, vec4 B, vec4 C, vec4 D, vec4 E, float t)
{
vec4 F = mix(A, B, t); // F = A + t(B - A)
vec4 G = mix(B, C, t); // G = B + t(C - B)
vec4 H = mix(C, D, t); // H = C + t(D - C)
vec4 I = mix(D, E, t); // I = D + t(E - D)
return cubic_bezier(F, G, H, I, t);
}

→Now that we see this pattern, we can take it further and produce even higher order curves. For
example, a quintic Bйzier curve (one with five control points) can be implemented as

→Click here to view code image
vec4 cubic_bezier(vec4 A, vec4 B, vec4 C, vec4 D, float t)
{
vec4 E = mix(A, B, t); // E = A + t(B - A)
vec4 F = mix(B, C, t); // F = B + t(C - B)
vec4 G = mix(C, D, t); // G = C + t(D - C)
return quadratic_bezier(E, F, G, t);
}

→Just as the structure of the equations for a cubic Bйzier curve “includes” the equations for a
quadratic curve, so too does the code to implement them. In fact, we can layer these curves on top of
each other, using the code for one to build the next:

→Click here to view code image
vec4 cubic_bezier(vec4 A, vec4 B, vec4 C, vec4 D, float t)
{
vec4 E = mix(A, B, t); // E = A + t(B - A)
vec4 F = mix(B, C, t); // F = B + t(C - B)
vec4 G = mix(C, D, t); // G = C + t(D - C)
vec4 H = mix(E, F, t); // H = E + t(F - E)
vec4 I = mix(F, G, t); // I = F + t(G - F)
vec4 P = mix(H, I, t); // P = H + t(I - H)
return P;
}

→If you think the equations above look familiar, you’d be right — our points E, F, and G form a
quadratic Bйzier curve that we use to interpolate to our final point P. If we were to substitute the
equations for E, F, and G into the equations for H and I, substitute those into the equation for P, and
crunch through the expansions, we would be left with a cubic equation with terms in t3 — hence the
name cubic Bйzier curve. Again, we can implement this simply and efficiently in terms of linear
interpolations in GLSL using the mix function: