Discussion :

[alcibiade]

Bonjour tout le monde,

Voilà j'ai un petit problème, je voudrais charger une texture et la mettre sur un carré. Mais je n'y comprend rien. Cela va faire presque deux semaines que je cherche sur tous les forums et sur tous les sites sans résultats. La plupart des sources sont sur windows et en c++ (je suis sur linux et je programme en c). Voici un bout de mon code.

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
 
#include<GL/gl.h>
#include<GL/glu.h>
#include<GL/glut.h>
#include<stdio.h>
#include<stdlib.h>
 
 
void
draw(void){
 
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);//glClear clears the window
    glColor3f(1.0,1.0,1.0);//etablishes what color to use for drawing object
 
    glBegin(GL_POLYGON);//defines the object to be drawn
    glVertex2f(-10,-10);//arg1=x arg2=y f means float
    glVertex2f(-10,10);
    glVertex2f(10,10);
    glVertex2f(10,-10);
    glEnd();
    glutSwapBuffers();
}
 
void
init(void){
  glClearColor(0.0,0.0,0.0,0.0);//etablishes what color the window will be cleared to
  glMatrixMode(GL_PROJECTION);
  glEnable(GL_TEXTURE_2D);
  glLoadIdentity();
  glOrtho(-20.0,20.0,-20.0,20.0,-1.0,1.0);
 
}
 
int
main(int argc, char **argv){
 
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
  glutInitWindowSize(640,480);
  glutInitWindowPosition(50,50);
  glutCreateWindow("Kirby");
  init();
  glutDisplayFunc(draw);
  glutMainLoop();
  return 0;
}

Malgré le fait de ne pas avoir trouvé grand chose sur le net, j'ai trouvé quelques réponses à mes questions. Tout d'abord il me faut un chargeur d'images (ce que je n'ai pas), il me faut aussi activer le glEnable pour les textures2D (oui mais où?). Vous me serez d'un grand merci si vous pouviez m'expliquer le processus de chargement d'images sur opengl. En effet je ne comprend pas pourquoi il est obligatoire d'utiliser un chargeur d'image et surtout comment il marche. Bien sûr ce que je veux faire pour l'instant est très simple. Une texture sur un carré. Je vous remercie d'avance pour vos réponses.

[kremvax]

Pour charger des textures, la première question que tu dois te poser c'est quels formats d'image comptes-tu utiliser? TGA, PNG, autres? Le chargement des images sera différent en fonction de ça. Par exemple pour du png, tu devras te renseigner sur la "libpng".
Mais si tu n'es pas obligé d'utiliser GLUT et que tu n'as pas envie de t'occuper toi-même du chargement des textures, tu peux passer par une bibliothèque intermédiaire telle que la SFML ( http://www.sfml-dev.org/features-fr.php ) qui simplifie pas mal certaines choses (y compris le chargement des textures, tu l'auras compris).
Sinon, le fait que tu sois sous linux ne change pas grand chose aux exemples de code que tu trouveras sur le net, en tout cas pas à ce niveau-là.

[kernerteam]

Les images que je veux charger dans un premier temps seraient au format BMP. Donc si je comprend bien je peux utiliser le SFML pour charger mon image. OKAY. Mais ce que je voudrais comprendre à titre informatif serait comment programmer un loader et comment ça marche surtout. MERCI.

[kremvax]

J'ai pas d'exemple sous la main pour du bmp, mais un exemple avec libpng : http://tfc.duke.free.fr/coding/png.html

[LittleWhite]

Pour OpenGL, le tuto que je conseillerai ( et pas que moi d'ailleurs ) c'est celui de NeHe. Bon si tu cherche NeHe sur internet tu trouvera ça : http://nehe.gamedev.net/ mais c'est en anglais.
Il existe sur ce même site un début de traduction. D'ailleurs pour ton cas les gens ( que j'applaudis pour l'avoir fait ) au traduit le tuto que tu as besoin. Si j'ai bonne mémoire c'est le chapitre 7.
( De toute façon il a pour titre texture mapping ou un truc dans le genre )
Dedans l'auteur donne un code pour charger un .bmp , l'implémenter à OpenGL et l'utiliser.

[ Attention ce qui suit je ne suis pas sur à 100% , la première personne qui se rend compte d'une erreur , qui le signale }

Procédure pour le chargement de textures :

Tu dis à OpenGL que tu vas utiliser des texture : glEnable(GL_TEXTURE)

Tu fais un parseur ( analiseur ) de ton fichier image ( pour le bmp c'est le plus simple je crois ) qui permet donc de lire le fichier et surtout d'en extraire un tableau d'octet avec la nuances ( couleurs ) des pixels.

Tu génère un identifiant de texture avec glGenTexture si je me rapelle bien.

Tu selectionne la texture qui va être crée : glBindTexture

Tu donne ce tableau à OpenGL qui le convertira en un truc qu'il sait utiliser. ( Il fait une copie , donc on peut libéré le tableau resultant du fichier ).

Après c'est lors du dessin de ton carré, tout ce qui était avant est à faire avant ( fonction d'init , ou de chargement ).

Tu selectionne ta texture avec l'identifiant qu'utilise OpenGL -> glBindTexture

Lors du dessin de ta surface ou tu vas appliquer la texture, tu vas définir les vertex, comme d'habitude, mais pour chaque vertex tu définira la position de la texture avec glTexCoord2f.

Et après c'est tout