Het is een standaard grafische applicatie voor 2D- en 3D-visualisatie, ontwikkeld in 1992. Opengl is verkrijgbaar in twee smaken. De eerste hiervan is "Microsoft OpenGL", die vaak in Windows wordt meegeleverd voor het installeren van een grafische kaart. De tweede – Cosmo OpenGL – is bedoeld voor systemen die niet over een versnelde videokaart beschikken. De OpenGL-bibliotheek is de belangrijkste vereiste om de applicatie te laten werken.

OpenGL-gebruikersrecensie

Vóór OpenGL moest elk bedrijf dat een grafische applicatie ontwikkelde de graphics voor elk besturingssysteemplatform herschrijven. Hiermee kun je dezelfde effecten op verschillende manieren creëren besturingssystemen ah, gebruik er een grafische adapter, ter ondersteuning van het programma. OpenGL specificeert een reeks “opdrachten” of onmiddellijk uitvoerbare functies, die elk de tekenactie aansturen of speciale effecten veroorzaken. Er kan een lijst van worden gemaakt voor herhalende effecten.

OpenGL is onafhankelijk van de Windows-kenmerken van elk besturingssysteem, maar biedt besturingssysteemspecifieke routines. Het wordt geleverd met een enorme lijst met ingebouwde functies die via de API worden aangevraagd. Deze omvatten:

• verborgen verwijdering oppervlakken;
• alpha-blend (transparantie);
• gladmaken;
• textuurtoewijzing;
• pixelbewerkingen;
• transformaties bekijken en modelleren;
• atmosferische effecten (mist en nevel).

Silicon Graphics - ontwikkelaars van geavanceerde grafische werkstations - startte de ontwikkeling van OpenGL. DEC, Intel, IBM, Microsoft en Sun Microsystems zitten in het beoordelingspanel voor de industriële architectuur. Er zijn geen kosten verbonden aan het ontwikkelen van applicaties die de OpenGL API gebruiken, afgezien van training. Microsoft biedt gratis downloaden haar bibliotheken voor hun systemen.

Set modules voor Windows

De applicatie is beschikbaar op veel Win32- en Unix-systemen. En f90gl is een implementatie in het publieke domein officiële betrekkingen Fortran 90 voor OpenGL, ontworpen als een database met modules en bibliotheken die definieert vereiste interfaces voor programmafunctionaliteit. f90gl zelf is ontwikkeld door William F. Mitchell van het Heitherberg Institute of Technology in de VS. Tot voor kort kon OpenGL LF9x alleen worden gemaakt als statisch gekoppelde programma's gericht op Visual C.

Dankzij de inspanningen van Lawson B. Wakefield uit Groot-Brittannië is er nu een veel vriendelijkere methode beschikbaar. Deze implementatie maakte de OpenGL-interface beschikbaar binnen WiSK en Winteracter en gebeurde op vrijwillige, niet-commerciële basis. Om de OpenGL-bibliotheek op te nemen, hebt u bepaalde OpenGL DLL's nodig die in de Windows SYSTEM32-map zijn geïnstalleerd. Deze omvatten het volgende:

• opengl32.dll;
• glu32.dll;
• glut32.dll.

De eerste twee van deze OpenGL-bibliotheken (u moet ze bestuderen voordat u ze installeert) zijn standaard onderdeel van Windows verschillende wijzigingen en ik. De f90gl-bibliotheken en modules moeten worden geïnstalleerd in de LF95 LIB-directory:

• F90GL.LIB;
• F90GLU.LIB;
• F90GLUT.LIB;
• OPENGL32.LIB;
• GLU32.LIB;
• GLUT32.LIB;
• OPENGL.MOD;
• OPENGL2.MOD;
• OPENGL_KINDS.MOD;
• OPENGL_GLINTERFACES.MOD;
• OPENGL_FWRAP.MOD;
• OPENGL_GLUINTERFACES.MOD;
• OPENGL_GLU.MOD;
• OPENGL_GLUTINTERFACES.MOD;
• OPENGL_GLUT.MOD;
• OPENGL_GL.MODd.

Het compileren en koppelen van f90gl-programma's vereist dat de LF95 LIB-directory wordt opgegeven in het compilermodulepad en de namen van de f90gl-bibliotheken waarnaar moet worden gelinkt.

Beeldbibliotheken

DevIL wordt gebruikt voor ontwikkelaars. Het ondersteunt meerdere beeldformaten voor lezen en schrijven, verschillende compilers en besturingssystemen (Windows, Linux, Mac). De bibliotheek heeft de volgende syntaxis:

1. FreeImage is een platformonafhankelijke OpenGL-bibliotheek voor het laden van afbeeldingen met ondersteuning voor zeer brede formaten (inclusief enkele HDR-formaten zoals OpenEXR).
2. OpenImageIO (OIIO) is een bibliotheek voor het lezen en schrijven van afbeeldingen, samen met vele gerelateerde klassen, hulpprogramma's en toepassingen. Wordt veel gebruikt in animatie- en VFX-studio's over de hele wereld, en is ook ingebouwd in verschillende commerciële producten.
3. SOIL is een platformonafhankelijke beelddownloader openbaar gebruik, wat uiterst klein is. C++ kan worden geladen DDS-texturen(DDS9 en DDS10) door MIT-licenties.
4. Glraw biedt een opdrachtregelprogramma dat afbeeldingsbestanden omzet in onbewerkte bestanden, die rechtstreeks eenvoudige textuurgegevens bevatten.

3D-bestandsmiddelen importeren

De OpenGL grafische bibliotheek voor het importeren van assets (Assimp) wordt gepresenteerd als een bibliotheek voor het importeren van een verscheidenheid aan populaire 3D-modellen. De nieuwste versie exporteert 3D-bestanden en is geschikt als converter algemeen doel. Er zijn verschillende soorten van dergelijke bibliotheken:

1. Kan lezen verschillende formaten 3D-bestanden - COLLADA, eigen bestanden Blender3D, Wavefront Obj (.obj) en vele anderen. De lib3ds-bibliotheek is ontworpen voor het lezen van 3ds-bestanden.
2. Open3mod is een op Windows gebaseerde modelviewer. Het laadt alle bestandsformaten die Assimp ondersteunt en ideaal voor is snelle controle 3D-middelen.
3. AssetKit (In Progress) is een OpenGL-bibliotheek voor het importeren/exporteren van 3D-middelen, een hulpprogramma gebaseerd op de COLLADA/glTF-specificaties. De nadruk ligt hier vooral op COLLADA en glTF. Het ondersteunt de formaten 1.4, 1.4.1, 1.5+ en enkele andere volledig als bibliotheek voor het laden van modellen in OpenGL.

Hoogwaardige 2D/3D-graphics

De OpenGL grafische bibliotheek voor Android biedt ondersteuning voor krachtige 2D- en 3D-graphics met bibliotheek openen, in het bijzonder de OpenGL ES API. Android ondersteunt het via zowel de infrastructuur-API als de Native Development Kit (NDK). Het platform van het genoemde besturingssysteem heeft twee fundamentele klassen waarmee u afbeeldingen kunt maken en manipuleren met behulp van de API: GLSurfaceView en GLSurfaceView.Renderer.

Als het doel is om OpenGL in een Android-applicatie te gebruiken, dan moet je begrijpen hoe je deze klassen in actie kunt implementeren. GLSurfaceView kan dus objecten tekenen en manipuleren met behulp van OpenGL API-aanroepen, vergelijkbaar met de SurfaceView-functie. Deze interface definieert de methoden die nodig zijn om afbeeldingen naar een GLSurfaceView te tekenen. En de gebruiker moet een implementatie van deze interface als een aparte klasse leveren en een exemplaar van GLSurfaceView.setRenderer aan de GLSurfaceView koppelen. Zodra u een containerweergave voor OpenGL ES, GLSurfaceView en GLSurfaceView.Renderer heeft gemaakt, kunt u beginnen met het verbinden van de OpenGL-bibliotheek en het gebruiken van de API.

Mobiele grafische apparaatset

Applicatie-implementaties variëren per Android-apparaat wat betreft de API-extensies die ze ondersteunen en omvatten textuurcompressie en een andere reeks functies. Android Extension Pack (AEP) ondersteunt een standaardbasis van extensies. Door ze samen te voegen, wordt consistente functionaliteit op alle apparaten bevorderd, waardoor ontwikkelaars optimaal kunnen profiteren van het nieuwste mobiele grafische ontwerppakket.

AEP verbetert ook de ondersteuning voor afbeeldingen, shader-opslagbuffers en tellers. Als een applicatie AEP wil gebruiken, moet de platformversie dit ondersteunen. Verder dient u de AEP-eis als volgt aan te geven:<использует функцию android: name = "android.hardware.opengles.aep" android: required = "true" />

Controleren en selecteren van de OpenGL ES-versie

Er zijn verschillende versies van de applicatie beschikbaar op Android-apparaten. U kunt de minimale API-versie opgeven die de applicatie op uw telefoon vereist. opengl ES API versie 1.0, versie 2.0 en versie 3.0 bieden krachtige GUI's voor het maken van 3D-games, renderings en gebruikersinterfaces. Het programma voor OpenGL ES 2.0 is in veel opzichten vergelijkbaar met versie 3.0, een superset van de 2.0 API met extra functionaliteit.

Het programmeren voor de 1.0/1.1 API is aanzienlijk anders dan voor 2.0 en 3.0, en daarom moeten ontwikkelaars verschillende factoren zorgvuldig overwegen voordat ze met de ontwikkeling met deze API's beginnen. Over het algemeen bieden 2 en 3 dus snellere grafische prestaties dan API ES 1/1.1. Het verschil kan echter variëren afhankelijk van Android-apparaten, waarop de applicatie draait, vanwege verschillen in de hardware-implementatie van de grafische pijplijn.

Vergelijking met DirectX-stuurprogramma's

Op Windows worden grafische stuurprogramma's van DirectX beter ondersteund dan OpenGL, ook al draaien ontwikkelaars snellere stuurprogramma's.

De OpenGL- en DirectX-bibliotheken (hun geschiedenis en vooruitzichten) worden geassocieerd met Microsoft, dat zich feitelijk tegen OpenGL verzette. In 2003 verklaarde Microsoft dat het niet langer geïnteresseerd was in OpenGL-abonnementen. Vervolgens legden ze in 2005 tijdens een presentatie bij SIGGRAPH een verklaring af Windows Vista zal zijn steun wegnemen.

