LAPORAN

KOMPUTER GRAFIK


NAMA
PRAKTIKUM

NPM
MAHASISWA

KELAS

TANDA
TANGAN

SALSABILA

1214370544

TI4D SORE



NAMA PENILAI

TANGGAL
KOREKSI

NILAI

TANDA TANGAN

Indri sulistianingsih.S,KOM


UNIVERSITAS PEMBANGUNAN PANCA BUDI
FAKULTAS TEHNIK
SISTEM KOMPUTER
2014



KATA PENGANTAR

Grafika Komputer merupakan salah satu bidang ilmu komputer yang menakjubkan,
dan banyak digunakan untuk menyajikan secara visual berbagaiinformasi dari berbagai
disiplin ilmu yang lain. Penyajian informasi secara visualmenggunakan grafika komputer
untuk tujuan pemodelan, analisis, dan sintesisbanyak dijumpai antara lain pada bidang
kerekayasaan, arsitektur, kedokterandan yang berkaitan dengan entertainment.Berbicara
tentang grafika komputer tidak terlepas dari berbagai metode danalgorithma yang diperlukan
untuk membangkitkan gambar pada layar tampilan,dan cara pemanipulasian gambar tersebut
sesuai dengan kebutuhan pengguna.Dengan selesainya buku ini, penulis ingin mengucapkan
terima kasih kepadasemua pihak yang telah banyak membantu hingga terselesaikannya buku
ini,khususnya saudara Pramudyo Ananto yang dengan segenap perhatian dankomitmennya
telah menyunting dan memeriksa bab demi bab dari buku ini.Sebagai akhir kata, penulis
berharap agar buku ini dapat bermanfaat bagi parapembaca sekalian. Tak lupa, segala kritik
dan saran demi sempurnanya buku inisangat penulis harapkan.







Medan, Juni 2014

Penulis

ii



DAFTAR ISI
HALAMAN JUDUL..............................................................................i
KATA PENGANTAR .......ii
DAFTAR ISI ......iii

BAB I PENDAHULUAN ................. 1
1.1 Latar Belakang .......... .......1
1.2 Identifikasi masalah ................ .1

BAB II Landasan Teori tentang komputer grafik..................................................2
2.1 Komputer Grafik .................... 2
2.1.1 Pengertian komputer grafik ...........2

BAB III Hasil Percobaan / Praktikum....................................................... .3
3.1 Desain ....................................................................................3
3.3.1 Contoh Latihan fungsi dari primitive drawing .............3
3.3.2 Membuat objek 2D.......................................................20
3.3.3 Membuat objek 3D.......................................................23

BAB IVAnalisa Hasil Percobaan................................................................ 30
4.1 Tujuan ................................................................................... 30

BAB V PENUTUP...................................................................................31
5.1 Kesimpulan............................................................................31
5.2 Saran.......................................................................................31

DAFTAR PUSTAKA ............................................................................. 32




iii



BAB I
PENDAHULUAN
1.1 Latar Belakang
Definisi definisi Grafik Komputer
Pertama : Proses untuk menciptakan suatu gambar berdasarkan deskripsi obyek maupun
latar belakang
Definisi definisi Grafik Komputer
Pertama : Proses untuk menciptakan suatu gambar berdasarkan deskripsi obyek maupun
latar belakang ang terkandung pada gambar tersebut.
Kedua : tehnik untuk membuat gambar obyek sesuai dengan obyek tersebut di alam
nyata ( realism)
Kemajuan tehnologi pada saat ini memungkinkan manusia untuk tidak menggambar
menngunakan media kertas. Dengan adanya kebutuhan manusia yang semakin meningkat
dan keinginan untuk mendapatkan sebuah hasil yang bagus dan cepat,maka di buat
berbagai program aplikasi untuk dapat kemungkinan manusia menggambar melalui media
komputer.

1.2 Identifikasi masalah
identifikasi masalah tentang menggambar grafik menggunaka program aplikasi grafik dan
bahasa pemograman,diantaranya sebagai berikut:
1. konsep dasar menggambar transformasi 2d grafik di dalam komputer
2. fasilitas yang di gunakan untuk menggambar grafik
3. perbandingan antara program aplikasi grafik dengan bahasa pemograman










