Illustrert opplæring på Visual Studio.NET. Opengl grafikkbibliotek

Å bli kjent med OpenGL må du begynne med det faktum at OpenGL er spesifikasjon. De. OpenGL definerer bare et sett med nødvendige funksjoner. Implementeringen avhenger av den spesifikke plattformen.
OpenGL er et språkuavhengig grafikk-API på tvers av plattformer. OpenGL er et lavt nivå API, så det er en god idé å ha litt forståelse av grafikk generelt og litt grunnleggende lineær algebra for å jobbe med det.

Navngivning

La oss si noen ord om navngivning av funksjoner i OpenGL. Først begynner navnene på alle funksjoner som leveres direkte av OpenGL med prefikset gl. For det andre har funksjoner som spesifiserer en bestemt parameter karakterisert ved et sett med tall (for eksempel en koordinat eller farge) et suffiks av formen [antall parametere + type parametere + representasjon av parametere].

Antall parametere - angir antall aksepterte parametere. Godtar følgende verdier: 1 , 2 , 3 , 4
Parametertype - indikerer hvilken type parametere som er akseptert. Følgende verdier er mulige: b, s, Jeg, f, d, ub, oss, ui. De. byte (char in C, 8-bits heltall), kort (16-bits heltall), int (32-bits heltall), float (flyttall), dobbel (dobbelt presisjon flyttallnummer), usignert byte, kort uten fortegn, usignert int (de tre siste er usignerte heltall)
Parameterrepresentasjon - indikerer i hvilken form parametrene sendes; hvis hvert tall er individuelt, skrives ingenting; hvis parametrene sendes som en matrise, legges en bokstav til funksjonsnavnet v

Eksempel: glVertex3iv spesifiserer toppunktkoordinaten, bestående av tre heltall som sendes som en peker til en matrise.

Grafisk kunst

Alle grafiske objekter i OpenGL er de en samling av punkter, linjer og polygoner. Det er 10 forskjellige primitiver som alle objekter er bygget med. Både todimensjonale og tredimensjonale. Alle primitiver er på sin side spesifisert av punkter - toppunkter.

GL_POINTS- hvert toppunkt definerer et punkt
GL_LINES- hvert enkelt hjørnepar definerer en linje
GL_LINE_STRIP- hvert hjørnepar definerer en linje (dvs. slutten av forrige linje er begynnelsen på neste)
GL_LINE_LOOP- lik den forrige, bortsett fra at det siste toppunktet er koblet til det første og en lukket figur oppnås
GL_TRIANGLES- hver enkelt trippel av hjørner definerer en trekant
GL_TRIANGLE_STRIP- hvert neste toppunkt definerer en trekant sammen med de to foregående (viser det seg bånd fra trekanter)
GL_TRIANGLE_FAN- hver trekant er definert av det første toppunktet og påfølgende par (dvs. trekantene er bygget rundt det første toppunktet, og danner noe som ligner på en diafragma)
GL_QUADS- hver fjerde topp danner en firkant
GL_QUAD_STRIP- Hver neste par vertekser danner en firkant sammen med et par tidligere
GL_POLYGON- definerer en polygon med antall vinkler lik antall gitte toppunkter

For å definere en primitiv, bruk konstruksjonen glBegin(primitiv_type)...glEnd(). Toppene er spesifisert glVertex*. Toppene settes mot klokken. Koordinatene settes fra øvre venstre hjørne av vinduet. Toppunktfargen settes av kommandoen glColor*. Farge er spesifisert som RGB eller RGBA. GlColor*-kommandoen virker på alle toppunktene som kommer etter den inntil en annen glColor*-kommando oppstår, eller på alle toppunktene hvis det ikke er andre glColor*-kommandoer.
Her er koden som tegner en firkant med forskjellig fargede hjørner:

glBegin (GL_QUADS) ;

glVertex2i(250, 450);

glVertex2i(250, 150);

glVertex2i(550, 150);

glVertex2i(550, 450);

glEnd() ;

Grunnleggende om OpenGL-programmet

For plattformuavhengig arbeid med vinduer kan du bruke . GLUT gjør arbeidet med OpenGL enklere.
For å initialisere GLUT i begynnelsen av programmet må du ringe glutInit(&argc, argv). For å stille inn visningsmodus, ring glutInitDisplayMode (modus), hvor modus kan ha følgende verdier:

GLUT_RGBA- inkluderer fire-komponent farge (standard)
GLUT_RGB- samme som GLUT_RGBA
GLUT_INDEX- inkluderer indeksert farge
GLUT_DOUBLE- muliggjør dobbel skjermbuffer
GLUT_SINGLE- aktiverer enkeltskjermbuffer (standard)
GLUT_DEPTH- aktiverer Z-buffer (dybdebuffer)
GLUT_STENCIL- inkluderer sjablongbuffer
GLUT_ACCUM- muliggjør akkumuleringsbuffer
GLUT_ALPHA- muliggjør alfablanding (gjennomsiktighet)
GLUT_MULTISAMPLE- muliggjør multisampling (anti-aliasing)
GLUT_STEREO- inkluderer stereobilde

For å velge flere moduser samtidig, bruk bitvis ELLER "|". For eksempel: glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH) aktiverer dobbel bufring, Z-buffer og quad color. Vindusstørrelsene er satt glutInitWindowSize(bredde, høyde). Hans posisjon er glutInitWindowPosition(x, y). Et vindu opprettes av funksjonen glutCreateWindow(window_title).
GLUT implementerer en hendelsesdrevet mekanisme. De. Det er en hovedsløyfe som starter etter initialisering, og alle deklarerte hendelsene er allerede behandlet i den. For eksempel å trykke på en tast på tastaturet eller flytte musepekeren osv. Du kan registrere hendelsesbehandlerfunksjoner ved å bruke følgende kommandoer:

void glutDisplayFunc (void (*func) (void))- setter funksjonen til å tegne et bilde
void glutReshapeFunc (void (*func) (int width, int height))- setter funksjonen for å behandle vinduets størrelse
void glutVisibilityFunc (void (*func)(int state))- setter funksjonen for å behandle endringer i vinduets synlighetstilstand
void glutKeyboardFunc (void (*func)(usignert tegnnøkkel, int x, int y))- setter funksjonen for behandling av tastaturtastetrykk (bare de som genererer ascii-tegn)
void glutSpecialFunc (void (*func)(int nøkkel, int x, int y))- setter funksjonen for behandling av tastaturtasttrykk (de som ikke genererer ascii-tegn)
void glutIdleFunc (void (*func) (void))- spesifiserer en funksjon som kalles når det ikke er andre hendelser
void glutMouseFunc (void (*func) (int-knapp, int-tilstand, int x, int y))- definerer en funksjon som behandler musekommandoer
void glutMotionFunc (void (*func)(int x, int y))- definerer en funksjon som behandler bevegelsen til musepekeren når en museknapp trykkes
void glutPassiveMotionFunc (void (*func)(int x, int y))- definerer en funksjon som behandler bevegelsen til musepekeren når ingen museknapp trykkes
void glutEntryFunc (void (*func)(int state))- definerer en funksjon som håndterer markørbevegelse utenfor vinduet og retur
void glutTimerFunc (usignert int msecs, void (*func)(int verdi), verdi)- spesifiserer en funksjon kalt på en timer

