BAB 1

PENDAHULUAN

1. Latar Belakang

Penggambaran objek bentuk 3D secara visual sering dibutuhkan untuk

keperluan visualisasi penggambaran suatu objek dengan atributnya. Visualisasi ini

digunakan untuk mempresentasikan bentuk suatu objek dengan pewarnaannya yang

mencakup beberapa faktor penting dalam pencahayaan seperti warna cahaya , posisi

cahaya dan koefisien pantul benda.

Salah satu teknik penggambaran objek 3D tersebut adalah denganmenggunakan

teknik ray tracing yaitu teknik yang digunakan untuk penggambaran membuat suatu

gambar yang realistik dengan mengkalkulasikan jalur yang dilewati cahaya yang

masuk ke pandangan pengamat pada beberapa sudut. Jalur ini ditelusuri mulai dari

titik pandang pengamat kembali ke objek yang akan digambar untuk menentukan

apakah titik pandang pengamat mengenai benda atau tidak. Pada saat titik pandang

pengamat mengenai benda maka akan dihitung nilai warna pixel pada titik tabrak

tersebut dengan memperhitungkan warna cahaya, posisi cahaya dan koefisien pantul

benda.

2. Rumusan Masalah

Dari latar belakang di atas, kami sadar permasalahan yang ada adalah bagaimana

langkah-langkah penggambaran objek 3D. Selain itu juga bagaimana algoritma dan

penjabaran tentang penggambaran objek 3D. Hal ini dikuatkan dengan

penggambaran objek tiga dimensi dengan bahasa pemograman java.

3. Kerangka Teori

a. Konsep Program Penggambaran Objek 3D

Program penggambaran objek 3D ini dibuat dengan menggunakan Java

dengan library openGL.

b. Dasar Teori Grafika Komputer

Objek 3D merupakan objek yang dibentuk dari beberapa koordinat (X,Y,Z)

yang dihubungkan. Koordinat-koordinat untuk merepresentasikan objek 3D akan

lebih dinamis dan mudah dipelajari apabila ditulis dalam sebuah file teks. File

teks ini selain berisi tentang informasi koordinat objek 3D juga menyimpan

informasi jumlah titik, jumlah garis dan garis yang menghubungkan antar titik.

Gambar di atas terdiri atas 8 buah titik dimana tiap-tiap titik dihubungkan

dengan garis dengan jumlah total garis adalah 12 buah garis. Dimana garis 1

menghubungkan T1 dan T2 dst hingga semuanya terhubung.

Translasi / Pergeseran

Sebuah titik dapat digeser atau ditranslasikan dengan persamaan sebagai berikut :

X’ = x1 + Tx

Y’ = y1 + Ty

Z’ = z1 + Tz

Ket :

x1,y1,z1 : koordinat titik awal

X’,Y’,Z’: koordinat titik hasil

Tx : faktor perpindahan ke arah X (horisontal)

Ty : faktor perpindahan ke arah Y (vertikal)

Tz : faktor perpindahan ke arah Z (kedalaman)

Skala

Sebuah objek dapat diperbesar atau diperkecil dengan persamaan sebagai berikut :

X’ = Sx * x

Y’ = Sy * y

Z’ = Sz * Z

Ket :

Sx : faktor pembesaran horizontal

Sy : faktor pembesaran vertical

Sz : faktor pembesaran kedalam

Rotasi

Mengelilingi Sumbu Z :

Rotasi 2D sebenarnya adalah rotasi 3D terhadap sumbu Z. Sebuah titik dapat

digeser atau ditranslasikan dengan persamaan sebagai berikut :

X’ = x.cos Θ – y.sin Θ

Y’ = x.sin Θ + y.cos Θ

Z’ = Z

Mengelilingi Sumbu X :

X’ = X

Y’ = y.cos Θ - z.sin Θ

Z’ = y.sin Θ + z.cos Θ

Mengelilingi Sumbu Y :

X’ = X.cos Θ + z.sin Θ

Y’ = Y

Z’ = -x.sin Θ + z.cos Θ

Ket :

x,y,z : koordinat titik asal

X’,Y’,Z’: koordinat hasil perputaran

Θ : sudut putar.

Dinyatakan dalam radian, maka tranformasinya

Θ = (sudut_derajat/180* Θ) dengan Θ = 22/7

BAB 2

PEMBAHASAN

A. Prinsip Dasar Pemrograman 3D

Untuk membuat suatu aplikasi 3D secara real-time dibutuhkan suatu teknik

