Voorkant 3D object bepalen

[lauwsa]

Hello iedereen,

Ik weet niet echt waar ik dit neer kan zetten, dit leek me de beste plaats.

Ik ben begonnen aan een D3D9 boek. Ik ben er net aan begonnen en ik heb al een vraag over iets dat onduidelijk is. Ze hebben het over het detecteren als een object van voren bekeken word. Alleen ik snap hun beredenatie niet. Ze zeggen:

"Als je het object met de klok mee nummers geeft aan elk punt, dan kan je daar aan zien als iets van de voor af achterkant bekeken word."



Als je dat dus doet krijg je dit:



Hun stelling als als volgt:

For example, the front face is made up of points P1, P4, P8 and P5. When viewed from in front of that
face this is a clockwise specification. It does not matter which vertex in the face begins the run. We
could have created the front face in this order: P8, P5, P1 and P4 and it would still work perfectly
because the order remains clockwise. This order is referred to as the polygon winding order. In
DirectX Graphics, polygons are assumed to have a clockwise winding by default (Fig 1.14) -- although
you can change this if desired.

Now look at the back face. It uses the vertex order P6, P7, P3 and P2. This is clearly counter-clockwise
so we will not draw it. Of course if we were to rotate the cube so that the back face was now facing us,
you would notice that the vertex order would then be clockwise.

Ik vind alleen 1 - 4 - 8 - 5 niet met de klok mee. Ik kan ook geen enkelen combinatie vinden hoe je deze kan zetten dat het met de klok mee gaat.

En als je dan naar de achter kant kijkt, 6 - 7 - 3 - 2. Dit vind ik ook niet echt aflopen. Hoe je het ook neer zet. Het enigste dat ik er uit kan opmaken wat ze misschien bedoelen is dat er 3 getallen zijn die aflopen of oplopen. Maar meer ook echt niet.

Ik heb ook al op Google gezocht. Het enige nuttige dat ik kan vinden is:

As you see, for every vertex we first define its position. Notice again that we have defined our vertices in a clockwise way, so DirectX will not cull them.

of

OpenGL face culling calculates the signed area of the filled primitive in window coordinate space. The signed area is positive when the window coordinates are in a counter-clockwise order and negative when clockwise. An app can use glFrontFace() to specify the ordering, counter-clockwise or clockwise, to be interpreted as a front-facing or back-facing primitive. An application can specify culling either front or back faces by calling glCullFace(). Finally, face culling must be enabled with a call to glEnable(GL_CULL_FACE); .

Maar nergens staat goed uitgelegd hoe het werkt.

In mijn boek staat het op de volgende manier:

So how does one determine which way a polygon is facing? After all, in our cube example, a face is
simply four points; we do not provide any directional information.

The answer lies in the order in which we store the vertices within our polygons. If you look at Fig 1.13
and then reference it against the code in LP 1.1, you will notice that the polygon vertices are passed in
using a clockwise order.

For example, the front face is made up of points P1, P4, P8 and P5. When viewed from in front of that
face this is a clockwise specification. It does not matter which vertex in the face begins the run. We
could have created the front face in this order: P8, P5, P1 and P4 and it would still work perfectly
because the order remains clockwise. This order is referred to as the polygon winding order. In
DirectX Graphics, polygons are assumed to have a clockwise winding by default (Fig 1.14) -- although
you can change this if desired.
Now look at the back face. It uses the vertex order P6, P7, P3 and P2. This is clearly counter-clockwise
so we will not draw it. Of course if we were to rotate the cube so that the back face was now facing us,
you would notice that the vertex order would then be clockwise.

BIj een driehoek zie ik het wel:


Zou iemand me kunnen uitleggen hoe dit nu zit?

Alvast bedankt!

[RobIII]

Euh; ik denk dat je 1 - 4 - 8 - 5 niet "op de klok" moet zoeken; de punten hadden net zo goed R, O, B, I of ♠,♣,♥,♦ kunnen heten. Het gaat er om dat die specifieke volgorde (1, 4, 8, 5 danwel R, O, B, I, danwel ♠,♣,♥,♦) kloksgewijs is; ofwel, als je een lijn zou trekken tussen die punten dan levert dat een 'clockwise' lijn op, geen 'counter-clockwise' lijn.

[ Voor 32% gewijzigd door RobIII op 22-11-2011 22:49 ]

[.oisyn]

lauwsa schreef op dinsdag 22 november 2011 @ 22:29:
Ik vind alleen 1 - 4 - 8 - 5 niet met de klok mee.

