OpenGL rotation and scaling

Does rotation always occur about the o开发者_JAVA技巧rigin (0,0,0)?

Does translation always occur relative to previous translation?

Does scaling increase the coordinates axes size?

I suggest that a good way for a beginner is to start by thinking about points rather than 3D objects. Then all the transformation can be thought of as functions to change a point position to a new position.

First imagine an XYZ cartesian coordinate space, then imagine a point (X,Y,Z) in space with origin (0, 0, 0). All OpenGL knows at this stage is the point X,Y,Z. Now you are ready to begin:

Rotation requires an angle and a center of rotation. glRotate allows you to only specify the angles. By virtue of mathematics, conceptually, the center of rotation is at the location (X-X,Y-Y,Z-Z) or (0,0,0).

Translation is just an offset from the current position. Since OpenGL knows your point (X,Y,Z) it simply adds the offest to the position vector. It is therefore more correct to say it is relative to the current position rather than previous translation.

Scaling is a multiplication of the point vector (X.m,Y.m,Z.m) hence it simply just translating that point by a factor of m. Hence conceptually one can say it doesn't change the coordinate axes size.

However, when you start to think in 3D things get abit tricky because you will realise that if you are not careful, the all the points in a single 3D object doesn't always change position in the way you desire relative to each other. You will learn for example that if you want to rotate about the object's center, you will have to "move it to the origin, rotate, and then move it back again". This process of moving it back an forth can be thought as specifying the center of rotation. These are actually mathematical "tricks" that you apply.

Does rotation always occur about the origin (0,0,0)?

Indeed this is the case.

Does translation always occur relative to previous translation?

Does scaling increase the coordinates axes size?

This requires some explanation: OpenGL, and so many other software operating with geometry data don't build a list of chained transformations. What they maintain is one single homogenous transformation matrix.

"Appending" a transformation is done by multiplying the current transformation matrix with the transformation matrix describing the "next" transformation, replacing the old transformation. This also means that a compound transformation matrix, like what you end up having in the OpenGL modelview, may be applied as transformation as well.

To make a long story short, it depends all on the transformation applied. Old OpenGL gives you some basic matrix manipulations. In OpenGL-3 they have been removed, because OpenGL is not a math library, but draws stuff.

So how does such a transformation matrix look like? Like this:

Xx Yx Zx Tx
Xy Yy Zy Ty
Xz Yz Zz Tz
_x _y _z  w

Maybe you noticed that there are 3 major columns designated by capital X, Y, Z. Those columns form vectors. And in the case of 3D transformations those are the base vectors of a coordinate system, relative the one the transformation is applied upon. However vectors only give "directions" and a length. So what's needed as well is the relative point of origin of the new coordinate system, and that's what the T vector contains.

Most of the time _x = _y = _z = 0 and w = 1

Transforming a point of geometry happens by multiplying the points vector with the matrix. Let such a matrix be M, the point p, then

p' = M * p

Now assume we chain transformations:

p'' = M' * p' = M' * M * p

We can substitute M_ = M' * M, so

p'' = M_ * p

It's easy to see, that we can chain this arbitrarily long

To answer your two last questions: Transformations (not just translations) do chain. And yes, applying a scaling transform will "scale" the axes.

And to clear up some commong misunderstanding: OpenGL is not a scene graph, it does not deal with "objects", but just lists of geometry. glScale, glTranslate, glRotate don't transform objects, but "chain up" transformation operations.

someone with more experience will surely point you to a good tutorial but your question reflect that you don't understand the 3D graphical pipeline and more precisely the concept of projection matrix (I might have the wrong name here since I studied this ages ago in French lol).

Basically whenever you apply a rotation/translation/scaling you are modifying the same matix

therefor when you each operation modifies the existing state. For example doing rotation then a translation will give you a different result that translation then rotaiton (try doing the solar system sun earth moon it will help you understand)

regarding your questions:

• No the basic rotation will not always occur in 0,0,0. for example if you first translate to 2,3,4 then the rotation will happen in 2,3,4.

• the simple answer is yes, you are moving your matrice form its last position.(read my comment at the end for the not the simple answer ^^)

• scaling will affect all the transformations done after. example scale 1,2,2 followed by a translation 2,3,4 could be seen as a a global translation 2,6,8

now for the not so simple part: as explained each change will be affected by the previous changes (example of the scale) also there is a lot of ways to do the same thing or to alter the behavior, for example: achieving absolute translation can be done like this -translate -create an object -indentity (reset the matrix to 0) -translate2 -create object2

My advice is read tutorials but also global 3D programing blogs or a book (red book is good when you start lol)