r_edge.c File Reference

#include "r_local.h"

Go to the source code of this file.

Functions
void	R_RotateBmodel (void)
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)
void	R_BeginEdgeFrame (void)
void	R_InsertNewEdges (edge_t *edgestoadd, edge_t *edgelist)
void	R_RemoveEdges (edge_t *pedge)
void	R_StepActiveU (edge_t *pedge)
void	R_CleanupSpan (void)
void	R_ScanEdges (void)
int	D_MipLevelForScale (float scale)
void	D_FlatFillSurface (surf_t *surf, int color)
void	D_CalcGradients (msurface_t *pface)
void	D_BackgroundSurf (surf_t *s)
void	D_TurbulentSurf (surf_t *s)
void	D_SkySurf (surf_t *s)
void	D_SolidSurf (surf_t *s)
void	D_DrawflatSurfaces (void)
void	D_DrawSurfaces (void)

Variables
edge_t *	auxedges
edge_t *	r_edges
edge_t *	edge_p
edge_t *	edge_max
surf_t *	surfaces
surf_t *	surface_p
surf_t *	surf_max
edge_t *	newedges [MAXHEIGHT]
edge_t *	removeedges [MAXHEIGHT]
espan_t *	span_p
espan_t *	max_span_p
int	r_currentkey
int	current_iv
int	edge_head_u_shift20
int	edge_tail_u_shift20
static void(*	pdrawfunc )(void)
edge_t	edge_head
edge_t	edge_tail
edge_t	edge_aftertail
edge_t	edge_sentinel
float	fv
static int	miplevel
float	scale_for_mip
int	ubasestep
int	errorterm
int	erroradjustup
int	erroradjustdown
msurface_t *	pface
surfcache_t *	pcurrentcache
vec3_t	transformed_modelorg
vec3_t	world_transformed_modelorg
vec3_t	local_modelorg

Function Documentation

D_BackgroundSurf()

void D_BackgroundSurf

(

surf_t *

s

)

Definition at line 864 of file r_edge.c.

{
// 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 & 0xFF);
    D_DrawZSpans (s->spans);
}

Referenced by D_DrawSurfaces().

D_CalcGradients()

void D_CalcGradients

(

msurface_t *

pface

)

Definition at line 801 of file r_edge.c.

{
    mplane_t    *pplane;
    float       mipscale;
    vec3_t      p_temp1;
    vec3_t      p_saxis, p_taxis;
    float       t;
 
    pplane = pface->plane;
 
    mipscale = 1.0 / (float)(1 << miplevel);
 
    TransformVector (pface->texinfo->vecs[0], p_saxis);
    TransformVector (pface->texinfo->vecs[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;
    sadjust = ((fixed16_t)(DotProduct (p_temp1, p_saxis) * 0x10000 + 0.5)) -
            ((pface->texturemins[0] << 16) >> miplevel)
            + pface->texinfo->vecs[0][3]*t;
    tadjust = ((fixed16_t)(DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5)) -
            ((pface->texturemins[1] << 16) >> miplevel)
            + pface->texinfo->vecs[1][3]*t;
 
    // PGM - changing flow speed for non-warping textures.
    if (pface->texinfo->flags & SURF_FLOWING)
    {
        if(pface->texinfo->flags & SURF_WARP)
            sadjust += 0x10000 * (-128 * ( (r_newrefdef.time * 0.25) - (int)(r_newrefdef.time * 0.25) ));
        else
            sadjust += 0x10000 * (-128 * ( (r_newrefdef.time * 0.77) - (int)(r_newrefdef.time * 0.77) ));
    }
    // PGM
 
//
// -1 (-epsilon) so we never wander off the edge of the texture
//
    bbextents = ((pface->extents[0] << 16) >> miplevel) - 1;
    bbextentt = ((pface->extents[1] << 16) >> miplevel) - 1;
}

Referenced by D_SkySurf(), D_SolidSurf(), and D_TurbulentSurf().

D_DrawflatSurfaces()

void D_DrawflatSurfaces

(

void

)

Definition at line 1062 of file r_edge.c.

{
    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, (int)s->msurf & 0xFF);
        D_DrawZSpans (s->spans);
    }
}

