Calcul simple entre deux matrices via la GPU

**kottogeek** · 15/07/2014, 10h08

Bonjour,

Tout est dans le titre, j'aimerais pouvoir effectuer un calcul simple entre deux matrices en utilisant la GPU mais je ne sais pas comment m'y prendre.

J'ai eu à disposition des vertex et fragments shaders mais il semblerait que la GPU les charge bien mais ne les exécute pas correctement car l'image traitée par celle ci ne semble pas modifiée en sortie.

C'est pour cette raison que j'ai envie via un calcul matriciel simple "vérifier" que la GPU bosse correctement via mon code et si oui, utiliser ce canal pour faire l'ensemble des traitements souhaités.

Donc toute aide serait la bienvenue

Merci d'avance à vous!!!!!!

**LittleWhite** · 19/07/2014, 17h10

Bonjour,

Vous parlez de calcul de matrices en 4x4, ou de matrice générales ? Dans le second cas, vous devriez utiliser les compute shader, ou OpenCL/CUDA.
Dans le premier cas, tout se passe en GLSL.

Vous pouvez déboguer le GLSL avec gDEBugger, par exemple.

**kottogeek** · 21/07/2014, 10h53

Bonjour LittleWhite,

Merci une fois de plus pour ta réactivité et ta disponibilité, je parle d'une matrice simple. En fait le projet sur lequel je bosse me génère des erreurs opengl error 1286 lors de l'execution de mes shaders et vu la grosseur du projet il est quasiment impossible de savoir d'où cela provient. Et j'ai même pu constater qu'à l'initialisation survient le premier problème avec l'utilisation de la fonction glClear qui a pour but de vider les tampons. Elle me génère l'erreur 1286.

C'est pour cette raison que je voulais indépendamment de mon projet en n'utilisant que Glsl, c'est à dire sans SDL ou autre, pouvoir faire travailler ma carte graphique via un calcul matriciel ou autre, une simple opération mathématique. Et par la suite, si jamais le résultat s'avérait concluant, réadapter l'ensemble du projet au fur et à mesure en essayant de reproduire l'ensemble des algorithmes mathématiques de traitement d'images.

Je ne sais pas si j'ai été clair?

Dans tous les cas si tu pouvais me fournir un bout de code simple à tester, ainsi que la procédure à suivre je t'en serais infiniment reconnaissant

Après je peux comprendre que tu n'aies pas que ça à faire, mais cela fait un moment déjà que je suis à l'étape où je souhaite interagir avec ma carte graphique et ce sans succès

Mes données d'entrées et de sorties restants identiques

Merci d'avance et merci encore pour ton aide

**LittleWhite** · 21/07/2014, 12h58

Mis à part en OpenCL/CUDA, il faut ouvrir une fenêtre (et un contexte OpenGL) pour faire du GLSL (pour agir avec le GPU). L'ouverture de la fenêtre et du contexte est énormément facilité par SDL/ou autre bibliothèque de fenêtrage. Vous ne pouvez pas vous en passer.
Elle dit quoi votre erreur ? Elle vient d'où ? Du compilateur ou du programme ? Y a t-il un message un peu plus complet ?

**kottogeek** · 21/07/2014, 13h37

Rebonjour,

J'ai créé une fonction qui s'intitule GLH_CHECKERROR() :

Code :

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

1
2
3
4
GLH_CHECKERROR() {
const GLenum glerror = glGetError();
 if (glerror != GL_NO_ERROR) {printf("%s:%s:%d: opengl error %d\n", __FILE__, __FUNCTION__, __LINE__, glerror);}
}

J'utilise donc glGetError() qui est une fonction opengl qui renvoie plusieurs types d'erreurs et ci dessous la liste des erreurs dont la 1286 :

https://www.opengl.org/wiki/OpenGL_Error

A mon avis c'est une erreur qui provient directement de Opengl. Comme je l'ai dit précédemment quand je fais l'initialisation j'ai un problème qui intervient après glClear qui est censée vider les tampons. J'en suis arrivé à utiliser GLH_CHECKERROR() après chaque appel de fonction Opengl afin de détecter où servenait les erreurs dans mon programme (programme hors shaders).

