LAPORAN PRAKTIKUM

TRANSFORMASI DAN ANIMASI

Disusun untuk Memenuhi Matakuliah Grafika Komputer

Dibimbing oleh Bapak Ahmad Mursyidun Nidhom

Oleh
Azizah Tri Novanti
170533628613
S1 PTI 2017 A

UNIVERSITAS NEGERI MALANG

FAKULTAS TEKNIK
JURUSAN TEKNIK ELEKTRO
PRODI S1 PENDIDIKAN TEKNIK INFORMATIKA
Oktober 2018
 Studi Kasus I
OpenGL

Nama Program : Membuat Animasi Bola Bergerak

Bahasa Pemrograman : C++
Compiler : Microsoft Visual Studio
Script Program :

#include <windows.h>
#include <glut.h>
#include <Math.h>
#define PI 3.14159265f

//1
char title[] = "Bouncing Ball (2D)";
int windowWidth = 640;
int windowHeight = 480;
int windowPosX = 50;
int windowPosY = 50;
//2
GLfloat ballXMax, ballXMin, ballYMax,
ballYMin;
GLfloat xSpeed = 0.02f;
GLfloat ySpeed = 0.007f;
int refreshMillis = 30;

GLfloat ballRadius = 0.5f; GLdouble clipAreaXLeft,

GLfloat ballX = 0.0f; clipAreaXRight, clipAreaYBottom,
GLfloat ballY = 0.0f; clipAreaYTop;

//3
void initGL() {
glClearColor(0.0, 1.0, 0.0,
1.0);
} glEnd();
void display() {
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(ballX, ballY,
0.0f);
glBegin(GL_TRIANGLE_FAN);
glColor4f(0.0f, 1.0f, 1.0f,
1.0f);
glVertex2f(0.0f, 0.0f);
glColor3f(0.0f, 0.5f, 1.0f);
int numSegments = 100;
GLfloat angle;
for (int i = 0; i <=
numSegments; i++) {
angle = i * 2.0f * PI /
numSegments;
//4
glVertex2f(cos(angle) * ballRadius,
sin(angle) * ballRadius);
}
glutSwapBuffers();
ballX += xSpeed;
ballY += ySpeed;
if (ballX > ballXMax) {
ballX = ballXMax;
xSpeed = -xSpeed;
}
else if (ballX < ballXMin) {
ballX = ballXMin;
xSpeed = -xSpeed;
}
if (ballY > ballYMax) {
ballY = ballYMax;
ySpeed = -ySpeed;
}
else if (ballY < ballYMin) {
ballY = ballYMin;
ySpeed = -ySpeed;
}
}

//5 //6
void reshape(GLsizei width, GLsizei else {
height) { clipAreaXLeft = -1.0;
if (height == 0) height = 1; clipAreaXRight = 1.0;
GLfloat aspect = clipAreaYBottom = -1.0 /
(GLfloat)width / (GLfloat)height; aspect;
glViewport(0, 0, width, clipAreaYTop = 1.0 /
height); aspect;
 glMatrixMode(GL_PROJECTION); }
glLoadIdentity(); gluOrtho2D(clipAreaXLeft,
if (width >= height) { clipAreaXRight, clipAreaYBottom,
clipAreaXLeft = -1.0 * clipAreaYTop);
aspect; ballXMin = clipAreaXLeft +
clipAreaXRight = 1.0 * ballRadius;
aspect; ballXMax = clipAreaXRight -
clipAreaYBottom = -1.0; ballRadius;
clipAreaYTop = 1.0; ballYMin = clipAreaYBottom +
} ballRadius;
ballYMax = clipAreaYTop -
ballRadius;
}
void Timer(int value) {
glutPostRedisplay();
glutTimerFunc(refreshMillis, Timer, 0);
}

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

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE);
glutInitWindowSize(windowWidth, windowHeight);
glutInitWindowPosition(windowPosX, windowPosY);
glutCreateWindow(title);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutTimerFunc(0, Timer, 0);
initGL();
glutMainLoop();
return 0;
}

