pamungkas bayu aji: Grafkom

PRAKTIKUM 1

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <glut.h>

void mydisplay(){

glClear (GL_COLOR_BUFFER_BIT);

glBegin (GL_POLYGON);

glVertex2f(0, 0);

glVertex2f(0.5, 0.5);

glVertex2f(0, 1);

glVertex2f(-0.5, 0.5);

glVertex2f(0, 0);

glVertex2f(0.5, -0.5);

glVertex2f(0, -1);

glVertex2f(-0.5, -0.5);

glVertex2f(0, 0);

glEnd();

glFlush();

}

int main (int argc, char** argv)

{

printf ("contoh sederhana kotak");

glutCreateWindow("Praktikum 1");

glutDisplayFunc (mydisplay);

glutMainLoop();}

PRAKTIKUM 2

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <GL/glut.h>

#define drawOneLine(x1,y1,x2,y2) glBegin(GL_LINES);

glVertex2f ((x1),(y1)); glVertex2f ((x2),(y2)); glEnd();

using namespace std;

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 (1.0, 1.0, 1.0);

glEnable (GL_LINE_STIPPLE);

glLineStipple (1, 0x0101);

drawOneLine (50.0, 125.0, 150.0, 125.0);

glLineStipple (1, 0x00FF);

drawOneLine (150.0, 125.0, 250.0, 125.0);

glLineStipple (1, 0x1C47);

drawOneLine (250.0, 125.0, 350.0, 125.0);

glLineWidth(5.0);

glLineStipple(1, 0x0101);

drawOneLine(50.0, 100.0, 150.0, 100.0);

glLineStipple(1, 0x00FF);

drawOneLine(150.0, 100.0, 250.0, 100.0);

glLineStipple(1, 0x1C47);

drawOneLine(250.0, 100.0, 350.0, 100.0);

glLineWidth(1.0);

glLineStipple (1, 0x0101);

drawOneLine (48.0, 48.0, 50.0, 125.0);

glLineWidth(1.0);

glLineStipple (1, 0x0101);

drawOneLine (248.0, 248.0, 50.0, 50.0);

glLineStipple(1, 0x0101);

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);

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(intargc, 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();

system("PAUSE");

return EXIT_SUCCESS;

}

PRAKTIKUM 3

#include<windows.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<stdarg.h>

#include<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,

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};

GLubyte halftone[] = {

0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,

0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55};

GLubyte S[] = {

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0xFF, 0xFF, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,

0x00, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,

0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00,

0xC0, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,};

glClear (GL_COLOR_BUFFER_BIT);

glColor3f (1.0, 1.0, 1.0);

/* draw one solid, unstippled rectangle, */

/* then two stippled rectangles */

glRectf (25.0, 25.0, 125.0, 125.0);

glEnable (GL_POLYGON_STIPPLE);

glPolygonStipple (fly);

glRectf (125.0, 25.0, 225.0, 125.0);

glPolygonStipple (halftone);

glRectf (225.0, 25.0, 325.0, 125.0);

glPolygonStipple (S);

