Tugas 2 Sistem Operasi

Batch System, yaitu Job yang dikerjakan dalam satu rangkaian, yang di mana job-job yang sejenis dikelompokkan, lalu dieksekusi secara berurutan.

Multiprogramming adalah suatu kemampuan dari sebuah system operasi untuk melayani lebih dari satu program yang dijalankan sekaligus dalam satu komputer yang sama.

Time Sharing adalah teknik penggunaan online system oleh beberapa pemakai secara bergantian menurut waktu yang diperlukan pemakai.

Sistem Paralel atau sistem multiprosessor mempunyai lebih dari satu prosessor yang dapat berkomunikasi, membagi bus, clock dan juga perangkat memory dan peripheral.

Sistem Terdistribusi yaitu prosessor berkomunikasi dengan prosessor lain melalui saluran komunikasi, misalnya bus kecepatan tinggi atau saluran telepon.

Sistem  Cluster adalah pengembangan dari system terdistribusi. Perbedaan sistem terklaster dengan sistem terdistribusi adalah pada system terklaster memungkinkan dua atau lebih sistem untuk membagi penyimpan sekunder (storage) bersama-sama.

Real time system adalah sebuah sistem yang tidak hanya memusatkan perhatian pada hasil(output) dari proses yang dihasilkan saja, tetapi memperhatikan juga masalah waktu yang sehingga sesuai dengan kebutuhan waktu yang diperlukan.

Sistem Handheld adalah sistem yang lebih kecil dari mikrokomputer yang mempunyai memori yang terbatas, kecepatan rendah dan display screen yang kecil.

Perbedaan sistem single programming dan multiprogramming.

Pada sistem single programming, satu processor mengerjakan satu program yang ada di memori utama. Sedangkan pada sistem multiprogramming, satu processor dapat mengerjakan banyak program yang ada di memori utama.

Perbedaan Symmetric dan asymmetric multiprocessing.

Pada symmetric multiprocessing, setiap prosessor menjalankan program atau proses secara bersamaan tanpa melihat prioritasnya. Sedangkan pada asymmetric multiprocessing, setiap prosessor berarti ada program tertentu yang akan diprioritaskan. Ada macam-macam cara memberi prioritas, salah satunya adalah mendahulukan program yang tidak banyak pakai I/O, karena I/O selalu lebih lambat dari memori, jadi kalau OS memprioritaskan program yang I/O-intensif berarti dia juga harus rela menunggu sedangkan user tidak akan mau menunggu. Umumnya asymmetric multiprocessing digunakan pada sistem besar.

Perbedaan system paralel dan system terdistribusi.

Pada sistem paralel tiap processor dapat menggunakan memori secara bersama-sama, sedangkan pada sistem terdistribusi kumpulan processor tidak dapat digunakan secara bersama-sama.

Perbedaan system terdistribusi dan system terklaster.

Sistem terdistribusi adalah mendistribusikan komputasi di antara beberapa processor. Processor berkomunikasi dengan processor lain melalui saluran komunikasi, misalnya bus kecepatan tinggi atau saluran telepon. Sistem terklaster  adalah pengembangan dari sistem terdistribusi.  Perbedaan sistem terklaster dengan sistem terdistribusi adalah pada sistem terklaster memungkinkan dua atau lebih sistem untuk membagi penyimpan sekunder (storage) bersama-sama.

Yang dimaksud symmetric dan asymmetric clustering.

Symmetric clustering, dimana semua host menjalankan aplikasi.

Asymmetric clustering, dimana satu server menjalankan aplikasi sementara server lainnya standby.

Tugas Sistem Operasi

Layanan Sistem Operasi

Sistem operasi  adalah seperangkat program yang mengelola sumber daya perangkat keras komputer, dan menyediakan layanan umum untuk aplikasi perangkat lunak. Sebuah sistem operasi yang baik menurut Tanenbaum harus memiliki layanan sebagai berikut: pembuatan program, eksekusi program, pengaksesan I/O Device, pengaksesan terkendali terhadap berkas pengaksesan sistem, deteksi dan pemberian tanggapan pada kesalahan, serta akunting.

