LOADER TGA OPENGL (TEXTURES + TRANSPARENCE)
Funto66
Messages postés
1267
Date d'inscription
mercredi 1 janvier 2003
Statut
Membre
Dernière intervention
28 février 2007
-
13 avril 2004 à 18:39
Funto66 Messages postés 1267 Date d'inscription mercredi 1 janvier 2003 Statut Membre Dernière intervention 28 février 2007 - 28 janv. 2006 à 17:12
Funto66 Messages postés 1267 Date d'inscription mercredi 1 janvier 2003 Statut Membre Dernière intervention 28 février 2007 - 28 janv. 2006 à 17:12
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/21912-loader-tga-opengl-textures-transparence
https://codes-sources.commentcamarche.net/source/21912-loader-tga-opengl-textures-transparence
28 janv. 2006 à 17:12
Je t'envoie le prog corrigé par mail, si ça te sert encore...
++
6 janv. 2006 à 01:13
Je met mon code source ici, si quelqu'un peut me dire où je me suis planté ça m'aiderais :)
//----------------------------------------
#ifdef WIN32
#include <windows.h>
#endif
#include <stdio.h>
#include <gl/gl.h>
#include <gl/glut.h>
#include <TGALoader/TGALoader.cpp>
#define TEXTURE_HERO 1
void Display(void);
void Reshape(int, int);
void ChargerTexture(char *Chemin, int id);
void DessinerTexture(int Id, int X, int Y, int Largeur, int Hauteur, int X_src, int Y_src, int Largeur_src, int Hauteur_src, float Transparence);
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE);
glutInitWindowSize(640, 480);
glutInitWindowPosition(50, 50);
glutCreateWindow("Fenetre OpenGL");
ChargerTexture("C:\\hero.tga", TEXTURE_HERO);
glutDisplayFunc(Display);
glutReshapeFunc(Reshape);
glutMainLoop();
return 0;
}
void ChargerTexture(char *Chemin, int id)
{
TGALoader tga_loader;
tga_loader.LoadOpenGLTextureWithID(Chemin, id, TGA_LINEAR);
}
void DessinerTexture(int Id, int X, int Y, int Largeur, int Hauteur, int X_src, int Y_src, int Largeur_src, int Hauteur_src, float Transparence)
{
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, Transparence);
glBindTexture(GL_TEXTURE_2D, Id);
glBegin(GL_QUADS);
glTexCoord2d(X_src, Y_src);
glVertex2i(X, Y);
glTexCoord2d(X_src + Largeur_src, Y_src);
glVertex2i(X+Largeur, Y);
glTexCoord2d(X_src + Largeur_src, Y_src + Hauteur_src);
glVertex2i(X+Largeur, Y+Hauteur);
glTexCoord2d(X_src, Y_src + Hauteur_src);
glVertex2i(X, Y+Hauteur);
glEnd();
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
void Display()
{
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
DessinerTexture(TEXTURE_HERO, 0, 0, 100, 100, 0, 0, 1, 1, 1);
glFlush();
}
void Reshape(int width, int height)
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float L;
float H;
if (width <= height)
{
H=(GLfloat) (10*height/width);
L=10.0;
}
else
{
H=10.0;
L=(GLfloat) (10*width/height);
}
gluOrtho2D(-L/2,L/2,-H/2,H/2);
}
//---------------------------------
Merci :)
5 janv. 2006 à 18:32
{
TGALoader tga_loader;
tga_loader.LoadOpenGLTextureWithID(Chemin, id, TGA_LINEAR);
}
tu fais genre ensuite avant de dessiner : ChargerTGA("mon_image.tga", 1);
Sinon voici une fonction pour dessiner que j'avais faite, que je recopie telle qu'elle ...
void Dessiner(ind Id, int X, int Y, int Largeur, int Hauteur, int X_src, int Y_src, int Largeur_src, int Hauteur_src, float Transparence)
{
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, Transparence);
glBindTexture(GL_TEXTURE_2D, Id);
glBegin(GL_QUADS);
glTexCoord2d(X_src, Y_src);
glVertex2i(X, Y);
glTexCoord2d(X_src + Largeur_src, Y_src);
glVertex2i(X+Largeur, Y);
glTexCoord2d(X_src + Largeur_src, Y_src + Hauteur_src);
glVertex2i(X+Largeur, Y+Hauteur);
glTexCoord2d(X_src, Y_src + Hauteur_src);
glVertex2i(X, Y+Hauteur);
glEnd();
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
pour dessiner donc par exemple ton image tu fais :
Dessiner(1, 0, 0, 100, 100, 0, 0, 1, 1, 1);
4 janv. 2006 à 20:16
Bah moi j'arrive pas à l'utiliser cette classe, et c'est pas faute d'avoir essayer..
Est ce qu'il serait possible d'avoir un exemple "SIMPLE" (:p) d'utilisation ? Genre une application qui charge une texture 2D et l'affiche au milieu de la fenêtre.
Ce serait vraiment sympa de votre part parce que je sèche là dessus depuis quelques jours, et je pense que ça servira à plusieurs débutants en graphisme comme moi.
Merci d'avance,
Psykocrash.
24 oct. 2005 à 01:52
(dsl de répondre si tard mais j'ai pas touché un PC depuis si longtemps...prépa oblige)
13 oct. 2005 à 19:17
http://matt2000.free.fr/prog/BmpLoader.rar
13 oct. 2005 à 19:12
28 avril 2005 à 15:51
1 mars 2005 à 20:06
1 mars 2005 à 10:36
De plus le code est tres propre, j'adore!!!
Juste une precision, si on veut l'utiliser avec OpenGL,
il faut prealable avoir un context OpenGL...
C'est a dire qu'il faut l'utiliser apres le "glutCreateWindow()".
J'ai eu le malheur de vouloir m'en servir avant cette fonction
et a chaque fois, "gluBuilt2DMipmaps()" plantait puisqu'il lui
manquait le context OpenGL.
(j'y ai passé 2 jours avant de comprendre :'( )
Bonne continuation
17 févr. 2005 à 12:56
Nouvelle version !
TGALoader 1.2 permet, comme l'explique la présentation du code, de charger des images embarquées directement dans l'exécutable, grâce aux fonctions du type Load*FromData().
J'ai aussi mis un exemple et le programme bin2h qui permet de transformer un binaire en fichier textuel pouvant être "#includé" dans une source.
Pour ceux que ça intéresse...;)
24 oct. 2004 à 18:56
il faut inclure glut.h apres tgaloader.h
voila sinon excelent !!
24 oct. 2004 à 17:49
c:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\include\stdlib.h(256) : error C2381: 'exit' : redéfinition ; __declspec(noreturn) est différent
c:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\include\GL\glut.h(146) : voir la déclaration de 'exit'
c:\documents and settings\propriétaire\mes documents\visual studio projects\tga\main.cpp(49) : error C2664: 'TGALoader::LoadOpenGLTexture' : impossible de convertir le paramètre 2 de 'int' en 'GLuint *'
La conversion d'un type intégral en type pointeur nécessite reinterpret_cast, un cast de style C ou un cast de style fonction
Je suis debutant et je ne sais pas du tout ceque ça veut dire
26 août 2004 à 01:09
25 août 2004 à 20:24
Si j'incorpore ce loader dans mon projet, j'ai des caisses de msg d'erreur à la compilation, alors que sans l'include, j'ai même pas un warning ..
Le 1er msg :
46 C:\Dev-Cpp\include\c++\bits\locale_facets.tcc:41, from C:\Dev-Cpp\include\c++\locale
In file included from C:/Dev-Cpp/include/c++/bits/locale_facets.tcc:41, from C:/Dev-Cpp/include/c++/locale
Le dernier :
C:\Documents and Settings\thy\Mes documents\_projets_devcpp\br3d\Makefile.win
[Build Error] [_MAIN.o] Error 1
J'utilise devcpp 4.9.8.10, si ça peut servir...
9 août 2004 à 01:06
Ce que je peux te dire c'est qu'au final l'image est chargée comme une image de côté 2^n; gluScaleImage() (utilisé en interne par gluBuild2DMipmaps()) apparemment arrondit jusqu'à la puissance de 2 la plus proche mais, et je sais pas comment fait GLU, les coordonnées de texture sont les mêmes que si les images de côté non-2^n étaient supportées (comment dans OpenGL 1.5)...
8 août 2004 à 18:31
8 août 2004 à 13:29
Grâce à un msg sur le forum de djl, on peut maintenant charger des textures dont les côtés ne sont pas des puissances de 2 :)
Pour tester, vous pouvez faire glisser "avion_non_pow2_rle.tga" sur TGA.exe, vous verrez, c'est un peu moche parce que l'image est redimensionnée par GLU masi ça marche :)
15 avril 2004 à 00:13
Bon sinon une idée qui, je l espere, sera constructive.
La, ton code supporte le format tga. pas de chance, t as envie d implementer un super bel effet de la mort qui tue, mais il faut obligatoirement passer par un fichier .bmp.
bon ca c est le scénario. En pratique, t as envie d étendre ton code pour supporter d autres formats : hé ben pas de chance, tu dois réécrire les fonctions d envoi a opengl dans cette nouvelle classe.
bon en fait c est trop long a expliquer la, alors jvais coder et le truc et jte l envoie.
14 avril 2004 à 22:49
Cette fois-ci j'utilise l'enum tant demandé.
GLuint ID;
tga_loader.LoadOpenGLTexture("texture;tga", &ID, TGA_BILINEAR);
et une texture est chargée :)
Cyberboy >> Désolé mais j'ai pas gardé le préfixe K2D, j'ai mis TGA...
Y'a un truc qui me fait marrer chaque fois que j'uploade une source sur CppFrance, c'est ce qui est écrit en bas à droite :
"Etes-vous sûr de l'orthographe de votre source ?
Avant de valider jettez un dernier p'tit coup d'oeil ;-)"
Pour ceux qui ne l'ont pas vu, vérifiez l'orthographe de "jettez"...:p
14 avril 2004 à 21:24
Mais là je vois que vous êtes 3 à penser qu'il en faudrait un...
Bon, je vais donc me plier à la majorité (et d'ailleurs vous avez certainement raison) : je vais remodifier mon code...
14 avril 2004 à 21:15
// enum minimum
enum K2D_Filtering
{
K2D_NO_FILTER=0,
K2D_LINEAR,
K2D_BILINEAR,
K2D_TRILINEAR,
K2D_ANISOTROPIC_TRILINEAR_FILTERING
};
/* faut modifier la fonction
En definissant une valeur par défaut, on est pas obligé de mettre ce parametre : on peut appeler LoadFile ("machine.tga"); sans problemes, le type de filtrage sera biliénéaire
*/
TGAErrorCode LoadFile (char* strFileName, K2D_FilteringType=K2D_BILINEAR);
/*
puis dans la generation
*/
switch(iType)
{
case K2D_NO_FILTER: glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST);
break;
case K2D_LINEAR: glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);
break;
case K2D_BILINEAR: glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
break;
case K2D_TRILINEAR: glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
break;
}
Bon ok c est un peu le bordel ... mais j avais la flemme de mettre un code complet.
Sinon, au passage, c est pas parceque tu mets inline que le compilateur optimisera ta fonction, ya qu a regarder le code asm généré ... c est juste une manière de lui dire que tu voudrais bien qu elle le soit. De plus, la plupart des fonctions déclarées dans les headers sont mises en inline meme si on ne le précise pas.
14 avril 2004 à 20:02
Pour les accesseurs, je trouve que ça fait perdre du temps (et des lignes) de les déclarer pour les implémenter plus tard dans le même fichier, alors qu'ils tiennent en une ligne...
Pour ça, il faut reconnaître, c'est un des rares avantages du C# par rapport au C++ : les accesseurs font partie intégrante du langage (genre int m_membre set get et ensuite on accède au membre via des accesseurs).
14 avril 2004 à 19:38
pour les acsesseur , tu peut par exemple les definirs dans le .h (apres le corps) et les specifier inline (ca se fait beaucoup, genre dans les entetes standard du c++)
14 avril 2004 à 18:30
Sinon pour l'enum ben je pense que je vais mettre ça en paramètres facultatifs, mais sans créer d'enum propre, en passant les constantes d'OpenGL. Comme ça celui qui n'aura pas glext.h par exemple n'aura pas de problème, et si jamais un nouveau filtrage est inventé j'aurai rien à updater.
"tu devrai faire une classe qui load different type de fichier ca serais encore mieux ;)" Ben là désolé mais non, je n'ai besoin que de ce format-là, et étudier les autres formats est très long. A la base j'ai créé cette classe pour un autre projet qui, s'il se finit, arrivera sur CppFrance.
Voilà, je vais prendre en compte vos remarques ;)
13 avril 2004 à 23:26
ca serait cool comme dit kirua de passer le filtrage de la texture en parametre (indispensable pour la 3d)
genre creer un type enum avec NEAREST, BILINEAR, TRILINEAR, ANISOTROPIC, opur anisotropic il te faut l'entete glext.h pour les extensions opengl
sinon c'est cool ta classe, tu devrai faire une classe qui load different type de fichier ca serais encore mieux ;)
bonne chance
13 avril 2004 à 20:47
Ben moi non plus je connais pas le nom des constantes lol (les GL_NEAREST et tout ça...). Mais de toutes façons quand t'as loadé la texture, t'as même pas besoin de faire un glBindTexture2D(), c'est déjà celle-là qui est en cours, donc c'est vraiment, vraiment de la fainéantise ! :p Bon mais si tu veux je vais l'implémenter ;)
Pour l'idée de l'en-tête (structure TGAHeader), franchement je vois pas trop l'utilité, à part pour un code plus beau...Mais ce serait une structure/classe (avec un opérateur surchargé, ça se rapproche d'une classe) qui ne serait utilisée que dans ce loader, donc ce ne serait pas une classe réutilisable.
Je suis parti du concept que celui qui lit le code source et veut le comprendre sait comment est organisé un fichier TGA.
En plus, c'est plus optimisé d'utiliser un tableau header[].
Enfin c'est une question de préférence ^^, et tant que ça marche ça j'y touche pas :p
Au sujet de malloc()/free() : j'ai préféré utiliser ça parce que ça ne dépend pas d'un runtime, et il me semble que new[]/delete[] par contre si, mais encore une fois je n'en suis pas sûr du tout. Et puis aussi j'étais pas sûr de la syntaxe avec delete[], s'il faut parcourir tout le tableau, mais il me semble que non, j'en suis presque sûr.
Aussi, la différence entre new/delete et malloc/free c'est que new/delete appellent les constructeurs et destructeurs des objets créés/détruits, or là mes objets étant des unsigned char, je n'en avais pas besoin.
""if (origin_non_bottom_left)" ça c le genre de saleté qui casse la tête ^^ c'est bien géré ;-)" Ben en fait non lol, la meilleure façon de le gérer aurait été de faire ça dès le "loadage" dans m_data[]. Mais comme j'arrivais pas j'ai préféré faire un flip vertical ensuite. Ca prend un petit plus de temps au chargement. D'ailleurs si je me rappelle bien c'est toi qui m'avais aidé pour ça non? ;)
pour ta fonction LoadOpenGLTexture(), en fait j'y avais déjà pensé mais j'avais la flemme de l'implémenter. Donc je vais faire ça maintenant, et aussi une version qui n'oblige pas à spécifier soi-même l'ID de la texture.
13 avril 2004 à 20:32
TGAErrorCode LoadOpenGLTexture(char* path, GLuint id)
{
TGAErrorCode ret = LoadFile(path);
if(ret == TGA_OK)
{
SendToOpenGLWithID(id);
Free();
}
return ret;
}
13 avril 2004 à 20:24
13 avril 2004 à 20:22
OUIIIIIIIIIIIIIIIIIIIIIIIIIII on est bien d'accord, la POO c'est ESTHETIQUE.
Après mes petites excentricités (pardon aux familles tt ça)
Voyons, première remarque: très propre :-)
La classe n'est pas "limitée" à OpenGL, puisque les données sont chargées et puis traitées selon le besoin. Ce qui veut dire que si je crée ma lib graphique ton code est utilisable, cool ^_^
"g_ID_texture = tga_loader.SendToOpenGL();
tga_loader.Free();"
idée:
C'est pas long à faire, permettre de définir la qualité de la texture via une méthode inline. (et définis toi même des constantes BAS/MOYEN/HAUT, parce que je retiens jamais les noms OpenGL ^^)
Le code est très propre (très beau ^^), mais si j'étais toi je créerais une structure TGAHeader. Tu mets les propriétés dans l'ordre et tu surcharges l'opérateur >>. Comme ça l'esthétisme est poussé jusqu'au bout: (avec file un objet fstream)
file >> MonEnTeteTGA;
et puis à patir de l'en-tête comem c une structure les propriétés sont nommées, et tu dois plus commenter: le code parle de lui-même. (c clair?)
Suis déçu que tu aies utilisé malloc et free... au diable la vieille école, utilise new/delete :-)
"if (origin_non_bottom_left)" ça c le genre de saleté qui casse la tête ^^ c'est bien géré ;-)
valaaa, à toi la parole.
Ah, puis si tu pouvais expliciter les commandes préprocesseurs du header, je comprends pas trop l'utilité du windows.h, ciao ;-)
13 avril 2004 à 19:34
C'est un réflexe d'optimiser quand c'est possible ;)
Pour ce qui est de la portabilité : mon code est portable. Selement, le #include <windows.h> est là parce que la compilation l'exige. C'est dû au fait que les déclarations des fonctions OpenGL sont du style :
WINGDIAPI GLvoid glVertex2i(GLint x, GLint y);
et WINGDIAPI est défini dans <windows.h>.
Sinon, le code en lui-même n'utilise rien de windows.h, et le #include est placé dans un #ifdef. Donc la compilation sous Linux ne devrait pas poser de problème, bien que je n'aie pas essayé.
PS : j'ai oublié de préciser : mon code d'exemple utilise GLUT, il vous faudra glut32.dll pour l'exécuter.
13 avril 2004 à 19:19
le code n'a pas specialement besoin d'etre rapide (ce qui je crois est le but de inline)
j'aurais plutot mis inline pour l'envoi de la texture a openGL
---> #include <windows.h>
et mais c'est pas portable ton code :p
ban ben je, enfin on vas mettre ton loader de tga a l'epreuve ;-)
code bien
13 avril 2004 à 18:39