Opacité d'un Polygon(GDI32)

Bonjour,

J'ai un code écrit en C++ sous la main que je ne peux malheureusement pas distribuer en entier.

Le programme en question dessine des éléments en assemblant des polygones.
Ces éléments peuvent être déplacer dans l'espace.

Le soucis vient du fait que lorsque un élément est dessiné, la face frontale est opaque, mais lorsque l'on déplace cet élément dans l'espace, on voit l'intérieur de l'élément.
Je vais donner un exemple : Un cube.
-Le cube est dessiné
-La face frontale est opaque
-Lorsque l'on tourne le cube, on peut voir les faces/arrêtes opposés, qui ne devraient pas apparaître.

Voici la partie du code qui s'occupe de ça :

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
HRESULT __declspec (dllexport) __stdcall PlotSolids(NODE   Nodes[], short nNodes, 
													SOLID Solids[], short nSolids,
													FACE Faces[], long nFaces, 
													short UserColor[],
													VARIANT_BOOL Displace, 
													short scale, 
													VARIANT_BOOL IgnoreCulled, 
													VARIANT_BOOL NodesNumbering, 
													VARIANT_BOOL ElementsNumbering, 
													VARIANT_BOOL ElementsOnScreen,
													VARIANT_BOOL PlotFrontiers, 
													VARIANT_BOOL PlotMaterials,
													VARIANT_BOOL NodesOnScreen, 
													VARIANT_BOOL ContourOnScreen,
													LPVIEWPORT lpViewport, 
													LPWINDOW lpClipRect, 
													LPMATRIX3D Projector, 
													HDC hDC)
{
 
	long    Face;
	int     F;
	long   Solid;
	long   Node1, Node2, Node3, Node4;
	long    lColor;
	BOOL    SetColor, Problem2D;
	LPSTR   lpszString;
	char    buffer[16];
	int     nPoints;
	POINT2D poly2d[4];
	POINT2D pt1, pt2;
 
	SetBkMode(hDC, TRANSPARENT);
 
        -------------Blablabla, rien dintéressant-----------------------
        Pour toutes les faces de lélément :
        PlotFace(Nodes, Faces, Face, Displace, scale, lpszString, 0, lColor, lpViewport, lpClipRect, hDC);

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
130
131
132
133
long __stdcall PlotFace(NODE Nodes[], FACE Faces[], long Face, VARIANT_BOOL Displace, short scale, 
						LPSTR lpszString, short NoEdge,
						LONG Color, LPVIEWPORT lpViewport, LPWINDOW lpClipRect, HDC hDC)
{
	long Node1, Node2, Node3, Node4;
	long tempColor;
	int nEdges;
	POINT2D rcoords[4];

	tempColor = Color;

    if (!Faces[Face - 1].Culled)
	{
		Node1 = Faces[Face - 1].Node[0];
		Node2 = Faces[Face - 1].Node[1];
		Node3 = Faces[Face - 1].Node[2];
		Node4 = Faces[Face - 1].Node[3];
		if (Displace == false) {
			if (Node4 == 0)
			{
				nEdges = 3;
				rcoords[0].X = Nodes[Node1 -1].TransX;
				rcoords[0].Y = Nodes[Node1 -1].TransY;
				rcoords[1].X = Nodes[Node2 -1].TransX;
				rcoords[1].Y = Nodes[Node2 -1].TransY;
				rcoords[2].X = Nodes[Node3 -1].TransX;
				rcoords[2].Y = Nodes[Node3 -1].TransY;
			}
			else
			{
				nEdges = 4;
				rcoords[0].X = Nodes[Node1 -1].TransX;
				rcoords[0].Y = Nodes[Node1 -1].TransY;
				rcoords[1].X = Nodes[Node2 -1].TransX;
				rcoords[1].Y = Nodes[Node2 -1].TransY;
				rcoords[2].X = Nodes[Node3 -1].TransX;
				rcoords[2].Y = Nodes[Node3 -1].TransY;
				rcoords[3].X = Nodes[Node4 -1].TransX;
				rcoords[3].Y = Nodes[Node4 -1].TransY;
			}
		}
		else {
			if (tempColor == -1) {
				tempColor = RGB(128,128,128);
			}
			if (Node4 == 0)
			{
				nEdges = 3;
				rcoords[0].X = scale * Nodes[Node1 -1].Displacement[0] + Nodes[Node1 -1].TransX;
				rcoords[0].Y = scale * Nodes[Node1 -1].Displacement[1] + Nodes[Node1 -1].TransY;
				rcoords[1].X = scale * Nodes[Node2 -1].Displacement[0] + Nodes[Node2 -1].TransX;
				rcoords[1].Y = scale * Nodes[Node2 -1].Displacement[1] + Nodes[Node2 -1].TransY;
				rcoords[2].X = scale * Nodes[Node3 -1].Displacement[0] + Nodes[Node3 -1].TransX;
				rcoords[2].Y = scale * Nodes[Node3 -1].Displacement[1] + Nodes[Node3 -1].TransY;
			}
			else
			{
				nEdges = 4;
				rcoords[0].X = scale * Nodes[Node1 -1].Displacement[0] + Nodes[Node1 -1].TransX;
				rcoords[0].Y = scale * Nodes[Node1 -1].Displacement[1] + Nodes[Node1 -1].TransY;
				rcoords[1].X = scale * Nodes[Node2 -1].Displacement[0] + Nodes[Node2 -1].TransX;
				rcoords[1].Y = scale * Nodes[Node2 -1].Displacement[1] + Nodes[Node2 -1].TransY;
				rcoords[2].X = scale * Nodes[Node3 -1].Displacement[0] + Nodes[Node3 -1].TransX;
				rcoords[2].Y = scale * Nodes[Node3 -1].Displacement[1] + Nodes[Node3 -1].TransY;
				rcoords[3].X = scale * Nodes[Node4 -1].Displacement[0] + Nodes[Node4 -1].TransX;
				rcoords[3].Y = scale * Nodes[Node4 -1].Displacement[1] + Nodes[Node4 -1].TransY;
			}
		}
		
		if (Displace) {
			if(Node4 == 0)
			{
				PlotEdge(Nodes, Node1, Node2, RGB(255,0,0), lpViewport, lpClipRect, hDC);
				PlotEdge(Nodes, Node2, Node3, RGB(255,0,0), lpViewport, lpClipRect, hDC);
				PlotEdge(Nodes, Node3, Node1, RGB(255,0,0), lpViewport, lpClipRect, hDC);
			}
			else
			{
				PlotEdge(Nodes, Node1, Node2, RGB(255,0,0), lpViewport, lpClipRect, hDC);
				PlotEdge(Nodes, Node2, Node3, RGB(255,0,0), lpViewport, lpClipRect, hDC);
				PlotEdge(Nodes, Node3, Node4, RGB(255,0,0), lpViewport, lpClipRect, hDC);
				PlotEdge(Nodes, Node4, Node1, RGB(255,0,0), lpViewport, lpClipRect, hDC);
			}
		}

		if(Color == -1)
		{
			if(Node4 == 0)
			{
				if (Displace) {
					PlotDisplacedEdge(Nodes, Node1, Node2, scale, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotDisplacedEdge(Nodes, Node2, Node3, scale, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotDisplacedEdge(Nodes, Node3, Node1, scale, RGB(128,128,128), lpViewport, lpClipRect, hDC);
				}
				else {
					PlotEdge(Nodes, Node1, Node2, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotEdge(Nodes, Node2, Node3, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotEdge(Nodes, Node3, Node1, RGB(128,128,128), lpViewport, lpClipRect, hDC);
				}
			}
			else
			{
				if (Displace) {
					PlotDisplacedEdge(Nodes, Node1, Node2, scale, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotDisplacedEdge(Nodes, Node2, Node3, scale, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotDisplacedEdge(Nodes, Node3, Node4, scale, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotDisplacedEdge(Nodes, Node4, Node1, scale, RGB(128,128,128), lpViewport, lpClipRect, hDC);
				}
				else {

					PlotEdge(Nodes, Node1, Node2, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotEdge(Nodes, Node2, Node3, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotEdge(Nodes, Node3, Node4, RGB(128,128,128), lpViewport, lpClipRect, hDC);
					PlotEdge(Nodes, Node4, Node1, RGB(128,128,128), lpViewport, lpClipRect, hDC);
				}
			}
		}
		else
		{
			if (NoEdge)
				PlotPolygon(lpClipRect, lpViewport, hDC, rcoords, nEdges, tempColor, tempColor);
			else {
---------------Cest ici que ça se passe-----------------------
				PlotPolygon(lpClipRect, lpViewport, hDC, rcoords, nEdges, tempColor, RGB(128,128,128));
			}
		}
		
		//if (lpszString != "")
			//TextonFace(lpszString, nEdges, rcoords, lpViewport, lpClipRect, hDC);
	}
	
	return 0;
}

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
long __stdcall PlotPolygon(LPWINDOW lpClipRect, LPVIEWPORT lpViewport, HDC hDC, POINT2D LogicalCoords[], int nPoints, long FillColor, long EdgeColor)
{
	HBRUSH  hBrush, hOldBrush;
	HPEN    hPen, hOldPen;
	LONG    lRet;
	POINT   DeviceCoords[10];
	POINT2D ClipPoly[10];
	int    np;
 
	np = ClipPolygon((short)nPoints, LogicalCoords, ClipPoly, lpClipRect);
	if (np != 0)
	{
		TransformLPtoDP(lpViewport, np, ClipPoly, DeviceCoords);
 
		hBrush = CreateSolidBrush(RGB(209, 95, 238));
		hOldBrush = (HBRUSH)SelectObject(hDC, hBrush);
		hPen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
		hOldPen = (HPEN)SelectObject(hDC, hPen);
 
		lRet = Polygon(hDC, DeviceCoords, np);
 
		SelectObject(hDC, hOldPen);
		lRet = DeleteObject(hPen);
 
		SelectObject(hDC, hOldBrush);
		lRet = DeleteObject(hBrush);
	}
	return S_OK;

Grosso modo, il fait ceci :
pour chaque faces de l'élément(premier code) :
- On enregistre les coordonnées des noeuds de la face(deuxième code) et on enregistre ça dans une matrice de points 2D(deuxième code)
- On dessine la face(troisième code)

Le pire, c'est que les faces sont dessinées, on voit leur surface, contour..
Et dans un certain cas particulier, des éléments sont bien dessinés, avec opacité complète. Mais je n'ai pas vu de différence de traitement entre ces éléments et ceux qui buggent.

Je sais que ça risque d'être difficile pour vous de me dire "où se trouve le problème". Je ne suis pas venu pour ce genre de réponse, mais plus pour une réponse du style "regarde du côté de ..", "essaye de ..".

Merci encore :)

Je vous prie de croire en mes salutations les plus distinguées,

Moi.

Le test ligne 86 de PlotEdge n'est peut-être pas suffisamment précis.
Que se passe-t-il si Color vaut -2 ?

Il ne peut pas valoir -2.
Il vaut soit -1 soit une couleur RGB(r, g, b).

C'est un LONG (long int) donc il peut valoir entre –2147483648 et 2147483647.

Tout à fait, mais les seules valeurs qui lui sont fournies sont soit -1 soit RGB(r, g, b).

Par acquit de conscience, je placerais quand même un assert(Color>=-1) au début de ~~PlotEdge~~ PlotFace.

De toute manière, ça ne vient pas de la couleur.
J'ai remplacer cette variable par une constante et le problème est le même.

Ca y est, j'ai trouvé. Après 10h dessus, j'ai trouvé.. grâce à mon chien.

Un élément est dessiné grâce à l'assemblage de polygones.
Or, comme dit précédemment, seule la face frontale est dessinée opaque(va savoir pourquoi..).
Puis j'ai vu mon chien qui essayait de se mordre la queue. Et en le voyant tourner sur lui même, je me suis dis : MAIS OUIII ! En tournant l'élément, la fonction redessine l'élément. Mais si il redessine et que seule la face frontale est opaque, il suffit qu'à chaque fois qu'il redessine je change l'ordre des faces et que je dise au programme que la face frontale est celle que je suis en train de visionner.

Pourquoi ça le faisait sur certains éléments et pas d'autres est du au fait que certains éléments n'avaient pas besoin d'un ordre d'affichage des faces.

J'aime mon chien !

Citation:

Envoyé par zizoufoot

Or, comme dit précédemment, seule la face frontale est dessinée opaque(va savoir pourquoi..).

Ça fait dix ans que je n'ai pas touché à la GDI mais dans le monde de la 3D à polygones, c'est très souvent le cas. C'est dû au fait que l'assemblage de polygones consécutif est censé composer une surface qui — elle — se replie sur elle-même pour former l'objet en 3D. Il est donc normal, dans cette vision des choses, de ne s'intéresser qu'au côté extérieur d'un polygone car l'autre est censé faire partie d'un volume plein. Sinon, suivant cette même philosophie, si un polygone avait deux faces, il faudrait s'intéresser à « l'épaisseur » de ton polygone, ce qui n'aurait pas de sens.

Bien sûr, on peut demander à le faire quand même mais, dans ce cas, il s'agit en fait d'ignorer toute notion d'orientation de ton polygone.