MINI MOTEUR GLUT

/*****************************************************************************/
/*																			 */
/* fichier	: moteur.h									version : V1.0		 */
/* projet	: moteur									date :	30/03/2004	 */
/* par		: aerith														 */
/*																			 */
/* mini moteur 3D															 */
/*																			 */
/*****************************************************************************/

#include	<stdio.h>
#include	<string.h>
#include	<stdlib.h>
#include	<stdio.h>
#include	<math.h>
#include	<time.h>
#include	"glut.h"

#define		NBCARLINE	1024
#define		PAUSE		printf("\nPressze entrer pour continuer\n");fflush(stdout);getchar()

typedef struct _vecteur {
	float	x;
	float	y;
	float	z;
} vecteur;

typedef struct _face {
	int		a;
	int		b;
	int		c;
} face;

typedef struct _quaternion {
	float	x;
	float	y;
	float	z;
	float	a;
} quaternion;

typedef struct _light {
	vecteur Pos;
	float	i;
	float	r;
	float	g;
	float	b;
} light;

typedef struct _camera {
	vecteur	Pos;
	vecteur	Look;
	vecteur	Up;
	int		RotMode;
	float	Zoom;
	int		Light;
} camera;

typedef struct _option {
	int		windowX;	/* <n> */
	int		windowY;	/* <n> */
	char	title[256];	/* <text> */
} option;

typedef struct _mesh {
	vecteur *	vertex;
	face	*	face;
	vecteur *	normal;
	vecteur *	centre;
	int			numvertex;
	int			numface;
} mesh;


void	m3d_loader(char *Fichier);
void	m3d_init(char *Fichier_init, int argc, char *argv[]);
void	Draw(void);
GLvoid	Reshape(GLsizei width, GLsizei height);
char *	gettok(char * Data, int Pos, char *Car);
void	InitGL();


option		m3d_option;
mesh		m3d_mesh;
camera		Camera;
light		Light;
int			Win1;

float	MatSpec[4]		= {0.1f, 0.1f, 0.1f, 1.0f};
float	MatDif[4]		= {0.5f, 0.5f, 0.5f, 1.0f};
float	MatAmb[4]		= {0.5f, 0.5f, 0.5f, 1.0f};
int		LightPos[4]		= {0, 0, 0, 0};
float	LightDif[4]		= {0.6f, 1.0f, 1.0f, 1.0f};
float	LightSpec[4]	= {0.6f, 1.0f, 1.0f, 1.0f};
float	LightAmb[4]		= {0.1f, 0.1f, 0.1f, 1.0f};

void	m3d_loader(char *Fichier)
{
	FILE *	file;
	int		noligne = 0;
	int		numvertex = 0;
	int		numface = 0;
	char	Data[NBCARLINE];
	clock_t start, finish;

	printf("\nloading...\n");
	start = clock();

	Data[0] = 0;

	file = fopen(Fichier, "r");
	if(!file)
	{
		printf("erreur map non trouver\n");
		PAUSE;
		exit(1);
	}

	while(!feof(file))
	{
		if(fgets(Data, NBCARLINE, file) != NULL)
		{
			if(strcmp(gettok(Data, 0, ":* \t\n\""), "MESH_NUMVERTEX") == 0)
				numvertex	= atoi(gettok(Data, 1, ":* \t\n\""));
			if(strcmp(gettok(Data, 0, ":* \t\n\""), "MESH_NUMFACES") == 0)
				numface		= atoi(gettok(Data, 1, ":* \t\n\""));
		}
	}
	fclose(file);

	m3d_mesh.numvertex	= numvertex;
	m3d_mesh.numface	= numface;
	m3d_mesh.vertex		= malloc(sizeof(vecteur) * (numvertex + 1));
	m3d_mesh.face		= malloc(sizeof(face) * (numface + 1));
	m3d_mesh.normal		= malloc(sizeof(vecteur) * (numface + 1));
	m3d_mesh.centre		= malloc(sizeof(vecteur) * (numface + 1));


	Data[0] = 0;

	file = fopen(Fichier, "r");
	if(!file)
	{
		printf("erreur map non trouver\n");
		PAUSE;
		exit(1);
	}

	while(!feof(file))
	{
		if(fgets(Data, NBCARLINE, file) != NULL)
		{
			if (strcmp(gettok(Data, 0, ":* \t\n"), "MESH_VERTEX") == 0)
			{
				m3d_mesh.vertex[atoi(gettok(Data, 1, ":* \t\n"))].x = (float)atof(gettok(Data, 2, ":* \t\n"));
				m3d_mesh.vertex[atoi(gettok(Data, 1, ":* \t\n"))].y = (float)atof(gettok(Data, 3, ":* \t\n"));
				m3d_mesh.vertex[atoi(gettok(Data, 1, ":* \t\n"))].z = (float)atof(gettok(Data, 4, ":* \t\n"));
			}
			if (strcmp(gettok(Data, 0, ":* \t\n"), "MESH_FACE") == 0)
			{
				m3d_mesh.face[atoi(gettok(Data, 1, ":* \t\n"))].a = atoi(gettok(Data, 3, ":* \t\n"));
				m3d_mesh.face[atoi(gettok(Data, 1, ":* \t\n"))].b = atoi(gettok(Data, 5, ":* \t\n"));
				m3d_mesh.face[atoi(gettok(Data, 1, ":* \t\n"))].c = atoi(gettok(Data, 7, ":* \t\n"));
			}
			if (strcmp(gettok(Data, 0, ":* \t\n"), "MESH_FACENORMAL") == 0)
			{
				m3d_mesh.normal[atoi(gettok(Data, 1, ":* \t\n"))].x = (float)atof(gettok(Data, 2, ":* \t\n"));
				m3d_mesh.normal[atoi(gettok(Data, 1, ":* \t\n"))].y = (float)atof(gettok(Data, 3, ":* \t\n"));
				m3d_mesh.normal[atoi(gettok(Data, 1, ":* \t\n"))].z = (float)atof(gettok(Data, 4, ":* \t\n"));
			}
		}
	}
	fclose(file);
	finish = clock();

	printf("%s loaded in %f ms\n", Fichier, (finish - start) / CLOCKS_PER_SEC);
}

