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.

**TanEk** · 20/09/2008, 19h13

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
/*      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

Tout ça est faux. Il faut que les données d'une texture soient contigus en mémoire or là tu fais seulement des tableaux de 3 chars contigus en mémoire.

Il faut que tu revoies l'allocation mémoire. Tu peux avoir les textures non contiguës en mémoire donc tu peux faire :

Code :

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

1
2
3
4
5
6
7
8
9
 
 blocks = new unsigned char **[indice1];       // 12
    for ( unsigned int i = 0 ; i < indice1 ; i++ )
        blocks[i] = new unsigned char *[indice2]; // 16
 
 // Allocation contiguë en mémoire
 for ( unsigned int i = 0 ; i < indice1 ; i++ )
        for ( unsigned int j = 0 ; j < indice2 ; j++ )
            blocks[i][j] = new unsigned char [FRAGMENT_SIZE * FRAGMENT_SIZE * 3];

Je te laisse le soin de changer la suite du code.

**GoldenEye** · 20/09/2008, 22h18

Ah oui effectivement je n'avais pas fait attention, le paramètre à transmettre à GlTexture2D est un pointeur simple.

**LittleWhite** · 20/09/2008, 22h32

TanEk => Je ne suis pas sur d'avoir compris.

Il faut avoir les données contigus ou pas? Après grande réflexion je crois que les miennes ne sont pas contigus et que avec ta méthode c'est mieux. Mais je ne suis pas sur que nos de code organise la mémoire différemment.

Je teste dans la soirée , une fois que j'aurais envie de retourner sur windows en faite.

**TanEk** · 21/09/2008, 00h14

Il faut que les données de toute une texture (tous les pixels) soient contiguës en mémoires. Après les textures ne doivent pas forcément être contiguës entre elles. Et pour l'agencement des pixels il faut voir comment c'est, si c'est ligne d'abord ou colonne d'abord... (i.e. on parcourt les lignes d'abord ou les colonnes d'abord, renseigne-toi sur le format de texture dans OpenGL).

**LittleWhite** · 21/09/2008, 02h29

Pour le moment j'arrive pas à coder le classement des pixels dans le nouveaux tableau, mais bon je vais prendre une feuille et posé le problème.
Pour savoir comment lit OpenGl , les données ( colonnes puis lignes , ou l'inverse ) de toute façon je vais vite le remarquer

**LittleWhite** · 21/09/2008, 18h53

Je crois que je vient de réussir de coder le truc, mais j'ai toujours les surfaces qui sont blanches ( même si je remplie mon tableau par la couleur noir directement ( sans tenir compte de mon image ))
Cela m'étonne que personne est cherché à faire un code comme celui ci , car comme plein de carte graphique ne peuvent pas prendre les surfaces non puissances de 2.
Enfin même si mon remplissage n'est pas tout a fait bon , ne verrai ton pas quelque chose même de pas joli ?

**TanEk** · 21/09/2008, 19h16

Les gens se prennent moins la tête, ils prennent un screen, redimensionnent en puissance de 2.

**LittleWhite** · 22/09/2008, 02h00

Les gens se prennent moins la tête, ils prennent un screen, redimensionnent en puissance de 2.

Je suis dans un cas ou c'est pas correct , surtout un background ... de la taille de la fenetre

**LittleWhite** · 24/09/2008, 00h18

Le :

Code :

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

glBindTexture(GL_TEXTURE_2D, 0);

Qui est après avoir donnée les données à OpenGL ne génerai t'il pas ?
Je ne sais pas, car lors de mes tests lorsque je l'enlève , la dernière petite texture et colorée ( au lieu du blanc habituel ).

**TanEk** · 24/09/2008, 00h51

Envoyé par LittleWhite

Je suis dans un cas ou c'est pas correct , surtout un background ... de la taille de la fenetre

Quel est le problème ? D'accord ce ne sera pas exact mais ça m'étonnerait que l'utilisateur voit vraiment la différence... Essayes tu verras bien

.

**LittleWhite** · 25/09/2008, 19h15

Dans le cas , ou le gars qui ma fait le joli background , va voir le programme , ça ne se fait pas , de plus l'image et au fond , et à la taille de la fenêtre. ( En mode windows et non full screen ).
Et puis ça veut dire que je m'incline devant un ( "ridicule" ) problème .

Par contre j'ai lu aujourd'hui que si je ne veux pas couper la texture je peux faire un truc avec :

Code :

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

gluScaleImage()

mais je ne vois pas comment l'utiliser , d'ailleur je ne vois pas comment tu veux que je fasse avec ta méthode.

**TanEk** · 25/09/2008, 20h28

Envoyé par LittleWhite

Dans le cas , ou le gars qui ma fait le joli background , va voir le programme , ça ne se fait pas , de plus l'image et au fond , et à la taille de la fenêtre. ( En mode windows et non full screen ).
Et puis ça veut dire que je m'incline devant un ( "ridicule" ) problème .

Par contre j'ai lu aujourd'hui que si je ne veux pas couper la texture je peux faire un truc avec :

Code :

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

gluScaleImage()

mais je ne vois pas comment l'utiliser , d'ailleur je ne vois pas comment tu veux que je fasse avec ta méthode.

Niquel cette fonction et bien tu fais un truc du genre :

Code :

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

1
2
3
 
gluScaleImage( GL_COLOR_INDEX, height, width, typeIn, screenBuffer, 
heightScaled, widthScaled, typeOut, screenResized);

Avec heightScaled les tailles les plus proches de height et width en puissance de 2 (j'ai pas vraiment réfléchi à un algo mais ça doit pas être bien compliqué).

Et après t'envoies ça dans une texture et c'est fini.

**LittleWhite** · 27/09/2008, 20h08

Je l'ai codé , il n'y a pas de problème apparent , mais je ne sais pas ça fait ce que je voulais car je n'ai pas accès au PC ou avant ça planté.

Merci de m'avoir donné le prototype de la commande et son fonctionnement, mais en fait je demandais comment tu fesait avec ta méthode.
Pour ce prototype , je suis entièrement capable d'aller le chercher tout seul.

J'ai fais l'algo suivant ( au cas ou tu ne voudrai pas trop cherché , mais je suis parfaitement conscient que tu es capable de le trouver tout seul )

Demande par le biais de glGet qu'elle est la taille de texture qu'il peut charger.
Si plus petit que la taille de la texture
alors on fait le gluScale
sinon on fait comme d'habitude

Quoi qu'il en soit , je te remercie de toute l'aide que tu m'as apporté, et je n'ai plus qu'a trouvé un PC sur lequel l'ancienne version ne fonctionne pas.

**LittleWhite** · 28/09/2008, 19h14

J'ai testé, mais cela ne règle pas mon problème de FPS , car le Pc sur lequel j'ai testé pouvez accepter des textures de 2046
...
J'ouvre un nouveau sujet afin de poser autrement mon problème
Merci

Texturage en puissance de 2

OpenGL

Discussions similaires

Partager

Partager