flat-shading algorithm and shaders.

Version imprimable

Bonjours les GL,

j'ai le problème suivant: je n'arrive pas a faire fonctionner le concept de shading.

Ou plutôt a implémenter le fonctionnement d'une source lumineuse qui projetterai de la lumière sur un polyèdre

ayant une couleur uniforme pour toutes ses faces.

Le but étant bien sur de calculer le taux de lumière réfracter donc a illuminer mon polyèdre de multiples intensités d'une couleurs,

selon la position de la source de lumière.

J'utilise pour l'instant l'algorithme de flat-shading: qui se base sur un calcule de deux vecteurs.

1. Le vecteur de position du vertex a colorer.

2. La source de lumière.

Et qui renvoie un cosinus dont ont peut se servir de la valeur (a condition que valeur == -1.0-0 ; // face a la lumière)

pour multiplier la valeur de départ de la couleur.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if (cos(alpha) < 0) {
 
  // The vertex and the light vectors make an angle of 90°-270°.
 
  // So the light is refracted in relationship to his position.
 
  color = vertex * -cos(alpha) ;
 
}
else {
 
  // The vertex is not lighted.
 
  color = color ;
}

:note: En fait le flat-shading n'est pas exact mais acceptable comme algorithme d'illumination et il demande peu de calcule.

---

J'ai essayer de multiples manières et selon le procéder suivant:

en implémentant la fonction de calcule du multiplicateur dans le shader.

---

Bon un du code est bien mieux que du blabla.

Voici ma méthode d'affichage:

Code:

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
 
 
 void Ellipsoid::display() {
 
    GLint color_id    ;
    GLint mv_matrix   ;
    GLint cam_matrix  ;
    GLint proj_matrix ;
 
    GLint light_src_id ;
 
    light_src_id = glGetUniformLocation(program, "lighting_pos") ;
 
    color_id   = glGetUniformLocation(program, "color_vec") ;
 
    mv_matrix  = glGetUniformLocation(program, "mv_matrix") ;
    cam_matrix = glGetUniformLocation(program, "cam_matrix") ;
    proj_matrix = glGetUniformLocation(program, "proj_matrix") ;
 
    // So that we can get the value for debugging purpose.
    GLint testing_id = glGetUniformLocation(program, "testing") ;
 
    glUseProgram(program) ;
 
 
    glUniformMatrix4fv(proj_matrix, 1, GL_FALSE, glm::value_ptr(proj))    ;
    glUniformMatrix4fv(cam_matrix,  1, GL_FALSE, glm::value_ptr(camera))  ;
    glUniformMatrix4fv(mv_matrix,   1, GL_FALSE, matrix.data() )  ;
 
    GLint position_id    = glGetAttribLocation(program,  "position");
    GLint text_sampler2D = glGetUniformLocation(program, "myTextureSampler");
    GLint texture_id     = glGetAttribLocation(program,  "vertexUV");
    GLint intensity_id   = glGetUniformLocation(program,  "color_intensity");
 
 
    glUniform1i(text_sampler2D, 0);
 
    glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
    glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 0, NULL) ;
 
    glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
    glVertexAttribPointer(texture_id,  2, GL_FLOAT, GL_FALSE, 0, NULL);
 
    glEnableVertexAttribArray(position_id);
    glEnableVertexAttribArray(texture_id);
 
    /** Start draw ellipsoid_sphere. **/
 
    int offset = 0 ;
 
    for (uint32_t c=0 ; c < number_of_quads ; c++) {
 
      if (use_colors) {
 
        if (uni) { // Boolean member value.
          if (not colors.empty()) {
            glUniform4fv(color_id, 1, colors.at(0).get_vector()) ;
          }
        }
        else {
          if (not colors.empty()) {
 
            glUniform4fv(light_src_id, 1, glm::value_ptr(lighting_vector)) ;
 
            glUniform4fv(color_id, 1, colors.at(c % colors.size()).get_vector()) ;
 
            #if 1
            // We grab the value of the output of the shadering function for displaying it's value: It always equal zero.zero.
            float testing_val  = 0 ;
            glGetUniformfv(program, testing_id, &testing_val) ;
 
             fprintf(stderr,"-> %.12f\n", testing_val) ;
            #endif
 
          }
        }
      }
      else if (use_textures) { // Boolean member value.
 
        if (uni) {
          glBindTexture(GL_TEXTURE_2D, texture_ids.at(0));
        }
        else {
          glBindTexture(GL_TEXTURE_2D, texture_ids.at(c));
        }
      }
      if (show_faces) { // Boolean member value.
        glDrawArrays(GL_TRIANGLE_FAN, offset,  4);
      }
      if (show_lines) { // Boolean member value.
        glUniform4fv(color_id, 1, lines_colors.get_vector()) ;
        glDrawArrays(GL_LINE_LOOP, offset,  4);
      }
 
      offset += 4 ;
 
    }
 
    /** End draw ellipsoid_sphere. **/
 
 
 
    glDisableVertexAttribArray(position_id);
    glDisableVertexAttribArray(texture_id);
 
 
 
 
}

