Calcul simple entre deux matrices via la GPU

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!!!!!!

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.

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 :aie:

Merci d'avance et merci encore pour ton aide

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 ?

Rebonjour,

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

Code:

---

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.

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).

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 :aie:

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.

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() ?

Bonjour LittleWhite,

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

Code:

---

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.

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

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

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

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 :aie:

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.

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:

---

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 :aie: mais l'erreur 1286 persiste!!!!!

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).

Citation:

---

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.

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!!!!

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.

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() :aie:.
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:

---

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 :'(

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 ?

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:

---

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:

---

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:

---

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.

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 ? :aie:

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

Code:

---

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);

---

Citation:

---

au fbo avant la fonction glBindFramebuffer(GL_FRAMEBUFFER,*pBuffer);

---

Car il faut lier le FBO pour pouvoir lui attacher des choses. La liaison != de l'utilisation.

Citation:

---

Sauf qu'ici apparait la première erreur glGetError() lors de l'appel de glClear!!!!

---

Car le FBO, même si vous l'avez attacher, n'était pas valide.

Ok, Je n'ai pas tout saisi je te l'accorde sinon je ne serais pas venu sur ce Forum. A vrai dire, c'était pour avoir les bases car je suis sur un gros projet, qui de base fonctionne sous Unix mais pas sous Windows. ET depuis que je suis sur la partie OpenGl ça compile mais les traitements ne voulant pas faire, j'ai creusé et je sais que c'est à l'exécution d'OpenGl que les problèmes apparaissent.

Il me semble qu'on a besoin d'un Fbo pour pouvoir réaliser des opérations de traitements d'image via notre Gpu et pouvoir y stocker nos résultats. Et perso, j'en ai besoin pour l'utilisation de mes algorithmes de traitements d'image.

J'ai une simple question, parce que bon interpréter mes erreurs et y donner un sens est une chose LittleWhite, j'ai filé le code de mes fonctions et j'ai posé une simple question, pourquoi ai je une erreur dans ma fonction de création du Fbo juste après l'appel de la fonction glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo). A ce stade je suis au début de la création de mon Fbo me générant une erreur telle que GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT?

L'erreur explique pourquoi vous avez une telle erreur.
Vous faites le glCheckFramebufferStatus() juste après le bind, alors que le FBO n'est pas du tout configuré. OpenGL vous l'indique.

Citation:

---

Il me semble qu'on a besoin d'un Fbo pour pouvoir réaliser des opérations de traitements d'image via notre Gpu et pouvoir y stocker nos résultats. Et perso, j'en ai besoin pour l'utilisation de mes algorithmes de traitements d'image.

---

Lorsque l'on utilise OpenGL, quelques fois, mais pas nécessairement en Cuda/OpenCL.

J'ai montré un tutoriel qui explique pas à pas la liste des choses à faire pour les FBO. Il y a un diagramme, il y a un code d'exemple. Faites déjà un truc qui marche et après, vous supprimerez les trucs, comme les render target en trop ou autre. Mais partez au moins d'une base stable.

Et je pense que vous faites une confusion de l'endroit où vienne les erreurs, du coup, j'ai du mal à suivre, mais on se débrouille.
Vous pourriez aussi utiliser gDEBugger pour déboguer le code OpenGL.

Note : montrez moi votre code (la partie complète sur les FBO) et on verra bien.

Bonjour,

Je vais créer un projet et suivre le tutorial, cependant comme je l'ai indiqué je ne souhaite pas utiliser autre chose qu'opengl pour la création de contexte ou autre. Je vais donc travailler uniquement qu'en glsl.

