Nurul Sabah

Rabu, 11 Oktober 2017

Tugas Praktikum Grafika Komputer (Primitive Drawing 2)

Berikut ini adalah tugas Praktikum pada materi Primitive Drawing 2 :

1. Coding :

#include <GL/glut.h>
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glEnable (GL_LINE_STIPPLE);
// glLineStipple (1, 0x0101); /* membuat titik */
// glLineStipple (1, 0x00ff); /* membuat strip-strip */
glLineStipple (1, 0x10ff); /* membuat strip titik strip */

glBegin(GL_LINE_STRIP);
glVertex2f (325, 75);
glVertex2f (5, 75);
glEnd();

glDisable (GL_LINE_STIPPLE);
glFlush ();
}
void reshape (int w, int h)
{
glViewport ( 0 , 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 150);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Output :

2. Coding :

#include <GL/glut.h>
#include <stdlib.h>

#define drawOneLine(x1,y1,x2,y2) glBegin(GL_LINES); \
glVertex2f ((x1),(y1)); \
glVertex2f ((x2),(y2)); \
glEnd();
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void display(void)
{

int i;
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.0, 1.0, 0.0);
glEnable (GL_LINE_STIPPLE);
glLineStipple (1, 0x0101); /* dotted */
drawOneLine (50.0, 125.0, 150.0, 125.0);
glLineStipple (1, 0x00FF); /* dashed */
drawOneLine (150.0, 125.0, 250.0, 125.0);
glLineStipple (1, 0x1C47); /* dash/dot/dash */
drawOneLine (250.0, 125.0, 350.0, 125.0);
glLineWidth (50.0);
glLineStipple (1, 0x0101); /* dotted */
drawOneLine (50.0, 100.0, 150.0, 100.0);
glLineStipple (1, 0x00FF); /* dashed */
drawOneLine (150., 100.0, 250.0, 100.0);
glLineStipple (1, 0x1C47); /* dash/dot/dash */
drawOneLine (250.0, 100.0, 350.0, 100.0);
glLineWidth (1.0);
glLineStipple (1, 0x1C47); /* dash/dot/dash */
glBegin (GL_LINE_STRIP);
for (i = 0; i < 7; i++)
glVertex2f (50.0 + ((GLfloat) i * 50.0), 75.0);
glEnd ();

for (i = 0; i < 6; i++)
{
drawOneLine (50.0 + ((GLfloat) i * 50.0), 50.0,
50.0 + ((GLfloat)(i+1) * 50.0), 50.0);
}
glLineStipple (5, 0x1C47); /* dash/dot/dash */
drawOneLine (50.0, 25.0, 350.0, 25.0);
glDisable (GL_LINE_STIPPLE);
glFlush ();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 150);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Output :

3. Coding :

