LAPORAN PRAKTIKUM 8

Interaksi Dengan Perangkat

Dosen pengampuh : Alifya NFH, S.Pd., M.Pd

Muhammad Alam Nur Haris

1829041060

PTIK-F 2018

PRODI PENDIDIKAN TEKNIK INFORMATIKA DAN KOMPUTER

JURUSAN PENDIDIKAN TEKNIK ELEKTRO

FAKULTAS TEKNIK

UNIVERSITAS NEGERI MAKASSAR

2020
A. Tujuan Praktikum
1) Mahasiswa mampu membuat fungsi interaksi perangkat dengan keyboard (GENERAL
BUTTON)
2) Mahasiswa mampu membuat fungsi interaksi perangkat dengan keyboard (SPECIAL
KEY)
3) Mahasiswa mampu membuat fungsi interaksi perangkat dengan mouse
B. Dasar Teori
1. Konsep input keyboard (GENERAL BUTTON)
glutKeyboardFunc adalah suatu fungsi callback untuk digunakan sebagai masukan
pada suatu jendela window. Konsepnya pada saat seorang user atau pengguna
memberikan input yaitu menekan pada tombol keyboard, setiap tombol keyboard yang
ditekan akan menghasilkan suatu karakter ASCII yang akan menghasilkan suatu
callback keyboard yang telah didefinisikan berupa fungsi dengan 3 parameter.
Penggunaan input keyboard pada tombol-tombol biasa atau normal key (a-z, 1-0), dapat
dilakukan dengan menggunakan callback function berupa
glutKeyboardFunc(myKeyboard) dengan dideklarasikan terlebih dahulu suatu fungsi
buatan untuk menampung semua perintah input yang akan digunakan oleh user. Fungsi
buatan tersebut seperti contoh dibawah ini:
void myKeyboard(unsigned char key, int x, int y)
{
//masukan perintah disini
}
Fungsi tersebut berisi suatu perintah yang akan digunakan dalam pengoperasian
program oleh user. Di dalam fungsi tersebut terdapat 3 parameter dan di dalamnya
dideklarasikan suatu perintah yang nantinya akan digunakan.
void timer(int value) {
glutPostRedisplay();
glutTimerFunc(100,timer, 0);
}
void myKeyboard( unsigned char key, int x, int y)
{
 If (key == ‘a’) glTranslatef (0, 5, 0); if (key == ‘d’) glTranslatef (0, -5, 0);
}
void renderScene(void){
glClear(GL_COLOR_BUFFER_BIT);
glColor3f (1.,0.,0.);
Draw();
glFlush();
}
Sintaks tersebuat adalah sintaks dasar yang digunakan , untuk bisa menggunakan input
keyboard maka harus diberikan callback function untuk memanggilnya.
glutDisplayFunc(renderScene);
glutKeyboardFunc(myKayboard);
glutTimerFunc(30, timer, 0);
Sintaks tersebut harus disertakan pada fungsi main. Selain itu, pada keyboard juga
terdapat method lain yang bisa digunakan dalam proses input ini, yaitu: Key Press, Key
Up, dan Key Buffering.
Key Press
Metode ini akan memberitahukan kita pada command line tombola apa yang sedang kita
tekan. Method ini dapat dinamakan keyPressed dan pada GLUT akan terdapat 3
parameter, satu untuk tombol yang saat itu ditekan, dan dua untuk memberitahukan
lokasi mouse ketika tombol ditekan.
void kayPressed(unsigned char key, int x, int y) {
if (key == ‘a’){
// saat tombol ‘a’ ditekan
// aksi yang diberikan saat tombol ‘a’ ditekan
}
}
Dan fungsi tersebut akan dipanggil pada fungsi main, namun callback functionnya
sedikit berbeda dari callback function yang sebelumnya.
glutKeyboardFunc (kayPressed); // memberitahukan pada GLUT unntuk
menggunakan method “keyPressed” untuk tombol yang ditekan.
 Key Up