BAB II
LANDASAN TEORI TENTANG KOMPUTER GRAFIK
2.1 komputer grafik
2.1.1.Pengertian Grafika Komputer
Perkembangan grafika komputer menuntut para pengembang sistem aplikasi
grafikakomputer untuk dapat mengembangkan suatu informasi yang dilengkapi
denganvisualisasi dan animasi, agar dapat lebih mudah dipahami oleh pihak yang
menggunakansistem tersebut. Grafika komputer telah menunjukkan kemajuan yang pesat
dalampengembangan berbagai aplikasi untuk menghasilkan gambar.Grafika komputer
digunakan untuk menunjang berbagai bidang dengan teknologigrafika berbasis komputer.
Penggunaan grafika komputer telah lama digunakan dalambeberapa macam aplikasi,
diantaranya pendidikan, kedokteran, fisika, matematika,multimedia, dan lain-lain. Pada saat
ini grafika komputer sudah digunakan pada bidangsains, engineering, kedokteran, bisnis,
industri, pemerintahan, seni, hiburan, iklan,pendidikan, dan lain-lain. Oleh karena itu, sudah
semakin banyak pula bahasapemrograman yang dilengkapi dengan tools/library pembuatan
grafik Salah satutools/library pembuatan aplikasi grafik adalah OpenGL (Open Graphics
Library).OpenGL(Open Graphics Library) adalah suatu spefikasi grafik yang low-levelyang
menyediakan fungsi untuk pembuatan grafik primitif termasuk titik, garis, danlingkaran.
OpenGL digunakan untuk mendefinisikan suatu objek, baik objek 2 dimensimaupun objek 3
dimensi.OpenGL juga merupakan suatu antarmuka pemrograman aplikasi
(applicationprogramming interface (API) yang tidak tergantung pada piranti dan
platform yangdigunakan, sehingga OpenGL dapat berjalan pada sistem operasi Windows,
UNIX dansistem operasi lainnya. OpenGL pada awalnya didesain untuk digunakan pada
bahasapemrograman C/C++, namun dalam perkembangannya OpenGL dapat juga
digunakandalam bahasa pemrograman yang lain seperti Java, Tc. Namun OpenGL di-
package secara berbeda-beda sesuai dengan bahasapemrograman yang digunakan. Oleh
karena itu, package OpenGL tersebut dapat di-download pada
situshttp://www.opengl.org sesuai dengan bahasa pemrograman yang akan digunakan.Grafika
komputer pada dasarnya adalah suatu bidang ilmu komputer yang mempelajaricara-cara
untuk meningkatkan dan memudahkan komunikasi antara manusia denganmesin (komputer)
dengan jalan membangkitkan, menyimpan, dan memanipulasi gambar



BAB III
HASIL PERCOBAAN/PRAKTIKUM

3.1 Desain
3.3.1 Contoh Latihan fungsi dari primitive drawing
1.syntax membuat pot bunga:
#include <GL/glut.h>
#include <math.h>

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);
}

void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_POLYGON);
for (i=0; i<n; i++)
{
glVertex2i(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 userdraw()
{

point2D_t
batang[4]={{-5,-190},{-5,0},{5,0},{5,-190}};
color_t biru ={0,0,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);

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<360; s++)
{
srad =(s+tick)*3.14/360;
r=80*sin(200*srad);
shape [s].x = (float)(r*cos(100*srad));
shape [s].y = (float)(r*sin(100*srad));
color_t merah ={1,0,0};
fillPolygon(shape,1, merah);
}
drawPolygon(shape, 360);
}

void display(void)
{
//clear screen
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(1.0,1.0,1.0,0.0);
gluOrtho2D(-300.,400.,-300.,300.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}








2. syntax membuat gambar kubus 3D
#include <GL/glut.h>
#include <math.h>
struct point {
float x,y,z;
};
struct vektor {
float v[4];
};
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;

}
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<4;i++) {
for (j=0;j<4;j++) {
if (i==j)
mat.m[i][j] = 1;
else
mat.m[i][j] = 0;
}
}
return mat;
}
matriks translasi(float dx, float dy, float dz) {
matriks trans = identitas();
trans.m[0][3] = dx;
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;

}
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<4;i++) {
c.v[i] = 0;
for (j=0;j<4;j++) {
c.v[i]+= mat.m[i][j] * b.v[j];
}
}
return c;
}



