zdoom/zdbsp
0
0
Fork 0
mirror of https://github.com/ZDoom/zdbsp.git synced 2024-11-14 00:10:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
zdbsp/nodebuild.h

306 lines
9.2 KiB
C
Raw Normal View History

- Nodebuilding is a little faster if we inline PointOnSide. SVN r171 (trunk)
2006-06-06 05:31:53 +00:00
#include <math.h>
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
#include "doomdata.h"
#include "workdata.h"
#include "tarray.h"
struct FEventInfo
{
int Vertex;
DWORD FrontSeg;
};
struct FEvent
{
FEvent *Parent, *Left, *Right;
double Distance;
FEventInfo Info;
};
class FEventTree
{
public:
FEventTree ();
~FEventTree ();
FEvent *GetMinimum ();
FEvent *GetSuccessor (FEvent *event) const { FEvent *node = Successor(event); return node == &Nil ? NULL : node; }
FEvent *GetPredecessor (FEvent *event) const { FEvent *node = Predecessor(event); return node == &Nil ? NULL : node; }
FEvent *GetNewNode ();
void Insert (FEvent *event);
FEvent *FindEvent (double distance) const;
void DeleteAll ();
ZDBSP fixes: - AddIntersection() should convert to doubles before subtracting the vertex from the node, not after, to avoid integer overflow. (See cah.wad, MAP12 and MAP13.) A simpler dot product will also suffice for distance calculation. - Splitters that come too close to a vertex should be avoided. (See cata.wad.) - Red-Black Tree implementation was broken and colored every node red. - Moved most of the code for outputting degenerate GL subsectors into another function. - Removed forgotten debugging file dump from WriteSSectors2(). - Enabled reference optimization and COMDAT folding in the linker for a slightly smaller executable. SVN r155 (trunk)
2006-05-31 15:39:58 +00:00
void PrintTree () const { PrintTree (Root); }
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
private:
FEvent Nil;
FEvent *Root;
FEvent *Spare;
void DeletionTraverser (FEvent *event);
FEvent *Successor (FEvent *event) const;
FEvent *Predecessor (FEvent *event) const;
ZDBSP fixes: - AddIntersection() should convert to doubles before subtracting the vertex from the node, not after, to avoid integer overflow. (See cah.wad, MAP12 and MAP13.) A simpler dot product will also suffice for distance calculation. - Splitters that come too close to a vertex should be avoided. (See cata.wad.) - Red-Black Tree implementation was broken and colored every node red. - Moved most of the code for outputting degenerate GL subsectors into another function. - Removed forgotten debugging file dump from WriteSSectors2(). - Enabled reference optimization and COMDAT folding in the linker for a slightly smaller executable. SVN r155 (trunk)
2006-05-31 15:39:58 +00:00
void PrintTree (const FEvent *event) const;
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
};
class FNodeBuilder
{
struct FPrivSeg
{
int v1, v2;
- UDMF implementation for ZDBSP. SVN r1482 (trunk)
2009-03-15 12:18:25 +00:00
DWORD sidedef;
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
int linedef;
int frontsector;
int backsector;
DWORD next;
DWORD nextforvert;
DWORD 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
angle_t angle;
fixed_t offset;
int planenum;
bool planefront;
FPrivSeg *hashnext;
};
struct FPrivVert
{
fixed_t x, y;
DWORD segs; // segs that use this vertex as v1
DWORD segs2; // segs that use this vertex as v2
- UDMF implementation for ZDBSP. SVN r1482 (trunk)
2009-03-15 12:18:25 +00:00
int index;
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
bool operator== (const FPrivVert &other)
{
return x == other.x && y == other.y;
}
};
struct FSimpleLine
{
fixed_t x, y, dx, dy;
};
union USegPtr
{
DWORD SegNum;
FPrivSeg *SegPtr;
};
struct FSplitSharer
{
double Distance;
DWORD Seg;
bool Forward;
};
- Added a "vertex map" for ZDBSP's vertex selection. (Think BLOCKMAP for vertices instead of lines.) On large maps, this can result in a very significant speed up. (In one particular map, ZDBSP had previously spent 40% of its time just scanning through all the vertices in the map. Now the time it spends finding vertices is immeasurable. Now 68% of its time on that map is spent inside ClassifyLine--because that routine is called more than 16 million times, which suggests that even a minor speedup in that routine should have a big impact--if I could just think of how that might happen.) On small maps, this won't make much of a difference, because the number of vertices to search was so small to begin with. SVN r167 (trunk)
2006-06-06 02:45:48 +00:00
// Like a blockmap, but for vertices instead of lines
class FVertexMap
{
public:
FVertexMap (FNodeBuilder &builder, fixed_t minx, fixed_t miny, fixed_t maxx, fixed_t maxy);
~FVertexMap ();
int SelectVertexExact (FPrivVert &vert);
int SelectVertexClose (FPrivVert &vert);
private:
FNodeBuilder &MyBuilder;
TArray<int> *VertexGrid;
fixed_t MinX, MinY, MaxX, MaxY;
int BlocksWide, BlocksTall;
- Fixed: The vertex selectors returned the vertex block number instead of the vertex number. Oops. The vertex map also didn't work for maps larger than 32767 units on a side. SVN r168 (trunk)
2006-06-06 03:27:24 +00:00
enum { BLOCK_SHIFT = 8 + FRACBITS };
enum { BLOCK_SIZE = 1 << BLOCK_SHIFT };
- Added a "vertex map" for ZDBSP's vertex selection. (Think BLOCKMAP for vertices instead of lines.) On large maps, this can result in a very significant speed up. (In one particular map, ZDBSP had previously spent 40% of its time just scanning through all the vertices in the map. Now the time it spends finding vertices is immeasurable. Now 68% of its time on that map is spent inside ClassifyLine--because that routine is called more than 16 million times, which suggests that even a minor speedup in that routine should have a big impact--if I could just think of how that might happen.) On small maps, this won't make much of a difference, because the number of vertices to search was so small to begin with. SVN r167 (trunk)
2006-06-06 02:45:48 +00:00
int InsertVertex (FPrivVert &vert);
inline int GetBlock (fixed_t x, fixed_t y)
{
assert (x >= MinX);
assert (y >= MinY);
assert (x <= MaxX);
assert (y <= MaxY);
- Fixed: The vertex selectors returned the vertex block number instead of the vertex number. Oops. The vertex map also didn't work for maps larger than 32767 units on a side. SVN r168 (trunk)
2006-06-06 03:27:24 +00:00
return (unsigned(x - MinX) >> BLOCK_SHIFT) + (unsigned(y - MinY) >> BLOCK_SHIFT) * BlocksWide;
- Added a "vertex map" for ZDBSP's vertex selection. (Think BLOCKMAP for vertices instead of lines.) On large maps, this can result in a very significant speed up. (In one particular map, ZDBSP had previously spent 40% of its time just scanning through all the vertices in the map. Now the time it spends finding vertices is immeasurable. Now 68% of its time on that map is spent inside ClassifyLine--because that routine is called more than 16 million times, which suggests that even a minor speedup in that routine should have a big impact--if I could just think of how that might happen.) On small maps, this won't make much of a difference, because the number of vertices to search was so small to begin with. SVN r167 (trunk)
2006-06-06 02:45:48 +00:00
}
};
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
friend class FVertexMap;
- Added a "vertex map" for ZDBSP's vertex selection. (Think BLOCKMAP for vertices instead of lines.) On large maps, this can result in a very significant speed up. (In one particular map, ZDBSP had previously spent 40% of its time just scanning through all the vertices in the map. Now the time it spends finding vertices is immeasurable. Now 68% of its time on that map is spent inside ClassifyLine--because that routine is called more than 16 million times, which suggests that even a minor speedup in that routine should have a big impact--if I could just think of how that might happen.) On small maps, this won't make much of a difference, because the number of vertices to search was so small to begin with. SVN r167 (trunk)
2006-06-06 02:45:48 +00:00
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
public:
struct FPolyStart
{
int polynum;
fixed_t x, y;
};
FNodeBuilder (FLevel &level,
TArray<FPolyStart> &polyspots, TArray<FPolyStart> &anchors,
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
const char *name, bool makeGLnodes, BYTE sselevel);
- Added a "vertex map" for ZDBSP's vertex selection. (Think BLOCKMAP for vertices instead of lines.) On large maps, this can result in a very significant speed up. (In one particular map, ZDBSP had previously spent 40% of its time just scanning through all the vertices in the map. Now the time it spends finding vertices is immeasurable. Now 68% of its time on that map is spent inside ClassifyLine--because that routine is called more than 16 million times, which suggests that even a minor speedup in that routine should have a big impact--if I could just think of how that might happen.) On small maps, this won't make much of a difference, because the number of vertices to search was so small to begin with. SVN r167 (trunk)
2006-06-06 02:45:48 +00:00
~FNodeBuilder ();
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
void GetVertices (WideVertex *&verts, int &count);
void GetNodes (MapNodeEx *&nodes, int &nodeCount,
MapSeg *&segs, int &segCount,
MapSubsectorEx *&ssecs, int &subCount);
void GetGLNodes (MapNodeEx *&nodes, int &nodeCount,
MapSegGLEx *&segs, int &segCount,
MapSubsectorEx *&ssecs, int &subCount);
// < 0 : in front of line
// == 0 : on line
// > 0 : behind line
- Nodebuilding is a little faster if we inline PointOnSide. SVN r171 (trunk)
2006-06-06 05:31:53 +00:00
static inline int PointOnSide (int x, int y, int x1, int y1, int dx, int dy);
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
private:
- Added a "vertex map" for ZDBSP's vertex selection. (Think BLOCKMAP for vertices instead of lines.) On large maps, this can result in a very significant speed up. (In one particular map, ZDBSP had previously spent 40% of its time just scanning through all the vertices in the map. Now the time it spends finding vertices is immeasurable. Now 68% of its time on that map is spent inside ClassifyLine--because that routine is called more than 16 million times, which suggests that even a minor speedup in that routine should have a big impact--if I could just think of how that might happen.) On small maps, this won't make much of a difference, because the number of vertices to search was so small to begin with. SVN r167 (trunk)
2006-06-06 02:45:48 +00:00
FVertexMap *VertexMap;
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
TArray<node_t> Nodes;
TArray<subsector_t> Subsectors;
TArray<DWORD> SubsectorSets;
TArray<FPrivSeg> Segs;
TArray<FPrivVert> Vertices;
TArray<USegPtr> SegList;
TArray<BYTE> PlaneChecked;
TArray<FSimpleLine> Planes;
size_t InitialVertices; // Number of vertices in a map that are connected to linedefs
TArray<int> Touched; // Loops a splitter touches on a vertex
TArray<int> Colinear; // Loops with edges colinear to a splitter
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
- Added code to explicitly handle outputting overlapping segs when building GL nodes with ZDBSP, removing the check that discarded them early on. SVN r157 (trunk)
2006-05-31 23:17:26 +00:00
DWORD HackMate; // Seg to use in front of hack seg
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
FLevel &Level;
bool GLNodes;
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
int SSELevel;
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
// Progress meter stuff
int SegsStuffed;
const char *MapName;
void FindUsedVertices (WideVertex *vertices, int max);
void BuildTree ();
void MakeSegsFromSides ();
- Added code to explicitly handle outputting overlapping segs when building GL nodes with ZDBSP, removing the check that discarded them early on. SVN r157 (trunk)
2006-05-31 23:17:26 +00:00
int CreateSeg (int linenum, int sidenum);
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
void GroupSegPlanes ();
void FindPolyContainers (TArray<FPolyStart> &spots, TArray<FPolyStart> &anchors);
bool GetPolyExtents (int polynum, fixed_t bbox[4]);
int MarkLoop (DWORD firstseg, int loopnum);
void AddSegToBBox (fixed_t bbox[4], const FPrivSeg *seg);
DWORD CreateNode (DWORD set, fixed_t bbox[4]);
DWORD CreateSubsector (DWORD set, fixed_t bbox[4]);
void CreateSubsectorsForReal ();
bool CheckSubsector (DWORD set, node_t &node, DWORD &splitseg, int setsize);
- Added code to explicitly handle outputting overlapping segs when building GL nodes with ZDBSP, removing the check that discarded them early on. SVN r157 (trunk)
2006-05-31 23:17:26 +00:00
bool CheckSubsectorOverlappingSegs (DWORD set, node_t &node, DWORD &splitseg);
bool ShoveSegBehind (DWORD set, node_t &node, DWORD seg, DWORD mate);
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
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);
DWORD SplitSeg (DWORD segnum, int splitvert, int v1InFront);
int Heuristic (node_t &node, DWORD set, bool honorNoSplit);
int CountSegs (DWORD set) const;
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
// Returns:
// 0 = seg is in front
// 1 = seg is in back
// -1 = seg cuts the node
inline int ClassifyLine (node_t &node, const FPrivSeg *seg, int &sidev1, int &sidev2);
int ClassifyLine2 (node_t &node, const FPrivSeg *seg, int &sidev1, int &sidev2);
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
#ifndef DISABLE_SSE
int ClassifyLineSSE1 (node_t &node, const FPrivSeg *seg, int &sidev1, int &sidev2);
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
int ClassifyLineSSE2 (node_t &node, const FPrivSeg *seg, int &sidev1, int &sidev2);
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
#if defined(_WIN32) && defined(__GNUC__) && !defined(DISABLE_BACKPATCH)
int ClassifyLineBackpatch (node_t &node, const FPrivSeg *seg, int &sidev1, int &sidev2) __attribute__((noinline));
#endif
#endif
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
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 SetNodeFromSeg (node_t &node, const FPrivSeg *pseg) const;
int RemoveMinisegs (MapNodeEx *nodes, TArray<MapSeg> &segs, MapSubsectorEx *subs, int node, short bbox[4]);
int StripMinisegs (TArray<MapSeg> &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);
void PushConnectingGLSeg (int subsector, TArray<MapSegGLEx> &segs, int v1, int v2);
ZDBSP fixes: - AddIntersection() should convert to doubles before subtracting the vertex from the node, not after, to avoid integer overflow. (See cah.wad, MAP12 and MAP13.) A simpler dot product will also suffice for distance calculation. - Splitters that come too close to a vertex should be avoided. (See cata.wad.) - Red-Black Tree implementation was broken and colored every node red. - Moved most of the code for outputting degenerate GL subsectors into another function. - Removed forgotten debugging file dump from WriteSSectors2(). - Enabled reference optimization and COMDAT folding in the linker for a slightly smaller executable. SVN r155 (trunk)
2006-05-31 15:39:58 +00:00
int OutputDegenerateSubsector (TArray<MapSegGLEx> &segs, int subsector, bool bForward, double lastdot, FPrivSeg *&prev);
Initial commit of zdbsp. SVN r12 (trunk)
2006-02-24 05:17:19 +00:00
static int SortSegs (const void *a, const void *b);
double InterceptVector (const node_t &splitter, const FPrivSeg &seg);
void PrintSet (int l, DWORD set);
};
- Nodebuilding is a little faster if we inline PointOnSide. SVN r171 (trunk)
2006-06-06 05:31:53 +00:00
// Points within this distance of a line will be considered on the line.
// Units are in fixed_ts.
const double SIDE_EPSILON = 6.5536;
inline int FNodeBuilder::PointOnSide (int x, int y, int x1, int y1, int dx, int dy)
{
// For most cases, a simple dot product is enough.
double d_dx = double(dx);
double d_dy = double(dy);
double d_x = double(x);
double d_y = double(y);
double d_x1 = double(x1);
double d_y1 = double(y1);
double s_num = (d_y1-d_y)*d_dx - (d_x1-d_x)*d_dy;
if (fabs(s_num) < 17179869184.f) // 4<<32
{
// Either the point is very near the line, or the segment defining
// the line is very short: Do a more expensive test to determine
// just how far from the line the point is.
double l = d_dx*d_dx + d_dy*d_dy; // double l = sqrt(d_dx*d_dx+d_dy*d_dy);
double dist = s_num * s_num / l; // double dist = fabs(s_num)/l;
if (dist < SIDE_EPSILON*SIDE_EPSILON) // if (dist < SIDE_EPSILON)
{
return 0;
}
}
return s_num > 0.0 ? -1 : 1;
}
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
inline int FNodeBuilder::ClassifyLine (node_t &node, const FPrivSeg *seg, int &sidev1, int &sidev2)
{
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
#ifdef DISABLE_SSE
return ClassifyLine2 (node, seg, sidev1, sidev2);
#else
#if defined(__SSE2__) || defined(_M_IX64)
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
// If compiling with SSE2 support everywhere, just use the SSE2 version.
return ClassifyLineSSE2 (node, seg, sidev1, sidev2);
#elif defined(_MSC_VER) && _MSC_VER < 1300
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
// VC 6 does not support SSE optimizations.
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
return ClassifyLine2 (node, seg, sidev1, sidev2);
#else
// Select the routine based on our flag.
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
#if defined(_WIN32) && defined(__GNUC__) && !defined(DISABLE_BACKPATCH)
return ClassifyLineBackpatch (node, seg, sidev1, sidev2);
#else
if (SSELevel == 2)
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
return ClassifyLineSSE2 (node, seg, sidev1, sidev2);
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
else if (SSELevel == 1)
return ClassifyLineSSE1 (node, seg, sidev1, sidev2);
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
else
return ClassifyLine2 (node, seg, sidev1, sidev2);
#endif
For ZDBSP: - Fixed the OrgSectorMap generation in FLevel::RemoveExtraSectors(). - Added a version of ClassifyLine compiled with SSE (but not SSE2) optimization for people with Pentium 3/Athlon XPs to use. - Added ClassifyLine backpatching for the GCC Windows build. The first time a function calls ClassifyLine, it has to check which version to use and jump to the appropriate one. After that, it calls the desired one straight away. SVN r227 (trunk)
2006-06-26 20:39:57 +00:00
#endif
#endif
- Added runtime detection of SSE2 so that ZDBSP can select either the regular ClassifyLine routine or a version compiled with SSE2 optimizations. This pretty much removes any reason to do a separate SSE2 build, since most of the time is spent in ClassifyLine, so using SSE2 in just that one function helps the most. SVN r172 (trunk)
2006-06-06 19:15:39 +00:00
}
Reference in a new issue Copy permalink