/*
**  Copyright (c) 1991 Microsoft Corporation
*/
//===========================================================================
// FILE                         RPGEN.C
//
// MODULE                       Host Resource Executor
//
// PURPOSE                      Rendering primitives, generic,
//
// DESCRIBED IN                 Resource Executor design spec.
//
//
// MNEMONICS                    n/a
//
// HISTORY                      Bert Douglas  5/1/91 Initial coding started
//                              mslin/dstseng 01/17/92 revise for HRE
//                              dstseng       03/06/92 <1> RP_FillScanRow 
//															 ->RP_FILLSCANROW for asm. version.
//										  dstseng		 03/19/92 <2> comment out unnecessary code.
//															 which was implemented for frac. version of
//															 slicing algorithm.
//
//===========================================================================
#include <windows.h>
#include "constant.h"
#include "jtypes.h"
#include "jres.h"
#include "frame.h"      // driver header file, resource block format
#include "hretype.h"    // define data structure used by hre.c and rpgen.c

//---------------------------------------------------------------------------
void RP_SliceLine
(
   SHORT s_x1, SHORT s_y1,  // endpoint 1
   SHORT s_x2, SHORT s_y2,  // endpoint 2
   RP_SLICE_DESC FAR* psd, // output slice form of line
   UBYTE fb_keep_order      // keep drawing order on styled lines/
)

