LAPORAN MODUL III

PRAKTIKUM GRAFIKA KOMPUTER

“Transformasi dan Animasi Objek 2D”

Disusun untuk Memenuhi Matakuliah Praktikum Grafika Komputer

Yang Dibimbing oleh Bapak Heru Wahyu Herwanto

Disusun Oleh :
Ananda Putri Syaviri (130533608243)
PTI Off B 2013

UNIVERSITAS NEGERI MALANG

FAKULTAS TEKNIK
JURUSAN TEKNIK ELEKTRO
PRODI PENDIDIKAN TEKNIK INFORMATIKA
MARET 2015
 PRAKTIKUM MODUL-3
Transformasi dan Animasi Objek 2D

A. TUJUAN
 Memahami fungsi-fungsi transformasi (translasi, rotasi, skala).
 Memahami dan dapat membuat multi objek menggunakan fungsi transformasi.
 Memahami prinsip-prinsip pembuatan animasi objek 2D.
 Membuat animasi objek 2D.

B. JOBSHEET PRAKTIKUM
1. Transformasi Object 2D
1) Script dasar transformasi objek 2D
Source Code
#include <stdlib.h>
glVertex2d(-100,200);
#include <glut.h>
glVertex2d(-100,150);
void drawLine() {
glVertex2d(-100,150);
glLineWidth(10);
glVertex2d(-50,150);
glClear(GL_COLOR_BUFFER_BIT);
glEnd();
glBegin(GL_QUADS);
glFlush();
glVertex2d(50,50);
}
glVertex2d(100,50);
void main(int argc,char **argv){
glutInit(&argc, argv);
glVertex2d(100,50);
glutInitDisplayMode(GLUT_DEPTH |
glVertex2d(100,100);
GLUT_SINGLE | GLUT_RGBA);
glVertex2d(100,100); glutInitWindowPosition(100,100);
glVertex2d(50,100); glutInitWindowSize(480,480);
glutCreateWindow("Praktikum
glVertex2d(50,100);
Modul 3");
glVertex2d(50,50);
gluOrtho2D(-320.,320.,-
glVertex2d(-50,150); 320.,320);
glVertex2d(-50,200); glutDisplayFunc(drawLine);
glutMainLoop();
glVertex2d(-50,200); }
glVertex2d(-100,200);
Hasil
 Penjelasan :
- Script diatas digunakan untuk mengatur posisi windows, ukuran windows dan system
koordinat yang digunakan. Script diatas merupakan script dasar untuk membangun
sebuah windows. Dimana glutInitWindowPosition(100, 100); berfungsi untuk
menentukan posisi windows dalam layar. glutInitWindowSize(480, 480); berfungsi
untuk mengatur ukuran (panjang dan lebar) jendela windows. Kemudian gluOrtho2D(-

320., 320., -240., 240.); bertujuan untuk mengatur panjang sistem koordinat jendela
windows dengan format (kiri, kanan, bawah, atas). Sebagai contoh untuk
pembentukan objek kotak diatas, pada fungsi main, dituliskan script-script dasar
untuk membangun sebuah jendela windows.

2) Translasi
Source Code
#include <stdlib.h> }
#include <glut.h> void main(int argc,char
**argv){
void drawQuad() { glutInit(&argc, argv);
glClear(GL_COLOR_BUFFER_BI glutInitDisplayMode(GLUT_D
T); EPTH | GLUT_SINGLE | GLUT_RGBA);
glBegin(GL_QUADS); glutInitWindowPosition(100
glTranslatef(50,0,0); ,100);
glVertex2f(0.,0.); glutInitWindowSize(480,480
glVertex2f(0.,10.); );
glTranslatef(50,0,0); glutCreateWindow("Praktiku
glVertex2f(20.,10.); m Modul 3");
glVertex2f(20.,0.); gluOrtho2D(-
glTranslatef(50,0,0); 320.,320.,-320.,320);
glEnd(); glutDisplayFunc(drawQuad);
glFlush(); glTranslatef(50,0,0);
 glutMainLoop(); }
Hasil

Penjelasan :
- Program diatas membuat bentuk persegi dengan menambahkan fungsi
glTranslatef(50,0,0);. Fungsi glTranslatef(50,0,0);tersebut digunakan untuk melakukan
perpindahan objek dengan x=50, y=0, dan z=0. Hal ini akan mempengaruhi posisi
objek yang dibangun. Pada program ini mencoba meletakkan fungsi glTranslatef pada
beberapa tempat, namun ada beberapa tempat yang tidak akan mempengaruhi hsil
program.Pada program diatas jika menempatkan glTranslatef pada beberapa tempat
akan mempengaruhi posisi objek sesuai parameter x,y,z yang digunakan.

3) Membuat bendera Indonesia dengan Translasi Objek

Source Code
#include <stdlib.h> void render(){
#include <glut.h> glClear(GL_COLOR_BUFFER_BI
T);
void drawQuad() { glTranslatef(-10,0,0);
glBegin(GL_QUADS); glColor3f(1,0,0);
glVertex2f(0.,0.); drawQuad();
glVertex2f(0.,50.); glTranslatef(0,-50,0);
glVertex2f(105.,50.); glColor3f(1,1,1);
glVertex2f(105.,0.); drawQuad();
glEnd(); glFlush();
} }
 void main(int argc,char glutCreateWindow("Praktiku
**argv){ m Modul 3");
glutInit(&argc, argv); gluOrtho2D(-
glutInitDisplayMode(GLUT_D 320.,320.,-320.,320);
EPTH | GLUT_SINGLE | GLUT_RGBA); glutDisplayFunc(render);
glutInitWindowPosition(100 glutMainLoop();
,100); }
glutInitWindowSize(480,480
);

Hasil

Penjelasan :
- Program diatas adalah program untuk membentuk sebuah bendera dengan
menggunakan titik koordinat
glVertex2f(0.,0.);
glVertex2f(0.,50.);
glVertex2f(105.,50.);
glVertex2f(105.,0.);
untuk pemanggilan fungsi drawQuad diletakkan double agar dapat membentuk 2
persegi dengan warna yang dideklarasikan berbeda,(merah dan putih) pada fungsi
render. Kemudian agar posisi 2 persegi berdekatan, menggunakan fungsi translatef
glTranslatef(0,-10,0); Dimana maksud dari syntax tersebut adalah objek persegi
panjang warna putih akan diberpindah sejauh -10 pada sumbu y (nilai minus pada
sumbu y membuat objek bergeser kebawah). Dan sebaliknya untuk persegi panjang
warna merah akan bergeserr sejauh -50 pada sumbu y, bergeser keatas.

4) Rotasi
Source Code
 #include <stdlib.h> drawQuad();