Output Program :
Penjelasan :
Program diatas menampilkan animasi bola yang dapat bergerak dan kembali
lagi seperti memantul ketika berada pada koordinat makksimal dan minimal pada
windows. Untuk membuat bola dua dimensi, perlu adanya script untuk menggambar
objek lingkaran dengan menggunakan rumus matematika. glMatrixMode(GL_MODELVIEW);
berfungsi untuk menentukan matrik yang akan ditampilkan saat ini kemudian
dilanjutkan dengan model view selanjutnya. glLoadIdentity(); digunakan untuk
menghentikan transformasi sebelumnya, sehingga keadaan selanjutnya dapat berjalan.
glTranslatef(ballX, ballY, 0.0f); digunakan untuk memindahkan bola sejauh
koordinat x dan y. Untuk membuat objek lingkaran, program diatas menggunakan
GL_TRIANGLE_FAN dimana untuk membentuk lingkaran dibuat terlebih dahulu
segmentnya dengan menggunakan perulangan, agar titik koordinat awal dan akhir
segment sama. Kemudian untuk membentuk garis lingkarannya menggunakan
perhitungan trigonometri sudut yang dikalikan dengan radius yang ditentukan. Agar
bola dapat bergerak, maka perlu adanya perpindahan bola sesuai dengan kecepatan bola
yang sudah dideklarasi. Pada program, bola tidak akan bergerak diluar batas windows,
maka terdapat pernyataan jika koordinat bola melebihi batas maksimal maka
perpindahannya akan dikurangi, sehingga bola akan bergeser kearah berlawanan.
Begitupun jika koordinat bola berada melebihi dari batas minimum, maka bola akan
bergerak berlawanan arah sehingga bola seperti memantul. Proram diatas juga membuat
apabila user mengganti ukuran window maka bola akan mengikuti perubahan ukuran
window tersebut secara otomatis. Terdapat void reshape(GLsizei width, GLsizei
height) yang digunakan untuk mengubah batas maksimal dan minimal window sesuai
dengan ukuran. Agar bola dapat bergerak dengan dikendalikan oleh waktu maka perlu
adanya void Timer(int value) yang digunakan untuk mengendalikan objek sesuai
waktu yang ditentukan.

Studi Kasus II
OpenGL

Nama Program : Membuat Objek translatef.rotatef dan rotatef.translatef

Bahasa Pemrograman : C++
Compiler : Microsoft Visual Studio
Script Program :
#include <windows.h>
#include <glut.h>

GLfloat angle = 0.0f;

void initGL() {
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
}
void idle() {
glutPostRedisplay();
}
//1
void display() {
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//translate.rotate
glPushMatrix();
glTranslatef(-0.5f, 0.4f, 0.0f);
glRotatef(angle, 0.0f, 0.0f,
1.0f);
glBegin(GL_QUADS);
glColor3f(1.0f, 0.0f, 0.0f); //
Red
glVertex2f(-0.3f, -0.3f);
glVertex2f(0.3f, -0.3f);
glVertex2f(0.3f, 0.3f);
glVertex2f(-0.3f, 0.3f);
glEnd();
//2
glBegin(GL_QUADS);
glColor3f(0.0f, 1.0f, 0.0f); //
Green
glVertex2f(-0.3f, -0.3f);
glVertex2f(0.3f, -0.3f);
glVertex2f(0.3f, 0.3f);
glVertex2f(-0.3f, 0.3f);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(-0.7f, -0.5f,
0.0f);
glRotatef(angle, 0.0f, 0.0f,
1.0f);

//rotate.translate glutSwapBuffers();
glPopMatrix(); angle += 0.2f;
glPushMatrix(); }
glRotatef(angle, 0.0f, 0.0f,
1.0f);
glTranslatef(-0.4f, -0.3f, 0.0f)

void reshape(GLsizei width, GLsizei height) {

if (height == 0) height = 1;
GLfloat aspect = (GLfloat)width / (GLfloat)height;
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (width >= height) {
gluOrtho2D(-1.0 * aspect, 1.0 * aspect, -1.0, 1.0);
}else {
gluOrtho2D(-1.0, 1.0, -1.0 / aspect, 1.0 / aspect);
}}
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE);
glutInitWindowSize(640, 480);
glutInitWindowPosition(50, 50);
glutCreateWindow("Animation via Idle Function");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
initGL();
glutMainLoop();
return 0;}