#include <GL/glut.h>
void display(void)
{
GLubyte fly[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60,
0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20,
0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20,
0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC,
0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30,
0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0,
0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0,
0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30,
0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08,
0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08,
0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08};

glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.0, 1.0, 0.0);
glRectf (25.0, 125.0, 125.0, 350.0);
glEnable (GL_POLYGON_STIPPLE);
glPolygonStipple (fly);
glRectf (200.0, 125.0, 800.0, 350.0);
glDisable (GL_POLYGON_STIPPLE);
glFlush ();
}
void init (void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void reshape (int w, int h) {
glViewport (50, 0,(GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (1000, 500); glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;

}

Output :

4. Coding :

#include <GL/glut.h>
int board[3][3]; /* jumlah warna untuk tiap kotak */
/* Clear nilai warna untuk setiap kotak pada board */
void init(void)
{
int i, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j ++)
board[i][j] = 0;
glClearColor (0.0, 0.0, 0.0, 0.0);
}
void drawSquares(GLenum mode)
{
GLuint i, j; for (i = 0; i < 3; i++)
{
if (mode == GL_SELECT)
glLoadName (i);
for (j = 0; j < 3; j ++)
{
if (mode == GL_SELECT)
glPushName (j);
glColor3f ((GLfloat) i/3.0, (GLfloat) j/3.0, (GLfloat) board[i][j]/3.0);
glRecti (i, j, i+1, j+1);
if (mode == GL_SELECT) glPopName ();
}
}
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
drawSquares (GL_RENDER);
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D (0.0, 3.0, 0.0, 3.0
);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutReshapeFunc (reshape);
glutDisplayFunc(display);
glutMainLoop();
return 0;

}

Output :

5. Coding :

#include <string.h>
#include <GL/glut.h>
void *font = GLUT_BITMAP_TIMES_ROMAN_24;
void *fonts[] ={GLUT_BITMAP_9_BY_15, GLUT_BITMAP_TIMES_ROMAN_10, GLUT_BITMAP_TIMES_ROMAN_24};
char defaultMessage[] = "Pustaka GLUT OpenGL.";
char *message = defaultMessage;
void selectFont(
int newfont)
{
font = fonts[newfont];
glutPostRedisplay();
}
void selectMessage(int msg)
{
switch (msg)
{
case1: message = "pustaka glut openGL...kecil.";
break;
case2: message = "PUSTAKA GLUT OPENGL...BESAR.";
break;
}
}
void selectColor(int color)
{
switch (color)
{
case1: glColor3f(0.0, 1.0, 0.0);
break;
case2: glColor3f(1.0, 0.0, 0.0);
break;
case3: glColor3f(1.0, 1.0, 1.0);
break;
}
glutPostRedisplay();
}
void tick(void)
{
glutPostRedisplay();
}
void output(int x, int y, char *string)
{
int len, i;
glRasterPos2f(x, y);
len = (int) strlen(string);
for (i = 0; i < len; i++)
{
glutBitmapCharacter(font, string[i]);
}
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
output(0, 24, "HELLO SAYA BELAJAR GLUT bitmap font.");
output(100, 100, message);
output(0, 145,"(Posisi dalam PIXEL dengan dimulai atas kiri,...xixixi)");
glutSwapBuffers();
}
void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char**argv)
{
int i, msg_submenu, color_submenu;
glutInit(&argc, argv);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-mono"))
{
font = GLUT_BITMAP_9_BY_15;
}
}
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(600, 150);
glutCreateWindow("GLUT bitmap font example");
glClearColor(0.0, 0.0, 0.0, 1.0);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(tick);
msg_submenu = glutCreateMenu(selectMessage);
glutAddMenuEntry("huruf kecil",1);
glutAddMenuEntry("HURUF BESAR", 2);
color_submenu = glutCreateMenu(selectColor);
glutAddMenuEntry("HIJAU", 1);
glutAddMenuEntry("MERAH", 2);
glutAddMenuEntry("PUTIH", 3);
glutCreateMenu(selectFont);
glutAddMenuEntry("Default", 0);
glutAddMenuEntry("Times Roman 10", 1);
glutAddMenuEntry("Times Roman 24", 2);
glutAddSubMenu("Messages", msg_submenu);
glutAddSubMenu("Warna", color_submenu);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop();
return 0;
}

Output :

TUGAS.

1. Garis Strip

Coding :
#include <GL/glut.h>
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 0.0, 1.0);
glEnable (GL_LINE_STIPPLE);
// glLineStipple (1, 0x0101); /* membuat titik */
glLineStipple (1, 0x00ff); /* membuat strip-strip */
//glLineStipple (1, 0x10ff); /* membuat strip titik strip */
glBegin(GL_LINE_STRIP);
glVertex2f (127, 80);
glVertex2f (500, 100);
glEnd();
glDisable (GL_LINE_STIPPLE);
glFlush ();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (600, 150);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;

}

Output :

2. Gambar Lilin

