Pemrograman OpenGL dan Setting di CodeBlock C++

OpenGL (Open Graphics Library) adalah suatu standar API yang digunakan untuk membuat aplikasi berbasis grafik,baik untuk 2 dimensi (2D) atau 3 dimensi (3D). OpenGL dapat berjalan berbagai perangkat keras dan bahasa pemrograman. OpenGL mempunyai banyak pustaka untuk membuat grafik dengan berbagai model dan bentuk seperti permukaan quadratic atau kurva NURBS. Pustaka standar ini disebut OpenGL Unit Library Toolkit(Glut). Didalam Glut tersebut sudah terdapat berbagai fungsi, mulai aplikasi windows (windowing) sampai aplikasi grafik lainnya, sehingga tidak repot-repot mengubah kode progam jika diterapkan pada sistem operasi dan perangkat lunak yang berbeda. Untuk membuat program OpenGL ini, kita membutuhkan kompailer dan editor . Untuk bahasa pemrograman C++, bisa menggunakan perangkat lunak CodeBlock, Eclipse, Microsoft Visual C++ dan lain-lain. Semua perangkat lunak diatas merupakan IDE (Integrated Development Environment) yang didalamnya sudah ada editor kode program, compiler atau interpreter atau link ke compiler atau interpreter, builder dan debuger. Instalasi CodeBlock C++ Download CodeBlock C++ di http://www.codeblocks.org/downloads/binaries , pilih codeblocks10.05mingw-setup.exe. Setelah di download, klik 2 kali pada file dan ikuti proses install sampai dengan selesai. Instalasi OpenGL Unit Library Glut Download Glut di http://www.xmission.com/~nate/glut/glut-3.7.6-bin.zip, kemudian ekstrak file tersebut. Setelah di ekstrak akan terlihat folder glut-3.7.6-bin dengan beberapa file glut di dalamnya. Lakukan langkah-langkah berikut untuk meng-Copy file dalam folder glut-3.7.6-bin, yaitu

Copy glut32.dll ke dalam folder C:\Windows\System32 Copy glut.h ke dalam folder C:\Program Files\CodeBlocks\MinGW\include\GL Copy glut32.lib ke dalam folder C:\Program Files\CodeBlocks\MinGW\lib

Setting OpenGl di CodeBlocks dan Project 1 OpenGL Sekarang jalan kan Program CodeBlocks untuk mensetting link librarynya agar ketika menulis code program dan mengkompile dikenal oleh IDE CodeBlocks.

1. Setelah Program CodeBlock dibuka, maka klik Menu File > New > Project.. Pada New From Template box pilih OpenGL project dan klik tombol Go.

2. Kemudian tentukan nama file dan Folder akan disimpan kode program dan ikuti wizard dengan mengklik tombol Next sampai muncul muncul tombol Finish.

3. Setelah mengklik tombol Finish maka akan terbentuk project dengan nama project yang ada buat, dibawahnya ada folder Source dengan sebuah file main.c

4. Kemudian klik Menu Settings>Compiler and Debuger.. Maka akan muncul kotak Global Compiler Settings. Kemudian klik Linker Setting. Klik tombol Add untuk menambah setting library yang berada di C:\Program Files\CodeBlocks\MinGW\lib\glut32.lib; Setelah tombol Ok diklik maka akan terlihat seperti gambar di bawah

5. Kemudian klik tombol Ok. Seterusnya buka program main.c, hapus isinya ganti dengan program di bawah ini.
#include <gl/glut.h> void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_LINES); glVertex3f(0.25, 0.25, 0.0); glVertex3f(0.75, 0.75, 0.0);

glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow("Lesson 1"); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; }

6. Untuk melihat hasilnya Klik Menu Build > Build Ctl+F9, kemudian Klik Menu Build > Run Ctrl+F10. Maka akan terlihat seperti gambar di bawah ini.

Dari program diatas terbentuk sebuah garis berwarna putih.

Dasar-Dasar Menggambar dengan OpenGL dan Menggambar Titik

Dalam Pembuatan Grafis melalui OpenGL ada 3 fungsi Utama yang umum digunakan 1. main ( bertipe int) di gunakan sebagai prosedur utama yg pertama di jalankan dan menjalankan prosedur lain 2. init digunakan untuk mengatur elemen-elemen yang terdapat di Openg GL seperti resolusi bukan besar window-nya tapi kyk ukuran gambar yg di tampilkan / zooming di dalam window, tebal garis dan sebagainya yang lain..

