OpenGLOpenGL adalah antarmuka perangkat lunak ke perangkat keras grafis.

Dengan
kata lain, perintah rendering grafis OpenGL yang dikeluarkan oleh aplikasi Anda dapat
diarahkan ke perangkat keras grafis dan dipercepat.
3 set perpustakaan dalam program OpenGL :
1. nti OpenGL (GL) : terdiri dari ratusan perintah, yang dimulai dengan awalan " gl"
(misalnya, glColor, glVertex, glTranslate, glRotate). Core OpenGL memodelkan
suatu objek melalui sekumpulan primitif geometri seperti titik, garis, dan poligon.
2. OpenGL Utility Library (GLU) : dibangun di atas inti OpenGL untuk
menyediakan utilitas penting (seperti mengatur tampilan dan proyeksi kamera) dan
lebih banyak model bangunan (seperti permukaan qradric dan tessellation
poligon). Perintah GLU mulai dengan awalan " glu"
(mis. gluLookAt, gluPerspective).
3. OpenGL Utilities Toolkit (GLUT) : OpenGL dirancang untuk terlepas dari
sistem windowing atau sistem operasi. GLUT diperlukan untuk berinteraksi dengan
Sistem Operasi (seperti membuat jendela, menangani input tombol dan mouse); itu
juga menyediakan lebih banyak model bangunan (seperti bola dan torus). Perintah
GLUT dimulai dengan awalan " glut"
(mis. glutCreatewindow, glutMouseFunc). GLUT adalah platform independen, yang
dibangun di atas ekstensi OpenGL khusus platform seperti GLX untuk Sistem X
Window, WGL untuk Microsoft Window, dan AGL, CGL atau Cocoa untuk Mac OS.
4. OpenGL Extension Wrangler Library (GLEW) : "GLEW adalah pustaka
pemuatan ekstensi open / source C / C ++ lintas-platform open-source. GLEW
menyediakan mekanisme run-time yang efisien untuk menentukan ekstensi OpenGL
mana yang didukung pada platform target.

1. Vertex, Primitive and Color

Contoh 2: Vertex, Primitive, dan Color ( GL02Primitive.cpp )
/*
* GL02Primitive.cpp: Vertex, Primitive, dan Color
* Menggambar Bentuk berwarna 2D Sederhana: quad, segitiga dan poligon.
*/
#sertakan <windows.h> // untuk MS Windows
#include <GL / glut.h> // GLUT, sertakan glu.h dan gl.h

/ * Menginisialisasi OpenGL Graphics * /

membatalkan initGL () {
// Tetapkan "clearing" atau warna latar belakang
glClearColor (0.0f, 0.0f, 0.0f, 1.0f); // Hitam dan buram
}

/ * Handler untuk acara pengecatan ulang jendela. Telepon balik ketika jendela
pertama kali muncul dan
setiap kali jendela perlu dicat ulang. * /
tampilan batal () {
 glClear (GL_COLOR_BUFFER_BIT); // Bersihkan buffer warna dengan warna
kliring saat ini

// Tetapkan bentuk terlampir dalam sepasang glBegin dan glEnd

glBegin (GL_QUADS); // Setiap set 4 simpul membentuk quad
glColor3f (1.0f, 0.0f, 0.0f); // Red
glVertex2f (-0.8f, 0.1f); // Tentukan simpul dalam berlawanan arah jarum
jam (CCW) agar
glVertex2f (-0.2f, 0.1f); // agar normal (muka-depan) menghadapmu
glVertex2f (-0.2f, 0.7f);
glVertex2f (-0.8f, 0.7f);

glColor3f (0,0f, 1.0f, 0.0f); // Hijau

glVertex2f (-0.7f, -0.6f);
glVertex2f (-0.1f, -0.6f);
glVertex2f (-0.1f, 0.0f);
glVertex2f (-0.7f, 0.0f);

glColor3f (0.2f, 0.2f, 0.2f); // Abu-abu gelap

glVertex2f (-0.9f, -0.7f);
glColor3f (1.0f, 1.0f, 1.0f); // Putih
glVertex2f (-0.5f, -0.7f);
glColor3f (0.2f, 0.2f, 0.2f); // Abu-abu gelap
glVertex2f (-0.5f, -0.3f);
glColor3f (1.0f, 1.0f, 1.0f); // Putih
glVertex2f (-0.9f, -0.3f);
glEnd ();

glBegin (GL_TRIANGLES); // Setiap set 3 simpul membentuk segitiga

glColor3f (0.0f, 0.0f, 1.0f); // Biru
glVertex2f (0.1f, -0.6f);
glVertex2f (0.7f, -0.6f);
glVertex2f (0.4f, -0.1f);

glColor3f (1.0f, 0.0f, 0.0f); // Merah

glVertex2f (0.3f, -0.4f);
glColor3f (0,0f, 1.0f, 0.0f); // Hijau
glVertex2f (0.9f, -0.4f);
glColor3f (0.0f, 0.0f, 1.0f); // Biru
glVertex2f (0.6f, -0.9f);
glEnd ();

glBegin (GL_POLYGON); // Simpul-simpul ini membentuk poligon

tertutup
glColor3f (1.0f, 1.0f, 0.0f); // Kuning
 glVertex2f (0.4f, 0.2f);
glVertex2f (0.6f, 0.2f);
glVertex2f (0.7f, 0.4f);
glVertex2f (0.6f, 0.6f);
glVertex2f (0.4f, 0.6f);
glVertex2f (0.3f, 0.4f);
glEnd ();

glFlush (); // Berikan sekarang

}

