Ilmu Copas: PemrogramanGrafik

Tampilkan postingan dengan label PemrogramanGrafik. Tampilkan semua postingan

#include <GL/glut.h>

typedef struct point2D_t
{
float x;
float y;
};

typedef struct Color_t
{
float r;
float g;
float b;
};

void setColor(Color_t col)
{
glColor3f(col.r, col.g, col.b);
}

void drawPolyline(point2D_t pnt[], int n)
{
int i;
glBegin(GL_LINE_STRIP);
for (i=0;i<n;i++){
glVertex2f(pnt[i].x,pnt[i].y);
}
glEnd();
}

void drawPolygon(point2D_t p[], int n)
{
int i;
glBegin(GL_LINE_LOOP);
for (i=0;i<n;i++){
glVertex2f(p[i].x,p[i].y);
}
glEnd();
}

void fillPolygon(point2D_t p[], Color_t col, int n){
int i;
glBegin(GL_POLYGON);
setColor(col);
for (int i=0;i<n;i++) glVertex2f (p[i].x,p[i].y);
glEnd();
}

void gradatePolygon(point2D_t p[], Color_t col[],int n){
int i;
glBegin(GL_POLYGON);
for (int i=0;i<n;i++){
setColor(col[i]);
glVertex2f(p[i].x,p[i].y);
}
glEnd();
}

void GambarPolyline(int x1,int y1,int x2,int y2,int x3, int y3,int x4, int y4,int x5, int y5,int x6, int y6,int x7, int y7,int x8,int y8, int x9, int y9, int x10, int y10){
glPointSize(4);
glBegin(GL_LINE_STRIP);
glVertex2i(x1,y1);
glVertex2i(x2,y2);
glVertex2i(x3,y3);
glVertex2i(x4,y4);
glVertex2i(x5,y5);
glVertex2i(x6,y6);
glVertex2i(x7,y7);
glVertex2i(x8,y8);
glVertex2i(x9,y9);
glVertex2i(x10,y10);
glEnd();
}

//draw area
//void userdraw() {
//static int tick=0;

//set warna (R,G,B{{0,30},{10,10},{35,10},{15,0},{25,-20},{0,-7.5},{-25,-20},{-15,0},{-35,10},{-10,10}}

// glColor3f(0,0,1);
// GambarPolyline(140,0,300,70,460,0,410,150,580,250,370,250,300,380,230,250,30,250,190,140);

/* glColor3f(0,1,0);
GambarPolyline(160,20,300,85,440,20,395,155,540,240,360,240,300,360,240,240,65,240,205,145);

glColor3f(1,1,0);
GambarPolyline(180,40,300,100,420,40,380,160,500,230,350,230,300,340,250,230,100,230,220,150);

glColor3f(1,0,0);
GambarPolyline(200,60,300,115,400,60,365,160,460,220,340,220,300,320,260,220,135,220,235,155);
*/

//}
void latar(){

Color_t merah={1,0,0};
Color_t ijo={0,1,0};
Color_t biru={0,0,1};

Color_t putih={1,1,1};
Color_t Kuning = {1,1,0};
Color_t ungu={0.7,0,1};
Color_t birumuda={0,1,1};

Color_t gradasi1[4]={{0,1,1},{0,0,0},{0,1,1},{1,0,0}};

point2D_t kotak1[4]={{0,190},{0,-20},{300,-20},{300,190}};
gradatePolygon(kotak1,gradasi1,4);

point2D_t kotak1[4]={{300,-20},{600,-20},{600,190},{300,190}};
gradatePolygon(kotak1,gradasi1,4);

point2D_t kotak1[4]={{600,190},{600,400},{300,400},{300,190}};
gradatePolygon(kotak1,gradasi1,4);

point2D_t kotak1[4]={{300,400},{0,400},{0,190},{300,190}};
gradatePolygon(kotak1,gradasi1,4);

}

void userdraw2(){

Color_t merah={1,0,0};
Color_t ijo={0,1,0};
Color_t biru={0,0,1};

Color_t putih={1,1,1};
Color_t Kuning = {1,1,0};
Color_t ungu={0.7,0,1};
Color_t birumuda={0,1,1};

point2D_t segi1[8]={{300,70},{460,0},{410,150},{580,250},{370,250},{300,380},{230,250},{30,250}};
fillPolygon(segi1,biru,8);

point2D_t segi2[8]={{300,85},{440,20},{395,155},{540,240},{360,240},{300,360},{240,240},{65,240}};
fillPolygon(segi2,ijo,8);

point2D_t segi3[8]={{300,100},{420,40},{380,160},{500,230},{350,230},{300,340},{250,230},{100,230}};
fillPolygon(segi3,Kuning,8);

}

