si l´erreur est gl/glut.h : No such file or directory
c´est simplement que tu n´as pas installé GLUT

regarde dans ton repertoire include/gl si tu as bien glut.h
( tu devrais avoir gl.h, glu.h et glaux.h)
il faut que tu installes glut

Non pas de pb , GLUT est bien installé, je vais essayer de telecharger UltraEdit

franco01 > toi pas besoin de glut
au pire, ouvre ton BMP avec le bloc note ( voir si ça commence par " BM") et essaie avec un autre BMP.

0[0]7 > Assure toi que tu aies glut

Ben pourtant ils commencent bien par BM et sont bien en bitmap.
Ca y est ca marche, la c´est passé mais c´est byzarre qu´au début il ne voulait pas et tout d´un coup ca a marchait , mais bon tant que ca marche c cool
Merci JYY

bizarre en effet, lol !
enfin si maintenant ça marche, C ce qu´il faut

apres, je pense que tu as du te documenter, mais le codage des données du BMP est particulier :

les pixels font 3 octets ( normal) en BGR ( moins normal) au lieu de RGB
de gauche a droite, et de BAS EN HAUT.

si tu lis en rgb de haut en bas, ton image sera H-flippée et les couleurs échangées entre le rouge et le bleu, lol !
je ne sais plus, mais il me semble qu´en +, tu as un pitch...

C´est pour cela alors qu´il y a ce bout de code ( je ne savais pas que c´etait en BGR)
/ /Inverse R et B
for ( x=0;x<Width*Height;x++)
{
t=Data[x*3];
Data[x*3]=Data[x*3+2];
Data[x*3+2]=t;
}
Donc lorsqu´on charge l´image en mémoire, la fonction renvoi un entier ( dans mon cas c´est 1).

Mais pour l´afficher à un endroit quelconque dans l´écran, on doit utiliser cet entier? et comment faire pour que GLUT l´affiche ( opengl)tu t´y connais un peu?

l´entier retourné est a tous les coups un code d´erreur : il ne renseigne pas sur la position, pour 2 raisons :

- il faut 2 coordonnées
- le BMP ne stocke pas de position, lol !

pour glut, oui je connais
en fait, tu sors les grosses armes la :

pour afficher ton bmp avec glut, il faut :
- initialiser un monde dans l´espace ( oui, glut, c´est opengl, c´est de la 3d pure)
- charger ton image avec ta fonction dans un char*
- intégrer ton image en tant que texture dans OpenGL
- dessiner un quads texturé avec ta texture devant la caméra.

Je te laisse chercher des exemples sur le net, je t´aiderai a les comprendre et/ou les modifier

Je te montre la fonction que j´ai pour charger l´image:

int load_image(char *File)
{
unsigned char *Data;
FILE *fichier;
unsigned char Header[0x36];
GLuint DataPos,DataSize;
GLint Components;
GLsizei Width,Height;
GLenum Format,Type;

unsigned char t;
int x;

int deb=-2;//For debug

//Lit le fichier et son header
fichier = fopen(File,"rb");
if ( !fichier) {
printf("##Erreur## Fichier %s non trouve\n", File);
return -1;
}

//deb=(fread(Header,1,0x36,fichier)); //0x36 hexa -> 54 decimale , deb = 54 -> nbre d´octet lu

if ( feof(fichier)) printf("end of file\n"); / /For debug

if ( fread(Header,1,0x36,fichier)!=0x36) {
printf("##Error## Not enough byte to read 0x36 header\n");
EXIT;
}

if ( Header[0]!=´B´ || Header[1]!=´M´) {
printf("##Error## header do not start with ´BM´\n");
EXIT;
}
if ( CTOI(Header[0x1E])!=0) {
printf("##Error## header byte 0x1E is ! = 0\n");
EXIT;
}
if ( CTOI(Header[0x1C])!=24) {
printf("##Error## header byte 0x1C is ! = 24\n");
EXIT;
}

/ /-- Récupère les infos du fichier
DataPos = CTOI(Header[0x0A]);
DataSize = CTOI(Header[0x22]);
/ /-- Récupère les infos de l´image
Width = CTOI(Header[0x12]);
Height = CTOI(Header[0x16]);
Type = GL_UNSIGNED_BYTE;
Format = GL_RGB;
Components = 3;

//!!!!
if ( DataSize==0)
DataSize=Width*Height*Components;
if ( DataPos==0)
DataPos=0x36;

printf("Texture is %d x %d x %d\n", Width, Height, Components);

/ /-- Charge l´image
fseek(fichier,DataPos,0);
Data = ( unsigned char*) malloc(DataSize);
if ( !Data)
EXIT;

if ( fread(Data,1,DataSize,fichier)!=DataSize)
{
free(Data);
fclose(fichier);
printf("##ERROR## Image size not cohenrent\n");
return -1;
}

fclose(fichier);

//Inverse R et B
for ( x=0;x<Width*Height;x++)
{
t=Data[x*3];
Data[x*3]=Data[x*3+2];
Data[x*3+2]=t;
}

/ /-- Envoie la texture à OpenGL
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glBindTexture(GL_TEXTURE_2D, tex_name[current_tex_name]);

glTexImage2D
(
GL_TEXTURE_2D, //target
0, //mipmap level
Components, //nb couleurs
Width, //largeur
Height, //hauteur
0, //largeur du bord
Format, //type des couleurs
Type, //codage de chaque composante
Data //Image
);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

printf("Image ´%s´ loaded\n", File);

current_tex_name++;
return tex_name[current_tex_name-1];
}

