Texturage en puissance de 2

**LittleWhite** · 20/09/2008, 00h14

Bonjour,

j'espère que je ne dérange personne surtout que j'ai l'impression que c'est une question souvent posée.
Je suis débutant

et je veux mettre une texture sur toute la surface de ma fenêtre.
Mon fichier image est de taille 1024 * 768. Je sais comment mettre la texture au fond et ça marche ( ... enfin presque, parce qu'au sinon je n'aurai pas posté ).
Sur un PC sur deux le programme rame lamentablement. Pour toutes mauvaises langues qu'on peut trouver, ce n'est pas un problème entre ATI et Nvidia. ( j'ai testé

)
C'est quand même un problème de carte graphique , car en venant ici j'ai vu que certaines ne peuvent pas gérée la chose facilement tant que les textures ne sont pas des puissances de 2.
Bon, comme je pense savoir programmer, je me suis dit, découpons cette texture en mémoire.
Soit j'ai ma texture en mémoire dans un unique tableau de 1024*768*3 cases ( du RGB ) et je veux faire 16 * 12 tableaux de 64*64*3 cases ( OK , j'espère que je me fais comprendre ). Mon image est découpé en morceaux de 64 pixels sur 64.
Après chaque bloc , je le met dans une texture OpenGL.

Voici le code qui fait ceci :

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
105
106
 
#define FRAGMENT_SIZE 64
 
void Image :: segmentTexture(unsigned char* data )
{
unsigned int indice1 = sizeY/FRAGMENT_SIZE;
    unsigned int indice2 = sizeX/FRAGMENT_SIZE;
 
    unsigned char  *****blocks = NULL;
 
/*      Construction */
 
    blocks = new unsigned char ****[indice1];       // 12
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        blocks[i] = new unsigned char ***[indice2]; // 16
 
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        for ( unsigned int j = 0 ; j < indice2 ; j++ )
            blocks[i][j] = new unsigned char **[FRAGMENT_SIZE]; // 64
 
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        for ( unsigned int j = 0 ; j < indice2 ; j++ )
            for ( unsigned int k = 0 ; k < FRAGMENT_SIZE ; k++ )
                blocks[i][j][k] = new unsigned char *[FRAGMENT_SIZE];   // 64
 
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        for ( unsigned int j = 0 ; j < indice2 ; j++ )
            for ( unsigned int k = 0 ; k < FRAGMENT_SIZE ; k++ )
                for ( unsigned int l = 0 ; l < FRAGMENT_SIZE ; l++ )
                    blocks[i][j][k][l] = new unsigned char [3];     // 3
 
    // Copie
    unsigned int lv3 = 0;
    unsigned int counter = 0;
 
    for ( unsigned int i = 0 ; i < sizeY*sizeX ; i++ )
    {
        //std::cout << " ??Lop " << std::endl;
        unsigned int lv1 = i%(64);
        unsigned int lv2 = i/(64*16);
 
        unsigned int lv4 = i/(64*64*16);
        //unsigned char j = i%3;
 
        lv2 = lv2 % 64;
 
        if ( lv1 == 0 && i != 0 )
            lv3++;
        if ( lv3 == 16 )
            lv3 = 0;
 
//std::cout << " blocks[ " << lv4 << " ][ " << lv3 << " ][ " << lv2 << " ][ " << lv1 << " ]" << std::endl;
 
        for ( unsigned char j = 0 ; j < 3 ; j++ )
        {
            counter++;
            blocks[lv4][lv3][lv2][lv1][j] = data[(i*3)+j];
        }
    }
 
    // Surfacage
 
    nb_texture = 12*16;
   texture = new unsigned int [16*12];
   //texture =(unsigned int* )  malloc (16*12*sizeof(unsigned int));
 
 
    glGenTextures(nb_texture, texture);					// Create The Texture
        // Typical Texture Generation Using Data From The Bitmap
 
    unsigned int count = 0;
 
    for ( unsigned int i = 0 ; i < 12; i++ )
    {
        for ( unsigned int j = 0 ; j < 16 ; j++ )
        {
            glBindTexture(GL_TEXTURE_2D, texture[count]);
 
            count++;
 
            glTexImage2D(GL_TEXTURE_2D, 0, 3, FRAGMENT_SIZE, FRAGMENT_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, blocks[i][j]);
 
            glBindTexture(GL_TEXTURE_2D, 0);
        }
    }
 
/*      Destruction */
 
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        for ( unsigned int j = 0 ; j < indice2 ; j++ )
            for ( unsigned int k = 0 ; k < FRAGMENT_SIZE ; k++ )
                for ( unsigned int l = 0 ; l < FRAGMENT_SIZE ; l++ )
                    delete blocks[i][j][k][l];
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        for ( unsigned int j = 0 ; j < indice2 ; j++ )
            for ( unsigned int k = 0 ; k < FRAGMENT_SIZE ; k++ )
                delete blocks[i][j][k];   // 64
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        for ( unsigned int j = 0 ; j < indice2 ; j++ )
            delete blocks[i][j]; // 64
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        delete blocks[i]; // 16
 
    delete [] blocks;
    delete blocks;
}