void userdraw3(){

Color_t merah={1,0,0};
Color_t ijo={0,1,0};
Color_t biru={0,0,1};

Color_t putih={1,1,1};
Color_t Kuning = {1,1,0};
Color_t ungu={0.7,0,1};
Color_t birumuda={0,1,1};

point2D_t segitiga1[3]={{140,0},{300,70},{200,150}};
fillPolygon(segitiga1,biru,3);

point2D_t segitiga2[3]={{160,20},{300,85},{215,155}};
fillPolygon(segitiga2,ijo,3);

point2D_t segitiga3[3]={{180,40},{300,100},{230,160}};
fillPolygon(segitiga3,Kuning,3);

Color_t gradasi[4]={{0,1,1},{0,0,0},{0,1,1},{1,0,0}};

//(200,60,300,115,400,60,365,160,460,220,340,220,300,320,260,220,135,220,235,155)

point2D_t segitiga4[4]={{235,155},{200,60},{300,115},{300,190}};
gradatePolygon(segitiga4,gradasi,4);

point2D_t segitiga5[4]={{300,115},{400,60},{365,160},{300,190}};
gradatePolygon(segitiga5,gradasi,4);

point2D_t segitiga6[4]={{365,160},{460,220},{340,220},{300,190}};
gradatePolygon(segitiga6,gradasi,4);

point2D_t segitiga7[4]={{340,220},{300,320},{260,220},{300,190}};
gradatePolygon(segitiga7,gradasi,4);

point2D_t segitiga8[4]={{260,220},{135,220},{235,155},{300,190}};
gradatePolygon(segitiga8,gradasi,4);

}

void display(void){
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
latar();
userdraw2();
userdraw3(); //jalanan userdraw()
glutSwapBuffers();
}
int main(int argc,char **argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100); //posisi windownya di(100,100)
glutInitWindowSize(640,480); //set ukuran window jadi 640x480
glutCreateWindow("Bintang"); //set judul app
glClearColor(0,0,0,0); //set warna backgroun(r,g,b,a)(range 0-1)
gluOrtho2D(0.,600.,-20.,400.); //set area menggambar
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

terimakasih sudah melihat....

#include <windows.h>
#include <glut.h>
#include <math.h>

void cylinder(float alas,float atas,float tinggi);
void kerucut(float ngisor, float nduwur, float dowo);
void blok(float tebal,int ratiol,int ratiop);

GLfloat source_light[]={0.30,0.30,0.30,0.50};
double Loop,LoopAll=0;

void Mobil(void)
{
glClearColor(1.0,9.0,1.0,0.0); //blackground
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0,1.5,10.0,1000.0);

glEnable (GL_DEPTH_TEST);
glPolygonMode   (GL_FRONT_AND_BACK,GL_FILL);
glEnable (GL_LIGHTING);
glLightfv (GL_LIGHT7,GL_DIFFUSE,source_light);
glEnable (GL_LIGHT7);
glEnable (GL_COLOR_MATERIAL);
glColorMaterial (GL_FRONT_AND_BACK,GL_AMBIENT);

}

