r_polyse.c File Reference

#include "r_local.h"
#include "rand1k.h"
#include "adivtab.h"

Go to the source code of this file.

Classes
struct	spanpackage_t
struct	edgetable
struct	adivtab_t

Macros
#define	MASK_1K   0x3FF
#define	DPS_MAXSPANS   MAXHEIGHT+1

Functions
void	R_PolysetDrawSpans8_33 (spanpackage_t *pspanpackage)
void	R_PolysetDrawSpans8_66 (spanpackage_t *pspanpackage)
void	R_PolysetDrawSpans8_Opaque (spanpackage_t *pspanpackage)
void	R_PolysetDrawThreshSpans8 (spanpackage_t *pspanpackage)
void	R_PolysetCalcGradients (int skinwidth)
void	R_DrawNonSubdiv (void)
void	R_PolysetSetEdgeTable (void)
void	R_RasterizeAliasPolySmooth (void)
void	R_PolysetScanLeftEdge (int height)
void	R_PolysetScanLeftEdge_C (int height)
void	R_PolysetUpdateTables (void)
void	R_DrawTriangle (void)
void	FloorDivMod (float numer, float denom, int *quotient, int *rem)
void	R_PolysetSetUpForLineScan (fixed8_t startvertu, fixed8_t startvertv, fixed8_t endvertu, fixed8_t endvertv)
void	R_PolysetDrawSpansConstant8_33 (spanpackage_t *pspanpackage)
void	R_PolysetDrawSpansConstant8_66 (spanpackage_t *pspanpackage)
void	R_PolysetFillSpans8 (spanpackage_t *pspanpackage)

Variables
int	rand1k []
int	rand1k_index = 0
aliastriangleparms_t	aliastriangleparms
int	r_p0 [6]
int	r_p1 [6]
int	r_p2 [6]
byte *	d_pcolormap
int	d_aflatcolor
int	d_xdenom
edgetable *	pedgetable
edgetable	edgetables [12]
int	a_sstepxfrac
int	a_tstepxfrac
int	r_lstepx
int	a_ststepxwhole
int	r_sstepx
int	r_tstepx
int	r_lstepy
int	r_sstepy
int	r_tstepy
int	r_zistepx
int	r_zistepy
int	d_aspancount
int	d_countextrastep
spanpackage_t *	a_spans
spanpackage_t *	d_pedgespanpackage
static int	ystart
byte *	d_pdest
byte *	d_ptex
short *	d_pz
int	d_sfrac
int	d_tfrac
int	d_light
int	d_zi
int	d_ptexextrastep
int	d_sfracextrastep
int	d_tfracextrastep
int	d_lightextrastep
int	d_pdestextrastep
int	d_lightbasestep
int	d_pdestbasestep
int	d_ptexbasestep
int	d_sfracbasestep
int	d_tfracbasestep
int	d_ziextrastep
int	d_zibasestep
int	d_pzextrastep
int	d_pzbasestep
static adivtab_t	adivtab [32 *32]
byte *	skintable [MAX_LBM_HEIGHT]
int	skinwidth
byte *	skinstart
void(*	d_pdrawspans )(spanpackage_t *pspanpackage)
byte	iractive = 0
byte	irtable [256]

Macro Definition Documentation

DPS_MAXSPANS

#define DPS_MAXSPANS   MAXHEIGHT+1

Definition at line 35 of file r_polyse.c.

MASK_1K

#define MASK_1K   0x3FF

Definition at line 29 of file r_polyse.c.

Function Documentation

FloorDivMod()

void FloorDivMod	(	float	numer,
		float	denom,
		int *	quotient,
		int *	rem
	)

Definition at line 336 of file r_polyse.c.

{
    int     q, r;
    float   x;
 
    if (numer >= 0.0)
    {
 
        x = floor(numer / denom);
        q = (int)x;
        r = (int)floor(numer - (x * denom));
    }
    else
    {
    //
    // perform operations with positive values, and fix mod to make floor-based
    //
        x = floor(-numer / denom);
        q = -(int)x;
        r = (int)floor(-numer - (x * denom));
        if (r != 0)
        {
            q--;
            r = (int)denom - r;
        }
    }
 
    *quotient = q;
    *rem = r;
}

Referenced by R_PolysetSetUpForLineScan().

R_DrawNonSubdiv()

void R_DrawNonSubdiv

(

void

)

R_DrawTriangle()

void R_DrawTriangle

(

void

)

Definition at line 204 of file r_polyse.c.

