Hoe om 'n kubus in OpenGL te maak (met foto's)

OpenGL is 'n kragtige 3D-programmeringsinstrument wat gebruik word om komplekse driedimensionele tonele uit eenvoudige primitiewe te teken. Hierdie artikel sal u leer hoe om 'n eenvoudige kubus te teken wat u in drie dimensies kan draai om te sien!

Vir hierdie projek benodig u 'n kode -redakteur en kennis van C -programmering.

Stappe

Deel 1 van 3: Aanvanklike opstelling

Stap 1. Installeer OpenGL Volg hierdie stappe om OpenGL op u stelsel te installeer

As u reeds OpenGL sowel as 'n versoenbare C -samesteller geïnstalleer het, kan u hierdie stap oorslaan en na die volgende gaan.

Stap 2. Skep die dokument

Skep 'n nuwe lêer in u gunsteling kode -redakteur en stoor dit as mycube.c

Stap 3. Voeg #insluit

Dit is die basiese inligting wat u benodig vir u program. Dit is belangrik om te besef dat daar eintlik verskillende insluitings nodig is vir die verskillende bedryfstelsels. Sluit dit alles in om te verseker dat u program veelsydig is en vir elke gebruiker kan werk.

// Sluit in #insluit #sluit in #sluit in #definieer GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include #else #include #endif

Stap 4. Voeg funksie prototipes en globale veranderlikes by

U volgende stap is om 'n paar funksie -prototipes te verklaar.

// Funksie prototipes leegte vertoon (); void specialKeys (); // Globale veranderlikes dubbel rotate_y = 0; dubbel draai_x = 0;

Stap 5. Stel die hooffunksie () op

