raze/source/core/rendering/hw_sections.cpp

/*
** hw_sectiona.cpp
** For decoupling the renderer from internal Build structures
**
**---------------------------------------------------------------------------
** Copyright 2021 Christoph Oelckers
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
**    notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
**    derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
** The sole reason for existence of this file is that Build's sector setup
** does not allow for easy splitting of sectors, either for having disjoint parts
** or requiring partial rendering. So we need to add a superstructure
** where we can shuffle around some content without disturbing the original
** order...
**
*/


#include "hw_sections.h"
#include "sectorgeometry.h"
#include "gamefuncs.h"
#include "earcut.hpp"
#include "nodebuilder/nodebuild.h"


TArray<SectionLine> sectionLines;
TArray<Section> Sections;
TArray<TArray<int>> sectionspersector;	// reverse map, mainly for the automap
int numsectionlines;

void hw_SplitSector(int sector, int startpos, int endpos);

TArray<int> splits;


void hw_BuildSections()
{
	Sections.Resize(numsectors);
	sectionspersector.Resize(numsectors);
	sectionLines.Resize(numwalls * 5 / 4); // cannot reallocate, unfortunately.
	numsectionlines = numwalls;
	for (int i = 0; i < numsectors; i++)
	{
		Sections[i].sector = i;
		Sections[i].lines.Resize(sector[i].wallnum);
		for (int j = 0; j < sector[i].wallnum; j++) Sections[i].lines[j] = sector[i].wallptr + j;
		sectionspersector[i].Resize(1);
		sectionspersector[i][0] = i;
	}

	// Initial setup just creates a 1:1 mapping of walls to section lines and sectors to sections.
	numsectionlines = numwalls;
	for (int i = 0; i < numwalls; i++)
	{
		auto& wal = wall[i];
		sectionLines[i].startpoint = sectionLines[i].wall = i;
		sectionLines[i].endpoint = wal.point2;
		sectionLines[i].partner = wal.nextwall;
		sectionLines[i].section = wal.sector;
		sectionLines[i].partnersection = wal.nextsector;
		sectionLines[i].point2index = 0;
		if (wal.sector == -1)
			Printf("Warning: Wall %d without a sector!\n", wall.IndexOf(&wal));
		else 
			sectionLines[i].point2index = wal.point2 - wal.sectorp()->wallptr;
	}

	for (unsigned i = 0; i < splits.Size(); i += 3)
		hw_SplitSector(splits[i], splits[i + 1], splits[i + 2]);
}


