Utiliser openGL et obtenir le contenu dans un buffer

**delfare** · 15/04/2006, 18h03

bonjours,
pour un projet, j'ai besoin d'utiliser openGL et d'obtenir le resultat dans un buffer.
j'ai besoin d'utiliser openGL sans librairie de fenetrage(donc, dans un buffer) : ce projet est deja cree avec gtk et win32(il y a 2 versions).

je sais que c'est possible(sinon, les GUI ne pourraient pas l'integrer(qt,gtk,...) )

je precise que je ne peux pas utiliser les fonctions deja faites pour openGL avec gtk ou win32 car ce projet gere au maximum 3 background qui se superposent(dont un qui peut contenir la 3d)

merci d'avance,
delfare

**shenron666** · 18/04/2006, 08h58

en cherchant su rle forum tu pouvais trouver des réponses à ce genre de question, à moins que ce n'est pas ce qu'il te faut :
regardes la fonction glReadPixels

**bafman** · 18/04/2006, 10h04

gné ??? j'ai pas tout compris la...
qu'est ce que tu veut exactement ?
- faire de l'openGL sans utiliser de librairie de fenetrage ? => impossible, il te faut obligatoirement un context qui te donne acces au driver
- recuperer le contenu d'un buffer openGL sans passer par des fonction du systeme de fenetrage ? => cf reponse de shenron

**delfare** · 19/04/2006, 15h29

je veux recuperer dans un char* ce que me renverrait openGL puis l'enregistrer dans un .bmp sans creer une fenetre(en restant en mode console).
j'ai fait un test avec la methode glreadpixel mais ca ne fonctionne pas :

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
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
 
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
#include <stdio.h>
 
 
void Display();
void Reshape(int,int);
void Init();
 
typedef struct
{
    unsigned long header_size;
    long width;
    long height;
    unsigned short r1;
    unsigned short depth;
    unsigned long r2;
    unsigned long size;
    long r3,r4;
    unsigned long r5,r6;
}pejaxx_BmpImageHeader;
 
typedef struct tagpejaxx_BmpFileHeader
{
    unsigned short type;
    unsigned long size;
    unsigned short r1, r2;
    unsigned long data_offset;
}pejaxx_BmpFileHeader, *LPpejaxx_BmpFileHeader;
 
int pejaxx_WriteBMP(const char *filename,unsigned char *bmp, int width, int height){
    pejaxx_BmpFileHeader  fileheader;
    pejaxx_BmpImageHeader imageheader;
    fileheader.size = 14;
    fileheader.type = 0x4D42;
    fileheader.r1 = 0;
    fileheader.r2=0;
    fileheader.data_offset = 14+40;
 
    imageheader.header_size = 40;
    imageheader.r1 = 1;
    imageheader.depth = 24;
    imageheader.r2 = 0;
    imageheader.size = width * abs(height) * 3;
    imageheader.r3 = 0;
    imageheader.r4 = 0;
    imageheader.r5 = 0;
    imageheader.r6 = 0;
    imageheader.width = width;
    imageheader.height = height;
 
    FILE *fichier = fopen(filename,"wb");
    //fwrite(&fileheader, 1, 14, fichier);
 
    //fwrite(&imageheader, 1, 40, fichier);
    fwrite( &fileheader.type,  sizeof(fileheader.type),  1, fichier);
    fwrite( &fileheader.size,  sizeof(fileheader.size),  1, fichier);
    fwrite( &fileheader.r1,  sizeof(fileheader.r1),  1, fichier);
    fwrite( &fileheader.r2,  sizeof(fileheader.r2),  1, fichier);
    fwrite( &fileheader.data_offset,  sizeof(fileheader.data_offset),  1, fichier);
    fwrite( &imageheader.header_size, sizeof(imageheader.header_size), 1, fichier);
    fwrite( &imageheader.width, sizeof(imageheader.width), 1, fichier);
    fwrite( &imageheader.height, sizeof(imageheader.height), 1, fichier);
    fwrite( &imageheader.r1, sizeof(imageheader.r1), 1, fichier);
    fwrite( &imageheader.depth, sizeof(imageheader.depth), 1, fichier);
    fwrite( &imageheader.r2, sizeof(imageheader.r2), 1, fichier);
    fwrite( &imageheader.size, sizeof(imageheader.size), 1, fichier);
    fwrite( &imageheader.r3, sizeof(imageheader.r3), 1, fichier);
    fwrite( &imageheader.r4, sizeof(imageheader.r4), 1, fichier);
    fwrite( &imageheader.r5, sizeof(imageheader.r5), 1, fichier);
    fwrite( &imageheader.r6, sizeof(imageheader.r6), 1, fichier);
    int i,j,k;
    for(j=0;j<height;j++)for(i=0;i<width;i++)for(k=0;k<3;k++){
    fwrite(&bmp[(i+j*width)*3+k], 1, sizeof(char), fichier); 
}
    fclose(fichier);
return 1;
}
 