Deretter kan du starte hovedsløyfen glutMainLoop().

Første program

Nå vet vi det grunnleggende om å jobbe med OpenGL. Du kan skrive et enkelt programå konsolidere kunnskap.
La oss starte med å inkludere GLUT-hodefilen:

Nå vet vi allerede hva vi skal skrive i hovedsak. La oss registrere to behandlere: for å tegne innholdet i vinduet og for å behandle endring av størrelse. Disse to behandlerne brukes i hovedsak i alle programmer som bruker OpenGL og GLUT.

int main (int argc, char * argv)

glutInit(& argc, argv) ;

glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*Aktiver dobbel buffering og fire-komponent farge*/

glutInitWindowSize(800, 600) ;

glutCreateWindow("OpenGL leksjon 1" ) ;

glutReshapeFunc(reshape) ;

glutDisplayFunc(display) ;

glutMainLoop() ;

returner 0 ;

Nå må vi skrive en behandlerfunksjon for å endre størrelse på vinduer. La oss sette bildeutdataområdet til å være på størrelse med hele vinduet ved å bruke kommandoen glViewport(x, y, width, height). Last deretter projeksjonsmatrisen glMatrixMode(GL_PROJECTION), erstatt den med enhet glLoadIdentity() og still inn den ortogonale projeksjonen. Og til slutt, last inn modellvisningsmatrisen glMatrixMode(GL_MODELVIEW) og erstatte den med en enhet.
Som et resultat får vi:

void omforming (int w, int h)

glViewport(0 , 0 , w, h) ;

glMatrixMode(GL_PROJECTION) ;

glLoadIdentity() ;

gluOrtho2D(0 , w, 0 , h) ;

glMatrixMode(GL_MODELVIEW) ;

glLoadIdentity() ;

Det gjenstår bare å skrive en funksjon for å tegne innholdet i vinduet. Vi vil tegne firkanten som jeg ga ovenfor som et eksempel. Du må legge til veldig lite kode. Først, før du tegner, må du fjerne forskjellige buffere ved hjelp av glClear (modus). Brukes på samme måte som glutInitDisplayMode. Mulige verdier:

GL_COLOR_BUFFER_BIT- for å tømme fargebufferen
GL_DEPTH_BUFFER_BIT- for å tømme dybdebufferen
GL_ACCUM_BUFFER_BIT- for å tømme akkumuleringsbufferen
GL_STENCIL_BUFFER_BIT- for rengjøring av skjermbufferen

I vårt tilfelle trenger vi bare å tømme fargebufferen, fordi Vi bruker ikke andre. For det andre, etter å ha tegnet, må du be OpenGL om å endre skjermbufferne ved hjelp av glutSwapBuffers(), fordi vi har dobbeltbuffring aktivert. Alt tegnes på en buffer skjult for brukeren og deretter endres bufferne. Dette gjøres for å få jevn animasjon og slik at det ikke er noen effekt flimre skjerm.
Vi får:

void display()

glClear(GL_COLOR_BUFFER_BIT) ;

glBegin(GL_QUADS) ;

glColor3f(1.0 ; 1.0 ; 1.0 );

glVertex2i(250, 450);

glColor3f(0,0; 0,0; 1,0);

glVertex2i(250, 150);

glColor3f(0.0; 1.0; 0.0);

glVertex2i(550, 150);

glColor3f(1.0 ; 0.0 ; 0.0 ) ;

glVertex2i(550, 450);

glEnd() ;

glutSwapBuffers() ;

Bunnlinjen

Alle! Kan kompileres. Det skal se omtrent slik ut:

INTRODUKSJON

OpenGL er et av de mest populære applikas(API - Application Programming Interface) for utvikling av applikasjoner innen todimensjonale og 3D-grafikk.

OpenGL-standarden (Open Graphics Library) ble utviklet og godkjent i 1992 av ledende selskaper innen utvikling programvare som et effektivt maskinvareuavhengig grensesnitt egnet for implementering på ulike plattformer. Standarden er basert på IRIS GL-biblioteket, utviklet av Silicon Graphics Inc.

Biblioteket inneholder rundt 120 forskjellige kommandoer som programmereren bruker for å spesifisere objektene og operasjonene som er nødvendige for å skrive interaktive grafiske applikasjoner.

Dagens grafikk OpenGL system støttes av de fleste maskinvareprodusenter og programvareplattformer. Dette systemet er tilgjengelig for de som jobber i Windows-miljø, brukere av Apple-datamaskiner. Den fritt tilgjengelige Mesa-koden (en OpenGL-basert API-pakke) kan kompileres på de fleste operativsystemer, inkludert Linux.

De karakteristiske egenskapene til OpenGL som sørget for spredning og utvikling av denne grafikkstandarden er:

Stabilitet. Tillegg og endringer i standarden er implementert på en slik måte at kompatibilitet med tidligere utviklet programvare opprettholdes.

Pålitelighet og portabilitet. Applikasjoner som bruker OpenGL garanterer det samme visuelle resultatet uavhengig av hvilken type programvare som brukes. operativsystem og organisering av informasjonsvisning. I tillegg kan disse applikasjonene kjøres på begge personlige datamaskiner, og på arbeidsstasjoner og superdatamaskiner.

Brukervennlighet. OpenGL-standarden har en gjennomtenkt struktur og et intuitivt grensesnitt, som lar deg lage effektive applikasjoner, som inneholder færre linjer med kode enn å bruke andre grafikkbiblioteker. De nødvendige funksjonene for å sikre kompatibilitet med diverse utstyr er implementert på biblioteksnivå og forenkler applikasjonsutviklingen betydelig.

Tilgjengelighet av gode grunnpakke for arbeid med 3D-applikasjoner gjør det lettere for studentene å forstå hovedemnene i datagrafikkkurset - modellering av 3D-objekter, skyggelegging, teksturering, animasjon, etc. Den omfattende funksjonaliteten til OpenGL gir et godt grunnlag for å presentere teoretisk og praktiske aspekter Emne.

PROGRAMMERING VED BRUK AV OPENGL LIBRARY

Hensikten med og funksjonene til OpenGL-biblioteket