static void SplitSection(int section, int start, int end)
{
#if 0 // disabled until refactoring. This code is a mess and needs to be redone.

	// note: to do this, the sector's lines must be well ordered and there must only be one outline and no holes.
	// This also can only apply a single split to a given sector.
	int firstsection = Sections.Reserve(2);
	int secondsection = firstsection+1;

	auto& sect = Sections[section];
	Section* sect1 = &Sections[firstsection];
	Section* sect2 = &Sections[secondsection];
	sect1->sector = sect.sector;
	sect2->sector = sect.sector;
	sect1->lines.Clear();
	sect2->lines.Clear();
	for (int aline : sect.lines)
	{
		int line = sectionLines[aline].wall;
		if (line < start || line >= end)
		{
			sect1->lines.Push(aline);
		}
		if (line == start)
		{
			sect1->lines.Push(-1);
			sect2->lines.Push(-1);
		}
		if (line >= start && line < end)
		{
			sect2->lines.Push(aline);
		}
	}

	int firstnewline = numsectionlines;
	int thisline = numsectionlines;
	int splitline1 = 0, splitline2 = 0;
	//numsectionlines += sect1->lines.Size() + 1;
	for (unsigned i = 0; i < sect1->lines.Size(); i++)//  auto& sline : sect1->lines)
	{
		int sline = sect1->lines[i];
		sect1->lines[i] = thisline;
		if (sline != -1)
		{
			SectionLine& newline = sectionLines[thisline];
			newline = sectionLines[sline];
			newline.section = Sections.IndexOf(sect1);
			if (i != sect1->lines.Size() - 1) newline.point2index = thisline + 1 - firstnewline;
			else newline.point2index = 0;
			assert(newline.point2index >= 0);

			// relink the partner
			if (newline.partner >= 0)
			{
				auto& partnerline = sectionLines[newline.partner];
				partnerline.partner = thisline;
				partnerline.partnersection = newline.section;
			}
			thisline++;
		}
		else
		{
			splitline1 = thisline++;
			sectionLines[splitline1].wall = -1;
			sectionLines[splitline1].section = Sections.IndexOf(sect1);
			sectionLines[splitline1].partnersection = Sections.IndexOf(sect2);
			sectionLines[splitline1].startpoint = start;
			sectionLines[splitline1].endpoint = end;
			sectionLines[splitline1].point2index = splitline1 + 1 - firstnewline;
		}
	}

	firstnewline = thisline;
	for (unsigned i = 0; i < sect2->lines.Size(); i++)//  auto& sline : sect1->lines)
	{
		int sline = sect2->lines[i];
		sect2->lines[i] = thisline;
		if (sline != -1)
		{
			SectionLine& newline = sectionLines[thisline];
			newline = sectionLines[sline];
			newline.section = Sections.IndexOf(sect1);
			if (i != sect2->lines.Size() - 1) newline.point2index = thisline + 1 - firstnewline;
			else newline.point2index = 0;
			assert(newline.point2index >= 0);

			// relink the partner
			if (newline.partner >= 0)
			{
				auto& partnerline = sectionLines[newline.partner];
				partnerline.partner = thisline;
				partnerline.partnersection = newline.section;
			}
			thisline++;
		}
		else
		{
			splitline2 = thisline++;
			sectionLines[splitline2].wall = -1;
			sectionLines[splitline2].section = Sections.IndexOf(sect2);
			sectionLines[splitline2].partnersection = Sections.IndexOf(sect1);
			sectionLines[splitline2].startpoint = end;
			sectionLines[splitline2].endpoint = start;
			sectionLines[splitline2].point2index = splitline2 + 1 - firstnewline;
		}
	}
	sectionLines[splitline1].partner = splitline2;
	sectionLines[splitline2].partner = splitline1;

	sectionspersector[sect.sector].Resize(2);
	sectionspersector[sect.sector][0] = Sections.IndexOf(sect1);
	sectionspersector[sect.sector][1] = Sections.IndexOf(sect2);
#endif
}

void hw_SplitSector(int sectnum, int start, int end)
{
	int wallstart = sector[sectnum].wallptr;
	int wallend = wallstart + sector[sectnum].wallnum;
	if (start < wallstart || start >= wallend || end < wallstart || end >= wallend || end < start) return;

	for (unsigned i = 0; i < sectionspersector[sectnum].Size(); i++)
	{
		int sect = sectionspersector[sectnum][i];
		bool foundstart = false, foundend = false;
		for (int aline : Sections[sect].lines)
		{
			int line = sectionLines[aline].wall;
			if (line == start) foundstart = true;
			if (line == end) foundend = true;
		}
		if (foundstart && foundend)
		{
			sectionspersector[sectnum].Delete(i);
			SplitSection(sect, start, end);
			return;
		}
	}
}

void hw_SetSplitSector(int sectnum, int start, int end)
{
	splits.Push(sectnum);
	splits.Push(start);
	splits.Push(end);
}

void hw_ClearSplitSector()
{
	splits.Clear();
}

// this got dumped here to move it out of the way.
static FVector3 CalcNormal(sectortype* sector, int plane)
{
	return { 0,0,0 };
}

class UVCalculator1
{
	sectortype* sect;
	int myplane;
	int stat;
	float z1;
	int ix1;
	int iy1;
	int ix2;
	int iy2;
	float sinalign, cosalign;
	FGameTexture* tex;
	float xpanning, ypanning;
	float xscaled, yscaled;
	FVector2 offset;

public:

