Discussion :

[Clad3]

Bonjour a tous !
Ca fait 2-3 jour que je regarde a droite a gauche , comment on fait pour texturer des objets en openGL .

Histoire de ne pas partir sur de mauvaises base, et avant de coder une premiére classe "test" qui se chargera pour moi de charger mes textures.
Je préfére vous soumettre ce que je sais / crois savoir avant de mettre véritablement les mains dans le camboui .

On distingue 2 étapes :
- le chargement de la texture a partir d'un fichier sur le HD ( je fait abstraction des texture procédurale ... je n'en suis pas encore la )
- l'utilisation de celle-ci sur de la géométrie de base ( je me limiterai la, car pour un monde en 2D, je n'aurais pas besoin de grand choses ^^ )

-> 1ére partie : le chargement de texture et son " enregistrement " sous openGL .

Il faut d'abord faire attention au format de notre image . j'ai vu qu'une fonction simple permetetai en natif de se débrouiller avec le format "bmp" . Pour les autres formats, j'ai vu que la pluspart du temps des librairie annexes étaient utilisés .

Le tout consiste donc a receuillir les donné de notre images ( largeur / hauteur / valeurs des pixel ( RGB+A ) ect ...

Pour simplifier on va se ramener au bmp ; pour receuillir ces information on va procéder comme suit :
- déclaration d'un tableau pour stocker le numero d'identification de chaque texture ( id )
- déclaration d'un "objet" texture
- on affecte a notre objet texture toutes les données necessaire a son exploitation ( issu de notre image au format bmp )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
GLuint textureId[1] ;// pour 1 texture
AUX_RGBImageRec * texture ;
texture = auxDIBImageLoad("chemin vers notre image") ;

Ensuite on indique a openGL qu'on va "enregistrer" véritablement une texture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
glGenTextures (param1, param2);

ou param1 est un entier correspondant au nombres de texture qu'on va créer
param2 correspond a notre tableau de GLuint ; si j'ai bien comprit en utilisant cette fonction, openGL va attribuer tout seul un id a la texture, si on voulais en préciser un nous même, il nous faudrait juste ne pas utiliser cette fonction, et indiqué un entier en deuxiemes paramétre de la fonction que l'on va voir dans peu de tps ( glBindTexture )
En ce qui nous concerne, avec atribution d'une id par oepnGL on obtient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
glGenTextures(1,&textureId[0]) ;

Puis on indique a openGL que la texture dont l'id est "param2" doit être assimilé en tant que "param1"

param1 prenant les valeur suivantes :
GL_TEXTURE_1D
GL_TEXTURE_2D
GL_TEXTURE_3D

Dans notre exemple on aura :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
glBindTexture(GL_TEXTURE_2D, textureId[0] );
OU
int id = 4 ;
glBindTexture(GL_TEXTURE_2D, id) ; // si on a pas fait appel a glGenTextures(...) avant

Ensuite on peut préciser des paramétres liée au traitement de la texture par openGL.
Pour le moment, je n'en utilise que 2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

Ils précisent le comportement ( GL_LINEAR ) qui va être apliqué lorsque la texture sera réduite ou agrandit pour 'être affiché a l'écran .

Enfin, on va utiliser les données receuillit dans la variable texture pour finalement "uploader" notre texture dans la mémoire video. Et c'est aprés ca qu'elle sera véritablement utilisable dans notre programme .

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB, texture->sizeX, texture->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture->data);

Et voila ! notre texture dont l'id est " textureId[0]" est prête a etre utilisé dans notre programme !

Il nous reste a libéré la mémoire prise par la variable " texture "
( la je ne suis pas trés sur de moi )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
free(texture);

Il reste a ajouter pas mal de code pour traquer les erreurs mais bon, l'idée est la je pense !

La suite prochainement , si vous avez des remarques / suggestion / idées / conseils , je suis trés vivement preneur , car je n'ai sans doute pas encore tout comprit et j'ai encore énormément a aprendre !
a bientot !

