User:Igabriel85/Computer graphics/2014-2015/Laborator 2

Ce este JOGL?
JOGL este o librărie (wrapper library) care permite folosirea OpenGL (binding) din limbajul Java folosind Java Native Interface (JNI) pentru call-urile a OpenGL C API.

Compararea OpenGL și JOGL
Nu există diferențe mari între OpenGL și JOGL cel puțin când vine vorba de sintaxă.

JOGL folosește limbajul Java pentru a efectua call-uri pentru OpenGL versiunea 4.5.

JOGL păstrează nomenclatura metodelor (funcțiilor) din API-ul principal OpenGL din limbajul C. Astfel dacă cineva știe să folosească API-ul din C un utilizator poate să înțeleagă și să scrie cod folosind JOGL. Orice tutorial pentru scene 2D sau 3D scris pentru OpenGL sunt reutilizabile în JOGL, deoarece logica programului este aceeași. Una din diferențele minore nu ține de JOGL ci de Java. Printre acestea enumerăm handling-ul ferestrelor, controlul mouse și tastatură, elemente de rețelistică și sunet. Cunoștințele dobândite în cadrul acestui laborator pot fi folosite în OpenGL iar cunoștințele OpenGL pot fi folosite în JOGL. Un mare plus în folosirea JOGL față de OpenGL este portabilitate codului. Nu este necesară rescrierea unei aplicații create pe sistemul de operare Windows pentru a rula pe Linux. Mai mult de atât, nu necesită un mediu special de dezvoltare.

JOGL nu folosește datatype-uri speciale.

Toate metodele JOGL sunt înfășurate (wrapped) într-o interfață numită GL (peste 1000 de metode). Acestă înfășurare este necesară deoarece în C o funcție poate fii apelată directi dar acest lucru nu este posibil în Java. O metodă trebuie să fie declarată în clasa curentă sau într-o superclasă. Prin înfășurare putem să instanțiem un object de tip GL și să apelăm metodele acesteia.

Link-uri Utile:
 * What is openGL?
 * Java OpenGL
 * Java Native Interface
 * Language binding

OpenGL ca și "state machine"
JOGL este un state machine. Astfel programatorul trebuie să știe în ce stare se află JOGL în orice moment dat. Aceste stări sunt importante pentru că:


 * unele operații sunt executabile în anumite stări
 * stările contin valori care controlează cum este randată (redată) o scenă (matrix transformations, light characteristics, material properties, polygon drawing characteristics, etc.)

Stările în JOGL sunt compuse din variabile bine definite. Toate variabilele au valori implicite astfel putem ignora variabilele care nu ne interesează și schimbăm doar cele care sunt relevante pentru o anumită scenă. Aceste variabile rămân la valorile date până nu sunt activate/deactivate în mod explicit prin apelarea; glEnable sau glDisable. Aceste variabile se pot interoga folosind glGet*v unde * poate avea valorile: Boolean, Integer, Float sau Double. De asemenea există functii specifice pentru anumite variabile de stare: glGetLight*,glGetError, sau glGetPolygonStipple. Nu este recomandată folosirea acestora.

Salvarea și interogarea valorilor a variabilelor de stare se face prin funcțiile (metodele) glPushAttrib și glPopAttrib. Aceste funcții (metode) manipulează stiva de atribute care are o adâncime de 16 elemente. Folosire metodei glPopAttrib pe o stivă goală va rezulta într-o eroare. Același lucru este valabil și pentru aplicarea glPushAttrib pe o stivă plină.

Link-uri utile:
 * OpenGL and JOGL
 * OpenGL State Machine
 * glPushAttrib and glPopAttrib

Nomenclatură
Nomenclatura JOGL o respectă pe cea din OpenGL.

