Vectors

For the most part, we use vectors. In math and physics, vectors are usually represented by a direction (angle) and a magnitude (length).
See the diagram below (imagine the hypotenuse as an arrow):

Theta (displayed as θ) is your angle in either degrees or radians (I will always talk about angles in degrees). The hypotenuse is the longest side of the triangle (your length or magnitude). The adjacent side is the side that touches the angle you’re working with, the opposite side is the side across from the angle. The adjacent and opposite sides are often your X and Y components, respectively.

In programming, we use the X and Y components so often that we just store and use them instead of the angle and magnitude.

Say we have a triangle with and angle and a magnitude, but we want the components. Here’s how to get them:

To get the components we use SOH CAH TOA, meaning this

so,
sine(θ)=O/H
cosine(θ)=A/H
tangent(θ)=O/A
*(θ just represents the angle)

keeping in mind that opposite will be our Y component and adjacent will be our X component, we come up with this

sine(theta) = Y/H
cosine(theta) = X/H
(we don’t need tangent at the moment)

and finally, this can be rearranged to make

Y = H × sine(theta)
X = H × cosine(theta)

Finally, Time for Some Code

We’ve got a good grasp on vectors now, so we need to make some code. How do we represent a vector in C++? Easy, like this:

struct Vector2D
{
    double x, y;
};

There, we now have a type Vector2D with the inner components ‘x’ and ‘y’.

Next, we have a vector. What can we use it for? The answer to that is “just about anything you want.” Vectors are used for so many applications that it’s nearly impossible to tell you what to use it for. The main things (in game programming) are position, direction and velocity.

2D Is So Old. I Need 3D.

So just add the Z component. It’s that easy (for now).

struct Vector3D
{
    double x, y, z;
};

Later, things won’t be so simple.

Coming Up Next…

We’ll be working with adding, subtracting vectors and multiplying and dividing scalars (magnitudes with no direction, aka regular numbers).

I’ve mostly been busy programming with OpenGL. I’m hoping to write a few simple tutorials using GLUT to get rid of the nasty Windows code. I’ll also be posting a DevIL image loading tutorial, because there are so painfully few on the internet. Basically, anything I struggle with finding information on, I will post a tutorial for when I get it figured out.

Planned so far:

• Making an OpenGL window with GLUT (Windows)
• Drawing primitives
• Changing view and using a ‘camera’
• Light
• Materials
• Loading textures with DevIL and displaying with OpenGL
• Mixing materials and texturing
• Putting it all together (Light, materials and textures)

Some extra tutorials

• Tips and tricks (skyboxes, skydomes, skyspheres)
• Collisions and 3D Vector math (probably split in two tutorials)
• Screenshots with OpenGL and DevIL

That’s quite a bit of code to write, so it’ll take me a while. I’ll likely end up writing some over the Christmas break, and during work (working at the IT lab at Humber is boring, but it gives me lots of time to code!).

Anyway, heres a couple screenies of my program!

[View with PicLens]