{
    spanpackage_t spans[DPS_MAXSPANS];
 
    int dv1_ab, dv0_ac;
    int dv0_ab, dv1_ac;
 
    /*
    d_xdenom = ( aliastriangleparms.a->v[1] - aliastriangleparms.b->v[1] ) * ( aliastriangleparms.a->v[0] - aliastriangleparms.c->v[0] ) -
               ( aliastriangleparms.a->v[0] - aliastriangleparms.b->v[0] ) * ( aliastriangleparms.a->v[1] - aliastriangleparms.c->v[1] );
    */
 
    dv0_ab = aliastriangleparms.a->u - aliastriangleparms.b->u;
    dv1_ab = aliastriangleparms.a->v - aliastriangleparms.b->v;
 
    if ( !( dv0_ab | dv1_ab ) )
        return;
 
    dv0_ac = aliastriangleparms.a->u - aliastriangleparms.c->u;
    dv1_ac = aliastriangleparms.a->v - aliastriangleparms.c->v;
 
    if ( !( dv0_ac | dv1_ac ) )
        return;
 
    d_xdenom = ( dv0_ac * dv1_ab ) - ( dv0_ab * dv1_ac );
 
    if ( d_xdenom < 0 )
    {
        a_spans = spans;
 
        r_p0[0] = aliastriangleparms.a->u;      // u
        r_p0[1] = aliastriangleparms.a->v;      // v
        r_p0[2] = aliastriangleparms.a->s;      // s
        r_p0[3] = aliastriangleparms.a->t;      // t
        r_p0[4] = aliastriangleparms.a->l;      // light
        r_p0[5] = aliastriangleparms.a->zi;     // iz
 
        r_p1[0] = aliastriangleparms.b->u;
        r_p1[1] = aliastriangleparms.b->v;
        r_p1[2] = aliastriangleparms.b->s;
        r_p1[3] = aliastriangleparms.b->t;
        r_p1[4] = aliastriangleparms.b->l;
        r_p1[5] = aliastriangleparms.b->zi;
 
        r_p2[0] = aliastriangleparms.c->u;
        r_p2[1] = aliastriangleparms.c->v;
        r_p2[2] = aliastriangleparms.c->s;
        r_p2[3] = aliastriangleparms.c->t;
        r_p2[4] = aliastriangleparms.c->l;
        r_p2[5] = aliastriangleparms.c->zi;
 
        R_PolysetSetEdgeTable ();
        R_RasterizeAliasPolySmooth ();
    }
}

Referenced by R_AliasClipTriangle(), and R_AliasPreparePoints().

R_PolysetCalcGradients()

void R_PolysetCalcGradients

(

int

skinwidth

)

Definition at line 673 of file r_polyse.c.

{
    float   xstepdenominv, ystepdenominv, t0, t1;
    float   p01_minus_p21, p11_minus_p21, p00_minus_p20, p10_minus_p20;
 
    p00_minus_p20 = r_p0[0] - r_p2[0];
    p01_minus_p21 = r_p0[1] - r_p2[1];
    p10_minus_p20 = r_p1[0] - r_p2[0];
    p11_minus_p21 = r_p1[1] - r_p2[1];
 
    xstepdenominv = 1.0 / (float)d_xdenom;
 
    ystepdenominv = -xstepdenominv;
 
// ceil () for light so positive steps are exaggerated, negative steps
// diminished,  pushing us away from underflow toward overflow. Underflow is
// very visible, overflow is very unlikely, because of ambient lighting
    t0 = r_p0[4] - r_p2[4];
    t1 = r_p1[4] - r_p2[4];
    r_lstepx = (int)
            ceil((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
    r_lstepy = (int)
            ceil((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv);
 
    t0 = r_p0[2] - r_p2[2];
    t1 = r_p1[2] - r_p2[2];
    r_sstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
            xstepdenominv);
    r_sstepy = (int)((t1 * p00_minus_p20 - t0* p10_minus_p20) *
            ystepdenominv);
 
    t0 = r_p0[3] - r_p2[3];
    t1 = r_p1[3] - r_p2[3];
    r_tstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
            xstepdenominv);
    r_tstepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
            ystepdenominv);
 
    t0 = r_p0[5] - r_p2[5];
    t1 = r_p1[5] - r_p2[5];
    r_zistepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
            xstepdenominv);
    r_zistepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
            ystepdenominv);
 
//#if   id386ALIAS
#if id386
    if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
    {
        a_sstepxfrac = r_sstepx << 16;
        a_tstepxfrac = r_tstepx << 16;
    }
    else
#endif
    {
//#else
        a_sstepxfrac = r_sstepx & 0xFFFF;
        a_tstepxfrac = r_tstepx & 0xFFFF;
    }
//#endif
 
    a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
}

Referenced by R_RasterizeAliasPolySmooth().

R_PolysetDrawSpans8_33()

void R_PolysetDrawSpans8_33

(

spanpackage_t *

pspanpackage

)

Definition at line 820 of file r_polyse.c.

{
    int     lcount;
    byte    *lpdest;
    byte    *lptex;
    int     lsfrac, ltfrac;
    int     llight;
    int     lzi;
    short   *lpz;
 
    do
    {
        lcount = d_aspancount - pspanpackage->count;
 
        errorterm += erroradjustup;
        if (errorterm >= 0)
        {
            d_aspancount += d_countextrastep;
            errorterm -= erroradjustdown;
        }
        else
        {
            d_aspancount += ubasestep;
        }
 
        if (lcount)
        {
            lpdest = pspanpackage->pdest;
            lptex = pspanpackage->ptex;
            lpz = pspanpackage->pz;
            lsfrac = pspanpackage->sfrac;
            ltfrac = pspanpackage->tfrac;
            llight = pspanpackage->light;
            lzi = pspanpackage->zi;
 
            do
            {
                if ((lzi >> 16) >= *lpz)
                {
                    int temp = vid.colormap[*lptex + ( llight & 0xFF00 )];
 
                    *lpdest = vid.alphamap[temp+ *lpdest*256];
                }
                lpdest++;
                lzi += r_zistepx;
                lpz++;
                llight += r_lstepx;
                lptex += a_ststepxwhole;
                lsfrac += a_sstepxfrac;
                lptex += lsfrac >> 16;
                lsfrac &= 0xFFFF;
                ltfrac += a_tstepxfrac;
                if (ltfrac & 0x10000)
                {
                    lptex += r_affinetridesc.skinwidth;
                    ltfrac &= 0xFFFF;
                }
            } while (--lcount);
        }
 
        pspanpackage++;
    } while (pspanpackage->count != -999999);
}

