Dessiner des cubes pour emcc et g++

**Neckara** · 13/07/2015, 20h15

Bonjour,

J'avais l'habitude d'utiliser Irrlicht, mais je ne m'étais jamais vraiment plongé dans OpenGL.

Mon objectif est juste de dessiner un malheureux petit cube, mais après de multiples recherches, je n'ai trouvé aucun code fonctionnel que je pourrais compiler à la fois avec g++ et emscripten. J'ai essayé de dessiner des triangles, sans plus de succès (assertions qui se déclenchent, écran noirs, erreurs avec emscripten, …). En effet la plupart des exemples d'emscripten me lèvent des assertions lorsque je les compile avec g++ puis que je les compile. Et les exemples "normaux" utilisent des fonctions non supportée par emscripten.
Sachant que je souhaiterais rester dans le WebGL-friendly subset of OpenGL à cause de emscripten.

Je me demande donc si cela vient de moi, des codes que j'ai trouvé ou même de mon Linux/ordinateur voir même des 3

.

Mon but ultime étant juste de :

dessiner 9x6 cubes ;
les faire changer de couleur au clic ;
faire apparaître d'autres cubes ;
déplacer la caméra ;
faire faire une rotation à mon ensemble.

Rien de bien insurmontable en somme, d'autant plus que juste pour afficher des cubes, je ne pense pas avoir besoin de quelconques astuces d'optimisations. Mais je bloque déjà rien que pour afficher un bête triangle

.

Pourriez-vous m'accompagner et me rediriger vers une ressource "sûre" permettant de dessiner un petit triangle de couleur unie afin de partir sur des bonnes bases ?
Merci d'avance pour votre aide.

Voici le seul code fonctionnel que j'ai réussi à trouver :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <GL/glew.h>
#include <GL/glut.h>
 
 
 
static int make_resources(void)
{
    return 1;
}
static void update_fade_factor(void)
{
}
 
 
static void render(void)
{
    glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
 
    // ??????
 
    glutSwapBuffers();
}
 
 
 
int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
  glutInitWindowSize(400, 300);
  glutCreateWindow("Hello World");
  glutDisplayFunc(&render);
  glutIdleFunc(&update_fade_factor);
 
  glewInit();
 
printf("OpenGL version supported by this platform (%s): \n", glGetString(GL_VERSION));
 
  if (!GLEW_VERSION_2_0) {
      fprintf(stderr, "OpenGL 2.0 not available\n");
      return 1;
    }
 
  if (!make_resources()) {
      fprintf(stderr, "Failed to load resources\n");
      return 1;
    }
 
  glutMainLoop();
  return 0;
}

**Neckara** · 13/07/2015, 21h23

Un amis me guide un peu pour l'OpenGL.

Voici où j'en suis pour le moment :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <GL/glew.h>
#include <GL/glut.h>
#include <assert.h>
 
 
static int make_resources(void)
{
    return 1;
}
static void update_fade_factor(void)
{
}
 
 
static void render(void)
{
    glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
 
    float vertex_data [] = {
         // v1
         0, 0, 0,
     // Color
     1,1,1,
     // Normal
     0,0,1,
         // v2
         0, 0, 1,
     // Color
     1,1,1,
     // Normal
     0,0,1,
         // v3
         1, 0, 0,
     // Color
     1,1,1,
     // Normal
     0,0,1,
 
    };
 
    int data_size_in_bytes = sizeof(vertex_data);
    GLvoid * data_vertices = (GLvoid *)vertex_data;
 
    // buffer avec vertex
    GLuint vertex_buffer; // Save this for later rendering
    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
    glBufferData(GL_ARRAY_BUFFER, data_size_in_bytes, data_vertices, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
    // màj partie
//glBufferSubData(GL_ARRAY_BUFFER, 0, data_size_in_bytes, data_vertices);
 
    GLint size = 0;
    glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
    if(data_size_in_bytes != size)
    {
        glDeleteBuffers(1, &vertex_buffer);
        // Log the error
        return;
    }
    // vertex
 
    // fragment shader
    const char *fragmentShader = "precision highp float;\nuniform vec4 colorparams;\n"
                "void main(void)\n"
                "{\n"
                " gl_FragColor = colorparams;\n"
                "}\n";
    GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
    glCompileShader(fragmentShaderID);
    glCompileShader(fragmentShaderID);
    int ok;
    glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &ok);
    assert(ok);
 
// shader ???
GLubyte indices[] = {0,1,2};
 
glDrawElements(GL_TRIANGLES,
     3,
     GL_UNSIGNED_BYTE,
     &indices);
 
    glutSwapBuffers();
 
// vertex shader + link program
}
 
 
 