/ * Fungsi utama: GLUT berjalan sebagai aplikasi konsol mulai dari main () * /
int main (int argc, char ** argv) {
glutInit (& argc, argv); // Inisialisasi GLUT
glutCreateWindow ("Vertex, Primitive & Color"); // Buat jendela dengan judul
yang diberikan
glutInitWindowSize (320, 320); // Tetapkan lebar & tinggi
glutInitWindowPosition awal jendela (50, 50); // Posisikan awal sudut kiri atas
glutDisplayFunc (tampilan); // Daftarkan callback handler untuk acara
pengecatan ulang jendela
initGL (); // Inisialisasi OpenGL kami sendiri
glutMainLoop (); // Masukkan loop pemrosesan-acara
return 0;
}

Output yang diharapkan dan koordinat adalah sebagai berikut. Perhatikan bahwa 4
bentuk memiliki warna murni, dan 2 bentuk memiliki warna yang menyatu dari
simpulnya.

2. OpenGL sebagai Mesin Negara

OpenGL beroperasi sebagai mesin negara , dan memelihara seperangkat variabel
status (seperti warna latar depan, warna latar belakang, dan banyak lagi
 lainnya). Dalam mesin keadaan, begitu nilai variabel keadaan diatur, nilainya tetap
sampai nilai baru diberikan.
Sebagai contoh, kita mengatur "kliring" (latar belakang) warna
hitam sekali di initGL(). Kami menggunakan pengaturan ini untuk menghapus jendela
di display() berulang kali ( display()dipanggil kembali setiap kali ada permintaan
melukis ulang jendela) - warna kliring tidak berubah di seluruh program.
// Dalam initGL (), atur "clearing" atau warna latar belakang
glClearColor (0.0f, 0.0f, 0.0f, 1.0f); // hitam dan buram

// Dalam tampilan (), kosongkan buffer warna (yaitu, atur latar belakang) dengan
glClear "kliring" warna saat ini (GL_COLOR_BUFFER_BIT);

3. Konvensi Penamaan untuk Fungsi OpenGL

Fungsi OpenGL:
 dimulai dengan huruf kecil gl(untuk OpenGL inti), glu(untuk OpenGL Utility)
atau glut(untuk OpenGL Utility Toolkit).
 diikuti oleh tujuan fungsi, dalam kasus unta (huruf kapital awal),
misalnya, glColoruntuk menentukan warna gambar, glVertexuntuk menentukan
posisi titik.
 diikuti oleh spesifikasi untuk parameter, misalnya, glColor3fmengambil
tiga floatparameter. glVectex2imembutuhkan dua intparameter.

Konvensi dapat dinyatakan sebagai berikut:

returnType gl Function [234] [sifd] ( nilai tipe , ...); // 2, 3 atau 4

parameter
returnType gl Fungsi [234] [sifd] v ( tipe * nilai ); // parameter array