data est mon image
sizeX et sizeY sont la taille de cette image ( je suis dans une classe bien à moi

)

Bonne chance avec ce code

; Je sais qu'il n'est pas très propre , vu que c'est en version de développement , et que c'est peut être idiot la méthode que je procède.
Le code d'affichage est correct , je passe en revue toute les textures et je les colles sur ma fenêtre , dans le mode 2D de la taille de la fenêtre ( gluOrtho2D ).
L'application fonctionne mais au lieu d'avoir mes textures , je n'ai que des carrés blancs ( genre il trouve pas le fichier ) ( bien sur le fichier existe , donc c'est mon code qui est nul ).
Je suis prêt à écouter toute vu suggestion

.

( Il se peut aussi , que en n'ayant pas lu toute la doc d'OpenGL il existe une fonction qui le faisse pour moi

; dans ce cas quel est telle ( juste pour orienter mes recherches )

Merci

**TanEk** · 20/09/2008, 12h41

Je crois que le soucis est que du désalloue de suite les textures, je ne pense pas que ce soit autorisé de désallouer les textures du tant que tu les utilises. Donc essaye voir de désallouer les textures à la fin de ton programme et pas juste après le binding. Mais je ne suis pas un expert en textures OpenGL donc j'ai peut-être tout faux

.

Après une p'tite astuce pour essayer de déboguer ton programme (tu l'as peut-être déjà fais). As-tu essayé d'afficher une seule texture voir si ça marche déjà ça ? Par exemple tu mets les i < 1 et j < 1 au lieu de i < 12 et j < 16. Ce genre de chose.

**GoldenEye** · 20/09/2008, 13h31

Bonjour
J'ai déjà été confronté au problème il y a quelques temps. N'oublie pas de faire un :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR );

après le glTexImage2D() et ce, afin d'être bien certain que la texture est correctement configurée
Par ailleurs et c'est peut-être tout bête, je ne vois pas le glEnable(GL_TEXTURE_2D)
En espérant t'avoir aidé

TanEK => il peut désallouer les pixels qui ont servi à générer la texture. OpenGL fonctionne ainsi

**LittleWhite** · 20/09/2008, 14h26

TanEk => La désallocation de la mémoire juste après ne gène pas. J'y avais penser, mais en regardant les tutos du genre ceux de NeHe , ils désalloue directement la texture chargée.

GoldenEye => Le glEnable(GL_TEXTURE_2D) est fait dans une fonction InitGL() n'ont retranscrite ici

Pour l'histoire du glTexParameteri il est fait après. ( Il ne semble pas que cela gêne OpenGL car pour l'ancien mode de chargement des textures ( sans la decoupe en mémoire ) y avait pas de problème.
Une fois j'ai testé avant , et seul la première case affiché quelquechose , mais ce quelquechose était genre un nuancier de la palette d'OpenGL.
( Je travaille en RGBA ).

Merci pour vos réponses, je reteste le glTexParameteri avant ; mais je pense pas que ce soit ça.

Peut être que quelqu'un à un code tout près pour faire ce genre de truc ?

**TanEk** · 20/09/2008, 14h59

Ce serait pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

glTexImage2D(GL_TEXTURE_2D, 0, 3, FRAGMENT_SIZE, FRAGMENT_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, &blocks[i][j]);

au lieu de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

glTexImage2D(GL_TEXTURE_2D, 0, 3, FRAGMENT_SIZE, FRAGMENT_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, blocks[i][j]);

?

**LittleWhite** · 20/09/2008, 18h40

TanEk : J'ai testé avec le '&' => aucun changement. Mais en suivant ton raisonnement ( enfin je crois ), c'est de mettre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

glTexImage2D(GL_TEXTURE_2D, 0, 3, FRAGMENT_SIZE, FRAGMENT_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, &blocks[i][j][0[0][0]);

( A vrai dire , lorsque j'ai relu mon message , je n'arrive pas à savoir si c'est juste )
Est t-on sur que OpenGL peut prendre des tableaux de ce genre ? Car habituellement il a les pixels et c'est tout.

Texturage en puissance de 2

OpenGL

Vue hybride

Discussions similaires

Partager

Partager