void display(void)
{

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

/*
Keterangan:
glTranslatef : coba nilainya diubah2 untuk menempatkan pada posisi yang tepat dengan sumbu (x, y, z)
glRotated : coba nilainya diubah2 untuk memutar objek agar sesuai dengan keinginan.
cylinder: untuk membentuk model tabung

*/

glTranslatef(0,0,-100);// besar kecilnya mobil

Loop++;
     glRotatef(Loop,0.9,4.0,0.6);//mobil yang berotasi

glPushMatrix();//body
//glpushmatrix();
glColor3f(0.0,0.0,9.0);
blok(10, 3, 2);

glTranslatef(0, 9, 0);
blok(10, 3, 2);
glTranslatef(10, -10,0);
blok(10, 5.5, 2);
glRotatef(-35, 0, 0, 15);
glTranslatef(0, 7,0);
blok(10, 2, 2);
glTranslatef(2, 4.9,-2.5);
glColor3f(0.9,0.9,0.9);// warna kaca
blok(0.5, 20, 31);

glRotatef(180, 45, -45, 0);
//glTranslatef(0, 10,0);
//blok(3, 2, 5);
//cylinder(2,2,30);
//glTranslatef(-10, -10,0);
//glRotatef(90, 45,-45, 0);
//cylinder(2,2,30);
//glRotatef(90, -45, 90, 90);
//blok(5, 3, 2);

glPopMatrix();

glPushMatrix();//roda
glColor3f(0.0,0.0,0.0);
glTranslatef(20, -8,-7);
cylinder(5, 5,3);

glColor3f(0.0,0.0,0.0);
glTranslatef(-20, 8,7);
glTranslatef(-5, -8,-7);
cylinder(5, 5,3);

glColor3f(0.0,0.0,0.0);
glTranslatef(5, 8,7);
glRotatef(180,0,180,0);
glTranslatef(3,-8,-17);
cylinder(5, 5,3);

glColor3f(0.0,0.0,0.0);
glTranslatef(-3,8,17);
glTranslatef(-22,-8,-17);
cylinder(5, 5,3);

glColor3f(1.0,1.0,1.0);

glRotatef(90,1,0,0);
glTranslatef(8, 2.5,-15);
blok(2, 4, 5);

glRotatef(90,0,1,0);
glTranslatef(0,-0.2,7);
blok(2, 4, 8);

glRotatef(0,0,0,0);
glTranslatef(0,19.2,0);
blok(2, 4, 8);

glRotatef(90,0,1,0);
glTranslatef(7, 0,-8);
blok(2, 4, 5);

glColor3f(9.9,9.9,0.0);//lampu
glRotatef(90,0,1,0);
glTranslatef(0,-3,20);
cylinder(2, 2,3);

glColor3f(9.9,9.9,0.0);//lampu
glRotatef(0,0,0,0);
glTranslatef(0,-12,0);
cylinder(2, 2,3);

glColor3f(0.0,0.0,0.0);//knalpot
glRotatef(0,0,0,0);
glTranslatef(0,0,-52);
cylinder(1, 1,3);

glColor3f(1.0,1.0,1.0);
glRotatef(90,1,0,0);
glTranslatef(-8,3.5,-12);
blok(2, 4, 8);

glColor3f(9.0,0.0,0.0);//lampu atas
glRotatef(0,0,0,0);
glTranslatef(-8,28,0);
cylinder(1, 1,12);

glPopMatrix();

glFlush();
glutSwapBuffers();

}

void kerucut(float ngisor, float nduwur, float dowo)
{
float i;
glPushMatrix();
glTranslatef(1.0,0.0,ngisor/24);
glutSolidCone(ngisor,0,32,4);
for(i=0;i<=dowo;i+=ngisor/24)
{
glTranslatef(0.0,0.0,ngisor/24);
glutSolidTorus(ngisor/4,ngisor-((i*(ngisor-nduwur))/dowo),16,16);
}
glTranslatef(0.0,0.0,ngisor/4);
glutSolidCone(nduwur,0,20,1);
glColor3f(0.,1.,1.);
glPopMatrix();
}
void cylinder(float alas,float atas,float tinggi)
{
float i;
glPushMatrix();
glTranslatef(1.0,0.0,-alas/8);
glutSolidCone(alas,0,32,4);
for(i=0;i<=tinggi;i+=alas/24)
{
glTranslatef(0.0,0.0,alas/24);
glutSolidTorus(alas/4,alas-((i*(alas-atas))/tinggi),16,16);
}
glTranslatef(0.0,0.0,alas/4);
glutSolidCone(atas,0,20,1);
glColor3f(1.,0.,0.);
glPopMatrix();
}

void blok(float tebal,int ratiol,int ratiop)
{
float i,j;
glPushMatrix();
for(i=0;i<ratiop;i++)
{
glTranslatef(-(ratiol+1)*tebal/2,0.0,0.0);
for(j=0;j<ratiol;j++)
{
   glTranslatef(tebal,0.0,0.0);
   glutSolidCube(tebal);
}
glTranslatef(-(ratiol-1)*tebal/2,0.0,tebal);
}
glPopMatrix();
}
void tampil()
{
display();
}