pemrograman level rendah dengan bantuan Application Programing Inteface (API).

Salah satu standar API yang digunakan untuk pemrograman 3D adalah OpenGl. Ada

beberapa prinsip dasar yang harus diperhatikan dalam membuat program 3D dengan

memanfaatkan API OpenGL, yaitu:

1. Mode Rendering

Ada dua pendekatan metode rendering yang digunakan dalam pemrograman

level-rendah pada appplication programing interface (API) OpenGL. Pendekatan

pertama menggunakan metode retained. Pada mode retained, data abstraksi

geometri dari objek yang akan dirender harus dibuat terlebih dahulu baik itu

menggunakan perangkat lunak pemodelan objek tiga dimensi atau bantuan API

yang lain. Selanjutnya kumpulan data tersebut ditransfer secara cepat ke

perangkat keras grafik, atau disimpan langsung pada memori local perangkat

keras grafik sehingga aksesnya lebih cepat.

Pendekatan yang kedua adalah menggunakan pendekatan metode

immediate. Pada metode ini geometrik objek ditentukan melaui perintah geometri

primitive OpenGL secara langsung. Tidak seperti metode retained, daftar

geometri objek tidak dibentuk atau disimpan dengan bantuan perangkat lunak

modeling atau API lain. Akan tetapi aplikasi harus mendefinisikan ulang semua

perintah penggambaran (melakukan rendering secara menyeluruh) pada bidang

gambar setiap kali dibuat suatu frame baru.

2. Sistem Koordinat

Untuk mengambarkan suatu objek pada lokasi dan ukuran tertentu, maka

dibutuhkan sebuah frame yang menjadi acuan posisi dan ukuran objek tersebut.

Sebagai contoh standar layar VGA memiliki 640 pixel dari kiri ke kanan dan 480

pixel dari atas ke bawah. Untuk menentukan titik pada tengah-tengan layar, maka

titik tersebut ditetapkan pada posisi (320, 240).

Pada OpenGL, setiap pembuatan jendela penggambaran dilengkapi dengan

sistem kordinat yang ingin digunakan beserta cara pemetaan kordinat tersebut ke

dalam pixel layar fisik (monitor). Berikut ini merupakan penerapan sistem

kordinat dan pemetaannya pada monitor pada penggambaran 2D dan

penggambaran 3D. menggunakan prinsip dasar penggambaran 2D.

a. Kordinat kartesian 2D

Sistem kordinat yang sering digunakan pada 2D adalah sistem kordinat

kartesian. kordinat kartesian terdiri atas kordinat x dan kordinat y. Kordinat x

merupakan ukuran posisi pada arah horisontal sedangkan kordinat y

merupakan ukuran posisi pada arah vertikal. Titik asal yang digunakan oleh

kordinat kartesian adalah x=0, y=0. Kordinat kartesian ditulis sebagai

pasangan kordinat didalam kurung, dengan posisi kordinat x diawal dan

kordinat y diposisi kedua dengan dipisahkan dengan tanda koma. Sebagai

contoh, titik asal ditulis dengan (0,0). Gambar 1 merupakan penggambaran

sistem kordinat kartesian pada dua dimensi. Garis x dan y dengan penanda

disebut sebagai axes yang dapat diperpanjang secara tak hingga dari negatif

menuju positif. Perpotongan antara sumbu x dan sumbu y membentuk bidang

kartesian.

b. Kordinat klipping

Ukuran window (jendela penggambaran) didasarkan pada satuan pixel.

Sebelum melakukan penggambaran titik, garis, dan bentuk pada window,

maka harus ada pemberitahuan pengaturan pada OpenGL mengenai tatacara

konversi dari pasangan kordinat tertentu menjadi kordinat layar. Konversi ini

dikerjakan dengan cara menetapkan area dari ruang kartesian dalam window,

area ini disebut sebagai area klipping. Pada ruang dua dimensi, area klipping

merupakan nilai minimum dan maksimum dari x dan y yang terletak dalam

window. Cara lain untuk menggambarkan pengertian area klipping adalah

menunjukkan titik asal kordinat kartesian yang berkorelasi dengan window.

Gambar 2 menunjukkan dua area klipping.

Pada contoh pertama (gambar sebelah kiri) pada gambar 2, kordinat x

didalam window memiliki jarak kiri ke kanan dari 0 ke 150, dan y memiliki

