gzdoom-gles/src/maploader/renderinfo.cpp

786 lines
20 KiB
C++
Raw Normal View History

//
//---------------------------------------------------------------------------
//
// Copyright(C) 2005-2016 Christoph Oelckers
// All rights reserved.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see http://www.gnu.org/licenses/
//
//--------------------------------------------------------------------------
//
/*
** gl_setup.cpp
** Initializes the data structures required by the hardware renderer to handle
** render hacks and optimization.
**
**/
#include "doomtype.h"
#include "p_local.h"
2016-02-16 21:01:04 +00:00
#include "p_spec.h"
#include "p_lnspec.h"
#include "c_dispatch.h"
#include "r_sky.h"
#include "p_setup.h"
#include "g_levellocals.h"
#include "maploader.h"
//==========================================================================
//
// Map section generation
// Map sections are physically separated parts of the map.
// If the player is in section A, any map part in other sections can
// often be quickly discarded to improve performance.
//
//==========================================================================
struct MapSectionGenerator
{
struct cvertex_t
{
double X, Y;
operator int() const { return xs_FloorToInt(X) + 65536 * xs_FloorToInt(Y); }
bool operator!= (const cvertex_t &other) const { return fabs(X - other.X) >= EQUAL_EPSILON || fabs(Y - other.Y) >= EQUAL_EPSILON; }
cvertex_t& operator =(const vertex_t *v) { X = v->fX(); Y = v->fY(); return *this; }
};
MapSectionGenerator(FLevelLocals *l)
{
Level = l;
}
typedef TMap<cvertex_t, int> FSectionVertexMap;
TArray<subsector_t *> MapSectionCollector;
FLevelLocals *Level;
//==========================================================================
//
//
//
//==========================================================================
void DoSetMapSection(subsector_t *sub, int num)
{
MapSectionCollector.Resize(1);
MapSectionCollector[0] = sub;
sub->mapsection = num;
for (unsigned a = 0; a < MapSectionCollector.Size(); a++)
{
sub = MapSectionCollector[a];
for (uint32_t i = 0; i < sub->numlines; i++)
{
seg_t * seg = sub->firstline + i;
if (seg->PartnerSeg)
{
subsector_t * sub2 = seg->PartnerSeg->Subsector;
if (sub2->mapsection != num)
{
assert(sub2->mapsection == 0);
sub2->mapsection = num;
MapSectionCollector.Push(sub2);
}
}
}
}
MapSectionCollector.Clear();
}
//==========================================================================
//
// Merge sections. This is needed in case the map contains errors
// like overlapping lines resulting in abnormal subsectors.
//
// This function ensures that any vertex position can only be in one section.
//
//==========================================================================
int MergeMapSections(int num)
{
FSectionVertexMap vmap;
FSectionVertexMap::Pair *pair;
TArray<int> sectmap;
TArray<bool> sectvalid;
sectmap.Resize(num);
sectvalid.Resize(num);
for (int i = 0; i < num; i++)
{
sectmap[i] = -1;
sectvalid[i] = true;
}
int mergecount = 1;
cvertex_t vt;
// first step: Set mapsection for all vertex positions.
for (auto &seg : Level->segs)
{
int section = seg.Subsector->mapsection;
for (int j = 0; j < 2; j++)
{
vt = j == 0 ? seg.v1 : seg.v2;
vmap[vt] = section;
}
}
// second step: Check if any seg references more than one mapsection, either by subsector or by vertex
for (auto &seg : Level->segs)
{
int section = seg.Subsector->mapsection;
for (int j = 0; j < 2; j++)
{
vt = j == 0 ? seg.v1 : seg.v2;
int vsection = vmap[vt];
if (vsection != section)
{
// These 2 sections should be merged
for (auto &sub : Level->subsectors)
{
if (sub.mapsection == vsection) sub.mapsection = section;
}
FSectionVertexMap::Iterator it(vmap);
while (it.NextPair(pair))
{
if (pair->Value == vsection) pair->Value = section;
}
sectvalid[vsection - 1] = false;
}
}
}
for (int i = 0; i < num; i++)
{
if (sectvalid[i]) sectmap[i] = mergecount++;
}
for (auto &sub : Level->subsectors)
{
sub.mapsection = sectmap[sub.mapsection - 1];
assert(sub.mapsection != -1);
}
return mergecount - 1;
}
//==========================================================================
//
//
//
//==========================================================================
void SetMapSections()
{
bool set;
int num = 0;
do
{
set = false;
for (auto &sub : Level->subsectors)
{
if (sub.mapsection == 0)
{
num++;
DoSetMapSection(&sub, num);
set = true;
break;
}
}
}
while (set);
num = MergeMapSections(num);
Level->NumMapSections = num;
#ifdef DEBUG
Printf("%d map sections found\n", num);
#endif
}
};
//==========================================================================
//
// prepare subsectors for GL rendering
// - analyze rendering hacks using open sectors
// - assign a render sector (for self referencing sectors)
// - calculate a bounding box
//
//==========================================================================
static void SpreadHackedFlag(subsector_t * sub)
{
// The subsector pointer hasn't been set yet!
for(uint32_t i=0;i<sub->numlines;i++)
{
seg_t * seg = sub->firstline + i;
if (seg->PartnerSeg)
{
subsector_t * sub2 = seg->PartnerSeg->Subsector;
if (!(sub2->hacked&1) && sub2->render_sector == sub->render_sector)
{
sub2->hacked|=1;
sub->hacked &= ~4;
SpreadHackedFlag (sub2);
}
}
}
}
//==========================================================================
//
//
//
//==========================================================================
void MapLoader::PrepareSectorData()
{
TArray<subsector_t *> undetermined;
// now group the subsectors by sector
Level->subsectorbuffer.Resize(Level->subsectors.Size());
for (auto &sub : Level->subsectors)
{
sub.render_sector->subsectorcount++;
}
auto subsectorbuffer = Level->subsectorbuffer.Data();
for (auto &sec : Level->sectors)
{
sec.subsectors = subsectorbuffer;
subsectorbuffer += sec.subsectorcount;
sec.subsectorcount = 0;
}
for (auto &sub : Level->subsectors)
{
sub.render_sector->subsectors[sub.render_sector->subsectorcount++] = &sub;
}
// marks all malformed subsectors so rendering tricks using them can be handled more easily
for (auto &sub : Level->subsectors)
{
if (sub.sector == sub.render_sector)
{
seg_t * seg = sub.firstline;
for(uint32_t j=0;j<sub.numlines;j++)
{
if (!(sub.hacked&1) && seg[j].linedef==0 &&
seg[j].PartnerSeg!=NULL &&
sub.render_sector != seg[j].PartnerSeg->Subsector->render_sector)
{
2016-08-28 08:11:09 +00:00
DPrintf(DMSG_NOTIFY, "Found hack: (%f,%f) (%f,%f)\n", seg[j].v1->fX(), seg[j].v1->fY(), seg[j].v2->fX(), seg[j].v2->fY());
sub.hacked|=5;
SpreadHackedFlag(&sub);
}
if (seg[j].PartnerSeg==NULL) sub.hacked|=2; // used for quick termination checks
}
}
}
MapSectionGenerator msg(Level);
msg.SetMapSections();
}
//==========================================================================
//
// Some processing for transparent door hacks using a floor raised by 1 map unit
// - This will be used to lower the floor of such sectors by one map unit
//
//==========================================================================
void MapLoader::PrepareTransparentDoors(sector_t * sector)
{
bool solidwall=false;
unsigned int notextures=0;
unsigned int nobtextures=0;
unsigned int selfref=0;
sector_t * nextsec=NULL;
if (sector->subsectorcount==0) return;
sector->transdoorheight=sector->GetPlaneTexZ(sector_t::floor);
2016-03-29 11:45:50 +00:00
sector->transdoor= !(sector->e->XFloor.ffloors.Size() || sector->heightsec || sector->floorplane.isSlope());
if (sector->transdoor)
{
for (auto ln : sector->Lines)
{
if (ln->frontsector == ln->backsector)
{
selfref++;
continue;
}
sector_t * sec=getNextSector(ln, sector);
if (sec==NULL)
{
solidwall=true;
continue;
}
else
{
nextsec=sec;
int side = ln->sidedef[0]->sector == sec;
if (sector->GetPlaneTexZ(sector_t::floor)!=sec->GetPlaneTexZ(sector_t::floor)+1. || sec->floorplane.isSlope())
{
sector->transdoor=false;
return;
}
if (!ln->sidedef[1-side]->GetTexture(side_t::top).isValid()) notextures++;
if (!ln->sidedef[1-side]->GetTexture(side_t::bottom).isValid()) nobtextures++;
}
}
if (sector->GetTexture(sector_t::ceiling)==skyflatnum)
{
sector->transdoor=false;
return;
}
if (selfref+nobtextures!=sector->Lines.Size())
{
sector->transdoor=false;
}
if (selfref+notextures!=sector->Lines.Size())
{
// This is a crude attempt to fix an incorrect transparent door effect I found in some
// WolfenDoom maps but considering the amount of code required to handle it I left it in.
// Do this only if the sector only contains one-sided walls or ones with no lower texture.
if (solidwall)
{
if (solidwall+nobtextures+selfref==sector->Lines.Size() && nextsec)
{
sector->heightsec=nextsec;
sector->heightsec->MoreFlags=0;
}
sector->transdoor=false;
}
}
}
}
//==========================================================================
//
//
//
//==========================================================================
static void AddToVertex(int secno, TArray<int> & list)
{
for(unsigned i=0;i<list.Size();i++)
{
if (list[i]==secno) return;
}
list.Push(secno);
}
//==========================================================================
//
// Attach sectors to vertices - used to generate vertex height lists
//
//==========================================================================
void MapLoader::InitVertexData()
{
TArray<TArray<int>> vt_sectorlists(Level->vertexes.Size(), true);
for(auto &line : Level->lines)
{
for(int j = 0; j < 2; ++j)
{
vertex_t * v = j==0? line.v1 : line.v2;
for(int k = 0; k < 2; ++k)
{
sector_t * sec = k==0? line.frontsector : line.backsector;
if (sec)
{
extsector_t::xfloor &x = sec->e->XFloor;
AddToVertex(Index(sec), vt_sectorlists[Index(v)]);
if (sec->heightsec) AddToVertex(Index(sec->heightsec), vt_sectorlists[Index(v)]);
}
}
}
}
for(unsigned i = 0; i < Level->vertexes.Size(); ++i)
{
auto &vert = Level->vertexes[i];
int cnt = vt_sectorlists[i].Size();
2017-01-08 23:46:16 +00:00
vert.dirty = true;
vert.numheights=0;
if (cnt>1)
{
2017-01-08 23:46:16 +00:00
vert.numsectors= cnt;
vert.sectors=new sector_t*[cnt];
vert.heightlist = new float[cnt*2];
for(int j=0;j<cnt;j++)
{
vert.sectors[j] = &Level->sectors[vt_sectorlists[i][j]];
}
}
else
{
2017-01-08 23:46:16 +00:00
vert.numsectors=0;
}
}
}
//==========================================================================
//
//
//
//==========================================================================
void MapLoader::GetSideVertices(int sdnum, DVector2 *v1, DVector2 *v2)
{
line_t *ln = Level->sides[sdnum].linedef;
if (ln->sidedef[0] == &Level->sides[sdnum])
{
*v1 = ln->v1->fPos();
*v2 = ln->v2->fPos();
}
else
{
*v2 = ln->v1->fPos();
*v1 = ln->v2->fPos();
}
}
static int segcmp(const void *a, const void *b)
{
seg_t *A = *(seg_t**)a;
seg_t *B = *(seg_t**)b;
return xs_RoundToInt(FRACUNIT*(A->sidefrac - B->sidefrac));
}
//==========================================================================
//
// Group segs to sidedefs
//
//==========================================================================
void MapLoader::PrepareSegs()
{
auto numsides = Level->sides.Size();
TArray<int> segcount(numsides, true);
int realsegs = 0;
// count the segs
memset(segcount.Data(), 0, numsides * sizeof(int));
for(auto &seg : Level->segs)
{
if (seg.sidedef == nullptr) continue; // miniseg
int sidenum = Index(seg.sidedef);
realsegs++;
segcount[sidenum]++;
DVector2 sidestart, sideend, segend = seg.v2->fPos();
GetSideVertices(sidenum, &sidestart, &sideend);
sideend -=sidestart;
segend -= sidestart;
seg.sidefrac = float(segend.Length() / sideend.Length());
}
// allocate memory
Level->segbuffer.Resize(realsegs);
Level->sides[0].segs = Level->segbuffer.Data();
Level->sides[0].numsegs = 0;
for(unsigned i = 1; i < numsides; i++)
{
Level->sides[i].segs = Level->sides[i-1].segs + segcount[i-1];
Level->sides[i].numsegs = 0;
}
// assign the segs
for (auto &seg : Level->segs)
{
if (seg.sidedef != NULL) seg.sidedef->segs[seg.sidedef->numsegs++] = &seg;
}
// sort the segs
for(unsigned i = 0; i < numsides; i++)
{
if (Level->sides[i].numsegs > 1) qsort(Level->sides[i].segs, Level->sides[i].numsegs, sizeof(seg_t*), segcmp);
}
}
//==========================================================================
//
// Initialize the level data for the GL renderer
//
//==========================================================================
void MapLoader::InitRenderInfo()
{
PrepareSegs();
PrepareSectorData();
InitVertexData();
TArray<int> checkmap(Level->vertexes.Size());
memset(checkmap.Data(), -1, sizeof(int)*Level->vertexes.Size());
for(auto &sec : Level->sectors)
{
int i = Index(&sec);
PrepareTransparentDoors(&sec);
// This ignores vertices only used for seg splitting because those aren't needed here
for(auto l : sec.Lines)
{
if (l->sidedef[0]->Flags & WALLF_POLYOBJ) continue; // don't bother with polyobjects
int vtnum1 = Index(l->v1);
int vtnum2 = Index(l->v2);
if (checkmap[vtnum1] < i)
{
checkmap[vtnum1] = i;
sec.e->vertices.Push(&Level->vertexes[vtnum1]);
Level->vertexes[vtnum1].dirty = true;
}
if (checkmap[vtnum2] < i)
{
checkmap[vtnum2] = i;
sec.e->vertices.Push(&Level->vertexes[vtnum2]);
Level->vertexes[vtnum2].dirty = true;
}
}
}
}
//==========================================================================
//
// FixMinisegReferences
//
// Sometimes it can happen that two matching minisegs do not have their partner set.
// Fix that here.
//
//==========================================================================
void MapLoader::FixMinisegReferences()
{
TArray<seg_t *> bogussegs;
for (unsigned i = 0; i < Level->segs.Size(); i++)
{
if (Level->segs[i].sidedef == nullptr && Level->segs[i].PartnerSeg == nullptr)
{
bogussegs.Push(&Level->segs[i]);
}
}
for (unsigned i = 0; i < bogussegs.Size(); i++)
{
auto seg1 = bogussegs[i];
seg_t *pick = nullptr;
unsigned int picki = -1;
// Try to fix the reference: If there's exactly one other seg in the set which matches as a partner link those two segs together.
for (unsigned j = i + 1; j < bogussegs.Size(); j++)
{
auto seg2 = bogussegs[j];
if (seg1->v1 == seg2->v2 && seg2->v1 == seg1->v2 && seg1->Subsector->render_sector == seg2->Subsector->render_sector)
{
pick = seg2;
picki = j;
break;
}
}
if (pick)
{
DPrintf(DMSG_NOTIFY, "Linking miniseg pair from (%2.3f, %2.3f) -> (%2.3f, %2.3f) in sector %d\n", pick->v2->fX(), pick->v2->fY(), pick->v1->fX(), pick->v1->fY(), Index(pick->frontsector));
pick->PartnerSeg = seg1;
seg1->PartnerSeg = pick;
assert(seg1->v1 == pick->v2 && pick->v1 == seg1->v2);
bogussegs.Delete(picki);
bogussegs.Delete(i);
i--;
}
}
}
//==========================================================================
//
// FixHoles
//
// ZDBSP can leave holes in the node tree on extremely detailed maps.
// To help out the triangulator these are filled with dummy subsectors
// so that it can process the area correctly.
//
//==========================================================================
void MapLoader::FixHoles()
{
TArray<seg_t *> bogussegs;
TArray<TArray<seg_t *>> segloops;
for (unsigned i = 0; i < Level->segs.Size(); i++)
{
if (Level->segs[i].sidedef == nullptr && Level->segs[i].PartnerSeg == nullptr)
{
bogussegs.Push(&Level->segs[i]);
}
}
while (bogussegs.Size() > 0)
{
segloops.Reserve(1);
auto *segloop = &segloops.Last();
seg_t *startseg;
seg_t *checkseg;
while (bogussegs.Size() > 0)
{
bool foundsome = false;
if (segloop->Size() == 0)
{
bogussegs.Pop(startseg);
segloop->Push(startseg);
checkseg = startseg;
}
for (unsigned i = 0; i < bogussegs.Size(); i++)
{
auto seg1 = bogussegs[i];
if (seg1->v1 == checkseg->v2 && seg1->Subsector->render_sector == checkseg->Subsector->render_sector)
{
foundsome = true;
segloop->Push(seg1);
bogussegs.Delete(i);
i--;
checkseg = seg1;
if (seg1->v2 == startseg->v1)
{
// The loop is complete. Start a new one
segloops.Reserve(1);
segloop = &segloops.Last();
}
}
}
if (!foundsome)
{
if ((*segloop)[0]->v1 != segloop->Last()->v2)
{
// There was no connected seg, leaving an unclosed loop.
// Clear this and continue looking.
segloop->Clear();
}
}
}
for (unsigned i = 0; i < segloops.Size(); i++)
{
if (segloops[i].Size() == 0)
{
segloops.Delete(i);
i--;
}
}
// Add dummy entries to the level's seg and subsector arrays
if (segloops.Size() > 0)
{
// cound the number of segs to add.
unsigned segcount = 0;
for (auto &segloop : segloops)
segcount += segloop.Size();
seg_t *oldsegstartptr = &Level->segs[0];
subsector_t *oldssstartptr = &Level->subsectors[0];
unsigned newsegstart = Level->segs.Reserve(segcount);
unsigned newssstart = Level->subsectors.Reserve(segloops.Size());
seg_t *newsegstartptr = &Level->segs[0];
subsector_t *newssstartptr = &Level->subsectors[0];
// Now fix all references to these in the level data.
// Note that the Index method does not work here due to the reallocation.
for (auto &seg : Level->segs)
{
if (seg.PartnerSeg) seg.PartnerSeg = newsegstartptr + (seg.PartnerSeg - oldsegstartptr);
seg.Subsector = newssstartptr + (seg.Subsector - oldssstartptr);
}
for (auto &sub : Level->subsectors)
{
sub.firstline = newsegstartptr + (sub.firstline - oldsegstartptr);
}
for (auto &node : Level->nodes)
{
// How hideous... :(
for (auto & p : node.children)
{
auto intp = (intptr_t)p;
if (intp & 1)
{
subsector_t *sp = (subsector_t*)(intp - 1);
sp = newssstartptr + (sp - oldssstartptr);
intp = intptr_t(sp) + 1;
p = (void*)intp;
}
}
}
for (auto &segloop : segloops)
{
for (auto &seg : segloop)
{
seg = newsegstartptr + (seg - oldsegstartptr);
}
}
// The seg lists in the sidedefs and the subsector lists in the sectors are not set yet when this gets called.
// Add the new data. This doesn't care about convexity. It is never directly used to generate a primitive.
for (auto &segloop : segloops)
{
DPrintf(DMSG_NOTIFY, "Adding dummy subsector for sector %d\n", Index(segloop[0]->Subsector->render_sector));
subsector_t &sub = Level->subsectors[newssstart++];
memset(&sub, 0, sizeof(sub));
sub.sector = segloop[0]->frontsector;
sub.render_sector = segloop[0]->Subsector->render_sector;
sub.numlines = segloop.Size();
sub.firstline = &Level->segs[newsegstart];
sub.flags = SSECF_HOLE;
for (auto otherseg : segloop)
{
DPrintf(DMSG_NOTIFY, " Adding seg from (%2.3f, %2.3f) -> (%2.3f, %2.3f)\n", otherseg->v2->fX(), otherseg->v2->fY(), otherseg->v1->fX(), otherseg->v1->fY());
seg_t &seg = Level->segs[newsegstart++];
memset(&seg, 0, sizeof(seg));
seg.v1 = otherseg->v2;
seg.v2 = otherseg->v1;
seg.frontsector = seg.backsector = otherseg->backsector = otherseg->frontsector;
seg.PartnerSeg = otherseg;
otherseg->PartnerSeg = &seg;
seg.Subsector = &sub;
}
}
}
}
}