mirror of
https://github.com/DrBeef/Raze.git
synced 2024-11-15 08:52:00 +00:00
582 lines
17 KiB
C++
582 lines
17 KiB
C++
/*
|
|
/*
|
|
** sectorgeometry.cpp
|
|
**
|
|
** caches the triangle meshes used for rendering sector planes.
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** 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.
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
**
|
|
*/
|
|
|
|
#include "sectorgeometry.h"
|
|
#include "build.h"
|
|
#include "gamefuncs.h"
|
|
#include "texturemanager.h"
|
|
#include "earcut.hpp"
|
|
#include "hw_sections2.h"
|
|
#include "tesselator.h"
|
|
|
|
SectionGeometry sectionGeometry;
|
|
|
|
//==========================================================================
|
|
//
|
|
// CalcPlane fixme - this should be stored in the sector, not be recalculated each frame.
|
|
//
|
|
//==========================================================================
|
|
|
|
static FVector3 CalcNormal(sectortype* sector, int plane)
|
|
{
|
|
FVector3 pt[3];
|
|
|
|
auto wal = sector->firstWall();
|
|
auto wal2 = wal->point2Wall();
|
|
|
|
pt[0] = { (float)WallStartX(wal), (float)WallStartY(wal), 0 };
|
|
pt[1] = { (float)WallEndX(wal), (float)WallEndY(wal), 0 };
|
|
PlanesAtPoint(sector, wal->x, wal->y, plane ? &pt[0].Z : nullptr, plane? nullptr : &pt[0].Z);
|
|
PlanesAtPoint(sector, wal2->x, wal2->y, plane ? &pt[1].Z : nullptr, plane ? nullptr : &pt[1].Z);
|
|
|
|
if (pt[0].X == pt[1].X)
|
|
{
|
|
if (pt[0].Y == pt[1].Y) return { 0.f, 0.f, plane ? -1.f : 1.f };
|
|
pt[2].X = pt[0].X + 4;
|
|
pt[2].Y = pt[0].Y;
|
|
}
|
|
else
|
|
{
|
|
pt[2].X = pt[0].X;
|
|
pt[2].Y = pt[0].Y + 4;
|
|
}
|
|
PlanesAtPoint(sector, pt[2].X * 16, pt[2].Y * 16, plane ? &pt[2].Z : nullptr, plane ? nullptr : &pt[2].Z);
|
|
|
|
auto normal = (pt[2] - pt[0]) ^ (pt[1] - pt[0]);
|
|
|
|
if ((pt[2].Z < 0 && !plane) || (pt[2].Z > 0 && plane)) return -pt[2];
|
|
return pt[2];
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// The math used here to calculate texture positioning was derived from
|
|
// Polymer but required several fixes for correctness.
|
|
//
|
|
//==========================================================================
|
|
class UVCalculator
|
|
{
|
|
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:
|
|
|
|
UVCalculator(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 };
|
|
|
|
}
|
|
};
|
|
|
|
|
|
enum class ETriangulateResult
|
|
{
|
|
Ok = 0,
|
|
Failed = 1, // unable to triangulate
|
|
Invalid = 2, // input data invalid.
|
|
};
|
|
|
|
//==========================================================================
|
|
//
|
|
// Convert the outline to render coordinates.
|
|
//
|
|
//==========================================================================
|
|
|
|
static int OutlineToFloat(Outline& outl, FOutline& polygon)
|
|
{
|
|
polygon.resize(outl.Size());
|
|
unsigned count = 0;
|
|
for (unsigned i = 0; i < outl.Size(); i++)
|
|
{
|
|
polygon[i].resize(outl[i].Size());
|
|
count += outl[i].Size();
|
|
for (unsigned j = 0; j < outl[i].Size(); j++)
|
|
{
|
|
float X = RenderX(outl[i][j].x);
|
|
float Y = RenderY(outl[i][j].y);
|
|
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 -1;
|
|
}
|
|
polygon[i][j] = { X, Y };
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Try to triangulate a given outline with Earcut.
|
|
//
|
|
//==========================================================================
|
|
|
|
ETriangulateResult TriangulateOutlineEarcut(const FOutline& polygon, int count, TArray<FVector2>& points, TArray<int>& indicesOut)
|
|
{
|
|
// Sections are already validated so we can assume that the data is well defined here.
|
|
|
|
auto indices = mapbox::earcut(polygon);
|
|
size_t numtriangles = count + (polygon.size() - 1) * 2 - 2; // accout for the extra connections needed to turn the polygon into s single loop.
|
|
if (indices.size() < numtriangles * 3)
|
|
{
|
|
// this means that full triangulation failed.
|
|
return ETriangulateResult::Failed;
|
|
}
|
|
points.Resize(count);
|
|
int p = 0;
|
|
for (size_t a = 0; a < polygon.size(); a++)
|
|
{
|
|
for (auto& pt : polygon[a])
|
|
{
|
|
points[p++] = { pt.first, pt.second };
|
|
}
|
|
}
|
|
indicesOut.Resize((unsigned)indices.size());
|
|
for (unsigned i = 0; i < indices.size(); i++)
|
|
{
|
|
indicesOut[i] = indices[i];
|
|
}
|
|
return ETriangulateResult::Ok;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Try to triangulate a given outline with libtess2.
|
|
//
|
|
//==========================================================================
|
|
FMemArena tessArena(100000);
|
|
|
|
ETriangulateResult TriangulateOutlineLibtess(const FOutline& polygon, int count, TArray<FVector2>& points, TArray<int>& indicesOut)
|
|
{
|
|
tessArena.FreeAll();
|
|
|
|
auto poolAlloc = [](void* userData, unsigned int size) -> void*
|
|
{
|
|
FMemArena* pool = (FMemArena*)userData;
|
|
return pool->Alloc(size);
|
|
};
|
|
|
|
auto poolFree = [](void*, void*)
|
|
{
|
|
};
|
|
|
|
TESSalloc ma{};
|
|
ma.memalloc = poolAlloc;
|
|
ma.memfree = poolFree;
|
|
ma.userData = (void*)&tessArena;
|
|
ma.extraVertices = 256; // realloc not provided, allow 256 extra vertices.
|
|
|
|
auto tess = tessNewTess(&ma);
|
|
if (!tess)
|
|
return ETriangulateResult::Failed;
|
|
|
|
tessSetOption(tess, TESS_CONSTRAINED_DELAUNAY_TRIANGULATION, 0);
|
|
tessSetOption(tess, TESS_REVERSE_CONTOURS, 1);
|
|
|
|
// Add contours.
|
|
for (auto& loop : polygon)
|
|
tessAddContour(tess, 2, &loop.data()->first, (int)sizeof(*loop.data()), (int)loop.size());
|
|
|
|
int result = tessTesselate(tess, TESS_WINDING_POSITIVE, TESS_POLYGONS, 3, 2, nullptr);
|
|
if (!result)
|
|
{
|
|
tessDeleteTess(tess);
|
|
return ETriangulateResult::Failed;
|
|
}
|
|
|
|
const float* verts = tessGetVertices(tess);
|
|
const int* vinds = tessGetVertexIndices(tess);
|
|
const int* elems = tessGetElements(tess);
|
|
const int nverts = tessGetVertexCount(tess);
|
|
const int nelems = tessGetElementCount(tess) * 3; // an 'element' here is a full triangle, not a single vertex like in OpenGL...
|
|
|
|
points.Resize(nverts);
|
|
indicesOut.Resize(nelems);
|
|
for (int i = 0; i < nverts; i++)
|
|
{
|
|
points[i] = { verts[i * 2], verts[i * 2 + 1] };
|
|
}
|
|
for (int i = 0; i < nelems; i++)
|
|
{
|
|
indicesOut[i] = elems[i];
|
|
}
|
|
return ETriangulateResult::Ok;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Try to triangulate a given outline with the ZDoom node builder.
|
|
//
|
|
//==========================================================================
|
|
|
|
#if 0
|
|
ETriangulateResult TriangulateOutlineNodeBuild(const FOutline& polygon, int count, TArray<FVector2>& points, TArray<int>& indicesOut)
|
|
{
|
|
TArray<vertex_t> vertexes(count, true);
|
|
TArray<line_t> lines(count, true);
|
|
TArray<side_t> sides(count, true);
|
|
sectortype dummy;
|
|
|
|
int n = 0;
|
|
for (size_t i = 0; i < polygon.size(); i++)
|
|
{
|
|
int firstn = n;
|
|
for (size_t j = 0; j < polygon[i].size(); i++)
|
|
{
|
|
vertexes[n].set(polygon[i][j].first, polygon[i][j].second);
|
|
|
|
lines[n].backsector = nullptr;
|
|
lines[n].frontsector = &dummy;
|
|
lines[n].linenum = (int)j;
|
|
lines[n].wallnum = n;
|
|
lines[n].sidedef[0] = &sides[n];
|
|
lines[n].sidedef[1] = nullptr;
|
|
lines[n].v1 = &vertexes[n];
|
|
lines[n].v2 = j == polygon[i].size() ? &vertexes[firstn] : &vertexes[n + 1];
|
|
|
|
sides[n].sidenum = n;
|
|
sides[n].sector = &dummy;
|
|
|
|
}
|
|
}
|
|
|
|
FNodeBuilder::FLevel leveldata =
|
|
{
|
|
&vertexes[0], count,
|
|
&sides[0], count,
|
|
&lines[0], count,
|
|
0, 0, 0, 0
|
|
};
|
|
leveldata.FindMapBounds();
|
|
FNodeBuilder builder(leveldata);
|
|
|
|
FLevelLocals Level;
|
|
builder.Extract(Level);
|
|
|
|
points.Resize(Level.vertexes.Size());
|
|
for (unsigned i = 0; i < Level.vertexes.Size(); i++)
|
|
{
|
|
points[i] = { (float)Level.vertexes[i].fX(), (float)Level.vertexes[i].fY() };
|
|
}
|
|
|
|
indicesOut.Clear();
|
|
for (auto& sub : Level.subsectors)
|
|
{
|
|
if (sub.numlines <= 2) continue;
|
|
auto v0 = Level.vertexes.IndexOf(sub.firstline->v1);
|
|
for (unsigned i = 1; i < sub.numlines - 1; i++)
|
|
{
|
|
auto v1 = Level.vertexes.IndexOf(sub.firstline->v1);
|
|
auto v2 = Level.vertexes.IndexOf(sub.firstline->v2);
|
|
indicesOut.Push(v0);
|
|
indicesOut.Push(v1);
|
|
indicesOut.Push(v2);
|
|
}
|
|
}
|
|
return ETriangulateResult::Ok;
|
|
}
|
|
#endif
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
bool SectionGeometry::ValidateSection(Section* section, int plane)
|
|
{
|
|
auto sec = §or[section->sector];
|
|
auto& sdata = data[section->index];
|
|
|
|
auto compare = &sdata.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 == sdata.poscompare[0] &&
|
|
sec->firstWall()->point2Wall()->pos == sdata.poscompare2[0] &&
|
|
!(section->dirty & EDirty::FloorDirty) && sdata.planes[plane].vertices.Size() ) return true;
|
|
|
|
section->dirty &= EDirty::FloorDirty;
|
|
}
|
|
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 == sdata.poscompare[1] &&
|
|
sec->firstWall()->point2Wall()->pos == sdata.poscompare2[1] &&
|
|
!(section->dirty & EDirty::CeilingDirty) && sdata.planes[1].vertices.Size()) return true;
|
|
|
|
section->dirty &= ~EDirty::CeilingDirty;
|
|
}
|
|
*compare = *sec;
|
|
sdata.poscompare[plane] = sec->firstWall()->pos;
|
|
sdata.poscompare2[plane] = sec->firstWall()->point2Wall()->pos;
|
|
return false;
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
bool SectionGeometry::CreateMesh(Section* section)
|
|
{
|
|
auto outline = BuildOutline(section);
|
|
FOutline foutline;
|
|
int count = OutlineToFloat(outline, foutline);
|
|
if (count == -1) return false; // gotta wait...
|
|
TArray<FVector2> meshVertices;
|
|
TArray<int> meshIndices;
|
|
ETriangulateResult result = ETriangulateResult::Failed;
|
|
|
|
auto& sdata = data[section->index];
|
|
|
|
if (!(section->flags & NoEarcut))
|
|
{
|
|
result = TriangulateOutlineEarcut(foutline, count, sdata.meshVertices, sdata.meshIndices);
|
|
}
|
|
if (result == ETriangulateResult::Failed && !(section->geomflags & NoLibtess))
|
|
{
|
|
section->geomflags |= NoEarcut;
|
|
result = TriangulateOutlineLibtess(foutline, count, sdata.meshVertices, sdata.meshIndices);
|
|
}
|
|
#if 0
|
|
if (result == ETriangulateResult::Failed)
|
|
{
|
|
section->geomflags |= NoLibtess;
|
|
result = TriangulateOutlineNodeBuild(foutline, count, sdata.meshVertices, meshIndices);
|
|
}
|
|
#endif
|
|
|
|
sdata.planes[0].vertices.Clear();
|
|
sdata.planes[1].vertices.Clear();
|
|
section->dirty &= ~EDirty::GeometryDirty;
|
|
section->dirty |= EDirty::FloorDirty | EDirty::CeilingDirty;
|
|
return true;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// assumes that the geometry has already been validated.
|
|
//
|
|
//==========================================================================
|
|
|
|
void SectionGeometry::CreatePlaneMesh(Section* section, int plane, const FVector2& offset)
|
|
{
|
|
auto sectorp = §or[section->sector];
|
|
// calculate the rest.
|
|
auto texture = tileGetTexture(plane ? sectorp->ceilingpicnum : sectorp->floorpicnum);
|
|
auto& sdata = data[section->index];
|
|
auto& entry = sdata.planes[plane];
|
|
int fz = sectorp->floorz, cz = sectorp->ceilingz;
|
|
sectorp->floorz = sectorp->ceilingz = 0;
|
|
|
|
UVCalculator uvcalc(sectorp, plane, texture, offset);
|
|
|
|
entry.vertices.Resize(sdata.meshVertices.Size());
|
|
entry.texcoords.Resize(entry.vertices.Size());
|
|
|
|
for (unsigned i = 0; i < entry.vertices.Size(); i++)
|
|
{
|
|
auto& org = sdata.meshVertices[i];
|
|
auto& pt = entry.vertices[i];
|
|
auto& tc = entry.texcoords[i];
|
|
|
|
pt.X = org.X; pt.Y = org.Y;
|
|
PlanesAtPoint(sectorp, (pt.X * 16), (pt.Y * -16), plane ? &pt.Z : nullptr, !plane ? &pt.Z : nullptr);
|
|
tc = uvcalc.GetUV(int(pt.X * 16.), int(pt.Y * -16.), pt.Z);
|
|
}
|
|
entry.normal = CalcNormal(sectorp, plane);
|
|
sectorp->floorz = fz;
|
|
sectorp->ceilingz = cz;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void SectionGeometry::MarkDirty(sectortype* sector)
|
|
{
|
|
for (auto section : sectionsPerSector[sectnum(sector)])
|
|
{
|
|
section->dirty = sector->dirty;
|
|
}
|
|
sector->dirty = 0;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
SectionGeometryPlane* SectionGeometry::get(Section* section, int plane, const FVector2& offset, TArray<int>** pIndices)
|
|
{
|
|
if (!section || section->index >= data.Size()) return nullptr;
|
|
auto sectp = §or[section->sector];
|
|
if (sectp->dirty) MarkDirty(sectp);
|
|
if (section->dirty & EDirty::GeometryDirty)
|
|
{
|
|
bool res = CreateMesh(section);
|
|
if (!res)
|
|
{
|
|
section->dirty &= ~EDirty::GeometryDirty; // sector is in an invalid state, so pretend the old setup is still valid. Happens in some SW maps.
|
|
}
|
|
}
|
|
if (!ValidateSection(section, plane))
|
|
{
|
|
CreatePlaneMesh(section, plane, offset);
|
|
}
|
|
*pIndices = &data[section->index].meshIndices;
|
|
return &data[section->index].planes[plane];
|
|
}
|