	UVCalculator1(sectortype* sec, int plane, FGameTexture* tx, const FVector2& off)
	{
		float xpan, ypan;

		sect = sec;
		tex = tx;
		myplane = plane;
		offset = off;

		auto firstwall = sec->firstWall();
		ix1 = firstwall->x;
		iy1 = firstwall->y;
		ix2 = firstwall->point2Wall()->x;
		iy2 = firstwall->point2Wall()->y;

		if (plane == 0)
		{
			stat = sec->floorstat;
			xpan = sec->floorxpan_;
			ypan = sec->floorypan_;
			PlanesAtPoint(sec, ix1, iy1, nullptr, &z1);
		}
		else
		{
			stat = sec->ceilingstat;
			xpan = sec->ceilingxpan_;
			ypan = sec->ceilingypan_;
			PlanesAtPoint(sec, ix1, iy1, &z1, nullptr);
		}

		DVector2 dv = { double(ix2 - ix1), -double(iy2 - iy1) };
		auto vang = dv.Angle() - 90.;

		cosalign = float(vang.Cos());
		sinalign = float(vang.Sin());

		int pow2width = 1 << sizeToBits((int)tx->GetDisplayWidth());
		int pow2height = 1 << sizeToBits((int)tx->GetDisplayHeight());

		xpanning = xpan / 256.f;
		ypanning = ypan / 256.f;

		float scalefactor = (stat & CSTAT_SECTOR_TEXHALF) ? 8.0f : 16.0f;

		if ((stat & (CSTAT_SECTOR_SLOPE | CSTAT_SECTOR_ALIGN)) == (CSTAT_SECTOR_ALIGN))
		{
			// This is necessary to adjust for some imprecisions in the math.
			// To calculate the inverse Build performs an integer division with significant loss of precision
			// that can cause the texture to be shifted by multiple pixels.
			// The code below calculates the amount of this deviation so that it can be added back to the formula.
			int len = ksqrt(uhypsq(ix2 - ix1, iy2 - iy1));
			if (len != 0)
			{
				int i = 1048576 / len;
				scalefactor *= 1048576.f / (i * len);
			}
		}

		xscaled = scalefactor * pow2width;
		yscaled = scalefactor * pow2height;
	}

	FVector2 GetUV(int x, int y, float z)
	{
		float tv, tu;

		if (stat & CSTAT_SECTOR_ALIGN)
		{
			float dx = (float)(x - ix1);
			float dy = (float)(y - iy1);

			tu = -(dx * sinalign + dy * cosalign);
			tv = (dx * cosalign - dy * sinalign);

			if (stat & CSTAT_SECTOR_SLOPE)
			{
				float dz = (z - z1) * 16;
				float newtv = sqrt(tv * tv + dz * dz);
				tv = tv < 0 ? -newtv : newtv;
			}
		}
		else
		{
			tu = x - offset.X;
			tv = -y - offset.Y;
		}

		if (stat & CSTAT_SECTOR_SWAPXY)
			std::swap(tu, tv);

		if (stat & CSTAT_SECTOR_XFLIP) tu = -tu;
		if (stat & CSTAT_SECTOR_YFLIP) tv = -tv;



		return { tu / xscaled + xpanning, tv / yscaled + ypanning };

	}
};

// moved out of the way

//==========================================================================
//
//
//
//==========================================================================