Fungsi Key Up ini adalah fungsi register yang menyimpan nilai masukan sampai ketika
tombol keyboard dilepaskan. Hal ini bisa berguna untuk pengaturan beberapa nilai
ketika suatu tombol pertama kali ditekan, dan tetap menjaga nilai tersebut sampai
tombol tersebut dilapaskan. Method sama seperti method Key Press tadi yaitu memiliki
3 parameter yang memiliki fungsi yang sama, hanya berbeda pada penamaannya yaitu,
keyUp.
Kemudian dilanjutkan dengan pendeklarasian masing-masing method.
void keyPressed (unsigned char key, int x, int y) {
keyStates[key] = true;
}
void keyUp (unsigned char key, int x, int y) {
keyStates[key] = false;
}
void keyOperations (void) { if (keyStates[‘a’]){
// saat tombol ‘a’ ditekan
// aksi yang diberikan saat tombol ‘a’ ditekan
}
}
Sama seperti sebelumnya funngsi-fungsi tersebut akan dipanggil pada fungsi main
dengan callback function berikut:
void display (void) { keyOperations();
glColor (1.0f, 0.0f, 0.0f, 1.0f);
// menjadikan background menjadi warna merah
..
}

2. Konsep input keyboard SPECIAL KEY

GlutSpecialFunc merupakan suatu fungsi callback pada opengl yang digunakan untuk
mengaktifkan tombol-tombol khusus pada keyboard sehingga dapat digunakan untuk
berinteraksi antara user dengan objek yang ada di dalam display opengl.
Pendeklarasiannya adalah:
void glutSpecial Func (void (* funnc) (int key, int x, int y));
callback keyboard khusus dipicu ketika keyboard fungsi atau tombol special yang
dideklarasikan ditekan. Parameter callback kunci adalah GLUT_KEY_tombol khusus.
Parameter x dan y mengindikasikan koordinat relatif jendela ketika tombol ditekan.
Ketika jendela baru dibuat, tidak ada callback khusus awalnya terdaftar dan stroke kunci
khusus di jendela diabaikan. Melewati NULL untuk glutSpecialFunc menonaktifkan
generasi callback khusus. Selama callback khusus, glutGetModifiers dapat dipanggil
untuk menentukan keadaan tombol pengubah ketika keystroke menghasilkan callback
terjadi. Nilai-nilai yang tersedia GLUT_KEY_*adalah:
GLUT_KEY_F1 F1 function key
GLUT_KEY_F2 F2 function key
GLUT_KEY_F3 F3 function key
GLUT_KEY_F4 F4 function key
GLUT_KEY_F5 F5 function key
GLUT_KEY_F6 F6 function key
GLUT_KEY_F7 F7 function key
GLUT_KEY_F8 F8 function key
GLUT_KEY_F9 F9 function key
GLUT_KEY_F10 F10 function key
GLUT_KEY_F11 F11 function key
GLUT_KEY_F12 F12 function key
GLUT_KEY_LEFT Left function key
GLUT_KEY_RIGHT Right function key
GLUT_KEY_UP Up function key
GLUT_KEY_DOWN Down function key
GLUT_KEY_PAGE_UP Page Up function key
 GLUT_KEY_PAGE_DOWN Page Down function key
GLUT_KEY_HOME Home function key

3. Sistim koordinat interaksi mouse pada glut

Sistem koordinat interaksi mouse pada glut adalah sebagai berikut. Misalnya ditentukan
inisialisasi awal adalah:
Int w = 480, h=480;
float x=0, y=0, z=0; maka:
a. Titik 0,0 berada pada pojok kiri atas, koordinatnya akan berubah apabila terjadi
pergeseran mouse.
b. Titik 480,0 berada pada pojok kanan atas.
c. Titik 0, 480 berada pada pojok kiri bawah.
d. Titik 480, 480 berada pada pojok kanan bawah.
C. Praktikum
Praktikum 8A
a. Program

#include <stdlib.h>
#include <GL/glut.h>
int c, d;

void triAngles () {
glBegin (GL_TRIANGLES);
glVertex2i(280, 0);
glVertex2i(250, 60);
glVertex2i(220, 0);
glEnd();
}