jarak bawah ke atas dari 0 ke 100. Titik pada tengah-tengah layar

direpresentasikan sebagai (75, 50). Contoh kedua gambar sebelah kanan pada

gambar 2 menunjukkan klipping area dengan kordinat x memiliki jarak kiri ke

kanan dari -75 ke 75 dan kordinat y memiliki jarak dari bawah ke atas dari -50

ke +50. Titik tengah-tengah pada gambar sebelah kanan direpresentasikan

sebagai (0,0).

c. Viewport

Ukuran lebar dan tinggi dari area klipping biasanya berbeda dengan

ukuran lebar dan tinggi window dalam satuan pixel. Dengan adanya

perbedaan ini, maka dilakukan pemetaan dari sistem logika kordinat kartesian

ke kordinat layar, pemetaan ini dikenal dengan viewport. Viewport adalah

area yang terletak pada area client window yang digunakan sebagai

penggambaran area klipping. Viewport mempermudah pemetaan area klipping

ke area window. Pada gambar 3 window dengan ukuran 300x200 dengan

viewport didefinisikan memenuhi keseluruhan area client. Jika area klipping

diatur dengan panjang sumbu x dimulai dari 0 sampai 150 dan panjang sumbu

y dimulai dari 0 sampai 100, maka kordinat logika dipetakan ke sistem

kordinat yang lebih besar dalam pandangan window. Setiap kenaikan pada

sistem kordinat logika dipadankan dengan dua kali kenaikan pada sistem fisik

kordinat (layar) dari window.

Gambar 3. viewport yang didefinisikan sebagai dua kali ukuran clipping area

Pada gambar 4 menunjukkan dimensi viewport yang sama dengan

dimensi area klipping. Ukurran Window adalah 300x200, sehingga membuat

area pandang terletak pada sisi kiri bawah dari window.

 Gambar 4. viewport yang didefinisikan sama dengan area kliping

Viewport dapat digunakan untuk mengecilkan atau membesarkan

gambar didalam window dan hanya menampilkan bagian dari area klipping

dengan mengatur viewport menjadi lebih besar dari area client window.

d. Vertex penggambaran objek baik pada 2D maupun 3D terdiri dari beberapa

bentuk kecil yang disebut sebagai primitive. Primitive merupakan entiti satu

atau dua dimensi atau permukaan seperti titik, garis, dan poligon yang dirakit

pada ruang 3D untuk menciptakan objek 3D. Sebagai contoh kubus 3D terdiri

dari 6 bidang persegi yang diletakkan pada muka yang berbeda-beda. Setiap

pojok dari persegi disebut vertex. Veretek tidak lebih dari kordinat pada ruang

2D atau 3D.

e. Kordinat kartesian 3D

Sistem kordinat 3D merupakan perluasan dari sistem kordinat 2D

dengan menambahakan dimensi ketiga. Gambar 5 merupakan sistem kordinat

kartesian dengan sumbu baru z. Sumbu z tegak lurus dengan sumbu x maupun

sumbu y.

Gambar 5. Kordinat kartesian 3D

f. Proyeksi

Dua proyeksi yang perlu diperhatikan dalam OpenGL adalah ortografik

dan perspektive.

Penerapan proyeksi ortografik dilakukan dengan menetapkan kotak

pandang volum (square viewing volume). Apapun yang berada diluar

volum tidak akan digambar. Selain itu pada proyeksi ortografik semua

objek yang memiliki dimensi sama nampak dengan ukuran yang sama

pula, tak peduli letaknya jauh ataupun dekat. Projeksi jenis ini (seperti

pada gambar 6) seringkali digunakan dalam desin arsitektur, computer-

aided design (CAD), atau grap 2D. Sering kali projeksi ini digunakan

untuk menambahkan tek atau 2D diatas skene grafik 3D.

Gambar 6. Klipping volum untuk proyeksi ortografik

Proyeksi yang kedua adalah proyeksi perspektive. Proyeksi ini

menambahkan efek semakin jauh jarak objek semakin kecil

penampakannya dibandingkan dengan penampakan objek dengan jarak

yang lebih dekat. Penglihatan volum (lihat gambar 7) kadangkala seperti

piramid dengan bagian atas terpenggal. Bentuk sisa disebut frustum.

Objek yang dekat terhadap bagian depan dari penglihatan volum akan

memiliki penampakan mendekati dengan ukuran sebenarnya, tetapi objek

yang terletak dekat dengan bagian belakang penglihatan volum memiliki