Funcții

 * Fiecare funcție(metodă) începe cu gl
 * Restul cuvintelor sunt scrise folosind camel case convention
 * Unele funcții (metode) au un sufix -- ex: 3f -- care reprezintă numărul de argumente  (3) și tipul (f) acesteia; (astfel este posibil să ave aceeași functie cu argumente diferite ; această caracteristică este contrară programării orientată Obiect (OOP) unde se folosește method overloading dar mentine sintaxa și logica OpenGL.

Tipurile posibile:
 * b -- byte -- 8 bit integer
 * s -- short -- 16 bit integer
 * i -- int -- 32 bit integer
 * f -- float -- 32 bit float
 * d -- double -- 64 bit float
 * ub, us, ui -- unsigned byte, short, int
 * Unele funcții (metode) au un v la sfârșit, acesta denotă faptul că funcția așteaptă un array de n valori.

Exemple de funcții (metode):


 * glBegin -- începutul unei primitive dată de o listă de noduri (vertices)
 * glEnd -- finalul primitivei
 * glVertex2i -- denotă coordonatele unui nod ca int (coordonata z este 0)
 * glVertex3f -- denotă coordonatele unui nod ca float
 * glColor3b -- denotă o culoare RGB cu valori între 0 și 255 bytes -- Atenție în Java byte este definit -128 până 127.
 * glColor4f -- denotă o culoare RGBA utilizând float de la 0.0 la 1.0 (A vine de la Alpha -- factor de transparență)
 * glColor4fv -- la fel cași cazul precedent doar că acceptă un singur argument -- float array

Constante

 * Fiecare constantă începe cu GL_
 * Cuvintele sunt scrise cu majuscule
 * Cuvintele sunt separate folosind underscore: _

Exemple de constante:


 * GL_COLOR_BUFFER_BIT
 * GL_LINES
 * GL_TEXTURE

Tipuri de Variabile
OpenGL are următoarele tipologii de variabile: GLbyte (signed char), GLshort (short), GLint and GLsizei (int și long), GLfloat și GLclampf (float), GLdouble și GLclampd (double), GLubyte și GLboolean (unsigned char), GLushort (unsigned short), GLuint și GLenum și GLbitfield (unsigned long). Acestea nu sunt prezente în JOGL din cauza limitărior limbajului Java. Astfel codul scris este mult mai portabil (cross platform)

Crearea primei șcene utilizănd JOGL și AWT
Următorii pași sunt obligatorii pentru a crea o aplicație JOGL minimală:


 * Instalarea librăriei JOGL
 * Crearea unei aplicații Java AWT
 * Inițializarea JOGL
 * Implementarea funcțiilor callback (methods)

Instalarea librăriei JOGL
Acesta implică: Următorul paragraf este preluat din fișierul Userguide.html găsit în arhiva librăriei (valabil pentru Windows):
 * Installarea -- sau verificarea -- runtime-ului OpenGL
 * Downloadarea distribuției JOGL (version 2.2.4) aceasta este o archivă 7z:
 * http://jogamp.org/deployment/webstart/
 * http://jogamp.org/deployment/webstart/archive/jogamp-all-platforms.7z începănd cu 2 Mai 2012 arhiva conține toate fișierele necesare (.jar, .dll(Windows) și .so (Linux)). Extrageți arhiva în folderul /lib
 * este recomandat să citiți fișierul Userguide.html aflat în arhivă
 * Dacă nu există creați folderul lib în proiectul vostru
 * Copiați toate fișierele în acest folder /lib
 * Adăugați jogl.all.jar și glugen-rt.jar CLASSPATH-ului proiectului -- acest pas depinde de IDE:
 * Pentru Eclipse expandați folderul lib și dați click-dreapta pe jogl.all.jar din meniul contextual alegeți opțiunea Add to build path
 * Dacă folosiți unelte în linie de comandă puteți include folderul lib în variabila de mediu (environmental variable) CLASSPATH'
 * Adăugarea folderului lib la variablia de mediu java.library.path în momentul rulării aplicației:
 * Din Eclipse selectați Run -> Open Run Dialog... -> Java Application -> New Configuration (sau numele dat configurației) -> Arguments tab -> adăugați linia -Djava.library.path=lib sau folderul unde se află dll-urile) în textbox-ul VM arguments
 * Dacă folosiți unelte în linie de comandă setați variabila de mediu LD_LIBRARY_PATH astfel încât să includă fodler-ul lib
 * Pentru informații mai detaliate consultați
 * The JOGL distribution for developers comes in the form of a zip archive which contains the Java classes to call OpenGL from Java, as well as the associated JNI native libraries. JOGL depends on some run-time support classes and native code provided by the GlueGen project; these classes and native code are also provided in the zip bundles.
 * If you are developing a new application which uses JOGL, download the zip archive for your platform (for example., jogl-[version]-windows-i586.zip) and unzip it. Modify your CLASSPATH environment variable to include the full paths to jogl.all.jar, nativewindow.all.jar, gluegen-rt.jar, and optionally newt.all.jar; for example, ".;C:\Some\Other\Package\foo.jar;C:\Users\myhome\jogl-[version]-windows-i586\lib\jogl.all.jar;C:\Users\myhome\jogl-[version]-windows-i586\lib\nativewindow.all.jar;C:\Users\myhome\jogl-[version]-windows-i586\lib\gluegen-rt.jar;C:\Users\myhome\jogl-[version]-windows-i586\lib\newt.all.jar". (If you did not previously set the CLASSPATH environment variable, you may want to make sure that ".", the current directory, is on your new CLASSPATH.) Modify your PATH environment variable (Windows), LD_LIBRARY_PATH environment variable (Solaris and Linux), or DYLD_LIBRARY_PATH environment variable (Mac OS X) to contain the full path to the "lib" directory; for example, on Windows, add "C:\Users\myhome\jogl-[version]-windows-i586\lib" to your PATH using the System control panel, Advanced tab, Environment Variables button. At this point your Java installation should be able to see the JOGL class files. Users of IDEs such as NetBeans and Eclipse should consult the IDE's documentation to see how to add jar files and native libraries to their current project.
 * Dropping the JOGL jar and native library into the extension directory of the JRE is strongly discouraged. Doing so can cause conflicts with third-party applications launched via Java Web Start, and causes confusion later when upgrading the distribution.

