C++ on bradleycarey.com

Fractal Mountains in OpenGL using GLUT

Sat, 24 Nov 2012 00:16:21 -0400

This was a project from my Computer Graphics course at Marshall University. The mountains are randomly generated from a normalized pseudo-random number generator and a fractal function. Every time you resize the windows or launch the program, they are drawn differently.

Pseudocode Interpreter

Thu, 23 Aug 2012 23:20:58 -0400

This program was an assignment for my Programming Languages course. The idea is to implement a simple pseudocode interpreter which has very basic functionality as well as a contiguous memory store. Here is how it works:

You feed the program a CRLF separated list of valid syntax. In this case, the file “pseudocode.txt” which should be in the same directory as the program (no file picker implemented).
The program reads, parses, and executes the given instructions
Any errors that are found are reported, else the program runs until STOP instruction or EOF.

The instruction set is very limited. There are a total of about 18 operations which can have 2 operands. If something is contained in [brackets] then that is referring to one of the 1000 available memory locations ([0] to [999]). You will find the instruction format in the source code, but here is a better explanation:

Simple *nix pipes proof of concept

Mon, 23 Jan 2012 23:17:06 -0400

This program is a simple program that uses pipes to relay information. In this case, the information is a string which the case is inverted and then displayed. This program was written on Minix using the elvis text editor and compiled in gcc.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <ctype.h>
#define BUFFER_SIZE 25
#define READ_END 0
#define WRITE_END 1

int main(void)
{
    printf("start");
    char write_msg[BUFFER_SIZE] = "Greetings";
    char read_msg[BUFFER_SIZE];
    pid_t pid;
    int first_pipe[2];
    int second_pipe[2];
    int i;

    if(pipe(first_pipe) == -1)
    {
        fprintf(stderr, "First Pipe failed");
        return 1;
    }

    if(pipe(second_pipe) == -1)
    {
        fprintf(stderr, "Second Pipe failed");
        return 1;
    }

    pid = fork();

    if(pid > 0)      // parent process
    {
        close(first_pipe[READ_END]);
        close(first_pipe[WRITE_END]);
        read(second_pipe[READ_END], read_msg, BUFFER_SIZE);
        printf("parent read :%s<\n",read_msg);
    }
    else            // child process
    {
        close(second_pipe[READ_END]);
        close(second_pipe[WRITE_END]);

        read(first_pipe[READ_END], read_msg, BUFFER_SIZE);
        printf("child read >%s<\n", read_msg);

        for (i=0; i < strlen(read_msg); i++)
        {
            if (isupper(read_msg[i]))
                write_msg[i] = tolower(read_msg[i]);
            else if (islower(read_msg[i]))
                write_msg[i] = toupper(read_msg[i]);
            else
                write_msg[i] = read_msg[i];
        }
        write(second_pipe[WRITE_END], write_msg, strlen(write_msg)+1);

        close(second_pipe[WRITE_END]);
        close(second_pipe[READ_END]);
    }
    return 0;
}

Sierpinski in OpenGL

Wed, 23 Nov 2011 23:35:07 -0400

This is just a simple 2D rendering of the famous Sierpinski gasket.

This was rendered using recursion, simple math, and GL_LINES.

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "GL/glut.h"

#include<GL/glut.h>

