LOADER TGA OPENGL (TEXTURES + TRANSPARENCE)

Commentaire de cppdupdup34 le 13/04/2004 19:19:05

peut etre me trompes-je mais pourquoi tu utilises des inline
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

Commentaire de Kirua le 13/04/2004 20:22:16

"...la POO c'est beau ;))"
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 ;-)

Commentaire de Kirua le 13/04/2004 20:32:36

Voici une fonction que je trouve intéressante à ajouter dans le bloc "#ifdef TGA_OPENGL_SUPPORT"

TGAErrorCode LoadOpenGLTexture(char* path, GLuint id)
{
TGAErrorCode ret = LoadFile(path);
if(ret == TGA_OK)
{
  SendToOpenGLWithID(id);
  Free();
}
return ret;
}

Commentaire de djl le 13/04/2004 23:26:27

les ascesseurs definis dans le corps de la classe sont inline par defaut, c'est redondant de le rajouter
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

Commentaire de djl le 14/04/2004 19:38:44

oui c'est vrai, moi en ce moment je me suis mi a utiliser devil, parce que c'est pratique de  charger des image jpeg, mais si on commence a devenir dependant de ce genre de bibliotheque la c moin cool

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++)

Commentaire de Cyberboy2054 le 14/04/2004 21:15:38

Ma ptite participation pour le filtrage .. Chuis très flemmard, alors va falloir que tu modifie pas mal ;)
// 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.

Commentaire de Funto66 le 14/04/2004 22:49:02

Nouvelle version !
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

Commentaire de Funto66 le 08/08/2004 13:29:44

Yup, nouvelle version, que j'ai baptisée 1.1 :p
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 :)

Commentaire de Funto66 le 09/08/2004 01:06:24

Je comprends pas exactement la question...
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)...

Commentaire de Funto66 le 26/08/2004 01:09:07

dsl les erreurs que t'as recopiées là ne peuvent pas m'aider vraiment; tu pourrais me les envoyer en entier si possible à funto [at] nomade.fr stp (sinon ben une capture d'écran lol), je verrai ce que je peux faire ^^ (normalement ça compile aussi avec Dev-C++).

Commentaire de gimli123 le 24/10/2004 18:56:54

Re j'ai trouver la solution :D
il faut inclure glut.h apres tgaloader.h
voila sinon excelent !!

Commentaire de Tsun le 01/03/2005 10:36:23

Tres bonne librairie, vraiment complete.
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

Commentaire de Funto66 le 28/04/2005 15:51:35

Nouvelle version 1.3, quelques changements minimes; Cf la présentation du code pour ceux que ça intéresserait ;)

Commentaire de Mattpbem le 13/10/2005 19:17:19

j'ai oublié de donnée le lien
http://matt2000.free.fr/prog/BmpLoader.rar

Commentaire de psykocrash le 04/01/2006 20:16:11

Salut :)
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.

Commentaire de psykocrash le 06/01/2006 01:13:03

Ca ne marche pas... Ca me dessine un carré effectivement, sauf qu'il est vide :/ (blanc).
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 :)