3. Display L merupakan prosedur tempat kita bermain-main membentuk grafis-grafis dari OpenGL disini segala Objek yang akan kita buat kita taruh. Dasar-dasar menggambar dengan OpenGL mempunyai 10 buah bentuk geometris sederhana,biasa disebut 10 Geometris Primitif. Disebut primitif karena bentuk sederhana dan ditampilkan sangat cepat dan bisa dibentuk gambar yang lebih kompleks lagi dengan penggabungan gambar geometris primitif tersebut. 10 Geometris tersebut adalah 1. 2. 3. 4. 5. Points (Point), Lines (Garis), Triangles (Segitiga), Triangle Strip (Segitiga Jalur), Quad Strip (Quad Jalur), 6. Line Strip (Garis Jalur), 7. Line Loop (Garis Looping), 8. Quads (Quad), 9. Polygon (Poligon), and 10. Triangle Fan (Segitiga Fan).

Untuk menggambar geometris diatas, openGL menggunakan fungsi, yaitu :

GL_POINTS GL_LINES GL_TRIANGLES GL_TRIANGLE_STRIP GL_QUAD_STRIP GL_LINE_STRIP

GL_LINE_LOOP GL_QUADS GL_POLYGON GL_TRIANGLE_FAN

Mengambar Titik Menggambar titik menggunakan perintah GL_POINTS dengan glVertex3f(x, y, z), dimana kordinat x sumbu horizontal, y sumbu vertikal dan kordinat z kearah kita. Koordinat dimulai dari kiri bawah, seperti gambar di bawah ini.

Untuk mulai menggambar titik kita menggunakan perintah GL_POINTS seperti dibawah ini glBegin(GL_POINTS); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); Sintak program menggambarkan grafik dalam sumbu x,y dan z adalah

Atau dalam bentuk lain yaitu

Untuk Kode program lengkap dalam Editor CodeBlocks adalah

#include <gl/glut.h>

void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_POINTS); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Point); Initialize();

glutDisplayFunc(Draw); glutMainLoop(); return 0; }

Jalankan Program tersebut di CodeBlocks hasilnya seperti gambar di bawah ini

Gambar ini terdiri 6 buah titik berwarna putih.

Menampilkan Garis dan Segitiga dengan OpenGL

Menampilkan Garis Menampilkan garis dalam OpenGL menggunakan perintah GL_LINES. Menggambarkan garis hanya menggunakan 2 buah vertex,yaitu titik mulai dan titik akhir. Untuk jelasnya, perhatikan gambar dibawah ini :

Program untuk membuat garis adalah:

glBegin(GL_LINES); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd();

Program Lengkap untuk membuat garis adalah: #include <gl/glut.h> void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_LINES); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity();

glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Line); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; } Hasil Kompile program garis diatas adalah :

Menampilkan Segitiga Menampilkan Segitiga menggunakan perintah GL_TRIANGLES dengan 3 buah vertex. Segitiga yang dibentuk bisa searah dengan jarum jam atau berlawanan. Pada contoh ini gambar pertama berlawanan dengan arah jarum jam dan yang kedua sebaliknya.

Perintah menampilkan segitiga adalah:

glBegin(GL_TRIANGLES); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd();

Perintah lengkap menampilkan segitiga adalah :

#include <gl/glut.h>

void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_TRIANGLES); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); glFlush(); }

void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); }

int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Triangles); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; }

Hasil Kompiler program segitiga diatas adalah:

Menampilkan Segitiga Strip dan Quad Strip

Menampilkan Segitiga Strip Segitiga Strip ialah gambar segitiga yang saling terhubung satu sama lain. Perintah untuk menampilkan Segitiga Strip ini adalah GL_TRIANGLE_STRIP dengan vertex v1,v2,v3 dan v3.,v1,v4 dan sebagainya. Perhatikan gambar di bawah ini:

Perintah untuk Segitiga Strip adalah : glBegin(GL_TRIANGLE_STRIP); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); Perintah diatas ini membentuk segitiga strip seperti

Program Lengkap Segitiga Strip adalah #include <gl/glut.h> void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_TRIANGLE_STRIP); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0);

glEnd(); glFlush(); }