Referenced by D_DrawSurfaces().

D_DrawSurfaces()

void D_DrawSurfaces

(

void

)

Definition at line 1090 of file r_edge.c.

{
    surf_t          *s;
 
//  currententity = NULL;   //&r_worldentity;
    VectorSubtract (r_origin, vec3_origin, modelorg);
    TransformVector (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 (! (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);
        }
    }
    else
        D_DrawflatSurfaces ();
 
    currententity = NULL;   //&r_worldentity;
    VectorSubtract (r_origin, vec3_origin, modelorg);
    R_TransformFrustum ();
}

Referenced by R_ScanEdges().

D_FlatFillSurface()

void D_FlatFillSurface	(	surf_t *	surf,
		int	color
	)

Definition at line 779 of file r_edge.c.

{
    espan_t *span;
    byte    *pdest;
    int     u, u2;
    
    for (span=surf->spans ; span ; span=span->pnext)
    {
        pdest = (byte *)d_viewbuffer + r_screenwidth*span->v;
        u = span->u;
        u2 = span->u + span->count - 1;
        for ( ; u <= u2 ; u++)
            pdest[u] = color;
    }
}

Referenced by D_BackgroundSurf(), and D_DrawflatSurfaces().

D_MipLevelForScale()

int D_MipLevelForScale

(

float

scale

)

Definition at line 752 of file r_edge.c.

{
    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;
}

Referenced by D_SolidSurf().

D_SkySurf()

void D_SkySurf

(

surf_t *

s

)

Definition at line 942 of file r_edge.c.

{
    pface = s->msurf;
    miplevel = 0;
    if (!pface->texinfo->image)
        return;
    cacheblock = pface->texinfo->image->pixels[0];
    cachewidth = 256;
 
    d_zistepu = s->d_zistepu;
    d_zistepv = s->d_zistepv;
    d_ziorigin = s->d_ziorigin;
 
    D_CalcGradients (pface);
 
    D_DrawSpans16 (s->spans);
 
// 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_DrawZSpans (s->spans);
}

Referenced by D_DrawSurfaces().

D_SolidSurf()

void D_SolidSurf

(

surf_t *

s

)

Definition at line 975 of file r_edge.c.

{
    d_zistepu = s->d_zistepu;
    d_zistepv = s->d_zistepv;
    d_ziorigin = s->d_ziorigin;
 
    if (s->insubmodel)
    {
    // FIXME: we don't want to do all this for every polygon!
    // TODO: store once at start of frame
        currententity = s->entity;  //FIXME: make this passed in to
                                    // R_RotateBmodel ()
        VectorSubtract (r_origin, currententity->origin, local_modelorg);
        TransformVector (local_modelorg, transformed_modelorg);
 
        R_RotateBmodel ();  // FIXME: don't mess with the frustum,
                            // make entity passed in
    }
    else
        currententity = &r_worldentity;
 
    pface = s->msurf;
#if 1
    miplevel = D_MipLevelForScale(s->nearzi * scale_for_mip * pface->texinfo->mipadjust);
#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 (base_vpn, vpn);
        VectorCopy (base_vup, vup);
        VectorCopy (base_vright, vright);
        R_TransformFrustum ();
        currententity = NULL;   //&r_worldentity;
    }
}

Referenced by D_DrawSurfaces().

D_TurbulentSurf()

void D_TurbulentSurf

(

surf_t *

s

)

Definition at line 881 of file r_edge.c.