Referenced by R_AliasDrawModel().

R_PolysetDrawSpans8_66()

void R_PolysetDrawSpans8_66

(

spanpackage_t *

pspanpackage

)

Definition at line 928 of file r_polyse.c.

{
    int     lcount;
    byte    *lpdest;
    byte    *lptex;
    int     lsfrac, ltfrac;
    int     llight;
    int     lzi;
    short   *lpz;
 
    do
    {
        lcount = d_aspancount - pspanpackage->count;
 
        errorterm += erroradjustup;
        if (errorterm >= 0)
        {
            d_aspancount += d_countextrastep;
            errorterm -= erroradjustdown;
        }
        else
        {
            d_aspancount += ubasestep;
        }
 
        if (lcount)
        {
            lpdest = pspanpackage->pdest;
            lptex = pspanpackage->ptex;
            lpz = pspanpackage->pz;
            lsfrac = pspanpackage->sfrac;
            ltfrac = pspanpackage->tfrac;
            llight = pspanpackage->light;
            lzi = pspanpackage->zi;
 
            do
            {
                if ((lzi >> 16) >= *lpz)
                {
                    int temp = vid.colormap[*lptex + ( llight & 0xFF00 )];
 
                    *lpdest = vid.alphamap[temp*256 + *lpdest];
                    *lpz = lzi >> 16;
                }
                lpdest++;
                lzi += r_zistepx;
                lpz++;
                llight += r_lstepx;
                lptex += a_ststepxwhole;
                lsfrac += a_sstepxfrac;
                lptex += lsfrac >> 16;
                lsfrac &= 0xFFFF;
                ltfrac += a_tstepxfrac;
                if (ltfrac & 0x10000)
                {
                    lptex += r_affinetridesc.skinwidth;
                    ltfrac &= 0xFFFF;
                }
            } while (--lcount);
        }
 
        pspanpackage++;
    } while (pspanpackage->count != -999999);
}

Referenced by R_AliasDrawModel().

R_PolysetDrawSpans8_Opaque()

void R_PolysetDrawSpans8_Opaque

(

spanpackage_t *

pspanpackage

)

Definition at line 1038 of file r_polyse.c.

{
    int     lcount;
 
    do
    {
        lcount = d_aspancount - pspanpackage->count;
 
        errorterm += erroradjustup;
        if (errorterm >= 0)
        {
            d_aspancount += d_countextrastep;
            errorterm -= erroradjustdown;
        }
        else
        {
            d_aspancount += ubasestep;
        }
 
        if (lcount)
        {
            int     lsfrac, ltfrac;
            byte    *lpdest;
            byte    *lptex;
            int     llight;
            int     lzi;
            short   *lpz;
 
            lpdest = pspanpackage->pdest;
            lptex = pspanpackage->ptex;
            lpz = pspanpackage->pz;
            lsfrac = pspanpackage->sfrac;
            ltfrac = pspanpackage->tfrac;
            llight = pspanpackage->light;
            lzi = pspanpackage->zi;
 
            do
            {
                if ((lzi >> 16) >= *lpz)
                {
//PGM
                    if(r_newrefdef.rdflags & RDF_IRGOGGLES && currententity->flags & RF_IR_VISIBLE)
                        *lpdest = ((byte *)vid.colormap)[irtable[*lptex]];
                    else
                    *lpdest = ((byte *)vid.colormap)[*lptex + (llight & 0xFF00)];
//PGM
                    *lpz = lzi >> 16;
                }
                lpdest++;
                lzi += r_zistepx;
                lpz++;
                llight += r_lstepx;
                lptex += a_ststepxwhole;
                lsfrac += a_sstepxfrac;
                lptex += lsfrac >> 16;
                lsfrac &= 0xFFFF;
                ltfrac += a_tstepxfrac;
                if (ltfrac & 0x10000)
                {
                    lptex += r_affinetridesc.skinwidth;
                    ltfrac &= 0xFFFF;
                }
            } while (--lcount);
        }
 
        pspanpackage++;
    } while (pspanpackage->count != -999999);
}

Referenced by R_AliasDrawModel(), R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

R_PolysetDrawSpansConstant8_33()

void R_PolysetDrawSpansConstant8_33

(

spanpackage_t *

pspanpackage

)

Definition at line 884 of file r_polyse.c.

{
    int     lcount;
    byte    *lpdest;
    int     lzi;
    short   *lpz;
 
    do
    {
        lcount = d_aspancount - pspanpackage->count;
 
        errorterm += erroradjustup;
        if (errorterm >= 0)
        {
            d_aspancount += d_countextrastep;
            errorterm -= erroradjustdown;
        }
        else
        {
            d_aspancount += ubasestep;
        }
 
        if (lcount)
        {
            lpdest = pspanpackage->pdest;
            lpz = pspanpackage->pz;
            lzi = pspanpackage->zi;
 
            do
            {
                if ((lzi >> 16) >= *lpz)
                {
                    *lpdest = vid.alphamap[r_aliasblendcolor + *lpdest*256];
                }
                lpdest++;
                lzi += r_zistepx;
                lpz++;
            } while (--lcount);
        }
 
        pspanpackage++;
    } while (pspanpackage->count != -999999);
}