void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); }

int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Triangles Strip); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; }

Hasil Eksekusi program Segitiga Strip diatas adalah:

Menampilkan Quad Strip

Quad Strip adalah gambar Quard yang saling terhubung satu dengan yang lain. Perintah untuk menampilkan Quard Strip ini adalah GL_QURD_STRIP. Bentuk Quad Srip seperti gambar di bawah ini.

Perintah untu Quad Strip adalah glBegin(GL_QUAD_STRIP); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); Program lengkap Quad Strip adalah: #include <gl/glut.h> void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_QUAD_STRIP); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); }

int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Quad Strip); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; } Hasil Kompiler dari program Quad Strip di atas adalah

Menampilkan Garis Strip dan Garis Loop dengan OpenGL

Menampilkan Garis Strip Untuk menampilkan Garis Strip, OpenGL menggunakan perintah GL_LINE_STRIP. Garis Strip adalah membuat garis-garis dengan menghubungkan ujung garis sebagai titik pertama untuk garis selanjutnya.

Perintah dasar Garis Strip adalah : glBegin(GL_LINE_STRIP); glVertex3f(0.2, 0.2, 0.0);

glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); Gambar dari perintah Garis Strip diatas adalah:

Program lengkap Garis Strip dalam main program c adalah : #include <gl/glut.h> void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_LINE_STRIP); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Line Strip); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; } Program di atas, setelah di kompile, hasilnya seperti gambar dibawah:

Menampilkan Garis Loop Garis Loop adalah menghubungkan garis pertama dengan garis selanjutnya dan garis terakhir terhubung dengan garis pertama. Untuk menampilkan Garis Loop, OpenGL menggunakan perintah GL_LINE_LOOP.

Perintah dasar Garis Loop adalah : glBegin(GL_LINE_LOOP); glVertex3f(0.2, 0.2, 0.0);

glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); Dari program dasar Garis Loop itu akan membentuk gambar seperti :

Program lengkap untuk membuat Garis Loop dalam main program c adalah : #include <gl/glut.h> void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_LINE_LOOP); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.2, 0.5, 0.0); glVertex3f(0.8, 0.5, 0.0); glVertex3f(0.2, 0.8, 0.0); glVertex3f(0.8, 0.8, 0.0); glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Lne Loop); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; } Hasil kompile program lengkap diatas adalah :

Program Perwarnaan BackGround OpenGL dengan C++

Program ini berisi kode program OpenGL paling singkat untuk menguji komputer anda yang sudah install kompailer C++ dan library Glut. Bila program yang ditulis singkat ini bisa berjalan dan berhasil, maka anda dapat meneruskan program-pogram lainnya, bila tidak maka dengan cepat anda mengetahui ada sesuatu yang tidak tidak lengkap untuk menjalankan OpenGL. Program singkat ini cuma menampilkan layar window dengan latar belakang merah dan tulisan di barnya. Programnya adalah :
#include <windows.h> #include <gl/glut.h> void Display(void) { glClear(GL_COLOR_BUFFER_BIT); glFlush(); } void init(void) { glClearColor(1.0,0.0,0.0,1.0);

glViewport(0,0,320,240); gluOrtho2D(0.0,160.0,0.0,120.0); } void main(int argc,char* argv[]) { glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(320,240); glutCreateWindow("My First OpenGL"); init(); glutDisplayFunc(Display); glutMainLoop(); }

Keterangan Program:
#include <windows.h> #include <gl/glut.h>

Ini File Include yang digunankan untuk window dan Library Glut
void Display(void) { glClear(GL_COLOR_BUFFER_BIT); glFlush(); }

Membersihkan semua warna yang ada di layar dan merefresh kembali layar, sehingga siap diisi warna baru.
void init(void) { glClearColor(1.0,0.0,0.0,1.0); glViewport(0,0,320,240); gluOrtho2D(0.0,160.0,0.0,120.0); }

Mengset warna merah,mengatur ukuran window view 320 x 240 dan meset layar dalam 2 dimensi. Hasil Compile Program :

Pewarnaan di Pemrograman OpenGL