{
    d_zistepu = s->d_zistepu;
    d_zistepv = s->d_zistepv;
    d_ziorigin = s->d_ziorigin;
 
    pface = s->msurf;
    miplevel = 0;
    cacheblock = pface->texinfo->image->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
        currententity = s->entity;  //FIXME: make this passed in to
                                    // R_RotateBmodel ()
        VectorSubtract (r_origin, 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(!(pface->texinfo->flags & SURF_WARP))
        NonTurbulent8 (s->spans);
    else
        Turbulent8 (s->spans);
//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
    //
        currententity = NULL;   // &r_worldentity;
        VectorCopy (world_transformed_modelorg,
                    transformed_modelorg);
        VectorCopy (base_vpn, vpn);
        VectorCopy (base_vup, vup);
        VectorCopy (base_vright, vright);
        R_TransformFrustum ();
    }
}

Referenced by D_DrawSurfaces().

R_BeginEdgeFrame()

void R_BeginEdgeFrame

(

void

)

Definition at line 109 of file r_edge.c.

{
    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 = 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=r_refdef.vrect.y ; v<r_refdef.vrectbottom ; v++)
    {
        newedges[v] = removeedges[v] = NULL;
    }
}

Referenced by R_EdgeDrawing().

R_CleanupSpan()

void R_CleanupSpan

(

void

)

Definition at line 284 of file r_edge.c.

{
    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]);
}

Referenced by R_GenerateSpans(), and R_GenerateSpansBackward().

R_GenerateSpans()

void R_GenerateSpans

(

void

)

Definition at line 564 of file r_edge.c.

{
    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 ();
}

Referenced by R_BeginEdgeFrame().

R_GenerateSpansBackward()

void R_GenerateSpansBackward

(

void

)

Definition at line 601 of file r_edge.c.

{
    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 ();
}

Referenced by R_BeginEdgeFrame().

R_InsertNewEdges()

void R_InsertNewEdges	(	edge_t *	edgestoadd,
		edge_t *	edgelist
	)

Definition at line 155 of file r_edge.c.

{
    edge_t  *next_edge;
 
    do
    {
        next_edge = edgestoadd->next;
edgesearch:
        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;
        if (edgelist->u >= edgestoadd->u)
            goto addedge;
        edgelist=edgelist->next;
        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);
}

Referenced by R_ScanEdges().

R_LeadingEdge()

void R_LeadingEdge

(

edge_t *

edge

)

Definition at line 439 of file r_edge.c.

{
    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.0 / 0x100000);
                newzi = surf->d_ziorigin + fv*surf->d_zistepv +
                        fu*surf->d_zistepu;
                newzibottom = newzi * 0.99;
 
                testzi = surf2->d_ziorigin + fv*surf2->d_zistepv +
                        fu*surf2->d_zistepu;
 
                if (newzibottom >= testzi)
                {
                    goto newtop;
                }
 
                newzitop = newzi * 1.01;
                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.0 / 0x100000);
                newzi = surf->d_ziorigin + fv*surf->d_zistepv +
                        fu*surf->d_zistepu;
                newzibottom = newzi * 0.99;
 
                testzi = surf2->d_ziorigin + fv*surf2->d_zistepv +
                        fu*surf2->d_zistepu;
 
                if (newzibottom >= testzi)
                {
                    goto gotposition;
                }
 
                newzitop = newzi * 1.01;
                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;
        }
    }
}

Referenced by R_GenerateSpans().

R_LeadingEdgeBackwards()

void R_LeadingEdgeBackwards

(

edge_t *

edge

)

Definition at line 318 of file r_edge.c.

{
    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;
    }
}

Referenced by R_GenerateSpansBackward().

R_RemoveEdges()

void R_RemoveEdges

(

edge_t *

pedge

)

Definition at line 196 of file r_edge.c.

{
 
    do
    {
        pedge->next->prev = pedge->prev;
        pedge->prev->next = pedge->next;
    } while ((pedge = pedge->nextremove) != NULL);
}

Referenced by R_ScanEdges().

R_RotateBmodel()

void R_RotateBmodel

(

void

)

Definition at line 75 of file r_bsp.c.

