Laporan Grafik 3d.docx

LAPORAN PRAKTIKUM COMPUTER GRAPHIC & ANIMATION

Disusun Oleh: Nama

: Muhammad Fadhil

NIM

: 1790343007

Kelas

: 2.1

Program Studi

: Teknologi Rekayasa Komputer Jaringan

JURUSAN TEKNOLOGI INFORMASI DAN KOMPUTER POLITEKNIK NEGERI LHOKSEUMAWE

2018

LEMBAR PENGESAHAN

Nomor

: 04/ R15/ PCG&A/ TRKJ/ 2018

Judul Pratikum

: Grafik 3D

Tanggal Pratikum

: 3 Desember 2018

Tanggal Penyerahan : 10 Desember 2018 Nama Pratikum

: Muhammad Fadhil

NIM

: 1790343007

Kelas

: TRKJ 2.1

Prodi

: Teknologi Rekayasa Komputer Jaringan

Dosen Pembimbing

: Indrawati, SST, MT

Nilai

:

Buketrata,10 Desember 2018 Dosen Pembimbing

Indrawati, SST, MT

Mahasiswa

Muhammad Fadhil NIM: 1790343007

i

DAFTAR ISI LEMBAR PENGESAHAN ....................................................................... i DAFTAR ISI ............................................................................................. ii BAB I PENDAHULUAN ......................................................................... 1 A. Tujuan ..................................................................................... 1 B. Dasar Teori .............................................................................. 1 BAB II ISI ................................................................................................... A. Langkah Kerja ........................................................................... BAB III PENUTUP .................................................................................... A. Kesimpulan................................................................................ DAFTAR PUSTAKA .................................................................................

ii

BAB I PENDAHULUAN A. Tujuan 1. Mahasiswa Mampu Membuat Struktur Grafik 3D pada Visual Studio. 2. Mahasiswa Mampu Membuat Bentuk Bentuk Dan Pewarnaan Objek Grafik 3D pada Visual Studio. B. Dasar Teori 1. Sistem Koordinat 3 Dimensi Sistem koordinat 3D merupakan perluasan dari sistem koordinat 2D (yang terdiri dari sumbu x dan y), yaitu dengan menambahkan sumbu z yang menyatakan kedalaman objek terhadap pengamat. Terdapat dua macam sistem koordinat tiga dimensi, yaitu aturan tangan kiri dan aturan tangan kanan. Sistem koordinat tangan kanan dapat diilustrasikan dengan tiga buah jari tangan kanan yaitu ibu jari, jari telunjuk dan jari tengah dengan telapak tangan kanan menghadap ke pengamat. Ibu jari dianggap sebagai sumbu x, jari telunjuk sebagai sumbu y, dan jari tengah (yang mengarah ke pengamat) sebagai sumbu z. Sistem koordinat tangan kiri dapat diilustrasikan dengan tiga buah jari tangan kiri, dengan punggung telapak tangan kiri menghadap pengamat. Ibu jari sebagai sumbu x, jari telunjuk sebagai sumbu y, dan jari tengah (yang menjauhi pengamat) sebagai sumbu z.

Koordinat Aturan Tangan Kanan

1

Koordinat Aturan Tangan Kiri

Perbedaan keduanya berada pada pemberian nilai untuk sumbu z. Pada sistem koordinat aturan tangan kanan nilai z positif mengarah ke pengamat (mendekati). Sedangkan pada sistem koordinat aturan tangan kiri nilai z positif menjauhi pengamat. Dan sistem koordinat yang digunakan pada OpenGL adalah sistem koordinat aturan tangan kanan, yaitu nilai sumbu z positif arahnya mendekati pengamat. Sehinga terlihat seperti ini

2

2.1.1

Titik 3D

Titik 3D dinyatakan dengan: P(x,y,z) Jadi Struktur Titik3D adalah : typedef struct { float x; float y; float z; } point3D_t;

2.1.2

Vektor 3D

Vektor 3D dinyatakan dengan :

Jadi Struktur Vektor3D adalah : typedef struct { float v[4]; } vector3D_t;

2.1.3

Matrik 3D

Struktur Dari Matrik3D adalah : typedef struct { float m[4] [4]; } matrix3D_t;

3

2.1 Objek 3 Dimensi Obyek3-D adalah sekumpulan titik-titik 3-D (x,y,z) yang membentuk luasan-luasan ( face ) yang digabungkan menjadi satu kesatuan. Face adalah gabungan titik-titik yang membentuk luasan tertentu atau sering dinamakan dengan sisi

Implementasi Definisi Dari Struktur Faces : typedefstruct{ int NumberofVertices; short int pnt[32]; } face_t



NumberofVertices menyatakan jumlah titik pada sebuah face.



pnt[32] menyatakan nomor-nomor titik yang digunakan untuk membentuk face, dengan maksimum 32 titik

4

Implementasi Definisi Dari Struktur Obyek3D : typedefstruct{ intNumberofVertices; point3D_t pnt[100]; intNumberofFaces; face_t fc[32]; } object3D_t_t

  

NumberofVertices menyatakan jumlah titik yang membentuk obyek. pnt[100] menyatakan titik-titik yang membentuk face, dengan maksimum100 titik NumberofFaces menyatakan jumlah face yang membentuk obyek Fc[32] menyatakan face-face yang membentuk obyek.

  Contoh Pernyataan Obyek Limas Segi Empat :

Titik-titik yang membentuk obyek: Titik 0 -> (0,150,0) Titik 1 -> (100,0,0) Titik 2 -> (0,0,100) Titik 3 -> (-100,0,0) Titik 4 -> (0,0,-100) Face yang membentuk obyek: Face 0 -> 0,2,1 Face 1 -> 0,3,2 Face 2 -> 0,4,3 Face 3 -> 0,1,4 Face 4 -> 1,2,3,4

Implementasi Pernyataan Obyek3 Dimensi : object3D_t prisma={5, {{0,100,0},{100,0,0},{0,0,100}, {100,0,0},{00,-100}}, 5, {{3,{0,1,2}},{3,{0,2,3}}, {3,{0,3,4}},{3,{0,4,1}}, {4,{1,4,3,2}}}}; 5

2.2 Cara Menggambar Objek 3 Dimensi • Obyek3 Dimens iterdiri dari titik-titik dan face-face. • Penggambaran dilakukan pada setiap face menggunakan polygon. • Polygon dibentuk dari titik-titik yang terdapat pada sebuah face. •Titik-titik dinyatakan dalam struktur3D, sedangkan layer computer dalam struktur 2D. Sehingga diperlukan konversi dari3D menjadi2D. • Untuk menggambar obyek3D, untuk setiap face perlu dilakukan pengubahan titik3D menjadi vektor3D, agar mudah dilakukan transformasi. • Setelah proses pengolahan vektor, maka bentuk vektor3D menjadi2D. • SumbuZ adalah sumbu yang searah dengan garis mata, sehingga perlu transformasi untuk menampilkan sumbu ini. Untuk hal ini perlu dilakukan rotasi sumbu. • Dalam konversi arahZ tidak diambil 2.3.1

Konversi Vektor 3D Menjadi Titik2D

Implementasi Konversi vektor 3D menjadi titik2D : point2D_t Vector2Point2D(vector3D_t vec) { point2D_t pnt; pnt.x=vec.v[0]; pnt.y=vec.v[1]; return pnt;

}

6

2.3.2

Konversi Titik 3D Menjadi Vektor3D

Implementasi Konversi titik3D menjadi vektor3D : 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; }

2.3.3

Implementasi Cara Menggambar Objek 3D

mat=tilting; for(i=0;i<prisma.NumberofVertices;i++) { vec[i]=Point2Vector(prisma.pnt[i]); vec[i]=mat*vec[i]; } for(i=0;i<prisma.NumberofFaces;i++) { for(j=0;j<prisma.fc[i].NumberofVertices;j++) vecbuff[j]=vec[prisma.fc[i].pnt[j]]; for(j=0;j<prisma.fc[i].NumberofVertices;j++) titik2D[j]=Vector2Point2D(vec[prisma.fc[i].pnt[j]]); drawPolygon(titik2D,prisma.fc[i].NumberofVertices); }

Deklarasi mat sebagai matrik tilting menyatakan bahwa obyek yang Digambar mengikuti pergerakan sumbu koordinat ( tilting ). Setiap titik diubah menjadi vector dengan memperhatikan matrik transformasi yang dinyatakan dalam mat. Untuk setiap face pada obyek3D: (1)Ambil vector dari setiap titik pada face tersebut (2)Konversikan setiap vektor3D menjadi titik2D (3)Dari hasil konversi digambarkan polygon 7

2.3.4

Implementasi Tilting float theta=0.5; matrix3D_t tilting=rotationXMTX(theta)*rotationYMTX(-theta);

Tilting adalah matrik rotasi dari sumbu koordinat dan semua obyek yang digambar didalamnya. Dalam deklarasi ini, matrik tilting adalah rotasi terhadap sumbuY sebesar -0.5rad dan rotasi terhadap sumbuX sebesar 0.5rad.

2.3 Visible dan Invisible 

Visible dan invisible menyatakan apakah suatu face terlihat(visible) atau tidak terlihat (invisible)



Pada obyek3D tidak semua face terlihat, karena terdapat face-face yang berada di bagian belakang dan terhalang oleh face yang lainnya.



Untuk menyatakan face visible dan invisible digunakan vector normal pada face tersebut.



Suatu face visible bila arah z pada vektor normal positif, dan invisible bila arah z pada vector normalnya negative

8

2.4.1 Vektor Normal Vektor normal adalah vektor yang arahnya tegak lurus dengan luasan suatu face. Vektor normal adalah hasil perkalian silang vektor (crossproduct) dari vektor vektor yang ada pada luasan face

2.4.2 Perkalian Silang ( Cross Product ) Perkalian silang(cross product) dari vektor a & b : a = (ax,ay,az) dan b =(bx,by,bz) didefinisikan dengan :

9

2.4.3 ImplementasiCross-Product vector3D_t operator ^ (vector3D_t a, vector3D_t b) { vector3D_t c;//c=a*b c.v[0]=a.v[1]*b.v[2]-a.v[2]*b.v[1]; c.v[1]=a.v[2]*b.v[0]-a.v[0]*b.v[2]; c.v[2]=a.v[0]*b.v[1]-a.v[1]*b.v[0]; c.v[3]=1.; return c; }

Cross product disimbolkan dengan operator ^ a=(ax,ay,az) diubah sesuai

struktur

b=(bx,by,bz)

data diubah

dari sesuai

vektor3D

menjadi(a.v[0],a.v[1],a.v[2])

struktur

data

dari

vektor3D

menjadi(b.v[0],b.v[1],b.v[2])

2.4.4 Implementasi Visible dan Invisible 

Untuk mengimplementasikan face visible dan invisible maka dilakukan penggambaran dua kali



Pertama Digambar dulu face-face yang invisible (NormalVector.v[2]<0)



Kedua Digambar face-face yang visible (NormalVector.v[2]>0)

10

BAB II ISI A. LANGKAH KERJA a) Program 1 #include <stdio.h> #include <stdlib.h> #include #include <math.h> typedef struct { float m[4][4]; } matrix3D_t; typedef struct { float v[4]; } vector3D_t; typedef struct { float x; float y; float z; } point3D_t; typedef struct { float x; float y; } point2D_t; typedef struct { float r; float g; float b; } color_t; //matrices and vectors 3D ver 2 // 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; } //Perkalian matrik dengan matrik matrix3D_t operator * (matrix3D_t a, matrix3D_t b) { matrix3D_t c; //c=a*b 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; }

11

//Perkalian matrik dengan vector, hasilnya vektor vector3D_t operator * (matrix3D_t a, vector3D_t b) { vector3D_t c; //c=a*b 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; }

12

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.z = 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; } //inner product(dot product) of homogeneous vector float operator * (vector3D_t a, vector3D_t b) { float c;//c=a*b int i; c = 0; for (i = 0; i<3; i++) { c += a.v[i] * b.v[i]; } return c; } //outer product (cross product) of homogenous vector // i j k // a0 a1 a2 // b0 b1 b2 vector3D_t operator ^ (vector3D_t a, vector3D_t b) { vector3D_t c;//c=a*b c.v[0] = a.v[1] * b.v[2] - a.v[2] * b.v[1]; c.v[1] = a.v[2] * b.v[0] - a.v[0] * b.v[2]; c.v[2] = a.v[0] * b.v[1] - a.v[1] * b.v[0]; c.v[3] = 1.; return c; }

13

vector3D_t operator - (vector3D_t v1, vector3D_t v0) { vector3D_t c;//c=v1-v0 c.v[0] = v1.v[0] - v0.v[0]; c.v[1] = v1.v[1] - v0.v[1]; c.v[2] = v1.v[2] - v0.v[2]; c.v[3] = 1.; return c; } vector3D_t operator - (vector3D_t v) { vector3D_t c;//c=-v c.v[0] = -v.v[0]; c.v[1] = -v.v[1]; c.v[2] = -v.v[2]; c.v[3] = 1.; return c; } vector3D_t operator * (float r, vector3D_t b) { vector3D_t c; //c=r*b int i; for (i = 0; i<3; i++) { c.v[i] = r*b.v[i]; } c.v[3] = 1.; return c; } vector3D_t operator * (vector3D_t b, float r) { vector3D_t c; //c=r*b int i; for (i = 0; i<3; i++) { c.v[i] = r*b.v[i]; } c.v[3] = 1.; return c; } float funcPositive(float x) { if (0.<x) return x; else return 0.; } //x to yth power float power(float x, float y) { //ln z = y ln x if (x == 0.) return 0; return exp(y*log(x)); }

z = exp (y ln x)

14

color_t operator + (color_t c1, color_t c2) { color_t col; col.r = c1.r + c2.r; col.g = c1.g + c2.g; col.b = c1.b + c2.b; return col; } color_t operator * (float r, color_t c) { color_t col; col.r = r*c.r; col.g = r*c.g; col.b = r*c.b; return col; } //End of matrices and vectors 3D ver 2 // //OpenGL drawShape Functions ver 1 // 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); } //n: number of points void drawPolyline(point2D_t pnt[], int n) { int i; glBegin(GL_LINE_STRIP); for (i = 0; i
15

//n: number of vertices void drawPolygon(point2D_t pnt[], int n) { int i; glBegin(GL_LINE_LOOP); for (i = 0; i
16

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); } typedef struct { int NumberofVertices; //in the face short int pnt[32]; } face_t; typedef struct { int NumberofVertices; //of the object point3D_t pnt[100]; int NumberofFaces; //of the object face_t fc[32]; } object3D_t; void userdraw(void) { static int tick = 0; float theta = 0.5; matrix3D_t tilting = rotationXMTX(theta)*rotationYMTX(-theta); setColor(0, 0, 0); drawAxes(tilting); object3D_t prisma = {5,//jumlah vertek pada prisma {{0,100,0},{100,0,0},{0,0,100},{ -100,0,0 },{ 0,0,-100 }}, //daftar koordinat vertek prisma 5, //jumlah sisi prisma {{3,{ 0,1,2 }},{ 3,{0,2,3 } },{ 3,{ 0,3,4 } },{ 3,{ 0,4,1 } }, { 4,{ 1,4,3,2 } }} //setiap sisi terdiri dari 3 vertek dan satu 4 //vertek dan masing-masing vertek dinomeri dan dibaca //sesuai urutan yang berlawan arah jarum jam }; vector3D_t vec[32]; point2D_t buff[32];

17

matrix3D_t rot, mat; int i, j; setColor(0, 1, 1); rot = rotationYMTX(0.02*tick); mat = tilting*rot; for (i = 0; i<prisma.NumberofVertices; i++) { vec[i] = Point2Vector(prisma.pnt[i]); vec[i] = mat*vec[i]; } for (i = 0; i<prisma.NumberofFaces; i++) { for (j = 0; j<prisma.fc[i].NumberofVertices; j++) { buff[j] = Vector2Point2D(vec[prisma.fc[i].pnt[j]]); } drawPolygon(buff, prisma.fc[i].NumberofVertices); } tick++; } int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowPosition(100, 100); glutInitWindowSize(640, 480); glutCreateWindow("Prisma"); 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 :

18

Analisa : Dengan coding dari program di atas kita akan membuat bentuk dari prisma face/sisinya,yang dimana objek prisma dapat berputar 360 derajat. Pada hasil program tersebut juga dapat terlihat sistem koordinat dari ruang prisma tersebut, sehingga memudahkan untuk melihat face/sisinya.Perputaran dari objek berikut ini merupakan implementasi dari tilting. b) Program 2. #include #include #include #include

<stdio.h> <stdlib.h> <math.h>

typedef struct { float m[4][4]; } matrix3D_t; typedef struct { float v[4]; } vector3D_t; typedef struct { float x; float y; float z; } point3D_t; typedef struct { float x; float y; } point2D_t; typedef struct { float r; float g; float b; } color_t; //matrices and vectors 3D ver 2 // 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; } //Perkalian matrik dengan matrik matrix3D_t operator * (matrix3D_t a, matrix3D_t b) {

19

matrix3D_t c; //c=a*b 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; }

//Perkalian matrik dengan vector, hasilnya vektor vector3D_t operator * (matrix3D_t a, vector3D_t b) { vector3D_t c; //c=a*b 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);

20

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.z = 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; } //inner product(dot product) of homogeneous vector float operator * (vector3D_t a, vector3D_t b) { float c;//c=a*b int i; c = 0; for (i = 0; i<3; i++) { c += a.v[i] * b.v[i]; } return c; } //outer product (cross product) of homogenous vector // i j k // a0 a1 a2 // b0 b1 b2 vector3D_t operator ^ (vector3D_t a, vector3D_t b) {

21

vector3D_t c;//c=a*b c.v[0] = a.v[1] * b.v[2] - a.v[2] * b.v[1]; c.v[1] = a.v[2] * b.v[0] - a.v[0] * b.v[2]; c.v[2] = a.v[0] * b.v[1] - a.v[1] * b.v[0]; c.v[3] = 1.; return c; }