OpenGL mendefinisikan tipe datanya sendiri :

 Integer yang Ditandatangani: GLbyte(8-bit), GLshort(16-bit), GLint(32-bit).
 Bilangan Bulat Tanpa Tanda: GLubyte(8-bit), GLushort(16-bit), GLuint(32-
bit).
 Angka titik-mengambang: GLfloat(32-bit), GLdouble(64-
bit), GLclampfdan GLclampd(antara 0,0 dan 1,0).
 GLboolean (char unsigned dengan 0 untuk false dan non-0 untuk true).
 GLsizei (Bilangan bulat non-negatif 32-bit).
 GLenum (Bilangan bulat 32-bit).
 Jenis OpenGL didefinisikan melalui typedef" gl.h" sebagai berikut:

mengetikkan unsigned int GLenum;

ketik char unsigned GLboolean;
ketikkan unsigned int GLbitfield;
typedef void GLvoid;
typedef signed char GLbyte; / * 1-byte bertanda * /
typedef GLshort pendek; / * 2-byte ditandatangani * /
typedef int GLint; / * 4-byte bertanda * /
typedef unsigned char GLubyte; / * 1-byte unsigned * /
typedef unsigned short GLushort; / * 2-byte unsigned * /
typedef unsigned int GLuint; / * 4-byte unsigned * /
typedef int GLsizei; / * 4 byte bertanda * /
typedef float GLfloat; / * float presisi tunggal * /
typedef float GLclampf; / * float presisi tunggal dalam [0,1] * /
ketik GL ganda; / * float presisi ganda * /
typedef GLclampd ganda; / * float presisi ganda dalam [0,1] * /
Konstanta OpenGL dimulai dengan " GL_", " GLU_" atau " GLUT_", dalam huruf
besar dipisahkan dengan garis bawah, misalnya GL_COLOR_BUFFER_BIT,

Sebagai contoh,

glVertex3f (1.1f, 2.2f, 3.3f); // 3 parameter GLfloat

glVertex2i (4, 5); // 2 paramaters GLint glColor4f
(0.0f, 0.0f, 0.0f, 1.0f); // 4 parameter GLfloat

GLdouble aVertex [] = {1.1, 2.2, 3.3};

glVertex3fv (aVertex); // array 3 nilai GLfloat
4. Inisialisasi Satu Kali initGL ()
Ini initGL()dimaksudkan untuk melakukan tugas inisialisasi OpenGL satu kali, seperti
mengatur warna kliring. initGL()dipanggil sekali (dan hanya sekali) di main().
5. tampilan Callback Handler ()
Fungsi display()ini dikenal sebagai pengendali event callback . Pengatur kejadian
menyediakan respons terhadap peristiwa tertentu (seperti penekanan tombol, klik
mouse, cat jendela). Fungsi ini dimaksudkan sebagai penangan untuk acara cat-jendela
. Sistem grafis OpenGL memanggil kembali sebagai tanggapan atas permintaan cat-
jendela untuk mengecat ulang jendela (misalnya, jendela pertama kali muncul, jendela
dipulihkan setelah diminimalkan, dan jendela diubah ukurannya).
6. Menyiapkan GLUT - main ()
GLUT menyediakan utilitas tingkat tinggi untuk menyederhanakan pemrograman
OpenGL, terutama dalam berinteraksi dengan Sistem Operasi (seperti membuat
jendela, menangani input tombol dan mouse). Fungsi GLUT berikut digunakan dalam
program di atas:
 glutInit: menginisialisasi GLUT, harus dipanggil sebelum fungsi GL / GLUT
lainnya. Dibutuhkan argumen yang sama dengan main().
 void glutInit (int * argc , char ** argv )

 glutCreateWindow: membuat jendela dengan judul yang diberikan.

int glutCreateWindow (char * title )

 glutInitWindowSize: menentukan lebar dan tinggi jendela awal, dalam piksel.

void glutInitWindowSize ( lebar int, tinggi int )

 glutInitWindowPosition: menempatkan sudut kiri atas jendela awal di

( x , y ). Koordinat ( x , y ), dalam hal piksel, diukur dalam koordinat jendela, yaitu asal
(0, 0) berada di sudut kiri atas layar; sumbu x mengarah ke kanan dan sumbu y
mengarah ke bawah.

void glutInitWindowPosition (int x , int y )

 glutDisplayFunc: mendaftarkan fungsi panggilan balik (atau pengendali acara) untuk