int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
  glutInitWindowSize(400, 300);
  glutCreateWindow("Hello World");
  glutDisplayFunc(&render);
  glutIdleFunc(&update_fade_factor);
 
  glewInit();
 
printf("OpenGL version supported by this platform (%s): \n", glGetString(GL_VERSION));
 
  if (!GLEW_VERSION_2_0) {
      fprintf(stderr, "OpenGL 2.0 not available\n");
      return 1;
    }
 
  if (!make_resources()) {
      fprintf(stderr, "Failed to load resources\n");
      return 1;
    }
 
  glutMainLoop();
  return 0;
}

**Kannagi** · 14/07/2015, 07h26

Je suis étonné que tu utilise encore glut , c'est une lib un peu obsolète (et un peu buggé en passant) ,je te conseille freeglut donc a vrai dire je te conseille juste de regardé mon template de freeglut (par contre c'est de OpenGL 1 mais la transition n'est pas si compliqué) mais a vu de nez il me semble que il manque pas mal de chose sur ton code pour qu'il soit fonctionnel .
Mais bon c'est bien de pratiqué mais n'oublie pas de lire des tutoriaux sur tout cela , le but c'est pas de t'accompagner pas a pas dans OpenGL.

**dragonjoker59** · 14/07/2015, 10h23

Salut!

Par rapport au code que tu as posté...
Ta méthode render va être appelée par la boucle d'affichage, à chaque frame.
Il vaut mieux éviter d'y mettre le code d'initialisation de tes buffers ^^.

Effectivement, on a de bons tutos OpenGL moderne sur DVP, je te conseille d'y jeter un oeil (ou 2 d'ailleurs, c'est plus pratique).

**LittleWhite** · 14/07/2015, 10h24

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
    glCompileShader(fragmentShaderID);
    glCompileShader(fragmentShaderID);

Huummm. J'imagine qu'il y a un truc inutile

Il vous faut un vertex shader et un fragment shader. Là, vous n'avez qu'un fragment shader.
De plus, après la compilation (glCompileShader()), il faut les lier (glLinkProgram()). Il faudra aussi penser à les utiliser (glUseProgram()) sinon, le rendu se fera sans (donc pas de rendu).

Pour réussir à respecter la norme de WebGL, vous pouvez simplement compiler contre OpenGL ES (et non juste OpenGL), qui est un subset pour l'embarqué/mobile, mais aussi, la base de WebGL. Je ne sais malheureusement pas comment on fait ceci.
Sinon, toutes nos ressources sont sur http://opengl.developpez.com

**Neckara** · 14/07/2015, 12h02

Merci pour votre aide, j'essaye cela dès ce soir

.

Je suis étonné que tu utilise encore glut , c'est une lib un peu obsolète (et un peu buggé en passant)

Pour le moment, je veux juste afficher un petit triangle.
Après, je pourrais peut-être utiliser la SDL pour le fenêtrage (?).

Mais bon c'est bien de pratiqué mais n'oublie pas de lire des tutoriaux sur tout cela