matriks kalim (matriks a, matriks b) {
int i,j,k;
matriks c;
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;
}
matriks titling = kalim(rotasiX(theta),rotasiY(-theta));
vektor cross (vektor a, vektor b) {
vektor c;
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;
}
void DrawPolygon(objek obj)
{
int i,j;
float r,g,b;

for(i=0;i<obj.jumsisi;i++)
{
r=1.0f; g=0.0f; b=0.0f;
glBegin(GL_LINE_LOOP);
if (i==0) { r=1.0f; g=0.0f; b=0.0f; }
if (i==1) { r=0.0f; g=1.0f; b=0.0f; }
if (i==2) { r=0.0f; g=0.0f; b=1.0f; }



if (i==3) { r=1.0f; g=1.0f; b=0.0f; }
if (i==4) { r=1.0f; g=0.0f; b=1.0f; }
if (i==5) { r=0.0f; g=1.0f; b=1.0f; }
if (i==6) { r=0.5f; g=0.0f; b=1.0f; }
if (i==7) { r=0.5f; g=0.5f; b=0.5f; }
glColor3f(r,g,b);
for(j=0;j<obj.sisi[i].jumtitikons;j++)
{
glVertex3f(obj.titik[obj.sisi[i].indextitik[j]].x,
obj.titik[obj.sisi[i].indextitik[j]].y,
obj.titik[obj.sisi[i].indextitik[j]].z);
}
glEnd();
}
}

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<8;i++) {
hasil = point2vektor(balok,i);
HslKali = kali(mat,hasil);
HslTitik = vektor2point(HslKali);
balok.titik[i] = HslTitik;
}
DrawPolygon(balok);
}
void UserDraw() {



glClearColor(1.0f,1.0f,1.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT);
//glRotatef(0.1f,0.0f,1.0f,0.0f);
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();
}









4. syntax membuat gambar monas
#include <GL/glut.h>
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);
}
void drawPolygon(point2D_t pnt[],int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0; i<n; i++)
{
glVertex2i(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 userdraw(void)
{
point2D_t
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);
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);
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);
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}};
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;
}





3.3.2 Membuat Objek 2 Dimensi
OpenGL adalah suatu graphic library yang sebagian bersifat open source, dipakai pada
banyak platform (windows, linux) dan dapat digunakan pada berbagai jenis compiler seperti
C++/Delphi.
Dikembangkan oleh Mark Kilgard. GLUT merupakan pengembangan dari OpenGL dimana
memiliki keunggulan sebagai berikut:
Mudah, portable window manager, menggunakan callback functions
untuk menambahkan interaksi dari user.
Didesain untuk aplikasi dengan level kecil hingga menengah.
Distribusi library bebas tetapi tidak open source.
Syntax Perintah OpenGL
Sintaks perintah OpenGL mengikuti aturan penulisan dari library dimana fungsi tersebut
berasal, format penulisan fungsi OpenGL adalah :
Semua perintah OpenGL menggunakan awalan gl diikuti dengan huruf kapital pada setiap
kata membentuk nama perintah (sebagai contoh glClearColor). Untuk mendefinisikan
konstanta diawali dengan GL_, dengan menggunakan huruf kapital dan garis bawah untuk
memisahkan kata (seperti GL_POLY_STIPPLE). Terkadang beberapa huruf dan angka
ditambahkan pada akhir perintah (seperti 3f pada glVertex3f). Dalam hal ini angka 3
menunjukkan berapa banyak argumen yang harus ada pada perintah tersebut dan akhiran
huruf f menunjukkan jenis datanya yaitu floating.
Library yang Berhubungan dengan OpenGL
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 :



o 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.
o OpenGL Extension untuk X-Windows yang menyediakan fungsi untuk
menciptakan OpenGL context dan mengasosiasikannya dengan mesin yang
menggunakan X-Windows. Rutin-rutin ini mempunyai awalan glx.
o Auxiliary atau aux library terdapat pada library glaux.lib dan file header
glaux.h. Perintah yang akan digunakan selalu menggunakan awalan aux
o OpenGL Utility Toolkit (GLUT) adalah toolkit untuk sistem windows yang
ditulis oleh Mark Kilgard untuk menyembunyikan perintah API sistem
windows yang kompleks.
Sekarang kita coba membuat sebuah bangun segitiga 2D dengan menggunakan open-GL