Waarom niet Als je de betreffende punten van de kubus in dat plaatje met elkaar verbindt met een potlood dan gaat je potlood toch echt met de klok mee over het papier. Zo dus: , en niet:

Met de klok mee en tegen de klok in zijn draairichtingen. Het heeft geen drol met de cijfers op een klok te maken (die overigens, niet geheel toevallig, ook met de klok mee oplopen ). Met de klok mee wordt ook wel rechtsom en tegen de klok in linksom genoemd. Die getallen zijn gewoon de indices van de vertices. Zoals Rob al zegt, je kan ze elk symbool geven, al is dat in de praktijk natuurlijk niet erg praktisch als werkt met 3D modellen van duizenden tot honderdduizenden vertices

[ Voor 62% gewijzigd door .oisyn op 22-11-2011 23:57 ]

[lauwsa]

Heel erg bedankt voor jullie antwoord. Het gaat dus om hoe je de lijn tekent.

Maar als je nu die kubes getekend hebt, dan kan je toch ook 6 - 2 - 3 - 7 met de klok mee tekenen. Alleen dan van binnen uit gezien. Je moet toch eigenlijk aan de waardes zien wat de voor of achter kant is. Want je geeft maar 1 keer de hoeken een "getal of teken" mee, en voor de rest kan je alles tekenen hoe je het maar wilt. Als het een vierkant is kan het altijd met de klok mee.

6 - 2 | 2 - 3 | 3 - 7 | 7 - 6

Op deze manier kan je er toch nooit achter komen dat 2 - 1 - 5 - 6 niet gezien word en 4 - 3 - 7 - 8 wel. Of word hier iets heel anders bedoeld? Dat je alleen de "texturer" tekent van de kanten die zichtbaar kunnen zijn?

Zoals, 1 - 4 - 8 - 5 is zichtbaar aan de voorkant maar niet aan de achterkant. Maar hoe je dat via deze methode kan zien zou ik ook niet weten .

[.oisyn]

lauwsa schreef op woensdag 23 november 2011 @ 08:07:
Heel erg bedankt voor jullie antwoord. Het gaat dus om hoe je de lijn tekent.

Maar als je nu die kubes getekend hebt, dan kan je toch ook 6 - 2 - 3 - 7 met de klok mee tekenen.

6-2-3-7 wel ja. Alleen de polygoon van de achterkant van de kubus wordt niet beschreven met 6-2-3-7 maar met 7-3-2-6 (of 3-2-6-7 of 2-6-7-3 of 6-7-3-2), want anders is ie, zoals je al opmerkt, verkeerd om. Het is de volgorde van punten die van belang zijn. Dit is de volgorde van punten waarin jij tegen de 3D api zegt "deze punten beschrijven mijn polygoon".

Oftewel, met een pseudo 3D api:

C++:

Vertex v[] = { /* 3d coordinaten van je 8 vertices */ };
DrawPolygon(v[7], v[3], v[2], v[6]);

Dit geeft een polygoon die vanaf de buitenkant van de kubus te zien is, niet vanaf de binnenkant. Met de orientatie zoals in het plaatje zal het dus niets tekenen, omdat hij juist naar achteren wijst. Als je de polygoon andersom wil tekenen, dan moet je de vertices van de polygoon omdraaien.

En ga maar na, als je de kubus in het plaatje omdraait en dus vanaf de achterkant naar de polygoon kijkt, dan zullen de volgorde van punten zijn veranderd van tegen de klok in naar met de klok mee. En dus is de polygoon dan zichtbaar.

In de praktijk zul je echter niet handmatig de polygonen tekenen, maar wordt je kubus beschreven door een datastructuur bestaande uit een lijst met vertices een lijst met indices. Elke 3 opeenvolgende indices beschrijven een driehoek van je model. Zoiets dus:

C++:

Vertex verts[] = { /* 3d coordinaten van je 8 vertices */ };
int indices[] = { /* ... */,    7, 3, 2,    3, 2, 6,    /* ... */ };

DrawIndexedPrimitive(TRIANGLELIST, verts, 8 /* aantal verts */, indices, 12 /* aantal driehoeken */);

De [7, 3, 2] en [3, 2, 6] beschrijven beide een helft van de achterste polygoon.

[ Voor 8% gewijzigd door .oisyn op 23-11-2011 10:45 ]

[lauwsa]

Bedankt, Ik denk dat ik het snap. Ik dacht dat er wat anders mee berijkt zou worden.