void mySpecialKeyboard(int key, int x, int y){

switch (key) {
 case GLUT_KEY_LEFT:
c+=-4;
d+=0;
break;
case GLUT_KEY_RIGHT:
c+=4;
d+=0;
break;
case GLUT_KEY_UP:
c+=0;
d+=4;
break;
case GLUT_KEY_DOWN:
c+=0;
d+=-4;
break;
}
}

void timer (int value){

glutPostRedisplay();
glutTimerFunc(50, timer, 0);
}

void renderScene(void){
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glTranslatef(c, d, 0);
triAngles();
glPopMatrix();
glFlush();
 }

int main (int argc, char **argv) {

glutInit(&argc, argv);
glutInitWindowPosition(100, 100);
glutInitWindowSize(640, 480);
glutCreateWindow("Uji KeyFunc");
gluOrtho2D(-320., 320., -240., 240.);
glutTimerFunc(50, timer, 0);
glutDisplayFunc(renderScene);
glutSpecialFunc(mySpecialKeyboard);
glutMainLoop();
}

b. Penjelasan sintaks
• #include <GL/glut.h> berfungsi untuk memanggil library grafik dari OpenGL.
• #include <stdlib.h> berfungsi untuk memanggil library transformasi objek dari
OpenGL
• int c,d; berfungsi untuk mendeklarasikan c dan d sebagai variable
• void triAngles () {}, berfungsi sebagai fungsi untuk menggambar objek segitiga
• glBegin(GL_TRIANGLE);berfungsi untuk memulai menggambar objek segitiga
• glVertex2i (x,y) berfungsi untuk menentukan koordinat suatu titik pada objek yang
akan dibuat
• glEnd() berfungsi untuk mengakhiri manggambar objek
• void mySpecialKeyboard(int key, int x, int y){} berfungsi sebagai fungsi untuk
mengontrol gerak objek menggunakan tombol keyboard serta mendeklarasikan key,
x, dan y sebagai variabel
• switch (key) {} perintah untuk memberikan opsi tombola apa yang akan digunakan
untuk menggerakkan objek.
• case GLUT_KEY_LEFT: berfungsi untuk menggerakan objek ke kiri
• case GLUT_KEY_RIGHT: berfungsi untuk menggerakan objek ke kanan
• case GLUT_KEY_UP: berfungsi untuk menggerakan objek ke atas
• case GLUT_KEY_DOWN: berfungsi untuk menggerakan objek ke bawah
• void timer (int value){} berfunsi sebagai fungsi timer
• glutPostRedisplay(); berfungsi untuk mengirimakan perintah untuk mengaktifkan
display secara berkala (looping) atau mengulang-ngulang tampilan,
• glutTimerFunc(50,timer,0); berfungsi untuk membuat sebuah animasi yang dikontrol
oleh waktu.
• void renderScene() {} berfungsi sabagai fungsi untuk membuat objek bergerak
• glTranslatef(c,d,0); berfungsi sebagai perintah transisi objek
• glFlush(); berfungsi untuk memastikan gambar bias dieksekusi
• int main(int argc, char** argv) {} Menampilkan banyaknya parameter yang
ditampung di dalam variabel argc.
• glutInit(&argc,argv); berfungsi mengatur pembuatan window.
• glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB); berfungsi meminta window
yang bersifat double buffered dengan warna RGB.
• glutInitWindowPosition(0,0); berfungsi fungsi ini menentukan letak window dengan
patokannya ialah pada indo kiri atas dengan posisi x = 0 dan y = 0.
• glutInitWindowSize(640,480); fungsi ini menspesifikasikan ukuran window yang
dibuat dalam pixel dengan panjang horizontal 640 dan vertical 480.
• glutCreateWindow ("Uji KeyFunc "); berfungsi untuk membuat window dalam
konteks openGL dan akan menghasilkan identitas atau judul window tersebut yaitu
Uji KeyFunc.
• gluOrtho2D (-320.,320., -320., 320.);berfungsi untuk mengatur proyeksi hasil
eksekusi dan mendefinisi besarnya sistem koordinat dengan urutan kiri kanan dan
atas bawah.
• glutTimerFunc(50, timer, 0); berfungsi agar fungsi timer dapat berfungsi
• glutDisplayFunc (renderScene); untuk menampilakan hasil dari fungsi renderScene
• glutSpecialFunc(mySpecialKeyboard); berfungsi agar fungsi perintah tombol
keyboard berfungsi
• glutMainLoop(); berfungsi sebagai looping sampai window ditutup oleh user.
c. Hasil