Silahkan coppast syntax di bawah ini:
#include <stdlib.h>
#include <gl/glut.h>
sintaks di atas adalah header dasar dan harus ada untuk dapat menjalankan GLUT, dan
standard Libarary.
void renderScene(void){



glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
glVertex3f(-10.,10.,0.0);
glVertex3f(-10.,0.,0.0);
glVertex3f(0.,0.,0.0);
glEnd();
glFlush(); }
Sedangkan sintaks di atas adalah sintaks untuk membuat objek primitif 2 dimensi berbentuk
segitiga. Fungsi yang digunakan adalah GL_TRANGLES yang berfungsi untuk membuat
setiap 3 buah titik disambungkan menjadi satu sehingga terbentuk sebuah segitiga.
Sedangkan untuk glVertex3f(x,y) digunakan untuk membuat sebuah titik pada koordinat x
dan y.
void main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_SINGLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(320,320);
glutCreateWindow("Pemrograman Grafis GLUT");
gluOrtho2D(-50.0,50.0,-50.0,50.0);
glutDisplayFunc(renderScene);
glutMainLoop(); }
Sedangkan pada fungsi void main adalah fungsi yang digunakan untuk menjalankan program
agar mampu menampilkan pada kanvas.








3.3.3 Membuat objek 3 dimensi (boneka danboo)

Pada kali ini membuat objek 3 dimensi menggunakan openGL, yang jelas sarat dengan
koding.
Kali ini membuat boneka danboo. Sebenarnya cukup mudah, hanya peletakannya saja yang
memkan waktu.
Untuk menggambar objek ini dibutuhkan beberapa fungsi objek 3 dimensi yaitu :
1. glutSolidCube (digunakan untuk membuat objek kubus)
2. glutSolidSphere (digunakan untuk membuat objek bola)
3. glutSolidCone (digunakan untuk membuat objek kerucut)
Tidak lupa untuk mengatur letak masing" objek 3dimensi menggunakan :
1. glRotatef();
2. glScalef();
3. glTranslatef();
Berikut contoh scrip dan tampilan dari pembuatan boneka danboo 3dimensi menggunakan
OpenGL.
chek disk out:



Scrip:
#include<stdlib.h>
#include<GL/glut.h>
int w=480, h=480, z=-20;
int x1=0, y1=0, sudut=0, z1=0, skalaX=0, skalaY=0;
void renderScene(void){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();






//camera awal
glTranslatef(0,0,z);
glRotatef(sudut,x1,y1,z1);

//kaki kanan
glPushMatrix();
glRotatef(20,0,0,-1);
glTranslatef(0.1,-4,0);
glColor3f(0.8,0.55,0.3);
glScalef(1,2.5,1);
glutSolidCube(1.3);
glPopMatrix();

//kaki kiri
glPushMatrix();
glRotatef(0,1,0,1);
glTranslatef(1.2,-4,0);
glColor3f(0.8,0.55,0.3);
glScalef(1,2.5,1);
glutSolidCube(1.3);
glPopMatrix();


//badan
glPushMatrix();
glTranslatef(0,0,0);
glColor3f(0.8,0.6,0.3);
glScalef(2,3,2);
glutSolidCube(2);
glPopMatrix();

//baju
glPushMatrix();
glRotatef(60,0,0,1);



glTranslatef(-0.7,-0.5,2.02);
glScalef(0.3,0.3,0.1);
glColor3f(0,1,0);
glutSolidCone(7.5,0,3,3);
glPopMatrix();

//tangan kanan
glPushMatrix();
glRotatef(80,0,0,1);
glTranslatef(-0.5,4,0);
glColor3f(0.8,0.55,0.3);
glScalef(1,3,1);
glutSolidCube(1.3);
glPopMatrix();

//Sendi Kanan
glPushMatrix();
glTranslatef(2.6,0,0);
glColor3f(1,0,0);
glScalef(1,1,1);
glutSolidSphere(1,100,100);
glPopMatrix();

//tangan kiri
glPushMatrix();
glRotatef(-80,0,0,1);
glTranslatef(0.5,4,0);
glColor3f(0.8,0.55,0.3);
glScalef(1,3,1);
glutSolidCube(1.3);
glPopMatrix();

//sendi kiri
glPushMatrix();



glTranslatef(-2.6,0,0);
glColor3f(1,0,0);
glScalef(1,1,1);
glutSolidSphere(1,100,100);
glPopMatrix();

//Kepala
glPushMatrix();
glTranslatef(0,3.5,0);
glColor3f(0.8,0.6,0.3);
glScalef(1.5,1,1);
glutSolidCube(5);
glPopMatrix();

//mata
glPushMatrix();
glTranslatef(-1.5,3.5,0.55);
glColor3f(0,0,0);
glutSolidSphere(2,100,100);
glPopMatrix();

//mata
glPushMatrix();
glTranslatef(1.5,3.5,0.55);
glColor3f(0,0,0);
glutSolidSphere(2,100,100);
glPopMatrix();

//mulut
glPushMatrix();
glRotatef(-65,1,0,0);
glTranslatef(0,-1.1,2.8);
glScalef(0.3,0.3,0.3);
glColor3f(0,0,0);



glutSolidCone(3,3,3,3);
glPopMatrix();
glutSwapBuffers();
}