Output Program :
Penjelasan :

Program diatas menampilkan perbedaan antara translate.rotatef dengan

rotate.translatef. dimana terdapat dua buah segi empat yang berwarna merah
menggunakan translate.rotatef dan yang berwarna hijau menampilkan rotate.translate.
perbedaannya tidak terlalu jauh, hanya urutan programnya yang membuat outputnya
juga sedikit berbeda. Pada segiempat warna merah, yang dijalankan terlebih dahulu
adalah translatefnya, berarti segiempat merah tersebut berpindah terlebih dahulu sejauh
koordinat x dan y yang telah ditentukan, setelah itu berputar sesuai sudut dan koorinat
yang ditentukan. Hasilnya, segiempat merah akan berpindah terlebih dahulu kemudian
berputar pada rotasi perpindahannya, sehingga segiempat merah akan berrputar pada
tempatnya dimana tempat segiempat merah tersebut berpindah. Berbeda dengan
segiempat hijau, yang medahulukan rotate daripada translate. Segiempat hijau akan
berputar terlebih dahulu sambal berpindah sesuai koordinat. Sehingga segiempat akan
berputar seperti mengelilingi perputaran tersebut.

Studi Kasus III

OpenGL

Nama Program : Membuat Baling-Baling clockwise dan unsclocwise

Bahasa Pemrograman : C++
Compiler : Microsoft Visual Studio
Script Program :

#include <stdlib.h>
#include <glut.h>

int x = 0;
int y = 360;
int z = 0;
//1 //2
void timer(int value) { void Triangles() {
if(z <= 360){ glBegin(GL_TRIANGLES);
x = 1; glColor3f(1.0f, 0.0f,
z += 1; 1.0f);//Purple
} glVertex2f(0., 0.);
if (z > 360) { glVertex2f(10., 30.);
x = -1; glVertex2f(-10., 30.);
y -= 1; glColor3f(0.5f, 1.0f, 1.0f);//cyan
} glVertex2f(0., 0.);
if (y < 0) { glVertex2f(-10., -30.);
x = 1; glVertex2f(10., -30.);
z = 0; glEnd();
y = 360; }
}
glutPostRedisplay();
glutTimerFunc(10, timer, 0);
}
void display(void) {
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(1.0f, 0.5f, 0.0f, 0.0f);
glPopMatrix();
glRotatef(x, 0, 0, 1);//sudut
Triangles();
glPushMatrix();
glFlush();
}
void main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitWindowPosition(100, 100);
glutInitWindowSize(400, 400);
glutCreateWindow("Baling-Baling");
gluOrtho2D(-50., 50., -50., 50.);
glutDisplayFunc(display);
glutTimerFunc(10, timer, 0);
glutMainLoop();
}

Output Program :
Penjelasan :
Program diatas menampilkan baling-baling yang dapat berputar secara
clockwise dan unclockwise dan dipengaruhi oleh waktu. Agar baling baling dapat
berputar secara clockwise dan unclockwise, maka pada void timer(int value) diberi
pernyataan agar baling baling dapat berputar. Misalkan terdapat variable x,y,z dimana x
digunakan untuk mendeklarasi sudut pada glRotatef dan y digunakan untuk
mendeklarasi perputaran maksimal. Apabila deklarasi pertama z adalah 0, maka
pernyataan if(z <= 360) dijalankan, sehingga variable x kan menyimpan satu sebagai
sudut perputaran objek, dan variable z akan bertambah 1, begitu seterusnya sampai nilai
variable z lebih dari 360. Apabila z lebih dari 360, maka if (z > 360) akan
dijalankan, sehingga nilai variable x berubah menjadi – 1 agar objek berputar secara
unclockwise dan y akan dikurangi 1. Akibatnya sudut akan berkurang sehingga
perputarannya berlawanan arah jarum jam. Nilai y yang awalnya 360 akan terus
berkurang sampai kurang dari 0. Apabila y kurang dari 0 maka if (y < 0) akan
dijalankan. Sehingga seluruh nilai variable akan kembali seperti awal. Ketika nilai
variabelnya kembali seperti awal, maka pernyataan pertama akan dijalankan kembali.
Sehingga baling baling dapat berputar secara clockwise dan unclockwise terus menerus.
Agar objek dapat berputar secara teratur perlu adanya glPopMatrix(); yang digunakan
untuk memunculkan objek saat ini yaitu objek baling baling dan glRotatef. Sedangkan
glPushMatrix(); digunakan untuk menghentikan objek yang sudah dimunculkan
sehingga transformasi selanjutkan dapat dijalankan.