menangani acara cat-jendela. Sistem grafis OpenGL memanggil kembali penangan ini
ketika menerima permintaan pengecatan ulang jendela. Dalam contoh, kita
mendaftarkan fungsi display()sebagai pengendali.

void glutDisplayFunc (void (* func ) (void))

 glutMainLoop: memasuki loop pemrosesan peristiwa tak terbatas, yaitu,

menempatkan sistem grafis OpenGL untuk menunggu acara (seperti mengecat ulang),
dan memicu masing-masing pengendali acara (seperti display()).

batal glutMainLoop ()

7. Warna
Kami menggunakan glColorfungsi untuk mengatur warna latar depan ,
dan glClearColorfungsi untuk mengatur warna latar belakang (atau membersihkan ).

membatalkan glColor3f (GLfloat merah , GLfloat hijau , GLfloat biru )

kekosongan glColor3fv (GLfloat * colorRGB )
membatalkan glColor4f (GLfloat merah , GLfloat hijau , GLfloat biru , GLfloat
alpha )
kekosongan glColor4fv (GLfloat * colorRGBA )
 void glClearColor (GLclampf red , GLclampf green , GLclampf blue , GLclampf
alpha )
// GLclampf di kisaran 0.0f hingga 1.0f

Catatan:
 Warna biasanya ditentukan dalam floatkisaran 0.0fdan 1.0f.
 Warna dapat ditentukan menggunakan komponen RGB (Merah-Hijau-Biru) atau
RGBA (Merah-Hijau-Biru-Alpha). 'A' (atau alpha) menentukan indeks transparansi
(atau opacity), dengan nilai 1 menunjukkan buram (tidak transparan dan tidak dapat
melihat-melalui) dan nilai 0 menunjukkan total transparan. Kami akan membahas
alpha nanti.

8. Primitif Geometris
Dalam OpenGL, suatu objek terdiri dari primitif geometris seperti segitiga, quad,
segmen garis dan titik. Primitif terdiri dari satu atau lebih simpul. OpenGL mendukung
primitif berikut:

9. Sistem Koordinat 2D dan Tampilan Default

 Area kliping OpenGL 2D default (yaitu, apa yang ditangkap oleh kamera) adalah
tampilan ortografis dengan x dan y dalam kisaran -1.0 dan 1.0, yaitu, persegi 2x2
dengan berpusat pada titik asal. Area kliping ini dipetakan ke viewport di layar.
Viewport diukur dalam piksel.

6. Animation
6.1 Idle Function
Untuk melakukan animasi (mis., Memutar bentuk), Anda bisa mendaftarkan
idle()penelepon panggilan balik dengan GLUT, melalui glutIdleFuncperintah. Sistem
grafis akan memanggil kembali idle()fungsi ketika tidak ada acara lain untuk diproses.

void glutIdleFunc (void (* func))

Dalam idle()fungsi tersebut, Anda bisa mengeluarkan glutPostRedisplayperintah untuk

mengirim permintaan pengecatan ulang jendela, yang pada gilirannya akan
mengaktifkan display()fungsi.

membatalkan idle () {
glutPostRedisplay (); // Posting permintaan cat ulang untuk
mengaktifkan tampilan ()
}

Perhatikan bahwa hal di atas setara dengan mendaftar display()sebagai idlefungsi.

// main
glutIdleFunc (tampilan);
6.2 Double Buffering
Double Buffering menggunakan dua penyangga tampilan untuk memperlancar
animasi. Layar selanjutnya disiapkan di buffer belakang , sedangkan layar saat ini disimpan
di buffer depan . Setelah persiapan selesai, Anda dapat
menggunakan glutSwapBufferperintah untuk menukar buffer depan dan belakang.
Untuk menggunakan buffering ganda, Anda perlu membuat dua perubahan:
1. Dalam main(), sertakan baris ini sebelum membuat jendela:

glutInitDisplayMode (GLUT_DOUBLE); // Tetapkan mode buffered ganda

2. Dalam display()fungsi, ganti glFlush()dengan glutSwapBuffers(), yang menukar

buffer depan dan belakang.

6.3 Example 5: Animation using Idle Function (GL05IdleFunc.cpp)