Pembuatan program yaitu sistem operasi menyediakan fasilitas dan layanan untuk membantu para pemrogram untuk menulis program; Eksekusi Program yang berarti Instruksi-instruksi dan data-data harus dimuat ke memori utama, perangkat-parangkat masukan/ keluaran dan berkas harus di-inisialisasi, serta sumber-daya yang ada harus disiapkan, semua itu harus di tangani oleh sistem operasi; Pengaksesan I/O Device, artinya Sistem Operasi harus mengambil alih sejumlah instruksi yang rumit dan sinyal kendali menjengkelkan agar pemrogram dapat berfikir sederhana dan perangkat pun dapat beroperasi; Pengaksesan terkendali terhadap berkas yang artinya disediakannya mekanisme proteksi terhadap berkas untuk mengendalikan pengaksesan terhadap berkas; Pengaksesan sistem artinya pada pengaksesan digunakan bersama (shared system); Fungsi pengaksesan harus menyediakan proteksi terhadap sejumlah sumber-daya dan data dari pemakai tak terdistorsi serta menyelesaikan konflik-konflik dalam perebutan sumber-daya; Deteksi dan Pemberian tanggapan pada kesalahan, yaitu jika muncul permasalahan muncul pada sistem komputer maka sistem operasi harus memberikan tanggapan yang menjelaskan kesalahan yang terjadi serta dampaknya terhadap aplikasi yang sedang berjalan; dan Akunting yang artinya Sistem Operasi yang bagus mengumpulkan data statistik penggunaan beragam sumber-daya dan memonitor parameter kinerja.

Jenis – jenis Sistem Operasi berdasarkan komponennya

A.     Sistem monolitik (monolithic system)

Sistem operasi  sebagai  kumpulan prosedur dimana prosedur dapat saling dipanggil oleh prosedur lain di sistem bila diperlukan. Karnel berisi semua layanan yang disediakan sistem operasi untuk pemakai. Sistem operasi ditulis sebagai sekumpulan prosedur (a collection of procedures), yang dapat dipanggil setiap saat oleh pemakai saat dibutuhkan.

B.      Sistem berlapis (layered system)

Sistem operasi dibentuk secara hirarki berdasar lapisan-lapisan, dimana lapisan-lapisan bawa memberi layanan lapisan lebih atas.Struktur berlapisdimaksudkan untuk mengurangi kompleksitas rancangan dan implementasi sistem operasi. Tiap lapisan mempunyai fungsional dan antarmuka masukan-keluaran antara dua lapisan bersebelahan yang terdefinisi bagus. Lapis-lapis dalam sistem operasi ada 6 lapis, yaitu :

·      Lapis 5 - The operator  = pemakai operator.

·      Lapis 4 - User programs = aplikasi program pemakai.

·      Lapis 3 - I/O management = menyederhanakan akses I/O pada level atas.

·      Lapis 2 -Operator-operatot communication = mengatur komunikasi antar

proses

·      Lapis 1 -Memory and drum management = mengatur alokasi ruang memori

               atau drum magnetic.

·      Lapis 0 -Processor allocation and multiprogramming = mengatur alokasi

               pemroses dan switching,multiprogramming dan pengaturan prosessor.

C.         System client – server

Sistem operasi merupakan kumpulan proses dengan proses-proses dikategorikan sebagai server dan client, yaitu :

·            Server, adalah proses yang menyediakan layanan.

·            Client, adalah proses yang memerlukan/meminta layanan  Proses client yang memerlukan layanan mengirim pesan ke server dan menanti pesan jawaban.

·            Permintaan pelayanan, seperti membaca sebuah blok file, sebuah user process (disebut client process) mengirimkan permintaan kepada sebuah server process, yang kemudian bekerja dan memberikan jawaban balik.

Evolusi Sistem Operasi

Sistem Operasi berevolusi dari tahun 1945an. Perkembangan sistem operasi :

Serial Processing
Pada generasi ini, programmer berinteraksi langsung dengan perangkat keras, tidak terdapat sistem operasi.Operasional mesin, dikontrol dengan console yang berupa display light, toggle switch, input devices.Input device dapat berupa card reader, sedangkan output devices dapat berupa printer.Tidak terdapat mekanisme penjadwalan / scheduling dinamis, karena programmer menentukan alokasi waktu setiap job yang akan dikerjakan.

