Informatique graphique 1

KINI8AI1 - M1 IAFA - UPS

Loïc Barthe
David Vanderhaeghe

# Plan du cours

---
## Introduction générale

- Outils fondamentaux pour la synthèse d'images.
- Représentation informatique d'une image
    - Espaces de couleur.
- Espaces vectoriels
    - coordonnées homogènes
	- matrices de transformation et projection

---

## Rendu 
- Spécification et problématique du rendu.
    - Équation du rendu. 
    - Modélisation de la réflectance par microfacette.
    - Fonction de texture discrète et procédurale.
	
---

## Rendu 
- Algorithme de rendu dans l'espace monde : lancer de rayons.
    - Calculs d'intersection. 
    - Structuration de la scène : kd-tree.
	
---

## Rendu 
- Algorithme de rendu dans l'espace image : discrétisation. 
    - Discrétisation et interpolation linéaire. 
    - Algorithme du z-buffer.
    - Pipeline graphique et programmation de shaders
---

## Rendu 
- Éclairage et ombrage dans l'espace image.
    - Textures d'ombre. 
    - Textures d'environnement.
    - Réflexion planes
	
---

## Géométrie

- Propriétés des objet 3D.
- Géométrie et forme.
- De la surface théorique au pixel.
- Représentations discrètes.
- Représentations continues.
- Surfaces paramétriques.

Outils fondamentaux pour la synthèse d'images

Logiciels de retouche photo
Dessin vectoriel
Modélisation/rendu 3D
CAD

Format d'images

# Points, vecteurs, repères
On considère un espace à $n$ dimensions scalaires : $\mathbb{R}^n$

- Repère (ou base) : une origine et $n$ axes
- Point : un tuple $(x, y, z) \in \mathbb{R}^3$, distance par rapport à l'origine, suivant les axes
- Vecteur : une direction, un sens, une longueur, défini un déplacement dans l'espace, représenté aussi par un tuple $(x, y, z) \in \mathbb{R}^3$

---

# Opérations

- Produit scalaire (_dot product_)
- Produit vectoriel (_cross product_)
- Combinaison linéaire sur les points : $r = \sum_i w_i p_i$
  - Si $\sum_i w_i = 1$, $r$ est un point
  - Si $\sum_i w_i = 0$, $r$ est un vecteur
  - non défini sinon
- Sur les vecteurs $v = \sum_i w_i v_i$
  - $v$ est un vecteur

---

# Transformations linéaires

- Représentée par une matrice
- Rotation
- Mise à l'échelle
- Cisallement

---

# Transformations affines

- Ajout de la translation

Utilisation des coordonnées homogènes pour représenter les translation (et les projections) par des matrices.

</div>

---

# Changement de repère

- Soit deux repères $B_1 = {O_1, (x_1, y_1, z_1)}$ et $B_2 = {O_2, (x_2, y_2, z_2)}$
- Soit $p_1 = (px_1, py_1, pz_1)$ un point exprimé dans $B_1$

Pipeline de rendu temps réel

# GPU Buffer objects

- permet d'envoyer des buffers au gpu
- de spécifier l'agencement
- et de dire au gpu comment utiliser le buffer

```{.cpp}
float vertices[] = {
    -0.5f, -0.5f, 0.0f,
     0.5f, -0.5f, 0.0f,
     0.0f,  0.5f, 0.0f
};

unsigned int VBO;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
```
ou avec globjects
```{.cpp}
globjects::Buffer* VBO = globjects::Buffer::create();
VBO->setData( sizeof(vertices), vertices, GL_DYNAMIC_DRAW );
```

---
# Premier shader

- vertex shader

```{.glsl}
layout (location = 0) in vec3 aPos;

void main()
{
    gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
}
```

- fragment shader

```{.glsl}

out vec4 FragColor;

void main()
{
    FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
} 
```
---

# Compilation de shader
```{.cpp}
unsigned int fragmentShader;
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);
```

---
# Shader program

```{.cpp}
unsigned int shaderProgram;
shaderProgram = glCreateProgram();

glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

glUseProgram(shaderProgram);
```

Une fois l'utilisation terminée
```{.cpp}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
glDeleteProgram(shaderProgram);
``` 
---

# Premier dessin
On définit les données d'entrées du vertex shader.
```{.cpp}
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
```

Ici 0 correspond à la donnée d'entrée du vertex shader aPos
```{.glsl}
layout (location = 0) in vec3 aPos;
```

---

# Recap

```{.cpp}
// 0. copy our vertices array in a buffer for OpenGL to use
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// 1. then set the vertex attributes pointers
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);  
// 2. use our shader program when we want to render an object
glUseProgram(shaderProgram);
// 3. now draw the object 
someOpenGLFunctionThatDrawsOurTriangle();
```

---
# VAO

```{.cpp}
unsigned int VAO;
glGenVertexArrays(1, &VAO);

// ..:: Initialization code (done once (unless your object frequently changes)) :: ..
// 1. bind Vertex Array Object
glBindVertexArray(VAO);
// 2. copy our vertices array in a buffer for OpenGL to use
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// 3. then set our vertex attributes pointers
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

// [...]

// ..:: Drawing code (in render loop) :: ..
// 4. draw the object
glUseProgram(shaderProgram);
glBindVertexArray(VAO);
someOpenGLFunctionThatDrawsOurTriangle(); 
```

---

# Draw call
```{.cpp}
glUseProgram(shaderProgram);
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, 3);
```

---

# Buffer d'indices

```{.cpp}
unsigned int VAO;
glGenVertexArrays(1, &VAO);
```

---

# Recap

</div>
<div class="row content">
<img src="/CG/assets/img/vao-binding.svg">
</div>
</div>
</div>

Informatique graphique 1

KINI8AI1 - M1 IAFA - UPS

Loïc Barthe
David Vanderhaeghe

L'équation du rendu

Outils fondamentaux pour la synthèse d'images

Format d'images

Pipeline de rendu temps réel

Représentation des données

Informatique graphique 1

KINI8AI1 - M1 IAFA - UPS

Loïc Barthe David Vanderhaeghe

L'équation du rendu

Outils fondamentaux pour la synthèse d'images

Format d'images

Pipeline de rendu temps réel

Représentation des données

Loïc Barthe
David Vanderhaeghe