/*
 * $Id$
 *
 * $Date$
 * $Revision$
 *
 * (C) 1999 by Hyperion
 * All rights reserved
 *
 * This file is part of the MiniGL library project
 * See the file Licence.txt for more details
 *
 */

#include "mgl/gl.h"
#include <math.h>
#include <exec/exec.h>
#include <intuition/intuition.h>
#include <graphics/gfx.h>
#include <libraries/lowlevel.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos/dos.h>
#ifdef __GNUC__
#ifdef __PPC__
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/lowlevel.h>
#include <proto/dos.h>
#include <proto/graphics.h>
#else
#include <inline/exec.h>
#include <inline/intuition.h>
#include <inline/lowlevel.h>
#include <inline/dos.h>
#include <inline/graphics.h>
#endif
#endif

#ifdef __STORMC__
#include <string.h>
#include <clib/powerpc_protos.h>
#ifndef __PPC__
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/lowlevel.h>
#include <proto/dos.h>
#include <proto/graphics.h>
#else
#include <clib/exec_protos.h>
#include <clib/intuition_protos.h>
#include <clib/lowlevel_protos.h>
#include <clib/dos_protos.h>
#include <clib/graphics_protos.h>
#endif
#define inline __inline
#define M_PI 3.1415927
int kprintf(char *format, ...)
{
	return 0;
}
#endif

#ifdef __VBCC__
#include <proto/exec.h>
include <proto/intuition.h>
#include <proto/lowlevel.h>
#include <proto/dos.h>
#include <proto/graphics.h>
#define inline
#define   M_PI 3.14159265358979323846
#endif

static char rcsid[] = "$Id$";
struct Library *LowLevelBase;

#ifndef __PPC__
extern struct IntuitionBase *IntuitionBase;
extern struct GfxBase *GfxBase;
extern struct Library *UtilityBase;
extern struct DosLibrary *DOSBase;
extern struct ExecBase *SysBase;
#endif

extern int kprintf(char *format, ...);
#define DEBUG(x) kprintf x

extern void GLPrintMatrix(int);

static struct EClockVal eval;
static float fps;
static GLfloat fog_start, fog_end;
static GLboolean fogon = GL_FALSE;
static GLboolean sync = GL_TRUE;

typedef struct
{
	GLfloat x,y,z,u,v;
} MyVertex;

static MyVertex vertices1 [] =
{
	{-1, -1, -1, 0.5, 0.5}, // 0
	{-1, -1,  1, 0.5, 0.0}, // 1
	{-1,  1,  1, 0.0, 0.0}, // 2
	{-1,  1, -1, 0.0, 0.5}, // 3
	{ 1,  1, -1, 0.0, 1.0}, // 4
	{ 1, -1, -1, 0.5, 1.0}, // 5
	{ 1, -1,  1, 1.0, 1.0}, // 6
	{-1, -1,  1, 1.0, 0.5}  // 7
};

static MyVertex vertices2 [] =
{
	{ 1,  1,  1, 0.5, 0.5}, // 0
	{ 1, -1,  1, 0.5, 0.0}, // 1
	{ 1, -1, -1, 0.0, 0.0}, // 2
	{ 1,  1, -1, 0.0, 0.5}, // 3
	{-1,  1, -1, 0.0, 1.0}, // 4
	{-1,  1,  1, 0.5, 1.0}, // 5
	{-1, -1,  1, 1.0, 1.0}, // 6
	{ 1, -1,  1, 1.0, 0.5}  // 7
};

struct ResInfo
{
	int width, height;
	char *name;
};

struct ResInfo Resolutions [] =
{
	{320, 240, "320 x 240"},
	{400, 300, "400 x 300"},
	{640, 480, "640 x 480"},
	{800, 600, "800 x 600"}, // Out of memory...
	{1024, 768, "1024 x 768"},
	{-1, -1, NULL}
};

GLint ResPtr;
char *CurrentRes;
GLboolean ShowRes = GL_TRUE;
GLboolean zbuffer = GL_TRUE;

GLfloat mouse_x = 0.0, mouse_y = 0.0, mouse_z = 0.0;
GLint offset = 0;
GLfloat fov = 70.0;
GLfloat inf_w = 0.1;
GLfloat zback = 1000.0;
GLfloat alpha = 1.0;