penampakan yang mengecil. Jenis proyeksi ini memberikan realisme

animasi dan simulasi 3D.

Gambar 7. Kliping volum (frustum)untuk proyeksi 3D

B. Tahapan-Tahapan Pemodelan 3D

Proses pemodelan 3D dibagi menjadi beberapa tahapan untuk

pembentukannya. Seperti obyek apa yang ingin dibentuk sebagai obyek dasar,

metoda pemodelan obyek 3D, pencahayaan dan animasi gerakan obyek sesuai

dengan urutan proses yang akan dilakukan.

Motion Capture/Model 2D

Yaitu langkah awal untuk menentukan bentuk model obyek yang akan

dibangun dalam bentuk 3D. Penekanannya adalah obyek berupa gambar wajah

yang sudah dibentuk intensitas warna tiap pixelnya dengan metode Image

Adjustment Brightness/Contrast, Image Color Balance, Layer Multiply, dan

tampilan Convert Mode RGB dan format JPEG. Dalam tahap ini digunakan

aplikasi grafis seperti Adobe Photoshop atau sejenisnya.

Dasar Metode Modeling 3D

Ada beberapa metode yang digunakan untuk pemodelan 3D. Ada jenis

metode pemodelan obyek yang disesuaikan dengan kebutuhannya seperti

dengan nurbs dan polygon ataupun subdivision. Modeling polygon merupakan

bentuk segitiga dan segiempat yang menentukan area dari permukaan sebuah

karakter. Setiap polygon menentukan sebuah bidang datar dengan meletakkan

sebuah jajaran polygon sehingga kita bisa menciptakan bentuk-bentuk

permukaan. Untuk mendapatkan permukaan yang halus, dibutuhkan banyak

bidang polygon. Bila hanya menggunakan sedikit polygon, maka object yang

didapat akan terbagi sejumlah pecahan polygon. Sedangkan Modeling dengan

NURBS (Non-Uniform Rational Bezier Spline) merupakan metode paling

populer untuk membangun sebuah model organik. Kurva pada Nurbs dapat

dibentuk dengan hanya tiga titik saja. Dibandingkan dengan kurva polygon

yang membutuhkan banyak titik (verteks) metode ini lebih memudahkan untuk

dikontrol. Satu titik CV (Control verteks) dapat mengendalikan satu area untuk

proses tekstur.

Proses Rendering

Rendering adalah proses akhir dari keseluruhan proses pemodelan ataupun

animasi komputer. Dalam rendering, semua data-data yang sudah dimasukkan

dalam proses modeling, animasi, texturing, pencahayaan dengan parameter

tertentu akan diterjemahkan dalam sebuah bentuk output. Dalam standard PAL

system, resolusi sebuah render adalah 720 x 576 pixels. Bagian rendering yang

sering digunakan:

- Field Rendering, sering digunakan untuk mengurangi strobing effect yang

disebabkan gerakan cepat dari sebuah obyek dalam rendering video.

- Shader, merupakan sebuah tambahan yang digunakan dalam 3D software

tertentu dalam proses special rendering. Biasanya shader diperlukan untuk

memenuhi kebutuhan special effect tertentu seperti lighting effects,

atmosphere, fog dan sebagainya.

Texturing

Proses texturing ini untuk menentukan karakterisik sebuah materi obyek

dari segi tekstur. Untuk materi sebuah object bisa digunakan aplikasi properti

tertentu seperti reflectivity, transparency, dan refraction. Texture kemudian bisa

digunakan untuk meng-create berbagai variasi warna pattern, tingkat

kehalusan/kekasaran sebuah lapisan object secara lebih detail.

Image dan Display

Merupakan hasil akhir dari keseluruhan proses dari pemodelan. Biasanya

obyek pemodelan yang menjadi output adalah berupa gambar untuk kebutuhan

koreksi pewarnaan, pencahayaan, atau visual effect yang dimasukkan pada

tahap teksturing pemodelan. Output images memiliki Resolusi tinggi berkisar

Full.

Eksperimen Pembuatan Program Penggambaran Objek 3 Dimensi

Pembuatan program penggambaran objek 3 dimensi dilakukan dengan

menggunakan Java openGL (JOGL).

1. Kubus

Source code :

package org.yourorghere;

import com.sun.opengl.util.Animator;import java.awt.Frame;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import javax.media.opengl.GLCanvas;import javax.media.opengl.GL;import javax.media.opengl.GLAutoDrawable;import javax.media.opengl.GLEventListener;import javax.media.opengl.glu.GLU;