For å forenkle utviklingen av programmer i C++-språket finnes det et stort nummer av ferdige biblioteker med implementering av algoritmer for spesifikke fagområder, fra numeriske beregninger til talegjenkjenning. Åpent bibliotek GL er et av de mest populære programmeringsgrensesnittene (API) for å jobbe med 3D-grafikk. OpenGL-standarden ble godkjent i 1992 av ledende programvareutviklingsfirmaer. Det var basert på IRIS GL-biblioteket, utviklet av Silicon Graphics basert på konseptet med en grafikkmaskin ved Stanford University (1982).

OpenGL står for Open Graphics Library. Programmer som bruker OpenGL garanterer de samme visuelle resultatene på mange operativsystemer – på personlige datamaskiner, på arbeidsstasjoner og på superdatamaskiner.

Fra en programmerers perspektiv er OpenGL et programmeringsgrensesnitt for grafikkenheter (som grafikkakseleratorer). Den inkluderer rundt 150 forskjellige funksjoner som programmereren kan bruke til å stille inn egenskapene til forskjellige tredimensjonale og todimensjonale objekter og utføre visualisering (gjengivelse) av dem. De. i programmet må du angi plasseringen av objekter i tredimensjonalt rom, definere andre parametere (rotasjon, strekking), angi egenskapene til objekter (farge, tekstur, materiale, etc.), posisjonen til observatøren, og deretter OpenGL-biblioteket vil generere en todimensjonal projeksjon av denne tredimensjonale scenen.

Vi kan si at OpenGL-biblioteket er et bibliotek kun for å visualisere 3D-scener (gjengivelsesbibliotek). Den støtter ikke noen eksterne enheter (som tastatur eller mus) og inneholder ikke verktøy for å administrere skjermvinduer. Sikre samhandling eksterne enheter med OpenGL-biblioteket på et spesifikt operativsystem er en programmerers oppgave.

De viktigste OpenGL-funksjonene som er gitt til programmereren kan deles inn i flere grupper:

1. Geometriske og rasterprimitiver. Alle andre objekter er bygget på grunnlag av disse primitivene. Geometriske primitiver er punkter, linjestykker og polygoner. Rasterprimitiver er punktgrafikk og bilder.

2. Splines. Splines brukes til å konstruere jevne kurver ved å bruke referansepunkter.

3. Se og modeller transformasjoner. Disse transformasjonene lar deg spesifisere den romlige plasseringen til objekter, endre formen på objekter og angi posisjonen til kameraet som OpenGL bygger det resulterende projeksjonsbildet for.

4. Arbeid med farger. For operasjoner med farge i OpenGL er det en RGBA-modus (rød - grønn - blå - gjennomsiktighet) og en indeksmodus (fargen er spesifisert av et serienummer i paletten).

5. Fjerne usynlige linjer og overflater.

6. Dobbel bufring. Både enkel og dobbel buffering er tilgjengelig i OpenGL. Dobbel bufring brukes for å eliminere flimmer under animasjon. I dette tilfellet blir bildet av hver ramme først tegnet i en usynlig buffer, og rammen kopieres til skjermen først etter at den er helt tegnet.

7. Teksturoverlegg. Teksturer gjør det lettere å lage realistiske scener. Hvis en tekstur (noen bilde) påføres et objekt, for eksempel en kule, vil objektet se annerledes ut (for eksempel vil kulen se ut som en flerfarget ball).

8. Utjevning. Automatisk kantutjevnelse kompenserer for ujevnheter som er vanlig på rasterskjermer. Når du jevner ut segmenter, endrer OpenGL intensiteten og fargen på pikslene slik at disse segmentene vises på skjermen uten sikksakk."

9. Belysning. Spesifisere plasseringen, intensiteten og fargen til lyskildene.

10. Spesialeffekter. For eksempel tåke, røyk, gjennomsiktighet av gjenstander. Disse verktøyene gjør scener mer realistiske.

Selv om OpenGL-biblioteket gir nesten alle funksjonene for modellering og gjengivelse av 3D-scener, er noen grafiske funksjoner direkte i OpenGL er ikke tilgjengelige. For å stille inn posisjonen og retningen til kameraet for å observere en scene, må du for eksempel beregne projeksjonsmatrisen, som innebærer ganske tungvinte beregninger. Derfor finnes det såkalte hjelpebiblioteker for OpenGL.

Et av disse bibliotekene heter GLU. Dette biblioteket er en del av standarden og kommer med OpenGL-hovedbiblioteket. GLU inneholder mer enn komplekse funksjoner(for eksempel kreves det bare én kommando for å lage en sylinder eller disk). GLU-biblioteket har også funksjoner for arbeid med splines, tilleggsoperasjoner på matriser og flere typer projeksjoner.

To mer kjente biblioteker er GLUT (for Unix) og GLAUX (for MS Windows). Ikke bare gir de ekstra OpenGL-funksjonalitet (for å bygge noen komplekse former som kjegler og tetraeder), men de har også funksjoner for å jobbe med vinduer, tastatur og mus i konsollapplikasjoner. For å jobbe med OpenGL på et spesifikt operativsystem (for eksempel Windows eller Unix), må du gjøre en foreløpig konfigurasjon, som avhenger av operativsystemet. GLUT og GLAUX lar deg bokstavelig talt definere vinduet der OpenGL skal fungere med bare noen få kommandoer, og angi funksjoner for å behandle kommandoer fra tastaturet eller musen.

Mulighetene til OpenGL er beskrevet gjennom biblioteksfunksjonene. Alle funksjoner kan deles inn i fem kategorier.

Primitive beskrivelsesfunksjoner definerer objekter på det lavere nivået av hierarkiet (primitiver) som grafikkundersystemet er i stand til å vise. I OpenGL er primitiver punkter, linjer, polygoner osv.

Lyskildebeskrivelsesfunksjoner brukes til å beskrive posisjonen og parametrene til lyskilder som befinner seg i en tredimensjonal scene.

Funksjoner for innstilling av attributter. Ved å angi attributter, bestemmer programmereren hvordan viste objekter vil se ut på skjermen. Med andre ord, mens primitiver definerer hva som skal vises på skjermen, definerer attributter hvordan det skal vises. OpenGL lar deg angi farge, materialegenskaper, teksturer og lysparametere som attributter.

Visualiseringsfunksjonen lar deg stille inn posisjonen til observatøren virtuelt rom, kameralinseparametere. Når du kjenner til disse parameterne, vil systemet ikke bare være i stand til å konstruere et bilde på riktig måte, men også å kutte av objekter som er utenfor synsfeltet.

Funksjonssett geometriske transformasjoner la programmereren gjøre det ulike transformasjoner objekter - rotasjon, translasjon, skalering.

Samtidig kan OpenGL utføre tilleggsoperasjoner, som å bruke splines for å konstruere linjer og overflater, fjerne usynlige deler av bilder, jobbe med bilder på pikselnivå, etc.