#include <glut.h> glFlush();
}
void drawQuad() {
glBegin(GL_QUADS); void main(int argc,char
glVertex2f(0.,0.); **argv){
glVertex2f(0.,50.); glutInit(&argc, argv);
glVertex2f(105.,50.); glutInitDisplayMode(GLUT_D
glVertex2f(105.,0.); EPTH | GLUT_SINGLE | GLUT_RGBA);
glEnd(); glutInitWindowPosition(100
} ,100);
glutInitWindowSize(480,480
void render(){ );
glClear(GL_COLOR_BUFFER_BI glutCreateWindow("Praktiku
T); m Modul 3");
glRotatef(45,1,0,0); gluOrtho2D(-
glColor3f(1,0,0); 320.,320.,-320.,320);
drawQuad(); glutDisplayFunc(render);
glRotatef(45,1,0,0); glutMainLoop();
glColor3f(1,1,1); }

Hasil

Penjelasan :
- Program diatas menggunakan fungsi Rotatef dengan sudut 45 pada sumbu x=1, y=0,
z=0, sehingga menghasilkan warna putih tertindih oleh bendera warna merah. Karena
berotasi pada sumbu x, maka hasilnya seperti pada gambar.

5) Skala
 Source Code
#include <stdlib.h> drawQuad();
#include <glut.h> glFlush();
}
void drawQuad() {
glBegin(GL_QUADS); void main(int argc,char
glVertex2f(0.,0.); **argv){
glVertex2f(0.,50.); glutInit(&argc, argv);
glVertex2f(105.,50.); glutInitDisplayMode(GLUT_D
glVertex2f(105.,0.); EPTH | GLUT_SINGLE | GLUT_RGBA);
glEnd(); glutInitWindowPosition(100
} ,100);
glutInitWindowSize(480,480
void render(){ );
glClear(GL_COLOR_BUFFER_BI glutCreateWindow("Praktiku
T); m Modul 3");
glScalef(45,20,0); gluOrtho2D(-
glColor3f(1,0,0); 320.,320.,-320.,320);
drawQuad(); glutDisplayFunc(render);
glScalef(45,20,0); glutMainLoop();
glColor3f(1,1,1); }

Hasil

Penjelasan :
- Program diatas menggunakan fungsi Scalef untuk mengubah skala bangun. Pada
program diatas menggunakan skala x = 45, y=20, z=20 sesuai dengan koordinat
x,y,dan z. Sehingga hasilnya akan tampak seperti gambar diatas.
 2. ANIMASI OBJECT 2D
1) Rotasi terhadap sumbu z unclockwise
Source Code
#include <stdlib.h> {
#include <glut.h> glutPostRedisplay();
glutTimerFunc(60,timer,0);
void Persegi() { }
glBegin(GL_QUADS); void main(int argc,char
glVertex2f(0.,0.); **argv){
glVertex2f(0.,75.); glutInit(&argc, argv);
glVertex2f(105.,75.); glutInitDisplayMode(GLUT_D
glVertex2f(105.,0.); EPTH | GLUT_SINGLE | GLUT_RGBA);
glEnd(); glutInitWindowPosition(100
} ,100);
void display(void){ glutInitWindowSize(640,480
glClear(GL_COLOR_BUFFER_BI );
T); glutCreateWindow("Latihan
glColor3f(1., 0., 1.); animasi prak 3");
Persegi(); gluOrtho2D(-
glRotatef(45,10,2,10); 320.,320.,-320.,320);
glColor3f(0., 1., 1.); glutDisplayFunc(display);
Persegi(); glutTimerFunc(50,timer,10)
glFlush(); ;
} glutMainLoop();
void timer (int value) }
Hasil

Penjelasan
 - Program diatas menggunakan fungsi Rotatef sehingga terlihat seperti berputar
(berlawanan arah jarum jam). Menggunakan fungsi timer sebagai Inisialisasi dalam
penggunaan Timer Function yakni Set unsign millis=50. Yang digunakan untuk
mengatur kecepatan rotasi objek.

2) Rotasi terhadap sumbu y Clockwise