Referenced by R_AliasDrawModel().

R_PolysetDrawSpansConstant8_66()

void R_PolysetDrawSpansConstant8_66

(

spanpackage_t *

pspanpackage

)

Definition at line 993 of file r_polyse.c.

{
    int     lcount;
    byte    *lpdest;
    int     lzi;
    short   *lpz;
 
    do
    {
        lcount = d_aspancount - pspanpackage->count;
 
        errorterm += erroradjustup;
        if (errorterm >= 0)
        {
            d_aspancount += d_countextrastep;
            errorterm -= erroradjustdown;
        }
        else
        {
            d_aspancount += ubasestep;
        }
 
        if (lcount)
        {
            lpdest = pspanpackage->pdest;
            lpz = pspanpackage->pz;
            lzi = pspanpackage->zi;
 
            do
            {
                if ((lzi >> 16) >= *lpz)
                {
                    *lpdest = vid.alphamap[r_aliasblendcolor*256 + *lpdest];
                }
                lpdest++;
                lzi += r_zistepx;
                lpz++;
            } while (--lcount);
        }
 
        pspanpackage++;
    } while (pspanpackage->count != -999999);
}

Referenced by R_AliasDrawModel().

R_PolysetDrawThreshSpans8()

void R_PolysetDrawThreshSpans8

(

spanpackage_t *

pspanpackage

)

Definition at line 745 of file r_polyse.c.

{
    int     lcount;
    byte    *lpdest;
    byte    *lptex;
    int     lsfrac, ltfrac;
    int     llight;
    int     lzi;
    short   *lpz;
 
    do
    {
        lcount = d_aspancount - pspanpackage->count;
 
        errorterm += erroradjustup;
        if (errorterm >= 0)
        {
            d_aspancount += d_countextrastep;
            errorterm -= erroradjustdown;
        }
        else
        {
            d_aspancount += ubasestep;
        }
 
        if (lcount)
        {
            lpdest = pspanpackage->pdest;
            lptex = pspanpackage->ptex;
            lpz = pspanpackage->pz;
            lsfrac = pspanpackage->sfrac;
            ltfrac = pspanpackage->tfrac;
            llight = pspanpackage->light;
            lzi = pspanpackage->zi;
 
            do
            {
                if ((lzi >> 16) >= *lpz)
                {
                    rand1k_index = (rand1k_index + 1) & MASK_1K;
 
                    if (rand1k[rand1k_index] <= r_affinetridesc.vis_thresh)
                    {
                        *lpdest = ((byte *)vid.colormap)[*lptex + (llight & 0xFF00)];
                        *lpz = lzi >> 16;
                    }
                }
 
                lpdest++;
                lzi += r_zistepx;
                lpz++;
                llight += r_lstepx;
                lptex += a_ststepxwhole;
                lsfrac += a_sstepxfrac;
                lptex += lsfrac >> 16;
                lsfrac &= 0xFFFF;
                ltfrac += a_tstepxfrac;
                if (ltfrac & 0x10000)
                {
                    lptex += r_affinetridesc.skinwidth;
                    ltfrac &= 0xFFFF;
                }
            } while (--lcount);
        }
 
        pspanpackage++;
    } while (pspanpackage->count != -999999);
}

R_PolysetFillSpans8()

void R_PolysetFillSpans8

(

spanpackage_t *

pspanpackage

)

Definition at line 1114 of file r_polyse.c.

{
    int             color;
 
// FIXME: do z buffering
 
    color = d_aflatcolor++;
 
    while (1)
    {
        int     lcount;
        byte    *lpdest;
 
        lcount = pspanpackage->count;
 
        if (lcount == -1)
            return;
 
        if (lcount)
        {
            lpdest = pspanpackage->pdest;
 
            do
            {
                *lpdest++ = color;
            } while (--lcount);
        }
 
        pspanpackage++;
    }
}

R_PolysetScanLeftEdge()

void R_PolysetScanLeftEdge

(

int

height

)

Referenced by R_RasterizeAliasPolySmooth().

R_PolysetScanLeftEdge_C()

void R_PolysetScanLeftEdge_C

(

int

height

)

Definition at line 266 of file r_polyse.c.

{
    do
    {
        d_pedgespanpackage->pdest = d_pdest;
        d_pedgespanpackage->pz = d_pz;
        d_pedgespanpackage->count = d_aspancount;
        d_pedgespanpackage->ptex = d_ptex;
 
        d_pedgespanpackage->sfrac = d_sfrac;
        d_pedgespanpackage->tfrac = d_tfrac;
 
    // FIXME: need to clamp l, s, t, at both ends?
        d_pedgespanpackage->light = d_light;
        d_pedgespanpackage->zi = d_zi;
 
        d_pedgespanpackage++;
 
        errorterm += erroradjustup;
        if (errorterm >= 0)
        {
            d_pdest += d_pdestextrastep;
            d_pz += d_pzextrastep;
            d_aspancount += d_countextrastep;
            d_ptex += d_ptexextrastep;
            d_sfrac += d_sfracextrastep;
            d_ptex += d_sfrac >> 16;
 
            d_sfrac &= 0xFFFF;
            d_tfrac += d_tfracextrastep;
            if (d_tfrac & 0x10000)
            {
                d_ptex += r_affinetridesc.skinwidth;
                d_tfrac &= 0xFFFF;
            }
            d_light += d_lightextrastep;
            d_zi += d_ziextrastep;
            errorterm -= erroradjustdown;
        }
        else
        {
            d_pdest += d_pdestbasestep;
            d_pz += d_pzbasestep;
            d_aspancount += ubasestep;
            d_ptex += d_ptexbasestep;
            d_sfrac += d_sfracbasestep;
            d_ptex += d_sfrac >> 16;
            d_sfrac &= 0xFFFF;
            d_tfrac += d_tfracbasestep;
            if (d_tfrac & 0x10000)
            {
                d_ptex += r_affinetridesc.skinwidth;
                d_tfrac &= 0xFFFF;
            }
            d_light += d_lightbasestep;
            d_zi += d_zibasestep;
        }
    } while (--height);
}

