FrameBuffer - image vide

Version imprimable

Salut à tous,
J'ai un problème lors de l'utilisation d'un framebuffer, la texture générée par le framebuffer est vide, ou noire. J'ai pourtant suivit à la lettre plusieurs tutoriel, et observé les codes de la plus parte des samples qu'on trouve sur le net, qui eux fonctionnent. Quand je ne bind pas le framebuffer pour voir ce que c'est censé faire, mon rendu fonctionne, mais dès que je le met dans le framebuffer, ma texture apparait noire. Je précise que j'ai bien les shader et les framebuffer disponible.

Voici mon 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
 
// Initialisation
int width = 800;
int height = 600;
 
GLuint fbo;
GLuint tex;
GLuint dbo;
 
 
// DepthBuffer
glGenRenderbuffersEXT(1, &dbo);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, dbo);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
 
// Texture
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,  width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
 
// FrameBuffer
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
 
// Binds
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, dbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);  
 
if (status == GL_FRAMEBUFFER_COMPLETE_EXT)
       printf("FrameBuffer cree avec succes");
 
 
// Dans la boucle d'affichage :
 
// Réinitialisation des matrices pour le frambuffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
 
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(Position.x, Position.y, Position.z, Target.x, Target.y, Target.z, 0, 1, 0 );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90, 800.0/600.0, 0.1, 1000);
 
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
 
glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0,0,width, height);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
RadialPrg.Use(); // Juste un simple program GLSL
       // Ci-dessous, un simple rendu
       glColor3f(255, 255 ,255);
       Sky.DrawSun(Camera);
       glColor3f(0,0,0);
       Terrain.Draw();
       Scene.Draw();
srl::Program::DUse();
 
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 
 
// Un autre rendu qui utilise la texture du framebuffer
// Réinitialisation des matrices pour le rendu
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(Position.x, Position.y, Position.z, Target.x, Target.y, Target.z, 0, 1, 0 );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90, 800.0/600.0, 0.1, 1000);
 
       glBindTexture(GL_TEXTURE_2D, tex);
       for (int i = 0; i < 4; i++) {
          glBegin(GL_QUADS);
          glTexCoord2d(0,1);
          glVertex3d(1,1,1);
          glTexCoord2d(0,0);
          glVertex3d(1,1,-1);
          glTexCoord2d(1,0);
          glVertex3d(-1,1,-1);
          glTexCoord2d(1,1);
          glVertex3d(-1,1,1);
          glEnd();
          glRotated(90,0,0,1);
       }

Merci d'avance,
A toute

13/05/2010, 17h18
TanEk

Utilises-tu des shaders pour rendre ta texture ou pas? Sinon, assures-toi bien de glEnable(GL_TEXTURE_2D) avant de faire le rendu de la texture...
13/05/2010, 17h29
SRL Killing

Oui j'utilise des shader pour rendre la texture, mais le coté rendu marche parfaitement, j'ai mis 4 face pour simplifier mon code, mais sa reviens au même, glEnable(GL_TEXTURE_2D); et toutes les textures se rendent correctement sauf celle du framebuffer.
13/05/2010, 22h42
Syl_20

Tu dois mettre ton bind de frame buffer avant gluLookAt et glViewport
;)
13/05/2010, 23h12
SRL Killing

Merci mais sa ne marche pas, toujours une texture noire

Coucou,

Je dirais que tu dessines dans la mauvaise pile de matrice à première vue.

Dans la configuration de ton buffer tu fais
Code:

1 2 3 4 5 6 7 8 9 glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(Position.x, Position.y, Position.z, Target.x, Target.y, Target.z, 0, 1, 0 ); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(90, 800.0/600.0, 0.1, 1000); //ton shader
En gros ta dernière pile de matrice appelée est la pile de matrices de projection. Je pense qu'il faut repassé sur la pile de matrice modelview avant de dessiner dans ton buffer ou inverser l'initialisation des deux piles de matrices dans le code précédent tel que :
Code:

1 2 3 4 5 6 7 8 9 10 glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(90, 800.0/600.0, 0.1, 1000); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(Position.x, Position.y, Position.z, Target.x, Target.y, Target.z, 0, 1, 0 ); //ton shader
Si tu restes sur la matrice de projection en dernier, tes appels à glRotatef, glTranslatef et autres transformation lors des dessins de tes objets se feront sur ta matrice de projection et non sur ta scène qui est manipulée par la matrice de modelview

17/05/2010, 15h03
SRL Killing

J'ai changé mais sa fait toujours pareil,
merci quand même.
17/05/2010, 15h06
Invité

SRL Killing, quelle est ta carte graphique ?
17/05/2010, 15h12
Invité

Tu peux essayer:
- de mettre GL_NEAREST ou GL_LINEAR pour les filtres GL_MAG_FILTER et GL_MAX_FILTER (sinon sur certaines NVIDIA les samplers renvoient 0)
- de rendre dans une texture POT2 (genre 1024x1024) (si ATI pas HD machin)

Sais tu à 100% si c'est le render-to-texture qui ne marche pas ou ton affichage de texture qui suit ?

Si tu remplis ta texture avec du blanc (glTexImage2D), est-ce que tu vois toujours du noir en l'affichant ?
17/05/2010, 15h15
Invité

Citation:

Envoyé par TanEk

Utilises-tu des shaders pour rendre ta texture ou pas? Sinon, assures-toi bien de glEnable(GL_TEXTURE_2D) avant de faire le rendu de la texture...

Même avec des shaders, les ATI nécessitent des fois cet appel à glEnable(GL_TEXTURE_xx)... :aie:

Coucou,

Encore moi, j'ai peut être une autre piste :mouarf:

Dans ton code tu as les deux lignes suivantes :
Code:

1 2 3 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, dbo);
Donc en gros tu as attaché une texture à ton buffer par glFramebufferTexture2DEXT, or ton buffer est vide et est rattaché à aucun espace mémoire donc la texture rattachée à ton buffer pointe vers aucun espace mémoire.

L'espace mémoire que tu attaches à ton buffer viens après avec glFramebufferRenderbufferEXT.

Essaies d'inverser les deux lignes, attache d'abord l'espace mémoire pour ton buffer avec glFramebufferRenderbufferEXT, et ensuite attache une texture à ton buffer (plus exactement à l'espace mémoire) avec glFramebufferTexture2DEXT :
Code:

1 2 3 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, dbo); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0);
En espérant que ce soit ça.:mrgreen:

17/05/2010, 15h49
SRL Killing

Alors j'ai une NVidia 9800 GT avec les drivers à jour. Les samples qui utilise cette technique marche mais quand j'essais de la reproduire sa ne marche pas, donc je comprend pas.
Le rendu fonctionne parfaitement puisque sur 2 texture, une est affiché (chargée depuis un png) et celle du FBO ne marche pas, alors qu'elles utilise la même technique.

J'ai aussi essayer d'inverser l'appel de glFrameBufferTexture et glFrameBufferRenderBuffer, sans résultat hélas.
17/05/2010, 15h58
Robxley

Question bête, on sait jamais.

Avez vous bien initialisée les fonctions extensions opengl utilisées, avec une lib (glew par ex) ou à la main.

Enfin je pense que oui si non ca ne compilerait pas et/ou l'application cracherait au lancement.
17/05/2010, 16h00
SRL Killing

Effectivement, je l'ai bien initialiser sinon sa n'aurait pas compiler, ou sa aurait crier au lancement, hors la le rendu est niquel à 600 fps.

Oulala...

Quand tu fais le rendu en deux fois, tu ne dois pas avoir la même matrice de projection la deuxième fois, vu que tu veux juste afficher ta texture offscreen (donc ni avec une matrice de perspective ni avec une matrice de camera).

Essaies avec un code genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnable(GL_TEXTURE_2D); glDisable(GL_DEPTH_TEST); glBindTexture(GL_TEXTURE_2D, tex); glBegin(GL_QUADS); glTexCoord2d(0,1); glVertex2d(-1, 1); glTexCoord2d(0,0); glVertex2d(1, 1); glTexCoord2d(1,0); glVertex2d(1, -1); glTexCoord2d(1,1); glVertex2d(-1, -1); glEnd();

17/05/2010, 16h14
Invité

Citation:

Envoyé par SRL Killing

