home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
1,001 Nights of Doom
/
1001NightsOfDoom1995wickedSensations.iso
/
nodebild
/
idbsp10.zip
/
SAVEBSP.C
< prev
next >
Wrap
Text File
|
1994-05-31
|
22KB
|
783 lines
/* savebsp.m */
#include "idbsp.h"
/*
id secstore_i;
id mapvertexstore_i;
id subsecstore_i;
id maplinestore_i;
id nodestore_i;
id mapthingstore_i;
id ldefstore_i;
id sdefstore_i;
*/
STORAGE *secstore_i;
STORAGE *mapvertexstore_i;
STORAGE *subsecstore_i;
STORAGE *maplinestore_i;
STORAGE *nodestore_i;
STORAGE *mapthingstore_i;
STORAGE *ldefstore_i;
STORAGE *sdefstore_i;
/*
===============================================================================
the output functions byte swap and write lumps
===============================================================================
*/
/*
================
=
= WriteStorage
=
================
*/
/*void WriteStorage (char *name, id store, int esize) */
void WriteStorage(char *name, STORAGE *store, int esize)
{
int count, len;
/* count = [store count]; */
count = store->count;
len = esize*count;
/* [wad_i addName: name data:[store elementAt:0] size:len]; */
addName(name, store->data, len);
printf ("%s (%i): %i\n",name,count,len);
}
/*
=================
=
= OutputSectors
=
=================
*/
void OutputSectors (void)
{
int i, count;
mapsector_t *p;
/*
count = [secstore_i count];
p = [secstore_i elementAt:0];
*/
count = secstore_i->count;
p = secstore_i->data;
/*
for (i=0 ; i<count ; i++, p++)
{
p->floorheight = SHORT(p->floorheight);
p->ceilingheight = SHORT(p->ceilingheight);
p->lightlevel = SHORT(p->lightlevel);
p->special = SHORT(p->special);
p->tag = SHORT(p->tag);
}
*/
WriteStorage ("sectors", secstore_i, sizeof(mapsector_t));
}
/*
=================
=
= OutputSegs
=
=================
*/
void OutputSegs (void)
{
int i, count;
mapseg_t *p;
/*
count = [maplinestore_i count];
p = [maplinestore_i elementAt:0];
*/
count = maplinestore_i->count;
p = maplinestore_i->data;
/*
for (i=0 ; i<count ; i++, p++)
{
p->v1 = SHORT(p->v1);
p->v2 = SHORT(p->v2);
p->angle = SHORT(p->angle);
p->linedef = SHORT(p->linedef);
p->side = SHORT(p->side);
p->offset = SHORT(p->offset);
}
*/
WriteStorage ("segs",maplinestore_i, sizeof(mapseg_t));
}
/*
=================
=
= OutputSubsectors
=
=================
*/
void OutputSubsectors (void)
{
int i, count;
mapsubsector_t *p;
/*
count = [subsecstore_i count];
p = [subsecstore_i elementAt:0];
*/
count = subsecstore_i->count;
p = subsecstore_i->data;
/*
for (i=0 ; i<count ; i++, p++)
{
p->numsegs = SHORT(p->numsegs);
p->firstseg = SHORT(p->firstseg);
}
*/
WriteStorage ("ssectors", subsecstore_i, sizeof(mapsubsector_t));
}
/*
=================
=
= OutputVertexes
=
=================
*/
void OutputVertexes (void)
{
int i, count;
mapvertex_t *p;
/*
count = [mapvertexstore_i count];
p = [mapvertexstore_i elementAt:0];
*/
count = mapvertexstore_i->count;
p = mapvertexstore_i->data;
/*
for (i=0 ; i<count ; i++, p++)
{
p->x = SHORT(p->x);
p->y = SHORT(p->y);
}
*/
WriteStorage ("vertexes",mapvertexstore_i, sizeof(mapvertex_t));
}
/*
=================
=
= OutputThings
=
=================
*/
void OutputThings (void)
{
int i, count;
mapthing_t *p;
/*
count = [mapthingstore_i count];
p = [mapthingstore_i elementAt:0];
*/
count = mapthingstore_i->count;
p = mapthingstore_i->data;
/*
for (i=0 ; i<count ; i++, p++)
{
p->x = SHORT(p->x);
p->y = SHORT(p->y);
p->angle = SHORT(p->angle);
p->type = SHORT(p->type);
p->options = SHORT(p->options);
}
*/
WriteStorage ("things", mapthingstore_i, sizeof(mapthing_t));
}
/*
=================
=
= OutputLineDefs
=
=================
*/
void OutputLineDefs (void)
{
int i, count;
maplinedef_t *p;
/*
count = [ldefstore_i count];
p = [ldefstore_i elementAt:0];
*/
count = ldefstore_i->count;
p = ldefstore_i->data;
#if 0
for (i=0 ; i<count ; i++, p++)
{
p->v1 = SHORT(p->v1);
p->v2 = SHORT(p->v2);
/* some ancient version of DoomEd left ML_MAPPED flags in some of the levels */
p->flags = SHORT(p->flags&~ML_MAPPED);
p->special = SHORT(p->special);
p->tag = SHORT(p->tag);
p->sidenum[0] = SHORT(p->sidenum[0]);
p->sidenum[1] = SHORT(p->sidenum[1]);
}
#endif
WriteStorage ("linedefs", ldefstore_i, sizeof(maplinedef_t));
}
/*
=================
=
= OutputSideDefs
=
=================
*/
void OutputSideDefs (void)
{
int i, count;
mapsidedef_t *p;
/*
count = [sdefstore_i count];
p = [sdefstore_i elementAt:0];
*/
count = sdefstore_i->count;
p = sdefstore_i->data;
/*
for (i=0 ; i<count ; i++, p++)
{
p->textureoffset = SHORT(p->textureoffset);
p->rowoffset = SHORT(p->rowoffset);
p->sector = SHORT(p->sector);
}
*/
WriteStorage ("sidedefs", sdefstore_i, sizeof(mapsidedef_t));
}
/*
=================
=
= OutputNodes
=
=================
*/
void OutputNodes (void)
{
int i, j, count;
mapnode_t *p;
/*
count = [nodestore_i count];
p = [nodestore_i elementAt:0];
*/
count = nodestore_i->count;
p = nodestore_i->data;
/*
for (i=0 ; i<count ; i++, p++)
{
for (j=0 ; j<sizeof(mapnode_t)/2 ; j++)
((short *)p)[j] = SHORT(((short *)p)[j]);
}
*/
WriteStorage ("nodes", nodestore_i, sizeof(mapnode_t));
}
/*
===============================================================================
PROCESSING
===============================================================================
*/
/*
=================
=
= UniqueVertex
=
= Returns the vertex number, adding a new vertex if needed
=================
*/
int UniqueVertex (int x, int y)
{
int i, count;
mapvertex_t mv, *mvp;
mv.x = x;
mv.y = y;
/* see if an identical vertex already exists */
/*
count = [mapvertexstore_i count];
mvp = [mapvertexstore_i elementAt:0];
*/
count = mapvertexstore_i->count;
mvp = mapvertexstore_i->data;
for (i=0 ; i<count ; i++, mvp++)
if (mvp->x == mv.x && mvp->y == mv.y)
return i;
/* [mapvertexstore_i addElement: &mv]; */
memcpy((mapvertex_t *)mapvertexstore_i->data + mapvertexstore_i->count, &mv,
sizeof(mapvertex_t));
mapvertexstore_i->count += 1;
mapvertexstore_i->data = (mapvertex_t *)realloc(mapvertexstore_i->data,
sizeof(mapvertex_t) * (mapvertexstore_i->count + 1));
return count;
}
/*
=============================================================================
*/
float bbox[4];
/*
=================
=
= AddPointToBBox
=
=================
*/
void AddPointToBBox (NXPoint *pt)
{
if (pt->x < bbox[BOXLEFT])
bbox[BOXLEFT] = pt->x;
if (pt->x > bbox[BOXRIGHT])
bbox[BOXRIGHT] = pt->x;
if (pt->y > bbox[BOXTOP])
bbox[BOXTOP] = pt->y;
if (pt->y < bbox[BOXBOTTOM])
bbox[BOXBOTTOM] = pt->y;
}
/*
=================
=
= ProcessLines
=
= Adds the lines in a subsector to the mapline storage
=================
*/
/* void ProcessLines (id store_i) */
void ProcessLines(STORAGE *store_i)
{
int i,count;
line_t *wline;
mapseg_t line;
short angle;
float fangle;
bbox[BOXLEFT] = INT_MAX;
bbox[BOXRIGHT] = INT_MIN;
bbox[BOXTOP] = INT_MIN;
bbox[BOXBOTTOM] = INT_MAX;
/* count = [store_i count]; */
count = store_i->count;
for (i=0 ; i<count ; i++)
{
/* wline = [store_i elementAt: i]; */
wline = (line_t *)store_i->data + i;
if (wline->grouped)
printf ("ERROR: line regrouped\n");
wline->grouped = true;
memset (&line, 0, sizeof(line));
AddPointToBBox (&wline->p1);
AddPointToBBox (&wline->p2);
line.v1 = UniqueVertex (wline->p1.x, wline->p1.y);
line.v2 = UniqueVertex (wline->p2.x, wline->p2.y);
line.linedef = wline->linedef;
line.side = wline->side;
line.offset = wline->offset;
fangle = atan2 (wline->p2.y - wline->p1.y, wline->p2.x - wline->p1.x);
angle = (short)(fangle/(PI*2)*0x10000);
line.angle = angle;
/* [maplinestore_i addElement: &line]; */
memcpy((mapseg_t *)maplinestore_i->data + maplinestore_i->count, &line,
sizeof(line));
maplinestore_i->count += 1;
maplinestore_i->data = (mapseg_t *)realloc(maplinestore_i->data,
sizeof(mapseg_t) * (maplinestore_i->count + 1));
}
}
/*
=================
=
= ProcessSubsector
=
=================
*/
/* int ProcessSubsector (id wmaplinestore_i) */
int ProcessSubsector(STORAGE *wmaplinestore_i)
{
int count;
worldline_t *linedef;
line_t *wline;
mapsubsector_t sub;
memset (&sub,0,sizeof(sub));
/* count = [wmaplinestore_i count]; */
count = wmaplinestore_i->count;
if (count < 1)
Error ("ProcessSubsector: count = %i",count);
/* wline = [wmaplinestore_i elementAt: 0]; */
wline = wmaplinestore_i->data;
/* linedef = [linestore_i elementAt: wline->linedef]; */
linedef = (worldline_t *)linestore_i->data + wline->linedef;
sub.numsegs = count;
/* sub.firstseg = [maplinestore_i count]; */
sub.firstseg = maplinestore_i->count;
ProcessLines (wmaplinestore_i);
/* add the new subsector
[subsecstore_i addElement: &sub];
*/
memcpy((mapsubsector_t *)subsecstore_i->data + subsecstore_i->count, &sub,
sizeof(mapsubsector_t));
subsecstore_i->count += 1;
subsecstore_i->data = (mapsubsector_t *)realloc(subsecstore_i->data,
sizeof(mapsubsector_t) * (subsecstore_i->count + 1));
/* return [subsecstore_i count]-1; */
return subsecstore_i->count - 1;
}
/*
=================
=
= ProcessNode
=
=================
*/
int ProcessNode (bspnode_t *node, short *totalbox)
{
short subbox[2][4];
int i, r;
mapnode_t mnode;
memset (&mnode,0,sizeof(mnode));
if (node->lines_i) /* NF_SUBSECTOR flags a subsector */
{
r = ProcessSubsector (node->lines_i);
for (i=0 ; i<4 ; i++)
totalbox[i] = bbox[i];
return r | NF_SUBSECTOR;
}
mnode.x =node->divline.pt.x;
mnode.y =node->divline.pt.y;
mnode.dx =node->divline.dx;
mnode.dy =node->divline.dy;
r = ProcessNode(node->side[0], subbox[0]);
mnode.children[0] =r;
for (i=0 ; i<4 ; i++)
mnode.bbox[0][i] =subbox[0][i];
r = ProcessNode (node->side[1],subbox[1]);
mnode.children[1] =r;
for (i=0 ; i<4 ; i++)
mnode.bbox[1][i] =subbox[1][i];
totalbox[BOXLEFT] = MIN(subbox[0][BOXLEFT], subbox[1][BOXLEFT]);
totalbox[BOXTOP] = MAX(subbox[0][BOXTOP], subbox[1][BOXTOP]);
totalbox[BOXRIGHT] = MAX(subbox[0][BOXRIGHT], subbox[1][BOXRIGHT]);
totalbox[BOXBOTTOM] = MIN(subbox[0][BOXBOTTOM], subbox[1][BOXBOTTOM]);
/* [nodestore_i addElement: &mnode]; */
memcpy((mapnode_t *)nodestore_i->data + nodestore_i->count, &mnode, sizeof(mapnode_t));
nodestore_i->count += 1;
nodestore_i->data = (mapnode_t *)realloc(nodestore_i->data,
sizeof(mapnode_t) * (nodestore_i->count + 1));
/* return [nodestore_i count] - 1; */
return nodestore_i->count - 1;
}
/*
=================
=
= ProcessNodes
=
= Recursively builds the nodes, subsectors, and line lists,
= then writes the lumps
=================
*/
void ProcessNodes (void)
{
short worldbounds[4];
/*
subsecstore_i = [[Storage alloc]
initCount: 0
elementSize: sizeof(mapsubsector_t)
description: NULL];
maplinestore_i = [[Storage alloc]
initCount: 0
elementSize: sizeof(mapseg_t)
description: NULL];
nodestore_i = [[Storage alloc]
initCount: 0
elementSize: sizeof(mapnode_t)
description: NULL];
*/
subsecstore_i = (STORAGE *)SafeMalloc(sizeof(STORAGE));
subsecstore_i->data = (mapsubsector_t *)SafeMalloc(sizeof(mapsubsector_t));
subsecstore_i->count = 0;
subsecstore_i->size = sizeof(mapsubsector_t);
maplinestore_i = (STORAGE *)SafeMalloc(sizeof(STORAGE));
maplinestore_i->data = (mapseg_t *)SafeMalloc(sizeof(mapseg_t));
maplinestore_i->count = 0;
maplinestore_i->size = sizeof(mapseg_t);
nodestore_i = (STORAGE *)SafeMalloc(sizeof(STORAGE));
nodestore_i->data = (mapnode_t *)SafeMalloc(sizeof(mapnode_t));
nodestore_i->count = 0;
nodestore_i->size = sizeof(mapnode_t);
ProcessNode (startnode, worldbounds);
}
/*
=================
=
= ProcessThings
=
=================
*/
void ProcessThings (void)
{
worldthing_t *wt;
mapthing_t mt;
int count;
/*
mapthingstore_i = [[Storage alloc]
initCount: 0
elementSize: sizeof(mapthing_t)
description: NULL];
*/
mapthingstore_i = (STORAGE *)SafeMalloc(sizeof(STORAGE));
mapthingstore_i->data = (mapthing_t *)SafeMalloc(sizeof(mapthing_t));
mapthingstore_i->count = 0;
mapthingstore_i->size = sizeof(mapthing_t);
/*
count = [thingstore_i count];
wt = [thingstore_i elementAt: 0];
*/
count = thingstore_i->count;
wt = thingstore_i->data;
while (count--)
{
memset (&mt,0,sizeof(mt));
mt.x =wt->origin.x;
mt.y =wt->origin.y;
mt.angle =wt->angle;
mt.type =wt->type;
mt.options =wt->options;
/* [mapthingstore_i addElement: &mt]; */
memcpy((mapthing_t *)mapthingstore_i->data + mapthingstore_i->count, &mt,
sizeof(mapthing_t));
mapthingstore_i->count += 1;
mapthingstore_i->data = (mapthing_t *)realloc(mapthingstore_i->data,
sizeof(mapthing_t) * (mapthingstore_i->count + 1));
wt++;
}
}
/*
=============================================================================
*/
/*
==================
=
= ProcessSidedef
=
==================
*/
int ProcessSidedef (worldside_t *ws)
{
mapsidedef_t ms;
ms.textureoffset = ws->firstcollumn;
ms.rowoffset = ws->firstrow;
memcpy (ms.toptexture, ws->toptexture, 8);
memcpy (ms.bottomtexture, ws->bottomtexture, 8);
memcpy (ms.midtexture, ws->midtexture, 8);
ms.sector = ws->sector;
/* [sdefstore_i addElement: &ms]; */
memcpy((mapsidedef_t *)sdefstore_i->data + sdefstore_i->count, &ms, sizeof(mapsidedef_t));
sdefstore_i->count += 1;
sdefstore_i->data = (mapsidedef_t *)realloc(sdefstore_i->data,
sizeof(mapsidedef_t) * (sdefstore_i->count + 1));
/* return [sdefstore_i count]-1; */
return sdefstore_i->count - 1;
}
/*
==================
=
= ProcessLineSideDefs
=
= Must be called after BuildSectors
==================
*/
void ProcessLineSideDefs (void)
{
int i, count;
maplinedef_t ld;
worldline_t *wl;
/*
mapvertexstore_i = [[Storage alloc]
initCount: 0
elementSize: sizeof(mapvertex_t)
description: NULL];
ldefstore_i = [[Storage alloc]
initCount: 0
elementSize: sizeof(maplinedef_t)
description: NULL];
sdefstore_i = [[Storage alloc]
initCount: 0
elementSize: sizeof(mapsidedef_t)
description: NULL];
*/
mapvertexstore_i = (STORAGE *)SafeMalloc(sizeof(STORAGE));
mapvertexstore_i->data = (mapvertex_t *)SafeMalloc(sizeof(mapvertex_t));
mapvertexstore_i->count = 0;
mapvertexstore_i->size = sizeof(mapvertex_t);
ldefstore_i = (STORAGE *)SafeMalloc(sizeof(STORAGE));
ldefstore_i->data = (maplinedef_t *)SafeMalloc(sizeof(maplinedef_t));
ldefstore_i->count = 0;
ldefstore_i->size = sizeof(maplinedef_t);
sdefstore_i = (STORAGE *)SafeMalloc(sizeof(STORAGE));
sdefstore_i->data = (mapsidedef_t *)SafeMalloc(sizeof(mapsidedef_t));
sdefstore_i->count = 0;
sdefstore_i->size = sizeof(mapsidedef_t);
/*
count = [linestore_i count];
wl = [linestore_i elementAt:0];
*/
count = linestore_i->count;
wl = linestore_i->data;
for (i=0 ; i<count ; i++, wl++)
{
ld.v1 = UniqueVertex(wl->p1.x,wl->p1.y);
ld.v2 =UniqueVertex(wl->p2.x,wl->p2.y);
ld.flags =wl->flags;
ld.special =wl->special;
ld.tag =wl->tag;
ld.sidenum[0] =ProcessSidedef(&wl->side[0]);
if (wl->flags & ML_TWOSIDED)
ld.sidenum[1] =ProcessSidedef(&wl->side[1]);
else
ld.sidenum[1] =-1;
/* [ldefstore_i addElement: &ld]; */
memcpy((maplinedef_t *)ldefstore_i->data + ldefstore_i->count, &ld, sizeof(maplinedef_t));
ldefstore_i->count += 1;
ldefstore_i->data = (maplinedef_t *)realloc(ldefstore_i->data,
sizeof(maplinedef_t) * (ldefstore_i->count + 1));
}
}
/*
=============================================================================
*/
/*
==================
=
= SaveDoomMap
=
==================
*/
void SaveDoomMap (void)
{
printf("\nBuildSectordefs\n");
BuildSectordefs ();
printf("ProcessThings\n");
ProcessThings ();
printf("ProcessLineSideDefs\n");
ProcessLineSideDefs ();
printf("ProcessNodes\n");
ProcessNodes ();
printf("ProcessSectors\n");
ProcessSectors ();
printf("\nProcessConnections\n");
ProcessConnections ();
/* all processing is complete, write everything out */
OutputThings ();
OutputLineDefs ();
OutputSideDefs ();
OutputVertexes ();
OutputSegs ();
OutputSubsectors ();
OutputNodes ();
OutputSectors ();
OutputConnections ();
}