OpenGL on bradleycarey.com

WebGL 3D Wireframe using GLGE

Sat, 23 Nov 2013 23:41:08 -0400

This is the same as the 3D wireframe example which was done in OpenGL, only ported to the new technology known as WebGL. WebGL is still a new technology that uses GPU acceleration to render 3D graphics in a web browser and it has shown vast potential to modernize the web.

Many browsers do not even fully support WebGL at the moment. As such, to view this example you will need an updated, modern browser such as Firefox, Chome, or Opera. Internet Explorer does not support WebGL rendering at the moment unless you install a plugin.

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.

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.