int main (int argc, char* argv []) {// Initialiseer GLUT en verwerk gebruikersparameters glutInit (& argc, argv); // Versoek venster met dubbele gebufferde ware kleur met Z-buffer glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

Hierdie stelling stel u omgewing op. 'N Groot ding om te onthou wanneer u OpenGL -programme skryf, is dat u alles moet vra. Dit vereis dat u 'n groter begrip het van hoe u program werk en wat u moet insluit om die gewenste funksie te kry. In hierdie reël stel u die skerm op met dubbele buffering, RGB-kleur en 'n Z-buffer.
Dubbele buffering is 'n tegniek wat in grafiese programme gebruik word om 'n probleem op te los as gevolg van hoe beelde na die skerm getrek word. Elke keer as u die toneel weer teken, moet die skerm eers uitgevee word en dan word die nuwe inligting geteken. Sonder dubbele buffering sien u 'n flikkerende effek terwyl die skerm herhaaldelik uitgevee en herteken word.
Hierdie probleem word opgelos deur 'n tweede buffer by te voeg. Met hierdie metode word 'n beeld na die eerste buffer getrek en die buffer word aan u gewys. Die volgende raam word na die tweede buffer getrek, en as dit klaar is, sal die twee buffers van plek verander. U sal onmiddellik die tweede buffer sien, maar, weggesteek vir ons, word die eerste buffer uitgevee en geteken met die derde raam wat ingeruil sal word wanneer dit klaar is.
U wil ook die RGB kleur stelsel in u venster.
Z-buffer is hoe u die gewenste 3D -effekte kry. OpenGL gebruik 'n driedimensionele koördinaatstelsel met x-, y- en z -asse. Om die effek te gee dat 'n voorwerp nader aan u is, word sy posisie op die z -as vergroot, maar om dit verder weg te laat lyk, word die posisie op die z -as verminder.

Stap 6. Skep die venster

Die volgende stap is om maak die venster waarbinne jy die kubus sal teken. In hierdie tutoriaal word die venster 'Awesome Cube' genoem.

// Skep venster glutCreateWindow ("Awesome Cube");

Stap 7. Aktiveer dieptetoets

OpenGL is 'n streng taal omdat dit nie aanvaar dat spesiale funksies geaktiveer is nie. U moet u program behoorlik in drie dimensies vertoon met die Z-buffer waarna u gekyk het diepte-toets moontlik maak. Terwyl u voortgaan om OpenGL te verken, ontdek u baie funksies wat u nodig sal hê, insluitend beligting, teksture, afskerming en nog baie meer.

// Aktiveer Z-buffer diepte toets glEnable (GL_DEPTH_TEST);

Stap 8. Voeg terugbelfunksies by

Hier is die terugbelfunksies waarvoor u die prototipes vroeër geskryf het. Elke keer word hierdie funksies deur die hooflus genoem. Die vertoningsfunksie teken die toneel weer op grond van enige veranderings aan veranderlikes wat sedert die vorige oproep aangebring is. Met die specialKeys -funksie kan ons met die program omgaan.

// Terugbelfunksies glutDisplayFunc (vertoon); glutSpecialFunc (spesiale sleutels);

Stap 9. Begin die MainLoop

Dit herroep die hooffunksie totdat u die program sluit om animasies en gebruikersinteraksie moontlik te maak.

// Slaag beheer na GLUT vir gebeure glutMainLoop (); // Keer terug na OS terugkeer 0; }

Deel 2 van 3: Die skerm () Funksie

Stap 1. Verstaan die doel van hierdie funksie

Al die werk om u kubus te teken, word in hierdie funksie uitgevoer. Die algemene idee agter u kubus is om al ses sye afsonderlik te teken en in die regte posisie te plaas.

Konseptueel word elke kant geteken deur die vier hoeke te definieer en OpenGL die lyne te laat verbind en dit in te vul met 'n kleur wat u definieer. Hieronder is die stappe om dit te doen

Stap 2. Voeg glClear () by

Die eerste stap wat u in hierdie funksie moet neem, is om maak die kleur en Z -buffer skoon. Sonder hierdie stappe is die ou tekeninge moontlik nog steeds sigbaar onder die nuwe tekeninge en kan voorwerpe wat geteken is nie op die regte plek op die skerm wees nie.

leegte vertoon () {// Maak skerm skoon en Z-buffer glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Stap 3. Voeg glBegin () en glEnd () by

OpenGL definieer voorwerpe as kombinasies van verskillende veelhoeke. Gebruik die glBegin () opdrag, sit u effektief 'n potlood neer wat 'n vorm sal teken. Om die potlood op te lig en 'n nuwe vorm te begin, moet u die glEnd () bevel. In hierdie tutoriaal gebruik u GL_POLYGON om elke kant van die kubus te teken, maar dit is moontlik om ander parameteropsies soos GL_LINE, GL_QUAD of GL_TRIANGLE te gebruik om ander vorms te skep.

Hier begin u met die voorkant van u kubus. Later sal u kleur aan al 6 kante toevoeg.

// Veelkleurige sy - VOOR glBegin (GL_POLYGON); // hoekpunte sal bygevoeg word in die volgende stap glEnd ();

Stap 4. Voeg glVertex3f () by

As u eers gesê het dat u met die veelhoek wil begin, moet u dit doen definieer die hoekpunte van die voorwerp. glVertex het verskeie vorme, afhangende van wat u met u voorwerp wil doen.

Die eerste is in hoeveel dimensies u werk. Die 3 hierbo in glVertex3f sê dat u in 3 dimensies teken. Dit is ook moontlik om in 2 of 4 dimensies te werk. Die f hierbo in glVertex3f sê dat u met dryfpuntgetalle werk. U kan ook kortbroek, heelgetalle of dubbelspel gebruik.
Let op dat hierdie punte gedefinieer word in a anti-kloksgewys manier. Dit is op die oomblik nie baie belangrik nie, maar as u met beligting, teksture en afskerming begin werk, sal dit ongelooflik belangrik word, so maak die gewoonte om u punte nou teen die kloksgewys te definieer.
Voeg die hoekpunte by tussen die glBegin () en glEnd () reëls.

// Veelkleurige sy - VOOR glBegin (GL_POLYGON); glVertex3f (-0.5, -0.5, -0.5); // P1 glVertex3f (-0.5, 0.5, -0.5); // P2 glVertex3f (0.5, 0.5, -0.5); // P3 glVertex3f (0.5, -0.5, -0.5); // P4 glEnd ();

Stap 5. Voeg glColor3f () by

glColor werk op dieselfde manier as glVertex. U kan punte definieer as kortbroek, heelgetalle, dubbels of vlotte. Elke kleur het 'n waarde van 0 tot 1. Alle 0's maak die punt swart en al 1's maak die punt wit. Die 3 in glColor3f () verwys na die RGB -kleurstelsel sonder 'n alfakanaal. Die alfa van 'n kleur bepaal die deursigtigheid daarvan. Om die alfavlak te verander, gebruik glColor4f () met die laaste parameter 'n waarde van 0 tot 1 vir ondeursigtig tot deursigtig.

As u glColor3f () bel, sal elke hoekpunt wat vanaf daardie punt getrek word, van daardie kleur wees. As u dus wil hê dat al vier hoekpunte rooi moet wees, moet u die kleur een keer stel voordat die glVertex3f () opdragte plaas, en alle hoekpunte sal rooi wees.
Die voorkant wat hieronder gedefinieer word, toon hoe u 'n nuwe kleur vir elke hoekpunt kan definieer. As u dit doen, kan u 'n interessante eienskap van die OpenGL -kleure sien. Aangesien elke hoekpunt van die veelhoek sy eie kleur het, meng OpenGL die kleure outomaties! Die volgende stap sal wys hoe u vier hoekpunte met dieselfde kleur toewys.

// Veelkleurige sy - VOOR glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1 is rooi glColor3f (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2 is groen glColor3f (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3 is blou glColor3f (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4 is pers glEnd ();

Stap 6. Hanteer die ander kante

Bepaal wat die ligging van elke hoekpunt vir die ander vyf kante van die kubus sal wees, maar vir die eenvoud is dit vir u bereken en ingesluit in die finale display () funksie hieronder.

// Wit kant - TERUG glBegin (GL_POLYGON); glColor3f (1.0, 1.0, 1.0); glVertex3f (0.5, -0.5, 0.5); glVertex3f (0.5, 0.5, 0.5); glVertex3f (-0,5, 0,5, 0,5); glVertex3f (-0.5, -0.5, 0.5); glEnd (); // Perskant - REGS glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 1.0); glVertex3f (0.5, -0.5, -0.5); glVertex3f (0.5, 0.5, -0.5); glVertex3f (0.5, 0.5, 0.5); glVertex3f (0.5, -0.5, 0.5); glEnd (); // Groen kant - LINKS glBegin (GL_POLYGON); glColor3f (0.0, 1.0, 0.0); glVertex3f (-0.5, -0.5, 0.5); glVertex3f (-0,5, 0,5, 0,5); glVertex3f (-0.5, 0.5, -0.5); glVertex3f (-0.5, -0.5, -0.5); glEnd (); // Blou kant - TOP glBegin (GL_POLYGON); glColor3f (0.0, 0.0, 1.0); glVertex3f (0.5, 0.5, 0.5); glVertex3f (0.5, 0.5, -0.5); glVertex3f (-0.5, 0.5, -0.5); glVertex3f (-0,5, 0,5, 0,5); glEnd (); // Rooi kant - ONDER glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); glVertex3f (0.5, -0.5, 0.5); glVertex3f (-0.5, -0.5, 0.5); glVertex3f (-0.5, -0.5, -0.5); glEnd (); glFlush (); glutSwapBuffers (); }

Ons wil ook twee laaste reëls kode vir hierdie funksie byvoeg. Hierdie is glFlush ();

en glutSwapBuffers ();

Dit gee ons die dubbelbuffer-effek wat u vroeër geleer het.

Deel 3 van 3: Gebruikersinteraktiwiteit

Stap 1. Voeg specialKeys () by

U is amper klaar, maar op die oomblik kan u 'n kubus teken, maar u kan dit nie draai nie. Om dit te doen, sal jy skep 'n spesiale sleutels () funksie sodat ons die pyltjie sleutels kan druk en die kubus kan draai!

Hierdie funksie is die rede waarom u die globale veranderlikes rotate_x en rotate_y verklaar het. As u op die pyltjie regs en links druk, word rotate_y met 5 grade verhoog of verminder. As u ook op die pyltjie op en af druk, sal rotate_x dienooreenkomstig verander.

void specialKeys (int key, int x, int y) {// Pyltjie regs - verhoog rotasie met 5 grade as (key == GLUT_KEY_RIGHT) rotate_y += 5; // Linkerpyl - verminder rotasie met 5 grade anders as (sleutel == GLUT_KEY_LEFT) draai_y - = 5; anders as (sleutel == GLUT_KEY_UP) rotate_x += 5; anders as (sleutel == GLUT_KEY_DOWN) rotate_x -= 5; // Versoek die opdatering van die skerm glutPostRedisplay (); }

Stap 2. Voeg glRotate () by

U laaste stelling is om die stelling by te voeg wat u voorwerp sal draai. Gaan terug na die display () -funksie en voeg die volgende reëls voor:

// Stel transformasies terug glLoadIdentity (); // Draai wanneer gebruiker verander rotate_x en rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (draai_y, 0.0, 1.0, 0.0); // Veelkleurige sy - VOOR …

Let eers op dat die sintaksis van glRotatef () is soortgelyk aan dié van glColor3f () en glVertex3f (), maar benodig altyd 4 parameters. Die eerste parameter is die graad van rotasie wat toegepas moet word. Die volgende drie parameters definieer watter as om te draai, met die eerste die x -as, die tweede die y -as en die derde die z -as. Op die oomblik hoef u net om die x- en y-as te draai.
Alle transformasies wat u in u program skryf, benodig soortgelyke lyne. Konseptueel kan u hieraan dink dat u u voorwerp om die x -as draai met die hoeveelheid gedefinieer deur rotate_x en dan om die y -as te draai deur rotate_y. OpenGL kombineer egter al hierdie stellings in een matrikstransformasie. Elke keer as u die vertoningsfunksie bel, bou u 'n transformasiematriks en glLoadIdentity () verseker dat u in elke pas met 'n nuwe matriks sal begin.
Die ander transformasiefunksies wat u kan toepas, is glTranslatef () en glScalef (). Hierdie funksies is soortgelyk aan glRotatef (), met die uitsondering dat dit slegs 3 parameters neem, die x, y en z hoeveelhede om die voorwerp te vertaal of te skaal.
Om die korrekte effek te kry wanneer u al drie transformasies op een voorwerp toepas, moet u dit in die regte volgorde toepas. Skryf dit altyd in die volgorde neer glTranslate, glRotate, dan glScale. OpenGL pas die transformasies in wese van onder na bo toe. Om dit te verstaan, moet u dink hoe 'n eenvoudige 1x1x1 -kubus met die transformasies sou lyk as OpenGL dit van bo na onder toepas en as OpenGL dit van onder na bo toepas.

Stap 3. Voeg die volgende opdragte by om die kubus met 2 langs die x-as, 2 langs die y-as te skaal, draai die kubus 180 grade om die y-as en vertaal die kubus met 0,1 langs die x-as

Rangskik hierdie sowel as die vorige glRotate () opdragte in die korrekte volgorde soos hierbo beskryf. (As u onseker is, word dit gedoen in die finale kode aan die einde van die tutoriaal.)

// Ander transformasies glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

Stap 4. Stel u kode saam en voer dit uit

As u gcc as u samesteller gebruik, voer hierdie opdragte vanaf u terminale uit om u program saam te stel en te toets.

Op Linux: gcc cube.c -o kubus -lglut -lGL./ mycube Op Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL./ mycube Op Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32./ mycube

Stap 5. Gaan u volledige kode na

Dit moet so wees:

// // Lêer: mycube.c // Skrywer: Matt Daisley // Geskep: 25-4-2012 // Projek: Bronkode vir Maak 'n kubus in OpenGL // Beskrywing: Maak 'n OpenGL -venster en teken 'n 3D -kubus/ / Dat die gebruiker kan draai met die pyltjie sleutels // // kontroles: pyl na links -draai links // pyl na regs -draai regs // pyl omhoog -draai om // pyl omlaag -draai af // ------ -------------------------------------------------- -// Sluit in // ------------------------------------------- --------------- #include #include #include #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include #else #include #endif // ------------- --------------------------------------------- // Funksie prototipes / / ------------------------------------------------- --------- leegte vertoon (); void specialKeys (); // ------------------------------------------------ ---------- // Globale veranderlikes // ---------------------------------- ------------------------ dubbel rotate_y = 0; dubbel draai_x = 0; // ------------------------------------------------ ---------- // display () Terugbelfunksie // ------------------------------- --------------------------- nietige vertoning () {// Duidelike skerm en Z-buffer glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Stel transformasies terug glLoadIdentity (); // Ander transformasies // glTranslatef (0.1, 0.0, 0.0); // Nie ingesluit // glRotatef (180, 0.0, 1.0, 0.0); // Nie ingesluit nie // Draai wanneer gebruiker rotate_x en rotate_y verander glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (draai_y, 0.0, 1.0, 0.0); // Ander transformasies // glScalef (2.0, 2.0, 0.0); // Nie ingesluit nie // Veelkleurige sy - VOOR glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); // P1 is rooi glColor3f (0.0, 1.0, 0.0); glVertex3f (0.5, 0.5, -0.5); // P2 is groen glColor3f (0.0, 0.0, 1.0); glVertex3f (-0.5, 0.5, -0.5); // P3 is blou glColor3f (1.0, 0.0, 1.0); glVertex3f (-0.5, -0.5, -0.5); // P4 is pers glEnd (); // Wit kant - TERUG glBegin (GL_POLYGON); glColor3f (1.0, 1.0, 1.0); glVertex3f (0.5, -0.5, 0.5); glVertex3f (0.5, 0.5, 0.5); glVertex3f (-0,5, 0,5, 0,5); glVertex3f (-0.5, -0.5, 0.5); glEnd (); // Perskant - REGS glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 1.0); glVertex3f (0.5, -0.5, -0.5); glVertex3f (0.5, 0.5, -0.5); glVertex3f (0.5, 0.5, 0.5); glVertex3f (0.5, -0.5, 0.5); glEnd (); // Groen kant - LINKS glBegin (GL_POLYGON); glColor3f (0.0, 1.0, 0.0); glVertex3f (-0.5, -0.5, 0.5); glVertex3f (-0,5, 0,5, 0,5); glVertex3f (-0.5, 0.5, -0.5); glVertex3f (-0.5, -0.5, -0.5); glEnd (); // Blou kant - TOP glBegin (GL_POLYGON); glColor3f (0.0, 0.0, 1.0); glVertex3f (0.5, 0.5, 0.5); glVertex3f (0.5, 0.5, -0.5); glVertex3f (-0.5, 0.5, -0.5); glVertex3f (-0,5, 0,5, 0,5); glEnd (); // Rooi kant - ONDER glBegin (GL_POLYGON); glColor3f (1.0, 0.0, 0.0); glVertex3f (0.5, -0.5, -0.5); glVertex3f (0.5, -0.5, 0.5); glVertex3f (-0.5, -0.5, 0.5); glVertex3f (-0.5, -0.5, -0.5); glEnd (); glFlush (); glutSwapBuffers (); } // ----------------------------------------------- ----------- // specialKeys () Terugbelfunksie // ------------------------------ ---------------------------- void specialKeys (int key, int x, int y) {// pyl na regs-verhoog rotasie met 5 graad as (sleutel == GLUT_KEY_RIGHT) draai_y += 5; // Linkerpyl - verminder rotasie met 5 grade anders as (sleutel == GLUT_KEY_LEFT) draai_y - = 5; anders as (sleutel == GLUT_KEY_UP) rotate_x += 5; anders as (sleutel == GLUT_KEY_DOWN) rotate_x -= 5; // Versoek opdateringsopdatering glutPostRedisplay (); } // ----------------------------------------------- ----------- // main () funksie // ------------------------------- --------------------------- int main (int argc, char* argv []) {// Initialiseer GLUT en verwerk gebruikersparameters glutInit (& argc, argv); // Versoek venster met dubbele gebufferde ware kleur met Z-buffer glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Skep venster glutCreateWindow ("Awesome Cube"); // Aktiveer Z-buffer diepte toets glEnable (GL_DEPTH_TEST); // Terugbelfunksies glutDisplayFunc (vertoon); glutSpecialFunc (spesiale sleutels); // Slaag beheer na GLUT vir gebeure glutMainLoop (); // Keer terug na OS terugkeer 0; }