gzdoom/unused/gl_builddraw.cpp

599 lines
15 KiB
C++
Raw Permalink Normal View History

/*
** gl_builddraw.cpp
** a build-like rendering algorithm
** Uses the sections created in gl_sections.cpp
**
** NOTE: Although this code generally works, it clearly shows the limitations
** of Build's algorithm. This requires constant sorting of the collected geometry
** and that causes extreme slowdowns on larger maps.
**
**---------------------------------------------------------------------------
** Copyright 2008 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.
** 4. When not used as part of GZDoom or a GZDoom derivative, this code will be
** covered by the terms of the GNU Lesser General Public License as published
** by the Free Software Foundation; either version 2.1 of the License, or (at
** your option) any later version.
** 5. Full disclosure of the entire project's source code, except for third
** party libraries is mandatory. (NOTE: This clause is non-negotiable!)
**
** 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 "i_system.h"
#include "p_local.h"
#include "c_dispatch.h"
#include "gl/renderer/gl_renderer.h"
#include "gl/scene/gl_clipper.h"
#include "gl/utility/gl_clock.h"
#include "gl/data/gl_sections.h"
#include "gl/scene/gl_wall.h"
#ifdef BUILD_TEST
#define D(x) x
#else
#define D(x) do{}while(0)
#endif
EXTERN_CVAR (Bool, dumpsections)
struct FBunch
{
int startline;
int endline;
angle_t startangle;
angle_t endangle;
fixed_t minviewdist;
fixed_t maxviewdist;
};
void DoSubsector(subsector_t * sub, bool handlelines);
EXTERN_CVAR(Bool, gl_render_walls)
//==========================================================================
//
// From Build but changed to use doubles to prevent overflows
//
//==========================================================================
static int WallInFront(FGLSectionLine *wal1, FGLSectionLine *wal2)
{
double x11, y11, x21, y21, x12, y12, x22, y22, dx, dy, t1, t2;
x11 = wal1->start->x;
y11 = wal1->start->y;
x21 = wal1->end->x;
y21 = wal1->end->y;
x12 = wal2->start->x;
y12 = wal2->start->y;
x22 = wal2->end->x;
y22 = wal2->end->y;
dx = x21-x11; dy = y21-y11;
t1 = (x12-x11)*dy - (y12-y11)*dx;
t2 = (x22-x11)*dy - (y22-y11)*dx;
if (t1 == 0)
{
t1 = t2;
if (t1 == 0) return(-1);
}
if (t2 == 0) t2 = t1;
if ((t1*t2) >= 0)
{
t2 = (double(viewx)-x11) * dy - (double(viewy)-y11)*dx;
return((t2*t1) < 0);
}
dx = x22-x12; dy = y22-y12;
t1 = (x11-x12)*dy - (y11-y12)*dx;
t2 = (x21-x12)*dy - (y21-y12)*dx;
if (t1 == 0)
{
t1 = t2;
if (t1 == 0) return(-1);
}
if (t2 == 0) t2 = t1;
if ((t1*t2) >= 0)
{
t2 = (double(viewx)-x12) * dy - (double(viewy)-y12)*dx;
return((t2*t1) >= 0);
}
return(-2);
}
//==========================================================================
//
// This is a bit more complicated than it looks because angles can wrap
// around so we can only compare angle differences.
//
// Rules:
// 1. Any bunch can span at most 180<38>.
// 2. 2 bunches can never overlap at both ends
// 3. if there is an overlap one of the 2 starting points must be in the
// overlapping area.
//
//==========================================================================
static int BunchInFront(FBunch *b1, FBunch *b2)
{
angle_t anglecheck, endang;
if (b2->startangle - b1->startangle < b1->endangle - b1->startangle)
{
// we have an overlap at b2->startangle
anglecheck = b2->startangle - b1->startangle;
// Find the wall in b1 that overlaps b2->startangle
for(int i = b1->startline; i <= b1->endline; i++)
{
#ifdef _DEBUG
angle_t startang = SectionLines[i].start->GetClipAngleInverse() - b1->startangle;
#endif
endang = SectionLines[i].end->GetClipAngleInverse() - b1->startangle;
if (endang > anglecheck)
{
assert (startang <= anglecheck);
// found a line
int ret = WallInFront(&SectionLines[b2->startline], &SectionLines[i]);
D(Printf (PRINT_LOG, "Line %d <-> line %d: Result = %d.\n",
SectionLines[b2->startline].linedef-lines,
SectionLines[i].linedef-lines, ret));
return ret;
}
}
}
else if (b1->startangle - b2->startangle < b2->endangle - b2->startangle)
{
// we have an overlap at b1->startangle
anglecheck = b1->startangle - b2->startangle;
// Find the wall in b2 that overlaps b1->startangle
for(int i = b2->startline; i <= b2->endline; i++)
{
#ifdef _DEBUG
angle_t startang = SectionLines[i].start->GetClipAngleInverse() - b2->startangle;
#endif
endang = SectionLines[i].end->GetClipAngleInverse() - b2->startangle;
if (endang > anglecheck)
{
assert (startang <= anglecheck);
// found a line
int ret = WallInFront(&SectionLines[i], &SectionLines[b1->startline]);
D(Printf (PRINT_LOG, "Line %d <-> line %d: Result = %d,\n",
SectionLines[i].linedef-lines,
SectionLines[b1->endline].linedef-lines, ret));
return ret;
}
}
}
// we have no overlap
return -1;
}
// ----------------------------------------------------------------------------
//
// Bunches are groups of continuous lines
// This array stores the amount of points per bunch,
// the view angles for each point and the line index for the starting line
//
// ----------------------------------------------------------------------------
class BunchDrawer
{
int LastBunch;
int StartTime;
TArray<FBunch> Bunches;
TArray<int> CompareData;
sector_t fakebacksec;
//==========================================================================
//
//
//
//==========================================================================
public:
BunchDrawer()
{
StartScene();
}
//==========================================================================
//
//
//
//==========================================================================
private:
void StartScene()
{
LastBunch = 0;
StartTime = I_MSTime();
Bunches.Clear();
}
//==========================================================================
//
//
//
//==========================================================================
void StartBunch(int linenum, angle_t startan, angle_t endan, vertex_t *startpt, vertex_t *endpt)
{
FBunch *bunch = &Bunches[LastBunch = Bunches.Reserve(1)];
bunch->startline = bunch->endline = linenum;
bunch->startangle = startan;
bunch->endangle = endan;
}
//==========================================================================
//
//
//
//==========================================================================
void AddLineToBunch(int newan)
{
Bunches[LastBunch].endline++;
Bunches[LastBunch].endangle = newan;
}
//==========================================================================
//
//
//
//==========================================================================
void DeleteBunch(int index)
{
Bunches.Delete(index);
}
//==========================================================================
//
// ClipLine
// Clips the given segment
//
//==========================================================================
enum
{
CL_Skip = 0,
CL_Draw = 1,
CL_Pass = 2,
};
int ClipLine (FGLSectionLine *line, sector_t * sector, sector_t **pbacksector)
{
angle_t startAngle, endAngle;
sector_t * backsector = NULL;
bool blocking;
startAngle = line->end->GetClipAngle();
endAngle = line->start->GetClipAngle();
*pbacksector = NULL;
// Back side, i.e. backface culling - read: endAngle >= startAngle!
if (startAngle-endAngle<ANGLE_180)
{
return CL_Skip;
}
if (!clipper.SafeCheckRange(startAngle, endAngle))
{
return CL_Skip;
}
if (line->otherside == -1)
{
// one-sided
clipper.SafeAddClipRange(startAngle, endAngle);
return CL_Draw;
}
else if (line->polysub == NULL)
{
// two sided and not a polyobject
if (line->linedef == NULL)
{
// Miniseg
return CL_Pass;
}
if (sector->sectornum == line->refseg->backsector->sectornum)
{
FTexture *tex = TexMan(line->sidedef->GetTexture(side_t::mid));
if (!tex || tex->UseType==FTexture::TEX_Null)
{
// no mid texture: nothing to do here
return CL_Pass;
}
*pbacksector = sector;
return CL_Draw|CL_Pass;
}
else
{
// clipping checks are only needed when the backsector is not the same as the front sector
gl_CheckViewArea(line->start, line->end, line->refseg->frontsector, line->refseg->backsector);
*pbacksector = backsector = gl_FakeFlat(line->refseg->backsector, &fakebacksec, true);
blocking = gl_CheckClip(line->sidedef, sector, backsector);
if (blocking)
{
clipper.SafeAddClipRange(startAngle, endAngle);
return CL_Draw;
}
return CL_Draw|CL_Pass;
}
}
else
{
*pbacksector = sector;
return CL_Draw;
}
}
//==========================================================================
//
//
//
//==========================================================================
void ProcessBunch(int bnch)
{
FBunch *bunch = &Bunches[bnch];
sector_t fake;
sector_t *sec;
sector_t *backsector;
D(Printf(PRINT_LOG, "------------------------------\nProcessing bunch %d (Startline %d)\n",bnch,SectionLines[bunch->startline].linedef-lines));
ClipWall.Clock();
for(int i=bunch->startline; i <= bunch->endline; i++)
{
FGLSectionLine *ln = &SectionLines[i];
// Draw this line. todo: optimize
sec = gl_FakeFlat(ln->refseg->frontsector, &fake, false);
int clipped = ClipLine(ln, sec, &backsector);
D(Printf(PRINT_LOG, "line %d clip result is %d\n", ln->linedef - lines, clipped));
if (clipped & CL_Draw)
{
ln->linedef->flags |= ML_MAPPED;
if (ln->linedef->validcount!=validcount)
{
ln->linedef->validcount=validcount;
#ifndef BUILD_TEST
if (gl_render_walls)
{
SetupWall.Clock();
GLWall wall;
wall.Process(ln->refseg, sec, backsector, ln->polysub);
rendered_lines++;
SetupWall.Unclock();
}
#endif
}
}
if (clipped & CL_Pass)
{
ClipWall.Unclock();
ProcessSection(ln->otherside);
ClipWall.Clock();
}
}
D(Printf(PRINT_LOG, "Bunch %d done\n------------------------------\n",bnch));
ClipWall.Unclock();
}
//==========================================================================
//
//
//
//==========================================================================
int FindClosestBunch()
{
int closest = 0; //Almost works, but not quite :(
CompareData.Clear();
for(unsigned i = 1; i < Bunches.Size(); i++)
{
switch (BunchInFront(&Bunches[i], &Bunches[closest]))
{
case 0: // i is in front
closest = i;
continue;
case 1: // i is behind
continue;
default: // can't determine
CompareData.Push(i); // mark for later comparison
continue;
}
}
// we need to do a second pass to see how the marked bunches relate to the currently closest one.
for(unsigned i = 0; i < CompareData.Size(); i++)
{
switch (BunchInFront(&Bunches[CompareData[i]], &Bunches[closest]))
{
case 0: // is in front
closest = i;
CompareData.Delete(i);
i = 0; // we need to recheck everything that's still marked.
continue;
case 1: // is behind
CompareData.Delete(i);
i--;
continue;
default:
continue;
}
}
return closest;
}
//==========================================================================
//
//
//
//==========================================================================
void ProcessSection(int sectnum)
{
FGLSection *sect = &Sections[sectnum];
bool inbunch;
angle_t startangle;
if (sect->validcount == StartTime) return;
sect->validcount = StartTime;
D(Printf(PRINT_LOG, "------------------------------\nProcessing section %d (sector %d)\n",sectnum, sect->sector->sectornum));
#ifndef BUILD_TEST
for(unsigned i = 0; i < sect->subsectors.Size(); i++)
{
DoSubsector(sect->subsectors[i], false);
if (sect->subsectors[i]->poly != NULL)
{
// ProcessPolyobject()
}
}
#endif
//Todo: process subsectors
for(int i=0; i<sect->numloops; i++)
{
FGLSectionLoop *loop = sect->GetLoop(i);
inbunch = false;
for(int j=0; j<loop->numlines; j++)
{
FGLSectionLine *ln = loop->GetLine(j);
angle_t ang1 = ln->start->GetClipAngle();
angle_t ang2 = ln->end->GetClipAngle();
if (ang2 - ang1 < ANGLE_180)
{
// Backside
D(Printf(PRINT_LOG, "line %d facing backwards\n", ln->linedef - lines));
inbunch = false;
}
else if (!clipper.SafeCheckRange(ang2, ang1))
{
// is it visible?
D(Printf(PRINT_LOG, "line %d not in view\n", ln->linedef - lines));
inbunch = false;
}
else if (!inbunch || startangle - ang2 >= ANGLE_180)
{
// don't let a bunch span more than 180<38> to avoid problems.
// This limitation ensures that the combined range of 2
// bunches will always be less than 360<36> which simplifies
// the distance comparison code because it prevents a
// situation where 2 bunches may overlap at both ends.
D(Printf(PRINT_LOG, "Starting bunch %d at line %d\n",Bunches.Size(), ln->linedef - lines));
startangle = ang2;
// Clipping angles are backward which makes this code very hard to read so let's use the inverse
StartBunch(loop->startline + j, 0 - ang1, 0 - ang2);
inbunch = true;
}
else
{
D(Printf(PRINT_LOG, " Adding line %d\n", ln->linedef - lines));
AddLineToBunch(0 - ang2);
}
}
}
D(Printf(PRINT_LOG, "Section %d done\n------------------------------\n",sectnum));
}
//==========================================================================
//
//
//
//==========================================================================
public:
void RenderScene(int viewsection)
{
ProcessSection(viewsection);
while (Bunches.Size() > 0)
{
int closest = FindClosestBunch();
ProcessBunch(closest);
DeleteBunch(closest);
}
}
};
void gl_RenderBuild()
{
subsector_t *sub = R_PointInSubsector(viewx, viewy);
clipper.Clear();
angle_t a1 = GLRenderer->FrustumAngle();
clipper.SafeAddClipRangeRealAngles(viewangle+a1, viewangle-a1);
if (Sections.Size() == 0) gl_CreateSections();
int startsection = SectionForSubsector[sub-subsectors];
BunchDrawer bd;
bd.RenderScene(startsection);
}
#ifdef BUILD_TEST
CCMD(testrender)
{
gl_RenderBuild();
}
#endif