La următoarele linkuri găsiti alte instrucțiuni de instalare -- unele se referă la versiuni mai vechi JOGL:
 * JOGL Installation -- o versiune
 * JOGL Installation -- altă versiune
 * mjbWorld - Troubleshooting
 * JOGL in Eclipse

Creare unei ferestre AWT
JOGL ne pune la dispoziție două clase pentru afișarea unei șcene:


 * GLCanvas -- componentă AWT
 * GLJpannel -- componentă Swing

Ambele clase implementează interfața GLAutoDrawable, astfel se pot folosii ambele variante; este recomandat să folosiți componente AWT  -- GLCanvas -- de oare ce aceasta are o performanță mai bună. În cazul unor calculatoare mai vechi overheadul cauzat de Java + compnenta Swing poate duce la performanțe drastic reduse.

În cadrul Laboratoarelor vom folosi componenta AWT; dacă doriți puteți să o înlocuiți cu componentaa Swing.

Link-uri utile:
 * Mixing heavy and light components
 * Abstract Window Toolkit
 * Swing (Java)
 * JOGL tutorial

Pentru a crea o aplicatie AWT trebuie să creăm două clase:


 * MainFrame -- frame-ul (cadrul) aplicației
 * Test -- entry point-ul aplicației

MainFrame
'Remarcați call-ul setVisible(true) după initializeJogl''. Acesta este obligatoriu, dacă este omis starea internă a librariei este coruptă la runtime.'''

Initializare JOGL
Odată ce avem fereastra AWT putem continua cu setările relevante pentru JOGL:
 * Crearea unui profil nou GL
 * Setarea unor parametrii JOGL -- denumite capacităti în OpenGL/JOGL
 * Crearea obiectului GLCanvas și adăugarea acestuia la fereastră
 * ÎnregistrareaGLEventListener

Astfel avem metoda initializJogl care are ca și scop:


 * Obținerea unui nou GLProfile
 * Setarea diferitelor variabile -- folosind instanța  GLCapabilities. Aici putem modifica:
 * Hardware acceleration: on / off
 * Double buffering: on / off
 * Rendering mode/Modul de Randare
 * Randarea unui singur canal de culori
 * etc.
 * Crearea unei instanțe GLCanvas care va fi folosită pentru randare
 * Adăugarea instanței GLCanvas în mijlocul frame-ului
 * Înregistrarea GLEventListener la noul canvas: în cazul nostru clasa  MainFrame implementează interfață GLEventListener

Link-uri Utile:
 * OpenGL and JOGL
 * JOGL Components and GLEventListener

Funcții callback (metode)
JOGL folosește funcții (metode) callback pentru operațiuni asupra ferestrei de randare(window resizing, rendering, inițializarea scenei, etc) Există 4 funcții (metode) callback în JOGL:


 * init -- chemat la inițializare (canvas)
 * reshape -- chemat când fereastra (canvas) este redimensionată sau mutată
 * displayChanged -- chemat când modul de randare este schimbat
 * display -- chemat când scena trebuie descrisă

Link-uri utile:
 * OpenGL and JOGL
 * JOGL Components and GLEventListener