Vous voyez bien que j'implémente les vertices dans un buffer mais le(s) couleur(s) sont passer par une variable uniform (Une couleur par face).

Du coup Il m'est pas possible de multiplier un vertice par une fonction qui renvoie le cosinus des deux vecteurs.

Autrement dit d'implémenter la fonction de calcule autre part que dans le shader.

Et en plus comme je ne peut accéder au vertice qui est dans le buffer mais je ne peut utiliser ma méthode de flat-shading

qui consiste a multiplier la valeur de la couleur d'origine du polyèdre par le cosinus si celui ci < 0.

---

Le shader de vertice est le suivant:

Code:

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
#version 150 core
//#version 430 core
 
in vec4 position ;
 
out VS_OUT {
 
    vec4 color;                               
 
} vs_out ;                                     
 
#if 1
float test(vec3 vertex, vec3 lighting_pos) {
 
  float vertex_vec_length = length(vertex) ;
 
  float lighting_pos_length = length(lighting_pos) ;
 
  vertex = normalize(vertex) ;  lighting_pos = normalize(lighting_pos) ;
 
  float cos_of_dot = (vertex[0] * lighting_pos[0] + vertex[1] * lighting_pos[1] + vertex[2] * lighting_pos[2]) / (vertex_vec_length * lighting_pos_length) ;
 
  return cos_of_dot ;
 
}
#endif
 
uniform vec4 color_vec  ;                                
 
uniform vec4 lighting_pos ;
 
 
uniform mat4 mv_matrix ;                                              
uniform mat4 cam_matrix ;
uniform mat4 proj_matrix ;
 
uniform float color_intensity ;
 
#if 1
uniform float testing = test(position, lighting_pos) ;
#endif
 
void main(void)                               
{
 
 
    gl_Position  = proj_matrix * cam_matrix * mv_matrix * position ;
    vs_out.color = color_vec ; // The goal is to multiplicate: color_vec * test(position, lighting_pos) but test(...) return always 0.0  ;                 
 
    //vs_out.color = color_vec * test(position, lighting_pos) ; // In this case it display nothing....
}

Le problème est aussi que la même fonction nommer test(...) implémenté dans le code source fonctionne: elle ne renvoie pas toujours zéro.

par contre dans le shader elle ne fonctionne pas (elle renvoie toujours zero.zero) ce qui me parait bizarroid...

---

Toute aide, conseils, réponses est la bienvenue.

Merci de bien vouloir éclairé ma lanterne.

P.S: J'ai essayer de maintes fois et j'avais même réussis a implémenter le concept en thrash python.

10/08/2017, 10h27
dragonjoker59

Salut!

Que ce soit en flat ou en smooth shading, la fonction de calcul de l'éclairage ne change pas.
Ce qui change, c'est la manière dont tu calcules tes normales.
Hors là, tu ne passes pas les normales de ton polyèdre au shader (on les met généralement dans le VBO, avec la position et les coordonnées de texture).
Commence par faire ça, et ça te simplifiera grandement la vie.
11/08/2017, 03h39
Luke spywoker

Merci pour la réponse,

est-t-il possible:

1. d'utiliser plusieurs buffer en entrée de shader.

Comme cela je pourrai mieux contrôler les couleurs.

2. de récupérer les données du buffer.

Si oui, comment ?

Merci pour vos réponses.

P.S: Un petit patron de shader m'aiderai, merci.

