LAPORAN PRAKTIKUM

TRANSFORMASI 3 DIMENSI

Nama Praktikan : Muzammil

Nim

: 1457301081

Kelas

: TI 2-4

POLITEKNIK NEGERI LHOKSEUMAWE

PROGARM STUDI TEKNIK INFORMATIKA
2015/2016

LEMBARAN PENGESAHAN

Nomor

: 05/GK/2.4/IT/2016

Nama Praktikum

: Grafika Komputer

Judul Praktikum

Tanggal Praktikum

: 29 Maret 2016

Tanggal Penyerahan Laporan

: 11 April 2016

Nama Praktikan

: Muzammil

NIM

: 1457301081

Prodi/Kelas

: Teknik Informatika/TI 2-4

Nilai

Keterangan

Buket Rata, 11 April 2016

Dosen Pembimbing,

Fachri Yanuar, SST, MT.

NIP.

DAFTAR ISI

LEMBARAN PENGESAHAN ............................................................................................................ i

DAFTAR ISI ....................................................................................................................................... ii
DAFTAR GAMBAR ..........................................................................................................................iii
TRANSFORMASI 3 DIMENSI ......................................................................................................... 1
5. 1.

Tujuan Praktikum ................................................................................................................ 1

5. 2.

Dasar Teori .......................................................................................................................... 1

5. 3.

Percobaan ............................................................................................................................ 2

5.3.1.

Percobaan 1 ................................................................................................................. 2

5.3.2.

Percobaan 2 ................................................................................................................. 8

5.3.3.

Percobaan 3 ............................................................................................................... 10

5.3.4.

Percobaan 4 ............................................................................................................... 12

5.3.5.

Percobaan 5 ............................................................................................................... 14

5.3.6.

Percobaan 6 ............................................................................................................... 16

5. 4.

Tugas Program .................................................................................................................. 18

5. 5.

Analisa Program ................................................................................................................ 32

5. 6.

Kesimpulan ....................................................................................................................... 35

DAFTAR PUSTAKA ....................................................................................................................... 36

ii

DAFTAR GAMBAR
Gambar 5.1 hasil output program percobaan 1 ...................................................................................7
Gambar 5.2 hasil output program percobaan 2 ...................................................................................9
Gambar 5.3 hasil output program percobaan 3 .................................................................................11
Gambar 5.4 hasil output program percobaan 4 .................................................................................13
Gambar 5.5 hasil output program percobaan 5 .................................................................................15
Gambar 5.6 hasil output program percobaan 6 .................................................................................17

Gambar 5.7 hasil output tugas kubus translasi .................................................................... 19

Gambar 5.8 hasil output tugas kubus rotasi sumbu z .......................................................... 21
Gambar 5.9 hasil output tugas kubus rotasi sumbu x .......................................................... 23
Gambar 5.10 hasil output tugas kubus rotasi sumbu y ........................................................ 25
Gambar 5.11 hasil output tugas kubus scalling ................................................................... 27
Gambar 5.12 hasil output tugas kubus refleksi ................................................................... 29
Gambar 5.13 hasil output tugas rumah 3D .......................................................................... 31

iii

LAPORAN 5
TRANSFORMASI 3 DIMENSI
5. 1.

Tujuan Praktikum

Tujuan dari praktikum transformasi 3 dimensi adalah sebagai berikut:

5. 2.

Mengenal dan mengerti prinsip-prinsip transformasi 3D dalam grafika koputer

Dapat mengimplementasikan transformasi 3D sebagai gerakan obyek grafik
Dapat mengimplementasikan komposisi atau gabungan beberapa transformasi 3D
sebagai gerakan obyek grafik yang lebih baik
Dasar Teori

Transformasi 3D adalah suatu teknik pemindahan atau mengubah nilai pada posisi
obyek (titik) dalam sistem koordinat 3 dimensi. Untuk dapat melakukan peimindahan
maka digunakan dua variabel dasar di dalam matematika yaitu vektor posisi dan matrik
tranformasi.
Bila obyek gambar ditansformasikan, hal yang harus dilakukan adalah:
1)
2)
3)
4)

Merubah struktur dan titik 3D ke struktur data vektor 3D

Menghitung transformasi
Mengubah struktur data vektor 3D ke struktur data titik 3D
Mengambar obyek