Desenarea
Probabil cea mai importantă componentă JOGL. Pentru a desena avem nevoie de implementarea metodelor display, init și reshape definite în interfața GLEventListener. Această metoda este chemată de fiecare dată JOGL redesenează scena/imaginea. De asemenea ne dă o referință către GLAutoDrawable care este instanța canvas unde a fost înregistrat listener-ul din metoda initializeJogl.

Metoda init va fi detaliată în secțiunea depre tipurile de proiecție. Dar merită să menționăm anumite aspecte ce sunt initializate în această metodă:
 * View-ul
 * Culoarea de fundal
 * Sursele de lumină
 * etc.

Metoda reshape va fii detaliată în aceeași secțiune. Scopul acesteia este ca scena randată să iși păstreze proporțiile când fereastra este manipulată (micșorată, mărită).

Animația
Metoda display este invocată când o scenă trebuie redesenată; dar dacă dorim să creăm o animație această metodă trebuie chemată de câteva ori pe secundă (cu cât este mai mare frecvență cu atât este animația mai realistă). Butem realiza acest lucru prin crearea unui fir de execuție special care forțează rerandarea imaginii dar o altă soluție -- și cea recomandată -- este de a folosi clasa Animator (care folosește un fir de executie special).

Pentru acesta trebuie să creăm un membru al clase Animator și să includem acest membru în funcția (metoda) initializeJogl:
 * Creara instanței
 * Adâugarea animatorului în canvas (suprafața de randare)
 * Pornirea animatorului

Link-uri Utile:
 * OpenGL and JOGL:
 * Animation
 * Animator

Șablon pentru aplicații JOGL
Puteți găsii șablonul pentru aplicații JOGL la link-ul: Grafica -- 2014-2015 -- info.uvt.ro/JOGL-Template.

Sistemul de Coordonate (JOGL vs. AWT)
În forma cea mai simplă sistemul de coordonate folosite este cel Cartezian cu cele 3 axe (X, Y, Z). În realitate OpenGL are o a patra coordonate care funcționează ca și factor de scalare -- homogeneous coordinates.

Este important să ținem minte că punctul de start este situat în partea din stânga jos a suprafeței de randat (de acum încolo va fi numită canvas). Pentru AWT și Swing punctul de start este partea din stânga sus fiind astfel inversa situației din OpenGL.

Link-uri Utile:
 * Cartesian coordinate system
 * Homogeneous coordinates
 * 
 * OpenGL and JOGL
 * Homogeneous Coordinates

Proiecții
JOGL ne oferă două tipuri de proiecții:


 * Perspectiva -- definită de un centru de proiecție și un plan de proiecție unde obiectele sunt proiectate (în engleză projection center și projection plane )
 * În JOGL acesta se poate obține folosind următoarele funcții (metode):
 * glFrustum(left, right, bottom, top, near, far) -- din instanțele GL
 * gluPerspective(fovy, aspect, near, far) -- din instanțele GLU
 * Este perfect pentru scene 3D


 * Ortogonal -- un tip de proiecție definită pintr-o direcție și un plan al proiecției. Acest tip de proiecție poate fii văzut ca o proiecție în prespectivă unde centru proiecției este la infinit.
 * În JOGL acest tipde proiecție se obtine prin functia (metoda) glOrtho(left, right, bottom, top, near, far)
 * Good for 2D scenes

Viewport și View volume
Viewport este o zonă dreptunghiulară -- în cadrul ferestrei JOGL -- unde se randează scenele/imaginile. Este măsurată în pixeli, și este poziționată față de colțul din stânga sus a componentei.

În mod implicit viewport-ul este setat să acopere toată suprafața componentei (canvas). Astfel dacă fereastra este redimensionată și viewport trebuie redimensionat -- folosind funcția (metoda) glViewport.

Când redăm o scenă trebuie să definim și viewing volume -- un paralelipiped dreptunghic (proiecție ortogonala) sau o piramidă trunchiată (perspectivă) -- care va fi afișată în viewport. Oricare obiect care nu se află în cadrul acestui volum nu este afișat (clipped). Fiecare parte a acestui volum este numit un clip plane.

Putem să definim și alte limite în cadrul acestor volume folosind funcția (metoda) glClipPlane(int plane, double[] equation). Parametrul equation se referă la coeficienții care corespund limitei (clip plane).

Aceste limite adiționale se pot activa și dezactiva folosind gl.glEnable(GL.GL_CLIP_PLANE1) și gl.glDisable(GL.GL_CLIP_PLANE1).