public class Kubus implements GLEventListener { private float rquad = 0.0f; private GLU glu = new GLU();

public void display(GLAutoDrawable gLDrawable) {

final GL gl = gLDrawable.getGL(); gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); gl.glLoadIdentity(); gl.glTranslatef(0.2f, 0.0f, -6.0f); gl.glRotatef(rquad, 1.0f, 1.0f, 1.0f);

gl.glBegin(GL.GL_QUADS); gl.glColor3f(0.0f, 0.0f, 0.0f); // Set warna hitam gl.glVertex3f(1.0f, 1.0f, -1.0f); // Kanan atas (Atas) gl.glVertex3f(-1.0f, 1.0f, -1.0f); // kiri atas (Atas) gl.glVertex3f(-1.0f, 1.0f, 1.0f); // Kiri bawah (Atas) gl.glVertex3f(1.0f, 1.0f, 1.0f); // Kanan bawah(Atas)

gl.glColor3f(0.4f, 1.0f, 1.0f); // Set warna biru muda gl.glVertex3f(1.0f, -1.0f, 1.0f); // kanan atas (Bawah) gl.glVertex3f(-1.0f, -1.0f, 1.0f); // kiri atas (Bawah) gl.glVertex3f(-1.0f, -1.0f, -1.0f); // kiri bawah (Bawah) gl.glVertex3f(1.0f, -1.0f, -1.0f); // kanan bawah (Bawah)

gl.glColor3f(0.5f, 0.1f, 1.0f); // Set warna ungu gl.glVertex3f(1.0f, 1.0f, 1.0f); // kanan atas (Depan) gl.glVertex3f(-1.0f, 1.0f, 1.0f); // kiri atas (Depan) gl.glVertex3f(-1.0f, -1.0f, 1.0f); // kiri bawah (Depan) gl.glVertex3f(1.0f, -1.0f, 1.0f); // kanan bawah (Depan)

gl.glColor3f(1.0f, 1.0f, 0.0f); // Set warna kuning gl.glVertex3f(1.0f, -1.0f, -1.0f); // kanan atas (Belakang) gl.glVertex3f(-1.0f, -1.0f, -1.0f); // kiri atas (Belakang) gl.glVertex3f(-1.0f, 1.0f, -1.0f); // kiri bawah (Belakang) gl.glVertex3f(1.0f, 1.0f, -1.0f); // kanan bawah (Belakang)

gl.glColor3f(0.7f, -1.0f, -1.0f); // Set warna maroon gl.glVertex3f(-1.0f, 1.0f, 1.0f); // kanan atas (Kiri) gl.glVertex3f(-1.0f, 1.0f, -1.0f); // kiri atas (Kiri) gl.glVertex3f(-1.0f, -1.0f, -1.0f); // kiria bawah (Kiri) gl.glVertex3f(-1.0f, -1.0f, 1.0f); // kanan bawah (Kiri)

gl.glColor3f(1.0f, 0.0f, 1.0f); // Set warna pink gl.glVertex3f(1.0f, 1.0f, -1.0f); // kanan atas (Kanan) gl.glVertex3f(1.0f, 1.0f, 1.0f); // kiri atas (kanan) gl.glVertex3f(1.0f, -1.0f, 1.0f); // kiri bawah (kanan) gl.glVertex3f(1.0f, -1.0f, -1.0f); // kanan bawah (kanan) gl.glEnd(); gl.glFlush();

rquad += 0.15f; }

public void displayChanged(GLAutoDrawable gLDrawable, boolean modeChanged, boolean deviceChanged) { }

public void init(GLAutoDrawable gLDrawable) { GL gl = gLDrawable.getGL(); gl.glShadeModel(GL.GL_SMOOTH); gl.glClearColor(1.0f, 1.0f, 1.0f, 0.5f); gl.glClearDepth(1.0f); gl.glEnable(GL.GL_DEPTH_TEST); gl.glDepthFunc(GL.GL_LEQUAL); \ gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); }

public void reshape(GLAutoDrawable gLDrawable, int x, int y, int width, int height) { final GL gl = gLDrawable.getGL();

if (height <= 0) height = 1; final float h = (float) width / (float) height; gl.glViewport(0, 0, width, height); gl.glMatrixMode(GL.GL_PROJECTION); gl.glLoadIdentity(); glu.gluPerspective(45.0f, h, 1.0, 20.0); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glLoadIdentity(); }

