Discussion :

[Neckara]

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]

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]

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]

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]

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]

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]

@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 ?