Macam-macam transformasi 3D yang dapat digunakan untuk keperluan grafika

komputer adalah:

Translasi
Scalling
Rotasi terhadap sumbu X
Rotasi terhadap sumbu Y
Rotasi terhadap sumbu Z

Translasi merupakan bentuk transformasi yang memindahkan posisi suatu objek, baik
pada sumbu x, sumbu y, atau sumbu z. Rotasi merupakan bentuk transformasi yang
digunakan untuk memutar posisisuatu benda. Skalasi merupakan bentuk transformasi
yang dapat mengubah ukuran (besar-kecil) suatu objek.

5. 3. Percobaan
5.3.1. Percobaan 1
#include <stdio.h>
#include <math.h>
#include <GL/glut.h>
typedef struct {
float m[4][4];
} matrix3D_t;
typedef struct {
float v[4];
} vector3D_t;
typedef struct{
float x,y,z;
} point3D_t;
typedef struct{
float x,y;
} point2D_t;
typedef struct {
float r,g,b;
} color_t;
matrix3D_t createIdentity(void){
matrix3D_t u;
int i,j;
for (i=0; i<4; i++) {
for(j=0; j<4; j++) u.m[i][j]=0.;
u.m[i][i]=1.;
}
return u;
}
matrix3D_t operator * (matrix3D_t a,matrix3D_t b){
matrix3D_t c;
int i,j,k;
for (i=0;i<4;i++) for (j=0;j<4;j++) {
c.m[i][j]=0;
for (k=0;k<4;k++) c.m[i][j]+=a.m[i][k]*b.m[k][j];
}
return c;
}
vector3D_t operator * (matrix3D_t a, vector3D_t b){
vector3D_t c;
int i,j;
for (i=0; i<4; i++) {
c.v[i]=0;
for (j=0;j<4;j++) c.v[i]+=a.m[i][j]*b.v[j];
}
return c;
}

matrix3D_t translationMTX(float dx, float dy, float dz){

matrix3D_t trans=createIdentity();
trans.m[0][3]=dx;
trans.m[1][3]=dy;
trans.m[2][3]=dz;
return trans;
}
matrix3D_t rotationXMTX(float theta){
matrix3D_t rotate=createIdentity();
float cs=cos(theta);
float sn=sin(theta);
rotate.m[1][1]=cs; rotate.m[1][2]=-sn;
rotate.m[2][1]=sn; rotate.m[2][2]=cs;
return rotate;
}
matrix3D_t rotationYMTX(float theta){
matrix3D_t rotate=createIdentity();
float cs=cos (theta);
float sn=sin (theta);
rotate.m[0][0] =cs; rotate.m[0][2] =sn;
rotate.m[2][0] =-sn; rotate.m[2][2] =cs;
return rotate;
}
matrix3D_t rotationZMTX(float theta){
matrix3D_t rotate=createIdentity();
float cs=cos (theta);
float sn=sin (theta);
rotate.m[0][0] =cs; rotate.m[0][1] =-sn;
rotate.m[1][0] =sn; rotate.m[1][1] =cs;
return rotate;
}
matrix3D_t scalingMTX(float factorx, float factory, float factorz){
matrix3D_t scale=createIdentity();
scale.m[0][0] =factorx;
scale.m[1][1] =factory;
scale.m[2][2] =factorz;
return scale;
}
point2D_t Vector2Point2D(vector3D_t vec){
point2D_t pnt;
pnt.x=vec.v[0];
pnt.y=vec.v[1];
return pnt;
}
point3D_t Vector2Point3D(vector3D_t vec){
point3D_t pnt;
pnt.x=vec.v[0];
pnt.y=vec.v[1];
pnt.y=vec.v[2];
return pnt;
}