Effectivement, je l'ai bien initialisé sinon ça n'aurait pas compilé, ou ça aurait crié au lancement, hors là, le rendu est nickel à 600 fps.
17/05/2010, 16h17
Robxley

Euh, je suis un peu à court d'idée.

Pouvez vous poster votre code en entier svp. Pour voir ce que ça donne chez moi.
17/05/2010, 16h24
SRL Killing

Euuhhh Ponce.... sois j'ai rien compris, sois tu as dit n'importe quoi.
Si je n'utilise pas les matrices sa fausse tout mon rendu... j'utilise quand meme une camera et tout pour mon vraie rendu, donc je doit utiliser les matrices. (enfin c'est plus pratique)

Je ne cherche pas à faire un rendu off-screen, mais un rendu normal sauf qu'il utilise des shader particulier auquel je veut passer le rendu de la scene sous une autre forme.
Donc je créer un framebuffer et tout ce qui va avec, je fait un premier rendu dans le framebuffer avec un program spécial, puis je fait un vrai rendu avec un program auquel j'ai passé la texture du framebuffer.

Explique toi mieux s'il te plait.
17/05/2010, 16h45
Invité
Si tu utilises un FBO c'est pour faire du rendu "offscreen" (ou "render-to-texture"). OK ?

Je me base sur le code que tu as posté.

Citation:

Euuhhh Ponce.... sois j'ai rien compris, sois tu as dit n'importe quoi.
Si je n'utilise pas les matrices sa fausse tout mon rendu... j'utilise quand meme une camera et tout pour mon vraie rendu, donc je doit utiliser les matrices. (enfin c'est plus pratique)

Oui c'est pour ca que j'ai mis

Citation:

tu ne dois pas avoir la même matrice de projection la deuxième fois

mais lors de ton premier rendu (ie: dans la texture bindée au FBO) c'est bon.

Je parle du code qui est en dessous de
Code:

1 2 // Un autre rendu qui utilise la texture du framebuffer // Réinitialisation des matrices pour le rendu
Lis mieux s'il te plait.

(en même temps c'est pas très clair ce que tu veux faire non plus)
17/05/2010, 16h48
SRL Killing

Je ne comprend toujours pas, pourquoi je ne devrait pas avoir la même matrice de projection ?
Et pourquoi une matrice vide pour le rendu que l'on est censé voir, alors qu'il utilise justement beaucoup de matrices ?
17/05/2010, 16h52
Invité

Ben, vu que ca ne marche pas essaie déjà d'afficher seulement la texture dans laquelle tu as rendu avec un shader simple, histoire d'isoler le problème.

Disons que là tu appliques ta camera (gluLookAt + gluperspective) à la fois lorsque tu rends la texture et lorsque tu l'utilise, ca fait une fois de trop.

Pour ce qui est de la matrice de projection, effectivement tu peux la déclarer qu'une seule fois pour les deux buffers (screen et FBO) vu que tu ne la modifie pas dans l'un et l'autre buffer si tu souhaites le meme type de projection.

Par contre pour la matrice de modelview il est nécessaire de la réinitialiser avec un glLoadIdentity gluLookAt... car contrairement à la matrice de projection, en dessinant tes objets pr l'un ou l'autre buffer tu modifies bien cette matrice en dessinant tes objets.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(...); glMatrixMode(GL_MODELVIEW); FBO_enable(); // active ton FBO glClear(...); glLoadIdentity(); gluLookAt(...); ma_scene1(); //avec des rotations, translations et ce que tu veux comme transformations FBO_disable(); //desactive ton FBO glLoadIdentity(); gluLookAt(...); ma_scene2();
Ce code est suffisant.

Mais bon pour l'optimisation, rien à voir pour le pourquoi du comment ca marche pas avec tes FBOs

17/05/2010, 16h56
SRL Killing

Ben non parcque je recharge la matrice modelview en matrice d'identité, certes sa fait une action inutile, mais c'est parcque des fois le fbo n'utilise pas la même camera que le rendu final.
17/05/2010, 17h44
SRL Killing

Alors en fait, sa fait pas une texture noire, c'est carrément qu'il n'utilise pas la texture, il utilise la couleur définie précédemment dans glColor.
18/05/2010, 10h29
Robxley

Eureka

Salut,

Encore moi :mouarf:

Le fait que ça prenait la couleur déclarée par le dernier glColor c'est normal et cela ne veut pas dire que ta texture ne soit pas pris en compte. Ça peut simplement signifier que ta texture est soit complétement blanche ou soit complétement vide (résultat également complétement blanc,:aie:).

Il n'y a aucune raison quel soit complétement blanche vu que tu cherches à dessiner dedans donc elle est complétement vide.

Une texture qui est complétement vide, c'est qu'elle a été mal initialisée dans le contexte opengl.

Petit rappel, pour les textures Opengl n'accepte que les textures de dimension une puissance de 2.

Donc au finale si on regarde bien ton FBO est bien définit mais ta texture non car les dimensions de ton FBO et par conséquent celles de ta texture ne sont pas des dimensions une puissance de 2 (800x600), tu auras donc ta texture qui sera mal initialisée et par conséquent elle sera vide.

Il faut que tu changes les dimensions de ton FBO par rapport à ce de l'écran. Prend par exemple du (1024*512) ou si tu ne veux pas perdre en résolution (vertical) par rapport à ta fenêtre du (1024x1024) ou toutes autres puissances de 2 qui te conviens.

Eureka ? Ca fait une erreur de plus trouvée, dis moi si maintenant ca fonctionne :mrgreen::mrgreen:

Pas à pas on va finir par y arriver:ccool::ccool:
18/05/2010, 12h44
SRL Killing

Comment ai-je pu passer à coté de ça :aie:
J'étais tellement à fond sur le FBO que j'en oubliais la texture.
Helas, même en définissant toute les taille en 512*512 sa ne marche toujours pas...

Je me disais justement, il n'y aurai pas une fonction openGL pour verifier l'état d'une texture, par hasard, et qui nous dirait justement qu'elle est mal initialisé, et surtout... pourquoi ?
18/05/2010, 14h18
Robxley

Plop,

Pour contrôler les erreurs avec Opengl tu as glGetError.

Mais bon, pour une texture pas besoin de s'embêter, soit tu as ta texture qui s'affiche soit tu as du blanc. A moins de vouloir afficher une texture blanche :mouarf::mouarf:

Euh si non y a pas moyen que tu postes ton code complet histoire de voir si j'arrive à quelque chose sur mon pc par ce que la à première vue j'ai pas d'autre idée.
18/05/2010, 15h47
TanEk

Citation:

Envoyé par Robxley

Une texture qui est complétement vide, c'est qu'elle a été mal initialisée dans le contexte opengl.

Ou qu'elle a ete effacee... En general, quand une texture n'est pas initialisee, elle est loin d'etre "vide" mais a plein de valeurs "aleatoires".

Citation:

Petit rappel, pour les textures Opengl n'accepte que les textures de dimension une puissance de 2.

Il y a une extension qui permet de supporter les textures de dimension quelconque:

http://www.opengl.org/registry/specs...wer_of_two.txt

De plus, cette extension est integree dans le core OpenGL depuis la version 2.0, ce que la majoritee des cartes supporte actuellement.

Citation:

Il faut que tu changes les dimensions de ton FBO par rapport à ce de l'écran. Prend par exemple du (1024*512) ou si tu ne veux pas perdre en résolution (vertical) par rapport à ta fenêtre du (1024x1024) ou toutes autres puissances de 2 qui te conviens.

Un FBO n'est pas oblige d'avoir la meme resolution que l'ecran, c'est d'ailleurs un de ses interets. Par contre, je te recommande d'avoir ta texture aux memes dimensions que ton viewport....

En réalité j'ai un code plus complexe, mais ce code semi-similaire ne marche pas non plus. Je précise que j'utilise ici la SFML, et un fichier pour charger les extensions, mais qui fonctionne (il utilise exactement les même ligne que glew, et les autres extensions chargés avec marche; de plus le compilateur ne grogne pas, et le programme non plus à l'exécution).

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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#include <GL/gl.h>
#include <GL/glu.h>
#include <iostream>
#include <SFML/Graphics.hpp>
#include <SRL/Utils/Extensions.h>
using namespace std;
 
int main()
{
    // Make the window with SFML
    sf::RenderWindow App(sf::VideoMode(800, 600, 32), "SRL_Engine");
    App.PreserveOpenGLStates(true);
    InitGLEXT();
 
    // Initialisation
    int width = 800;
    int height = 600;
 
    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);
    glClearDepth(1.f);
    glClearColor(0.5,0.5,0.5,1);  
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(90, (double)width/height, 0.1, 1000); 
    glViewport(0,0,width, height);
 
    GLuint fbo;
    GLuint tex;
    GLuint dbo;
 
 
    // DepthBuffer
    glGenRenderbuffersEXT(1, &dbo);
    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, dbo);
    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, 512, 512);
    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
 
    // Texture
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,  512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindTexture(GL_TEXTURE_2D, 0);
 
    // FrameBuffer
    glGenFramebuffersEXT(1, &fbo);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
 
    // Binds
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0);
    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, dbo);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 
    GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);  
 
    if (status == GL_FRAMEBUFFER_COMPLETE_EXT)
       printf("FrameBuffer cree avec succes");
 
    sf::Event Event;
    while (App.IsOpened()) {
        while (App.GetEvent(Event)) {
            if(Event.Type == sf::Event::Closed)
                App.Close();
 
            if(Event.Type == sf::Event::Resized)
                glViewport(0, 0, Event.Size.Width, Event.Size.Height);
        }
 
 
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
            gluLookAt(3, 2, 4, 0, 0, 0, 0, 1, 0 );
            glMatrixMode(GL_PROJECTION);
            glLoadIdentity();
            gluPerspective(90, 1.0, 0.1, 1000);
            glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
            glPushAttrib(GL_VIEWPORT_BIT);
            glViewport(0,0, 512, 512);
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
            glBegin(GL_QUADS);
                glTexCoord2i(0,0);glVertex3i(-1,-1,-1);
                glTexCoord2i(1,0);glVertex3i(+1,-1,-1);
                glTexCoord2i(1,1);glVertex3i(+1,+1,-1); 
                glTexCoord2i(0,1);glVertex3i(-1,+1,-1);
 
                glTexCoord2i(0,0);glVertex3i(-1,-1,+1);
                glTexCoord2i(1,0);glVertex3i(+1,-1,+1); 
                glTexCoord2i(1,1);glVertex3i(+1,+1,+1); 
                glTexCoord2i(0,1);glVertex3i(-1,+1,+1);
 
                glTexCoord2i(0,0);glVertex3i(+1,-1,-1); 
                glTexCoord2i(1,0);glVertex3i(+1,-1,+1);
                glTexCoord2i(1,1);glVertex3i(+1,+1,+1);
                glTexCoord2i(0,1);glVertex3i(+1,+1,-1);
 
                glTexCoord2i(0,0);glVertex3i(-1,-1,-1); 
                glTexCoord2i(1,0);glVertex3i(-1,-1,+1); 
                glTexCoord2i(1,1);glVertex3i(-1,+1,+1);
                glTexCoord2i(0,1);glVertex3i(-1,+1,-1);
 
                glTexCoord2i(1,0);glVertex3i(-1,+1,-1); 
                glTexCoord2i(1,1);glVertex3i(+1,+1,-1); 
                glTexCoord2i(0,1);glVertex3i(+1,+1,+1);
                glTexCoord2i(0,0);glVertex3i(-1,+1,+1);
 
                glTexCoord2i(1,0);glVertex3i(-1,-1,+1); 
                glTexCoord2i(1,1);glVertex3i(+1,-1,+1);
                glTexCoord2i(0,1);glVertex3i(+1,-1,-1);
                glTexCoord2i(0,0);glVertex3i(-1,-1,-1);
        glEnd();
        glPopAttrib();
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 
 
        // Un autre rendu qui utilise la texture du framebuffer
        // Réinitialisation des matrices pour le rendu
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(3, 2, 4, 0, 0, 0, 0, 1, 0 );
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(90, (double)width/height, 0.1, 1000);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        glColor3f(150, 150, 150);
        glBindTexture(GL_TEXTURE_2D, tex);
        glBegin(GL_QUADS);
                glTexCoord2i(0,0);glVertex3i(-1,-1,-1);
                glTexCoord2i(1,0);glVertex3i(+1,-1,-1);
                glTexCoord2i(1,1);glVertex3i(+1,+1,-1); 
                glTexCoord2i(0,1);glVertex3i(-1,+1,-1);
 
                glTexCoord2i(0,0);glVertex3i(-1,-1,+1);
                glTexCoord2i(1,0);glVertex3i(+1,-1,+1); 
                glTexCoord2i(1,1);glVertex3i(+1,+1,+1); 
                glTexCoord2i(0,1);glVertex3i(-1,+1,+1);
 
                glTexCoord2i(0,0);glVertex3i(+1,-1,-1); 
                glTexCoord2i(1,0);glVertex3i(+1,-1,+1);
                glTexCoord2i(1,1);glVertex3i(+1,+1,+1);
                glTexCoord2i(0,1);glVertex3i(+1,+1,-1);
 
                glTexCoord2i(0,0);glVertex3i(-1,-1,-1); 
                glTexCoord2i(1,0);glVertex3i(-1,-1,+1); 
                glTexCoord2i(1,1);glVertex3i(-1,+1,+1);
                glTexCoord2i(0,1);glVertex3i(-1,+1,-1);
 
                glTexCoord2i(1,0);glVertex3i(-1,+1,-1); 
                glTexCoord2i(1,1);glVertex3i(+1,+1,-1); 
                glTexCoord2i(0,1);glVertex3i(+1,+1,+1);
                glTexCoord2i(0,0);glVertex3i(-1,+1,+1);
 
                glTexCoord2i(1,0);glVertex3i(-1,-1,+1); 
                glTexCoord2i(1,1);glVertex3i(+1,-1,+1);
                glTexCoord2i(0,1);glVertex3i(+1,-1,-1);
                glTexCoord2i(0,0);glVertex3i(-1,-1,-1);
        glEnd();
        App.Display();
    }
    return(EXIT_SUCCESS);
}