void sierpinski2d(float vertex1[], float vertex2[], float vertex3[], int current_depth)
{
    float next_vertex1[3],next_vertex2[3],next_vertex3[3];

    //float perimeter = sqrt(vertex1[0]);

    //if(perimeter > 0.01)
    //  return;

    if(current_depth >= 12)
        return;

    glBegin(GL_LINES);
        glVertex3fv(vertex1);
        glVertex3fv(vertex2);
        glVertex3fv(vertex3);
    glEnd();


    next_vertex1[0] = (vertex1[0]+vertex2[0])/2;
    next_vertex1[1] = (vertex1[1]+vertex2[1])/2;
    next_vertex1[2] = (vertex1[2]+vertex2[2])/2;

    next_vertex3[0] = (vertex2[0]+vertex3[0])/2;
    next_vertex3[1] = (vertex2[1]+vertex3[1])/2;
    next_vertex3[2] = (vertex2[2]+vertex3[2])/2;

    next_vertex2[0] = (vertex1[0]+vertex3[0])/2;
    next_vertex2[1] = (vertex1[1]+vertex3[1])/2;
    next_vertex2[2] = (vertex1[2]+vertex3[2])/2;

    sierpinski2d(next_vertex1,vertex1,next_vertex2,current_depth+1);
    sierpinski2d(next_vertex1,vertex2,next_vertex3,current_depth+1);
    sierpinski2d(next_vertex3,vertex3,next_vertex2,current_depth+1);
}

void myInit(void)
{

}

void display(void)
{
    float vertex1[3]={5.0,0.0,0.0};
    float vertex2[3]={-5.0,0.0,0.0};
    float vertex3[3]={0.0,5.0,0.0};
        glClearColor(0.0,0.0,0.0,1.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0.0,0.8,0.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-5.0,5.0,0.0,5.0);
    glMatrixMode(GL_MODELVIEW);

    sierpinski2d(vertex1,vertex2,vertex3,0);
    glFlush();
}

int main(int argc,char **argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH );
    glutInitWindowSize(800,800);
    glutInitWindowPosition(10,10);
    glutCreateWindow("Sierpinski 2D");
    myInit();
    glutDisplayFunc(display);
    glutMainLoop();
}

3D Wireframe Solids in OpenGL using GLUT

Wed, 23 Nov 2011 23:33:56 -0400

This is esentially the same thing as the code from 3D wireframe except now it has textures. Instead of GL_LINE_LOOP as in the last example, the solid was rendered using GL_POLYGON and colored accordingly.

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "GL/glut.h"

void init();
void display();
void myIdle();
int main(int argc, char** argv);
float f(double x, double z);
void normalVector(float x, float y, float z, float *norm);

float thetaY = 0;
float thetaX = 20;
float increment = 0.5;
float xNear = -6, xFar = 6, yNear = -6, yFar = 6, zNear = -6, zFar = 6;
float n = 50, m = 50;

void init()
{
    glClearColor(1.0, 1.0, 1.0, 0);
    glMatrixMode(GL_PROJECTION);
    glOrtho(xNear, xFar, yNear, yFar, zNear, zFar);
    glColor3f(1.0,1.0,1.0);
    GLfloat light_specular[] = {1.0,1.0,1.0,1.0};
    GLfloat light_diffuse[] = {1.0, 0.8, 1.0, 1.0};
    GLfloat light_ambient[] = {0.9, 0.9, 0.71, 1.0};
    GLfloat light_position[] = {0.0, 8.0, 20.0, 0.0};
    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);
}

float f(double x, double z)
{
    return 4*cos(sqrt(x*x+z*z));
}

void normalVector(float x, float y, float z, float *norm)
{
    norm[0] = 4*sin(sqrt(x*x+z*z))*x/sqrt(x*x+z*z);
    norm[1] = 1;
    norm[2] = 4*sin(sqrt(x*x+z*z))*z/sqrt(x*x+z*z);
    float d = norm[0]*norm[0] + norm[1]*norm[1] + norm[2]*norm[2];
    if(d > 0)
        for (int k = 0; k < 3; k++)
            norm[k] /= sqrt(d);
}