{
    float   angle, s, c, temp1[3][3], temp2[3][3], temp3[3][3];
 
// TODO: should use a look-up table
// TODO: should really be stored with the entity instead of being reconstructed
// TODO: could cache lazily, stored in the entity
// TODO: share work with R_SetUpAliasTransform
 
// yaw
    angle = currententity->angles[YAW];     
    angle = angle * M_PI*2 / 360;
    s = sin(angle);
    c = cos(angle);
 
    temp1[0][0] = c;
    temp1[0][1] = s;
    temp1[0][2] = 0;
    temp1[1][0] = -s;
    temp1[1][1] = c;
    temp1[1][2] = 0;
    temp1[2][0] = 0;
    temp1[2][1] = 0;
    temp1[2][2] = 1;
 
 
// pitch
    angle = currententity->angles[PITCH];       
    angle = angle * M_PI*2 / 360;
    s = sin(angle);
    c = cos(angle);
 
    temp2[0][0] = c;
    temp2[0][1] = 0;
    temp2[0][2] = -s;
    temp2[1][0] = 0;
    temp2[1][1] = 1;
    temp2[1][2] = 0;
    temp2[2][0] = s;
    temp2[2][1] = 0;
    temp2[2][2] = c;
 
    R_ConcatRotations (temp2, temp1, temp3);
 
// roll
    angle = currententity->angles[ROLL];        
    angle = angle * M_PI*2 / 360;
    s = sin(angle);
    c = cos(angle);
 
    temp1[0][0] = 1;
    temp1[0][1] = 0;
    temp1[0][2] = 0;
    temp1[1][0] = 0;
    temp1[1][1] = c;
    temp1[1][2] = s;
    temp1[2][0] = 0;
    temp1[2][1] = -s;
    temp1[2][2] = c;
 
    R_ConcatRotations (temp1, temp3, entity_rotation);
 
//
// rotate modelorg and the transformation matrix
//
    R_EntityRotate (modelorg);
    R_EntityRotate (vpn);
    R_EntityRotate (vright);
    R_EntityRotate (vup);
 
    R_TransformFrustum ();
}

Referenced by D_SolidSurf(), and D_TurbulentSurf().

R_ScanEdges()

void R_ScanEdges

(

void

)

Definition at line 635 of file r_edge.c.