Referenced by R_RasterizeAliasPolySmooth().

R_PolysetSetEdgeTable()

void R_PolysetSetEdgeTable

(

void

)

Definition at line 1483 of file r_polyse.c.

{
    int         edgetableindex;
 
    edgetableindex = 0; // assume the vertices are already in
                        //  top to bottom order
 
//
// determine which edges are right & left, and the order in which
// to rasterize them
//
    if (r_p0[1] >= r_p1[1])
    {
        if (r_p0[1] == r_p1[1])
        {
            if (r_p0[1] < r_p2[1])
                pedgetable = &edgetables[2];
            else
                pedgetable = &edgetables[5];
 
            return;
        }
        else
        {
            edgetableindex = 1;
        }
    }
 
    if (r_p0[1] == r_p2[1])
    {
        if (edgetableindex)
            pedgetable = &edgetables[8];
        else
            pedgetable = &edgetables[9];
 
        return;
    }
    else if (r_p1[1] == r_p2[1])
    {
        if (edgetableindex)
            pedgetable = &edgetables[10];
        else
            pedgetable = &edgetables[11];
 
        return;
    }
 
    if (r_p0[1] > r_p2[1])
        edgetableindex += 2;
 
    if (r_p1[1] > r_p2[1])
        edgetableindex += 4;
 
    pedgetable = &edgetables[edgetableindex];
}

Referenced by R_DrawTriangle().

R_PolysetSetUpForLineScan()

void R_PolysetSetUpForLineScan	(	fixed8_t	startvertu,
		fixed8_t	startvertv,
		fixed8_t	endvertu,
		fixed8_t	endvertv
	)

Definition at line 374 of file r_polyse.c.

{
    float       dm, dn;
    int         tm, tn;
    adivtab_t   *ptemp;
 
// TODO: implement x86 version
 
    errorterm = -1;
 
    tm = endvertu - startvertu;
    tn = endvertv - startvertv;
 
    if (((tm <= 16) && (tm >= -15)) &&
        ((tn <= 16) && (tn >= -15)))
    {
        ptemp = &adivtab[((tm+15) << 5) + (tn+15)];
        ubasestep = ptemp->quotient;
        erroradjustup = ptemp->remainder;
        erroradjustdown = tn;
    }
    else
    {
        dm = tm;
        dn = tn;
 
        FloorDivMod (dm, dn, &ubasestep, &erroradjustup);
 
        erroradjustdown = dn;
    }
}

Referenced by R_RasterizeAliasPolySmooth().

R_PolysetUpdateTables()

void R_PolysetUpdateTables

(

void

)

Definition at line 182 of file r_polyse.c.

{
    int     i;
    byte    *s;
    
    if (r_affinetridesc.skinwidth != skinwidth ||
        r_affinetridesc.pskin != skinstart)
    {
        skinwidth = r_affinetridesc.skinwidth;
        skinstart = r_affinetridesc.pskin;
        s = skinstart;
        for (i=0 ; i<MAX_LBM_HEIGHT ; i++, s+=skinwidth)
            skintable[i] = s;
    }
}

Referenced by R_AliasSetupSkin().

R_RasterizeAliasPolySmooth()

void R_RasterizeAliasPolySmooth

(

void

)

Definition at line 1151 of file r_polyse.c.