void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glRotatef(thetaX,1,0,0);
    glRotatef(thetaY,0,1,0);
    float norm[3];
    double xGap=(xNear-xFar)/n;
    double zGap=(zNear-zFar)/m;
    for (int i=0; i<n; i++)
    {
        for (int j=0; j<m; j++)
        {
            glBegin(GL_POLYGON);
                float x = xFar + i*xGap;
                float z = zFar + j*zGap;
                float y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + i*xGap;
                z = zFar + (j+1)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + (i+1)*xGap;
                z = zFar + (j+1)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
            glEnd();
            glBegin(GL_POLYGON);
                x = xFar + i*xGap;
                z = zFar + j*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + (i+1)*xGap;
                z = zFar + (j+1)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + (i+1)*xGap;
                z = zFar + (j)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
            glEnd();
        }
    }
    glutSwapBuffers();
}

void myIdle()
{
    double zzz=0;
    thetaY += increment;
    if(thetaY > 360.0)
        thetaY -= 360.0;
    for (int i=0; i<1000000; i++)
        zzz = sqrt((double)i);
    glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    glutInitWindowSize(800,800);
    glutInitWindowPosition(10,10);
    glutCreateWindow("3D Wireframe Solids with Lighting");
    glutDisplayFunc(display);
    glutIdleFunc(myIdle);
    init();
    glutMainLoop();
    return 0;
}

3D Wireframe in OpenGL using GLUT

Wed, 23 Nov 2011 23:32:12 -0400

The wireframe you see here is nothing more than the 3d plot of the function f(x,z) = 4*cos(sqrt(x*x+z*z)) rendered using GL_LINE_LOOP and a little math. As of now, is is still untextured and without lighting. Though in 3D Wireframe Solids, I added that functionality as well.

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "GL/glut.h"

void init();
void display();
void myIdle();
int main(int argc, char** argv);
float f(double x, double z);
void normalVector(float x, float y, float z, float *norm);

float thetaY = 0;
float thetaX = 20;
float increment = 0.5;
float xNear = -6, xFar = 6, yNear = -6, yFar = 6, zNear = -6, zFar = 6;
float n = 50, m = 50;

void init()
{
    glClearColor(1.0, 1.0, 1.0, 0);
    glMatrixMode(GL_PROJECTION);
    glOrtho(xNear, xFar, yNear, yFar, zNear, zFar);
    glColor3f(0.0,0.0,1.0);

}

float f(double x, double z)
{
    return 4*cos(sqrt(x*x+z*z));
}

void normalVector(float x, float y, float z, float *norm)
{
    norm[0] = 4*sin(sqrt(x*x+z*z))*x/sqrt(x*x+z*z);
    norm[1] = 1;
    norm[2] = 4*sin(sqrt(x*x+z*z))*z/sqrt(x*x+z*z);
    float d = norm[0]*norm[0] + norm[1]*norm[1] + norm[2]*norm[2];
    if(d > 0)
        for (int k = 0; k < 3; k++)
            norm[k]/=sqrt(d);
}

void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glRotatef(thetaX,1,0,0);
    glRotatef(thetaY,0,1,0);
    float norm[3];
    double xGap=(xNear-xFar)/n;
    double zGap=(zNear-zFar)/m;
    for (int i=0; i<n; i++)
    {
        for (int j=0; j<m; j++)
        {
            glBegin(GL_LINE_LOOP);
                float x = xFar + i*xGap;
                float z = zFar + j*zGap;
                float y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + i*xGap;
                z = zFar + (j+1)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + (i+1)*xGap;
                z = zFar + (j+1)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
            glEnd();
            glBegin(GL_LINE_LOOP);
                x = xFar + i*xGap;
                z = zFar + j*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + (i+1)*xGap;
                z = zFar + (j+1)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
                x = xFar + (i+1)*xGap;
                z = zFar + (j)*zGap;
                y = f(x,z);
                glVertex3f(x,y,z);
                normalVector(x,y,z,norm);
                glNormal3fv(norm);
            glEnd();
        }
    }
    glutSwapBuffers();
}