////////////////////////////////////////////////////////////////////////////
int main( int argc, char *argv[ ])
{
 
    Init();
 
    Reshape(256,256);
 
    Display();
 
    return 0;
}
 
void Init()
{
    glEnable(GL_DEPTH_TEST);
}
 
void Display()
{
    glClearColor(0,0,0,0); // selectionne la couleur noire (qui est celle par défaut)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(4,3,3,0,0,0,0,1,0);
 
    glBegin(GL_QUADS); 
    glColor3d(1,0,0);
    glVertex3i(1,1,1);
    glVertex3i(1,-1,1);
    glVertex3i(-1,-1,1);
    glVertex3i(-1,1,1);
 
    glColor3d(0,1,0);
    glVertex3i(1,1,-1);
    glVertex3i(1,-1,-1);
    glVertex3i(-1,-1,-1);
    glVertex3i(-1,1,-1);
 
    glColor3d(0,0,1);
    glVertex3i(1,1,1);
    glVertex3i(1,-1,1);
    glVertex3i(1,-1,-1);
    glVertex3i(1,1,-1);
 
    glColor3d(0,1,1);
    glVertex3i(-1,1,1);
    glVertex3i(-1,-1,1);
    glVertex3i(-1,-1,-1);
    glVertex3i(-1,1,-1);
 
    glColor3d(1,1,0);
    glVertex3i(-1,1,-1);
    glVertex3i(-1,1,1);
    glVertex3i(1,1,1);
    glVertex3i(1,1,-1);
 
    glColor3d(1,0,1);
    glVertex3i(-1,-1,-1);
    glVertex3i(-1,-1,1);
    glVertex3i(1,-1,1);
    glVertex3i(1,-1,-1);
 
    glEnd();
 
    glFlush();
 
    unsigned char buffer[256*256*3];
 glReadPixels(0, 0, 256, 256, GL_RGB, GL_UNSIGNED_BYTE, buffer);
 pejaxx_WriteBMP("testopenGLtobuffer.bmp",buffer,256,256);
}
 
void Reshape(int w, int h) 
{
    glViewport(0,0,w,h);
    glMatrixMode(GL_PROJECTION); // Choisit la matrice de projection
    glLoadIdentity();
    gluPerspective(45.0,(float) w/h,1.,10.);
}

**shenron666** · 19/04/2006, 15h45

tu ne peux pas ne pas créer de fenêtre car il te faut un contexte qui définit le format d'affichage (16/32 bits, profondeur zbuffer, ect)

ce que tu peux faire c'est créer une fenêtre mais ne pas l'afficher

par contre je pense que tu ne peux pas faire cela avec une bibliothèque de fenêtrage et qu'il te faudra le faire en natif

**delfare** · 19/04/2006, 17h02

tu ne peux pas ne pas créer de fenêtre car il te faut un contexte qui définit le format d'affichage (16/32 bits, profondeur zbuffer, ect)

n'y a-t'il pas moyen de le definir sans utiliser glut,...

le projet sur le quel je bosse est un emulateur, j'ai besoin d'un maximum de vitesse, je croix que creer une fenetre(meme si on l'affiche pas) et utiliser glut risque de ralentir l'emulateur(si c'est ca, on gere pas la 3d et tant pis).

mais ce que je demande doit etre possible car certaines librairies le font(gtkglext, qt, ...)

**bafman** · 20/04/2006, 09h48

Envoyé par delfare

n'y a-t'il pas moyen de le definir sans utiliser glut,...

oui, bien sur on peut le faire sans glut... avec la SDL, en WIN32, GTK QT ou autre lib de fenetrage... mais il faut imperativement un systeme de fenetrage.
ceci vient du fait qu'openGL est multiplateform, donc pour pouvoir tourner sur toutes les plateformes, la lib ne connait rien sur les drivers (logique, un driver windows ne fonctionne pas comme un driver linux

) et donc le seul moyen d'avoir acces au driver, c'est de passer par le system de fenetrage qui crée un context de fonctionnement...

**yoloosis** · 21/04/2006, 14h13

Mesa semble permettre de faire du rendu sans fenetre : http://www.mesa3d.org/osmesa.html

Utiliser openGL et obtenir le contenu dans un buffer

OpenGL

Discussions similaires

Partager

Partager