Source Code
#include <stdlib.h> //Load
library void timer (int value)
#include <glut.h> //Load library {
glut glutPostRedisplay();
glutTimerFunc(100,timer,0);
void Persegi (void) }
{
glBegin(GL_QUADS); void main (int argc, char **argv)
glVertex2f(0.,0.); {
glVertex2f(0.,40.); glutInit (&argc, argv);
glVertex2f(100.,40.); /* ... */
glVertex2f(100.,0.); glutInitDisplayMode (GLUT_DEPTH |
glEnd(); GLUT_SINGLE | GLUT_RGBA);
glFlush(); glutInitWindowPosition(100,100);
} glutInitWindowSize(640,480);
void display () glutCreateWindow("Latihan Animasi
{ 2D");
glClear(GL_COLOR_BUFFER_BIT); gluOrtho2D(-320.,320.,-
glRotatef(45,0,0,1); 240.,240.);
Persegi(); glutDisplayFunc(display);
/* ... */ glutTimerFunc(100,timer,0);
glFlush(); glutMainLoop();
} }

Hasil
 Penjelasan
- Program diatas menggunakan fungsi Rotatef untuk membuat objek berputar dengan
parameter 45,0,0,1 maka objek akan berputar sebesar 45 derajat pada sumbu y
clockwise(arah putar jarum jam). Artinya karena menggunakan parameter x= 0, y=0
maka objek akan berputar tepat ditengah koordinat sumbu x dan y.

3) Rotasi terhadap sumbu x Clockwise

