-1.0f 0.0f 0.0f   ,   0.0f -1.0f 0.0f   ,   1.0f 0.0f 0.0f    ;initial polygon, format style #1

[-1.0f 0.0f 0.0f] [0.0f -1.0f 0.0f] [1.0f 0.0f 0.0f]    ;initial polygon, format style #2

// model.h; 

typedef struct vertex_s
{
	float x,
	      y,
	      z;
} vertex_t;

typedef struct polygon_s
{
	vertex_t v[3];
} polygon_t;

typedef struct model_s
{
	int nPolygons;		// number of polygons
	polygon_t *pList;	// list of polygons
} model_t;

extern model_t sampleModel;

// render a polygon
void DrawPolygon (polygon_t *p);

// model ops:
void LoadModel (char *sFilename, model_t *model);	// loads a *.m model file
void DrawModel (model_t *model, vertex_t *translate, vertex_t *rotate);
void FreeModel (model_t *model);

// model.cpp - *.m file loading and displaying functions

// from:  www.falloutsoftware.com
// by:    Greg Damon (gregd@falloutsoftware.com)
// ---------------------------------------------

#include "glbase.h"

model_t sampleModel;

int mmReadCh (FILE **file)
{
	return fgetc(*file);
}

void mmSkipLine (FILE **file)
{
	fgets(sysBuffer, 128, *file);
}

// mmReadNextParam: reads the next parameter from a *.m file stream,
// skips all unneeded characters
float mmReadNextParam (FILE **file)
{
	int ch = 0;
	float f = 0;
	bool legal = false;

	while (true)
	{
		ch = mmReadCh(file);
		
                // EOF or error: set err to 1 and break out of the loop
		if (ch == EOF)
			SysShutdownMSG("mmReadNextParam: unexpected EOF or parsing"
                                       "error\r\ncheck your *.m model file syntax");

                // skip spaces or any other misc. characters (, . etc)
                // also; a vertex param. could be negative
                // so look out for '-' (0x2d) while parsing

		((ch >= 0x30  && ch <= 0x39) || ch == 0x2d) ? legal = true : legal = false;

		if (legal)
		{
			// back up by one character
			if (fseek(*file, (ftell(*file)- 1), SEEK_SET) != 0)
				SysShutdownMSG("mmReadNextParam: fseek failed, "
                                               "sorry; check your *.m model file syntax");

			// read the floating-point parameter and return it
			fscanf(*file, "%f", &f);
			return f;
		}
	}

	return 0; // EOF or error at this point
}

// LoadModel(); loads an m file format model into model_t *model
void LoadModel (char *sFilename, model_t *model)
{
	FILE *file = fopen(sFilename, "r");

	if (file)
	{
		// find the "beginmodel" tag
		while (true)
			if (strncmp(fgets(sysBuffer, 128, file), "beginmodel", 10) == 0)
				break;

		// read the number of polygons in this model
		sscanf(sysBuffer, "beginmodel %d", &model->nPolygons);

		// allocate enough memory for this model
		model->pList = (polygon_t *)malloc(model->nPolygons * sizeof(polygon_t));

		// read all polygon vertices
		for (int i=0; inPolygons * 3; i++) {
			model->pList->v[i].x = mmReadNextParam(&file);
			model->pList->v[i].y = mmReadNextParam(&file);
			model->pList->v[i].z = mmReadNextParam(&file);
		}

		fclose(file);
	}
	else
	{
		sprintf(sysBuffer, "LoadModelM(): Cannot open file \"%s\"", sFilename);
		SysShutdownMSG(sysBuffer);
	}
}

LoadModel("model.m", &sampleModel);

// ... at this point we're ready to display the model by calling DrawModel(&sampleModel);

// DrawPolygon(); draws an opengl polygon defined by polygon_t struct
void DrawPolygon (polygon_t *p)
{
	glBegin(GL_TRIANGLES);

	glColor3f(1.0f, 1.0f, 1.0f);
	glVertex3f(p->v[0].x, p->v[0].y, p->v[0].z);
	glVertex3f(p->v[1].x, p->v[1].y, p->v[1].z);
	glVertex3f(p->v[2].x, p->v[2].y, p->v[2].z);

	glEnd();
}

// DrawModel(); draws a model
void DrawModel (model_t *model, vertex_t *translate, float r_anglex, float r_angley, float r_anglez)
{
	glLoadIdentity();
	glTranslatef(translate->x, translate->y, translate->z);
	glRotatef(r_anglex, 1.0f, 0.0f, 0.0f);
	glRotatef(r_angley, 0.0f, 1.0f, 0.0f);
	glRotatef(r_anglez, 0.0f, 0.0f, 1.0f);

	for (int i=0; inPolygons; i++)
		DrawPolygon(&model->pList[i]);
}

// FreeModel(); frees model memory
void FreeModel (model_t *model)
{
	if (model->pList)
	{
		free(model->pList);
		model->pList = NULL;
	}
}

// define the model
model_t sampleModel;

// ...somewhere before the main rendering loop begins
// load "model.h" into sampleModel...
LoadModel("model.m", &sampleModel);

// ... within the main rendering loop
// render the model to the screen...

float modelAnglex = 0.0f;
float modelAngley = 0.0f;
float modelAnglez = 0.0f;
float modelTranslate[3] = { 0.0f, 0.0f, -6.0f };

DrawModel(&sampleModel, &modelTranslate, modelAnglex, modelAngley, 0.0f);

// ... during program shutdown, free memory...
FreeModel(&sampleModel);

void GetInput (void)
{
	I_GetMouse();

	// rotate the model only when the left mouse button is pressed
	if (mse.state.rgbButtons[0])
	{
		float prevx = modelAnglex;
		float prevy = modelAngley;

		modelAnglex += mse.state.lY;
		modelAngley += mse.state.lX;

		addAnglex = modelAnglex - prevx;
		addAngley = modelAngley - prevy;
	}
	else
	{
		modelAnglex += addAnglex;
		modelAngley += addAngley;
	}
}