int main(int argc,char **argv)
{

glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);//|GLUT_DEPTH);
glutInitWindowPosition(10,10);
glutInitWindowSize(1000,700);
glutCreateWindow("Mobil");
glClearColor(0.5,0.5,0.0,0.0);
glutDisplayFunc(display);
gluOrtho2D(-320., 320., -240.0, 240.0);
glutIdleFunc(tampil);
Mobil();
glutMainLoop();
return(0);
}

Gambar :

SIntak :

#include <GL/glut.h>
static int shoulder = 0, elbow = 0;
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glPushMatrix();
glTranslatef (-1.0, 0.0, 0.0);
glRotatef ((GLfloat) shoulder, 0.0, 0.0, 1.0);
glTranslatef (1.0, 0.0, 0.0); glPushMatrix();
glScalef (2.0, 0.4, 1.0); glutWireCube (1.0);
glPopMatrix();
glTranslatef (1.0, 0.0, 0.0);
glRotatef ((GLfloat) elbow, 0.0, 0.0, 1.0);
glTranslatef (1.0, 0.0, 0.0); glPushMatrix();
glScalef (2.0, 0.4, 1.0);
glutWireCube (1.0);
glPopMatrix();
glPopMatrix();
glutSwapBuffers();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective(65.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef (0.0, 0.0, -5.0);
}
void keyboard (unsigned char key, int x, int y)
{
switch (key)
{
case 's':
shoulder = (shoulder + 5) % 360;
glutPostRedisplay();
break;
case 'S':
shoulder = (shoulder - 5) % 360;
glutPostRedisplay();
break;
case 'e':
elbow = (elbow + 5) % 360;
glutPostRedisplay();
break;
case 'E':
elbow = (elbow - 5) % 360;
glutPostRedisplay();
break;
case 27:
exit(0);
break;
default:
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (700, 600);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;}

Semoga bermanfaat :) thx.

Gambar :

sintak :

#include <GL/glut.h>
static GLfloat spin = 0.0;
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(spin, 0.0, 0.0, 1.0);
glColor3f(1.0,0.0,0.0);
glRectf(-25.0, -25.0, 25.0, 25.0);
glPopMatrix();
glutSwapBuffers();
}
void spinDisplay(void)
{
spin = spin + 2.0;
if (spin > 360.0)
spin = spin - 360.0;
glutPostRedisplay();
}
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void reshape(int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 'p': //memutar kotak
glutIdleFunc(spinDisplay);
break;
case 'o': //menghentikan kotak yang berputar
glutIdleFunc(0);
break;
default:
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (300, 300);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Semoga bermanfaat :)

Pencahayaan pada OpenGL

OpenGL akan melakukan komputasi warna setiap pixel di display akhir,

ditampilkan adegan itu dilakukan di frame buffer. Bagian dari komputasi ini tergantung

pada pencahayaan yang digunakan dalam adegan dan hal tersebut berkenaan dengan

bagaimana suatu benda dalam adegan yang memantulkan atau menyerap cahaya.

Sebagai contoh saja misalnya sebuah lautan memiliki warna yang berbeda pada cerah

maupun pada saat hari mendung. Adanya sinar matahari atau awan menentukan apakah

laut termelihat sebagai pirus terang atau abu-abu keruh kehijauan. Pada kenyataannya,

sebagian besar objek bahkan yang tidak terlihat tiga dimensi sampai mereka diterangi

cahaya. Pada gambar 2 menunjukkan dua versi dari adegan yang persis sama yaitu

sebuah bola, dimana satu dengan pencahayaan dan satu tanpa pencahayaan.

Gambar Sebuah spere dengan diterangi cahaya dan tidak diterangi

Seperti ditunjukkan pada Gambar 2, wilayah gelap tampak tidak berbeda dari

bulatan dua dimensi . hal Ini menunjukkan betapa pentingnya interaksi antara obyek dan

cahaya adalah dalam menciptakan adegan tiga dimensi.

Agar obyek yang telah dibuat terlihat lebih nyata, diperlukan tambahan efek

pencahayaan pada obyek yang telah kita buat. Pencahayaan adalah proses pemberian

cahaya pada suatu obyek, dikenal dengan istilah lighting atau iluminasi. Pada OpenGL

terdapat sebuah perbedaan penting antara warna dan pencahayaan yang perlu pahami.

