Charger une bmp..

**Happy** · 02/04/2007, 17h01

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

**Laurent Gomila** · 02/04/2007, 17h21

Vu toutes les questions que tu poses, je ne pense pas que gérer les formats de fichiers à la main soit une bonne idée. D'autant plus que BMP est l'un des plus faciles à charger, et qu'il est loin d'être adapté pour les jeux (png, tga, jpg, dds le sont plus).

Ce qui t'attend là c'est une quête sans fin et parsemée de plein d'erreurs.

Il y aurait plein de choses à dire par rapport à ton code et à tes questions, mais la seule chose à répondre c'est "utilise une bibliothèque" (il y en a tellement en plus...).

Pour GL_BGR, il faut peut-être aller le chercher sous forme d'extension (genre GL_BGR_EXT) ou alors au pire inverser toi-même les canaux rouge / bleu.

**Mat.M** · 02/04/2007, 17h26

Eh oui si tu fais ton propre format comment vas-tu faire pour dessiner ? Vu que la majorité des programmes de dessins utilisent les mêmes formats ( bmp,jpg,png ) ??

**Happy** · 02/04/2007, 17h36

Je vois, en fait je voulait avoir le controle de chaque detail sur le loader de l'image de départ pour en créer le mien, effectivement une lib faciliterai bien la tache, faut que je trouve maintenant laquelle serais adaptée

De toutes façons, comme je travaille sous photoshop, je vais choisir le .tga alors.

Mat.M, par example photoshop me donne .tga, je convertis dans mon propre format, et je l'utilise

**Laurent Gomila** · 02/04/2007, 17h44

Ah tu veux carrément faire ton propre format (j'avais pas compris

).
Quelle sombre idée t'a bien pu pousser à faire ça ?

Moi j'aime bien DevIL comme bibliothèque de chargement d'image, mais il y en a plein d'autres, que tu trouveras avec une recherche sur le forum ou dans la FAQ C++.

**Happy** · 02/04/2007, 18h05

Je n'aime pas qu'on prenne mes textures comme ca facilement

Et merci beaucoup je vais me pencher sur DevIL

.

Charger une bmp..

OpenGL

Vue hybride

Discussions similaires

Partager

Partager