1) Oui, tu peux avoir plusieurs VBO en entrée d'un shader, il faut juste que leur contenu corresponde.
Supposons que tu as dans ton premier VBO les positions, normales, et coordonnées de texture, et dans le second VBO les couleurs.
Le layout du premier VBO ressemblerait à ceci : V0N0T0,V1N1T1, ..., VnNnTn.
Le layout du second VBO doit alors ressembler à ceci: C0,C1, ..., Cn.
Tu pourrais même envisager d'avoir un VBO pour chaque composante d'un sommet (donc 4 dans cet exemple):
V0,V1,...,Vn
N0,N1,...,Nn
T0,T1,...,Tn
C0,C1,...,Cn

2) Pour la récupération des données d'un buffer, ce n'est pas possible via les VBO, car le vertex shader aura en entrée pour notre exemple Vi, Ni, Ti, Ci.
Si tu veux faire autrement (pour les couleurs par exemple), il te faut alors stocker les couleurs dans un autre buffer : UBO si tu en as peu (il est limité en taille) ou SSBO si tu en as beaucoup (il n'est pas limité en taille, mais les accès sont un peu moins rapides qu'un UBO).
Et il te faut alors stocker l'index de la couleur voulue dans une composante d'un VBO.

3) Un patron de shader ?
En voilà un (non testé) pour une lumière directionnelle (donc sans position, et avec une direction).
J'utilise un SSBO pour le stockage des couleurs, et un UBO pour le stockage des données de la lumière.

Vertex Shader :
Code:

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 #version 450 in vec3 position; in vec3 normal; in vec2 texture; in int index; uniform mat4 world; uniform mat4 view; uniform mat4 projection; out vec3 pxl_position; out vec3 pxl_normal; out vec3 pxl_texture; flat out int pxl_index; void main() { vec4 pos = vec4( position, 1.0 ); pos = view * world * pos; pxl_position = pos.xyz; pxl_normal = mat3( transpose( inverse( world ) ) ) * normal; pxl_texture = texture; pxl_index = index; gl_Position = projection * pos; }
Fragment Shader :
Code:

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 #version 450 in vec3 pxl_position; in vec3 pxl_normal; in vec3 pxl_texture; in int pxl_index; uniform vec3 cameraWorldPos; layout( std130, binding = 0 ) uniform Light { vec3 lightColour; vec3 lightDirection; vec3 lightIntensity; // (ambient, diffuse, specular) } layout( std430, binding = 1 ) buffer Colours { vec4 colour[]; }; out vec4 out_fragColour; void main() { // On récupère la couleur de l'objet : vec4 objColour = colour[pxl_index]; // Composante ambiante de la lumière. vec3 lightAmbient = lightColour * lightIntensity.x; // Composante diffuse de la lumière. vec3 lightDir = normalize( -lightDirection ); vec3 normal = normalize( pxl_normal ); float diffuseFactor = max( dot( normal, lightDir ), 0.0); vec3 lightDiffuse = diffuseFactor * lightColour * lightIntensity.y; // Composante spéculaire de la lumière. vec3 viewDir = normalize( cameraWorldPos - pxl_position); vec3 reflectDir = reflect(-lightDir, normal ); float specularFactor = pow( max( dot( viewDir, reflectDir ), 0.0 ), 32 ); vec3 lightSpecular = specularFactor * lightColour * lightIntensity.z; // Combine les 4 pour obtenir le résultat. out_fragColour = objColour * vec4( lightAmbient + lightDiffuse + lightSpecular, 1.0 ); }

12/08/2017, 13h52
Luke spywoker

Merci pour la réponse,

je ne suis pas un pro de OpenGL donc j'apprécie ton aide et je regrette l'ancien OpenGL (<= 2.0).

Car je ne comprends pas la abbréviation UBO nie SSBO par contre un VBO c'est un (Vertex Buffer Object ???) si je me trompe pas.

Quand ont utilise des abbréviations il vaut mieux mettre la définition entre parenthèse au moins une fois.

Car même si je savait ce qu'ils veulent dire d'autres pourraient tomber sur ce poste.

Encore merci aussi pour les patrons je vais les essayer...

:Info: Les 2 types de shaders ont pour extension de nom de fichier: glslv (Vertex shader) et glslf (Fragment shader).
12/08/2017, 17h49
dragonjoker59

UBO => Uniform Buffer Object (dans le core depuis la version 3.1 : GL wiki).
SSBO => Shader Storage Buffer Object (dans le core depuis la version 4.3 : GL wiki).

Moi je ne regrette absolument pas les glBegin/glEnd ni les display lists :P