GLubyte index_texture[] =
{
	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
	1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
	1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,
	1,0,1,2,2,2,2,2,2,2,2,2,2,1,0,1,
	1,0,1,2,1,1,1,1,1,1,1,1,2,1,0,1,
	1,0,1,2,1,3,3,3,3,3,3,1,2,1,0,1,
	1,0,1,2,1,3,1,1,1,1,3,1,2,1,0,1,
	1,0,1,2,1,3,1,4,4,1,3,1,2,1,0,1,
	1,0,1,2,1,3,1,4,4,1,3,1,2,1,0,1,
	1,0,1,2,1,3,1,1,1,1,3,1,2,1,0,1,
	1,0,1,2,1,3,3,3,3,3,3,1,2,1,0,1,
	1,0,1,2,1,1,1,1,1,1,1,1,2,1,0,1,
	1,0,1,2,2,2,2,2,2,2,2,2,2,1,0,1,
	1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,
	1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
};

GLubyte palette[] =
{
	0x00, 0x00, 0x00,
	0xFF, 0x00, 0x00,
	0x00, 0xFF, 0x00,
	0x00, 0x00, 0xff,
	0xFF, 0xFF, 0xFF,
};

static void ReplaceTexture(void)
{
	GLenum error;
	int i=1;

	glDeleteTextures(1, (const unsigned int *)&i);
	glBindTexture(GL_TEXTURE_2D, 1);
	glColorTable(GL_COLOR_TABLE, GL_RGB, 5, GL_RGB, GL_UNSIGNED_BYTE, palette);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 16, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, index_texture);
	error = glGetError();
	kprintf("Error = %d\n", error);
}

static void MakeRot(GLfloat angle1, GLfloat angle2)
{
	GLfloat sinel = (GLfloat)sin((double)angle1/180*M_PI);
	GLfloat cosel = (GLfloat)cos((double)angle1/180*M_PI);
	GLfloat sinaz = (GLfloat)sin((double)angle2/180*M_PI);
	GLfloat cosaz = (GLfloat)cos((double)angle2/180*M_PI);
	GLfloat mat[16];

	mat[0] = cosaz;        mat[4] = 0.0;    mat[8] = -sinaz;       mat[12] = 0;
	mat[1] = -sinel*sinaz; mat[5] = cosel;  mat[9] = -sinel*cosaz; mat[13] = 0.0;
	mat[2] = cosel*sinaz;  mat[6] = sinel;  mat[10] = cosel*cosaz; mat[14] = 0.0;
	mat[3] =               mat[7] =         mat[11] = 0.0;         mat[15] = 1.0;
	glMultMatrixf(mat);
}

static void UpRes(void)
{
	ResPtr++; if (Resolutions[ResPtr].width == -1) ResPtr = 0;
	mglResizeContext(Resolutions[ResPtr].width, Resolutions[ResPtr].height);
	CurrentRes = Resolutions[ResPtr].name;
	ShowRes = GL_TRUE;
}

void PrExit(void)
{
	if (LowLevelBase)   CloseLibrary(LowLevelBase);
	exit(0L);
}

void PrInit(void)
{
	LowLevelBase  = OpenLibrary("lowlevel.library", 40L);
	if (!LowLevelBase) PrExit();
}

GLdouble angle = 0.0;
GLfloat mouse_angle_x = 0.0;
GLfloat mouse_angle_y = 0.0;
GLfloat tlow = 0.0;
GLfloat offx = 0.f, offy = 0.f;
GLdouble zclear = 1.0;
GLenum primitive = GL_POLYGON;