C´est surtout la fin que je ne saisi pas tout avec glTexParameteri et l´envoi de la texture à opengl.
Mais bon je regarde sur le net ce que je trouve...

il manque bcp de choses dans ton chargement de texture !

bref, déja :
glTexParameteri est une fonction qui sert a mettre des parametres pour ta texture :
n´oublie pas, elle est censée etre affichée dans un monde 3d.
donc tu as :

glTexParameteri(type,parametre,valeur);

type : c´est toujours texture2d : parce que bon, c´est ça que tu traites ( il existe aussi les textures 3d, mais C pas adapté a ce que tu veux faire, et couteux en mémoire, et les textures 1d, mais bon...)

parametre : tu définis ce que tu veux changer :
par exemple :
GL_TEXTURE_MAG_FILTER veut dire " qu´est ce qui se passe quand on zoome ? ?"
GL_TEXTURE_MIN_FILTER veut dire " qu´est ce qui se passe quand on réduit ? ??"

car n´oublie pas : dans un monde 3d, tes textures vont sans arret etre zoomées ou dézoomées :

prenons l´exemple de :

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

valeur = GL_NEAREST :
ça veut littéralement dire :
" quand on zoome, pour un pixel, tu prends le pixel le plus proche : en gros, tu fais de gros patés" --> quand tu zoomeras, ta texture sera pixelisée
si a la place tu mets :
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
ça veut dire : " quand tu zoomes, on fait une interpolation linéaire des couleurs : donc en t´approchant, ce ne sera pas pixelisé mais flouté"
laisse ces lignes pour le moment, et tu verras quand ça marchera, tu essaieras de les changer, et tu verras que ça aura effet sur l´affichage de la texture en fonction de ta position...
pour le moment, c´est pas important

j´espere que je ne t´ai pas trop embrouillé avec ça !

Glut est pour la 3D, donc si tu veux suelement voir ton image, C peut etre pas l´adapté !

si tu veux des infos sur la 3d, va sur mon site ( cf ma carte de visite)
rubrique info / culture / theorie prog image

si tu veux voir ton image, va dans :
rubrique info / progs / tuto C++