bool SectorGeometry::MakeVertices(unsigned int secnum, int plane, const FVector2& offset)
{
	auto sec = &Sections[secnum];
	auto sectorp = &sector[sec->sector];
	int numvertices = sec->lines.Size();
	
	TArray<FVector3> points(numvertices, true);
	using Point = std::pair<float, float>;
	std::vector<std::vector<Point>> polygon;
	std::vector<Point>* curPoly;

	polygon.resize(1);
	curPoly = &polygon.back();
	FixedBitArray<MAXWALLSB> done;

	int fz = sectorp->floorz, cz = sectorp->ceilingz;

	int vertstoadd = numvertices;

	done.Zero();
	while (vertstoadd > 0)
	{
		int start = 0;
		while (done[start] && start < numvertices) start++;
		int s = start;
		if (start >= 0 && start < numvertices)
		{
			while (start >= 0 && start < numvertices && !done[start])
			{
				auto sline = &sectionLines[sec->lines[start]];
				auto wallp = &wall[sline->startpoint];
				float X = float(WallStartX(wallp));
				float Y = float(WallStartY(wallp));
				if (fabs(X) > 32768.f || fabs(Y) > 32768.f)
				{
					// If we get here there's some fuckery going around with the coordinates. Let's better abort and wait for things to realign.
					// Do not try alternative methods if this happens.
					return true;
				}
				curPoly->push_back(std::make_pair(X, Y));
				done.Set(start);
				vertstoadd--;
				start = sline->point2index;
			}
			polygon.resize(polygon.size() + 1);
			curPoly = &polygon.back();
			if (start != s) return false; // means the sector is badly defined. RRRA'S E1L3 triggers this.
		}
	}
	// Now make sure that the outer boundary is the first polygon by picking a point that's as much to the outside as possible.
	int outer = 0;
	float minx = FLT_MAX;
	float miny = FLT_MAX;
	for (size_t a = 0; a < polygon.size(); a++)
	{
		for (auto& pt : polygon[a])
		{
			if (pt.first < minx || (pt.first == minx && pt.second < miny))
			{
				minx = pt.first;
				miny = pt.second;
				outer = int(a);
			}
		}
	}
	if (outer != 0) std::swap(polygon[0], polygon[outer]);
	auto indices = mapbox::earcut(polygon);
	if (indices.size() < 3 * (sec->lines.Size() - 2))
	{
		// this means that full triangulation failed.
		return false;
	}
	sectorp->floorz = sectorp->ceilingz = 0;

	int p = 0;
	for (size_t a = 0; a < polygon.size(); a++)
	{
		for (auto& pt : polygon[a])
		{
			float planez = 0;
			PlanesAtPoint(sectorp, (pt.first * 16), (pt.second * -16), plane ? &planez : nullptr, !plane ? &planez : nullptr);
			FVector3 point = { pt.first, pt.second, planez };
			points[p++] = point;
		}
	}
	
	auto& entry = data[secnum].planes[plane];
	entry.vertices.Resize((unsigned)indices.size());
	entry.texcoords.Resize((unsigned)indices.size());
	entry.normal = CalcNormal(sectorp, plane);

	auto texture = tileGetTexture(plane ? sectorp->ceilingpicnum : sectorp->floorpicnum);

	UVCalculator1 uvcalc(sectorp, plane, texture, offset);
	
	for(unsigned i = 0; i < entry.vertices.Size(); i++)
	{
		auto& pt = points[indices[i]];
		entry.vertices[i] = pt;
		entry.texcoords[i] = uvcalc.GetUV(int(pt.X * 16), int(pt.Y * -16), pt.Z);
	}

	sectorp->floorz = fz;
	sectorp->ceilingz = cz;
	return true;
}

//==========================================================================
//
// Use ZDoom's node builder if the simple approach fails.
// This will create something usable in the vast majority of cases, 
// even if the result is less efficient.
//
//==========================================================================