glRectf (125.0, 25.0, 225.0, 125.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 (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 (350, 150);

glutCreateWindow (argv[0]);

init ();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutMainLoop();

return 0;

}

PRAKTIKUM 4

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <glut.h>

#include <math.h>

void display (void)

{

glClearColor(1.0,1.0,1.0,0.0);

glMatrixMode (GL_PROJECTION);

gluOrtho2D(0.0,300.0,0.0,300.0);

}

void setPixel (GLint xCoordinate, GLint yCoordinate)

{

glBegin (GL_POINTS);

glVertex2i (xCoordinate, yCoordinate);

glEnd();

glFlush();

}

void lineBres (GLint x0, GLint y0, GLint xEnd, GLint yEnd)

{

GLint dx = (float) fabs ((float) xEnd - x0);

GLint dy = (float) fabs ((float) yEnd - y0);

GLint p = 2 * dy - dx;

GLint twoDy = 2 * dy;

GLint twoDyMinusDx = 2 * (dy-dx);

GLint x,y;

if (x0 > xEnd){

x = xEnd;

y = yEnd;

xEnd = x;

}else{

x = x0;

y = y0;

}

setPixel (x,y);

while (x<xEnd){

x++;

if(p<0)

p += twoDy;

else{

y++;

p+= twoDyMinusDx;

}

setPixel (x, y);

}

void drawMyLine(void)

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f (1.0,0.0,0.0);

glPointSize(4.0);

GLint x0 = 50;

GLint y0 = 50;

GLint xEnd = 125;

GLint yEnd = 100;

lineBres (x0, y0, xEnd, yEnd);

glColor3f (0.0,1.0,0.0);

glPointSize(4.0);

GLint x1 = 75;

GLint y1 = 50;

GLint x1End = 125;

GLint y1End = 150;

lineBres (x1, y1, x1End, y1End);

glColor3f (0.0,0.0,1.0);

glPointSize(4.0);

GLint x2 = 50;

GLint y2 = 50;

GLint x2End = 75;

GLint y2End = 50;

lineBres (x2, y2, x2End, y2End);

}

int main (int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize (400,400);

glutInitWindowPosition (0,0);

glutCreateWindow ("Digital Differential Analyzer Algorithm");

display();

glutDisplayFunc (drawMyLine);

glutMainLoop();

return 0;

}

PRAKTIKUM 5

#include <iostream>

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <glut.h>

#include<math.h>

using namespace std;

typedef unsigned char uchar;

// number of line segments

static int num_lines = 20;

static int num_liness = 3;

// callback prototypes

void disp(void);

void keyb(uchar k, int x, int y);

void reshape(int x, int y);

// main

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

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);

glutInitWindowSize(400,400);

glutInitWindowPosition(100,100);

glutCreateWindow("circle.cpp");

glClearColor(0.0,0.0,0.0,0.0);

glutDisplayFunc(disp);

glutKeyboardFunc(keyb);

glutReshapeFunc(reshape);

glutMainLoop();

return 0; }

// disp

void disp(void){

double angle;

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINE_LOOP);

glColor3f(1.0,1.0,0.0);

for(int i =0;i<num_lines;i++)

{

angle = i*2*3.14/num_lines;

glVertex2f(cos(angle),sin(angle));

}

glEnd();

// glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINE_LOOP);

glColor3f(0.0,0.0,1.0);

for(int i =0;i<3;i++)

{

angle = i*2*3.14/3;

glVertex2f(cos(angle),sin(angle));

}

glEnd();

glBegin(GL_LINE_LOOP);

for(int i =0;i<num_lines;i++){

glColor3f(0.0,1.0,0.0);

angle = i*2*3.14/num_lines;

glVertex2f(cos(angle)/2,sin(angle)/2);

}

glEnd();

glBegin(GL_LINE_LOOP);

for(int i =0;i<4;i++){

glColor3f(1.0,0.0,0.0);

angle = i*2*3.14/4;

glVertex2f(cos(angle)/4,sin(angle)/4);

}

glEnd();

glBegin(GL_LINE_LOOP);

for(int i =0;i<num_lines;i++){

glColor3f(1.0,0.1,0.0);

angle = i*2*3.14/num_lines;

glVertex2f(cos(angle)/4,sin(angle)/4);

}

glEnd();

glutSwapBuffers();

}

// keyb

void keyb(uchar k, int x, int y){

switch (k){

case 'q':

exit(0);

break;

case '+':

if(num_lines < 99){

num_lines++;

cout << "Circle consists of " << num_lines << " lines " << endl;

glutPostRedisplay();

}

break;

case '-':

if(num_lines >3){

num_lines--;

cout << "Circle consists of " << num_lines << " lines " << endl;

glutPostRedisplay();

}

break; } }

// reshape

void reshape(int x,int y){

if(x<y)

glViewport(0,(y-x)/2,x,x);

else

glViewport((x-y)/2,0,y,y); }

PRAKTIKUM 6

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <glut.h>

#include <glu.h>

#include <iostream>

float _angle = 45.0f; //sudut saat melakukan rotasi

//Draws the 3D scene

void mydisplay() //bentuk objek berupa kotak

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);//Switch to setting

glLoadIdentity();//Reset the camera

glPushMatrix();//Save the transformations