Studi Kasus IV
OpenGL

Nama Program : Membuat Objek bergerak secara Horizontal

Bahasa Pemrograman : C++
Compiler : Microsoft Visual Studio
Script Program :
#include <stdlib.h>
#include <glut.h>

//1 //2
void Draw() { int y = 0;
glBegin(GL_QUADS); void renderScene() {
glColor3f(0.0f, 1.0f, 0.4f); glClear(GL_COLOR_BUFFER_BIT);
glVertex2i(-8., 2); glClearColor(0.0 , 0.0 ,
glVertex2i(-10., -2); 0.1,0.0);//Navy
glVertex2i(0., -2); if (y<15) {
glVertex2i(2., 2); y += 5;
glEnd(); }else {
} y = -15;
}
glTranslatef(y, 0, 0);
Draw();
glFlush();
}
 void timer(int value) {
glutPostRedisplay();
glutTimerFunc(150, timer, 0);
}
void main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_SINGLE | GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(480, 480);
glutCreateWindow("Gerak Horizontal");
gluOrtho2D(-10.,33., -20., 20.);
glutDisplayFunc(renderScene);
glutTimerFunc(150, timer, 0);
glutMainLoop();
}

Output Program :

Penjelasan :

Program diatas menampilkan objek yang dapat bergerak secara horizontal. Agar
dapat bergerak secara horizontal, maka pada void renderScene() terdapat pernyataan
jika variable y kurang dari 15 maka variable tersebut akan bertambah sejauh 5, jika
nilai variable tersebut sudah melebihi 15 maka nilai y akan dikurangi sejauh 15
sehingga objek akan kembali ke koordinat awal. Objek akan berpindah secara
horizontal karena terdapat glTranslatef(y, 0, 0); dimana nilai variable y diletakkan
pada perpindahan koordinat x yang berada pada parameter pertama.
glutPostRedisplay(); digunakan agar objek dapat bergerak dengan waktu yang
ditentukan secara berulang ulang seperti looping. Objek tersebut bergerak dengan
waktu 150 milisecond atau 0.15 second, sehigga hasilnya objek akan bergerak secara
cepat.
 Studi Kasus V
OpenGL

Nama Program : Membuat Jam Analog

Bahasa Pemrograman : C++
Compiler : Microsoft Visual Studio
Script Program :

#include<glut.h>
#include<math.h>
#define PI 3.14159265f

float sudut = 0;
int i, n;

void lingkaran(int radius, 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 + radius*cos(sudut);
float y = y_tengah + radius*sin(sudut);
glVertex2f(x,y);
}
glEnd();
}

//1
void angka() {
//tiga
glBegin(GL_POLYGON);
glColor3f(0.7,0.7,0.7);
glVertex2f(200,50);//a
glVertex2f(180, 50);//b
glVertex2f(180, -50);//c
glVertex2f(200, -50);//d
glEnd();
glBegin(GL_POLYGON);
glVertex2f(150, 50);//e
glVertex2f(150, 30);//f
glVertex2f(200, 30);//g
glVertex2f(200, 50);//a
glEnd();
glBegin(GL_POLYGON);
glVertex2f(200, 10);//h
glVertex2f(150, 10);//i
glVertex2f(150, -10);//j
glVertex2f(200, -10);//k
glEnd();
glBegin(GL_POLYGON);
glVertex2f(150,-50);//l
glVertex2f(150, -30);//m
glVertex2f(200, -30);//n
glVertex2f(200, -50);//d
glEnd();
//2
//enam
glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7);
glVertex2f(-40, -100);//o
glVertex2f(-40, -200);//p
glVertex2f(-20, -200);//q
glVertex2f(-20, -100);//r
glEnd();
glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7);
glVertex2f(40, -140);//s
glVertex2f(40, -200);//t
glVertex2f(20, -200);//u
glVertex2f(20, -140);//v
glEnd();
glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7);
glVertex2f(40, -100);//w
glVertex2f(40, -120);//z
glVertex2f(-40, -120);//a1
glVertex2f(-40, -100);//o
glEnd();
glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7);
glVertex2f(40, -180);//b1
glVertex2f(-40, -180);//c1
glVertex2f(-40, -200);//p
glVertex2f(40, -200);//t
glEnd();
glBegin(GL_POLYGON);
 glColor3f(0.7, 0.7, 0.7);