/*
** Load a PPM file into memory.
** The resulting pointer can be free()'d
*/
GLubyte *LoadPPM(char *name, GLint *w, GLint *h)
{
	int i;
	unsigned long x,y;
	FILE *f;
	GLubyte *where;

	f = fopen(name, "r");

	if (!f)
	{
		*w = 0; *h=0;
		return NULL;
	}
	#ifndef __STORM__
	i = fscanf(f, "P6\n%ld %ld\n255\n",&x, &y);
	#else
	i = fscanf(f, "P6\n%ld\n%ld\n255\n", &x, &y);
	#endif

	if (i!= 2)
	{
		printf("Error scanning PPM header\n");
		fclose(f);
		*w = 0; *h = 0;
		return NULL;
	}

	*w = x;
	*h = y;

	where = malloc(x*y*3);
	if (!where)
	{
		printf("Error out of Memory\n");
		fclose(f);
		*w = 0; *h = 0;
		return NULL;
	}

	i = fread(where, 1, x*y*3, f);
	fclose(f);

	if (i != x*y*3)
	{
		printf("Error while reading file\n");
		free(where);
		*w = 0; *h = 0;
		return NULL;
	}

	return where;
}

void TexInit(void)
{
	GLubyte *tmap;
	GLint x,y;

	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);

	tmap = LoadPPM("data/t1.ppm",&x, &y);
	glBindTexture(GL_TEXTURE_2D, 1);
	glTexImage2D(GL_TEXTURE_2D, 0, 3,
		x,y, 0, GL_RGB, GL_UNSIGNED_BYTE, tmap);
	free(tmap);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	tmap = LoadPPM("data/t2.ppm",&x, &y);
	glBindTexture(GL_TEXTURE_2D, 2);
	glTexImage2D(GL_TEXTURE_2D, 0, 3,
		x,y, 0, GL_RGB, GL_UNSIGNED_BYTE, tmap);
	free(tmap);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	tmap = LoadPPM("data/stars.ppm",&x, &y);
	glBindTexture(GL_TEXTURE_2D, 3);
	glTexImage2D(GL_TEXTURE_2D, 0, 3,
		x,y, 0, GL_RGB, GL_UNSIGNED_BYTE, tmap);
	free(tmap);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

}

static void drawCubeFan(GLint tex1, GLint tex2)
{
	GLfloat w = 1.0;

	if (tex1 == tex2) w = inf_w;

	glBindTexture(GL_TEXTURE_2D, tex1);
	glBegin(GL_TRIANGLE_FAN);
		//glColor3f(1.0, 0.0, 0.0);
		glTexCoord2f(vertices1[0].u, vertices1[0].v);
		glVertex4f(vertices1[0].x, vertices1[0].y, vertices1[0].z,w);
		if (tex1 != tex2) glColor4f(0.7, 0.7, 0.7, alpha);
		glTexCoord2f(vertices1[1].u, vertices1[1].v);
		glVertex4f(vertices1[1].x, vertices1[1].y, vertices1[1].z,w);
		glTexCoord2f(vertices1[2].u, vertices1[2].v);
		glVertex4f(vertices1[2].x, vertices1[2].y, vertices1[2].z,w);
		glTexCoord2f(vertices1[3].u, vertices1[3].v);
		glVertex4f(vertices1[3].x, vertices1[3].y, vertices1[3].z,w);
		glTexCoord2f(vertices1[4].u, vertices1[4].v);
		glVertex4f(vertices1[4].x, vertices1[4].y, vertices1[4].z,w);
		glTexCoord2f(vertices1[5].u, vertices1[5].v);
		glVertex4f(vertices1[5].x, vertices1[5].y, vertices1[5].z,w);
		glTexCoord2f(vertices1[6].u, vertices1[6].v);
		glVertex4f(vertices1[6].x, vertices1[6].y, vertices1[6].z,w);
		glTexCoord2f(vertices1[7].u, vertices1[7].v);
		glVertex4f(vertices1[7].x, vertices1[7].y, vertices1[7].z,w);
	glEnd();

	glBindTexture(GL_TEXTURE_2D, tex2);
	glBegin(GL_TRIANGLE_FAN);
		if (tex1 != tex2) glColor4f(0.0, 1.0, 0.0, alpha);
		glTexCoord2f(vertices2[0].u, vertices2[0].v);
		glVertex4f(vertices2[0].x, vertices2[0].y, vertices2[0].z,w);
		if (tex1 != tex2) glColor4f(0.7, 0.7, 0.7, alpha);
		glTexCoord2f(vertices2[1].u, vertices2[1].v);
		glVertex4f(vertices2[1].x, vertices2[1].y, vertices2[1].z,w);
		glTexCoord2f(vertices2[2].u, vertices2[2].v);
		glVertex4f(vertices2[2].x, vertices2[2].y, vertices2[2].z,w);
		glTexCoord2f(vertices2[3].u, vertices2[3].v);
		glVertex4f(vertices2[3].x, vertices2[3].y, vertices2[3].z,w);
		glTexCoord2f(vertices2[4].u, vertices2[4].v);
		glVertex4f(vertices2[4].x, vertices2[4].y, vertices2[4].z,w);
		glTexCoord2f(vertices2[5].u, vertices2[5].v);
		glVertex4f(vertices2[5].x, vertices2[5].y, vertices2[5].z,w);
		glTexCoord2f(vertices2[6].u, vertices2[6].v);
		glVertex4f(vertices2[6].x, vertices2[6].y, vertices2[6].z,w);
		glTexCoord2f(vertices2[7].u, vertices2[7].v);
		glVertex4f(vertices2[7].x, vertices2[7].y, vertices2[7].z,w);
	glEnd();
}