Pour le message d'erreur dans le terminal, glGetError() ne renvoie que le numéro de l'erreur openGl rien de plus.

En espérant avoir été plus clair.

**LittleWhite** · 21/07/2014, 16h01

Premier conseil :

Faites une fonction d'affichage des erreurs OpenGL. En soit, c'est un gros switch case, qui, selon l'erreur renvoyer par glGetError() va afficher un message clair, par rapport à ce qui est écrit dans la doc.

Ensuite, dans ma super calculatrice, 1286, c'est 506 en hexadécimal et donc, c'est : GL_INVALID_FRAMEBUFFER_OPERATION
Et donc, c'est clair. Votre FBO est mal configuré (car de mémoire, cette erreur arrive pratiquement que pour les FBO).

**kottogeek** · 21/07/2014, 16h23

Ca me rassure que l'on soit arrivé à la même conclusion ^^

C'est bien un problème lié au Framebuffer sauf que lors de la création de celui ci quand je fais la vérification d'une présence d'erreur ou non OpenGl je n'ai pas de soucis.

Ce qui est cependant étonnant, c'est qu'au moment de l'initialisation de j'ai l'erreur qui apparait dès le 1er glclear

En tout cas merci pour tes indications mais j'en étais déjà arrivé à cette même conclusion, c'est pourquoi je voulais faire un calcul simple (hors projet) afin de voir si le problème est lié au projet ou à ma définition des fbo qui comme je le disais à la création ne renvoie pas d'erreur.

**LittleWhite** · 21/07/2014, 17h02

Dans ce tutoriel, vous avez un projet simple de FBO : http://alexandre-laurent.developpez....enGL-FBO/#L2-E
Après, pour une erreur de FBO, votre titre de discussion est très éloigné, c'est pour ça que j'ai fait tout ce cheminement.
Je pense qu'il vous manque un glCheckFramebufferStatus. Sinon, un glBindFrameBuffer() avant le glClear() ?

**kottogeek** · 23/07/2014, 13h33

Bonjour LittleWhite,

Je n'ai pas eu besoin d'utiliser glBindFrameBuffer() dans ma fonction ci dessous :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
//Initialisation
void glsl_texture_clear(t_texture *tex, t_u_int32 level, t_double v1, t_double v2, t_double v3, t_double v4, t_u_int8 verbose) {
 
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex->target, tex->handle, level);
	GLH_CHECKERROR();
	glClearColor(v1, v2, v3, v4);
	GLH_CHECKERROR();
	glClear(GL_COLOR_BUFFER_BIT); //On vide les tampons (erreur 1286??? dans texture clear pour texture Vibe).
	GLH_CHECKERROR();
 
	if (verbose)
		TRACE("[GLSL] clear texture (%f,%f,%f,%f) -> %s[%d]\n", v1, v2, v3, v4, tex->name, level);
}

Petite précision, je n'ai pas de soucis lors de la création de mon FrameBufferObject,je n'ai pas d'erreur OpenGL. Cependant, lors de l'initialisation des textures j'ai un soucis avec la fonction glClear qui me génère une erreur.
ps : l'objet de la discussion est vraiment "calcul simple de deux matrices", c'est l'idée que j'ai eu c'est à dire partir d'une opération faite au niveau de la GPU, vérifier que celle ci s'effectue sans encombre PUIS une fois ceci fait, utiliser ce canal pour des opérations plus complexes. Le but étant de vérifier si la GPU réalise bien les traitements souhaités.

**LittleWhite** · 23/07/2014, 14h27

Si vous pensez que c'est au niveau de la texture, pourquoi ne pas copier le code de la création de la texture ?

**kottogeek** · 23/07/2014, 14h37

