267 lines
8.3 KiB
C
267 lines
8.3 KiB
C
/*
|
||
** 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;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|