Voici la partie du code sur le fbo :

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

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); GLH_CHECKERROR();     bDepth = true;   if (bDepth) { GLuint depth_rb; // Create a render buffer for the depth glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height); GLH_CHECKERROR(); // Attach depth buffer to FBO glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); GLH_CHECKERROR(); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); status = glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT); } 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(); status = glCheckFramebufferStatus(GL_FRAMEBUFFER); return fbo; }

---

Merci encore pour ton aide LittleWhite :D !!!!!

Bonjour !

Comme le dit LittleWhite depuis un moment, dans ton code d'initialisation du FBO, tu n'attaches pas à ton FBO de texture pour la partie couleur.
A la sortie de ta fonction d'initialisation, ton FBO est incomplet et donc inutilisable.

Ok, donc par déduction pour rendre mon fbo fonctionnel celui ci doit impérativement être attaché à une texture?

Voici une autre fonction que j'ai écrite en y intégrant la texture mais rien y fait :

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

GLuint glsl_fbo_create(t_texture *tex, t_u_int32 width, t_u_int32 height, bool bDepth) {     int WindowSizeWidth = (int) width; int WindowSizeHeight = (int) height; GLuint fbo; GLenum status; // 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"); }   glGenFramebuffersEXT(1, &fbo); GLH_CHECKERROR();     if (bDepth) { GLuint depth_rb; // Create a render buffer for the depth glGenRenderbuffersEXT(1, &depth_rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height); GLH_CHECKERROR(); glBindRenderbuffer(GL_RENDERBUFFER,0); GLH_CHECKERROR(); // Attach depth buffer to FBO // Attachement des donnees au FBO glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); GLH_CHECKERROR(); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, tex->target, tex->handle,0); GLH_CHECKERROR();// Attach depth buffer to FBO glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb); GLH_CHECKERROR(); status = glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT); 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(); status = glCheckFramebufferStatus(GL_FRAMEBUFFER); return fbo; }

---

Je tiens quand même à souligner que l'attache à la texture n'est pas une obligation car j'ai vu pas mal de code de création de fbo qui ne se contentait que d'une attache au render.

Bien sur, l'attache à une texture est optionnelle.
En fait, il doit y avoir quelque chose attaché à la composante couleur.
Ce quelque chose peut être :
- Un render buffer si tu ne souhaites pas faire de traitement sur cette composante
- Une texture si tu veux récupérer le résultat et y effectuer un traitement (ce qui est ton cas, si je ne me trompe pas...)

Oui oui effectivement, c'est mon cas!!!!

N'est il donc pas possible de créer indépendamment une texture et un fbo et ensuite les lier?

En l'occurrence créer le fbo comme je le fais en le liant au render puis l'attacher à ma texture créée?

J'ai du mal avec l'erreur liée à mon fbo car dans le code que j'ai fourni je n'ai pas l'impression d'avoir zappé une étape, si ce n'est l'attache à la texture qui dans la fonction une est remplacée par l'attache au render. Mon fbo devrait donc néanmoins être valide à sa création non?

Le principal est qu'au moment de l'utilisation de ton FBO, il soit complet.

La question est là, pourquoi ne l'est il pas? :aie:

Je ne vois pas ce qui cloche mais bon je recommence en partant du tutorial de LittleWhite, je verrais bien ^^

Salut LittleWhite,

Je suis parti sur la base de ton exemple Fbo mais sans l'utilisation de la SDL pour la création du contexte mais plutôt l'utilisation de Glut ;)

Cependant, je suis un peu bloqué car j'essaye de faire la multiplication de deux images dont je stocke initialement en théorie les valeurs de pixels et l'intensité des pixels dans des vertex et fragment shaders. Mais je ne vois pas comment procéder.

Maintenant que mon Fbo est valide, je veux y stocker le résultat de mon calcul, il s'agit bien sur là d'une multiplication de matrices.

La méthode vraiment basique pour ce faire est d'afficher un rectangle recouvrant l'écran (l'écran doit être de la taille de vos images dans ce cas), afin de forcer le pixel shader à s'executer sur chacun des pixels des images. Les sources de vos données seront deux textures. De plus, il faudra enlever tout filtrage des texture.
Sinon, il faudrait utiliser CUDA ou les compute shader (OpenGL 4), c'est plus approprié.