void resize(int w1,int h1){
glViewport(0,0,w1,h1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0,(float) w1/(float) h1, 1.0,300.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void myKeyboard(unsigned char key, int x, int y){
if (key == 'x') {
x1=1;
y1=0;
z1=0;
sudut+=10;
}
else if (key == 'y') {
y1=1;
x1=0;
z1=0;
sudut+=-10;
}
else if (key == 't') {
y1=1;
x1=0;
z1=0;
sudut+=+10;
}
else if (key == 'z') {



y1=0;
x1=0;
z1=1;
sudut+=-10;
}
}

void mySpecialKeyboard(int key, int x, int y){
switch(key){
case GLUT_KEY_UP:
z+=5;
break;
case GLUT_KEY_DOWN:
z-=5;
break;
}
}

void init(){
glClearColor(0,0,0,1);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0,(GLdouble) w/(GLdouble) h, 1.0,300.0);
glMatrixMode(GL_MODELVIEW);
}
void timer(int value){
glutPostRedisplay();
glutTimerFunc(50,timer,0);
}

void main (int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA);



glutInitWindowPosition(100,100);
glutInitWindowSize(w,h);
glutCreateWindow("kelompok 20");
gluOrtho2D(-w/2,w/2,-h/2,h/2);
glutDisplayFunc(renderScene);
glutReshapeFunc(resize);
glutKeyboardFunc(myKeyboard);
glutSpecialFunc(mySpecialKeyboard);
glutTimerFunc(1,timer,0);
init();
glutMainLoop();
}








BAB IV
ANALISA HASIL PERCOBAAN
4.1 TUJUAN
1. mendeskripsikan pengertian, kegunaan dan ruang linkup transformasi di dalam
komputer grafik
2. mengkaji beberapa pembuatan grafik menggunkan bahasa pemograman menggunakan
bahassa aplikasi dan bahasa pemograman
3. mengevaluasi makalah ini yang terangkum dalam ringkasan kesimpulan



















BAB V
PENUTUP
5.1 KESIMPULAN
1. Dari program tersebut, dapat ditampilkan gambar titik dan garis yang digabungkan
agar menghasilkan gambar 2 dimensi dan 3 dimensi.
2. Dalam pembuatan grafik 3 dimensi ada hal yang perlu dilakukan yaitu, mengubah
titik 3D menjadi vektor 3D agar gambar yang dihasilkan lebih sempurna.
3. Pada gambar 2 Dimensi memiliki kelebihan Pada gambar 2 Dimensi memiliki
kelebihan yaitu, gambar yang dirancang dapat diberi warna sesuai dengan RGB (Red,
Green, Blue).
4. Gambar yang dihasilkan pada grafik 2D dapat juga diberi efek-efek, seperti gambar
yang dapat melayang pada tampilan layarnya.
5.2 Saran
1. Dalam penulisan program grafik 2D dan 3D,titik koordinat harus ditemukan
dengan tepat agar gambar yang dihasilkan sempurna.
2. Pada garfik 2D penulisan proses program sangat bergantung pade titik sinus,
cosinus, dan tangen.
3. Pada grafik 3D penulisan proses program sangat bergantung pada matriks dan
vektor serta gabungan dari grafik 2D.





















DAFTAR PUSTAKA

1. http://titi-nyunyun.blogspot.com/2011/10/pemanfaatan-grafik-komputer-dan.html
2. http://chiaisadora.wordpress.com/2011/10/11/contoh-aplikasi-grafik-komputer-dan-
pengolahan-citra/
3. http://nzsha1104.wordpress.com/2011/10/08/grafik-komp-pengolahan-citra-dalam-
kehidupan-sehari-hari/
4. http://irnieirindra.blogspot.com/2011/10/aplikasi-grafik-komputer-dan-pengolahan.html