Source Code
#include <stdlib.h> //Load
library void timer (int value)
#include <glut.h> //Load library {
glut glutPostRedisplay();
glutTimerFunc(200,timer,0);
void Persegi (void) }
{
glBegin(GL_QUADS); void main (int argc, char **argv)
glVertex2f(0.,0.); {
glVertex2f(0.,40.); glutInit (&argc, argv);
glVertex2f(100.,40.); /* ... */
glVertex2f(100.,0.); glutInitDisplayMode (GLUT_DEPTH |
glEnd(); GLUT_SINGLE | GLUT_RGBA);
glFlush(); glutInitWindowPosition(100,100);
} glutInitWindowSize(640,480);
void display () glutCreateWindow("Latihan Animasi
{ 2D");
glClear(GL_COLOR_BUFFER_BIT); gluOrtho2D(-320.,320.,-
glRotatef(45,0,1,0); 240.,240.);
Persegi(); glutDisplayFunc(display);
/* ... */ glutTimerFunc(200,timer,0);
glFlush(); glutMainLoop();
} }
 Hasil

Penjelasan
- Program diatas hampir sama dengan latihan sebelumnya, hanya saja perbedaannya
adalah merotasi objek pada sumbu x clockwise. Rotasinya dapat menggunakan
glutTimerFunc(200,timer,0);fungsi ini digunakan untuk mengatur kecepatan rotasi
objek. Kemudian karena menggunakan fungsi rotate dengan parameter 45, 0, 1, 0,
yang artinya objek akan berotasi sebesar 45 derajat pada sumbu x=0, y=1, z=0,
sehingga hasilnya akan tampak seperti pada gambar.

4) Timer Translasi
Source Code
#include <stdlib.h> //Load library glVertex2f(80.,40.);
#include <glut.h> //Load library glut glVertex2f(80.,0.);
glEnd();
int x=1; glFlush();
void Draw (void) }
{
glBegin(GL_QUADS); void renderScene ()
glVertex2f(0.,0.); {
glVertex2f(0.,40.); glClear(GL_COLOR_BUFFER_BIT);
 glPushMatrix(); void main (int argc, char **argv)
if(x<200) {
{ glutInit (&argc, argv);
x+=4; /* ... */
glTranslatef(x,0,0); glutInitDisplayMode (GLUT_DEPTH |
Draw(); GLUT_SINGLE | GLUT_RGBA);
} glutInitWindowPosition(100,100);
glPopMatrix(); glutInitWindowSize(640,480);
glFlush(); glutCreateWindow("LATIHAN
} ANIMASI 2D");
gluOrtho2D(-320.,320.,-
void timer (int value) 240.,240.);
{ glutDisplayFunc(renderScene);
glutPostRedisplay(); glutTimerFunc(100,timer,0);
glutTimerFunc(100,timer,0); glutMainLoop();
} }

Hasil

Penjelasan
- Pada program diatas, menggunakan perkondisian if
int x=0;
void timer(int value){
if(x<200){
x+=4; }
yang artinya, jika nilai xlebih kecil dari 200 maka x ditambah dengan 4, yang
digunakan untuk perpindahan objek hingga akhir windows(fungsinya dalam mengatur
jarak jalan segiempat tersebut). Sedangkan untuk menampilkan fungsi looping
 menggunakan glutPostRedisplay(); sehingga objek akan bergerak secara terus
menerus hingga menghilang karena sudah mencapai batas perkondisian.

5) Timer Translasi terhadap sumbu y

Source Code
#include <stdlib.h> //Load glPopMatrix();
library glFlush();
#include <glut.h> //Load library }
glut
void timer (int value)
int y=0; {
void Draw (void) glutPostRedisplay();
{ glutTimerFunc(150,timer,0);
glBegin(GL_QUADS); }
glVertex2f(0.,0.);
glVertex2f(0.,40.);
glVertex2f(100.,40.); void main (int argc, char **argv)
glVertex2f(100.,0.); {
glEnd(); glutInit (&argc, argv);
glFlush(); /* ... */
} glutInitDisplayMode (GLUT_DEPTH |
GLUT_SINGLE | GLUT_RGBA);
void renderScene () glutInitWindowPosition(100,100);
{ glutInitWindowSize(640,480);
glClear(GL_COLOR_BUFFER_BIT); glutCreateWindow("LATIHAN
glPushMatrix(); ANIMASI 2D");
if(y>-200) gluOrtho2D(-320.,320.,-
{ 240.,240.);
y+=4; glutDisplayFunc(renderScene);
glTranslatef(0,-y,0); glutTimerFunc(150,timer,0);
Draw(); glutMainLoop();
} }

Hasil
 Penjelasan
- Program diatas hampir sama dengan program sebelumnya , hanya saja perbedaanya
terletak pada pergerakan objek yang bergerak ke bawah. Pada script menggunakan
inisialisasi nilai sumbu y yang negative, yang artinya, pergerakan objek akan berjalan
ke titik koordinat sumbu y negative (bawah) Pada script menambahkan penggunaan
fungsi glPopMatrix(); yang akan memanggil fungsi yang disimpan dalam
glPushMatrix

6) Timer Translasi terhadap sumbu z

Source Code
#include <stdlib.h> //Load library glVertex2f(80.,0.);
#include <glut.h> //Load library glEnd();
glut glFlush();
}
int z=1;
void Draw (void) void renderScene ()
{ {
glBegin(GL_QUADS); glClear(GL_COLOR_BUFFER_BIT);
glVertex2f(0.,0.); glPushMatrix();
glVertex2f(0.,20.); if(z<200)
glVertex2f(80.,20.); {
 z+=4; {
glTranslatef(0,0,z); glutInit (&argc, argv);
Draw(); /* ... */
} glutInitDisplayMode (GLUT_DEPTH |
glPopMatrix(); GLUT_SINGLE | GLUT_RGBA);
glFlush(); glutInitWindowPosition(100,100);
} glutInitWindowSize(640,480);
glutCreateWindow("LATIHAN
void timer (int value) ANIMASI 2D");
{ gluOrtho2D(-320.,320.,-
glutPostRedisplay(); 240.,240.);
glutTimerFunc(150,timer,0); glutDisplayFunc(renderScene);
} glutTimerFunc(150,timer,0);
glutMainLoop();
}
void main (int argc, char **argv)

Hasil

Penjelasan
- Pada program datas juga menggunakan prinsip yang sama dengan program
sebelumnya. Program diatas menggunakan titik z untuk membentuk objek.
Menggunakan perkondisian if jika inisialisasi z < 200 maka z ditambah 4. Pada hasil
tidak terlihat karena pada intinya dalam system koordinat yang ditampilkan hanya
titik x dan y, sedangkan titik z tidak ditampilkan , sehinnga tidak muncul objek
appun, tidak jarang juga jika menggunakan parameter sumbu x,y,z , nilai z selalu
menggunakan nilai 0.

C. TUGAS ASISTENSI
1. Tugas Asistensi 1
Source Code
#include <stdlib.h> #include <glut.h>
 glColor3f(1,1,1);
void drawQuads(){ drawQuads2 ();

glBegin(GL_QUADS); glTranslatef(120,-100,0);
glVertex2f(-45.0,-10.0); glColor3f(1,0,0);
glVertex2f (45.0,-10.0); drawQuads ();
glVertex2d (45.0,30.0); glTranslatef (-90,0,0);
glVertex2d (-45.0,30.0); glColor3f(1,0,0);
glEnd (); drawQuads ();
} glTranslatef (-90,0,0);
glColor3f(1,0,0);
void drawQuads2(){ drawQuads ();
glBegin(GL_QUADS);
glVertex2f(150.0,180.0); glTranslatef(20,-40,0);
glVertex2f (180.0,180.0); glColor3f(1,1,1);
glVertex2d (180.0,240.0); drawQuads ();
glVertex2d (150.0,240.0);
glEnd (); glTranslatef(120,0,0);
} glColor3f(1,1,1);
void render(){ drawQuads ();
glFlush ();
glClear(GL_COLOR_BUFFER_BIT); }
glColor3f(1,0,0); void main(int argc,char **argv){
drawQuads (); glutInit(&argc,argv);
glTranslatef(0,-40,0);
glColor3f(1,1,1); glutInitDisplayMode(GLUT_DEPTH |
drawQuads (); GLUT_SINGLE |GLUT_RGBA);

glColor3f(1,0,0); glutInitWindowPosition(150,250);
drawQuads2 (); glutInitWindowSize(640,480);
glRotatef(180,0,-1,0); glutCreateWindow("ASISTENSI
glColor3f(1,1,1); 1");
drawQuads2 (); gluOrtho2D(-640,640,-480,480);
glTranslatef(30,0,0); glutDisplayFunc(render);
glColor3f(1,0,0); glutMainLoop();
drawQuads2 (); }
glRotatef(180,0,-1,0);

Hasil

Penjelasan
- Pada program diatas menggunakan fungsi GL_QUADS untuk membangun objek segi
empat. Saya menggunakan 2 fungsi drawQuads, yang akan membangun 2 buah objek
dengan warna berbeda. Menggunakan fungsi Translatef juga untuk posisi objek yang
beragam. Menggunakan Rotatef untuk mengubah posisi objek. Menggunakan
glColor3f untuk pewarnaan objek.

2. Tugas Asistensi 2
Source Code
#include <stdlib.h>
#include <glut.h> glTranslatef (10,-
10,0);
int x,y; }
else if (x <400)
void guide() {
{ x += 10;
glBegin (GL_QUADS); glTranslatef (-10,-
glVertex2i(-1, 250); 10,0);
//a }
glVertex2i(1, 250); else if (x < 600)
//b {
glVertex2i(1, -250); x += 10;
//c glTranslatef (-
glVertex2i(-1, -250); 10,10,0);
//d }
else if (x < 800)
glVertex2i(250, -1); {
//a x += 10;
glVertex2i(250, 1); glTranslatef
//b (10,10,0);
glVertex2i(-250, 1); }
//c else if (x = 790)
glVertex2i(-250, -1); {
//d x=0;
glEnd(); }
}
glutPostRedisplay();
void kotak() glutTimerFunc(500,timer,0);
{ }
glBegin (GL_QUADS);
glVertex2i(-20, 240); void render()
//a {
glVertex2i(20, 240);
//b
glClear(GL_COLOR_BUFFER_BI
glVertex2i(20, 200);
T);
//c
glPushMatrix();
glVertex2i(-20, 200);
//guide();
//d
glTranslatef(10,-10,0);
glEnd();
kotak();
}
glPopMatrix();
glFlush();
void timer (int value)
}
{
if (x<200)
{
void main (int argc, char
x += 10;
**argv)
 {
glutInit(&argc, argv); glutCreateWindow("ASISTENSI
2)");
glutInitDisplayMode(GLUT_DE gluOrtho2D(-640.,640.,-
PTH | GLUT_SINGLE | 320.,320.);
GLUT_RGBA); glutDisplayFunc(render);
glutInitWindowPosition(150, glutTimerFunc(500,timer,0);
150); glutMainLoop();
glutInitWindowSize(640, }
480);

Hasil

Penjelasan :
- Program diatas menggunakan fungsi GL_QUADS untuk membentuk guide arah objek
bergerak. Menggunakan fungsi kotak untuk membentuk objeknya. Menggunakan
fungsi timer dengan perkondisian jika nilai x kurang dari 200 maka x ditambah 10,
hal ini yang mengakibatkan trerjadinya pergerakan objek. Menggunakan fungsi
Translatef juga. Kemudian perkondisian selanjutnya dideklarasikan jika x kurang dari
400 maka x ditambah 10 dengan menerapkan fungsi glTranslatef (-10,10,0). Kondisi
selanjutnya jika kurang dari 600 maka sama menggunakan fungsi glTranslatef pada
kondisi x<400. Untuk kondisi selanjutnya juga sama pendeklarasiannya, hingga jika
nilai x = 790 maka x=0. Menggunakan timer 500 untuk kecepatan geraknya.
3. Tugas Asistensi 3
Source Code
#include <stdlib.h> }
#include <glut.h>
#include <math.h> void detik()
{
#define PI 3.1415926535 glBegin(GL_QUADS);
glColor3f(0.,1.,0.);
float sudut = 0; glVertex2f(5.,200.);
int i,n; glVertex2f(5.,0.);
glVertex2f(-5.,0.);
void lingkaran(int radius, int glVertex2f(-5.,200.);
jumlah_titik, int xtengah, int glEnd();
ytengah) }
{

glBegin(GL_POLYGON); //titik jam

for void angka(float jarak, float
(i=0;i<=360;i++) x, float y)
{ {
float glPointSize(10);
sudut=i*(2*PI/jumlah_titik); glBegin(GL_POINTS);
float glColor3f(0.,0.,0.);
x=xtengah+radius*cos(sudut);
float for(n=0;n<360;n+=90)
y=ytengah+radius*sin(sudut);

glVertex2f(x,y); glVertex2f(jarak*(float)sin(n*PI/180.
0)+x,jarak*(float)cos(n*PI/180.0)+y
glColor3f(0., 1., 1.); );
} glEnd();
glEnd(); }
}
// titik menit
//Jarum kecil void menit(float jarak, float
void kecil() x, float y)
{ {
glBegin(GL_QUADS); glPointSize(4);
glBegin(GL_POINTS);
glColor3f(1.,1.,0.);//kuning glColor3f(0.,0.,0.);
glVertex2f(5.,125.);
glVertex2f(5.,0.); for(n=0;n<360;n+=6)
glVertex2f(-5.,0.);
glVertex2f(-5.,125.);
glEnd();
glVertex2f(jarak*(float)sin(n*PI/180.
}
0)+x,jarak*(float)cos(n*PI/180.0)+y
);
//Jarum panjang
glEnd();
}
void panjang()
{
glBegin(GL_QUADS); void renderScene(void)
{
glColor3f(1.,1.,1.);//putih
glVertex2f(5.,175.);
glVertex2f(5.,0.); glClear(GL_COLOR_BUFFER_BIT);
glVertex2f(-5.,0.); //warna lingkaran
glVertex2f(-5.,175.); glPushMatrix();
glEnd(); glColor3f(1.,0.,0.);
 void timer(int value)
lingkaran(260,100,0,0); {
angka(230.,0.,0.); sudut-=6;
menit(230.,0.,0.); glutPostRedisplay();
glPopMatrix();
//panah detik
glPushMatrix(); glutTimerFunc(1000,timer,0);
}
glRotatef(sudut,0,0,1);
detik(); void main (int argc, char
glPopMatrix(); **argv)
//panah menit {
glPushMatrix(); glutInit(&argc, argv);

glRotatef(sudut/60,0,0,1); glutInitDisplayMode(GLUT_DEPTH |
panjang(); GLUT_SINGLE | GLUT_RGBA);
glPopMatrix(); glutInitWindowPosition(150,
//panah jam 150);
glPushMatrix(); glutInitWindowSize(640,
480);
glRotatef(sudut/720,0,0,1);
kecil(); glutCreateWindow("ASISTENSI 3");
glPopMatrix(); gluOrtho2D(-640.,640.,-
glColor3f(0,0,0); 320.,320.);

lingkaran(10,50,0,1); glutDisplayFunc(renderScene);
glFlush(); glutTimerFunc(1,timer,0);
} glutMainLoop();
}

Hasil

Penjelasan
- Pada program diatas menngunakan fungsi matematika untuk perhitungan arah jam.
Terdapat banyak fungsi yang menggambarkan objek-objek yang akan dibentuk untuk
menyusun jam analog ini. Menggunakan perulangan for untuk membuat jam
 bergerak/berputar secara nyata. Pendeklarasian pembentukan panah jam dari jam
menit, detik dengan warna berbeda dan panjang yang berbeda. Menggunakan fungsi
timer untuk pergerakan panah. Mendeklarasikan titik titik yang digunakan sebagai
titik menit dari jam analog.

4. Tugas Asistensi 4
Source Code
#include <glut.h> glRotatef(45,0,0,1);
glScalef(0.1,0.1,0);
void bintang() glTranslatef(3000,20,0);
{ glColor3f(1.,0.,1.);
glBegin(GL_POLYGON); bintang();
glVertex2f(0,0);//a glPopMatrix();
glVertex2f(50,150);//b glPushMatrix();
glVertex2f(100,0);//c glRotatef(60,0,0,1);
glVertex2f(250,0);//d glScalef(0.3,0.3,0);
glVertex2f(130,-100);//e glTranslatef(999,99,0);
glVertex2f(200,-250);//f glColor3f(0.,1.,0.);
glVertex2f(50,-150);//g bintang();
glVertex2f(-100,-250);//h glPopMatrix();
glVertex2f(-25,-100);//i glPushMatrix();
glVertex2f(-175,0); //j glRotatef(10,0,0,1);
glEnd(); glScalef(-0.5,-0.5,0);
glFlush(); glTranslatef(444,333,0);
} glColor3f(0,0,1);
bintang();
void renderScene(void) glPopMatrix();
{ glPushMatrix();
glTranslatef(-320,-320,0);
glClear(GL_COLOR_BUFFER_BIT) glRotatef(-30,0,0,1);
; glScalef(0.6,0.6,0);
//garis diagonal glColor3f(0,1,1);
glPushMatrix(); bintang();
glRotatef(135,0,0,1); glPopMatrix();
glColor3f(0,0.6,1);
glPopMatrix(); glPushMatrix();
//kumpulan bintang glRotatef(90,0,0,1);
glPushMatrix(); glScalef(0.1212,0.21,0);
glTranslatef(-100,-190,0); glTranslatef(-999,120,0);
glRotatef(180,0,0,1); glColor3f(0,1,0);
glScalef(1.4,1.4,0); bintang();
glPopMatrix();
glColor3f(0.987,0.123,0.567); //
glPushMatrix();
pink
glRotatef(180,1,1,0);
bintang();
glScalef(-0.1,-0.1,0);
glPopMatrix();
glTranslatef(10,2222,0);
glFlush();
glColor3f(0.,0.,1.);
bintang();
glPushMatrix();
glPopMatrix();
glScalef(1.1,1.1,0);
glTranslatef(200,300,0);
glPushMatrix();
glColor3f(1,1,0);
glRotatef(90,0,0,1);
bintang();
glScalef(0.4,-0.4,0);
glPopMatrix();
glTranslatef(100,90,0);
glPushMatrix();
glColor3f(0.,1.,1.);
bintang(); }
glPopMatrix();
void main (int argc, char
glPushMatrix(); **argv)
glTranslatef(100,90,0); {
glRotatef(90,30,0,1); glutInit(&argc, argv);
glScalef(0.2,-0.5,0);
glColor3f(1,1,0); glutInitDisplayMode(GLUT_DEPT
bintang(); H | GLUT_SINGLE | GLUT_RGBA);
glPopMatrix(); glutInitWindowPosition(150,
150);
glutInitWindowSize(640,
glPushMatrix(); 480);
glTranslatef(-300,-90,0);
glRotatef(180,0,0,1);
glutCreateWindow("ASISTENSI
glScalef(0.3,0.3,0);
4");
glColor3f(1.,0.,0.);
gluOrtho2D(-640.,640.,-
bintang();
320.,320.);
glPopMatrix();
glFlush();
glutDisplayFunc(renderScene);
glutMainLoop();
}
 Hasil

Penjelasan
- Program diatas merupakan program yang menampilkan 10 bintang dengan
menggunakan fungsi Translatef, Rotatef, skala yang dikombinasikan pada program
ini. Dengan ukuran yang beragam dan warna ynag berbeda , dapat dibedakan mana
bintang yang menggunakan fungsi Translatef , Rotatef dan skala. untuk pembuatan
satu bintang menerapkan ketiga fungsi tersebut, sehingga skala , rotasi dan translasi
per satu bintang berbeda dengan bintang yang lainnya. Menggunakan fungsi
glPlushMatrix dan glPopMatrix.

D. KESIMPULAN
 Fungsi Translatef digunakan untuk merubah posisi objek.
 Fungsi Translatef menggunakan parameter (x,y,z).
 Fungsi Rotated digunakan untuk merotasi/memutar objek dengan besarnya sudut
yang diinginkan. Menggunakan parameter (besar sudut, x, y,z).
 Fungsi Scalef digunakan untuk merubah ukuran objek, memperkecil maupun
memperbesar.
 Penginisialisasian penggunaan timer untuk pergerakan objek menggunakan fungsi
glutPostRedisplay, glutTimerFunc(unsigned millis, Glut function(callback), int
value).
 Fungsi dari glutPostRedisplay adalah untuk mengirimkan perintah mengaktifkan
display secara berkala (looping).

E. DAFTAR RUJUKAN
 Asisten Praktikum. 2015. Modul 3 Transformasi dan Animasi Objek 2D.Malang :
Universitas Negeri Malang.