Tugas Besar Grafika Komputer

Pembuatan Objek 3D Menggunakan OpenGL

Diajukan untuk Memenuhi Tugas Grafika Komputer

Fakultas Teknik dan Ilmu Komputer

Universitas Komputer Indonesia

Kelompok - IF10

Abidin Satya Wirawan / 10109406

Dadan Ramdani Fadilah / 10109446

Teguh Pribadhi / 10109447

JURUSAN TEKNIK INFORMATIKAFAKULTAS TEKNIK DAN ILMU KOMPUTER

UNIVERSTAS KOMPUTER INDONESIA2013

i

Daftar Isi

DAFTAR ISI ...................................................................................................................... i

BAB I PENDAHULUAN .................................................................................................. 1

1.1................................................................................................................................... Latar Belakang ................................................................................................................ 2

1.2................................................................................................................................... Rumusan Masalah ........................................................................................................ 3

1.3................................................................................................................................... Bata

san Masalah .............................................................................................................. 3

BAB II ISI .......................................................................................................................... 4

2.1. Tema Program ......................................................................................................... 4

2.2. Deskripsi Objek Program ........................................................................................ 4

2.3. Bahasa Pemrograman yang digunakan ................................................................... 4

2.4. Progres .................................................................................................................... 5

2.5. Perencanaan Kerja .................................................................................................. 5

2.6. Tampilan Program .................................................................................................. 6

2.7. Interaksi Objek dengan Mouse dan Keyboard ........................................................ 8

BAB III KESIMPULAN DAN SARAN ............................................................................ 9

3.1. Kesimpulan ............................................................................................................. 9

3.2. Saran ....................................................................................................................... 9

LAMPIRAN ....................................................................................................................... 10

DAFTAR PUSTAKA ......................................................................................................... 21

1

BAB IPENDAHULUAN

1.1. Latar Belakang

Grafika komputer (bahasa Inggris: computer graphics) adalah bagian dari ilmu

komputer yang berkaitan dengan pembuatan dan manipulasi gambar (visual) secara

digital. Bentuk sederhana dari grafika komputer adalah grafika komputer 2D yang

kemudian berkembang menjadi grafika komputer 3D, pemrosesan citra (image

processing), dan pengenalan pola (pattern recognition). Grafika komputer sering dikenal

juga dengan istilah visualisasi data.

Bagian dari grafika komputer meliputi Geometri yaitu mempelajari cara

menggambarkan permukaan bidang. Animasi yaitu mempelajari cara menggambarkan

dan memanipulasi gerakan. Rendering yaitu mempelajari algoritma untuk menampilkan

efek cahaya. Citra (Imaging) yaitu mempelajari cara pengambilan dan penyuntingan

gambar.

Salah satu aplikasi yang digunakan pada Grafika Komputer adalah OpenGL.

Fungsi dasar dari OpenGL adalah untuk mengeluarkan koleksi perintah khusus atau

executable ke sistem operasi. Dengan demikian, program ini bekerja dengan perangkat

keras grafis yang ada yang berada pada hard drive atau sumber tertentu lainnya. Setiap

perintah dalam dirancang untuk melakukan tindakan tertentu, atau memulai efek khusus

tertentu yang terkait dengan grafis.

Pada Program ini menggunakan OpenGL yang dimiliki oleh Bahasa

Pemrograman Java yaitu LWJGL (Lightweight Java Game Library). Objek-objek yang

dibuat terdiri dari 3 Pyramid, 1 bulan, permukaan pasir sebagai alasnya dan kumpulan

beberapa bintang. Sebagai inputan kamera digunakan keyboard dan mouse. Pyramid,

bulan dan permukaan pasir menggunakan texture yang diatur sedemikian rupa sehingga

terlihat seperti nyata.

2

1.2. Rumusan Masalah

Dari Latar belakang yang telah diuraikan, didapatkan rumusan masalah sebagai

berikut :

1. Membuat objek 3D menggunakan LWJGL

2. Belajar mengatur vertex sehingga membentuk objek 3D

3. Menginputkan texture ke dalam objek 3D

1.3. Batasan Masalah

Batasan masalah dari Program ini adalah :

1. Permukaan pasir hanya bisa dilihat dari atas

2. Objek bintang berupa titik

3. Background berwarna hitam

3

BAB II

ISI

2.1. Tema Program

Tema dari program pembuatan objek menggunakan openGL ini adalah

pembuatan objek yang terdiri dari beberapa objek yang membentuk sebuah area padang

pasir yang meliputi objek Piramid ,pasir ,bulan dan titik-titik yang menyerupai bintang.

2.2. Deskripsi Objek Program

Objek utama pada program ini merupakan pencitra dari beberapa objek yang

digabungkan dengan menonjolkan teksture gambar pada objek dan pencahayaan.

Objek-objek yang ada dalam program tersebut berupa :

1. Pasir : Pasir dibuat dengan texture menyerupai pasir.

2. Piramida : Piramida dibuat dengan penggabungan bangun segitiga yang

didesign sedemikian rupa menyerupai piramida dengan merapatkan 2

buah objek tersebut menggunakan vertex serta pemberian texture

gambar piramida .

3. Bulan : Bulan dibuat dengan Sphere serta texture bulan.

4. Bintang : Bintang dibuat menggunakan titik-titik yang dibuat dengan

GL_POINT.

2.3. Bahasa Pemrograman Yang Digunakan

Bahasa pemrograman yang digunakan adalah Java dengan menggunakan aplikasi

OpenGL LWJGL serta menggunakan Tools Netbeans IDE versi 7.3.1 dan JDK 7.20

serta media penyimpanan github.

4

2.4. Progres

Tahapan Pembuatan Perogram :

1. Merancang dan menetapkan konsep program yang akan dibuat.

2. Pengumpulan bahan dan referensi dari berbagai media.

3. Analisis dan prediksi pembuatan design.

4. Pembuatan program.

5. Pembuatan laporan.

2.5. Perencanaan Kerja

Proses dalam pembuatan objek bangun ruang piramid 3D ini meliputi tahapan

yang di lalui dalam perencanaan pembangunan, diantaranya :

1. Perancangan Konsep.

- Mencari referensi dalam pembuatan objek.

- Menetapkan konsep yang sudah dipilih dari referensi-referensi yang sudah ada.

- Merancang konsep yang sudah di buat.

2. Perancangan Kebutuhan.

- Menganalisa objek apa saja yang akan dibuat.

- Menentukan tools yang akan dipakai dalam pembuatan objek.

- Menetukan aplikasi yang dipakai dalam pembuatan objek, dalam hal ini aplikasi

yang dipakai adalah OpenGL dalam Netbeans.

- Merancang struktur letak desain objek.

3. Pembuatan Laporan.

2.6. Pembagian Kerja

Pembagian kontribusi dalam pengerjaan tugas ini dibagi menjadi sedemikian

rupa, agar pengerjaan dalam tugas menjadi ringan.

Abidin Satya (10109406) Pembuatan aplikasi (objek piramid, bulan,

pasir), design, laporan

Dadan Ramdani (10109446) Pembuatan aplikasi (objek bintang), laporan

5

Teguh Pribadhi (10109447) Pembuatan apliaksi (objek pasir), design

2.7. Tampilan Program

Tampilan awal saat di running

6

Tampilan pencahayaan

Tampilan bulan dan bintang

Tampilan view dari atas

7

2.8. Interaksi Objek Dengan Mouse Dan Keyboard

Objek ini dapat berinteraksi dengan mouse dan beberapa fungsi yang dapat dijalankan

dengan navigasi keyboard ataupun huruf sebagai berikut:

Keyboard

Tombol Fungsi

A Tombol arah kiri

S Tombol arah bawah

D Tombol arah kanan

W Tombol arah atas

Panah Atas Tombol arah atas

Panah Bawah Tombol arah bawah

Panah Kanan Tombol arah kanan

Panah Kiri Tombol arah kiri

Mouse

Klik Fungsi

8

Kanan Cursor Out

Kiri Cursor In

BAB III

Kesimpulan Dan Saran

3.1. Kesimpulan

Segala suatu objek yang nyata ataupun bangun 2D dapat diimplementasikan

kedalam suatu bentuk bangun ruang yaitu berbentuk 3D dengan komputer. Dalam

pembuatan bangun ruang 3D ataupun 2D ini didapatkan dalam matakuliah “Grafik

Komputer”.

Untuk menunjang pembuatan objek ini menjadi sebuah bentuk bangun ruang

3D ataupun 2D memerlukan sebuah software yaitu Netbeans serta penunjang jalannya

pembuatan objek dengan OpenGL disertai library LWJGL dalam memudahkan dalam

proses pembuatan objek 3D ataupun 2D.

3.2. Saran

Butuh pemahaman tentang tools yang akan menunjang dalam pembuatan

objek 3D ataupun 2D, tools disini adalah Netbeans serta aplikasi penunjangnya yaitu

9

OpenGL, sehingga untuk kedepannya objek 3D ataupun 2D yang akan dibuat dapat

mendekati kepada objek nyata.

LAMPIRAN

Class Tugas.java

import static org.lwjgl.opengl.GL11.*;

import static org.lwjgl.util.glu.GLU.*;

import static org.lwjgl.opengl.GL20.glDeleteProgram;

import static org.lwjgl.opengl.GL20.glUseProgram;

import org.lwjgl.BufferUtils;

import org.lwjgl.input.Keyboard;

import org.lwjgl.input.Mouse;

import org.lwjgl.LWJGLException;

import org.lwjgl.Sys;

import org.lwjgl.opengl.Display;

import org.lwjgl.opengl.DisplayMode;

import org.lwjgl.util.glu.Sphere;

import utility.EulerCamera;

10

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.nio.FloatBuffer;

import org.newdawn.slick.opengl.Texture;

import org.newdawn.slick.opengl.TextureLoader;

public class tugas {

private static final int[] WINDOW_DIMENSIONS = {1024, 840};

private static final float ASPECT_RATIO = (float) WINDOW_DIMENSIONS[0] / (float) WINDOW_DIMENSIONS[1];

private static final EulerCamera camera = new EulerCamera.Builder().setPosition(2.5f, 0.0f, //edit 2

8.5f).setRotation(0, 5, 0).setAspectRatio(ASPECT_RATIO).setFieldOfView(60).build(); //edit 2

private float rtri;

private long lastTime;

private int fps;

private static boolean flatten = false;

private static int shaderProgram;

private static Texture wall;

private static Texture wall2;

private static Texture moon;

private static Texture sand;

private static int sphereId;

//----------- Variables added for Lighting Test -----------//

private FloatBuffer matSpecular;

private FloatBuffer lightPosition;

private FloatBuffer whiteLight;

private FloatBuffer lModelAmbient;

//----------- END: Variables added for Lighting Test -----------//

public static void main(String[] args) {

tugas main = null;

try {

11

main = new tugas();

main.create();

main.run();

}catch(Exception e){}

if(main != null) {

main.destroy();

}

}

public tugas() {

}

public void create() throws LWJGLException {

Display.setDisplayMode(new DisplayMode(WINDOW_DIMENSIONS[0],WINDOW_DIMENSIONS[1]));

Display.setTitle("Tugas Besar");

Display.setFullscreen(true);

Display.create();

initGL();

resizeGL();

try {

// Load the wood texture from "C:/res/moon.png"

wall = TextureLoader.getTexture("PNG", new FileInputStream(new File("C:/res/pyramid5.png")));

wall2 = TextureLoader.getTexture("PNG", new FileInputStream(new File("C:/res/pyramid4.png")));

moon = TextureLoader.getTexture("PNG", new FileInputStream(new File("C:/res/moon.png")));

sand = TextureLoader.getTexture("PNG", new FileInputStream(new File("C:/res/sand3.png")));

} catch (IOException e) {

e.printStackTrace();

Display.destroy();

System.exit(1);

}

}

public void destroy() {

12

Display.destroy();

}

public void initGL() {

glShadeModel(GL_SMOOTH); // Enables Smooth Shading

glClearColor(0, 0.03f, 0, 0); // Black Background

glClearDepth(1.0f); // Depth Buffer Setup

glEnable(GL_DEPTH_TEST); // Enables Depth Testing

glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do

glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations

lastTime = Sys.getTime();

initLightArrays();

glMaterial(GL_FRONT, GL_SPECULAR, matSpecular); // sets specular material color

glMaterialf(GL_FRONT, GL_SHININESS, 10.0f); // sets shininess

glLight(GL_LIGHT0, GL_POSITION, lightPosition); // sets light position

glLight(GL_LIGHT0, GL_SPECULAR, whiteLight); // sets specular light to white

glLight(GL_LIGHT0, GL_DIFFUSE, whiteLight); // sets diffuse light to white

glLightModel(GL_LIGHT_MODEL_AMBIENT, lModelAmbient); // global ambient light

glEnable(GL_LIGHTING);// enables lighting

glEnable(GL_LIGHT0);// enables light0

//glEnable(GL_COLOR_MATERIAL); // enables opengl to use glColor3f to define material color

glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); // tell opengl glColor3f effects the ambient and diffuse properties of material

//----------- END: Variables & method calls added for Lighting Test -----------//

}

//------- Added for Lighting Test----------//

13

private void initLightArrays() {

matSpecular = BufferUtils.createFloatBuffer(4);

matSpecular.put(1.0f).put(1.0f).put(1.0f).put(1.0f).flip();

lightPosition = BufferUtils.createFloatBuffer(4);

lightPosition.put(1.0f).put(1.0f).put(1.0f).put(8.0f).flip();

whiteLight = BufferUtils.createFloatBuffer(4);

whiteLight.put(1.0f).put(1.0f).put(1.0f).put(1.0f).flip();

lModelAmbient = BufferUtils.createFloatBuffer(4);

lModelAmbient.put(0.5f).put(0.5f).put(0.5f).put(1.0f).flip();

}

public void resizeGL() {

glViewport(0,0,WINDOW_DIMENSIONS[0],WINDOW_DIMENSIONS[1]);

glMatrixMode(GL_PROJECTION); // Select The Projection Matrix

glLoadIdentity(); // Reset The Projection Matrix

// Calculate The Aspect Ratio Of The Window

gluPerspective(45.0f,(float)WINDOW_DIMENSIONS[0]/(float)WINDOW_DIMENSIONS[1],0.1f,50.0f);

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix

glLoadIdentity(); // Reset The Modelview Matrix

}

public void render() {

glEnable(GL_TEXTURE_2D);

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

camera.applyTranslations();

glTranslated(4.0f,7.0f,-7.0f);

sand.bind();

glBegin(GL_QUADS);

14

glTexCoord2f(1.0f, 0.0f);

glVertex3f(-15.0F, -8.0F, -15.0f);

glTexCoord2f(0.0f, 0.0f);

glVertex3f(-15.0F, -8.0F, 15.0f);

glTexCoord2f(0.0f, 1.0f);

glVertex3f(15.0F, -8.0F, 15.0f);

glTexCoord2f(1.0f, 1.0f);

glVertex3f(15.0F, -8.0F, -15.0f);

glEnd();

glTranslated(-2.0f,-6.0f,1.0f); // Translasi piramid ke belakang

wall.bind();

glBegin(GL_TRIANGLES); // Start Drawing The Pyramid

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 2.0f, 0.0f); // Top Of Triangle (Front)

glTexCoord2f(0.0f, 0.0f); // Green

glVertex3f(-2.0f,-2.0f, 2.0f); // Left Of Triangle (Front)

glTexCoord2f(0.0f, 1.0f); // Blue

glVertex3f( 2.0f,-2.0f, 2.0f); // Right Of Triangle (Front)

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 2.0f, 0.0f); // Top Of Triangle (Right)

glTexCoord2f(0.0f, 0.0f); // Blue

glVertex3f( 2.0f,-2.0f, 2.0f); // Left Of Triangle (Right)

glTexCoord2f(0.0f, 1.0f); // Green

glVertex3f( 2.0f,-2.0f, -2.0f); // Right Of Triangle (Right)

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 2.0f, 0.0f); // Top Of Triangle (Back)

glTexCoord2f(0.0f, 0.0f); // Green

glVertex3f( 2.0f,-2.0f, -2.0f); // Left Of Triangle (Back)

glTexCoord2f(0.0f, 1.0f); // Blue

glVertex3f(-2.0f,-2.0f, -2.0f); // Right Of Triangle (Back)

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 2.0f, 0.0f); // Top Of Triangle (Left)

15

glTexCoord2f(0.0f, 0.0f); // Blue

glVertex3f(-2.0f,-2.0f,-2.0f); // Left Of Triangle (Left)

glTexCoord2f(0.0f, 1.0f); // Green

glVertex3f(-2.0f,-2.0f, 2.0f); // Right Of Triangle (Left)

glEnd(); // Done Drawing The Pyramid

glTranslated(4.0f,-1.0f,-1.0f); // Translasi piramid ke belakang

wall2.bind();

glBegin(GL_TRIANGLES); // Start Drawing The Pyramid

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Front)

glTexCoord2f(0.0f, 0.0f); // Green

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

glTexCoord2f(0.0f, 1.0f); // Blue

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

glTexCoord2f(1.0f, 0.0f); // Red

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

glTexCoord2f(0.0f, 0.0f); // Blue

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

glTexCoord2f(0.0f, 1.0f); // Green

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

glTexCoord2f(1.0f, 0.0f); // Red

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

glTexCoord2f(0.0f, 0.0f); // Green

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

glTexCoord2f(0.0f, 1.0f); // Blue

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

glTexCoord2f(1.0f, 0.0f); // Red

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

glTexCoord2f(0.0f, 0.0f); // Blue

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

glTexCoord2f(0.0f, 1.0f); // Green

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

16

glEnd();

glTranslated(-1.0f,2.0f,-5.0f); // Translasi piramid ke belakang

wall.bind();

glBegin(GL_TRIANGLES); // Start Drawing The Pyramid

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 3.0f, 0.0f); // Top Of Triangle (Front)

glTexCoord2f(0.0f, 0.0f); // Green

glVertex3f(-3.0f,-3.0f, 3.0f); // Left Of Triangle (Front)

glTexCoord2f(0.0f, 1.0f); // Blue

glVertex3f( 3.0f,-3.0f, 3.0f); // Right Of Triangle (Front)

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 3.0f, 0.0f); // Top Of Triangle (Right)

glTexCoord2f(0.0f, 0.0f); // Blue

glVertex3f( 3.0f,-3.0f, 3.0f); // Left Of Triangle (Right)

glTexCoord2f(0.0f, 1.0f); // Green

glVertex3f( 3.0f,-3.0f, -3.0f); // Right Of Triangle (Right)

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 3.0f, 0.0f); // Top Of Triangle (Back)

glTexCoord2f(0.0f, 0.0f); // Green

glVertex3f( 3.0f,-3.0f, -3.0f); // Left Of Triangle (Back)

glTexCoord2f(0.0f, 1.0f); // Blue

glVertex3f(-3.0f,-3.0f, -3.0f); // Right Of Triangle (Back)

glTexCoord2f(1.0f, 0.0f); // Red

glVertex3f( 0.0f, 3.0f, 0.0f); // Top Of Triangle (Left)

glTexCoord2f(0.0f, 0.0f); // Blue

glVertex3f(-3.0f,-3.0f,-3.0f); // Left Of Triangle (Left)

glTexCoord2f(0.0f, 1.0f); // Green

glVertex3f(-3.0f,-3.0f, 3.0f); // Right Of Triangle (Left)

glEnd();

glTranslated(8.0f, 9.0f, -20.0f); // Translasi bulan (left/right side,top/bottom side,size)

//glRotatef(rtri,0.0f,-1.0f,0.0f);

17

renderSphere(-2f, -0.5f, -1f);

glCallList(sphereId);

Point[] points = new Point[200];

Random random = new Random();

for (int i = 0; i < points.length; i++) {

// I altered the zFar variable to adapt to the points.length.

// Points, no matter how much, now appear evenly distributed along the screen

points[i] = new Point((random.nextFloat() - 0.5f) * 100f, (random.nextFloat() - 0.5f) * 100f,

random.nextInt(points.length / 50) - points.length / 50);

}

glTranslatef(0, 0, 0);

glBegin(GL_POINTS);

for (Point p : points) {

glVertex3f(p.x, p.y, p.z);

}

glEnd();

rtri+=2.1f;

}

private void renderSphere(float x, float y, float z) {

Sphere sphere = new Sphere();

sphere.setDrawStyle(GLU_FILL);

sphere.setTextureFlag(true);

sphere.setNormals(GLU_SMOOTH);

sphereId = glGenLists(1);

glNewList(sphereId, GL_COMPILE);

moon.bind();

sphere.draw(1.0f, 70, 70);

glEndList();

}

private static void input() {

while (Keyboard.next()) {

if (Keyboard.getEventKeyState()) {

if (Keyboard.isKeyDown(Keyboard.KEY_F)) {

18

flatten = !flatten;

}

if (Keyboard.getEventKey() == Keyboard.KEY_L) {

// Reload the shaders and the heightmap data.

glUseProgram(0);

glDeleteProgram(shaderProgram);

}

if (Keyboard.getEventKey() == Keyboard.KEY_P) {

// Switch between normal mode, point mode, and wire-frame mode.

int polygonMode = glGetInteger(GL_POLYGON_MODE);

if (polygonMode == GL_LINE) {

glPolygonMode(GL_FRONT, GL_FILL);

} else if (polygonMode == GL_FILL) {

glPolygonMode(GL_FRONT, GL_POINT);

} else if (polygonMode == GL_POINT) {

glPolygonMode(GL_FRONT, GL_LINE);

}

}

}

}

if (Mouse.isButtonDown(0)) {

Mouse.setGrabbed(true);

} else if (Mouse.isButtonDown(1)) {

Mouse.setGrabbed(false);

}

if (Mouse.isGrabbed()) {

camera.processMouse(1, 80, -80);

}

camera.processKeyboard(25, 1);

}

private static void setUpMatrices() {

camera.applyPerspectiveMatrix();

}

private static void setUpStates() {

camera.applyOptimalStates();

19

glPointSize(2);

// Enable the sorting of shapes from far to near

glEnable(GL_DEPTH_TEST);

// Remove the back (bottom) faces of shapes for performance

glEnable(GL_CULL_FACE);

}

public void run() {

while(!Display.isCloseRequested()) {

if(Display.isVisible()) {

update();

render();

input();

setUpStates();

setUpMatrices();

}

else {

if(Display.isDirty()) {

render();

}

try {

Thread.sleep(100);

}

catch(InterruptedException ex) {

}

}

Display.update();

Display.sync(60); //fps --> 60

}

}

public void update() {

updateFPS();

}

public void updateFPS(){

if(Sys.getTime()-lastTime>1000){

20

Display.setTitle("Tugas Besar 3D OpenGL fps: "+fps);

fps = 0;

lastTime = Sys.getTime();

}

fps++;

}

private static class Point {

final float x;

final float y;

final float z;

public Point(float x, float y, float z) {

this.x = x;

this.y = y;

this.z = z;

}

}

}

DAFTAR PUSTAKA

1. http://agussale.com/penjelasan-mengenai-apa-itu-opengl

2. http://id.wikipedia.org/wiki/Grafika_komputer

3. http://lwjgl.org/forum/index.php?topic=4928.0

4. http://thecodinguniverse.com/

5. http://www.lwjgl.org/wiki/index.php?title=Main_Page

21