char *	gettok(char *Data, int Pos, char *Car)
{
	static char	Data2[NBCARLINE];
	char *	Token;
	int		i;
	strcpy(Data2, Data);
	for(Token = strtok(Data2, Car), i = 0; Token && (i < Pos); ++i, Token = strtok(0, Car));
	return Token;
}

GLvoid Reshape(GLsizei width, GLsizei height)
{
	if (height==0)
		height=1;
	glViewport(0,0,width,height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

void	m3d_init(char *Fichier_init, int argc, char *argv[])
{
	FILE *	file;
	char	Data[NBCARLINE];
	clock_t start, finish;

	printf("\nInitialize...\n");
	start = clock();

	Camera.Pos.x	= 0;
	Camera.Pos.y	= 0;
	Camera.Pos.z	= 10;
	Camera.Look.x	= 0;
	Camera.Look.y	= 0;
	Camera.Look.z	= 0;
	Camera.Up.x		= 0;
	Camera.Up.y		= 1;
	Camera.Up.z		= 0;
	Camera.Zoom		= 1;
	Camera.Light	= 1;
	Camera.RotMode	= 1;
	Light.i			= 1;
	Light.r			= 1;
	Light.g			= 1;
	Light.b			= 1;
	Light.Pos.x		= 0;
	Light.Pos.y		= 0;
	Light.Pos.z		= 0;
	m3d_option.windowX	= 320;
	m3d_option.windowY	= 240;
	strcpy(m3d_option.title, "m3d");

	Data[0] = 0;
	file = fopen(Fichier_init, "r");
	if(!file)
	{
		printf("erreur fichier init inexistant\n");
		PAUSE;
		exit (2);
	}
	while(!feof(file))
	{
		if(fgets(Data, NBCARLINE, file) != NULL)
		{
			if(!(Data[0] == '\\' && Data[1] == '\\') && Data[0] != '\n')
			{
				if(strcmp(gettok(Data, 0, "=: \t\n\""), "camera") == 0)
				{
					Camera.Pos.x	= (float)atof(gettok(Data, 1, "=: \t\n\""));
					Camera.Pos.y	= (float)atof(gettok(Data, 2, "=: \t\n\""));
					Camera.Pos.z	= (float)atof(gettok(Data, 3, "=: \t\n\""));
					Camera.Look.x	= (float)atof(gettok(Data, 4, "=: \t\n\""));
					Camera.Look.y	= (float)atof(gettok(Data, 5, "=: \t\n\""));
					Camera.Look.z	= (float)atof(gettok(Data, 6, "=: \t\n\""));
					Camera.Up.x		= (float)atof(gettok(Data, 7, "=: \t\n\""));
					Camera.Up.y		= (float)atof(gettok(Data, 8, "=: \t\n\""));
					Camera.Up.z		= (float)atof(gettok(Data, 9, "=: \t\n\""));
					Camera.Zoom		= (float)atof(gettok(Data, 10, "=: \t\n\""));
					Camera.Light	= atoi(gettok(Data, 11, "=: \t\n\""));
				}
				if(strcmp(gettok(Data, 0, "=: \t\n\""), "light") == 0)
				{
					Light.Pos.x		= (float)atof(gettok(Data, 1, "=: \t\n\""));
					Light.Pos.y		= (float)atof(gettok(Data, 2, "=: \t\n\""));
					Light.Pos.z		= (float)atof(gettok(Data, 3, "=: \t\n\""));
					Light.i			= atoi(gettok(Data, 4, "=: \t\n\""));
					Light.r			= atoi(gettok(Data, 5, "=: \t\n\""));
					Light.g			= atoi(gettok(Data, 6, "=: \t\n\""));
					Light.b			= atoi(gettok(Data, 7, "=: \t\n\""));
				}
				if(strcmp(gettok(Data, 0, "=: \t\n\""), "window") == 0)
				{
					m3d_option.windowX	= atoi(gettok(Data, 1, "=: \t\n\""));
					m3d_option.windowY	= atoi(gettok(Data, 2, "=: \t\n\""));
				}
				if(strcmp(gettok(Data, 0, "=: \t\n\""), "title") == 0)
					strcpy(m3d_option.title, gettok(Data, 1, "=: \t\n\""));
			}
		}
	}
	fclose(file);
	
	glutInit(&argc,argv);
	glutInitWindowSize(m3d_option.windowX, m3d_option.windowY);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);

	Win1 = glutCreateWindow(m3d_option.title);
	printf("Window : %i*%i\n", m3d_option.windowX, m3d_option.windowY);

	InitGL();

	finish = clock();
	printf("Initialized in %f ms\n", (finish - start) / CLOCKS_PER_SEC);
}

void	InitGL()
{
	glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,MatSpec);
	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,MatDif);
	glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,MatAmb);
	glMateriali(GL_FRONT_AND_BACK,GL_SHININESS,50);
	glLightfv(GL_LIGHT0,GL_DIFFUSE,LightDif);
	glLightfv(GL_LIGHT0,GL_SPECULAR,LightSpec);
	glLightfv(GL_LIGHT0,GL_AMBIENT,LightAmb);
	
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glMatrixMode(GL_MODELVIEW);
}