I dette kapittelet vil vi se på gjengivelse av 3D-grafikk ved hjelp av OpenGL-biblioteket, studere GLU- og GLUT-bibliotekene (FreeGLUT-biblioteket brukes i stedet for sistnevnte på Linux), og analysere prosessen med å laste inn teksturer ved å bruke SOIL- og DevIL-bibliotekene.

Som allerede nevnt i kap. 9, Grafikkprogrammerere jobber vanligvis ikke direkte med GPU. Dette skyldes både at det finnes mange forskjellige GPUer, og fordi lavnivåarbeid med GPUer er ganske komplekst og vanligvis gjøres av driverutviklere. I stedet bruker de forskjellige APIer som gir noe mer grensesnitt høy level for arbeid med GPU. Dette grensesnittet abstraherer bort den spesifikke GPUen (som alt håndteres gjennom en driver, vanligvis levert av GPU-produsenten), slik at du kan skrive bærbar kode som fungerer på tvers av forskjellige GPUer. En slik API skjuler også en rekke detaljer på lavt nivå om arbeid med GPU fra programmereren.

De viktigste APIene for 3D-grafikkprogrammering for øyeblikket er OpenGL og Dircct3D. Sistnevnte er kun plattformspesifikk Microsoft Windows. Denne boken dekker det grunnleggende om å jobbe med OpenGL. Dette er et kryssplattform-API som støtter alle større operativsystemer (Windows, Linux, Mac OS X) og lar deg jobbe med stort beløp ulike GPUer.

Det er en versjon av API - OpenGL ES, designet for å fungere på mobile enheter. Med dens hjelp kan du lage tredimensjonal grafikk for iOS-plattformer og Android. I tillegg kommer WebGL, et bibliotek som lar deg bruke OpenGL ES direkte i nettleservinduet ved hjelp av javascript. Det er også bindinger for OpenGL som fungerer med alle store programmeringsspråk, noe som gjør det enkelt å bruke OpenGL fra nesten alle programmeringsspråk.

Hovedoppgaven til OpenGL er å gjengi to- og tredimensjonal grafikk. Dessuten omhandler ikke denne API-en i det hele tatt å lage vinduer for gjengivelse, lese input fra brukeren og annet lignende arbeid som er svært avhengig av det spesifikke operativsystemet, så vi vil bruke GLUT-biblioteket på tvers av plattformer til disse formålene. Dette biblioteket gir enkel og praktisk måte for å lage vinduer, gjengi dem ved hjelp av OpenGL, og motta meldinger fra mus og tastatur.

Fra et arkitektonisk synspunkt er OpenGL bygget på modellen klient server. I dette tilfellet fungerer selve programmet, som bruker OpenGL, som en klient, og GPUen og dens driver fungerer som en server. Vanligvis kjører programmet på samme datamaskin der GPUen er installert, men dette er ikke nødvendig.

I praksis blir alle OpenGL-kommandoer som utføres bufret og deretter satt i kø for overføring til GPU. Dermed indikerer utførelsen av en CPU-kommando bare det denne kommandoen kom inn i bufferen eller ble lagt til køen; det er ganske mulig at GPU-en ennå ikke har begynt å utføre den. Samtidig kan OpenGL betraktes som statsmaskin- han har sin egen tilstand. Den eneste måten å endre denne tilstanden på er å bruke OpenGL-kommandoer. OpenGL-tilstanden endres ikke mellom kommandoer.

Et viktig konsept i OpenGL er buffere (Figur 10.1). For å gjengi må de nødvendige bufferne opprettes. Fargebuffer brukes alltid og lagrer fargen for hver piksel som et 24-bits tall i RGB-format(8 bits for hver av grunnfargene - rød, grønn og blå) eller som 32-biter RGBA-format(en fjerde komponent legges til standard tre komponentene - alfa, som setter opasiteten).

Når du bruker r-buffermetoden for å fjerne usynlige overflater, må du lagre den tilsvarende dybdeverdien for hver piksel (vanligvis lagres dybdeverdien som et 16-, 24- og 32-biters heltall). Følgelig dannes alle dybdeverdier samlet dybdebuffer. Du kan også bruke sjablongbuffer, akkumuleringsbuffer.

Når du oppretter et vindu å gjengi til, må du opprette en OpenGL-kontekst og de riktige bufferne. Selve konteksten er vanligvis knyttet til den gjeldende tråden, så hvis en applikasjon bruker flere tråder, kan den opprettede konteksten egentlig bare brukes fra tråden der den ble opprettet.

Databehandling i OpenGL er basert på renderingspipeline (se figur 9.1). Rørledningen definerer hovedstadiene i behandlingen av innkommende data. Hvor nøyaktig dataene vil bli behandlet avhenger av OpenGL-tilstandsparameterne, men selve disse stadiene og rekkefølgen de oppstår i er strengt fastsatt.

Ris. 10.1.

For moderne GPUer er to deler av denne rørledningen representert av programmer som kjører på GPUen, kalt shaders. Deretter vil vi vurdere OpenGL versjon 2, der disse programmene ikke trenger å spesifiseres eksplisitt: det er shaders som fungerer som standard (det vil si i tilfellet når programmereren ikke eksplisitt har spesifisert de tilsvarende shaders). Fra og med versjon 3 krever OpenGL obligatoriske shaders og bryter delvis kompatibiliteten med tidligere versjoner, og det er derfor vi vil vurdere OpenGL-versjon 2.

Geometri er definert som et sett med toppunkter som danner ulike primitiver (punkter, segmenter, trekanter). Ved hvert toppunkt, i tillegg til koordinatene, kan du også angi en rekke tilleggsattributter, for eksempel farge, normal, teksturkoordinater. Dataene ved hvert toppunkt er inngangen til toppunktskyggeren: for hvert toppunkt kjører og genererer toppunktsskyggeren noen utgangsverdier. Den nødvendige utgangsverdien er de ensartede toppunktkoordinatene etter at alle transformasjoner er utført.

OpenGL bruker 4x4-matriser for toppunkttransformasjon - modellvisningsdesignmatrisen (Figur 10.2). Hvis en toppunktskyggelegging ikke er spesifisert, brukes standard toppunktskyggelegging, som multipliserer toppunktkoordinatene (som en vektor i homogene koordinater) først med modellvisningsmatrisen og deretter med designmatrisen.

Etter dette settes primitivene sammen og kuttes av: alle deler av hver primitiv som strekker seg utover det synlige området (ser frustum) blir automatisk trimmet slik at primitiver som er fullstendig inneholdt i scope, overføres til neste trinn av rørledningen. Deretter utfører den faste delen av rørledningen perspektivdeling - vektoren i homogene koordinater er delt inn i sin fjerde komponent.

Ris. 10.2.