În general raportul de aspect (aspect ration) a viewport și view volume este același. În caz contrar imaginea/scena va apare distorsionată.

JOGL folosește matrici pentru a administra view:


 * projection view -- matricea este folosită pentru a definii viewing volume-ul, folosind funcția (metoda) glMatrixMode(GLMatrixFunc.GL_PROJECTION).
 * model view -- matricea care este folosită pentru transformări geometrice a obiectelor (translation, rotation, scaling, etc.) căt și orientarea viewport-ului. Pentru aceasta se folosește funcția (metoda) glMatrixMode(GLMatrixFunc.GL_MODELVIEW)

Aceste matrici sunt modificate de fiecare dată o scenă este modificată, ea se poate reseta aplicând matricea identitate (unitate) matricii curente. Pentru acesta se folosește funcția (metoda) glLoadIdentity.

Cum se folosesc în JOGL?
Matricea de proiecție (projection matrix) este folosită în cadrul funcției (metodei) reshape și inițializată în init. Acest lucru este posibil de oare ce evenimentele de modificare a dimensiunii se rezolvă în funcția reshape. La fiecare eveniment de redimensionare trebuiesc modificate proiecțiile  și aspec ratio.

După ce modificăm matricea de proiecție trebuie să schimbăm (switch) pe modul modelview.

Următorul fragment de cod exemplifică acest lucru:

Link-uri Utile:
 * Orthographic projection
 * Perspective (graphical)
 * OpenGL and JOGL:
 * Viewport Transformation
 * Projection Transformations
 * Orthographic Projection
 * Perspective Projection

Spațiul de Coordonate
JOGL folosește mai multe spații de coordonate (coordinate spaces) pentru a transforma coordonatele date de utilizator la cele folosite pentru a afișa scena:
 * Object Coordinates -- coordonatele carteziene definite folosind funcția (metoda) glVertex*
 * Eye Coordinates -- este obtinută de ModelView matrix care contine transformările ale modelului cât și a vizualizării astfel poate plasa punctul de privire orientat pe axa negativă Z.
 * Clip Coordinates - sunt ibținute din Projection Matrix după transformarea Eye Coordinates. Coordonatele sunt are valorile de la -W la W pe toate cele 3 axe, obiectele înafară acestor coordonate nu se afișează
 * Normalized Device Coordinates -- situate între -1 și 1 si sunt obținute după transformarea Clip Coordinates cu ajutor Perspective division
 * Window Coordinates -- scalarea și translatarea coordonatele Normalized Device Coordinates față de  viewport. Acestă operațiune ne dă coordonatle finale utilizate pentru a reda o șcenă. Această operație este realizată cu ajutorul funcțiilor (metodelor)  glViewport și glDepthRange.

Astfel workflow-ul normal pentru transformarea coordonatelor este: Object Coordinates → Eye Coordinates → Clip Coordinates → Normalized Device Coordinates → Window Coordinates.

Un sistem special de coordonate este reprezentat de World Coordinates care este rezultatul transformărilor Object Coordinates folosind rotations, translations și scalings stocate în ModelView matrix. Practic World Coordinates este diferit pentru fiecare aplicatie. Este creată după rotirea, scalarea și translatarea Object Coordinates în zona de afișare a applicației.

În secțiunile anterioare am discutate despre proiecții ortostatice. Acestea sunt create folosind funcțiile (metodele) callback init și reshape:

Acum vrem să setăm ca o unitate de măsură din proiecție să fie reprezentață de un pixel. Pentru aceasta trebuie să modificăm funcția (metoda) glOrtho:

Acesta ne dă un viewport având ca dimensiune toată suprafața ferestre de randare (canvas) JOGL. Este important de menționat faptul că  viewport-ului poate fi de orice dimensiune. Dacă definim view colum-ul ca fiind gl.glOrtho(0, 1, 0, 1, -1, 1) observăm că nodul definit de glVertex2f(2.0f, 2.0f) nu va fi afișat. Dacă folosim gl.glOrtho(0, 800, 0, 600, -1, 1); același nod va apare în partea din stânga jos a ferestrei. JOGL nu are o unitate standard de măsură pentru plasarea obiectelor. Astfel putem folosii orice unitate potrivită pentru o aplicație. De exemplu o unitate astronomică pentru a crea un simulator spațial sau nanometrii pentru a crea un simulator de structuri atomice.