edit: bon je part en vacances, donc la suite dans 5-6 jours :/ mais je lirai tout vos msg avec la plus grande joie et attention en rentrant ! bonne fin de fêtes a tous !

[bafman]

ben ma fois, a y regarder rapidement ca m'a l'aire tout bon tu peut continuer comme ca...

Par contre tu ne parle pas du parametre 3 de glTexImage2d : GL_RGB... ce parametre est tres important car il definit le mode de stockage des informations de la texture... pour un TGA avec canal alpha, il faut mettre GL_RGBA, et il existe plein de mode differents (GL_LUMINANCE ...) dont une bonne partie en temps qu'extention openGL permettant de gerer les differents type de formats d'images...

[Clad3]

Coucou tout le monde
Oui, je n'ai pas beaucoup détaillé la fin de mon exemple...plus par manque de tps qu'autre chose d'ailleur ! Mais me voici de retour, alors je m'y remet dés ce soir !

[venomelektro]

t es pas du tout obligé de passer par la glaux pour charger un bitmap

[ReD-@]

avec la glaux tu fai plu du natif+opengl t utilise une lib j crois
mé bon pr le bmp c un peu inutile une lib le format est simple (pr 24 bits en tout cas) passé un header contenant -entre autres- les dimensions tu trouve tes données l une a la suite de l autre des chars avec les valeur (bleu, vert, rouge) point par point
c suffisant pour opengl donc faut juste connaitre la taille du header et l emplacement des dimensions dans ce header le reste c est immediat
ah wi fo aussi inverser l ordre des couleurs : bgr->rgb

par contre pour ton int id=4 je suis pas tres sur pcq opengl libere les textures a la sortie du programme et donc doit lier un id a un certain programme donc si 2 progs utilisent le meme id pour la texture (ou que tu lances ton prog 2 fois en paralelle) il risque d y avoir conflit je crois

sinon pr le free(texture) je n crois pas que ca soit efficace puisque l image est essentiellement stokée dans texture->data et que ce free ne fait que supprimer l element pointé par "texture" y compris le pointeur data mé ne libere pas l image de la mémoire
un delete(texture->data) avant devrait faire l affaire mé on ne sait jamais le mieux c est encore de se documenter il doit y avoir une fonction qui libere un AUX_RGBImageRec

euh , bafman, pour cet exemple on a un bmp 24bits donc pas de alpha ni rien du tout ==> GL_RGB



PS: &textureId[0] == textureId , &textureId[1] == textureId+1 , &textureId[2] == textureId+2 , &tex....

[Clad3]

Re tout le monde !

Concernant la libération de mémoire, je n'avais pas vraiment comprit la routine de Nehe, mais grace a vos explication j'y vois plus clair ! ( je ne suis pas famillier avec ce genre de methode ... )
ca doit donner plutot ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
free(texture->data);
free(texture);

non ?

par contre pour ton int id=4 je suis pas tres sur pcq opengl libere les textures a la sortie du programme et donc doit lier un id a un certain programme donc si 2 progs utilisent le meme id pour la texture (ou que tu lances ton prog 2 fois en paralelle) il risque d y avoir conflit je crois

Je n'avais pas pensé à ça !
Mais bon, le probléme ne se posera pas, puisque je vais plutot utiliser la fonction glGenTextures ; tout en conservant quelquepart un tableau de string ou quelque chose comme ca, me rapellant a quoi correspond chaque texture

contenant -entre autres- les dimensions tu trouve tes données l une a la suite de l autre des chars avec les valeur (bleu, vert, rouge) point par point
c suffisant pour opengl donc faut juste connaitre la taille du header et l emplacement des dimensions dans ce header le reste c est immediat
ah wi fo aussi inverser l ordre des couleurs : bgr->rgb

Hum oui, pour le peu que j'en sais, chaque format d'image est "codé" différement et il y a toujours moyen en connaissant bien le format de retrouver ce genre de donné ( mais ma connaissance dans le domaine est trés faible ).


