Return to d_scan.c CVS log

Up to [Quake] / quakeworld / client

Annotation of quakeworld/client/d_scan.c, revision 1.1

1.1     ! root        1: /*
        !             2: Copyright (C) 1996-1997 Id Software, Inc.
        !             3: 
        !             4: This program is free software; you can redistribute it and/or
        !             5: modify it under the terms of the GNU General Public License
        !             6: as published by the Free Software Foundation; either version 2
        !             7: of the License, or (at your option) any later version.
        !             8: 
        !             9: This program is distributed in the hope that it will be useful,
        !            10: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
        !            12: 
        !            13: See the GNU General Public License for more details.
        !            14: 
        !            15: You should have received a copy of the GNU General Public License
        !            16: along with this program; if not, write to the Free Software
        !            17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
        !            18: 
        !            19: */
        !            20: // d_scan.c
        !            21: //
        !            22: // Portable C scan-level rasterization code, all pixel depths.
        !            23: 
        !            24: #include "quakedef.h"
        !            25: #include "r_local.h"
        !            26: #include "d_local.h"
        !            27: 
        !            28: unsigned char  *r_turb_pbase, *r_turb_pdest;
        !            29: fixed16_t              r_turb_s, r_turb_t, r_turb_sstep, r_turb_tstep;
        !            30: int                            *r_turb_turb;
        !            31: int                            r_turb_spancount;
        !            32: 
        !            33: void D_DrawTurbulent8Span (void);
        !            34: 
        !            35: 
        !            36: /*
        !            37: =============
        !            38: D_WarpScreen
        !            39: 
        !            40: // this performs a slight compression of the screen at the same time as
        !            41: // the sine warp, to keep the edges from wrapping
        !            42: =============
        !            43: */
        !            44: void D_WarpScreen (void)
        !            45: {
        !            46:        int             w, h;
        !            47:        int             u,v;
        !            48:        byte    *dest;
        !            49:        int             *turb;
        !            50:        int             *col;
        !            51:        byte    **row;
        !            52:        byte    *rowptr[1024];
        !            53:        int             column[1280];
        !            54:        float   wratio, hratio;
        !            55: 
        !            56:        w = r_refdef.vrect.width;
        !            57:        h = r_refdef.vrect.height;
        !            58: 
        !            59:        wratio = w / (float)scr_vrect.width;
        !            60:        hratio = h / (float)scr_vrect.height;
        !            61: 
        !            62:        for (v=0 ; v<scr_vrect.height+AMP2*2 ; v++)
        !            63:        {
        !            64:                rowptr[v] = d_viewbuffer + (r_refdef.vrect.y * screenwidth) +
        !            65:                                 (screenwidth * (int)((float)v * hratio * h / (h + AMP2 * 2)));
        !            66:        }
        !            67: 
        !            68:        for (u=0 ; u<scr_vrect.width+AMP2*2 ; u++)
        !            69:        {
        !            70:                column[u] = r_refdef.vrect.x +
        !            71:                                (int)((float)u * wratio * w / (w + AMP2 * 2));
        !            72:        }
        !            73: 
        !            74:        turb = intsintable + ((int)(cl.time*SPEED)&(CYCLE-1));
        !            75:        dest = vid.buffer + scr_vrect.y * vid.rowbytes + scr_vrect.x;
        !            76: 
        !            77:        for (v=0 ; v<scr_vrect.height ; v++, dest += vid.rowbytes)
        !            78:        {
        !            79:                col = &column[turb[v]];
        !            80:                row = &rowptr[v];
        !            81:                for (u=0 ; u<scr_vrect.width ; u+=4)
        !            82:                {
        !            83:                        dest[u+0] = row[turb[u+0]][col[u+0]];
        !            84:                        dest[u+1] = row[turb[u+1]][col[u+1]];
        !            85:                        dest[u+2] = row[turb[u+2]][col[u+2]];
        !            86:                        dest[u+3] = row[turb[u+3]][col[u+3]];
        !            87:                }
        !            88:        }
        !            89: }
        !            90: 
        !            91: 
        !            92: #if    !id386
        !            93: 
        !            94: /*
        !            95: =============
        !            96: D_DrawTurbulent8Span
        !            97: =============
        !            98: */
        !            99: void D_DrawTurbulent8Span (void)
        !           100: {
        !           101:        int             sturb, tturb;
        !           102: 
        !           103:        do
        !           104:        {
        !           105:                sturb = ((r_turb_s + r_turb_turb[(r_turb_t>>16)&(CYCLE-1)])>>16)&63;
        !           106:                tturb = ((r_turb_t + r_turb_turb[(r_turb_s>>16)&(CYCLE-1)])>>16)&63;
        !           107:                *r_turb_pdest++ = *(r_turb_pbase + (tturb<<6) + sturb);
        !           108:                r_turb_s += r_turb_sstep;
        !           109:                r_turb_t += r_turb_tstep;
        !           110:        } while (--r_turb_spancount > 0);
        !           111: }
        !           112: 
        !           113: #endif // !id386
        !           114: 
        !           115: /*
        !           116: =============
        !           117: Turbulent8
        !           118: =============
        !           119: */
        !           120: void Turbulent8 (espan_t *pspan)
        !           121: {
        !           122:        int                             count;
        !           123:        fixed16_t               snext, tnext;
        !           124:        float                   sdivz, tdivz, zi, z, du, dv, spancountminus1;
        !           125:        float                   sdivz16stepu, tdivz16stepu, zi16stepu;
        !           126:        
        !           127:        r_turb_turb = sintable + ((int)(cl.time*SPEED)&(CYCLE-1));
        !           128: 
        !           129:        r_turb_sstep = 0;       // keep compiler happy
        !           130:        r_turb_tstep = 0;       // ditto
        !           131: 
        !           132:        r_turb_pbase = (unsigned char *)cacheblock;
        !           133: 
        !           134:        sdivz16stepu = d_sdivzstepu * 16;
        !           135:        tdivz16stepu = d_tdivzstepu * 16;
        !           136:        zi16stepu = d_zistepu * 16;
        !           137: 
        !           138:        do
        !           139:        {
        !           140:                r_turb_pdest = (unsigned char *)((byte *)d_viewbuffer +
        !           141:                                (screenwidth * pspan->v) + pspan->u);
        !           142: 
        !           143:                count = pspan->count;
        !           144: 
        !           145:        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
        !           146:                du = (float)pspan->u;
        !           147:                dv = (float)pspan->v;
        !           148: 
        !           149:                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
        !           150:                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
        !           151:                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
        !           152:                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
        !           153: 
        !           154:                r_turb_s = (int)(sdivz * z) + sadjust;
        !           155:                if (r_turb_s > bbextents)
        !           156:                        r_turb_s = bbextents;
        !           157:                else if (r_turb_s < 0)
        !           158:                        r_turb_s = 0;
        !           159: 
        !           160:                r_turb_t = (int)(tdivz * z) + tadjust;
        !           161:                if (r_turb_t > bbextentt)
        !           162:                        r_turb_t = bbextentt;
        !           163:                else if (r_turb_t < 0)
        !           164:                        r_turb_t = 0;
        !           165: 
        !           166:                do
        !           167:                {
        !           168:                // calculate s and t at the far end of the span
        !           169:                        if (count >= 16)
        !           170:                                r_turb_spancount = 16;
        !           171:                        else
        !           172:                                r_turb_spancount = count;
        !           173: 
        !           174:                        count -= r_turb_spancount;
        !           175: 
        !           176:                        if (count)
        !           177:                        {
        !           178:                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
        !           179:                        // calculate s and t steps across span by shifting
        !           180:                                sdivz += sdivz16stepu;
        !           181:                                tdivz += tdivz16stepu;
        !           182:                                zi += zi16stepu;
        !           183:                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
        !           184: 
        !           185:                                snext = (int)(sdivz * z) + sadjust;
        !           186:                                if (snext > bbextents)
        !           187:                                        snext = bbextents;
        !           188:                                else if (snext < 16)
        !           189:                                        snext = 16;     // prevent round-off error on <0 steps from
        !           190:                                                                //  from causing overstepping & running off the
        !           191:                                                                //  edge of the texture
        !           192: 
        !           193:                                tnext = (int)(tdivz * z) + tadjust;
        !           194:                                if (tnext > bbextentt)
        !           195:                                        tnext = bbextentt;
        !           196:                                else if (tnext < 16)
        !           197:                                        tnext = 16;     // guard against round-off error on <0 steps
        !           198: 
        !           199:                                r_turb_sstep = (snext - r_turb_s) >> 4;
        !           200:                                r_turb_tstep = (tnext - r_turb_t) >> 4;
        !           201:                        }
        !           202:                        else
        !           203:                        {
        !           204:                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
        !           205:                        // can't step off polygon), clamp, calculate s and t steps across
        !           206:                        // span by division, biasing steps low so we don't run off the
        !           207:                        // texture
        !           208:                                spancountminus1 = (float)(r_turb_spancount - 1);
        !           209:                                sdivz += d_sdivzstepu * spancountminus1;
        !           210:                                tdivz += d_tdivzstepu * spancountminus1;
        !           211:                                zi += d_zistepu * spancountminus1;
        !           212:                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
        !           213:                                snext = (int)(sdivz * z) + sadjust;
        !           214:                                if (snext > bbextents)
        !           215:                                        snext = bbextents;
        !           216:                                else if (snext < 16)
        !           217:                                        snext = 16;     // prevent round-off error on <0 steps from
        !           218:                                                                //  from causing overstepping & running off the
        !           219:                                                                //  edge of the texture
        !           220: 
        !           221:                                tnext = (int)(tdivz * z) + tadjust;
        !           222:                                if (tnext > bbextentt)
        !           223:                                        tnext = bbextentt;
        !           224:                                else if (tnext < 16)
        !           225:                                        tnext = 16;     // guard against round-off error on <0 steps
        !           226: 
        !           227:                                if (r_turb_spancount > 1)
        !           228:                                {
        !           229:                                        r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1);
        !           230:                                        r_turb_tstep = (tnext - r_turb_t) / (r_turb_spancount - 1);
        !           231:                                }
        !           232:                        }
        !           233: 
        !           234:                        r_turb_s = r_turb_s & ((CYCLE<<16)-1);
        !           235:                        r_turb_t = r_turb_t & ((CYCLE<<16)-1);
        !           236: 
        !           237:                        D_DrawTurbulent8Span ();
        !           238: 
        !           239:                        r_turb_s = snext;
        !           240:                        r_turb_t = tnext;
        !           241: 
        !           242:                } while (count > 0);
        !           243: 
        !           244:        } while ((pspan = pspan->pnext) != NULL);
        !           245: }
        !           246: 
        !           247: 
        !           248: #if    !id386
        !           249: 
        !           250: /*
        !           251: =============
        !           252: D_DrawSpans8
        !           253: =============
        !           254: */
        !           255: void D_DrawSpans8 (espan_t *pspan)
        !           256: {
        !           257:        int                             count, spancount;
        !           258:        unsigned char   *pbase, *pdest;
        !           259:        fixed16_t               s, t, snext, tnext, sstep, tstep;
        !           260:        float                   sdivz, tdivz, zi, z, du, dv, spancountminus1;
        !           261:        float                   sdivz8stepu, tdivz8stepu, zi8stepu;
        !           262: 
        !           263:        sstep = 0;      // keep compiler happy
        !           264:        tstep = 0;      // ditto
        !           265: 
        !           266:        pbase = (unsigned char *)cacheblock;
        !           267: 
        !           268:        sdivz8stepu = d_sdivzstepu * 8;
        !           269:        tdivz8stepu = d_tdivzstepu * 8;
        !           270:        zi8stepu = d_zistepu * 8;
        !           271: 
        !           272:        do
        !           273:        {
        !           274:                pdest = (unsigned char *)((byte *)d_viewbuffer +
        !           275:                                (screenwidth * pspan->v) + pspan->u);
        !           276: 
        !           277:                count = pspan->count;
        !           278: 
        !           279:        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
        !           280:                du = (float)pspan->u;
        !           281:                dv = (float)pspan->v;
        !           282: 
        !           283:                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
        !           284:                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
        !           285:                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
        !           286:                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
        !           287: 
        !           288:                s = (int)(sdivz * z) + sadjust;
        !           289:                if (s > bbextents)
        !           290:                        s = bbextents;
        !           291:                else if (s < 0)
        !           292:                        s = 0;
        !           293: 
        !           294:                t = (int)(tdivz * z) + tadjust;
        !           295:                if (t > bbextentt)
        !           296:                        t = bbextentt;
        !           297:                else if (t < 0)
        !           298:                        t = 0;
        !           299: 
        !           300:                do
        !           301:                {
        !           302:                // calculate s and t at the far end of the span
        !           303:                        if (count >= 8)
        !           304:                                spancount = 8;
        !           305:                        else
        !           306:                                spancount = count;
        !           307: 
        !           308:                        count -= spancount;
        !           309: 
        !           310:                        if (count)
        !           311:                        {
        !           312:                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
        !           313:                        // calculate s and t steps across span by shifting
        !           314:                                sdivz += sdivz8stepu;
        !           315:                                tdivz += tdivz8stepu;
        !           316:                                zi += zi8stepu;
        !           317:                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
        !           318: 
        !           319:                                snext = (int)(sdivz * z) + sadjust;
        !           320:                                if (snext > bbextents)
        !           321:                                        snext = bbextents;
        !           322:                                else if (snext < 8)
        !           323:                                        snext = 8;      // prevent round-off error on <0 steps from
        !           324:                                                                //  from causing overstepping & running off the
        !           325:                                                                //  edge of the texture
        !           326: 
        !           327:                                tnext = (int)(tdivz * z) + tadjust;
        !           328:                                if (tnext > bbextentt)
        !           329:                                        tnext = bbextentt;
        !           330:                                else if (tnext < 8)
        !           331:                                        tnext = 8;      // guard against round-off error on <0 steps
        !           332: 
        !           333:                                sstep = (snext - s) >> 3;
        !           334:                                tstep = (tnext - t) >> 3;
        !           335:                        }
        !           336:                        else
        !           337:                        {
        !           338:                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
        !           339:                        // can't step off polygon), clamp, calculate s and t steps across
        !           340:                        // span by division, biasing steps low so we don't run off the
        !           341:                        // texture
        !           342:                                spancountminus1 = (float)(spancount - 1);
        !           343:                                sdivz += d_sdivzstepu * spancountminus1;
        !           344:                                tdivz += d_tdivzstepu * spancountminus1;
        !           345:                                zi += d_zistepu * spancountminus1;
        !           346:                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
        !           347:                                snext = (int)(sdivz * z) + sadjust;
        !           348:                                if (snext > bbextents)
        !           349:                                        snext = bbextents;
        !           350:                                else if (snext < 8)
        !           351:                                        snext = 8;      // prevent round-off error on <0 steps from
        !           352:                                                                //  from causing overstepping & running off the
        !           353:                                                                //  edge of the texture
        !           354: 
        !           355:                                tnext = (int)(tdivz * z) + tadjust;
        !           356:                                if (tnext > bbextentt)
        !           357:                                        tnext = bbextentt;
        !           358:                                else if (tnext < 8)
        !           359:                                        tnext = 8;      // guard against round-off error on <0 steps
        !           360: 
        !           361:                                if (spancount > 1)
        !           362:                                {
        !           363:                                        sstep = (snext - s) / (spancount - 1);
        !           364:                                        tstep = (tnext - t) / (spancount - 1);
        !           365:                                }
        !           366:                        }
        !           367: 
        !           368:                        do
        !           369:                        {
        !           370:                                *pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
        !           371:                                s += sstep;
        !           372:                                t += tstep;
        !           373:                        } while (--spancount > 0);
        !           374: 
        !           375:                        s = snext;
        !           376:                        t = tnext;
        !           377: 
        !           378:                } while (count > 0);
        !           379: 
        !           380:        } while ((pspan = pspan->pnext) != NULL);
        !           381: }
        !           382: 
        !           383: #endif
        !           384: 
        !           385: 
        !           386: #if    !id386
        !           387: 
        !           388: /*
        !           389: =============
        !           390: D_DrawZSpans
        !           391: =============
        !           392: */
        !           393: void D_DrawZSpans (espan_t *pspan)
        !           394: {
        !           395:        int                             count, doublecount, izistep;
        !           396:        int                             izi;
        !           397:        short                   *pdest;
        !           398:        unsigned                ltemp;
        !           399:        double                  zi;
        !           400:        float                   du, dv;
        !           401: 
        !           402: // FIXME: check for clamping/range problems
        !           403: // we count on FP exceptions being turned off to avoid range problems
        !           404:        izistep = (int)(d_zistepu * 0x8000 * 0x10000);
        !           405: 
        !           406:        do
        !           407:        {
        !           408:                pdest = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
        !           409: 
        !           410:                count = pspan->count;
        !           411: 
        !           412:        // calculate the initial 1/z
        !           413:                du = (float)pspan->u;
        !           414:                dv = (float)pspan->v;
        !           415: 
        !           416:                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
        !           417:        // we count on FP exceptions being turned off to avoid range problems
        !           418:                izi = (int)(zi * 0x8000 * 0x10000);
        !           419: 
        !           420:                if ((long)pdest & 0x02)
        !           421:                {
        !           422:                        *pdest++ = (short)(izi >> 16);
        !           423:                        izi += izistep;
        !           424:                        count--;
        !           425:                }
        !           426: 
        !           427:                if ((doublecount = count >> 1) > 0)
        !           428:                {
        !           429:                        do
        !           430:                        {
        !           431:                                ltemp = izi >> 16;
        !           432:                                izi += izistep;
        !           433:                                ltemp |= izi & 0xFFFF0000;
        !           434:                                izi += izistep;
        !           435:                                *(int *)pdest = ltemp;
        !           436:                                pdest += 2;
        !           437:                        } while (--doublecount > 0);
        !           438:                }
        !           439: 
        !           440:                if (count & 1)
        !           441:                        *pdest = (short)(izi >> 16);
        !           442: 
        !           443:        } while ((pspan = pspan->pnext) != NULL);
        !           444: }
        !           445: 
        !           446: #endif

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