{
    int     iv, bottom;
    byte    basespans[MAXSPANS*sizeof(espan_t)+CACHE_SIZE];
    espan_t *basespan_p;
    surf_t  *s;
 
    basespan_p = (espan_t *)
            ((long)(basespans + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
    max_span_p = &basespan_p[MAXSPANS - r_refdef.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 = r_refdef.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 = (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 << 24;       // make sure nothing sorts past this
    edge_sentinel.prev = &edge_aftertail;
 
//  
// process all scan lines
//
    bottom = r_refdef.vrectbottom - 1;
 
    for (iv=r_refdef.vrect.y ; 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);
        }
 
        (*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;
        }
 
        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 ();
}

Referenced by R_EdgeDrawing().

R_StepActiveU()

void R_StepActiveU

(

edge_t *

pedge

)

Definition at line 216 of file r_edge.c.

{
    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;
 
        while (pwedge->u > pedge->u)
        {
            pwedge = pwedge->prev;
        }
 
    // 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;
    }
}

Referenced by R_ScanEdges().

R_TrailingEdge()

void R_TrailingEdge	(	surf_t *	surf,
		edge_t *	edge
	)

Definition at line 398 of file r_edge.c.

{
    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;
    }
}

Referenced by R_GenerateSpans(), and R_GenerateSpansBackward().

R_TransformFrustum()

void R_TransformFrustum

(

void

)

Definition at line 187 of file r_misc.c.

{
    int     i;
    vec3_t  v, v2;
    
    for (i=0 ; i<4 ; i++)
    {
        v[0] = screenedge[i].normal[2];
        v[1] = -screenedge[i].normal[0];
        v[2] = screenedge[i].normal[1];
 
        v2[0] = v[1]*vright[0] + v[2]*vup[0] + v[0]*vpn[0];
        v2[1] = v[1]*vright[1] + v[2]*vup[1] + v[0]*vpn[1];
        v2[2] = v[1]*vright[2] + v[2]*vup[2] + v[0]*vpn[2];
 
        VectorCopy (v2, view_clipplanes[i].normal);
 
        view_clipplanes[i].dist = DotProduct (modelorg, v2);
    }
}

Referenced by D_DrawSurfaces(), D_SolidSurf(), D_TurbulentSurf(), R_DrawBEntitiesOnList(), and R_RotateBmodel().

Variable Documentation

auxedges

edge_t* auxedges

Definition at line 48 of file r_edge.c.

Referenced by R_EdgeDrawing(), and R_NewMap().

current_iv

int current_iv

Definition at line 64 of file r_edge.c.

Referenced by R_CleanupSpan(), R_LeadingEdge(), R_LeadingEdgeBackwards(), R_ScanEdges(), and R_TrailingEdge().

edge_aftertail

edge_t edge_aftertail

Definition at line 72 of file r_edge.c.

Referenced by R_ScanEdges(), and R_StepActiveU().

edge_head

edge_t edge_head

Definition at line 70 of file r_edge.c.

Referenced by R_GenerateSpans(), R_GenerateSpansBackward(), and R_ScanEdges().

edge_head_u_shift20

int edge_head_u_shift20

Definition at line 66 of file r_edge.c.

Referenced by R_GenerateSpans(), R_GenerateSpansBackward(), and R_ScanEdges().

edge_max

edge_t * edge_max

Definition at line 49 of file r_edge.c.

Referenced by R_BeginEdgeFrame(), R_RenderBmodelFace(), and R_RenderFace().

edge_p

edge_t * edge_p

Definition at line 49 of file r_edge.c.

Referenced by R_BeginEdgeFrame(), R_EmitEdge(), R_RenderBmodelFace(), and R_RenderFace().

edge_sentinel

edge_t edge_sentinel

Definition at line 73 of file r_edge.c.

Referenced by R_ScanEdges().

edge_tail

edge_t edge_tail

Definition at line 71 of file r_edge.c.

Referenced by R_GenerateSpans(), R_GenerateSpansBackward(), R_ScanEdges(), and R_StepActiveU().

edge_tail_u_shift20

int edge_tail_u_shift20

Definition at line 66 of file r_edge.c.

Referenced by R_CleanupSpan(), and R_ScanEdges().

erroradjustdown

int erroradjustdown

Definition at line 80 of file r_edge.c.

Referenced by R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), R_PolysetDrawSpansConstant8_33(), R_PolysetDrawSpansConstant8_66(), R_PolysetDrawThreshSpans8(), R_PolysetScanLeftEdge_C(), and R_PolysetSetUpForLineScan().

erroradjustup

int erroradjustup

Definition at line 80 of file r_edge.c.

Referenced by R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), R_PolysetDrawSpansConstant8_33(), R_PolysetDrawSpansConstant8_66(), R_PolysetDrawThreshSpans8(), R_PolysetScanLeftEdge_C(), and R_PolysetSetUpForLineScan().

errorterm

int errorterm

Definition at line 80 of file r_edge.c.

Referenced by R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), R_PolysetDrawSpansConstant8_33(), R_PolysetDrawSpansConstant8_66(), R_PolysetDrawThreshSpans8(), R_PolysetScanLeftEdge_C(), and R_PolysetSetUpForLineScan().

fv

float fv

Definition at line 75 of file r_edge.c.

Referenced by CL_ParseMuzzleFlash(), R_AliasProjectAndClipTestFinalVert(), R_AliasTransformFinalVerts(), R_LeadingEdge(), and R_ScanEdges().

local_modelorg

vec3_t local_modelorg

Definition at line 745 of file r_edge.c.

Referenced by D_SolidSurf(), and D_TurbulentSurf().

max_span_p

espan_t * max_span_p

Definition at line 60 of file r_edge.c.