public static void main(String[] args) { Frame frame = new Frame("Kubus_3D_Grafkom_Mika"); GLCanvas canvas = new GLCanvas();

canvas.addGLEventListener(new Kubus()); frame.add(canvas); frame.setSize(640, 480); final Animator animator = new Animator(canvas); frame.addWindowListener(new WindowAdapter() {

@Override public void windowClosing(WindowEvent e) {

new Thread(new Runnable() {

public void run() { animator.stop(); System.exit(0); } }).start(); } }); frame.setLocationRelativeTo(null); frame.setVisible(true); animator.start(); }}

Output:

Analisa Hasil

Dalam pembuatan objek 3D dengan Java OpenGL ini pertama-tama kita perlu

meng-import beberapa package seperti :

import com.sun.opengl.util.Animator;

import java.awt.Frame;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import javax.media.opengl.GLCanvas;

import javax.media.opengl.GL;

import javax.media.opengl.GLAutoDrawable;

import javax.media.opengl.GLEventListener;

import javax.media.opengl.glu.GLU;

Class Kubus mengimplementasi interface GLEventListener, yang kemudian

mewarisi beberapa method dari GLEventListener tersebut, seperti: method

display, displayChange, init, dan reshape.

Method-method yang diwarisi dari interface GLEventListener tadi kemudian

dioverride (dimodifikasi agar lebih spesifik).

Pada method display kita mulai melakukan penggambaran kubus dengan

membentuk vertex-vertexnya satu persatu.

Penggambaran kubus dimulai dengan perintah gl.glBegin(GL_QUADS);

Pembuatan sisi atas kubus dengan perintah:

gl.glColor3f(0.0f, 0.0f, 0.0f); // Set warna hitam

gl.glVertex3f(1.0f, 1.0f, -1.0f); // Kanan atas (Atas)

gl.glVertex3f(-1.0f, 1.0f, -1.0f); // kiri atas (Atas)

gl.glVertex3f(-1.0f, 1.0f, 1.0f); // Kiri bawah (Atas)

gl.glVertex3f(1.0f, 1.0f, 1.0f); // kanan bawah (Atas)

Pembuatan sisi bawah kubus dengan perintah:

gl.glColor3f(0.4f, 1.0f, 1.0f); // Set warna biru muda

gl.glVertex3f(1.0f, -1.0f, 1.0f); // kanan atas (Bawah)

gl.glVertex3f(-1.0f, -1.0f, 1.0f); // kiri atas (Bawah)

gl.glVertex3f(-1.0f, -1.0f, -1.0f); // kiri bawah (Bawah)

gl.glVertex3f(1.0f, -1.0f, -1.0f); // kanan bawah (Bawah)

Pembuatan sisi depan kubus dengan perintah:

gl.glColor3f(0.5f, 0.1f, 1.0f); // Set warna ungu

gl.glVertex3f(1.0f, 1.0f, 1.0f); // kanan atas (Depan)

gl.glVertex3f(-1.0f, 1.0f, 1.0f); // kiri atas (Depan)

gl.glVertex3f(-1.0f, -1.0f, 1.0f); // kiri bawah (Depan)

gl.glVertex3f(1.0f, -1.0f, 1.0f); // kanan bawah (Depan)

Pembuatan sisi belakang kubus dengan perintah:

gl.glColor3f(1.0f, 1.0f, 0.0f); // Set warna kuning

gl.glVertex3f(1.0f, -1.0f, -1.0f); // kanan atas (Belakang)

gl.glVertex3f(-1.0f, -1.0f, -1.0f); // kiri atas (Belakang)

gl.glVertex3f(-1.0f, 1.0f, -1.0f); // kiri bawah (Belakang)

gl.glVertex3f(1.0f, 1.0f, -1.0f); // kanan bawah (Belakang)

Pembuatan sisi kiri kubus dengan perintah:

gl.glColor3f(0.7f, -1.0f, -1.0f); // Set warna maroon

gl.glVertex3f(-1.0f, 1.0f, 1.0f); // kanan atas (Kiri)

gl.glVertex3f(-1.0f, 1.0f, -1.0f); // kiri atas (Kiri)

gl.glVertex3f(-1.0f, -1.0f, -1.0f); // kiria bawah (Kiri)

gl.glVertex3f(-1.0f, -1.0f, 1.0f); // kanan bawah (Kiri)

Pembuatan sisi kanan kubus dengan perintah:

gl.glColor3f(1.0f, 0.0f, 1.0f); // Set warna pink

gl.glVertex3f(1.0f, 1.0f, -1.0f); // kanan atas (Kanan)

gl.glVertex3f(1.0f, 1.0f, 1.0f); // kiri atas (kanan)

gl.glVertex3f(1.0f, -1.0f, 1.0f); // kiri bawah (kanan)

gl.glVertex3f(1.0f, -1.0f, -1.0f); // kanan bawah (kanan)

Penggambaran kubus ini diakhiri dengan statement gl.glEnd();

gl.glFlush mengosongkan semua buffer, menyebabkan semua perintah yang

dikeluarkan untuk dieksekusi secepat mereka diterima oleh mesin rendering

yang sebenarnya.

Statement gl.glShadeModel(GL.GL_SMOOTH); digunakan untuk mengeset

mode gadasi warna halus (smooth).

gl.glClearColor(1.0f, 1.0f, 1.0f, 0.5f); untuk memberi background warna

putih

gl.glClearDepth(1.0f); untuk membersihkan depth buffer

gl.glEnable(GL.GL_DEPTH_TEST); mengaktifkan depth testing,

melakukan perbandingan kedalaman dan update depth buffer.

gl.glDepthFunc(GL.GL_LEQUAL); menetapkan fungsi yang digunakan

untuk membandingkan setiap nilai kedalaman pixel yang masuk dengan nilai

kedalaman pixel yang ada dalam depth buffer, GL_LEQUAL untuk nilai

kedalaman yang masuk kurang dari atau sama dengan nilai kedalaman yang

disimpan.

gl.glHint() Aspek-aspek tertentu perilaku GL, ketika ada ruang untuk

interpretasi, dapat dikontrol dengan petunjuk(hint).

GL_PERSPECTIVE_CORRECTION_HINT Menunjukkan kualitas warna

dan tekstur koordinat interpolasi.

GL_NICEST Kualitas paling benar atau tertinggi.

2. Piramid

Source code:

package org.yourorghere;

import com.sun.opengl.util.Animator;

import java.awt.Frame;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import javax.media.opengl.GLCanvas;

import javax.media.opengl.GL;

import javax.media.opengl.GLAutoDrawable;

import javax.media.opengl.GLEventListener;

import javax.media.opengl.glu.GLU;

public class Pyramid implements GLEventListener {

private float r = 0.0f;

private GLU glu = new GLU();

public void display(GLAutoDrawable gLDrawable) {

final GL gl = gLDrawable.getGL();

gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

gl.glLoadIdentity();

gl.glTranslatef(0.2f, 0.0f, -6.0f);

gl.glRotatef(r, 0.0f, 1.0f, 0.0f);

gl.glBegin(GL.GL_TRIANGLES);

gl.glColor3f(1.0f, 1.0f, 0.0f); // Set warna kuning

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (depan)

gl.glVertex3f(-1.0f, -1.0f, 1.0f); // Left Of Triangle (depan)

gl.glVertex3f(1.0f, -1.0f, 1.0f); // Right Of Triangle (depan)

gl.glColor3f(0.4f, 1.0f, 1.0f); // Set warna biru muda

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (Right)

gl.glVertex3f(1.0f, -1.0f, 1.0f); // Left Of Triangle (Right)

gl.glVertex3f(1.0f, -1.0f, -1.0f); // Right Of Triangle (Right)

gl.glColor3f(0.5f, 0.1f, 1.0f); //Set warna ungu

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (Back)

gl.glVertex3f(1.0f, -1.0f, -1.0f); // Left Of Triangle (Back)

gl.glVertex3f(-1.0f, -1.0f, -1.0f); // Right Of Triangle (Back)

gl.glColor3f(1.0f, 0.0f, 1.0f); // Set warna pink

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (Left)

gl.glVertex3f(-1.0f, -1.0f, -1.0f); // Left Of Triangle (Left)

gl.glVertex3f(-1.0f, -1.0f, 1.0f); // Right Of Triangle (Left)

gl.glEnd();

gl.glFlush();

r += 0.3f;

}

public void displayChanged(GLAutoDrawable gLDrawable,

boolean modeChanged, boolean deviceChanged) {

}

public void init(GLAutoDrawable gLDrawable) {

GL gl = gLDrawable.getGL();

gl.glShadeModel(GL.GL_SMOOTH);

gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);

gl.glClearDepth(1.0f);

gl.glEnable(GL.GL_DEPTH_TEST);

gl.glDepthFunc(GL.GL_LEQUAL);

gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);

}