void	Draw(void)
{
	int		noligne = 0;
	clock_t start, finish;
	static	int FpsCt = 0;
	static float a = 0, b = 0;

	start = clock();

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	LightPos[0]	= Light.Pos.x;
	LightPos[1]	= Light.Pos.y;
	LightPos[2]	= Light.Pos.z;
	LightPos[3]	= 0;
	glLightiv(GL_LIGHT0, GL_POSITION, LightPos);
	glEnable(GL_LIGHTING);

	glLoadIdentity();

	gluLookAt(Camera.Pos.x, Camera.Pos.y, Camera.Pos.z,
		Camera.Look.x, Camera.Look.y, Camera.Look.z,
		Camera.Up.x, Camera.Up.y, Camera.Up.z);

	glScalef(Camera.Zoom, Camera.Zoom, Camera.Zoom);

	glBegin(GL_TRIANGLES);
	for(noligne = 0; noligne < m3d_mesh.numface; noligne++)
	{
		glVertex3f(m3d_mesh.vertex[m3d_mesh.face[noligne].a].x,
			m3d_mesh.vertex[m3d_mesh.face[noligne].a].y,
			m3d_mesh.vertex[m3d_mesh.face[noligne].a].z);
		glVertex3f(m3d_mesh.vertex[m3d_mesh.face[noligne].b].x,
			m3d_mesh.vertex[m3d_mesh.face[noligne].b].y,
			m3d_mesh.vertex[m3d_mesh.face[noligne].b].z);
		glVertex3f(m3d_mesh.vertex[m3d_mesh.face[noligne].c].x,
			m3d_mesh.vertex[m3d_mesh.face[noligne].c].y,
			m3d_mesh.vertex[m3d_mesh.face[noligne].c].z);
	}
	glEnd();

	glutSwapBuffers();
	glutPostRedisplay();

	finish = clock();
	FpsCt += finish - start;
	if(FpsCt > 250)
	{
		FpsCt = 0;
		system("CLS");
		printf("[vertex : %i]  [faces : %i]\n", m3d_mesh.numvertex, m3d_mesh.numface);
		printf("fps : %i\n\n", (CLOCKS_PER_SEC / (finish - start + 1)));
		printf("cam : \t[pos  : %.2f, %.2f, %.2f]\n", Camera.Pos.x,  Camera.Pos.y,  Camera.Pos.z );
		printf("      \t[look : %.2f, %.2f, %.2f]\n", Camera.Look.x, Camera.Look.y, Camera.Look.z);
		printf("      \t[up   : %.2f, %.2f, %.2f]\n", Camera.Up.x,   Camera.Up.y,   Camera.Up.z  );
		printf("      \t[zoom : %.2f]\n\n", Camera.Zoom);
		if(Camera.RotMode == 0)
			printf("Look Mode : [rotation relative]\n");
		else
			printf("Look Mode : [rotation absolut]\n");
	}
}