mirror of
https://github.com/ZDoom/qzdoom-gpl.git
synced 2024-11-17 17:50:57 +00:00
8ca7c05e9d
that animated icons can be done with it. - Changed FImageCollection to use a TArray to hold its data. - Fixed: SetChanHeadSettings did an assignment instead of comparing the channel ID witg CHAN_CEILING. - Changed sound sequence names for animated doors to FNames. - Automatically fixed: DCeiling didn't properly serialize its texture id. - Replaced integers as texture ID representation with a specific new type to track down all potentially incorrect uses and remaining WORDs used for texture IDs so that more than 32767 or 65535 textures can be defined. SVN r1036 (trunk)
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));
|
||
}
|
||
|