:info: Il n'y a pas d'extension standard pour les fichiers de shader GLSL ;)
13/08/2017, 11h21
Luke spywoker

Citation:

Il n'y a pas d'extension standard pour les fichiers de shader GLSL

Peut être que ce n'est pas normer mais mon éditeur que j'ai créer reconnait ses extension et son dans sa liste d'extensions pris en charge.

Et du coup la coloration syntaxique pour les deux extension sont fort pratique.

Encore merci, comme je fait un break après un demi-paver de lecture de l'âge des dinosaures de la programmation 3D (OpenGL et DirectX), je verrai tes patrons shaders un peu plus tard.

D'ailleurs ce vieux bouquin explique tout ce que vous fournis OpenGL automatiquement rastérisation, z-buffer, Bresenham, ... clipping.

Tout a la mains sans invoquer aucune fonction OpenGL ou presque...

Merci gracieusement pour ton aide, en espérant que j'arrive a mes fins d'ailleurs j'ai créer un générateur de simple ou double dégradé afin de colorier mes polyèdre.
14/08/2017, 10h08
dragonjoker59

Et bien ajoute les extension .glsl, .vert, .frag, .geom, .ctrl, .eval, .comp à ton éditeur, du coup
19/08/2017, 06h04
Luke spywoker

C'est la bibliothèque sur lequel se base mon éditeur qui fait cela.

D'ailleurs glslf et glslv se comprend facilement GLShaderLanguageFragment && GLShaderLanguageVertex.

Commentaire

On va commencer doucement par ce je galère:

en commençant par mettre mes couleurs dans un buffer au lieu de mettre une couleur par polygone usant d'un glUniform...

Je remplit correctement mon buffer (? GL_ARRAY_BUFFER) de float puis le bout de code suivant ne marche pas:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 // [...] // Ma boucle d'affichage: exactement comme mes vertex sauf que là il s'agit de couleurs et cela ne fonctionne pas. int offset = 0 for (int c = 0 ; c < nb_of_quads ; ++c) { // Code pour les autres choses [...] if (use_colors) { // Comme les vertex dans l'ordre de la déclaration des **in** dans le shader. // Car il n'y pas de constante comme pour les vertex. // 3*4 float pour 4 vertex: une couleur par vertex...??? (J'ai pas mon code sur moi, désolé). glDrawArrays(GL_TRIANGLE_FAN, offset, 3*4); } offset += 4 ; // Voir notes. }
:note: je boucle en général sur des QUADS selon des vertex d'un polygone dans un vecteur.

Autrement dit:
Code:

1 2 3 std::vector<std::vector<glm::vec3>> vertex_list = generate_polyhedron(...)
Et la documentation n'est pas très verbeuse concernant les couleurs.

P.S: Je ne suis actuellement pas chez moi donc mon poste est un peu trash, désolé.

09/09/2017, 11h17
dragonjoker59

Ben un buffer de couleurs n'est pas différent d'un buffer de positions, il faut l'ajouter au VAO comme les autres, ajouter son traitement dans le shader (un attribut in vec4 colour; en plus), et la boucle de rendu déjà existante s'en sortira très bien
14/09/2017, 21h40
Luke spywoker

Merci pour la réponse,

Il me semble que je fait tout correctement:

D'abord mon constructeur (using c++) qui génère les vertex et remplis un buffer.

Puis obliger d'appeler un setter qui remplie un deuxième buffer pour les couleurs.

Puis dans la boucle dans de la fonction display ``glDrawArrays(GL_TRIANGLE_FAN, offset, 4);``...

Mon polyèdre apparait tout noir et même des fois tout rouge, je ne comprend pas ?

Peut être un problème avec mon système Ubuntu car j'inclus que ces 2 buffers (in vec4 position) et (in vec4 color_vec) pour l'instant.

---

Merci pour vos réponses éclairées.

P.S: Je vous montrerai plus de code la prochaine fois.
15/09/2017, 09h48
Luke spywoker
Je vous envoie un zizip avec:

+ un Makefile
Code:

1 2 3 $ make # Build $ make exec # Execute
+ Et un polyèdre simple ou je fait mes essaie dessus: un Ellipsoid.

+ L'objet Ellipsoid a comme père la classe Polyhedron.

Ne vous souciez pas du reste ou si comme il vous plaira.

Le zip est un peut trashy parce que c'est pour expérimenter.