bool SectorGeometry::MakeVertices2(unsigned int secnum, int plane, const FVector2& offset)
{
	auto sec = &Sections[secnum];
	auto sectorp = &sector[sec->sector];
	int numvertices = sec->lines.Size();

	// Convert our sector into something the node builder understands
	TArray<vertex_t> vertexes(sectorp->wallnum, true);
	TArray<line_t> lines(numvertices, true);
	TArray<side_t> sides(numvertices, true);
	int j = 0;

	for (int i = 0; i < numvertices; i++)
	{
		auto sline = &sectionLines[sec->lines[i]];
		if (sline->point2index < 0) continue; // Exhumed LEV14 triggers this on sector 169.

		auto wallp = &wall[sline->startpoint];
		vertexes[j].p = { wallp->x * (1 / 16.), wallp->y * (1 / -16.) };

		if (fabs(vertexes[j].p.X) > 32768.f || fabs(vertexes[j].p.Y) > 32768.f)
		{
			// If we get here there's some fuckery going around with the coordinates. Let's better abort and wait for things to realign.
			return true;
		}

		lines[j].backsector = nullptr;
		lines[j].frontsector = sectorp;
		lines[j].linenum = j;
		lines[j].wallnum = sline->wall;
		lines[j].sidedef[0] = &sides[j];
		lines[j].sidedef[1] = nullptr;
		lines[j].v1 = &vertexes[j];
		lines[j].v2 = &vertexes[sline->point2index + j - i];

		sides[j].sidenum = j;
		sides[j].sector = sectorp;
		j++;
	}

	vertexes.Clamp(j);
	lines.Clamp(j);
	sides.Clamp(j);
	// Weed out any overlaps. These often happen with door setups and can lead to bad subsectors
	for (unsigned i = 0; i < lines.Size(); i++)
	{
		auto p1 = lines[i].v1->p, p2 = lines[i].v2->p;

		// Throw out any line with zero length.
		if (p1 == p2)
		{
			lines.Delete(i);
			i--;
			continue;
		}

		for (unsigned j = i + 1; j < lines.Size(); j++)
		{
			auto pp1 = lines[j].v1->p, pp2 = lines[j].v2->p;

			if (pp1 == p2 && pp2 == p1)
			{
				// handle the simple case first, i.e. line j is the inverse of line i.
				// in this case both lines need to be deleted.
				lines.Delete(j);
				lines.Delete(i);
				i--;
				goto nexti;
			}
			else if (pp1 == p2)
			{
				// only the second line's start point matches.
				// In this case we have to delete the shorter line and truncate the other one.

				// check if the second line's end point is on the line we are checking
				double d1 = PointOnLineSide(pp2, p1, p2);
				if (fabs(d1) > FLT_EPSILON) continue; // not colinear
				bool vert = p1.X == p2.X;
				double p1x = vert ? p1.X : p1.Y;
				double p2x = vert ? p2.X : p2.Y;
				double pp1x = vert ? pp1.X : pp1.Y;
				double pp2x = vert ? pp2.X : pp2.Y;

				if (pp2x > min(p1x, p2x) && pp2x < max(p1x, p2x))
				{
					// pp2 is on line i.
					lines[i].v2 = lines[j].v2;
					lines.Delete(j);
					continue;
				}
				else if (p1x > min(pp1x, pp2x) && p1x < max(pp1x, pp2x))
				{
					// p1 is on line j
					lines[j].v1 = lines[j].v2;
					lines.Delete(i);
					goto nexti;
				}
			}
			else if (pp2 == p1)
			{
				// only the second line's start point matches.
				// In this case we have to delete the shorter line and truncate the other one.

				// check if the second line's end point is on the line we are checking
				double d1 = PointOnLineSide(pp1, p1, p2);
				if (fabs(d1) > FLT_EPSILON) continue; // not colinear
				bool vert = p1.X == p2.X;
				double p1x = vert ? p1.X : p1.Y;
				double p2x = vert ? p2.X : p2.Y;
				double pp1x = vert ? pp1.X : pp1.Y;
				double pp2x = vert ? pp2.X : pp2.Y;

				if (pp1x > min(p1x, p2x) && pp1x < max(p1x, p2x))
				{
					// pp1 is on line i.
					lines[i].v1 = lines[j].v1;
					lines.Delete(j);
					continue;
				}
				else if (p2x > min(pp1x, pp2x) && p2x < max(pp1x, pp2x))
				{
					// p2 is on line j
					lines[j].v2 = lines[j].v1;
					lines.Delete(i);
					goto nexti;
				}
			}
			else
			{
				// no idea if we should do further checks here. Blood's doors do not need them. We'll see.
			}
		}
nexti:;
	}

	if (lines.Size() < 4)
	{
		// nothing to generate. If line count is < 4 this sector is degenerate and should not be processed further.
		auto& entry = data[secnum].planes[plane];
		entry.vertices.Clear();
		entry.texcoords.Clear();
		return true;
	}


	FNodeBuilder::FLevel leveldata =
	{
		&vertexes[0], (int)vertexes.Size(),
		&sides[0], (int)sides.Size(),
		&lines[0], (int)lines.Size(),
		0, 0, 0, 0
	};
	leveldata.FindMapBounds();
	FNodeBuilder builder(leveldata);

	FLevelLocals Level;
	builder.Extract(Level);

	// Now turn the generated subsectors into triangle meshes

	auto& entry = data[secnum].planes[plane];
	entry.vertices.Clear();
	entry.texcoords.Clear();

	int fz = sectorp->floorz, cz = sectorp->ceilingz;
	sectorp->floorz = sectorp->ceilingz = 0;

	for (auto& sub : Level.subsectors)
	{
		if (sub.numlines <= 2) continue;
		auto v0 = sub.firstline->v1;
		for (unsigned i = 1; i < sub.numlines - 1; i++)
		{
			auto v1 = sub.firstline[i].v1;
			auto v2 = sub.firstline[i].v2;

			entry.vertices.Push({ (float)v0->fX(), (float)v0->fY(), 0 });
			entry.vertices.Push({ (float)v1->fX(), (float)v1->fY(), 0 });
			entry.vertices.Push({ (float)v2->fX(), (float)v2->fY(), 0 });

		}

	}

	// calculate the rest.
	auto texture = tileGetTexture(plane ? sectorp->ceilingpicnum : sectorp->floorpicnum);

	UVCalculator1 uvcalc(sectorp, plane, texture, offset);

	entry.texcoords.Resize(entry.vertices.Size());
	for (unsigned i = 0; i < entry.vertices.Size(); i++)
	{
		auto& pt = entry.vertices[i];

		float planez = 0;
		PlanesAtPoint(sectorp, (pt.X * 16), (pt.Y * -16), plane ? &planez : nullptr, !plane ? &planez : nullptr);
		entry.vertices[i].Z = planez;
		entry.texcoords[i] = uvcalc.GetUV(int(pt.X * 16.), int(pt.Y * -16.), pt.Z);
	}
	entry.normal = CalcNormal(sectorp, plane);
	sectorp->floorz = fz;
	sectorp->ceilingz = cz;
	return true;
}