Voici le code de la création de la texture:

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
t_texture* glsl_texture_create(const char *name, t_s_int32 format, t_u_int32 width, t_u_int32 height, t_u_int32 levels, t_u_int32 clamping, t_u_int32 interpol) {
	t_texture *tex = (t_texture*)memory_malloc_shared(sizeof(t_texture));
 
	tex->format = format;
	tex->width[0] = width;
	tex->height[0] = height;
	tex->levels = levels;
	tex->target = GL_TEXTURE_2D; //GL_TEXTURE_RECTANGLE_ARB
 
	strcpy(tex->name, name);
 
	t_u_int32 i;
	for (i = 1; i < levels; i++) {
		tex->width[i] = tex->width[i - 1] / 2;
		tex->height[i] = tex->height[i - 1] / 2;
	}
 
	glGenTextures(1, &tex->handle);
	GLH_CHECKERROR();
	glBindTexture(tex->target, tex->handle);
	GLH_CHECKERROR();
	float v[] = {0.0, 0.0, 0.0, 0.0};
	glTexParameteriv(tex->target, GL_TEXTURE_BORDER_COLOR, (const GLint*)v);
	glTexParameteri(tex->target, GL_TEXTURE_WRAP_S, clamping);
	glTexParameteri(tex->target, GL_TEXTURE_WRAP_T, clamping);
	glTexParameteri(tex->target, GL_TEXTURE_MAG_FILTER, interpol);
	glTexParameteri(tex->target, GL_TEXTURE_MIN_FILTER, (levels > 1) ? GL_LINEAR_MIPMAP_LINEAR : interpol);
	glTexImage2D(tex->target, 0, tex->format, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
	GLH_CHECKERROR();
	if (levels > 1)
		glGenerateMipmapEXT(tex->target);
 
	return tex;
}

Quand j'utilise glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex->target, tex->handle, level) dans ma fonction lsl_texture_clear l'erreur opengl intervient à glClear. Du coup j'en ai déduis que cela devait venir de ma création de texture

Je suis dans le flou total

**LittleWhite** · 23/07/2014, 16h31

Je suis tout de même étonné. Je vous ai envoyé les liens sur un tutoriel, contenant en plus de cela, un code d'exemple.
Je vous ai parlé de la fonction glCheckFramebufferStatus en disant qu'elle est obligatoire.
Je vais maintenant être très précis.
Veuillez utiliser la fonction glCheckFramebufferStatus juste après votre glFramebufferTexture2D afin de rendre votre FBO valide ! Sans quoi, vous ne pourrez pas effectuer de glClear() dessus, ni rien d'autre.

**kottogeek** · 24/07/2014, 09h42

Bonjour LittleWhite,

Si tu as bien regardé le code glCheckFramebufferStatus n'a pas sa place après glFramebufferTexture2D dans la fonction glclear qui est utilisé lors de l'initialisation de la texture donc rien à voir avec le Fbo.

De plus, j'avais déjà testé glCheckFramebufferStatus lors de la création du Fbo juste après glGenFramebuffers(1, &fbo) mais cela n'a pas résolu mon problème. Donc t'inquiètes pas j'écoute tes remarques. La preuve (le code ci dessous entre balises)

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
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// FBO
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
GLuint glsl_fbo_create(t_u_int32 width, t_u_int32 height, bool bDepth) {
 
	int WindowSizeWidth = (int) width;
	int WindowSizeHeight = (int) height;
	GLuint fbo;
 
// On utilise GLEW pour avoir acces aux fonctions 
	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
        return 0;
	}
 
	// Nous voulons au minimum la version 2 (shader et FBO en extension)
	if (!GLEW_VERSION_2_0)
	{
		fprintf(stderr, "OpenGL 2 is not supported\n");
	}
 
	glGenFramebuffers(1, &fbo);
	glCheckFramebufferStatus(GL_FRAMEBUFFER);
	GLH_CHECKERROR();
	glBindFramebuffer(GL_FRAMEBUFFER, fbo);
	GLH_CHECKERROR();
 
	if (bDepth) {
		GLuint depth_rb;
		// Create a render buffer for the depth
		glGenRenderbuffers(1, &depth_rb);
		glBindRenderbuffer(GL_RENDERBUFFER, depth_rb);
		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
		glBindRenderbuffer(GL_RENDERBUFFER, 0); //test voir si cela change quoique ce soit à depth_rb = 0 (à supprimer si test non concluant)
		GLH_CHECKERROR();
		// Attach depth buffer to FBO
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_rb);
		GLH_CHECKERROR();
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LEQUAL);
	}
	else {
		glDisable(GL_DEPTH_TEST);
	}
 
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
 
	glDisable(GL_BLEND);
	glEnable(GL_TEXTURE_2D);
	glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
	GLH_CHECKERROR();
	return fbo;
}