Pour finir, quant a passer par un autre moyen que glut pour charger mes images, je planche sur le sujet ; car évidement il va me faloir charger autre chose que des .bmp et je n'ai pas envie de recoder les fonction de "loading" a la main ! Donc si vous avez des moyens "user-friendly" et compatible dev c++, je suis preneur ^^

merci de toutes vos contributions !

[ReD-@]

J'ai ce qu'il te faut
voila comment s'utilise ma librairie:
pour créer une fenetre :

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
 
 ig3_window  le_fenetre; //declaration d variable
 
int main() {
  int larg=250,haut=500;
  la_fenetre.create("fenetre test IG3",larg,haut,IG_CLOSE|IG_RESIZE);
                   //fenetre redimensionnable avec bouton d fermeture seulement
      //c est l moment d faire ses initialisations opengl
  while(la_fenetre.active()) {
               //boucle principale: sortie par bouton d fermeture ou ctrl+alt+supr...etc
               // active() met aussi a jour les variables de gestion clavier/souris de la lib
    //des  trucs opengl
    if(la_fenetre.key['Q'] || la_fenetre.key['VK_ESCAPE'] || la_fenetre.key[IG_RIGHT]) PostQuitMessage(0);
          //quitte par echap , Q  ou l bouton droit d la souris (y a aussi IG_LEFT et IG_MIDDLE et toutes les touches de l api windows)
    }
  return la_fenetre.close(); //a ton avis ?
}

alors ? qu attendre de plus simple
de plus rien ne t oblige a suivre le modele classique : initialisations - boucle principal - fermeture do moment que tu réaffiches ton ecran avec active() chaque fois que tu en as besoin

pour les image c est ig3_load_image ki s occupe de mettr ton fichier dans un GLuint

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
GLuint __declspec(dllexport)ig3_load_image(char*);

attention l extension est importante (c est avec ca qu il reconnait le type) et dans le cas d une erreur dans le format jpeg rien n a été prévu(je ne suis meme pas sur de detecter toujours l erreur) par contre pour les autres bmp et tga ca va (liberation de la memoire + retourne 0)

bon pour l instant c est encore en developpement donc je n ai pas encore uploadé et y a pas de documentation mais donne moi ton mail je t enverrai une version qui fait tout ca

[bafman]

librairie portable pour faire de l'openGL qui est reconnue par toute la comunautée (c'est même celle qui est utilisée par l'unreal engine sous linux) => SDL

http://www.libsdl.org/index.php

et en plus elle charge les images gere les entrée sortie, le reseau fait le menage et lave le linge (pour les 2 dernier je suis pas sur de mon coup )

[Elendil_BzH]

La SDL en natif je crois pas qu'elle gere beaucoup de formats d'images. En rajoutant SDL_image on peut utiliser des JPG, PNG, BMP en ne manipulant qu'une seule fonction, la bibliothèque on la trouve sur le site de la SDL avec la doc.

[Clad3]

merci a vous ,
J'utilise déja la SDL ( rho quelle belle lib ! ) pour gerer ma fenêtre ainsi que les imput clavier/soursi et 2-3 autres bavioles !

Pour le chargement des image j'ai opté pour DevIL que je suis entrain d'apprendre a utiliser ; mais j'arrive a des résultat tout a fait correct pour le moment

Prochiane étape : le blending .. ouch

[FVIRTMAN]

si ça t'intéresse (petite pub de ma part)
j'ai un tuto en construction sur mon site, je parle de OPENGL avec SDL
j'ai fait le blending, mipmapping, et diverses options pour les textures
cf monsite (profil) info / progs / tutoC++ / § 3.0

[ReD-@]

devil ... j avais essayé cette lib mais elle fonctionnait pas avec mon dev-c++ je crois que toutes les libs sont en .lib et pas .a ou un truc du genre
existe t il un truc pareil pour dev-c++ ? a part compiler les sources de devil