How models are resized when resizing glViewport() and glFrustum()? - opengl

Question

static void resize(int width, int height)
{
const float ar = (float) width / (float) height;
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity() ;
}
We know when we resize window, this resize() is called and viewport is resized. But how models are resized when we change the window size?

Answer 1

What appreas on the screen of course changes when you change the projection matrix or viewport, since that is the whole point of the exercise. If you look at the end result in screen space, the models will of course appear bigger or smaller if the projection or viewport parameters are changed. And mathematically, there is a scale component involved. Since the projection matrix and viewport transform is applied to every vertex in every draw call, you could view this as the models beeing "resized". But one typically doesn't look at things that way.
That's more of a matter of how you look at things. The object space vertices of the models are not changed, neither is the world space position and size (if you like to think in such terms).

Answer 2

We use three different "coordinates" to make sense of a 3D world:
Models, with the positions of their vertices and whatnot, are defined in Model Space. This is the coordinate system that was originally used (for example in Blender) to create the model and define where the vertex positions are.
There can be lots of models, all with different positions, in a world. To make sense of this all, we define World Space. You have to set up a matrix that transforms every model from its Model Space to our global World Space.
Next, there's Eye Space (or Camera Space, or View Space). A matrix that transforms from World Space to Eye Space gives us the ability to easily move our camera around. Eventually, Eye Space is what we will actually "see".
But wait! There's more! Eye Space is only still a bunch of vertices, there's no concept of perspective. In the end, all OpenGL does is render all triangles that are inside a unit cube. This is known as Normalized Device Coordinate Space. To go from Eye Space to Normalized Device Coordinate Space, we apply yet again a matrix, which we usually call the projection matrix at this stage.
Old OpenGL used to have all functionality built in: you are using it yourself when you call
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);
This basically says: We want to adjust the projection matrix. Then we set it equal to the identity matrix. Then we use a convenience function called glFrustum to set up the correct projection matrix. The call to glFrustum sets up a perspective projection matrix, i.e. one where "things that are further away become smaller".