{
    int             initialleftheight, initialrightheight;
    int             *plefttop, *prighttop, *pleftbottom, *prightbottom;
    int             working_lstepx, originalcount;
 
    plefttop = pedgetable->pleftedgevert0;
    prighttop = pedgetable->prightedgevert0;
 
    pleftbottom = pedgetable->pleftedgevert1;
    prightbottom = pedgetable->prightedgevert1;
 
    initialleftheight = pleftbottom[1] - plefttop[1];
    initialrightheight = prightbottom[1] - prighttop[1];
 
//
// set the s, t, and light gradients, which are consistent across the triangle
// because being a triangle, things are affine
//
    R_PolysetCalcGradients (r_affinetridesc.skinwidth);
//
// rasterize the polygon
//
 
//
// scan out the top (and possibly only) part of the left edge
//
    d_pedgespanpackage = a_spans;
 
    ystart = plefttop[1];
    d_aspancount = plefttop[0] - prighttop[0];
 
    d_ptex = (byte *)r_affinetridesc.pskin + (plefttop[2] >> 16) +
            (plefttop[3] >> 16) * r_affinetridesc.skinwidth;
//#if   id386ALIAS
#if id386
    if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
    {
        d_sfrac = (plefttop[2] & 0xFFFF) << 16;
        d_tfrac = (plefttop[3] & 0xFFFF) << 16;
    }
//#else
    else
#endif
    {
        d_sfrac = plefttop[2] & 0xFFFF;
        d_tfrac = plefttop[3] & 0xFFFF;
    }
//#endif
    d_light = plefttop[4];
    d_zi = plefttop[5];
 
    d_pdest = (byte *)d_viewbuffer +
            ystart * r_screenwidth + plefttop[0];
    d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0];
 
    if (initialleftheight == 1)
    {
        d_pedgespanpackage->pdest = d_pdest;
        d_pedgespanpackage->pz = d_pz;
        d_pedgespanpackage->count = d_aspancount;
        d_pedgespanpackage->ptex = d_ptex;
 
        d_pedgespanpackage->sfrac = d_sfrac;
        d_pedgespanpackage->tfrac = d_tfrac;
 
    // FIXME: need to clamp l, s, t, at both ends?
        d_pedgespanpackage->light = d_light;
        d_pedgespanpackage->zi = d_zi;
 
        d_pedgespanpackage++;
    }
    else
    {
        R_PolysetSetUpForLineScan(plefttop[0], plefttop[1],
                              pleftbottom[0], pleftbottom[1]);
 
//#if   id386ALIAS
#if id386
        if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
        {
            d_pzbasestep = (d_zwidth + ubasestep) << 1;
            d_pzextrastep = d_pzbasestep + 2;
        }
//#else
        else
#endif
        {
            d_pzbasestep = d_zwidth + ubasestep;
            d_pzextrastep = d_pzbasestep + 1;
        }
//#endif
 
        d_pdestbasestep = r_screenwidth + ubasestep;
        d_pdestextrastep = d_pdestbasestep + 1;
 
    // TODO: can reuse partial expressions here
 
    // for negative steps in x along left edge, bias toward overflow rather than
    // underflow (sort of turning the floor () we did in the gradient calcs into
    // ceil (), but plus a little bit)
        if (ubasestep < 0)
            working_lstepx = r_lstepx - 1;
        else
            working_lstepx = r_lstepx;
 
        d_countextrastep = ubasestep + 1;
        d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) +
                ((r_tstepy + r_tstepx * ubasestep) >> 16) *
                r_affinetridesc.skinwidth;
//#if   id386ALIAS
#if id386
        if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
        {
            d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16;
            d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16;
        }
        else
#endif
        {
//#else
            d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF;
            d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF;
        }
//#endif
        d_lightbasestep = r_lstepy + working_lstepx * ubasestep;
        d_zibasestep = r_zistepy + r_zistepx * ubasestep;
 
        d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) +
                ((r_tstepy + r_tstepx * d_countextrastep) >> 16) *
                r_affinetridesc.skinwidth;
//#if   id386ALIAS
#if id386
        if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
        {
            d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) << 16;
            d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) << 16;
        }
        else
#endif
        {
//#else
            d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) & 0xFFFF;
            d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) & 0xFFFF;
        }
//#endif
        d_lightextrastep = d_lightbasestep + working_lstepx;
        d_ziextrastep = d_zibasestep + r_zistepx;
 
#if id386
        if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
        {
            R_PolysetScanLeftEdge (initialleftheight);
        }
        else
#endif
        {
            R_PolysetScanLeftEdge_C(initialleftheight);
        }
    }
 
//
// scan out the bottom part of the left edge, if it exists
//
    if (pedgetable->numleftedges == 2)
    {
        int     height;
 
        plefttop = pleftbottom;
        pleftbottom = pedgetable->pleftedgevert2;
 
        height = pleftbottom[1] - plefttop[1];
 
// TODO: make this a function; modularize this function in general
 
        ystart = plefttop[1];
        d_aspancount = plefttop[0] - prighttop[0];
        d_ptex = (byte *)r_affinetridesc.pskin + (plefttop[2] >> 16) +
                (plefttop[3] >> 16) * r_affinetridesc.skinwidth;
        d_sfrac = 0;
        d_tfrac = 0;
        d_light = plefttop[4];
        d_zi = plefttop[5];
 
        d_pdest = (byte *)d_viewbuffer + ystart * r_screenwidth + plefttop[0];
        d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0];
 
        if (height == 1)
        {
            d_pedgespanpackage->pdest = d_pdest;
            d_pedgespanpackage->pz = d_pz;
            d_pedgespanpackage->count = d_aspancount;
            d_pedgespanpackage->ptex = d_ptex;
 
            d_pedgespanpackage->sfrac = d_sfrac;
            d_pedgespanpackage->tfrac = d_tfrac;
 
        // FIXME: need to clamp l, s, t, at both ends?
            d_pedgespanpackage->light = d_light;
            d_pedgespanpackage->zi = d_zi;
 
            d_pedgespanpackage++;
        }
        else
        {
            R_PolysetSetUpForLineScan(plefttop[0], plefttop[1],
                                  pleftbottom[0], pleftbottom[1]);
 
            d_pdestbasestep = r_screenwidth + ubasestep;
            d_pdestextrastep = d_pdestbasestep + 1;
 
//#if   id386ALIAS
#if id386
            if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
            {
                d_pzbasestep = (d_zwidth + ubasestep) << 1;
                d_pzextrastep = d_pzbasestep + 2;
            }
//#else
            else
#endif
            {
                d_pzbasestep = d_zwidth + ubasestep;
                d_pzextrastep = d_pzbasestep + 1;
            }
//#endif
 
            if (ubasestep < 0)
                working_lstepx = r_lstepx - 1;
            else
                working_lstepx = r_lstepx;
 
            d_countextrastep = ubasestep + 1;
            d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) +
                    ((r_tstepy + r_tstepx * ubasestep) >> 16) *
                    r_affinetridesc.skinwidth;