Praktikum 8B
a) Program

#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>

float x = 1, y = 1, z = 0;
int w = 480, h = 480, flag = 0, flg;
void drawQuad() {
glBegin(GL_POLYGON);
glColor3f(0, 0, 1);
glVertex2f(-20., -20.);
glVertex2f(20., -20.);
glVertex2f(20., 20.);
glVertex2f(-20., 20.);
glEnd();
}

void mouse(int button, int state, int xmouse, int ymouse){if (flg == 0)
{
if (state == GLUT_DOWN)
{
if (button == GLUT_LEFT_BUTTON)
{
flag++; if (flag == 2)
{
flg = 3; x = 3; y = 3;
printf("%d", flg);
}
}
}
}
if (flg == 3)
{
if (state == GLUT_DOWN)
{
if (button == GLUT_LEFT_BUTTON)
{
 flag--; if (flag == 0)
{
x = 1; y = 1; flg =0;
}
}

}
}
}

void renderScene(void){
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(1, 1, 1, 1);
glPushMatrix();
glScalef(x, y, z);
drawQuad();
glPopMatrix();
glFlush();
}

void timer(int value){

glutPostRedisplay();
glutTimerFunc(50, timer, 0);
}

int main(int argc, char **argv){

glutInit(&argc, argv);
glutInitWindowPosition(100, 100);
glutInitWindowSize(w, h);
glutCreateWindow("Interaksi Mouse");
gluOrtho2D(-w / 2, w / 2, -h / 2, h / 2);
 glutDisplayFunc(renderScene);
glutMouseFunc(mouse);
glutTimerFunc(1, timer, 0);
glutMainLoop();
}

b) Penjelasan sintaks
• #include <GL/glut.h> berfungsi untuk memanggil library grafik dari OpenGL.
• #include <stdlib.h> berfungsi untuk memanggil library transformasi objek dari
OpenGL
• float x = 1, y = 1, z = 0; berfungsi untuk mendeklarasikan x, y, dan z sebagai variabel
bilangan desimal, dengan nilai x = 1, y = 1, dan z = 0
• int w = 480, h = 480, flag = 0, flg;, berfungsi untuk mendeklarasikan w, h sebagai
variabel dengan w = 480 dan h = 480
• void drawQuad() {} berfungsi sebagai fungsi untuk menggambar objek
• glBegin (GL_POLYGON); berfungsi untuk memulai menggambar objek
• glVertex2f (x,y) berfungsi untuk menentukan koordinat suatu titik pada objek yang
akan dibuat
• glEnd() berfungsi untuk mengakhiri manggambar objek
• void mouse(int button, int state, int xmouse, int ymouse){if (flg == 0){}} sebagai
fungsi yang mengandung suatu kondisi agar objek bergerak saat mouse diklik
• void renderScene() {} berfungsi sabagai fungsi untuk membuat objek bergerak
• glScalef(x, y, z); berfungsi sebagai perintah transisi skala objek
• glFlush(); berfungsi untuk memastikan gambar bias dieksekusi
• void timer (int value){} berfunsi sebagai fungsi timer
• glutPostRedisplay(); berfungsi untuk mengirimakan perintah untuk mengaktifkan
display secara berkala (looping) atau mengulang-ngulang tampilan,
• glutTimerFunc(10,timer,0); berfungsi untuk membuat sebuah animasi yang
dikontrol oleh waktu.
 • int main(int argc, char** argv) {} Menampilkan banyaknya parameter yang