Deze campagne veroorzaakte chaos in de OpenGL-gemeenschap, waarna veel professionele grafische programmeurs overstapten op DirectX. Nadat Vista eindelijk was uitgebracht, werden de grote claims niet opgevolgd: leveranciers creëerden nieuwe performance drivers (ICD's) die de ingebouwde functionaliteit herstelden. Open verzonden nieuwsbrieven met informatie die nog actueel is beste app. De schade was echter al aangericht en het vertrouwen van het publiek in OpenGL was ernstig beschadigd.

OpenGL is zelfs krachtiger dan DirectX, ondersteunt meer platforms en is essentieel voor de toekomst van gaming. De geschiedenis en vooruitzichten van de OpenGL- en DirectX-bibliotheken geven aan dat de eerste nog steeds positievere aspecten heeft:

1. Biedt de mogelijkheid om grafische functies te gebruiken besturingssystemen, terwijl DirectX er in de nieuwste versies van Windows alleen directe elementen van biedt. De tessellation-technologie die Microsoft voor DirectX 11 ontwikkelt, is al drie jaar een uitbreiding van OpenGL. Door nauwgezet werk is het mogelijk geworden om ervoor te zorgen dat DirectX 10 en 11 nu net zo snel werken als OpenGL en bijna evenveel functies ondersteunen. Er is er echter één groot probleem: Ze werken niet op Windows XP, dat veel mensen nog steeds gebruiken.
2. Platformonafhankelijk. Veel Lugaru-gebruikers draaien op Mac, Linux en Windows XP en kunnen niet via DirectX spelen. De enige manier om de nieuwste graphics te leveren voor Windows-gamers XP - via 32bits opengl-bibliotheken.
3. Beter voor de toekomst van gaming. Het is een niet-commerciële, open standaard die is gemaakt om ervoor te zorgen dat gebruikers op elk platform de hoogwaardige grafische weergave van hun hardware kunnen ervaren. De ontwikkeling ervan wordt vandaag vernietigd door de monopolistische aanval van de bedrijfsgigant die de industrie probeert te domineren. Dit is de reden waarom Direct3D de enige grafische gaming-API wordt die op Windows wordt ondersteund.

C++ en Visual Studio-installatie

De OpenGL-bibliotheek voor c heeft gratis versie. Experts raden aan om programma's te compileren die zijn geschreven in ANSI C met OpenGL en GLUT met behulp van Dev-C++.

Bloedvergieten Dev-C++ is gratis compiler C++ en ontwikkelomgevingen voor besturingssystemen Windows-systemen. Net als de meeste andere hardware kan het worden gebruikt om ANSI C te compileren. Zodra de GLUT-headerbestanden en -bibliotheken zijn geïnstalleerd, kan het worden gebruikt om programma's te schrijven. Om dit project te implementeren, kunt u 32-bits of 64-bits Windows gebruiken.

Voordat je de OpenGL-bibliotheek met devc verbindt, heb je de glew-headers nodig, die je kunt vinden op de sourceforge Extension Wrangler-website, en een versie van freeglut voor Visuele Studio:

1. Klik op de link in het freeglut 3.0.0 MSVC-pakket.
2. Voer de naam in van het bestand dat u wilt downloaden.
3. Download het in de freeglut-map.
4. Uitpakken en hernoemen naar freeglut.
5. Algemene map installeren: C:\DEV.
6. De map waar de projecten zich bevinden: C:\DEV\visual-studio-c++.
7. De map waarin de bibliotheken zich bevinden: C:\DEV\Lib Visual Studio.
8. Open het en maak een leeg project > Sjablonen > Visual C++ > Leeg project.
9. Schrijf vervolgens “Naam”: Shapes2D.
10. Locatie: C:\dev\visual-studio-c++\.
11. Maak een nieuwe oplossing in de OpenGL-bibliotheek voor Visual Studio. Naam van de oplossing: BadprogTutorial OK.
12. Het Shapes2D-project is gemaakt in de BadprogTutorial-oplossing.
13. Voeg main.cpp toe > klik met de rechtermuisknop op "Project" > "Toevoegen" > " Nieuw element»>Visueel C++>C++-bestand. Schrijf de naam: main.cpp en voeg toe.
14. Configureer GL- en OpenGL-glutbibliotheekconfiguraties.
15. Klik op het Shapes2D-project > Eigenschappen. Zoek in de linkerbovenhoek van het vervolgkeuzemenu “Configuratie” en selecteer Alle configuraties (in plaats van Debug).
16. Klik op “Configuratie-eigenschappen”> C/C++> “Algemeen”> “Extra bijlagemappen”. Aan de rechterkant is een vervolgkeuzemenu, klik op "Bewerken...".
17. Er is een nieuw venster verschenen: “Extra mappen”.
18. Klik op het pictogram Nieuwe regel > bladerknop en selecteer de volgende twee mappen: C:\DEV\Lib\Glew-1.12.0\. C:\DEV\Lib\freeglut-3.0.0\.
19. Klik op OK. Dwing het gebruik van de OpenGL-bibliotheek af, inclusief bibliotheken en bibliotheekmappen.
20. Klik met de rechtermuisknop op het Shapes2D-project > Eigenschappen > Configuratie-eigenschappen > Connector > Algemeen > Extra bibliotheekmappen.
21. Aan de rechterkant is een vervolgkeuzemenu. Klik op “Wijzigen...”. Er is een nieuw venster verschenen: “Extra bibliotheken”.
22. Klik op het pictogram Nieuwe regel > klik op de bladerknop > selecteer de volgende twee mappen voor de 64-bits versie: C:\DEV\Lib\Glew-1.12.0\Lib\Release\x64 en C:\DEV\Lib\freeglut -3.0 .0\Lib\x64.
23. Klik op OK > bibliotheekbestanden toepassen. Klik op het Shapes2D-project > Eigenschappen > Configuratie-eigenschappen > Connector > Invoer.
24. Er is een vervolgkeuzemenu aan de rechterkant, klik op "Bewerken...".
25. Er verschijnt een nieuw venster: “Aanvullende afhankelijkheden”. Klik op het witte gebied en schrijf: freeglut.lib.
26. Druk op Enter om naar de volgende regel te gaan: glew32.lib.
27. Klik op "Toepassen" en OK.

Visual Studio IDE is nu klaar om met OpenGL te werken.

Download Dev-C++

Deze instructies zijn getest op een grote verscheidenheid aan Windows-systemen die worden geleverd met de bestanden die nodig zijn voor OpenGL, maar niet de bestanden die nodig zijn voor GLUT. Dev-C++ werkt niet met Microsoft Vista.

Downloadprocedure:

1. Download Dev-C++ en installeer het.
2. Download Dev-C++ 5.0 beta 9.2 (4.9.9.2) (9,0 MB) met Mingw/GCC 3.4.2 (hoewel het een "bèta" is, werkt het prima).
3. Nu moet je op SourceForge klikken om naar de lijst met downloadsites te gaan en er een te selecteren.
4. Bewaar dit bestand op een locatie zoals C:\Temp.
5. Wanneer het downloaden is voltooid, klikt u op de knop “openen” om het installatieproces te starten. Of ga naar C:\Temp en dubbelklik op devcpp4.9.9.2_setup.exe.
6. Selecteer "typische" installatie. Accepteer de voorgestelde installatiebestemming.
7. Antwoord "Ja" wanneer de installatie vraagt ​​of u Dev-cpp voor alle gebruikers wilt installeren. Er verschijnt een bericht op het scherm dat aangeeft dat de installatie is voltooid. Klik op "Gereed". Het eerste configuratiescherm verschijnt.
8. Selecteer "Engels" en "Nieuwe look". Klik in de volgende paar schermen op “Ja”. Het programma start automatisch.
9. Klik op "Bestand" en maak vervolgens een project aan.
10. Kies een naam voor het project (bijvoorbeeld 'mijnProject').
11. Klik op "C Project", "Project leegmaken" en OK.
12. In het venster "Maken". nieuw project» Klik op “Opslaan”.
13. Klik op “Bestand / Nieuw / Bronbestand” en klik in “Bronbestand toevoegen aan huidig ​​project” op “Ja”.
14. Klik op "Bestand/Opslaan als" en sla het bestand op als "hello.c" (of een andere naam). Het is belangrijk om ervoor te zorgen dat de bestandsextensie .c is. Elke andere extensie (zoals die voorgesteld door .cpp) zal compilatieproblemen opleveren.
15. Klik op "Uitvoeren/Compileren en uitvoeren". Het programma compileert, voert uit en schrijft de uitvoer naar een DOS-venster.
16. Probeer een andere manier om het programma uit te voeren (nadat het gecompileerd is) - start een DOS-venster buiten het Dev-Cpp-systeem.
17. Ga naar de submap die het project bevat en typ hello.exe.
18. Zoek Dev-C++ vermeld onder Programma's in het startmenu.

De gebruiker kan nu C- (en C++)-programma's maken, compileren en uitvoeren. Het zal bestanden, bibliotheken en dll's hebben voor OpenGL (en alle andere standaardpakketten), maar niet voor GLUT. GLUT beheert vensters en andere componenten van de gebruikersinterface die daarvoor nodig zijn, en deze worden afzonderlijk geïnstalleerd.

Het programma installeren en uitvoeren op Windows 7

Runtimeplatform voor Visual Studio 2010 - Geïntegreerd. Omgeving (IDE), met Windows 7. U moet Microsoft Visual C++ 2010 Express downloaden en installeren. En nadat Visual C++ met succes is geïnstalleerd, zou u moeten uitvoeren volgende stappen:

1. Download en pak het bestand freeglut-MSVC-2.8.1-1 uit.
2. Open het welkomstscherm van Visual C++ 2010 vanuit het Start-menu.
3. Maak een nieuw project door Bestand -> Nieuw -> Project te selecteren.
4. Selecteer Win32 in het paneel Geïnstalleerde sjablonen en vervolgens Win32-consoletoepassing in het volgende paneel.
5. Geef uw project een naam en selecteer de map waarin u het wilt opslaan.
6. Schakel het selectievakje 'Maak map voor oplossing aan' uit.
7. Klik op OK om het welkomstvenster en de toepassingsopties van de wizard voor het instellingendialoogvenster te openen.
8. Schakel het selectievakje "Vooraf gecompileerde header" uit, vink het selectievakje "Leeg project" aan en selecteer "Consoletoepassing".
9. Klik op "Voltooien" om een ​​nieuw OpenGL-bibliotheekprojectvenster voor Windows 7 te zien.
10. Klik op Bronbestanden en selecteer Toevoegen -> Nieuw item om een ​​dialoogvenster te openen.
11. Selecteer "Code" in het paneel "Geïnstalleerde sjablonen" en "C++-bestand" (.cpp) in het volgende paneel.
12. Geef uw bestand een naam en klik op 'Toevoegen' om een ​​leeg codepaneel in het projectvenster te zien met de naam 'Geselecteerde naam'.
13. Sla het project op en maak het aan door naar Debug -> Build Solution te gaan. Voer vervolgens het programma uit met Debug -> Start Debugging.

Als grafische kaart ondersteunt OpenGL 4.3 niet, dan kunnen programma's die dit gebruiken compileren maar niet draaien omdat het systeem geen OpenGL 4.3-renderingcontext kan bieden, gegeven door het commando glutInitContextVersion (4. 3) in de hoofdprocedure. In dit geval kunt u versie 4.3 vervangen door 3.3 of zelfs 2.1.

Hoewel bijna alle platforms dit ondersteunen OpenGL-API moeten ontwikkelaars nog steeds apps op maat maken voor verschillende platforms. Dit komt omdat graphics slechts een deel van de applicatie zijn en andere componenten nog steeds verschillen tussen platforms. Om dit op te lossen is WebApp ontworpen om volledige programma's in een webbrowser uit te voeren, zoals Chrome en Firefox. Eén programma kan dus op alle platforms met een compatibele browser worden uitgevoerd.

Ondertussen wordt aan de clientzijde alles direct vanaf de servers overgedragen, dus er is geen verdere installatie van de applicatie vereist. Er is ook een speciale API gemaakt voor het web, WebGL genaamd, die is gebaseerd op ES, een subset van OpenGL die speciaal is ontworpen voor mobiele apparaten. Om een ​​soortgelijk doel voor VR te bereiken, is een andere API genaamd WebVR ontwikkeld om de VR-ervaring eenvoudig naar browsers te brengen, ongeacht het platform.

Typisch wordt het gebied waarin het nodig is om de aanwezigheid van objecten te bepalen (objectselectiegebied) gedefinieerd als een fragment van de scèneprojectie. De gebruiker selecteert bijvoorbeeld een rechthoekig gebied in het projectiebeeld met behulp van een manipulator (bijvoorbeeld een muisaanwijzer) of klikt eenvoudigweg op de muisknop, waardoor het selectiegebied wordt gedefinieerd.

Omdat in deze gevallen het selectiegebied wordt bepaald op basis van de projectie van de driedimensionale scène, is het noodzakelijk om het overeenkomstige gebied van de driedimensionale scène (selectiescène) te bepalen. De scène die u kiest, is afhankelijk van verschillende factoren: de gebruikte projectie, de grootte van de scène en het uitvoergebied.

Om op basis van een rechthoekig deel van de scèneprojectie een 3D-selectiegebied te bepalen, is informatie over de projectiematrix nodig. Om dit te doen, kunt u enkele functies uit de GLUT-bibliotheek gebruiken, die een add-on is voor de OpenGL-bibliotheek en een aantal extra mogelijkheden biedt.

In de OpenTK-bibliotheek bevinden de GLUT-bibliotheekfuncties zich in de Glu-klasse in de naamruimte Tao.OpenGL(C#). In Object Pascal worden alle GLUT-bibliotheekfuncties en -procedures voorafgegaan door "glu" om ze te onderscheiden van procedures en OpenGL-functies.

Om een ​​projectiematrix te genereren op basis van een geselecteerd fragment van de scèneprojectie, kunt u het PickMatrix-commando van de GLUT-bibliotheek gebruiken:

C#: void gluPickMatrix(dubbele x, dubbele y, dubbele breedte, dubbele hoogte, int viewport); Object Pascal: procedure gluPickMatrix(x,y,breedte,hoogte: GLdouble; zichtvenster: PGLint);

Het PickMatrix-commando van de GLUT-bibliotheek wijzigt de huidige matrix zodat de grootte van het scènegebied overeenkomt met het selectiegebied dat is gedefinieerd in de projectiecoördinaten van die scène. Teams heeft volgende parameters:

• x, y – horizontale en verticale coördinaten van het selectiegebied in de coördinaten van het venster waarin de projectie van de 3D-scène wordt weergegeven.
• breedte, hoogte – breedte en hoogte van het geselecteerde rechthoekige projectiegebied van de 3D-scène in venstercoördinaten.
• viewport is een array van vier gehele elementen. In C# wordt een array rechtstreeks als parameter doorgegeven; Object Pascal, een verwijzing naar de array wordt als parameter doorgegeven. De array definieert het uitvoergebied van de 3D-scèneprojectie. De arraywaarden moeten overeenkomen met de coördinaten van het uitvoergebied die zijn gedefinieerd met de ViewPort-opdracht. De elementen van deze array moeten hebben volgende waarden: Het 1e en 2e element zijn de x- en y-coördinaten van de linkerbovenhoek van het geselecteerde gebied in schermcoördinaten, het 3e en 4e element zijn de breedte en hoogte van dit gebied.

Het commando moet worden uitgevoerd voordat de Ortho- of Frushtum-commando's worden uitgevoerd, die de projectiematrix genereren.

De OpenGL-bibliotheek in de selectiemodus zetten

Om de bibliotheek in de selectiemodus te zetten, gebruikt u de opdracht RenderMode:

C#: int RenderMode(RenderingMode-modus); Object Pascal: functie glRenderMode(modus: GLenum): GLint;

De modusparameter bepaalt de bedrijfsmodus van de OpenGL-bibliotheek en kan een van de volgende drie waarden aannemen:

Tabel 10.1.

Mogelijke waarden voor de modusparameter van de opdracht RenderMode	Beschrijving
	Betekenis	OpenTK-bibliotheek, C#
Selectiemodus, deze waarde wordt gebruikt om de bibliotheek in de selectiemodus te zetten.	RenderingMode.Selecteren	GL_SELECT
Scène-beeldvormingsmodus. Deze modus wordt standaard gebruikt nadat de OpenGL-bibliotheek is geïnitialiseerd. In deze modus wordt de afbeelding gegenereerd door de OpenGL-bibliotheek.	RenderingMode.Render	GL_RENDER
Feedback-modus.	RenderingMode.Feedback	GL_FEEDBACK

Na het overschakelen naar de selectiemodus rendert OpenGL de afbeelding pas nadat de modus is gewijzigd naar de scèneweergavemodus met behulp van de opdracht RenderMode met de waarde RenderingMode.Render in C# en GL_RENDER in Object Pascal.

Het benoemen en vormen van scèneobjecten

Zoals hierboven besproken wordt er geen afbeelding gegenereerd in de selectiemodus. De beeldcommando's in deze modus worden gebruikt om objecten te definiëren die binnen het selectiegebied vallen.

Omdat de objecten waarmee de gebruiker werkt meestal uit veel verschillende primitieven bestaan, wordt een stapel namen gebruikt om het geselecteerde object te bepalen. De namen zijn gehele waarden. Voordat de uitvoer van het volgende object begint, wordt de naam (nummer) van dit object op de namenstapel geplaatst. Als de bibliotheek bij het construeren van een object detecteert dat de primitieven van het object binnen het selectiegebied vallen, wordt de inhoud van de namenstapel gekopieerd naar een selectiebuffer (samen met wat aanvullende informatie) die is geïnitialiseerd met de opdracht SelectBuffer. Wanneer de primitieven van een ander benoemd object het scènegebied binnenkomen, wordt de inhoud van de namenstapel ook naar de selectiebuffer gekopieerd. Zo kunnen de namen (nummers) worden verkregen van objecten die zich geheel of gedeeltelijk binnen het selectiegebied bevinden. Er moet rekening mee worden gehouden dat om de geselecteerde objecten correct te bepalen, het noodzakelijk is dat de coördinaattransformaties van de objecten samenvallen met de transformaties die werden uitgevoerd bij het vormen van het scènebeeld.

Er worden verschillende opdrachten gebruikt om met de namenstapel te werken. Het wissen van de namenstapel gebeurt met de opdracht InitNames:

C#: ongeldige InitNames(); Object Pascal: procedure glInitNames;

Het pushen van een naam naar de stapel gebeurt met behulp van het PushName-commando:

C#: void PushName(uint-naam); Object Pascal: procedure glPushName(naam: GLuint);

De naam wordt doorgegeven als opdrachtparameter.

Voordat een namenstapel kan worden gebruikt, moet deze worden geïnitialiseerd met de opdracht InitNames. Vervolgens moet u één element op de stapel duwen met behulp van de opdracht PushName. Voordat elk object wordt gevormd, wordt een enkel element van de namenstapel vervangen door de naam van het object dat wordt gevormd met behulp van de opdracht LoadName. De procedure vervangt het laatste element in de namenstapel door het element dat als parameter is opgegeven. De initialisatie en het gebruik van de namenstapel kunnen dus schematisch als volgt worden weergegeven:

InitNamen; PushNaam(0); ...Laadnaam(1); //vorming van object nr. 1 LoadName(2); //vorming van object nr. 2 LoadName(3); //vorming van object nr. 3 //etc. Lijst 10.7.

Diagram voor het gebruik van een namenstapel om objecten te selecteren

1. Laboratoriumwerk nr. 2.

Invoering OpenGL – Open grafische bibliotheek, open source grafische bibliotheek . De term "open" betekent onafhankelijk van fabrikanten. Er is een specificatie (standaard) voor OpenGL, waarin alles duidelijk gedocumenteerd en beschreven is. Iedereen kan een OpenGL-bibliotheek maken. Het belangrijkste is dat de bibliotheek voldoet aan de OpenGL-specificatie en een aantal tests. Als gevolg hiervan zijn er geen donkere plaatsen, geheimen, ongedocumenteerde kenmerken enz., degenen die onder MS Windows of MS DOS hebben geprogrammeerd, begrijpen waar ik het over heb. De bibliotheek wordt geproduceerd door bedrijven zoals Microsoft, Silicon Graphics, maar ook door groepen programmeurs. Een voorbeeld hiervan is de Mesa-implementatie. Deze bibliotheek is geschreven door een aantal programmeurs, waarvan Brian Paul de hoofdauteur is. De Mesa-bibliotheek wordt gedistribueerd in bronteksten

De OpenGL-bibliotheek is een grafische programmeerinterface voor 3D. De eenheid van informatie is het hoekpunt; er zijn meer complexe objecten uit samengesteld. De programmeur maakt de hoekpunten, specificeert hoe ze moeten worden verbonden (met lijnen of polygonen), stelt de coördinaten en parameters van de camera en lampen in, en de OpenGL-bibliotheek neemt de taak over van het creëren van de afbeelding op het scherm. OpenGL is ideaal voor programmeurs die een kleine 3D-scène moeten creëren zonder zich zorgen te hoeven maken over de implementatiedetails van 3D grafische algoritmen. Voor professionals die betrokken zijn bij het programmeren van 3D grafische afbeeldingen zal de bibliotheek ook nuttig zijn, omdat deze de basismechanismen vertegenwoordigt en een bepaalde automatisering uitvoert. Met OpenGL kunt u eenvoudig driedimensionale oppervlakken maken, er texturen op toepassen, ze verlichten met lichtbronnen, mist, transparantie en kleurmengeffecten creëren, een stencil toepassen, scène-objecten, lampen en camera's langs bepaalde trajecten verplaatsen, waardoor animatie ontstaat. OpenGL ondersteunt niet rechtstreeks invoerapparaten zoals een muis of toetsenbord, omdat het een platformonafhankelijke bibliotheek is. Maar u kunt de functies gebruiken van het specifieke besturingssysteem waarvoor u uw programma schrijft of add-ons voor OpenGL gebruiken, zoals de GLUT- of GLAUX-bibliotheken.

2. Eerste programma

Het eenvoudigste object waarmee je de volledige kracht van OpenGL kunt zien, is een bol. Je kunt proberen het in beeld te brengen. Om dit te doen, moet u een nieuw project maken in VisualC++ door deze stappen te volgen:

— start Visual C++;

— voer het commando Bestand | uit Nieuw...;

— selecteer in het dialoogvenster dat wordt geopend het projecttype Win32-toepassing, geef in het veld Projectnaam de naam van het project op en in het veld Locatie de map waarin het project zich zal bevinden;

— druk op de OK-knop. Klik vervolgens, zonder iets te veranderen, op de knop Voltooien en nogmaals op OK;

— kopieer twee voorbeeldbestanden naar de projectmap. cpp en voorbeeld. h (uitgegeven door de docent);

— verbind deze twee bestanden met het project door de opdracht Project | uit te voeren Toevoegen aan project | Bestanden...;

— plaats de volgende code in de weergavefunctie:

GlColor3d(1,0,0);

AuxSolidSphere(1);

— maak een exe-module (F7).

Laten we het doel van de twee ingevoegde functies uitleggen. De glColor3d-functie stelt de huidige kleur in waarmee vormen worden getekend. Hier moeten we uitleggen hoe kleur wordt ingesteld en de algemene filosofie bij het benoemen van OpenGL-functies. De kleur wordt bepaald door vier parameters: rood, blauw, groen en transparantie. Deze parameters variëren van nul tot één. We hebben de vierde parameter nog niet nodig, dus hebben we glColor aangeroepen met drie parameters. In dit geval wordt de waarde van de vierde parameter, transparantie, standaard beschouwd als gelijk aan één, d.w.z. absoluut ondoorzichtig, nul zal absoluut transparant zijn. De volgende syntaxis voor functieaanroepen wordt gebruikt: FuncionName[parametertype].

De volgende typen zijn beschikbaar:

B – GLbyte-byte;

S – GLkort kort geheel getal;

I – GLint geheel getal;

F – GLfloat fractioneel;

D – GLdubbel fractioneel met dubbele precisie;

Ub – GLubyte niet-ondertekende byte;

Wij – GLushort niet-ondertekend kort geheel getal;

Ui – GLuint geheel getal zonder teken;

V – array van n parameters van het opgegeven type;

In ons geval betekent glColor3d dat drie parameters van het type GLdouble aan de functie worden doorgegeven. Het was ook mogelijk om glColor3i aan te roepen, d.w.z. drie parameters van het type GLint. Als het type parameters een kort geheel getal, geheel getal, byte of lang is, wordt de kleurcomponent naar het bereik gegoten. De reductie tot dit bereik wordt uitgevoerd volgens de volgende regels. In het geval van een niet-ondertekend type wordt de grootst mogelijke waarde teruggebracht tot één, nul tot nul. In het geval van ondertekend wordt de maximale waarde teruggebracht tot één of min één, en wordt min één teruggebracht tot één. In de praktijk wordt veelal gebruik gemaakt van één van de drie hieronder als voorbeeld besproken gevallen. Voor een niet-ondertekende byte wordt de cast bijvoorbeeld uitgevoerd met behulp van de volgende formule: variabele_waarde_opgeslagen_in_byte/255, aangezien 255 het maximale aantal is dat in één byte kan worden opgeslagen. De functie glColor3dv betekent dat een array van drie elementen van het type GLdouble als parameters wordt doorgegeven. Bijvoorbeeld:

Dubbele array = (0,5, 0,75, 0,3);

GlColor3dv(matrix);

GlColor3ub(200.100,0); // gereduceerd tot

// 200/256, 100/256, 0,256

GlColor3d(0,25,0,25,0); // donkergeel

GlColot3ub(0,100,0); // donkergroen

GlColor3ub(0,0,255); // blauw

3. Eenvoudige voorwerpen. Algemene bepalingen

Punten, lijnen, driehoeken, vierhoeken en polygonen zijn eenvoudige objecten waaruit ze bestaan complexe figuren. OpenGL ondersteunt niet direct functies voor het maken hiervan complexe objecten zoals een bol, cilindertorus, enz., d.w.z. dergelijke functies bevinden zich niet in opengl32.dll. Deze functies bevinden zich in de hulpprogrammabibliotheek glu32.dll en zijn als volgt gerangschikt. Om een ​​bol te tekenen, gebruikt de functie auxSolidSphere functies uit de glu32.dll-bibliotheek, die op hun beurt de basisbibliotheek opengl32.dll gebruiken en een bol construeren uit lijnen of polygonen. Primitieven worden als volgt gemaakt:

GlBegin(modus); // geef aan wat we gaan tekenen

glVertex(...); // eerste hoekpunt

... // hier zijn de resterende hoekpunten

glVertex(...); // laatst

// hoekpunt

GlEnd(); // klaar met het tekenen van de primitief

Eerst moet u het begin van de tekening opgeven - glBegin met de juiste parameter.

Mogelijke moduswaarden staan ​​​​in de onderstaande tabel. Vervolgens worden de hoekpunten aangegeven die objecten van het opgegeven type definiëren. Normaal gesproken wordt een hoekpunt op een van de volgende vier manieren gespecificeerd.

GlVertex2d(x, y); // twee dubbele variabelen

GlVertex3d(x, y,z); // drie dubbele variabelen

GlVertex2dv(array); // array van twee typevariabelen

GlVertex3d(matrix); // array van drie typevariabelen

Leegte glEnd(ongeldig);

Geeft het einde aan van tekenobjecten van het type dat is opgegeven in glBegin. Vervolgens zullen we de creatie van alle primitieven in detail analyseren.

Tabel 1.

Mogelijke waardenmodus

Beschrijving	Mogelijke waarden voor de modusparameter van de opdracht RenderMode
	Elke aanroep naar glVertex specificeert een ander punt.
	Elk paar hoekpunten definieert een segment.
	Er wordt een onderbroken lijn getekend.
	Er wordt een onderbroken lijn getrokken, en zijn laatste punt sluit aan bij de eerste.
	Elke drie aanroepen naar glVertex definiëren een driehoek.
GL_TRIANGLE_STRIP	Er worden driehoeken met een gemeenschappelijke zijde getekend.
	Hetzelfde, maar de hoekpunten zijn verbonden volgens een andere regel.
	Elke vier aanroepen naar glVertex definiëren een quad.
	Vierhoeken met een gemeenschappelijke zijde.
	Veelhoek.

3.1. Punten

Je kunt zoveel punten tekenen als je wilt door glVertex3d aan te roepen en daarmee setting nieuw punt. Bij het aanmaken van punten kunt u de volgende parameters wijzigen. Je kunt glColor3d binnen glBegin/glEnd aanroepen. De puntgrootte kan worden ingesteld met behulp van de functie:

Ongeldig glPointSize(GLfloat-grootte);

De afvlakkingsmodus kan worden ingesteld door de functie aan te roepen

GlEnable(GL_POINT_SMOOTH);

Het wordt dienovereenkomstig uitgeschakeld door glDisable(GL_POINT_SMOOTH) aan te roepen. De laatste functies - glPointSize en glEnable/glDisable moeten buiten glBegin/glEnd worden aangeroepen, anders worden ze genegeerd. De glEnable/glDisable-functies schakelen veel opties in/uit, maar houd er rekening mee dat sommige opties grote berekeningen met zich meebrengen en daarom de toepassing aanzienlijk vertragen, dus u moet ze niet inschakelen tenzij dit noodzakelijk is.

// teken punten

GlBegin(GL_POINTS);

glColor3d(1,0,0);

glVertex3d(-4.5,4,0); // eerste punt

glColor3d(0,1,0);

glVertex3d(-4,4,0); // tweede punt

glColor3d(0,0,1);

glVertex3d(-3.5,4,0); // derde

GlBegin(GL_POINTS);

glColor3d(1,0,0);

glVertex3d(-2,4,0); // eerste punt

glColor3d(0,1,0);

glVertex3d(-1,4,0); // tweede punt

glColor3d(0,0,1);

glVertex3d(0,4,0); // derde

GlPuntgrootte(10);

GlEnable(GL_POINT_SMOOTH);

GlBegin(GL_POINTS);

glColor3d(1,0,0);

glVertex3d(2,4,0); // eerste punt

glColor3d(0,1,0);

glVertex3d(3,4,0); // tweede punt

glColor3d(0,0,1);

glVertex3d(4,4,0); // derde

GlUitschakelen(GL_POINT_SMOOTH);

3.2. Lijnen

Voor lijnen kunt u ook de breedte, kleur, grootte en vloeiendheid wijzigen. Als u verschillende kleuren instelt voor het begin en einde van een lijn, zal de kleur iriserend zijn. OpenGL voert standaard interpolatie uit. Je kunt ook onderbroken lijnen tekenen; dit doe je door een masker toe te passen met behulp van de volgende functie:

Void glLineStipple(GLint-factor, GLushort-patroon);

De tweede parameter specificeert het masker zelf. Als de waarde bijvoorbeeld 255(0x00FF) is, gebruiken we een rekenmachine om het opgegeven masker te berekenen. IN binair dit nummer ziet er als volgt uit: 0000000011111111, d.w.z. slechts 16 bits. De hoogste acht zijn op nul gezet, wat betekent dat er hier geen lijn zal zijn. De kleine zijn ingesteld op één, hier wordt een lijn getrokken. De eerste parameter bepaalt hoe vaak elke bit wordt herhaald. Als u dit bijvoorbeeld op 2 instelt, ziet het overlaymasker er als volgt uit:

GlLijnbreedte(1); // lijndikte

// set 1

GlBegin(GL_LINES);

glColor3d(1,0,0); // rode kleur

glVertex3d(-4.5,3,0); // eerste regel

glVertex3d(-3,3,0);

glColor3d(0,1,0); // groente

glVertex3d(-3,3.3,0); // tweede regel

glVertex3d(-4,3.4,0);

GlLijnbreedte(3); // breedte 3

GlBegin(GL_LINE_STRIP); // zie hieronder

glColor3d(1,0,0);

glVertex3d(-2.7,3,0);

glVertex3d(-1,3,0);

glColor3d(0,1,0);

glVertex3d(-1,5,3,3,0);

glColor3d(0,0,1);

glVertex3d(-1,3.5,0);

GlEnable(GL_LINE_SMOOTH);

GlEnable(GL_LINE_STIPPLE); // laat tekenen toe

// stippellijn

GlLineStipple(2,58360); // stel het masker in

// zie hieronder voor uitleg

GlBegin(GL_LINE_LOOP);

glColor3d(1,0,0);

glVertex3d(1,3,0);

glVertex3d(4,3,0);

glColor3d(0,1,0);

glVertex3d(3,2.7,0);

glColor3d(0,0,1);

glVertex3d(2,5,3,7,0);

GlUitschakelen(GL_LINE_SMOOTH);

GlUitschakelen(GL_LINE_STIPPLE);

3.3. Driehoeken

Voor een driehoek kun je dezelfde parameters instellen als voor een lijn, en er is nog een functie

Ongeldig glPolygonMode(

Het stelt opties in voor het tekenen van de polygoon. Mogelijke waarden van de functieparameters worden gegeven in Tabel 2.

Tabel 2.

glPolygonMode-functieparameterwaarden

De eerste parameter geeft aan voor welke partijen de door de tweede parameter gespecificeerde mogelijkheid geldt. Driehoeken kunnen worden getekend door GL_TRIANGLE_STRIP of GL_TRIANGLE_FAN door te geven aan glBegin. In het eerste geval definiëren de eerste, tweede en derde hoekpunten de eerste driehoek. Het tweede, derde en vierde hoekpunt zijn de tweede driehoek. Het derde, vierde en vijfde hoekpunt zijn de derde driehoek, enz. De hoekpunten n, n+1 en n+2 definiëren de n-de driehoek. In het tweede geval definiëren de eerste, tweede en derde hoekpunten de eerste driehoek. De eerste, derde en vierde hoekpunten definiëren de tweede driehoek, enz. Hoekpunten 1, n+1, n+2 definiëren de n-de driehoek. Hieronder volgt een voorbeeld met commentaar.

GlPolygonModus(GL_FRONT_AND_BACK, GL_FILL); // zie hierboven

GlBegin(GL_TRIANGLES);

glColor3d(1,0,0); // teken een driehoek

glVertex3d(-4,2,0);

glVertex3d(-3,2.9,0);

glVertex3d(-2,2,0);

// teken draaddriehoeken

GlBegin(GL_TRIANGLE_STRIP); //let op

// hoekpuntvolgorde

glColor3d(0,1,0);

glVertex3d(1,2,0);

glVertex3d(0,2,9,0);

glVertex3d(-1,2,0);

glVertex3d(0,1.1,0);

GlEnable(GL_LINE_STIPPLE);

GlPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

GlBegin(GL_TRIANGLE_FAN);

glColor3d(0,0,1);

glVertex3d(4,2,0);

glVertex3d(2.6,2.8,0);

glVertex3d(2,2,0);

glVertex3d(3,1.1,0);

GlUitschakelen(GL_LINE_STIPPLE);

3.4. Vierhoeken en veelhoeken

Vierhoeken worden getekend door de functie glBegin aan te roepen met de parameter GL_QUADS of GL_QUAD_STRIP. Voor het eerste geval definiëren elke vier hoekpunten hun eigen vierhoek. In het tweede geval worden verbonden vierhoeken getekend. De eerste, tweede, derde en vierde hoekpunten definiëren de eerste vierhoek. De derde, vierde, vijfde en zesde hoekpunten definiëren de tweede vierhoek, etc. (2n-1), 2n, (2n+1) en (2n+2) hoekpunten definiëren de n-de vierhoek. Polygonen worden gespecificeerd door glBegin aan te roepen met de parameter GL_POLYGON. Alle hoekpunten definiëren één veelhoek. Voor polygonen kunt u stijlen instellen met behulp van de hierboven beschreven glPolygonMode-functie, lijndikte, puntdikte en kleur.

4. Verplaatsen naar nieuwe coördinaten

In het vorige gedeelte heb je geleerd hoe je primitief tekent driedimensionale objecten. Maar het probleem is dat ze alleen bij de oorsprong worden getekend, dat wil zeggen in het punt (0,0,0). Om een ​​object op het punt (x0,y0,z0) af te beelden, moet u de oorsprong van de coördinaten naar dit punt verplaatsen, d.w.z. u moet naar nieuwe coördinaten gaan. Deze procedure is vrij gebruikelijk bij het programmeren van afbeeldingen en animaties. Vaak is het erg handig om de coördinaten naar een nieuw punt te verplaatsen en ze naar de gewenste hoek te draaien, waardoor uw berekeningen aanzienlijk worden vereenvoudigd. Er zijn twee functies in OpenGL om naar nieuwe coördinaten te gaan:

Ongeldig glTranslated(Dx, Dy, Dz);

Leegte glRotated(j, x0,y0,z0);

De eerste functie verschuift de oorsprong van het coördinatensysteem met (Dx, Dy, Dz). De tweede roteert over een hoek j tegen de klok in rond de vector (x0,y0,z0). Nu is het de moeite waard om nog twee zeer belangrijke functies te noemen:

Ongeldig glPushMatrix();

Ongeldig glPopMatrix();

Ze zijn ontworpen om huidige coördinaten op te slaan en te herstellen. Het is vaak lastig om van het ene coördinatensysteem naar het andere te gaan en alle overgangen te onthouden. Het is veel handiger om glPushMatrix() te gebruiken om de huidige coördinaten op te slaan, vervolgens te verplaatsen, roteren, zoals je wilt, en dan terug te keren naar de oude coördinaten door glPopMatrix aan te roepen. Nu kun je experimenteren. Laten we een coördinatenverschuiving overwegen. Plak de volgende code in de weergavefunctie:

GlTranslated(1.4,0,0);// verschuiving langs de X-as met 1,4

GlColor3d(0,1,0);

AuxSolidSphere(0,5); // teken een bol op (1.4,0,0)

// in absolute coördinaten

GlVertaald(1,0,0); // opnieuw bewegen

GlColor3d(0,0,1);

AuxSolidSphere(0,3);

GlPopMatrix(); // terug naar oud systeem

// coördinaten

GlColor3d(1,0,0);

AuxSolidSphere(0,75); // teken een bol op punt (0,0,0)

// in absolute coördinaten

5. Roteer coördinaten

Beschouw nu de rotatie van coördinaten. Plak de volgende code in de weergavefunctie:

GlColor3d(1,0,0);

AuxSolidCone(1, 2); // teken een kegel in het midden van de coördinaten

GlPushMatrix(); // bewaar huidige coördinaten

glVertaald(1,0,0); // ga naar punt (1,0,0)

glGeroteerd(75,1,0,0); // roteer het systeem

// coördinaten op 75 graden

glColor3d(0,1,0);

auxSolidCone(1, 2); // teken een kegel

GlPopMatrix(); // keer terug naar oude coördinaten

Zoals je kunt zien, is de kegel in absolute coördinaten geroteerd. Om dus een figuur te tekenen die niet bij de oorsprong ligt, moet je:

· verplaatsen(glTranslated), roteren(glRotated);

· teken wat je wilde;

· terug naar oude coördinaten.

glPushMatrix/PopMatrix-oproepen kunnen worden genest, d.w.z.:

Uiteraard moet het aantal oproepen naar glPopMatrix overeenkomen met het aantal oproepen naar glPushMatrix, anders vliegt de scène in een onbekende richting weg. De maximaal toegestane nestdiepte van glPushMatrix/glPopMatrix wordt als volgt bepaald:

GlGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &n);

Printf("n=%d ",n);

De OpenGL-specificatie garandeert dat de stapeldiepte niet minder dan 32 mag zijn.

6. Constructie van oppervlakken

Er is een reeks functies voor het construeren van bollen, cilinders en schijven. Deze functies bieden een zeer krachtige controle over de constructie van 3D-objecten. De volgende functies worden gebruikt om oppervlakken te tekenen:

GLUquadricObj * qobj,

GLdubbele straal,

Leegte gluCilinder(

GLUquadricObj *qobj,

GLdubbele basisRadius,

GLdubbele topRadius,

GLdubbele hoogte,

GLUquadricObj *qobj,

GLdubbele binnenradius,

GLdubbele buitenradius,

Void gluGedeeltelijkeSchijf(

GLUquadricObj *qobj,

GLdubbele binnenradius,

GLdubbele buitenradius,

GLdubbele starthoek,

GLdubbele veeghoek

Aan het begin van deze les hebt u geleerd hoe u 3D-objecten kunt construeren met behulp van functies uit de hulpbibliotheek. De functies auxSphere, auxCylinder en auxCone roepen eenvoudigweg gluSphere en gluCylinder aan. Microsoft's auxCylinder en auxCone bevatten bugs. De constructie van bollen en cilinders wordt hier uitgebreid besproken, waardoor de noodzaak voor auxCylinder en auxCone niet meer nodig zal zijn.

De eerste parameter voor gluSphere, gluCylinder, gluDisk en gluPartialDisk is een verwijzing naar een object van het type GLUquadricObj. Hieronder volgen direct de parameters het figuur dat wordt gemaakt. Voor een bol is dit de straal; voor een cilinder – straal van de onderste basis, straal van de bovenste basis en hoogte; voor een schijf - binnenradius, buitenradius en voor een gedeeltelijke schijf - binnenradius, buitenradius, hoek van waaruit moet worden getekend, booglengte in graden om te tekenen. De laatste twee parameters zijn voor al deze functies hetzelfde. Dit is het aantal partities rond de Z-as en het aantal partities langs de Z-as. Zoals u weet bestaan ​​alle complexe objecten uit eenvoudige: punten, lijnen en polygonen. Het is duidelijk dat het onmogelijk is om een ​​perfect gladde bol of cilinder te tekenen (creëren). Daarom wordt een benadering opgebouwd uit vlakken. Om dit te doen, moet u het aantal splitsingen opgeven. Hoe groter de splitsing, hoe beter uw object eruit zal zien. U dient hier echter geen getal met zes nullen op te geven. Dit heeft geen enkele zin. Het optimale aantal is van 10 tot 20. Hoe groter het object, hoe meer partities er nodig zijn. Het is beter om het aantal partities (in de lengte en in de breedte) hetzelfde in te stellen.

Eerst moet u een object van het type GLUquadricObj maken met behulp van de functie

GLUquadricObj * gluNewQuadric(ongeldig);

Vervolgens moet u de eigenschappen instellen met behulp van de functie

Leegte gluQuadricDrawStyle(

GLUquadricObj *qobj,

Glenum drawStyle

Beschikbare stijlen:

GLU_FILL – een solide object wordt getekend;

GLU_LINE – draadobject;

GLU_POINT – er worden alleen punten getekend.

U kunt een aangemaakt object verwijderen met behulp van de functie

Ongeldig gluDeleteQuadric(GLUquadricObj * staat);

Nu kun je experimenteren. Wijzig de weergavefunctie als volgt.

Ongeldige weergave (ongeldig)

GLUquadricObj * quadObj;

// maak een nieuw object om bollen en cilinders te maken

quadObj = gluNewQuadric();

glColor3d(1,0,0);

// ingestelde stijl: effen

gluQuadricDrawStyle(quadObj, GLU_FILL);

// teken een bol met straal 0,5

gluSphere(quadObj, 0,5, 10, 10);

glVertaald(-2,0,0); // ga naar links

glGeroteerd(45, 1,0,0); // roteren

glColor3d(0,1,0);

// stijl instellen: draad

gluQuadricDrawStyle(quadObj, GLU_LINE);

gluCilinder(quadObj, 0,5, 0,75, 1, 15, 15);

gluDeleteQuadric(quadObj);

auxSwapBuffers();

7. Vliegtuigen knippen

Als u een bol of een ander bijgesneden object wilt tekenen, kunt u dit doen met behulp van een uitknipvlak. Er kunnen zes snijvlakken zijn. Standaard zijn ze allemaal uitgeschakeld. Het uitknipvlak wordt ingeschakeld met de opdracht glEnable(GL_CLIP_PLANE0). De nul aan het einde van GL_CLIP_PLANE betekent het grondvlak; je kunt één, twee, drie, etc. opgeven. Het vlak zelf wordt ingesteld door de functie

Ongeldig glClipPlane(

const GLdouble *vergelijking

Het eerste argument van deze functie is het vlak, het tweede is een array van vier elementen die de coëfficiënten (A, B, C, D) van de vlakvergelijking opslaan: A*x + B*y + C*z + D = 0. Wijzig de functieweergave zoals hieronder weergegeven.

Ongeldige weergave (ongeldig)

GLdubbele vergelijking = (-1,-0,25,0,2);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glEnable(GL_CLIP_PLANE0);

glClipPlane(GL_CLIP_PLANE0, vergelijking);

glColor3d(1,0,0);

auxSolidSphere(3);

glUitschakelen(GL_CLIP_PLANE0);

auxSwapBuffers();

8. Zoektochten

1. Teken een kubus die vertegenwoordigt RGB-ruimte. De hoekpunten van de kubus hebben de kleuren: R - rood, G - groen, B - blauw, C - cyaan, M - magenta, Y - geel, W - wit, K - zwart. De kleur van elke rand verandert vloeiend van de kleur van het ene hoekpunt naar de kleur van een ander hoekpunt.

Nadat de kubus is getekend, verschuift u deze zodat de oorsprong samenvalt met het midden van de kubus en draait u deze vervolgens rond de OX-as in een hoek van 30° en rond de OZ-as in een hoek van -20°.

2. Teken een scène waarin in de oorsprong een bol met straal r is afgebeeld. Op een afstand R1 van de eerste bol op een bepaald punt (x1, y1, 0) is een bol met straal r1 afgebeeld. Daarvan wordt op een afstand R2 op een bepaald punt (x2, y2, 0) een bol met straal r2 afgebeeld.

Nadat de scène is getekend, is het nodig om deze te "doen herleven", dat wil zeggen, bol r1 rond bol r te laten draaien, en bol r2 rond r1. Om dit te doen, is het noodzakelijk om globale variabelen f1 en f2 te declareren - respectievelijk de rotatiehoeken r1 rond r en r2 rond r1. Verhoog vervolgens vóór elke uitvoer f1f2 met constante waarden en bereken x1, y1, x2, y2 met behulp van de volgende formules.

In dit hoofdstuk zullen we kijken naar het renderen van 3D-afbeeldingen met behulp van de OpenGL-bibliotheek, de GLU- en GLUT-bibliotheken bestuderen (de FreeGLUT-bibliotheek wordt gebruikt in plaats van de laatste op Linux) en het proces van het laden van texturen analyseren met behulp van de SOIL- en DevIL-bibliotheken.

Zoals al opgemerkt in hfdst. 9. Grafische programmeurs werken meestal niet rechtstreeks met de GPU. Dit komt zowel door het feit dat er veel verschillende GPU's zijn, als omdat het werken op laag niveau met GPU's behoorlijk complex is en meestal wordt gedaan door ontwikkelaars van stuurprogramma's. In plaats daarvan gebruiken ze verschillende API's die een extra interface bieden hoog niveau voor het werken met GPU. Deze interface abstraheert de specifieke GPU (die wordt afgehandeld via een stuurprogramma, meestal geleverd door de GPU-fabrikant), waardoor u draagbare code kunt schrijven die op verschillende GPU's werkt. Bovendien verbergt zo'n API een aantal details op laag niveau over het werken met de GPU voor de programmeur.

De belangrijkste API's voor het programmeren van 3D-graphics in op dit moment zijn OpenGL en Dircct3D. Dit laatste is alleen gericht op het Microsoft Windows-platform. Dit boek behandelt de basisbeginselen van het werken met OpenGL. Dit is een platformonafhankelijke API die alle belangrijke besturingssystemen (Windows, Linux, Mac OS X) ondersteunt en waarmee u kunt werken een groot aantal diverse GPU's.

Er is een versie van de API - OpenGL ES, ontworpen om op mobiele apparaten te werken. Met zijn hulp kunt u 3D-afbeeldingen maken voor iOS- en Android-platforms. Daarnaast is er WebGL, een bibliotheek waarmee u OpenGL ES rechtstreeks in het browservenster kunt gebruiken met behulp van javascript. Er zijn ook bindingen voor OpenGL die met alle belangrijke programmeertalen werken, waardoor het gemakkelijk wordt om OpenGL vanuit vrijwel elke programmeertaal te gebruiken.

De hoofdtaak van OpenGL is het weergeven van twee- en driedimensionale afbeeldingen. Tegelijkertijd deze API houdt zich over het algemeen niet bezig met het maken van vensters voor weergave, het lezen van invoer van de gebruiker en ander soortgelijk werk dat sterk afhankelijk is van het specifieke besturingssysteem, dus zullen we de platformonafhankelijke GLUT-bibliotheek voor deze doeleinden gebruiken. Deze bibliotheek biedt eenvoudige en handige manier om vensters te maken, deze weer te geven met OpenGL en berichten te ontvangen via de muis en het toetsenbord.

Vanuit architectonisch oogpunt is OpenGL op het model gebouwd client-server. In dit geval fungeert het programma zelf, dat OpenGL gebruikt, als een client en fungeren de GPU en het stuurprogramma als een server. Normaal gesproken draait het programma op dezelfde computer waarop de GPU is geïnstalleerd, maar dit is niet noodzakelijk.

In de praktijk worden alle uitgevoerde OpenGL-opdrachten gebufferd en vervolgens in de wachtrij geplaatst voor verzending naar de GPU. De uitvoering van een commando door de CPU geeft dus alleen aan dat dit commando is gebufferd of aan de wachtrij is toegevoegd; het is heel goed mogelijk dat de GPU nog niet is begonnen met het uitvoeren ervan. Tegelijkertijd kan OpenGL worden beschouwd als een staatsmachine: het heeft zijn eigen staat. De enige manier om deze status te veranderen is door OpenGL-opdrachten te gebruiken. De OpenGL-status verandert niet tussen opdrachten.

Een belangrijk concept in OpenGL zijn buffers (Figuur 10.1). Om te kunnen renderen moeten de nodige buffers worden aangemaakt. Kleurbuffer wordt altijd gebruikt en slaat voor elke pixel zijn kleur op als een 24-bits getal RGB-formaat(8 bits voor elk van de basiskleuren - rood, groen en blauw) of als 32-bits in RGBA-formaat(een vierde component wordt toegevoegd aan de standaard drie componenten - alpha, die de dekking instelt).

Wanneer u de r-buffermethode gebruikt om onzichtbare oppervlakken te verwijderen, moet u de corresponderende dieptewaarde voor elke pixel opslaan (meestal wordt de dieptewaarde opgeslagen als een 16-, 24- en 32-bits geheel getal). Dienovereenkomstig vormen alle dieptewaarden samen genomen dieptebuffer. Je kunt ook gebruiken stencilbuffer, accumulatiebuffer.

Wanneer u een venster maakt om naar te renderen, moet u een OpenGL-context en de juiste buffers maken. De context zelf is meestal gekoppeld aan de huidige thread, dus als een toepassing meerdere threads gebruikt, kan de gemaakte context alleen echt worden gebruikt vanuit de thread waarin deze is gemaakt.

Gegevensverwerking in OpenGL is gebaseerd op de weergavepijplijn (zie figuur 9.1). De pijplijn definieert de belangrijkste fasen van het verwerken van binnenkomende gegevens. Hoe de gegevens precies zullen worden verwerkt, hangt af van de OpenGL-statusparameters, maar deze fasen zelf en de volgorde waarin ze plaatsvinden, liggen strikt vast.

Rijst. 10.1.

Voor moderne GPU's worden twee delen van deze pijplijn vertegenwoordigd door programma's die op de GPU draaien, genaamd shaders. Vervolgens bekijken we OpenGL versie 2, waarin deze programma's niet expliciet gespecificeerd hoeven te worden: er zijn shaders die standaard werken (dat wil zeggen, in het geval dat de programmeur de corresponderende shaders niet expliciet heeft gespecificeerd). Vanaf versie 3 vereist OpenGL verplichte shaders en wordt de compatibiliteit met eerdere versies gedeeltelijk verbroken. Daarom zullen we dit overwegen OpenGL-versie 2.

Geometrie wordt gedefinieerd als een reeks hoekpunten die verschillende primitieven vormen (punten, segmenten, driehoeken). Bij elk hoekpunt kunt u, naast de coördinaten, ook een aantal extra attributen instellen, zoals kleur, normaal en textuurcoördinaten. De gegevens bij elk hoekpunt zijn de invoer van de hoekpuntshader: voor elk hoekpunt wordt de hoekpuntshader uitgevoerd en genereert deze enkele uitvoerwaarden. De vereiste uitvoerwaarde zijn de uniforme hoekpuntcoördinaten nadat alle transformaties zijn uitgevoerd.

OpenGL gebruikt 4x4-matrices voor hoekpunttransformatie: de ontwerpmatrix voor modelaanzichten (Figuur 10.2). Als er niet expliciet een hoekpuntshader is opgegeven, wordt de standaard hoekpuntshader gebruikt, die de hoekpuntcoördinaten (als een vector in homogene coördinaten) eerst vermenigvuldigt met de modelviewmatrix en vervolgens met de ontwerpmatrix.

Hierna worden de primitieven samengevoegd en afgesneden: alle delen van elke primitief die verder reiken dan het zichtbare gebied (frustum bekijken) worden automatisch bijgesneden, zodat primitieven die volledig binnen het bereik vallen, doorgaan naar de volgende fase van de pijpleiding. Vervolgens voert het vaste deel van de pijpleiding een perspectiefdeling uit - de vector in homogene coördinaten wordt verdeeld in zijn vierde component.

Rijst. 10.2.

Als de coördinaten aanvankelijk in hun eigen coördinatensysteem waren gespecificeerd, worden ze door vermenigvuldiging met de modelaanzichtmatrix overgebracht naar het cameracoördinatensysteem. Verdere vermenigvuldiging met de projectiematrix brengt de coördinaten naar clip-ruimte. Na het uitvoeren van de perspectiefdeling krijgen we genormaliseerde apparaatcoördinaten (genormaliseerde apparaatcoördinaten).

De laatste stap is het converteren van de genormaliseerde coördinaten naar venstercoördinaten uitgedrukt in pixels.

Vóór de perspectiefverdeling worden primitieven samengevoegd en vervolgens afgesneden: alles wat niet binnen het bereik van de zichtbaarheid valt, wordt afgesneden. Vervolgens wordt elke primitief gerasterd, d.w.z. wordt vertaald in een reeks fragmenten. De reeks waarden die in de hoekpunten is gespecificeerd, wordt geïnterpoleerd en elk fragment krijgt een waarde die daarmee overeenkomt. Hierna wordt voor elk fragment een fragmentshader uitgevoerd, met als taak het berekenen van de kleur voor elk fragment. In dit geval worden geïnterpoleerde waarden gebruikt, het is mogelijk om toegang te krijgen tot texturen - vooraf voorbereide afbeeldingen die over de uitvoerprimitieven heen worden gelegd. Merk op dat elk fragment zijn eigen coördinaten op het scherm heeft en een dieptewaarde die wordt verkregen door interpolatie. Ook kan de fragmentarcering, in plaats van de kleur van het fragment te berekenen, expliciet het hele fragment verwijderen.

Bij de volgende stap van de pijplijn wordt voor elk fragment een groep controles uitgevoerd, die elk het gegeven fragment kunnen weggooien. Bij de eerste van deze controles wordt onderzocht of een bepaalde pixel overeenkomt met het zichtbare deel van het venster. Zo niet, dan wordt dit fragment onmiddellijk weggegooid. De volgende test controleert of het fragment zich binnen een bepaalde rechthoek bevindt (in venstercoördinaten). Er zijn ook stencil- en dieptetesten. De stenciltest haalt een groep bits op die overeenkomt met een bepaald fragment uit de stencilbuffer en controleert of aan de voorwaarde voor deze bits is voldaan. De dieptetest vergelijkt de diepte van een fragment met de overeenkomstige waarde uit de dieptebuffer. Elk van deze tests kan ertoe leiden dat het overeenkomstige fragment wordt weggegooid. Daarnaast is er een alfatest waarmee u fragmenten kunt weggooien op basis van de waarde van de alfacomponent van de kleur ervan.

Hierna wordt de stap uitgevoerd van het mengen van de kleur van het fragment met de kleur die overeenkomt met dit fragment in de kleurbuffer. Deze operatie nodig om translucent™ te ondersteunen.

De berekening van de kleurwaarde kan met veel grotere nauwkeurigheid worden uitgevoerd dan kan worden opgeslagen in een kleurbuffer. Meestal wordt de kleur in dit geval eenvoudigweg afgerond. Gebruik rasterisatie (dithering) biedt nog een optie: de kleur wordt gewijzigd zodat het gemiddelde van aangrenzende pixels de gewenste waarde geeft.

De laatste stap is om het gegeven bitsgewijze uit te voeren logische werking tussen de inhoud van de kleurbuffer en de resulterende kleurwaarde. Houd er rekening mee dat veel van deze tests en bewerkingen kunnen worden uitgeschakeld als ze niet nodig zijn; dit verbetert meestal de prestaties.

Als u een programma schrijft met OpenGL in C (of C++), moet u eerst het volgende headerbestand opnemen:

Om codecompatibiliteit en draagbaarheid te garanderen, introduceert OpenGL een aantal eigen gegevenstypen; de naam van elk van deze typen begint met het voorvoegsel GL. GLint komt overeen met het standaard integer-type, GLuint komt overeen met het standaard unsigned integer-type en GLfloat komt overeen met het float-type. OpenGL gebruikt ook verschillende speciale typen, zoals GLsizei, het type dat wordt gebruikt om de grootte in te stellen, en GLclampf, dat wordt gebruikt om de drijvende-kommawaarden in te stellen die op de lijn liggen.

Er wordt ook een speciaal type GLenum geïntroduceerd om het type waarden aan te geven dat overeenkomt met verschillende constanten.

De OpenGL-bibliotheek (evenals de GLU- en GLUT-bibliotheken die daarbij horen) hebben de neiging om een ​​vrij eenvoudige naamgevingsconventie te gebruiken voor constanten en functies. De namen van alle OpenGL-opdrachten (functies) beginnen met het voorvoegsel gl (voor functies uit de GLU- en GLUT-bibliotheken - respectievelijk met glu en glut).

De namen van alle constanten beginnen met GL_ (respectievelijk met GLU_ en GLUTJ.

Veel OpenGL-opdrachten hebben er meerdere verschillende opties, verschillend in het aantal doorgegeven argumenten en hun typen. In dit geval bevat de opdrachtnaam ook een speciaal achtervoegsel dat het aantal parameters bevat, en een achtervoegsel dat hun type specificeert. Dus de opdrachtnaam in OpenGL ziet er meestal als volgt uit:

glCommand(1 2 3 4)(b s i f d ub us ui)(v)

Een optioneel getal wordt gebruikt om het aantal doorgegeven argumenten te specificeren (in het geval dat er versies van deze opdracht zijn met ander nummer argumenten). Vervolgens komt een optioneel achtervoegsel van één of twee letters dat het type argumenten specificeert dat wordt doorgegeven (in het geval dat er versies van deze opdracht zijn die invoerwaarden accepteren verschillende soorten). Het achtervoegsel v geeft aan dat een aantal parameters (meestal de set van de laatste parameters) als een array wordt doorgegeven. In werkelijkheid ontvangt de functie een verwijzing naar deze array in plaats van naar deze parameters.

Het glVertex2i-commando heeft dus twee integer-argumenten, het glColor3f-commando heeft drie argumenten soort vlotter en de opdracht glColor4ubv heeft vier argumenten niet-ondertekend type byte, doorgegeven als een array (dat wil zeggen: wanneer de functie wordt aangeroepen, ontvangt deze slechts één argument: het adres van de array).

OpenGL is momenteel een van de meest populaire programmeerinterfaces (API's) voor het ontwikkelen van applicaties op het gebied van tweedimensionale en driedimensionale grafische afbeeldingen. De OpenGL-standaard is in 1992 ontwikkeld en goedgekeurd door toonaangevende softwareontwikkelingsbedrijven en is gebaseerd op de IRIS GL-bibliotheek ontwikkeld door Silicon Graphics.

Op dit moment omvat de OpenGL-implementatie verschillende bibliotheken (beschrijving van de basisfuncties van OpenGL, GLU, GLUT, GLAUX en andere), waarvan het doel hieronder zal worden beschreven.

De karakteristieke kenmerken van OpenGL die zorgden voor de verspreiding en ontwikkeling van deze grafische standaard zijn:

Stabiliteit - toevoegingen en wijzigingen aan de standaard worden zodanig geïmplementeerd dat compatibiliteit met eerder ontwikkelde software behouden blijft.

Betrouwbaarheid en draagbaarheid - applicaties die OpenGL gebruiken garanderen hetzelfde visuele resultaat, ongeacht het gebruikte type besturingssysteem en de organisatie van de weergave van informatie. Bovendien kunnen deze applicaties draaien op personal computers, werkstations en supercomputers.

Gebruiksgemak - De OpenGL-standaard heeft een goed doordachte structuur en een intuïtieve interface, waarmee u tegen lagere kosten efficiënte applicaties kunt maken met minder regels code dan andere grafische bibliotheken. De noodzakelijke functies om compatibiliteit met verschillende apparatuur te garanderen, zijn geïmplementeerd op bibliotheekniveau en vereenvoudigen de ontwikkeling van applicaties aanzienlijk.

Basis OpenGL-functies

Een reeks basisprimitieven: punten, lijnen, polygonen, enz.

Transformaties bekijken en coördineren

Onzichtbare lijnen en vlakken verwijderen (z-buffer)

Splines gebruiken om lijnen en oppervlakken te construeren

Texture mapping en verlichtingstoepassing

Speciale effecten toevoegen: mist, transparantie wijzigen, kleuren mengen, aliasing elimineren (anti-aliasing).

Zoals eerder vermeld, zijn er OpenGL-implementaties voor verschillende platforms, waarvoor het handig was om de basisfuncties van het grafische systeem en functies voor het weergeven van grafische informatie en interactie met de gebruiker te scheiden. Er zijn bibliotheken gemaakt voor het weergeven van informatie met behulp van het venstersubsysteem voor de Windows- en Unix-besturingssystemen (respectievelijk WGL en GLX), evenals de GLAUX- en GLUT-bibliotheken, die worden gebruikt om zogenaamde consoletoepassingen te maken.

De GLAUX-bibliotheek is qua populariteit inferieur aan de GLUT-bibliotheek die iets later is geschreven, hoewel ze ongeveer dezelfde mogelijkheden bieden. De GLU-bibliotheek omvat de implementatie van complexere functies, zoals een reeks populaire geometrische primitieven (kubus, bal, cilinder, schijf), functies voor het construeren van splines, implementatie van aanvullende bewerkingen op matrices, enz. Ze worden allemaal geïmplementeerd via basis OpenGL-functies.

Architectuur- en syntaxisfuncties

Vanuit architectonisch oogpunt is het grafische systeem OpenGL een pijplijn die bestaat uit verschillende fasen van gegevensverwerking:

Benadering van rondingen en oppervlakken

Vertexverwerking en primitieve assemblage

Rasterisatie en fragmentverwerking

Bewerkingen op pixels

De textuur voorbereiden

Gegevens overbrengen naar de framebuffer

Over het algemeen kan OpenGL worden vergeleken met een toestandsmachine, waarvan de toestand wordt bepaald door een reeks waarden van speciale variabelen (hun namen beginnen meestal met de tekens GL_) en de waarden van de huidige normale, kleur- en textuurcoördinaten. Al deze informatie zal worden gebruikt bij het invoeren van het hoekpuntcoördinatensysteem om de figuur te construeren waarin deze is opgenomen. Statusveranderingen vinden plaats met behulp van opdrachten, die worden uitgegeven als functieaanroepen.

INITIALISATIE VAN DE OpenGL-BIBLIOTHEEK IN C++

Allereerst moet u de headerbestanden opnemen:

#erbij betrekken

#erbij betrekken

#erbij betrekken

· gl.h en glu.h bevatten prototypen van de belangrijkste OpenGL-functies gedefinieerd in opengl32.dll en glu32.dll.

· glaux.h bevat hulpfuncties (glaux.dll).

Nadat u de headerbestanden hebt aangesloten, moet u het pixelformaat instellen. Hiervoor wordt de volgende functie gebruikt:

BOOL bSetupPixelFormat(HDC hdc)

PIXELFORMAATBESCHRIJVING pfd, *ppfd;

int pixelformaat;

ppfd->nSize = groottevan(PIXELFORMATDESCRIPTOR);

ppfd->nVersie = 1;

ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DUBBELEBUFFER;

ppfd->dwLayerMask = PFD_MAIN_PLANE;

ppfd->iPixelType = PFD_TYPE_RGBA;

ppfd->cColorBits = 16;

ppfd->cDepthBits = 16;

ppfd->cAccumBits = 0;

ppfd->cStencilBits = 0;

if ((pixelformaat = KiesPixelFormat(hdc, ppfd)) == 0)

MessageBox(NULL, "ChoosePixelFormat mislukt", "Fout", MB_OK);

if (SetPixelFormat(hdc, pixelformaat, ppfd) == ONWAAR)

MessageBox(NULL, "SetPixelFormat mislukt", "Fout", MB_OK);

De structuur van PIXELFORMATDESCRIPTOR moet gezegd worden.

cColorBits - kleurdiepte

cDepthBits - dieptebuffergrootte (Z-buffer)

cStencilBits - stencilbuffergrootte (we gebruiken het nog niet)

iPixelType - kleurspecificatieformaat. Kan de waarden PFD_TYPE_RGBA aannemen (de kleur wordt aangegeven door vier RGBA-parameters - rood, groen, blauw en alpha) en PFD_TYPE_COLORINDEX (de kleur wordt aangegeven door een index in het palet).

De functie ChoosePixelFormat() selecteert een pixelformaat en retourneert de handle ervan, en SetPixelFormat() stelt het in de apparaatcontext (dc).

Nadat het pixelformaat in de apparaatcontext is ingesteld, moet u hiervoor een afspeelcontext (Rendering Context) maken. In OpenGL zijn de volgende functies gedefinieerd:

HGLRC wglCreateContext(HDC hdc);

BOOL wglMakeCurrent(HDC hdc, HGLRC hglrc);

In de klassedeclaratie van het formulier, in het privégedeelte, moet u het volgende toevoegen:

ghRC - verwijzing naar de weergavecontext (Renderingcontext)

ghDC is een apparaathandvat (voor ons is het slechts een verwijzing naar een venster)

De tekenprocedure is verantwoordelijk voor het tekenen.

void __fastcall TForm1::FormCreate(TObject *Afzender)

ghDC = GetDC(Handvat);

if (!bSetupPixelFormat(ghDC))

ghRC = wglCreateContext(ghDC);

wglMakeCurrent(ghDC, ghRC);

glClearColor(0,0, 0,0, 0,0, 0,0);

Formaat wijzigen (afzender);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_DEPTH_TEST);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

zweven p=(3,3,3,1),

glLightfv(GL_LIGHT0,GL_POSITION,p);

glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,d);

glViewport(0, 0, Breedte, Hoogte);

glMatrixModus(GL_PROJECTION);

glLoadIdentity();

glOrtho(-5,5, -5,5, 2,12);

gluLookAt(0,0,5, 0,0,0, 0,1,0);

glMatrixModus(GL_MODELVIEW);

glClearColor() stelt de kleur in die het scherm vult bij het wissen. Deze procedure heeft 4 parameters, die overeenkomen met RGBA. In plaats daarvan kunt u glClearIndex(0.0) schrijven. Met deze procedure wordt de kleurindex in het palet ingesteld.

glViewport() stelt het uitvoergebied in - het gebied waarin OpenGL de afbeelding zal uitvoeren.

glMatrixMode() stelt de modus van de weergavetransformatiematrix in.

glLoadIdentity() vervangt de huidige weergavetransformatiematrix door een identiteitsmatrix.

glOrtho() stelt de orthogonale (rechthoekige) projectiemodus in. Dit betekent dat de afbeelding wordt getekend zoals in isometrie. 6 parameters van het GLdouble-type (of eenvoudigweg dubbel): links, rechts, onder, boven, dichtbij, ver bepalen de coördinaten van respectievelijk de linker, rechter, onder, boven, nabije en verre uitsnijvlakken, d.w.z. alles wat buiten deze grenzen valt, wordt niet getekend. In feite stelt deze procedure eenvoudigweg de schaal van de coördinaatassen in. Om de perspectiefprojectie in te stellen, worden de procedures glFrustum() en gluPerspective() gebruikt.

gluLookAt() stelt de cameraparameters in: de eerste drie zijn de coördinaten, de tweede is de richtingsvector, de derde is de richting van de Y-as.

In OpenGL wordt alles in- en uitgeschakeld (in- en uitgeschakeld) door de procedures glEnable() en glDisable().

glLightfv() stelt de eigenschappen van de "gloeilampen" in: de positie en richting van het licht.

Nadat u klaar bent met het werken met OpenGL, moet u de bezette bronnen vrijmaken: maak de context vrij door wglMakeCurrent aan te roepen met een null-parameter voor de OpenGL-context-ID en vernietig die context met wglDeleteContext. Bovendien moet u de ghDC-handgreep verwijderen. Omdat het werk met OpenGL meestal eindigt wanneer de applicatie wordt afgesloten, moet de bijbehorende code in FormClose worden geplaatst:

void __fastcall TForm1::FormClose(TObject *Sender, TSluitActie &Actie)

wglMakeCurrent(ghDC,0);

wglDeleteContext(ghRC);

ReleaseDC(Handvat, ghDC);

CONCLUSIE

Tijdens mijn stage van 5 juli tot en met 31 juli 2011 bij JSC Transas, afdeling Luchtvaart op de afdeling programmering, heb ik kennis gemaakt met de werkzaamheden van de afdeling programmering. Ik maakte kennis met het ontwerp en de werking van complexe vluchtsimulatoren ontwikkeld bij JSC Transas. Ik leerde over een systeem voor het visualiseren van landschappen en verschillende objecten genaamd Aurora. Ik heb de eerste praktische vaardigheden en capaciteiten verworven die nodig zijn om applicaties en software te ontwikkelen met behulp van een moderne programmeertaal en grafische bibliotheek op hoog niveau.