Pour le non-power-of-two, je connaissais l'extension, mais je ne l'utilise pas donc il faut effectivement que je mette une texture qui respecte la puissance de 2.

18/05/2010, 18h51
Invité
Remarque en vrac:
- ne fait pas glClear deux fois de suite dans le même rendu
- avec glColor3f on exprime les valeurs de couleurs entre 0.f et 1.f, pas entre 0.f et 255.f
- gluPerspective(90, 1.0, 0.1, 1000); => essayes avec 60 au lieu de 90, je ne vois pas trop à quoi peut ressembler ton frustum sinon...
- je te conseille de checker les erreurs OpenGL quasiment à chaque appel
18/05/2010, 18h57
TanEk

Citation:

Envoyé par SRL Killing

Pour le non-power-of-two, je connaissais l'extension, mais je ne l'utilise pas donc il faut effectivement que je mette une texture qui respecte la puissance de 2.

Non, si ton driver a une version d'OpenGL superieure a 2.0 (ce qui est le cas maintenant pour la majorite des ordinateurs), cette extension est integree par defaut. Ce n'est donc plus vraiment une extension. Tu ne devrais donc pas t'inquieter d'utiliser des textures de taille quelconque (verifies quand meme la version de ton contexte OpenGL au cas ou).

En gros pour savoir si tu as une fonctionnalite supportee dans OpenGL en general:
- Verifier si elle est integree dans une version d'OpenGL (ici version 2.0) et verifier que la version actuelle est superieure a cette version ;
- SINON, verifier que cette fonctionnalite est dans une extension et verifier que cette extension est presente.
21/05/2010, 22h01
SRL Killing

Merci beaucoup pour vaut réponse, mais les FBO ne marchent toujours pas. Je vais essayer de compiler les samples parcque je trouve bizarre que l'exécutable fonctionne, mais que le code sources casi-similaire ne marche pas.
23/05/2010, 10h03
SRL Killing

J'ai trouvé !
C'est vraiment bête : il faut en fait faire un glGenerateMipmap() sur la texture à chaque fois qu'elle change... allez savoir pourquoi, sans ça, sa ne marche pas.

Merci quand même à vous !