You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1267 lines
27 KiB
1267 lines
27 KiB
/* |
|
Copyright (C) 1997-2001 Id Software, Inc. |
|
|
|
This program is free software; you can redistribute it and/or |
|
modify it under the terms of the GNU General Public License |
|
as published by the Free Software Foundation; either version 2 |
|
of the License, or (at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
|
|
See the GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software |
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
|
|
|
*/ |
|
// r_edge.c |
|
|
|
#include "r_local.h" |
|
|
|
#ifndef id386 |
|
void R_SurfacePatch (void) |
|
{ |
|
} |
|
#endif |
|
|
|
|
|
#if 0 |
|
the complex cases add new polys on most lines, so dont optimize for keeping them the same |
|
have multiple free span lists to try to get better coherence? |
|
low depth complexity -- 1 to 3 or so |
|
|
|
have a sentinal at both ends? |
|
#endif |
|
|
|
|
|
edge_t *auxedges; |
|
edge_t *r_edges, *edge_p, *edge_max; |
|
|
|
surf_t *surfaces, *surface_p, *surf_max; |
|
|
|
// surfaces are generated in back to front order by the bsp, so if a surf |
|
// pointer is greater than another one, it should be drawn in front |
|
// surfaces[1] is the background, and is used as the active surface stack |
|
|
|
edge_t *newedges[MAXHEIGHT]; |
|
edge_t *removeedges[MAXHEIGHT]; |
|
|
|
espan_t *span_p, *max_span_p; |
|
|
|
int r_currentkey; |
|
|
|
int current_iv; |
|
|
|
int edge_head_u_shift20, edge_tail_u_shift20; |
|
|
|
static void (*pdrawfunc)(void); |
|
|
|
edge_t edge_head; |
|
edge_t edge_tail; |
|
|
|
edge_t edge_aftertail; |
|
edge_t edge_sentinel; |
|
|
|
static float fv; |
|
|
|
static int miplevel; |
|
|
|
float scale_for_mip; |
|
|
|
// FIXME: should go away |
|
extern void R_RotateBmodel (void); |
|
extern void R_TransformFrustum (void); |
|
|
|
|
|
|
|
void R_GenerateSpans (void); |
|
void R_GenerateSpansBackward (void); |
|
|
|
void R_LeadingEdge (edge_t *edge); |
|
void R_LeadingEdgeBackwards (edge_t *edge); |
|
void R_TrailingEdge (surf_t *surf, edge_t *edge); |
|
|
|
|
|
/* |
|
=============================================================================== |
|
|
|
EDGE SCANNING |
|
|
|
=============================================================================== |
|
*/ |
|
|
|
/* |
|
============== |
|
R_BeginEdgeFrame |
|
============== |
|
*/ |
|
void R_BeginEdgeFrame (void) |
|
{ |
|
int v; |
|
|
|
edge_p = r_edges; |
|
edge_max = &r_edges[r_numallocatededges]; |
|
|
|
surface_p = &surfaces[2]; // background is surface 1, |
|
// surface 0 is a dummy |
|
surfaces[1].spans = NULL; // no background spans yet |
|
surfaces[1].flags = 0; // SURF_DRAWBACKGROUND; |
|
|
|
// put the background behind everything in the world |
|
if (sw_draworder.value) |
|
{ |
|
pdrawfunc = R_GenerateSpansBackward; |
|
surfaces[1].key = 0; |
|
r_currentkey = 1; |
|
} |
|
else |
|
{ |
|
pdrawfunc = R_GenerateSpans; |
|
surfaces[1].key = 0x7FFfFFFF; |
|
r_currentkey = 0; |
|
} |
|
|
|
// FIXME: set with memset |
|
for (v=RI.vrect.y ; v<RI.vrectbottom ; v++) |
|
{ |
|
newedges[v] = removeedges[v] = NULL; |
|
} |
|
} |
|
|
|
|
|
#if !id386 |
|
|
|
/* |
|
============== |
|
R_InsertNewEdges |
|
|
|
Adds the edges in the linked list edgestoadd, adding them to the edges in the |
|
linked list edgelist. edgestoadd is assumed to be sorted on u, and non-empty (this is actually newedges[v]). edgelist is assumed to be sorted on u, with a |
|
sentinel at the end (actually, this is the active edge table starting at |
|
edge_head.next). |
|
============== |
|
*/ |
|
static void R_InsertNewEdges (edge_t *edgestoadd, edge_t *edgelist) |
|
{ |
|
edge_t *next_edge; |
|
|
|
do |
|
{ |
|
next_edge = edgestoadd->next; |
|
edgesearch: |
|
if( !edgelist ) |
|
{ |
|
// gEngfuncs.Con_Printf("NULL edgelist!\n"); |
|
//return; |
|
} |
|
if (edgelist->u >= edgestoadd->u) |
|
goto addedge; |
|
edgelist=edgelist->next; |
|
#if 1 |
|
if (edgelist->u >= edgestoadd->u) |
|
goto addedge; |
|
edgelist=edgelist->next; |
|
if (edgelist->u >= edgestoadd->u) |
|
goto addedge; |
|
edgelist=edgelist->next; |
|
if (edgelist->u >= edgestoadd->u) |
|
goto addedge; |
|
edgelist=edgelist->next; |
|
#endif |
|
goto edgesearch; |
|
|
|
// insert edgestoadd before edgelist |
|
addedge: |
|
edgestoadd->next = edgelist; |
|
edgestoadd->prev = edgelist->prev; |
|
edgelist->prev->next = edgestoadd; |
|
edgelist->prev = edgestoadd; |
|
} while ((edgestoadd = next_edge) != NULL); |
|
} |
|
|
|
#endif // !id386 |
|
|
|
|
|
#if !id386 |
|
|
|
/* |
|
============== |
|
R_RemoveEdges |
|
============== |
|
*/ |
|
static void R_RemoveEdges (edge_t *pedge) |
|
{ |
|
|
|
do |
|
{ |
|
pedge->next->prev = pedge->prev; |
|
pedge->prev->next = pedge->next; |
|
} while ((pedge = pedge->nextremove) != NULL); |
|
} |
|
|
|
#endif // !id386 |
|
|
|
|
|
#if !id386 |
|
|
|
/* |
|
============== |
|
R_StepActiveU |
|
============== |
|
*/ |
|
static void R_StepActiveU (edge_t *pedge) |
|
{ |
|
edge_t *pnext_edge, *pwedge; |
|
|
|
while (1) |
|
{ |
|
nextedge: |
|
pedge->u += pedge->u_step; |
|
if (pedge->u < pedge->prev->u) |
|
goto pushback; |
|
pedge = pedge->next; |
|
|
|
pedge->u += pedge->u_step; |
|
if (pedge->u < pedge->prev->u) |
|
goto pushback; |
|
pedge = pedge->next; |
|
|
|
pedge->u += pedge->u_step; |
|
if (pedge->u < pedge->prev->u) |
|
goto pushback; |
|
pedge = pedge->next; |
|
|
|
pedge->u += pedge->u_step; |
|
if (pedge->u < pedge->prev->u) |
|
goto pushback; |
|
pedge = pedge->next; |
|
|
|
goto nextedge; |
|
|
|
pushback: |
|
if (pedge == &edge_aftertail) |
|
return; |
|
|
|
// push it back to keep it sorted |
|
pnext_edge = pedge->next; |
|
|
|
// pull the edge out of the edge list |
|
pedge->next->prev = pedge->prev; |
|
pedge->prev->next = pedge->next; |
|
|
|
// find out where the edge goes in the edge list |
|
pwedge = pedge->prev->prev; |
|
// if( !pwedge ) |
|
// return; |
|
|
|
while (pwedge->u > pedge->u) |
|
{ |
|
pwedge = pwedge->prev; |
|
//if( !pwedge ) |
|
//return; |
|
} |
|
|
|
// put the edge back into the edge list |
|
pedge->next = pwedge->next; |
|
pedge->prev = pwedge; |
|
pedge->next->prev = pedge; |
|
pwedge->next = pedge; |
|
|
|
pedge = pnext_edge; |
|
if (pedge == &edge_tail) |
|
return; |
|
} |
|
} |
|
|
|
#endif // !id386 |
|
|
|
|
|
/* |
|
============== |
|
R_CleanupSpan |
|
============== |
|
*/ |
|
static void R_CleanupSpan (void) |
|
{ |
|
surf_t *surf; |
|
int iu; |
|
espan_t *span; |
|
|
|
// now that we've reached the right edge of the screen, we're done with any |
|
// unfinished surfaces, so emit a span for whatever's on top |
|
surf = surfaces[1].next; |
|
iu = edge_tail_u_shift20; |
|
if (iu > surf->last_u) |
|
{ |
|
span = span_p++; |
|
span->u = surf->last_u; |
|
span->count = iu - span->u; |
|
span->v = current_iv; |
|
span->pnext = surf->spans; |
|
surf->spans = span; |
|
} |
|
|
|
// reset spanstate for all surfaces in the surface stack |
|
do |
|
{ |
|
surf->spanstate = 0; |
|
surf = surf->next; |
|
} while (surf != &surfaces[1]); |
|
} |
|
|
|
|
|
/* |
|
============== |
|
R_LeadingEdgeBackwards |
|
============== |
|
*/ |
|
void R_LeadingEdgeBackwards (edge_t *edge) |
|
{ |
|
espan_t *span; |
|
surf_t *surf, *surf2; |
|
int iu; |
|
|
|
// it's adding a new surface in, so find the correct place |
|
surf = &surfaces[edge->surfs[1]]; |
|
|
|
// don't start a span if this is an inverted span, with the end |
|
// edge preceding the start edge (that is, we've already seen the |
|
// end edge) |
|
if (++surf->spanstate == 1) |
|
{ |
|
surf2 = surfaces[1].next; |
|
|
|
if (surf->key > surf2->key) |
|
goto newtop; |
|
|
|
// if it's two surfaces on the same plane, the one that's already |
|
// active is in front, so keep going unless it's a bmodel |
|
if (surf->insubmodel && (surf->key == surf2->key)) |
|
{ |
|
// must be two bmodels in the same leaf; don't care, because they'll |
|
// never be farthest anyway |
|
goto newtop; |
|
} |
|
|
|
continue_search: |
|
|
|
do |
|
{ |
|
surf2 = surf2->next; |
|
} while (surf->key < surf2->key); |
|
|
|
if (surf->key == surf2->key) |
|
{ |
|
// if it's two surfaces on the same plane, the one that's already |
|
// active is in front, so keep going unless it's a bmodel |
|
if (!surf->insubmodel) |
|
goto continue_search; |
|
|
|
// must be two bmodels in the same leaf; don't care which is really |
|
// in front, because they'll never be farthest anyway |
|
} |
|
|
|
goto gotposition; |
|
|
|
newtop: |
|
// emit a span (obscures current top) |
|
iu = edge->u >> 20; |
|
|
|
if (iu > surf2->last_u) |
|
{ |
|
span = span_p++; |
|
span->u = surf2->last_u; |
|
span->count = iu - span->u; |
|
span->v = current_iv; |
|
span->pnext = surf2->spans; |
|
surf2->spans = span; |
|
} |
|
|
|
// set last_u on the new span |
|
surf->last_u = iu; |
|
|
|
gotposition: |
|
// insert before surf2 |
|
surf->next = surf2; |
|
surf->prev = surf2->prev; |
|
surf2->prev->next = surf; |
|
surf2->prev = surf; |
|
} |
|
} |
|
|
|
|
|
/* |
|
============== |
|
R_TrailingEdge |
|
============== |
|
*/ |
|
void R_TrailingEdge (surf_t *surf, edge_t *edge) |
|
{ |
|
espan_t *span; |
|
int iu; |
|
|
|
// don't generate a span if this is an inverted span, with the end |
|
// edge preceding the start edge (that is, we haven't seen the |
|
// start edge yet) |
|
if (--surf->spanstate == 0) |
|
{ |
|
if (surf == surfaces[1].next) |
|
{ |
|
// emit a span (current top going away) |
|
iu = edge->u >> 20; |
|
if (iu > surf->last_u) |
|
{ |
|
span = span_p++; |
|
span->u = surf->last_u; |
|
span->count = iu - span->u; |
|
span->v = current_iv; |
|
span->pnext = surf->spans; |
|
surf->spans = span; |
|
} |
|
|
|
// set last_u on the surface below |
|
surf->next->last_u = iu; |
|
} |
|
|
|
surf->prev->next = surf->next; |
|
surf->next->prev = surf->prev; |
|
} |
|
} |
|
|
|
|
|
#if !id386 |
|
|
|
/* |
|
============== |
|
R_LeadingEdge |
|
============== |
|
*/ |
|
void R_LeadingEdge (edge_t *edge) |
|
{ |
|
espan_t *span; |
|
surf_t *surf, *surf2; |
|
int iu; |
|
float fu, newzi, testzi, newzitop, newzibottom; |
|
|
|
if (edge->surfs[1]) |
|
{ |
|
// it's adding a new surface in, so find the correct place |
|
surf = &surfaces[edge->surfs[1]]; |
|
|
|
// don't start a span if this is an inverted span, with the end |
|
// edge preceding the start edge (that is, we've already seen the |
|
// end edge) |
|
if (++surf->spanstate == 1) |
|
{ |
|
surf2 = surfaces[1].next; |
|
|
|
if (surf->key < surf2->key) |
|
goto newtop; |
|
|
|
// if it's two surfaces on the same plane, the one that's already |
|
// active is in front, so keep going unless it's a bmodel |
|
if (surf->insubmodel && (surf->key == surf2->key)) |
|
{ |
|
// must be two bmodels in the same leaf; sort on 1/z |
|
fu = (float)(edge->u - 0xFFFFF) * (1.0f / 0x100000); |
|
newzi = surf->d_ziorigin + fv*surf->d_zistepv + |
|
fu*surf->d_zistepu; |
|
newzibottom = newzi * 0.99f; |
|
|
|
testzi = surf2->d_ziorigin + fv*surf2->d_zistepv + |
|
fu*surf2->d_zistepu; |
|
|
|
if (newzibottom >= testzi) |
|
{ |
|
goto newtop; |
|
} |
|
|
|
newzitop = newzi * 1.01f; |
|
if (newzitop >= testzi) |
|
{ |
|
if (surf->d_zistepu >= surf2->d_zistepu) |
|
{ |
|
goto newtop; |
|
} |
|
} |
|
} |
|
|
|
continue_search: |
|
|
|
do |
|
{ |
|
surf2 = surf2->next; |
|
} while (surf->key > surf2->key); |
|
|
|
if (surf->key == surf2->key) |
|
{ |
|
// if it's two surfaces on the same plane, the one that's already |
|
// active is in front, so keep going unless it's a bmodel |
|
if (!surf->insubmodel) |
|
goto continue_search; |
|
|
|
// must be two bmodels in the same leaf; sort on 1/z |
|
fu = (float)(edge->u - 0xFFFFF) * (1.0f / 0x100000); |
|
newzi = surf->d_ziorigin + fv*surf->d_zistepv + |
|
fu*surf->d_zistepu; |
|
newzibottom = newzi * 0.99f; |
|
|
|
testzi = surf2->d_ziorigin + fv*surf2->d_zistepv + |
|
fu*surf2->d_zistepu; |
|
|
|
if (newzibottom >= testzi) |
|
{ |
|
goto gotposition; |
|
} |
|
|
|
newzitop = newzi * 1.01f; |
|
if (newzitop >= testzi) |
|
{ |
|
if (surf->d_zistepu >= surf2->d_zistepu) |
|
{ |
|
goto gotposition; |
|
} |
|
} |
|
|
|
goto continue_search; |
|
} |
|
|
|
goto gotposition; |
|
|
|
newtop: |
|
// emit a span (obscures current top) |
|
iu = edge->u >> 20; |
|
|
|
if (iu > surf2->last_u) |
|
{ |
|
span = span_p++; |
|
span->u = surf2->last_u; |
|
span->count = iu - span->u; |
|
span->v = current_iv; |
|
span->pnext = surf2->spans; |
|
surf2->spans = span; |
|
} |
|
|
|
// set last_u on the new span |
|
surf->last_u = iu; |
|
|
|
gotposition: |
|
// insert before surf2 |
|
surf->next = surf2; |
|
surf->prev = surf2->prev; |
|
surf2->prev->next = surf; |
|
surf2->prev = surf; |
|
} |
|
} |
|
} |
|
|
|
|
|
/* |
|
============== |
|
R_GenerateSpans |
|
============== |
|
*/ |
|
void R_GenerateSpans (void) |
|
{ |
|
edge_t *edge; |
|
surf_t *surf; |
|
|
|
// clear active surfaces to just the background surface |
|
surfaces[1].next = surfaces[1].prev = &surfaces[1]; |
|
surfaces[1].last_u = edge_head_u_shift20; |
|
|
|
// generate spans |
|
for (edge=edge_head.next ; edge != &edge_tail; edge=edge->next) |
|
{ |
|
if (edge->surfs[0]) |
|
{ |
|
// it has a left surface, so a surface is going away for this span |
|
surf = &surfaces[edge->surfs[0]]; |
|
|
|
R_TrailingEdge (surf, edge); |
|
|
|
if (!edge->surfs[1]) |
|
continue; |
|
} |
|
|
|
R_LeadingEdge (edge); |
|
} |
|
|
|
R_CleanupSpan (); |
|
} |
|
|
|
#endif // !id386 |
|
|
|
|
|
/* |
|
============== |
|
R_GenerateSpansBackward |
|
============== |
|
*/ |
|
void R_GenerateSpansBackward (void) |
|
{ |
|
edge_t *edge; |
|
|
|
// clear active surfaces to just the background surface |
|
surfaces[1].next = surfaces[1].prev = &surfaces[1]; |
|
surfaces[1].last_u = edge_head_u_shift20; |
|
|
|
// generate spans |
|
for (edge=edge_head.next ; edge != &edge_tail; edge=edge->next) |
|
{ |
|
if (edge->surfs[0]) |
|
R_TrailingEdge (&surfaces[edge->surfs[0]], edge); |
|
|
|
if (edge->surfs[1]) |
|
R_LeadingEdgeBackwards (edge); |
|
} |
|
|
|
R_CleanupSpan (); |
|
} |
|
|
|
|
|
/* |
|
============== |
|
R_ScanEdges |
|
|
|
Input: |
|
newedges[] array |
|
this has links to edges, which have links to surfaces |
|
|
|
Output: |
|
Each surface has a linked list of its visible spans |
|
============== |
|
*/ |
|
void R_ScanEdges (void) |
|
{ |
|
int iv, bottom; |
|
byte basespans[MAXSPANS*sizeof(espan_t)+CACHE_SIZE]; |
|
espan_t *basespan_p; |
|
surf_t *s; |
|
|
|
basespan_p = (espan_t *) |
|
((uintptr_t)(basespans + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1)); |
|
max_span_p = &basespan_p[MAXSPANS - RI.vrect.width]; |
|
|
|
span_p = basespan_p; |
|
|
|
// clear active edges to just the background edges around the whole screen |
|
// FIXME: most of this only needs to be set up once |
|
edge_head.u = RI.vrect.x << 20; |
|
edge_head_u_shift20 = edge_head.u >> 20; |
|
edge_head.u_step = 0; |
|
edge_head.prev = NULL; |
|
edge_head.next = &edge_tail; |
|
edge_head.surfs[0] = 0; |
|
edge_head.surfs[1] = 1; |
|
|
|
edge_tail.u =(RI.vrectright << 20) + 0xFFFFF; // (r_refdef.vrectright << 20) + 0xFFFFF; |
|
edge_tail_u_shift20 = edge_tail.u >> 20; |
|
edge_tail.u_step = 0; |
|
edge_tail.prev = &edge_head; |
|
edge_tail.next = &edge_aftertail; |
|
edge_tail.surfs[0] = 1; |
|
edge_tail.surfs[1] = 0; |
|
|
|
edge_aftertail.u = -1; // force a move |
|
edge_aftertail.u_step = 0; |
|
edge_aftertail.next = &edge_sentinel; |
|
edge_aftertail.prev = &edge_tail; |
|
|
|
// FIXME: do we need this now that we clamp x in r_draw.c? |
|
edge_sentinel.u = 2000 << 20; // make sure nothing sorts past this |
|
edge_sentinel.prev = &edge_aftertail; |
|
|
|
// |
|
// process all scan lines |
|
// |
|
bottom = RI.vrectbottom - 1; |
|
|
|
for (iv=0 ; iv<bottom ; iv++) |
|
{ |
|
current_iv = iv; |
|
fv = (float)iv; |
|
|
|
// mark that the head (background start) span is pre-included |
|
surfaces[1].spanstate = 1; |
|
|
|
if (newedges[iv]) |
|
{ |
|
R_InsertNewEdges (newedges[iv], edge_head.next); |
|
} |
|
#if 1 |
|
(*pdrawfunc) (); |
|
|
|
// flush the span list if we can't be sure we have enough spans left for |
|
// the next scan |
|
if (span_p > max_span_p) |
|
{ |
|
D_DrawSurfaces (); |
|
|
|
// clear the surface span pointers |
|
for (s = &surfaces[1] ; s<surface_p ; s++) |
|
s->spans = NULL; |
|
|
|
span_p = basespan_p; |
|
} |
|
#endif |
|
if (removeedges[iv]) |
|
R_RemoveEdges (removeedges[iv]); |
|
|
|
if (edge_head.next != &edge_tail) |
|
R_StepActiveU (edge_head.next); |
|
} |
|
|
|
// do the last scan (no need to step or sort or remove on the last scan) |
|
|
|
current_iv = iv; |
|
fv = (float)iv; |
|
|
|
// mark that the head (background start) span is pre-included |
|
surfaces[1].spanstate = 1; |
|
|
|
if (newedges[iv]) |
|
R_InsertNewEdges (newedges[iv], edge_head.next); |
|
|
|
(*pdrawfunc) (); |
|
|
|
// draw whatever's left in the span list |
|
D_DrawSurfaces (); |
|
} |
|
|
|
|
|
/* |
|
========================================================================= |
|
|
|
SURFACE FILLING |
|
|
|
========================================================================= |
|
*/ |
|
|
|
msurface_t *pface; |
|
surfcache_t *pcurrentcache; |
|
vec3_t transformed_modelorg; |
|
vec3_t world_transformed_modelorg; |
|
vec3_t local_modelorg; |
|
|
|
/* |
|
============= |
|
D_MipLevelForScale |
|
============= |
|
*/ |
|
static int D_MipLevelForScale (float scale) |
|
{ |
|
int lmiplevel; |
|
|
|
if (scale >= d_scalemip[0] ) |
|
lmiplevel = 0; |
|
else if (scale >= d_scalemip[1] ) |
|
lmiplevel = 1; |
|
else if (scale >= d_scalemip[2] ) |
|
lmiplevel = 2; |
|
else |
|
lmiplevel = 3; |
|
|
|
if (lmiplevel < d_minmip) |
|
lmiplevel = d_minmip; |
|
|
|
return lmiplevel; |
|
} |
|
|
|
|
|
/* |
|
============== |
|
D_FlatFillSurface |
|
|
|
Simple single color fill with no texture mapping |
|
============== |
|
*/ |
|
static void D_FlatFillSurface (surf_t *surf, int color) |
|
{ |
|
espan_t *span; |
|
pixel_t *pdest; |
|
int u, u2; |
|
|
|
for (span=surf->spans ; span ; span=span->pnext) |
|
{ |
|
pdest = d_viewbuffer + r_screenwidth*span->v; |
|
u = span->u; |
|
u2 = span->u + span->count - 1; |
|
for ( ; u <= u2 ; u++) |
|
pdest[u] = color; |
|
} |
|
} |
|
|
|
|
|
/* |
|
============== |
|
D_CalcGradients |
|
============== |
|
*/ |
|
static void D_CalcGradients (msurface_t *pface) |
|
{ |
|
mplane_t *pplane; |
|
float mipscale; |
|
vec3_t p_temp1; |
|
vec3_t p_saxis, p_taxis; |
|
float t; |
|
|
|
pplane = pface->plane; |
|
|
|
mipscale = 1.0f / (float)(1 << miplevel); |
|
|
|
|
|
if( pface->texinfo->flags & TEX_WORLD_LUXELS ) |
|
{ |
|
TransformVector (pface->texinfo->vecs[0], p_saxis); |
|
TransformVector (pface->texinfo->vecs[1], p_taxis); |
|
} |
|
else |
|
{ |
|
TransformVector (pface->info->lmvecs[0], p_saxis); |
|
TransformVector (pface->info->lmvecs[1], p_taxis); |
|
} |
|
|
|
t = xscaleinv * mipscale; |
|
d_sdivzstepu = p_saxis[0] * t; |
|
d_tdivzstepu = p_taxis[0] * t; |
|
|
|
t = yscaleinv * mipscale; |
|
d_sdivzstepv = -p_saxis[1] * t; |
|
d_tdivzstepv = -p_taxis[1] * t; |
|
|
|
d_sdivzorigin = p_saxis[2] * mipscale - xcenter * d_sdivzstepu - |
|
ycenter * d_sdivzstepv; |
|
d_tdivzorigin = p_taxis[2] * mipscale - xcenter * d_tdivzstepu - |
|
ycenter * d_tdivzstepv; |
|
|
|
VectorScale (transformed_modelorg, mipscale, p_temp1); |
|
|
|
t = 0x10000*mipscale; |
|
if( pface->texinfo->flags & TEX_WORLD_LUXELS ) |
|
{ |
|
sadjust = ((fixed16_t)(DotProduct (p_temp1, p_saxis) * 0x10000 + 0.5f)) - |
|
((pface->texturemins[0] << 16) >> miplevel) |
|
+ pface->texinfo->vecs[0][3]*t; |
|
tadjust = ((fixed16_t)(DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5f)) - |
|
((pface->texturemins[1] << 16) >> miplevel) |
|
+ pface->texinfo->vecs[1][3]*t; |
|
} |
|
else |
|
{ |
|
sadjust = ((fixed16_t)(DotProduct (p_temp1, p_saxis) * 0x10000 + 0.5f)) - |
|
((pface->info->lightmapmins[0] << 16) >> miplevel) |
|
+ pface->info->lmvecs[0][3]*t; |
|
tadjust = ((fixed16_t)(DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5f)) - |
|
((pface->info->lightmapmins[1] << 16) >> miplevel) |
|
+ pface->info->lmvecs[1][3]*t; |
|
} |
|
// PGM - changing flow speed for non-warping textures. |
|
if (pface->flags & SURF_CONVEYOR) |
|
{ |
|
|
|
if(pface->flags & SURF_DRAWTURB) |
|
sadjust += 0x10000 * (-128 * ( (gp_cl->time * 0.25f) - (int)(gp_cl->time * 0.25f) )); |
|
else |
|
sadjust += 0x10000 * (-128 * ( (gp_cl->time * 0.77f) - (int)(gp_cl->time * 0.77f) )); |
|
bbextents = ((pface->extents[0] << 16) >> miplevel) - 1; |
|
} |
|
else |
|
bbextents = ((pface->info->lightextents[0] << 16) >> miplevel) - 1; |
|
bbextentt = ((pface->info->lightextents[1] << 16) >> miplevel) - 1; |
|
|
|
if( pface->texinfo->flags & TEX_WORLD_LUXELS ) |
|
{ |
|
bbextents = ((pface->extents[0] << 16) >> miplevel) - 1; |
|
bbextentt = ((pface->extents[1] << 16) >> miplevel) - 1; |
|
} |
|
} |
|
|
|
|
|
/* |
|
============== |
|
D_BackgroundSurf |
|
|
|
The grey background filler seen when there is a hole in the map |
|
============== |
|
*/ |
|
static void D_BackgroundSurf (surf_t *s) |
|
{ |
|
// set up a gradient for the background surface that places it |
|
// effectively at infinity distance from the viewpoint |
|
d_zistepu = 0; |
|
d_zistepv = 0; |
|
d_ziorigin = -0.9; |
|
|
|
D_FlatFillSurface (s, (int)sw_clearcolor.value & 0xFFFF); |
|
D_DrawZSpans (s->spans); |
|
} |
|
|
|
/* |
|
================= |
|
D_TurbulentSurf |
|
================= |
|
*/ |
|
static void D_TurbulentSurf (surf_t *s) |
|
{ |
|
d_zistepu = s->d_zistepu; |
|
d_zistepv = s->d_zistepv; |
|
d_ziorigin = s->d_ziorigin; |
|
|
|
pface = s->msurf; |
|
miplevel = 0; |
|
cacheblock = R_GetTexture(pface->texinfo->texture->gl_texturenum)->pixels[0]; |
|
cachewidth = 64; |
|
|
|
if (s->insubmodel) |
|
{ |
|
// FIXME: we don't want to do all this for every polygon! |
|
// TODO: store once at start of frame |
|
RI.currententity = s->entity; //FIXME: make this passed in to |
|
// R_RotateBmodel () |
|
VectorSubtract (RI.vieworg, RI.currententity->origin, |
|
local_modelorg); |
|
TransformVector (local_modelorg, transformed_modelorg); |
|
|
|
R_RotateBmodel (); // FIXME: don't mess with the frustum, |
|
// make entity passed in |
|
} |
|
|
|
D_CalcGradients (pface); |
|
|
|
//============ |
|
//PGM |
|
// textures that aren't warping are just flowing. Use NonTurbulent8 instead |
|
#if 0 |
|
Turbulent8 (s->spans); |
|
#else |
|
if(!(pface->flags & SURF_DRAWTURB)) |
|
NonTurbulent8 (s->spans); |
|
else |
|
Turbulent8 (s->spans); |
|
#endif |
|
//PGM |
|
//============ |
|
|
|
D_DrawZSpans (s->spans); |
|
|
|
if (s->insubmodel) |
|
{ |
|
// |
|
// restore the old drawing state |
|
// FIXME: we don't want to do this every time! |
|
// TODO: speed up |
|
// |
|
RI.currententity = NULL; // &r_worldentity; |
|
VectorCopy (world_transformed_modelorg, |
|
transformed_modelorg); |
|
VectorCopy (RI.base_vpn, RI.vforward); |
|
VectorCopy (RI.base_vup, RI.vup); |
|
VectorCopy (RI.base_vright, RI.vright); |
|
R_TransformFrustum (); |
|
} |
|
} |
|
|
|
qboolean alphaspans; |
|
/* |
|
============== |
|
D_SolidSurf |
|
|
|
Normal surface cached, texture mapped surface |
|
============== |
|
*/ |
|
static void D_AlphaSurf (surf_t *s) |
|
{ |
|
int alpha; |
|
|
|
d_zistepu = s->d_zistepu; |
|
d_zistepv = s->d_zistepv; |
|
d_ziorigin = s->d_ziorigin; |
|
if(s->flags & SURF_DRAWSKY) |
|
return; |
|
if (!s->insubmodel) // wtf? how it is possible? |
|
return; |
|
|
|
// FIXME: we don't want to do all this for every polygon! |
|
// TODO: store once at start of frame |
|
RI.currententity = s->entity; //FIXME: make this passed in to |
|
// R_RotateBmodel () |
|
VectorSubtract (RI.vieworg, RI.currententity->origin, local_modelorg); |
|
TransformVector (local_modelorg, transformed_modelorg); |
|
|
|
R_RotateBmodel (); // FIXME: don't mess with the frustum, |
|
// make entity passed in |
|
|
|
|
|
pface = s->msurf; |
|
|
|
|
|
if( !pface ) |
|
return; |
|
#if 1 |
|
|
|
if( pface->flags & SURF_CONVEYOR ) |
|
miplevel = 1; |
|
else |
|
miplevel = 0; |
|
#else |
|
{ |
|
float dot; |
|
float normal[3]; |
|
|
|
if ( s->insubmodel ) |
|
{ |
|
VectorCopy( pface->plane->normal, normal ); |
|
// TransformVector( pface->plane->normal, normal); |
|
dot = DotProduct( normal, vpn ); |
|
} |
|
else |
|
{ |
|
VectorCopy( pface->plane->normal, normal ); |
|
dot = DotProduct( normal, vpn ); |
|
} |
|
|
|
if ( pface->flags & SURF_PLANEBACK ) |
|
dot = -dot; |
|
|
|
if ( dot > 0 ) |
|
printf( "blah" ); |
|
|
|
miplevel = D_MipLevelForScale(s->nearzi * scale_for_mip * pface->texinfo->mipadjust); |
|
} |
|
#endif |
|
alpha = RI.currententity->curstate.renderamt * 7 / 255; |
|
if( alpha <= 0 && RI.currententity->curstate.renderamt > 0 ) |
|
alpha = 1; |
|
|
|
if (s->flags & SURF_DRAWTURB ) |
|
{ |
|
cacheblock = R_GetTexture(pface->texinfo->texture->gl_texturenum)->pixels[0]; |
|
cachewidth = 64; |
|
D_CalcGradients (pface); |
|
TurbulentZ8( s->spans, alpha); |
|
} |
|
else |
|
{ |
|
// FIXME: make this passed in to D_CacheSurface |
|
pcurrentcache = D_CacheSurface (pface, miplevel); |
|
|
|
cacheblock = (pixel_t *)pcurrentcache->data; |
|
cachewidth = pcurrentcache->width; |
|
|
|
D_CalcGradients (pface); |
|
|
|
|
|
|
|
if( RI.currententity->curstate.rendermode == kRenderTransAlpha ) |
|
D_AlphaSpans16(s->spans); |
|
else if( RI.currententity->curstate.rendermode == kRenderTransAdd ) |
|
D_AddSpans16(s->spans); |
|
else |
|
D_BlendSpans16(s->spans, alpha ); |
|
} |
|
|
|
VectorCopy (world_transformed_modelorg, |
|
transformed_modelorg); |
|
VectorCopy (RI.base_vpn, RI.vforward); |
|
VectorCopy (RI.base_vup, RI.vup); |
|
VectorCopy (RI.base_vright, RI.vright); |
|
R_TransformFrustum (); |
|
} |
|
|
|
|
|
/* |
|
============== |
|
D_SolidSurf |
|
|
|
Normal surface cached, texture mapped surface |
|
============== |
|
*/ |
|
static void D_SolidSurf (surf_t *s) |
|
{ |
|
d_zistepu = s->d_zistepu; |
|
d_zistepv = s->d_zistepv; |
|
d_ziorigin = s->d_ziorigin; |
|
if(s->flags & SURF_DRAWSKY) |
|
return; |
|
if (s->flags & SURF_DRAWTURB ) |
|
return; |
|
|
|
if (s->insubmodel) |
|
{ |
|
// FIXME: we don't want to do all this for every polygon! |
|
// TODO: store once at start of frame |
|
RI.currententity = s->entity; //FIXME: make this passed in to |
|
// R_RotateBmodel () |
|
VectorSubtract (RI.vieworg, RI.currententity->origin, local_modelorg); |
|
TransformVector (local_modelorg, transformed_modelorg); |
|
|
|
R_RotateBmodel (); // FIXME: don't mess with the frustum, |
|
// make entity passed in |
|
// setup dlight transform |
|
if( s->msurf && s->msurf->dlightframe == tr.framecount ) |
|
{ |
|
Matrix4x4_CreateFromEntity( RI.objectMatrix, RI.currententity->angles, RI.currententity->origin, 1 ); |
|
tr.modelviewIdentity = false; |
|
} |
|
} |
|
else |
|
{ |
|
if( alphaspans ) |
|
return; |
|
RI.currententity = CL_GetEntityByIndex(0); //r_worldentity; |
|
tr.modelviewIdentity = true; |
|
} |
|
|
|
pface = s->msurf; |
|
|
|
|
|
if( !pface ) |
|
return; |
|
#if 1 |
|
if( pface->flags & SURF_CONVEYOR ) |
|
miplevel = 1; |
|
else |
|
miplevel = D_MipLevelForScale(s->nearzi * scale_for_mip ); |
|
while( 1 << miplevel > gEngfuncs.Mod_SampleSizeForFace(pface)) |
|
miplevel--; |
|
#else |
|
{ |
|
float dot; |
|
float normal[3]; |
|
|
|
if ( s->insubmodel ) |
|
{ |
|
VectorCopy( pface->plane->normal, normal ); |
|
// TransformVector( pface->plane->normal, normal); |
|
dot = DotProduct( normal, vpn ); |
|
} |
|
else |
|
{ |
|
VectorCopy( pface->plane->normal, normal ); |
|
dot = DotProduct( normal, vpn ); |
|
} |
|
|
|
if ( pface->flags & SURF_PLANEBACK ) |
|
dot = -dot; |
|
|
|
if ( dot > 0 ) |
|
printf( "blah" ); |
|
|
|
miplevel = D_MipLevelForScale(s->nearzi * scale_for_mip * pface->texinfo->mipadjust); |
|
} |
|
#endif |
|
|
|
// FIXME: make this passed in to D_CacheSurface |
|
pcurrentcache = D_CacheSurface (pface, miplevel); |
|
|
|
cacheblock = (pixel_t *)pcurrentcache->data; |
|
cachewidth = pcurrentcache->width; |
|
|
|
D_CalcGradients (pface); |
|
|
|
D_DrawSpans16 (s->spans); |
|
|
|
D_DrawZSpans (s->spans); |
|
|
|
if (s->insubmodel) |
|
{ |
|
// |
|
// restore the old drawing state |
|
// FIXME: we don't want to do this every time! |
|
// TODO: speed up |
|
// |
|
VectorCopy (world_transformed_modelorg, |
|
transformed_modelorg); |
|
VectorCopy (RI.base_vpn, RI.vforward); |
|
VectorCopy (RI.base_vup, RI.vup); |
|
VectorCopy (RI.base_vright, RI.vright); |
|
R_TransformFrustum (); |
|
RI.currententity = NULL; //&r_worldentity; |
|
} |
|
} |
|
|
|
/* |
|
============= |
|
D_DrawflatSurfaces |
|
|
|
To allow developers to see the polygon carving of the world |
|
============= |
|
*/ |
|
static void D_DrawflatSurfaces (void) |
|
{ |
|
surf_t *s; |
|
|
|
for (s = &surfaces[1] ; s<surface_p ; s++) |
|
{ |
|
if (!s->spans) |
|
continue; |
|
|
|
d_zistepu = s->d_zistepu; |
|
d_zistepv = s->d_zistepv; |
|
d_ziorigin = s->d_ziorigin; |
|
|
|
// make a stable color for each surface by taking the low |
|
// bits of the msurface pointer |
|
D_FlatFillSurface (s, (uintptr_t)s->msurf & 0xFFFF); |
|
D_DrawZSpans (s->spans); |
|
} |
|
} |
|
|
|
/* |
|
============== |
|
D_DrawSurfaces |
|
|
|
Rasterize all the span lists. Guaranteed zero overdraw. |
|
May be called more than once a frame if the surf list overflows (higher res) |
|
============== |
|
*/ |
|
void D_DrawSurfaces (void) |
|
{ |
|
surf_t *s; |
|
|
|
// currententity = NULL; //&r_worldentity; |
|
VectorSubtract (RI.vieworg, vec3_origin, tr.modelorg); |
|
TransformVector (tr.modelorg, transformed_modelorg); |
|
VectorCopy (transformed_modelorg, world_transformed_modelorg); |
|
|
|
if (!sw_drawflat.value) |
|
{ |
|
for (s = &surfaces[1] ; s<surface_p ; s++) |
|
{ |
|
if (!s->spans) |
|
continue; |
|
|
|
//r_drawnpolycount++; |
|
#if 1 |
|
if( alphaspans ) |
|
D_AlphaSurf (s); |
|
else if(s->flags & SURF_DRAWSKY) |
|
D_BackgroundSurf (s); |
|
else if (s->flags & SURF_DRAWTURB ) |
|
D_TurbulentSurf (s); |
|
else |
|
D_SolidSurf (s); |
|
#else |
|
if (! (s->flags & (SURF_DRAWSKYBOX|SURF_DRAWBACKGROUND|SURF_DRAWTURB) ) ) |
|
D_SolidSurf (s); |
|
else if (s->flags & SURF_DRAWSKYBOX) |
|
D_SkySurf (s); |
|
else if (s->flags & SURF_DRAWBACKGROUND) |
|
D_BackgroundSurf (s); |
|
else if (s->flags & SURF_DRAWTURB) |
|
D_TurbulentSurf (s); |
|
#endif |
|
} |
|
} |
|
else |
|
D_DrawflatSurfaces (); |
|
|
|
//RI.currententity = NULL; //&r_worldentity; |
|
VectorSubtract (RI.vieworg, vec3_origin, tr.modelorg); |
|
R_TransformFrustum (); |
|
} |
|
|
|
|