J'ai toujours le même soucis avec glCear et le fait d'introduire dans la fonction glCheckFramebufferStatus(GL_FRAMEBUFFER) après glFramebufferTexture2D me génère non seulement une nouvelle erreur opengl

mais l'erreur 1286 persiste!!!!!

**LittleWhite** · 24/07/2014, 09h55

La nouvelle erreur OpenGL, donne normalement plus d'indication sur le problème de FBO, si c'est celle qui est retournée par glCheckFramebufferStatus().
Donc étudiez là

(et il va falloir une seconde fonction pour afficher les erreurs/code d'erreur).

Si tu as bien regardé le code glCheckFramebufferStatus n'a pas sa place après glFramebufferTexture2D

Je dis peut être une bêtise, mais de mémoire, il faut vérifier le FBO à chaque changement de configuration, sinon le FBO n'est jamais valide.

**kottogeek** · 24/07/2014, 10h16

Désolé, je me suis avancé, il n'y a pas de nouvelle erreur ^^

En fait ça ne change rien, mon problème intervient au niveau de glClear et c'est l'erreur 1286.

Merci pour ton aide LittleWhite, je vais essayer la solution d'un calcul simple directement via la GPU et une fois que je saurais comment interargir avec celle ci je ferais les autres traitements qui aujourd'hui n'ont pas l'air de se faire soit parce que j'ai des problèmes en amont (erreur opengl 1286) soit tout simplement parce que ma GPU ne travaille pas!!!!

**LittleWhite** · 24/07/2014, 10h27

Dans le dernier code que vous avez envoyé, vous n'associez aucune texture à votre FBO. Donc il n'est pas valide, j'imagine.
De plus, s'il y a une erreur OpenGL, alors il serait étonnant que vous puissiez faire quoi que ce soit sur le GPU, vu que les ordres envoyés ne seront pas validés.

**kottogeek** · 25/07/2014, 11h58

Bonjour,

Que de problèmes avec openGl alors que je respecte l'ordre d'appel des fonctions afin de créer mon Fbo, ma texture et autres

Dans ma fonction de création du Fbo je ne comprends pas pourquoi j'ai une erreur du type GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 dans ma variable status après l'utilisation de glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) alors que je n'ai aucune erreur retournée par glGetError()

.
Voici le début du code ci dessous et mon erreur apparait juste après l'utilisation de la fonction glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo).

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
GLuint glsl_fbo_create(t_u_int32 width, t_u_int32 height, bool bDepth) {
 
	GLuint fbo;
	GLenum status;
 
		GLenum err = glewInit();
 
	if(GLEW_OK != err){
	  std::stringstream emsg;
	  emsg << "Failed to inisialize GLEW - Reason = " << glewGetErrorString(err);
	  throw std::runtime_error(emsg.str());
	}
	// Nous voulons au minimum la version 2 (shader et FBO en extension)
	if (!GLEW_VERSION_2_0)
	{
		fprintf(stderr, "OpenGL 2 is not supported\n");
	}
 
	glGenFramebuffersEXT(1, &fbo);
	GLH_CHECKERROR();
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
	status = glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT);

Je ne sais plus que faire, et dès la présence d'une erreur, impossible d'effectuer les traitements via la GPU :'(

**LittleWhite** · 25/07/2014, 12h06

L'erreur me semble clair. Il faut attaché un buffer de couleur (ici une texture) et une render target au minimum pour que le FBO soit valide. Vous ne le faites pas.
Le tutoriel que j'ai lié n'est t-il pas clair ?

**kottogeek** · 25/07/2014, 13h11

Bonjour,

Je ne dirais pas qu'il n'est pas clair mais la liaison à la texture ne se fait pas dès l'initialisation du Fbo.

Là il est question dans cette fonction de créer mon Fbo et je ne vois pas pourquoi je le lierais à une texture. Je fais aussi indépendamment la création de la texture. Et dans l'exemple du tutorial j'ai vu qu'il y avait deux fonctions distinctes dans render.cpp.

