Projections

We have been looking at the clipping space.
What we want to do now is to look at an arbitrary box in space.
Or thinking about it the other way around, we want to move an arbitrary box in space to the clipping space.

We will accomplish this with a projection matrix.

The hardware uses the following matrix after the vertex shader

 +-      -+
 | 1 0 0 0|
 | 0 1 0 0|
 | 0 0 0 0|
 | 0 0 0 1|
 +-      -+

This effectively disposes of the z coordinate

But the depth information is computed and kept for fragment processing.

What if we just want to scale to the clipping volume

Start by picturing the camera at (0,0,0) looking down the negative z axis.
How would we specify the view volume now?
- Traditionally you specify a left and right plane
- A front and back plane
- A top and bottom plane
- Or (left, bottom, -near), (right, top, -far)

To accomplish this we want to:

Translate the view volume so it is centered at the origin (T)
Then scale this volume to a 2x2 cube (S)

Right now it is

right-left wide,
And the center of the volume <(r+l)/2, (t+b)/2, -(f+n)/2)>
Write the Transformation matrix T.

     +-             -+
     | 1 0 0 -(r+l)/2|
     | 0 1 0 -(t+b)/2|
T =  | 0 0 0 -(f+n)/2|
     | 0 0 0     1   |
     +-             -+

The volume is (r-l) wide
- so I want to scale in the x dimension by 2/(r-l)
- and scale in y by 2/(t-b)
- and scale in z by -2/(f-n) remember: (-far--near)

     +-                          -+
     | 2/(l-r)    0         0    0|
     |    0    2/(t-b)      0    0|
S =  |    0       0     -2/(f-n) 0|
     |    0       0         0    1|
     +-                          -+

Do S×T

       +-                                              -+
       | 2/(l-r)    0         0             -(r+l)/(r-l)|
       |    0    2/(t-b)      0             -(t+b)/(t-b)|
S×T =  |    0       0     -2/(f-n)           (f+n)/(f-n)|
       |    0       0         0                        1|
       +-                                              -+

There is an ortho function in MV.js
- It takes six values
- left, right, bottom, top, near, far
- and returns the transformation matrix
Note, we normally specify left, right, ... WRT the camera
- So these are in camera coordinates and thus do not need to be transformed.
- So this matrix is applied AFTER the transformation to camera coordinates.
- The shader could become :
```
precision mediump float;

attribute vec4 aPosition;
attribute vec3 aBC;

uniform mat4 uMatrix1, uWorld;
uniform mat4 uCamera, uVolume;

varying vec3 vBC;

void main() {

    gl_Position = uVolume * uCamera * uWorld * uMatrix1 * aPosition;
    vBC = aBC;
}
	     
```
- But you may want to take care of that in the CPU program as well.

If we do not specify a rectangle, but rather a parallel piped

The viewing volume is skewed.
But we would need to generate the matrix for this by hand.

Here is a a Demo