komputer grafik SASTRA

LAPORAN

KOMPUTER GRAFIK

NAMA

PRAKTIKUM

NPM

MAHASISWA

KELAS TANDA

TANGAN

SASTRA 1214370263 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

http://www.opengl.org/

http://www.opengl.org/

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


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


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


return rotate;

}

matriks rotasiY(float theta) {








return rotate;

}

matriks rotasiZ(float theta) {








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


//glRotatef(0.1f,0.0f,1.0f,0.0f);

gambarbalok();

glutSwapBuffers();

}

void main(int argc,char **argv) {

glutInit(&argc,argv);




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


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


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


point2D_t

petaktengah3[4]={{80,90},{70,110},{290,110},{280,90}};


fillpolygon(petaktengah3, 4, kuning3);


point2D_t

batang2[4]={{160,510},{160,530},{200,530},{200,510}};


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


fillpolygon(petaktengah4, 4, hitam3);


point2D_t

segitiga[3]={{170,530},{180,580},{190,530}};


fillpolygon(segitiga, 3, kuning4);

drawPolygon(segitiga,3);

point2D_t

bayangbatang[4]={{160,530},{160,535},{200,535},{200,530}};


fillpolygon(bayangbatang, 4, putih3);

drawPolygon(bayangbatang,4);

point2D_t

bayangbatang2[4]={{200,510},{200,535},{203,535},{203,510}};


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


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


point2D_t

petaktengah22[4]={{100,70},{80,90},{280,90},{260,70}};


point2D_t

petaktengah33[4]={{80,90},{70,110},{290,110},{280,90}};


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


point2D_t

anaktangga4[4]={{150,10},{150,15},{210,15},{210,10}};


}

void display(void)

{

//clear screen


userdraw();

glutSwapBuffers();

}

int main(int argc, char **argv)

{

glutInit(&argc,argv);//Inisialisasi Toolkit




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){

http://pendtium11.files.wordpress.com/2013/05/lat6.jpg


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



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


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


glPopMatrix();

//mata

glPushMatrix();

glTranslatef(1.5,3.5,0.55);

glColor3f(0,0,0);


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


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

Documents

komputer grafik SASTRA