zdoom/zdray
0
0
Fork 0
mirror of https://github.com/ZDoom/ZDRay.git synced 2025-02-03 05:01:00 +00:00
Code Issues Projects Releases Packages Wiki Activity

- use the standardized typedefs for sized integers

Browse source
This commit is contained in:
Magnus Norddahl 2018-11-03 17:43:42 +01:00
parent ef8dfe3744
commit 627098b671
16 changed files with 308 additions and 316 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

72
src/blockmapbuilder/blockmapbuilder.cpp
View file

@ -72,7 +72,7 @@ int BoxOnSide (int bx1, int by1, int bx2, int by2,
}
#endif
WORD *FBlockmapBuilder::GetBlockmap (int &size)
uint16_t *FBlockmapBuilder::GetBlockmap (int &size)
{
#ifdef BLOCK_TEST
FILE *f = fopen ("blockmap.lmp", "rb");
@ -86,10 +86,10 @@ WORD *FBlockmapBuilder::GetBlockmap (int &size)
fread (stuff, 2, fsize/2, f);
fclose (f);
if ((WORD)stuff[0] != BlockMap[0] ||
(WORD)stuff[1] != BlockMap[1] ||
(WORD)stuff[2] != BlockMap[2] ||
(WORD)stuff[3] != BlockMap[3])
if ((uint16_t)stuff[0] != BlockMap[0] ||
(uint16_t)stuff[1] != BlockMap[1] ||
(uint16_t)stuff[2] != BlockMap[2] ||
(uint16_t)stuff[3] != BlockMap[3])
{
printf ("different blockmap sizes\n");
goto notest;
@ -98,7 +98,7 @@ WORD *FBlockmapBuilder::GetBlockmap (int &size)
for (i = 0; i < stuff[2] * stuff[3]; ++i)
{
WORD i1, i2;
uint16_t i1, i2;
i1 = stuff[4+i] + 1;
while (stuff[i1] != -1)
{
@ -138,7 +138,7 @@ WORD *FBlockmapBuilder::GetBlockmap (int &size)
i2 = stuff[4+i] + 1;
while (stuff[i2] != -1)
{
if ((WORD)stuff[i2] == BlockMap[i1])
if ((uint16_t)stuff[i2] == BlockMap[i1])
break;
i2++;
}
@ -172,11 +172,11 @@ notest:
void FBlockmapBuilder::BuildBlockmap ()
{
TArray<WORD> *BlockLists, *block, *endblock;
WORD adder;
TArray<uint16_t> *BlockLists, *block, *endblock;
uint16_t adder;
int bmapwidth, bmapheight;
int minx, maxx, miny, maxy;
WORD line;
uint16_t line;
if (Level.NumVertices <= 0)
return;
@ -203,12 +203,12 @@ void FBlockmapBuilder::BuildBlockmap ()
bmapwidth = ((maxx - minx) >> BLOCKBITS) + 1;
bmapheight = ((maxy - miny) >> BLOCKBITS) + 1;
adder = WORD(minx); BlockMap.Push (adder);
adder = WORD(miny); BlockMap.Push (adder);
adder = WORD(bmapwidth); BlockMap.Push (adder);
adder = WORD(bmapheight); BlockMap.Push (adder);
adder = uint16_t(minx); BlockMap.Push (adder);
adder = uint16_t(miny); BlockMap.Push (adder);
adder = uint16_t(bmapwidth); BlockMap.Push (adder);
adder = uint16_t(bmapheight); BlockMap.Push (adder);
BlockLists = new TArray<WORD>[bmapwidth * bmapheight];
BlockLists = new TArray<uint16_t>[bmapwidth * bmapheight];
for (line = 0; line < Level.NumLines(); ++line)
{
@ -331,15 +331,15 @@ void FBlockmapBuilder::BuildBlockmap ()
delete[] BlockLists;
}
void FBlockmapBuilder::CreateUnpackedBlockmap (TArray<WORD> *blocks, int bmapwidth, int bmapheight)
void FBlockmapBuilder::CreateUnpackedBlockmap (TArray<uint16_t> *blocks, int bmapwidth, int bmapheight)
{
TArray<WORD> *block;
WORD zero = 0;
WORD terminator = 0xffff;
TArray<uint16_t> *block;
uint16_t zero = 0;
uint16_t terminator = 0xffff;
for (int i = 0; i < bmapwidth * bmapheight; ++i)
{
BlockMap[4+i] = WORD(BlockMap.Size());
BlockMap[4+i] = uint16_t(BlockMap.Size());
BlockMap.Push (zero);
block = &blocks[i];
for (unsigned int j = 0; j < block->Size(); ++j)
@ -350,10 +350,10 @@ void FBlockmapBuilder::CreateUnpackedBlockmap (TArray<WORD> *blocks, int bmapwid
}
}
static unsigned int BlockHash (TArray<WORD> *block)
static unsigned int BlockHash (TArray<uint16_t> *block)
{
int hash = 0;
WORD *ar = &(*block)[0];
uint16_t *ar = &(*block)[0];
for (size_t i = 0; i < block->Size(); ++i)
{
hash = hash * 12235 + ar[i];
@ -361,7 +361,7 @@ static unsigned int BlockHash (TArray<WORD> *block)
return hash & 0x7fffffff;
}
static bool BlockCompare (TArray<WORD> *block1, TArray<WORD> *block2)
static bool BlockCompare (TArray<uint16_t> *block1, TArray<uint16_t> *block2)
{
size_t size = block1->Size();
@ -373,8 +373,8 @@ static bool BlockCompare (TArray<WORD> *block1, TArray<WORD> *block2)
{
return true;
}
WORD *ar1 = &(*block1)[0];
WORD *ar2 = &(*block2)[0];
uint16_t *ar1 = &(*block1)[0];
uint16_t *ar2 = &(*block2)[0];
for (size_t i = 0; i < size; ++i)
{
if (ar1[i] != ar2[i])
@ -385,20 +385,20 @@ static bool BlockCompare (TArray<WORD> *block1, TArray<WORD> *block2)
return true;
}
void FBlockmapBuilder::CreatePackedBlockmap (TArray<WORD> *blocks, int bmapwidth, int bmapheight)
void FBlockmapBuilder::CreatePackedBlockmap (TArray<uint16_t> *blocks, int bmapwidth, int bmapheight)
{
WORD buckets[4096];
WORD *hashes, hashblock;
TArray<WORD> *block;
WORD zero = 0;
WORD terminator = 0xffff;
WORD *array;
uint16_t buckets[4096];
uint16_t *hashes, hashblock;
TArray<uint16_t> *block;
uint16_t zero = 0;
uint16_t terminator = 0xffff;
uint16_t *array;
int i, hash;
int hashed = 0, nothashed = 0;
hashes = new WORD[bmapwidth * bmapheight];
hashes = new uint16_t[bmapwidth * bmapheight];
memset (hashes, 0xff, sizeof(WORD)*bmapwidth*bmapheight);
memset (hashes, 0xff, sizeof(uint16_t)*bmapwidth*bmapheight);
memset (buckets, 0xff, sizeof(buckets));
for (i = 0; i < bmapwidth * bmapheight; ++i)
@ -422,8 +422,8 @@ void FBlockmapBuilder::CreatePackedBlockmap (TArray<WORD> *blocks, int bmapwidth
else
{
hashes[i] = buckets[hash];
buckets[hash] = WORD(i);
BlockMap[4+i] = WORD(BlockMap.Size());
buckets[hash] = uint16_t(i);
BlockMap[4+i] = uint16_t(BlockMap.Size());
BlockMap.Push (zero);
array = &(*block)[0];
for (size_t j = 0; j < block->Size(); ++j)

8
src/blockmapbuilder/blockmapbuilder.h
View file

@ -9,13 +9,13 @@ class FBlockmapBuilder
{
public:
FBlockmapBuilder (FLevel &level);
WORD *GetBlockmap (int &size);
uint16_t *GetBlockmap (int &size);
private:
FLevel &Level;
TArray<WORD> BlockMap;
TArray<uint16_t> BlockMap;
void BuildBlockmap ();
void CreateUnpackedBlockmap (TArray<WORD> *blocks, int bmapwidth, int bmapheight);
void CreatePackedBlockmap (TArray<WORD> *blocks, int bmapwidth, int bmapheight);
void CreateUnpackedBlockmap (TArray<uint16_t> *blocks, int bmapwidth, int bmapheight);
void CreatePackedBlockmap (TArray<uint16_t> *blocks, int bmapwidth, int bmapheight);
};

14
src/framework/zdray.h
View file

@ -45,22 +45,14 @@ extern int SSELevel;
#define FRACBITS 16
typedef int fixed_t;
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef signed short SWORD;
#ifdef _WIN32
typedef unsigned long DWORD;
#else
typedef uint32_t DWORD;
#endif
typedef uint32_t angle_t;
angle_t PointToAngle (fixed_t x, fixed_t y);
static const WORD NO_MAP_INDEX = 0xffff;
static const DWORD NO_INDEX = 0xffffffff;
static const uint16_t NO_MAP_INDEX = 0xffff;
static const uint32_t NO_INDEX = 0xffffffff;
static const angle_t ANGLE_MAX = 0xffffffff;
static const DWORD DWORD_MAX = 0xffffffff;
static const uint32_t DWORD_MAX = 0xffffffff;
static const angle_t ANGLE_180 = (1u<<31);
static const angle_t ANGLE_EPSILON = 5000;

78
src/level/doomdata.h
View file

@ -37,7 +37,7 @@ struct MapSideDef
char toptexture[8];
char bottomtexture[8];
char midtexture[8];
WORD sector;
uint16_t sector;
};
struct IntLineDef;
@ -60,32 +60,32 @@ struct IntSideDef
struct MapLineDef
{
WORD v1;
WORD v2;
uint16_t v1;
uint16_t v2;
short flags;
short special;
short tag;
WORD sidenum[2];
uint16_t sidenum[2];
};
struct MapLineDef2
{
WORD v1;
WORD v2;
uint16_t v1;
uint16_t v2;
short flags;
unsigned char special;
unsigned char args[5];
WORD sidenum[2];
uint16_t sidenum[2];
};
struct IntLineDef
{
DWORD v1;
DWORD v2;
uint32_t v1;
uint32_t v2;
int flags;
int special;
int args[5];
DWORD sidenum[2];
uint32_t sidenum[2];
TArray<UDMFKey> props;
};
@ -120,52 +120,52 @@ struct IntSector
struct MapSubsector
{
WORD numlines;
WORD firstline;
uint16_t numlines;
uint16_t firstline;
};
struct MapSubsectorEx
{
DWORD numlines;
DWORD firstline;
uint32_t numlines;
uint32_t firstline;
};
struct MapSeg
{
WORD v1;
WORD v2;
WORD angle;
WORD linedef;
uint16_t v1;
uint16_t v2;
uint16_t angle;
uint16_t linedef;
short side;
short offset;
};
struct MapSegEx
{
DWORD v1;
DWORD v2;
WORD angle;
WORD linedef;
uint32_t v1;
uint32_t v2;
uint16_t angle;
uint16_t linedef;
short side;
short offset;
};
struct MapSegGL
{
WORD v1;
WORD v2;
WORD linedef;
WORD side;
WORD partner;
uint16_t v1;
uint16_t v2;
uint16_t linedef;
uint16_t side;
uint16_t partner;
};
struct MapSegGLEx
{
DWORD v1;
DWORD v2;
DWORD linedef;
WORD side;
DWORD partner;
uint32_t v1;
uint32_t v2;
uint32_t linedef;
uint16_t side;
uint32_t partner;
};
#define NF_SUBSECTOR 0x8000
@ -175,21 +175,21 @@ struct MapNode
{
short x,y,dx,dy;
short bbox[2][4];
WORD children[2];
uint16_t children[2];
};
struct MapNodeExO
{
short x,y,dx,dy;
short bbox[2][4];
DWORD children[2];
uint32_t children[2];
};
struct MapNodeEx
{
int x,y,dx,dy;
short bbox[2][4];
DWORD children[2];
uint32_t children[2];
};
struct MapThing
@ -319,18 +319,18 @@ struct FLevel
MapSubsectorEx *Subsectors; int NumSubsectors;
MapSegEx *Segs; int NumSegs;
MapNodeEx *Nodes; int NumNodes;
WORD *Blockmap; int BlockmapSize;
BYTE *Reject; int RejectSize;
uint16_t *Blockmap; int BlockmapSize;
uint8_t *Reject; int RejectSize;
MapSubsectorEx *GLSubsectors; int NumGLSubsectors;
MapSegGLEx *GLSegs; int NumGLSegs;
MapNodeEx *GLNodes; int NumGLNodes;
WideVertex *GLVertices; int NumGLVertices;
BYTE *GLPVS; int GLPVSSize;
uint8_t *GLPVS; int GLPVSSize;
int NumOrgVerts;
DWORD *OrgSectorMap; int NumOrgSectors;
uint32_t *OrgSectorMap; int NumOrgSectors;
fixed_t MinX, MinY, MaxX, MaxY;

236
src/level/level.cpp
View file

@ -325,7 +325,7 @@ void FLevel::RemoveExtraLines ()
void FLevel::RemoveExtraSides ()
{
BYTE *used;
uint8_t *used;
int *remap;
int i, newNumSides;
@ -333,7 +333,7 @@ void FLevel::RemoveExtraSides ()
// They just waste space, so get rid of them.
int NumSides = this->NumSides();
used = new BYTE[NumSides];
used = new uint8_t[NumSides];
memset (used, 0, NumSides*sizeof(*used));
remap = new int[NumSides];
@ -397,22 +397,22 @@ void FLevel::RemoveExtraSides ()
void FLevel::RemoveExtraSectors ()
{
BYTE *used;
DWORD *remap;
uint8_t *used;
uint32_t *remap;
int i, newNumSectors;
// Extra sectors are those that aren't referenced by any sides.
// They just waste space, so get rid of them.
NumOrgSectors = NumSectors();
used = new BYTE[NumSectors()];
used = new uint8_t[NumSectors()];
memset (used, 0, NumSectors()*sizeof(*used));
remap = new DWORD[NumSectors()];
remap = new uint32_t[NumSectors()];
// Mark all used sectors
for (i = 0; i < NumSides(); ++i)
{
if ((DWORD)Sides[i].sector != NO_INDEX)
if ((uint32_t)Sides[i].sector != NO_INDEX)
{
used[Sides[i].sector] = 1;
}
@ -447,13 +447,13 @@ void FLevel::RemoveExtraSectors ()
// Renumber sector references in sides
for (i = 0; i < NumSides(); ++i)
{
if ((DWORD)Sides[i].sector != NO_INDEX)
if ((uint32_t)Sides[i].sector != NO_INDEX)
{
Sides[i].sector = remap[Sides[i].sector];
}
}
// Make a reverse map for fixing reject lumps
OrgSectorMap = new DWORD[newNumSectors];
OrgSectorMap = new uint32_t[newNumSectors];
for (i = 0; i < NumSectors(); ++i)
{
if (remap[i] != NO_INDEX)
@ -667,8 +667,8 @@ void FProcessor::Write (FWadWriter &out)
#ifdef BLOCK_TEST
int size;
BYTE *blockmap;
ReadLump<BYTE> (Wad, Wad.FindMapLump ("BLOCKMAP", Lump), blockmap, size);
uint8_t *blockmap;
ReadLump<uint8_t> (Wad, Wad.FindMapLump ("BLOCKMAP", Lump), blockmap, size);
if (blockmap)
{
FILE *f = fopen ("blockmap.lmp", "wb");
@ -684,9 +684,9 @@ void FProcessor::Write (FWadWriter &out)
if (!isUDMF)
{
FBlockmapBuilder bbuilder (Level);
WORD *blocks = bbuilder.GetBlockmap (Level.BlockmapSize);
Level.Blockmap = new WORD[Level.BlockmapSize];
memcpy (Level.Blockmap, blocks, Level.BlockmapSize*sizeof(WORD));
uint16_t *blocks = bbuilder.GetBlockmap (Level.BlockmapSize);
Level.Blockmap = new uint16_t[Level.BlockmapSize];
memcpy (Level.Blockmap, blocks, Level.BlockmapSize*sizeof(uint16_t));
Level.RejectSize = (Level.NumSectors()*Level.NumSectors() + 7) / 8;
Level.Reject = NULL;
@ -705,7 +705,7 @@ void FProcessor::Write (FWadWriter &out)
if (lump >= 0)
{
ReadLump<BYTE> (Wad, lump, Level.Reject, Level.RejectSize);
ReadLump<uint8_t> (Wad, lump, Level.Reject, Level.RejectSize);
if (Level.RejectSize != (Level.NumOrgSectors*Level.NumOrgSectors + 7) / 8)
{
// If the reject is the wrong size, don't use it.
@ -720,7 +720,7 @@ void FProcessor::Write (FWadWriter &out)
else if (Level.NumOrgSectors != Level.NumSectors())
{
// Some sectors have been removed, so fix the reject.
BYTE *newreject = FixReject (Level.Reject);
uint8_t *newreject = FixReject (Level.Reject);
delete[] Level.Reject;
Level.Reject = newreject;
Level.RejectSize = (Level.NumSectors() * Level.NumSectors() + 7) / 8;
@ -733,7 +733,7 @@ void FProcessor::Write (FWadWriter &out)
break;
case ERM_CreateZeroes:
Level.Reject = new BYTE[Level.RejectSize];
Level.Reject = new uint8_t[Level.RejectSize];
memset (Level.Reject, 0, Level.RejectSize);
break;
}
@ -848,11 +848,11 @@ void FProcessor::Write (FWadWriter &out)
}
//
BYTE *FProcessor::FixReject (const BYTE *oldreject)
uint8_t *FProcessor::FixReject (const uint8_t *oldreject)
{
int x, y, ox, oy, pnum, opnum;
int rejectSize = (Level.NumSectors()*Level.NumSectors() + 7) / 8;
BYTE *newreject = new BYTE[rejectSize];
uint8_t *newreject = new uint8_t[rejectSize];
memset (newreject, 0, rejectSize);
@ -886,12 +886,12 @@ MapNodeEx *FProcessor::NodesToEx (const MapNode *nodes, int count)
for (x = 0; x < count; ++x)
{
WORD child;
uint16_t child;
int i;
for (i = 0; i < 4+2*4; ++i)
{
*((WORD *)&Nodes[x] + i) = LittleShort(*((WORD *)&nodes[x] + i));
*((uint16_t *)&Nodes[x] + i) = LittleShort(*((uint16_t *)&nodes[x] + i));
}
for (i = 0; i < 2; ++i)
{
@ -986,11 +986,11 @@ void FProcessor::WriteLines (FWadWriter &out)
Lines[i].args[2] = Level.Lines[i].args[2];
Lines[i].args[3] = Level.Lines[i].args[3];
Lines[i].args[4] = Level.Lines[i].args[4];
Lines[i].v1 = LittleShort(WORD(Level.Lines[i].v1));
Lines[i].v2 = LittleShort(WORD(Level.Lines[i].v2));
Lines[i].flags = LittleShort(WORD(Level.Lines[i].flags));
Lines[i].sidenum[0] = LittleShort(WORD(Level.Lines[i].sidenum[0]));
Lines[i].sidenum[1] = LittleShort(WORD(Level.Lines[i].sidenum[1]));
Lines[i].v1 = LittleShort(uint16_t(Level.Lines[i].v1));
Lines[i].v2 = LittleShort(uint16_t(Level.Lines[i].v2));
Lines[i].flags = LittleShort(uint16_t(Level.Lines[i].flags));
Lines[i].sidenum[0] = LittleShort(uint16_t(Level.Lines[i].sidenum[0]));
Lines[i].sidenum[1] = LittleShort(uint16_t(Level.Lines[i].sidenum[1]));
}
out.WriteLump ("LINEDEFS", Lines, Level.NumLines()*sizeof(*Lines));
delete[] Lines;
@ -1001,13 +1001,13 @@ void FProcessor::WriteLines (FWadWriter &out)
for (i = 0; i < Level.NumLines(); ++i)
{
ld[i].v1 = LittleShort(WORD(Level.Lines[i].v1));
ld[i].v2 = LittleShort(WORD(Level.Lines[i].v2));
ld[i].flags = LittleShort(WORD(Level.Lines[i].flags));
ld[i].sidenum[0] = LittleShort(WORD(Level.Lines[i].sidenum[0]));
ld[i].sidenum[1] = LittleShort(WORD(Level.Lines[i].sidenum[1]));
ld[i].special = LittleShort(WORD(Level.Lines[i].args[0]));
ld[i].tag = LittleShort(WORD(Level.Lines[i].args[1]));
ld[i].v1 = LittleShort(uint16_t(Level.Lines[i].v1));
ld[i].v2 = LittleShort(uint16_t(Level.Lines[i].v2));
ld[i].flags = LittleShort(uint16_t(Level.Lines[i].flags));
ld[i].sidenum[0] = LittleShort(uint16_t(Level.Lines[i].sidenum[0]));
ld[i].sidenum[1] = LittleShort(uint16_t(Level.Lines[i].sidenum[1]));
ld[i].special = LittleShort(uint16_t(Level.Lines[i].args[0]));
ld[i].tag = LittleShort(uint16_t(Level.Lines[i].args[1]));
}
out.WriteLump ("LINEDEFS", ld, Level.NumLines()*sizeof(*ld));
delete[] ld;
@ -1056,8 +1056,8 @@ void FProcessor::WriteSegs (FWadWriter &out)
for (i = 0; i < Level.NumSegs; ++i)
{
segdata[i].v1 = LittleShort(WORD(Level.Segs[i].v1));
segdata[i].v2 = LittleShort(WORD(Level.Segs[i].v2));
segdata[i].v1 = LittleShort(uint16_t(Level.Segs[i].v1));
segdata[i].v2 = LittleShort(uint16_t(Level.Segs[i].v2));
segdata[i].angle = LittleShort(Level.Segs[i].angle);
segdata[i].linedef = LittleShort(Level.Segs[i].linedef);
segdata[i].side = LittleShort(Level.Segs[i].side);
@ -1089,8 +1089,8 @@ void FProcessor::WriteSSectors2 (FWadWriter &out, const char *name, const MapSub
for (i = 0; i < count; ++i)
{
ssec[i].firstline = LittleShort((WORD)subs[i].firstline);
ssec[i].numlines = LittleShort((WORD)subs[i].numlines);
ssec[i].firstline = LittleShort((uint16_t)subs[i].firstline);
ssec[i].numlines = LittleShort((uint16_t)subs[i].numlines);
}
out.WriteLump (name, ssec, sizeof(*ssec)*count);
delete[] ssec;
@ -1144,14 +1144,14 @@ void FProcessor::WriteNodes2 (FWadWriter &out, const char *name, const MapNodeEx
nodes += j;
for (j = 0; j < 2; ++j)
{
DWORD child = zaNodes[i].children[j];
uint32_t child = zaNodes[i].children[j];
if (child & NFX_SUBSECTOR)
{
*nodes++ = LittleShort(WORD(child - (NFX_SUBSECTOR + NF_SUBSECTOR)));
*nodes++ = LittleShort(uint16_t(child - (NFX_SUBSECTOR + NF_SUBSECTOR)));
}
else
{
*nodes++ = LittleShort((WORD)child);
*nodes++ = LittleShort((uint16_t)child);
}
}
}
@ -1199,7 +1199,7 @@ void FProcessor::WriteBlockmap (FWadWriter &out)
}
size_t i, count;
WORD *blocks;
uint16_t *blocks;
count = Level.BlockmapSize;
blocks = Level.Blockmap;
@ -1289,25 +1289,25 @@ void FProcessor::WriteGLSegs (FWadWriter &out, bool v5)
for (i = 0; i < count; ++i)
{
if (Level.GLSegs[i].v1 < (DWORD)Level.NumOrgVerts)
if (Level.GLSegs[i].v1 < (uint32_t)Level.NumOrgVerts)
{
segdata[i].v1 = LittleShort((WORD)Level.GLSegs[i].v1);
segdata[i].v1 = LittleShort((uint16_t)Level.GLSegs[i].v1);
}
else
{
segdata[i].v1 = LittleShort(0x8000 | (WORD)(Level.GLSegs[i].v1 - Level.NumOrgVerts));
segdata[i].v1 = LittleShort(0x8000 | (uint16_t)(Level.GLSegs[i].v1 - Level.NumOrgVerts));
}
if (Level.GLSegs[i].v2 < (DWORD)Level.NumOrgVerts)
if (Level.GLSegs[i].v2 < (uint32_t)Level.NumOrgVerts)
{
segdata[i].v2 = (WORD)LittleShort(Level.GLSegs[i].v2);
segdata[i].v2 = (uint16_t)LittleShort(Level.GLSegs[i].v2);
}
else
{
segdata[i].v2 = LittleShort(0x8000 | (WORD)(Level.GLSegs[i].v2 - Level.NumOrgVerts));
segdata[i].v2 = LittleShort(0x8000 | (uint16_t)(Level.GLSegs[i].v2 - Level.NumOrgVerts));
}
segdata[i].linedef = LittleShort((WORD)Level.GLSegs[i].linedef);
segdata[i].linedef = LittleShort((uint16_t)Level.GLSegs[i].linedef);
segdata[i].side = LittleShort(Level.GLSegs[i].side);
segdata[i].partner = LittleShort((WORD)Level.GLSegs[i].partner);
segdata[i].partner = LittleShort((uint16_t)Level.GLSegs[i].partner);
}
out.WriteLump ("GL_SEGS", segdata, sizeof(MapSegGL)*count);
delete[] segdata;
@ -1332,7 +1332,7 @@ void FProcessor::WriteGLSegs5 (FWadWriter &out)
for (i = 0; i < count; ++i)
{
if (Level.GLSegs[i].v1 < (DWORD)Level.NumOrgVerts)
if (Level.GLSegs[i].v1 < (uint32_t)Level.NumOrgVerts)
{
segdata[i].v1 = LittleLong(Level.GLSegs[i].v1);
}
@ -1340,7 +1340,7 @@ void FProcessor::WriteGLSegs5 (FWadWriter &out)
{
segdata[i].v1 = LittleLong(0x80000000u | ((int)Level.GLSegs[i].v1 - Level.NumOrgVerts));
}
if (Level.GLSegs[i].v2 < (DWORD)Level.NumOrgVerts)
if (Level.GLSegs[i].v2 < (uint32_t)Level.NumOrgVerts)
{
segdata[i].v2 = LittleLong(Level.GLSegs[i].v2);
}
@ -1432,7 +1432,7 @@ void FProcessor::WriteGLBSPZ (FWadWriter &out, const char *label)
void FProcessor::WriteVerticesZ (ZLibOut &out, const WideVertex *verts, int orgverts, int newverts)
{
out << (DWORD)orgverts << (DWORD)newverts;
out << (uint32_t)orgverts << (uint32_t)newverts;
for (int i = 0; i < newverts; ++i)
{
@ -1442,82 +1442,82 @@ void FProcessor::WriteVerticesZ (ZLibOut &out, const WideVertex *verts, int orgv
void FProcessor::WriteSubsectorsZ (ZLibOut &out, const MapSubsectorEx *subs, int numsubs)
{
out << (DWORD)numsubs;
out << (uint32_t)numsubs;
for (int i = 0; i < numsubs; ++i)
{
out << (DWORD)subs[i].numlines;
out << (uint32_t)subs[i].numlines;
}
}
void FProcessor::WriteSegsZ (ZLibOut &out, const MapSegEx *segs, int numsegs)
{
out << (DWORD)numsegs;
out << (uint32_t)numsegs;
for (int i = 0; i < numsegs; ++i)
{
out << (DWORD)segs[i].v1
<< (DWORD)segs[i].v2
<< (WORD)segs[i].linedef
<< (BYTE)segs[i].side;
out << (uint32_t)segs[i].v1
<< (uint32_t)segs[i].v2
<< (uint16_t)segs[i].linedef
<< (uint8_t)segs[i].side;
}
}
void FProcessor::WriteGLSegsZ (ZLibOut &out, const MapSegGLEx *segs, int numsegs, int nodever)
{
out << (DWORD)numsegs;
out << (uint32_t)numsegs;
if (nodever < 2)
{
for (int i = 0; i < numsegs; ++i)
{
out << (DWORD)segs[i].v1
<< (DWORD)segs[i].partner
<< (WORD)segs[i].linedef
<< (BYTE)segs[i].side;
out << (uint32_t)segs[i].v1
<< (uint32_t)segs[i].partner
<< (uint16_t)segs[i].linedef
<< (uint8_t)segs[i].side;
}
}
else
{
for (int i = 0; i < numsegs; ++i)
{
out << (DWORD)segs[i].v1
<< (DWORD)segs[i].partner
<< (DWORD)segs[i].linedef
<< (BYTE)segs[i].side;
out << (uint32_t)segs[i].v1
<< (uint32_t)segs[i].partner
<< (uint32_t)segs[i].linedef
<< (uint8_t)segs[i].side;
}
}
}
void FProcessor::WriteNodesZ (ZLibOut &out, const MapNodeEx *nodes, int numnodes, int nodever)
{
out << (DWORD)numnodes;
out << (uint32_t)numnodes;
for (int i = 0; i < numnodes; ++i)
{
if (nodever < 3)
{
out << (SWORD)(nodes[i].x >> 16)
<< (SWORD)(nodes[i].y >> 16)
<< (SWORD)(nodes[i].dx >> 16)
<< (SWORD)(nodes[i].dy >> 16);
out << (int16_t)(nodes[i].x >> 16)
<< (int16_t)(nodes[i].y >> 16)
<< (int16_t)(nodes[i].dx >> 16)
<< (int16_t)(nodes[i].dy >> 16);
}
else
{
out << (DWORD)nodes[i].x
<< (DWORD)nodes[i].y
<< (DWORD)nodes[i].dx
<< (DWORD)nodes[i].dy;
out << (uint32_t)nodes[i].x
<< (uint32_t)nodes[i].y
<< (uint32_t)nodes[i].dx
<< (uint32_t)nodes[i].dy;
}
for (int j = 0; j < 2; ++j)
{
for (int k = 0; k < 4; ++k)
{
out << (SWORD)nodes[i].bbox[j][k];
out << (int16_t)nodes[i].bbox[j][k];
}
}
out << (DWORD)nodes[i].children[0]
<< (DWORD)nodes[i].children[1];
out << (uint32_t)nodes[i].children[0]
<< (uint32_t)nodes[i].children[1];
}
}
@ -1570,7 +1570,7 @@ void FProcessor::WriteGLBSPX (FWadWriter &out, const char *label)
void FProcessor::WriteVerticesX (FWadWriter &out, const WideVertex *verts, int orgverts, int newverts)
{
out << (DWORD)orgverts << (DWORD)newverts;
out << (uint32_t)orgverts << (uint32_t)newverts;
for (int i = 0; i < newverts; ++i)
{
@ -1580,82 +1580,82 @@ void FProcessor::WriteVerticesX (FWadWriter &out, const WideVertex *verts, int o
void FProcessor::WriteSubsectorsX (FWadWriter &out, const MapSubsectorEx *subs, int numsubs)
{
out << (DWORD)numsubs;
out << (uint32_t)numsubs;
for (int i = 0; i < numsubs; ++i)
{
out << (DWORD)subs[i].numlines;
out << (uint32_t)subs[i].numlines;
}
}
void FProcessor::WriteSegsX (FWadWriter &out, const MapSegEx *segs, int numsegs)
{
out << (DWORD)numsegs;
out << (uint32_t)numsegs;
for (int i = 0; i < numsegs; ++i)
{
out << (DWORD)segs[i].v1
<< (DWORD)segs[i].v2
<< (WORD)segs[i].linedef
<< (BYTE)segs[i].side;
out << (uint32_t)segs[i].v1
<< (uint32_t)segs[i].v2
<< (uint16_t)segs[i].linedef
<< (uint8_t)segs[i].side;
}
}
void FProcessor::WriteGLSegsX (FWadWriter &out, const MapSegGLEx *segs, int numsegs, int nodever)
{
out << (DWORD)numsegs;
out << (uint32_t)numsegs;
if (nodever < 2)
{
for (int i = 0; i < numsegs; ++i)
{
out << (DWORD)segs[i].v1
<< (DWORD)segs[i].partner
<< (WORD)segs[i].linedef
<< (BYTE)segs[i].side;
out << (uint32_t)segs[i].v1
<< (uint32_t)segs[i].partner
<< (uint16_t)segs[i].linedef
<< (uint8_t)segs[i].side;
}
}
else
{
for (int i = 0; i < numsegs; ++i)
{
out << (DWORD)segs[i].v1
<< (DWORD)segs[i].partner
<< (DWORD)segs[i].linedef
<< (BYTE)segs[i].side;
out << (uint32_t)segs[i].v1
<< (uint32_t)segs[i].partner
<< (uint32_t)segs[i].linedef
<< (uint8_t)segs[i].side;
}
}
}
void FProcessor::WriteNodesX (FWadWriter &out, const MapNodeEx *nodes, int numnodes, int nodever)
{
out << (DWORD)numnodes;
out << (uint32_t)numnodes;
for (int i = 0; i < numnodes; ++i)
{
if (nodever < 3)
{
out << (SWORD)(nodes[i].x >> 16)
<< (SWORD)(nodes[i].y >> 16)
<< (SWORD)(nodes[i].dx >> 16)
<< (SWORD)(nodes[i].dy >> 16);
out << (int16_t)(nodes[i].x >> 16)
<< (int16_t)(nodes[i].y >> 16)
<< (int16_t)(nodes[i].dx >> 16)
<< (int16_t)(nodes[i].dy >> 16);
}
else
{
out << (DWORD)nodes[i].x
<< (DWORD)nodes[i].y
<< (DWORD)nodes[i].dx
<< (DWORD)nodes[i].dy;
out << (uint32_t)nodes[i].x
<< (uint32_t)nodes[i].y
<< (uint32_t)nodes[i].dx
<< (uint32_t)nodes[i].dy;
}
for (int j = 0; j < 2; ++j)
{
for (int k = 0; k < 4; ++k)
{
out << (SWORD)nodes[i].bbox[j][k];
out << (int16_t)nodes[i].bbox[j][k];
}
}
out << (DWORD)nodes[i].children[0]
<< (DWORD)nodes[i].children[1];
out << (uint32_t)nodes[i].children[0]
<< (uint32_t)nodes[i].children[1];
}
}
@ -1719,7 +1719,7 @@ ZLibOut::~ZLibOut ()
Out.AddToLump (Buffer, BUFFER_SIZE - Stream.avail_out);
}
void ZLibOut::Write (BYTE *data, int len)
void ZLibOut::Write (uint8_t *data, int len)
{
int err;
@ -1742,36 +1742,36 @@ void ZLibOut::Write (BYTE *data, int len)
}
}
ZLibOut &ZLibOut::operator << (BYTE val)
ZLibOut &ZLibOut::operator << (uint8_t val)
{
Write (&val, 1);
return *this;
}
ZLibOut &ZLibOut::operator << (WORD val)
ZLibOut &ZLibOut::operator << (uint16_t val)
{
val = LittleShort(val);
Write ((BYTE *)&val, 2);
Write ((uint8_t *)&val, 2);
return *this;
}
ZLibOut &ZLibOut::operator << (SWORD val)
ZLibOut &ZLibOut::operator << (int16_t val)
{
val = LittleShort(val);
Write ((BYTE *)&val, 2);
Write ((uint8_t *)&val, 2);
return *this;
}
ZLibOut &ZLibOut::operator << (DWORD val)
ZLibOut &ZLibOut::operator << (uint32_t val)
{
val = LittleLong(val);
Write ((BYTE *)&val, 4);
Write ((uint8_t *)&val, 4);
return *this;
}
ZLibOut &ZLibOut::operator << (fixed_t val)
{
val = LittleLong(val);
Write ((BYTE *)&val, 4);
Write ((uint8_t *)&val, 4);
return *this;
}

14
src/level/level.h
View file

@ -16,18 +16,18 @@ public:
ZLibOut(FWadWriter &out);
~ZLibOut();
ZLibOut &operator << (BYTE);
ZLibOut &operator << (WORD);
ZLibOut &operator << (SWORD);
ZLibOut &operator << (DWORD);
ZLibOut &operator << (uint8_t);
ZLibOut &operator << (uint16_t);
ZLibOut &operator << (int16_t);
ZLibOut &operator << (uint32_t);
ZLibOut &operator << (fixed_t);
void Write(BYTE *data, int len);
void Write(uint8_t *data, int len);
private:
enum { BUFFER_SIZE = 8192 };
z_stream Stream;
BYTE Buffer[BUFFER_SIZE];
uint8_t Buffer[BUFFER_SIZE];
FWadWriter &Out;
};
@ -54,7 +54,7 @@ private:
MapSubsectorEx *SubsectorsToEx(const MapSubsector *ssec, int count);
MapSegGLEx *SegGLsToEx(const MapSegGL *segs, int count);
BYTE *FixReject(const BYTE *oldreject);
uint8_t *FixReject(const uint8_t *oldreject);
bool CheckForFracSplitters(const MapNodeEx *nodes, int count);
void WriteLines(FWadWriter &out);

4
src/level/workdata.h
View file

@ -17,6 +17,6 @@ struct node_t
struct subsector_t
{
DWORD numlines;
DWORD firstline;
uint32_t numlines;
uint32_t firstline;
};

56
src/nodebuilder/nodebuild.cpp
View file

@ -73,11 +73,11 @@ void FNodeBuilder::BuildTree ()
fprintf (stderr, " BSP: 100.0%%\n");
}
DWORD FNodeBuilder::CreateNode (DWORD set, unsigned int count, fixed_t bbox[4])
uint32_t FNodeBuilder::CreateNode (uint32_t set, unsigned int count, fixed_t bbox[4])
{
node_t node;
int skip, selstat;
DWORD splitseg;
uint32_t splitseg;
// When building GL nodes, count may not be an exact count of the number of segs
// in this set. That's okay, because we just use it to get a skip count, so an
@ -91,7 +91,7 @@ DWORD FNodeBuilder::CreateNode (DWORD set, unsigned int count, fixed_t bbox[4])
CheckSubsector (set, node, splitseg))
{
// Create a normal node
DWORD set1, set2;
uint32_t set1, set2;
unsigned int count1, count2;
SplitSegs (set, node, splitseg, set1, set2, count1, count2);
@ -112,7 +112,7 @@ DWORD FNodeBuilder::CreateNode (DWORD set, unsigned int count, fixed_t bbox[4])
}
}
DWORD FNodeBuilder::CreateSubsector (DWORD set, fixed_t bbox[4])
uint32_t FNodeBuilder::CreateSubsector (uint32_t set, fixed_t bbox[4])
{
int ssnum, count;
@ -125,7 +125,7 @@ DWORD FNodeBuilder::CreateSubsector (DWORD set, fixed_t bbox[4])
#if defined(_DEBUG)// || 1
// Check for segs with duplicate start/end vertices
DWORD s1, s2;
uint32_t s1, s2;
for (s1 = set; s1 != DWORD_MAX; s1 = Segs[s1].next)
{
@ -181,9 +181,9 @@ void FNodeBuilder::CreateSubsectorsForReal ()
for (i = 0; i < SubsectorSets.Size(); ++i)
{
subsector_t sub;
DWORD set = SubsectorSets[i];
uint32_t set = SubsectorSets[i];
sub.firstline = (DWORD)SegList.Size();
sub.firstline = (uint32_t)SegList.Size();
while (set != DWORD_MAX)
{
USegPtr ptr;
@ -192,7 +192,7 @@ void FNodeBuilder::CreateSubsectorsForReal ()
SegList.Push (ptr);
set = ptr.SegPtr->next;
}
sub.numlines = (DWORD)(SegList.Size() - sub.firstline);
sub.numlines = (uint32_t)(SegList.Size() - sub.firstline);
// Sort segs by linedef for special effects
qsort (&SegList[sub.firstline], sub.numlines, sizeof(USegPtr), SortSegs);
@ -215,7 +215,7 @@ void FNodeBuilder::CreateSubsectorsForReal ()
Vertices[SegList[i].SegPtr->v2].y>>16,
Vertices[SegList[i].SegPtr->v1].x, Vertices[SegList[i].SegPtr->v1].y,
Vertices[SegList[i].SegPtr->v2].x, Vertices[SegList[i].SegPtr->v2].y));
SegList[i].SegNum = DWORD(SegList[i].SegPtr - &Segs[0]);
SegList[i].SegNum = uint32_t(SegList[i].SegPtr - &Segs[0]);
}
Subsectors.Push (sub);
}
@ -286,10 +286,10 @@ int STACK_ARGS FNodeBuilder::SortSegs (const void *a, const void *b)
// a splitter is synthesized, and true is returned to continue processing
// down this branch of the tree.
bool FNodeBuilder::CheckSubsector (DWORD set, node_t &node, DWORD &splitseg)
bool FNodeBuilder::CheckSubsector (uint32_t set, node_t &node, uint32_t &splitseg)
{
int sec;
DWORD seg;
uint32_t seg;
sec = -1;
seg = set;
@ -347,10 +347,10 @@ bool FNodeBuilder::CheckSubsector (DWORD set, node_t &node, DWORD &splitseg)
// When creating GL nodes, we need to check for segs with the same start and
// end vertices and split them into two subsectors.
bool FNodeBuilder::CheckSubsectorOverlappingSegs (DWORD set, node_t &node, DWORD &splitseg)
bool FNodeBuilder::CheckSubsectorOverlappingSegs (uint32_t set, node_t &node, uint32_t &splitseg)
{
int v1, v2;
DWORD seg1, seg2;
uint32_t seg1, seg2;
for (seg1 = set; seg1 != DWORD_MAX; seg1 = Segs[seg1].next)
{
@ -390,7 +390,7 @@ bool FNodeBuilder::CheckSubsectorOverlappingSegs (DWORD set, node_t &node, DWORD
// seg in front of the splitter is partnered with a new miniseg on
// the back so that the back will have two segs.
bool FNodeBuilder::ShoveSegBehind (DWORD set, node_t &node, DWORD seg, DWORD mate)
bool FNodeBuilder::ShoveSegBehind (uint32_t set, node_t &node, uint32_t seg, uint32_t mate)
{
SetNodeFromSeg (node, &Segs[seg]);
HackSeg = seg;
@ -412,12 +412,12 @@ bool FNodeBuilder::ShoveSegBehind (DWORD set, node_t &node, DWORD seg, DWORD mat
// each unique plane needs to be considered as a splitter. A result of 0 means
// this set is a convex region. A result of -1 means that there were possible
// splitters, but they all split segs we want to keep intact.
int FNodeBuilder::SelectSplitter (DWORD set, node_t &node, DWORD &splitseg, int step, bool nosplit)
int FNodeBuilder::SelectSplitter (uint32_t set, node_t &node, uint32_t &splitseg, int step, bool nosplit)
{
int stepleft;
int bestvalue;
DWORD bestseg;
DWORD seg;
uint32_t bestseg;
uint32_t seg;
bool nosplitters = false;
bestvalue = 0;
@ -494,7 +494,7 @@ int FNodeBuilder::SelectSplitter (DWORD set, node_t &node, DWORD &splitseg, int
// true. A score of 0 means that the splitter does not split any of the segs
// in the set.
int FNodeBuilder::Heuristic (node_t &node, DWORD set, bool honorNoSplit)
int FNodeBuilder::Heuristic (node_t &node, uint32_t set, bool honorNoSplit)
{
// Set the initial score above 0 so that near vertex anti-weighting is less likely to produce a negative score.
int score = 1000000;
@ -502,7 +502,7 @@ int FNodeBuilder::Heuristic (node_t &node, DWORD set, bool honorNoSplit)
int counts[2] = { 0, 0 };
int realSegs[2] = { 0, 0 };
int specialSegs[2] = { 0, 0 };
DWORD i = set;
uint32_t i = set;
int sidev[2];
int side;
bool splitter = false;
@ -733,7 +733,7 @@ int FNodeBuilder::Heuristic (node_t &node, DWORD set, bool honorNoSplit)
return score;
}
void FNodeBuilder::SplitSegs (DWORD set, node_t &node, DWORD splitseg, DWORD &outset0, DWORD &outset1, unsigned int &count0, unsigned int &count1)
void FNodeBuilder::SplitSegs (uint32_t set, node_t &node, uint32_t splitseg, uint32_t &outset0, uint32_t &outset1, unsigned int &count0, unsigned int &count1)
{
unsigned int _count0 = 0;
unsigned int _count1 = 0;
@ -865,7 +865,7 @@ void FNodeBuilder::SplitSegs (DWORD set, node_t &node, DWORD splitseg, DWORD &ou
}
if (hack && GLNodes)
{
DWORD newback, newfront;
uint32_t newback, newfront;
newback = AddMiniseg (seg->v2, seg->v1, DWORD_MAX, set, splitseg);
if (HackMate == DWORD_MAX)
@ -917,7 +917,7 @@ void FNodeBuilder::SetNodeFromSeg (node_t &node, const FPrivSeg *pseg) const
}
}
DWORD FNodeBuilder::SplitSeg (DWORD segnum, int splitvert, int v1InFront)
uint32_t FNodeBuilder::SplitSeg (uint32_t segnum, int splitvert, int v1InFront)
{
double dx, dy;
FPrivSeg newseg;
@ -970,7 +970,7 @@ DWORD FNodeBuilder::SplitSeg (DWORD segnum, int splitvert, int v1InFront)
return newnum;
}
void FNodeBuilder::RemoveSegFromVert1 (DWORD segnum, int vertnum)
void FNodeBuilder::RemoveSegFromVert1 (uint32_t segnum, int vertnum)
{
FPrivVert *v = &Vertices[vertnum];
@ -980,7 +980,7 @@ void FNodeBuilder::RemoveSegFromVert1 (DWORD segnum, int vertnum)
}
else
{
DWORD prev, curr;
uint32_t prev, curr;
prev = 0;
curr = v->segs;
while (curr != DWORD_MAX && curr != segnum)
@ -995,7 +995,7 @@ void FNodeBuilder::RemoveSegFromVert1 (DWORD segnum, int vertnum)
}
}
void FNodeBuilder::RemoveSegFromVert2 (DWORD segnum, int vertnum)
void FNodeBuilder::RemoveSegFromVert2 (uint32_t segnum, int vertnum)
{
FPrivVert *v = &Vertices[vertnum];
@ -1005,7 +1005,7 @@ void FNodeBuilder::RemoveSegFromVert2 (DWORD segnum, int vertnum)
}
else
{
DWORD prev, curr;
uint32_t prev, curr;
prev = 0;
curr = v->segs2;
while (curr != DWORD_MAX && curr != segnum)
@ -1041,7 +1041,7 @@ double FNodeBuilder::InterceptVector (const node_t &splitter, const FPrivSeg &se
return num / den;
}
void FNodeBuilder::PrintSet (int l, DWORD set)
void FNodeBuilder::PrintSet (int l, uint32_t set)
{
Printf ("set %d:\n", l);
for (; set != DWORD_MAX; set = Segs[set].next)
@ -1078,7 +1078,7 @@ int ClassifyLineBackpatchC (node_t &node, const FSimpleVert *v1, const FSimpleVe
int *calleroffset;
int diff;
int (*func)(node_t &, const FSimpleVert *, const FSimpleVert *, int[2]);
DWORD oldprotect;
uint32_t oldprotect;
#ifdef __GNUC__
calleroffset = (int *)__builtin_return_address(0);

66
src/nodebuilder/nodebuild.h
View file

@ -9,7 +9,7 @@
struct FEventInfo
{
int Vertex;
DWORD FrontSeg;
uint32_t FrontSeg;
};
struct FEvent
@ -74,16 +74,16 @@ class FNodeBuilder
struct FPrivSeg
{
int v1, v2;
DWORD sidedef;
uint32_t sidedef;
int linedef;
int frontsector;
int backsector;
DWORD next;
DWORD nextforvert;
DWORD nextforvert2;
uint32_t next;
uint32_t nextforvert;
uint32_t nextforvert2;
int loopnum; // loop number for split avoidance (0 means splitting is okay)
DWORD partner; // seg on back side
DWORD storedseg; // seg # in the GL_SEGS lump
uint32_t partner; // seg on back side
uint32_t storedseg; // seg # in the GL_SEGS lump
angle_t angle;
fixed_t offset;
@ -93,8 +93,8 @@ class FNodeBuilder
};
struct FPrivVert : FSimpleVert
{
DWORD segs; // segs that use this vertex as v1
DWORD segs2; // segs that use this vertex as v2
uint32_t segs; // segs that use this vertex as v1
uint32_t segs2; // segs that use this vertex as v2
int index;
int pad; // This structure must be 8-byte aligned.
@ -109,13 +109,13 @@ class FNodeBuilder
};
union USegPtr
{
DWORD SegNum;
uint32_t SegNum;
FPrivSeg *SegPtr;
};
struct FSplitSharer
{
double Distance;
DWORD Seg;
uint32_t Seg;
bool Forward;
};
@ -185,11 +185,11 @@ private:
TArray<node_t> Nodes;
TArray<subsector_t> Subsectors;
TArray<DWORD> SubsectorSets;
TArray<uint32_t> SubsectorSets;
TArray<FPrivSeg> Segs;
TArray<FPrivVert> Vertices;
TArray<USegPtr> SegList;
TArray<BYTE> PlaneChecked;
TArray<uint8_t> PlaneChecked;
TArray<FSimpleLine> Planes;
size_t InitialVertices; // Number of vertices in a map that are connected to linedefs
@ -198,8 +198,8 @@ private:
FEventTree Events; // Vertices intersected by the current splitter
TArray<FSplitSharer> SplitSharers; // Segs collinear with the current splitter
DWORD HackSeg; // Seg to force to back of splitter
DWORD HackMate; // Seg to use in front of hack seg
uint32_t HackSeg; // Seg to force to back of splitter
uint32_t HackMate; // Seg to use in front of hack seg
FLevel &Level;
bool GLNodes;
@ -214,18 +214,18 @@ private:
void GroupSegPlanes ();
void FindPolyContainers (TArray<FPolyStart> &spots, TArray<FPolyStart> &anchors);
bool GetPolyExtents (int polynum, fixed_t bbox[4]);
int MarkLoop (DWORD firstseg, int loopnum);
int MarkLoop (uint32_t firstseg, int loopnum);
void AddSegToBBox (fixed_t bbox[4], const FPrivSeg *seg);
DWORD CreateNode (DWORD set, unsigned int count, fixed_t bbox[4]);
DWORD CreateSubsector (DWORD set, fixed_t bbox[4]);
uint32_t CreateNode (uint32_t set, unsigned int count, fixed_t bbox[4]);
uint32_t CreateSubsector (uint32_t set, fixed_t bbox[4]);
void CreateSubsectorsForReal ();
bool CheckSubsector (DWORD set, node_t &node, DWORD &splitseg);
bool CheckSubsectorOverlappingSegs (DWORD set, node_t &node, DWORD &splitseg);
bool ShoveSegBehind (DWORD set, node_t &node, DWORD seg, DWORD mate);
int SelectSplitter (DWORD set, node_t &node, DWORD &splitseg, int step, bool nosplit);
void SplitSegs (DWORD set, node_t &node, DWORD splitseg, DWORD &outset0, DWORD &outset1, unsigned int &count0, unsigned int &count1);
DWORD SplitSeg (DWORD segnum, int splitvert, int v1InFront);
int Heuristic (node_t &node, DWORD set, bool honorNoSplit);
bool CheckSubsector (uint32_t set, node_t &node, uint32_t &splitseg);
bool CheckSubsectorOverlappingSegs (uint32_t set, node_t &node, uint32_t &splitseg);
bool ShoveSegBehind (uint32_t set, node_t &node, uint32_t seg, uint32_t mate);
int SelectSplitter (uint32_t set, node_t &node, uint32_t &splitseg, int step, bool nosplit);
void SplitSegs (uint32_t set, node_t &node, uint32_t splitseg, uint32_t &outset0, uint32_t &outset1, unsigned int &count0, unsigned int &count1);
uint32_t SplitSeg (uint32_t segnum, int splitvert, int v1InFront);
int Heuristic (node_t &node, uint32_t set, bool honorNoSplit);
// Returns:
// 0 = seg is in front
@ -236,19 +236,19 @@ private:
void FixSplitSharers ();
double AddIntersection (const node_t &node, int vertex);
void AddMinisegs (const node_t &node, DWORD splitseg, DWORD &fset, DWORD &rset);
DWORD CheckLoopStart (fixed_t dx, fixed_t dy, int vertex1, int vertex2);
DWORD CheckLoopEnd (fixed_t dx, fixed_t dy, int vertex2);
void RemoveSegFromVert1 (DWORD segnum, int vertnum);
void RemoveSegFromVert2 (DWORD segnum, int vertnum);
DWORD AddMiniseg (int v1, int v2, DWORD partner, DWORD seg1, DWORD splitseg);
void AddMinisegs (const node_t &node, uint32_t splitseg, uint32_t &fset, uint32_t &rset);
uint32_t CheckLoopStart (fixed_t dx, fixed_t dy, int vertex1, int vertex2);
uint32_t CheckLoopEnd (fixed_t dx, fixed_t dy, int vertex2);
void RemoveSegFromVert1 (uint32_t segnum, int vertnum);
void RemoveSegFromVert2 (uint32_t segnum, int vertnum);
uint32_t AddMiniseg (int v1, int v2, uint32_t partner, uint32_t seg1, uint32_t splitseg);
void SetNodeFromSeg (node_t &node, const FPrivSeg *pseg) const;
int RemoveMinisegs (MapNodeEx *nodes, TArray<MapSegEx> &segs, MapSubsectorEx *subs, int node, short bbox[4]);
int StripMinisegs (TArray<MapSegEx> &segs, int subsector, short bbox[4]);
void AddSegToShortBBox (short bbox[4], const FPrivSeg *seg);
int CloseSubsector (TArray<MapSegGLEx> &segs, int subsector);
DWORD PushGLSeg (TArray<MapSegGLEx> &segs, const FPrivSeg *seg);
uint32_t PushGLSeg (TArray<MapSegGLEx> &segs, const FPrivSeg *seg);
void PushConnectingGLSeg (int subsector, TArray<MapSegGLEx> &segs, int v1, int v2);
int OutputDegenerateSubsector (TArray<MapSegGLEx> &segs, int subsector, bool bForward, double lastdot, FPrivSeg *&prev);
@ -256,7 +256,7 @@ private:
double InterceptVector (const node_t &splitter, const FPrivSeg &seg);
void PrintSet (int l, DWORD set);
void PrintSet (int l, uint32_t set);
void DumpNodes(MapNodeEx *outNodes, int nodeCount);
};

2
src/nodebuilder/nodebuild_extract.cpp
View file

@ -317,7 +317,7 @@ int FNodeBuilder::OutputDegenerateSubsector (TArray<MapSegGLEx> &segs, int subse
return count;
}
DWORD FNodeBuilder::PushGLSeg (TArray<MapSegGLEx> &segs, const FPrivSeg *seg)
uint32_t FNodeBuilder::PushGLSeg (TArray<MapSegGLEx> &segs, const FPrivSeg *seg)
{
MapSegGLEx newseg;

28
src/nodebuilder/nodebuild_gl.cpp
View file

@ -67,7 +67,7 @@ void FNodeBuilder::FixSplitSharers ()
D(Events.PrintTree());
for (unsigned int i = 0; i < SplitSharers.Size(); ++i)
{
DWORD seg = SplitSharers[i].Seg;
uint32_t seg = SplitSharers[i].Seg;
int v2 = Segs[seg].v2;
FEvent *event = Events.FindEvent (SplitSharers[i].Distance);
FEvent *next;
@ -119,12 +119,12 @@ void FNodeBuilder::FixSplitSharers ()
Vertices[event->Info.Vertex].y>>16,
event->Distance));
DWORD newseg = SplitSeg (seg, event->Info.Vertex, 1);
uint32_t newseg = SplitSeg (seg, event->Info.Vertex, 1);
Segs[newseg].next = Segs[seg].next;
Segs[seg].next = newseg;
DWORD partner = Segs[seg].partner;
uint32_t partner = Segs[seg].partner;
if (partner != DWORD_MAX)
{
int endpartner = SplitSeg (partner, event->Info.Vertex, 1);
@ -159,7 +159,7 @@ void FNodeBuilder::FixSplitSharers ()
}
}
void FNodeBuilder::AddMinisegs (const node_t &node, DWORD splitseg, DWORD &fset, DWORD &bset)
void FNodeBuilder::AddMinisegs (const node_t &node, uint32_t splitseg, uint32_t &fset, uint32_t &bset)
{
FEvent *event = Events.GetMinimum (), *prev = NULL;
@ -167,8 +167,8 @@ void FNodeBuilder::AddMinisegs (const node_t &node, DWORD splitseg, DWORD &fset,
{
if (prev != NULL)
{
DWORD fseg1, bseg1, fseg2, bseg2;
DWORD fnseg, bnseg;
uint32_t fseg1, bseg1, fseg2, bseg2;
uint32_t fnseg, bnseg;
// Minisegs should only be added when they can create valid loops on both the front and
// back of the splitter. This means some subsectors could be unclosed if their sectors
@ -225,9 +225,9 @@ void FNodeBuilder::AddMinisegs (const node_t &node, DWORD splitseg, DWORD &fset,
}
}
DWORD FNodeBuilder::AddMiniseg (int v1, int v2, DWORD partner, DWORD seg1, DWORD splitseg)
uint32_t FNodeBuilder::AddMiniseg (int v1, int v2, uint32_t partner, uint32_t seg1, uint32_t splitseg)
{
DWORD nseg;
uint32_t nseg;
FPrivSeg *seg = &Segs[seg1];
FPrivSeg newseg;
@ -279,13 +279,13 @@ DWORD FNodeBuilder::AddMiniseg (int v1, int v2, DWORD partner, DWORD seg1, DWORD
return nseg;
}
DWORD FNodeBuilder::CheckLoopStart (fixed_t dx, fixed_t dy, int vertex, int vertex2)
uint32_t FNodeBuilder::CheckLoopStart (fixed_t dx, fixed_t dy, int vertex, int vertex2)
{
FPrivVert *v = &Vertices[vertex];
angle_t splitAngle = PointToAngle (dx, dy);
DWORD segnum;
uint32_t segnum;
angle_t bestang;
DWORD bestseg;
uint32_t bestseg;
// Find the seg ending at this vertex that forms the smallest angle
// to the splitter.
@ -338,13 +338,13 @@ DWORD FNodeBuilder::CheckLoopStart (fixed_t dx, fixed_t dy, int vertex, int vert
return bestseg;
}
DWORD FNodeBuilder::CheckLoopEnd (fixed_t dx, fixed_t dy, int vertex)
uint32_t FNodeBuilder::CheckLoopEnd (fixed_t dx, fixed_t dy, int vertex)
{
FPrivVert *v = &Vertices[vertex];
angle_t splitAngle = PointToAngle (dx, dy) + ANGLE_180;
DWORD segnum;
uint32_t segnum;
angle_t bestang;
DWORD bestseg;
uint32_t bestseg;
// Find the seg starting at this vertex that forms the smallest angle
// to the splitter.

10
src/nodebuilder/nodebuild_utility.cpp
View file

@ -108,7 +108,7 @@ void FNodeBuilder::MakeSegsFromSides ()
int FNodeBuilder::CreateSeg (int linenum, int sidenum)
{
FPrivSeg seg;
DWORD backside;
uint32_t backside;
int segnum;
seg.next = DWORD_MAX;
@ -287,7 +287,7 @@ void FNodeBuilder::FindPolyContainers (TArray<FPolyStart> &spots, TArray<FPolySt
// Scan right for the seg closest to the polyobject's center after it
// gets moved to its start spot.
fixed_t closestdist = FIXED_MAX;
DWORD closestseg = 0;
uint32_t closestseg = 0;
P(Printf ("start %d,%d -- center %d, %d\n", spot->x>>16, spot->y>>16, center.x>>16, center.y>>16));
@ -333,7 +333,7 @@ void FNodeBuilder::FindPolyContainers (TArray<FPolyStart> &spots, TArray<FPolySt
}
}
int FNodeBuilder::MarkLoop (DWORD firstseg, int loopnum)
int FNodeBuilder::MarkLoop (uint32_t firstseg, int loopnum)
{
int seg;
int sec = Segs[firstseg].frontsector;
@ -355,8 +355,8 @@ int FNodeBuilder::MarkLoop (DWORD firstseg, int loopnum)
Vertices[s1->v1].x>>16, Vertices[s1->v1].y>>16,
Vertices[s1->v2].x>>16, Vertices[s1->v2].y>>16));
DWORD bestseg = DWORD_MAX;
DWORD tryseg = Vertices[s1->v2].segs;
uint32_t bestseg = DWORD_MAX;
uint32_t tryseg = Vertices[s1->v2].segs;
angle_t bestang = ANGLE_MAX;
angle_t ang1 = s1->angle;

4
src/viewer/view.cpp
View file

@ -234,7 +234,7 @@ static TArray<short> DesiredHistory;
static void DrawSubsector (HDC dc, int ssec)
{
for (DWORD i = 0; i < Level->Subsectors[ssec].numlines; ++i)
for (uint32_t i = 0; i < Level->Subsectors[ssec].numlines; ++i)
{
int seg = Level->Subsectors[ssec].firstline + i;
if (Level->Segs[seg].side == 0)
@ -256,7 +256,7 @@ static void DrawSubsectorGL (HDC dc, int ssec, HPEN miniPen, HPEN badPen)
seg = Level->GLSubsectors[ssec].firstline;
MoveToEx (dc, GLVERTX(Level->GLSegs[seg].v1), GLVERTY(Level->GLSegs[seg].v1), NULL);
for (DWORD i = 0; i < Level->GLSubsectors[ssec].numlines; ++i)
for (uint32_t i = 0; i < Level->GLSubsectors[ssec].numlines; ++i)
{
HPEN oldPen = NULL;
seg = Level->GLSubsectors[ssec].firstline + i;

20
src/wad/wad.cpp
View file

@ -415,10 +415,10 @@ void FWadWriter::WriteLump (const char *name, const void *data, int len)
void FWadWriter::CopyLump (FWadReader &wad, int lump)
{
BYTE *data;
uint8_t *data;
int size;
ReadLump<BYTE> (wad, lump, data, size);
ReadLump<uint8_t> (wad, lump, data, size);
if (data != NULL)
{
WriteLump (wad.LumpName (lump), data, size);
@ -449,37 +449,37 @@ void FWadWriter::SafeWrite (const void *buffer, size_t size)
}
}
FWadWriter &FWadWriter::operator << (BYTE val)
FWadWriter &FWadWriter::operator << (uint8_t val)
{
AddToLump (&val, 1);
return *this;
}
FWadWriter &FWadWriter::operator << (WORD val)
FWadWriter &FWadWriter::operator << (uint16_t val)
{
val = LittleShort(val);
AddToLump ((BYTE *)&val, 2);
AddToLump ((uint8_t *)&val, 2);
return *this;
}
FWadWriter &FWadWriter::operator << (SWORD val)
FWadWriter &FWadWriter::operator << (int16_t val)
{
val = LittleShort(val);
AddToLump ((BYTE *)&val, 2);
AddToLump ((uint8_t *)&val, 2);
return *this;
}
FWadWriter &FWadWriter::operator << (DWORD val)
FWadWriter &FWadWriter::operator << (uint32_t val)
{
val = LittleLong(val);
AddToLump ((BYTE *)&val, 4);
AddToLump ((uint8_t *)&val, 4);
return *this;
}
FWadWriter &FWadWriter::operator << (fixed_t val)
{
val = LittleLong(val);
AddToLump ((BYTE *)&val, 4);
AddToLump ((uint8_t *)&val, 4);
return *this;
}

8
src/wad/wad.h
View file

@ -94,10 +94,10 @@ public:
void StartWritingLump (const char *name);
void AddToLump (const void *data, int len);
FWadWriter &operator << (BYTE);
FWadWriter &operator << (WORD);
FWadWriter &operator << (SWORD);
FWadWriter &operator << (DWORD);
FWadWriter &operator << (uint8_t);
FWadWriter &operator << (uint16_t);
FWadWriter &operator << (int16_t);
FWadWriter &operator << (uint32_t);
FWadWriter &operator << (fixed_t);
private:

4
zlib/gzguts.h
View file

@ -102,7 +102,7 @@
/* get errno and strerror definition */
#if defined UNDER_CE
# include <windows.h>
# define zstrerror() gz_strwinerror((DWORD)GetLastError())
# define zstrerror() gz_strwinerror((uint32_t)GetLastError())
#else
# ifndef NO_STRERROR
# include <errno.h>
@ -179,7 +179,7 @@ typedef gz_state FAR *gz_statep;
/* shared functions */
void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
#if defined UNDER_CE
char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
char ZLIB_INTERNAL *gz_strwinerror OF((uint32_t error));
#endif
/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t