Ketika menggunakan pencahayaan atau tekstur pemetaan dengan efek pencahayaan

dihidupkan, warna dari vertex adalah efek kumulatif dari warna bahan dan cahaya yang

bersinar di puncak. Ketika pencahayaan dimatikan, maka warna dari vertex adalah efek

pengaturan warna dan warna yang berbeda dengan bahan warna.

Gambar. Contoh ambient, diffuse, dan specular pada pantulan cahaya

Dengan menggunakan OpenGL, dapat memanipulasi pencahayaan dan obyek dalam

sebuah adegan untuk menciptakan berbagai macam efek. Dalam pokok bahasan pada bab

pencahayaan akan dimulai dengan sebuah pencahayaan yang penting pada permukaan

tersembunyi penghapusan. Kemudian menjelaskan bagaimana untuk mengontrol

pencahayaan dalam suatu adegan, membahas model konseptual OpenGL pencahayaan, dan

menggambarkan secara rinci cara mengatur pencahayaan dengan banyak parameter untuk

mendapatkan efek tertentu. Pada akhir bab, perhitungan matematis yang menentukan

bagaimana warna mempengaruhi pencahayaan disajikan

Silabus-XII-Pemrograman Grafik download

A. Pengertian Grafika Komputer

Grafika komputer adalah suatu bidang ilmu yang mempelajari

bagaimana “membangun” grafik (gambar) baik 2D maupun 3D yang kelihatan

nyata menggunakan komputer.

Salah satu bidang grafika komputer yang sangat terkenal adalah

Desain Grafis.Teknik – teknik yang dipelajari dalam grafika computer adalah

teknik – teknik bagaimana membuat atau menciptakan gambar dengan

menggunakan computer.Ada perbedaan yang sangat mendasar antara photo

dan gambar, dimana pada photo semua detail objek terlihat sedangkan gambar

(baik itu gambar manusia atau gambar computer) tidak dapat memperlihatkan

semua detail yang ada tetapi hanya detail yang dianggap penting dalam

menunjukkan pola suatu gambar.

Grafika computer merupakan perangkat (tool) dasar yang digunakan

untuk membuat gambar dengan computer.Dengan menggunakan perangkat

ini, penciptaan gambar dapat dilakukan, bahkan dimudahkan, dengan

menggunakan computer. Ada beberapa program yang sangat kompleks guna

membuat gambar computer, antara lain Microsoft Photo Editor, Adobe

Photoshop, Maya, Autocad, 3D space Max, dan lain – lain.

Untuk membuat program – program diatas dapat digunakan berbagai

macam bahasa pemrograman dengan library grafis yang sesuai.Dalam laporan

ini digunakan bahasa pemrograman C++, karena dalam system operasi

Microsoft Windows maka menggunakan Microsoft Visual C++ dengan library

grafik yang digunakan adalah OpenGL.

B. Pegertian OpenGL

OpenGL adalah library yang khusus menyediakan perangkat – perangkat

pembuatan grafik. OpenGL bekerja pada bahasa C. Dan berikut adalah cara

menginstall OpenGL pada Microsoft Windows:

1. Ada tiga file yang penting dalam OpenGL yang akan digunakan dalam

operasi MS-Windows, yaitu glut.h, glut32.lib dan glut.dll.

2. Letakkan glut.h di direktori include pada Visual C (vc98/include/GL).

3. Letakkan glut32.lib di direktori lib pada Visual C (vc98/lib).

4. Letakkan glut32.dll di direktori windows/system.