Program ini menampilkan 4 buah titik dengan ukuran tertentu dengan warna yang berbeda-beda. Warna dasar dari dalam OpenGL itu adalah merah,hijau dan biru (RGB). Kode Program pewarnaan adalah :
#include <windows.h> #include <gl/glut.h> void Display(void) { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POINTS); glColor3f(0.0,1.0,0.0); glVertex2f(10.,10.); glColor3f(1.0,1.0,0.0); glVertex2f(10.,110.); glColor3f(0.0,0.0,1.0); glVertex2f(150.,110.0); glColor3f(1.0,1.0,1.0); glVertex2f(150.,10); glEnd(); glFlush(); } void reshape(int w,int h) { glViewport(0,0,(GLsizei)w,(GLsizei)h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,160.0,0.0,120); } void init(void) { glClearColor(1.0,0.0,0.0,1.0); glPointSize(20.0); } void main(int argc,char* argv[]) { glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(320,240); glutCreateWindow("ProgramPertama"); init(); glutDisplayFunc(Display); glutReshapeFunc(reshape); glutMainLoop(); }

Program di atas bila dikompel hasilnya :

Membuat Lingkaran dengan OpenGL

Dalam geometri Euklid, sebuah lingkaran adalah himpunan semua titik pada bidang dalam jarak tertentu, yang disebut jari-jari, dari suatu titik tertentu, yang disebut pusat. Lingkaran adalah contoh dari kurva tertutup sederhana, membagi bidang menjadi bagian dalam dan bagian luar.

Pada pembuatan lingkaran ini kita menggunakan rumus-rumus matematika berupa cos dan sin. Berkaitan dengan cos dan sin, maka yang paling penting kita harus mengubah sudut dari dari deg ke radian, yaitu 1 deg = 3.14159/180, untuk 1 lingkaran maka 2 deg. Program Sederhana Lingkaran
#include <gl/glut.h> #include <windows.h> #include <math.h> const double PI = 3.141592653589793; int i,radius,jumlah_titik,x_tengah,y_tengah; void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_LINE_LOOP); radius=40; jumlah_titik=20; x_tengah=50;

y_tengah=50; for (i=0;i<=360;i++){ float sudut=i*(2*PI/jumlah_titik); float x=x_tengah+radius*cos(sudut); float y=y_tengah+radius*sin(sudut); glVertex2f(x/100,y/100); } glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow("Lingkaran"); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; }

Hasil Compile Program di atas

Program Sedikit variasi dengan Lingkaran

#include <gl/glut.h> #include <windows.h> #include <math.h> const double PI = 3.141592653589793; int i,radius,jumlah_titik,x_tengah,y_tengah; void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0);

glBegin(GL_LINE_LOOP); radius=40; jumlah_titik=20; x_tengah=50; y_tengah=50; for (i=0;i<=360;i++){ float sudut=i*(2*PI/jumlah_titik); float x=x_tengah+radius*cos(sudut); float y=y_tengah+radius*sin(sudut); glVertex2f(x/100,y/100); } glEnd(); glBegin(GL_TRIANGLE_FAN); radius=5; jumlah_titik=20; x_tengah=30; y_tengah=60; for (i=0;i<=jumlah_titik;i++){ float sudut=i*(2*PI/jumlah_titik); float x=x_tengah+radius*cos(sudut); float y=y_tengah+radius*sin(sudut); glVertex2f(x/100,y/100); } glEnd(); glBegin(GL_TRIANGLE_FAN); radius=5; jumlah_titik=20; x_tengah=70; y_tengah=60; for (i=0;i<=jumlah_titik;i++){ float sudut=i*(2*PI/jumlah_titik); float x=x_tengah+radius*cos(sudut); float y=y_tengah+radius*sin(sudut); glVertex2f(x/100,y/100); } glEnd(); glBegin(GL_LINE_LOOP); glVertex2f(0.5,0.6); glVertex2f(0.4,0.5); glVertex2f(0.6,0.5); glEnd(); glBegin(GL_LINE_LOOP); radius=20; jumlah_titik=180; x_tengah=50; y_tengah=40; for (i=90;i<=jumlah_titik;i++){ float sudut=i*(2*PI/jumlah_titik); float x=x_tengah+radius*cos(sudut); float y=y_tengah+radius*sin(sudut); glVertex2f(x/100,y/100); } glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION);

glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow("Lingkaran senyum"); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; }

Hasil Compile Program diatas

Menampilkan Quad,Polygon dan Triangle Fan dengan OpenGL