#ifndef __STORM__
static
#endif
inline void myVertex(int i)
{
	glTexCoord2f(vertices1[i].u, vertices1[i].v);
	glVertex3f(vertices1[i].x, vertices1[i].y, vertices1[i].z);
}

#ifndef __STORM__
static
#endif
inline void myVertex2(int i)
{
	glTexCoord2f(vertices2[i].u, vertices2[i].v);
	glVertex3f(vertices2[i].x, vertices1[i].y, vertices2[i].z);
}

static void drawCubeQuad(GLint tex1, GLint tex2)
{
	glDisable(GL_TEXTURE_2D);
	glBegin(GL_QUADS);
		glColor3f(1.0, 0.0, 0.0);
		glVertex3f(-1,-1,-1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,-1); glVertex3f(1,1,-1); glVertex3f(1,-1,-1);

		glColor3f(1.0, 0.5, 0.0);
		glVertex3f(-1,1,-1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,1); glVertex3f(1,1,1); glVertex3f(1,1,-1);

		glColor3f(0.0, 1.0, 0.0);
		glVertex3f(1,1,-1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(1,1,1); glVertex3f(1,-1,1); glVertex3f(1,-1,-1);

		glColor3f(0.0, 0.0, 1.0);
		glVertex3f(1,1,1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,1); glVertex3f(-1,-1,1); glVertex3f(1,-1,1);

		glColor3f(0.0, 0.0, 0.0);
		glVertex3f(-1,1,1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,-1); glVertex3f(-1,-1,-1); glVertex3f(-1,-1,1);

		glColor3f(1.0, 1.0, 1.0);
		glVertex3f(-1,-1,1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,-1,-1);
		glVertex3f(1,-1,-1);
		glVertex3f(1,-1,1);

	glEnd();
	glEnable(GL_TEXTURE_2D);
}

static void drawCubePoly(GLint tex1, GLint tex2)
{
	glDisable(GL_TEXTURE_2D);
	glBegin(GL_POLYGON);
		glColor3f(1.0, 0.0, 0.0);
		glVertex3f(-1,-1,-1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,-1); glVertex3f(1,1,-1); glVertex3f(1,-1,-1);
	glEnd();
	glBegin(GL_POLYGON);
		glColor3f(1.0, 0.5, 0.0);
		glVertex3f(-1,1,-1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,1); glVertex3f(1,1,1); glVertex3f(1,1,-1);
	glEnd();
	glBegin(GL_POLYGON);
		glColor3f(0.0, 1.0, 0.0);
		glVertex3f(1,1,-1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(1,1,1); glVertex3f(1,-1,1); glVertex3f(1,-1,-1);
	glEnd();
	glBegin(GL_POLYGON);
		glColor3f(0.0, 0.0, 1.0);
		glVertex3f(1,1,1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,1); glVertex3f(-1,-1,1); glVertex3f(1,-1,1);
	glEnd();
	glBegin(GL_POLYGON);
		glColor3f(0.0, 0.0, 0.0);
		glVertex3f(-1,1,1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,1,-1); glVertex3f(-1,-1,-1); glVertex3f(-1,-1,1);
	glEnd();
	glBegin(GL_POLYGON);
		glColor3f(1.0, 1.0, 1.0);
		glVertex3f(-1,-1,1); glColor3f(0.5, 0.5, 0.5);
		glVertex3f(-1,-1,-1);
		glVertex3f(1,-1,-1);
		glVertex3f(1,-1,1);
	glEnd();
	glEnable(GL_TEXTURE_2D);
}


typedef void (*drawFunc)(GLint, GLint);

drawFunc funcs[] =
{
	drawCubeFan,
	drawCubeQuad,
	drawCubePoly,
	NULL,
};

static void (*drawCube)(GLint, GLint) = drawCubeFan;

void Rot1(void)
{
	glLoadIdentity();
	glTranslatef(0.f, 0.f, -8.f);
	glRotatef(angle, 0.f, 1.f, 1.f);
}

void Rot2(void)
{
	glLoadIdentity();
	glTranslatef(1.0, 3.0, -8.f);
	glRotatef(-angle, 0.f, 1.f, 1.f);
	glScalef(0.8, 2.0, 1.2);
}

void Rot3(void)
{
	glLoadIdentity();
	glTranslatef(-3.0, 2.0, -7.0);
	glRotatef(-90, 1,0,0);
	glRotatef(90, 0,0,1);
	glRotatef(angle, 1.0, 0.0, 0.0);
	glRotatef(-angle, 0.0, 1.0, 0.0);
	glRotatef(angle/2.0, 0.0, 0.0, 1.0);
	glRotatef(-angle, 1.0, 1.0, 1.0);
}

void Rot4(void)
{
	glLoadIdentity();
	glTranslatef(3.0, 3.0, -10.0);
	glRotatef(2.0*angle, 0.0, 0.0, 1.0);
}

void Rot5(void)
{
	glScalef(20.0, 20.0, 20.0);
}


static
GLboolean draw(void)
{
	static int framecount = 0;
	ULONG fracsecs;
	static  char buffer[256];
	struct Window *win = mglGetWindowHandle();


	#ifndef NODRAW
	if (GL_FALSE == mglLockDisplay())
	{
		printf("Unable to lock drawing area\n");
		return GL_FALSE;
	}

	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	#endif


	if (alpha != 1.0)
	{
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	}

	glEnable(GL_TEXTURE_2D);

	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glLoadIdentity();
	//MakeRot(mouse_angle_x, mouse_angle_y);
	MakeRot(angle, angle);
	Rot5();
	glFrontFace(GL_CW);
	glColor4f(1.f, 1.f, 1.f, 1.f);
	drawCube(3,3);
	glFrontFace(GL_CCW);

	if (alpha != 1.0) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

	Rot1();
	glColor4f(1.0, 1.0, 0.0, alpha);
	drawCube(1,2);

	Rot2();
	glColor4f(1.0, 0.0, 0.0, alpha);
	drawCube(1,2);

	Rot3();
	glColor4f(0.0, 0.0, 1.0, alpha);
	drawCube(1,2);

	Rot4();
	glColor4f(0.0, 1.0, 1.0, alpha);
	drawCube(1,2);

	#ifndef NODRAW
	mglUnlockDisplay();
	#endif

	mglSwitchDisplay();
	framecount++;

	if (fogon == GL_TRUE)
	{
		Move(win->RPort, 10, win->Height-5);
		sprintf(buffer, "S: %6.3f E: %6.3f", fog_start, fog_end);
		Text(win->RPort, buffer, strlen(buffer));
	}

	fracsecs  = ElapsedTime(&eval);
	fracsecs &= 0xFFFF;

	fps = 65536.0/(float)(fracsecs+1);
	
	Move(win->RPort, win->Width - 50, 14);
	sprintf(buffer, "%4.2f", fps);
	Text(win->RPort, buffer, strlen(buffer));
	
	return GL_TRUE;
//    return GL_FALSE;
}

static GLboolean idle (void)
{
  return draw ();
}

static void reshape(int width, int height, int offset, float fov)
{
	GLfloat fog_color[4] = {0.6, 0.3, 0.1, 1.0};
	glFogfv(GL_FOG_COLOR, fog_color);
	glFogf(GL_FOG_MODE, GL_LINEAR);
	glFogf(GL_FOG_START, 1.5);
	glFogf(GL_FOG_END,   fog_end);


	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(fov, 1.3333333, 1.0, (GLdouble)zback);

	glMatrixMode(GL_MODELVIEW);
	glViewport(offset,offset, (GLint)width-2*offset, (GLint)height-2*offset);
	glClearColor(0.0f, 0.f, 0.f, 1.f);
	glClearDepth(zclear);
	glEnable(GL_TEXTURE_2D);
	if (alpha == 1.0) glEnable(GL_CULL_FACE);
	else              glDisable(GL_CULL_FACE);

}

void ClampMouse(struct Window *window, int x, int y, GLboolean left, GLboolean right)
{
	if (left == GL_FALSE && right == GL_FALSE)
	{
		mouse_x = (GLfloat)x/(GLfloat)(window->Width)*8.0;
		mouse_y = (GLfloat)(window->Height - y)/(GLfloat)(window->Height)*8.0;
		if (mouse_x > 8.0) mouse_x = 8.0;
		if (mouse_y > 8.0) mouse_y = 8.0;
		if (mouse_x < 0.0) mouse_x = 0.0;
		if (mouse_y < 0.0) mouse_y = 0.0;
		mouse_x -= 4.0;
		mouse_y -= 4.0;
		mouse_x *= 2.0;
		mouse_y *= 2.0;
	}
	else
	if (left == GL_TRUE && right == GL_FALSE)
	{
		mouse_z = (GLfloat)y/(GLfloat)(window->Height)*15.0;
		if (mouse_z > 15.0) mouse_z = 15.0;
		if (mouse_z < 0.0) mouse_z = 0.0;
		mouse_z -= 5.0;
	}
	else
	if (left == GL_FALSE && right == GL_TRUE)
	{
		mouse_angle_x = (GLfloat)x/(GLfloat)(window->Width)*360.0;
		mouse_angle_y = (GLfloat)y/(GLfloat)(window->Height)*360.0;
	}
}


GLenum LockMode = MGL_LOCK_SMART;

void IdleHandler(void)
{
	angle+=1.0;
	idle();
}

void KeyHandler(char key)
{
	struct Window *window;
	static int drawfn = 0;
	static GLenum WHint = GL_DONT_CARE;

	window = (struct Window *)mglGetWindowHandle();

	switch(key)
	{
		case '1':
			if (WHint == GL_DONT_CARE) WHint = GL_FASTEST;
			else                       WHint = GL_DONT_CARE;
			glHint(MGL_W_ONE_HINT, WHint);
			break;
		case 's':
			if (sync == GL_FALSE)   sync = GL_TRUE;
			else                sync = GL_FALSE;
			mglEnableSync(sync);
			break;
		case '8':
			fog_end++; if (fog_end > zback) fog_end = zback;
			glFogf(GL_FOG_END, fog_end);
			break;
		case '5':
			fog_end--; if (fog_end < fog_start) fog_end = fog_start;
			glFogf(GL_FOG_END, fog_end);
			break;
		case '7':
			fog_start++; if (fog_start > fog_end) fog_start = fog_end;
			glFogf(GL_FOG_START, fog_start);
			break;
		case '4':
			fog_start--; if (fog_start < 1.5) fog_start = 1.5;
			glFogf(GL_FOG_START, fog_start);
			break;
		case 'f':
			if (fogon == GL_FALSE)
			{
				glEnable(GL_FOG);
				fogon = GL_TRUE;
			}
			else
			{
				glDisable(GL_FOG);
				fogon = GL_FALSE;
			}
			break;
		case 'd':
			drawfn++; if (funcs[drawfn] == NULL) drawfn = 0;
			drawCube = funcs[drawfn];
			break;
		case 'Q':
		case 27:
			mglExit();
			break;
		case '+':
			if (zclear < 1.0) zclear += 0.01;
			if (zclear > 1.0) zclear = 1.0;
			glClearDepth(zclear);
			break;
		case '-':
			if (zclear > 0.0) zclear -= 0.01;
			if (zclear < 0.0) zclear = 0.0;
			glClearDepth(zclear);
			break;
		case 'e':
			mouse_z = 10.0;
			break;
		case 'w':
			offset += 10;
			if (offset >=100) offset = 100;
			reshape((int)window->Width,(int)window->Height, offset, fov);
			break;
		case 'q':
			offset -= 10;
			if (offset <=0) offset = 0;
			reshape((int)window->Width,(int)window->Height, offset, fov);
			break;
		case 'y':
			fov += 2.0;
			if (fov>180.0) fov = 180.0;
			reshape((int)window->Width,(int)window->Height, offset, fov);
			break;
		case 'x':
			fov -= 2.0;
			if (fov<40.0) fov = 40.0;
			reshape((int)window->Width,(int)window->Height, offset, fov);
			break;
		case 'z':
			if (zbuffer == GL_TRUE)
			{
				zbuffer = GL_FALSE;
				glDisable(GL_DEPTH_TEST);
			}
			else
			{
				zbuffer = GL_TRUE;
				glEnable(GL_DEPTH_TEST);
			}
			break;
		case 'r':
			ReplaceTexture();
			break;
	}
}

void MouseHandler(GLint MouseX, GLint MouseY, GLbitfield buttons)
{
}

void MainLoop(void)
{
	struct Window *window;


	window = (struct Window *)mglGetWindowHandle();

	TexInit();

	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);

	reshape((int)window->Width,(int)window->Height, offset, fov);
	ElapsedTime(&eval);
	SetAPen(window->RPort, 2);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_TEXTURE_2D);

	mglLockMode(LockMode);
	mglKeyFunc(KeyHandler);
	mglMouseFunc(MouseHandler);
	mglIdleFunc(IdleHandler);
	mglMainLoop();
}