Hvis koordinatene opprinnelig ble spesifisert i deres eget koordinatsystem, overfører multiplikasjon med modellvisningsmatrisen dem til kameraets koordinatsystem. Ytterligere multiplikasjon med projeksjonsmatrisen bringer koordinatene til klipp plass. Etter å ha utført perspektivdelingen får vi normaliserte enhetskoordinater (normaliserte enhetskoordinater).

Det siste trinnet er å konvertere de normaliserte koordinatene til vinduskoordinater uttrykt i piksler.

Før perspektivdelingen blir primitiver satt sammen og deretter kuttet av: alt som ikke faller innenfor synlighet, kuttes av. Deretter rastreres hver primitiv, dvs. er oversatt til et sett med fragmenter. Serien med verdier spesifisert i toppunktene er interpolert, og hvert fragment får en verdi som tilsvarer det. Etter dette utføres en fragmentskyggelegging for hvert fragment, hvis oppgave er å beregne fargen for hvert fragment. I dette tilfellet brukes interpolerte verdier, det er mulig å få tilgang til teksturer - forhåndsforberedte bilder som er lagt over utgangsprimitivene. Vær oppmerksom på at hvert fragment har sine egne koordinater på skjermen og en interpolert dybdeverdi. I stedet for å beregne fargen på fragmentet kan fragmentskyggeren også forkaste hele fragmentet.

Ved neste trinn i rørledningen utføres en gruppe kontroller for hvert fragment, som hver kan kaste det gitte fragmentet. Den første av disse kontrollene undersøker om en gitt piksel tilsvarer den synlige delen av vinduet. Hvis ikke, blir dette fragmentet umiddelbart forkastet. Neste test sjekker om fragmentet er inneholdt i det gitte rektangelet (i vinduskoordinater). Det finnes også sjablong- og dybdetester. Sjablongtesten henter en gruppe biter som tilsvarer et gitt fragment fra sjablongbufferen og kontrollerer at betingelsen for disse bitene er oppfylt. Dybdetesten sammenligner dybden til et fragment med den tilsvarende verdien fra dybdebufferen. Hver av disse testene kan føre til at det tilsvarende fragmentet blir kastet. I tillegg er det en alfa-test som lar deg forkaste fragmenter basert på verdien av alfa-komponenten i fargen.

Etter dette utføres trinnet med å blande fargen på fragmentet med fargen som tilsvarer dette fragmentet i fargebufferen. Denne operasjonen nødvendig for å støtte translucent™.

Fargeverdiberegningen kan gjøres med mye større presisjon enn det som kan lagres i en fargebuffer. Vanligvis i dette tilfellet er fargen ganske enkelt avrundet. Bruk rasterisering (rastring) gir et annet alternativ: fargen endres slik at gjennomsnittet av tilstøtende piksler gir ønsket verdi.

Det siste trinnet er å utføre den gitte bitvis logisk operasjon mellom innholdet i fargebufferen og den resulterende fargeverdien. Merk at mange av disse testene og operasjonene kan slås av hvis de ikke er nødvendige - dette forbedrer vanligvis ytelsen.

Hvis du skriver et program med OpenGL i C (eller C++), er det første du må gjøre å inkludere følgende overskriftsfil:

For å sikre kodekompatibilitet og portabilitet introduserer OpenGL en rekke egne datatyper, navnet på hver av disse typene begynner med prefikset GL. GLint matcher standard type heltall, GLuint-typen er standard heltallstype uten fortegn, og GLfloat er flytetypen. OpenGL bruker også flere spesielle typer, for eksempel GLsizei, som betegner typen som brukes til å spesifisere størrelsen, og GLclampf, som brukes til å spesifisere flyttallsverdier som ligger på linjen.

En spesiell type GLenum er også introdusert for å indikere typen verdier som tilsvarer forskjellige konstanter.

OpenGL-biblioteket (så vel som GLU- og GLUT-bibliotekene som følger med) har en tendens til å bruke en ganske enkel navnekonvensjon for konstanter og funksjoner. Navnene på alle OpenGL-kommandoer (funksjoner) begynner med prefikset gl (for funksjoner fra GLU- og GLUT-bibliotekene - med henholdsvis glu og glut).

