/*
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