void myIdle()
{
    double zzz=0;
    thetaY += increment;
    if(thetaY > 360.0)
        thetaY -= 360.0;
    for (int i=0; i<1000000; i++)
        zzz = sqrt((double)i);
    glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    glutInitWindowSize(800,800);
    glutInitWindowPosition(10,10);
    glutCreateWindow("3D Wireframe Solids");
    glutDisplayFunc(display);
    glutIdleFunc(myIdle);
    init();
    glutMainLoop();
    return 0;
}

Dynamic Lighting in OpenGL using GLUT

Wed, 23 Nov 2011 23:30:35 -0400

This is a simple program to show dynamic lighting. The heavy lifting is done in the shadePolygons() function which determines the luminosity of the surface of the cube according to the angle.

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "GL/glut.h"

void init();
void display();
void myIdle();
int main(int argc, char** argv);
void shadePolygons(double x[], double y[], double z[], double kr, double kg, double kb);

float xNear = -3, xFar = 3, yNear = -3, yFar = 3, zNear = 3, zFar = -3;
double lightPos[3] = {-60, 10, 20};
double Id = 4.0;
double Ia = 1.0;
int direction = 1;

void shadePolygons(double x[], double y[], double z[], double kr, double kg, double kb)
{
    float vx = x[1] - x[0];
    float vy = y[1] - y[0];
    float vz = z[1] - z[0];

    float wx = x[2] - x[1];
    float wy = y[2] - y[1];
    float wz = z[2] - z[1];

    float Nx = vy*wz-vz*wy;
    float Ny = vx*wz-vz*wx;
    float Nz = vx*wy-vy*wx;

    float Lx = lightPos[0] - ((x[0]+x[1])/2);
    float Ly = lightPos[1] - ((y[0]+y[1])/2);
    float Lz = lightPos[2] - ((z[0]+z[1])/2);

    float LdotN = (Lx*Nx)+(Ly*Ny)+(Lz*Nz);
    float normL = sqrt(Lx*Lx + Ly*Ly + Lz*Lz);
    float normN = sqrt(Nx*Nx + Ny*Ny + Nz*Nz);

    float lightAmt = ( (LdotN*Id)/(normL*normN) );
    lightAmt = lightAmt + Ia;
    lightAmt = lightAmt / (Ia+Id);
    glColor3f(kr*lightAmt, kg*lightAmt, kb*lightAmt);
    glBegin(GL_POLYGON);
        glVertex3f(x[0], y[0], z[0]);
        glVertex3f(x[1], y[1], z[1]);
        glVertex3f(x[2], y[2], z[2]);
        glVertex3f(x[3], y[3], z[3]);
    glEnd();
}

void init()
{
    glClearColor(0, 0, 0, 0);
    glMatrixMode(GL_PROJECTION);
    glOrtho(xNear, xFar, yNear, yFar, zNear, zFar);
    glRotatef(30, -1, 1, 0);
}

void display()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glColor3f(1,1,1);

    char title[15];
    sprintf(title,"%f", lightPos[0]);
    glutSetWindowTitle(title);

    double face1x[] = {0,0,1,1};
    double face1y[] = {0,0,0,0};
    double face1z[] = {0,-1,-1,0};
    shadePolygons(face1x,face1y,face1z,1,0,0);

    double face2x[] = {0,0,1,1};
    double face2y[] = {0,-1,-1,0};
    double face2z[] = {-1,-1,-1,-1};
    shadePolygons(face2x,face2y,face2z,0,1,0);

    double face3x[] = {1,1,1,1};
    double face3y[] = {0,-1,-1,0};
    double face3z[] = {-1,-1,0,0};
    shadePolygons(face3x,face3y,face3z,1,1,1);

    double face4x[] = {0,0,1,1};
    double face4y[] = {-1,-1.5,-1.5,-1};
    double face4z[] = {-1,-1.5,-1.5,-1};
    shadePolygons(face4x,face4y,face4z,1,1,0);

    double face5x[] = {1,1,2,2};
    double face5y[] = {0,-1,-1,0};
    double face5z[] = {0,0,0,0};
    shadePolygons(face5x,face5y,face5z,0,0,1);
    glutSwapBuffers();
}

