Prikazujem rezultate 1 do 7 od 7

Tema: [Tutorial] OpenGL through C++

  1. #1
    Senior Member Small step for mankind
    Datum registracije
    Aug 2007
    Lokacija
    Latitude:45.286° Longitude:18.688°
    Postova
    2.150

    [Tutorial]SOpenGL through C++

    Yep, paralelno uz DirectX već poduže vrijeme proučavam i ovaj neizostavni API za razvoj 3D aplikacija. Ono što sam dosad iskusio je jednostavno predobro i jednostavno krenuo sam pisati ovaj tutorial koji izgleda malo profesionalnije jer ću ga predati profesorici iz informatike. Dakle:



    OpenGL ( Open Graphics Library, OGL ) naziv je jednog od najraširenijih API-a (Application Programming Interface) za razvoj bogatih 2D/3D aplikacija. Prvobitno razvijen od strane Silicon Graphics Inc., danas njegov izvorni kôd dostupan je za preuzimanje i daljnje prilagođavanje potrebama developera i krajnjih korisnika. Njegova primjena seže od CAD (Computer Aided Design) programa do hitova iz industrije igara.

    Otkad je izašao u 1992. godini, bio je vodeći API za razvoj grafičkih aplikacija. Ubrzo nakon izlaska Windows-a '95, Microsoft (prvobitno član ARBa) izdaje svoj multimedijalni API za razvoj bogatih 3D aplikacija specifično za svoj operacijski sustav s ciljem da konkurira OpenGLu i privuče više korisnika na Windows OS. Konačno povlačenje Microsofta iz OpenGL ARB-a događa se 2003. godine. Prednost OpenGLa leži u činjenici da je OpenGL nezavisan o platformi na kojoj se koristi dok mu je eventualna mana to što je OpenGL grafički API, za razliku od DirectXa koji se sastoji od više modula (grafika, video streaming, audio, networking, input). No, OpenGL se lagano može upariti sa veoma kvalitetnom alternativnom bibliotekom, SDL (Simple DirectMedia Layer), koja mu omogućuje lakšu kontrolu nad ulazom korisnika, manipuliranje zvukom i dr.

    Ovaj tekst specifično će se baviti implementacijom OpenGLa u vaše aplikacije te će nastojati ponuditi kvalitetni uvod u programiranje 3D aplikacija sa OpenGL-om nastojeći više se koncentrirati na sam kôd nego na teoriju. Prvo ćemo postaviti OpenGL i „sinkronizirati“ ga s Visual Studio-om, a nakon toga ćemo krenuti u zanimljiv svijet dizajniranja i programiranja 3D aplikacija koristeći OpenGL API. Specifično, krenut ćemo od jednostavnog trokuta, transformacijskih matrica, osnovnog osvjetljenja, uvod u teksturiranje te kasnije malo napredniji koncepti poput generatora terena te GLSLa (Graphics Library Shading Language).
    Gdje je nestao mozak
    gdje se skriva on
    iz vagona pameti
    na tračnice ispao...

  2. #2
    Senior Member Small step for mankind
    Datum registracije
    Aug 2007
    Lokacija
    Latitude:45.286° Longitude:18.688°
    Postova
    2.150

    Re: TUTORIAL >> OpenGL through C++

    POSTAVLJANJE OpenGL-a

    OpenGL za razliku od DirectXa nema pojednostavljenu instalaciju koja će odmah pohraniti podatke na vaše računalu i dodati potrebne direktorije u Visual C++ Directories, nego je sve potrebno napraviti ručno. Nema potrebe za pretragom hrpe stranica za GLUT-om (Graphics Library Utility Kit) kojeg ćemo specifično koristiti za razvoj naših budućih aplikacija. Svoju kopiju GLUT-a možete pronaći na: GLUT.

    Upute (step by step)

    1.) Raspakirajte arhivu negdje na vašem računalu, pa napravite folder negdje na vašem HDDu (npr. C:\GLUT) te u njemu napravite dva zasebna foldera „include“ i „lib“.
    2.) Otvorite include, pa u njemu napravite još jedan folder nazvan „GL“ (tradicija nalaže takav pristup postavljanju OpenGL-a). Tu kopirajte iz raspakirane arhive file zvan glut.h, a ostale file-ove stavite u lib folder.
    3.) Pokrenite Visual Studio 2005 (Express Edition ili puna verzija, nije bitno).
    4.) Otvorite Tools -> Options
    5.) Sada idite na Projects and Solutions -> VC++ Directories, gore iz padajućeg izbornika odaberite Include files i dodajte novi put (path) i onda klikom na ... postavite isti (npr. C:\GLUT\include\GL\)
    6.) Nakon što ste potvrdili gore navedeno, ponovno na padajući izbornik i odaberite Library files. Sada možete slobodno ponoviti prethodni postupak samo neka putanja bude naravno navodila prema lib folderu (npr. C:\GLUT\lib\)
    7.) I to je to. Čestitam, postavili ste OpenGL.... Odsad sve što vam treba jest vaša pamet, logika i kreativnost.
    Gdje je nestao mozak
    gdje se skriva on
    iz vagona pameti
    na tračnice ispao...

  3. #3
    Senior Member Small step for mankind
    Datum registracije
    Aug 2007
    Lokacija
    Latitude:45.286° Longitude:18.688°
    Postova
    2.150

    Re: TUTORIAL >> OpenGL through C++

    OpenGL TROKUT

    Trokut je osnova matematičkih domena poput geometrije i trigonometrije, a mogu reći i 3D grafike. Točka u matematici je zapravo mjesto u 2D/3D prostoru određeno specifičnim koordinatama na X, Y ili Z osi, a 3D aplikacija koristi se istom logikom. Jedina specifična razlika između 3D matematike i matematike jest da se točke nazivaju vertex (vertices u množini). Teoriju u stranu, kôd na zaslon...

    Code:
    // header file-ovi koje je potrebno pohraniti 
    #include <iostream>
    #include <GL/glut.h>
    using namespace std;
    
    // prototipi funkcija
    void initRenderer(void);
    void resize(int, int);
    void render(void);
    void update(int);
    
    //globalne deklaracije
    float _angle = 30.f;
    
    
    
    int main(int argc, char** argv) {
    	//inicijalizacija GLUTa
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    	glutInitWindowSize(400, 400); // postavi win32 prozor
    	
    	// napravi prozor
    	glutCreateWindow("Ucionica");
    	initRenderer(); //inicijalizacija iscrtavanja
    	
    	// postaviti ručice za funkcije koje manipuliraju scenom i prozorom
    	glutDisplayFunc(render);
    	glutReshapeFunc(resize);
    	
    	glutTimerFunc(25, update, 0);
    	glutMainLoop(); // pokreće glavnu petlju
    	return 0;  // simbolično, jer nikad se do nje neće doći
    }
    
    void initRenderer(void) 
    {
    	// omogućuje renderiranje dubine tj. ako se objekt nađe ispred nekog drugog
    	glEnable(GL_DEPTH_TEST);
    	glEnable(GL_COLOR_MATERIAL);
    	glClearColor(0.7f, 0.9f, 1.0f, 1.0f);
    }
    
    // poziva se pri mijenjanju visine i širine prozora
    void resize(int w, int h) {
    	// postavljanje viewporta, kako pretvarati podatke u pixele
    	glViewport(0, 0, w, h);
    	
    	glMatrixMode(GL_PROJECTION); // perspektiva kamere
    	
    	// postavljanje perspektive kamere
    	glLoadIdentity(); // resetiraj kameru
    	gluPerspective(45.0,                  // kut kamere
    				   (double)w / (double)h, // aspect ratio ( podijeljena visina sa širinom )
    				   1.0,                   // ono što je preblizu, ne renderiraj
    				   200.0);                // ono što je predaleko, ne renderiraj
    }
    
    // iscrtava scenu
    void render() {
    	// očisti ekran od posljednjeg iscrtavanja
    	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    	
    	glMatrixMode(GL_MODELVIEW); // perspektiva za iscrtavanje
    	glLoadIdentity(); // resetiraj perspektivu iscrtavanja
    	glTranslatef(0.0f, 0.0f, -5.0f);
    	
    	
    	glRotatef(_angle, 0.0f, 0.0f, 1.0f);
    	glBegin(GL_TRIANGLES);
    	
    	// trokut, doduše, nabubane koordinate
    	glVertex3f(0.5f, 00.5f, 0.0f);
    	glVertex3f(0.0f, 1.5f, 1.0f);
    	glVertex3f(-1.5f, -0.5f, 0.0f);
    	
    	glEnd(); // završi upisivanje koordinata verticesa trokuta
    	
    	glutSwapBuffers(); // zamijeni back buffer sa front bufferom
    }
    
    void update (int value) 
    {
    	_angle += 2.0f;
    	if( _angle > 360 ) 
    	{
    		_angle -= 360;
    	}
    	glutPostRedisplay();
    	glutTimerFunc(25, update, 0);
    }
    Gledajući sam kôd, kao zadrti C++ programeri, i ne izgleda jako strašno. Pa krenimo kao compiler, od vrha prema dolje!

    Code:
    #include <iostream>
    #include <GL/glut.h>
    using namespace std;
    Dakle, prvo uključujemo iostream header file za kontrolu inputa i outputa. GL/glut.hr je header file kojeg koristimo da utjeramo OpenGL u naš skromni c++ program, kao što vidite onaj GL/ mora biti uključen jer je to putanja nakon što ga compiler dođe do GLUT/include... using namespace std; služi jednostavno tome da ne moramo koristiti std::nešto stalno.

    Code:
    // prototipi funkcija
    void initRenderer(void);
    void resize(int, int);
    void render(void);
    void update(int);
    Kao što i sam komentar u programu kaže, ovo su prototipi funkcija, naših naravno, ne onih iz GLUTa.

    void initRenderer(void);
    Ova funkcija pokreće osnovne rendering parametre o kojima ćemo govoriti više kad dođemo do funkcije.

    void resize(int, int);
    Funkcija koja će se aktivirati kada korisnik promijeni širinu ili visinu prozora aplikacije.

    void render(void);
    Funkcija koja će se naći ravno u main loopu i stalno se ponavljati, ovo je mjesto gdje se sva čarolija iscrtavanja dešava.

    void update(int);
    Ova funkcija služi da ažurira scenu... Kasnije slijedi bolje pojašnjenje.

    Code:
    //globalne deklaracije
    float _angle = 30.f;
    Ovdje idu globalne deklaracije našeg programa, a specifično _angle varijabla kako joj i samo ime kaže jest kut kojeg ćemo koristiti da bi rotirali naše 2D/3D objekte.

    Code:
    int main(int argc, char** argv) {
    	//inicijalizacija GLUTa
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    	glutInitWindowSize(400, 400); // postavi win32 prozor
    	
    	// napravi prozor
    	glutCreateWindow("Ucionica");
    	initRenderer(); //inicijalizacija iscrtavanja
    	
    	// postaviti ručice za funkcije koje manipuliraju scenom i prozorom
    	glutDisplayFunc(render);
    	glutReshapeFunc(resize);
    	
    	glutTimerFunc(25, update, 0);
    	glutMainLoop(); // pokreće glavnu petlju
    	return 0;  // simbolično, jer nikad se do nje neće doći
    }
    Ovo je ulazna točka programa. Volio bih istaknuti potrebu za argumentima u funkciji koje ćemo u narednim linijama kôda proslijediti OpenGLu da može dalje manipulirati prozorom.

    Code:
    //inicijalizacija GLUTa
    	glutInit(&argc, argv);
    	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    	glutInitWindowSize(400, 400); // postavi win32 prozor
    Kao što komentar ističe, ovdje se događa inicijalizacija samog GLUTa i njegovo ugrađivanje u naš program.

    glutInit(&argc, argv);
    glutInit() je funkcija koja koristeći argumente iz main() funkcije tj. ulaza u naš program omogućuje ugradnju GLUTa u naš program.

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitDisplayMode() služi za postavljanje osnovnih paramatera potrebnih za bilo koji program pogonjen OpenGL-om. Ubacivanjem par zastavica tj. flag-ova dajemo GLUTu "ideju" kako bi početni display mode trebao izgledati.

    glutInitWindowSize(400, 400); // postavi win32 prozor
    Postavlja veličinu prozora davajući joj width i height argumente.


    Code:
    // napravi prozor
    	glutCreateWindow("Ucionica");
    	initRenderer(); //inicijalizacija iscrtavanja
    Ovaj dio kôda govori GLUT-u da napravi prozor nazvan Ucionica, te poziva funkciju za inicijalizaciju iscrtavanja čiji smo prototip maloprije spominjali.

    Code:
    // postaviti ručice za funkcije koje manipuliraju scenom i prozorom
    	glutDisplayFunc(render);
    	glutReshapeFunc(resize);
    Ove dvije funkcije govore GLUTu koju funkciju da koristi za iscrtavanje, a koju za resizing.

    Code:
    glutTimerFunc(25, update, 0);
    	glutMainLoop(); // pokreće glavnu petlju
    	return 0;  // simbolično, jer nikad se do nje neće doći
    glutTimerFunc(25, update, 0)
    Ova funckija omogućuje nam da radimo transformacije u stvarnom vremenu dok protječe vrijeme, najlakše rečeno, animiramo prijelaz iz jedne pozicije u drugu. Prvi argument su milisekunde koje moraju proći prije prvog poziva navedene funkcije u programu, naš odabir je 25, drugi argument je ime funkcije koju koristimo da ažuriramo scenu (update, remember?), a treći argument jednostavno ostavite na 0.

    glutMainLoop()
    Ovo bi bila OpenGL-ova točka iza koje nema povrata... Dakle, pošto je OpenGL dizajniran proceduralno potrebno je definirati sve redom i onda pokrenuti glavni loop koji u biti nakon aktiviranja se ne vraća. Dakle, onaj return 0; iza njega je čisto simbolično, jer do njega program neće ni doći.

    Code:
    void initRenderer(void) 
    {
    	// omogućuje renderiranje dubine tj. ako se objekt nađe ispred nekog drugog
    	glEnable(GL_DEPTH_TEST);
    	glEnable(GL_COLOR_MATERIAL);
    	glClearColor(0.7f, 0.9f, 1.0f, 1.0f);
    }
    Kao što vidite, ovo je funkcija koja postavlja osnovu za renderiranje u OpenGLu. Možete ju zamisliti kao paljenje motora u automobilu. A sad je vrijeme da zavirimo ispod haube...

    glEnable(GL_DEPTH_TEST)
    Ova funckija je prilično jednostavna... Njen zadatak je osigurati mogućnost renderiranja dubine, tj. ako se neki objekt nađe ispred nekog drugog da se dogodi ono što je fizički točno, dakle, ovaj bliži se nalazi ispred, a ovaj drugi negdje iza.

    glEnable(GL_COLOR_MATERIAL);
    Vrlo jednostavna funkcija, jednostavno postavlja zastavicu da možemo bojiti objekte/pozadinu...

    glClearColor(0.7f, 0.9f, 1.0f, 1.0f);
    Ovo je boja kojom ćemo čistiti zaslon tj. boja pozadine, a trenutne specifikacije su neka svjetlo plava boja. Radi se o standardnom RGBA sustavu. (A stoji za Alpha, tj. prozirnost, 1.0f znači nema prozirnosti, a kako se vrijednost kreće prema dolje dobivamo finu prozirnost)

    Code:
    // poziva se pri mijenjanju visine i širine prozora
    void resize(int w, int h) {
    	// postavljanje viewporta, kako pretvarati podatke u pixele
    	glViewport(0, 0, w, h);
    	
    	glMatrixMode(GL_PROJECTION); // perspektiva kamere
    	
    	// postavljanje perspektive kamere
    	glLoadIdentity(); // resetiraj kameru
    	gluPerspective(45.0,                  // kut kamere
    				   (double)w / (double)h, // aspect ratio ( podijeljena visina sa širinom )
    				   1.0,                   // ono što je preblizu, ne renderiraj
    				   200.0);                // ono što je predaleko, ne renderiraj
    }
    Spominjali smo već prototip, radi se o funkciji koja kontrolira promjenu širine ili visine prozora.... Ima dva argumenta, naravno, radi se o širini i visini.

    glViewport(0, 0, w, h)
    Ova funkcija služi za postavljanje osnove viewporta, dakle bez potrebe za daljnim kompliciranjem, objašnjenje iz komentara je više nego dovoljno. Ova funkcija koristi se da bi transformirala podatke koje dobiva u vidljive grafičke točkice na zaslonu a.k.a (also known as) pixels.

    glMatrixMode(GL_PROJECTION)
    Ovo je najjednostavnije rečeno perspektiva kamere.

    glLoadIdentity() koju sam preskočio služi za resetiranje kamere

    gluPerspective()
    Funkcija gluPerspective() postavlja perspektivu prilagođenu ljudskom oku. Ima par argumenata, prvi je 45.0f, a to je kut kojeg korisnikovo oko može vidjeti, sljedeći argument je aspect ratio tj. kako se modeli trebaju skalirati tj. prilagoditi korisnikovu monitoru... To se radi tako da podijelimo širinu sa visinom, no bitna je stvar da castamo varijable w i h kao double data tipove jer tako možemo dobiti preciznije podatke. Zadnja dva argumenta su near i far clipping, near postavljamo na 1.0f, a far na 200.0f... Oni se koriste da izbacimo ono što korisnikovo oko ne može vidjeti (jer je preblizu ili predaleko).

    Code:
    // iscrtava scenu
    void render() {
    	// očisti ekran od posljednjeg iscrtavanja
    	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    	
    	glMatrixMode(GL_MODELVIEW); // perspektiva za iscrtavanje
    	glLoadIdentity(); // resetiraj perspektivu iscrtavanja
    	glTranslatef(0.0f, 0.0f, -5.0f);
    	
    	
    	glRotatef(_angle, 0.0f, 0.0f, 1.0f);
    	glBegin(GL_TRIANGLES);
    	
    	// trokut, doduše, nabubane koordinate
    	glVertex3f(0.5f, 00.5f, 0.0f);
    	glVertex3f(0.0f, 1.5f, 1.0f);
    	glVertex3f(-1.5f, -0.5f, 0.0f);
    	
    	glEnd(); // završi upisivanje koordinata verticesa trokuta
    	
    	glutSwapBuffers(); // zamijeni back buffer sa front bufferom
    }
    Polako ali sigurno došli smo do dijela gdje se sva čarolija događa. Ova funkcija iscrtava trenutni frame i stalno se ponavlja u main loopu. Vrijeme je da ju rastavimo na uvozne dijelove.

    glClear()
    Ovom malenom funkcijom čistimo zaslon od prošle sličice te postavljamo boju pozadine koristeći dvije malene zastavice, a ovo ćete vjerojatno koristiti u većini programa.

    glMatrixMode(GL_MODELVIEW)
    Ova funkcija jednostavno postavlja MatrixMode na sređivanje transformacija na točkama (verticesima) na sceni.

    glLoadIdentity()
    U ovoj lekciji zadržat ćemo se na najjednostavnijem objašnjenju, a ono glasi za trenutni segment kôda: "resetiraj perspektivu iscrtavanja".

    glTranslatef(0.0f, 0.0f, -5.0f)
    Ovu funkciju koristimo da bi pomicali objekte tj. točke pojedinačno okolo/naokolo po prozoru. Od argumenata imamo x, y, z koordinate i forsiramo floating point zbog preciznosti ( 0.0f)

    glRotatef(_angle, 0.0f, 0.0f, 1.0f)
    Ovo je funkcija koja rotira objekte ili točke na sceni prema određenim pravilima koje utvrđujemo među 4 ljepuškasta argumenta funkcije. Prvi je kut koji koristimo, a njega smo deklarirali gore (30° remember?) i jednostavno ga ubacujemo na ovo mjesto, i onda imamo x, y, z os argumente, pa biramo oko kojih osi želimo rotirati određeni objekt.

    Code:
    glBegin(GL_TRIANGLES);
    	
    	// trokut, doduše, nabubane koordinate
    	glVertex3f(0.5f, 00.5f, 0.0f);
    	glVertex3f(0.0f, 1.5f, 1.0f);
    	glVertex3f(-1.5f, -0.5f, 0.0f);
    	
    	glEnd(); // završi upisivanje koordinata verticesa trokuta
    Ovaj segment sam odlučio zasebno obraditi. Dakle, prvo što radimo jest poručimo OpenGLu da želimo iscrtavati stuff. To radimo sa funkcijom glBegin() kojoj pridružujemo zastavicu GL_TRIANGLES čime govorimo OGLu da radimo sa trokutima, tako da automatski nakon svaka 3 vertexa krene na sljedeći trokut. Koordinate su nabubane ali lijepo izgleda u konačnici. glEnd() funkcija kaže OGLu da smo završili iscrtavanje te da krene dalje u avanture iscrtavanja.

    glutSwapBuffers()
    Prvo da pojasnim dva termina, back buffer i front buffer (eng. buffer == spremnik). Tehnologija iza animiranih serija, 3D igara, 2D igara bazira se na mani ljudskog oka, a to je tromost. Dakle, ljudsko ne može u jednoj sekundi vidjeti više od 20-ak sličica pa se one pričinjavaju kao da su zapravo "žive" da se kreću. E tako kroz mainloop stalno se obavljaju mali milijun operacija stvarajući hrpetinu sličica po sekundi, ovisno koliko je računalo sposobno obraditi. Optimalno je negdje 35-40 sličica u sekundi u današnjim hitovima. Ono što trenutačno vidite na zaslonu je front buffer, a u pozadini se vrti back buffer u kojeg se spremaju slike koje će uskoro biti na zaslonu... Swap buffer, ako niste shvatili dosad, zamjenjuje front buffer sa novim back bufferom koji postaje front buffer... I tako u nedogled tj. dok se program ne prekine. Zanimljivo, ha?

    Code:
    void update (int value) 
    {
    	_angle += 2.0f;
    	if( _angle > 360 ) 
    	{
    		_angle -= 360;
    	}
    	glutPostRedisplay();
    	glutTimerFunc(25, update, 0);
    }
    Ovo je poprilično jednostavno... Prvo povećamo kut za 2°, a pošto se ovo konstantno vrti brzo će doći do 360°, pa mi zbog preciznosti floating point varijabli koristeći if statement provjerimo stanje _angle varijable. Ako se nalazi na 360°, oduzmemo 360°, i time dobivajući na efikasnosti kôda. glutPostRedisplay() funkcija služi tome da obavijesti OGL da smo ažurirali scenu te da ju ponovno iscrta. I onda pozivamo već poznatu glutTimerFunc() funkciju. Argumenti su, dakako, isti...

    To je to, imate maleni trokut pred vama sada.


    Da biste uspješno pokrenuli vaš kompilirani projekt, potrebno je kopirati glut32.dll iz vašeg GLUT direktorija (specifično npr. C:\GLUT\lib). To je to za danas... Nadam se da ste uživali. Vidimo se sljedeći put!
    Gdje je nestao mozak
    gdje se skriva on
    iz vagona pameti
    na tračnice ispao...

  4. #4
    Senior Member Respawned sorcerer
    Datum registracije
    Oct 2007
    Lokacija
    Jebem radoznale
    Postova
    1.209

    Re: TUTORIAL >> OpenGL through C++

    Maaaah...namlatit ću te,maznuo si moje! xD
    Na hardu imam spremljen jedan OpenGL i GLUT tutorial kojeg bi objavio....da mi nije crkao grafički renderer i glavni kalkulator ^^

    GG na tutorialu,super šta je GLUT korišten a ne win32...

    btw,mogao bi na kraju render funkcije poslije swap-a dodati glFlush(),čisto za optimizaciju i čišćenje buffera...
    = Citat = Izvorno postao Fenrir
    ...Onda se pobereš doma gdje isplačeš potisnuti bijes,staviš si frišku crnu maskaru na oči i metneš na plejlistu diskografiju tokyo hotela...
    Sickmanno1:Meni se na te spike dize

  5. #5
    Senior Member Small step for mankind
    Datum registracije
    Aug 2007
    Lokacija
    Latitude:45.286° Longitude:18.688°
    Postova
    2.150

    Re: TUTORIAL >> OpenGL through C++

    = Citat = Izvorno postao Plexihack
    Maaaah...namlatit ću te,maznuo si moje! xD
    Na hardu imam spremljen jedan OpenGL i GLUT tutorial kojeg bi objavio....da mi nije crkao grafički renderer i glavni kalkulator ^^

    GG na tutorialu,super šta je GLUT korišten a ne win32...

    btw,mogao bi na kraju render funkcije poslije swap-a dodati glFlush(),čisto za optimizaciju i čišćenje buffera...
    Heh... Yep, GLUT je puno bolje koristiti, win32 nikako, barem ja neću... Što se tiče glFlush(), to baš pripremam kasnije ubaciti jedan tutorial o optimizaciji i ubrzanju samog kôda. Ali prvo treba ovladati jednostavnim konceptima, pa onda razmišljati što se može bolje uraditi. Sutra stiže novi tutorial...
    Gdje je nestao mozak
    gdje se skriva on
    iz vagona pameti
    na tračnice ispao...

  6. #6
    Senior Member Small step for mankind
    Datum registracije
    Aug 2007
    Lokacija
    Latitude:45.286° Longitude:18.688°
    Postova
    2.150

    Re: TUTORIAL >> OpenGL through C++

    Malo sam se noćaš igrao sa kôdom od trokuta gore, pa evo malo pogledajte... Pokušajte skužiti što sve ima, a ja ću kasnije napisati tut na osnovu toga.

    Code:
    // header file-ovi koje je potrebno pohraniti 
    #include <iostream>
    #include <GL/glut.h>
    using namespace std;
    
    // prototipi funkcija
    void initRenderer(void);
    void resize(int, int);
    void render(void);
    void update(int);
    
    //globalne deklaracije
    float _angle = 30.f;
    int startingX = 0;
    int startingY = 0;
    float vertex1 = 1.0;
    float vertex2 = 1.0;
    float vertex3 = 1.0;
    float axisX = 0.0f;
    float axisY = 0.0f;
    float axisZ = 0.0f;
    bool leave = false;
    char choice = NULL;
    
    
    
    int main(int argc, char** argv) {
    	// korisnički ulaz
    	cout << "Unesite pocetnu sirinu i visinu prozora ( format: X Y , bez zareza): ";
    	cin >> startingX >> startingY;
    
    	cout << "Promijenite ton boje na tri vertexa: ";
    	cin >> vertex1 >> vertex2 >> vertex3;
    
    	cout << "Odaberite os(i) po kojima ce se trokut rotirati ( unos kao i kod boje): ";
    	cin >> axisX >> axisY >> axisZ;
    		
    	if ((startingX == 0) || (startingY == 0))
    	{
    		cout << "Uneseni parametri nisu ispravni! Pokusajte ponovno!";
    		return 0;
    	}
    	else 
    	{
    		cout << "Uneseni parametri su ispravni! X = " << startingX << ", Y = " << startingY << "\n";
    	}
    
    	//inicijalizacija GLUTa
    	glutInit(&argc, argv);
    	if(!glutInit)
    	{
    		cout << "Program nije uspio inicijalizirati Win32 prozor!";
    		return 0;
    	}
    	else
    	{
    		cout << "Program je uspjesno inicijalizirao Win32 prozor koristeci dane parametre!\n";
    	}
    	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    	if(!glutInitDisplayMode)
    	{
    		cout << "Program nije uspio postaviti DisplayMode prema danim parametrima!";
    		return 0;
    	}
    	else
    	{
    		cout << "Program je uspjesno postavio DisplayMode prema danim parametrima!\n";
    	}
    	glutInitWindowSize(startingX, startingY); // postavi win32 prozor
    	
    	// napravi prozor
    	glutCreateWindow("Ucionica");
    	if(!glutCreateWindow)
    	{
    		cout << "Program nije uspio napraviti prozor!";
    		return 0;
    	}
    	else
    	{
    		cout << "Program je uspjesno napravio prozor!\n";
    	}
    	initRenderer(); //inicijalizacija iscrtavanja
    
    	// postaviti ručice za funkcije koje manipuliraju scenom i prozorom
    	glutDisplayFunc(render);
    	glutReshapeFunc(resize);
    	
    	glutTimerFunc(25, update, 0);
    	glutMainLoop(); // pokreće glavnu petlju
    	return 0;  // simbolično, jer nikad se do nje neće doći
    }
    
    void initRenderer(void) 
    {
    	// omogućuje renderiranje dubine tj. ako se objekt nađe ispred nekog drugog
    	glEnable(GL_DEPTH_TEST);
    	glEnable(GL_COLOR_MATERIAL);
    	glClearColor(0.7f, 0.9f, 1.0f, 1.0f);
    }
    
    // poziva se pri mijenjanju visine i širine prozora
    void resize(int w, int h) {
    	// postavljanje viewporta, kako pretvarati podatke u pixele
    	glViewport(0, 0, w, h);
    	
    	glMatrixMode(GL_PROJECTION); // perspektiva kamere
    	
    	// postavljanje perspektive kamere
    	glLoadIdentity(); // resetiraj kameru
    	gluPerspective(45.0,                  // kut kamere
    				   (double)w / (double)h, // aspect ratio ( podijeljena visina sa širinom )
    				   1.0,                   // ono što je preblizu, ne renderiraj
    				   200.0);                // ono što je predaleko, ne renderiraj
    }
    
    // iscrtava scenu
    void render() {
    	// očisti ekran od posljednjeg iscrtavanja
    	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    	
    	glMatrixMode(GL_MODELVIEW); // perspektiva za iscrtavanje
    	glLoadIdentity(); // resetiraj perspektivu iscrtavanja
    	glTranslatef(0.0f, 0.0f, -5.0f);
    
    	glRotatef(_angle, axisX, axisY, axisZ);
    	glBegin(GL_TRIANGLES);
    	
    	// trokut, doduše, nabubane koordinate
    	glColor3f(vertex1, 0.0f, 0.0f);
    	glVertex3f(0.5f, 00.5f, 0.0f);
    	glColor3f(0.0f, vertex2, 0.0f);
    	glVertex3f(0.0f, 1.5f, 1.0f);
    	glColor3f(0.0f, 0.0f, vertex3);
    	glVertex3f(-1.5f, -0.5f, 0.0f);
    	
    	glEnd(); // završi upisivanje koordinata verticesa trokuta
    	
    	glutSwapBuffers(); // zamijeni back buffer sa front bufferom
    }
    
    void update (int value) 
    {
    	_angle += 2.0f;
    	if( _angle > 360 ) 
    	{
    		_angle -= 360;
    	}
    	glutPostRedisplay();
    	glutTimerFunc(25, update, 0);
    }
    Unosi idu ovako: x y (bez zareza, npr: 500 600 za rezoluciju)
    Za ton boje: vrijednost1 (prvi vertex) vrijednost2 (drugi vertex) vrijednost3 (treći vertex)... npr: 1.0 1.0 1.0
    Za rotaciju: osX osY osZ (npr: 2.0 1.0 3.0)
    Gdje je nestao mozak
    gdje se skriva on
    iz vagona pameti
    na tračnice ispao...

  7. #7
    Senior Member My way or the highway
    Datum registracije
    Oct 2006
    Lokacija
    Complex
    Postova
    9.283

    Re: [Tutorial]SOpenGL through C++

    Ajde, ako možeš, napravi mi dvije izvršne aplikacije (*.exe), koje pokreću 3D window (OpenGL), s time da prva ima 3D model od cca 10 poligona (kocka, tokut i sl., samo da ima malo poligona), a druga, 3D model od 1 000 (ili više) poligona, i da se model kreće randomizirano. Možeš li to napraviti i uploadati?
    [sub:16lsqdy7]Χάος

    [center:16lsqdy7]Zvuk leptirovih krila na jednoj strani svijeta izaziva efekt divljenja, a na drugoj prouzrokuje domino efekt uništenja.[/center:16lsqdy7]

    [center:16lsqdy7][ Complex Server ][/center:16lsqdy7][/sub:16lsqdy7]

Slične teme

  1. OpenGL
    By evil teddy bear in forum Programiranje i izrada igara
    Odgovora: 12
    Posljednji post: 09-07-2009, 12:22
  2. OpenGL - downside
    By RayDX in forum Programiranje i izrada igara
    Odgovora: 2
    Posljednji post: 15-06-2008, 22:47
  3. Pascal & OpenGL
    By RayDX in forum Programiranje i izrada igara
    Odgovora: 2
    Posljednji post: 23-04-2008, 14:17
  4. OpenGL 1.4.0
    By revenion in forum Pomagaj brate!
    Odgovora: 3
    Posljednji post: 22-03-2008, 23:19
  5. D3D vs OpenGL
    By Plexihack in forum Programiranje i izrada igara
    Odgovora: 5
    Posljednji post: 18-12-2007, 20:55

Pravila postanja

  • Ne možeš stvarati nove teme
  • Ne možeš odgovarati na postove
  • Ne možeš slati privitke
  • Ne možeš mijenjati svoje postove
  •