//glTranslatef(0.0f, 0.0f, 0.0f); //mentraslasikan kotak geser sesuai koor

//glScalef(0.7f, 0.7f, 0.7f); //merubah ukuran dari objek kotak

glRotatef(_angle, 0.0f, 0.0f, 1.0f); //diputar sebesar angle

//bentuk kotak

glBegin(GL_POLYGON);

glVertex3f(-0.1f, -0.1f,0.0f);

glVertex3f(-0.1f, 0.1f,0.0f);

glVertex3f(0.1f, 0.1f,0.0f);

glVertex3f(0.1f, -0.1f,0.0f);

glEnd();

//glPopMatrix();//Undo the move to the center of

glPushMatrix();//Save the transformations

glTranslatef(0.0f, 0.4f, 0.0f); //mentraslasikan kotak geser sesuai koor

glScalef(0.6f, 0.6f, 0.6f); //merubah ukuran dari objek kotak

glRotatef(_angle, 0.0f, 0.0f, -1.0f); //diputar sebesar angle

//bentuk kotak

glBegin(GL_POLYGON);

glVertex3f(-0.1f, -0.1f,0.0f);

glVertex3f(-0.1f, 0.1f,0.0f);

glVertex3f(0.1f, 0.1f,0.0f);

glVertex3f(0.1f, -0.1f,0.0f);

glEnd();

//glPopMatrix();//Undo the move to the center of

glTranslatef(0.0f, 0.6f, 0.0f); //mentraslasikan kotak geser sesuai koor

glScalef(0.5f, 0.5f, 0.5f); //merubah ukuran dari objek kotak

glRotatef(_angle, 0.0f, 0.0f, -1.0f); //diputar sebesar angle

glPushMatrix();//Save the transformations

//bentuk kotak

glBegin(GL_POLYGON);

glVertex3f(-0.1f, -0.1f,0.0f);

glVertex3f(-0.1f, 0.1f,0.0f);

glVertex3f(0.1f, 0.1f,0.0f);

glVertex3f(0.1f, -0.1f,0.0f);

glEnd();

glPopMatrix();//Undo the move to the center of

glutSwapBuffers();//Send the 3D scene to the

glFlush();

}

void update(int value) { //bantuan dari glrotate

_angle += 9.0f;

if (_angle > 360) {

_angle -= 360;

}

glutPostRedisplay();

glutTimerFunc(35, update, 0);//25:ukuran milisecond

}

int main(int argc, char** argv)

{

glutInitWindowSize(400, 400);

printf("Contoh Sederhana Kotak ");

glutCreateWindow("Praktikum06");

glutDisplayFunc(mydisplay);

glutTimerFunc(35, update, 0);

glutMainLoop();

return 0;

}

PRAKTIKUM 7

#include<windows.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<stdarg.h>

#include<glut.h>

#include<glu.h>

void init(void)

{

glClearColor (0.0, 0.0, 0.0, 0.0);

glShadeModel (GL_FLAT);

}

void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

glColor3f (1.0, 1.0, 1.0);

glLoadIdentity ();/* clear the matrix */

/* viewing transformation */

gluLookAt (0.5, 2.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

glScalef (1.0, 1.0, 1.0); /* modeling transformation 1*/

glutWireCube(0.5);

glTranslatef(-1.0,0.0,0.0); /* modeling transformation 2*/

glutWireCube(0.5);

glTranslatef(2.0,0.0,0.0); /* modeling transformation 3*/

glutWireCube(0.5);

/* modeling transformation */

glTranslatef(0.0,0.0,1.0);

glutWireCube(0.5);

glTranslatef(-2.0,0.0,0.0); /* modeling transformation */

glutWireCube(0.5);

glTranslatef(1.0,0.0,0.0); /* modeling transformation */

glutWireCube(0.5);

glColor3f(0.0,0.0,1.0);

glTranslatef(0.5,0.5,-0.5); /* modeling transformation */

glutWireCube(0.5);

glColor3f(1.0,0.0,0.0);

glTranslatef(-1.0,0.0,0.0); /* modeling transformation */

glutWireCube(0.5);

glColor3f(1.0,1.0,1.0);

glTranslatef(0.5,0.5,0.0); /* modeling transformation */

glutWireCube(0.5);

glFlush ();

}

