bronson/pulsar
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Files
master
pulsar/graphics.c

846 lines
23 KiB
C
Raw Permalink Blame History

/* Derived from scene.c in the The OpenGL Programming Guide */
/* Keyboard and mouse rotation taken from Swiftless Tutorials #23 Part 2 */
/* http://www.swiftless.com/tutorials/opengl/camera2.html */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "graphics.h"
extern void update();
extern void collisionResponse();
extern void buildDisplayList();
extern void mouse(int, int, int, int);
extern void draw2D();
extern void quit();
/* flags used to control the appearance of the image */
int lineDrawing = 0; // draw polygons as solid or lines
int lighting = 1; // use diffuse and specular lighting
int smoothShading = 1; // smooth or flat shading
int textures = 0;
/* texture data */
GLubyte Image[64][64][4];
GLuint textureID[1];
/* viewpoint coordinates */
float vpx = -50.0, vpy = -50.0, vpz = -50.0;
float oldvpx, oldvpy, oldvpz;
/* mouse direction coordiates */
float mvx = 0.0, mvy = 45.0, mvz = 0.0;
/* stores current mouse position value */
float oldx, oldy;
/* location for the light source (the sun), the first three
values are the x,y,z coordinates */
GLfloat lightPosition[] = {0.0, 49.0, 0.0, 0.0};
/* location for light source that is kept at viewpoint location */
GLfloat viewpointLight[] = {-50.0, -50.0, -50.0, 1.0};
/* sky cube size */
float skySize;
/* screen dimensions */
int screenWidth = 1024;
int screenHeight = 768;
/* command line flags */
int flycontrol = 1; // allow viewpoint to move in y axis when 1
int displayAllCubes = 0; // draw all of the cubes in the world when 1
int testWorld = 0; // sample world for timing tests
int fps = 0; // turn on frame per second output
int netClient = 0; // network client flag, is client when = 1
int netServer = 0; // network server flag, is server when = 1
/* list of cubes to display */
int displayList[MAX_DISPLAY_LIST][3];
int displayCount = 0; // count of cubes in displayList[][]
/* list of mobs - number of mobs, xyz values and rotation about y */
float mobPosition[MOB_COUNT][6];
/* visibility of mobs, 0 not drawn, 1 drawn */
short mobVisible[MOB_COUNT];
/* list of players - number of mobs, xyz values and rotation about y */
float playerPosition[MOB_COUNT][4];
/* visibility of players, 0 not drawn, 1 drawn */
short playerVisible[MOB_COUNT];
/* flag indicating the user wants the cube in front of them removed */
int space = 0;
/* flag indicates if map is to be printed */
int displayMap = 1;
/* functions draw 2D images */
void draw2Dline(int, int, int, int, int);
void draw2Dbox(int, int, int, int);
void draw2Dtriangle(int, int, int, int, int, int);
void set2Dcolour(float []);
/***************/
int isMobVisible(int mob) {
return mobVisible[mob];
}
int getMapState() {
return displayMap;
}
/* player control functions */
/* set all player location, rotation, and visibility values to zero */
void initPlayerArray() {
int i;
for (i=0; i<MOB_COUNT; i++) {
playerPosition[i][0] = 0.0;
playerPosition[i][1] = 0.0;
playerPosition[i][2] = 0.0;
playerPosition[i][3] = 0.0;
playerVisible[i] = 0;
}
}
/* create player with identifier "number" at x,y,z with */
/* heading of rotx, roty, rotz */
void createPlayer(int number, float x, float y, float z, float playerroty) {
if (number >= PLAYER_COUNT) {
printf("ERROR: player number greater than %d\n", PLAYER_COUNT);
exit(1);
}
playerPosition[number][0] = x;
playerPosition[number][1] = y;
playerPosition[number][2] = z;
playerPosition[number][3] = playerroty;
playerVisible[number] = 1;
}
/* move player to a new position xyz with rotation rotx,roty,rotz */
void setPlayerPosition(int number, float x, float y, float z, float playerroty){
if (number >= PLAYER_COUNT) {
printf("ERROR: player number greater than %d\n", PLAYER_COUNT);
exit(1);
}
playerPosition[number][0] = x;
playerPosition[number][1] = y;
playerPosition[number][2] = z;
playerPosition[number][3] = playerroty;
}
/* turn off drawing for player number */
void hidePlayer(int number) {
if (number >= PLAYER_COUNT) {
printf("ERROR: player number greater than %d\n", PLAYER_COUNT);
exit(1);
}
playerVisible[number] = 0;
}
/* turn on drawing for player number */
void showPlayer(int number) {
if (number >= PLAYER_COUNT) {
printf("ERROR: player number greater than %d\n", PLAYER_COUNT);
exit(1);
}
playerVisible[number] = 1;
}
/* mob control functions */
/* set all mob location, rotation, and visibility values to zero */
void initMobArray() {
int i;
for (i=0; i<MOB_COUNT; i++) {
mobPosition[i][0] = 0.0;
mobPosition[i][1] = 0.0;
mobPosition[i][2] = 0.0;
mobPosition[i][3] = 0.0;
mobVisible[i] = 0;
}
}
/* create mob with identifier "number" at x,y,z with */
/* heading of rotx, roty, rotz */
void createMob(int number, float x, float y, float z, float mobroty) {
if (number >= MOB_COUNT) {
printf("ERROR: mob number greater than %d\n", MOB_COUNT);
exit(1);
}
mobPosition[number][0] = x;
mobPosition[number][1] = y;
mobPosition[number][2] = z;
mobPosition[number][3] = mobroty;
mobVisible[number] = 1;
}
void mobTrajectory(int number, float mobrotx, float mobrotz) {
mobPosition[number][4] = mobrotx;
mobPosition[number][5] = mobrotz;
}
/* move mob to a new position xyz with rotation rotx,roty,rotz */
void setMobPosition(int number, float x, float y, float z, float mobroty){
if (number >= MOB_COUNT) {
printf("ERROR: mob number greater than %d\n", MOB_COUNT);
exit(1);
}
mobPosition[number][0] = x;
mobPosition[number][1] = y;
mobPosition[number][2] = z;
mobPosition[number][3] = mobroty;
}
void getMobPosition(int number, float* x, float* y, float* z, float* roty, float* rotx, float* rotz) {
*x = mobPosition[number][0];
*y = mobPosition[number][1];
*z = mobPosition[number][2];
*roty = mobPosition[number][3];
*rotx = mobPosition[number][4];
*rotz = mobPosition[number][5];
}
/* turn off drawing for mob number */
void hideMob(int number) {
if (number >= MOB_COUNT) {
printf("ERROR: mob number greater than %d\n", MOB_COUNT);
exit(1);
}
mobVisible[number] = 0;
}
/* turn on drawing for mob number */
void showMob(int number) {
if (number >= MOB_COUNT) {
printf("ERROR: mob number greater than %d\n", MOB_COUNT);
exit(1);
}
mobVisible[number] = 1;
}
/* allows user to set position of the light */
void setLightPosition(GLfloat x, GLfloat y, GLfloat z) {
lightPosition[0] = x;
lightPosition[1] = y;
lightPosition[2] = z;
glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
}
/* returns current position of the light */
GLfloat* getLightPosition() {
return(lightPosition);
}
/* functions store and return the current location of the viewpoint */
void getViewPosition(float *x, float *y, float *z) {
*x = vpx;
*y = vpy;
*z = vpz;
}
void setViewPosition(float x, float y, float z) {
oldvpx = vpx;
oldvpy = vpy;
oldvpz = vpz;
vpx = x;
vpy = y;
vpz = z;
}
/* returns the previous location of the viewpoint */
void getOldViewPosition(float *x, float *y, float *z) {
*x = oldvpx;
*y = oldvpy;
*z = oldvpz;
}
/* sets the current orientation of the viewpoint */
void setViewOrientation(float xaxis, float yaxis, float zaxis) {
mvx = xaxis;
mvy = yaxis;
mvz = zaxis;
}
/* returns the current orientation of the viewpoint */
void getViewOrientation(float *xaxis, float *yaxis, float *zaxis) {
*xaxis = mvx;
*yaxis = mvy;
*zaxis = mvz;
}
/* add the cube at world[x][y][z] to the display list and */
/* increment displayCount */
void addDisplayList(int x, int y, int z) {
displayList[displayCount][0] = x;
displayList[displayCount][1] = y;
displayList[displayCount][2] = z;
displayCount++;
if (displayCount > MAX_DISPLAY_LIST) {
printf("You have put more items in the display list then there are\n");
printf("cubes in the world. Set displayCount = 0 at some point.\n");
exit(1);
}
}
/* Initialize material property and light source. */
void init (void)
{
GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat light_diffuse[] = { 0.8, 0.8, 0.8, 1.0 };
GLfloat light_specular[] = { 0.5, 0.5, 0.5, 1.0 };
GLfloat light_full_off[] = {0.0, 0.0, 0.0, 1.0};
GLfloat light_full_on[] = {1.0, 1.0, 1.0, 1.0};
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
/* if lighting is turned on then use ambient, diffuse and specular
lights, otherwise use ambient lighting only */
if (lighting == 1) {
/* sun light */
glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse);
/* no specular reflection from sun, it is too distracting */
glLightfv (GL_LIGHT0, GL_SPECULAR, light_full_off);
} else {
glLightfv (GL_LIGHT0, GL_AMBIENT, light_full_on);
glLightfv (GL_LIGHT0, GL_DIFFUSE, light_full_off);
glLightfv (GL_LIGHT0, GL_SPECULAR, light_full_off);
}
glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
/* viewpoint light */
glLightfv (GL_LIGHT1, GL_POSITION, viewpointLight);
glLightfv (GL_LIGHT1, GL_AMBIENT, light_ambient);
glLightfv (GL_LIGHT1, GL_DIFFUSE, light_diffuse);
glLightfv (GL_LIGHT1, GL_SPECULAR, light_specular);
glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5);
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
glEnable (GL_LIGHT1);
glEnable(GL_DEPTH_TEST);
}
/* draw cube in world[i][j][k] */
void drawCube(int i, int j, int k) {
GLfloat blue[] = {0.0, 0.0, 1.0, 1.0};
GLfloat red[] = {1.0, 0.0, 0.0, 1.0};
GLfloat green[] = {0.0, 1.0, 0.0, 1.0};
GLfloat yellow[] = {1.0, 1.0, 0.0, 1.0};
GLfloat purple[] = {1.0, 0.0, 1.0, 1.0};
GLfloat orange[] = {1.0, 0.64, 0.0, 1.0};
GLfloat white[] = {1.0, 1.0, 1.0, 1.0};
GLfloat black[] = {0.0, 0.0, 0.0, 1.0};
GLfloat dblue[] = {0.0, 0.0, 0.5, 1.0};
GLfloat dred[] = {0.5, 0.0, 0.0, 1.0};
GLfloat dgreen[] = {0.0, 0.5, 0.0, 1.0};
GLfloat dyellow[] = {0.5, 0.5, 0.0, 1.0};
GLfloat dpurple[] = {0.5, 0.0, 0.5, 1.0};
GLfloat dorange[] = {0.5, 0.32, 0.0, 1.0};
/* select colour based on value in the world array */
glMaterialfv(GL_FRONT, GL_SPECULAR, white);
if (world[i][j][k] == 1) {
glMaterialfv(GL_FRONT, GL_AMBIENT, dgreen);
glMaterialfv(GL_FRONT, GL_DIFFUSE, green);
}
else if (world[i][j][k] == 2) {
glMaterialfv(GL_FRONT, GL_AMBIENT, dblue);
glMaterialfv(GL_FRONT, GL_DIFFUSE, blue);
}
else if (world[i][j][k] == 3) {
glMaterialfv(GL_FRONT, GL_AMBIENT, dred);
glMaterialfv(GL_FRONT, GL_DIFFUSE, red);
}
else if (world[i][j][k] == 4) {
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, black);
}
else if (world[i][j][k] == 5) {
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, white);
}
else if (world[i][j][k] == 6) {
glMaterialfv(GL_FRONT, GL_AMBIENT, dpurple);
glMaterialfv(GL_FRONT, GL_DIFFUSE, purple);
}
else if (world[i][j][k] == 7) {
glMaterialfv(GL_FRONT, GL_AMBIENT, dorange);
glMaterialfv(GL_FRONT, GL_DIFFUSE, orange);
}
else {
glMaterialfv(GL_FRONT, GL_AMBIENT, dyellow);
glMaterialfv(GL_FRONT, GL_DIFFUSE, yellow);
}
glPushMatrix ();
/* offset cubes by 0.5 so the centre of the */
/* cube falls in the centre of the world array */
glTranslatef(i + 0.5, j + 0.5, k + 0.5);
glutSolidCube(1.0);
glPopMatrix ();
}
/* called each time the world is redrawn */
void display (void)
{
GLfloat skyblue[] = {0.52, 0.74, 0.84, 1.0};
GLfloat black[] = {0.0, 0.0, 0.0, 1.0};
GLfloat red[] = {1.0, 0.0, 0.0, 1.0};
GLfloat gray[] = {0.3, 0.3, 0.3, 1.0};
GLfloat white[] = {1.0, 1.0, 1.0, 1.0};
int i, j, k;
buildDisplayList();
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* position viewpoint based on mouse rotation and keyboard
translation */
glLoadIdentity();
glRotatef(mvx, 1.0, 0.0, 0.0);
glRotatef(mvy, 0.0, 1.0, 0.0);
glRotatef(mvz, 0.0, 0.0, 1.0);
/* Subtract 0.5 to raise viewpoint slightly above objects. */
/* Gives the impression of a head on top of a body. */
glTranslatef(vpx, vpy - 0.5, vpz);
// glTranslatef(vpx, vpy, vpz);
/* set viewpoint light position */
viewpointLight[0] = -vpx;
viewpointLight[1] = -vpy;
viewpointLight[2] = -vpz;
glLightfv (GL_LIGHT1, GL_POSITION, viewpointLight);
/* draw surfaces as either smooth or flat shaded */
if (smoothShading == 1)
glShadeModel(GL_SMOOTH);
else
glShadeModel(GL_FLAT);
/* draw polygons as either solid or outlines */
if (lineDrawing == 1)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
/* give all objects the same shininess value and specular colour */
glMaterialf(GL_FRONT, GL_SHININESS, 90.0);
/* set starting location of objects */
glPushMatrix ();
/* make a blue sky cube */
glShadeModel(GL_SMOOTH);
/* turn off all reflection from sky so it is a solid colour */
glMaterialfv(GL_FRONT, GL_AMBIENT, black);
glMaterialfv(GL_FRONT, GL_DIFFUSE, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, skyblue);
glPushMatrix ();
/* move the sky cube center to middle of world space */
glTranslatef((float)WORLDX/2.0, (float)WORLDY/2.0, (float)WORLDZ/2.0);
//glutSolidCube(150.0);
glutSolidCube(skySize);
glPopMatrix ();
glShadeModel(GL_SMOOTH);
/* turn off emision lighting, use only for sky */
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
/* draw mobs in the world */
for(i=0; i<MOB_COUNT; i++) {
if (mobVisible[i] == 1) {
glPushMatrix();
/* black body */
glTranslatef(mobPosition[i][0]+0.5, mobPosition[i][1]+0.5,
mobPosition[i][2]+0.5);
glMaterialfv(GL_FRONT, GL_AMBIENT, black);
glMaterialfv(GL_FRONT, GL_DIFFUSE, gray);
glutSolidSphere(0.5, 8, 8);
/* white eyes */
glRotatef(mobPosition[i][3], 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, white);
glTranslatef(0.3, 0.1, 0.3);
glutSolidSphere(0.1, 4, 4);
glTranslatef(-0.6, 0.0, 0.0);
glutSolidSphere(0.1, 4, 4);
glPopMatrix();
}
}
/* draw players in the world */
for(i=0; i<PLAYER_COUNT; i++) {
if (playerVisible[i] == 1) {
glPushMatrix();
/* black body */
glTranslatef(playerPosition[i][0]+0.5, playerPosition[i][1]+0.5,
playerPosition[i][2]+0.5);
glMaterialfv(GL_FRONT, GL_AMBIENT, white);
glMaterialfv(GL_FRONT, GL_DIFFUSE, gray);
glutSolidSphere(0.5, 8, 8);
/* white eyes */
glRotatef(playerPosition[i][3], 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
glTranslatef(0.3, 0.1, 0.3);
glutSolidSphere(0.1, 4, 4);
glTranslatef(-0.6, 0.0, 0.0);
glutSolidSphere(0.1, 4, 4);
glPopMatrix();
}
}
/* draw all cubes in the world array */
if (displayAllCubes == 1) {
/* draw all cubes */
for(i=0; i<WORLDX; i++) {
for(j=0; j<WORLDY; j++) {
for(k=0; k<WORLDZ; k++) {
if (world[i][j][k] != 0) {
drawCube(i, j, k);
}
}
}
}
} else {
/* draw only the cubes in the displayList */
/* these should have been selected in the update function */
for(i=0; i<displayCount; i++) {
drawCube(displayList[i][0],
displayList[i][1],
displayList[i][2]);
}
}
/* 2D drawing section used to create interface components */
/* change to orthographic mode to display 2D images */
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity ();
gluOrtho2D(0, screenWidth, 0, screenHeight);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
/* turn on alpha blending for 2D */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel(GL_FLAT);
glNormal3f(0.0, 0.0, -1.0);
/* call user's 2D drawing function */
draw2D();
/* reset graphics for 3D drawing */
glDisable(GL_BLEND);
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
/* end 2d display code */
glutSwapBuffers();
}
/* sets viewport information */
void reshape(int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
/* use skySize for far clipping plane */
gluPerspective(45.0, (GLfloat)w/(GLfloat)h, 0.1, skySize);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
/* set global screen width and height */
screenWidth = w;
screenHeight = h;
}
/* respond to keyboard events */
void keyboard(unsigned char key, int x, int y)
{
float rotx, roty;
switch (key) {
case 27:
case 'q':
quit();
break;
case '1': // draw polygons as outlines
lineDrawing = 1;
lighting = 0;
smoothShading = 0;
textures = 0;
init();
glutPostRedisplay();
break;
case '2': // draw polygons as filled
lineDrawing = 0;
lighting = 0;
smoothShading = 0;
textures = 0;
init();
glutPostRedisplay();
break;
case '3': // diffuse and specular lighting, flat shading
lineDrawing = 0;
lighting = 1;
smoothShading = 0;
textures = 0;
init();
glutPostRedisplay();
break;
case '4': // diffuse and specular lighting, smooth shading
lineDrawing = 0;
lighting = 1;
smoothShading = 1;
textures = 0;
init();
glutPostRedisplay();
break;
case '5': // texture with smooth shading
lineDrawing = 0;
lighting = 1;
smoothShading = 1;
textures = 1;
init();
glutPostRedisplay();
break;
case 'w': // forward motion
oldvpx = vpx;
oldvpy = vpy;
oldvpz = vpz;
rotx = (mvx / 180.0 * 3.141592);
roty = (mvy / 180.0 * 3.141592);
vpx -= sin(roty) * 0.3;
// turn off y motion so you can't fly
if (flycontrol == 1)
vpy += sin(rotx) * 0.3;
vpz += cos(roty) * 0.3;
collisionResponse();
glutPostRedisplay();
break;
case 's': // backward motion
oldvpx = vpx;
oldvpy = vpy;
oldvpz = vpz;
rotx = (mvx / 180.0 * 3.141592);
roty = (mvy / 180.0 * 3.141592);
vpx += sin(roty) * 0.3;
// turn off y motion so you can't fly
if (flycontrol == 1)
vpy -= sin(rotx) * 0.3;
vpz -= cos(roty) * 0.3;
collisionResponse();
glutPostRedisplay();
break;
case 'a': // strafe left motion
oldvpx = vpx;
oldvpy = vpy;
oldvpz = vpz;
roty = (mvy / 180.0 * 3.141592);
vpx += cos(roty) * 0.3;
vpz += sin(roty) * 0.3;
collisionResponse();
glutPostRedisplay();
break;
case 'd': // strafe right motion
oldvpx = vpx;
oldvpy = vpy;
oldvpz = vpz;
roty = (mvy / 180.0 * 3.141592);
vpx -= cos(roty) * 0.3;
vpz -= sin(roty) * 0.3;
collisionResponse();
glutPostRedisplay();
break;
case 'f': // toggle flying controls
if (flycontrol == 0) flycontrol = 1;
else flycontrol = 0;
break;
case ' ': // toggle space flag
space = 1;
break;
case 'm': // toggle map display, 0=none, 1=small, 2=large
displayMap++;
if (displayMap > 2)
displayMap = 0;
break;
}
}
/* load a texture from a file */
/* not currently used */
void loadTexture() {
FILE *fp;
int i, j;
int red, green, blue;
if ((fp = fopen("image.txt", "r")) == 0) {
printf("Error, failed to find the file named image.txt.\n");
exit(0);
}
for(i=0; i<64; i++) {
for(j=0; j<64; j++) {
fscanf(fp, "%d %d %d", &red, &green, &blue);
Image[i][j][0] = red;
Image[i][j][1] = green;
Image[i][j][2] = blue;
Image[i][j][3] = 255;
}
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1,textureID);
glBindTexture(GL_TEXTURE_2D, textureID[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA,
GL_UNSIGNED_BYTE, Image);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
fclose(fp);
}
/* responds to mouse movement when a button is pressed */
void motion(int x, int y) {
/* update current mouse movement but don't use to change the viewpoint*/
oldx = x;
oldy = y;
}
/* responds to mouse movement when a button is not pressed */
void passivemotion(int x, int y) {
mvx += (float) y - oldy;
mvy += (float) x - oldx;
oldx = x;
oldy = y;
glutPostRedisplay();
}
/* initilize graphics information and mob data structure */
void graphicsInit(int *argc, char **argv) {
int i, fullscreen;
/* set GL window information */
glutInit(argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
/* parse command line args */
fullscreen = 0;
for(i=1; i<*argc; i++) {
if (strcmp(argv[i],"-full") == 0)
fullscreen = 1;
if (strcmp(argv[i],"-drawall") == 0)
displayAllCubes = 1;
if (strcmp(argv[i],"-testworld") == 0)
testWorld = 1;
if (strcmp(argv[i],"-fps") == 0)
fps = 1;
if (strcmp(argv[i],"-client") == 0)
netClient = 1;
if (strcmp(argv[i],"-server") == 0)
netServer = 1;
if (strcmp(argv[i],"-help") == 0) {
printf("Usage: a4 [-full] [-drawall] [-testworld] [-fps] [-client] [-server]\n");
exit(0);
}
}
if (fullscreen == 1) {
glutGameModeString("1024x768:32@75");
glutEnterGameMode();
} else {
glutInitWindowSize (screenWidth, screenHeight);
glutCreateWindow (argv[0]);
}
init();
/* not used at the moment */
// loadTexture();
/* attach functions to GL events */
glutReshapeFunc (reshape);
glutDisplayFunc(display);
glutKeyboardFunc (keyboard);
glutPassiveMotionFunc(passivemotion);
glutMotionFunc(motion);
glutMouseFunc(mouse);
glutIdleFunc(update);
/* initialize mob and player array to empty */
initMobArray();
initPlayerArray();
/* set the size of the sky */
if (WORLDX > WORLDY)
skySize = (float) WORLDX;
else
skySize = (float) WORLDY;
if (WORLDZ > skySize)
skySize = (float) WORLDZ;
skySize *= 1.5;
}
/* functions to draw 2d images on screen */
void draw2Dline(int x1, int y1, int x2, int y2, int lineWidth) {
glLineWidth(lineWidth);
glBegin(GL_LINES);
glVertex2i(x1, y1);
glVertex2i(x2, y2);
glEnd();
glLineWidth(1);
}
void draw2Dbox(int x1, int y1, int x2, int y2) {
glBegin(GL_QUADS);
glVertex2i(x1, y1);
glVertex2i(x1, y2);
glVertex2i(x2, y2);
glVertex2i(x2, y1);
glEnd();
}
void draw2Dtriangle(int x1, int y1, int x2, int y2, int x3, int y3) {
glBegin(GL_TRIANGLES);
glVertex2i(x1, y1);
glVertex2i(x2, y2);
glVertex2i(x3, y3);
glEnd();
}
void set2Dcolour(float colourv[]) {
glMaterialfv(GL_FRONT, GL_EMISSION, colourv);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colourv);
}
Reference in New Issue View Git Blame Copy Permalink