zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-24 13:11:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

- replaced DWORD_MAX with UINT_MAX globally.

Browse source 
This was the last remnant of ZDoom's old integer types.
This commit is contained in:
Christoph Oelckers 2019-01-30 22:34:11 +01:00
parent 0eb3b2abca
commit c18a0e7736
5 changed files with 80 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/maploader/glnodes.cpp
View file

@ -346,7 +346,7 @@ bool MapLoader::LoadGLSegs(FileReader &lump)
segs[i].v2 = &Level->vertexes[checkGLVertex3(LittleLong(ml->v2))];
const uint32_t partner = LittleLong(ml->partner);
segs[i].PartnerSeg = DWORD_MAX == partner ? nullptr : &segs[partner];
segs[i].PartnerSeg = UINT_MAX == partner ? nullptr : &segs[partner];
if(ml->linedef != 0xffff) // skip minisegs
{

54
src/nodebuild.cpp
View file

@ -117,8 +117,8 @@ void FNodeBuilder::BuildTree ()
{
fixed_t bbox[4];
HackSeg = DWORD_MAX;
HackMate = DWORD_MAX;
HackSeg = UINT_MAX;
HackMate = UINT_MAX;
CreateNode (0, Segs.Size(), bbox);
CreateSubsectorsForReal ();
}
@ -171,7 +171,7 @@ int FNodeBuilder::CreateSubsector (uint32_t set, fixed_t bbox[4])
D(Printf (PRINT_LOG, "Subsector from set %d\n", set));
assert (set != DWORD_MAX);
assert (set != UINT_MAX);
// We cannot actually create the subsector now because the node building
// process might split a seg in this subsector (because all partner segs
@ -181,7 +181,7 @@ int FNodeBuilder::CreateSubsector (uint32_t set, fixed_t bbox[4])
ssnum = (int)SubsectorSets.Push (set);
count = 0;
while (set != DWORD_MAX)
while (set != UINT_MAX)
{
AddSegToBBox (bbox, &Segs[set]);
set = Segs[set].next;
@ -211,7 +211,7 @@ void FNodeBuilder::CreateSubsectorsForReal ()
uint32_t set = SubsectorSets[i];
uint32_t firstline = (uint32_t)SegList.Size();
while (set != DWORD_MAX)
while (set != UINT_MAX)
{
USegPtr ptr;
@ -349,9 +349,9 @@ bool FNodeBuilder::CheckSubsector (uint32_t set, node_t &node, uint32_t &splitse
}
}
seg = Segs[seg].next;
} while (seg != DWORD_MAX);
} while (seg != UINT_MAX);
if (seg == DWORD_MAX)
if (seg == UINT_MAX)
{ // It's a valid non-GL subsector, and probably a valid GL subsector too.
if (GLNodes)
{
@ -361,13 +361,13 @@ bool FNodeBuilder::CheckSubsector (uint32_t set, node_t &node, uint32_t &splitse
}
D(Printf(PRINT_LOG, "Need to synthesize a splitter for set %d on seg %d\n", set, seg));
splitseg = DWORD_MAX;
splitseg = UINT_MAX;
// This is a very simple and cheap "fix" for subsectors with segs
// from multiple sectors, and it seems ZenNode does something
// similar. It is the only technique I could find that makes the
// "transparent water" in nb_bmtrk.wad work properly.
return ShoveSegBehind (set, node, seg, DWORD_MAX);
return ShoveSegBehind (set, node, seg, UINT_MAX);
}
// When creating GL nodes, we need to check for segs with the same start and
@ -378,7 +378,7 @@ bool FNodeBuilder::CheckSubsectorOverlappingSegs (uint32_t set, node_t &node, ui
int v1, v2;
uint32_t seg1, seg2;
for (seg1 = set; seg1 != DWORD_MAX; seg1 = Segs[seg1].next)
for (seg1 = set; seg1 != UINT_MAX; seg1 = Segs[seg1].next)
{
if (Segs[seg1].linedef == -1)
{ // Do not check minisegs.
@ -386,7 +386,7 @@ bool FNodeBuilder::CheckSubsectorOverlappingSegs (uint32_t set, node_t &node, ui
}
v1 = Segs[seg1].v1;
v2 = Segs[seg1].v2;
for (seg2 = Segs[seg1].next; seg2 != DWORD_MAX; seg2 = Segs[seg2].next)
for (seg2 = Segs[seg1].next; seg2 != UINT_MAX; seg2 = Segs[seg2].next)
{
if (Segs[seg2].v1 == v1 && Segs[seg2].v2 == v2)
{
@ -395,7 +395,7 @@ bool FNodeBuilder::CheckSubsectorOverlappingSegs (uint32_t set, node_t &node, ui
swapvalues (seg1, seg2);
}
D(Printf(PRINT_LOG, "Need to synthesize a splitter for set %d on seg %d (ov)\n", set, seg2));
splitseg = DWORD_MAX;
splitseg = UINT_MAX;
return ShoveSegBehind (set, node, seg2, seg1);
}
@ -410,7 +410,7 @@ bool FNodeBuilder::CheckSubsectorOverlappingSegs (uint32_t set, node_t &node, ui
// set, all the other segs will be in front of the splitter. Since
// the splitter is formed from this seg, the back of the splitter
// will have a one-dimensional subsector. SplitSegs() will add one
// or two new minisegs to close it: If mate is DWORD_MAX, then a
// or two new minisegs to close it: If mate is UINT_MAX, then a
// new seg is created to replace this one on the front of the
// splitter. Otherwise, mate takes its place. In either case, the
// seg in front of the splitter is partnered with a new miniseg on
@ -447,7 +447,7 @@ int FNodeBuilder::SelectSplitter (uint32_t set, node_t &node, uint32_t &splitseg
bool nosplitters = false;
bestvalue = 0;
bestseg = DWORD_MAX;
bestseg = UINT_MAX;
seg = set;
stepleft = 0;
@ -456,7 +456,7 @@ int FNodeBuilder::SelectSplitter (uint32_t set, node_t &node, uint32_t &splitseg
D(Printf (PRINT_LOG, "Processing set %d\n", set));
while (seg != DWORD_MAX)
while (seg != UINT_MAX)
{
FPrivSeg *pseg = &Segs[seg];
@ -495,7 +495,7 @@ int FNodeBuilder::SelectSplitter (uint32_t set, node_t &node, uint32_t &splitseg
seg = pseg->next;
}
if (bestseg == DWORD_MAX)
if (bestseg == UINT_MAX)
{ // No lines split any others into two sets, so this is a convex region.
D(Printf (PRINT_LOG, "set %d, step %d, nosplit %d has no good splitter (%d)\n", set, step, nosplit, nosplitters));
return nosplitters ? -1 : 0;
@ -532,7 +532,7 @@ int FNodeBuilder::Heuristic (node_t &node, uint32_t set, bool honorNoSplit)
Touched.Clear ();
Colinear.Clear ();
while (i != DWORD_MAX)
while (i != UINT_MAX)
{
const FPrivSeg *test = &Segs[i];
@ -756,13 +756,13 @@ void FNodeBuilder::SplitSegs (uint32_t set, node_t &node, uint32_t splitseg, uin
{
unsigned int _count0 = 0;
unsigned int _count1 = 0;
outset0 = DWORD_MAX;
outset1 = DWORD_MAX;
outset0 = UINT_MAX;
outset1 = UINT_MAX;
Events.DeleteAll ();
SplitSharers.Clear ();
while (set != DWORD_MAX)
while (set != UINT_MAX)
{
bool hack;
FPrivSeg *seg = &Segs[set];
@ -772,7 +772,7 @@ void FNodeBuilder::SplitSegs (uint32_t set, node_t &node, uint32_t splitseg, uin
if (HackSeg == set)
{
HackSeg = DWORD_MAX;
HackSeg = UINT_MAX;
side = 1;
sidev[0] = sidev[1] = 0;
hack = true;
@ -822,7 +822,7 @@ void FNodeBuilder::SplitSegs (uint32_t set, node_t &node, uint32_t splitseg, uin
_count1++;
// Also split the seg on the back side
if (Segs[set].partner != DWORD_MAX)
if (Segs[set].partner != UINT_MAX)
{
int partner1 = Segs[set].partner;
int partner2 = SplitSeg(partner1, vertnum, sidev[1]);
@ -884,8 +884,8 @@ void FNodeBuilder::SplitSegs (uint32_t set, node_t &node, uint32_t splitseg, uin
{
uint32_t newback, newfront;
newback = AddMiniseg (seg->v2, seg->v1, DWORD_MAX, set, splitseg);
if (HackMate == DWORD_MAX)
newback = AddMiniseg (seg->v2, seg->v1, UINT_MAX, set, splitseg);
if (HackMate == UINT_MAX)
{
newfront = AddMiniseg (Segs[set].v1, Segs[set].v2, newback, set, splitseg);
Segs[newfront].next = outset0;
@ -996,7 +996,7 @@ void FNodeBuilder::RemoveSegFromVert1 (uint32_t segnum, int vertnum)
uint32_t prev, curr;
prev = 0;
curr = v->segs;
while (curr != DWORD_MAX && curr != segnum)
while (curr != UINT_MAX && curr != segnum)
{
prev = curr;
curr = Segs[curr].nextforvert;
@ -1021,7 +1021,7 @@ void FNodeBuilder::RemoveSegFromVert2 (uint32_t segnum, int vertnum)
uint32_t prev, curr;
prev = 0;
curr = v->segs2;
while (curr != DWORD_MAX && curr != segnum)
while (curr != UINT_MAX && curr != segnum)
{
prev = curr;
curr = Segs[curr].nextforvert2;
@ -1059,7 +1059,7 @@ double FNodeBuilder::InterceptVector (const node_t &splitter, const FPrivSeg &se
void FNodeBuilder::PrintSet (int l, uint32_t set)
{
Printf (PRINT_LOG, "set %d:\n", l);
for (; set != DWORD_MAX; set = Segs[set].next)
for (; set != UINT_MAX; set = Segs[set].next)
{
Printf (PRINT_LOG, "\t%u(%d)%c%d(%d,%d)-%d(%d,%d)\n", set, Segs[set].frontsector->sectornum,
Segs[set].linedef == -1 ? '+' : ':',

8
src/nodebuild_extract.cpp
View file

@ -122,10 +122,10 @@ void FNodeBuilder::Extract (FLevelLocals &theLevel)
{
outSegs[i] = *(seg_t *)&segs[i];
if (segs[i].Partner != DWORD_MAX)
if (segs[i].Partner != UINT_MAX)
{
const uint32_t storedseg = Segs[segs[i].Partner].storedseg;
outSegs[i].PartnerSeg = DWORD_MAX == storedseg ? nullptr : &outSegs[storedseg];
outSegs[i].PartnerSeg = UINT_MAX == storedseg ? nullptr : &outSegs[storedseg];
}
else
{
@ -330,7 +330,7 @@ int FNodeBuilder::CloseSubsector (TArray<glseg_t> &segs, int subsector, vertex_t
{
angle_t bestdiff = ANGLE_MAX;
FPrivSeg *bestseg = NULL;
uint32_t bestj = DWORD_MAX;
uint32_t bestj = UINT_MAX;
j = first;
do
{
@ -526,6 +526,6 @@ void FNodeBuilder::PushConnectingGLSeg (int subsector, TArray<glseg_t> &segs, ve
newseg.frontsector = NULL;
newseg.linedef = NULL;
newseg.sidedef = NULL;
newseg.Partner = DWORD_MAX;
newseg.Partner = UINT_MAX;
segs.Push (newseg);
}

52
src/nodebuild_gl.cpp
View file

@ -56,7 +56,7 @@ double FNodeBuilder::AddIntersection (const node_t &node, int vertex)
{
static const FEventInfo defaultInfo =
{
-1, DWORD_MAX
-1, UINT_MAX
};
// Calculate signed distance of intersection vertex from start of splitter.
@ -142,7 +142,7 @@ void FNodeBuilder::FixSplitSharers (const node_t &node)
Segs[seg].next = newseg;
uint32_t partner = Segs[seg].partner;
if (partner != DWORD_MAX)
if (partner != UINT_MAX)
{
int endpartner = SplitSeg (partner, event->Info.Vertex, 1);
@ -184,13 +184,13 @@ void FNodeBuilder::AddMinisegs (const node_t &node, uint32_t splitseg, uint32_t
// are unclosed, but at least we won't be needlessly creating subsectors in void space.
// Unclosed subsectors can be closed trivially once the BSP tree is complete.
if ((fseg1 = CheckLoopStart (node.dx, node.dy, prev->Info.Vertex, event->Info.Vertex)) != DWORD_MAX &&
(bseg1 = CheckLoopStart (-node.dx, -node.dy, event->Info.Vertex, prev->Info.Vertex)) != DWORD_MAX &&
(fseg2 = CheckLoopEnd (node.dx, node.dy, event->Info.Vertex)) != DWORD_MAX &&
(bseg2 = CheckLoopEnd (-node.dx, -node.dy, prev->Info.Vertex)) != DWORD_MAX)
if ((fseg1 = CheckLoopStart (node.dx, node.dy, prev->Info.Vertex, event->Info.Vertex)) != UINT_MAX &&
(bseg1 = CheckLoopStart (-node.dx, -node.dy, event->Info.Vertex, prev->Info.Vertex)) != UINT_MAX &&
(fseg2 = CheckLoopEnd (node.dx, node.dy, event->Info.Vertex)) != UINT_MAX &&
(bseg2 = CheckLoopEnd (-node.dx, -node.dy, prev->Info.Vertex)) != UINT_MAX)
{
// Add miniseg on the front side
fnseg = AddMiniseg (prev->Info.Vertex, event->Info.Vertex, DWORD_MAX, fseg1, splitseg);
fnseg = AddMiniseg (prev->Info.Vertex, event->Info.Vertex, UINT_MAX, fseg1, splitseg);
Segs[fnseg].next = fset;
fset = fnseg;
@ -243,14 +243,14 @@ uint32_t FNodeBuilder::AddMiniseg (int v1, int v2, uint32_t partner, uint32_t se
newseg.sidedef = NO_SIDE;
newseg.linedef = -1;
newseg.loopnum = 0;
newseg.next = DWORD_MAX;
newseg.next = UINT_MAX;
newseg.planefront = true;
newseg.hashnext = NULL;
newseg.storedseg = DWORD_MAX;
newseg.storedseg = UINT_MAX;
newseg.frontsector = NULL;
newseg.backsector = NULL;
if (splitseg != DWORD_MAX)
if (splitseg != UINT_MAX)
{
newseg.planenum = Segs[splitseg].planenum;
}
@ -264,16 +264,16 @@ uint32_t FNodeBuilder::AddMiniseg (int v1, int v2, uint32_t partner, uint32_t se
newseg.nextforvert = Vertices[v1].segs;
newseg.nextforvert2 = Vertices[v2].segs2;
newseg.next = seg->next;
if (partner != DWORD_MAX)
if (partner != UINT_MAX)
{
newseg.partner = partner;
}
else
{
newseg.partner = DWORD_MAX;
newseg.partner = UINT_MAX;
}
nseg = Segs.Push (newseg);
if (newseg.partner != DWORD_MAX)
if (newseg.partner != UINT_MAX)
{
Segs[partner].partner = nseg;
}
@ -295,8 +295,8 @@ uint32_t FNodeBuilder::CheckLoopStart (fixed_t dx, fixed_t dy, int vertex, int v
// to the splitter.
segnum = v->segs2;
bestang = ANGLE_MAX;
bestseg = DWORD_MAX;
while (segnum != DWORD_MAX)
bestseg = UINT_MAX;
while (segnum != UINT_MAX)
{
FPrivSeg *seg = &Segs[segnum];
angle_t segAngle = PointToAngle (Vertices[seg->v1].x - v->x, Vertices[seg->v1].y - v->y);
@ -317,25 +317,25 @@ uint32_t FNodeBuilder::CheckLoopStart (fixed_t dx, fixed_t dy, int vertex, int v
}
segnum = seg->nextforvert2;
}
if (bestseg == DWORD_MAX)
if (bestseg == UINT_MAX)
{
return DWORD_MAX;
return UINT_MAX;
}
// Now make sure there are no segs starting at this vertex that form
// an even smaller angle to the splitter.
segnum = v->segs;
while (segnum != DWORD_MAX)
while (segnum != UINT_MAX)
{
FPrivSeg *seg = &Segs[segnum];
if (seg->v2 == vertex2)
{
return DWORD_MAX;
return UINT_MAX;
}
angle_t segAngle = PointToAngle (Vertices[seg->v2].x - v->x, Vertices[seg->v2].y - v->y);
angle_t diff = splitAngle - segAngle;
if (diff < bestang && seg->partner != bestseg)
{
return DWORD_MAX;
return UINT_MAX;
}
segnum = seg->nextforvert;
}
@ -354,8 +354,8 @@ uint32_t FNodeBuilder::CheckLoopEnd (fixed_t dx, fixed_t dy, int vertex)
// to the splitter.
segnum = v->segs;
bestang = ANGLE_MAX;
bestseg = DWORD_MAX;
while (segnum != DWORD_MAX)
bestseg = UINT_MAX;
while (segnum != UINT_MAX)
{
FPrivSeg *seg = &Segs[segnum];
angle_t segAngle = PointToAngle (Vertices[seg->v2].x - v->x, Vertices[seg->v2].y - v->y);
@ -376,21 +376,21 @@ uint32_t FNodeBuilder::CheckLoopEnd (fixed_t dx, fixed_t dy, int vertex)
}
segnum = seg->nextforvert;
}
if (bestseg == DWORD_MAX)
if (bestseg == UINT_MAX)
{
return DWORD_MAX;
return UINT_MAX;
}
// Now make sure there are no segs ending at this vertex that form
// an even smaller angle to the splitter.
segnum = v->segs2;
while (segnum != DWORD_MAX)
while (segnum != UINT_MAX)
{
FPrivSeg *seg = &Segs[segnum];
angle_t segAngle = PointToAngle (Vertices[seg->v1].x - v->x, Vertices[seg->v1].y - v->y);
angle_t diff = segAngle - splitAngle;
if (diff < bestang && seg->partner != bestseg)
{
return DWORD_MAX;
return UINT_MAX;
}
segnum = seg->nextforvert2;
}

44
src/nodebuild_utility.cpp
View file

@ -152,13 +152,13 @@ int FNodeBuilder::CreateSeg (int linenum, int sidenum)
FPrivSeg seg;
int segnum;
seg.next = DWORD_MAX;
seg.next = UINT_MAX;
seg.loopnum = 0;
seg.partner = DWORD_MAX;
seg.partner = UINT_MAX;
seg.hashnext = NULL;
seg.planefront = false;
seg.planenum = DWORD_MAX;
seg.storedseg = DWORD_MAX;
seg.planenum = UINT_MAX;
seg.storedseg = UINT_MAX;
if (sidenum == 0)
{ // front
@ -202,13 +202,13 @@ void FNodeBuilder::AddSegs(seg_t *segs, int numsegs)
FPrivVert vert;
int segnum;
seg.next = DWORD_MAX;
seg.next = UINT_MAX;
seg.loopnum = 0;
seg.partner = DWORD_MAX;
seg.partner = UINT_MAX;
seg.hashnext = NULL;
seg.planefront = false;
seg.planenum = DWORD_MAX;
seg.storedseg = DWORD_MAX;
seg.planenum = UINT_MAX;
seg.storedseg = UINT_MAX;
seg.frontsector = segs[i].frontsector;
seg.backsector = segs[i].backsector;
@ -239,13 +239,13 @@ void FNodeBuilder::AddPolySegs(FPolySeg *segs, int numsegs)
FPrivVert vert;
int segnum;
seg.next = DWORD_MAX;
seg.next = UINT_MAX;
seg.loopnum = 0;
seg.partner = DWORD_MAX;
seg.partner = UINT_MAX;
seg.hashnext = NULL;
seg.planefront = false;
seg.planenum = DWORD_MAX;
seg.storedseg = DWORD_MAX;
seg.planenum = UINT_MAX;
seg.storedseg = UINT_MAX;
side_t *side = segs[i].wall;
assert(side != NULL);
@ -286,7 +286,7 @@ void FNodeBuilder::GroupSegPlanes ()
seg->hashnext = NULL;
}
Segs[Segs.Size()-1].next = DWORD_MAX;
Segs[Segs.Size()-1].next = UINT_MAX;
for (i = planenum = 0; i < (int)Segs.Size(); ++i)
{
@ -379,7 +379,7 @@ void FNodeBuilder::GroupSegPlanesSimple()
pline->dx = Vertices[seg->v2].x - Vertices[seg->v1].x;
pline->dy = Vertices[seg->v2].y - Vertices[seg->v1].y;
}
Segs.Last().next = DWORD_MAX;
Segs.Last().next = UINT_MAX;
PlaneChecked.Reserve((Segs.Size() + 7) / 8);
}
@ -497,13 +497,13 @@ int FNodeBuilder::MarkLoop (uint32_t firstseg, int loopnum)
Vertices[s1->v1].x>>16, Vertices[s1->v1].y>>16,
Vertices[s1->v2].x>>16, Vertices[s1->v2].y>>16));
uint32_t bestseg = DWORD_MAX;
uint32_t bestseg = UINT_MAX;
uint32_t tryseg = Vertices[s1->v2].segs;
angle_t bestang = ANGLE_MAX;
angle_t ang1 = PointToAngle (Vertices[s1->v2].x - Vertices[s1->v1].x,
Vertices[s1->v2].y - Vertices[s1->v1].y);
while (tryseg != DWORD_MAX)
while (tryseg != UINT_MAX)
{
FPrivSeg *s2 = &Segs[tryseg];
@ -523,7 +523,7 @@ int FNodeBuilder::MarkLoop (uint32_t firstseg, int loopnum)
}
seg = bestseg;
} while (seg != DWORD_MAX && Segs[seg].loopnum == 0);
} while (seg != UINT_MAX && Segs[seg].loopnum == 0);
return loopnum + 1;
}
@ -563,7 +563,7 @@ bool FNodeBuilder::GetPolyExtents (int polynum, fixed_t bbox[4])
vert = Segs[i].v2;
i = Vertices[vert].segs;
count++; // to prevent endless loops. Stop when this reaches the number of segs.
} while (i != DWORD_MAX && (Vertices[vert].x != start.fixX() || Vertices[vert].y != start.fixY()) && count < Segs.Size());
} while (i != UINT_MAX && (Vertices[vert].x != start.fixX() || Vertices[vert].y != start.fixY()) && count < Segs.Size());
return true;
}
@ -691,8 +691,8 @@ int FNodeBuilder::FVertexMap::InsertVertex (FNodeBuilder::FPrivVert &vert)
{
int vertnum;
vert.segs = DWORD_MAX;
vert.segs2 = DWORD_MAX;
vert.segs = UINT_MAX;
vert.segs2 = UINT_MAX;
vertnum = (int)MyBuilder.Vertices.Push (vert);
// If a vertex is near a block boundary, then it will be inserted on
@ -772,7 +772,7 @@ int FNodeBuilder::FVertexMapSimple::SelectVertexClose(FNodeBuilder::FPrivVert &v
int FNodeBuilder::FVertexMapSimple::InsertVertex (FNodeBuilder::FPrivVert &vert)
{
vert.segs = DWORD_MAX;
vert.segs2 = DWORD_MAX;
vert.segs = UINT_MAX;
vert.segs2 = UINT_MAX;
return (int)MyBuilder.Vertices.Push (vert);
}