Return to d_init.c CVS log

Up to [Quake] / quake1

Annotation of quake1/d_init.c, revision 1.1.1.3

1.1       root        1: // d_init.c: rasterization driver initialization
                      2: 
                      3: #include "quakedef.h"
                      4: #include "d_local.h"
                      5: 
                      6: #define NUM_MIPS       4
                      7: 
                      8: cvar_t d_subdiv16 = {"d_subdiv16", "1"};
                      9: cvar_t d_mipcap = {"d_mipcap", "0"};
                     10: cvar_t d_mipscale = {"d_mipscale", "1"};
                     11: 
                     12: surfcache_t            *d_initial_rover;
                     13: qboolean               d_roverwrapped;
                     14: int                            d_minmip;
                     15: float                  d_scalemip[NUM_MIPS-1];
                     16: 
                     17: static float   basemip[NUM_MIPS-1] = {1.0, 0.5*0.8, 0.25*0.8};
                     18: 
                     19: extern int                     d_aflatcolor;
                     20: 
                     21: void (*d_drawspans) (espan_t *pspan);
                     22: 
                     23: 
                     24: /*
                     25: ===============
                     26: D_Init
                     27: ===============
                     28: */
                     29: void D_Init (void)
                     30: {
                     31: 
                     32:        r_skydirect = 1;
                     33: 
                     34:        Cvar_RegisterVariable (&d_subdiv16);
                     35:        Cvar_RegisterVariable (&d_mipcap);
                     36:        Cvar_RegisterVariable (&d_mipscale);
                     37: 
                     38:        r_drawpolys = false;
                     39:        r_worldpolysbacktofront = false;
                     40:        r_recursiveaffinetriangles = true;
                     41:        r_pixbytes = 1;
                     42:        r_aliasuvscale = 1.0;
                     43: }
                     44: 
                     45: 
                     46: /*
                     47: ===============
                     48: D_CopyRects
                     49: ===============
                     50: */
                     51: void D_CopyRects (vrect_t *prects, int transparent)
                     52: {
                     53: 
                     54: // this function is only required if the CPU doesn't have direct access to the
                     55: // back buffer, and there's some driver interface function that the driver
                     56: // doesn't support and requires Quake to do in software (such as drawing the
                     57: // console); Quake will then draw into wherever the driver points vid.buffer
                     58: // and will call this function before swapping buffers
                     59: 
                     60:        UNUSED(prects);
                     61:        UNUSED(transparent);
                     62: }
                     63: 
                     64: 
                     65: /*
                     66: ===============
                     67: D_EnableBackBufferAccess
                     68: ===============
                     69: */
                     70: void D_EnableBackBufferAccess (void)
                     71: {
1.1.1.3 ! root       72:        VID_LockBuffer ();
1.1       root       73: }
                     74: 
                     75: 
                     76: /*
                     77: ===============
                     78: D_TurnZOn
                     79: ===============
                     80: */
                     81: void D_TurnZOn (void)
                     82: {
                     83: // not needed for software version
                     84: }
                     85: 
                     86: 
                     87: /*
                     88: ===============
                     89: D_DisableBackBufferAccess
                     90: ===============
                     91: */
                     92: void D_DisableBackBufferAccess (void)
                     93: {
1.1.1.3 ! root       94:        VID_UnlockBuffer ();
1.1       root       95: }
                     96: 
                     97: 
                     98: /*
                     99: ===============
                    100: D_SetupFrame
                    101: ===============
                    102: */
                    103: void D_SetupFrame (void)
                    104: {
                    105:        int             i;
                    106: 
                    107:        if (r_dowarp)
                    108:                d_viewbuffer = r_warpbuffer;
                    109:        else
                    110:                d_viewbuffer = (void *)(byte *)vid.buffer;
                    111: 
                    112:        if (r_dowarp)
                    113:                screenwidth = WARP_WIDTH;
                    114:        else
                    115:                screenwidth = vid.rowbytes;
                    116: 
                    117:        d_roverwrapped = false;
                    118:        d_initial_rover = sc_rover;
                    119: 
                    120:        d_minmip = d_mipcap.value;
                    121:        if (d_minmip > 3)
                    122:                d_minmip = 3;
                    123:        else if (d_minmip < 0)
                    124:                d_minmip = 0;
                    125: 
                    126:        for (i=0 ; i<(NUM_MIPS-1) ; i++)
                    127:                d_scalemip[i] = basemip[i] * d_mipscale.value;
                    128: 
1.1.1.3 ! root      129: #if    id386
1.1       root      130:                                if (d_subdiv16.value)
                    131:                                        d_drawspans = D_DrawSpans16;
                    132:                                else
                    133:                                        d_drawspans = D_DrawSpans8;
                    134: #else
                    135:                                d_drawspans = D_DrawSpans8;
                    136: #endif
                    137: 
                    138:        d_aflatcolor = 0;
                    139: }
                    140: 
                    141: 
                    142: /*
                    143: ===============
                    144: D_UpdateRects
                    145: ===============
                    146: */
                    147: void D_UpdateRects (vrect_t *prect)
                    148: {
                    149: 
                    150: // the software driver draws these directly to the vid buffer
                    151: 
                    152:        UNUSED(prect);
                    153: }
                    154: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.