[go: up one dir, main page]

glium 0.32.1

Elegant and safe OpenGL wrapper. Glium is an intermediate layer between OpenGL and your application. You still need to manually handle the graphics pipeline, but without having to use OpenGL's old and error-prone API. Its objectives: - Be safe to use. Many aspects of OpenGL that can trigger a crash if misused are automatically handled by glium. - Provide an API that enforces good pratices such as RAII or stateless function calls. - Be compatible with all OpenGL versions that support shaders, providing unified API when things diverge. - Avoid all OpenGL errors beforehand. - Produce optimized OpenGL function calls, and allow the user to easily use modern OpenGL techniques.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

# The camera and summary of the vertex processing stages

With the current code, you can move, rotate or rescale the teapot by adjusting the content of
`matrix`.

But in a real game, you need to organize things differently. Objects are inside a scene and
viewed from a camera. You can't just modify each object's characteristic by thinking
about how it will be viewed on the screen. You need a better organization.

In a real game engine, computing the position of a vertex (from the `position` attribute to
`gl_Position`) is usually done in three steps:

 - Turning the coordinates relative to the model's center (the `position` attribute) into
   coordinates relative to the scene (where coordinates `(0, 0)` are common to all objects
   of the scene). This uses the object's position, rotation and scale.

 - Turning the coordinates relative to the scene into coordinates relative to the camera's
   position and rotation. This uses what is called a *view matrix* (we will see this below).

 - Turning the coordinates relative to the camera into coordinates relative to the screen,
   with the perspective matrix.

*Note*: This gets a bit more complex when dealing with animated models.

Consequently you have three matrices:

 - The *model* matrix, built using the object's position, rotation and scale in the scene.
 - The *view* matrix, built with the camera's position and rotation in the scene.
 - The *perspective* matrix, built with the field of view and aspect ratio of the screen.

The first two matrices are sometimes combined into one *modelview* matrix before being
uploaded to your shaders. But for the sake of simplicity, we are going to use two matrices.

## The view matrix

Just like the perspective matrix, here is the view matrix:

```rust
fn view_matrix(position: &[f32; 3], direction: &[f32; 3], up: &[f32; 3]) -> [[f32; 4]; 4] {
    let f = {
        let f = direction;
        let len = f[0] * f[0] + f[1] * f[1] + f[2] * f[2];
        let len = len.sqrt();
        [f[0] / len, f[1] / len, f[2] / len]
    };

    let s = [up[1] * f[2] - up[2] * f[1],
             up[2] * f[0] - up[0] * f[2],
             up[0] * f[1] - up[1] * f[0]];

    let s_norm = {
        let len = s[0] * s[0] + s[1] * s[1] + s[2] * s[2];
        let len = len.sqrt();
        [s[0] / len, s[1] / len, s[2] / len]
    };

    let u = [f[1] * s_norm[2] - f[2] * s_norm[1],
             f[2] * s_norm[0] - f[0] * s_norm[2],
             f[0] * s_norm[1] - f[1] * s_norm[0]];

    let p = [-position[0] * s_norm[0] - position[1] * s_norm[1] - position[2] * s_norm[2],
             -position[0] * u[0] - position[1] * u[1] - position[2] * u[2],
             -position[0] * f[0] - position[1] * f[1] - position[2] * f[2]];

    [
        [s_norm[0], u[0], f[0], 0.0],
        [s_norm[1], u[1], f[1], 0.0],
        [s_norm[2], u[2], f[2], 0.0],
        [p[0], p[1], p[2], 1.0],
    ]
}
```

The function takes three arguments:

 - The `position` of the camera in the scene.
 - The `direction` the camera is facing in scene coordinates.
 - The `up` vector, representing the direction in scene coordinates of the top of the screen.

We need to reorganize our vertex shader one more time:

```glsl
#version 140

in vec3 position;
in vec3 normal;

out vec3 v_normal;

uniform mat4 perspective;
uniform mat4 view;
uniform mat4 model;

void main() {
    mat4 modelview = view * model;
    v_normal = transpose(inverse(mat3(modelview))) * normal;
    gl_Position = perspective * modelview * vec4(position, 1.0);
}
```

Remember that the order of multiplications is the inverse of the order in which the
transformations must be applied. The matrix to apply first is the nearest to the input.

As usual, we need to pass a new uniform:

```rust
let view = view_matrix(&[2.0, -1.0, 1.0], &[-2.0, 1.0, 1.0], &[0.0, 1.0, 0.0]);

target.draw((&positions, &normals), &indices, &program,
            &uniform! { model: model, view: view, perspective: perspective, u_light: light },
            &params).unwrap();
```

We are using fixed coordinates for the example. A first person camera is not that easy to create
and requires a lot of code that would be out of scope.

And here is the result:

![Result](resources/tuto-12-result.png)

**[You can find the entire source code here](https://github.com/glium/glium/blob/master/examples/tutorial-12.rs).**