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,200);
void drawLine() { glVertex2d(-100,150);
glLineWidth(10);
glClear(GL_COLOR_BUFFER_BIT); glVertex2d(-100,150);
glBegin(GL_QUADS); glVertex2d(-50,150);
glVertex2d(50,50); glEnd();
glVertex2d(100,50); glFlush();
}
glVertex2d(100,50); void main(int argc,char **argv){
glVertex2d(100,100); glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH |
glVertex2d(100,100); GLUT_SINGLE | GLUT_RGBA);
glVertex2d(50,100); glutInitWindowPosition(100,100);
glutInitWindowSize(480,480);
glVertex2d(50,100); glutCreateWindow("Praktikum
glVertex2d(50,50); Modul 3");
gluOrtho2D(-320.,320.,-
glVertex2d(-50,150); 320.,320);
glVertex2d(-50,200); glutDisplayFunc(drawLine);
glutMainLoop();
glVertex2d(-50,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> glTranslatef(50,0,0);
#include <glut.h> glEnd();
glFlush();
void drawQuad() { }
glClear(GL_COLOR_BUFFER_BI void main(int argc,char
T); **argv){
glBegin(GL_QUADS); glutInit(&argc, argv);
glTranslatef(50,0,0); glutInitDisplayMode(GLUT_D
glVertex2f(0.,0.); EPTH | GLUT_SINGLE | GLUT_RGBA);
glVertex2f(0.,10.); glutInitWindowPosition(100
glTranslatef(50,0,0); ,100);
glVertex2f(20.,10.); glutInitWindowSize(480,480
glVertex2f(20.,0.); );
 glutCreateWindow("Praktiku glutDisplayFunc(drawQuad);
m Modul 3"); glTranslatef(50,0,0);
gluOrtho2D(- glutMainLoop();
320.,320.,-320.,320); }
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> glVertex2f(105.,50.);
#include <glut.h> glVertex2f(105.,0.);
glEnd();
void drawQuad() { }
glBegin(GL_QUADS);
glVertex2f(0.,0.); void render(){
glVertex2f(0.,50.);
 glClear(GL_COLOR_BUFFER_BI glutInitDisplayMode(GLUT_D
T); EPTH | GLUT_SINGLE | GLUT_RGBA);
glTranslatef(-10,0,0); glutInitWindowPosition(100
glColor3f(1,0,0); ,100);
drawQuad(); glutInitWindowSize(480,480
glTranslatef(0,-50,0); );
glColor3f(1,1,1); glutCreateWindow("Praktiku
drawQuad(); m Modul 3");
glFlush(); gluOrtho2D(-
} 320.,320.,-320.,320);
glutDisplayFunc(render);
void main(int argc,char glutMainLoop();
**argv){ }
glutInit(&argc, argv);

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

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> Persegi();
#include <glut.h> glRotatef(45,10,2,10);
glColor3f(0., 1., 1.);
void Persegi() { Persegi();
glBegin(GL_QUADS); glFlush();
glVertex2f(0.,0.); }
glVertex2f(0.,75.); void timer (int value)
glVertex2f(105.,75.); {
glVertex2f(105.,0.); glutPostRedisplay();
glEnd(); glutTimerFunc(60,timer,0);
} }
void display(void){ void main(int argc,char
glClear(GL_COLOR_BUFFER_BI **argv){
T); glutInit(&argc, argv);
glColor3f(1., 0., 1.);
 glutInitDisplayMode(GLUT_D gluOrtho2D(-
EPTH | GLUT_SINGLE | GLUT_RGBA); 320.,320.,-320.,320);
glutInitWindowPosition(100 glutDisplayFunc(display);
,100); glutTimerFunc(50,timer,10)
glutInitWindowSize(640,480 ;
); glutMainLoop();
glutCreateWindow("Latihan }
animasi prak 3");
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 glVertex2f(0.,0.);
library glVertex2f(0.,40.);
#include <glut.h> //Load library glVertex2f(100.,40.);
glut glVertex2f(100.,0.);
glEnd();
void Persegi (void) glFlush();
{ }
glBegin(GL_QUADS); void display ()
 { {
glClear(GL_COLOR_BUFFER_BIT); glutInit (&argc, argv);
glRotatef(45,0,0,1); /* ... */
Persegi(); glutInitDisplayMode (GLUT_DEPTH
/* ... */ | 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(100,timer,0); glutDisplayFunc(display);
} glutTimerFunc(100,timer,0);
glutMainLoop();
void main (int argc, char **argv) }

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 glEnd();
#include <glut.h> //Load library glFlush();
glut }

int x=1; void renderScene ()

void Draw (void) {
{ glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS); glPushMatrix();
glVertex2f(0.,0.); if(x<200)
glVertex2f(0.,40.); {
glVertex2f(80.,40.); x+=4;
glVertex2f(80.,0.);
 {
glTranslatef(x,0,0); 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(100,timer,0); glutDisplayFunc(renderScene);
} glutTimerFunc(100,timer,0);
glutMainLoop();
}
void main (int argc, char **argv)

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,- glutTimerFunc(150,timer,0);
y,0); glutMainLoop();
Draw(); }
}

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; void main (int argc, char **argv)
{
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();
}

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>
 drawQuads2 ();
void drawQuads(){
glTranslatef(120,-100,0);
glBegin(GL_QUADS); glColor3f(1,0,0);
glVertex2f(-45.0,-10.0); drawQuads ();
glVertex2f (45.0,-10.0); glTranslatef (-90,0,0);
glVertex2d (45.0,30.0); glColor3f(1,0,0);
glVertex2d (-45.0,30.0); drawQuads ();
glEnd (); glTranslatef (-90,0,0);
} glColor3f(1,0,0);
drawQuads ();
void drawQuads2(){
glBegin(GL_QUADS); glTranslatef(20,-40,0);
glVertex2f(150.0,180.0); glColor3f(1,1,1);
glVertex2f (180.0,180.0); drawQuads ();
glVertex2d (180.0,240.0);
glVertex2d (150.0,240.0); glTranslatef(120,0,0);
glEnd (); glColor3f(1,1,1);
} drawQuads ();
void render(){ glFlush ();
}
glClear(GL_COLOR_BUFFER_BIT); void main(int argc,char **argv){
glColor3f(1,0,0); glutInit(&argc,argv);
drawQuads ();
glTranslatef(0,-40,0); glutInitDisplayMode(GLUT_DEPTH |
glColor3f(1,1,1); GLUT_SINGLE |GLUT_RGBA);
drawQuads ();
glutInitWindowPosition(150,250);
glColor3f(1,0,0);
drawQuads2 ();
glutInitWindowSize(640,480);
glRotatef(180,0,-1,0);
glColor3f(1,1,1);
drawQuads2 (); glutCreateWindow("ASISTENSI 1");
glTranslatef(30,0,0); gluOrtho2D(-640,640,-
glColor3f(1,0,0); 480,480);
drawQuads2 (); glutDisplayFunc(render);
glRotatef(180,0,-1,0); glutMainLoop();
glColor3f(1,1,1); }

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, 10,0);
250); //a }
glVertex2i(1, 250); else if (x < 600)
//b {
glVertex2i(1, x += 10;
-250); //c glTranslatef (-
glVertex2i(-1, 10,10,0);
-250); //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); //a
void render()
glVertex2i(20,
{
240); //b
glVertex2i(20,
200); //c glClear(GL_COLOR_BUFFER_BIT
glVertex2i(-20, );
200); //d glPushMatrix();
glEnd(); //guide();
} glTranslatef(10,-10,0);
kotak();
void timer (int value) glPopMatrix();
{ glFlush();
if (x<200) }
{
x += 10;
 void main (int argc, char glutInitWindowSize(640,
**argv) 480);
{
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();
}

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> glBegin(GL_QUADS);
#include <math.h>

#define PI 3.1415926535
glColor3f(1.,1.,1.);//putih
float sudut = 0;
int i,n; glVertex2f(5.,175.);
glVertex2f(5.,0.);
void lingkaran(int radius, glVertex2f(-5.,0.);
int jumlah_titik, int xtengah, glVertex2f(-
int ytengah) 5.,175.);
{ glEnd();
}
glBegin(GL_POLYGON);
void detik()
for
{
(i=0;i<=360;i++)
glBegin(GL_QUADS);
{
float
sudut=i*(2*PI/jumlah_titik); glColor3f(0.,1.,0.);
float
x=xtengah+radius*cos(sudut); glVertex2f(5.,200.);
float glVertex2f(5.,0.);
y=ytengah+radius*sin(sudut); glVertex2f(-5.,0.);
glVertex2f(-
glVertex2f(x,y); 5.,200.);
glEnd();
}
glColor3f(0., 1., 1.);
}
glEnd();
//titik jam
}
void angka(float jarak,
float x, float y)
//Jarum kecil
{
void kecil()
glPointSize(10);
{
glBegin(GL_POINTS);
glBegin(GL_QUADS);

glColor3f(0.,0.,0.);

glColor3f(1.,1.,0.);//kuning
for(n=0;n<360;n+=90)

glVertex2f(5.,125.);
glVertex2f(5.,0.);
glVertex2f(-5.,0.); glVertex2f(jarak*(float)sin(n*PI
glVertex2f(- /180.0)+x,jarak*(float)cos(n*PI/
5.,125.); 180.0)+y);
glEnd(); glEnd();
} }