public void reshape(GLAutoDrawable gLDrawable, int x, int y, int width,

int height) {

final GL gl = gLDrawable.getGL();

if (height <= 0)

height = 1;

final float h = (float) width / (float) height;

gl.glViewport(0, 0, width, height);

gl.glMatrixMode(GL.GL_PROJECTION);

gl.glLoadIdentity();

glu.gluPerspective(45.0f, h, 1.0, 20.0);

gl.glMatrixMode(GL.GL_MODELVIEW);

gl.glLoadIdentity();

}

public static void main(String[] args) {

Frame frame = new Frame("Pyramid");

GLCanvas canvas = new GLCanvas();

canvas.addGLEventListener(new Pyramid());

frame.add(canvas);

frame.setSize(640, 480);

final Animator animator = new Animator(canvas);

frame.addWindowListener(new WindowAdapter() {

@Override

public void windowClosing(WindowEvent e) {

new Thread(new Runnable() {

public void run() {

animator.stop();

System.exit(0);

}

}).start();

}

});

frame.setLocationRelativeTo(null);

frame.setVisible(true);

animator.start();

}

}

Output:

Analisa Hasil

Untuk pembuatan pyramid ini sebenarnya tidak jauh berbeda seperti

pembuatan kubus, perbedaannya hanya pada modifikasi method display.

Penggambaran objek dimulai dengan gl.glBegin(GL.GL_TRIANGLES);

kemudian dilanjutkan dengan pembuatan vertex-vertexnya.

Pembuatan sisi depan dengan perintah:

gl.glColor3f(1.0f, 1.0f, 0.0f); // Set warna kuning

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (depan)

gl.glVertex3f(-1.0f, -1.0f, 1.0f); // Left Of Triangle (depan)

gl.glVertex3f(1.0f, -1.0f, 1.0f); // Right Of Triangle (depan)

Pembuatan sisi kanan dengan perintah:

gl.glColor3f(0.4f, 1.0f, 1.0f); // Set warna biru muda

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (Right)

gl.glVertex3f(1.0f, -1.0f, 1.0f); // Left Of Triangle (Right)

gl.glVertex3f(1.0f, -1.0f, -1.0f); // Right Of Triangle (Right)

Pembuatan sisi belakang dengan perintah:

gl.glColor3f(0.5f, 0.1f, 1.0f); //Set warna ungu

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (Back)

gl.glVertex3f(1.0f, -1.0f, -1.0f); // Left Of Triangle (Back)

gl.glVertex3f(-1.0f, -1.0f, -1.0f); // Right Of Triangle (Back)

Pembuatan sisi kiri dengan perintah:

gl.glColor3f(1.0f, 0.0f, 1.0f); // Set warna pink

gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top Of Triangle (Left)

gl.glVertex3f(-1.0f, -1.0f, -1.0f); // Left Of Triangle (Left)

gl.glVertex3f(-1.0f, -1.0f, 1.0f); // Right Of Triangle (Left)

Pembuatan objek diakhiri dengan gl.glEnd();

Untuk statement-statement yang lain penjelasannya masih sama seperti pada

pembuatan kubus.

BAB 3

PENUTUP

Kesimpulan

o Objek 3D merupakan objek yang dibentuk dari beberapa koordinat (X,Y,Z)

yang dihubungkan.

o Sebuah titik dapat digeser atau ditranslasikan.

o Sebuah objek dapat diperbesar atau diperkecil, dan berotasi (Mengelilingi

Sumbu Z).

o Prinsip-prinsip dasar dalam pemrograman 3D: metode rendering dan sistem

koordinat.

o sistem koordinat : koordinat kartesian 2D, koordinat klipping, viewport, vertex

penggambaran, koordinat kartesian 3D, dan proyeksi.

o Tahapan-tahapan pemodelan 3D: Motion Capture/Model 2D,Dasar Metode

Modeling 3D, Proses rendering, Texturing, Image and Display.

Saran dan Kritik

Kami sadar bahwa laporan kami tidaklah sempurna, banyak kekurangan

yang terdapat didalamnya. Jadi, kami harapkan laporan ini disetujui oleh dosen

pembimbing dan kami membutuhkan kritik dan saran yang sifatnya mendukung

dan membangun, agar program aplikasi yang kami buat dapat terlaksana dengan

baik.