mirror of
https://github.com/ZDoom/qzdoom.git
synced 2024-11-12 15:44:24 +00:00
1592 lines
47 KiB
C++
1592 lines
47 KiB
C++
/**************************************************************************************************
|
||
"POLYMOST" code written by Ken Silverman
|
||
Ken Silverman's official web site: http://www.advsys.net/ken
|
||
This file has been modified (severely) from Ken Silverman's original release
|
||
|
||
Motivation:
|
||
When 3D Realms released the Duke Nukem 3D source code, I thought somebody would do a OpenGL or
|
||
Direct3D port. Well, after a few months passed, I saw no sign of somebody working on a true
|
||
hardware-accelerated port of Build, just people saying it wasn't possible. Eventually, I realized
|
||
the only way this was going to happen was for me to do it myself. First, I needed to port Build to
|
||
Windows. I could have done it myself, but instead I thought I'd ask my Australian buddy, Jonathon
|
||
Fowler, if he would upgrade his Windows port to my favorite compiler (MSVC) - which he did. Once
|
||
that was done, I was ready to start the "POLYMOST" project.
|
||
|
||
About:
|
||
This source file is basically a complete rewrite of the entire rendering part of the Build engine.
|
||
There are small pieces in ENGINE.C to activate this code, and other minor hacks in other source
|
||
files, but most of it is in here. If you're looking for polymost-related code in the other source
|
||
files, you should find most of them by searching for either "polymost" or "rendmode". Speaking of
|
||
rendmode, there are now 4 rendering modes in Build:
|
||
|
||
rendmode 0: The original code I wrote from 1993-1997
|
||
rendmode 1: Solid-color rendering: my debug code before I did texture mapping
|
||
rendmode 2: Software rendering before I started the OpenGL code (Note: this is just a quick
|
||
hack to make testing easier - it's not optimized to my usual standards!)
|
||
rendmode 3: The OpenGL code
|
||
|
||
The original Build engine did hidden surface removal by using a vertical span buffer on the tops
|
||
and bottoms of walls. This worked nice back in the day, but it it's not suitable for a polygon
|
||
engine. So I decided to write a brand new hidden surface removal algorithm - using the same idea
|
||
as the original Build - but one that worked with vectors instead of already rasterized data.
|
||
|
||
Brief history:
|
||
06/20/2000: I release Build Source code
|
||
04/01/2003: 3D Realms releases Duke Nukem 3D source code
|
||
10/04/2003: Jonathon Fowler gets his Windows port working in Visual C
|
||
10/04/2003: I start writing POLYMOST.BAS, a new hidden surface removal algorithm for Build that
|
||
works on a polygon level instead of spans.
|
||
10/16/2003: Ported POLYMOST.BAS to C inside JonoF KenBuild's ENGINE.C; later this code was split
|
||
out of ENGINE.C and put in this file, POLYMOST.C.
|
||
12/10/2003: Started OpenGL code for POLYMOST (rendmode 3)
|
||
12/23/2003: 1st public release
|
||
01/01/2004: 2nd public release: fixed stray lines, status bar, mirrors, sky, and lots of other bugs.
|
||
|
||
----------------------------------------------------------------------------------------------------
|
||
|
||
Todo list (in approximate chronological order):
|
||
|
||
High priority:
|
||
* BOTH: Do accurate software sorting/chopping for sprites: drawing in wrong order is bad :/
|
||
* BOTH: Fix hall of mirrors near "zenith". Call polymost_drawrooms twice?
|
||
* OPENGL: drawmapview()
|
||
|
||
Low priority:
|
||
* SOFT6D: Do back-face culling of sprites during up/down/tilt transformation (top of drawpoly)
|
||
* SOFT6D: Fix depth shading: use saturation&LUT
|
||
* SOFT6D: Optimize using hyperbolic mapping (similar to KUBE algo)
|
||
* SOFT6D: Slab6-style voxel sprites. How to accelerate? :/
|
||
* OPENGL: KENBUILD: Write flipping code for floor mirrors
|
||
* BOTH: KENBUILD: Parallaxing sky modes 1&2
|
||
* BOTH: Masked/1-way walls don't clip correctly to sectors of intersecting ceiling/floor slopes
|
||
* BOTH: Editart x-center is not working correctly with Duke's camera/turret sprites
|
||
* BOTH: Get rid of horizontal line above Duke full-screen status bar
|
||
* BOTH: Combine ceilings/floors into a single triangle strip (should lower poly count by 2x)
|
||
* BOTH: Optimize/clean up texture-map setup equations
|
||
|
||
**************************************************************************************************/
|
||
|
||
#include <stdlib.h>
|
||
#include <assert.h>
|
||
#include <math.h>
|
||
#include "doomtype.h"
|
||
#include "r_polymost.h"
|
||
#include "c_cvars.h"
|
||
#include "c_dispatch.h"
|
||
#include "r_main.h"
|
||
#include "r_draw.h"
|
||
#include "templates.h"
|
||
#include "r_sky.h"
|
||
|
||
EXTERN_CVAR (Int, r_polymost)
|
||
|
||
#define SCISDIST 1.0 //1.0: Close plane clipping distance
|
||
|
||
static double gyxscale, gxyaspect, gviewxrange, ghalfx, grhalfxdown10, grhalfxdown10x, ghoriz;
|
||
static double gcosang, gsinang, gcosang2, gsinang2;
|
||
static double gchang, gshang, gctang, gstang;
|
||
//static float gtang = 0.0;
|
||
CVAR (Float, gtang, 0, 0);
|
||
double guo, gux, guy; //Screen-based texture mapping parameters
|
||
double gvo, gvx, gvy;
|
||
double gdo, gdx, gdy;
|
||
|
||
#ifdef _MSC_VER
|
||
#pragma warning (disable:4244)
|
||
#endif
|
||
|
||
PolyClipper::PolyClipper ()
|
||
: vsps (&EmptyList)
|
||
{
|
||
UsedList.Next = UsedList.Prev = &UsedList;
|
||
}
|
||
|
||
PolyClipper::~PolyClipper ()
|
||
{
|
||
vspgroup *probe = vsps.NextGroup;
|
||
while (probe != NULL)
|
||
{
|
||
vspgroup *next = probe->NextGroup;
|
||
delete probe;
|
||
probe = next;
|
||
}
|
||
}
|
||
|
||
PolyClipper::vspgroup::vspgroup (vsptype *sentinel)
|
||
{
|
||
int i;
|
||
|
||
NextGroup = NULL;
|
||
vsp[0].Prev = sentinel;
|
||
vsp[0].Next = &vsp[1];
|
||
for (i = 1; i < GROUP_SIZE-1; ++i)
|
||
{
|
||
vsp[i].Next = &vsp[i+1];
|
||
vsp[i].Prev = &vsp[i-1];
|
||
}
|
||
vsp[i].Next = sentinel;
|
||
vsp[i].Prev = &vsp[i-1];
|
||
sentinel->Next = &vsp[0];
|
||
sentinel->Prev = &vsp[i];
|
||
}
|
||
|
||
/*Init viewport boundary (must be 4 point convex loop):
|
||
// (px[0],py[0]).----.(px[1],py[1])
|
||
// / \
|
||
// / \
|
||
// (px[3],py[3]).--------------.(px[2],py[2])
|
||
*/
|
||
void PolyClipper::InitMosts (double *px, double *py, int n)
|
||
{
|
||
int i, j, k, imin;
|
||
int vcnt;
|
||
vsptype *vsp[8];
|
||
|
||
EmptyAll ();
|
||
vcnt = 1; // 0 is dummy solid node
|
||
|
||
if (n < 3) return;
|
||
imin = (px[1] < px[0]);
|
||
for(i=n-1;i>=2;i--) if (px[i] < px[imin]) imin = i;
|
||
|
||
vsp[0] = &UsedList;
|
||
vsp[vcnt] = GetVsp ();
|
||
vsp[vcnt]->X = px[imin];
|
||
vsp[vcnt]->Cy[0] = vsp[vcnt]->Fy[0] = py[imin];
|
||
vsp[vcnt]->CTag = vsp[vcnt]->FTag = 1;
|
||
vcnt++;
|
||
i = imin+1; if (i >= n) i = 0;
|
||
j = imin-1; if (j < 0) j = n-1;
|
||
do
|
||
{
|
||
if (px[i] < px[j])
|
||
{
|
||
if ((vcnt > 1) && (px[i] - vsp[vcnt-1]->X < 0.00001)) vcnt--;
|
||
else vsp[vcnt] = GetVsp ();
|
||
vsp[vcnt]->X = px[i];
|
||
vsp[vcnt]->Cy[0] = py[i];
|
||
k = j+1; if (k >= n) k = 0;
|
||
//(px[k],py[k])
|
||
//(px[i],?)
|
||
//(px[j],py[j])
|
||
vsp[vcnt]->Fy[0] = (px[i]-px[k])*(py[j]-py[k])/(px[j]-px[k]) + py[k];
|
||
if (vcnt > 1)
|
||
{
|
||
vsp[vcnt]->CTag = vsp[vcnt-1]->CTag + 1;
|
||
vsp[vcnt]->FTag = vsp[vcnt-1]->FTag;
|
||
}
|
||
vcnt++;
|
||
i++; if (i >= n) i = 0;
|
||
}
|
||
else if (px[j] < px[i])
|
||
{
|
||
if ((vcnt > 1) && (px[j] - vsp[vcnt-1]->X < 0.00001)) vcnt--;
|
||
else vsp[vcnt] = GetVsp ();
|
||
vsp[vcnt]->X = px[j];
|
||
vsp[vcnt]->Fy[0] = py[j];
|
||
k = i-1; if (k < 0) k = n-1;
|
||
//(px[k],py[k])
|
||
//(px[j],?)
|
||
//(px[i],py[i])
|
||
vsp[vcnt]->Cy[0] = (px[j]-px[k])*(py[i]-py[k])/(px[i]-px[k]) + py[k];
|
||
if (vcnt > 1)
|
||
{
|
||
vsp[vcnt]->FTag = vsp[vcnt-1]->FTag + 1;
|
||
vsp[vcnt]->CTag = vsp[vcnt-1]->CTag;
|
||
}
|
||
vcnt++;
|
||
j--; if (j < 0) j = n-1;
|
||
}
|
||
else
|
||
{
|
||
if ((vcnt > 1) && (px[i] - vsp[vcnt-1]->X < 0.00001)) vcnt--;
|
||
else vsp[vcnt] = GetVsp ();
|
||
vsp[vcnt]->X = px[i];
|
||
vsp[vcnt]->Cy[0] = py[i];
|
||
vsp[vcnt]->Fy[0] = py[j];
|
||
if (vcnt > 1)
|
||
{
|
||
vsp[vcnt]->CTag = vsp[vcnt-1]->CTag + 1;
|
||
vsp[vcnt]->FTag = vsp[vcnt-1]->FTag + 1;
|
||
}
|
||
vcnt++;
|
||
i++; if (i >= n) i = 0; if (i == j) break;
|
||
j--; if (j < 0) j = n-1;
|
||
}
|
||
} while (i != j);
|
||
if (px[i] > vsp[vcnt-1]->X)
|
||
{
|
||
vsp[vcnt] = GetVsp ();
|
||
vsp[vcnt]->X = px[i];
|
||
vsp[vcnt]->Cy[0] = vsp[vcnt]->Fy[0] = py[i];
|
||
vsp[vcnt]->CTag = vsp[vcnt-1]->CTag + 1;
|
||
vsp[vcnt]->FTag = vsp[vcnt-1]->FTag + 1;
|
||
vcnt++;
|
||
}
|
||
|
||
assert (vcnt < 8);
|
||
|
||
vsp[vcnt-1]->CTag = vsp[vcnt-1]->FTag = vcnt-1;
|
||
for(i=0;i<vcnt-1;i++)
|
||
{
|
||
vsp[i]->Cy[1] = vsp[i+1]->Cy[0]; //vsp[i]->CTag = i;
|
||
vsp[i]->Fy[1] = vsp[i+1]->Fy[0]; //vsp[i]->FTag = i;
|
||
vsp[i]->Next = vsp[i+1]; vsp[i]->Prev = vsp[i-1];
|
||
}
|
||
vsp[vcnt-1]->Next = &UsedList; UsedList.Prev = vsp[vcnt-1];
|
||
GTag = vcnt;
|
||
}
|
||
|
||
void PolyClipper::EmptyAll ()
|
||
{
|
||
if (UsedList.Next != &UsedList)
|
||
{
|
||
if (EmptyList.Next != &EmptyList)
|
||
{
|
||
// Move the used list to the start of the empty list
|
||
UsedList.Prev->Next = EmptyList.Next;
|
||
EmptyList.Next = UsedList.Next;
|
||
UsedList.Next->Prev = &EmptyList;
|
||
}
|
||
else
|
||
{
|
||
// The empty list is empty, so we can just move the
|
||
// used list to the empty list.
|
||
EmptyList.Next = UsedList.Next;
|
||
EmptyList.Prev = UsedList.Prev;
|
||
}
|
||
UsedList.Next = UsedList.Prev = &UsedList;
|
||
}
|
||
}
|
||
|
||
void PolyClipper::AddGroup ()
|
||
{
|
||
vspgroup *group = new vspgroup (&EmptyList);
|
||
group->NextGroup = vsps.NextGroup;
|
||
vsps.NextGroup = group;
|
||
}
|
||
|
||
PolyClipper::vsptype *PolyClipper::GetVsp ()
|
||
{
|
||
vsptype *vsp;
|
||
|
||
if (EmptyList.Next == &EmptyList)
|
||
{
|
||
AddGroup ();
|
||
}
|
||
vsp = EmptyList.Next;
|
||
EmptyList.Next = vsp->Next;
|
||
vsp->Next->Prev = &EmptyList;
|
||
return vsp;
|
||
}
|
||
|
||
void PolyClipper::FreeVsp (vsptype *vsp)
|
||
{
|
||
vsp->Next->Prev = vsp->Prev;
|
||
vsp->Prev->Next = vsp->Next;
|
||
|
||
vsp->Next = EmptyList.Next;
|
||
vsp->Next->Prev = vsp;
|
||
vsp->Prev = &EmptyList;
|
||
EmptyList.Next = vsp;
|
||
}
|
||
|
||
PolyClipper::vsptype *PolyClipper::vsinsaft (vsptype *i)
|
||
{
|
||
vsptype *r;
|
||
|
||
// Get an element from the empty list
|
||
r = GetVsp ();
|
||
|
||
*r = *i; // Copy i to r
|
||
|
||
// Insert r after i
|
||
r->Prev = i;
|
||
r->Next = i->Next;
|
||
i->Next->Prev = r;
|
||
i->Next = r;
|
||
|
||
return r;
|
||
}
|
||
|
||
bool PolyClipper::TestVisibleMost (float x0, float x1)
|
||
{
|
||
vsptype *i, *newi;
|
||
|
||
for (i = UsedList.Next; i != &UsedList; i = newi)
|
||
{
|
||
newi = i->Next;
|
||
if ((x0 < newi->X) && (i->X < x1) && (i->CTag >= 0)) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
int PolyClipper::DoMost (float x0, float y0, float x1, float y1, pmostcallbacktype callback, void *callbackdata)
|
||
{
|
||
double dpx[4], dpy[4];
|
||
float f, slop, dx0, dx1, nx, nx0, ny0, nx1, ny1;
|
||
double dx, d, n, t;
|
||
float spx[4], spy[4], cy[2], cv[2];
|
||
int j, k, z, scnt, dir, spt[4];
|
||
vsptype *vsp, *nvsp, *vcnt = NULL, *ni;
|
||
int did = 1;
|
||
|
||
if (x0 < x1)
|
||
{
|
||
dir = 1; //clip dmost (floor)
|
||
y0 -= .01f; y1 -= .01f;
|
||
}
|
||
else
|
||
{
|
||
if (x0 == x1) return 0;
|
||
f = x0; x0 = x1; x1 = f;
|
||
f = y0; y0 = y1; y1 = f;
|
||
dir = 0; //clip umost (ceiling)
|
||
//y0 += .01f; y1 += .01f; //necessary?
|
||
}
|
||
|
||
slop = (y1-y0)/(x1-x0);
|
||
for (vsp = UsedList.Next; vsp != &UsedList; vsp = nvsp)
|
||
{
|
||
nvsp = vsp->Next; nx0 = vsp->X; nx1 = nvsp->X;
|
||
if ((x0 >= nx1) || (nx0 >= x1) || (vsp->CTag <= 0)) continue;
|
||
dx = nx1-nx0;
|
||
cy[0] = vsp->Cy[0]; cv[0] = vsp->Cy[1]-cy[0];
|
||
cy[1] = vsp->Fy[0]; cv[1] = vsp->Fy[1]-cy[1];
|
||
|
||
scnt = 0;
|
||
|
||
//Test if left edge requires split (x0,y0) (nx0,cy(0)),<dx,cv(0)>
|
||
if ((x0 > nx0) && (x0 < nx1))
|
||
{
|
||
t = (x0-nx0)*cv[dir] - (y0-cy[dir])*dx;
|
||
if (((!dir) && (t < 0)) || ((dir) && (t > 0)))
|
||
{ spx[scnt] = x0; spy[scnt] = y0; spt[scnt] = -1; scnt++; }
|
||
}
|
||
|
||
//Test for intersection on umost (j == 0) and dmost (j == 1)
|
||
for(j=0;j<2;j++)
|
||
{
|
||
d = (y0-y1)*dx - (x0-x1)*cv[j];
|
||
n = (y0-cy[j])*dx - (x0-nx0)*cv[j];
|
||
if ((fabsf(n) <= fabsf(d)) && (d*n >= 0) && (d != 0))
|
||
{
|
||
t = n/d; nx = (x1-x0)*t + x0;
|
||
if ((nx > nx0) && (nx < nx1))
|
||
{
|
||
spx[scnt] = nx; spy[scnt] = (y1-y0)*t + y0;
|
||
spt[scnt] = j; scnt++;
|
||
}
|
||
}
|
||
}
|
||
|
||
//Nice hack to avoid full sort later :)
|
||
if ((scnt >= 2) && (spx[scnt-1] < spx[scnt-2]))
|
||
{
|
||
f = spx[scnt-1]; spx[scnt-1] = spx[scnt-2]; spx[scnt-2] = f;
|
||
f = spy[scnt-1]; spy[scnt-1] = spy[scnt-2]; spy[scnt-2] = f;
|
||
j = spt[scnt-1]; spt[scnt-1] = spt[scnt-2]; spt[scnt-2] = j;
|
||
}
|
||
|
||
//Test if right edge requires split
|
||
if ((x1 > nx0) && (x1 < nx1))
|
||
{
|
||
t = (x1-nx0)*cv[dir] - (y1-cy[dir])*dx;
|
||
if (((!dir) && (t < 0)) || ((dir) && (t > 0)))
|
||
{ spx[scnt] = x1; spy[scnt] = y1; spt[scnt] = -1; scnt++; }
|
||
}
|
||
|
||
vsp->Tag = nvsp->Tag = -1;
|
||
for(z = 0; z <= scnt; z++, vsp = vcnt)
|
||
{
|
||
if (z < scnt)
|
||
{
|
||
vcnt = vsinsaft(vsp);
|
||
t = (spx[z]-nx0)/dx;
|
||
vsp->Cy[1] = t*cv[0] + cy[0];
|
||
vsp->Fy[1] = t*cv[1] + cy[1];
|
||
vcnt->X = spx[z];
|
||
vcnt->Cy[0] = vsp->Cy[1];
|
||
vcnt->Fy[0] = vsp->Fy[1];
|
||
vcnt->Tag = spt[z];
|
||
}
|
||
|
||
ni = vsp->Next; if (ni == &UsedList) continue; //this 'if' fixes many bugs!
|
||
dx0 = vsp->X; if (x0 > dx0) continue;
|
||
dx1 = ni->X; if (x1 < dx1) continue;
|
||
ny0 = (dx0-x0)*slop + y0;
|
||
ny1 = (dx1-x0)*slop + y0;
|
||
|
||
// dx0 dx1
|
||
// <20> <20>
|
||
//----------------------------
|
||
// t0+=0 t1+=0
|
||
// vsp[i].cy[0] vsp[i].cy[1]
|
||
//============================
|
||
// t0+=1 t1+=3
|
||
//============================
|
||
// vsp[i].fy[0] vsp[i].fy[1]
|
||
// t0+=2 t1+=6
|
||
//
|
||
// ny0 ? ny1 ?
|
||
|
||
k = 1+3;
|
||
if ((vsp->Tag == 0) || (ny0 <= vsp->Cy[0]+.01)) k--;
|
||
if ((vsp->Tag == 1) || (ny0 >= vsp->Fy[0]-.01)) k++;
|
||
if ((ni->Tag == 0) || (ny1 <= vsp->Cy[1]+.01)) k -= 3;
|
||
if ((ni->Tag == 1) || (ny1 >= vsp->Fy[1]-.01)) k += 3;
|
||
|
||
if (!dir)
|
||
{
|
||
switch(k)
|
||
{
|
||
case 1: case 2:
|
||
dpx[0] = dx0; dpy[0] = vsp->Cy[0];
|
||
dpx[1] = dx1; dpy[1] = vsp->Cy[1];
|
||
dpx[2] = dx0; dpy[2] = ny0;
|
||
if(callback) callback(dpx,dpy,3,callbackdata);
|
||
vsp->Cy[0] = ny0; vsp->CTag = GTag; break;
|
||
case 3: case 6:
|
||
dpx[0] = dx0; dpy[0] = vsp->Cy[0];
|
||
dpx[1] = dx1; dpy[1] = vsp->Cy[1];
|
||
dpx[2] = dx1; dpy[2] = ny1;
|
||
if(callback) callback(dpx,dpy,3,callbackdata);
|
||
vsp->Cy[1] = ny1; vsp->CTag = GTag; break;
|
||
case 4: case 5: case 7:
|
||
dpx[0] = dx0; dpy[0] = vsp->Cy[0];
|
||
dpx[1] = dx1; dpy[1] = vsp->Cy[1];
|
||
dpx[2] = dx1; dpy[2] = ny1;
|
||
dpx[3] = dx0; dpy[3] = ny0;
|
||
if(callback) callback(dpx,dpy,4,callbackdata);
|
||
vsp->Cy[0] = ny0; vsp->Cy[1] = ny1; vsp->CTag = GTag; break;
|
||
case 8:
|
||
dpx[0] = dx0; dpy[0] = vsp->Cy[0];
|
||
dpx[1] = dx1; dpy[1] = vsp->Cy[1];
|
||
dpx[2] = dx1; dpy[2] = vsp->Fy[1];
|
||
dpx[3] = dx0; dpy[3] = vsp->Fy[0];
|
||
if(callback) callback(dpx,dpy,4,callbackdata);
|
||
vsp->CTag = vsp->FTag = -1; break;
|
||
default: did = 0; break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
switch(k)
|
||
{
|
||
case 7: case 6:
|
||
dpx[0] = dx0; dpy[0] = ny0;
|
||
dpx[1] = dx1; dpy[1] = vsp->Fy[1];
|
||
dpx[2] = dx0; dpy[2] = vsp->Fy[0];
|
||
if(callback) callback(dpx,dpy,3,callbackdata);
|
||
vsp->Fy[0] = ny0; vsp->FTag = GTag; break;
|
||
case 5: case 2:
|
||
dpx[0] = dx0; dpy[0] = vsp->Fy[0];
|
||
dpx[1] = dx1; dpy[1] = ny1;
|
||
dpx[2] = dx1; dpy[2] = vsp->Fy[1];
|
||
if(callback) callback(dpx,dpy,3,callbackdata);
|
||
vsp->Fy[1] = ny1; vsp->FTag = GTag; break;
|
||
case 4: case 3: case 1:
|
||
dpx[0] = dx0; dpy[0] = ny0;
|
||
dpx[1] = dx1; dpy[1] = ny1;
|
||
dpx[2] = dx1; dpy[2] = vsp->Fy[1];
|
||
dpx[3] = dx0; dpy[3] = vsp->Fy[0];
|
||
if(callback) callback(dpx,dpy,4,callbackdata);
|
||
vsp->Fy[0] = ny0; vsp->Fy[1] = ny1; vsp->FTag = GTag; break;
|
||
case 0:
|
||
dpx[0] = dx0; dpy[0] = vsp->Cy[0];
|
||
dpx[1] = dx1; dpy[1] = vsp->Cy[1];
|
||
dpx[2] = dx1; dpy[2] = vsp->Fy[1];
|
||
dpx[3] = dx0; dpy[3] = vsp->Fy[0];
|
||
if(callback) callback(dpx,dpy,4,callbackdata);
|
||
vsp->CTag = vsp->FTag = -1; break;
|
||
default: did = 0; break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
GTag++;
|
||
|
||
//Combine neighboring vertical strips with matching collinear top&bottom edges
|
||
//This prevents x-splits from propagating through the entire scan
|
||
vsp = UsedList.Next;
|
||
while (vsp->Next != &UsedList)
|
||
{
|
||
ni = vsp->Next;
|
||
if ((vsp->Cy[0] >= vsp->Fy[0]) && (vsp->Cy[1] >= vsp->Fy[1]))
|
||
{ vsp->CTag = vsp->FTag = -1; }
|
||
if ((vsp->CTag == ni->CTag) && (vsp->FTag == ni->FTag))
|
||
{ vsp->Cy[1] = ni->Cy[1]; vsp->Fy[1] = ni->Fy[1]; FreeVsp (ni); }
|
||
else vsp = ni;
|
||
}
|
||
return did;
|
||
}
|
||
|
||
#include "d_event.h"
|
||
CVAR(Bool, testpolymost, false, 0)
|
||
static int pmx, pmy;
|
||
static int pt, px0, py0, px1, py1;
|
||
static struct polypt { float x, y; } polypts[80];
|
||
static BYTE polysize[32];
|
||
static int numpoly, polypt;
|
||
PolyClipper TestPoly;
|
||
|
||
void drawline2d (float x1, float y1, float x2, float y2, BYTE col)
|
||
{
|
||
float dx, dy, fxresm1, fyresm1, f;
|
||
long i, x, y, xi, yi, xup16, yup16;
|
||
|
||
//Always draw lines in same direction
|
||
if ((y2 > y1) || ((y2 == y1) && (x2 > x1))) { f = x1; x1 = x2; x2 = f; f = y1; y1 = y2; y2 = f; }
|
||
|
||
dx = x2-x1; dy = y2-y1; if ((dx == 0) && (dy == 0)) return;
|
||
fxresm1 = (float)RenderTarget->GetWidth()-.5; fyresm1 = (float)RenderTarget->GetHeight()-.5;
|
||
if (x1 >= fxresm1) { if (x2 >= fxresm1) return; y1 += (fxresm1-x1)*dy/dx; x1 = fxresm1; }
|
||
else if (x1 < 0) { if (x2 < 0) return; y1 += ( 0-x1)*dy/dx; x1 = 0; }
|
||
if (x2 >= fxresm1) { y2 += (fxresm1-x2)*dy/dx; x2 = fxresm1; }
|
||
else if (x2 < 0) { y2 += ( 0-x2)*dy/dx; x2 = 0; }
|
||
if (y1 >= fyresm1) { if (y2 >= fyresm1) return; x1 += (fyresm1-y1)*dx/dy; y1 = fyresm1; }
|
||
else if (y1 < 0) { if (y2 < 0) return; x1 += ( 0-y1)*dx/dy; y1 = 0; }
|
||
if (y2 >= fyresm1) { x2 += (fyresm1-y2)*dx/dy; y2 = fyresm1; }
|
||
else if (y2 < 0) { x2 += ( 0-y2)*dx/dy; y2 = 0; }
|
||
|
||
dx = x2-x1; dy = y2-y1;
|
||
i = (long)(MAX(fabsf(dx)+1,fabsf(dy)+1)); f = 65536.f/((float)i);
|
||
x = (long)(x1*65536.f)+32768; xi = (long)(dx*f); xup16 = (RenderTarget->GetWidth()<<16);
|
||
y = (long)(y1*65536.f)+32768; yi = (long)(dy*f); yup16 = (RenderTarget->GetHeight()<<16);
|
||
do
|
||
{
|
||
if (((unsigned long)x < (unsigned long)xup16) && ((unsigned long)y < (unsigned long)yup16))
|
||
*(ylookup[y>>16]+(x>>16)+dc_destorg) = col;
|
||
x += xi; y += yi; i--;
|
||
} while (i >= 0);
|
||
}
|
||
|
||
static int maskhack;
|
||
|
||
void fillconvpoly (float x[], float y[], int n, int col, int bcol)
|
||
{
|
||
int mini = y[0] >= y[1], maxi = 1 - mini;
|
||
int i, j, y2, oz, z, yy, zz, ncol;
|
||
float area, xi, xx;
|
||
static int lastx[MAXHEIGHT+2];
|
||
|
||
for (z = 2; z < n; ++z)
|
||
{
|
||
if (y[z] < y[mini]) mini = z;
|
||
if (y[z] > y[maxi]) maxi = z;
|
||
}
|
||
|
||
area = 0; zz = n - 1;
|
||
for (z = 0; z < n; ++z)
|
||
{
|
||
area += (x[zz] - x[z]) * (y[z] + y[zz]); zz = z;
|
||
}
|
||
if (area <= 0) return;
|
||
|
||
i = maxi; y2 = int(y[i]);
|
||
do
|
||
{
|
||
j = i + 1; if (j == n) j = 0;
|
||
yy = int(ceilf(y[j]));
|
||
if (yy < 0) yy = 0;
|
||
if (yy < y2)
|
||
{
|
||
xi = (x[j] - x[i]) / (y[j] - y[i]);
|
||
xx = (y2 - y[j]) * xi + x[j];
|
||
if (y2 >= RenderTarget->GetHeight()) { xx = xx - (y2 - RenderTarget->GetHeight() + 1)*xi; y2 = RenderTarget->GetHeight()-1; }
|
||
for (; y2 >= yy; --y2)
|
||
{
|
||
lastx[y2] = MAX (0, int(ceilf(xx))); xx = xx - xi;
|
||
}
|
||
}
|
||
i = j;
|
||
} while (i != mini);
|
||
if (y2 == yy) lastx[yy] = lastx[yy+1];
|
||
do
|
||
{
|
||
j = i + 1; if (j == n) j = 0;
|
||
y2 = int(y[j]);
|
||
if (y2 >= RenderTarget->GetHeight()) y2 = RenderTarget->GetHeight()-1;
|
||
if (y2 > yy)
|
||
{
|
||
xi = (x[j] - x[i]) / (y[j] - y[i]);
|
||
xx = (yy - y[i]) * xi + x[i];
|
||
if (yy < 0) { xx = xx - xi*yy; yy = 0; }
|
||
ncol = col; if (yy & 1) ncol = ncol ^ maskhack;
|
||
for (; yy <= y2; ++yy)
|
||
{
|
||
//drawline2d(lastx[yy], yy, int(ceilf(xx)), yy, ncol); xx = xx + xi;
|
||
int xxx = MIN(RenderTarget->GetWidth(), int(ceilf(xx)));
|
||
if (yy < RenderTarget->GetHeight() && lastx[yy] < xxx) memset(RenderTarget->GetBuffer()+yy*RenderTarget->GetPitch()+lastx[yy], ncol, xxx-lastx[yy]);
|
||
xx = xx + xi;
|
||
ncol = ncol ^ maskhack;
|
||
}
|
||
}
|
||
i = j;
|
||
} while (i != maxi);
|
||
|
||
if (col != bcol)
|
||
{
|
||
oz = n - 1;
|
||
for (z = 0; z < n; ++z)
|
||
{
|
||
drawline2d(x[oz], y[oz], x[z], y[z], bcol);
|
||
oz = z;
|
||
}
|
||
}
|
||
}
|
||
|
||
void drawtri(float x0, float y0, float x1, float y1, float x2, float y2, int col, int bcol)
|
||
{
|
||
float x[3], y[3];
|
||
x[0] = x0; y[0] = y0;
|
||
x[1] = x1; y[1] = y1;
|
||
x[2] = x2; y[2] = y2;
|
||
fillconvpoly(x, y, 3, col, bcol);
|
||
}
|
||
|
||
void drawquad(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, int col, int bcol)
|
||
{
|
||
float x[4], y[4];
|
||
x[0] = x0; y[0] = y0;
|
||
x[1] = x1; y[1] = y1;
|
||
x[2] = x2; y[2] = y2;
|
||
x[3] = x3; y[3] = y3;
|
||
fillconvpoly(x, y, 4, col, bcol); // 2 triangles
|
||
if (col != bcol)
|
||
{
|
||
if (fabsf(y0-y2) < fabsf(y1-y3))
|
||
drawline2d(x0,y0,x2,y2,bcol);
|
||
else
|
||
drawline2d(x1,y1,x3,y3,bcol);
|
||
}
|
||
}
|
||
|
||
void printnum(int x, int y, int num)
|
||
{
|
||
char foo[16]; sprintf (foo, "%d", num);
|
||
RenderTarget->DrawText (CR_WHITE, x, y, foo);
|
||
}
|
||
|
||
void drawpolymosttest()
|
||
{
|
||
float cx0 = 0, cy0 = 0, fx0 = 0, fy0 = 0;
|
||
int ccol, fcol;
|
||
PolyClipper::vsptype *vsp, *ovsp = &TestPoly.UsedList, *nvsp;
|
||
|
||
fcol = 0; ccol = 0;
|
||
|
||
RenderTarget->Clear(0, 0, RenderTarget->GetWidth(), RenderTarget->GetHeight(), 0, 0);
|
||
for (vsp = ovsp->Next; vsp->Next != &TestPoly.UsedList; ovsp = vsp, vsp = nvsp)
|
||
{
|
||
nvsp = vsp->Next;
|
||
if (vsp->CTag == -1 && vsp->FTag == -1)
|
||
{ // Hide spans that have been clipped away
|
||
vsp->Cy[0] = vsp->Cy[1] = vsp->Fy[0] = vsp->Fy[1] = RenderTarget->GetHeight()/2;
|
||
}
|
||
|
||
if (vsp->CTag != ovsp->CTag) cx0 = vsp->X, cy0 = vsp->Cy[0];
|
||
if (vsp->CTag != nvsp->CTag)
|
||
{ // fill the ceiling region
|
||
maskhack = 0x18;
|
||
drawquad(cx0, 0, nvsp->X, 0, nvsp->X, vsp->Cy[1], cx0, cy0, ccol, ccol);
|
||
maskhack = 0; ccol ^= 0x18;
|
||
printnum(int(cx0 + nvsp->X) / 2, 2, vsp->CTag);
|
||
}
|
||
|
||
if(vsp->FTag != ovsp->FTag) fx0 = vsp->X, fy0 = vsp->Fy[0];
|
||
if(vsp->FTag != nvsp->FTag)
|
||
{ // fill the floor region
|
||
maskhack = 0x78;
|
||
drawquad(fx0, fy0+1, nvsp->X, vsp->Fy[1]+1, nvsp->X, RenderTarget->GetHeight(), fx0, RenderTarget->GetHeight(), fcol, fcol);
|
||
maskhack = 0; fcol ^= 0x78;
|
||
printnum(int(fx0 + nvsp->X) / 2, RenderTarget->GetHeight()-10, vsp->FTag);
|
||
}
|
||
|
||
// fill the unclipped middle region
|
||
drawquad(vsp->X, vsp->Cy[0], nvsp->X, vsp->Cy[1], nvsp->X, vsp->Fy[1], vsp->X, vsp->Fy[0], 0xC4, 0xE6);
|
||
}
|
||
|
||
int x = (pmx + 3) & ~7, y = (pmy + 3) & ~7;
|
||
|
||
drawline2d (x - 3, y, x + 3, y, 30);
|
||
drawline2d (x, y - 3, x, y + 3, 30);
|
||
printnum ( 0, 20, x);
|
||
printnum (50, 20, y);
|
||
|
||
if (pt > 0 && px0 != px1)
|
||
{
|
||
if (px0 < px1)
|
||
{
|
||
drawline2d (px0, py0, px0, RenderTarget->GetHeight()-1, 47);
|
||
drawline2d (px1, py1, px1, RenderTarget->GetHeight()-1, 47);
|
||
}
|
||
else
|
||
{
|
||
drawline2d (px0, py0, px0, 0, 47);
|
||
drawline2d (px1, py1, px1, 0, 47);
|
||
}
|
||
drawline2d (px0, py0, px1, py1, 47);
|
||
}
|
||
if (pt == 2)
|
||
{
|
||
int i = 0;
|
||
for (x = 0; x < numpoly; ++x)
|
||
{
|
||
if (polysize[x] == 3)
|
||
{
|
||
drawtri (polypts[i ].x, polypts[i ].y,
|
||
polypts[i+1].x, polypts[i+1].y,
|
||
polypts[i+2].x, polypts[i+2].y, 0x7f, 0x9f);
|
||
i += 3;
|
||
}
|
||
else
|
||
{
|
||
drawquad (polypts[i ].x, polypts[i ].y,
|
||
polypts[i+1].x, polypts[i+1].y,
|
||
polypts[i+2].x, polypts[i+2].y,
|
||
polypts[i+3].x, polypts[i+3].y, 0x7f, 0x9f);
|
||
i += 4;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
CCMD(initpolymosttest)
|
||
{
|
||
double px[4], py[4];
|
||
int test = 0;
|
||
|
||
if (argv.argc() > 1)
|
||
test = atoi(argv[1]);
|
||
|
||
// Box
|
||
px[0] = px[3] = 0;
|
||
px[1] = px[2] = screen->GetWidth();
|
||
py[0] = py[1] = screen->GetHeight()/4;
|
||
py[2] = py[3] = screen->GetHeight()*3/4;
|
||
|
||
switch (test)
|
||
{
|
||
case 1: // Shorter top edge
|
||
px[0] = px[1]/6;
|
||
px[1] = px[1]*5/6;
|
||
break;
|
||
|
||
case 2: // Shorter bottom edge
|
||
px[3] = px[2]/6;
|
||
px[2] = px[2]*5/6;
|
||
break;
|
||
|
||
case 3: // Shorter left edge
|
||
py[0] = screen->GetHeight()*3/8;
|
||
py[3] = screen->GetHeight()*5/8;
|
||
break;
|
||
|
||
case 4: // Shorter right edge
|
||
py[1] = screen->GetHeight()*3/8;
|
||
py[2] = screen->GetHeight()*5/8;
|
||
break;
|
||
|
||
case 5:
|
||
px[0] = -1.0048981460288360/2+50; py[0] = -1.0/2+50;
|
||
px[1] = 643.00492866407262/2+50; py[1] = -1.0/2+50;
|
||
px[2] = 643.00492866407262/2+50; py[2] = 483/2+50;
|
||
px[3] = -1.0048981460288360/2+50; py[3] = 483/2+50;
|
||
break;
|
||
}
|
||
TestPoly.InitMosts (px, py, 4);
|
||
pmx = screen->GetWidth()/2;
|
||
pmy = screen->GetHeight()/2;
|
||
pt = 0;
|
||
}
|
||
|
||
static void testpolycallback (double *dpx, double *dpy, int n, void *foo)
|
||
{
|
||
if (numpoly == sizeof(polysize)) return;
|
||
if (size_t(polypt + n) > countof(polypts)) return;
|
||
polysize[numpoly++] = n;
|
||
for (int i = 0; i < n; ++i)
|
||
{
|
||
polypts[polypt + i].x = dpx[i];
|
||
polypts[polypt + i].y = dpy[i];
|
||
}
|
||
polypt += n;
|
||
}
|
||
|
||
void Polymost_Responder (event_t *ev)
|
||
{
|
||
if (ev->type == EV_Mouse && pt < 2)
|
||
{
|
||
pmx = clamp (pmx + ev->x, 0, screen->GetWidth()-1);
|
||
pmy = clamp (pmy - ev->y, 0, screen->GetHeight()-1);
|
||
int x = (pmx + 3) & ~7, y = (pmy + 3) & ~7;
|
||
if (pt == 0) px0 = x, py0 = y;
|
||
if (pt <= 1) px1 = x, py1 = y;
|
||
}
|
||
else if (ev->type == EV_KeyDown && ev->data1 == KEY_MOUSE1)
|
||
{
|
||
if (pt == 0) pt = 1; else pt = 0;
|
||
}
|
||
else if (ev->type == EV_KeyUp && ev->data1 == KEY_MOUSE1)
|
||
{
|
||
if (pt == 1) { if (px0 != px1) pt++; else pt--; }
|
||
if (pt == 2)
|
||
{
|
||
numpoly = polypt = 0;
|
||
TestPoly.DoMost (px0, py0, px1, py1, testpolycallback, NULL);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
extern fixed_t WallSZ1, WallSZ2, WallTX1, WallTX2, WallTY1, WallTY2, WallCX1, WallCX2, WallCY1, WallCY2;
|
||
extern int WallSX1, WallSX2;
|
||
extern float WallUoverZorg, WallUoverZstep, WallInvZorg, WallInvZstep, WallDepthScale, WallDepthOrg;
|
||
extern fixed_t rw_backcz1, rw_backcz2;
|
||
extern fixed_t rw_backfz1, rw_backfz2;
|
||
extern fixed_t rw_frontcz1, rw_frontcz2;
|
||
extern fixed_t rw_frontfz1, rw_frontfz2;
|
||
extern fixed_t rw_offset;
|
||
extern bool rw_markmirror;
|
||
extern bool rw_havehigh;
|
||
extern bool rw_havelow;
|
||
extern bool markfloor;
|
||
extern bool markceiling;
|
||
extern FTexture *toptexture;
|
||
extern FTexture *bottomtexture;
|
||
extern FTexture *midtexture;
|
||
extern bool rw_mustmarkfloor, rw_mustmarkceiling;
|
||
extern void R_NewWall(bool);
|
||
extern void R_GetExtraLight (int *light, const secplane_t &plane, FExtraLight *el);
|
||
extern int doorclosed;
|
||
extern int viewpitch;
|
||
#include "p_lnspec.h"
|
||
|
||
PolyClipper Mosts;
|
||
static bool drawback;
|
||
|
||
bool RP_SetupFrame (bool backside)
|
||
{
|
||
double ox, oy, oz, ox2, oy2, oz2, r, px[6], py[6], pz[6], px2[6], py2[6], pz2[6], sx[6], sy[6];
|
||
int i, j, n, n2;
|
||
|
||
drawback = backside;
|
||
if (backside)
|
||
{
|
||
viewangle += ANGLE_180;
|
||
viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
|
||
viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];
|
||
viewtansin = FixedMul (FocalTangent, viewsin);
|
||
viewtancos = FixedMul (FocalTangent, viewcos);
|
||
}
|
||
//Polymost supports true look up/down :) Here, we convert horizon to angle.
|
||
//gchang&gshang are cos&sin of this angle (respectively)
|
||
// gyxscale = ((double)xdimenscale)/131072.0;
|
||
gyxscale = double(InvZtoScale)/65536.0;///131072.0/320.0;
|
||
// gxyaspect = ((double)xyaspect*(double)viewingrange)*(5.0/(65536.0*262144.0));
|
||
// gviewxrange = ((double)viewingrange)*((double)xdimen)/(32768.0*128.0);
|
||
gcosang = double(viewcos)/65536.0;
|
||
gsinang = double(viewsin)/65536.0;
|
||
gcosang2 = gcosang*double(FocalTangent)/65536.0;
|
||
gsinang2 = gsinang*double(FocalTangent)/65536.0;
|
||
ghalfx = (double)viewwidth*0.5; grhalfxdown10 = 1.0/(((double)ghalfx)*1024);
|
||
|
||
//global cos/sin height angle
|
||
angle_t pitch = (angle_t)viewpitch;
|
||
if (backside) pitch = ANGLE_180 - pitch;
|
||
|
||
gshang = double(finesine[pitch>>ANGLETOFINESHIFT])/65536.0;
|
||
gchang = double(finecosine[pitch>>ANGLETOFINESHIFT])/65536.0;
|
||
ghoriz = double(viewheight)*0.5;
|
||
|
||
//global cos/sin tilt angle
|
||
gctang = cos(gtang);
|
||
gstang = sin(gtang);
|
||
if (fabs(gstang) < .001) //This hack avoids nasty precision bugs in domost()
|
||
{ gstang = 0; if (gctang > 0) gctang = 1.0; else gctang = -1.0; }
|
||
|
||
// Generate viewport trapezoid
|
||
px[0] = px[3] = 0-1; px[1] = px[2] = viewwidth+3;
|
||
py[0] = py[1] = 0-1; py[2] = py[3] = viewheight+3; n = 4;
|
||
for(i=0;i<n;i++)
|
||
{
|
||
ox = px[i]-ghalfx; oy = py[i]-ghoriz; oz = ghalfx;
|
||
|
||
//Tilt rotation (backwards)
|
||
ox2 = ox*gctang + oy*gstang;
|
||
oy2 = oy*gctang - ox*gstang;
|
||
oz2 = oz;
|
||
|
||
//Up/down rotation (backwards)
|
||
px[i] = ox2;
|
||
py[i] = oy2*gchang + oz2*gshang;
|
||
pz[i] = oz2*gchang - oy2*gshang;
|
||
}
|
||
|
||
//Clip to SCISDIST plane
|
||
n2 = 0;
|
||
bool clipped = false;
|
||
for(i=0;i<n;i++)
|
||
{
|
||
j = i+1; if (j >= n) j = 0;
|
||
if (pz[i] >= SCISDIST/16) { px2[n2] = px[i]; py2[n2] = py[i]; pz2[n2] = pz[i]; n2++; }
|
||
if ((pz[i] >= SCISDIST/16) != (pz[j] >= SCISDIST/16))
|
||
{
|
||
clipped = true;
|
||
r = (SCISDIST/16-pz[i])/(pz[j]-pz[i]);
|
||
px2[n2] = (px[j]-px[i])*r + px[i];
|
||
py2[n2] = (py[j]-py[i])*r + py[i];
|
||
pz2[n2] = SCISDIST/16;
|
||
if (backside) py2[n2] -= r;
|
||
n2++;
|
||
}
|
||
}
|
||
if (n2 < 3) { return true; }
|
||
for(i=0;i<n2;i++)
|
||
{
|
||
r = ghalfx / pz2[i];
|
||
sx[i] = px2[i]*r + ghalfx;
|
||
sy[i] = py2[i]*r + ghoriz;
|
||
}
|
||
Mosts.InitMosts (sx, sy, n2);
|
||
return clipped;
|
||
}
|
||
|
||
CVAR (Bool, r_nopolytilt, 0, 0)
|
||
|
||
static void wireframe (double *dpx, double *dpy, int n, void *data)
|
||
{
|
||
int wfc = (int)(size_t)data;
|
||
double f, r, ox, oy, oz, ox2, oy2, oz2;
|
||
float px[16], py[16];
|
||
int i, j, k;
|
||
|
||
if (n == 3)
|
||
{
|
||
if ((dpx[0]-dpx[1])*(dpy[2]-dpy[1]) >= (dpx[2]-dpx[1])*(dpy[0]-dpy[1])) return; //for triangle
|
||
}
|
||
else
|
||
{
|
||
f = 0; //f is area of polygon / 2
|
||
for(i=n-2,j=n-1,k=0;k<n;i=j,j=k,k++) f += (dpx[i]-dpx[k])*dpy[j];
|
||
if (f <= 0) return;
|
||
}
|
||
|
||
j = 0;
|
||
for(i=0;i<n;i++)
|
||
{
|
||
if (!r_nopolytilt)
|
||
{
|
||
ox = dpx[i]-ghalfx;
|
||
oy = dpy[i]-ghoriz;
|
||
oz = ghalfx;
|
||
|
||
//Up/down rotation
|
||
ox2 = ox;
|
||
oy2 = oy*gchang - oz*gshang;
|
||
oz2 = oy*gshang + oz*gchang;
|
||
|
||
//Tilt rotation
|
||
ox = ox2*gctang - oy2*gstang;
|
||
oy = ox2*gstang + oy2*gctang;
|
||
oz = oz2;
|
||
|
||
r = ghalfx / oz;
|
||
|
||
if (drawback)
|
||
{
|
||
ox = -ox;
|
||
oy = -oy;
|
||
}
|
||
px[j] = ox*r + ghalfx;
|
||
py[j] = oy*r + ghoriz;
|
||
}
|
||
else
|
||
{
|
||
px[j] = (dpx[i]-ghalfx)*0.5+ghalfx;
|
||
py[j] = (dpy[i]-ghoriz)*0.5+ghoriz;
|
||
}
|
||
if ((!j) || (px[j] != px[j-1]) || (py[j] != py[j-1])) j++;
|
||
}
|
||
if (r_polymost == 2 || r_polymost == 3)
|
||
{
|
||
fillconvpoly (px, py, j, wfc+4, r_polymost == 2 ? wfc : wfc+4);
|
||
}
|
||
if (r_polymost == 1)
|
||
{
|
||
for (i=0, k=j-1; i < j; k=i, ++i)
|
||
{
|
||
drawline2d (px[k], py[k], px[i], py[i], wfc);
|
||
}
|
||
}
|
||
}
|
||
|
||
void RP_AddLine (seg_t *line)
|
||
{
|
||
static sector_t tempsec; // killough 3/8/98: ceiling/water hack
|
||
bool solid;
|
||
fixed_t tx1, tx2, ty1, ty2;
|
||
fixed_t fcz0, ffz0, fcz1, ffz1, bcz0, bfz0, bcz1, bfz1;
|
||
double x0, x1, xp0, yp0, xp1, yp1, oxp0, oyp0, nx0, ny0, nx1, ny1, ryp0, ryp1;
|
||
double cy0, fy0, cy1, fy1, ocy0 = 0, ofy0 = 0, ocy1 = 0, ofy1 = 0;
|
||
double t0, t1;
|
||
double x, y;
|
||
|
||
curline = line;
|
||
|
||
if (line->linedef == NULL) return;
|
||
|
||
//Offset&Rotate 3D coordinates to screen 3D space
|
||
x = double(line->v1->x - viewx); y = double(line->v1->y - viewy);
|
||
xp0 = x*gsinang - y*gcosang;
|
||
yp0 = x*gcosang2 + y*gsinang2;
|
||
x = double(line->v2->x - viewx); y = double(line->v2->y - viewy);
|
||
xp1 = x*gsinang - y*gcosang;
|
||
yp1 = x*gcosang2 + y*gsinang2;
|
||
|
||
oxp0 = xp0; oyp0 = yp0;
|
||
|
||
//Clip to close parallel-screen plane
|
||
// [RH] Why oh why does clipping the left side of the wall against
|
||
// a small SCISDIST not work for me? Strictly speaking, it's not
|
||
// the clipping of the left side that's the problem, because if I
|
||
// rotate the view 180 degrees so the right side of the wall is on
|
||
// the left of the screen, then clipping the right side becomes
|
||
// problematic.
|
||
#define WCLIPDIST (SCISDIST*256.0)
|
||
if (yp0 < WCLIPDIST)
|
||
{
|
||
if (yp1 < WCLIPDIST) return;
|
||
t0 = (WCLIPDIST-yp0)/(yp1-yp0);
|
||
xp0 = (xp1-xp0)*t0+xp0;
|
||
yp0 = WCLIPDIST;
|
||
nx0 = (line->v2->x - line->v1->x)*t0 + line->v1->x;
|
||
ny0 = (line->v2->y - line->v1->y)*t0 + line->v1->y;
|
||
}
|
||
else { t0 = 0.f; nx0 = line->v1->x; ny0 = line->v1->y; }
|
||
if (yp1 < WCLIPDIST)
|
||
{
|
||
t1 = (WCLIPDIST-oyp0)/(yp1-oyp0);
|
||
xp1 = (xp1-oxp0)*t1+oxp0;
|
||
yp1 = WCLIPDIST;
|
||
nx1 = (line->v2->x - line->v1->x)*t1 + line->v1->x;
|
||
ny1 = (line->v2->y - line->v1->y)*t1 + line->v1->y;
|
||
}
|
||
else { t1 = 1.f; nx1 = line->v2->x; ny1 = line->v2->y; }
|
||
|
||
ryp0 = 1.0/yp0; ryp1 = 1.0/yp1;
|
||
|
||
//Generate screen coordinates for front side of wall
|
||
x0 = ghalfx*xp0*ryp0 + ghalfx;
|
||
x1 = ghalfx*xp1*ryp1 + ghalfx;
|
||
if (x1 <= x0) return;
|
||
|
||
ryp0 *= gyxscale; ryp1 *= gyxscale;
|
||
fixed_t fnx0 = fixed_t(nx0), fny0 = fixed_t(ny0);
|
||
fixed_t fnx1 = fixed_t(nx1), fny1 = fixed_t(ny1);
|
||
|
||
fcz0 = frontsector->ceilingplane.ZatPoint (fnx0, fny0);
|
||
ffz0 = frontsector->floorplane.ZatPoint (fnx0, fny0);
|
||
fcz1 = frontsector->ceilingplane.ZatPoint (fnx1, fny1);
|
||
ffz1 = frontsector->floorplane.ZatPoint (fnx1, fny1);
|
||
bool cc = (t0>0 && x1 > 0);
|
||
cy0 = ghoriz - double(fcz0 - viewz) * ryp0;
|
||
fy0 = ghoriz - double(ffz0 - viewz) * ryp0;
|
||
cy1 = ghoriz - double(fcz1 - viewz) * ryp1;
|
||
fy1 = ghoriz - double(ffz1 - viewz) * ryp1;
|
||
|
||
/*
|
||
tx1 = line->v1->x - viewx;
|
||
tx2 = line->v2->x - viewx;
|
||
ty1 = line->v1->y - viewy;
|
||
ty2 = line->v2->y - viewy;
|
||
// Reject lines not facing viewer
|
||
if (DMulScale32 (ty1, tx1-tx2, tx1, ty2-ty1) >= 0)
|
||
return;
|
||
|
||
WallTX1 = DMulScale20 (tx1, viewsin, -ty1, viewcos);
|
||
WallTX2 = DMulScale20 (tx2, viewsin, -ty2, viewcos);
|
||
|
||
WallTY1 = DMulScale20 (tx1, viewtancos, ty1, viewtansin);
|
||
WallTY2 = DMulScale20 (tx2, viewtancos, ty2, viewtansin);
|
||
|
||
if (MirrorFlags & RF_XFLIP)
|
||
{
|
||
int t = 256-WallTX1;
|
||
WallTX1 = 256-WallTX2;
|
||
WallTX2 = t;
|
||
swap (WallTY1, WallTY2);
|
||
}
|
||
|
||
if (WallTX1 >= -WallTY1)
|
||
{
|
||
if (WallTX1 > WallTY1) return; // left edge is off the right side
|
||
if (WallTY1 == 0) return;
|
||
WallSX1 = (centerxfrac + Scale (WallTX1, centerxfrac, WallTY1)) >> FRACBITS;
|
||
if (WallTX1 >= 0) WallSX1 = MIN (viewwidth, WallSX1+1); // fix for signed divide
|
||
WallSZ1 = WallTY1;
|
||
}
|
||
else
|
||
{
|
||
if (WallTX2 < -WallTY2) return; // wall is off the left side
|
||
fixed_t den = WallTX1 - WallTX2 - WallTY2 + WallTY1;
|
||
if (den == 0) return;
|
||
WallSX1 = 0;
|
||
WallSZ1 = WallTY1 + Scale (WallTY2 - WallTY1, WallTX1 + WallTY1, den);
|
||
}
|
||
|
||
if (WallSZ1 < 32)
|
||
return;
|
||
|
||
if (WallTX2 <= WallTY2)
|
||
{
|
||
if (WallTX2 < -WallTY2) return; // right edge is off the left side
|
||
if (WallTY2 == 0) return;
|
||
WallSX2 = (centerxfrac + Scale (WallTX2, centerxfrac, WallTY2)) >> FRACBITS;
|
||
if (WallTX2 >= 0) WallSX2 = MIN (viewwidth, WallSX2+1); // fix for signed divide
|
||
WallSZ2 = WallTY2;
|
||
}
|
||
else
|
||
{
|
||
if (WallTX1 > WallTY1) return; // wall is off the right side
|
||
fixed_t den = WallTY2 - WallTY1 - WallTX2 + WallTX1;
|
||
if (den == 0) return;
|
||
WallSX2 = viewwidth;
|
||
WallSZ2 = WallTY1 + Scale (WallTY2 - WallTY1, WallTX1 - WallTY1, den);
|
||
}
|
||
|
||
if (WallSZ2 < 32 || WallSX2 <= WallSX1)
|
||
return;
|
||
|
||
if (WallSX1 > WindowRight || WallSX2 < WindowLeft)
|
||
return;
|
||
if (line->linedef == NULL)
|
||
{
|
||
return;
|
||
}
|
||
*/
|
||
|
||
vertex_t *v1, *v2;
|
||
|
||
v1 = line->linedef->v1;
|
||
v2 = line->linedef->v2;
|
||
|
||
if ((v1 == line->v1 && v2 == line->v2) || (v2 == line->v1 && v1 == line->v2))
|
||
{ // The seg is the entire wall.
|
||
if (MirrorFlags & RF_XFLIP)
|
||
{
|
||
WallUoverZorg = (float)WallTX2 * WallTMapScale;
|
||
WallUoverZstep = (float)(-WallTY2) * 32.f;
|
||
WallInvZorg = (float)(WallTX2 - WallTX1) * WallTMapScale;
|
||
WallInvZstep = (float)(WallTY1 - WallTY2) * 32.f;
|
||
}
|
||
else
|
||
{
|
||
WallUoverZorg = (float)WallTX1 * WallTMapScale;
|
||
WallUoverZstep = (float)(-WallTY1) * 32.f;
|
||
WallInvZorg = (float)(WallTX1 - WallTX2) * WallTMapScale;
|
||
WallInvZstep = (float)(WallTY2 - WallTY1) * 32.f;
|
||
}
|
||
}
|
||
else
|
||
{ // The seg is only part of the wall.
|
||
if (line->linedef->sidenum[0] != DWORD(line->sidedef - sides))
|
||
{
|
||
swap (v1, v2);
|
||
}
|
||
tx1 = v1->x - viewx;
|
||
tx2 = v2->x - viewx;
|
||
ty1 = v1->y - viewy;
|
||
ty2 = v2->y - viewy;
|
||
|
||
fixed_t fullx1 = DMulScale20 (tx1, viewsin, -ty1, viewcos);
|
||
fixed_t fullx2 = DMulScale20 (tx2, viewsin, -ty2, viewcos);
|
||
fixed_t fully1 = DMulScale20 (tx1, viewtancos, ty1, viewtansin);
|
||
fixed_t fully2 = DMulScale20 (tx2, viewtancos, ty2, viewtansin);
|
||
|
||
if (MirrorFlags & RF_XFLIP)
|
||
{
|
||
fullx1 = -fullx1;
|
||
fullx2 = -fullx2;
|
||
}
|
||
|
||
WallUoverZorg = (float)fullx1 * WallTMapScale;
|
||
WallUoverZstep = (float)(-fully1) * 32.f;
|
||
WallInvZorg = (float)(fullx1 - fullx2) * WallTMapScale;
|
||
WallInvZstep = (float)(fully2 - fully1) * 32.f;
|
||
}
|
||
WallDepthScale = WallInvZstep * WallTMapScale2;
|
||
WallDepthOrg = -WallUoverZstep * WallTMapScale2;
|
||
|
||
backsector = line->backsector;
|
||
|
||
rw_mustmarkfloor = rw_mustmarkceiling = false;
|
||
rw_havehigh = rw_havelow = false;
|
||
|
||
// Single sided line?
|
||
if (backsector == NULL)
|
||
{
|
||
solid = true;
|
||
}
|
||
else
|
||
{
|
||
// killough 3/8/98, 4/4/98: hack for invisible ceilings / deep water
|
||
backsector = R_FakeFlat (backsector, &tempsec, NULL, NULL, true);
|
||
|
||
doorclosed = 0; // killough 4/16/98
|
||
|
||
bcz0 = backsector->ceilingplane.ZatPoint (fnx0, fny0);
|
||
bfz0 = backsector->floorplane.ZatPoint (fnx0, fny0);
|
||
bcz1 = backsector->ceilingplane.ZatPoint (fnx1, fny1);
|
||
bfz1 = backsector->floorplane.ZatPoint (fnx1, fny1);
|
||
ocy0 = ghoriz - double(bcz0 - viewz) * ryp0;
|
||
ofy0 = ghoriz - double(bfz0 - viewz) * ryp0;
|
||
ocy1 = ghoriz - double(bcz1 - viewz) * ryp1;
|
||
ofy1 = ghoriz - double(bfz1 - viewz) * ryp1;
|
||
|
||
if (fcz0 > bcz0 || fcz1 > bcz1)
|
||
{
|
||
rw_havehigh = true;
|
||
}
|
||
if (ffz0 < bfz0 ||ffz1 < bfz1)
|
||
{
|
||
rw_havelow = true;
|
||
}
|
||
|
||
// Closed door.
|
||
if ((bcz0 <= ffz0 && bcz1 <= ffz1) || (bfz0 >= fcz0 && bfz1 >= fcz1))
|
||
{
|
||
solid = true;
|
||
}
|
||
else if (
|
||
(backsector->ceilingpic != skyflatnum ||
|
||
frontsector->ceilingpic != skyflatnum)
|
||
|
||
// if door is closed because back is shut:
|
||
&& bcz0 <= bfz0 && bcz1 <= bfz1
|
||
|
||
// preserve a kind of transparent door/lift special effect:
|
||
&& bcz0 >= fcz0 && bcz1 >= fcz1
|
||
|
||
&& ((bfz0 <= ffz0 && bfz1 <= ffz1) || line->sidedef->GetTexture(side_t::bottom).isValid()))
|
||
{
|
||
// killough 1/18/98 -- This function is used to fix the automap bug which
|
||
// showed lines behind closed doors simply because the door had a dropoff.
|
||
//
|
||
// It assumes that Doom has already ruled out a door being closed because
|
||
// of front-back closure (e.g. front floor is taller than back ceiling).
|
||
|
||
// This fixes the automap floor height bug -- killough 1/18/98:
|
||
// killough 4/7/98: optimize: save result in doorclosed for use in r_segs.c
|
||
doorclosed = true;
|
||
solid = true;
|
||
}
|
||
else if (frontsector->ceilingplane != backsector->ceilingplane ||
|
||
frontsector->floorplane != backsector->floorplane)
|
||
{
|
||
// Window.
|
||
solid = false;
|
||
}
|
||
else if (backsector->lightlevel != frontsector->lightlevel
|
||
|| backsector->floorpic != frontsector->floorpic
|
||
|| backsector->ceilingpic != frontsector->ceilingpic
|
||
|| curline->sidedef->GetTexture(side_t::mid).isValid()
|
||
|
||
// killough 3/7/98: Take flats offsets into account:
|
||
|| backsector->GetXOffset(sector_t::floor) != frontsector->GetXOffset(sector_t::floor)
|
||
|| backsector->GetYOffset(sector_t::floor) != frontsector->GetYOffset(sector_t::floor)
|
||
|| backsector->GetXOffset(sector_t::ceiling) != frontsector->GetXOffset(sector_t::ceiling)
|
||
|| backsector->GetYOffset(sector_t::ceiling) != frontsector->GetYOffset(sector_t::ceiling)
|
||
|
||
|| backsector->FloorLight != frontsector->FloorLight
|
||
|| backsector->CeilingLight != frontsector->CeilingLight
|
||
|| backsector->FloorFlags != frontsector->FloorFlags
|
||
|| backsector->CeilingFlags != frontsector->CeilingFlags
|
||
|
||
// [RH] Also consider colormaps
|
||
|| backsector->ColorMap != frontsector->ColorMap
|
||
|
||
// [RH] and scaling
|
||
|| backsector->GetXScale(sector_t::floor) != frontsector->GetXScale(sector_t::floor)
|
||
|| backsector->GetYScale(sector_t::floor) != frontsector->GetYScale(sector_t::floor)
|
||
|| backsector->GetXScale(sector_t::ceiling) != frontsector->GetXScale(sector_t::ceiling)
|
||
|| backsector->GetYScale(sector_t::ceiling) != frontsector->GetYScale(sector_t::ceiling)
|
||
|
||
// [RH] and rotation
|
||
|| backsector->GetAngle(sector_t::floor) != frontsector->GetAngle(sector_t::floor)
|
||
|| backsector->GetAngle(sector_t::ceiling) != frontsector->GetAngle(sector_t::ceiling)
|
||
)
|
||
{
|
||
solid = false;
|
||
}
|
||
else
|
||
{
|
||
// Reject empty lines used for triggers and special events.
|
||
// Identical floor and ceiling on both sides, identical light levels
|
||
// on both sides, and no middle texture.
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (line->linedef->special == Line_Horizon)
|
||
{
|
||
// Be aware: Line_Horizon does not work properly with sloped planes
|
||
fcz1 = fcz0 = ffz1 = ffz0 = viewz;
|
||
markceiling = markfloor = true;
|
||
}
|
||
|
||
// must be fixed in case the polymost renderer ever gets developed further!
|
||
rw_offset = line->sidedef->GetTextureXOffset(side_t::mid);
|
||
|
||
R_NewWall (false);
|
||
if (rw_markmirror)
|
||
{
|
||
WallMirrors.Push (ds_p - drawsegs);
|
||
}
|
||
|
||
// render it
|
||
if (markceiling)
|
||
{
|
||
Mosts.DoMost (x1, cy1, x0, cy0, wireframe, !cc||1?(void *)0xc3:(void*)0xca);
|
||
}
|
||
if (markfloor)
|
||
{
|
||
Mosts.DoMost (x0, fy0, x1, fy1, wireframe, (void *)0xd3);
|
||
}
|
||
if (midtexture)
|
||
{ // one sided line
|
||
//if(line->linedef-lines==1)Printf ("%g %g %g -> %g %g %g : %g %g -> %g %g\n", yp0, x0, fy0, yp1, x1, fy1, nx0, ny0, nx1, ny1);
|
||
if (viewpitch > 0)
|
||
Mosts.DoMost (x0, -10000, x1, -10000, wireframe, !cc||1?(void *)0x83:(void*)0x93);
|
||
else
|
||
Mosts.DoMost (x1, 10000, x0, 10000, wireframe, !cc||1?(void *)0x83:(void*)0x93);
|
||
}
|
||
else
|
||
{ // two sided line
|
||
if (toptexture != NULL && toptexture->UseType != FTexture::TEX_Null)
|
||
{ // top wall
|
||
Mosts.DoMost (x1, ocy1, x0, ocy0, wireframe, (void *)0xa3);
|
||
}
|
||
if (bottomtexture != NULL && bottomtexture->UseType != FTexture::TEX_Null)
|
||
{ // bottom wall
|
||
Mosts.DoMost (x0, ofy0, x1, ofy1, wireframe, (void *)0x93);
|
||
/* float bfz2 = float(-(rw_backfz2 - viewz)) / 65536.f;
|
||
float bfz1 = float(-(rw_backfz1 - viewz)) / 65536.f;
|
||
Mosts.DoMost (WallSX1, bfz1 * izs / sz1 + ghoriz,
|
||
WallSX2, bfz2 * izs / sz2 + ghoriz,
|
||
wireframe, (void *)0x93);*/
|
||
}
|
||
}
|
||
}
|
||
|
||
void RP_Subsector (subsector_t *sub)
|
||
{
|
||
int count;
|
||
seg_t* line;
|
||
sector_t tempsec; // killough 3/7/98: deep water hack
|
||
int floorlightlevel; // killough 3/16/98: set floor lightlevel
|
||
int ceilinglightlevel; // killough 4/11/98
|
||
|
||
frontsector = sub->sector;
|
||
count = sub->numlines;
|
||
line = &segs[sub->firstline];
|
||
|
||
// killough 3/8/98, 4/4/98: Deep water / fake ceiling effect
|
||
frontsector = R_FakeFlat(frontsector, &tempsec, &floorlightlevel,
|
||
&ceilinglightlevel, false); // killough 4/11/98
|
||
|
||
basecolormap = frontsector->ColorMap;
|
||
R_GetExtraLight (&ceilinglightlevel, frontsector->ceilingplane, frontsector->ExtraLights);
|
||
|
||
// [RH] set foggy flag
|
||
foggy = level.fadeto || frontsector->ColorMap->Fade || (level.flags & LEVEL_HASFADETABLE);
|
||
r_actualextralight = foggy ? 0 : extralight << 4;
|
||
basecolormap = frontsector->ColorMap;
|
||
/* ceilingplane = frontsector->ceilingplane.ZatPoint (viewx, viewy) > viewz ||
|
||
frontsector->ceilingpic == skyflatnum ||
|
||
(frontsector->CeilingSkyBox != NULL && frontsector->CeilingSkyBox->bAlways) ||
|
||
(frontsector->heightsec &&
|
||
!(frontsector->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC) &&
|
||
frontsector->heightsec->floorpic == skyflatnum) ?
|
||
R_FindPlane(frontsector->ceilingplane, // killough 3/8/98
|
||
frontsector->ceilingpic,
|
||
ceilinglightlevel + r_actualextralight, // killough 4/11/98
|
||
frontsector->ceiling_xoffs, // killough 3/7/98
|
||
frontsector->ceiling_yoffs + frontsector->base_ceiling_yoffs,
|
||
frontsector->ceiling_xscale,
|
||
frontsector->ceiling_yscale,
|
||
frontsector->ceiling_angle + frontsector->base_ceiling_angle,
|
||
frontsector->sky,
|
||
frontsector->CeilingSkyBox
|
||
) : NULL;*/
|
||
|
||
basecolormap = frontsector->ColorMap;
|
||
R_GetExtraLight (&floorlightlevel, frontsector->floorplane, frontsector->ExtraLights);
|
||
|
||
// killough 3/7/98: Add (x,y) offsets to flats, add deep water check
|
||
// killough 3/16/98: add floorlightlevel
|
||
// killough 10/98: add support for skies transferred from sidedefs
|
||
/* floorplane = frontsector->floorplane.ZatPoint (viewx, viewy) < viewz || // killough 3/7/98
|
||
frontsector->floorpic == skyflatnum ||
|
||
(frontsector->FloorSkyBox != NULL && frontsector->FloorSkyBox->bAlways) ||
|
||
(frontsector->heightsec &&
|
||
!(frontsector->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC) &&
|
||
frontsector->heightsec->ceilingpic == skyflatnum) ?
|
||
R_FindPlane(frontsector->floorplane,
|
||
frontsector->floorpic,
|
||
floorlightlevel + r_actualextralight, // killough 3/16/98
|
||
frontsector->floor_xoffs, // killough 3/7/98
|
||
frontsector->floor_yoffs + frontsector->base_floor_yoffs,
|
||
frontsector->floor_xscale,
|
||
frontsector->floor_yscale,
|
||
frontsector->floor_angle + frontsector->base_floor_angle,
|
||
frontsector->sky,
|
||
frontsector->FloorSkyBox
|
||
) : NULL;*/
|
||
|
||
// killough 9/18/98: Fix underwater slowdown, by passing real sector
|
||
// instead of fake one. Improve sprite lighting by basing sprite
|
||
// lightlevels on floor & ceiling lightlevels in the surrounding area.
|
||
// [RH] Handle sprite lighting like Duke 3D: If the ceiling is a sky, sprites are lit by
|
||
// it, otherwise they are lit by the floor.
|
||
// R_AddSprites (sub->sector, frontsector->ceilingpic == skyflatnum ?
|
||
// ceilinglightlevel : floorlightlevel, FakeSide);
|
||
|
||
// [RH] Add particles
|
||
// int shade = LIGHT2SHADE((floorlightlevel + ceilinglightlevel)/2 + r_actualextralight);
|
||
// for (WORD i = ParticlesInSubsec[sub-subsectors]; i != NO_PARTICLE; i = Particles[i].snext)
|
||
// {
|
||
// R_ProjectParticle (Particles + i, subsectors[sub-subsectors].sector, shade, FakeSide);
|
||
// }
|
||
|
||
if (sub->poly)
|
||
{ // Render the polyobj in the subsector first
|
||
int polyCount = sub->poly->numsegs;
|
||
seg_t **polySeg = sub->poly->segs;
|
||
while (polyCount--)
|
||
{
|
||
RP_AddLine (*polySeg++);
|
||
}
|
||
}
|
||
|
||
while (count--)
|
||
{
|
||
if (!line->bPolySeg)
|
||
{
|
||
RP_AddLine (line);
|
||
}
|
||
line++;
|
||
}
|
||
}
|
||
|
||
extern "C" const int checkcoord[12][4];
|
||
|
||
static bool RP_CheckBBox (fixed_t *bspcoord)
|
||
{
|
||
int boxx;
|
||
int boxy;
|
||
int boxpos;
|
||
|
||
fixed_t x1, y1, x2, y2;
|
||
double x, y, xp0, yp0, xp1, yp1, t, sx0, sx1;
|
||
|
||
// Find the corners of the box
|
||
// that define the edges from current viewpoint.
|
||
if (viewx <= bspcoord[BOXLEFT])
|
||
boxx = 0;
|
||
else if (viewx < bspcoord[BOXRIGHT])
|
||
boxx = 1;
|
||
else
|
||
boxx = 2;
|
||
|
||
if (viewy >= bspcoord[BOXTOP])
|
||
boxy = 0;
|
||
else if (viewy > bspcoord[BOXBOTTOM])
|
||
boxy = 1;
|
||
else
|
||
boxy = 2;
|
||
|
||
boxpos = (boxy<<2)+boxx;
|
||
if (boxpos == 5)
|
||
return true;
|
||
|
||
x1 = bspcoord[checkcoord[boxpos][0]] - viewx;
|
||
y1 = bspcoord[checkcoord[boxpos][1]] - viewy;
|
||
x2 = bspcoord[checkcoord[boxpos][2]] - viewx;
|
||
y2 = bspcoord[checkcoord[boxpos][3]] - viewy;
|
||
|
||
// check clip list for an open space
|
||
|
||
// Sitting on a line?
|
||
if (DMulScale32 (y1, x1-x2, x1, y2-y1) >= 0)
|
||
return true;
|
||
|
||
//Offset&Rotate 3D coordinates to screen 3D space
|
||
x = double(x1); y = double(y1);
|
||
xp0 = x*gsinang - y*gcosang;
|
||
yp0 = x*gcosang2 + y*gsinang2;
|
||
x = double(x2); y = double(y2);
|
||
xp1 = x*gsinang - y*gcosang;
|
||
yp1 = x*gcosang2 + y*gsinang2;
|
||
|
||
//Clip to close parallel-screen plane
|
||
if (yp0 < SCISDIST)
|
||
{
|
||
if (yp1 < SCISDIST) return false;
|
||
t = (SCISDIST-yp0)/(yp1-yp0);
|
||
xp0 = (xp1-xp0)*t+xp0;
|
||
yp0 = SCISDIST;
|
||
}
|
||
if (yp1 < SCISDIST)
|
||
{
|
||
t = (SCISDIST-yp0)/(yp1-yp0);
|
||
xp1 = (xp1-xp0)*t+xp0;
|
||
yp1 = SCISDIST;
|
||
}
|
||
|
||
//Generate screen coordinates for front side of wall
|
||
sx0 = ghalfx*xp0/yp0 + ghalfx;
|
||
sx1 = ghalfx*xp1/yp1 + ghalfx;
|
||
|
||
// Does not cross a pixel.
|
||
if (sx1 <= sx0)
|
||
return false;
|
||
|
||
return Mosts.TestVisibleMost (sx0, sx1);
|
||
}
|
||
|
||
void RP_RenderBSPNode (void *node)
|
||
{
|
||
if (numnodes == 0)
|
||
{
|
||
RP_Subsector (subsectors);
|
||
return;
|
||
}
|
||
while (!((size_t)node & 1)) // Keep going until found a subsector
|
||
{
|
||
node_t *bsp = (node_t *)node;
|
||
|
||
// Decide which side the view point is on.
|
||
int side = R_PointOnSide (viewx, viewy, bsp);
|
||
|
||
// Recursively divide front space (toward the viewer).
|
||
RP_RenderBSPNode (bsp->children[side]);
|
||
|
||
// Possibly divide back space (away from the viewer).
|
||
side ^= 1;
|
||
if (!RP_CheckBBox (bsp->bbox[side]))
|
||
return;
|
||
|
||
node = bsp->children[side];
|
||
}
|
||
RP_Subsector ((subsector_t *)((BYTE *)node - 1));
|
||
}
|
||
|