Return to d_sky.c CVS log

Up to [Quake] / quake1

Annotation of quake1/d_sky.c, revision 1.1

1.1     ! root        1: // d_sky.c
        !             2: 
        !             3: #include "quakedef.h"
        !             4: #include "r_local.h"
        !             5: #include "d_local.h"
        !             6: 
        !             7: #define SKY_SPAN_SHIFT 5
        !             8: #define SKY_SPAN_MAX   (1 << SKY_SPAN_SHIFT)
        !             9: 
        !            10: 
        !            11: /*
        !            12: =================
        !            13: D_Sky_uv_To_st
        !            14: =================
        !            15: */
        !            16: void D_Sky_uv_To_st (int u, int v, fixed16_t *s, fixed16_t *t)
        !            17: {
        !            18:        float   wu, wv, temp;
        !            19:        vec3_t  end;
        !            20: 
        !            21:        if (r_refdef.vrect.width >= r_refdef.vrect.height)
        !            22:                temp = (float)r_refdef.vrect.width;
        !            23:        else
        !            24:                temp = (float)r_refdef.vrect.height;
        !            25: 
        !            26:        wu = 8192.0 * (float)(u-((int)vid.width>>1)) / temp;
        !            27:        wv = 8192.0 * (float)(((int)vid.height>>1)-v) / temp;
        !            28: 
        !            29:        end[0] = 4096*vpn[0] + wu*vright[0] + wv*vup[0];
        !            30:        end[1] = 4096*vpn[1] + wu*vright[1] + wv*vup[1];
        !            31:        end[2] = 4096*vpn[2] + wu*vright[2] + wv*vup[2];
        !            32:        end[2] *= 3;
        !            33:        VectorNormalize (end);
        !            34: 
        !            35:        temp = skytime*skyspeed;        // TODO: add D_SetupFrame & set this there
        !            36:        *s = (int)((temp + 6*(SKYSIZE/2-1)*end[0]) * 0x10000);
        !            37:        *t = (int)((temp + 6*(SKYSIZE/2-1)*end[1]) * 0x10000);
        !            38: }
        !            39: 
        !            40: 
        !            41: /*
        !            42: =================
        !            43: D_DrawSkyScans8
        !            44: =================
        !            45: */
        !            46: void D_DrawSkyScans8 (espan_t *pspan)
        !            47: {
        !            48:        int                             count, spancount, u, v;
        !            49:        unsigned char   *pdest;
        !            50:        fixed16_t               s, t, snext, tnext, sstep, tstep;
        !            51:        int                             spancountminus1;
        !            52: 
        !            53:        sstep = 0;      // keep compiler happy
        !            54:        tstep = 0;      // ditto
        !            55: 
        !            56:        do
        !            57:        {
        !            58:                pdest = (unsigned char *)((byte *)d_viewbuffer +
        !            59:                                (screenwidth * pspan->v) + pspan->u);
        !            60: 
        !            61:                count = pspan->count;
        !            62: 
        !            63:        // calculate the initial s & t
        !            64:                u = pspan->u;
        !            65:                v = pspan->v;
        !            66:                D_Sky_uv_To_st (u, v, &s, &t);
        !            67: 
        !            68:                do
        !            69:                {
        !            70:                        if (count >= SKY_SPAN_MAX)
        !            71:                                spancount = SKY_SPAN_MAX;
        !            72:                        else
        !            73:                                spancount = count;
        !            74: 
        !            75:                        count -= spancount;
        !            76: 
        !            77:                        if (count)
        !            78:                        {
        !            79:                                u += spancount;
        !            80: 
        !            81:                        // calculate s and t at far end of span,
        !            82:                        // calculate s and t steps across span by shifting
        !            83:                                D_Sky_uv_To_st (u, v, &snext, &tnext);
        !            84: 
        !            85:                                sstep = (snext - s) >> SKY_SPAN_SHIFT;
        !            86:                                tstep = (tnext - t) >> SKY_SPAN_SHIFT;
        !            87:                        }
        !            88:                        else
        !            89:                        {
        !            90:                        // calculate s and t at last pixel in span,
        !            91:                        // calculate s and t steps across span by division
        !            92:                                spancountminus1 = (float)(spancount - 1);
        !            93: 
        !            94:                                if (spancountminus1 > 0)
        !            95:                                {
        !            96:                                        u += spancountminus1;
        !            97:                                        D_Sky_uv_To_st (u, v, &snext, &tnext);
        !            98: 
        !            99:                                        sstep = (snext - s) / spancountminus1;
        !           100:                                        tstep = (tnext - t) / spancountminus1;
        !           101:                                }
        !           102:                        }
        !           103: 
        !           104:                        do
        !           105:                        {
        !           106:                                *pdest++ = r_skysource[((t & R_SKY_TMASK) >> 8) +
        !           107:                                                ((s & R_SKY_SMASK) >> 16)];
        !           108:                                s += sstep;
        !           109:                                t += tstep;
        !           110:                        } while (--spancount > 0);
        !           111: 
        !           112:                        s = snext;
        !           113:                        t = tnext;
        !           114: 
        !           115:                } while (count > 0);
        !           116: 
        !           117:        } while ((pspan = pspan->pnext) != NULL);
        !           118: }
        !           119: 

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