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.