Referenced by R_ScanEdges().

miplevel

int miplevel

static

Definition at line 77 of file r_edge.c.

Referenced by D_CacheSurface(), D_CalcGradients(), D_SkySurf(), D_SolidSurf(), D_TurbulentSurf(), and GL_Upload32().

newedges

edge_t* newedges[MAXHEIGHT]

Definition at line 57 of file r_edge.c.

Referenced by R_BeginEdgeFrame(), R_EmitEdge(), and R_ScanEdges().

pcurrentcache

surfcache_t* pcurrentcache

Definition at line 742 of file r_edge.c.

Referenced by D_SolidSurf().

pdrawfunc

void(* pdrawfunc) (void)

static

Definition at line 68 of file r_edge.c.

Referenced by R_BeginEdgeFrame().

pface

msurface_t* pface

Definition at line 741 of file r_edge.c.

Referenced by D_CalcGradients(), D_SkySurf(), D_SolidSurf(), and D_TurbulentSurf().

r_currentkey

int r_currentkey

Definition at line 62 of file r_edge.c.

Referenced by R_BeginEdgeFrame(), R_DrawSubmodelPolygons(), R_EmitSkyBox(), R_RecursiveWorldNode(), and R_RenderFace().

r_edges

edge_t* r_edges

Definition at line 49 of file r_edge.c.

Referenced by R_BeginEdgeFrame(), R_EdgeDrawing(), R_EmitCachedEdge(), and R_RenderFace().

removeedges

edge_t* removeedges[MAXHEIGHT]

Definition at line 58 of file r_edge.c.

Referenced by R_BeginEdgeFrame(), R_EmitEdge(), and R_ScanEdges().

scale_for_mip

float scale_for_mip

Definition at line 79 of file r_edge.c.

Referenced by D_SolidSurf(), and D_ViewChanged().

span_p

espan_t* span_p

Definition at line 60 of file r_edge.c.

Referenced by R_CleanupSpan(), R_LeadingEdge(), R_LeadingEdgeBackwards(), R_ScanEdges(), and R_TrailingEdge().

surf_max

surf_t * surf_max

Definition at line 51 of file r_edge.c.

Referenced by R_EdgeDrawing(), R_NewMap(), R_RenderBmodelFace(), and R_RenderFace().

surface_p

surf_t * surface_p

Definition at line 51 of file r_edge.c.

Referenced by D_DrawflatSurfaces(), D_DrawSurfaces(), R_BeginEdgeFrame(), R_EmitCachedEdge(), R_EmitEdge(), R_NewMap(), R_RenderBmodelFace(), R_RenderFace(), and R_ScanEdges().

surfaces

surf_t* surfaces

Definition at line 51 of file r_edge.c.

Referenced by D_DrawflatSurfaces(), D_DrawSurfaces(), R_BeginEdgeFrame(), R_CleanupSpan(), R_EdgeDrawing(), R_EmitCachedEdge(), R_EmitEdge(), R_GenerateSpans(), R_GenerateSpansBackward(), R_LeadingEdge(), R_LeadingEdgeBackwards(), R_NewMap(), R_ScanEdges(), and R_TrailingEdge().

transformed_modelorg

vec3_t transformed_modelorg

Definition at line 743 of file r_edge.c.

Referenced by D_CalcGradients(), D_DrawSurfaces(), D_SolidSurf(), and D_TurbulentSurf().

ubasestep

int ubasestep

Definition at line 80 of file r_edge.c.

Referenced by R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), R_PolysetDrawSpansConstant8_33(), R_PolysetDrawSpansConstant8_66(), R_PolysetDrawThreshSpans8(), R_PolysetScanLeftEdge_C(), R_PolysetSetUpForLineScan(), and R_RasterizeAliasPolySmooth().

world_transformed_modelorg

vec3_t world_transformed_modelorg

Definition at line 744 of file r_edge.c.

Referenced by D_DrawSurfaces(), D_SolidSurf(), and D_TurbulentSurf().