Disons qu'au début, j'étais un peu pommé entre les ~5 versions de OpenGL, les bouts de codes (issus d'exemples ou de tutoriels) qui marchaient avec emscripten et pas sur l'autre, et inversement

.

Difficile de savoir quel tutoriel/exemple prendre pour afficher mon petit triangle.

Ta méthode render va être appelée par la boucle d'affichage, à chaque frame.
Il vaut mieux éviter d'y mettre le code d'initialisation de tes buffers ^^.

Merci.

Niveau rendu d'objets multiples, il y a des bonnes pratiques que je devrais connaître ?
Je présume que je ne vais pas dessiner mes cubes triangles par triangles et que je vais dessiner un cube entier en "une fois". Par contre, pour des cubes qui se répètent, je vais sûrement réutiliser les mêmes shaders, mais il y a des choses particuliers pour limiter le nombre de calculs pour le "clonage" d'objets identiques ou cela ne pose aucun problème de les dessiner chacun séparément ?

Sinon, j'avais bien vu les tutoriels OpenGL sur DVP, mais il ne me semble pas en avoir trouvé un "GLES"-only. Mais depuis que j'ai trouvé la liste des fonctions GLES2, je m'y retrouve déjà un peu mieux. Ne serait-ce que pour voir si les codes/fonctions que je vois sont compatibles emscripten.

**Neckara** · 14/07/2015, 12h36

@LittleWhite

Pour OpenGL j'ai :

Desktop : OpenGL version supported by this platform (3.0 Mesa 10.3.2)
HTML : OpenGL version supported by this platform (WebGL 1.0)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

printf("OpenGL version supported by this platform (%s): \n", glGetString(GL_VERSION));

Je peux utiliser les tutoriels sur l'OpenGL 3.3 ou c'est trop récent pour moi ?
GLES2.0 n'est-il pas lié à OpenGL2.0 ?

**Kannagi** · 14/07/2015, 13h32

En lisant ton code ça me semble être de OpenGL2 donc je te conseille sur ce coup de regardé mon template , ensuite tu rajoutera les VBO (pas compliqué mais en général les Vertex Array sont plus simple comme première approche) ensuite les shaders (je rappelle qu'il y a un très bon tutoriel ici pour les shader : http://alexandre-laurent.developpez....L/OpenGL-GLSL/) bref d'y aller pas a pas.

Pour le fenêtrage la SDL1.2 ou 2 suffit largement aussi , pour ma part j'utilise peu freeglut vu que la dernière version que j’avais utilisé avait encore quelque bug lié au joystick.

Je présume que je ne vais pas dessiner mes cubes triangles par triangles et que je vais dessiner un cube entier en "une fois".

D'un coté tu le fait deja presque un peu vu que glDrawElements(GL_TRIANGLES,3,GL_UNSIGNED_BYTE,&indices); permet d'afficher plusieurs triangle.

**Neckara** · 14/07/2015, 13h46

Envoyé par Kannagi

En lisant ton code ça me semble être de OpenGL2

Après, si je peux utiliser de l'OpenGL3 et ainsi lire les tutoriels de la rubriques, je ne suis pas contre. Je n'ai absolument aucune préférence quant à la version d'OpenGL.
Il me semble que l'OpenGL1 est obsolète et qu'il existe l'OpenGL2, 3 et 4 ?

Je présume que la 4 est trop récente et que je dois choisir entre la 2 et la 3?

**Kannagi** · 14/07/2015, 14h44

La différence entre OpenGL 1 et 2 n'est pas si grande pour moi OpenGL 2 apporte juste 2 choses principal les shader et les VBO.
OpengGL 3 commence a être une refonte de la librairie donc des choses sont déprécié et d'autre fonction les remplaces , le 4 comme toi je suis sur Linux et donc Mesa ne supporte chez moi que OpenGL 3.

Mais sinon oui tu as le choix entre la 2 et la 3 dans ton cas (enfin un peu le mien aussi et donc je fait les deux).

**Neckara** · 14/07/2015, 14h52

Je pense que je n'ai pas le choix finalement : "OpenGL3.0+ is not supported in Emscripten.".

Je vais donc devoir me contenter d'OpenGL2. Par contre, j'ai pas l'air d'avoir vu de tutoriels d'OpenGL2 dans la rubrique

.
Je peux peut-être tenter de suivre celui d'OpenGL 3 en espérant que la plupart des fonctions sont communes entre OpenGL2 et OpenGL3 (?).

**Kannagi** · 14/07/2015, 15h01

Envoyé par Neckara

Je vais donc devoir me contenter d'OpenGL2. Par contre, j'ai pas l'air d'avoir vu de tutoriels d'OpenGL2 dans la rubrique

.
Je peux peut-être tenter de suivre celui d'OpenGL 3 en espérant que la plupart des fonctions sont communes entre OpenGL2 et OpenGL3 (?).

Mais s'il n'y a aucun tutoriel OpenGL c'est comme je t'ai dit c'est juste une amélioration de OpenGL 1 avec quelque truc en plus.
Sinon non OpenGL 3 est assez différent de OpenGL 2 donc je pense que cela sera difficile pour toi de faire la transcription (enfin peut etre j'ai jamais commencé par cet ordre).

Donc je t'ai deja donné toute les clé en main pour faire de OpenGL 2 correctement , un lien d'un code minimal (et je te rappel que tu as juste rajouté deux chose shader + VBO) et n'utilise juste jamais glVertex (qui sont quand même encore utilisable dans OpenGL 2 même dans le long terme ces celle que tu n'utilisera plus jamais par exemple dans OpenGL ES 1 ou 2 elle n'existe plus).

**Neckara** · 14/07/2015, 15h13

D'accord, j'essaye de regarder cela ce soir, merci

.

**LittleWhite** · 14/07/2015, 15h15

Ok pour OpenGL 2 précisément, il n'y a pas de tutoriel. Mais dans cette série : http://opengl.developpez.com/tutoriels/opengl-tutorial/ en bas de la page, l'auteur propose un code en version 3.X et un autre en version 2.1. Donc les tutoriels peuvent être suivis (peu de changement) et le code est là en support.

**Neckara** · 14/07/2015, 16h13

@LittleWhite Merci

Je passe en résolut dès que j'arrive à afficher deux petits cubes

**Neckara** · 14/07/2015, 17h11

J'ai réussi à compiler l'exemple de la fenêtre, au niveau du code, il m'a juste suffit de modifier un header :
#include <GLFW/glfw3.h>

Par contre emscripten est un peu capricieux :

glm, j'ai dû copier les sources dans un dossier pour les compiler avec mon projet principal ;
pour glfw3, j'ai dû rajouter l'option "-s USE_GLFW=3" (trouvé dans une des issues github).

Donc contrairement à ce qu'on peut lire sur internet, glfw3 est bel est bien supporté par emscripten, ouf.

**dragonjoker59** · 14/07/2015, 17h40

Par rapport aux différences OpenGL 2 / Open 3, on peut dire ce qu'on veut, elles ne sont pas énormes.
Le seul truc qui m'a chamboulé, c'est la suppression des matrices.
Tout le reste (VBO, IBO, FBO, RBO, shaders), je le faisais déjà en OpenGL 2.1.
Après, avec l'appui d'une bibliothèque comme GLM, les matrices, ça se fait facilement...

**Neckara** · 14/07/2015, 17h50

D'accord.

Je viens de réussir l'affichage d'un triangle marchant avec emscripten et g++, je pense que je pourrais marquer ce sujet en résolu demain.

Concernant les shaders, j'ai dû enlever les "#version 120", car cette version n'est pas supportée par emscripten.
J'ai aussi modifié le code afin d'intégrer les shader à mon code au lieu d'utiliser des fichiers pour emscripten.

Par contre, j'ai dans la sortie standard :

Compiling shader :
(unknown error)
Compiling shader :
(unknown error)
Linking program

Ce qui est étrange sachant que mon triangle est bel et bien affiché correctement.

Dessiner des cubes pour emcc et g++

OpenGL

Discussions similaires

Partager

Partager