Les shaders sont dans le sous-dossier shader.

Et donc pensant tout avoir fait correctement soit il m'affiche le polyèdre en noir soit en rouge cela dépends de l'ordre des 2 différents``in``.
Code:

1 2 3 4 5 6 7 8 9 #version 150 core //#version 430 core in vec4 position ; in vec4 color_vec ; // [...]
Merci.

Bon, je suis sous Windows, donc j'ai galéré à compiler ton code (c'est quoi cet abus de 'and', 'not', 'or' ? en C et en C++, on utilise '&&', '!', '||').
Ensuite, je n'ai pas Python installé, donc je ne peux même pas pousser l'exécution jusqu'a ton probleme.
Enfin, j'ai eu un crash lorsque le log d'erreur de compilation de shader est vide, j'ai modifié comme suit :

Code:

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
  glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
  glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
 
  if (InfoLogLength)
  {
    std::vector<char> VertexShaderErrorMessage(InfoLogLength, '\0');
    glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
    fprintf(stdout, "Vertex shader error: %s\n", VertexShaderErrorMessage.data());
  }
 
  // Compile the fragment shader.
  printf("Compiling shader : %s\n", fragment_file_path.c_str());
  char const * FragmentSourcePointer = FragmentShaderCode.c_str();
  glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
  glCompileShader(FragmentShaderID);
 
  // Check the fragment shader.
  glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
  glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
 
  if (InfoLogLength)
  {
    std::vector<char> FragmentShaderErrorMessage(InfoLogLength, '\0');
    glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
    fprintf(stdout, "Fragment shader error: %s\n", FragmentShaderErrorMessage.data());
  }
 
  // Read the program.
  fprintf(stdout, "Linking program\n");
  GLuint ProgramID = glCreateProgram();
  glAttachShader(ProgramID, VertexShaderID);
  glAttachShader(ProgramID, FragmentShaderID);
  glLinkProgram(ProgramID);
 
  // Check the program.
  glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
  glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
 
  if (InfoLogLength)
  {
    std::vector<char>  ProgramErrorMessage(InfoLogLength,'\0') ;
    glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
    fprintf(stdout, "Error message: %s\n", ProgramErrorMessage.data());
  }

15/09/2017, 20h17
Luke spywoker

Merci beaucoup pour le portage que tu dû a supporter: GNU/Linux vers Windows.

Tu n'as pas besoin de python sauf pour charger des textures: dans ce cas l'image de fond d'écran (regarde la variable bg_image) et commente ses quelques apparitions.

Ce que je ne comprends pas c'est pourquoi un shader aussi simple avec 2 buffers en entrée ne fonctionne pas.

Qu'est ce que j'ai fait de travers ?

---

Sinon tu peut te servir librement des fonction de générations de formes fournis avec (surtout le fichier sphere_generators.cpp).

Il suffit de faire a l'ancienne pour voir la sortie des différentes formes, si vous voulez.

---

Merci pour la peine que tu t'est donner.

:note: L'univers courbe est intéressant non ?
18/09/2017, 09h02
dragonjoker59

Pourquoi utiliser Python pour charger les images, alors que tu utilises la SDL qui fait cela très bien ?

Voilà un code de chargement d'image via la SDL, que j'ai utilisé (mais pas complètement testé), et adapté pour ton code.

