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

  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Juin 2007
    Messages : 128
    Points : 70
    Points
    70
    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 éprouvé

    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
    Points : 1 086
    Points
    1 086
    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 régulier
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

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

  4. #4
    Membre éprouvé

    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
    Points : 1 086
    Points
    1 086
    Par défaut
    C'est un LONG (long int) donc il peut valoir entre –2147483648 et 2147483647.

  5. #5
    Membre régulier
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

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

  6. #6
    Membre éprouvé

    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
    Points : 1 086
    Points
    1 086
    Par défaut
    Par acquit de conscience, je placerais quand même un assert(Color>=-1) au début de PlotEdge PlotFace.

  7. #7
    Membre régulier
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

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

  8. #8
    Membre régulier
    Profil pro
    Inscrit en
    Juin 2007
    Messages
    128
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

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

  9. #9
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Septembre 2007
    Messages
    7 360
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 360
    Points : 23 600
    Points
    23 600
    Par défaut
    Citation Envoyé par zizoufoot Voir le message
    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.

+ 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, 10h35
  2. Comment detecter un polygon sous le curseur
    Par FreshVic dans le forum OpenGL
    Réponses: 2
    Dernier message: 04/07/2003, 11h48
  3. Triangulation de Polygones
    Par seb_lisha dans le forum DirectX
    Réponses: 1
    Dernier message: 01/07/2003, 13h40
  4. [Algo] Point à l'intérieur d'un polygone ?
    Par kebby dans le forum C++Builder
    Réponses: 5
    Dernier message: 23/05/2003, 14h22
  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, 11h39

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