vector3D_t operator - (vector3D_t v1, vector3D_t v0) { vector3D_t c;//c=v1-v0 c.v[0] = v1.v[0] - v0.v[0]; c.v[1] = v1.v[1] - v0.v[1]; c.v[2] = v1.v[2] - v0.v[2]; c.v[3] = 1.; return c; } vector3D_t operator - (vector3D_t v) { vector3D_t c;//c=-v c.v[0] = -v.v[0]; c.v[1] = -v.v[1]; c.v[2] = -v.v[2]; c.v[3] = 1.; return c; } vector3D_t operator * (float r, vector3D_t b) { vector3D_t c; //c=r*b int i; for (i = 0; i<3; i++) { c.v[i] = r*b.v[i]; } c.v[3] = 1.; return c; } vector3D_t operator * (vector3D_t b, float r) { vector3D_t c; //c=r*b int i; for (i = 0; i<3; i++) { c.v[i] = r*b.v[i]; } c.v[3] = 1.; return c; } float funcPositive(float x) { if (0.<x) return x; else return 0.; }

22

//x to yth power float power(float x, float y) { //ln z = y ln x if (x == 0.) return 0; return exp(y*log(x)); }

z = exp (y ln x)

color_t operator + (color_t c1, color_t c2) { color_t col; col.r = c1.r + c2.r; col.g = c1.g + c2.g; col.b = c1.b + c2.b; return col; } color_t operator * (float r, color_t c) { color_t col; col.r = r*c.r; col.g = r*c.g; col.b = r*c.b; return col; } //End of matrices and vectors 3D ver 2 // //OpenGL drawShape Functions ver 1 // 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); }

23

//n: number of points void drawPolyline(point2D_t pnt[], int n) { int i; glBegin(GL_LINE_STRIP); for (i = 0; i
24

} 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); } typedef struct { int NumberofVertices; //in the face short int pnt[32]; } face_t; typedef struct { int NumberofVertices; //of the object point3D_t pnt[100]; int NumberofFaces; //of the object face_t fc[32]; } object3D_t; void userdraw(void) { static int tick = 0; float theta = 0.5; matrix3D_t tilting = rotationXMTX(theta)*rotationYMTX(-theta); setColor(0, 0, 0); drawAxes(tilting);

25

object3D_t prisma = {5,//jumlah vertek pada prisma {{0,100,0},{100,0,0},{0,0,100},{ -100,0,0 },{ 0,0,-100 }}, //daftar koordinat vertek prisma 5, //jumlah sisi prisma {{3,{ 0,1,2 }},{ 3,{0,2,3 } },{ 3,{ 0,3,4 } },{ 3,{ 0,4,1 } }, { 4,{ 1,4,3,2 } }} //setiap sisi terdiri dari 3 vertek dan satu 4 //vertek dan masing-masing vertek dinomeri dan dibaca //sesuai urutan yang berlawan arah jarum jam };

vector3D_t vec[32]; point2D_t buff[32]; vector3D_t vecbuff[32]; vector3D_t NormalVector; float normalz[32]; //z of normal vector of the face matrix3D_t rot, mat; int i, j; setColor(0, 1, 1); rot = rotationYMTX(0.02*tick); mat = tilting*rot; for (i = 0; i<prisma.NumberofVertices; i++) { vec[i] = Point2Vector(prisma.pnt[i]); vec[i] = mat*vec[i]; } //menggambar sisi yang tidak tampak dengan warna biru setColor(0, 0, 1); for (i = 0; i<prisma.NumberofFaces; i++) { for (j = 0; j<prisma.fc[i].NumberofVertices; j++) { vecbuff[j] = vec[prisma.fc[i].pnt[j]]; } NormalVector = (vecbuff[1] - vecbuff[0]) ^ (vecbuff[2] - vecbuff[0]); normalz[i] = NormalVector.v[2]; if (normalz[i]<0.) { for (j = 0; j<prisma.fc[i].NumberofVertices; j++) { buff[j] = Vector2Point2D(vecbuff[j]); } drawPolygon(buff, prisma.fc[i].NumberofVertices); } } //menggambar sisi yang tampak dengan warna merah setColor(1, 0, 0); for (i = 0; i<prisma.NumberofFaces; i++) { if (0. <= normalz[i]) { for (j = 0; j<prisma.fc[i].NumberofVertices; j++) { vecbuff[j] = vec[prisma.fc[i].pnt[j]]; buff[j] = Vector2Point2D(vecbuff[j]); }

26

drawPolygon(buff, prisma.fc[i].NumberofVertices); } } tick++; }

int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowPosition(100, 100); glutInitWindowSize(640, 480); glutCreateWindow("Prisma"); 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 :

27

Analisa : Program ini adalah program yang sudah dikembangkan dari program yang pertama,perbedaannya adalah program ini hanya terlihat pada face atau sisinya atau tidak akan terlihat. Sehingga dapat diketahui mana bagian belakang face.

BAB 3 PENUTUP A. KESIMPULAN Setelah melakukan praktikum Grafik 3D saya dapat menyimpulkan bahwa Obyek 3D adalah sekumpulan titik-titik 3D (x,y,z) yang membentuk suatu luasan atau face yang di gabungkan menjadi suatu kesatuan. Untuk menyatakan suatu face agar terlihat atau tidak,perlu diimplementasikan pada visible dan invisiblenya.Untuk menggambar obyek yang berotasi terhadap sumbu x dan x membutuhkan suatu implementasi dari tilting.

28

DAFTAR PUSTAKA  https://id.wikipedia.org/wiki/3_dimensi  http://mr-key14.blogspot.com/2015/01/pengantar-grafikakomputer.html  file:///D:/Kuliah/TRKJ%202.1/Computer%20Graphic%20&%2 0Animation/MODUL-Grafika-Komputer.pdf

29