665 lines
18 KiB
C
665 lines
18 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <GL/gl.h>
|
|
#include <neofx/math.h>
|
|
#include <zoom/types.h>
|
|
#include <zoom/texture.h>
|
|
#include <zoom/level.h>
|
|
#include <zoom/light.h>
|
|
#include <libxml/parser.h>
|
|
#include <libxml/tree.h>
|
|
#include <libxml/valid.h>
|
|
|
|
|
|
extern GLuint sphere;
|
|
extern GLuint meditex_blue;
|
|
extern float objrot;
|
|
extern LIGHT *lights;
|
|
extern int nLights;
|
|
|
|
|
|
static int SortTextures(const void *t1, const void *t2) {
|
|
return strcmp(((TEXTURE*)t1)->name, ((TEXTURE*)t2)->name);
|
|
}
|
|
|
|
static int SortRooms(const void *r1, const void *r2) {
|
|
return strcmp(((ROOM*)r1)->id, ((ROOM*)r2)->id);
|
|
}
|
|
|
|
|
|
static void LoadTriangles(xmlNodePtr node, LEVEL *level, WALL* walls, int nWalls) {
|
|
int i = 0, j;
|
|
xmlNodePtr node2;
|
|
xmlChar *data;
|
|
TEXTURE tex, *texp;
|
|
VECTOR v;
|
|
|
|
|
|
for(; node = node->next; node != NULL) {
|
|
if(node->type != XML_ELEMENT_NODE || xmlStrcmp(node->name, "triangle")) continue;
|
|
|
|
walls[i].visible = 1;
|
|
data = xmlGetProp(node, "visible");
|
|
if(data) {
|
|
if(!xmlStrcmp(data, "false")) walls[i].visible = 0;
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node, "texture");
|
|
if(data) {
|
|
tex.name = data;
|
|
texp = bsearch(&tex, level->textures, level->nTextures, sizeof(TEXTURE), SortTextures);
|
|
|
|
if(texp) walls[i].texture = texp->id;
|
|
|
|
xmlFree(data);
|
|
}
|
|
|
|
j = -1;
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type != XML_ELEMENT_NODE) continue;
|
|
|
|
if(!xmlStrcmp(node2->name, "vertex")) {
|
|
if(++j > 2) break;
|
|
|
|
data = xmlGetProp(node2, "x");
|
|
if(data) {
|
|
walls[i].vertices[j].x = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node2, "y");
|
|
if(data) {
|
|
walls[i].vertices[j].y = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node2, "z");
|
|
if(data) {
|
|
walls[i].vertices[j].z = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
}
|
|
else if(!xmlStrcmp(node2->name, "normal")) {
|
|
if(j < 0) continue;
|
|
|
|
data = xmlGetProp(node2, "x");
|
|
if(data) {
|
|
walls[i].normals[j].x = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node2, "y");
|
|
if(data) {
|
|
walls[i].normals[j].y = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node2, "z");
|
|
if(data) {
|
|
walls[i].normals[j].z = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
}
|
|
else if(!xmlStrcmp(node2->name, "texcoords")) {
|
|
if(j < 0) continue;
|
|
|
|
data = xmlGetProp(node2, "s");
|
|
if(data) {
|
|
walls[i].texcoords[j].s = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node2, "t");
|
|
if(data) {
|
|
walls[i].texcoords[j].t = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
v = VectorCross(
|
|
VectorSub(walls[i].vertices[1], walls[i].vertices[0]),
|
|
VectorSub(walls[i].vertices[2], walls[i].vertices[0])
|
|
);
|
|
if(VectorLengthSq(v) > 0.0) {
|
|
walls[i].normal = VectorNormalize(v);
|
|
|
|
for(j = 0; j < 3; j++) {
|
|
if(VectorLengthSq(walls[i].normals[j]) == 0.0)
|
|
walls[i].normals[j] = walls[i].normal;
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
|
|
|
|
LEVEL *LoadLevel(char *filename) {
|
|
LEVEL *level;
|
|
xmlDocPtr doc;
|
|
xmlDtdPtr dtd;
|
|
xmlValidCtxtPtr validCtxt;
|
|
xmlNodePtr root, node, node2, node3, rooms = NULL, gates = NULL;
|
|
xmlChar *data;
|
|
char *name;
|
|
int i, j;
|
|
ROOM room, *roomp;
|
|
|
|
|
|
name = malloc(strlen(filename)+8);
|
|
strcpy(name, "levels/");
|
|
strcat(name, filename);
|
|
|
|
doc = xmlParseFile(name);
|
|
|
|
free(name);
|
|
|
|
if(!doc)
|
|
return NULL;
|
|
|
|
dtd = xmlParseDTD("-//libzoom//DTD level 0.1//EN", "levels/level.dtd");
|
|
|
|
if(!dtd) {
|
|
xmlFreeDoc(doc);
|
|
xmlCleanupParser();
|
|
return NULL;
|
|
}
|
|
|
|
validCtxt = xmlNewValidCtxt();
|
|
|
|
if(!validCtxt) {
|
|
xmlFreeDtd(dtd);
|
|
xmlFreeDoc(doc);
|
|
xmlCleanupParser();
|
|
return NULL;
|
|
}
|
|
|
|
if(!xmlValidateDtd(validCtxt, doc, dtd)) {
|
|
xmlFreeValidCtxt(validCtxt);
|
|
xmlFreeDtd(dtd);
|
|
xmlFreeDoc(doc);
|
|
xmlCleanupParser();
|
|
return NULL;
|
|
}
|
|
|
|
xmlFreeValidCtxt(validCtxt);
|
|
xmlFreeDtd(dtd);
|
|
|
|
root = xmlDocGetRootElement(doc);
|
|
if(!root || xmlStrcmp(root->name, "level")) {
|
|
xmlFreeDoc(doc);
|
|
xmlCleanupParser();
|
|
return NULL;puts("Loaded.");
|
|
|
|
|
|
}
|
|
|
|
level = calloc(1, sizeof(LEVEL));
|
|
|
|
for(node = root->children; node = node->next; node != NULL) {
|
|
if(node->type != XML_ELEMENT_NODE) continue;
|
|
|
|
if(!xmlStrcmp(node->name, "info")) {
|
|
level->info = calloc(1, sizeof(LEVELINFO));
|
|
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type != XML_ELEMENT_NODE) continue;
|
|
|
|
if(!xmlStrcmp(node2->name, "name")) {
|
|
if(level->info->name != NULL) continue;
|
|
|
|
data = xmlNodeGetContent(node2);
|
|
level->info->name = strdup(data);
|
|
xmlFree(data);
|
|
}
|
|
else if(!xmlStrcmp(node2->name, "desc")) {
|
|
if(level->info->desc != NULL) continue;
|
|
|
|
data = xmlNodeGetContent(node2);
|
|
level->info->desc = strdup(data);
|
|
xmlFree(data);
|
|
}
|
|
else if(!xmlStrcmp(node2->name, "start")) {
|
|
data = xmlGetProp(node2, "x");
|
|
if(data) level->info->start.x = atof(data);
|
|
xmlFree(data);
|
|
|
|
data = xmlGetProp(node2, "y");
|
|
if(data) level->info->start.y = atof(data);
|
|
xmlFree(data);
|
|
|
|
data = xmlGetProp(node2, "z");
|
|
if(data) level->info->start.z = atof(data);
|
|
xmlFree(data);
|
|
}
|
|
}
|
|
}
|
|
else if(!xmlStrcmp(node->name, "rooms")) {
|
|
if(rooms != NULL) continue;
|
|
|
|
rooms = node;
|
|
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type == XML_ELEMENT_NODE && !xmlStrcmp(node2->name, "room")) level->nRooms++;
|
|
}
|
|
}
|
|
else if(!xmlStrcmp(node->name, "gates")) {
|
|
if(gates != NULL) continue;
|
|
|
|
gates = node;
|
|
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type == XML_ELEMENT_NODE && !xmlStrcmp(node2->name, "gate")) level->nGates++;
|
|
}
|
|
}
|
|
else if(!xmlStrcmp(node->name, "textures")) {
|
|
if(level->textures != NULL) continue;
|
|
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type == XML_ELEMENT_NODE && !xmlStrcmp(node2->name, "texture")) level->nTextures++;
|
|
}
|
|
|
|
level->textures = calloc(level->nTextures, sizeof(TEXTURE));
|
|
|
|
i = 0;
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type != XML_ELEMENT_NODE || xmlStrcmp(node2->name, "texture")) continue;
|
|
|
|
data = xmlGetProp(node2, "name");
|
|
if(data) {
|
|
level->textures[i].id = LoadTexture(data);
|
|
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node2, "id");
|
|
if(data) {
|
|
level->textures[i].name = strdup(data);
|
|
|
|
xmlFree(data);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
qsort(level->textures, level->nTextures, sizeof(TEXTURE), SortTextures);
|
|
}
|
|
}
|
|
|
|
level->rooms = calloc(level->nRooms, sizeof(ROOM));
|
|
|
|
i = 0;
|
|
for(node = rooms->children; node = node->next; node != NULL) {
|
|
if(node->type != XML_ELEMENT_NODE || xmlStrcmp(node->name, "room")) continue;
|
|
|
|
data = xmlGetProp(node, "id");
|
|
if(data) {
|
|
level->rooms[i].id = strdup(data);
|
|
|
|
xmlFree(data);
|
|
}
|
|
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type == XML_ELEMENT_NODE && !xmlStrcmp(node2->name, "triangle")) level->rooms[i].nWalls++;
|
|
}
|
|
|
|
level->rooms[i].walls = calloc(level->rooms[i].nWalls, sizeof(WALL));
|
|
|
|
LoadTriangles(node->children, level, level->rooms[i].walls, level->rooms[i].nWalls);
|
|
|
|
i++;
|
|
}
|
|
|
|
qsort(level->rooms, level->nRooms, sizeof(ROOM), SortRooms);
|
|
|
|
level->gates = calloc(level->nGates, sizeof(GATE));
|
|
|
|
i = 0;
|
|
for(node = gates->children; node = node->next; node != NULL) {
|
|
if(node->type != XML_ELEMENT_NODE || xmlStrcmp(node->name, "gate")) continue;
|
|
|
|
data = xmlGetProp(node2, "room1");
|
|
if(data) {
|
|
room.id = data;
|
|
roomp = bsearch(&room, level->rooms, level->nRooms, sizeof(ROOM), SortRooms);
|
|
|
|
if(roomp) level->gates[i].room1 = roomp;
|
|
|
|
xmlFree(data);
|
|
}
|
|
|
|
data = xmlGetProp(node2, "room2");
|
|
if(data) {
|
|
room.id = data;
|
|
roomp = bsearch(&room, level->rooms, level->nRooms, sizeof(ROOM), SortRooms);
|
|
|
|
if(roomp) level->gates[i].room2 = roomp;
|
|
|
|
xmlFree(data);
|
|
}
|
|
|
|
for(node2 = node->children; node2 = node2->next; node2 != NULL) {
|
|
if(node2->type == XML_ELEMENT_NODE && !xmlStrcmp(node2->name, "triangle")) level->gates[i].nWalls++;
|
|
}
|
|
|
|
level->gates[i].walls = calloc(level->gates[i].nWalls, sizeof(WALL));
|
|
|
|
LoadTriangles(node->children, level, level->gates[i].walls, level->gates[i].nWalls);
|
|
|
|
i++;
|
|
}
|
|
|
|
xmlFreeDoc(doc);
|
|
xmlCleanupParser();
|
|
|
|
return level;
|
|
}
|
|
|
|
POLYGON_LIST *DrawRoom(LEVEL *level, int nr) {
|
|
ROOM room = level->rooms[nr];
|
|
POLYGON_LIST *p;
|
|
int i;
|
|
|
|
p = malloc(sizeof(POLYGON_LIST)+sizeof(POLYGON)*room.nWalls);
|
|
p->nPolygons = room.nWalls;
|
|
|
|
for(i = 0; i < room.nWalls; i++) {
|
|
p->polygons[i].vertices[0] = room.walls[i].vertices[0];
|
|
p->polygons[i].vertices[1] = room.walls[i].vertices[1];
|
|
p->polygons[i].vertices[2] = room.walls[i].vertices[2];
|
|
|
|
p->polygons[i].normal = room.walls[i].normal;
|
|
p->polygons[i].normals[0] = room.walls[i].normals[0];
|
|
p->polygons[i].normals[1] = room.walls[i].normals[1];
|
|
p->polygons[i].normals[2] = room.walls[i].normals[2];
|
|
|
|
p->polygons[i].texture = room.walls[i].texture;
|
|
|
|
p->polygons[i].texcoords[0] = room.walls[i].texcoords[0];
|
|
p->polygons[i].texcoords[1] = room.walls[i].texcoords[1];
|
|
p->polygons[i].texcoords[2] = room.walls[i].texcoords[2];
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
/*void DrawRoom(LEVEL *level, int nr) {
|
|
int i, j;
|
|
int r, g;
|
|
GLfloat std_emission[] = {0.0, 0.0, 0.0, 1.0};
|
|
GLfloat medipak100_emission[] = {1.0, 0.0, 0.0, 1.0};
|
|
ROOM room = level->rooms[nr];
|
|
WALL t1, t2;
|
|
VERTEX p1, p2;
|
|
VECTOR v1, v2, n, v;
|
|
float s, t, d;
|
|
MATRIX transform;
|
|
|
|
|
|
for(i = 0; i < room.nWalls; i++)
|
|
RenderWallDepth(room.walls[i]);
|
|
|
|
for(i = 0; i < nLights; i++) {
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
for(j = 0; j < room.nWalls; j++)
|
|
RenderWallLight(room.walls[j], lights[i]);
|
|
|
|
glAccum(GL_ACCUM, 1.0/(nLights+1));
|
|
}
|
|
|
|
glAccum(GL_RETURN, 1.0);
|
|
|
|
//for(i = 0; i < room.nWalls; i++)
|
|
// RenderWall(room.walls[i], level->textures);
|
|
|
|
glColor3f(1.0/(nLights+1), 1.0/(nLights+1), 1.0/(nLights+1));
|
|
|
|
for(i = 0; i < room.nThings; i++) {
|
|
if(!room.things[i].visible) continue;
|
|
switch(room.things[i].type) {
|
|
case THING_MEDIPAK100:
|
|
glPushMatrix();
|
|
glBindTexture(GL_TEXTURE_2D, meditex_blue);
|
|
glMaterialfv(GL_FRONT, GL_EMISSION, medipak100_emission);
|
|
glTranslatef(room.things[i].pos.x, room.things[i].pos.y, room.things[i].pos.z);
|
|
glRotatef(objrot*10, 0.0, 1.0, 0.0);
|
|
glScalef(0.3, 0.3, 0.3);
|
|
glCallList(sphere);
|
|
glMaterialfv(GL_FRONT, GL_EMISSION, std_emission);
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
|
|
for(i = 0; i < room.nGates; i++) {
|
|
if(room.gateinfo[i].state == STATE_CLOSED) {
|
|
glBindTexture(GL_TEXTURE_2D, level->textures[room.gates[i].walls[0].texture]);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glNormal3fv((GLfloat*)&room.gates[i].walls[0].normal);
|
|
glTexCoord2fv((GLfloat*)&room.gates[i].walls[0].texcoords[0]);
|
|
glVertex3fv((GLfloat*)&room.gates[i].walls[0].vertices[0]);
|
|
glTexCoord2fv((GLfloat*)&room.gates[i].walls[0].texcoords[1]);
|
|
glVertex3fv((GLfloat*)&room.gates[i].walls[0].vertices[1]);
|
|
glTexCoord2fv((GLfloat*)&room.gates[i].walls[0].texcoords[2]);
|
|
glVertex3fv((GLfloat*)&room.gates[i].walls[0].vertices[2]);
|
|
|
|
glEnd();
|
|
|
|
glBindTexture(GL_TEXTURE_2D, level->textures[room.gates[i].walls[0].texture]);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glNormal3fv((GLfloat*)&room.gates[i].walls[1].normal);
|
|
glTexCoord2fv((GLfloat*)&room.gates[i].walls[1].texcoords[0]);
|
|
glVertex3fv((GLfloat*)&room.gates[i].walls[1].vertices[0]);
|
|
glTexCoord2fv((GLfloat*)&room.gates[i].walls[1].texcoords[1]);
|
|
glVertex3fv((GLfloat*)&room.gates[i].walls[1].vertices[1]);
|
|
glTexCoord2fv((GLfloat*)&room.gates[i].walls[1].texcoords[2]);
|
|
glVertex3fv((GLfloat*)&room.gates[i].walls[1].vertices[2]);
|
|
|
|
glEnd();
|
|
}
|
|
else if(room.gateinfo[i].state == STATE_OPENING) {
|
|
t1 = room.gates[i].walls[0];
|
|
t2 = room.gates[i].walls[1];
|
|
|
|
t1.vertices[2] = VectorAdd(VectorMul(t1.vertices[2], room.gateinfo[i].timer/1000.0),
|
|
VectorMul(t1.vertices[1], 1 - (room.gateinfo[i].timer/1000.0)));
|
|
t2.vertices[1] = t1.vertices[2];
|
|
t2.vertices[2] = VectorAdd(VectorMul(t2.vertices[2], room.gateinfo[i].timer/1000.0),
|
|
VectorMul(t2.vertices[0], 1 - (room.gateinfo[i].timer/1000.0)));
|
|
|
|
|
|
t1.texcoords[0].s = t1.texcoords[0].s * room.gateinfo[i].timer/1000.0
|
|
+ t2.texcoords[2].s * (1 - room.gateinfo[i].timer/1000.0);
|
|
t1.texcoords[0].t = t1.texcoords[0].t * room.gateinfo[i].timer/1000.0
|
|
+ t2.texcoords[2].t * (1 - room.gateinfo[i].timer/1000.0);
|
|
t1.texcoords[1].s = t1.texcoords[1].s * room.gateinfo[i].timer/1000.0
|
|
+ t1.texcoords[2].s * (1 - room.gateinfo[i].timer/1000.0);
|
|
t1.texcoords[1].t = t1.texcoords[1].t * room.gateinfo[i].timer/1000.0
|
|
+ t1.texcoords[2].t * (1 - room.gateinfo[i].timer/1000.0);
|
|
t2.texcoords[0] = t1.texcoords[0];
|
|
|
|
glBindTexture(GL_TEXTURE_2D, level->textures[t1.texture]);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glNormal3fv((GLfloat*)&t1.normal);
|
|
glTexCoord2fv((GLfloat*)&t1.texcoords[0]);
|
|
glVertex3fv((GLfloat*)&t1.vertices[0]);
|
|
glTexCoord2fv((GLfloat*)&t1.texcoords[1]);
|
|
glVertex3fv((GLfloat*)&t1.vertices[1]);
|
|
glTexCoord2fv((GLfloat*)&t1.texcoords[2]);
|
|
glVertex3fv((GLfloat*)&t1.vertices[2]);
|
|
|
|
glEnd();
|
|
|
|
glBindTexture(GL_TEXTURE_2D, level->textures[t2.texture]);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glNormal3fv((GLfloat*)&t2.normal);
|
|
glTexCoord2fv((GLfloat*)&t2.texcoords[0]);
|
|
glVertex3fv((GLfloat*)&t2.vertices[0]);
|
|
glTexCoord2fv((GLfloat*)&t2.texcoords[1]);
|
|
glVertex3fv((GLfloat*)&t2.vertices[1]);
|
|
glTexCoord2fv((GLfloat*)&t2.texcoords[2]);
|
|
glVertex3fv((GLfloat*)&t2.vertices[2]);
|
|
|
|
glEnd();
|
|
|
|
r = room.gates[i].room;
|
|
g = room.gates[i].gate;
|
|
|
|
t1 = room.gates[i].walls[0];
|
|
t2 = room.gates[i].walls[1];
|
|
p1 = room.gates[i].point;
|
|
v1 = t1.normal;
|
|
|
|
t1 = level->rooms[r].gates[g].walls[0];
|
|
t2 = level->rooms[r].gates[g].walls[1];
|
|
p2 = level->rooms[r].gates[g].point;
|
|
v2 = VectorNeg(t1.normal);
|
|
|
|
glPushMatrix();
|
|
transform = VectorMatrix(p1, v1, p2, v2);
|
|
glMultMatrixf(transform.f);
|
|
//DrawRoom(level, r);
|
|
glPopMatrix();
|
|
}
|
|
else if(room.gateinfo[i].state == STATE_CLOSING) {
|
|
t1 = room.gates[i].walls[0];
|
|
t2 = room.gates[i].walls[1];
|
|
|
|
t1.vertices[2] = VectorAdd(VectorMul(t1.vertices[2], 1 - (room.gateinfo[i].timer/1000.0)),
|
|
VectorMul(t1.vertices[1], room.gateinfo[i].timer/1000.0));
|
|
t2.vertices[1] = t1.vertices[2];
|
|
t2.vertices[2] = VectorAdd(VectorMul(t2.vertices[2], 1 - (room.gateinfo[i].timer/1000.0)),
|
|
VectorMul(t2.vertices[0], room.gateinfo[i].timer/1000.0));
|
|
|
|
|
|
t1.texcoords[0].s = t1.texcoords[0].s * (1 - room.gateinfo[i].timer/1000.0)
|
|
+ t2.texcoords[2].s * room.gateinfo[i].timer/1000.0;
|
|
t1.texcoords[0].t = t1.texcoords[0].t * (1 - room.gateinfo[i].timer/1000.0)
|
|
+ t2.texcoords[2].t * room.gateinfo[i].timer/1000.0;
|
|
t1.texcoords[1].s = t1.texcoords[1].s * (1 - room.gateinfo[i].timer/1000.0)
|
|
+ t1.texcoords[2].s * room.gateinfo[i].timer/1000.0;
|
|
t1.texcoords[1].t = t1.texcoords[1].t * (1 - room.gateinfo[i].timer/1000.0)
|
|
+ t1.texcoords[2].t * room.gateinfo[i].timer/1000.0;
|
|
t2.texcoords[0] = t1.texcoords[0];
|
|
|
|
glBindTexture(GL_TEXTURE_2D, level->textures[t1.texture]);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glNormal3fv((GLfloat*)&t1.normal);
|
|
glTexCoord2fv((GLfloat*)&t1.texcoords[0]);
|
|
glVertex3fv((GLfloat*)&t1.vertices[0]);
|
|
glTexCoord2fv((GLfloat*)&t1.texcoords[1]);
|
|
glVertex3fv((GLfloat*)&t1.vertices[1]);
|
|
glTexCoord2fv((GLfloat*)&t1.texcoords[2]);
|
|
glVertex3fv((GLfloat*)&t1.vertices[2]);
|
|
|
|
glEnd();
|
|
|
|
glBindTexture(GL_TEXTURE_2D, level->textures[t2.texture]);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glNormal3fv((GLfloat*)&t2.normal);
|
|
glTexCoord2fv((GLfloat*)&t2.texcoords[0]);
|
|
glVertex3fv((GLfloat*)&t2.vertices[0]);
|
|
glTexCoord2fv((GLfloat*)&t2.texcoords[1]);
|
|
glVertex3fv((GLfloat*)&t2.vertices[1]);
|
|
glTexCoord2fv((GLfloat*)&t2.texcoords[2]);
|
|
glVertex3fv((GLfloat*)&t2.vertices[2]);
|
|
|
|
glEnd();
|
|
|
|
r = room.gates[i].room;
|
|
g = room.gates[i].gate;
|
|
|
|
t1 = room.gates[i].walls[0];
|
|
t2 = room.gates[i].walls[1];
|
|
p1 = room.gates[i].point;
|
|
v1 = t1.normal;
|
|
|
|
t1 = level->rooms[r].gates[g].walls[0];
|
|
t2 = level->rooms[r].gates[g].walls[1];
|
|
p2 = level->rooms[r].gates[g].point;
|
|
v2 = VectorNeg(t1.normal);
|
|
|
|
glPushMatrix();
|
|
transform = VectorMatrix(p1, v1, p2, v2);
|
|
glMultMatrixf(transform.f);
|
|
//DrawRoom(level, r);
|
|
glPopMatrix();
|
|
}
|
|
else {
|
|
r = room.gates[i].room;
|
|
g = room.gates[i].gate;
|
|
|
|
t1 = room.gates[i].walls[0];
|
|
t2 = room.gates[i].walls[1];
|
|
p1 = room.gates[i].point;
|
|
v1 = t1.normal;
|
|
|
|
t1 = level->rooms[r].gates[g].walls[0];
|
|
t2 = level->rooms[r].gates[g].walls[1];
|
|
p2 = level->rooms[r].gates[g].point;
|
|
v2 = VectorNeg(t1.normal);
|
|
|
|
glPushMatrix();
|
|
transform = VectorMatrix(p1, v1, p2, v2);
|
|
glMultMatrixf(transform.f);
|
|
//DrawRoom(level, r);
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
}*/
|
|
|
|
void FreeLevel(LEVEL *level) {
|
|
int i;
|
|
|
|
if(level) {
|
|
if(level->info) {
|
|
free(level->info->name);
|
|
free(level->info->desc);
|
|
free(level->info);
|
|
}
|
|
|
|
if(level->nRooms) {
|
|
for(i = 0; i < level->nRooms; i++) {
|
|
if(level->rooms[i].nWalls) free(level->rooms[i].walls);
|
|
/*if(level->rooms[i].nThings) free(level->rooms[i].things);
|
|
if(level->rooms[i].nGates) {
|
|
free(level->rooms[i].gates);
|
|
free(level->rooms[i].gateinfo);
|
|
}*/
|
|
|
|
free(level->rooms[i].id);
|
|
}
|
|
free(level->rooms);
|
|
}
|
|
|
|
if(level->nGates) {
|
|
for(i = 0; i < level->nGates; i++) {
|
|
if(level->gates[i].nWalls) free(level->gates[i].walls);
|
|
}
|
|
free(level->gates);
|
|
}
|
|
|
|
if(level->nTextures) {
|
|
for(i = 0; i < level->nTextures; i++)
|
|
free(level->textures[i].name);
|
|
|
|
free(level->textures);
|
|
}
|
|
|
|
free(level);
|
|
}
|
|
}
|