Bonjour à tous,

Le moment est venu de créer mon propre format d'image, j'ai donc choisi le format de départ, le fameux .bmp, car j'ai trouvé plus de doc pour.(Enfin pas tant que ca).
En fait c'est la première fois que je me penche sur le chargement de texture en faisant le code tout seul au lieu d'utiliser une lib ou quoi .

Ait-je fait le bon choix avec BMP comme image de départ?
Je dois pouvoir gerer des images avec l'alpha aussi des fois, et de differentes dimensions genre (128*32 et pas toujours 128*128 etc).

Deja pour le moment, j'ai quelques problèmes avec le loader, vu que je commence a lire les données à partir de la:
file.seekg(54,ios::beg); au lieu de "taille_entete+".. donc ca n'ira pas avec tous les images bmp
Et aussi pour recuperer "bits_per_pixel", c'est valeur allant de 0 à 4 je crois^^, mais moi j'ai toujours 0, surement un problème de file.seekg(..)?
Devrais-je continuer a travailler avec ce format ou bien d'autres seront mieu?

Voici mon code actuel;
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#define BMP_NO_FILTER 0
#define BMP_LINEAR 1
#define BMP_BILINEAR 2
#define BMP_TRILINEAR 3
#define BMP_ANISOTROPIC 4
 
struct LDEbmp
{
    unsigned long   taille,
                    largeur,
                    hauteur,
                    compression,
                    bits_per_pixel;
    unsigned short  couleur;
    unsigned char * bmp;
    LDEuint ID;
    string name;
 
    void load(string path)
    {
        name = path;
        // read stuff
        ifstream file( (char*)LDEstc(path) );
        if ( file )
        {
            file.seekg(18,ios::beg);
            file.read((char *)&largeur,sizeof(largeur));
            file.seekg(22,ios::beg);
            file.read((char *)&hauteur,sizeof(hauteur));
            file.seekg(34,ios::beg);
            file.read((char *)&taille,sizeof(taille));
            file.seekg(28,ios::beg);
            file.read((char *)&couleur,sizeof(couleur));
            file.seekg(30,ios::beg);
            file.read((char *)&compression,sizeof(compression));
            file.seekg(45,ios::beg);
            file.read((char *)&bits_per_pixel,sizeof(bits_per_pixel));
 
            bmp = new unsigned char[taille];
            if (!bmp) LDEcout<<"  Couldn't allow memory for '"<<path<<"'.";
 
            file.seekg(54,ios::beg); // !!!!!!!!!!!!!!!!!!!!!!
            file.read(reinterpret_cast<char*>(bmp),taille);
 
            file.close();
        }
        else LDEcout<<"  Couldn't load '"<<path<<"' file.";
    }
 
    void build(LDEuint &id, int mode)
    {
        // gen id and build 2D mipmaps
        glGenTextures(1, &id); ID = id;
        glBindTexture(GL_TEXTURE_2D, id);
        gluBuild2DMipmaps(GL_TEXTURE_2D,4,hauteur,largeur,GL_RGB,GL_UNSIGNED_BYTE,bmp);
 
        // filter
        switch ( mode )
        {
            case BMP_NO_FILTER:
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            break;
 
            case BMP_LINEAR:
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            break;
 
            case BMP_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 BMP_TRILINEAR:
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
            break;
 
        #ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
            case BMP_ANISOTROPIC:
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2.0f);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
            break;
        #endif
        }
 
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    }
 
    void exportLDEt( string path )
    {
        ofstream file( (char*)LDEstc(path) );
        file.write((char *)&largeur,sizeof(largeur));
        file.write((char *)&hauteur,sizeof(hauteur));
        file.write((char *)&taille,sizeof(taille));
        file.write((char *)&taille,sizeof(taille));
        file.write((char *)&couleur,sizeof(couleur));
        file.write((char *)&compression,sizeof(compression));
        file.write((char *)&bits_per_pixel,sizeof(bits_per_pixel));
        file.write(reinterpret_cast<char*>(bmp),taille);
    }
};
Voici le test du loader, l'image de depart:

Resultat:

J'ai lu quelque part que les bmp sont stoquées de BLUE GREEN RED au lieu de RED GREEN BLUE, mais GL_BGR undeclard pour tester dans gluBuild2DMipmaps() donc je ne peux pas tester.

Pouvez-vous me dire quoi qui va pas dans tout ca?
Je suis preneur aussi de liens qui decrivent en plus de détails les formats d'image actuels

Par avance Merci à vous