Coding :
#include <GL/glut.h>
void display(void)
{
GLubyte line[] = {
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF
};
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (2.0, 1.0, 3.0);
glEnable (GL_POLYGON_STIPPLE);
glPolygonStipple (line);
glRectf (100.0, 100.0, 300.0, 320.0);
glDisable (GL_POLYGON_STIPPLE);
glFlush ();
}
void init (void)
{
glClearColor (0.1, 2.0, 3.0, 4.0);
glShadeModel (GL_FLAT);
}
void reshape (int w, int h)
{
glViewport (50, 0,(GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (1000, 500);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;

}

Output :

Sekian untuk tugas ini, semoga bermanfaat bagi para pembaca.

Selasa, 03 Oktober 2017

Tugas Praktikum Grafika Komputer

Berikut ini adalah tugas praktikum :

1.
a. Titik

Coding :

#include <GL/glut.h>

void titik ();

main(int argc, char** argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(600,800);

glutInitWindowPosition(100,100);

glutCreateWindow("Percobaan 1");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glOrtho(1.0,1.0,1.0,1.0,-1.0,1.0);

glutDisplayFunc(titik);

glutMainLoop();

}

void titik()

{

glClear(GL_COLOR_BUFFER_BIT);

glPointSize(5.5);

glBegin(GL_POINTS);

glColor3f(1.0,1.0,1.0);

glVertex2f(0.25,0.25);

glColor3f(0.1,1.0,1.0);

glVertex2f(0.5,0.5);

//glPointSize(2.0);

glEnd();

glFlush();

}

Output:

b. Titik Banyak

Coding :

#include <GL/glut.h>

void titik ();

main(int argc, char** argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(600,800);

glutInitWindowPosition(100,100);

glutCreateWindow("Percobaan 1");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glOrtho(1.0,1.0,1.0,1.0,-1.0,1.0);

glutDisplayFunc(titik);

glutMainLoop();

}

void titik()

{

glClear(GL_COLOR_BUFFER_BIT);

glPointSize(5.5);

glBegin(GL_POINTS);

glColor3f(1.0,1.0,1.0);

glVertex2f(0.25,0.25);

glColor3f(0.1,1.0,1.0);

glVertex2f(0.5,0.5);

glColor3f(1.0,0.0,0.0);

glVertex2f(0.15,0.15);

glColor3f(1.0,0.0,1.0);

glVertex2f(0.50,0.50);

glColor3f(0.0,0.0,1.0);

glVertex2f(0.85,0.85);

glEnd();

glFlush();

}

Output :

2. Lines

Coding :

#include<GL/glut.h>

void titik();

main(int argc,char** argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(800,600);

glutInitWindowPosition(100,100);

glutCreateWindow("Percobaan !");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

//glOrtho(1.0,1.0,1.0,1.0,-1.0,1.0);

glutDisplayFunc(titik);

glutMainLoop();

}

void titik()

{

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINES);

glColor3f(1.0,1.0,1.0);

glVertex2f(0.25,0.25);

glColor3f(0.1,1.0,1.0);

glVertex2f(0.5,0.5);

glVertex2f(0.75,0.5);

glVertex2f(0.5,0.8);

glPointSize(50.0f);

glEnd();

glFlush();

}

Output :

3. Stripe

Coding :

#include<GL/glut.h>

void titik();

main(int argc,char** argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(800,600);

glutInitWindowPosition(100,100);

glutCreateWindow("Percobaan !");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

//glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

glOrtho(1.0,1.0,1.0,1.0,-1.0,1.0);

glutDisplayFunc(titik);

glutMainLoop();

}

void titik()

{

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINE_STRIP);

glColor3f(1.0,0.0,0.0);

glVertex2f(0.25,0.25);

glColor3f(0.1,1.0,0.0);

glVertex2f(0.5,0.5);

glColor3f(0.0,0.0,1.0);

glVertex2f(0.75,0.75);

glVertex2f(0.7,0.8);

glPointSize(50.0f);

glEnd();

glFlush();

}

Output :

4. Segitiga

Coding :

#include<GL/glut.h>

void titik();

main(int argc,char** argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(800,600);

glutInitWindowPosition(100,100);

glutCreateWindow("Percobaan !");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

//glOrtho(1.0,1.0,1.0,1.0,-1.0,1.0);

glutDisplayFunc(titik);

glutMainLoop();

}

void titik()

{

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINES);

glColor3f(0.1,0.1,1.0);

glVertex2f(0.75,0.5);

