-
Page 1
Laporan Praktikum
Komputer Grafik
NAMA PRAKTIKAN
NOMOR
MAHASISWA
TANGGAL
KUMPUL
TANDA TANGAN
PRAKTIKAN
FANI ADIANI 1214370424
NAMA PENILAI TANGGAL
KOREKSI NILAI
TANDA TANGAN
DOSEN
INDRI SULISTIANINGSIH,
S.KOM
Jurusan Teknik Informatika
Fakultas Teknik
Universitas Pembangunan Panca Budi Medan
2014
KELAS
SK 4B SORE
-
Page 2
DAFTAR ISI
DAFTAR ISI
.....................................................................................................................
2
KATA PENGANTAR
.......................................................................................................
3
BAB I PENDAHULUAN
.................................................................................................
4
1.1 Umum
...............................................................................................................
4
1.2 Latar Belakang
..................................................................................................
5
1.3 Tujuan Praktikum
..............................................................................................
6
BAB II LANDASAN TEORI
............................................................................................
7
BAB III PRAKTIKUM
......................................................................................................
9
3.1 Latihan Fungsi Primitif Drawing
.......................................................................
9
a) Garis
.........................................................................................................
9
b) Segitia Sama Kaki
...................................................................................
11
3.2 Latihan Fungsi Dua Dimensi (2D)
....................................................................
13
a) Bunga Pot
................................................................................................
13
b) Monas
......................................................................................................
18
c) Segi Empat
...............................................................................................
25
3.3 Latihan Fungsi Tiga Dimensi (3D)
....................................................................
27
a) Point to Vector
.........................................................................................
27
b) The Cube World
......................................................................................
36
BAB IV
ANALISA..............................................................................................................
44
BAB V PENUTUP
..............................................................................................................
45
5.1 Kesimpulan
........................................................................................................
45
5.2 Saran
..................................................................................................................
45
5.3 Hasil Aplikasi
....................................................................................................
46
DAFTAR PUSTAKA
..........................................................................................................
48
-
Page 3
KATA PENGANTAR
Puji dan Syukur penulis panjatkan kepada Allah SWT yang mana
karena rahmat dan
hidayahNya penulis dapat menyelesaikan laporan praktikum sesuai
dengan waktu yang telah
ditetapkan sebagai syarat tugas akhir praktikum pada mata kuliah
Komputer Grafik dengan
judul Laporan Praktikum Komputer Aplikasi Menggunakan
OpenGL.
Rasa dan ucapan terima kasih penulis sampaikan kepada pihak yang
telah membantu
dalam penyusunan laporan ini, pihak yang penulis ucapkan terima
kasih adalah :
1. Ibu Indri Sulistianingsih S.Kom selaku dosen pembimbing mata
kuliah
komputer grafik.
2. Semua pihak yang ikut dalam penyusunan laporan praktikum
ini.
Demikian laporan praktikum ini dibuat, semoga Allah SWT
memberikan balasan yang
berlipat ganda kepada semuanya. Demi perbaikan selanjutnya,
saran dan kritik yang
membangun akan penulis terima dengan senang hati. Akhirnya,
hanya kepada Allah SWT
penulis serahkan segalanya mudah-mudahan dapat bermanfaat
khususnya bagi penulis
umumnya bagi kita semua.
Medan, 9 Juni 2014
Penulis
-
Page 4
BAB I
PENDAHULUAN
1.1 Umum
Grafik Komputer adalah suatu bidang ilmu yang mempelajari
bagaimana membangun
grafik (gambar), memanipulasi gambar (visual) secara digital
baik 2 dimensi maupun 3
dimensi sehingga kelihatan nyata menggunakan komputer. Grafika
komputer meliputi
gambar dan pencitraan lain yang dihasilkan komputer berbentuk
garis, lengkungan, kurva dan
lain sebagainya.
OpenGL (Open Graphics Library) adalah standar API yang dapat
digunakan untuk
membuat aplikasi grafik, baik dua dimensi (2D) maupun tiga
dimensi (3D). OpenGL ini
bersifat cross-platform, artinya dapat dijalankan pada berbagai
platform sistem operasi yang
ada saat ini.
OpenGL menyediakan set perintah untuk menggambar dan semua
penggambaran
yang lebih tinggi tingkatnya harus dilakukan dengan mengambil
fungsi dasar dari perintah
ini. Maka dari itu dapat dibuat library itu sendiri di atas
program OpenGL yang
mempermudah pemrograman lebih lanjut. Fungsi asli dari OpenGL
sendiri selalu diawali
dengan gl yang terdapat pada library opengl32.dll dan file
header gl.h. Sedangkan beberapa
library yang telah ditulis untuk menyediakan fungsi-fungsi
tambahan pada OpenGL adalah :
1. OpenGL Utility Library (GLU) yang didalamnya terdapat
sejumlah rutin yang
menggunakan level bawah dari perintah OpenGL. Rutin-rutin ini
mempunyai awalan
glu. Library ini digunakan sebagai bagian dari implementasi
OpenGL.
2. OpenGL Extension untuk X-Windows yang menyediakan fungsi
untuk
menciptakan OpenGL context dan mengasosiasikannya dengan mesin
yang
menggunakan XWindows. Rutin-rutin ini mempunyai awalan glx.
3. Auxiliary atau aux library terdapat pada library glaux.lib
dan file header glaux.h.
Perintah yang akan digunakan selalu menggunakan awalan aux .
4. OpenGL Utility Toolkit (GLUT) adalah toolkit untuk sistem
windows yang ditulis
oleh Mark Kilgard untuk menyembunyikan perintah API sistem
windows yang
kompleks.
-
Page 5
Yang digunakan kali ini adalah GLUT (OpenGL Utility Toolkit),
GLUT dipilih
karena di dalamnya terdapat banyak fungsi yang dapat dipakai
untuk pembuatan application
window. Disamping itu, windowing pada GLUT juga bersifat
independen terhadap sistem
operasi, sehingga tidak perlu repot-repot untuk mengubah kode
program jika diterapkan pada
sistem operasi yang berbeda.
1.2 Latar Belakang
Digital Image Processing, Komputer Grafik, Analisis dan Computer
telah
dikembangkan dan diaplikasikan dengan mengesankan selama
beberapa dekade. Dimana
perkembangan aplikasi-aplikasi yang menggunakan disiplin ilmu
telah memimpin teknologi
di beberapa bidang seperti komunikasi digital dan internet,
penyiaran (broadcasting), alat
kedokteran, sistem multimedia, biologi, ilmu pengetahuan
material, robot dan manufaktur,
sistem intelligent sensing, remote sensing, seni grafik dan
proses print. Pertumbuhan yang
pesat ini direfleksikan dengan diterbitkannya paper di jurnal
ilmiah internasional setiap
tahunnya dan diluncurkannya buku-buku tentang Pemrosesan Image
Digital dan Komputer
Grafik.
Grafik komputer dua dimensi (2D) adalah pembuatan objek gambar
dengan
menggunakan dua titik sebagai acuannya, yaitu sumbu x dan y.
Karakteristik pada grafik
komputer 2D adalah terlihat dari tampilan objeknya yang datar,
tidak beruang, berupa
struktur garis dan tampilan frame layarnya terbatas. Dalam
grafika komputer, objek 2D
memiliki keunggulan di antaranya adalah kemudahan dalam membuat
gambar dan tidak
memerlukan waktu banyak untuk meresource.
Selain itu, objek 2D juga memiliki kelemahan, yaitu gambar
terlihat biasa saja, belum
mendukung bentuk-bentuk 3D atau fenomena yang bersifat tiga
dimensi, seperti
pencahayaan, bayangan, pantulan, refraksi, dan sebagainya.
Macam-macam objek 2D di
antaranya, line, circle, arc, polygon, text, section, rectangle,
ellips, donut, star, dan helix.
Riset-riset mengenai cara mempermudah memvisualisasikan ide atau
data secara lebih
cepat dan akurat telah banyak dilakukan, khususnya teknologi
visualisasi tiga dimensi (3D)
telah mengalami perkembangan yang sangat pesat, misalnya dengan
diciptakan teknologi
motion capture, menggerakan objek 3D menjadi lebih mudah, facial
capture membuat
animasi ekspresi wajah menjadi lebih mudah dan akurat, scanner
3D membuat proses
-
Page 6
pemodelan objek tiga dimensi (3D) menjadi lebih cepat dan
akurat, software-software
authoring tiga dimensi yang lengkap dengan objek-objek 3D
mempercepat desain suatu
model objek tiga dimensi.
Namun pada umumnya software-software authoring tiga dimensi
tersebut tidak
mendukung representasi visual tiga dimensi (3D), maka perlu
proses render yang cukup
memakan waktu sebelum hasil akhirnya bisa dilihat.
Ada 3 file penting dalam OpenGL yang akan digunakan dalam sistem
operasi
MSWindows, yaitu glut.h, glut32.lib dan glut32.dll. Dimana
masing-masing file OpenGL
tersebut akan diinstal kedalam Windows, adapun cara
penginstalannya sebagai berikut:
Letakkan glut.h di direktori include pada Visual C
(vc98/include/GL)
Letakkan glut32.lib di direktori lib pada Visual C
(vc98/lib)
Letakkan glut32.dll di direktori windows/system
OpenGL tersebut harus sudah terinstal kedalam komputer apabila
di dalam komputer
tidak terdapat OpenGL maka hasil gambar tidak akan dapat
terlihat meskipun listing program
yang telah dibuat didalam C++ telah sukses (jalan). Oleh karena
itu OpenGL tersebut harus
sudah terinstal agar hasil gambar tersebut dapat terlihat.
1.3 Tujuan Praktikum
1. Membuat objek primitive drawing
2. Mengembangkan beberapa objek dasar menjadi objek 2D hingga
3D
3. Membuat objek dua dimensi (2D)
4. Membuat objek tiga dimensi (3D)
-
Page 7
BAB II
LANDASAN TEORI
2.1 Landasan Teori
Grafika Komputer adalah suatu bidang ilmu yang mempelajari
bagaimana
membangun grafik(gambar), memanipulasi gambar (visual) secara
digital baik 2 dimensi
maupun 3 dimensi yang keliatan nyata menggunakan komputer.
Grafika komputer meliputi
gambar dan pencitraan lain yang dihasilkan komputer berbentuk
garis, lengkungan, kurva,
dan lain sebagainya.
Bagian dari grafika komputer meliputi:
Geometri: mempelajari cara menggambar permukaan bidang
Animasi: mempelajari cara menggambarkan dan memanipulasi
gerakan
Rendering: mempelajari algoritma untuk menampilkan efek
cahaya
Citra (Imaging): mempelajari cara pengambilan dan penyuntingan
gambar
Salah satu bidang grafika komputer yang sangat terkenal adalah
design grafis.
Beberapa penerapan grafika komputer sebagai berikut:
1) Entertainment
Misalnya dalam pembuatan animasi pada film Terminator 2 dan
Titanic
merupakan contoh film non animasi yang memanfaatkan efek-efek
dari grafika
komputer yang sangat canggih.
2) Visualisasi Proses
Misalnya menggambarkan layout kinerja proses public atau
proses-proses yang
dalam modul saja.
3) Visualisasi Hasil Penelitian
Visualisasi hasil penelitian ini seperti menggambar perfomers
grafik perubahan
bahkan grafik model hasil implementasi program.
4) Image Prosesi
Image Prosesi digunakan sebagai algoritma identifikasi seperti
yang dilakukan
pada kepolisian untuk menggambar wajah seseorang dan
identifikasi seseorang.
5) GIS ( Geografic Information Sytem).
-
Page 8
Adapun macam-macam gambar komputer yang mana disetiap jenisnya
memiliki
sturktur yang berbeda sehingga disetiap gambar memiliki
penggunaan atau pemanfaatan pada
grafika komputer yang berbeda, yakni:
a. Raster Image
Raster Image adalah gambar yang strukturnya berupa matrik,
dimana setiap titik (x,y)
mempunyai nilai berupa warna sesuai dengan model warna yang
digunakan seperti
RGB/CYMK. File dengan ekstensi (.BMP), (.Gif), (.Tiff), (.JPG),
(.PNG) itu
merupakan contoh dari RASTER IMAGE. Model gambar semacam ini
digunakan
emage processing.
b. Vektor Image
Vektor image adalah gambar yang strukturnya berupa vector gambar
yang dibuat
menggunakan AutoCad / maya atau gambar-gambar pada GIS merupakan
contoh dari
Vektor Image. Model gambar semacam ini digunakan dalam grafika
komputer dan
GIS.
-
Page 9
BAB III
PRAKTIKUM
3.1 Latihan Fungsi dari Primitive drawing
Beberapa objek yang dihasilkan dari fungsi primitive drawing,
sebagai berikut:
a) Garis
List Programnya:
#include
void userdraw()
{
static int tick=0;
void drawline(int x1,int x2, int y1,int y2);
glBegin(GL_LINES);
glVertex2i(100,100);
glVertex2i(200,150);
glEnd();
-
Page 10
}
void display(void)
{
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);//Inisialisasi Toolkit
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
glutCreateWindow("GARIS");
glClearColor(0.0,0.0,0.0,0.0);
gluOrtho2D(0.,640.,-240.,240.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
-
Page 11
b) Segitiga Sama Kaki
List programnya:
#include
void display(void)
{
/* bersihkan layar dari titik pixel yang masih ada */
glClear (GL_COLOR_BUFFER_BIT);
/* gambar poligon (rectangle) dengan titik sudut *
* (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0) */
glColor3f (1.0, 1.0, 0.0);
/////////pembentuk segitiga sama kaki/////
glBegin(GL_LINE_LOOP);
glVertex3f (0.0, 0.0, 0.0);
glVertex3f (0.3, 0.8, 0.0);
glVertex3f (0.6, 0.0, 0.0);
-
Page 12
glEnd();
/////////pembentuk segitiga sama kaki///////
glFlush (); }
void kunci(unsigned char key, int x, int y) {
switch (key) {
case 27 : case 'q': exit(0); break; } glutPostRedisplay(); }
int main(int argc, char *argv[]) {
glutInitWindowSize(200,200);
glutInitWindowPosition(100,100);
glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
glutCreateWindow("Fani Adiani");
glutDisplayFunc(display);
glutKeyboardFunc(kunci);
glutMainLoop();
return 0;
}
-
Page 13
3.2 Latihan Fungsi dari Dua Dimensi (2D)
Grafik Dua Dimensi adalah merupakan sekumpulan titik-titik dua
dimensi yang
dihubungkan dengan garis lurus baik berupa Polyline, polygon
atau kurva.
Berikut beberapa objek dua dimensi (2D), yakni:
a). Bunga Pot
List programnya:
#include
#include
typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;
-
Page 14
}color_t;
void setColor (color_t col)
{
glColor3f(col.r, col.g, col.b);
}
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_POLYGON);
for (i=0; i
-
Page 15
}
glEnd();
}
void userdraw()
{
point2D_t
batang[4]={{-5,-190},{-5,0},{5,0},{5,-190}};
color_t biru ={1,1,1};
fillPolygon(batang,4, biru);
drawPolygon(batang,4);
point2D_t
pot[4]={{-60,-190},{60,-190},{30,-240},{-30,-240}};
color_t hitam ={0,0,0};
fillPolygon(pot,4, hitam);
drawPolygon(pot,4);
point2D_t
pot2[6]={{-80,-160},{-50,-160},{-50,-190},{-60,-190},{-60,-170},{-80,-170}};
color_t hitam3 ={0,0,0};
fillPolygon(pot2,4, hitam3);
drawPolygon(pot2,4);
-
Page 16
point2D_t
pot3[6]={{80,-160},{50,-160},{50,-190},{60,-190},{60,-170},{80,-170}};
color_t hitam2 ={0,0,0};
fillPolygon(pot3,4, hitam2);
drawPolygon(pot3,4);
static int tick=0;
point2D_t shape[360];
double srad,r;
for(int s=0; s
-
Page 17
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
//posisi layar
glutInitWindowPosition(150,150);
//ukuran layar
glutInitWindowSize(640,480);
//title windows
glutCreateWindow("Bunga Raflesia");
//warna back layar
glClearColor(0.0,1.0,0.1,0.0);
gluOrtho2D(-300.,400.,-300.,300.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
-
Page 18
b). Monas
List programnya:
#include
typedef struct
{
int x,y;
}point2D_t;
typedef struct
{
float r,g,b;
}color_t;
void setColor(color_t col)
{
glColor3f(col.r, col.g, col.b);
}
-
Page 19
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i
-
Page 20
petakdasar[4]={{0,0},{0,80},{350,80},{350,0}};
color_t hijau ={0,1,0};
fillpolygon(petakdasar, 4, hijau);
drawPolygon(petakdasar,4);
point2D_t
tangga[4]={{10,10},{50,50},{310,50},{340,10}};
color_t merah ={1,0,0};
fillpolygon(tangga, 4, merah);
drawPolygon(tangga,4);
point2D_t
petaktengah1[4]={{110,50},{100,70},{260,70},{250,50}};
color_t kuning ={1,1,0};
fillpolygon(petaktengah1, 4, kuning);
drawPolygon(petaktengah1,4);
point2D_t
petaktengah2[4]={{100,70},{80,90},{280,90},{260,70}};
color_t kuning2 ={1,1,0};
fillpolygon(petaktengah2, 4, kuning2);
drawPolygon(petaktengah2,4);
point2D_t
petaktengah3[4]={{80,90},{70,110},{290,110},{280,90}};
color_t kuning3 ={1,1,0};
fillpolygon(petaktengah3, 4, kuning3);
-
Page 21
drawPolygon(petaktengah3,4);
point2D_t
batang2[4]={{160,510},{160,530},{200,530},{200,510}};
color_t hitam4 ={0,0,0};
fillpolygon(batang2, 4, hitam4);
drawPolygon(batang2,4);
point2D_t
batang[4]={{150,120},{170,520},{190,520},{210,120}};
color_t putih2 ={1,1,1};
fillpolygon(batang, 4, putih2);
drawPolygon(batang,4);
point2D_t
petaktengah4[4]={{70,110},{70,120},{290,120},{290,110}};
color_t hitam3 ={0,0,0};
fillpolygon(petaktengah4, 4, hitam3);
drawPolygon(petaktengah4,4);
point2D_t
segitiga[3]={{170,530},{180,580},{190,530}};
color_t kuning4 ={1,1,0};
fillpolygon(segitiga, 3, kuning4);
drawPolygon(segitiga,3);
-
Page 22
point2D_t
bayangbatang[4]={{160,530},{160,535},{200,535},{200,530}};
color_t putih3 ={1,1,1};
fillpolygon(bayangbatang, 4, putih3);
drawPolygon(bayangbatang,4);
point2D_t
bayangbatang2[4]={{200,510},{200,535},{203,535},{203,510}};
color_t putih4 ={1,1,1};
fillpolygon(bayangbatang2, 4, putih4);
drawPolygon(bayangbatang2,4);
point2D_t
tanggatgh1[4]={{140,10},{140,50},{150,50},{150,10}};
color_t hitam ={0,0,0};
fillpolygon(tanggatgh1, 4, hitam);
drawPolygon(tanggatgh1,4);
point2D_t
tanggatgh2[4]={{210,10},{210,50},{220,50},{220,10}};
color_t hitam2 ={0,0,0};
fillpolygon(tanggatgh2, 4, hitam2);
drawPolygon(tanggatgh2,4);
point2D_t
tangga2[4]={{10,10},{50,50},{310,50},{340,10}};
drawPolygon(tangga2,4);
-
Page 23
point2D_t
petaktengah11[4]={{110,50},{100,70},{260,70},{250,50}};
drawPolygon(petaktengah11,4);
point2D_t
petaktengah22[4]={{100,70},{80,90},{280,90},{260,70}};
drawPolygon(petaktengah22,4);
point2D_t
petaktengah33[4]={{80,90},{70,110},{290,110},{280,90}};
drawPolygon(petaktengah33,4);
point2D_t
batang3[4]={{150,120},{170,520},{190,520},{210,120}};
drawPolygon(batang3,4);
point2D_t
anaktangga[4]={{150,40},{150,45},{210,45},{210,40}};
drawPolygon(anaktangga,4);
point2D_t
anaktangga2[4]={{150,30},{150,35},{210,35},{210,30}};
drawPolygon(anaktangga2,4);
point2D_t
anaktangga3[4]={{150,20},{150,25},{210,25},{210,20}};
drawPolygon(anaktangga3,4);
point2D_t
anaktangga4[4]={{150,10},{150,15},{210,15},{210,10}};
-
Page 24
drawPolygon(anaktangga4,4);
}
void display(void)
{
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char **argv)
{
glutInit(&argc,argv);//Inisialisasi Toolkit
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(500,640);
glutCreateWindow("MONUMEN NASIONAL JAKARTA");
glClearColor(0.0,0.0,1.0,0.0);
gluOrtho2D(0.,350.,-5.,600.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
-
Page 25
c). Persegi Empat
List programnya:
#include //Mengakses file library stdio.h
#include //Mengakses file library stdlib.h
#include //Mengakses file library string.h
#include //Mengakses file library stdarg.h
#include //Mengakses file library glut.h
void mydisplay(){
glClear(GL_COLOR_BUFFER_BIT); //Menghapus layar
glBegin(GL_POLYGON); //Memanggil fungsi openGL Geometric
Primitive
glColor3f(1,0,0); //Untuk memberi warna biru
glVertex2f(-0.5, -0.5); //Vertex 2 dimensi
glVertex2f(-0.5, 0.5);
glVertex2f(0.5, 0.5);
glVertex2f(0.5, -0.5);
-
Page 26
glEnd();
glFlush();
}
void reshape( int w, int h ) // fungsi reshape
{
if (w >= h)
glViewport(0, 0, (GLsizei)h, (GLsizei)h) ;
else
glViewport(0, 0, (GLsizei)w, (GLsizei)w) ;
}
int main(int argc, char** argv)
{
printf("Hello World this is 2D Rectangle"); //Output berupa
text
glutCreateWindow("Fani Adiani"); //Memberi nama untuk file yang
akan di run
glutDisplayFunc(mydisplay);
glutReshapeFunc(reshape); //Memanggil fungsi reshape
glutMainLoop();
}
-
Page 27
3.3 Latihan Fungsi dari Tiga Dimensi (3D)
Grafik Komputer 3D merupakan perkembangan dari grafik 2D.
Istilah atau Pengertian
Grafik 3D adalah sebuah gambar,garis,lengkungan,dan sebagainya
yang memiliki titik-titik
yang menghubungkan menjadi sebuah bentuk 3D.
Berikut beberapa objek dari grafik tiga dimensi (3D), yakni:
a. Point to Vektor
Dapat dilihat pada gambar di bawah bahwa objek kubus tersebut
bergerak:
List Programnya:
#include
#include
struct point {
float x,y,z;
};
struct vektor {
float v[4];
};
-
Page 28
struct matriks {
float m[4][4];
};
struct face {
int jumtitikons;
int indextitik[40];
};
struct objek {
int jumtitik;
point titik[40];
int jumsisi;
face sisi[30];
};
matriks mat;
float theta=0.5;
vektor point2vektor(objek balok, int i) {
vektor vec;
vec.v[0] = balok.titik[i].x;
vec.v[1] = balok.titik[i].y;
vec.v[2] = balok.titik[i].z;
vec.v[3] = 1;
return vec;
}
-
Page 29
point vektor2point(vektor vec) {
point pnt;
pnt.x = vec.v[0];
pnt.y = vec.v[1];
pnt.z = vec.v[2];
return pnt;
}
matriks identitas(void) {
int i,j;
matriks mat;
for (i=0;i
-
Page 30
trans.m[1][3] = dx;
trans.m[2][3] = dx;
return trans;
}
matriks rotasiX(float theta) {
matriks rotate = identitas();
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;
}
matriks rotasiY(float theta) {
matriks rotate = identitas();
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;
-
Page 31
}
matriks rotasiZ(float theta) {
matriks rotate = identitas();
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][2] = cs;
return rotate;
}
vektor kali (matriks mat, vektor b) {
int i,j;
vektor c;
for (i=0;i
-
Page 32
int i,j,k;
matriks c;
for (i=0;i
-
Page 33
int i,j;
float r,g,b;
for(i=0;i
-
Page 34
}
void gambarbalok() {
int i;
vektor hasil,HslKali;
point HslTitik;
mat = titling;
objek balok =
{8,{{10,15,30},{30,15,30},{30,15,10},{10,15,10},{10,30,30},{30,30,30},{30,30,10},{10,30
,10
}},
6,{{4,{0,1,5,4}},{4,{3,2,6,7}},{4,{0,3,7,4}},{4,{1,2,6,5}},{4,{0,1,2,3}},{4,{4,5,6,7}}}};
for (i=0;i
-
Page 35
gambarbalok();
glutSwapBuffers();
}
void main(int argc,char **argv) {
glutInit(&argc,argv);
glutInitWindowPosition(20,20);
glutInitWindowSize(640,640);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutCreateWindow("Point To Vektor");
glOrtho(-100.0f,100.0f,-100.0f,100.0f,-100.0f,100.0f);
glutIdleFunc(UserDraw);
glutDisplayFunc(UserDraw);
glutMainLoop();
}
-
Page 36
b. The Cube World
List Programnya:
#include
#include
#include
#include /* GLU extention library */
void init(void);
void display(void);
void keyboard(unsigned char, int, int);
void resize(int, int);
void drawcube(int, int, int);
int is_depth; /* depth testing flag */
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
-
Page 37
glutInitWindowSize(600, 600);
glutInitWindowPosition(40, 40);
glutCreateWindow("The Cube World");
init();
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
/* this time we're going to keep the aspect ratio
constant by trapping the window resizes */
glutReshapeFunc(resize);
glutMainLoop();
return 0;
}
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
is_depth = 1;
glMatrixMode(GL_MODELVIEW);
}
void display(void)
{
if (is_depth)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
Page 38
else
glClear(GL_COLOR_BUFFER_BIT);
/* draw the floor */
glBegin(GL_QUADS);
glColor3f(0.2f, 0.2f, 0.2f);
glVertex3f(-100.0, 0.0, -100.0);
glColor3f(0.4f, 0.4f, 0.4f);
glVertex3f(-100.0, 0.0, 100.0);
glColor3f(0.6f, 0.6f, 0.6f);
glVertex3f(100.0, 0.0, 100.0);
glColor3f(0.8f, 0.8f, 0.8f);
glVertex3f(100.0, 0.0, -100.0);
glEnd();
/* draw 12 cubes with different colors */
drawcube(75, 57, 2);
drawcube(-65, -12, 3);
drawcube(50, -50, 1);
drawcube(-56, 17, 2);
drawcube(67, 12, 3);
drawcube(-87, 32, 1);
drawcube(-26, 75, 2);
drawcube(57, 82, 3);
drawcube(-3, 12, 1);
-
Page 39
drawcube(46, 35, 2);
drawcube(37, -2, 3);
glutSwapBuffers();
}
void keyboard(unsigned char key, int x, int y)
{
/* This time the controls are:
"a": move left
"d": move right
"w": move forward
"s": move back
"t": toggle depth-testing
*/
switch (key)
{
case 'a':
case 'A':
glTranslatef(5.0, 0.0, 0.0);
break;
case 'd':
case 'D':
glTranslatef(-5.0, 0.0, 0.0);
break;
-
Page 40
case 'w':
case 'W':
glTranslatef(0.0, 0.0, 5.0);
break;
case 's':
case 'S':
glTranslatef(0.0, 0.0, -5.0);
break;
case 't':
case 'T':
if (is_depth)
{
is_depth = 0;
glDisable(GL_DEPTH_TEST);
}
else
{
is_depth = 1;
glEnable(GL_DEPTH_TEST);
}
}
display();
}
-
Page 41
void resize(int width, int height)
{
if (height == 0) height = 1;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* note we divide our width by our height to get the aspect
ratio */
gluPerspective(45.0, width / height, 1.0, 400.0);
/* set initial position */
glTranslatef(0.0, -5.0, -150.0);
glMatrixMode(GL_MODELVIEW);
}
void drawcube(int x_offset, int z_offset, int color)
{
/* this function draws a cube centerd at (x_offset,
z_offset)
x and z _big are the back and rightmost points, x and z _small
are
the front and leftmost points */
float x_big = (float)x_offset + 5;
float z_big = (float)z_offset + 5;
float x_small = (float)x_offset - 5;
float z_small = (float)z_offset - 5;
switch(color)
{
case 1:
-
Page 42
glColor3f(1.0,1.0,0.0);
break;
case 2:
glColor3f(0.0,1.0,0.0);
break;
case 3:
glColor3f(0.0,1.0,0.0);
break;
}
glBegin(GL_QUADS);
glVertex3f(x_small,10.0,z_big); /* front */
glVertex3f(x_small,0.0,z_big);
glVertex3f(x_big,0.0,z_big);
glVertex3f(x_big,10.0,z_big);
glVertex3f(x_big,10.0,z_small); /* back */
glVertex3f(x_big,0.0,z_small);
glVertex3f(x_small,0.0,z_small);
glVertex3f(x_small,10.0,z_small);
glVertex3f(x_big,10.0,z_big); /* right */
glVertex3f(x_big,0.0,z_big);
glVertex3f(x_big,0.0,z_small);
glVertex3f(x_big,10.0,z_small);
glVertex3f(x_small,10.0,z_small); /* left */
-
Page 43
glVertex3f(x_small,0.0,z_small);
glVertex3f(x_small,0.0,z_big);
glVertex3f(x_small,10.0,z_big);
glVertex3f(x_small,10.0,z_big); /* top */
glVertex3f(x_big,10.0,z_big);
glVertex3f(x_big,10.0,z_small);
glVertex3f(x_small,10.0,z_small);
glVertex3f(x_small,0.0,z_small); /* bottom */
glVertex3f(x_big,0.0,z_small);
glVertex3f(x_big,0.0,z_big);
glVertex3f(x_small,0.0,z_big);
glEnd();
}
-
Page 44
BAB IV
ANALISA
Dari objek-objek atau gambar di atas yang telah dibuat, dapat
dilihat
perkembangannya tahap demi tahap dari hasil objek yang tahap
pertama memakai fungsi
primitive drawing hanya berupa garis-garis yang membentuk gambar
sangat sederhana.
Pada tahap kedua yaitu objek yang memakai fungsi dua dimensi
(2D) dapat dilihat
perkembangannya dimana kumpulan titik, garis, gambar yang
memakai titik kordinat sumbu
x,y dapat membentuk suatu objek yang indah seperti meja, kursi,
bunga, rumah minimalis.
Pada tahap akhir yaitu objek yang memakai fungsi tiga dimensi
(3D) dapat dilihat
perkembangannya dimana objek primitive drawing dan dua dimensi
(2D) yang hanya
memakai 2 titik kordinat yaitu x dan y digunakan juga namun pada
objek tiga dimensi (3D)
ini pemakaian fungsinya memakai 3 titik kordinat yaitu sumbu x,y
dan z sehingga objek
memiliki ruang dan gambar tampak lebih hidup, bahkan objek dapat
bergerak seperti
berputar, berpindah tempat, ataupun keduanya dapat juga terjadi
pada waktu yang bersamaan
saat program dijalankan.
-
Page 45
BAB V
PENUTUP
5.1 Kesimpulan
Dalam pembuatan gambar-gambar diatas dengan menggunakan bahasa
pemograman
Visual C++, selain menggunakan keahlian dalam menguasai bahasa
pemograman Visual
C++, membutuhkan ketelitian dan kesabaran dalam pembuatan
program-program gambar
diatas agar program tersebut tidak terdapat kesalahan (error)
sehingga program tersebut dapat
di jalankan (Execute) dan gambar tersebut dapat di tampilkan
hasilnya.
5.2 Saran
Adapun saran yang dapat penulis sampaikan ialah agar
pembelajaran komputer grafik
dalam pembuatan gambar 2D dan 3D menggunakan bahasa pemograman
Visual C++ ini
dapat di implementasikan menjadi Tugas Akhir nantinya.
-
Page 46
5.3 Hasil Aplikasi
Primitif Drawing
Dua Dimensi (2D)
-
Page 47
Tiga Dimensi (3D)
-
Page 48
DAFTAR PUSTAKA
o
http://informasi-inofatif.blogspot.com/2012/05/praktikum-grafika-komputer.html
o
http://ejournal.unsrat.ac.id/index.php/elekdankom/article/download/595/467
o
http://daraluvheechul.blogspot.com/2010/02/grafik-2d-3d.html