Simple Batch System
Sistem Operasi Batch Sederhana menghasilkan mekanisme pengurutan dan pengelompokan instruksi secara otomatis. Masalah timbul jika mekanisme eksekusi instruksi berhubungan dengan I/O. Masalahnya I/O relatif lambat jika dibandingkan dengan processor, sehingga terdapat banyak sekali kondisi idle.
Kelemahan pada Sistem Batch Sederhana, yaitu penggunaan utilitas processor yang seringkali dalam keadaan idle, pada saat menunggu mekanisme dari I/O. Idle : pada saat processor menunggu mekanisme dari I/O, processor dapat melakukan eksekusi instruksi yang lain.

Multiprogramming Batch System
Multi-programming adalah salah satu teknik penjadwalan dimana tugas (task) yang sedang berjalan tetap berjalan sampai ia melakukan operasi yang membutuhkan waktu untuk menunggu respon dari luar (external event), misalnya membaca data dari disket/CD/dsb, atau sampai komputer memaksa untuk menukar tugas yang sedang berjalan dengan tugas lainnya. Sistem operasi yang yang menggunakan multi-program sebagai scheduler-nya bertujuan untuk memaksimalkan penggunaan CPU.
Usaha pertama untuk membuat sistem operasi berbasis multi-program dilakukan pada tahun 1960an. Beberapa program yang berlainan di dalam batch di-load ke memori komputer, dan program yang pertama akan dijalankan. Saat program tersebut mencapai instruksi untuk menunggu akses ke peripheral, konteks dari program ini disimpan, dan program berikutnya di memori mulai dijalankan. Proses ini berulang terus sampai semua program selesai dijalankan.

Time-Sharing System
Time-Sharing System adalah metode yang dipakai dalam sistem operasi yang memungkinkan sejumlah pemakai dapat berinteraksi dengan proses yang dibuatnya secara bergantian dengan jumlah waktu yang sama. Time sharing merupakan pengembangan lebih lanjut dari multiprogramming.
Time-Sharing memungkinkan beberapa pemakai komputer menggunakan CPU secara bersamaan dan CPU akan memberikan waktunya bergantian kepada setiap pemakai untuk memproses programnya dalam waktu yang sangat cepat.


Komponen utama dalam System Operasi

menurut A.S. Tanenbaum, sistem operasi mempunyai empat komponen utama, yaitu:

1) Managemen proses,

Proses adalah sebuah program yang sedang dieksekusi. Sebuah proses membutuhkan beberapa

sumber daya untuk menyelesaikan tugasnya. Sumber daya tersebut dapat berupa CPU time,

memori, berkas-berkas, dan perangkat-perangkat Masukan/Keluaran. Sistem operasi

mengalokasikan sumber daya-sumber daya tersebut saat proses itu diciptakan atau sedang

diproses/dijalankan. Ketika proses tersebut berhenti dijalankan, sistem operasi akan

mendapatkan kembali semua sumber daya yang bisa digunakan kembali. Sistem operasi

bertanggung-jawab atas aktivitas-aktivitas yang berkaitan dengan managemen proses seperti:

•         Membuat dan menghapus proses pengguna dan sistem proses.

•        Menunda atau melanjutkan proses.

•         Menyediakan mekanisme untuk proses sinkronisasi.

•        Menyediakan mekanisme untuk proses komunikasi.

•        Menyediakan mekanisme untuk penanganan deadlock.

2) Masukan/Keluaran

Sering disebut device manager. Menyediakan device driver yang umum sehingga operasi

Masukan/Keluaran dapat seragam (membuka, membaca, menulis, menutup). Contoh:

pengguna menggunakan operasi yang sama untuk membaca berkas pada perangkat keras, CDROM

dan floppy disk. Komponen Sistem Operasi untuk sistem Masukan/Keluaran:

•        Penyangga: menampung sementara data dari/ke perangkat Masukan/Keluaran.

•        Spooling: melakukan penjadualan pemakaian Masukan/Keluaran sistem supaya lebih efisien (antrian dsb.).