//#if   id386ALIAS
#if id386
            if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
            {
                d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) << 16;
                d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) << 16;
            }
//#else
            else
#endif
            {
                d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF;
                d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF;
            }
//#endif
            d_lightbasestep = r_lstepy + working_lstepx * ubasestep;
            d_zibasestep = r_zistepy + r_zistepx * ubasestep;
 
            d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) +
                    ((r_tstepy + r_tstepx * d_countextrastep) >> 16) *
                    r_affinetridesc.skinwidth;
//#if   id386ALIAS
#if id386
            if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
            {
                d_sfracextrastep = ((r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF)<<16;
                d_tfracextrastep = ((r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF)<<16;
            }
            else
#endif
//#endif
            {
                d_sfracextrastep = (r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF;
                d_tfracextrastep = (r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF;
            }
//#endif
            d_lightextrastep = d_lightbasestep + working_lstepx;
            d_ziextrastep = d_zibasestep + r_zistepx;
 
#if id386
            if ( d_pdrawspans == R_PolysetDrawSpans8_Opaque )
            {
                R_PolysetScanLeftEdge (height);
            }
            else
#endif
            {
                R_PolysetScanLeftEdge_C(height);
            }
        }
    }
 
// scan out the top (and possibly only) part of the right edge, updating the
// count field
    d_pedgespanpackage = a_spans;
 
    R_PolysetSetUpForLineScan(prighttop[0], prighttop[1],
                          prightbottom[0], prightbottom[1]);
    d_aspancount = 0;
    d_countextrastep = ubasestep + 1;
    originalcount = a_spans[initialrightheight].count;
    a_spans[initialrightheight].count = -999999; // mark end of the spanpackages
    (*d_pdrawspans) (a_spans);
 
// scan out the bottom part of the right edge, if it exists
    if (pedgetable->numrightedges == 2)
    {
        int             height;
        spanpackage_t   *pstart;
 
        pstart = a_spans + initialrightheight;
        pstart->count = originalcount;
 
        d_aspancount = prightbottom[0] - prighttop[0];
 
        prighttop = prightbottom;
        prightbottom = pedgetable->prightedgevert2;
 
        height = prightbottom[1] - prighttop[1];
 
        R_PolysetSetUpForLineScan(prighttop[0], prighttop[1],
                              prightbottom[0], prightbottom[1]);
 
        d_countextrastep = ubasestep + 1;
        a_spans[initialrightheight + height].count = -999999;
                                            // mark end of the spanpackages
        (*d_pdrawspans) (pstart);
    }
}

Referenced by R_DrawTriangle().

Variable Documentation

a_spans

spanpackage_t* a_spans

Definition at line 91 of file r_polyse.c.

Referenced by R_DrawTriangle(), and R_RasterizeAliasPolySmooth().

a_sstepxfrac

int a_sstepxfrac

Definition at line 86 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), and R_PolysetDrawThreshSpans8().

a_ststepxwhole

int a_ststepxwhole

Definition at line 86 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), and R_PolysetDrawThreshSpans8().

a_tstepxfrac

int a_tstepxfrac

Definition at line 86 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), and R_PolysetDrawThreshSpans8().

adivtab

adivtab_t adivtab[32 *32]

static

Initial value:

= {
}

Definition at line 109 of file r_polyse.c.

Referenced by R_PolysetSetUpForLineScan().

aliastriangleparms

aliastriangleparms_t aliastriangleparms

Definition at line 59 of file r_polyse.c.

Referenced by R_AliasClipTriangle(), R_AliasPreparePoints(), and R_DrawTriangle().

d_aflatcolor

int d_aflatcolor

Definition at line 65 of file r_polyse.c.

Referenced by R_PolysetFillSpans8(), and R_SetupFrame().

d_aspancount

int d_aspancount

Definition at line 89 of file r_polyse.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_RasterizeAliasPolySmooth().

d_countextrastep

int d_countextrastep

Definition at line 89 of file r_polyse.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_RasterizeAliasPolySmooth().

d_light

int d_light

Definition at line 96 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_lightbasestep

int d_lightbasestep

Definition at line 99 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_lightextrastep

int d_lightextrastep

Definition at line 98 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_pcolormap

byte* d_pcolormap

Definition at line 63 of file r_polyse.c.

d_pdest

byte* d_pdest

Definition at line 94 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_pdestbasestep

int d_pdestbasestep

Definition at line 99 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_pdestextrastep

int d_pdestextrastep

Definition at line 98 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_pdrawspans

void(* d_pdrawspans) (spanpackage_t *pspanpackage)

Definition at line 117 of file r_polyse.c.

Referenced by R_AliasDrawModel(), R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

d_pedgespanpackage

spanpackage_t* d_pedgespanpackage

Definition at line 92 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_ptex

byte * d_ptex

Definition at line 94 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_ptexbasestep

int d_ptexbasestep

Definition at line 99 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_ptexextrastep