// PURPOSE
//    Convert a line from endpoint form to slice form
//
//    Slices will run from left to right
//
//    The generated slices are of maximal length and are in a horizontal,
//    vertical or diagonal direction.  Most frame buffer hardware can be
//    accessed with particular efficiency in these directions.  All slices
//    of a line are in the same direction.
//
//    Clipping must be performed by caller.  All coordinates will be non-negative.
//
//    Basic algorithm is taken from :
//      Bresenham, J. E. Run length slice algorithms for incremental lines.
//      In "Fundamental Algorithms for Computer Graphics", R. A. Earnshaw, Ed.
//      NATO ASI Series, Springer Verlag, New York, 1985, 59-104.
//
//    Modifications have been made to the above algorithm for:
//      - sub-pixel endpoint coordinates
//      - equal error rounding rules
//      - GIQ (grid intersect quantization) rules
//      - first/last pixel exclusion
//
//    The line is sliced in four steps:
//
//    STEP 1:  Find the pixel center cooridnates of the first and
//    last pixels in the line.  This is done according to the GIQ conventions.
//
//    STEP 2:  Use these integer pixel center endpoint coordinates
//    to produce the Bresenham slices for the line.  The equal error rounding
//    rule is used, when the first and last slices are not of equal length, to
//    decide which end gets the short slice.
//
//    STEP 3:  Adjust the length of the first and last slices for the
//    effect of the sub-pixel endpoint coordinates.  Note that the sub-pixel
//    part of the coordinates can only effect the first and last slices and
//    has no effect on the intermediate slices.
//
//    STEP 4:  Perform the conditional exclusion of the first and
//    last pixels from the line.
//
//
// ASSUMPTIONS & ASSERTIONS     none.
//
// INTERNAL STRUCTURES          none.
//
// UNRESOLVED ISSUES            programmer development notes
//---------------------------------------------------------------------------
{
   SHORT  s_q,s_r;               /* defined in Bresenhams paper            */
   SHORT  s_m,s_n;               /* "                                      */
   SHORT  s_dx,s_dy;             /* "                                      */
   SHORT  s_da,s_db;             /* "                                      */
   SHORT  s_del_b;               /* "                                      */
   SHORT  s_abs_dy;              /* absolute value of s_dy                 */

   SHORT  s_sy;                  /* 1 or -1 , sign of s_dy                 */
   SHORT  s_dx_oct,s_dy_oct;     /* octant dir  xy= 0/1 1/1 1/0 1/-1 0/-1  */
   SHORT  s_dx_axial,s_dy_axial; /* 1/2 octant axial dir xy= 0/1 1/0 -1/0  */
   SHORT  s_dx_diag, s_dy_diag;  /* 1/2 octant diagonal dir xy= 1/1 1/-1   */
   SHORT  s_t;                   /* temporary                              */
   FBYTE  fb_short_end_last;     /* 0=first end short, 1=last end short    */
   UBYTE  fb_unswap;             /* need to un-swap endpoints at return    */

   fb_unswap = FALSE;


   /*------------------------------------------------------------*/
   /* STEP 1: Find pixel center coordinates of first/last pixels */
   /*------------------------------------------------------------*/

   /* always draw left to right, normalize to semicircle with x >= 0 */
   s_dx = s_x2 - s_x1;
   if ( s_dx < 0 )
   {
      fb_unswap = fb_keep_order;
      s_dx  = -s_dx;
      s_t     = s_x2;
      s_x2 = s_x1;
      s_x1 = s_t;
      s_t     = s_y2;
      s_y2 = s_y1;
      s_y1 = s_t;
   }
   s_dy = s_y2 - s_y1;


   /*------------------------------------------------------------*/
   /* STEP 2: Produce slices using the Bresenham algorithm       */
   /*------------------------------------------------------------*/

   if ( s_dy < 0 )
   {
      s_abs_dy = -s_dy;
      s_sy = -1;
      fb_short_end_last = 1;
    }
   else
   {
      s_abs_dy = s_dy;
      s_sy = 1;
      fb_short_end_last = 0;
   }

   /* normalize to octant */
   if ( s_dx >= s_abs_dy )
   {
      s_da = s_dx;
      s_db = s_abs_dy;
      s_dx_oct = 1;
      s_dy_oct = 0;
   }
   else
   {
      s_da = s_abs_dy;
      s_db = s_dx;
      s_dx_oct = 0;
      s_dy_oct = s_sy;
      fb_short_end_last = 1;
   }

   /* normalize to half octant */
   s_del_b = s_db;
   s_t = s_da - s_db;
   if ( s_del_b > s_t )
   {
      s_del_b = s_t;
      fb_short_end_last ^= 1;
   }

   /* handle special case of slope of 2 */
   s_dx_axial = s_dx_oct;
   s_dy_axial = s_dy_oct;
   s_dx_diag = 1;
   s_dy_diag = s_sy;
   if (  ( s_da == (2 * s_del_b) )
      && ( s_dy < 0 )
      )
   {  s_dx_axial = 1;
      s_dy_axial = s_sy;
      s_dx_diag = s_dx_oct;
      s_dy_diag = s_dy_oct;
      fb_short_end_last ^= 1;
   }

   /* determine slice movement and skip directions */
   if ( s_db == s_del_b )
   {
      /* slice direction is axial, skip direction is diagonal */
      psd->s_dx_draw = s_dx_axial;
      psd->s_dy_draw = s_dy_axial;
      psd->s_dx_skip = s_dx_diag - s_dx_axial;
      psd->s_dy_skip = s_dy_diag - s_dy_axial;
   }
   else
   {
      /* slice direction is diagonal, skip direction is axial */
      psd->s_dx_draw = s_dx_diag;
      psd->s_dy_draw = s_dy_diag;
      psd->s_dx_skip = s_dx_axial - s_dx_diag;
      psd->s_dy_skip = s_dy_axial - s_dy_diag;
   }

   /* handle zero slope lines with special case */
   if ( s_del_b == 0 )
   {
      psd->us_first = s_da + 1;
      psd->us_n_slices = 0;
      psd->us_last = 0;
   }
   else
   /* general case, non-zero slope lines */
   {
      /* basic Bresenham parameters */
      s_q = s_da / s_del_b;
      s_r = s_da % s_del_b;
      s_m = s_q / 2;
      s_n = s_r;
      if ( s_q & 1 ) s_n += s_del_b;

      /* first and last slice length */
      psd->us_first = psd->us_last = s_m + 1;
      if ( s_n == 0 )
      {
         if ( fb_short_end_last )
            psd->us_last -= 1;
         else
            psd->us_first -= 1;
      }

      /* remaining line slice parameters */
      psd->us_small = s_q;
      psd->s_dis_sm = 2*s_r;
      psd->s_dis_lg = psd->s_dis_sm - (2*s_del_b);
      psd->s_dis = s_n + psd->s_dis_lg;
      if ( s_dy < 0 ) psd->s_dis -= 1;
      psd->us_n_slices = s_del_b - 1;

   }

   /* output endpoints */
   psd->us_x1 = s_x1;
   psd->us_y1 = s_y1;
   psd->us_x2 = s_x2;
   psd->us_y2 = s_y2;

   if ( fb_unswap )
   {
      psd->us_x1 = s_x2;
      psd->us_y1 = s_y2;
      psd->us_x2 = s_x1;
      psd->us_y2 = s_y1;
      psd->s_dx_draw = -psd->s_dx_draw;
      psd->s_dy_draw = -psd->s_dy_draw;
      psd->s_dx_skip = -psd->s_dx_skip;
      psd->s_dy_skip = -psd->s_dy_skip;
      s_t = psd->us_first;
      psd->us_first = psd->us_last;
      psd->us_last = s_t;
   }
}