glVertex2f(-40, -140);//d1
glVertex2f(-40, -160);//e1
glVertex2f(40, -160);//f1
glVertex2f(40, -140);//s
glEnd();
//3 //4
//sembilan //duabelas
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7); glColor3f(0.7, 0.7, 0.7);
glVertex2f(-150, 50);//g1 glVertex2f(-40, 200);//w1
glVertex2f(-150, -50);//h1 glVertex2f(-40, 100);//z1
glVertex2f(-170, -50);//i1 glVertex2f(-20, 100);//a2
glVertex2f(-170, 50);//j1 glVertex2f(-20, 200);//b2
glEnd(); glEnd();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7); glColor3f(0.7, 0.7, 0.7);
glVertex2f(-200, 50);//k1 glVertex2f(-10, 200);//c2
glVertex2f(-200, 30);//l1 glVertex2f(-10, 180);//d2
glVertex2f(-150, 30);//m1 glVertex2f(40, 180);//e2
glVertex2f(-150, 50);//g1 glVertex2f(40, 200);//f2
glEnd(); glEnd();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7); glColor3f(0.7, 0.7, 0.7);
glVertex2f(-200, -50);//n1 glVertex2f(20, 200);//g2
glVertex2f(-150, -50);//h1 glVertex2f(40, 200);//f2
glVertex2f(-150, -30);//o1 glVertex2f(40, 140);//h2
glVertex2f(-200, -30);//p1 glVertex2f(20, 140);//i2
glEnd(); glEnd();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7); glColor3f(0.7, 0.7, 0.7);
glVertex2f(-180, 50);//q1 glVertex2f(40, 160);//j2
glVertex2f(-200, 50);//k1 glVertex2f(-10, 160);//k2
glVertex2f(-200, -10);//r1 glVertex2f(-10, 140);//l2
glVertex2f(-180, -10);//s1 glVertex2f(40, 140);//h2
glEnd(); glEnd();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7); glColor3f(0.7, 0.7, 0.7);
glVertex2f(-150, 10);//t1 glVertex2f(-10, 100);//m2
glVertex2f(-200, 10);//u1 glVertex2f(10, 100);//n2
glVertex2f(-200, -10);//r1 glVertex2f(10, 160);//o2
glVertex2f(-150, -10);//v1 glVertex2f(-10, 160);//k2
glEnd(); glEnd();
glBegin(GL_POLYGON);
glColor3f(0.7, 0.7, 0.7);
glVertex2f(-10, 120);//p2
glVertex2f(40, 120);//q2
glVertex2f(40, 100);//r2
glVertex2f(-10, 100);//m2
glEnd();
}
//5 //6
void panahJam() void panahDetik()
{ {
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(1,0.3,0.1); glColor3f(0.6, 1, 0.2);
glVertex2i(0,200); glVertex2i(0, 220);
glVertex2i(10, 180); glVertex2i(10, 280);
glVertex2i(5, 180); glVertex2i(5, 200);
glVertex2i(5, 0); glVertex2i(5, 0);
glVertex2i(-5, 0); glVertex2i(-5, 0);
glVertex2i(-5, 180); glVertex2i(-5, 200);
 glVertex2i(-10, 180); glVertex2i(-10, 200);
glVertex2i(0, 200); glVertex2i(0, 220);
glEnd(); glEnd();
} }
//7 //8
void panahMenit() glColor3f(0.2,0.2,0.2);
{ for (n = 0; n < 360; n += 30)
glBegin(GL_POLYGON); glVertex2f(jarak*(float)sin(n*PI
glColor3f(1, 0.5,0.5); / 180.0) + x, jarak*(float)cos(n*PI /
glVertex2i(0, 240); 180.0) + y);
glVertex2i(10, 210); glEnd();
glVertex2i(5, 210); }
glVertex2i(5, 0); void detik(float jarak, float x, float
glVertex2i(-5, 0); y)
glVertex2i(-5, 210); {
glVertex2i(-10, 210); glPointSize(5);
glVertex2i(0, 240); glBegin(GL_POINTS);
glEnd(); glColor3f(0.2,0.2, 0.2);
} for (n = 0; n < 360; n += 6)
void menit(float jarak, float x,
float y) glVertex2f(jarak*(float)sin(n*PI
{ / 180.0) + x, jarak*(float)cos(n*PI /
glPointSize(10); 180.0) + y);
glBegin(GL_POINTS); glEnd();
}
//9 //10
void renderScene(void) {
glPushMatrix();
glClear(GL_COLOR_BUFFER_BIT); glRotatef(sudut / 60, 0, 0, 1);
glClearColor(1, 1, 1, 1); panahMenit();
glPushMatrix(); glPopMatrix();
glColor3f(0.0f, 0.0f, 0.4f);
lingkaran(275,100,0,0); glPushMatrix();
glColor3f(0.0f, 0.5f, glRotatef(sudut / 720, 0, 0, 1);
1.0f);//baby Blue panahJam();
lingkaran(250, 100, 0, 0); glPopMatrix();
menit(230., 0., 0.);
detik(230., 0., 0.); glColor3f(1,0.9,0.7);
angka(); lingkaran(20, 100, 0, 0);
glPopMatrix(); glFlush();
}
glPushMatrix();
glRotatef(sudut, 0, 0, 1);
panahDetik();
glPopMatrix();

