[DX9][C#] Optimisation rendu

**lancer83** · 18/08/2006, 17h37

Salut,

Voilà je suis sur un projet de modélisation d'étagère d'entrepot...

Ces étagère peuvent être constituées de centaine de cubes (meshbox).

J'ai mis en place une gestion de la camera pour me deplacer à l'intérieur ...
Seulement dès que je bouge avec la camera je suis obligé de tout recharger sur la 3D ( le nombre de meshbox peut aller jusqu'à 16000).
A cause du grand nombre de mesh un lague se créé...

Est-il possible de bouger la camera sans avoir à tout redessiner.

Je voulais savoir ce que je pouvais faire pour optimiser la modélisation pendant le changement de d'angle de la camera ??

J'ai pensé mettre en place un thread qui tournerait pendant le deplacement de la camera et remplacerait une étagere de meshbox par un seul meshbox de la taille de l'étagère.

Vais-je gagner en performance par ce procédé ? Voyez vous une autre solution ??

Merci

**funkydata** · 18/08/2006, 17h48

Qu'est-ce que tu entends par "tout recharger" ?

**lancer83** · 18/08/2006, 17h48

Je redessine tous mes meshbox des que je bouge ma camera ...

**funkydata** · 18/08/2006, 18h06

Ca dépend donc de ta scène... si tes boites ne sont pas tout le temps visible du fait de la rotation ou du mouvement de la caméra tu peux faire du Frustum Culling. Si les boites sont en générale toutes affichées mais cachées les unes derrière les autres tu peux faire de l'Occlusion Culling... Enfin bref sa dépend surtout de ta scène. Tu peux aussi, accessoirement, faire les 2

**Sixissor** · 18/08/2006, 18h10

Salut.

Tu fais comment pour tout afficher ? Tu peux montrer ta boucle de rendu (le principal) ?

En tout cas 16 000 meshBox ça me parait beaucoup compte tenu que tu veux afficher une étagère d'entrepot si j'ai bien compris. Y'a peut-être moyen de faire ça avec moins de polygones non ?

**xterminhate** · 19/08/2006, 07h20

LOD, progressive mesh est peut etre aussi une solution à envisager.

**funkydata** · 19/08/2006, 11h43

Envoyé par xterminhate

LOD, progressive mesh est peut etre aussi une solution à envisager.

Ben disons que la mise en place de ces techniques dans le cas présent n'est pas trop possible : comment simplifier la géométrie d'un cube ?

**lancer83** · 19/08/2006, 16h45

En gros j'appelle une méthode modéliser qui pour chaque clé d'une table de hashage va effecetuer la fonction suivante :

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
public void modeliserEtagereHorizontal(int dir, float coordX, float coordY, float coordZ)
		{
			float x = coordX , y = coordY , z = coordZ ;
			float yTemp = 0.0f;
			// Pour gérer les emplacement de différentes tailles.
			float xDiff = 0f, yDiff = 0f, zDiff = 0f;
			float xDiff2 = 0f, yDiff2 = 0f, zDiff2;
			float xBase = 0.0f, yBase = 0.0f, zBase = 0.0f;
			float diff = 0f, diff2 = 0f;
 
			//this.initialiserCoordonnes(coordX,coordY,coordZ);
			this.mesh = (Mesh)this.meshListe[this.numeroEmplacementMeshListe];
			Hashtable tableHashage;
			tableHashage = this.tableDeHashage.TableHashageEtag;
			Material mat = new Material();
 
			TableDeHashage.CodificationEmplacement codifEmpl = new TableDeHashage.CodificationEmplacement();
			TableDeHashage.Emplacement emplacement = new TableDeHashage.Emplacement();
			int indiceColonne = 0,indiceNiveau = 0;
			string etat = "";
 
 
			codifEmpl.allee = codifEtagere.allee;
			codifEmpl.zoneStockage = codifEtagere.zoneStockage;
 
 
			/** Parcours de la zone de l'entrepot choisie **/			
			#region Boucle de Modélisation
 
			for (indiceColonne = 0; (indiceColonne < this.nombreColonne) ; indiceColonne++)
			{
				for (indiceNiveau = 0; (indiceNiveau < this.nombreNiveau) ; indiceNiveau++)
				{									
					codifEmpl.colonne = indiceColonne;
					codifEmpl.niveau = indiceNiveau;
					emplacement = this.recupererEmplacement(indiceColonne, indiceNiveau);
					etat = emplacement.etat;
					if(emplacement.dimension.longueur != 0)
					{
						if((indiceColonne == 0) && (indiceNiveau == 0))
						{
							xBase = emplacement.dimension.longueur * 100;
							yBase = emplacement.dimension.largeur * 100;
							zBase = emplacement.dimension.profondeur * 100;
 
							// Permet de se posistionner sur le même niveau
							yTemp = (1.0f - yBase)/2;
							if(yTemp > 0)
								y = yBase - yTemp;
							else
								y = yBase + yTemp;
							this.initialiserCoordonnes(x,y,z);
						}
 
						xDiff = emplacement.dimension.longueur * 100;
						yDiff = emplacement.dimension.largeur * 100;
						zDiff = emplacement.dimension.profondeur * 100;
						this.initialiserTailleEmplacement(xDiff,yDiff,zDiff);
 
						switch(CritereMod)
						{
							case "etatEmplacement":
								if(etat != "")
								{			
									if(siCritereCkecked(etat))
									{
										mat.Diffuse = this.recupererCouleurEtatEmplacement(etat);	// On récupere la couleur correspondant à l'état de l'emplacement
										// Si en mode texture
										if(textureElem)
										{
											// Si etat vide on passe en mode "arrete"
											if(mat.Diffuse.Equals(matEmplVide.Diffuse))
												DirectxManager.DeviceD3D.RenderState.FillMode = FillMode.WireFrame;
											// Sinon en mode texture
											else
												DirectxManager.DeviceD3D.RenderState.FillMode = FillMode.Solid;
										}		
										else
										{
											DirectxManager.DeviceD3D.RenderState.FillMode = FillMode.Solid;
										}
									}
									else
									{
										mat.Diffuse = Color.White;
										DirectxManager.DeviceD3D.RenderState.FillMode = FillMode.Solid;
									}
									DirectxManager.DeviceD3D.RenderState.CullMode = Cull.CounterClockwise;
								}
								break;
 
							case "emplacementReserves":
								if(emplacement.reserve)
									mat.Diffuse = Color.Black;
								else
									mat.Diffuse = Color.White;
								break;
 
							case "classeAffectation":
								mat.Diffuse = emplacement.classeAffectation.couleurClasseAff;
								break;
 
							case "classeRotation":
								mat.Diffuse = emplacement.classeRotation.couleurClasseRot;
								break;
 
							case "codeArticle":
								if(emplacement.codeArticle.codeArt == fenetre.CodeArticleRecherche)
									mat.Diffuse = Color.Red;
								else
									mat.Diffuse = Color.White;
								break;
 
							case "codeFamilleArticle":
								mat.Diffuse = emplacement.codeFamilleArticle.couleurCodeFamilleArt;
								break;
						}
						DirectxManager.DeviceD3D.Material = mat;
 
 
 
 
						emplacement = this.recupererEmplacementSuivant(indiceColonne, indiceNiveau);
						if(emplacement.dimension.longueur != 0)
						{
							xDiff2 = emplacement.dimension.longueur * 100;
							yDiff2 = emplacement.dimension.largeur * 100;
							zDiff2 = emplacement.dimension.profondeur * 100;
						}
 
						if(indiceNiveau == 0)
						{
							z += (xDiff - xBase)/2;
							y += (yDiff - yBase)/2;													
						}
						Matrix WorldMatrix = Matrix.RotationYawPitchRoll(rotation.Y, rotation.X, rotation.Z);                        
						WorldMatrix *= Matrix.Translation(x, y, z);                        
						DirectxManager.DeviceD3D.Transform.World = WorldMatrix;
 
 
						diff2 = yDiff - yDiff2;			// Calcul de la différence en longueur
						diff2 = diff2 / 2;	
						if(diff2 > 0)
							y += this.largeurEmpl - diff2;
 
						else 
							if(diff2 < 0)
							y += this.largeurEmpl - diff2;
						else
							y += this.largeurEmpl;
 
 
						if(this.longueurEmpl != 0)
						{
							if(this.numeroEmplacementMeshListe < (this.nombreDEmplacements -1))
							{
								this.mesh.DrawSubset(0);
								this.numeroEmplacementMeshListe++;
								this.mesh = (Mesh)this.meshListe[this.numeroEmplacementMeshListe];
							}
						}
					}
 
				}
				diff = xBase - xDiff;			// Calcul de la différence en longueur
				diff = diff / 2;	
				if(diff > 0)
					x += (this.longueurEmpl *dir)+ diff;  // on décale en largeur		
				else
					x += (this.longueurEmpl *dir)- diff;  // on décale en largeur		
				y = coordOrd;
			}
			#endregion
		}

Dedans je définis la position de chaque meshBox, la couleur et le mode d'affichage ... tout ça dans le but de former mon étagère sans que les emplacement se chevauchent ...

Sinon comment faire du frustum culling ??
Merci

**funkydata** · 20/08/2006, 03h53

Oula !!! Oui ca doit ramer en effet

Ben déjà tu recréé à chaque itération tous les meshs

Crée ta géometrie une bonne fois pour toute à l'initialisation aprés tu n'auras qu'a gérer les transformations et l'affichage de tes subsets dans la boucle de rendu... C'est sur que si tu pars de zéro à chaque fois aucunes techniques ne te fera rendre ta scène plus vite !

**xterminhate** · 20/08/2006, 19h32

Envoyé par funkydata

Ben disons que la mise en place de ces techniques dans le cas présent n'est pas trop possible : comment simplifier la géométrie d'un cube ?

Quelle idée aussi des cubes....

**lancer83** · 21/08/2006, 11h57

Quelles sont les lignes qui sont gourmandes en ressources dans ma fonction qui font ralentir et qui peuvent être mises ailleurs ?

Pouvez vous m'aider à retirer ce qui ne devrait pas être dans mes "for" ??

Existe-t-il un logiciel permettant de savoir ça pour les cartes ATI ?
Merci.

[DX9][C#] Optimisation rendu

DirectX

Vue hybride

Discussions similaires

Partager

Partager