[C++]Hidden surfaces met matrices

[Verwijderd]

Ik ben bezig met een simpele 3D engine (max 320x240 en monochroom), gebaseerd op matrices, en kom uit 1 ding nog niet uit; hoe haal je lijnen/punten weg die ergens achter liggen en dus niet zichtbaar zijn? Als voorbeeld neem ik ff dit testje:



Zoals je ziet zijn de vlakken 'doorschijnend' en dat wil ik dus voorkomen. Ik heb het een en ander zitten zoeken op google, maar een duidelijke uitleg over wat er nou bij komt kijken kan ik niet vinden. Blijkbaar zijn er 2 geschikte mogelijkheden; inverse matrices en Z-buffering. Maar hoe zit dit precies in elkaar? Ik wil hier graag meer over weten, dus als iemand bereid is uitleg te geven en/of een website met goede en duidelijke(!) weet, maak je mij een gelukkig man Ik werk in C++, dus wat code is altijd meegenomen, maar niet noodzakelijk. Als maar duidelijk is welke stappen erbij komen kijken.

[.oisyn]

als je backface culling toepast kom je al een heel eind, maar dat helpt je nog steeds niet voorkomen dat het doorschijnt

Je kunt dan idd een z-buffer implementeren, maar je moet dan wel de hele quads gaan tekenen, en niet alleen de lijntjes die eromheen zitten

.edit: of je kunt voor iedere pixel een straal terug naar het oogpunt schieten en kijken of ie door andere polygonen geraakt wordt, maar dat lijkt me een beetje inefficient

[ Voor 26% gewijzigd door .oisyn op 25-02-2003 11:29 ]

[Verwijderd]

Quads zijn de oppervlakte vierkantjes van elk vlak toch? Ik ben wat deze materie betreft een echte beginneling hoor 2 weken geleden werd m'n eerste regel matrix code ingetyped en ik heb net de beginselen een beetje onder de knie.
In iedergeval ga ik nu eens zoeken naar backface culling. Dat zal toch niet te lastig zijn lijkt me. Daarnaast is het dus noodzakelijk om de vlakken op te vullen (of iig ervan uit te gaan dat ze gevuld zijn).

[.oisyn]

Een quad is een quadilateral, wat staat voor een polygoon met 4 punten

Backface culling is dat je een quad die naar achteren gericht staat (dus dat je tegen de achterkant aan kijkt) niet tekent. Om te bepalen of ie naar achteren of naar voren gericht is kun je bepalen aan de hand van de z-coordinaat van de normaal. Een normaal van een vlak is zeg maar de richtingsvector van het vlak, dus waar het vlak heen 'kijkt'.

Om een normaal van een vlak te bepalen kun je het uitwendig product (kruisproduct / crossproduct) nemen van 2 willekeurige edges op het vlak (zolang de 2 edges maar niet in het verlengde van elkaar liggen)

[Verwijderd]

Als ik het goed begrijp is wat je in je post hierboven schrijft dus makkelijker te doen dan een inverse transformatie?
Dus als de z-coordinaat van de normaal van de camera af gericht is, moet het vlak niet getekend worden.

Je legt het overigens heel duidelijk uit! Zo ga ik het nog snappen ook

[Verwijderd]

Als je net met 3D begint zoals je zelf zegt kun je het best investeren in dit boek (of naar de bieb gaan ) :

Principles and Practice in Computer Graphics (dacht ik)
Foley & Van Dam

Daar staat zo'n beetje alles in uitgelegd wat je maar wilt weten over 3D basiskennis.
(Dus geen pixelshader-asm etc - gewoon de theorie achter clippen, cullen, transformeren, belichting etc.)

-- Edit: Jezus, spellen schijnt echt een probleem voor me te zijn zeg..

[ Voor 47% gewijzigd door Verwijderd op 25-02-2003 14:00 ]

[.oisyn]

Computer Graphics, Principles and Practice in C (2nd edition)
Foley, Van Dam, Feiner, Hughes
ISBN: 0-201-84840-6

er was ooit een 3e editie gepland voor jan. 2000, maar die was toen verplaatst naar jan. 2001, en nu kan ik er helemaal niets meer over terug vinden

[Verwijderd]

Zoals reeds gezegd gaat backface culling slechts gedeeltelijk helpen, bepaalde vlakken zullen nog steeds zichtbaar zijn door andere vlakken heen. Voor een volledige oplossing met je huidige implementatie is hoogstwaarschijnlijk een beamtree achtig algoritme nodig, dit kost echter zeer veel rekenwerk.

Mocht je de quads op gaan vullen dan kun je gebruik maken van overdraw. In essentie zorg je er dan voor dat iedere pixel alleen opgevuld wordt wanneer deze dichter bij de camera ligt dan de vorige pixel waarde (een z-buffer dus), dit effect kan ook bereikt worden door de quads van achter naar voren te renderen, dan is geen z-buffer nodig.

Wil je het nog een stap verder nemen, dan kun je de quads sorteren van voor naar achteren en gebruik maken van een span-buffer, dit werkt (vooral met grote quads) aanzienlijk sneller dan een z-buffer. Hierbij ga je hele rijen pixels vergelijken met rijen die al in de framebuffer staan.

[Verwijderd]

Een boek zou idd geen verkeerd idee zijn Aangezien jullie bovenstaand boek aanraden, neem ik aan dat het een handig boek is waar je ook echt wat aan hebt. Eens kijken wat het kost.

Inmiddels ben ik alweer een stukje verder. De backface culling werkt nu prima, maar zoals Cheesehead al aangaf, voorkomt het niet dat overlappende vlakken door elkaar heen zichtbaar zijn. Om dat op te lossen, wil ik een z-buffer gaan gebruiken, maar dat is voor morgen De andere opties is misschien iets voor de toekomst, maar voorlopig is een z-buffer meer dan genoeg voor de simple engine waar ik mee bezig ben.

[Verwijderd]

Is het mogelijk om de Z waarde van een punt te berekenen op de een of andere manier? Het zit zo; je hebt het model, gooit daar wat matrix rekenen overheen (scaling, rotation en als laatste de projection), vervolgens worden alle lijnen getekend.
Van punt A(x, y) naar punt B(x, y). De pixels op de te tekenen lijn krijgen dus geen z-coordinaat mee. Kan deze berekend worden (lineaire interpolatie?) en zo ja hoe?

PS, dat boek is wel een behoorlijke overkill voor dat beetje wat ik wil... heb bij Amazon de index door gelezen.

edit: op punt A en B zelf is ook geen z-coordinaat beschikbaar. Dit alles is na het vermenigvuldigen met de projection/perspective matrix.

[ Voor 26% gewijzigd door Verwijderd op 26-02-2003 12:23 ]

[Verwijderd]

Je kunt de z waarden interpoleren over de lijnen. Wat je doet is het volgende: Je past alle transformaties behalve de projectie toe, vervolgens projecteer je de punten op het platte vlak en bewaar je het z-coordinaat van voor de projectie (je hebt dan nog steeds een 3-dimensionale vector). Deze z-waarde kun je vervolgens interpoleren over de lijnen van het vlak (edges) om deze vervolgens ook nog een keer horizontaal te interpoleren over de spans in het vlak (maar ik weet niet of je al zo ver bent).

[.oisyn]

als het goed is heb je nog altijd je z-coordinaat, en anders doe je iets verkeerd

.edit: vergeet trouwens niet dat je 1/z waarden moet interpoleren, aangezien z niet lineair loopt in screen space

[ Voor 42% gewijzigd door .oisyn op 26-02-2003 12:44 ]