int d_ptexextrastep

Definition at line 97 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_pz

short* d_pz

Definition at line 95 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_pzbasestep

int d_pzbasestep

Definition at line 102 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_pzextrastep

int d_pzextrastep

Definition at line 102 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_sfrac

int d_sfrac

Definition at line 96 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_sfracbasestep

int d_sfracbasestep

Definition at line 100 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_sfracextrastep

int d_sfracextrastep

Definition at line 97 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_tfrac

int d_tfrac

Definition at line 96 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_tfracbasestep

int d_tfracbasestep

Definition at line 100 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_tfracextrastep

int d_tfracextrastep

Definition at line 98 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_xdenom

int d_xdenom

Definition at line 66 of file r_polyse.c.

Referenced by R_DrawTriangle(), and R_PolysetCalcGradients().

d_zi

int d_zi

Definition at line 96 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_zibasestep

int d_zibasestep

Definition at line 101 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

d_ziextrastep

int d_ziextrastep

Definition at line 101 of file r_polyse.c.

Referenced by R_PolysetScanLeftEdge_C(), and R_RasterizeAliasPolySmooth().

edgetables

edgetable edgetables[12]

Initial value:

= {
    {0, 1, r_p0, r_p2, NULL, 2, r_p0, r_p1, r_p2 },
    {0, 2, r_p1, r_p0, r_p2,   1, r_p1, r_p2, NULL},
    {1, 1, r_p0, r_p2, NULL, 1, r_p1, r_p2, NULL},
    {0, 1, r_p1, r_p0, NULL, 2, r_p1, r_p2, r_p0 },
    {0, 2, r_p0, r_p2, r_p1,   1, r_p0, r_p1, NULL},
    {0, 1, r_p2, r_p1, NULL, 1, r_p2, r_p0, NULL},
    {0, 1, r_p2, r_p1, NULL, 2, r_p2, r_p0, r_p1 },
    {0, 2, r_p2, r_p1, r_p0,   1, r_p2, r_p0, NULL},
    {0, 1, r_p1, r_p0, NULL, 1, r_p1, r_p2, NULL},
    {1, 1, r_p2, r_p1, NULL, 1, r_p0, r_p1, NULL},
    {1, 1, r_p1, r_p0, NULL, 1, r_p2, r_p0, NULL},
    {0, 1, r_p0, r_p2, NULL, 1, r_p0, r_p1, NULL},
}

Definition at line 70 of file r_polyse.c.

Referenced by R_PolysetSetEdgeTable().

iractive

byte iractive = 0

Definition at line 134 of file r_polyse.c.

Referenced by R_AliasPreparePoints().

irtable

byte irtable[256]

Definition at line 135 of file r_polyse.c.

Referenced by R_PolysetDrawSpans8_Opaque().

pedgetable

edgetable* pedgetable

Definition at line 68 of file r_polyse.c.

Referenced by R_PolysetSetEdgeTable(), and R_RasterizeAliasPolySmooth().

r_lstepx

int r_lstepx

Definition at line 86 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), R_PolysetDrawSpans8_33(), R_PolysetDrawSpans8_66(), R_PolysetDrawSpans8_Opaque(), R_PolysetDrawThreshSpans8(), and R_RasterizeAliasPolySmooth().

r_lstepy

int r_lstepy

Definition at line 87 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

r_p0

int r_p0[6]

Definition at line 61 of file r_polyse.c.

Referenced by R_DrawTriangle(), R_PolysetCalcGradients(), and R_PolysetSetEdgeTable().

r_p1

int r_p1[6]

Definition at line 61 of file r_polyse.c.

Referenced by R_DrawTriangle(), R_PolysetCalcGradients(), and R_PolysetSetEdgeTable().

r_p2

int r_p2[6]

Definition at line 61 of file r_polyse.c.

Referenced by R_DrawTriangle(), R_PolysetCalcGradients(), and R_PolysetSetEdgeTable().

r_sstepx

int r_sstepx

Definition at line 87 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

r_sstepy

int r_sstepy

Definition at line 87 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

r_tstepx

int r_tstepx

Definition at line 87 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

r_tstepy

int r_tstepy

Definition at line 87 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

r_zistepx

int r_zistepx

Definition at line 88 of file r_polyse.c.

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

r_zistepy

int r_zistepy

Definition at line 88 of file r_polyse.c.

Referenced by R_PolysetCalcGradients(), and R_RasterizeAliasPolySmooth().

rand1k

int rand1k[]

Initial value:

= {
}

Definition at line 25 of file r_polyse.c.

Referenced by R_PolysetDrawThreshSpans8().

rand1k_index

int rand1k_index = 0

Definition at line 31 of file r_polyse.c.

Referenced by R_PolysetDrawThreshSpans8().

skinstart

byte* skinstart

Definition at line 115 of file r_polyse.c.

Referenced by R_PolysetUpdateTables().

skintable

byte* skintable[MAX_LBM_HEIGHT]

Definition at line 113 of file r_polyse.c.

Referenced by R_PolysetUpdateTables().

skinwidth

int skinwidth

Definition at line 114 of file r_polyse.c.

Referenced by R_FloodFillSkin(), R_PolysetCalcGradients(), and R_PolysetUpdateTables().

ystart

int ystart

static

Definition at line 93 of file r_polyse.c.

Referenced by M_Main_Draw(), and R_RasterizeAliasPolySmooth().