Menampilkan Quad Gambar Quad adalah bentuk segiempat dengan vertex yang bebas. Bebas disini artinya mempunyai segi empat buah yang bebas. Untuk menampilkan Quad, OpenGL mengunakan perintah GL_QUADS.

Perintah sederhana menampilkan SQUAD adalah : glBegin(GL_QUADS); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.6, 0.4, 0.0); glVertex3f(0.4, 0.4, 0.0);

glVertex3f(0.4, 0.6, 0.0); glVertex3f(0.6, 0.6, 0.0); glVertex3f(0.8, 0.8, 0.0); glVertex3f(0.2, 0.8, 0.0); glEnd();

Gambar yang dihasilkan dari peritah diatas adalah :

Perintah lengkap menampilkan SQUAD dalam main program bahasa C adalah :

#include <gl/glut.h>

void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_QUADS); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.8, 0.2, 0.0); glVertex3f(0.6, 0.4, 0.0); glVertex3f(0.4, 0.4, 0.0); glVertex3f(0.4, 0.6, 0.0); glVertex3f(0.6, 0.6, 0.0); glVertex3f(0.8, 0.8, 0.0); glVertex3f(0.2, 0.8, 0.0); glEnd(); glFlush(); }

void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); }

int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Quads); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; }

Hasil setelah di kompile dari program SQUAD diatas adalah :

Menampilkan Polygon

Polygon atau segibanyak dapat dibentuk dengan menggunakan perintah GL_POLYGON di OpenGL.

Perintah sederhana menampilkan POLYGON adalah:

glBegin(GL_POLYGON); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.6, 0.1, 0.0); glVertex3f(0.8, 0.3, 0.0); glVertex3f(0.7, 0.6, 0.0); glVertex3f(0.4, 0.8, 0.0); glEnd();

Gambar yang hasil dari perintah diatas adalah :

Perintah lengkap menampilkan POLYGON dalam main program bahasa C adalah : #include <gl/glut.h> void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0);

glBegin(GL_POLYGON); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.6, 0.1, 0.0); glVertex3f(0.8, 0.3, 0.0); glVertex3f(0.7, 0.6, 0.0); glVertex3f(0.4, 0.8, 0.0); glEnd(); glFlush(); } void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Polygon); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; } Hasil setelah di kompile dari program POLYGON diatas adalah :

Menampilkan Triangle Fan

Triangle Fan adalah menghubungkan beberapa segitiga ke titik pusat. Untuk menampilkan Triangle fan, OpenGL menggunakan perintah GL_TRIANGLE_FAN.

Perintah dasar menampilkan Triangle Fan adalah :

glBegin(GL_TRIANGLE_FAN); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.6, 0.1, 0.0); glVertex3f(0.8, 0.3, 0.0); glVertex3f(0.7, 0.6, 0.0); glVertex3f(0.4, 0.8, 0.0); glEnd();

Gambar dari perintah dasar diatas adalah :

Program lengkap Triangle fan dalam fungsi main bahasa C adalah :

#include <gl/glut.h>

void Draw() { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glBegin(GL_TRIANGLE_FAN); glVertex3f(0.2, 0.2, 0.0); glVertex3f(0.6, 0.1, 0.0); glVertex3f(0.8, 0.3, 0.0); glVertex3f(0.7, 0.6, 0.0); glVertex3f(0.4, 0.8, 0.0); glEnd(); glFlush(); }

void Initialize() { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); }