//==========================================================================
//
//
//
//==========================================================================

void SectorGeometry::ValidateSector(unsigned int secnum, int plane, const FVector2& offset)
{
	auto sec = &sector[Sections[secnum].sector];

	auto compare = &data[secnum].compare[plane];
	if (plane == 0)
	{
		if (sec->floorheinum == compare->floorheinum &&
			sec->floorpicnum == compare->floorpicnum &&
			((sec->floorstat ^ compare->floorstat) & (CSTAT_SECTOR_ALIGN | CSTAT_SECTOR_YFLIP | CSTAT_SECTOR_XFLIP | CSTAT_SECTOR_TEXHALF | CSTAT_SECTOR_SWAPXY)) == 0 &&
			sec->floorxpan_ == compare->floorxpan_ &&
			sec->floorypan_ == compare->floorypan_ &&
			sec->firstWall()->pos == data[secnum].poscompare[0] &&
			sec->firstWall()->point2Wall()->pos == data[secnum].poscompare2[0] &&
			!(sec->dirty & 1) && data[secnum].planes[plane].vertices.Size() ) return;

		sec->dirty &= ~1;
	}
	else
	{
		if (sec->ceilingheinum == compare->ceilingheinum &&
			sec->ceilingpicnum == compare->ceilingpicnum &&
			((sec->ceilingstat ^ compare->ceilingstat) & (CSTAT_SECTOR_ALIGN | CSTAT_SECTOR_YFLIP | CSTAT_SECTOR_XFLIP | CSTAT_SECTOR_TEXHALF | CSTAT_SECTOR_SWAPXY)) == 0 &&
			sec->ceilingxpan_ == compare->ceilingxpan_ &&
			sec->ceilingypan_ == compare->ceilingypan_ &&
			sec->firstWall()->pos == data[secnum].poscompare[1] &&
			sec->firstWall()->point2Wall()->pos == data[secnum].poscompare2[1] &&
			!(sec->dirty & 2) && data[secnum].planes[1].vertices.Size()) return;

		sec->dirty &= ~2;
	}
	*compare = *sec;
	data[secnum].poscompare[plane] = sec->firstWall()->pos;
	data[secnum].poscompare2[plane] = sec->firstWall()->point2Wall()->pos;
	if (data[secnum].degenerate || !MakeVertices(secnum, plane, offset))
	{
		data[secnum].degenerate = true;
		//Printf(TEXTCOLOR_YELLOW "Normal triangulation failed for sector %d. Retrying with alternative approach\n", secnum);
		MakeVertices2(secnum, plane, offset);
	}
}