ditampung di dalam variabel argc.
• glutInit(&argc,argv); berfungsi mengatur pembuatan window.
• glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB); berfungsi meminta
window yang bersifat double buffered dengan warna RGB.
• glutInitWindowPosition(100,100); berfungsi fungsi ini menentukan letak window
dengan patokannya ialah pada indo kiri atas dengan posisi x = 100 dan y = 100.
• glutInitWindowSize(w,h); fungsi ini menspesifikasikan ukuran window yang
dibuat dalam pixel dengan panjang horizontal sama dengan nilai dari w dan vertical
sama dengan nilai dari h.
• glutCreateWindow ("Interaksi Mouse "); berfungsi untuk membuat window dalam
konteks openGL dan akan menghasilkan identitas atau judul window tersebut yaitu
Interaksi Mouse.
• gluOrtho2D (-w / 2, w / 2, -h / 2, h / 2); berfungsi untuk mengatur proyeksi hasil
eksekusi dan mendefinisi besarnya sistem koordinat dengan urutan kiri kanan dan
atas bawah.
• glutDisplayFunc (renderScene); untuk menampilakan hasil dari fungsi renderScene
• glutTimerFunc(1, timer, 0); berfungsi agar fungsi timer dapat berfungsi
• glutMainLoop(); berfungsi sebagai looping sampai window ditutup oleh user.
c) Hasil
D. Latihan
a. Program

#include <GL/glut.h>
#include <math.h>
#include <stdlib.h>
int c, d;
const double PI = 3.141592653589793;
int i;

void lingkaran (int jari2, int jumlah_titik, int x_tengah, int y_tengah){
glBegin (GL_POLYGON);
for (i=0; i<=360;i++){
float sudut = i * (2*PI/jumlah_titik);
float x=x_tengah+jari2*cos(sudut);
float y=y_tengah+jari2*sin(sudut);
glVertex2f(x,y);
}
glEnd();
}

void minion(){
glColor3f(1.0,1.0,0.0);//kepala
lingkaran(20,80,0,75);
glColor3f (1.0,1.0,0.0);
glBegin (GL_POLYGON);
glVertex2i (-10, 90); //badan
glVertex2i (10, 90);
glVertex2i (20, 80);
glVertex2i (20, 20);
glVertex2i (10, 10);
glVertex2i (-10, 10);
glVertex2i (-20, 20);
glVertex2i (-20, 80);
glEnd();

glColor3f (1.0,1.0,0.0);
glBegin (GL_POLYGON);
glVertex2i (-20, 30); //tangan kiri
glVertex2i (-20, 50);
glVertex2i (-25, 40);
glVertex2i (-25, 30);
glEnd();

glColor3f (1.0,1.0,0.0);
glBegin (GL_POLYGON);
glVertex2i (20, 30); //tangan kanan
glVertex2i (20, 50);
glVertex2i (25, 40);
glVertex2i (25, 30);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (-9, 10); //kaki celana kiri
glVertex2i (-1, 10);
glVertex2i (-1, 5);
glVertex2i (-9, 5);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (9, 10); //kaki celana kanan
glVertex2i (1, 10);
glVertex2i (1, 5);
glVertex2i (9, 5);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_POLYGON);
glVertex2i (-1, 5); //sepatu kiri
glVertex2i (-9, 5);
glVertex2i (-15, 0);
glVertex2i (-1, 0);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_POLYGON);
glVertex2i (1, 5); //sepatu kanan
glVertex2i (9, 5);
glVertex2i (15, 0);
glVertex2i (1, 0);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_POLYGON);
glVertex2i (-20, 80); //gagang kaca mata
glVertex2i (20, 80);
glVertex2i (20, 70);
glVertex2i (-20, 70);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (20, 55); //bju
glVertex2i (20, 50);
glVertex2i (15, 45);
glVertex2i (10, 45);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (-20, 55);
glVertex2i (-20, 50);
glVertex2i (-15, 45);
glVertex2i (-10, 45);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (-15, 45);
glVertex2i (15, 45);
glVertex2i (15, 30);
glVertex2i (-15, 30);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (15, 30);
glVertex2i (-15, 30);
glVertex2i (-20, 25);
glVertex2i (-20, 20);
glVertex2i (-10, 10);
glVertex2i (10, 10);
glVertex2i (20, 20);
glVertex2i (20, 25);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (-20, 30);
glVertex2i (-10, 30);
glVertex2i (-20, 25);
glEnd();

