/*
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_edge.c

#include "quakedef.h"
#include "d_local.h"

#ifndef __STORM__
#ifdef PPCASM
#define VBCCPPCASM
#endif
#endif

#if !defined(M68KASM) && !defined(VBCCPPCASM)
static int  miplevel;
#else
int miplevel;
#endif

float   scale_for_mip;
int     screenwidth;
int     ubasestep, errorterm, erroradjustup, erroradjustdown;
int     vstartscan;

// FIXME: should go away
extern void     R_RotateBmodel (void);
extern void     R_TransformFrustum (void);

#if defined(M68KASM) || defined(VBCCPPCASM)
extern void D_CalcGradients(msurface_t *);
#endif

vec3_t    transformed_modelorg;

/*
==============
D_DrawPoly

==============
*/
void D_DrawPoly (void)
{
// this driver takes spans, not polygons
}


/*
=============
D_MipLevelForScale
=============
*/
int D_MipLevelForScale (float scale)
{
  int   lmiplevel;

  if (scale >= d_scalemip[0] )
    lmiplevel = 0;
  else if (scale >= d_scalemip[1] )
    lmiplevel = 1;
  else if (scale >= d_scalemip[2] )
    lmiplevel = 2;
  else
    lmiplevel = 3;

  if (lmiplevel < d_minmip)
    lmiplevel = d_minmip;

  return lmiplevel;
}


/*
==============
D_DrawSolidSurface
==============
*/

// FIXME: clean this up

void D_DrawSolidSurface (surf_t *surf, int color)
{
  espan_t *span;
  byte  *pdest;
  int   u, u2, pix;
  
  pix = (color<<24) | (color<<16) | (color<<8) | color;
  for (span=surf->spans ; span ; span=span->pnext)
  {
    pdest = (byte *)d_viewbuffer + screenwidth*span->v;
    u = span->u;
    u2 = span->u + span->count - 1;
    ((byte *)pdest)[u] = pix;

    if (u2 - u < 8)
    {
      for (u++ ; u <= u2 ; u++)
        ((byte *)pdest)[u] = pix;
    }
    else
    {
      for (u++ ; u & 3 ; u++)
        ((byte *)pdest)[u] = pix;

      u2 -= 4;
      for ( ; u <= u2 ; u+=4)
        *(int *)((byte *)pdest + u) = pix;
      u2 += 4;
      for ( ; u <= u2 ; u++)
        ((byte *)pdest)[u] = pix;
    }
  }
}


#if !defined(M68KASM) && !defined(VBCCPPCASM)
/*
==============
D_CalcGradients
==============
*/
void D_CalcGradients (msurface_t *pface)
{
  mplane_t  *pplane;
  float   mipscale;
  vec3_t    p_temp1;
  vec3_t    p_saxis, p_taxis;
  float   t;

  pplane = pface->plane;

  mipscale = 1.0 / (float)(1 << miplevel);

  TransformVector (pface->texinfo->vecs[0], p_saxis);
  TransformVector (pface->texinfo->vecs[1], p_taxis);

  t = xscaleinv * mipscale;
  d_sdivzstepu = p_saxis[0] * t;
  d_tdivzstepu = p_taxis[0] * t;

  t = yscaleinv * mipscale;
  d_sdivzstepv = -p_saxis[1] * t;
  d_tdivzstepv = -p_taxis[1] * t;

  d_sdivzorigin = p_saxis[2] * mipscale - xcenter * d_sdivzstepu -
      ycenter * d_sdivzstepv;
  d_tdivzorigin = p_taxis[2] * mipscale - xcenter * d_tdivzstepu -
      ycenter * d_tdivzstepv;

  VectorScale (transformed_modelorg, mipscale, p_temp1);

  t = 0x10000*mipscale;
  sadjust = ((fixed16_t)(DotProduct (p_temp1, p_saxis) * 0x10000 + 0.5)) -
      ((pface->texturemins[0] << 16) >> miplevel)
      + pface->texinfo->vecs[0][3]*t;
  tadjust = ((fixed16_t)(DotProduct (p_temp1, p_taxis) * 0x10000 + 0.5)) -
      ((pface->texturemins[1] << 16) >> miplevel)
      + pface->texinfo->vecs[1][3]*t;

//
// -1 (-epsilon) so we never wander off the edge of the texture
//
  bbextents = ((pface->extents[0] << 16) >> miplevel) - 1;
  bbextentt = ((pface->extents[1] << 16) >> miplevel) - 1;
}