int main(int argc, char **argv)
{
	int i;
	int numb=3, resnr=0;

	printf("Calling MGLInit...\n");
	PrInit();
	MGLInit();

	for (i=1; i<argc; i++)
	{
		if (0 == strcmp(argv[i], "-window"))
		{
			mglChooseWindowMode(GL_TRUE);
		}
		else if (0 == strcmp(argv[i], "-zback"))
		{
			i++;
			zback = (GLfloat)atof(argv[i]);
		}
		else if (0 == strcmp(argv[i], "-w"))
		{
			i++;
			inf_w = (GLfloat)atof(argv[i]);
		}
		else if (0 == strcmp(argv[i], "-buffers"))
		{
			i++;
			numb = atoi(argv[i]);
		}
		else if (0 == strcmp(argv[i], "-res"))
		{
			i++;
			resnr = atoi(argv[i]);
		}
		else if (0 == strcmp(argv[i], "-alpha"))
		{
			i++;
			alpha = atof(argv[i]);
		}
		else if (0 == strcmp(argv[i], "-lock"))
		{
			i++;
			if (0 == stricmp(argv[i], "manual"))
			{
				LockMode = MGL_LOCK_MANUAL;
			}
			else if (0 == stricmp(argv[i], "auto"))
			{
				LockMode = MGL_LOCK_AUTOMATIC;
			}
			else if (0 == stricmp(argv[i], "smart"))
			{
				LockMode = MGL_LOCK_SMART;
			}
			else printf("Unknown lockmode. Using default\n");
		}
		else
		{
			printf("Unknown option %s\n", argv[i]);
			printf("Usage: %s -zback <float> -w <float> -res <int> -lock (manual|auto|smart) -buffers <int>\n", argv[0]);
			exit(0);
		}
	}

	ResPtr = resnr;
	CurrentRes = Resolutions[ResPtr].name;

	fog_start = 1.5;
	fog_end = 100.0;

	//mglSetDebugLevel(10);
	printf("Setting number of buffers to %d...\n", numb);
	mglChooseNumberOfBuffers(numb);
	printf("Setting pixel depth to 15...\n");
	mglChoosePixelDepth(15);
	printf("Creating context...\n");
	if (mglCreateContext(0,0, Resolutions[ResPtr].width, Resolutions[ResPtr].height))
	{
		if (alpha != 1.0) glShadeModel(GL_FLAT);
		printf("Switching sync...\n");
		mglEnableSync(GL_TRUE);
		printf("Going into main loop...\n");
		MainLoop();
		printf("Done\n");
		mglDeleteContext();
	}
	else
	{
		printf("Error: Can't mglCreateContext()\n");
	}

	MGLTerm();
	PrExit();
	return 0;
}