Navnene på alle konstanter begynner med GL_ (henholdsvis med GLU_ og GLUTJ.

Mange OpenGL-kommandoer har flere ulike alternativer, forskjellig i antall beståtte argumenter og deres typer. I dette tilfellet inkluderer kommandonavnet også et spesielt suffiks som inneholder antall parametere og et suffiks som spesifiserer deres type. Så kommandonavnet i OpenGL ser vanligvis slik ut:

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

Et valgfritt tall brukes til å spesifisere antall argumenter som er bestått (i tilfellet der det finnes versjoner av denne kommandoen med annet nummer argumenter). Deretter kommer et valgfritt suffiks på en eller to bokstaver som spesifiserer typen argumenter som sendes (i tilfellet der det er versjoner av denne kommandoen som godtar inngangsverdier forskjellige typer). v-suffikset indikerer at en rekke parametere (vanligvis et sett siste parametere) sendes som en matrise - i virkeligheten mottar funksjonen en peker til denne matrisen i stedet for disse parameterne.

Dermed har glVertex2i-kommandoen to heltallsargumenter, glColor3f-kommandoen har tre flytargumenter, og glColor4ubv-kommandoen har fire argumenter. usignert type byte, sendt som en matrise (det vil si at når funksjonen kalles, mottar den bare ett argument - adressen til matrisen).

Send ditt gode arbeid i kunnskapsbasen er enkelt. Bruk skjemaet nedenfor

Studenter, hovedfagsstudenter, unge forskere som bruker kunnskapsbasen i studiene og arbeidet vil være deg veldig takknemlig.

postet på http://www.allbest.ru/

OpenGL er et programvaregrensesnitt til grafisk maskinvare. Dette grensesnittet består av omtrent 250 separate kommandoer (ca. 200 kommandoer i OpenGL selv og ytterligere 50 i verktøybiblioteket) som brukes til å spesifisere objektene og operasjonene som må utføres for å produsere en interaktiv 3D-grafikkapplikasjon. opengl grafisk programmeringsgrensesnitt

OpenGL-biblioteket er designet som et generalisert, uavhengig grensesnitt som kan implementeres på en rekke maskinvare. Av denne grunn inkluderer ikke OpenGL i seg selv funksjoner for å lage vinduer eller for å fange brukerinndata; For disse operasjonene må du bruke verktøyene til operativsystemet du arbeider i. Av samme grunner har ikke OpenGL funksjoner på høyt nivå for å beskrive modeller av 3D-objekter. Slike kommandoer vil tillate deg å beskrive relativt komplekse former, for eksempel biler, menneskelige kroppsdeler eller molekyler. Når du bruker OpenGL-biblioteket, må du bygge de nødvendige modellene ved å bruke et lite sett med geometriske primitiver - punkter, linjer og polygoner (polygoner).

Imidlertid kan et bibliotek som gir de beskrevne egenskapene bygges på toppen av OpenGL. OpenGL Utility Library (GLU) gir mange modelleringsverktøy, for eksempel kvadriske overflater, kurver og NURBS-overflater. GLU er en standard del av enhver OpenGL-implementering. Det finnes også biblioteker på høyere nivå, for eksempel Fahrenheit Scene Graph (FSG), som er bygget ved hjelp av OpenGL og distribuert separat for mange av implementeringene.

Følgende liste beskriver kort de grunnleggende grafikkoperasjonene som OpenGL utfører for å vise bilder på skjermen.

1. Konstruerer figurer fra geometriske primitiver, skaper matematisk beskrivelse objekter (primitiver i OpenGL er punkter, linjer, polygoner, punktgrafikk og bilder).

2. Plasserer objekter i tredimensjonalt rom og velger et observasjonspunkt for å se den resulterende komposisjonen.

3. Beregner farger for alle objekter. Farger kan bestemmes av applikasjonen, avledet fra lysforhold, beregnet ved hjelp av teksturer brukt på objekter, eller en hvilken som helst kombinasjon av disse faktorene.

4. Konverterer en matematisk beskrivelse av objekter og tilhørende fargeinformasjon til piksler på skjermen. Denne prosessen kalles rasterisering (eller rasterisering).

I løpet av alle disse stadiene kan OpenGL utføre andre operasjoner, for eksempel å fjerne deler av objekter som er skjult av andre objekter. I tillegg til dette, etter at scenen er rasterisert, men før den er gjengitt på skjermen, kan du utføre noen operasjoner på pikseldataene om nødvendig.

Den generelle prosedyren for å jobbe med OpenGl-biblioteket er som følger:

1. Initialiser vinduet (hent området for visning av bildet)

2. Installer kameraet

3. Slå på lyset (om nødvendig)

4. I løkken, begynn å tegne primitiver (punkter, linjer, polygoner), tøm først vinduet fra forrige tegning.

Initialiserer vinduet.

Hvis du jobber i Visual C++, opprettes vinduet ved hjelp av funksjonene

auxInitDisplayMode

Hovedramme-tegnesløyfen opprettes i Tegn-funksjonen og registreres ved hjelp av funksjonen

auxMainLoop(Tegne);

static void CALLBACK Draw(void) // opprettet av bruker

// plassering av OpenGL-vinduet på skjermen

auxInitPosition(100, 100, windowW, windowH);

// sette grunnleggende parametere OpenGL fungerer

// fargemodus RGB | aktiverer Z-buffer for dybdesortering

// |Dobbel bufring

auxInitDisplayMode(AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

// initialiser OpenGL-vinduet med Title

if(auxInitWindow("Eksempel1") ==GL_FALSE) auxQuit();

// registrere en funksjon som kalles ved omtegning

// og start hendelsessløyfen

// Draw() - brukerfunksjon

auxMainLoop(Tegne);

Hvis du jobber i Borland C++ Builder, så for å initialisere vinduet, må du få Handle ( unik identifikator Windows-vinduer) i vinduet du skal tegne. Håndtak finnes i alle applikasjonsvinduer på toppnivå og i de fleste underordnede vinduer. I våre eksempler vil vi tegne på et StaticText underordnet vindu.

Deretter må vi lage en tegnekontekst (enhetskontekst) og angi formatet. For å gjøre dette initialiseres PIXELFORMATDESCRIPTOR-strukturen (pikselbeskrivelsesformat). Denne strukturen beskriver om vi trenger støtte for en dybdebuffer, dobbel buffering osv.).

Følg deretter funksjonene:

Velg PixelFormat

En OpenGL-tegningskontekst opprettes:

wglCreateContext(hdc);

Og så er OpenGL- og Windows-kontekstene koblet sammen:

wglMakeCurrent(hdc, hrc)

void __fastcall TFormMain::FormCreate(TObject *Sender)

// ta HANDLE i StaticText-vinduet

statisk HWND Håndtak=a->Håndtak;

// lag et tegningsstedhåndtak for StaticText-vinduet

hdc = GetDC(Håndtak);

// angi de riktige enhetskontekstinnstillingene

PIXELFORMATDESCRIPTOR pfd = (

sizeof(PIXELFORMATDESCRIPTOR),

PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,

// velg riktig format

PixelFormat = ChoosePixelFormat(hdc, &pfd);

SetPixelFormat(hdc, PixelFormat, &pfd);

// opprett en enhetskontekst for OpenGL

// ved å bruke tegneplasshåndtaket

hrc = wglCreateContext(hdc);

ShowMessage(":-)~ hrc == NULL");

if(wglMakeCurrent(hdc, hrc) == usann)

ShowMessage("Kunne ikke lage gjeldende");

Kamera installasjon

Som standard er kameraet plassert ved origo (0, 0, 0), pekt langs den negative z-aksens retning, og retningsvektoren opp er (0, 1, 0).

For å installere kameraet er det praktisk å bruke gluLookAt()-funksjonen. Selv om den har 9 parametere, er de enkle å forstå. De er delt inn i tre parametere, henholdsvis for tre punkter: Eye (Eye), Center, Up.

Øyet bestemmer punktet vi ser fra, senteret bestemmer hvor vi ser, og vektoren til toppen bestemmer hvor vi skal ha toppen (forestill deg en pilot i et fly som flyr hodet ned). Det er praktisk å omslutte vektorer i klasser med overstyrte operasjoner.

gluLookAt(e.x,e.y,e.z, c.x,c.y,c.z, u.x,u.y,u.z);

Hovedsløyfen inkluderer følgende rammetegningstrinn:

1. Fjerne buffere fra å tegne det forrige bildet

2. Funksjoner for å tegne primitiver

3. Funksjoner for å fullføre tegningen og vente på svar fra skjermkortet

4. Funksjoner for å kopiere bilder fra minne til skjerm

Hovedsløyfen inkluderer ikke håndtering av hendelser som tastetrykk og endring av vindu. For å behandle hendelser opprettes det separate funksjoner som i tillegg legges til applikasjonen.

Hvis du jobber i Visual C, så gjøres dette ved å bruke funksjoner hvis prototyper er beskrevet i glaux.h-filen:

auxReshapeFunc()

Hvis du jobber i Borland C, utføres hendelsesbehandling på en tradisjonell måte for de som er opprettet av dette programvaremiljøet: du velger ganske enkelt en komponent (for eksempel Button1), oppretter en behandler (for eksempel et tastetrykk) og inni beskriv hoveddelen av funksjonen.

Å tegne primitiver

Å tegne primitiver gjøres med kommandoene glBegin() og glEnd().

Konstanten som sendes til glBegin-funksjonen bestemmer typen primitiv som skal tegnes

Koordinatene til punktene er spesifisert av en tredimensjonal romlig vektor. Farger spesifiseres av tre (RGB) eller fire (RGBA) parametere. I vårt eksempel kan verdien av fargekomponenten til hver farge varieres fra 0 til 1. Hvis du er vant til verdien av fargekomponenten fra 0 til 255 (MsPaint), så bruk glColor3ub(255,0,0 ) funksjon. Suffikset ub betyr usignert byte.

Belysning inn Data-grafikk har 3 komponenter

Bakgrunnsstråling er lys som er så fordelt av omgivelsene (gjenstander, vegger osv.) at retningen ikke kan bestemmes – det ser ut til å komme fra overalt. Lampe dagslys har en stor bakgrunnskomponent fordi det meste av lyset som når øyet ditt først reflekteres fra mange overflater. gatelykt har en liten bakgrunnskomponent: det meste av lyset går i én retning, pluss siden det er utendørs, treffer svært lite av lyset øyet ditt etter å ha sprettet av andre objekter. Når bakgrunnslyset treffer en overflate, fordeles det likt i alle retninger.

Den diffuse komponenten er lys som kommer fra én retning, så det virker lysere hvis det treffer en flate i rette vinkler, og virker svakt hvis det bare berører den kort. Men når den treffer en overflate, er den fordelt likt i alle retninger, noe som betyr at lysstyrken er den samme uansett hvilken vei du ser på overflaten. Det er sannsynlig at alt lys som kommer fra en bestemt retning eller posisjon har en diffus komponent.

Spekulært lys kommer fra en bestemt retning og reflekteres fra en overflate i en bestemt retning. Når du reflekterer en godt fokusert laser stråle nesten 100 prosent kommer fra et speil av høy kvalitet speilrefleksjon. Skinnende metall eller plast har en høy speilende komponent, men et stykke teppe eller et plysjleketøy gjør det ikke. Du kan tenke på spekularitet som hvor skinnende et materiale fremstår.

I tillegg til bakgrunnsfarger, diffuse og speilende farger, kan materialer også ha en emitterende farge som simulerer lyset som kommer fra selve objektet. I OpenGL-belysningsmodellen gir utgående overflatelys intensitet til et objekt, men det påvirkes ikke av noen lyskilder og produserer ikke ekstra lys til scenen som helhet.

Selv om lyskilden avgir enkelt distribusjon frekvenser, bakgrunn, diffuse og speilende komponenter kan være forskjellige. For eksempel, hvis rommet ditt har røde vegger og hvitt lys, vil dette lyset som reflekteres fra veggene være mer rødt enn hvitt (til tross for at lyset som faller på veggen er hvitt). OpenGL lar deg angi de røde, grønne og blå verdiene uavhengig for hver lyskomponent.

Kommandoene som brukes til å angi materialet er:

// instanser for lys og materiale

// Slå på lyskilde nummer null

glEnable(GL_LIGHT0);

// angi posisjonen og fargekomponentene til lyskilden

glLightfv(GL_LIGHT0, GL_POSITION, LL.pos);

glLightfv(GL_LIGHT0, GL_AMBIENT, LL.amb);

glLightfv(GL_LIGHT0, GL_DIFFUSE, LL.dif);

glLightfv(GL_LIGHT0, GL_SPECULAR, LL.spec);

// aktiver skyggelegging/lysmodus

glEnable(GL_LIGHTING);

// angi objektets materialparametere

// på forsidene --- GL_FRONT for de bakre GL_BACK for begge - GL_FRONT_AND_BACK

// andre parameter - hvilken komponent av materialet

// mulig GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS

// tilsvarende DISTRIBUTERT, REFLEKTERT, SPEIL, SELV-EMISSION, speilende fakkelindikator

glMaterialfv(GL_FRONT,GL_AMBIENT,MM.amb);

glMaterialfv(GL_FRONT,GL_DIFFUSE,MM.dif);

glMaterialfv(GL_FRONT,GL_SPECULAR,MM.spec);

glMaterialf(GL_FRONT,GL_SHININESS,MM.pos);

glNormal3f(0,0,1);

glBegin(GL_QUADS);

for(i=-10; i<20;i++)

for(j=-10;j<20;j++)

glVertex3f(i,j,0);

glVertex3f(i+1,j,0);

glVertex3f(i+1,j+1,0);

glVertex3f(i,j+1,0);

Konklusjon

OpenGL-systemet er et fleksibelt prosedyregrensesnitt som lar programmereren utvikle ulike applikasjoner ved hjelp av tredimensjonal grafikk. Standarden inneholder ikke forskrifter for å beskrive strukturen til grafiske objekter; hovedoppmerksomheten rettes mot å beskrive prosessen med visualisering av dem. Takket være dette øker effektiviteten til eksisterende utstyr: fra enkle enheter som bare bruker en rammebuffer til moderne grafikksystemer som er i stand til å gjengi tredimensjonale objekter på maskinvarenivå. OpenGL gir kun muligheter for bildeutgang; organiseringen av input er helt overlatt til det spesifikke vindussystemet, som gir mulighet for ytterligere maskinvareuavhengighet av applikasjoner.

På grunn av minimal bruk av komplekse strukturer for å representere tredimensjonale objekter, er det mulig å bruke OpenGL som grunnlag for å bygge biblioteker for å administrere strukturerte objekter. Eksempler på slike biblioteker inkluderer objektorienterte verktøypakker som brukes til å visualisere og modellere komplekse grafiske strukturer

Skrevet på Allbest.ru

Lignende dokumenter

OpenGL-kode. OpenGL kommandosyntaks. OpenGL som en statsmaskin. OpenGL-gjengivelsespipeline. OpenGL-relaterte biblioteker. OpenGL-bibliotek. Inkluderte filer. GLUT, et verktøysett med OpenGL-biblioteksverktøy.

kursarbeid, lagt til 06/01/2004

Programmere en applikasjon ved hjelp av OpenGL-biblioteket og funksjoner for å tegne geometriske objekter. Utvikling av en prosedyre for å visualisere en tredimensjonal scene og brukergrensesnitt. Logisk struktur og funksjonell dekomponering av prosjektet.

kursarbeid, lagt til 23.06.2011

Bli kjent med grensesnittet, hovedfunksjonene og fordelene ved bruk av OpenGL-programmet - et populært bibliotek for arbeid med 2D- og 3D-grafikk. Hensyn til formålet, grunnleggende komponenter og initialiseringsregler for DirectX-programvaremotoren.

presentasjon, lagt til 14.08.2013

Opprette et program i C++ ved hjelp av OpenGL-grafikkbiblioteker i Microsoft Visual Studio. Konstruksjon av et dynamisk bilde av en tredimensjonal modell av "Oil platform"-objektet. Logisk struktur og funksjonell dekomponering av prosjektet.

kursarbeid, lagt til 23.06.2011

Essensen av programmering ved hjelp av OpenGL-biblioteket, dets formål, arkitektur, fordeler og grunnleggende muligheter. Utvikling av en applikasjon for å konstruere et dynamisk bilde av en tredimensjonal modell av datamaskinobjektet, brukerhåndbok.

kursarbeid, lagt til 22.06.2011

Arbeide med farger ved å bruke OpenGL-grafikkbiblioteket. Et program som viser en firkant med en skiftende farge avhengig av endringer i gradienter (R, G, B), en trekant, hvis hjørner har forskjellige farger, en rektangulær stripe i form av et spektrum.

test, lagt til 21.01.2011

Formål og implementeringsstandarder for OpenGL for Windows, rekkefølge for tilkobling av grafikkbiblioteket. Grunnleggende funksjoner og kommandosyntaks. Tegning av primitiver, arter og affine transformasjoner. Modellering av todimensjonale grafiske objekter og animasjon.

laboratoriearbeid, lagt til 07/04/2009

Grunnleggende om programmering ved hjelp av OpenGL-biblioteket. Søknad for å konstruere et dynamisk bilde av en modell av Bathyscaphe-objektet: utvikling av en prosedyre for å visualisere et tredimensjonalt diagram, brukergrensesnitt og undersystem for hendelsesadministrasjon.

kursarbeid, lagt til 26.06.2011

Forstå den sfæren av vikoristannya trivimirnoy grafikk. En beskrivelse av funksjonene til OpenGL-biblioteket. En detaljert beskrivelse av Borland C++ programmeringsgrensesnitt, en liste over programmer som demonstrerer dens evner. Rozrakhunok vitrat na vikonannya-prosjektet.

avhandling, lagt til 24.06.2015

Utvikling av en komponent for matematiske beregninger (operasjoner på matriser) ved bruk av OpenGL teknologi (addisjon, subtraksjon, multiplikasjon, transposisjon, determinant, invers matrise). Grunnleggende ferdigheter i arbeid med teknologi i .Net-miljøet.

I denne delen vil vi lære hvordan du lager 3D-bilder ved hjelp av OpenGL-biblioteksfunksjonene, slik at vi i neste kapittel kan utvikle en Windows-applikasjon som kan betraktes som et verktøy for å se resultatene av vitenskapelige beregninger. Materialet i denne delen lar deg gradvis komme i gang og mestre den svært attraktive teknologien for å lage og administrere tredimensjonale bilder. Først vil vi se på de grunnleggende egenskapene til OpenGL-biblioteket, deretter vil vi lære hvordan du administrerer OpenGL-funksjoner ved å bruke eksemplet med enkle applikasjoner av konsolltypen, og først etter det vil vi begynne å utvikle en Windows-applikasjon.

Leseren vet sannsynligvis at OpenGL er et optimert, høyytelses grafikkbibliotek med funksjoner og datatyper for visning av to- og tredimensjonal grafikk. OpenGL-standarden ble godkjent i 1992. Den er basert på IRIS GL-biblioteket utviklet av Silicon Graphics (www.sgi.com). OpenGL støttes på alle plattformer. I tillegg støttes OpenGL i maskinvare. Det finnes skjermkort med akseleratorer og spesialiserte SD-kort som utfører OpenGL-primitiver i maskinvare.

Materialet i første del av denne leksjonen er inspirert av en veldig god bok (tilgjengelig på nett) fra Addison-Wesley, "OpenGL Programming Guide, The Official Guide to Learning OpenGL". Hvis leseren snakker engelsk, anbefaler vi å lese den.

Koblede biblioteker

Microsoft-implementeringen av OpenGL inkluderer hele settet med OpenGL-kommandoer, det vil si globale funksjoner som er inkludert i kjernen av OPENGL32.LIB-biblioteket og har prefikset gl(f.eks glLineWidth). Merk at kjernebibliotekets funksjoner har flere versjoner, slik at du kan spesifisere ønsket parameter eller innstilling på hvilken som helst måte du vil. Se hjelp for funksjoner i glColor*-familien. Det viser seg at du kan stille inn gjeldende farge på 32 måter. For eksempel funksjonen:

Void glColorSb(GLbyte rød, GLbyte grønn, GLbyte blå);

Definerer en farge ved hjelp av tre komponenter av typen GLbyte, og funksjonen:

Ugyldig glColor4dv (konst GLdouble *v);

Spesifiserer den ved å bruke adressen til en matrise med fire komponenter.

Tar disse alternativene i betraktning, inneholder kjernebiblioteket mer enn 300 kommandoer. I tillegg kan du koble til GLU32.LIB-biblioteket med verktøy som utfyller hovedkjernen. Det er funksjoner for å kontrollere teksturer, koordinattransformasjon, generering av kuler, sylindre og skiver, splinetilnærminger av kurver og overflater ( NURBS - Ikke-uniform Rasjonell B-Spline), samt feilhåndtering. En til, i tillegg ( hjelpemiddel) GLAUX.LIB-biblioteket lar deg lage Windows-vinduer på en enkel måte, vise noen SD-objekter, håndtere inndatahendelser og kontrollere bakgrunnsprosessen. Dessverre er ikke dette biblioteket dokumentert. Microsoft anbefaler ikke å bruke den til å utvikle kommersielle prosjekter, siden den inneholder meldingssløyfekode som det er umulig å sette inn behandling av andre vilkårlige meldinger i.

Merk
GLbyte-typen tilsvarer en tegn-type, og GLdouble tilsvarer en dobbel type. Egne typer brukes for å forenkle portabilitet til andre plattformer. Vi gir en liste over OpenGL-typer nedenfor. Den fjerde fargekomponenten bestemmer fargens gjennomsiktighet, som er hvordan bakgrunnsfargen blander seg med bildefargen. Noen OpenGL-kommandoer har en v på slutten, som indikerer at argumentet skal være adressen til en matrise (vektor). En vektor i matematikk er en sekvens av tall (koordinater) som unikt definerer et element i et vektorrom. Mange kommandoer har flere versjoner, som til slutt lar deg spesifisere en vektor på forskjellige måter.

Omtrent tjue Windows GDI-funksjoner er laget spesielt for å fungere med OpenGL. De fleste av dem har prefikset wgl(akronym for Windows GL). Disse funksjonene er analoger av funksjonene prefikset med glx, som kobler OpenGL til X window System-plattformen. Til slutt er det flere Win32-funksjoner for å kontrollere pikselformat og dobbel buffering. De gjelder kun for spesialiserte OpenGL-vinduer.