IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Opacité d'un Polygon(GDI32)


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre très actif
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Juin 2007
    Messages : 128
    Par défaut 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 : 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.

  2. #2
    Membre émérite

    Profil pro
    Inscrit en
    Décembre 2008
    Messages
    533
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2008
    Messages : 533
    Par défaut
    Le test ligne 86 de PlotEdge n'est peut-être pas suffisamment précis.
    Que se passe-t-il si Color vaut -2 ?

  3. #3
    Membre très actif
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Juin 2007
    Messages : 128
    Par défaut
    Il ne peut pas valoir -2.
    Il vaut soit -1 soit une couleur RGB(r, g, b).

  4. #4
    Membre émérite

    Profil pro
    Inscrit en
    Décembre 2008
    Messages
    533
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2008
    Messages : 533
    Par défaut
    C'est un LONG (long int) donc il peut valoir entre –2147483648 et 2147483647.

  5. #5
    Membre très actif
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Juin 2007
    Messages : 128
    Par défaut
    Tout à fait, mais les seules valeurs qui lui sont fournies sont soit -1 soit RGB(r, g, b).

  6. #6
    Membre émérite

    Profil pro
    Inscrit en
    Décembre 2008
    Messages
    533
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2008
    Messages : 533
    Par défaut
    Par acquit de conscience, je placerais quand même un assert(Color>=-1) au début de PlotEdge PlotFace.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Transformer une ligne en polygone
    Par bl4d3 dans le forum Algorithmes et structures de données
    Réponses: 6
    Dernier message: 02/09/2003, 09h35
  2. Comment detecter un polygon sous le curseur
    Par FreshVic dans le forum OpenGL
    Réponses: 2
    Dernier message: 04/07/2003, 10h48
  3. Triangulation de Polygones
    Par seb_lisha dans le forum DirectX
    Réponses: 1
    Dernier message: 01/07/2003, 12h40
  4. [Algo] Point à l'intérieur d'un polygone ?
    Par kebby dans le forum C++Builder
    Réponses: 5
    Dernier message: 23/05/2003, 13h22
  5. une ligne et un polygone convexe
    Par rekam dans le forum Algorithmes et structures de données
    Réponses: 10
    Dernier message: 20/12/2002, 10h39

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo