Post on 02-Aug-2015
description
GRAFIKA KOMPUTER
SIMULASI GERAK BULAN, BUMI DAN MATAHARI
Makalah ini disusun untuk memenuhi UTS matakuliah Grafika Komputer
Oleh :
JesichaDwiAyuMayasari 105090607111017
Alfa Ridhoana 105090613111003
PROGRAM STUDI ILMU KOMPUTER
JURUSAN MATEMATIKA
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
UNIVERSITAS BRAWIJAYA
MALANG
2012
BAB I
PENDAHULUAN
1.1 Latar Belakang
Simulasi dalam 3d modeling biasanya sangat efektif untuk digunakan
sebagai metode pembelajaran. Selain itu, 3d modeling juga digunakan sebagai
media simulasi, misalnya simulasi dalam bidang kedokteran untuk melakukan
virtualisasi pembedahan, virtualisasi pilot mengemudikan pesawat dan lain
sebagainya. Dalam menciptakan sebuah pembelajaran yang efektif dibutuhkan suatu
metode pembelajaran yang efektif pula. Dewasa ini, salah satu masalah pendidikan
di Indonesia adalah kurangnya penerapan metode pembelajaran yang efektif yang
dapat membawa siswa mengimajinasikan suatu materi yang abstrak menjadi lebih
nyata yang dapat membuat siswa lebih mengerti tentang materi yang mereka
pelajari.
Berbicara metode pembelajaran, takkan lepas dari media pembelajaran
yang akan digunakan dalam metode yang digunakan. Banyak media pembelajaran
yang digunakan, baik itu bersifat konvensional (tradisional) maupun yang
berkembang mengikuti pesatnya perkembang-an teknologi. Melihat fenomena
tersebut, tak ada salahnya untuk memanfaatkan teknologi saat ini yang semakin
canggih dalam menerapkan sebuah metode yang mengajak siswa untuk berimajinasi
dan mendeskripsikan hal yang abstrak menjadi sesuatu yang mudah dibayangkan
dan dimengerti. Oleh karena itu dalam makalah ini akan dibahas mengenai simulasi
gerak bulan, bumi dan matahari yang mana hal ini terkait dengan metode
pembelajaran. Namun di sini, akan dijelaskan beberapa mengenai simulai tersebut
termasuk juga implementasinya ke dalam program Delphi.
1.2 Rumusan Masalah
1. Apa yang dimasud dengan simulasi 3D Modelling?
2. Metode apa saja dalam simulasi 3D itu bisa diterapkan?
3. Apa manfaat diterapkannya simulasi 3D Modelling dalam kehidupan?
4. Bagaimana implementasi simulasi gerak bulan, bumi dan matahari dalam
program Delphi?
1.3 Tujuan
1. Mengetahui dan memahami definisi dari simulasi 3D Modelling.
2. Mengetahui metode yang dapat diterapkan dalam simulasi 3D.
3. Mengetahui manfaat diterapkannya simulasi 3D Modelling dalam kehidupan.
4. Mengimplementasikan simulasi gerak bulan, bumi dan matahri dalam bentuk
program Delphi.
BAB II
PEMBAHASAN
2.1 Definisi Simulasi 3D Modelling
Simulasi 3D modeling adalah pembentukan karakter atau metode 3
dimensi (seperti dalam dunia nyata) dengan menggunakan teknik dan alat yang
disediakan oleh perangkat lunak komputer. Produk yang dihasilkan ini disebut
sebagai metode 3D. Metode 3D mewakili objek 3D menggunakan koleksi poin
dalam ruang 3D, dihubungkan dengan berbagai entitas geometris seperti segitiga,
garis, permukaan lengkung dan sebagianya. Metode 3D menggunakan koordinat x,
y dan z yang memungkinkan kita dapat melihat sudut pandang objek secara lebih
nyata.
Model 3D mewakili objek 3D menggunakan kumpulan titik dalam ruang
3D, Dihubungkan dengan berbagai entitas geometris seperti segitiga, garis,
permukaan lengkung, dan sebagainya. Menjadi kumpulan data (titik dan informasi
lainnya), 3D model dapat diciptakan melalui karya tangan, secara algoritma atau
permodelan procedural, serta melalui proses scan. Melihat objek secara tiga dimensi
(3D) berarti melihat objek dalam bentuk sesungguhnya. Penggambaran 3D akan
lebih memperjelas maksud dan perancangan objek karena bentuk sesungguhnya dari
objek yang akan diciptakan divisualisasikan secara nyata.
3D model banyak digunakan dalam grafik 3D (3D graphic). Penggunaan
3D graphic tersebut dimulai dari personal computer. Sebelum Komputer dapat
menggubah image secara real time, banyak game komputer menggunakan pre-
render image dari 3D model.
2.2 Metode dalam Simulasi 3D
2.2 1 Metode 3D
Seperi halnya yang sudah dijelaskan dalam subbab sebelumnya mengenai
definisi simulasi 3D modeling, maka dapat dikatakan hampir semua metode 3D
dapat dibagi menjadi dua kategori, yaitu:
1. Solid – Metode-metode ini menentukan volume objek yang mereka wakili
(seperti batu). Ini lebih realistis, tapi lebih sulit untuk membangun. Metode
padat banyak digunakan untuk simulasi nonvisual seperti dalam dunia medis.
2. Shell / batas – metode ini mewakili permukaan, misalnya batas dari objek, bukan
volume (seperti kulit telur yang amat sangat tipis). Ini lebih mudah untuk
bekerja daripada metode padat. Hampir semua metode visual digunakan dalam
permainan.
Metode 3D telah banyak dimanfaatkan di segala bidang. Dalam dunia
pendidikan, metode 3D dimanfaatkan untuk membuat media pembelajaran. Media
pembelajaran seperti ini dapat menunjang metode pembelajaran. Pemanfaatan
metode 3D bertujuan untuk mempermudah mempelajari suatu materi, khususnya
pada materi yang konsepnya bersifat abstrak atau konsep tersebut sulit untuk
diwujudkan dalam kehidupan nyata. Hal ini dapat diimplementasikan melalui media
pembelajaran animasi 3D, dimana objek-objek yang ada dimetodekan ke dalam
bentuk 3 dimensi. Animasi 3D visual sehingga dapat dengan mudah dipelajari oleh
peserta didik. Animasi 3D berbentuk simulasi dapat membawa peserta didik
mempelajari materi yang sulit dibayangkan, misalnya materi tata surya.
Berdasarkan penjealasan di atas, maka dapat pula dikatakan ada lima
metode popular dalam pemodelan 3D, yaitu :
1. Polygonal modeling
Titik pada ruang 3D, yang disebut simpul, terhubung dengan segmen
garis membentuk suatu poligonal mesh. Sebagian besar model 3D saat ini
dibangun sebagai model polygonal bertekstur, karena bersifat fleksibel dan
komputer dapat me-render dengan sangat cepat. 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 terbagis ejumlah pecahan polygon. Hal tersebutlah yang menjadi
kekurangan polygon, yaitu terletak pada sifat planar polygon sehingga hanya
dapat mendekati permukaan lengkung menggunakan banyak polygon.
2. NURBS modeling
Merupakan proses permodelan yang popular saat ini. NURBS adalah
cara pemodelan permukaan secara parametrik yang umumnya digunakan dalam
grafik komputer. NURBS bersifat lebih universal dari Bezier Spline atau B-
spline karena selain bisa memodelkan sebarang permukaan ia bisa memodelkan
geometri analitik seperti lingkaran, elipsis, bola, dan lain-lain. 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.
3. Splines & Patches modeling
Seperti NURBS, Splines dan Patch tergantung pada garis lengkung untuk
menentukan permukaan yang terlihat. Dalam hal fleksibilitas dan kemudahan
penggunaan, Spline dan Patch terletak diantara pemodelan poligondan NURBS.
4. Primitives modeling
Prosedur pemodelan ini memerlukan bentuk-bentuk geometri primitive
seperti bola, silinder, kerucut atau kubus. pemodelan primitif cocok untuk pada
aplikasi teknis tetapi kurang digunakan untuk bentuk-bentuk organic. Beberapa
perangkat lunak 3D dapat merender secara langsung dari bentuk primitive, tetapi
sebagian perangkat lunak lainnya hanya dapat dipergunakan untuk pemodelan
yang kemudian mengkonversikannya ke dalam bentuk mesh untuk render
ataupun proses selanjutnya.
5. Sculpt modeling
Merupakan metode baru dalam pemodelan 3D. metode ini cukup popular
dalam beberapa tahun terakhir ini. Memiliki 2 tipe yaitu Displacement dan
volumetric. Kedua tipe tersebut memungkinkan untuk eksplorasi dan
menciptakan suatu model topologi dan memungkinkan perincian setelah proses
sculpt.
2.2.2 Koordinat 3D
Koordinat 3D dalam ruang koordinat
Dalam 3D, penggambaran penampilan objek 3D bermain didalam 3
ruang koordinat yaitu X, Y, Z.
Koordinat kartesius
Koordnat kartesius, format umumnya adalah (x,y,z)
Koordinat Polar
Format umum @jarak. Misal : @4<30<45
2.2.3 Sistem Koordinat 3D
1. WCS (world coordinate system)
WCS adalah koordinat yang posisi dan arahnya selalu tetap dan
bersifat absolute. Disini arah sumbu x, y, zyang anda masukan selalu dihitung
dari titik acuan yang sama, tidak tergantung dari arah pandangan saat ini.
2. UCS (user coordinate system)
UCS adaalh system koordianat yang dapat diubah-ubah (dipindah dan
dirotasikan) sesuai dengan keinginan pengguna.
2.2.4 Tipe Objek 3D
1. Wireframe
Adalah objek yang hanya terdiri atas garis lurus dan garis lengkung
yang mempresentasikan tepi-tepi objek tanpa permukaan tertutup. Tipe ini
mempergunakan objek 2D yang digambarkan dalam ruang 3D.
2. Surface
Adalah obkjek yang tersususn atas permukaan. Objek ini dapat
diibaratkan seperti didinding tipis pada sebuah kotak, objek surface tidak
memiliki volume (kosong). Surface dapat dipakai untuk benda-benda
fleksibel, seperti : badan mobil, badan pesawat, pohon, dan lainnya.
3. Solid
Memiliki mass properties. Hal tersebut menunjukan bahwa objek
solid merupakan benda yang padat dan memiliki titik berat.
2.3 Manfaat Penerapan 3D Modelling dalam Kehidupan
Saat ini, 3D model digunakan dalam berbagai bidang. Industri medis
menggunakan detail dari organ. Dalam industri perfilman, 3D model digunakan
sebagai karakter dan objek untuk film animasi. Industri game menggunakannya
sebagai asset computer dan video game. Pada sector ilmu pengetahuan digunakan
untuk menggambarkan dengan terperinci senyawa kimia. Industri arsitektur
menggunakannya untuk mendemonstrasikan rancangan bangunan dengan
menggunakan Software Architectural Models. Komunitas teknisi menggunakannnya
untuk mendesain piranti baru, kendaraan, serta kegunaan lainnya. Pada abad ini,
komunitas ilmuwan telah mulai membangun model geologi 3D sebagai pelatihan
standar.
2.4 Implementasi Simulasi Gerak Bulan, Bumi dan Matahari
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls,
Forms, Dialogs, OpenGL,
ExtCtrls, StdCtrls, ComCtrls, Menus,Math;
type
TCoord = Record
X, Y, Z : glFLoat;
end;
TForm1 = class(TForm)
Panel1: TPanel;
Panel2: TPanel;
Button1: TButton;
Button5: TButton;
Button6: TButton;
Timer1: TTimer;
Timer2: TTimer;
Timer3: TTimer;
procedure FormCreate(Sender: TObject);
procedure Panel1Resize(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormKeyPress(Sender: TObject; var Key: Char);
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure GroupBox4Click(Sender: TObject);
procedure ShowStart1Click(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
procedure Panel1MouseDown(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Panel1MouseUp(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Timer2Timer(Sender: TObject);
procedure Button5MouseDown(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Button6MouseDown(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Button6MouseUp(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Button5MouseUp(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Timer3Timer(Sender: TObject);
private
{ Private declarations }
rc : HGLRC; // Rendering Context
dc : HDC; // Device Context
ElapsedTime, AppStart, LastTime : DWord; // Timing
variables
g_CurrentTime : GLfloat; // This is the current position
of the sphere along the curve (0 to 1)
procedure glDraw;
procedure Idle(Sender: TObject; var Done: Boolean);
procedure glInit;
procedure SetArrayLength;
procedure UpdateTextValues;
procedure DoUpDown(txtBox : TEdit;Button: TUDBtnType);
procedure UpdatePointValues();
public
{ Public declarations }
end;
const
MAX_STEPS = 38.0;
BALL_SPEED = 0.02;
var
Form1: TForm1;
g_CurrentTime : GLfloat;
rotateY : GLfloat;
zView : GLfloat;
zViewModifier : glFloat;
year: GLfloat = 0;
day : GLfloat = 0;
hour : GLfloat = 0;
implementation
{$R *.DFM}
procedure TForm1.glDraw();
var pSphere : GLUquadricObj;
begin
pSphere := gluNewQuadric();
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
// Clear The Screen And The Depth Buffer
glLoadIdentity();
// Reset The matrix
gluLookAt(0, 0.5, zView, 0, 1, 0, 0, 1, 0); // Set
up our camera position and view
glDisable(GL_LIGHTING);
// Disable lighting for now
glEnable(GL_LIGHTING);
// Turn lighting back on
glPushMatrix(); // Copy the
curent matrix and add it to the stack
glColor3f (1.0, 1.0, 0.0); // Set colour
to Yellow
gluSphere(pSphere, 1.5, 32, 32); // draw sun
glRotatef(year, 0.0, 1.0, 0.0); // Rotate
according to sun
glTranslatef (3.0, 0.0, 0.0); // Translate 2
units away from the sun
glRotatef(day, 0.0, 1.0, 0.0); // Rotate the
planet according to the time of day
glColor3f (0.0, 1.0, 0.0); // Set colour
to green
gluSphere(pSphere, 0.3, 32, 32); // Draw smaller planet
glPushMatrix(); // Copy the
curent matrix and add it to the stack
glColor3f(0.5,0.5,0.5); // Set colour
to grey
glTranslatef (0.5, 0.0, 0.0);
glRotatef(hour, 0.0, 1.0, 0.0);
gluSphere(pSphere, 0.1, 32, 32);// Draw Moon
glEnd();
end;
{------------------------------------------------------------
------}
{ Initialise OpenGL
}
{------------------------------------------------------------
------}
procedure TForm1.glInit();
begin
glClearColor(0.0, 0.0, 0.0, 0.0); // Black
Background
glShadeModel(GL_SMOOTH); // Enables Smooth
Color Shading
glClearDepth(1.0); // Depth Buffer
Setup
glEnable(GL_DEPTH_TEST); // Enable Depth
Buffer
glDepthFunc(GL_LESS); // The Type Of Depth
Test To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
//Realy Nice perspective calculations
glEnable(GL_LIGHT0);
// Turn on this light
glEnable(GL_LIGHTING);
// Turn lighting on
glEnable(GL_COLOR_MATERIAL);
// Since lighting is on, allow glColor*() functions
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
g_CurrentTime := 0.0;
// This is the current position of the sphere along the
curve (0 to 1)
zView := 10.0;
end;
{------------------------------------------------------------
------}
{ Create the form and initialist openGL
}
{------------------------------------------------------------
------}
procedure TForm1.FormCreate(Sender: TObject);
var pfd : TPIXELFORMATDESCRIPTOR;
pf : Integer;
begin
Form1.Caption:='Molekul Sederhana';
// OpenGL initialisieren
dc:=GetDC(Panel1.Handle);
// PixelFormat
pfd.nSize:=sizeof(pfd);
pfd.nVersion:=1;
pfd.dwFlags:=PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL or
PFD_DOUBLEBUFFER or 0;
pfd.iPixelType:=PFD_TYPE_RGBA; // PFD_TYPE_RGBA or
PFD_TYPEINDEX
pfd.cColorBits:=32;
pf :=ChoosePixelFormat(dc, @pfd); // Returns format that
most closely matches above pixel format
SetPixelFormat(dc, pf, @pfd);
rc :=wglCreateContext(dc); // Rendering Context =
window-glCreateContext
wglMakeCurrent(dc,rc); // Make the DC (Form1) the
rendering Context
// Initialist GL environment variables
glInit;
Panel1Resize(sender); // sets up the perspective
AppStart :=GetTickCount();
// when the app has spare time, render the GL scene
Application.OnIdle := Idle;
end;
{------------------------------------------------------------
------}
{ Release rendering context when form gets detroyed
}
{------------------------------------------------------------
------}
procedure TForm1.FormDestroy(Sender: TObject);
begin
wglMakeCurrent(0,0);
wglDeleteContext(rc);
end;
{------------------------------------------------------------
------}
{ Application onIdle event
}
{------------------------------------------------------------
------}
procedure TForm1.Idle(Sender: TObject; var Done: Boolean);
begin
Done := FALSE;
LastTime :=ElapsedTime;
ElapsedTime :=GetTickCount() - AppStart; // Calculate
Elapsed Time
ElapsedTime :=(LastTime + ElapsedTime) DIV 2; // Average it
out for smoother movement
glDraw(); // Draw the scene
SwapBuffers(DC); // Display the scene
end;
{------------------------------------------------------------
------}
{ If the panel resizes, reset the GL scene
}
{------------------------------------------------------------
------}
procedure TForm1.Panel1Resize(Sender: TObject);
begin
glViewport(0, 0, Panel1.Width, Panel1.Height); // Set
the viewport for the OpenGL window
glMatrixMode(GL_PROJECTION); // Change Matrix Mode
to Projection
glLoadIdentity(); // Reset View
gluPerspective(45.0, Panel1.Width/Panel1.Height, 1.0,
500.0); // Do the perspective calculations. Last value = max
clipping depth
glMatrixMode(GL_MODELVIEW); // Return to the
modelview matrix
end;
{------------------------------------------------------------
------}
{ Monitors all keypress events for the app
}
{------------------------------------------------------------
------}
procedure TForm1.FormKeyPress(Sender: TObject; var Key:
Char);
begin
if Key = char(VK_LEFT) then // If we hit the
LEFT arrow
begin
g_CurrentTime := g_CurrentTime - BALL_SPEED;
// Increase the position of the ball along the curve
if g_CurrentTime < 0 then
// If we go below 0
begin
g_CurrentTime := 0; // Set
it back to 0
end;
end;
if Key = char(VK_RIGHT) then // If we hit the
Right arrow
begin
g_CurrentTime := g_CurrentTime + BALL_SPEED;
// Increase the position of the ball along the curve
if g_CurrentTime > 1 then
// If we go below 0
begin
g_CurrentTime := 1; // Set
it back to 0
end;
end;
if Key = #27 then
Close;
end;
{------------------------------------------------------------
------------}
{ Close the application
}
{------------------------------------------------------------
------------}
procedure TForm1.Button1Click(Sender: TObject);
begin
Close;
end;
{------------------------------------------------------------
------------}
{ Apply button
}
{------------------------------------------------------------
------------}
procedure TForm1.Button2Click(Sender: TObject);
begin
UpdatePointValues();
end;
{------------------------------------------------------------
------------}
{ Set the value of the target textBox higher or lower
}
{------------------------------------------------------------
------------}
procedure TForm1.DoUpDown(txtBox : TEdit;Button: TUDBtnType);
begin
if Button = btPrev then
begin
txtBox.Text := FloatToStr(StrToFloat(txtBox.Text) -
0.01);
end
else
begin
txtBox.Text := FloatToStr(StrToFloat(txtBox.Text) +
0.01);
end;
UpdatePointValues();
end;
{ Event Handlers for UpDowns
}
{------------------------------------------------------------
------------}
{ Increment Control point array sizes
}
{------------------------------------------------------------
------------}
procedure TForm1.SetArrayLength();
begin
end;
{------------------------------------------------------------
------------}
{ Update the text values from the control point arrays
}
{------------------------------------------------------------
------------}
procedure TForm1.UpdateTextValues();
begin
end;
{------------------------------------------------------------
------------}
{ Update the control point array values from the text boxes
}
{------------------------------------------------------------
------------}
procedure TForm1.UpdatePointValues();
begin
end;
{------------------------------------------------------------
------------}
{ Highlight Control point 2
}
{------------------------------------------------------------
------------}
procedure TForm1.GroupBox4Click(Sender: TObject);
begin
end;
{------------------------------------------------------------
------------}
{ Highlight Control point 3
}
{------------------------------------------------------------
------------}
{------------------------------------------------------------
------------}
{ Show/Hide start position
}
{------------------------------------------------------------
------------}
procedure TForm1.ShowStart1Click(Sender: TObject);
begin
// ShowStart1.Checked := not ShowStart1.Checked
end;
{------------------------------------------------------------
------------}
{ Set Y rotation when mouseclick occurs on panel
}
{------------------------------------------------------------
------------}
procedure TForm1.Timer1Timer(Sender: TObject);
var mpos : TPoint;
begin
GetCursorPos(mpos);
if mpos.X > Panel1.Width div 2 then
begin
rotateY := rotateY + mpos.X/10000;
day := day+ mpos.X/100;
hour := hour+ mpos.X/500;
year := year+ mpos.X/1000;
end
else
begin
rotateY := rotateY - (mpos.X+1000)/10000;
day := day- mpos.X/100;
hour := hour- mpos.X/500;
year := year- mpos.X/1000;
end;
end;
{------------------------------------------------------------
------------}
{ Enable Y rotation
}
{------------------------------------------------------------
------------}
procedure TForm1.Panel1MouseDown(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
Timer1.Enabled := true;
end;
{------------------------------------------------------------
------------}
{ Disable Y rotation
}
{------------------------------------------------------------
------------}
procedure TForm1.Panel1MouseUp(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
Timer1.Enabled := false;
end;
{------------------------------------------------------------
------------}
{ Zoom scene in or out depending on zViewModifier
}
{------------------------------------------------------------
------------}
procedure TForm1.Timer2Timer(Sender: TObject);
begin
zView := zView + zViewModifier;
end;
{------------------------------------------------------------
------------}
{ Enable Zoom out
}
{------------------------------------------------------------
------------}
procedure TForm1.Button5MouseDown(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
zViewModifier := 0.1;
timer2.Enabled := true;
end;
{------------------------------------------------------------
------------}
{ Enable Zoom in
}
{------------------------------------------------------------
------------}
procedure TForm1.Button6MouseDown(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
zViewModifier := -0.1;
timer2.Enabled := true;
end;
{------------------------------------------------------------
------------}
{ Disable Zoom in
}
{------------------------------------------------------------
------------}
procedure TForm1.Button6MouseUp(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
timer2.Enabled := false;
end;
{------------------------------------------------------------
------------}
{ Disable Zoom out
}
{------------------------------------------------------------
------------}
procedure TForm1.Button5MouseUp(Sender: TObject; Button:
TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
timer2.Enabled := false;
end;
{------------------------------------------------------------
------------}
{ Re-initialise Point Arrays and TextBoxes (New Curve)
}
{------------------------------------------------------------
------------}
procedure TForm1.Timer3Timer(Sender: TObject);
begin
Timer1.Enabled := false;
//DrawScene;
Yield;
Timer1.Enabled := true;
end;
end.
BAB III
PENUTUP
Kesimpulan
Dengan manggunakan multimedia pembelajaran, yaitu penerapan Simulasi 3D
Modelling, maka tujuan pembelajaran akan lebih mudah untuk dicapai. 3D Modeling
mempermudah penyampaian materi yang abstrak menjadi terlihat lebih nyata. Dalam
program yang telah diimplementasikan, yaitu simulasi gerak bulan, bumi dan matahari
ini sangat terkait dengan materi pembelajaran. Hal ini bisa mempermudah seseorang
untuk mengimajinasikan bagaimana bulan berevolusi terhadap bumi dan mengikuti
berevolusi terhadap matahari beserta bumi. Selain itu, juga diketahui rotasi dari bumi
dan bulan itu sendiri. Dalam implementasi program ini, digunakan OpenGL sebagai
piranti untuk mempermudah dalam pembuatan objek agar dapat berotasi dan berevolusi.
Karena dalam OpenGL sudah disediakan fasilitas siap pakai, jadi tidak perlu
memikirkan bagaimana rumus atau formula yang digunakan.
Saat ini, 3D model digunakan dalam berbagai bidang. Industri medis
menggunakan detail dari organ. Dalam industri perfilman, 3D model digunakan sebagai
karakter dan objek untuk film animasi. Industri game menggunakannya sebagai asset
computer dan video game.
DAFTAR PUSTAKA
Alat Peraga Pembelajaran, 2009 (http://gurupembaharu.com/pembelajaran_/proses/alat-
peraga-pembelajaran/). Diakses pada tanggal 13 Mei 2012.
Danisius, A. 2009. Pemodelan Karakter 3D.
http://riquripu.blogspot.com/2009/12/pemodelan-karakter-3d.html. Diakses pada
tanggal 13 Mei 2012.
Sudrajat, Akhmad. 2008. Konsep 3D dalam Pembelajaran.
(http://akhmadsudrajat.wordpress.com/2008/01/22/konsep-pakem/). Diakses pada
tanggal 13 Mei 2012.
Parto, S. 2009. Simulasi 3D dalam Pembedahan.
http://www.henindo.co.id/index.php/aplikasi/kendalimutu/pesawatterbang/17-msms.
Diakses pada tanggal 13 Mei 2012.