void timer(int value) {

sudut -= 6;
glutPostRedisplay();
glutTimerFunc(1000, timer, 0);
}
void main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitWindowPosition(100, 100);
glutInitWindowSize(300, 300);
glutCreateWindow("JAM ANALOG");
gluOrtho2D(-300., 300., -300., 300.);
glutDisplayFunc(renderScene);
glutTimerFunc(60, timer, 0);
glutMainLoop();
}
Output Program :

Penjelasan :

Program diatas menjalankan jam analog dimana detik akan bergerak tiap secondnya
dan terdapat angka untuk menunjukkan jam. Pertama buat terlebih dahulu objek
lingkaran untuk jam analognya dengan mengguakan GL_POLYGON. Kemudian buat objek
untuk membuat panah jarum jam yaitu panah detik, panah menit dan panah jam. Untuk
membuat point point yang menunjukkan menit dan detiknya mengunakan perulangan
pada GL_POINTS dengan memperhitungkan jumlah titik pada lingkaran. Pada void
renderScene(void) seluruh objek dipanggil, yang pertama dipanggil terlebih dahulu
adalah objek jamnya yaitu lingkaran, agar lingkaran memiliki tepi seperti gambar, maka
perlu dua lingkaran dengan radius yang berbeda. Objek lingkaran, point menit dan detik
serta gambar angka yang sudah dibuat di dipanggil dalam satu popmatrik dan
pushmatrik, karena objek objek tersebut dipanggil dan di simpan terlebih dahulu
kemudian ditampilkan sehingga matrik selanjutnya dapat dipanggiil. Objek yang
dipanggil selanjutnya adalah panah detik dimana diperlukan transformasi glRotatef
agar panah detik berputar setiap detiknya sesuai sudut yang ditentukan. Kemudian
objek yang ditransformasi dengan glRotatef adala panah menit, dimana perputarannya
akan dilakukan setelah panah detik sudah melewati 60 titik, oleh karena itu sudutnya
dibagi 60 agar ketika panah detik sudah mencapai 60 maka panah menit akan bergerak.
Begitu pula pada panah jam, sudutnya dibagi 720 agar ketika panah menit sudah
berputar 360 maka panah jam aka bergerak. Pada void timer(int value) di
deklarasikan bahwa sudut -= 6 maka waktu tersebut berjalan selama 1 detik atau 1000
milissecond. Hasilnya panah detik akan berputar perdetik, panah menit akan berputar
setekah panah detik sudah mencapai sudut 360 dan panah jam akan berotasi setelah
panah menit sudah mencapai sudut 360.