void myIdle()
{
    lightPos[0] = lightPos[0]+direction;
    if(lightPos[0] >= 60)
        direction = direction*(-1);
    if(lightPos[0] <= -60)
        direction = direction*(-1);
    double zzz=0;
    for (int i=0; i<2000000; i++)
        zzz = sqrt((double)i);
    glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    glutInitWindowSize(400,400);
    glutInitWindowPosition(20,20);
    glutCreateWindow("Shader Lab");
    glutDisplayFunc(display);
    glutIdleFunc(myIdle);
    init();
    glutMainLoop();
    return 0;
}

Dynamically Generated Textures in OpenGL using GLUT

Wed, 23 Nov 2011 23:29:12 -0400

The textures in this small program were generated procedurally and added to 3 sides of a cube. If you look at the sourcem the createTexture functions actually create the three textures. After created, the textures are then added onto a GL_POLYGON. Finally, simple lighting and rotation is added.

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "GL/glut.h"

void createTexture1(GLubyte image1[64][64][3]);
void createTexture2(GLubyte image1[64][64][3]);
void createTexture3(GLubyte image1[64][64][3]);
void myinit();
void display();
//void myReshape(int w, int h);
void idle();
int main(int argc, char** argv);

#define PI 3.141592653
typedef float point3[4];
double theta=0, beta=40, r=6;
float xMin=-4, xMax=4, yMin=-4, yMax =4, zMin=-6, zMax=6;
int n=32, m=32;
GLubyte image1[64][64][3];
GLubyte image2[64][64][3];

void createTexture1(GLubyte image1[64][64][3]) // checkerboard
{
    int row, col;
    for(int i=0; i<16; i++)
    {
        for(int j=0; j<16; j++)
        {
            row = i*4;
            col = j*4;
            int c1, c2, c3;
            for(int k = row; k < row+4; k++)
            {
                for(int l = col; l<col+4; l++)
                {
                    if((i+j)%2==0)
                    {
                        c1=128; c2=128; c3=128;
                    }
                    else
                    {
                        c1=255; c2=255; c3=255;
                    }
                    image1[k][l][0]=(GLubyte)c1;
                    image1[k][l][1]=(GLubyte)c2;
                    image1[k][l][2]=(GLubyte)c3;
                }
            }
        }
    }
    glEnable(GL_TEXTURE_2D);
    glTexImage2D(GL_TEXTURE_2D,0,3,64,64,0,GL_RGB, GL_UNSIGNED_BYTE, image1);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}

void createTexture2(GLubyte image1[64][64][3]) // blue flag
{
    for (int k=0; k<64; k++)
    {
        for(int l=0; l<64; l++)
        {
            if((l >= 0 && l <= 8) || (l >= 16 && l <= 24) || (l >= 32 && l <= 40) || (l >= 48 && l <= 56) )
            {
                image1[k][l][0]=255;
                image1[k][l][1]=100;
                image1[k][l][2]=0;
            } else {
                image1[k][l][0]=0;
                image1[k][l][1]=100;
                image1[k][l][2]=0;
            }
        }
    }
    glEnable(GL_TEXTURE_2D);
    glTexImage2D(GL_TEXTURE_2D,0,3,64,64,0,GL_RGB, GL_UNSIGNED_BYTE, image1);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}

void createTexture3(GLubyte image1[64][64][3])
{
    for (int k=0; k<64; k++)
    {
        for(int l=0; l<64; l++)
        {
            if(k<l)
            {
                image1[k][l][0]=100;
                image1[k][l][1]=255;
                image1[k][l][2]=0;
            } else {
                image1[k][l][0]=255;
                image1[k][l][1]=255;
                image1[k][l][2]=255;
            }
        }
    }
    glEnable(GL_TEXTURE_2D);
    glTexImage2D(GL_TEXTURE_2D,0,3,64,64,0,GL_RGB, GL_UNSIGNED_BYTE, image1);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}

