mind-shear/greed
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
greed/CODE/R_PLANE.C
archive 9bf82bf4fa as released 2014-12-12
2014-12-12 00:00:00 +00:00

428 lines
13 KiB
C
Raw Permalink Blame History

/***************************************************************************/
/* */
/* */
/* Raven 3D Engine */
/* Copyright (C) 1996 by Softdisk Publishing */
/* */
/* Original Design: */
/* John Carmack of id Software */
/* */
/* Enhancements by: */
/* Robert Morgan of Channel 7............................Main Engine Code */
/* Todd Lewis of Softdisk Publishing......Tools,Utilities,Special Effects */
/* John Bianca of Softdisk Publishing..............Low-level Optimization */
/* Carlos Hasan..........................................Music/Sound Code */
/* */
/* */
/***************************************************************************/
#include <MATH.H>
#include <STRING.H>
#include "d_global.h"
#include "d_disk.h"
#include "r_refdef.h"
/**** VARIABLES ****/
int mr_y, mr_x1, mr_x2; // used by mapplane to calculate texture end
int mr_shadow; // special lighting effect
int mr_light;
fixed_t mr_deltaheight;
int flatpic;
boolean transparent, ceilingbit;
// vertexes for drawable polygon
int numvertex;
int vertexy[5];
int vertexx[5];
int spantype;
// vertexes in need of Z clipping
clippoint_t vertexpt[5];
// coefficients of the plane equation for sloping polygons
fixed_t planeA, planeB, planeC, planeD;
#define COPYFLOOR(s,d) \
vertexpt[d].tx = vertex[s]->tx; \
vertexpt[d].ty = vertex[s]->floorheight; \
vertexpt[d].tz = vertex[s]->tz; \
vertexpt[d].px = vertex[s]->px; \
vertexpt[d].py = vertex[s]->floory;
#define COPYCEILING(s,d) \
vertexpt[d].tx = vertex[s]->tx; \
vertexpt[d].ty = vertex[s]->ceilingheight; \
vertexpt[d].tz = vertex[s]->tz; \
vertexpt[d].px = vertex[s]->px; \
vertexpt[d].py = vertex[s]->ceilingy;
/**** FUNCTIONS ****/
void FlatSpan(void)
/* used for flat floors and ceilings, coordinates must be pre clipped
mr_deltaheight is planeheight - viewheight, with height values increased
mr_picture and mr_deltaheight are set once per polygon */
{
fixed_t pointz; // row's distance to view plane
span_t *span_p;
unsigned span;
pointz=FIXEDDIV(mr_deltaheight,yslope[mr_y+MAXSCROLL]);
if (pointz>MAXZ) return;
// post the span in the draw list
span=(pointz<<ZTOFRAC)&ZMASK;
spansx[numspans]=mr_x1;
span|=numspans;
spantags[numspans]=span;
span_p=&spans[numspans];
span_p->spantype=spantype;
span_p->picture=mr_picture;
span_p->x2=mr_x2;
span_p->y=mr_y;
span_p->shadow=mr_shadow;
span_p->light=mr_light;
numspans++;
#ifdef VALIDATE
if (numspans>=MAXSPANS) MS_Error("MAXSPANS exceeded, FlatSpan (%i>=%i)",numspans,MAXSPANS);
#endif
}
void SlopeSpan(void)
/* used for sloping floors and ceilings
planeA, planeB, planeC, planeD must be precalculated
mr_picture is set once per polygon */
{
fixed_t pointz, pointz2; // row's distance to view plane
fixed_t partial, denom;
span_t *span_p;
unsigned span;
// calculate the Z values for each end of the span
partial=FIXEDMUL(planeB,yslope[mr_y+MAXSCROLL])+planeC;
denom=FIXEDMUL(planeA,xslope[mr_x1])+partial;
if (denom<8000) return;
pointz=FIXEDDIV(planeD,denom);
if (pointz>MAXZ) return;
denom=FIXEDMUL(planeA,xslope[mr_x2])+partial;
if (denom<8000) return;
pointz2=FIXEDDIV(planeD,denom);
if (pointz2>MAXZ) return;
// post the span in the draw list
span=(pointz<<ZTOFRAC)&ZMASK;
spansx[numspans]=mr_x1;
span|=numspans;
spantags[numspans]=span;
span_p=&spans[numspans];
span_p->spantype=spantype;
span_p->picture=mr_picture;
span_p->x2=mr_x2;
span_p->y=mr_y;
span_p->yh=pointz2;
span_p->shadow=mr_shadow;
span_p->light=mr_light;
numspans++;
#ifdef VALIDATE
if (numspans>=MAXSPANS) MS_Error("MAXSPANS exceeded, SlopeSpan (%i>=%i)",numspans,MAXSPANS);
#endif
}
void RenderPolygon(void (*spanfunction)(void))
/* Vertex list must be precliped, convex, and in clockwise order
Backfaces (not in clockwise order) generate no pixels
The polygon is divided into trapezoids (from 1 to numvertex-1 can be
which have a constant slope on both sides
mr_x1 screen coordinates of the span to draw, use by map
mr_x2 plane to calculate textures at the endpoints
mr_y along with mr_deltaheight
mr_dest pointer inside viewbuffer where span starts
mr_count length of span to draw (mr_x2 - mr_x1)
spanfunction is a pointer to a function that will handle determining
in the calculated span (FlatSpan or SlopeSpan) */
{
int stopy;
fixed_t leftfrac, rightfrac;
fixed_t leftstep, rightstep;
int leftvertex, rightvertex;
int deltax, deltay;
int oldx;
// find topmost vertex
rightvertex=0; // topmost so far
for (leftvertex=1; leftvertex<numvertex; leftvertex++)
if (vertexy[leftvertex]<vertexy[rightvertex]) rightvertex=leftvertex;
// ride down the left and right edges
mr_y=vertexy[rightvertex];
leftvertex=rightvertex;
if (mr_y>=scrollmax) return; // totally off bottom
do
{
if (mr_y==vertexy[rightvertex])
{
skiprightvertex:
oldx=vertexx[rightvertex];
if (++rightvertex==numvertex) rightvertex=0;
deltay=vertexy[rightvertex]-mr_y;
if (!deltay)
{
if (leftvertex==rightvertex) return; // the last edge is exactly horizontal
goto skiprightvertex;
}
deltax=vertexx[rightvertex]-oldx;
rightfrac=(oldx<<FRACBITS); // fix roundoff
rightstep=(deltax<<FRACBITS)/deltay;
}
if (mr_y==vertexy[leftvertex])
{
skipleftvertex:
oldx=vertexx[leftvertex];
if (--leftvertex==-1) leftvertex=numvertex-1;
deltay=vertexy[leftvertex]-mr_y;
if (!deltay) goto skipleftvertex;
deltax=vertexx[leftvertex]-oldx;
leftfrac=(oldx<<FRACBITS); // fix roundoff
leftstep=(deltax<<FRACBITS)/deltay;
}
if (vertexy[rightvertex]<vertexy[leftvertex]) stopy=vertexy[rightvertex];
else stopy=vertexy[leftvertex];
// draw a trapezoid
if (stopy<=scrollmin)
{
leftfrac+=leftstep * (stopy-mr_y);
rightfrac+=rightstep * (stopy-mr_y);
mr_y=stopy;
continue;
}
if (mr_y<scrollmin)
{
leftfrac+=leftstep * (scrollmin-mr_y);
rightfrac+=rightstep * (scrollmin-mr_y);
mr_y=scrollmin;
}
if (stopy>scrollmax) stopy=scrollmax;
for (; mr_y<stopy; mr_y++)
{
mr_x1=leftfrac>>FRACBITS;
mr_x2=rightfrac>>FRACBITS;
if (mr_x1<xclipl) mr_x1=xclipl;
if (mr_x2>xcliph) mr_x2=xcliph;
if (mr_x1<xcliph && mr_x2>mr_x1) spanfunction(); // different functions for flat and slope
leftfrac+=leftstep;
rightfrac+=rightstep;
}
} while (rightvertex!=leftvertex && mr_y!=scrollmax);
}
void CalcPlaneEquation(void)
/* Calculates planeA, planeB, planeC, planeD
planeD is actually -planeD
for vertexpt[0-2] */
{
fixed_t x1, y1, z1;
fixed_t x2, y2, z2;
// calculate two vectors going away from the middle vertex
x1=vertexpt[0].tx-vertexpt[1].tx;
y1=vertexpt[0].ty-vertexpt[1].ty;
z1=vertexpt[0].tz-vertexpt[1].tz;
x2=vertexpt[2].tx-vertexpt[1].tx;
y2=vertexpt[2].ty-vertexpt[1].ty;
z2=vertexpt[2].tz-vertexpt[1].tz;
// the A, B, C coefficients are the cross product of v1 and v2
// shift over to save some precision bits
planeA=(FIXEDMUL(y1, z2)-FIXEDMUL(z1, y2))>>8;
planeB=(FIXEDMUL(z1, x2)-FIXEDMUL(x1, z2))>>8;
planeC=(FIXEDMUL(x1, y2)-FIXEDMUL(y1, x2))>>8;
// calculate D based on A,B,C and one of the vertex points
planeD=FIXEDMUL(planeA,vertexpt[0].tx) + FIXEDMUL(planeB,vertexpt[0].ty) +
FIXEDMUL(planeC,vertexpt[0].tz);
}
boolean ZClipPolygon(int numvertexpts, fixed_t minz)
{
int v;
fixed_t scale;
fixed_t frac, cliptx, clipty;
clippoint_t *p1, *p2;
numvertex=0;
if (minz<MINZ) minz=MINZ; // less than this will cause problems
p1=&vertexpt[0];
for (v=1; v<=numvertexpts; v++)
{
p2=p1; // p2 is old point
if (v!=numvertexpts) p1=&vertexpt[v]; // p1 is new point
else p1=&vertexpt[0];
if ((p1->tz<minz) ^ (p2->tz<minz))
{
scale=FIXEDDIV(SCALE,minz);
frac=FIXEDDIV((p1->tz-minz),(p1->tz-p2->tz));
cliptx=p1->tx+FIXEDMUL((p2->tx-p1->tx),frac);
clipty=p1->ty+FIXEDMUL((p2->ty-p1->ty),frac);
vertexx[numvertex]=CENTERX+(FIXEDMUL(cliptx,scale)>>FRACBITS);
vertexy[numvertex]=CENTERY-(FIXEDMUL(clipty,scale)>>FRACBITS);
if (ceilingbit && vertexy[numvertex]>640) return false;
numvertex++;
}
if (p1->tz>=minz)
{
vertexx[numvertex]=p1->px;
vertexy[numvertex]=p1->py;
if (ceilingbit && vertexy[numvertex]>640) return false;
numvertex++;
}
}
if (!numvertex) return false;
return true;
}
void RenderTileEnds(void)
/* draw floor and ceiling for tile */
{
int flags, polytype;
xcliph++;
flags=mapflags[mapspot];
// draw the floor
flatpic=floorpic[mapspot];
mr_shadow=mapeffects[mapspot];
if (mr_shadow==1) mr_shadow=(int)(colormaps+(wallglow<<8));
else if (mr_shadow==2) mr_shadow=(int)(colormaps+(wallflicker1<<8));
else if (mr_shadow==3) mr_shadow=(int)(colormaps+(wallflicker2<<8));
else if (mr_shadow==4) mr_shadow=(int)(colormaps+(wallflicker3<<8));
else if (mr_shadow>=5 && mr_shadow<=8)
{
if (wallcycle==mr_shadow-5) mr_shadow=(int)colormaps;
else mr_shadow=0;
}
mr_light=maplight;
flatpic=flattranslation[flatpic];
mr_picture=lumpmain[flatlump+flatpic];
polytype=(flags&FL_FLOOR)>>FLS_FLOOR;
ceilingbit=false;
switch (polytype)
{
case POLY_FLAT:
spantype=sp_flat;
mr_deltaheight=vertex[0]->floorheight;
if (mr_deltaheight<0)
{
COPYFLOOR(0, 0);
COPYFLOOR(1, 1);
COPYFLOOR(2, 2);
COPYFLOOR(3, 3);
if (ZClipPolygon(4, -mr_deltaheight)) RenderPolygon(FlatSpan);
}
break;
case POLY_SLOPE:
spantype=sp_slope;
COPYFLOOR(0, 0);
COPYFLOOR(1, 1);
COPYFLOOR(2, 2);
COPYFLOOR(3, 3);
CalcPlaneEquation();
if (ZClipPolygon(4,(fixed_t)MINZ)) RenderPolygon(SlopeSpan);
break;
case POLY_ULTOLR:
spantype=sp_slope;
COPYFLOOR(0, 0);
COPYFLOOR(1, 1);
COPYFLOOR(2, 2);
CalcPlaneEquation();
if (ZClipPolygon(3,(fixed_t)MINZ)) RenderPolygon(SlopeSpan);
COPYFLOOR(2, 0);
COPYFLOOR(3, 1);
COPYFLOOR(0, 2);
CalcPlaneEquation();
if (ZClipPolygon(3,(fixed_t)MINZ)) RenderPolygon(SlopeSpan);
break;
case POLY_URTOLL:
spantype=sp_slope;
COPYFLOOR(0, 0);
COPYFLOOR(1, 1);
COPYFLOOR(3, 2);
CalcPlaneEquation();
if (ZClipPolygon(3,(fixed_t)MINZ)) RenderPolygon(SlopeSpan);
COPYFLOOR(1, 0);
COPYFLOOR(2, 1);
COPYFLOOR(3, 2);
CalcPlaneEquation();
if (ZClipPolygon(3,(fixed_t)MINZ)) RenderPolygon(SlopeSpan);
break;
}
// draw the ceiling
ceilingbit=true;
flatpic=ceilingpic[mapspot];
if (ceilingflags[mapspot] & F_TRANSPARENT) transparent=true;
else transparent=false;
flatpic=flattranslation[flatpic];
mr_picture=lumpmain[flatlump+flatpic];
polytype=(flags&FL_CEILING)>>FLS_CEILING;
switch (polytype)
{
case POLY_FLAT:
if (flatpic==63) spantype=sp_sky;
else if (transparent) spantype=sp_flatsky;
else spantype=sp_flat;
mr_deltaheight=vertex[0]->ceilingheight;
if (mr_deltaheight>0)
{
COPYCEILING(3, 0);
COPYCEILING(2, 1);
COPYCEILING(1, 2);
COPYCEILING(0, 3);
if (ZClipPolygon(4, mr_deltaheight)) RenderPolygon(FlatSpan);
}
break;
case POLY_SLOPE:
if (flatpic==63) spantype=sp_sky;
else if (transparent) spantype=sp_slopesky;
else spantype=sp_slope;
COPYCEILING(3, 0);
COPYCEILING(2, 1);
COPYCEILING(1, 2);
COPYCEILING(0, 3);
CalcPlaneEquation();
if (ZClipPolygon(4, MINZ)) RenderPolygon(SlopeSpan);
break;
case POLY_ULTOLR:
if (flatpic==63) spantype=sp_sky;
else if (transparent) spantype=sp_slopesky;
else spantype=sp_slope;
COPYCEILING(3, 0);
COPYCEILING(2, 1);
COPYCEILING(1, 2);
CalcPlaneEquation();
if (ZClipPolygon(3, MINZ)) RenderPolygon(SlopeSpan);
COPYCEILING(3, 0);
COPYCEILING(1, 1);
COPYCEILING(0, 2);
CalcPlaneEquation();
if (ZClipPolygon(3, MINZ)) RenderPolygon(SlopeSpan);
break;
case POLY_URTOLL:
if (flatpic==63) spantype=sp_sky;
else if (transparent) spantype=sp_slopesky;
else spantype=sp_slope;
COPYCEILING(3, 0);
COPYCEILING(2, 1);
COPYCEILING(0, 2);
CalcPlaneEquation();
if (ZClipPolygon(3, MINZ)) RenderPolygon(SlopeSpan);
COPYCEILING(2, 0);
COPYCEILING(1, 1);
COPYCEILING(0, 2);
CalcPlaneEquation();
if (ZClipPolygon(3, MINZ)) RenderPolygon(SlopeSpan);
break;
}
}
Reference in a new issue View git blame Copy permalink