Je tekent op deze methode alleen de kanten die naar de gebruiker gericht zijn. Dus van het achterste vlak word van binnen dus ook getekent (2 - 3 - 7 - 6). De zijkanten worden op deze manier ook goed getekent. Want als je het scherm draait zodat het linker vlak naar jou toe komt (1 - 2 - 6 - 5) dan draait P2 zo dat hij kloks gewijs eerder komt dan P1, dit zelfde geld ook voor P5 en P6. Dus dan word het (2 - 1 - 5 - 6). Op deze manier word dus de rechterkant van rechts getekend en de linkerkant ook van rechts (Als je op de postitie staat in de afbeelding).

Ik dacht eerst dat de hele achterkant en de hele linkerkant niet getekend zou moeten worden.

Heel erg bedankt iedereen.

Edit:

Hier nog een keer het plaatje voor de overzicht:

[ Voor 8% gewijzigd door lauwsa op 23-11-2011 12:28 ]

[.oisyn]

lauwsa schreef op woensdag 23 november 2011 @ 12:21:
Ik denk dat ik het snap

Ik denk eerlijk gezegd dat je het nog niet helemaal snapt, gezien de alinea die volgt . Maar misschien is dat slechts een communicatie-iets

Je tekent op deze methode alleen de kanten die naar de gebruiker gericht zijn. Dus van het achterste vlak word van binnen dus ook getekent (2 - 3 - 7 - 6)

De binnenkant wordt alleen getekend als jij 2 - 3 - 7 - 6 daadwerkelijk hebt opgenomen in je lijst met polygonen. De bedoeling is niet dat je gaat uitvogelen of je de voorkant of de achterkant wilt tekenen. Je hebt gewoon een lijstje met polygonen, en die teken je - verder maak je je niet druk over welke je wel en welke je niet wilt tekenen. Dat doet de driver of GPU wel voor je (er is een handig wiskundig trucje om te bepalen of de volgorde van punten zoals die geprojecteerd zijn op je scherm CW (clockwise) of CCW (counter clockwise) zijn). Tevens kun je tegen de API zeggen dat je alleen CW of alleen CCW polygonen wilt tekenen. Of juist gewoon allemaal. Meestal kies je voor 1 optie voor ál je modellen en raak je de setting nooit meer aan, tenzij je specifiek hele modellen als "double-sided" wilt tekenen. Als je specifieke polygonen hebt in je model die double sided zijn, dan zorg je dat ze twee keer in je lijst met polygonen voorkomen - een CW en een CCW variant.

[lauwsa]

Ja idd, je moet eigelijk alleen maar mogelijk zichtbaren punten mee geven. Dat was ik even vergeten. Dat verklaart ook als je bij een spel door de map heen valt. Dat je dan overal door heen kunt kijken. Maar wanneer zou je dan CW en CCW bijden aan willen zetten? Of is dit als je bijvoorbeeld een spiegel wilt gebruiken waarmee je voor de gebruiker niet zichbaren dingen ook kunt zien?

Maar hoe doet de GPU dat dan? Of geeft de GPU zelf nummers aan elk deel als hij er naar toe gericht staat en kijkt dan als dit op of af loopt?

[CodeCaster]

lauwsa schreef op woensdag 23 november 2011 @ 12:47:
Maar wanneer zou je dan CW en CCW bijden aan willen zetten?

Sprites, bijvoorbeeld. Denk aan de platte bomen of verkeersborden uit de oude Need for Speed.

Ze worden afaik echter steeds minder gebruikt omdat de grafische kaarten steeds sneller worden en dus net zo makkelijk een full-fledged 3D-model kunnen renderen.

[.oisyn]

Maar je zult altijd platte polygonen blijven houden. Het is onzinnig om iets als een velletje papier of een blaadje van een boom een dikte mee te geven. Echter, in de regel blijf je gewoon van die culling instelling af, want je rendert niet maar 1 blaadje, maar een hele boom, en je wilt niet dat de boomstam ook doublesided wordt. En dus zorg je gewoon dat het blaadje gewoon 2 kanten heeft - 2 polygonen die op elkaar liggen maar tegenovergestelde kanten opwijzen.

[lauwsa]

Daar had ik nog niet aan gedacht. Heel erg bedankt voor de goeie uitleg.

[jvo]

.oisyn schreef op woensdag 23 november 2011 @ 12:32:
Tevens kun je tegen de API zeggen dat je alleen CW of alleen CCW polygonen wilt tekenen. Of juist gewoon allemaal.

Let wel dat je dat omgekeerd aangeeft. Je geeft aan welke polygonen je culled en dus niet tekent. Standaard staat dit op CCW, waarbij je dus CW tekent. Andere opties zijn CW, waarbij je CCW tekent, en NONE, waarbij je beide tekent.

[.oisyn]

De default is NONE overigens in D3D