vector3D_t Point2Vector(point3D_t pnt){

vector3D_t vec;
vec.v[0]=pnt.x;
vec.v[1]=pnt.y;
vec.v[2]=pnt.z;
vec.v[3]=1.;
return vec;
}
void setColor(float red, float green, float blue){
glColor3f(red, green, blue);
}
void setColor(color_t col){
glColor3f(col.r, col.g, col.b);
}
void drawDot(float x, float y){
glBegin(GL_POINTS);
glVertex2f(x,y);
glEnd();
}
void drawLine(float x1, float y1, float x2, float y2){
glBegin(GL_LINES);
glVertex2f(x1,y1);
glVertex2f(x2,y2);
glEnd();
}
void drawLine(point2D_t p1, point2D_t p2){
drawLine(p1.x,p1.y,p2.x,p2.y);
}
void drawPolyline(point2D_t pnt[], int n){
int i;
glBegin(GL_LINE_STRIP);
for (i=0; i<n; i++){
glVertex2f(pnt[i].x, pnt[i].y);
}
glEnd();
}
void drawPolygon(point2D_t pnt[], int n){
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i<n; i++){
glVertex2f(pnt[i].x, pnt[i].y);
}glEnd();
}
void fillPolygon(point2D_t pnt[], int n, color_t color){
int i;
setColor(color);
glBegin(GL_POLYGON);
for(i=0; i<n; i++){
glVertex2f(pnt[i].x, pnt[i].y);
}glEnd();
}

void gradatePolygon(point2D_t pnt[], color_t col[], int num){

int i;
glBegin(GL_POLYGON);
for(i=0; i<num; i++){
setColor(col[i]);
glVertex2f(pnt[i].x, pnt[i].y);
}
glEnd();
}
void userdraw(void);
void display(void){
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
void drawcharX(float x, float y){
drawLine (x,y,x+10,y+12);
drawLine(x,y+12,x+10,y);
}
void drawcharY(float x, float y){
drawLine (x+5,y,x+5,y+7);
drawLine(x,y+12,x+5,y+7);
drawLine(x+10,y+12,x+5,y+7);
}
void drawcharZ(float x, float y){
drawLine (x,y+12,x+10,y+12);
drawLine(x+10,y+12,x,y);
drawLine(x,y,x+10,y);
}
void drawAxes(matrix3D_t view){
#define HALFAXIS 220
#define HALFAXIS1 (HALFAXIS-10)
point3D_t axes[14]={
{-HALFAXIS,0,0},{HALFAXIS,0,0},{HALFAXIS1,5,0},
{HALFAXIS1,0,0},{0,0,0},{0,-HALFAXIS,0},
{0,HALFAXIS,0},{0,HALFAXIS1,5},{0,HALFAXIS1,0},{0,0,0},
{0,0,-HALFAXIS},{0,0,HALFAXIS},{5,0,HALFAXIS1},{0,0,HALFAXIS1}};
vector3D_t vec[14];
point2D_t buff[14];
int i;
for (i=0; i<14; i++){
vec[i]=Point2Vector(axes[i]);
vec[i]=view*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolyline(buff,14);
drawcharX(buff[1].x,buff[1].y);
drawcharY(buff[6].x,buff[6].y);
drawcharZ(buff[11].x-14,buff[11].y);
}

void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[10]={
{10,100,0},{10,10,0},{30,10,0},{30,40,0},{60,40,0},
{60,60,0},{30,60,0},{30,80,0},{70,80,0},{70,100,0}
};
vector3D_t vec[10];
matrix3D_t trans,mat;
point2D_t buff[10];
int i, loop;
setColor(0,0,0);
setColor(0.4,0.7,1.0);
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
glutSetWindowTitle("Translasi 3D");
trans=translationMTX(62,22,0);
mat=tilting*trans;
for(loop=0; loop<4; loop++){
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
mat=mat*trans;
}
tick+=0.1;
}
int main(int argc, char **argv){
glutInit(&argc,argv);
glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGB );
glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
glutCreateWindow ("Transformasi 3D");
glClearColor(1.0,1.0,1.0,0.0);
gluOrtho2D(-320., 320., -240.0, 240.0);
// Define the dimensions of the Orthographic Viewing Volume
glutIdleFunc(display); // idle event call back
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Hasil output program percobaan 1 sebagai berikut:

Gambar 5.1 hasil output program percobaan 1

5.3.2.

Percobaan 2
void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[10]={
{10,100,0},{10,10,0},{30,10,0},{30,40,0},{60,40,0},
{60,60,0},{30,60,0},{30,80,0},{70,80,0},{70,100,0}
};
vector3D_t vec[10];
matrix3D_t mat,rot;
point2D_t buff[10];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
glutSetWindowTitle("Rotasi Sb Z 3D");
rot=rotationZMTX(0.75);
mat=tilting*rot;
for(loop=0; loop<4; loop++){
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
mat=mat*rot;
}
tick+=0.1;
}

Hasil output program percobaan 2 sebagai berikut:

Gambar 5.2 hasil output program percobaan 2

5.3.3.

Percobaan 3
void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[10]={
{10,100,0},{10,10,0},{30,10,0},{30,40,0},{60,40,0},
{60,60,0},{30,60,0},{30,80,0},{70,80,0},{70,100,0}
};
vector3D_t vec[10];
matrix3D_t mat,rot;
point2D_t buff[10];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
glutSetWindowTitle("Rotasi sumbu x 3D");
rot=rotationXMTX(0.75);
mat=tilting*rot;
for(loop=0; loop<4; loop++){
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
mat=mat*rot;
}
tick+=0.1;
}

10

Hasil output program percobaan 3 sebagai berikut:

Gambar 5.3 hasil output program percobaan 3

11

5.3.4.

Percobaan 4
void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[10]={
{10,100,0},{10,10,0},{30,10,0},{30,40,0},{60,40,0},
{60,60,0},{30,60,0},{30,80,0},{70,80,0},{70,100,0}
};
vector3D_t vec[10];
matrix3D_t mat,rot;
point2D_t buff[10];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
glutSetWindowTitle("Rotasi sumbu Y 3D");
rot=rotationYMTX(0.75);
mat=tilting*rot;
for(loop=0; loop<4; loop++){
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
mat=mat*rot;
}
tick+=0.1;
}

12

Hasil output program percobaan 4 sebagai berikut:

Gambar 5.4 hasil output program percobaan 4

13

5.3.5.

Percobaan 5
void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[10]={
{10,100,0},{10,10,0},{30,10,0},{30,40,0},{60,40,0},
{60,60,0},{30,60,0},{30,80,0},{70,80,0},{70,100,0}
};
vector3D_t vec[10];
matrix3D_t mat,scale;
point2D_t buff[10];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
glutSetWindowTitle("Scalling 3D");
scale=scalingMTX(1.2,1.2,1);
mat=tilting*scale;
for(loop=0; loop<4; loop++){
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
mat=mat*scale;
}
tick+=0.1;
}

14

Hasil output program percobaan 5 sebagai berikut:

Gambar 5.5 hasil output program percobaan 5

15

5.3.6.

Percobaan 6
void userdraw(void){
static float tick=0; float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0); drawAxes(tilting);
point3D_t ef[10]={
{10,100,0},{10,10,0},{30,10,0},{30,40,0},{60,40,0},
{60,60,0},{30,60,0},{30,80,0},{70,80,0},{70,100,0}
};
vector3D_t vec[10];
matrix3D_t mat,refxaxis,refyaxis,reforg;
point2D_t buff[10];
int i, loop; setColor(0.4,0.7,1.0);
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
glutSetWindowTitle("Pencerminan 3D");
refxaxis=scalingMTX(1.,-1.,1);
refyaxis=scalingMTX(-1.,1.,1);
reforg=scalingMTX(-1.,-1.,1);
mat=tilting*refxaxis;
for(loop=0; loop<4; loop++){
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
mat=tilting*refyaxis;
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
mat=tilting*reforg;
for(i=0; i<10; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,10);
}
tick+=0.1;
}

16

Hasil output program percobaan 6 sebagai berikut:

Gambar 5.6 hasil output program percobaan 6

17

5. 4.

Tugas Program

Soal:
1) Kembangakan program tugas kubus pada praktikum 4 dengan melakukan translasi,
rotasi sumbu x, rotasi sumbu y, rotasi sumbu z, scalling dan refleksi
2) Buatlah program menggambar rumah 3D yang berputar terhadap sumbu pusat
Jawab:
1) Kubus translasi
void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[18]={
{0,0,0},{0,40,0},{0,40,40},{0,0,40}, {0,0,0},{40,0,0},{40,40,0},{0,40,0},
{0,0,0},{40,0,0},{40,0,40},{0,0,40}, {0,40,40},{40,40,40},{40,40,0},{40,40,40},
{40,0,40},{40,0,0}
};
vector3D_t vec[18];
matrix3D_t trans,mat;
point2D_t buff[18];
int i, loop;
setColor(0,0,0);
setColor(0.4,0.7,1.0);
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
glutSetWindowTitle("Translasi 3D");
trans=translationMTX(70,30,0);
mat=tilting*trans;
for(loop=0; loop<4; loop++){
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
mat=mat*trans;
}
tick+=0.1;

Hasil output program tugas translasi sebagai berikut:

18

Gambar 5.7 hasil output tugas kubus translasi

19

Kubus rotasi pada sumbu z

void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[18]={
{0+40,0+40,0},{0+40,40+40,0},{0+40,40+40,40},{0+40,0+40,40},
{0+40,0+40,0},{40+40,0+40,0},{40+40,40+40,0},{0+40,40+40,0},
{0+40,0+40,0},{40+40,0+40,0},{40+40,0+40,40},{0+40,0+40,40},
{0+40,40+40,40},{40+40,40+40,40},{40+40,40+40,0},{40+40,40+40,40},
{40+40,0+40,40},{40+40,0+40,0}
};
vector3D_t vec[18];
matrix3D_t mat,rot;
point2D_t buff[18];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
glutSetWindowTitle("Rotasi Sb Z 3D");
rot=rotationZMTX(0.75);
mat=tilting*rot;
for(loop=0; loop<4; loop++){
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
mat=mat*rot;
}
tick+=0.1;
}

20

Hasil output tugas kubus rotasi sumbu z sebagai berikut:

Gambar 5.8 hasil output tugas kubus rotasi sumbu z

21

Kubus rotasi pada sumbu x

void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[18]={
{0,0+40,0+40},{0,40+40,0+40},{0,40+40,40+40},{0,0+40,40+40},
{0,0+40,0+40},{40,0+40,0+40},{40,40+40,0+40},{0,40+40,0+40},
{0,0+40,0+40},{40,0+40,0+40},{40,0+40,40+40},{0,0+40,40+40},
{0,40+40,40+40},{40,40+40,40+40},{40,40+40,0+40},{40,40+40,40+40},
{40,0+40,40+40},{40,0+40,0+40}
};
vector3D_t vec[18];
matrix3D_t mat,rot;
point2D_t buff[18];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
glutSetWindowTitle("Rotasi sumbu x 3D");
rot=rotationXMTX(0.75);
mat=tilting*rot;
for(loop=0; loop<4; loop++){
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
mat=mat*rot;
}
tick+=0.1;
}

22

Hasil output tugas kubus rotasi sumbu x sebagai berikut:

Gambar 5.9 hasil output tugas kubus rotasi sumbu x

23

Kubus rotasi pada sumbu y

void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[18]={
{0+40,0,0+40},{0+40,40,0+40},{0+40,40,40+40},{0+40,0,40+40},
{0+40,0,0+40},{40+40,0,0+40},{40+40,40,0+40},{0+40,40,0+40},
{0+40,0,0+40},{40+40,0,0+40},{40+40,0,40+40},{0+40,0,40+40},
{0+40,40,40+40},{40+40,40,40+40},{40+40,40,0+40},{40+40,40,40+40},
{40+40,0,40+40},{40+40,0,0+40}
};
vector3D_t vec[18];
matrix3D_t mat,rot;
point2D_t buff[18];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
glutSetWindowTitle("Rotasi sumbu Y 3D");
rot=rotationYMTX(0.75);
mat=tilting*rot;
for(loop=0; loop<4; loop++){
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
mat=mat*rot;
}
tick+=0.1;
}

24

Hasil output tugas kubus rotasi sumbu x sebagai berikut:

Gambar 5.10 hasil output tugas kubus rotasi sumbu y

25

kubus scalling
void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[18]={
{0,0,0},{0,40,0},{0,40,40},{0,0,40},
{0,0,0},{40,0,0},{40,40,0},{0,40,0},
{0,0,0},{40,0,0},{40,0,40},{0,0,40},
{0,40,40},{40,40,40},{40,40,0},{40,40,40},
{40,0,40},{40,0,0}
};
vector3D_t vec[18];
matrix3D_t mat,scale;
point2D_t buff[18];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
glutSetWindowTitle("Scalling 3D");
scale=scalingMTX(1.4,1.4,1);
mat=tilting*scale;
for(loop=0; loop<4; loop++){
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
mat=mat*scale;
}
tick+=0.1;
}

26

Hasil output tugas kubus scalling sebagai berikut:

Gambar 5.11 hasil output tugas kubus scalling

27

kubus refleksi
void userdraw(void){
static float tick=0; float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0); drawAxes(tilting);
point3D_t ef[18]={
{0+20,0+20,0},{0+20,40+20,0},{0+20,40+20,40},{0+20,0+20,40},
{0+20,0+20,0},{40+20,0+20,0},{40+20,40+20,0},{0+20,40+20,0},
{0+20,0+20,0},{40+20,0+20,0},{40+20,0+20,40},{0+20,0+20,40},
{0+20,40+20,40},{40+20,40+20,40},{40+20,40+20,0},{40+20,40+20,40},
{40+20,0+20,40},{40+20,0+20,0}
};
vector3D_t vec[18]; matrix3D_t mat,refxaxis,refyaxis,reforg;
point2D_t buff[18];
int i, loop; setColor(0.4,0.7,1.0);
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
glutSetWindowTitle("Pencerminan 3D");
refxaxis=scalingMTX(1.,-1.,1); refyaxis=scalingMTX(-1.,1.,1); reforg=scalingMTX(-1.,-1.,1);
mat=tilting*refxaxis;
for(loop=0; loop<4; loop++){
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18); mat=tilting*refyaxis;
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18); mat=tilting*reforg;
for(i=0; i<18; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,18);
}tick+=0.1;
}

28

Hasil output tugas kubus refleksi sebagai berikut:

Gambar 5.12 hasil output tugas kubus refleksi

29

2) Rumah 3D
void userdraw(void){
static float tick=0;
float theta=-0.5;
theta=0.1*sin(0.05*tick)-0.5;
matrix3D_t tilting=rotationXMTX(0.5)*rotationYMTX(theta);
setColor(0,0,0);
drawAxes(tilting);
point3D_t ef[28]={
{0+30,0,0+30},{0+30,50,0+30},{0+30,50,40+30},{0+30,0,40+30},
{0+30,0,0+30},{60+30,0,0+30},{60+30,50,0+30},{0+30,50,0+30},
{0+30,0,0+30},{60+30,0,0+30},{60+30,0,40+30},{0+30,0,40+30},
{0+30,50,40+30},{60+30,50,40+30},{60+30,50,0+30},{60+30,50,40+30},
{60+30,0,40+30},{40+30,0,40+30},{40+30,25,40+30},{20+30,25,40+30},
{20+30,0,40+30},{0+30,0,40+30},{0+30,50,40+30},{30+30,80,20+30},
{60+30,50,0+30},{60+30,50,40+30},{30+30,80,20+30},{0+30,50,0+30}
};
vector3D_t vec[28];
matrix3D_t mat,rot;
point2D_t buff[28];
int i, loop;
setColor(0.4,0.7,1.0);
for(i=0; i<28; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=tilting*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,28);
glutSetWindowTitle("Rotasi sumbu Y 3D");
rot=rotationYMTX(1.12);
mat=tilting*rot;
for(loop=0; loop<4; loop++){
for(i=0; i<28; i++){
vec[i]=Point2Vector(ef[i]);
vec[i]=mat*vec[i];
buff[i]=Vector2Point2D(vec[i]);
}
drawPolygon(buff,28);
mat=mat*rot;
}
tick+=0.1;
}

30

Hasil output tugas rumah 3D sebagai berikut:

Gambar 5.13 hasil output tugas rumah 3D

31

5. 5.

Analisa Program
typedef struct {
float m[4][4];
} matrix3D_t;

Fungsi dari struktur data matrik 3D

typedef struct {
float v[4];
} vector3D_t;

Fungsi dari struktur data vektor 3D

typedef struct{
float x,y,z;
} point3D_t;

Fungsi dari struktur data titik 3D

point2D_t Vector2Point2D(vector3D_t vec){
point2D_t pnt;
pnt.x=vec.v[0];
pnt.y=vec.v[1];
return pnt;
}

Fungsi dari vektor2point berguna untuk memindahkan tipe data vektor 3D menjadi tipe
data titik 2D
point3D_t Vector2Point3D(vector3D_t vec){
point3D_t pnt;
pnt.x=vec.v[0];
pnt.y=vec.v[1];
pnt.y=vec.v[2];
return pnt;
}

Fungsi dari vektor2point berguna untuk memindahkan tipe data vektor 3D menjadi tipe
data titik 3D
vector3D_t Point2Vector(point3D_t pnt){
vector3D_t vec;
vec.v[0]=pnt.x;
vec.v[1]=pnt.y;
vec.v[2]=pnt.z;
vec.v[3]=1.;
return vec;
}

Fungsi dari point2vektor berguna untuk memindahkan tipe data titik 3D menjadi tipe data
vektor 3D

32

matrix3D_t createIdentity(void){
matrix3D_t u;
int i,j;
for (i=0; i<4; i++) {
for(j=0; j<4; j++) u.m[i][j]=0.;
u.m[i][i]=1.;
}
return u;
}

Fungsi untuk membuat matrik identitas yang nilai diagonal utamanya sama dengan satu
dan lainnya nol
matrix3D_t translationMTX(float dx, float dy, float dz){
matrix3D_t trans=createIdentity();
trans.m[0][3]=dx;
trans.m[1][3]=dy;
trans.m[2][3]=dz;
return trans;
}

Fungsi untuk membuat matrik transformasi translasi

matrix3D_t rotationXMTX(float theta){
matrix3D_t rotate=createIdentity();
float cs=cos(theta);
float sn=sin(theta);
rotate.m[1][1]=cs; rotate.m[1][2]=-sn;
rotate.m[2][1]=sn; rotate.m[2][2]=cs;
return rotate;
}

Fungsi untuk membuat matirk transformasi rotasi pada sumbu x

matrix3D_t rotationYMTX(float theta){
matrix3D_t rotate=createIdentity();
float cs=cos (theta);
float sn=sin (theta);
rotate.m[0][0] =cs; rotate.m[0][2] =sn;
rotate.m[2][0] =-sn; rotate.m[2][2] =cs;
return rotate;
}

Fungsi untuk membuat matirk transformasi rotasi pada sumbu y

matrix3D_t rotationZMTX(float theta){
matrix3D_t rotate=createIdentity();
float cs=cos (theta);
float sn=sin (theta);
rotate.m[0][0] =cs; rotate.m[0][1] =-sn;
rotate.m[1][0] =sn; rotate.m[1][1] =cs;
return rotate;
}

Fungsi untuk membuat matirk transformasi rotasi pada sumbu z

33

matrix3D_t scalingMTX(float factorx, float factory, float factorz){

matrix3D_t scale=createIdentity();
scale.m[0][0] =factorx;
scale.m[1][1] =factory;
scale.m[2][2] =factorz;
return scale;
}

Fungsi untuk membuat matrik transformasi scalling

matrix3D_t operator * (matrix3D_t a,matrix3D_t b){
matrix3D_t c;
int i,j,k;
for (i=0;i<4;i++) for (j=0;j<4;j++) {
c.m[i][j]=0;
for (k=0;k<4;k++) c.m[i][j]+=a.m[i][k]*b.m[k][j];
}
return c;
}

Fungsi untuk melakukan perkalian matrik dengan matrik

vector3D_t operator * (matrix3D_t a, vector3D_t b){
vector3D_t c;
int i,j;
for (i=0; i<4; i++) {
c.v[i]=0;
for (j=0;j<4;j++) c.v[i]+=a.m[i][j]*b.v[j];
}
return c;
}

Fungsi untuk melakukan perkalian matrik dengan vektor

34

5. 6.

Kesimpulan

Berdasarkan pembahasan yang telah dikaji, maka dapat disimpulkan:

Matrik identitas adalah matrik yang nilai diagonal utamanya sama dengan satu dan
lainnya nol
Translasi adalah perpindahan obyek dari titik P ke titik P secara linier
Scalling adalah perpindahan obyek dari titik P ke titik P, dimana jarak P adalah m
kali titik P
Rotasi adalah perpindahan obyek dari titik P ke titik P, yang berupa perpindahan
berputar sebesar sudut
Perkalian matrik digunakan untuk operasional transformasi 3D dan untuk komposisi
(menggabungkan) transformasi

35

DAFTAR PUSTAKA
Atmika,

Chaca.
2012.
Transformasi
Geometrik
3
Dimensi.
http://chacaatmika.blogspot.co.id/2012/04/transformasi-geometrik-3dimensi.html (diakses : 2 april 2016)

Rosyida,

Binti.
2013.
Transformasi
Objek.
http://rosyidahbinti.blogspot.co.id/2013/04/transformasi-objek.html (diakses : 1 april 2016)

36