Juni 2014 ~ pamungkas bayu aji

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

Senin, 09 Juni 2014

serikat mahasiswa indonesia

Sabtu, 07 Juni 2014

TP anton

Rabu, 04 Juni 2014

soal inhal jarkomdat 2014

Jarkomdat prak 10

Selasa, 03 Juni 2014

inhal grafkom 5

postest grafkom 1-10

About Me

kategori

Blogger templates

buku

Translate

daftar

x

sms gratis

Blog Archive

Senin, 09 Juni 2014

Sabtu, 07 Juni 2014

Rabu, 04 Juni 2014

Selasa, 03 Juni 2014

Social Profiles

About Me

kategori

Blogger templates

buku

Translate

daftar