Opacité d'un Polygon(GDI32)

**zizoufoot** · 04/04/2012, 23h24

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 :

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
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 :

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
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 :

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
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.

Opacité d'un Polygon(GDI32)

C++

Mode arborescent

Discussions similaires

Partager

Partager