OpenGL - windings, cw of ccw?

[Anoniem: 55811]

Hallo,


Ik ben momenteel OpenGL aan het leren voor mijn examen. Ik zit aan een stukje over windings en had een paar vragen. Wanneer je een object maakt (driehoek, vierkant, ...) is het belangrijk of je de punten in cw of ccw volgorde zet (clockwise / counter clockwise).

- Nu vroeg ik mij af wat de standaard volgorde is van opengl, dus zonder dat je dit specifieerd?
- Is deze volgorde voor alle objecten hetzelfde (vierkant, driehoek, ...)?

Alvast bedankt

[Anoniem: 130503]

Ik meen uit een donker verleden dat OpenGL ccw werkt waarbij standaard back face culling wordt toegepast. Weet het eigenlijk 100% zeker. Dit is wel in het verkeerde forum en ik kan me gewoon *niet* voorstellen dat je dit met een beetje zoekwerk niet had kunnen vinden

Volgens mij kan je dit veranderen met glFrontFace()

[ Voor 37% gewijzigd door Anoniem: 130503 op 15-01-2005 16:54 ]

[Dark Blue]

Winding
An important characteristic of any polygonal primitive is illustrated in Figure 3.14. Notice the arrows on the lines that connect the vertices. When the first triangle is drawn, the lines are drawn from V0 to V1, then to V2, and finally back to V0 to close the triangle. This path is in the order that the vertices are specified, and for this example, that order is clockwise from your point of view. The same directional characteristic is present for the second triangle as well.

The combination of order and direction in which the vertices are specified is called winding. The triangles in Figure 3.14 are said to have clockwise winding because they are literally wound in the clockwise direction. If we reverse the positions of V4 and V5 on the triangle on the left, we get counterclockwise winding. Figure 3.15 shows two triangles, each with opposite windings.

Figure 3.15 Two triangles with different windings.

OpenGL, by default, considers polygons that have counterclockwise winding to be front facing. This means that the triangle on the left in Figure 3.15 shows the front of the triangle, and the one on the right shows the back side of the triangle.

Why is this issue important? As you will soon see, you will often want to give the front and back of a polygon different physical characteristics. You can hide the back of a polygon altogether or give it a different color and reflective property (see Chapter 5, "Color, Materials, and Lighting: The Basics"). It's important to keep the winding of all polygons in a scene consistent, using front-facing polygons to draw the outside surface of any solid objects. In the upcoming section on solid objects, we demonstrate this principle using some models that are more complex.

If you need to reverse the default behavior of OpenGL, you can do so by calling the following function:

code:

glFrontFace(GL_CW);

The GL_CW parameter tells OpenGL that clockwise-wound polygons are to be considered front facing. To change back to counterclockwise winding for the front face, use GL_CCW.

_bron

Wat je zegt, Quist. En dat terwijl ik op de setting van Unreal Tournament na werkelijk geen kaas heb gegeten van OpenGL

[Anoniem: 55811]

Blijkbaar werkt opengl ccw ja, maar wel alleen bij driehoeken, voor andere vormen (quad, polygon, etc) werkt opengl wel degelijk cw ... dus er zit wel een verschil in welke figuur je maakt ...

[Anoniem: 130503]

Had je dit nou niet zelf kunnen vinden? Zelfs een eenvoudige testcase had je al uitsluitsel kunnen geven...

[Anoniem: 4364]

Ik doe het altijd met glPolygonMode

bijv:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);


Opties zoals
GL_FRONT / GL_BACK and GL_FRONT_AND_BACK

voor de tweede
GL_POINT / GL_LINE and GL_FILL.

[edit]-----[edit]
maar over de vraag clockwise/counter clockwise,
ik gebruik altijd counter-clockwise, of het nu driehoeken/vierkanten zijn, of
een array met 10.000 vlakken.

En werkte veel met vertex/normal array`s,
en nu glInterleavedArrays aan het uitzoeken.

[ Voor 43% gewijzigd door Anoniem: 4364 op 15-01-2005 22:01 ]

[Anoniem: 105830]

Anoniem: 55811 schreef op zaterdag 15 januari 2005 @ 19:06:
maar wel alleen bij driehoeken, voor andere vormen (quad, polygon, etc) werkt opengl wel degelijk cw ... dus er zit wel een verschil in welke figuur je maakt ...

Quads en polys worden intern opgebroken in tri's dus het lijkt me niet dat er veel verschil in zit (zelf nog nooit wat van gemerkt iig).

[phaas]

Even OT: weet de TS mss een goede manier op OpenGL te leren voor de beginner? Misschien een goede internet tutorial om mee te starten of een boek? Ik heb iig (veel) C kennis, dus dat is het probleem niet

[Anoniem: 130503]

Phaas, afgezien het feit dat je nu heerlijk een topic aan het kapen bent, is er ook genoeg op internet te vinden. De tutorials van Jeff Molofee vind ik persoonlijk erg duidelijk (soms te duidelijk).

http://nehe.gamedev.net

[phaas]

Anoniem: 130503 schreef op zondag 16 januari 2005 @ 11:35:
Phaas, afgezien het feit dat je nu heerlijk een topic aan het kapen bent, is er ook genoeg op internet te vinden. De tutorials van Jeff Molofee vind ik persoonlijk erg duidelijk (soms te duidelijk).

http://nehe.gamedev.net

Bedankt
BTW, nu we toch gaan zeuren: hoort dit topic eigenlijk niet gewoon in Programming & Webscripting thuis?

[Dark Blue]

I wonder, want OpenGL heeft wel weer met 3D te maken en dat hoort weer hier. Ah, de modjes zullen wel een familieweekendje hebben...

[Anoniem: 4364]

download hier de gratis c/c++ compiler -> dev-c++
http://bloodshed.net/
(en download de tutorials van nehe (hierboven genoemd) En 'there you go')

Anyway, ikzelf zit veel graphics te coden of het nu java/shockwave/flash of C++/openGL is.
Meestal vanuit een puur grafische/animatie achtergrond.
Anyway dan zit je toch een beetje tussen /13 en /14 in.

[Soultaker]

Anoniem: 105830 schreef op zondag 16 januari 2005 @ 06:17:
Quads en polys worden intern opgebroken in tri's dus het lijkt me niet dat er veel verschil in zit (zelf nog nooit wat van gemerkt iig).

Maar als je een trianglestrip bouwt, dan zijn je driehoekjes technisch gezien afwisselend clockwise en counterclockwise opgebouwd. Dat is natuurlijk nooit de bedoeling, dus dat zal wel een uitzondering opleveren.

Anoniem: 4364 schreef op zaterdag 15 januari 2005 @ 21:52:
Ik doe het altijd met glPolygonMode

bijv:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

Dat is wel een erg lompe oplossing. In 99% van de gevallen heb je alleen een voorkant nodig, dus als je dan beide kanten erin laat kan dat flink in de performance schelen. Je kan dan beter twee minuten nadenken over wat je aan het doen bent en de polygonen de juiste kant op laten kijken, lijkt me.

[Anoniem: 4364]

@ soultaker;

voor transparante objecten doe ik bijv: front and back,
voor solid weer front

[Pelle]

Andere kant van de schutting \o/

[Creepy]

nehe.gamedev.net zijn zat OpenGL tuts te vinden. Daarnaast stikt het van de informatie op www.opengl.org en zijn er ook nog twee opengl bijbels: opengl bluebook en redbook.

Hoe te beginnen met OpenGL is nou niet echt een topic waard hier. De manier van punten specificeren (cw of ccw) is zelf in te stelen en ook vrij makkelijk zelf op te zoeken (iets wat DarkBlue laat zien ).