•        Menyediakan driver: untuk dapat melakukan operasi rinci untuk perangkat keras masukan/Keluaran tertentu.

3) Managemen Memori

Memori utama atau lebih dikenal sebagai memori adalah sebuah array yang besar dari word

atau byte, yang ukurannya mencapai ratusan, ribuan, atau bahkan jutaan. Setiap word atau byte mempunyai alamat tersendiri. Memori utama berfungsi sebagai tempat penyimpanan

instruksi/data yang akses datanya digunakan oleh CPU dan perangkat Masukan/Keluaran.

Memori utama termasuk tempat penyimpanan data yang yang bersifat volatile -- tidak

permanen -- yaitu data akan hilang kalau komputer dimatikan. Sistem operasi bertanggungjawab

atas aktivitas-aktivitas yang berkaitan dengan managemen memori seperti:

•         Menjaga track dari memori yang sedang digunakan dan siapa yang menggunakannya.

•        Memilih program yang akan di-load ke memori.

4) Sistem Berkas.

Berkas adalah kumpulan informasi yang berhubungan, sesuai dengan tujuan pembuat berkas

tersebut. Umumnya berkas merepresentasikan program dan data. Berkas dapat mempunyai

struktur yang bersifat hirarkis (direktori, volume, dll.). Sistem operasi mengimplementasikan

konsep abstrak dari berkas dengan mengatur media penyimpanan massa, misalnya tapes dan

disk. Sistem operasi bertanggung-jawab dalam aktivitas yang berhubungan dengan

managemen berkas:

•        Pembuatan dan penghapusan berkas.

•        Pembuatan dan penghapusan direktori.

•        Mendukung manipulasi berkas dan direktori.

•        Memetakan berkas ke secondary-storage.

•        Mem-back-up berkas ke media penyimpanan yang permanen (non-volatile).

Kubus 3 Dimensi di DevC++

Membuat Kubus 3D dan menempelkan objek foto pada bidang kubus tersebut.

Pertama, kita harus menggunakan imageLoader.cpp dan imageLoad.h.
Kemudian dalam file main.cpp kita akan membuat coding bagaimana kita membuat kubus dan  menempelkan objek foto pada setiap sisinya tersebut.
Coding nya seperti ini :

#include <iostream>
#include <stdlib.h>
#ifdef __APPLE__
#include <OpenGL/OpenGL.h>
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include “imageloader.h”
using namespace std;
const float BOX_SIZE = 7.0f;
float _angle = 0; //Rotasi terhadap box
GLuint _textureId;
void handleKeypress(unsigned char key, int x, int y) {
switch (key) {
case 27:
exit(0);
}
}
//Membuat gambar menjadi tekstur
GLuint loadTexture(Image* image) {
GLuint textureId;
glGenTextures(1, &textureId);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image->width, image->height, 0, GL_RGB, GL_UNSIGNED_BYTE, image->pixels);
return textureId;
}
void initRendering() {
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
Image* image = loadBMP(“antonl.bmp”);
_textureId = loadTexture(image);
delete image;
}
void handleResize(int w, int h) {
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, (float)w / (float)h, 1.0, 200.0);
}
void drawScene() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -20.0f);
GLfloat ambientLight[] = {0.3f, 0.3f, 0.3f, 1.0f};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight);
GLfloat lightColor[] = {0.7f, 0.7f, 0.7f, 1.0f};
GLfloat lightPos[] = {-2 * BOX_SIZE, BOX_SIZE, 4 * BOX_SIZE, 1.0f};
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glRotatef(-_angle, 1.0f, 1.0f, 0.0f);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, _textureId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS);
//glBegin(GL_QUADS);
//Sisi atas
glTexCoord2f(0.0f, 0.0f);
glNormal3f(0.0, 1.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2);
//Sisi bawah
glTexCoord2f(0.0f, 0.0f);
glNormal3f(0.0, -1.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2);
//Sisi kiri
glNormal3f(-1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2);
//Sisi kanan
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2);
//glEnd();
//Sisi depan
glNormal3f(0.0, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2);
//Sisi belakang
glNormal3f(0.0, 0.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2);
glEnd();
glDisable(GL_TEXTURE_2D);
glutSwapBuffers();
}
//Panggil setiap 25ms
void update(int value) {
_angle += 1.0f;
if (_angle > 360) {
_angle -= 360;
}
glutPostRedisplay();
glutTimerFunc(25, update, 0);
}
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(400, 400);
glutCreateWindow(“antonl-ganteng”);
initRendering();
glutDisplayFunc(drawScene);
glutKeyboardFunc(handleKeypress);
glutReshapeFunc(handleResize);
glutTimerFunc(25, update, 0);
glutMainLoop();
return 0;
}