glColor3f(0.1,1.0,0.1);

glVertex2f(0.25,0.5);

glColor3f(0.0,0.0,1.0);

glVertex2f(0.75,0.5);

glColor3f(1.0,0.1,0.1);

glVertex2f(0.5,0.9);

glColor3f(0.1,1.0,0.1);

glVertex2f(0.25,0.5);

glColor3f(1.0,0.0,0.0);

glVertex2f(0.5,0.9);

glEnd();

glFlush();

}

Output :

5. Kubus

Coding :

#include <GL/glut.h>

void titik();

main(int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(600,600);

glutInitWindowPosition(100,100);

glutCreateWindow("PERCOBAAN 2");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glutDisplayFunc(titik);

glutMainLoop();

}

void titik()

{

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_POLYGON);

glColor3f(1.0,1.0,0.0); //persegi ungu

glVertex2f(-0.5,-0.5);

glVertex2f(-0.5,0.5);

glVertex2f(0.5,0.5);

glVertex2f(0.5,-0.5);

glEnd();

glFlush();

} //untuk mengeksekusi opengL infinite time

Output :

6. Pelangi

Coding :

#include<GL/glut.h>

void titik ();

main(int argc, char** argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(800,600);

glutInitWindowPosition(100,100);

glutCreateWindow("Percobaan 2");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

glutDisplayFunc(titik);

glutMainLoop();

}

void titik()

{

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINES);

glColor3f(1.0,0.0,0.0);

glVertex2f(0.5,0.7);

glColor3f(0.0,0.0,0.0);

glVertex2f(0.5,0.9);

glColor3f(0.0,1.0,0.0);

glVertex2f(0.8,0.3);

glColor3f(0.0,1.0,0.0);

glVertex2f(0.2,0.2);

glColor3f(0.0,0.0,1.0);

glVertex2f(0.6,0.9);

glColor3f(0.0,0.0,1.0);

glVertex2f(0.4,0.4);

glColor3f(1.0,5.0,0.0);

glVertex2f(0.15,0.3);

glColor3f(1.0,5.0,0.0);

glVertex2f(0.7,0.7);

glColor3f(0.0,5.0,0.0);

glVertex2f(0.55,0.8);

glColor3f(0.1,1.0,1.0);

glVertex2f(0.10,0.9);

glColor3f(1.0,0.0,1.0);

glVertex2f(0.3,0.9);

glColor3f(1.0,0.0,1.0);

glVertex2f(0.5,0.5);

glColor3f(1.0,1.0,1.0);

glVertex2f(0.8,0.15);

glColor3f(1.0,1.0,1.0);

glVertex2f(0.7,0.3);

glPointSize(50.0f);

glEnd();

glFlush();

}

Output :

7. Kubus dalam kubus

Coding :

#include<GL/glut.h>

void titik();

void titik()

{

glClear(GL_COLOR_BUFFER_BIT); //merah

glBegin(GL_POLYGON);

glColor3f(0.0,1.0,0.0);

glVertex2f(-0.7f,-0.7f);

glVertex2f(-0.7f,0.7f);

glVertex2f(0.7f,0.7f);

glVertex2f(0.7f,-0.7f);

glVertex2f(-0.7f,-0.7f);

glPointSize(50.0f);

glEnd();//akhir perintah OpenGL

glBegin(GL_POLYGON);

glColor3f(1.0,0.0,0.0);

glVertex2f(-0.3f,-0.3f);

glVertex2f(-0.3f,0.3f);

glVertex2f(0.3f,0.3f);

glVertex2f(0.3f,-0.3f);

glVertex2f(-0.3f,-0.3f);

glPointSize(50.0f);

glEnd();//akhir perintah OpenGL

glFlush();//untuk mengeksekusi openGL infinite time

}

main(int argc, char** argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);

glutInitWindowSize(800,800);

glutInitWindowPosition(100,100);

glutCreateWindow("Percobaan 3");

glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);

// glOrtho(0.0,1.0,0.0,1.0,-1.0,1.0);

glOrtho(1.0,1.0,1.0,1.0,-1.0,1.0);

