FrameBuffer - image vide

Version imprimable

Voir 40 message(s) de cette discussion en une page

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 !

Voir 40 message(s) de cette discussion en une page