Program berikut memutar semua bentuk yang dibuat dalam contoh sebelumnya
menggunakan fungsi idle dengan buffering ganda.
1/ *
2 * GL05IdleFunc.cpp: Terjemahan dan Rotasi
3 * Mengubah primitif dari ruang model mereka ke ruang dunia (Model Transform).
4 * /
5#sertakan <windows.h> // untuk MS Windows
6#include <GL / glut.h> // GLUT, sertakan glu.h dan gl.h
7
8// Variabel global,
9Angle GLfloat = 0.0f; // Sudut rotasi saat ini dari bentuk
10
11 / * Inisialisasi OpenGL Graphics * /
12void initGL () { // Atur "kliring" atau warna latar belakang
13 glClearColor (0.0f, 0.0f, 0.0f, 1.0f); // Hitam dan buram
14} / * Dipanggil kembali ketika tidak ada acara lain yang harus ditangani * /
15void idle () {
16 glutPostRedisplay ();
17
18
19// Posting permintaan cat ulang untuk mengaktifkan tampilan ()
20}
21
22/ * Handler untuk acara pengecatan ulang jendela. Menelepon kembali ketika jendela pertama k
23 setiap kali jendela perlu dicat ulang. * /
24batal tampilan () {
25 glClear (GL_COLOR_BUFFER_BIT); // Bersihkan buffer warna
26 glMatrixMode (GL_MODELVIEW); // Untuk beroperasi pada Model-View matrix
27 glLoadIdentity (); // Atur ulang model-view matrix
28
29 glPushMatrix (); // Simpan pengaturan model-view
30 glTranslatef (-0.5f, 0.4f, 0.0f); // Terjemahkan
31 glRotatef (angle, 0.0f, 0.0f, 1.0f); // putar dengan sudut dalam derajat
32 glBegin (GL_QUADS); // Setiap set 4 simpul membentuk
33 quad
34 glColor3f (1.0f, 0.0f, 0.0f); // Red
35 glVertex2f (-0.3f, -0.3f);
36 glVertex2f (0.3f, -0.3f);
37 glVertex2f (0.3f, 0.3f);
38 glVertex2f (-0.3f, 0.3f);
39 glEnd (); glPopMatrix (); // Kembalikan matriks model-view
40 glPushMatrix (); // Simpan pengaturan model-view matrix
41 glTranslatef (-0.4f, -0.3f, 0.0f); // Terjemahkan
42 glRotatef (angle, 0.0f, 0.0f, 1.0f); // putar dengan sudut dalam derajat
43 glBegin (GL_QUADS);
44 glColor3f (0,0f, 1.0f, 0.0f); // Hijau
45 glVertex2f (-0.3f, -0.3f);
46
47
48 glVertex2f (0.3f, -0.3f);
49 glVertex2f (0.3f, 0.3f);
50 glVertex2f (-0.3f, 0.3f);
51 glEnd (); glPopMatrix (); // Kembalikan matriks model-view
52 glPushMatrix (); // Simpan pengaturan model-view matrix
53 glTranslatef (-0.7f, -0.5f, 0.0f); // Terjemahkan
54 glRotatef (angle, 0.0f, 0.0f, 1.0f); // putar dengan sudut dalam derajat
55 glBegin (GL_QUADS);
56 glColor3f (0.2f, 0.2f, 0.2f); // Dark Grey
57 glVertex2f (-0.2f, -0.2f);
58 glColor3f (1.0f, 1.0f, 1.0f); // White
59 glVertex2f (0.2f, -0.2f);
60 glColor3f (0.2f, 0.2f, 0.2f);
61
62 // Dark Grey
63 glVertex2f (0.2f, 0.2f);
64 glColor3f (1.0f, 1.0f, 1.0f); // White
65 glVertex2f (-0.2f, 0.2f);
66 glEnd (); glPopMatrix (); // Kembalikan matriks model-view
67 glPushMatrix (); // Simpan pengaturan matriks model-view
68 glTranslatef (0.4f, -0.3f, 0.0f); // Terjemahkan
69 glRotatef (angle, 0.0f, 0.0f, 1.0f); // putar dengan sudut dalam derajat
70 glBegin (GL_TRIANGLES);
71 glColor3f (0.0f, 0.0f, 1.0f); // Blue
72 glVertex2f (-0.3f, -0.2f);
 73 glVertex2f (0.3f, -0.2f);
74 glVertex2f (0.0f, 0.3f);
75 glEnd ();
76
77
78 glPopMatrix (); // Kembalikan matriks model-view
79
80 glPushMatrix (); // Simpan pengaturan matriks tampilan model
81 glTranslatef (0.6f, -0.6f, 0.0f); // Terjemahkan
82 glRotatef (180.0f + sudut, 0.0f, 0.0f, 1.0f); // Putar 180 + derajat sudut
83 glBegin (GL_TRIANGLES);
84 glColor3f (1.0f, 0.0f, 0.0f); // Red
85 glVertex2f (-0.3f, -0.2f);
86 glColor3f (0,0f, 1.0f, 0.0f); // Hijau
87 glVertex2f (0.3f, -0.2f);
88 glColor3f (0.0f, 0.0f, 1.0f); // Blue
89 glVertex2f (0.0f, 0.3f);
90 glEnd (); glPopMatrix ();
91 // Kembalikan matriks model-view
92
93 glPushMatrix (); // Simpan pengaturan model-view
94 glTranslatef (0.5f, 0.4f, 0.0f); // Terjemahkan
95 glRotatef (angle, 0.0f, 0.0f, 1.0f); // putar dengan sudut dalam derajat
96 glBegin (GL_POLYGON);
97 glColor3f (1.0f, 1.0f, 0.0f); // Kuning
98 glVertex2f (-0.1f, -0.2f);
99 glVertex2f (0.1f, -0.2f);
100 glVertex2f (0.2f, 0.0f);
101 glVertex2f (0.1f, 0.2f);
102 glVertex2f (-0.1f, 0.2f);
103 glVertex2f (-0.2f, 0.0f);
104 glEnd (); glPopMatrix (); // Kembalikan matriks model-view
105 glutSwapBuffers ();
106
107 // Double buffered - menukar buffer depan dan belakang
108
109 // Ubah sudut rotasi setelah setiap tampilan ()
110 sudut + = 0,2f;
111} / * Handler untuk event ukuran ulang window. Dipanggil kembali ketika
112 jendela pertama kali muncul dan
113 setiap kali jendela diukur ulang dengan lebar dan tinggi baru * /
114membatalkan pembentukan kembali (lebar GLsizei, tinggi GLsizei) { //
115 GLsizei untuk bilangan bulat non-negatif // Hitung rasio aspek jendela baru
116 if (height == 0) height = 1; // Untuk mencegah pembagian
117 dengan 0
118 aspek GLfloat = lebar (GLfloat) / tinggi (GLfloat); // Tetapkan viewport
119untuk menutup jendela
120 glViewport baru (0, 0, lebar, tinggi);
121
122
123
124
125
126
127 // Tetapkan rasio aspek area kliping agar sesuai dengan viewport
128 glMatrixMode (GL_PROJECTION); // Untuk beroperasi pada matriks Proyeksi
129 glLoadIdentity ();
130 if (width> = height) { // aspect> = 1, atur tinggi dari -1 ke 1,
131 dengan lebar
132 gluOrtho2D yang lebih besar (aspek -1.0 *, aspek 1.0 *, -1.0, 1.0);
133 } else { // aspek <1, atur lebar ke -1 ke 1, dengan tinggi
134 gluOrtho2D yang lebih besar (-1.0, 1.0, -1.0 / aspek, 1.0 / aspek);
135 }
136} / * Fungsi utama: GLUT berjalan sebagai aplikasi konsol mulai dari main () * /
137int main (int argc, char ** argv) {
138 glutInit (& argc, argv); // Inisialisasi GLUT glutInitDisplayMode (GLUT_DOUBLE);
139
140
141
142
143 // Aktifkan mode buffered ganda
144 glutInitWindowSize (640, 480); // Tetapkan lebar & tinggi awal jendela
145- non-square
146 glutInitWindowPosition (50, 50); // Posisikan awal sudut kiri atas
147 glutCreateWindow ("Animasi melalui Fungsi Diam"); // Buat jendela dengan
judul yang diberikan
glutDisplayFunc (tampilan); // Daftarkan callback handler untuk
melukis ulang acara
glutReshapeFunc (membentuk kembali) jendela ; // Daftarkan callback
handler untuk acara kembali ukuran jendela
glutIdleFunc (idle);
initGL (); // Inisialisasi OpenGL kami sendiri
glutMainLoop (); // Masukkan
kembali loop pemrosesan-peristiwa tak terhingga 0;
}