[hlsl] Comment mapper une texture selon la face de mon objet (multitexturing)

Version imprimable

18/09/2012, 20h26
Themacleod1980

[hlsl] Comment mapper une texture selon la face de mon objet (multitexturing)

Salut,

j'ai créé un polygone de type prisme hexagonal auquel je souhaite appliquer une texture différente pour chaque face (haut, bas, et les autres...).

j'ai créé pour cela ma propre structure de vertex :
Position
Normale
TextureUV0 (haut)
TextureUV1 (bas)
TextureUV2 (autres...)

Là où je bloque c'est dans le code hlsl :
Chaque vertex faisant partie de 3 faces de mon polygone, comment appliquer une TextureUV différente pour chaque face ?

c'est bien au niveau du PixelShader que je dois chercher ?
(ce qui m’amène d’ailleurs à poser la question : Connaissez-vous une bonne doc complète en fr de préférence ?)

voici ce que j'ai dans mon PS :

Code:

Out.Color = tex2D(texture0MapSampler, In.Texture0);

Comment peut-on connaitre la face en cours de 'traçage' afin de lui coller une autre texture ?

merci
20/09/2012, 18h51
LittleWhite

Bonjour,

Si vous essayez de mettre une texture différente par face, alors il vous fera un vertex différent pour chaque face (et là, l'indexation n'est plus possible :( ).
Je me demande s'il n'y aura pas une autre méthode, afin de spécifier que les huit vertex et les 48 texcoords, mais je ne connais pas une telle méthode :(
21/09/2012, 21h29
Themacleod1980

Bonjour,
déjà merci pour la réponse :)

malheureusement j'affiche énormément de ces polygones (je fais une sorte de map de jeu volumétrique) et si je passe en non indexé je passe de 120fps à 34 ..., vu que je compte rajouter des machins dessus ultérieurement ca fait short :/

j'ai pensé à faire un mix des deux en restant en indexé mais en doublant les vertices mais je pense que ca reviendrait au même question perf :p

j'ai finalement continué à chercher du coté des shader et suis tombé sur un GeometryShader (qui permettrait de toucher non plus aux vertices mais aux triangles) disponible avec ... directx11 ! pas supporté par XNA semble t'il (9.0c je crois)

du coup deux solution s'offrent à moi :
- soit j'abandonne ce concept de map volumétrique et je reste avec une simple surface :(
- soit je laisse tomber XNA pour me mettre au DX11 :(
- soit j'ai loupé un truc et quelqu'un à une idée qui tue :)
22/09/2012, 11h39
MoDDiB

Avec un meilleur dépliage de ta texture ce n'est pas possible ?
( j'ai l'impression que tu reste bloqué sur une façon trop simpliste de texturer : si cela peut t'inspirer : http://blog.khamsin.org/public/Tutor..._01_entete.jpg )
N'hésites pas à poster un Screenshots pour nous aiguiller !
24/09/2012, 14h04
Themacleod1980

2 pièce(s) jointe(s)

Salut,
merci pour ta réponse,

cette méthode serait possible si mon polygone avait toujours les mêmes proportions. Or, il a une part d'aléatoire : les vertices sont légèrement déplacés en x,y,z (aléatoirement entre +0 et +0.5) lors de sa création.
Cela fait qu'une texture basée sur un objet aux proportions définies ne collerait pas (serait décalée au niveau des raccords).
L'avantage d'avoir une texture par face est que je peux compenser les déplacements aléatoire des vertices en jouant sur les coordonnées de la texture.

Par exemple pour un cube (plus simple :p) :
Si je mappe simplement les coins de mon cubes, une fois aléatoirement déplacés, mes vertices déforment la texture (admirez mes talents de dessinateur...)
http://www.developpez.net/forums/att...1&d=1348487682

Si je mappe les coins en prenant un peu de marge sur les cotés (équivalente aux déplacements Max) le rendu ne sera pas affecté :
http://www.developpez.net/forums/att...1&d=1348487763
le problème par contre, c'est que toute la partie non mappée (la bordure) de la texture déborde sur les faces latérales.

C'est pour ca que j'aurais aimé caser une texture par face. En non indexé ca fonctionne mais c'est ultra lent ! (je passe de 120fps à 34...)

et avec le mappage de texture complexe j'aurais forcément des bavures ou déformations de la texture.
24/09/2012, 16h19
MoDDiB

Ça m'a l'air extrêmement spécifique comme problème : des screens permettraient de mieux cerner ce que tu souhaites.

Par contre passer de 120fps à 34 lorsque tu n'indexes pas je penses que tu as un problème ailleurs aussi : tu affiches certainement une tonne de faces qui ne sont pas visibles, pas de LOD etc...
24/09/2012, 20h30
Themacleod1980

1 pièce(s) jointe(s)

Voila un petit dessin qui permettra peut être de mieux expliquer le problème :
http://www.developpez.net/forums/att...1&d=1348510277
(au MsPaint ... sisi...)

je fais tout un maillage de ce genre de figures genre yen a 64*2*64.
Du coup en non indexé ca fait chuter le fps :
je passe de 14 vertices pour 18 indices à 72 vertices pour chaque polygones...

si j'en affiche 64*2*64 = 8192 polygones.
en indexé ca fait 8192 * 14 = 114 688 vertices
en non indexé ca fait 8192 * 72 = 589 824 vertices
et là ma carte graphique pleure :calim2:

du coup je cherchais au niveau non plus des vertices mais au niveau du shader lui-même :) mais ca n'a pas l'air possible :?
24/09/2012, 21h25
MoDDiB

J'ai très bien compris le problème tu l'avais déjà très bien expliqué, un screen aurait juste permis de proposer d'autres solutions, et surtout de mettre en avant un manque d'optimisations.

Sinon tu n'as pas à passer en non indexé, il te suffit de découper ton objet en 3 et tu pourras faire ce que tu souhaites de manière moins gourmande qu'en non indexé.

Ce que tu souhaites faire ( plusieurs uv pour un même point ) est possible, en s'amusant à choisir la texture en fonction de la normale actuelle mais ça sera très coûteux en performance et ça me semble un peu tricky.

ce ne serait pas découpé en 3 mais en 8 (haut, bas et 6*coté)
ce qui ferait
7 pour le haut
7 pour le bas
6*4 pour les cotés
= 38 vertices
ca peut être un bon compromis

une partie du code pour faire le polygone en non indexé :

Code:

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
            //hexa dessous
            Vector3 pointOrigineA = new Vector3(demiX, zero, demiZ);
            Vector3 pointOrigineB = new Vector3(demiX, zero, zero);
            Vector3 pointOrigineC = new Vector3(unX, zero, tiersZ);
            Vector3 pointOrigineD = new Vector3(unX, zero, deuxTiersZ);
            Vector3 pointOrigineE = new Vector3(demiX, zero, unZ);
            Vector3 pointOrigineF = new Vector3(zero, zero, deuxTiersZ);
            Vector3 pointOrigineG = new Vector3(zero, zero, tiersZ);
 
            //hexa dessus
            Vector3 pointOrigineH = new Vector3(demiX, unY, demiZ);
            Vector3 pointOrigineI = new Vector3(demiX, unY, zero);
            Vector3 pointOrigineJ = new Vector3(unX, unY, tiersZ);
            Vector3 pointOrigineK = new Vector3(unX, unY, deuxTiersZ);
            Vector3 pointOrigineL = new Vector3(demiX, unY, unZ);
            Vector3 pointOrigineM = new Vector3(zero, unY, deuxTiersZ);
            Vector3 pointOrigineN = new Vector3(zero, unY, tiersZ);
            //            l
            //           / \
            //          /   \      
            //         m     k          e
            //         |  h  |         / \
            //         |     |        /   \
            //         n     j       f     d
            //          \   /        |  a  |
            //           \i/         |     |
            //                       g     c
            //                        \   /
            //                         \b/
 
//ensuite j'effectue sur les pointOrigine* un déplacement individuel et j'obtiens mes point* 
//mes pointTexHexaA représentent les coordonnées texture calculée après les déplacements
//et je crée mes vertices :
VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[72]
            {
                //hexagone 1 (dessous)
                new VertexPositionNormalTexture( pointA   ,pointA,pointTexHexaA ), 
                new VertexPositionNormalTexture( pointB   ,pointB,pointTexHexaB), 
                new VertexPositionNormalTexture( pointC   ,pointC,pointTexHexaC), 
 
                new VertexPositionNormalTexture( pointA   ,pointA,pointTexHexaA), 
                new VertexPositionNormalTexture( pointC   ,pointC,pointTexHexaC), 
                new VertexPositionNormalTexture( pointD   ,pointD,pointTexHexaD), 
 
                new VertexPositionNormalTexture( pointA   ,pointA,pointTexHexaA), 
                new VertexPositionNormalTexture( pointD   ,pointD,pointTexHexaD), 
                new VertexPositionNormalTexture( pointE   ,pointE,pointTexHexaE), 
 
                new VertexPositionNormalTexture( pointA   ,pointA,pointTexHexaA), 
                new VertexPositionNormalTexture( pointE   ,pointE,pointTexHexaE), 
                new VertexPositionNormalTexture( pointF   ,pointF,pointTexHexaF), 
 
                new VertexPositionNormalTexture( pointA   ,pointA,pointTexHexaA), 
                new VertexPositionNormalTexture( pointF   ,pointF,pointTexHexaF), 
                new VertexPositionNormalTexture( pointG   ,pointG,pointTexHexaG), 
 
                new VertexPositionNormalTexture( pointA   ,pointA,pointTexHexaA), 
                new VertexPositionNormalTexture( pointG   ,pointG,pointTexHexaG), 
                new VertexPositionNormalTexture( pointB   ,pointB,pointTexHexaB), 
 
                //hexagone 2 (dessus)                         
                new VertexPositionNormalTexture( pointH   ,pointH,pointTexHexaH), 
                new VertexPositionNormalTexture( pointI   ,pointI,pointTexHexaI), 
                new VertexPositionNormalTexture( pointJ   ,pointJ,pointTexHexaJ), 
 
                new VertexPositionNormalTexture( pointH   ,pointH,pointTexHexaH), 
                new VertexPositionNormalTexture( pointJ   ,pointJ,pointTexHexaJ), 
                new VertexPositionNormalTexture( pointK   ,pointK,pointTexHexaK), 
 
                new VertexPositionNormalTexture( pointH   ,pointH,pointTexHexaH), 
                new VertexPositionNormalTexture( pointK   ,pointK,pointTexHexaK), 
                new VertexPositionNormalTexture( pointL   ,pointL,pointTexHexaL), 
 
                new VertexPositionNormalTexture( pointH   ,pointH,pointTexHexaH), 
                new VertexPositionNormalTexture( pointL   ,pointL,pointTexHexaL), 
                new VertexPositionNormalTexture( pointM   ,pointM,pointTexHexaM), 
 
                new VertexPositionNormalTexture( pointH   ,pointH,pointTexHexaH), 
                new VertexPositionNormalTexture( pointM   ,pointM,pointTexHexaM), 
                new VertexPositionNormalTexture( pointN   ,pointN,pointTexHexaN), 
 
                new VertexPositionNormalTexture( pointH   ,pointH,pointTexHexaH), 
                new VertexPositionNormalTexture( pointN   ,pointN,pointTexHexaN), 
                new VertexPositionNormalTexture( pointI   ,pointI,pointTexHexaI), 
 
                //faces
                new VertexPositionNormalTexture( pointB   ,pointB,pointTexFaceB), 
                new VertexPositionNormalTexture( pointI   ,pointI,pointTexFaceI), 
                new VertexPositionNormalTexture( pointC   ,pointC,pointTexFaceC), 
                new VertexPositionNormalTexture( pointC   ,pointC,pointTexFaceC), 
                new VertexPositionNormalTexture( pointI   ,pointI,pointTexFaceI), 
                new VertexPositionNormalTexture( pointJ   ,pointJ,pointTexFaceJ), 
 
                new VertexPositionNormalTexture( pointC   ,pointC,pointTexFaceC ), 
                new VertexPositionNormalTexture( pointJ   ,pointJ,pointTexFaceJ ), 
                new VertexPositionNormalTexture( pointD   ,pointD,pointTexFaceD ), 
                new VertexPositionNormalTexture( pointD   ,pointD,pointTexFaceD ), 
                new VertexPositionNormalTexture( pointJ   ,pointJ,pointTexFaceJ ), 
                new VertexPositionNormalTexture( pointK   ,pointK,pointTexFaceK ), 
 
                new VertexPositionNormalTexture( pointD   ,pointD,pointTexFaceD ), 
                new VertexPositionNormalTexture( pointK   ,pointK,pointTexFaceK ), 
                new VertexPositionNormalTexture( pointE   ,pointE,pointTexFaceE ), 
                new VertexPositionNormalTexture( pointE   ,pointE,pointTexFaceE ), 
                new VertexPositionNormalTexture( pointK   ,pointK,pointTexFaceK ), 
                new VertexPositionNormalTexture( pointL   ,pointL,pointTexFaceL ), 
 
                new VertexPositionNormalTexture( pointE   ,pointE,pointTexFaceE ), 
                new VertexPositionNormalTexture( pointL   ,pointL,pointTexFaceL ), 
                new VertexPositionNormalTexture( pointF   ,pointF,pointTexFaceF ), 
                new VertexPositionNormalTexture( pointF   ,pointF,pointTexFaceF ), 
                new VertexPositionNormalTexture( pointL   ,pointL,pointTexFaceL ), 
                new VertexPositionNormalTexture( pointM   ,pointM,pointTexFaceM ), 
 
                new VertexPositionNormalTexture( pointF   ,pointF,pointTexFaceF ), 
                new VertexPositionNormalTexture( pointM   ,pointM,pointTexFaceM ), 
                new VertexPositionNormalTexture( pointG   ,pointG,pointTexFaceG ), 
                new VertexPositionNormalTexture( pointG   ,pointG,pointTexFaceG ), 
                new VertexPositionNormalTexture( pointM   ,pointM,pointTexFaceM ), 
                new VertexPositionNormalTexture( pointN   ,pointN,pointTexFaceN ), 
 
                new VertexPositionNormalTexture( pointG   ,pointG,pointTexFaceG ), 
                new VertexPositionNormalTexture( pointN   ,pointN,pointTexFaceN ), 
                new VertexPositionNormalTexture( pointB   ,pointB,pointTexFaceB ), 
                new VertexPositionNormalTexture( pointB   ,pointB,pointTexFaceB ), 
                new VertexPositionNormalTexture( pointN   ,pointN,pointTexFaceN ), 
                new VertexPositionNormalTexture( pointI   ,pointI,pointTexFaceI )
            };

en indexé :

Code:

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
VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[14]
            {
                //hexagone 1 (dessous)
                new VertexPositionNormalTexture( pointA   ,pointA,pointTexHexaA), 
                new VertexPositionNormalTexture( pointB   ,pointB,pointTexHexaB), 
                new VertexPositionNormalTexture( pointC   ,pointC,pointTexHexaC),                 
                new VertexPositionNormalTexture( pointD   ,pointD,pointTexHexaD), 
                new VertexPositionNormalTexture( pointE   ,pointE,pointTexHexaE),                
                new VertexPositionNormalTexture( pointF   ,pointF,pointTexHexaF), 
                new VertexPositionNormalTexture( pointG   ,pointG,pointTexHexaG),
                //hexa dessus
                new VertexPositionNormalTexture( pointH   ,pointH,pointTexHexaH), 
                new VertexPositionNormalTexture( pointI   ,pointI,pointTexHexaI), 
                new VertexPositionNormalTexture( pointJ   ,pointJ,pointTexHexaJ), 
                new VertexPositionNormalTexture( pointK   ,pointK,pointTexHexaK),             
                new VertexPositionNormalTexture( pointL   ,pointL,pointTexHexaL), 
                new VertexPositionNormalTexture( pointM   ,pointM,pointTexHexaM), 
                new VertexPositionNormalTexture( pointN   ,pointN,pointTexHexaN),                                
            };
 
            indices = new short[72]{ 
                //hexa dessous
                0,1,2,                
                0,2,3,
                0,3,4,           
                0,4,5,                
                0,5,6,
                0,6,1,
 
                //hexa dessus
                7,8,9,                
                7,9,10,                
                7,10,11,
                7,11,12,                
                7,12,13,                
                7,13,8,
 
                //faces
                1,8,2,
                2,8,9,
 
                2,9,3,
                3,9,10,
 
                3,10,4,
                4,10,11,
 
                4,11,5,
                5,11,12,
 
                5,12,6,
                6,12,13,
 
                6,13,1,
                1,13,8
            };

24/09/2012, 23h08
MoDDiB

Normalement tu n'as aucunement besoin d'afficher toutes les faces.
Renseigne toi sur les vertex buffer dynamique et jette un oeil aux optimisations effectuées ici :
https://techcraft.codeplex.com/

Certes c'est plus complexe dans ton cas mais l'idée est la même !
25/09/2012, 09h43
Themacleod1980

je vais me pencher là-dessus,
merci beaucoup :)