va sur le paragraphe , télécharge le 2.1.1 afficher une image, vérifie que ça marche, met ton image a la place.
Puis, comme tu verras, ça utilise le LoadBMP interne de SDL.
Pour tester ta fonction, shunte la fonction SDL_LoadBMP et remplace par la tienne. Tu devras remplir la structure manuellement ( elle est simple, il y a le x,y, un format ( a mettre a 24 bits) et un void* pixel que tu devrais caster en char* . Une fois remplie correctement, le reste du programme inchangé t´affichera l´image...

J´ai regardé rapidement, ca a l´air pas mal tout ca,
C´est vrai que ca simplifie les choses.

Mais le souci c´est que j´utilise GLUT incorporé dans FLTK et je ne sais pas si on peut faire ca avec SDL, car j´ai plusieurs fenêtres , et j´ai des boutons dans FLTK?

bon, ben fltk je ne connais pas
si tu utilises glut, alors faut bien construire correctement les textures

ayé j´ai ENFIN réussi à configurer correctement Dev-C++ pour faire fonctionner WxWidgets. Je le mets là au cas où...

d´abord il faut télécharger puis installer le DevPack imagelib, puis faire de même avec le DevPack de wxWidgets ( il est dit de commencer par installer celui de imagelib, va savoir pourquoi).

Ensuite créer un nouveau projet -> GUI -> wxWidgets, enregistrer.
Aller dans Tools -> compiler options -> directories -> libraries ( ouf on est arrivés ! ). A partir de là on ajoute le rép lib du package :
< Dev-Cpp-Root>\wxWidgets-2.5.2-msw-static\lib

Ensuite faire de même mais pour les include :

<Dev-Cpp-Root>\wxWidgets-2.5.2-msw-static\include

ET

<Dev-Cpp-Root>\wxWidgets-2.5.2-msw-static\lib\wx\i
nclude\msw-2.5

c´est normal que le projet tout con qui affiche une frame, un menu bar et un about fasse 1.89Mo ? ?

ça met ´achement longtemps aussi pour compiler ! C´est la galère dès que tu as 1000 lignes, s´il faut recompiler pour tester le prog....
Je viens là de faire un debuggage et il m´a demandé si je souhaitait inclure les infos de debuggage dans le prog. J´ai cliqué oui et maintenant il pèse 4.26 Mo ! ! C´est dû à quoi une telle différence ?

tu l´as dit... aux info de debug... Mais quand tu distribues ton projet, tu files la version release plus legere, et si possible linkee en dynamique.
le 1.9 il doit venir de . lib que t´as linké en static, et qui comporte plein de fonctions que t´utilises pas encore ; si tu t´en serts, ton programme ne fera guère plus en terme de poids

Qu´est-ce que t´appelle long pour compiler ? Compiler tout un gros projet peut facilement prendre qq bonnes dizaines de minutes, mais pour un projet perso ou tu parles de seulement qq milliers de lignes, qq secondes devraient suffire.
D´où l´idée par la suite de bien découper ton projet en fichier, tu peux les compiler indépendamment ( enfin.. pour simplifier...) et tu peux les relinker sans les recompiler si le source n´a pas changé.
au passage, ne demande pas une compile complete à chaque fois que tu fais une modif ( pour tester que ça passe niveau syntaxe par ex) ; compile juste le fichier en court, et seulement quand tu veux tester, compiles tout et linke.

ok merci du conseil
" long" pour moi ( dans ce cas) = une 20aine de secondes. J´avais l´habitude avec les projets en mode console de compiler en maximum 7-8 secondes.

Maintenant que tu dis que c´est normal je m´en fais plus. On dira que c´était le choc du passage au niveau supérieur :p

J´ai réussi à afficher un carré non texturé mais rempli de rouge ( pour le moment) car j´arrive pas à afficher la texture.
Ma fonction redraw est la suivante :
void gmed_redraw(void)
{
int x=200,y=100,w=255,h=255;
int i,j;

glViewport ( 0, 0, glutwindow_w, glutwindow_h);
glMatrixMode ( GL_PROJECTION);
glLoadIdentity ( );
glOrtho(0, glutwindow_w, glutwindow_h, 0, -1, 1);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glBindTexture(GL_TEXTURE_2D, id_tex_tile);//id_tex_tile -> int renvoyer par la fonction load_image()
glEnable(GL_TEXTURE_2D);
glColor3f(1, 0, 0);
glBegin(GL_QUADS); / / Square

glTexCoord2f(0, 0); / / V must be inverted, do not know why
glVertex2f(x,y);
glTexCoord2f(0,1);
glVertex2f(x+w,y);
glTexCoord2f(1,1);
glVertex2f(x+w,y+h);
glTexCoord2f(1,0);
glVertex2f(x,y+h);

glEnd();

glDisable(GL_TEXTURE_2D);

glutSwapBuffers();
}

En quoi est-ce qu´une documentation automatique de code source ( genre Doxygen et CppDoc) est utile ? Il faut respecter des mises en forme pour que le programme de documentation fasse son boulot, donc ça prend plus de temps. Si on veut voir à quoi sert une classe ben suffit de regarder dans le code source...