untuk lebih jelasnya, silahkan download projectnya disini gan!

Segitiga Bertingkat Di DevC++

Ini cara membuat segitiga bertingkat di DevC++.
Ouptupnya seperti ini :

saya menggunakan secara manual menggunakan coding ini,,
glBegin(GL_POLYGON);
glColor3f(1.f, 0.0f, 1.0f); 
        glVertex2i(320, 410);
        glVertex2i(290, 350);
        glVertex2i(350, 350);
    glEnd();   
tetapi posisinya di rubah,, setiap posisi segitiga berbeda-beda,, di ganti nilai x dan y nya..
untuk coding lengkapnya dapat di download disini gan!

Menghitung titik potong garis pada OpenGL

Untuk menentukan titik potong dua buah gagis pada C++ seperti yang terlihat pada gambar di atas.

kita mengguakan rumus matematika. yang di mana rumus tersebutlah yang nantinya akan di masukkan ke dalam program yang kita buat. Berikut ini adalah source code untuk menentukan titik potong garis, yang di mana source code ini dapat di masukkan kedalam fungsi display.

float    xa = 50,ya = 70,

         xb = 200,yb = 250,

         xc = 250,yc = 50,

         xd = 50,yd = 350,

         x,y,m1,m2,c1,c2;

         

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(0.0f, 0.0f, 1.0f);

glBegin(GL_LINES);

glVertex2f(xa, ya); 

glVertex2f(xb, yb);

glEnd();

glColor3f(0.0f, 1.0f, 0.0f);

glBegin(GL_LINES);

glVertex2f(xc, yc);

glVertex2f(xd, yd);

glEnd();

m1 = (yb-ya)/(xb-xa);

m2 = (yd-yc)/(xd-xc);

c1 = ya - (m1*xa);

c2 = yc - (m2*xc);

x=(c2-c1)/(m1-m2);

y=(m1*x)+c1;

glColor3f(1.0f, 0.0f, 0.0f);

glBegin(GL_POINTS);

glVertex2f(x,y);

glEnd();

Membuat Hexagon pada OpenGL

Berikut adalah gambar dari Hexagon obat nyamuk dengan menggunakan Dev C++ pada OpenGL.

Di sini saya menggunakan rumus secara manual. Adapun rumus yang di gunakan untuk membuat hexagon di atas yaitu:
glBegin(GL_LINE_STRIP);
    glColor3f(0.0f, 0.0f, 1.0f);
    glVertex2f(10.0, 0.0);
    glVertex2f(10 * cos(2*3.14159265 * 1/6), 10 * sin(2*3.14159265*1/6));
    glVertex2f(10 * cos(2*3.14159265 * 2/6), 10 * sin(2*3.14159265*2/6));
    glVertex2f(10 * cos(2*3.14159265 * 3/6), 10 * sin(2*3.14159265*3/6));
    glVertex2f(10 * cos(2*3.14159265 * 4/6), 10 * sin(2*3.14159265*4/6));
    glVertex2f(10 * cos(2*3.14159265 * 5/6), 10 * sin(2*3.14159265*5/6));
    glVertex2f(11 * cos(2*3.14159265 * 6/6), 11 * sin(2*3.14159265*6/6));
    glEnd();

 Yang dimana 10 merupakan jari-jarinya dan 6 merupakan jumlah sudutnya.
dan untuk membuat hexagon seperti gambar di atas, rumus ini terus di ulang dengan merubah nilai jari-jari dan warna dari tiap=tiap hexagon.