/*
==============
D_DrawSurfaces
==============
*/
void D_DrawSurfaces (void)
{
  surf_t      *s;
  msurface_t    *pface;
  surfcache_t   *pcurrentcache;
  vec3_t      world_transformed_modelorg;
  vec3_t      local_modelorg;

  currententity = &cl_entities[0];
  TransformVector (modelorg, transformed_modelorg);
  VectorCopy (transformed_modelorg, world_transformed_modelorg);

// TODO: could preset a lot of this at mode set time
  if (r_drawflat.value)
  {
    for (s = &surfaces[1] ; s<surface_p ; s++)
    {
      if (!s->spans)
        continue;

      d_zistepu = s->d_zistepu;
      d_zistepv = s->d_zistepv;
      d_ziorigin = s->d_ziorigin;

      D_DrawSolidSurface (s, (int)s->data & 0xFF);
      D_DrawZSpans (s->spans);
    }
  }
  else
  {
    for (s = &surfaces[1] ; s<surface_p ; s++)
    {
      if (!s->spans)
        continue;

      r_drawnpolycount++;

      d_zistepu = s->d_zistepu;
      d_zistepv = s->d_zistepv;
      d_ziorigin = s->d_ziorigin;

      if (s->flags & SURF_DRAWSKY)
      {
        if (!r_skymade)
        {
          R_MakeSky ();
        }

        D_DrawSkyScans8 (s->spans);
        D_DrawZSpans (s->spans);
      }
      else if (s->flags & SURF_DRAWBACKGROUND)
      {
      // set up a gradient for the background surface that places it
      // effectively at infinity distance from the viewpoint
        d_zistepu = 0;
        d_zistepv = 0;
        d_ziorigin = -0.9;

        D_DrawSolidSurface (s, (int)r_clearcolor.value & 0xFF);
        D_DrawZSpans (s->spans);
      }
      else if (s->flags & SURF_DRAWTURB)
      {
        pface = s->data;
        miplevel = 0;
        cacheblock = (pixel_t *)
            ((byte *)pface->texinfo->texture +
            pface->texinfo->texture->offsets[0]);
        cachewidth = 64;

        if (s->insubmodel)
        {
        // FIXME: we don't want to do all this for every polygon!
        // TODO: store once at start of frame
          currententity = s->entity;  //FIXME: make this passed in to
                        // R_RotateBmodel ()
          VectorSubtract (r_origin, currententity->origin,
              local_modelorg);
          TransformVector (local_modelorg, transformed_modelorg);

          R_RotateBmodel ();  // FIXME: don't mess with the frustum,
                    // make entity passed in
        }

        D_CalcGradients (pface);
        Turbulent8 (s->spans);
        D_DrawZSpans (s->spans);

        if (s->insubmodel)
        {
        //
        // restore the old drawing state
        // FIXME: we don't want to do this every time!
        // TODO: speed up
        //
          currententity = &cl_entities[0];
          VectorCopy (world_transformed_modelorg,
                transformed_modelorg);
          VectorCopy (base_vpn, vpn);
          VectorCopy (base_vup, vup);
          VectorCopy (base_vright, vright);
          VectorCopy (base_modelorg, modelorg);
          R_TransformFrustum ();
        }
      }
      else
      {
        if (s->insubmodel)
        {
        // FIXME: we don't want to do all this for every polygon!
        // TODO: store once at start of frame
          currententity = s->entity;  //FIXME: make this passed in to
                        // R_RotateBmodel ()
          VectorSubtract (r_origin, currententity->origin, local_modelorg);
          TransformVector (local_modelorg, transformed_modelorg);

          R_RotateBmodel ();  // FIXME: don't mess with the frustum,
                    // make entity passed in
        }

        pface = s->data;
        miplevel = D_MipLevelForScale (s->nearzi * scale_for_mip
        * pface->texinfo->mipadjust);

      // FIXME: make this passed in to D_CacheSurface
        pcurrentcache = D_CacheSurface (pface, miplevel);

        cacheblock = (pixel_t *)pcurrentcache->data;
        cachewidth = pcurrentcache->width;

        D_CalcGradients (pface);

        (*d_drawspans) (s->spans);

        D_DrawZSpans (s->spans);

        if (s->insubmodel)
        {
        //
        // restore the old drawing state
        // FIXME: we don't want to do this every time!
        // TODO: speed up
        //
          currententity = &cl_entities[0];
          VectorCopy (world_transformed_modelorg,
                transformed_modelorg);
          VectorCopy (base_vpn, vpn);
          VectorCopy (base_vup, vup);
          VectorCopy (base_vright, vright);
          VectorCopy (base_modelorg, modelorg);
          R_TransformFrustum ();
        }
      }
    }
  }
}
#endif