'Important: Când definim plaja de valori pentru Z de la -1 la 1 trebuie să folosim funcția (metoda) glVertex2*''. În cazul glVertex3* a treia coordonată trebuie să fie 0.'''

Link-uri Utile:
 * OpenGL and JOGL:
 * The Camera Analogy
 * Stages of Vertex Transformation

Vertices vs. Points vs. Pixels

 * Vertices sau noduri sunt cele mai simple primitive folosite în JOGL
 * Nodurile pot fii văzute ca puncte reprezentate ca și vectori definiți cu ajutorul float
 * Un nod (sau vertex) NU este un pixel
 * Un nod este declarat folosind funcția (metoda) glVertex*

Nodurile se pot grupa astfel încât să formeze forme geometrice precum linii, triunghiuri, poligoane, etc.

Nodurile grupate astfel trebuie să fie în cadrul unui bloc glBegin și glEnd : To group together vertices one must bound them inside a glBegin and glEnd block:

Liste de puncte (points, lines, line strip, line loop)
Nodurile pot fi interpretate de către JOGL în felul următor:


 * points -- specificat de GL.GL_POINTS și le consideră un set de puncte
 * lines -- specificat de GL.GL_LINES punctele sunt considerate ca și segmente de drepte
 * line strip -- specificat de GL.GL_LINE_STRIP consideră punctele ca o serie de drepte interconectate
 * line loop -- specificat de GL.GL_LINE_LOOP la fel ca și cazul precedent dar adaugă o dreaptă între prima și ultima dreaptă

Link-uri Utile:
 * Points
 * Lines
 * Geometric Lines Primitves
 * Specifying Vertices
 * Drawing Primitives in OpenGL:
 * Primitive examples

Schimbarea proprietăților pentru puncte (dimensiune, grosime)
Punctele și liniile au proprietătile:


 * dimensiune (puncte) -- modificat utilizând funcția (metoda) glPointSize:


 * lățime (linii) -- modificat folosind funcția (metoda) glLineWidth:


 * stipple (lininii) -- modificat folosind funcția (metoda) glLineStipple:

Culori
JOGL -- ca și majoritatea produselor software -- folosește culori RGB definite pe 24 de biti, în unele situații RGBA.

De fiecare dată o șcenă este (re)desenată acesta este acoperită cu o culoare definită prin funcția (metoda) glClearColor -- culoarea implicită este culoarea neagra definită RGB = (0,0,0). Acest lucru implică manipularea color buffer -ului (acesta contine culorile pixelilor a ferestrei curente). Acest buffer va fi detaliat în laboratoarele următoare.

Fiecare obiect este desenată cu o altă culoare defeinită folosind functia (metoda) glColor*.

Link-uri Utile:
 * OpenGL and JOGL:
 * Bitplanes
 * Colormode: RGBA versus Color-Index Mode
 * Color in RGBA Mode: glColor

API

 * java.media.opengl:
 * GLCapabilities
 * GLCanvas
 * GLAutoDrawable
 * GL:
 * glClear(int)
 * glBegin(int)
 * glEnd
 * glFlush
 * glVertex3f(float, float, float)
 * glColor3f(float, float, float)
 * glClearColor(float, float, float, float)
 * glMatrixMode(int)
 * glLoadIdentity
 * glOrtho(double, double, double, double, double, double)
 * glFrustum(double, double, double, double, double, double)
 * glClipPlane(int, doublev)
 * glPushAttrib(int)
 * glPopAttrib
 * glAccum(int, float)
 * glHint(int, int)


 * javax.media.opengl.glu:
 * GLU
 * void gluPerspective(double, double, double, double)


 * com.sun.opengl.util:
 * Animator:
 * add(GLAutoDrawable)
 * start
 * FPSAnimator:
 * constructor(int)
 * GLUT

Exerciții

 * Creați o aplicatie minimală JOGL folosind Eclipse care instanțiază o simplă fereastră de randare.
 * Desenați câte un pătrat folosind GL_LINES, GL_LINE_STRIP and GL_LINE_LOOP. Fiecare nod (vertex) să aibă o culoare diferită
 * Desenați un cerc folosind GL_LINE_LOOP
 * Desenați o casă utilizând GL_LINES. Adăugați mai multe culori. Opțional adăugați un soare care se mișcă de la dreapta la stânga.
 * Opțional -- Desenați fractalul de la site-ul acesta. Puteți vedea și alți fractali la această pagină.
 * Metoda de desenare trebuie să fie recursivă!