Struktur Dasar Program Grafik Dengan OpenGL
#include <GL/glut.h>
void userdraw()
{ static int tick=0;
//program grafik ditulis disini
}
void display(void)
{ //clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
int main(int argc, char**argv)
{ glutInit(&argc,argv);//Inisialisasi Toolkit
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
glutCreateWindow("Drawing by Nita");
glClearColor(0.0,0.0,0.0,0.0);
gluOrtho2D(0.,640.,-240.,240.);
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Keterangan :
* #include <GL/Glut.h>
Statment dasar yang harus ada dalam membuat gambar dengan library OpenGL.

* void userdraw()
{
static int tick=0;
//program grafik ditulis disini
}
Untuk menggambar objek yang akan dibuat dalam komputer grafik.

* void display(void)
{
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw();
glutSwapBuffers();
}
Untuk menggambarkan gambar di layar computer ketika program dijalankan.

* glutInitWindowPosition(100,100);
glutInitWindowSize(640,480);
Membuat window dengan ukuran(640,480) dengan titik kiri atas jendela
diletakkan pada posisi (100,100) di layar computer.

* glutCreateWindow("Drawing by Nita");
Memberi judul pada window dengan “Drawing by Nita”

* glClearColor(0.0,0.0,0.0,0.0);
Mendefenisikan warna dari window yang dibuat dengan warna (0,0,0), yaitu
warna hitam.

* gluOrtho2D(0.,640.,-240.,240.);
Mendefenisikan besarnya system koordinat dengan range sumbu x adalah [0,640]
dan range sumbu y adalah [-240,240].

C. Pengertian Polyline
Polyline adalah sekumpulan garis yang terhubung satu dengan yang lainnya hingga membentuk sebuah obyek gambar.

D. Pengertian Polygon
Polygon adalah sekumpulan garis yang terhubung satu dengan yang lainnya dan berbentuk kurva tertutup hingga membentuk sebuah obyek gambar.

F. Pewarnaan
glColor3f(red,green,blue);
Red,green,blue bervariasi diantara 0. S/d 1.

glColor3f(0.,0.,0.);//black

glColor3f(0.,0.,1.);//blue

glColor3f(0.,1.,0.);//green

glColor3f(0.,1.,1.);//cyan

glColor3f(1.,0.,0.);//red

glColor3f(1.,0.,1.);//magenta

glColor3f(1.,1.,0.);//yellow

glColor3f(1.,1.,1.);//white .

Berikut adalah tampilan gambar bintang yang dibuat menggunakan program Visual C++.

Berikut kode programnya :

#include <GL/glut.h>

void GambarPolyline(int x1,int y1,int x2,int y2,int x3, int y3,int x4, int y4,int x5, int y5,int x6, int y6,int x7, int y7,int x8,int y8, int x9, int y9, int x10, int y10){
glPointSize(4);
glBegin(GL_LINE_LOOP);
glVertex2i(x1,y1);
glVertex2i(x2,y2);
glVertex2i(x3,y3);
glVertex2i(x4,y4);
glVertex2i(x5,y5);
glVertex2i(x6,y6);
glVertex2i(x7,y7);
glVertex2i(x8,y8);
glVertex2i(x9,y9);
glVertex2i(x10,y10);
glEnd();
}

//draw area
void userdraw() {
static int tick=0;

//set warna (R,G,B)
glColor3f(1,0,0);

GambarPolyline(200,60,300,115,400,60,365,160,460,220,340,220,300,320,260,220,135,220,235,155);
glColor3f(1,1,0);
GambarPolyline(180,40,300,100,420,40,380,160,500,230,350,230,300,340,250,230,100,230,220,150);
glColor3f(0,1,0);
GambarPolyline(160,20,300,85,440,20,395,155,540,240,360,240,300,360,240,240,65,240,205,145);
glColor3f(0,0,1);
GambarPolyline(140,0,300,70,460,0,410,150,580,250,370,250,300,380,230,250,30,250,190,140);
}

void display(void){
//clear screen
glClear(GL_COLOR_BUFFER_BIT);
userdraw(); //jalanan userdraw()
glutSwapBuffers();
}
int main(int argc,char **argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
glutInitWindowPosition(100,100); //posisi windownya di(100,100)
glutInitWindowSize(640,480); //set ukuran window jadi 640x480
glutCreateWindow("Bintang Colorfull"); //set judul app
glClearColor(0,0,0,0); //set warna backgroun(r,g,b,a)(range 0-1)
gluOrtho2D(0.,640.,0.,480.); //set area menggambar
glutIdleFunc(display);
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Ilmu Copas

Membuat Animasi bintang dengan warna Gradasi

Membuat mobil dengan visual C++

Membuat Animasi sederhana yaitu lengan bergerak menggunakan Visual C++

membuat animasi kotak berputar menggunakan Visual C++

Materi Tentang pencahayaan pada OpenGL

Silabus materi pemrograman grafik kelas 12

Materi Dasar tentang Pemrograman Grafik

Membuat gambar bintang menggunakan Visual C++

About

Labels

Kategori

Kategori

Recent Comments

Mengenai Profil Saya

Total Pageviews

Blog Archive

Labels

POPULAR TAGS

Translate