void myinit()
{
    GLfloat light_ambient[] = {0.75, 0.75, 0.75, 1.0};
    GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};
    GLfloat light_specular[] = {1.0, 0.0, 0.0, 1.0};
    GLfloat light_position[] = {0.0, 0.0, 28.0, 0.0};
    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    float lmodel_ambient[] = {0.5, 0.5, 0.5, 1.0};
    //glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(xMin, xMax, yMin, yMax, zMin, zMax);
}

void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glRotatef(20, 1, 0, 0);
    glTranslatef(1, 0, 0);
    glRotatef(theta, 0, 1, 0);
    glTranslatef(-1, 0, 0);
    createTexture2(image2); // side 1
    glBegin(GL_POLYGON);
        glTexCoord2f(0,0); glNormal3f(0,0,1); glVertex3f(-2,-2,0);
        glTexCoord2f(0,1); glNormal3f(0,0,1); glVertex3f(2,-2,0);
        glTexCoord2f(1,1); glNormal3f(0,0,1); glVertex3f(2,2,0);
        glTexCoord2f(1,0); glNormal3f(0,0,1); glVertex3f(-2,2,0);
    glEnd();
    createTexture1(image1); // side 2
    glBegin(GL_POLYGON);
        glTexCoord2f(0,0); glNormal3f(0,1,0); glVertex3f(2,-2,0);
        glTexCoord2f(0,1); glNormal3f(0,1,0); glVertex3f(2,2,0);
        glTexCoord2f(1,1); glNormal3f(0,1,0); glVertex3f(2,2,-4);
        glTexCoord2f(1,0); glNormal3f(0,1,0); glVertex3f(2,-2,-4);
    glEnd();
    createTexture3(image2); // side 3
    glBegin(GL_POLYGON);
        glTexCoord2f(0,0); glNormal3f(1,0,0); glVertex3f(-2,-2,-4);
        glTexCoord2f(0,1); glNormal3f(1,0,0); glVertex3f(2,-2,-4);
        glTexCoord2f(1,1); glNormal3f(1,0,0); glVertex3f(2,2,-4);
        glTexCoord2f(1,0); glNormal3f(1,0,0); glVertex3f(-2,2,-4);
    glEnd();
    //createTexture1(image1); // side 4
    //glBegin(GL_POLYGON);
    //  glTexCoord2f(0,0); glNormal3f(0,0,1); glVertex3f(-2,-2,0);
    //  glTexCoord2f(0,1); glNormal3f(0,0,1); glVertex3f(2,-2,-4);
    //  glTexCoord2f(1,1); glNormal3f(0,0,1); glVertex3f(-2,-2,-4);
    //  glTexCoord2f(1,0); glNormal3f(0,0,1); glVertex3f(-2,-2,0);
    //glEnd();
    glutSwapBuffers();
}

void idle()
{
    theta += 0.25;
    if(theta > 360)
        theta -= 360;
    glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800,800);
    glutInitWindowPosition(50,50);
    glutCreateWindow("Texture Map, 10-2b");
    myinit();
    glutDisplayFunc(display);
    glutIdleFunc(idle);
    //glutReshapeFunc(myReshape);
    glutMainLoop();
    return 0;
}

3D Walkthrough Skybox in OpenGL

Wed, 16 Nov 2011 23:38:29 -0400

This is a walkthrough with a bunch of random items. Included are: a giant pyramid (hide it by pressing the p key!), a snowman, a bird, a torus, a rotating texture, and a golden spiral of teapots in the background.

Look at the myKeyboard() function to see what keys move. This program also relies upon texture.bmp as well as grass.bmp and BitmapLoader.h in order to run.