int main(int iArgc, char** cppArgv) { glutInit(&iArgc, cppArgv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(200, 200); glutCreateWindow(Triangle Fan); Initialize(); glutDisplayFunc(Draw); glutMainLoop(); return 0; } Setelah di kompile, maka hasilnya adalah :

Setting DOS Graphics Emulation graphics.h di kompiler C/C++

Graphics Emulation dengan pustaka graphics.h digunakan dulunya pada sistem operasi DOS. Penggunaan pustaka ini pada Compiler Turbo C pada tahun 1994. Pustaka ini standar pustaka grafik yang dikeluarkan oleh Borlad BGI Emulation, yang di distribusi Michael Universitas Colorado. Sebenarnya sekarang, sejak ada windows baik 32 bit atau 64 sudah banyak pustaka-pustaka lain yang lebih banyak fitur-fitur, seperti Glut untuk OpenGL,Direct3D dari Microsoft dan lain-lain. Saya menggunakan pustaka ini karena beberapa buku komputer grafik masih menggunakannya dalam beberapa program, seperti program yang baru saya dapat yaitu metode Bresenham. Metode ini menjelaskan bagaimana membuat garis dengan kesalahan sedikit mungkin, dan programnya menggunakan bahasa C . Saya sudah berhasil menginstall dan mengkonfigurasi di IDE CodeBlocks dengan kompiler Mingw. Setelah itu saya mencoba program sederhana untuk melihat apakah pustaka tersebut berjalan dengan baik. Dari tutorial yang didapat, pustaka graphics.h bisa bekerja di selain IDE CodeBlocks seperti Microsoft Visual C++, Netbeans, Bloodshed Dev C++, Eclipse. Pustaka graphics.h gratis dan bisa didapat dengan mudah di internet. Langkah-langkah untuk setting graphics.h di GNU Mingw ialah: 1. Install IDE C/C++ ( CodeBlocks,Microsoft Visual C++, Netbeans, Bloodshed Dev C++, Eclipse) dan Kompiler Mingw. Ada beberapa IDE sudah ada kompiler didalamnya, seperti Codeblocks,MS Visual C++. Saya disini menggunakan Codeblocks. 2. Download WinBGIm di http://codecutter.org/tools/winbgim/ dan ekstraks filenya. Didalamnya berisi 3 buah file yang berekstensi .h dan berekstensi .a, yaitu graphics.h, winbgim.h dan libbgi.a. 3. Copy file graphics.h, winbgim.h ke Folder C:\Program Files\CodeBlocks\MinGW\include dan file libbgi.a ke C:\Program Files\CodeBlocks\MinGW\lib. Ini untuk CodeBlocks dan Mingw, untuk IDE lain cocok dengan melihat Mingw foldernya. 4. Tambahkan link library pada IDE Codeblocks, tambahkan 6 file yaitu : libbgi, libgdi32, libcomdlg32, libuuid, liboleaut32, libole32. Untuk menambah 6 file ini di CodeBlocks melalui menu : Settings> Compiler and debugger..> Linker settings > Add dan masuk ke

folder C:\Program Files\CodeBlocks\MinGW\lib pilih 6 file diatas. Setelah dipilih akan tampak seperti gambar dibawah . Untuk IDE selain CodeBlocks, cocokkan dengan IDE itu sendiri.

5. Buat program C dengan memasukan header graphics.h, seperti kode program dibawah ini
#include <graphics.h> #include"conio.h" int main() { int gd=DETECT, gm; initgraph(&gd, &gm, ""); circle(330,180,100); rectangle (10,30,500,400); ellipse(100,150,0,360,100,50); arc(120,160,300,90,70); line(100,50,100,400); getch(); closegraph(); restorecrtmode (); }

6. Program diatas dikompile akan menghasilkan grafik seperti gambar di bawah

Sumber : http://rushabhthathi.wordpress.com/2011/01/22/getting-graphics-h-to-work-on-mingw32-gnu-ccompiler/ http://www.cse.dmu.ac.uk/~bb/Teaching/8051board/BorlandGrpahics/BorlandGraphicsInterface.html http://www.dreamincode.net/forums/topic/158177-how-to-use-graphicsh-in-code-block-compiler/ http://codecutter.org/tools/winbgim/ http://onecore.net/turbo-c-graphics-programming.htm http://onecore.net/turbo-c-graphics-part-2.htm

Fakta Menarik Seputar Bilangan Fibonacci dan Perhitungan dengan Program C++
Dalam matematika, bilangan Fibonacci adalah barisan yang didefinisikan secara rekursif sebagai berikut:

Golden Ratio yang nilainya mendekati 1,618. Bilangan Fibonacci adalah sebuah pola bilangan yang terkenal setelah Leonardo of Pisa alias Fibonacci mengenalkannya ke Eropa pada tahun 1202 lewat bukunya, Liber Abaci, walaupun pada mulanya bilangan ini telah dikenal pertama kali di India. Fibonacci merumuskan barisan bilangan ini ketika dia mengikuti sebuah turnamen matematika di tahun itu. Permasalahan yang mengilhaminya adalah masalah teka-teki kelinci berikut ini. Seseorang menaruh sepasang kelinci yang semua sisinya dibatasi dinding. Berapa banyak pasang kelinci dapat dihasilkan dari pasangan tersebut dalam setahun jika diandaikan setiap bulan tiap pasangan beranak satu pasangan baru yang mulai produktif pada bulan ke dua dan seterusnya. Kelinci-kelinci Fibonacci Pertama-tama kita bayangkan ada sepasang kelinci. Di bulan pertama kelinci itu matang, dan dapat melahirkan sepasang anaknya setelah minggu kedua setiap bulannya . Kita umpamakan kelinci-kelinci itu tidak pernah mati, dan kelinci betina selalu dapat melahirkan sepasang kelinci baru (satu kelinci jantan dan satu kelinci betina) di bulan kedua setelah dia dilahirkan induknya.

Di akhir bulan pertamanya, sepasang kelinci (pertama) telah matang, tetapi belum dapat menghasilkan kelinci baru (masih ada 1 pasang kelinci). Di akhir bulan kedua, dari kelinci betina lahir sepasang kelinci (1 kelinci jantan dan 1 kelinci betina). Jadi ada 2 pasang kelinci sekarang. Di akhir bulan ketiga, kelinci betina awal melahirkan lagi sepasang kelinci. Jadi ada 3 pasang kelinci sekarang. Di akhir bulan keempat, kelinci betina awal melahirkan lagi sepasang kelinci, dan kelinci betina yang lahir di bulan kedua juga melahirkan sepasang kelinci pertamanya. Jadi, sekarang ada 5 pasang kelinci di kandang itu. Begitu seterusnya.

Berikut adalah pasangan-pasangan kelinci baru yang dihasilkan setelah beberapa bulan.

Dari ilustrasi gambar di atas, terlihat pola banyaknya pasangan kelinci itu sejak awal bulan pertama adalah: 1, 1, 2, 3, 5, 8, 13, 21, 34, Susunan silsilah keluarga kelinci itu juga dapat disajikan sebagai berikut:

Program Fibonacci dalam Program C++ #include <iostream> using namespace std; int fibonacci(int n){ if(n==0){ return(0);

} else if(n==1){ return(1); }else{ return(fibonacci(n-1)+fibonacci(n-2)); } } int main() { int n; cout<<Masukkan jumlah nilai bilangan fibonacci : ;cin>>n; for(int i=1;i<=n;i++){ cout << fibonacci(i)<<, ; } } Hasil kompile adalah :