glutDisplayFunc(titik);

glutMainLoop();

}

Output :

Terima Kasih telah mengunjungi blog ini. Semoga bermanfaat bagi pembaca.

Senin, 25 September 2017

Tugas Praktek Grafika Komputer (Membuat Rumah)

Berikut adalah program untuk membuat sebuah rumah sederhana dengan menggunakan Dev C++. Langsung saja ikuti langkah-langkahnya.

Langkah 1 :

Buat 1 Project untuk menyimpan file yang ingin kita buat kemudian buka lembar kerja baru (Ctrl + N)

Langkah 2 :

Pada Menu Project, pilih Project Option (Alt + P), pilih tab Parameters. Pada kolom Linker, copy kan linker di bawah ini dan klik Ok.

-lopengl32

-lfreeglut

-lglu32

Langkah 3 :

Simpan, compile, dan run file berikut :

#include <iostream>

#include <windows.h>

#include <gl/GL.h>

#include <gl/glut.h>

#include <stdlib.h>

#include <stdio.h>

int screenWidth=640;

int screenHeight=480;

struct Point

{

int x;

int y;

};

struct GlintPoint

{

GLint x,y;

};

void myInit(void)

{

glClearColor (0.0,0,0.0,0);

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

glPointSize(4.0);

glLineWidth(4.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0.0,(GLdouble)screenWidth,0.0,(GLdouble)screenHeight);

}

void paraHouse(struct Point peak, GLint width, GLint height)

{

glBegin (GL_LINE_LOOP);

glVertex2i(peak.x - width / 2, peak.y - height);

glVertex2i(peak.x - width / 2, peak.y - 4 * height/9);

glVertex2i(peak.x - width / 3, peak.y - 2 * height/9);

glVertex2i(peak.x + width / 3, peak.y - 2 * height/9);

glVertex2i(peak.x + width / 2, peak.y - 4 * height/9);

glVertex2i(peak.x + width / 2, peak.y - height);

glEnd();

glBegin(GL_LINE_STRIP);

glVertex2i(peak.x - width / 6, peak.y - 2*height /9);

glVertex2i(peak.x, peak.y );

glVertex2i(peak.x + width / 6, peak.y - 2*height/9);

glEnd();

glBegin(GL_LINE_STRIP);

glVertex2i(peak.x - width / 3, peak.y - height);

glVertex2i(peak.x - width / 3, peak.y - 5*height /9);

glVertex2i(peak.x - 5 * width / 60, peak.y - 5*height/9);

glVertex2i(peak.x - 5 * width / 60, peak.y - height);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex2i(peak.x + width / 12, peak.y - 7*height/9);

glVertex2i(peak.x + width / 12, peak.y - 5*height/9);

glVertex2i(peak.x + width / 4, peak.y - 5*height/9);

glVertex2i(peak.x + width / 4, peak.y - 7*height/9);

glEnd();

}

void Display (void)

{

struct Point p;

p.x=300;

p.y=300;

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_POINT);

paraHouse(p,100,200);

glBegin(GL_LINE_LOOP);

glVertex2i(10,10);

glVertex2i(10,60);

glVertex2i(20,80);

glVertex2i(60,80);

glVertex2i(70,60);

glVertex2i(70,10);

glEnd();

glBegin(GL_LINE_STRIP);

glVertex2i(20,10);

glVertex2i(20,50);

glVertex2i(35,50);

glVertex2i(35,10);

glEnd();

glBegin(GL_LINE_STRIP);

glVertex2i(30,80);

glVertex2i(40,100);

glVertex2i(50,80);

glEnd();

glBegin(GL_LINE_LOOP);

glVertex2i(45,30);

glVertex2i(45,50);

glVertex2i(55,50);

glVertex2i(55,30);

glEnd();

glFlush();

}

int main(int argc, char**argv)

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE);

glutInitWindowSize(800,600);

glutInitWindowPosition(100,150);

glutCreateWindow("HOUSE");

glutDisplayFunc(Display);

myInit();

glutMainLoop();

}

Jadilah gambar rumah sederhana seperti diatas.