1 files changed, 449 insertions, 0 deletions

diff --git a/apps/plugins/sdl/progs/quake/d_scan.c b/apps/plugins/sdl/progs/quake/d_scan.c
new file mode 100644
index 0000000000..008c783be6
--- /dev/null
+++ b/apps/plugins/sdl/progs/quake/d_scan.c
@@ -0,0 +1,449 @@
+/*
+Copyright (C) 1996-1997 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+// d_scan.c
+//
+// Portable C scan-level rasterization code, all pixel depths.
+
+#include "quakedef.h"
+#include "r_local.h"
+#include "d_local.h"
+
+unsigned char   *r_turb_pbase, *r_turb_pdest;
+fixed16_t               r_turb_s, r_turb_t, r_turb_sstep, r_turb_tstep;
+int                             *r_turb_turb;
+int                             r_turb_spancount;
+
+void D_DrawTurbulent8Span (void);
+
+
+/*
+=============
+D_WarpScreen
+
+// this performs a slight compression of the screen at the same time as
+// the sine warp, to keep the edges from wrapping
+=============
+*/
+void D_WarpScreen (void)
+{
+        int             w, h;
+        int             u,v;
+        byte    *dest;
+        int             *turb;
+        int             *col;
+        byte    **row;
+        byte    *rowptr[MAXHEIGHT+(AMP2*2)];
+        int             column[MAXWIDTH+(AMP2*2)];
+        float   wratio, hratio;
+
+        w = r_refdef.vrect.width;
+        h = r_refdef.vrect.height;
+
+        wratio = w / (float)scr_vrect.width;
+        hratio = h / (float)scr_vrect.height;
+
+        for (v=0 ; v<scr_vrect.height+AMP2*2 ; v++)
+        {
+                rowptr[v] = d_viewbuffer + (r_refdef.vrect.y * screenwidth) +
+                                 (screenwidth * (int)((float)v * hratio * h / (h + AMP2 * 2)));
+        }
+
+        for (u=0 ; u<scr_vrect.width+AMP2*2 ; u++)
+        {
+                column[u] = r_refdef.vrect.x +
+                                (int)((float)u * wratio * w / (w + AMP2 * 2));
+        }
+
+        turb = intsintable + ((int)(cl.time*SPEED)&(CYCLE-1));
+        dest = vid.buffer + scr_vrect.y * vid.rowbytes + scr_vrect.x;
+
+        for (v=0 ; v<scr_vrect.height ; v++, dest += vid.rowbytes)
+        {
+                col = &column[turb[v]];
+                row = &rowptr[v];
+
+                for (u=0 ; u<scr_vrect.width ; u+=4)
+                {
+                        dest[u+0] = row[turb[u+0]][col[u+0]];
+                        dest[u+1] = row[turb[u+1]][col[u+1]];
+                        dest[u+2] = row[turb[u+2]][col[u+2]];
+                        dest[u+3] = row[turb[u+3]][col[u+3]];
+                }
+        }
+}
+
+
+#if     !id386
+
+/*
+=============
+D_DrawTurbulent8Span
+=============
+*/
+void D_DrawTurbulent8Span (void)
+{
+        int             sturb, tturb;
+
+        do
+        {
+                sturb = ((r_turb_s + r_turb_turb[(r_turb_t>>16)&(CYCLE-1)])>>16)&63;
+                tturb = ((r_turb_t + r_turb_turb[(r_turb_s>>16)&(CYCLE-1)])>>16)&63;
+                *r_turb_pdest++ = *(r_turb_pbase + (tturb<<6) + sturb);
+                r_turb_s += r_turb_sstep;
+                r_turb_t += r_turb_tstep;
+        } while (--r_turb_spancount > 0);
+}
+
+#endif  // !id386
+
+
+/*
+=============
+Turbulent8
+=============
+*/
+void Turbulent8 (espan_t *pspan)
+{
+        int                             count;
+        fixed16_t               snext, tnext;
+        float                   sdivz, tdivz, zi, z, du, dv, spancountminus1;
+        float                   sdivz16stepu, tdivz16stepu, zi16stepu;
+        
+        r_turb_turb = sintable + ((int)(cl.time*SPEED)&(CYCLE-1));
+
+        r_turb_sstep = 0;       // keep compiler happy
+        r_turb_tstep = 0;       // ditto
+
+        r_turb_pbase = (unsigned char *)cacheblock;
+
+        sdivz16stepu = d_sdivzstepu * 16;
+        tdivz16stepu = d_tdivzstepu * 16;
+        zi16stepu = d_zistepu * 16;
+
+        do
+        {
+                r_turb_pdest = (unsigned char *)((byte *)d_viewbuffer +
+                                (screenwidth * pspan->v) + pspan->u);
+
+                count = pspan->count;
+
+        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
+                du = (float)pspan->u;
+                dv = (float)pspan->v;
+
+                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
+                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
+                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
+                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
+
+                r_turb_s = (int)(sdivz * z) + sadjust;
+                if (r_turb_s > bbextents)
+                        r_turb_s = bbextents;
+                else if (r_turb_s < 0)
+                        r_turb_s = 0;
+
+                r_turb_t = (int)(tdivz * z) + tadjust;
+                if (r_turb_t > bbextentt)
+                        r_turb_t = bbextentt;
+                else if (r_turb_t < 0)
+                        r_turb_t = 0;
+
+                do
+                {
+                // calculate s and t at the far end of the span
+                        if (count >= 16)
+                                r_turb_spancount = 16;
+                        else
+                                r_turb_spancount = count;
+
+                        count -= r_turb_spancount;
+
+                        if (count)
+                        {
+                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
+                        // calculate s and t steps across span by shifting
+                                sdivz += sdivz16stepu;
+                                tdivz += tdivz16stepu;
+                                zi += zi16stepu;
+                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
+
+                                snext = (int)(sdivz * z) + sadjust;
+                                if (snext > bbextents)
+                                        snext = bbextents;
+                                else if (snext < 16)
+                                        snext = 16;     // prevent round-off error on <0 steps from
+                                                                //  from causing overstepping & running off the
+                                                                //  edge of the texture
+
+                                tnext = (int)(tdivz * z) + tadjust;
+                                if (tnext > bbextentt)
+                                        tnext = bbextentt;
+                                else if (tnext < 16)
+                                        tnext = 16;     // guard against round-off error on <0 steps
+
+                                r_turb_sstep = (snext - r_turb_s) >> 4;
+                                r_turb_tstep = (tnext - r_turb_t) >> 4;
+                        }
+                        else
+                        {
+                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
+                        // can't step off polygon), clamp, calculate s and t steps across
+                        // span by division, biasing steps low so we don't run off the
+                        // texture
+                                spancountminus1 = (float)(r_turb_spancount - 1);
+                                sdivz += d_sdivzstepu * spancountminus1;
+                                tdivz += d_tdivzstepu * spancountminus1;
+                                zi += d_zistepu * spancountminus1;
+                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
+                                snext = (int)(sdivz * z) + sadjust;
+                                if (snext > bbextents)
+                                        snext = bbextents;
+                                else if (snext < 16)
+                                        snext = 16;     // prevent round-off error on <0 steps from
+                                                                //  from causing overstepping & running off the
+                                                                //  edge of the texture
+
+                                tnext = (int)(tdivz * z) + tadjust;
+                                if (tnext > bbextentt)
+                                        tnext = bbextentt;
+                                else if (tnext < 16)
+                                        tnext = 16;     // guard against round-off error on <0 steps
+
+                                if (r_turb_spancount > 1)
+                                {
+                                        r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1);
+                                        r_turb_tstep = (tnext - r_turb_t) / (r_turb_spancount - 1);
+                                }
+                        }
+
+                        r_turb_s = r_turb_s & ((CYCLE<<16)-1);
+                        r_turb_t = r_turb_t & ((CYCLE<<16)-1);
+
+                        D_DrawTurbulent8Span ();
+
+                        r_turb_s = snext;
+                        r_turb_t = tnext;
+
+                } while (count > 0);
+
+        } while ((pspan = pspan->pnext) != NULL);
+}
+
+
+#if     !id386
+
+/*
+=============
+D_DrawSpans8
+=============
+*/
+void D_DrawSpans8 (espan_t *pspan)
+{
+        int                             count, spancount;
+        unsigned char   *pbase, *pdest;
+        fixed16_t               s, t, snext, tnext, sstep, tstep;
+        float                   sdivz, tdivz, zi, z, du, dv, spancountminus1;
+        float                   sdivz8stepu, tdivz8stepu, zi8stepu;
+
+        sstep = 0;      // keep compiler happy
+        tstep = 0;      // ditto
+
+        pbase = (unsigned char *)cacheblock;
+
+        sdivz8stepu = d_sdivzstepu * 8;
+        tdivz8stepu = d_tdivzstepu * 8;
+        zi8stepu = d_zistepu * 8;
+
+        do
+        {
+                pdest = (unsigned char *)((byte *)d_viewbuffer +
+                                (screenwidth * pspan->v) + pspan->u);
+
+                count = pspan->count;
+
+        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
+                du = (float)pspan->u;
+                dv = (float)pspan->v;
+
+                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
+                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
+                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
+                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
+
+                s = (int)(sdivz * z) + sadjust;
+                if (s > bbextents)
+                        s = bbextents;
+                else if (s < 0)
+                        s = 0;
+
+                t = (int)(tdivz * z) + tadjust;
+                if (t > bbextentt)
+                        t = bbextentt;
+                else if (t < 0)
+                        t = 0;
+
+                do
+                {
+                // calculate s and t at the far end of the span
+                        if (count >= 8)
+                                spancount = 8;
+                        else
+                                spancount = count;
+
+                        count -= spancount;
+
+                        if (count)
+                        {
+                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
+                        // calculate s and t steps across span by shifting
+                                sdivz += sdivz8stepu;
+                                tdivz += tdivz8stepu;
+                                zi += zi8stepu;
+                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
+
+                                snext = (int)(sdivz * z) + sadjust;
+                                if (snext > bbextents)
+                                        snext = bbextents;
+                                else if (snext < 8)
+                                        snext = 8;      // prevent round-off error on <0 steps from
+                                                                //  from causing overstepping & running off the
+                                                                //  edge of the texture
+
+                                tnext = (int)(tdivz * z) + tadjust;
+                                if (tnext > bbextentt)
+                                        tnext = bbextentt;
+                                else if (tnext < 8)
+                                        tnext = 8;      // guard against round-off error on <0 steps
+
+                                sstep = (snext - s) >> 3;
+                                tstep = (tnext - t) >> 3;
+                        }
+                        else
+                        {
+                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
+                        // can't step off polygon), clamp, calculate s and t steps across
+                        // span by division, biasing steps low so we don't run off the
+                        // texture
+                                spancountminus1 = (float)(spancount - 1);
+                                sdivz += d_sdivzstepu * spancountminus1;
+                                tdivz += d_tdivzstepu * spancountminus1;
+                                zi += d_zistepu * spancountminus1;
+                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
+                                snext = (int)(sdivz * z) + sadjust;
+                                if (snext > bbextents)
+                                        snext = bbextents;
+                                else if (snext < 8)
+                                        snext = 8;      // prevent round-off error on <0 steps from
+                                                                //  from causing overstepping & running off the
+                                                                //  edge of the texture
+
+                                tnext = (int)(tdivz * z) + tadjust;
+                                if (tnext > bbextentt)
+                                        tnext = bbextentt;
+                                else if (tnext < 8)
+                                        tnext = 8;      // guard against round-off error on <0 steps
+
+                                if (spancount > 1)
+                                {
+                                        sstep = (snext - s) / (spancount - 1);
+                                        tstep = (tnext - t) / (spancount - 1);
+                                }
+                        }
+
+                        do
+                        {
+                                *pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
+                                s += sstep;
+                                t += tstep;
+                        } while (--spancount > 0);
+
+                        s = snext;
+                        t = tnext;
+
+                } while (count > 0);
+
+        } while ((pspan = pspan->pnext) != NULL);
+}
+
+#endif
+
+
+#if     !id386
+
+/*
+=============
+D_DrawZSpans
+=============
+*/
+void D_DrawZSpans (espan_t *pspan)
+{
+        int                             count, doublecount, izistep;
+        int                             izi;
+        short                   *pdest;
+        unsigned                ltemp;
+        double                  zi;
+        float                   du, dv;
+
+// FIXME: check for clamping/range problems
+// we count on FP exceptions being turned off to avoid range problems
+        izistep = (int)(d_zistepu * 0x8000 * 0x10000);
+
+        do
+        {
+                pdest = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
+
+                count = pspan->count;
+
+        // calculate the initial 1/z
+                du = (float)pspan->u;
+                dv = (float)pspan->v;
+
+                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
+        // we count on FP exceptions being turned off to avoid range problems
+                izi = (int)(zi * 0x8000 * 0x10000);
+
+                if ((long)pdest & 0x02)
+                {
+                        *pdest++ = (short)(izi >> 16);
+                        izi += izistep;
+                        count--;
+                }
+
+                if ((doublecount = count >> 1) > 0)
+                {
+                        do
+                        {
+                                ltemp = izi >> 16;
+                                izi += izistep;
+                                ltemp |= izi & 0xFFFF0000;
+                                izi += izistep;
+                                *(int *)pdest = ltemp;
+                                pdest += 2;
+                        } while (--doublecount > 0);
+                }
+
+                if (count & 1)
+                        *pdest = (short)(izi >> 16);
+
+        } while ((pspan = pspan->pnext) != NULL);
+}
+
+#endif
+