Sumber :

http://id.wikipedia.org/wiki/Bilangan_Fibonacci http://wartapedia.com/tekno/terapan/4873-fibonacciantarkan-bocah-asal-usa-hasilkan-inovasibaru-plts.html http://www.mate-mati-kaku.com/matematikawan/fibonacci.html http://www.matematikamenyenangkan.com/fakta-menarik-seputar-bilangan-fibonacci/ http://riskianawulan.net/2011/04/deret-bilangan-fibonacci/ http://id.shvoong.com/internet-and-technologies/software/2061836-program-untuk-bilanganfibonacci/

Ackermann function with C++

In computability theory, the Ackermann function, named after Wilhelm Ackermann, is one of the simplest and earliest-discovered examples of a total computable function that is notprimitive recursive. All primitive recursive functions are total and computable, but the Ackermann function illustrates that not all total computable functions are primitive recursive. After Ackermanns publication[1] of his function (which had three nonnegative integer arguments), many authors modified it to suit various purposes, so that today the Ackermann function may refer to any of numerous variants of the original function. One common version, the twoargument AckermannPter function, is defined as follows for nonnegative integers m and n:

Its value grows rapidly, even for small inputs. For example A(4,2) is an integer of 19,729 decimal digits.
#include <stdio.h> /* The three conditions can be found here: http://en.wikipedia.org/wiki/Ackermann%27s_function */ int acker(int m, int n){ if (m == 0) return (n + 1); else if ((m > 0) && (n == 0)){ return acker(m-1, 1); } else if ((m > 0) && (n > 0)){ return acker(m-1, acker(m, n-1)); } } /*sample usage*/ int main(){ /*iterate through the first 4 "pairs" 1 3 7 61 */ for(int i = 0; i < 4; i++){ printf("%d ", acker(i,i)); } return 0; }

Source http://en.wikipedia.org/wiki/Ackermann_function http://www.dreamincode.net/code/snippet5771.htm http://www.cplusplus.com/forum/articles/2935/