//Jarum panjang // titik menit

void menit(float jarak,
void panjang() float x, float y)
{
 glPointSize(4);
glBegin(GL_POINTS);
glRotatef(sudut/720,0,0,1);
glColor3f(0.,0.,0.); kecil();
for(n=0;n<360;n+=6) glPopMatrix();
glColor3f(0,0,0);

glVertex2f(jarak*(float)sin(n*PI lingkaran(10,50,0,1);
/180.0)+x,jarak*(float)cos(n*PI/ glFlush();
180.0)+y); }
glEnd();
} void timer(int value)
{
void renderScene(void) sudut-=6;
{
glutPostRedisplay();

glClear(GL_COLOR_BUFFER_BIT);
//warna lingkaran glutTimerFunc(1000,timer,0);
glPushMatrix(); }

glColor3f(1.,0.,0.); void main (int argc, char

**argv)
lingkaran(260,100,0,0); {
angka(230.,0.,0.); glutInit(&argc, argv);
menit(230.,0.,0.);
glPopMatrix(); glutInitDisplayMode(GLUT_DEPTH |
//panah detik GLUT_SINGLE | GLUT_RGBA);
glPushMatrix();
glutInitWindowPosition(150,
glRotatef(sudut,0,0,1); 150);
detik(); glutInitWindowSize(640,
glPopMatrix(); 480);
//panah menit
glPushMatrix(); glutCreateWindow("ASISTENSI 3");
gluOrtho2D(-640.,640.,-
glRotatef(sudut/60,0,0,1); 320.,320.);
panjang();
glPopMatrix(); glutDisplayFunc(renderScene);
//panah jam glutTimerFunc(1,timer,0);
glPushMatrix(); 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>
void renderScene(void)
void bintang() {
{
glBegin(GL_POLYGON); glClear(GL_COLOR_BUFFER_BIT);
glVertex2f(0,0);//a //garis diagonal
glVertex2f(50,150);//b glPushMatrix();
glVertex2f(100,0);//c glRotatef(135,0,0,1);
glVertex2f(250,0);//d glColor3f(0,0.6,1);
glVertex2f(130,-100);//e glPopMatrix();
glVertex2f(200,-250);//f //kumpulan bintang
glVertex2f(50,-150);//g glPushMatrix();
glVertex2f(-100,-250);//h glTranslatef(-100,-190,0);
glVertex2f(-25,-100);//i glRotatef(180,0,0,1);
glVertex2f(-175,0); //j glScalef(1.4,1.4,0);
glEnd();
glFlush();
glColor3f(0.987,0.123,0.567);
}
//pink
 bintang();
glPopMatrix();
glFlush();
glPushMatrix();
glScalef(1.1,1.1,0);
glTranslatef(200,300,0);
glColor3f(1,1,0);
bintang();
glPopMatrix();
glPushMatrix();
glRotatef(45,0,0,1);
glScalef(0.1,0.1,0);
glTranslatef(3000,20,0);
glColor3f(1.,0.,1.);
bintang();
glPopMatrix();
glPushMatrix();
glRotatef(60,0,0,1);
glScalef(0.3,0.3,0);
glTranslatef(999,99,0);
glColor3f(0.,1.,0.);
bintang();
glPopMatrix();
glPushMatrix();
glRotatef(10,0,0,1);
glScalef(-0.5,-0.5,0);
glTranslatef(444,333,0);
glColor3f(0,0,1);
bintang();
glPopMatrix();
glPushMatrix();
glTranslatef(-320,-320,0); **argv)
glRotatef(-30,0,0,1);
glScalef(0.6,0.6,0);
glColor3f(0,1,1);
bintang(); glutInitDisplayMode(GLUT_DEPT
glPopMatrix(); H | GLUT_SINGLE | GLUT_RGBA);
glPopMatrix();
glPushMatrix();
glRotatef(90,0,0,1);
glScalef(0.4,-0.4,0);
glTranslatef(100,90,0);
glColor3f(0.,1.,1.);
bintang();
glPopMatrix();
glPushMatrix();
glTranslatef(100,90,0);
glRotatef(90,30,0,1);
glScalef(0.2,-0.5,0);
glColor3f(1,1,0);
bintang();
glPopMatrix();
glPushMatrix();
glTranslatef(-300,-90,0);
glRotatef(180,0,0,1);
glScalef(0.3,0.3,0);
glColor3f(1.,0.,0.);
bintang();
glPopMatrix();
glFlush();
}
void main (int argc, char
{
glutInit(&argc, argv);

glPushMatrix();
glutInitWindowPosition(150,
glRotatef(90,0,0,1);
150);
glScalef(0.1212,0.21,0);
glutInitWindowSize(640,
glTranslatef(-999,120,0);
480);
glColor3f(0,1,0);
bintang();
glPopMatrix(); glutCreateWindow("ASISTENSI
4");
glPushMatrix(); gluOrtho2D(-640.,640.,-
glRotatef(180,1,1,0); 320.,320.);
glScalef(-0.1,-0.1,0);
glTranslatef(10,2222,0); glutDisplayFunc(renderScene);
glColor3f(0.,0.,1.); glutMainLoop();
bintang(); }

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.