Code:

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
122
123
124
125
126
127
128
	SDL_Surface * surface = IMG_Load( path.c_str() );
 
	if ( !surface )
	{
		throw std::runtime_error( "couldn't load image " + path );
	}
 
	GLuint internal;
	GLuint format;
	GLuint type;
 
	switch ( surface->format->format )
	{
	case SDL_PIXELFORMAT_RGB444:
		internal = GL_RGBA4;
		format = GL_RGB;
		type = GL_UNSIGNED_SHORT_4_4_4_4;
		break;
	case SDL_PIXELFORMAT_RGB555:
		internal = GL_RGB5;
		format = GL_RGB;
		type = GL_UNSIGNED_SHORT_5_5_5_1;
		break;
	case SDL_PIXELFORMAT_BGR555:
		internal = GL_RGB5;
		type = GL_UNSIGNED_SHORT_5_5_5_1;
		format = GL_BGR;
		break;
	case SDL_PIXELFORMAT_RGBA4444:
		internal = GL_RGBA4;
		format = GL_RGBA;
		type = GL_UNSIGNED_SHORT_4_4_4_4;
		break;
	case SDL_PIXELFORMAT_BGRA4444:
		internal = GL_RGBA4;
		format = GL_BGRA;
		type = GL_UNSIGNED_SHORT_4_4_4_4;
		break;
	case SDL_PIXELFORMAT_RGBA5551:
		internal = GL_RGB5_A1;
		type = GL_UNSIGNED_SHORT_5_5_5_1;
		format = GL_RGBA;
		break;
	case SDL_PIXELFORMAT_BGRA5551:
		internal = GL_RGB5_A1;
		type = GL_UNSIGNED_SHORT_5_5_5_1;
		format = GL_BGRA;
		break;
	case SDL_PIXELFORMAT_RGB565:
		internal = GL_RGB;
		type = GL_UNSIGNED_SHORT_5_6_5;
		format = GL_RGB;
		break;
	case SDL_PIXELFORMAT_BGR565:
		internal = GL_RGB;
		type = GL_UNSIGNED_SHORT_5_6_5;
		format = GL_BGR;
		break;
	case SDL_PIXELFORMAT_RGB24:
		internal = GL_RGB;
		type = GL_UNSIGNED_BYTE;
		format = GL_RGB;
		break;
	case SDL_PIXELFORMAT_BGR24:
		internal = GL_RGB;
		type = GL_UNSIGNED_BYTE;
		format = GL_BGR;
		break;
	case SDL_PIXELFORMAT_RGB888:
		internal = GL_RGB;
		type = GL_UNSIGNED_BYTE;
		format = GL_RGB;
		break;
	case SDL_PIXELFORMAT_RGBX8888:
		internal = GL_RGBA;
		type = GL_UNSIGNED_BYTE;
		format = GL_RGBA;
		break;
	case SDL_PIXELFORMAT_BGR888:
		internal = GL_RGB;
		type = GL_UNSIGNED_BYTE;
		format = GL_BGR;
		break;
	case SDL_PIXELFORMAT_BGRX8888:
		internal = GL_RGBA;
		type = GL_UNSIGNED_BYTE;
		format = GL_BGRA;
		break;
	case SDL_PIXELFORMAT_RGBA8888:
		internal = GL_RGBA;
		type = GL_UNSIGNED_BYTE;
		format = GL_RGBA;
		break;
	case SDL_PIXELFORMAT_BGRA8888:
		internal = GL_RGBA;
		type = GL_UNSIGNED_BYTE;
		format = GL_BGRA;
		break;
	case SDL_PIXELFORMAT_RGBA32:
		internal = GL_RGBA;
		type = GL_UNSIGNED_BYTE;
		format = GL_RGBA;
		break;
	case SDL_PIXELFORMAT_BGRA32:
		internal = GL_RGBA;
		type = GL_UNSIGNED_BYTE;
		format = GL_BGRA;
		break;
	default:
		throw std::runtime_error( "Unsupported image format" );
	}
 
	GLuint text_id;
 
	glGenTextures( 1, &text_id );
	glBindTexture( GL_TEXTURE_2D, text_id );
 
	glTexImage2D( GL_TEXTURE_2D, //target
		0, //level=First mip-level  
		internal, //internal_format=bytes per pixel <= Non!
		surface->w,  //image width
		surface->h, //image height
		0, //border=texture border set or not 1|0
		format, //format=GL_RGB|GL_RGBA
		type, //type=storing format
		( unsigned char * )surface->pixels );
 
	SDL_FreeSurface( surface );

Il ne faut pas oublier d'ajouter IMG_Init( IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF | IMG_INIT_WEBP ); (pour initialiser les loaders spécifiques) juste après SDL_Init();, et IMG_Quit(); juste avant le SDL_Quit();

22/09/2017, 13h15
Luke spywoker

Ca marche pour les textures.

Merci grandement pour le code pour charger une texture avec la SDL2,

comme ça je ne suis plus dépendant de python pour cette tâche et surtout j'ai pas besoin de forker.

J'avais pas remarquer l'analogie des codes pour le format entre la SDL2 et OpenGL.

Ton code fait partie de ma library personnel maintenant que je ne compte pas publier.

Merci beaucoup et il va falloir que je fasse un nouveau poste concernant les 2 buffers:

1 pour les vertex,

1 pour les couleurs.

Luke Spywoker.