glColor3f (0.0,0.0,1.0);
glBegin (GL_POLYGON);
glVertex2i (20, 30);
glVertex2i (10, 30);
glVertex2i (20, 25);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (-15, 30);
glVertex2i (-20, 25);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (15, 30);
glVertex2i (20, 25);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (-20, 30);
glVertex2i (-20, 40);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (20, 30);
glVertex2i (20, 40);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (-15, 45);
glVertex2i (15, 45);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (15, 45);
glVertex2i (15, 30);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (-15, 45);
glVertex2i (-15, 30);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (-5, 40);
glVertex2i (5, 40);

glVertex2i (5, 35);

glVertex2i (3, 32);

glVertex2i (-5, 35);

glVertex2i (-3, 32);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (-5, 40);
glVertex2i (-5, 35);

glVertex2i (5, 35);

glVertex2i (5, 40);

glVertex2i (-3, 32);

glVertex2i (3, 32);
glEnd();

glColor3f (0.0,0.0,0.0); // mulut

glBegin (GL_LINES);
glVertex2i (-10, 60);
glVertex2i (-5, 55);
glVertex2i (5, 55);
glVertex2i (10, 60);
glEnd();

glColor3f (0.0,0.0,0.0);
glBegin (GL_LINES);
glVertex2i (-5, 55);
glVertex2i (5, 55);
glEnd();

glColor3f(0.75,0.75,0.75);//kaca mata
lingkaran(10,80,0,75);

glColor3f(1.0,1.0,1.0);//mata
lingkaran(7,80,0,75);

glColor3f(0.0,0.0,0.0);//tengah mata
lingkaran(3,80,0,75);

glColor3f(0.0,0.0,0.0);//telapak tangan kanan

lingkaran(3,80,23,28);

glColor3f(0.0,0.0,0.0);//telapak tangan kiri

lingkaran(3,80,-23,28);
glFlush();
}

void myKeyboard(unsigned char key, int x, int y){

if (key == 'a'){
c+=-4;
d+=0;
}
else if(key == 'd')
{
c+=4;
d+=0;
}
else if (key == 'w')
{
c+=0;
d+=4;
}
else if (key == 's')
{
c+=0;
d+=-4;
}
}

void timer (int value){

glutPostRedisplay();
glutTimerFunc(50, timer, 0);
}
 void renderScene (void){
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glTranslatef(c, d, 0);
minion();
glPopMatrix();
glFlush();
}

int main(int argc, char** argv) {

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DEPTH | GLUT_SINGLE| GLUT_RGBA);
glutInitWindowSize(640,480);
glutInitWindowPosition(100,100);
glutCreateWindow("latihan prak 8");
glClearColor (1.0,1.0,1.0,1.0);
gluOrtho2D (-100.,100.,-10.,100.);
glutTimerFunc(50, timer, 0);
glutDisplayFunc (renderScene);
glutKeyboardFunc (myKeyboard);
glutMainLoop();
}