void reshape (int w, int h)

{

glViewport (0, 0, (GLsizei) w, (GLsizei) h);

glMatrixMode (GL_PROJECTION);

glLoadIdentity ();

glFrustum (-1.0, 1.0, -1.0, 1.0, 2.0, 20.0);

glMatrixMode (GL_MODELVIEW);

}

int main(int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize (500, 500);

//glutInitWindowPosition (100, 100);

glutCreateWindow (argv[0]);

init ();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutMainLoop();

return 0;

}

PRAKTIKUM 8

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <glut.h>

#include <glu.h>

float _angle = 45.0f;

void initRendering() {

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glShadeModel(GL_SMOOTH);

}

void handleResize(int w, int h) {

glViewport(0, 0, w, h);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, (double)w / (double)h,7.0, 100.0); //sdt pandang

glMatrixMode (GL_MODELVIEW);

}

void drawScene() {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -8.0f);//pindah posisi xyz

GLfloat ambientColor[] = {0.0f, 0.0f, 0.0f, 1.0f};

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);

GLfloat lightColor0[] = {0.0f, 1.0f, 1.0f, 2.0f};

GLfloat lightPos0[] = {3.0f, 10.0f, 2.0f, 4.0f}; //

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);

glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);

gluLookAt (2.0, 4.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

//glScalef (2.0, 2.0, 2.0);

glTranslatef(0.0, 0.0,0.0);

glutSolidCube(1.0);

glTranslatef(1.0f, 0.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor1[] = {0.0f, 1.0f, 1.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor1);

glutSolidCube(1.0);

glTranslatef(1.0f, 0.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor2[] = {0.0f, 1.0f, 1.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor2);

glutSolidCube(1.0);

glTranslatef(0.0f, -1.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor3[] = {1.0f, 1.0f, 0.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor3);

glutSolidCube(1.0);

glTranslatef(0.0f, -1.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor4[] = {1.0f, 1.0f, 0.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor4);

glutSolidCube(1.0);

glTranslatef(0.0f, -1.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor5[] = {1.0f, 1.0f, 0.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor5);

glutSolidCube(1.0);

glTranslatef(-2.0f, 0.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor6[] = {0.0f, 0.0f, 2.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor6);

glutSolidCube(1.0);

glTranslatef(-1.0f, 0.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor7[] = {0.0f, 0.0f, 2.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor7);

glutSolidCube(1.0);

glTranslatef(-1.0f, 0.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor8[] = {0.0f, 0.0f, 2.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor8);

glutSolidCube(1.0);

glTranslatef(0.0f, 1.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor9[] = {0.0f, 1.0f, 0.0f, 0.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor9);

glutSolidCube(1.0);

glTranslatef(0.0f, 1.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor10[] = {0.0f, 1.0f, 0.0f, 0.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor10);

glutSolidCube(1.0);

glTranslatef(0.0f, 1.0f, 0.0f);//pindah posisi xyz

GLfloat lightColor11[] = {0.0f, 1.0f, 0.0f, 0.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor11);

glutSolidCube(1.0);

glTranslatef(0.0f, 2.0f, 0.0f);//pindah posisi xyz

glRotatef(_angle, 0.0f, 1.0f, 0.0f);

GLfloat lightColor12[] = {1.0f, 0.0f, 0.0f, 2.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor12);

glutSolidCube(1.0);

glFlush ();

glEnd();

glutSwapBuffers();

}

void update(int value) {

_angle += 9.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("praktikum_8");

initRendering();

glutDisplayFunc(drawScene);

glutReshapeFunc(handleResize);

glutTimerFunc(25, update, 0);

glutMainLoop();

return 0;

}

PRAKTIKUM 9

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <glut.h>

#include <glu.h>

void initRendering() {

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glEnable(GL_LIGHT1);

glEnable(GL_NORMALIZE);

glShadeModel(GL_SMOOTH);

}

void handleResize(int w, int h) {

glViewport(0, 0, w, h);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, (double)w / (double)h, 1.0, 200.0);

}

float _angle = 60.0f;

void drawScene() {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -8.0f);

GLfloat ambientColor[] = {0.2f, 0.2f, 0.2f, 1.0f};

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);

GLfloat lightColor0[] = {0.5f, 0.5f, 0.5f, 1.0f};

GLfloat lightPos0[] = {4.0f, 0.0f, 8.0f, 1.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);

glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);

//radius

GLfloat lightColor1[] = {0.5f, 0.2f, 0.2f, 1.0f};

GLfloat lightPos1[] = {-1.0f, 0.5f, 0.5f, 0.0f};

glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor1);

glLightfv(GL_LIGHT1, GL_POSITION, lightPos1);

glRotatef(_angle, 1.5f, 1.0f, 2.0f);

glBegin(GL_QUADS);

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

glVertex3f(0, 3, 0);

glVertex3f(1, 0, -1);

glVertex3f(1, 0, 1);

glVertex3f(0, 3, 0);

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

glVertex3f(0, 3, 0);

glVertex3f(1, 0, 1);

glVertex3f(-1, 0, 1);

glVertex3f(0, 3, 0);

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

glVertex3f(0, 3, 0);

glVertex3f(1, 0, -1);

glVertex3f(-1, 0, -1);

glVertex3f(0, 3, 0);

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

glVertex3f(0, 3, 0);

glVertex3f(-1, 0, -1);

glVertex3f(-1, 0, 1);

glVertex3f(0, 3, 0);

glColor3f(1.0f, 1.0f, 1.0f); //alas

glVertex3f(-1, 0, -1);

glVertex3f(-1, 0, 1);

glVertex3f(1, 0, 1);

glVertex3f(1, 0, -1);

glEnd();

glutSwapBuffers();

}

void update(int value) {

_angle += 1.5f;

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("Lighting - videotutorialsrock.com");

initRendering();

glutDisplayFunc(drawScene);

glutReshapeFunc(handleResize);

glutTimerFunc(25, update, 0);

glutMainLoop();

return 0;

}

PRAKTIKUM 10

main

#include <windows.h>

#include <iostream>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <glut.h>

#include <glu.h>

#include "imageloader.h"

using namespace std;

Image::Image(char* ps, int w, int h) : pixels(ps), width(w), height(h) {

}

Image::~Image() {

delete[] pixels;

}

namespace {

//Converts a four-character array to an integer, using little-endian form

int toInt(const char* bytes) {

return (int)(((unsigned char)bytes[3] << 24) |

((unsigned char)bytes[2] << 16) |

((unsigned char)bytes[1] << 8) |

(unsigned char)bytes[0]);

}

//Converts a two-character array to a short, using little-endian form

short toShort(const char* bytes) {

return (short)(((unsigned char)bytes[1] << 8) |

(unsigned char)bytes[0]);

}

//Reads the next four bytes as an integer, using little-endian form

int readInt(ifstream &input) {

char buffer[4];

input.read(buffer, 4);

return toInt(buffer);

}

//Reads the next two bytes as a short, using little-endian form

short readShort(ifstream &input) {

char buffer[2];

input.read(buffer, 2);

return toShort(buffer);

}

//Just like auto_ptr, but for arrays

template<class T>

class auto_array {

private:

T* array;

mutable bool isReleased;

public:

explicit auto_array(T* array_ = NULL) :

array(array_), isReleased(false) {

}

auto_array(const auto_array<T> &aarray) {

array = aarray.array;

isReleased = aarray.isReleased;

aarray.isReleased = true;

}

~auto_array() {

if (!isReleased && array != NULL) {

delete[] array;

}

T* get() const {

return array;

}

T &operator*() const {

return *array;

}

void operator=(const auto_array<T> &aarray) {

if (!isReleased && array != NULL) {

delete[] array;

}

array = aarray.array;

isReleased = aarray.isReleased;

aarray.isReleased = true;

}

T* operator->() const {

return array;

}

T* release() {

isReleased = true;

return array;

}

void reset(T* array_ = NULL) {

if (!isReleased && array != NULL) {

delete[] array;

}

array = array_;

}

T* operator+(int i) {

return array + i;

}

T &operator[](int i) {

return array[i];

}

};

}

Image* loadBMP(const char* filename) {

ifstream input;

input.open(filename, ifstream::binary);

assert(!input.fail() || !"Could not find file");

char buffer[2];

input.read(buffer, 2);

assert(buffer[0] == 'B' && buffer[1] == 'M' || !"Not a bitmap file");

input.ignore(8);

int dataOffset = readInt(input);

//Read the header

int headerSize = readInt(input);

int width;

int height;

switch(headerSize) {

case 40:

//V3

width = readInt(input);

height = readInt(input);

input.ignore(2);

assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");

assert(readShort(input) == 0 || !"Image is compressed");

break;

case 12:

//OS/2 V1

width = readShort(input);

height = readShort(input);

input.ignore(2);

assert(readShort(input) == 24 || !"Image is not 24 bits per pixel");

break;

case 64:

//OS/2 V2

assert(!"Can't load OS/2 V2 bitmaps");

break;

case 108:

//Windows V4

assert(!"Can't load Windows V4 bitmaps");

break;

case 124:

//Windows V5

assert(!"Can't load Windows V5 bitmaps");

break;

default:

assert(!"Unknown bitmap format");

}

//Read the data

int bytesPerRow = ((width * 3 + 3) / 4) * 4 - (width * 3 % 4);

int size = bytesPerRow * height;

auto_array<char> pixels(new char[size]);

input.seekg(dataOffset, ios_base::beg);

input.read(pixels.get(), size);

//Get the data into the right format

auto_array<char> pixels2(new char[width * height * 3]);

for(int y = 0; y < height; y++) {

for(int x = 0; x < width; x++) {

for(int c = 0; c < 3; c++) {

pixels2[3 * (width * y + x) + c] =

pixels[bytesPerRow * y + 3 * x + (2 - c)];

}

input.close();

return new Image(pixels2.release(), width, height);

}

GLuint loadTexture(Image* image) {

GLuint textureId;

glGenTextures(1, &textureId); //Make room for our texture

glBindTexture(GL_TEXTURE_2D, textureId); //Tell OpenGL which texture to edit

//Map the image to the texture

glTexImage2D(GL_TEXTURE_2D, //Always GL_TEXTURE_2D

0, //0 for now

GL_RGB, //Format OpenGL uses for image

image->width, image->height, //Width and height

0, //The border of the image

GL_RGB, //GL_RGB, because pixels are stored in RGB format

GL_UNSIGNED_BYTE, //GL_UNSIGNED_BYTE, because pixels are stored

//as unsigned numbers

image->pixels); //The actual pixel data

return textureId; //Returns the id of the texture

}

GLuint _textureId; //The id of the texture

void initRendering() {

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glEnable(GL_LIGHT1);

glEnable(GL_NORMALIZE);

glShadeModel(GL_SMOOTH);

Image* image = loadBMP("mu.bmp");

_textureId = loadTexture(image);

delete image;

}

void handleResize(int w, int h) {

glViewport(0, 0, w, h);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, (double)w / (double)h, 1.0, 200.0);

}

float _angle = 60.0f;

void drawScene() {

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -8.0f);

GLfloat ambientColor[] = {0.2f, 0.2f, 0.2f, 1.0f};

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);

GLfloat lightColor0[] = {0.5f, 0.5f, 0.5f, 1.0f};

GLfloat lightPos0[] = {4.0f, 0.0f, 8.0f, 1.0f};

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);

glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);

//radius

GLfloat lightColor1[] = {0.5f, 0.2f, 0.2f, 1.0f};

GLfloat lightPos1[] = {-1.0f, 0.5f, 0.5f, 0.0f};

glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor1);

glLightfv(GL_LIGHT1, GL_POSITION, lightPos1);

glEnable(GL_TEXTURE_2D);

glBindTexture(GL_TEXTURE_2D, _textureId);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

glRotatef(_angle, 0.0f, 1.0f, 0.0f);

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

//glScalef(1.0f, 1.5f, 1.0f);

glBegin(GL_QUADS);

//Front

glNormal3f(0.1f, 0.0f, 1.0f);

//glNormal3f(-1.0f, 0.0f, 1.0f);

glTexCoord2f(0.0f, 0.0f);

glVertex3f(-1.5f, -1.0f, 1.5f);

glNormal3f(1.0f, 0.0f, 1.0f);

glTexCoord2f(1.0f, 0.0f);

glVertex3f(1.5f, -1.0f, 1.5f);

glNormal3f(1.0f, 0.0f, 1.0f);

glTexCoord2f(1.0f, 1.0f);

glVertex3f(1.5f, 1.0f, 1.5f);

glNormal3f(-1.0f, 0.0f, 1.0f);

glTexCoord2f(0.0f, 1.0f);

glVertex3f(-1.5f, 1.0f, 1.5f);

//Right

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

glNormal3f(1.0f, 0.0f, 0.0f);

//glNormal3f(1.0f, 0.0f, -1.0f);

glTexCoord2f(0.0f, 0.0f);

glVertex3f(1.5f, -1.0f, -1.5f);

glNormal3f(1.0f, 0.0f, -1.0f);

//glTexCoord2f(1.0f, 0.0f);

glVertex3f(1.5f, 1.0f, -1.5f);

glNormal3f(1.0f, 0.0f, 1.0f);

glVertex3f(1.5f, 1.0f, 1.5f);

//glTexCoord2f(1.0f, 1.0f);

glNormal3f(1.0f, 0.0f, 1.0f);

//glTexCoord2f(0.0f, 1.0f);

glVertex3f(1.5f, -1.0f, 1.5f);

//Back

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

glNormal3f(0.0f, 0.0f, -1.0f);

//glNormal3f(-1.0f, 0.0f, -1.0f);

glVertex3f(-1.5f, -1.0f, -1.5f);

glNormal3f(-1.0f, 0.0f, -1.0f);

glVertex3f(-1.5f, 1.0f, -1.5f);

glNormal3f(1.0f, 0.0f, -1.0f);

glVertex3f(1.5f, 1.0f, -1.5f);

glNormal3f(1.0f, 0.0f, -1.0f);

glVertex3f(1.5f, -1.0f, -1.5f);

//Left

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

glNormal3f(-1.0f, 0.0f, 0.0f);

//glNormal3f(-1.0f, 0.0f, -1.0f);

glVertex3f(-1.5f, -1.0f, -1.5f);

glNormal3f(-1.0f, 0.0f, 1.0f);

glVertex3f(-1.5f, -1.0f, 1.5f);

glNormal3f(-1.0f, 0.0f, 1.0f);

glVertex3f(-1.5f, 1.0f, 1.5f);

glNormal3f(-1.0f, 0.0f, -1.0f);

glVertex3f(-1.5f, 1.0f, -1.5f);

glEnd();

glDisable(GL_TEXTURE_2D);

glutSwapBuffers();

}

void update(int value) {

_angle += 1.5f;

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("Lighting");

initRendering();

glutDisplayFunc(drawScene);

glutReshapeFunc(handleResize);

glutTimerFunc(25, update, 0);

glutMainLoop();

return 0;

}

header

#ifndef IMAGE_LOADER_H_INCLUDED

#define IMAGE_LOADER_H_INCLUDED

//Represents an image

class Image {

public:

Image(char* ps, int w, int h);

~Image();

/* An array of the form (R1, G1, B1, R2, G2, B2, ...) indicating the

* color of each pixel in image. Color components range from 0 to 255.

* The array starts the bottom-left pixel, then moves right to the end

* of the row, then moves up to the next column, and so on. This is the

* format in which OpenGL likes images.

char* pixels;

int width;

int height;

};

//Reads a bitmap image from file.

Image* loadBMP(const char* filename);

#endif

pamungkas bayu aji

x

sms gratis

Blog Archive

@bayu_aji94

Bayu Aji

Serikat Mahasiswa Indonesia

Manchester City

Selasa, 03 Juni 2014

inhal grafkom 5

postest grafkom 1-10

About Me

kategori

Blogger templates

buku

Translate

daftar

pamungkas bayu aji

x

sms gratis

Blog Archive

@bayu_aji94

Bayu Aji

Serikat Mahasiswa Indonesia

Manchester City

Selasa, 03 Juni 2014

inhal grafkom 5

postest grafkom 1-10

Social Profiles

About Me

kategori

Blogger templates

buku

Translate

daftar