initFBO :

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
char initFBO(GLuint* pBuffer, GLuint* pRenderBuffer, GLuint* pTexture, unsigned int width, unsigned int height)
{
    char error = 0;
 
    assert(pBuffer);
    assert(pRenderBuffer);
    assert(pTexture);
 
    glGenFramebuffers(1, pBuffer);
 
    // Creation du render buffer
    glGenRenderbuffers(1, pRenderBuffer);
    glBindRenderbuffer(GL_RENDERBUFFER,*pRenderBuffer);
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT32, width, height);
    error |= checkError("glRenderbufferStorage");
    glBindRenderbuffer(GL_RENDERBUFFER,0);
 
    // Attachement des donnees au FBO
    glBindFramebuffer(GL_FRAMEBUFFER,*pBuffer);
    error |= checkError("glBindFramebuffer(FBO)");
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *pTexture, 0);
    error |= checkError("glFramebufferTexture2D");
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, *pRenderBuffer);
    error |= checkError("glFramebufferRenderbuffer");
    glBindFramebuffer(GL_FRAMEBUFFER,0);
    error |= checkError("glBindFramebuffer(0)");
 
    return error;
}

et InitTexture:

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
 
char initTexture(GLuint* pTextureID, unsigned int width, unsigned int height)
{
    char error = 0;
 
    assert(pTextureID);
 
    glGenTextures(1,pTextureID);
    error |= checkError("glGenTextures");
 
    glBindTexture(GL_TEXTURE_2D,*pTextureID);
    error |= checkError("glBindTexture(texId)");
 
    // Definit les paramètre de la texture
    // Si ce n'est pas fait, la texture n'est pas valide
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    error |= checkError("glTexParameterf");
    // On alloue un espace pour les futures donnees
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
    error |= checkError("glTexImage2D");
 
    glBindTexture(GL_TEXTURE_2D,0);
    error |= checkError("glBindTexture(0)");
 
    return error;
}

Et dans InitFbo il n'y a pas d'attachement au fbo avant la fonction glBindFramebuffer(GL_FRAMEBUFFER,*pBuffer); qui est celle qui pose soucis dans mon cas. Et je ne vois pas en quoi le fait de ne pas attacher une texture poserait un problème. Moi dans mon cas j'ai fait une attache avec un rendu et ce n'est qu'après que dans ma fonction glsl_texture_clear que je réalise l'attache de la texture au Fbo. Sauf qu'ici apparait la première erreur glGetError() lors de l'appel de glClear!!!!

Code :

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

1
2
3
4
5
6
7
8
9
void glsl_texture_clear(t_texture *tex, t_u_int32 level, t_double v1, t_double v2, t_double v3, t_double v4, t_u_int8 verbose) {
	GLenum status;
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex->target, tex->handle, level);
	status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
	GLH_CHECKERROR();
	glClearColor(v1, v2, v3, v4);
	GLH_CHECKERROR();
	glClear(GL_COLOR_BUFFER_BIT);
	GLH_CHECKERROR();

Je tiens à te remercier LittleWhite

car tu me donnes beaucoup de pistes à explorer même si celles ci s'avèrent des fois infructueuses.

**LittleWhite** · 25/07/2014, 14h01

Les pistes ne sont pas infructueuses du tout, car à chaque fois que vous écrivez un nouveau message vous apportez des incohérences entre votre raisonnement et le fonctionnement d'OpenGL (ce n'est pas une critique, juste, je pense que vous n'avez pas tout saisi).

Reprenons. Pour pouvoir utiliser un FBO, il faut le valider du coté de la carte graphique avec glCheckFramebufferStatus().
Un FBO n'est valide que s'il est complet (un render target et une texture de sortie pour au minimum les couleurs). Tant que cela n'est pas fait, vous ne pouvez pas le faire valider (et vous avez donc des erreurs comme : GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT ).

Tant que le FBO n'est pas valide et s'il est actif, vous aurez des erreurs : GL_INVALID_FRAMEBUFFER_OPERATION

Maintenant, une question m'est venue à l'esprit. Pourquoi avez vous besoin d'un FBO ?

Note : dans InitFBO il y a bien les attachements, ils sont là :

Code :

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

1
2
3
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *pTexture, 0);
    error |= checkError("glFramebufferTexture2D");
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, *pRenderBuffer);