b. Penjelasan persintaks
• #include <GL/glut.h> berfungsi untuk memanggil library grafik dari OpenGL.
• #include <stdlib.h> berfungsi untuk memanggil library transformasi objek dari
OpenGL
• #include <math.h>berfungsi untuk memanggil library matematika pada OpenGL
• int i; berfungsi untuk mendeklarasikan r sebagai variable
• const double PI = 3.141592653589793; berfungsi untuk mendeklarasikan PI sebagai
variable bilangan desimal dengan nilai 3.141592653589793
• void lingkaran (int jari2, int jumlah_titik, int x_tengah, int y_tengah){} berfungsi
sebagai fungsi untuk menggambar lingkaran dan mendeklarasikan variable yang
akan digunakan untuk menggambar lingkaran.
• glBegin(GL_POLYGON);berfungsi untuk memulai menggambar objek
• glColor3f (1,1,1); berfungsi memberi warna pada objek dengan warna putih
• for (i=0;i<=360;i++){float sudut=i*(2*PI/jumlah_tit ik);
x=x_tengah+jari2*cos(sudut); float y=y_tengah+jari2*sin(sudut); glVertex2f(x,y); }
berfungsi untuk menggambar lingkaran
• void minion(){} berfungsi sebagai fungsi untuk menggambar objek minion
• glBegin (GL_POLYGON); berfungsi untuk memulai menggambar objek
• glVertex2i (x,y) berfungsi untuk menentukan koordinat suatu titik pada objek yang
akan dibuat
• glBegin (GL_LINES); berfungsi untuk memulai menggambar garis
• glEnd() berfungsi untuk mengakhiri manggambar objek
• glFlush(); berfungsi untuk memastikan gambar bias dieksekusi
• void myKeyboard(unsigned char key, int x, int y){} berfungsi sebagai fungsi untuk
mengontrol gerak objek menggunakan tombol keyboard serta mendeklarasikan key,
x, dan y sebagai variabel
• if (key == 'a'){} berfungsi untuk menggerakan objek ke kiri
• if (key == 'd'){} berfungsi untuk menggerakan objek ke kanan
• if (key == 'w'){} berfungsi untuk menggerakan objek ke atas
• if (key == 's'){} berfungsi untuk menggerakan objek ke bawah
• void timer (int value){} berfunsi sebagai fungsi timer
• glutPostRedisplay(); berfungsi untuk mengirimakan perintah untuk mengaktifkan
display secara berkala (looping) atau mengulang-ngulang tampilan,
• glutTimerFunc(10,timer,0); berfungsi untuk membuat sebuah animasi yang dikontrol
oleh waktu.
• void renderScene() {} berfungsi sabagai fungsi untuk membuat objek bergerak
• glTranslatef(c,d,0); berfungsi sebagai perintah transisi objek
 • int main(int argc, char** argv) {} Menampilkan banyaknya parameter yang
ditampung di dalam variabel argc.
• glutInit(&argc,argv); berfungsi mengatur pembuatan window.
• glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB); berfungsi meminta window
yang bersifat double buffered dengan warna RGB.
• glutInitWindowPosition(100,100); berfungsi fungsi ini menentukan letak window
dengan patokannya ialah pada indo kiri atas dengan posisi x = 100 dan y = 100.
• glutInitWindowSize(640,640); fungsi ini menspesifikasikan ukuran window yang
dibuat dalam pixel dengan panjang horizontal 640 dan vertical 640.
• glutCreateWindow ("latihan prak 8 "); berfungsi untuk membuat window dalam
konteks openGL dan akan menghasilkan identitas atau judul window tersebut yaitu
latihan prak 8.
• gluOrtho2D (-100.,100.,-10.,100.); berfungsi untuk mengatur proyeksi hasil eksekusi
dan mendefinisi besarnya sistem koordinat dengan urutan kiri kanan dan atas bawah.
• glutTimerFunc(50, timer, 0); berfungsi agar fungsi timer dapat berfungsi
• glutDisplayFunc (renderScene); untuk menampilakan hasil dari fungsi renderScene
• glutKeyboardFunc (myKeyboard); berfungsi agar fungsi perintah tombol keyboard
berfungsi
• glutMainLoop(); berfungsi sebagai looping sampai window ditutup oleh user.
c. hasil
E. Kesimpulan
OpenGL memungkan kita untuk membuat suatu objek 2D yang dapat di gerakkan dengan
menggunakan perintah interaksi dengan perangkat, sehingga objek dapat digerakkan
dengan menekan salah satu tombol pada keyboard yang telah dideklarasikan sebagai
tombol untuk berinteraksi dengan objek. Serta interaksi perangkat juga bukan sebatas pada
tombol pada keyboard melainkan juga dapat menggunkaan mouse atau keypad.
 Daftar Pustaka
Heriadi.2015. Buku Pemrograman Grafik 3D Menggunakan C & OpenGL