hwrasterizer.rs - mozsearch

comm-central/third_party/rust/wpf-gpu-raster/src/hwrasterizer.rs

Enable keyboard shortcuts

Revision control

Copy as Markdown

Other Tools

HG Web

// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// See the LICENSE file in the project root for more information.

#![allow(unused_parens)]

use crate::aacoverage::{CCoverageBuffer, c_rInvShiftSize, c_antiAliasMode, c_nShift, CCoverageInterval, c_nShiftMask, c_nShiftSize, c_nHalfShiftSize};

use crate::hwvertexbuffer::CHwVertexBufferBuilder;

use crate::matrix::{CMILMatrix, CMatrix};

use crate::nullable_ref::Ref;

use crate::aarasterizer::*;

use crate::geometry_sink::IGeometrySink;

use crate::helpers::Int32x32To64;

use crate::types::*;

use typed_arena_nomut::Arena;

//-----------------------------------------------------------------------------

//

//

//  Description:

//      Trapezoidal anti-aliasing implementation

//

//  >>>> Note that some of this code is duplicated in sw\aarasterizer.cpp,

//  >>>> so changes to this file may need to propagate.

//

//   pursue reduced code duplication

//

macro_rules! MIL_THR {

    ($e: expr) => {

        $e//assert_eq!($e, S_OK);

//

// Optimize for speed instead of size for these critical methods

//

//-------------------------------------------------------------------------

//

// Coordinate system encoding

//

// All points/coordinates are named as follows:

//

//    <HungarianType><CoordinateSystem>[X|Y][Left|Right|Top|Bottom]VariableName

//

//    Common hungarian types:

//        n - INT

//        u - UINT

//        r - FLOAT

//

//    Coordinate systems:

//        Pixel - Device pixel space assuming integer coordinates in the pixel top left corner.

//        Subpixel - Overscaled space.

//

//        To convert between Pixel to Subpixel, we have:

//            nSubpixelCoordinate = nPixelCoordinate << c_nShift;

//            nPixelCoordinate = nSubpixelCoordinate >> c_nShift;

//

//        Note that the conversion to nPixelCoordinate needs to also track

//        (nSubpixelCoordinate & c_nShiftMask) to maintain the full value.

//

//        Note that since trapezoidal only supports 8x8, c_nShiftSize is always equal to 8.  So,

//        (1, 2) in pixel space would become (8, 16) in subpixel space.

//

//    [X|Y]

//        Indicates which coordinate is being referred to.

//

//    [Left|Right|Top|Bottom]

//        When referring to trapezoids or rectangular regions, this

//        component indicates which edge is being referred to.

//

//    VariableName

//       Descriptive portion of the variable name

//

//-------------------------------------------------------------------------

//-------------------------------------------------------------------------

//

//  Function:   IsFractionGreaterThan

//

//  Synopsis:

//     Determine if nNumeratorA/nDenominatorA > nNumeratorB/nDenominatorB

//

//     Note that we assume all denominators are strictly greater than zero.

//

//-------------------------------------------------------------------------

fn IsFractionGreaterThan(

    nNumeratorA: INT,                    // Left hand side numerator

   /* __in_range(>=, 1) */ nDenominatorA: INT, // Left hand side denominator

    nNumeratorB: INT,                    // Right hand side numerator

   /* __in_range(>=, 1) */ nDenominatorB: INT,  // Right hand side denominator

    ) -> bool

//

    // nNumeratorA/nDenominatorA > nNumeratorB/nDenominatorB

    // iff nNumeratorA*nDenominatorB/nDenominatorA > nNumeratorB, since nDenominatorB > 0

    // iff nNumeratorA*nDenominatorB > nNumeratorB*nDenominatorA, since nDenominatorA > 0

//

    // Now, all input parameters are 32-bit integers, so we need to use

    // a 64-bit result to compute the product.

//

    let lNumeratorAxDenominatorB = Int32x32To64(nNumeratorA, nDenominatorB);

    let lNumeratorBxDenominatorA = Int32x32To64(nNumeratorB, nDenominatorA);

    return (lNumeratorAxDenominatorB > lNumeratorBxDenominatorA);

//-------------------------------------------------------------------------

//

//  Function:   IsFractionLessThan

//

//  Synopsis:

//     Determine if nNumeratorA/nDenominatorA < nNumeratorB/nDenominatorB

//

//     Note that we assume all denominators are strictly greater than zero.

//

//-------------------------------------------------------------------------

fn

IsFractionLessThan(

    nNumeratorA: INT,                    // Left hand side numerator

    /* __in_range(>=, 1) */ nDenominatorA: INT, // Left hand side denominator

    nNumeratorB: INT,                    // Right hand side numerator

    /* __in_range(>=, 1) */ nDenominatorB: INT,  // Right hand side denominator

) -> bool

//

    // Same check as previous function with less than comparision instead of

    // a greater than comparison.

//

    let lNumeratorAxDenominatorB = Int32x32To64(nNumeratorA, nDenominatorB);

    let lNumeratorBxDenominatorA = Int32x32To64(nNumeratorB, nDenominatorA);

    return (lNumeratorAxDenominatorB < lNumeratorBxDenominatorA);

//-------------------------------------------------------------------------

//

//  Function:   AdvanceDDAMultipleSteps

//

//  Synopsis:

//     Advance the DDA by multiple steps

//

//-------------------------------------------------------------------------

fn

AdvanceDDAMultipleSteps(

    pEdgeLeft: &CEdge,         // Left edge from active edge list

    pEdgeRight: &CEdge,        // Right edge from active edge list

    nSubpixelYAdvance: INT,                    // Number of steps to advance the DDA

    nSubpixelXLeftBottom: &mut INT,     // Resulting left x position

    nSubpixelErrorLeftBottom: &mut INT, // Resulting left x position error

    nSubpixelXRightBottom: &mut INT,    // Resulting right x position

    nSubpixelErrorRightBottom: &mut INT // Resulting right x position error

//

    // In this method, we need to be careful of overflow.  Expected input ranges for values are:

//

    //      edge points: x and y subpixel space coordinates are between [-2^26, 2^26]

    //                   since we start with 28.4 space (and are now in subpixel space,

    //                   i.e., no 16x scale) and assume 2 bits of working space.

//

    //                   This assumption is ensured by TransformRasterizerPointsTo28_4.

//

    #[cfg(debug_assertions)]

    let nDbgPixelCoordinateMax = (1 << 26);

    let nDbgPixelCoordinateMin = -nDbgPixelCoordinateMax;

    assert!(pEdgeLeft.X.get() >= nDbgPixelCoordinateMin && pEdgeLeft.X.get() <= nDbgPixelCoordinateMax);

    assert!(pEdgeLeft.EndY >= nDbgPixelCoordinateMin && pEdgeLeft.EndY <= nDbgPixelCoordinateMax);

    assert!(pEdgeRight.X.get() >= nDbgPixelCoordinateMin && pEdgeRight.X.get() <= nDbgPixelCoordinateMax);

    assert!(pEdgeRight.EndY >= nDbgPixelCoordinateMin && pEdgeRight.EndY <= nDbgPixelCoordinateMax);

//

    //        errorDown: (0, 2^30)

    //                   Since errorDown is the edge delta y in 28.4 space (not subpixel space

    //                   like the end points), we have a larger range of (0, 2^32) for the positive

    //                   error down.  With 2 bits of work space (which TransformRasterizerPointsTo28_4

    //                   ensures), we know we are between (0, 2^30)

//

    let nDbgErrorDownMax: INT = (1 << 30);

    assert!(pEdgeLeft.ErrorDown  > 0 && pEdgeLeft.ErrorDown  < nDbgErrorDownMax);

    assert!(pEdgeRight.ErrorDown > 0 && pEdgeRight.ErrorDown < nDbgErrorDownMax);

//

    //          errorUp: [0, errorDown)

//

    assert!(pEdgeLeft.ErrorUp  >= 0 && pEdgeLeft.ErrorUp  < pEdgeLeft.ErrorDown);

    assert!(pEdgeRight.ErrorUp >= 0 && pEdgeRight.ErrorUp < pEdgeRight.ErrorDown);

//

    // Advance the left edge

//

    // Since each point on the edge is withing 28.4 space, the following computation can't overflow.

    *nSubpixelXLeftBottom = pEdgeLeft.X.get() + nSubpixelYAdvance*pEdgeLeft.Dx;

    // Since the error values can be close to 2^30, we can get an overflow by multiplying with yAdvance.

    // So, we need to use a 64-bit temporary in this case.

    let mut llSubpixelErrorBottom: LONGLONG = pEdgeLeft.Error.get() as LONGLONG + Int32x32To64(nSubpixelYAdvance, pEdgeLeft.ErrorUp);

    if (llSubpixelErrorBottom >= 0)

        let llSubpixelXLeftDelta = llSubpixelErrorBottom / (pEdgeLeft.ErrorDown as LONGLONG);

        // The delta should remain in range since it still represents a delta along the edge which

        // we know fits entirely in 28.4.  Note that we add one here since the error must end up

        // less than 0.

        assert!(llSubpixelXLeftDelta < INT::MAX as LONGLONG);

        let nSubpixelXLeftDelta: INT = (llSubpixelXLeftDelta as INT) + 1;

        *nSubpixelXLeftBottom += nSubpixelXLeftDelta;

        llSubpixelErrorBottom -= Int32x32To64(pEdgeLeft.ErrorDown, nSubpixelXLeftDelta);

    // At this point, the subtraction above should have generated an error that is within

    // (-pLeft->ErrorDown, 0)

    assert!((llSubpixelErrorBottom > -pEdgeLeft.ErrorDown as LONGLONG) && (llSubpixelErrorBottom < 0));

    *nSubpixelErrorLeftBottom = (llSubpixelErrorBottom as INT);

//

    // Advance the right edge

//

    // Since each point on the edge is withing 28.4 space, the following computation can't overflow.

    *nSubpixelXRightBottom = pEdgeRight.X.get() + nSubpixelYAdvance*pEdgeRight.Dx;

    // Since the error values can be close to 2^30, we can get an overflow by multiplying with yAdvance.

    // So, we need to use a 64-bit temporary in this case.

    llSubpixelErrorBottom = pEdgeRight.Error.get() as LONGLONG + Int32x32To64(nSubpixelYAdvance, pEdgeRight.ErrorUp);

    if (llSubpixelErrorBottom >= 0)

        let llSubpixelXRightDelta: LONGLONG = llSubpixelErrorBottom / (pEdgeRight.ErrorDown as LONGLONG);

        // The delta should remain in range since it still represents a delta along the edge which

        // we know fits entirely in 28.4.  Note that we add one here since the error must end up

        // less than 0.

        assert!(llSubpixelXRightDelta < INT::MAX as LONGLONG);

        let nSubpixelXRightDelta: INT = (llSubpixelXRightDelta as INT) + 1;

        *nSubpixelXRightBottom += nSubpixelXRightDelta;

        llSubpixelErrorBottom -= Int32x32To64(pEdgeRight.ErrorDown, nSubpixelXRightDelta);

    // At this point, the subtraction above should have generated an error that is within

    // (-pRight->ErrorDown, 0)

    assert!((llSubpixelErrorBottom > -pEdgeRight.ErrorDown as LONGLONG) && (llSubpixelErrorBottom < 0));

    *nSubpixelErrorRightBottom = (llSubpixelErrorBottom as INT);

//-------------------------------------------------------------------------

//

//  Function:   ComputeDeltaUpperBound

//

//  Synopsis:

//     Compute some value that is >= nSubpixelAdvanceY*|1/m| where m is the

//     slope defined by the edge below.

//

//-------------------------------------------------------------------------

fn

ComputeDeltaUpperBound(

    pEdge: &CEdge,  // Edge containing 1/m value used for computation

    nSubpixelYAdvance: INT          // Multiplier in synopsis expression

    ) -> INT

    let nSubpixelDeltaUpperBound: INT;

//

    // Compute the delta bound

//

    if (pEdge.ErrorUp == 0)

//

        // No errorUp, so simply compute bound based on dx value

//

        nSubpixelDeltaUpperBound = nSubpixelYAdvance*(pEdge.Dx).abs();

    else

        let nAbsDx: INT;

        let nAbsErrorUp: INT;

//

        // Compute abs of (dx, error)

//

        // Here, we can assume errorUp > 0

//

        assert!(pEdge.ErrorUp > 0);

        if (pEdge.Dx >= 0)

            nAbsDx = pEdge.Dx;

            nAbsErrorUp = pEdge.ErrorUp;

        else

//

            // Dx < 0, so negate (dx, errorUp)

//

            // Note that since errorUp > 0, we know -errorUp < 0 and that

            // we need to add errorDown to get an errorUp >= 0 which

            // also means substracting one from dx.

//

            nAbsDx = -pEdge.Dx - 1;

            nAbsErrorUp = -pEdge.ErrorUp + pEdge.ErrorDown;

//

        // Compute the bound of nSubpixelAdvanceY*|1/m|

//

        // Note that the +1 below is included to bound any left over errorUp that we are dropping here.

//

        nSubpixelDeltaUpperBound = nSubpixelYAdvance*nAbsDx + (nSubpixelYAdvance*nAbsErrorUp)/pEdge.ErrorDown + 1;

    return nSubpixelDeltaUpperBound;

//-------------------------------------------------------------------------

//

//  Function:   ComputeDistanceLowerBound

//

//  Synopsis:

//     Compute some value that is <= distance between

//     (pEdgeLeft->X, pEdgeLeft->Error) and (pEdgeRight->X, pEdgeRight->Error)

//

//-------------------------------------------------------------------------

fn

ComputeDistanceLowerBound(

    pEdgeLeft: &CEdge, // Left edge containing the position for the distance computation

    pEdgeRight: &CEdge // Right edge containing the position for the distance computation

    ) -> INT

//

    // Note: In these comments, error1 and error2 are theoretical. The actual Error members

    // are biased by -1.

//

    // distance = (x2 + error2/errorDown2) - (x1 + error1/errorDown1)

    //          = x2 - x1 + error2/errorDown2 - error1/errorDown1

    //          >= x2 - x1 + error2/errorDown2   , since error1 < 0

    //          >= x2 - x1 - 1                   , since error2 < 0

    //          = pEdgeRight->X - pEdgeLeft->X - 1

//

    // In the special case where error2/errorDown2 >= error1/errorDown1, we

    // can get a tigher bound of:

//

    //          pEdgeRight->X - pEdgeLeft->X

//

    // This case occurs often in thin strokes, so we check for it here.

//

    assert!(pEdgeLeft.Error.get()  < 0);

    assert!(pEdgeRight.Error.get() < 0);

    assert!(pEdgeLeft.X <= pEdgeRight.X);

    let mut nSubpixelXDistanceLowerBound: INT = pEdgeRight.X.get() - pEdgeLeft.X.get();

//

    // If error2/errorDown2 < error1/errorDown1, we need to subtract one from the bound.

    // Note that error's are actually baised by -1, we so we have to add one before

    // we do the comparison.

//

    if (IsFractionLessThan(

             pEdgeRight.Error.get()+1,

             pEdgeRight.ErrorDown,

             pEdgeLeft.Error.get()+1,

             pEdgeLeft.ErrorDown

))

            // We can't use the tighter lower bound described above, so we need to subtract one to

            // ensure we have a lower bound.

            nSubpixelXDistanceLowerBound -= 1;

    return nSubpixelXDistanceLowerBound;

pub struct CHwRasterizer<'x, 'y, 'z> {

    m_rcClipBounds: MilPointAndSizeL,

    m_matWorldToDevice: CMILMatrix,

    m_pIGeometrySink: &'x mut CHwVertexBufferBuilder<'y, 'z>,

    m_fillMode: MilFillMode,

/*

DynArray<MilPoint2F> *m_prgPoints;

DynArray<BYTE>       *m_prgTypes;

MilPointAndSizeL      m_rcClipBounds;

CMILMatrix            m_matWorldToDevice;

IGeometrySink        *m_pIGeometrySink;

MilFillMode::Enum     m_fillMode;

//

// Complex scan coverage buffer

//

CCoverageBuffer m_coverageBuffer;

CD3DDeviceLevel1 * m_pDeviceNoRef;*/

    //m_coverageBuffer: CCoverageBuffer,

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::ConvertSubpixelXToPixel

//

//  Synopsis:

//      Convert from our subpixel coordinate (x + error/errorDown)

//      to a floating point value.

//

//-------------------------------------------------------------------------

fn ConvertSubpixelXToPixel(

    x: INT,

    error: INT,

    rErrorDown: f32

    ) -> f32

    assert!(rErrorDown > f32::EPSILON);

    return ((x as f32) + (error as f32)/rErrorDown)*c_rInvShiftSize;

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::ConvertSubpixelYToPixel

//

//  Synopsis:

//      Convert from our subpixel space to pixel space assuming no

//      error.

//

//-------------------------------------------------------------------------

fn ConvertSubpixelYToPixel(

    nSubpixel: i32

    ) -> f32

    return (nSubpixel as f32)*c_rInvShiftSize;

impl<'x, 'y, 'z> CHwRasterizer<'x, 'y, 'z> {

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::RasterizePath

//

//  Synopsis:

//      Internal rasterizer fill path.  Note that this method follows the

//      same basic structure as the software rasterizer in aarasterizer.cpp.

//

//      The general algorithm used for rasterization is a vertical sweep of

//      the shape that maintains an active edge list.  The sweep is done

//      at a sub-scanline resolution and results in either:

//          1. Sub-scanlines being combined in the coverage buffer and output

//             as "complex scans".

//          2. Simple trapezoids being recognized in the active edge list

//             and output using a faster simple trapezoid path.

//

//      This method consists of the setup to the main rasterization loop

//      which includes:

//

//          1. Setup of the clip rectangle

//          2. Calling FixedPointPathEnumerate to populate our inactive

//             edge list.

//          3. Delegating to RasterizePath to execute the main loop.

//

//-------------------------------------------------------------------------

pub fn RasterizePath(

    &mut self,

    rgpt: &[POINT],

    rgTypes: &[BYTE],

    cPoints: UINT,

    pmatWorldTransform: &CMILMatrix

    ) -> HRESULT

    let mut hr;

    // Default is not implemented for arrays of size 40 so we need to use map

    let mut inactiveArrayStack: [CInactiveEdge; INACTIVE_LIST_NUMBER!()] = [(); INACTIVE_LIST_NUMBER!()].map(|_| Default::default());

    let mut pInactiveArray: &mut [CInactiveEdge];

    let mut pInactiveArrayAllocation: Vec<CInactiveEdge>;

    let mut edgeHead: CEdge = Default::default();

    let mut edgeTail: CEdge = Default::default();

    let pEdgeActiveList: Ref<CEdge>;

    let mut edgeStore = Arena::new();

    //edgeStore.init();

    let mut edgeContext: CInitializeEdgesContext = CInitializeEdgesContext::new(&mut edgeStore);

    edgeContext.ClipRect = None;

    edgeTail.X.set(i32::MAX);       // Terminator to active list

    edgeTail.StartY = i32::MAX;  // Terminator to inactive list

    edgeTail.EndY = i32::MIN;

    edgeHead.X.set(i32::MIN);       // Beginning of active list

    edgeContext.MaxY = i32::MIN;

    edgeHead.Next.set(Ref::new(&edgeTail));

    pEdgeActiveList = Ref::new(&mut edgeHead);

    //edgeContext.Store = &mut edgeStore;

    edgeContext.AntiAliasMode = c_antiAliasMode;

    assert!(edgeContext.AntiAliasMode != MilAntiAliasMode::None);

    // If the path contains 0 or 1 points, we can ignore it.

    if (cPoints < 2)

        return S_OK;

    let nPixelYClipBottom: INT = self.m_rcClipBounds.Y + self.m_rcClipBounds.Height;

    // Scale the clip bounds rectangle by 16 to account for our

    // scaling to 28.4 coordinates:

    let mut clipBounds : RECT = Default::default();

    clipBounds.left   = self.m_rcClipBounds.X * FIX4_ONE!();

    clipBounds.top    = self.m_rcClipBounds.Y * FIX4_ONE!();

    clipBounds.right  = (self.m_rcClipBounds.X + self.m_rcClipBounds.Width) * FIX4_ONE!();

    clipBounds.bottom = (self.m_rcClipBounds.Y + self.m_rcClipBounds.Height) * FIX4_ONE!();

    edgeContext.ClipRect = Some(&clipBounds);

    //////////////////////////////////////////////////////////////////////////

    // Convert all our points to 28.4 fixed point:

    let mut matrix: CMILMatrix = (*pmatWorldTransform).clone();

    AppendScaleToMatrix(&mut matrix, TOREAL!(16), TOREAL!(16));

    let coverageBuffer: CCoverageBuffer = Default::default();

    // Initialize the coverage buffer

    coverageBuffer.Initialize();

    // Enumerate the path and construct the edge table:

    hr = MIL_THR!(FixedPointPathEnumerate(

        rgpt,

        rgTypes,

        cPoints,

        &matrix,

        edgeContext.ClipRect,

        &mut edgeContext

));

    if (FAILED(hr))

        if (hr == WGXERR_VALUEOVERFLOW)

            // Draw nothing on value overflow and return

            hr = S_OK;

        return hr;

    let nTotalCount: UINT; nTotalCount = edgeContext.Store.len() as u32;

    if (nTotalCount == 0)

        hr = S_OK;     // We're outta here (empty path or entirely clipped)

        return hr;

    // At this point, there has to be at least two edges.  If there's only

    // one, it means that we didn't do the trivially rejection properly.

    assert!((nTotalCount >= 2) && (nTotalCount <= (UINT::MAX - 2)));

    pInactiveArray = &mut inactiveArrayStack[..];

    if (nTotalCount > (INACTIVE_LIST_NUMBER!() as u32 - 2))

        pInactiveArrayAllocation = vec![Default::default(); nTotalCount as usize + 2];

        pInactiveArray = &mut pInactiveArrayAllocation;

    // Initialize and sort the inactive array:

    let nSubpixelYCurrent = InitializeInactiveArray(

        edgeContext.Store,

        pInactiveArray,

        nTotalCount,

        Ref::new(&edgeTail)

);

    let mut nSubpixelYBottom = edgeContext.MaxY;

    assert!(nSubpixelYBottom > 0);

    // Skip the head sentinel on the inactive array:

    pInactiveArray = &mut pInactiveArray[1..];

//

    // Rasterize the path

//

    // 'nPixelYClipBottom' is in screen space and needs to be converted to the

    // format we use for antialiasing.

    nSubpixelYBottom = nSubpixelYBottom.min(nPixelYClipBottom << c_nShift);

    // 'nTotalCount' should have been zero if all the edges were

    // clipped out (RasterizeEdges assumes there's at least one edge

    // to be drawn):

    assert!(nSubpixelYBottom > nSubpixelYCurrent);

    IFC!(self.RasterizeEdges(

        pEdgeActiveList,

        pInactiveArray,

        &coverageBuffer,

        nSubpixelYCurrent,

        nSubpixelYBottom

));

    return hr;

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::new

//

//  Synopsis:

//      1. Ensure clean state

//      2. Convert path to internal format

//

//-------------------------------------------------------------------------

pub fn new(

    pIGeometrySink: &'x mut CHwVertexBufferBuilder<'y, 'z>,

    fillMode: MilFillMode,

    pmatWorldToDevice: Option<CMatrix<CoordinateSpace::Shape,CoordinateSpace::Device>>,

    clipRect: MilPointAndSizeL,

    ) -> Self

//

    // PS#856364-2003/07/01-ashrafm  Remove pixel center fixup

//

    // Incoming coordinate space uses integers at upper-left of pixel (pixel

    // center are half integers) at device level.

//

    // Rasterizer uses the coordinate space with integers at pixel center.

//

    // To convert from center (1/2, 1/2) to center (0, 0) we need to subtract

    // 1/2 from each coordinate in device space.

//

    // See InitializeEdges in aarasterizer.ccp to see how we unconvert for

    // antialiased rendering.

//

    let mut matWorldHPCToDeviceIPC = pmatWorldToDevice.unwrap_or(CMatrix::Identity());

    matWorldHPCToDeviceIPC.SetDx(matWorldHPCToDeviceIPC.GetDx() - 0.5);

    matWorldHPCToDeviceIPC.SetDy(matWorldHPCToDeviceIPC.GetDy() - 0.5);

//

    // Set local state.

//

    //  There's an opportunity for early clipping here

//

    // However, since the rasterizer itself does a reasonable job of clipping some

    // cases, we don't early clip yet.

    Self {

        m_fillMode: fillMode,

        m_rcClipBounds: clipRect,

        m_pIGeometrySink: pIGeometrySink,

        m_matWorldToDevice: matWorldHPCToDeviceIPC,

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::SendGeometry

//

//  Synopsis:

//     Tessellate and send geometry to the pipeline

//

//-------------------------------------------------------------------------

pub fn SendGeometry(&mut self,

    points: &[POINT],

    types: &[BYTE],

    ) -> HRESULT

    let mut hr = S_OK;

//

    // Rasterize the path

//

    let count = points.len() as u32;

    IFR!(self.RasterizePath(

        points,

        types,

        count,

        &self.m_matWorldToDevice.clone(),

));

/*

    IFC!(self.RasterizePath(

        self.m_prgPoints.as_ref().unwrap().GetDataBuffer(),

        self.m_prgTypes.as_ref().unwrap().GetDataBuffer(),

        self.m_prgPoints.as_ref().unwrap().GetCount() as u32,

        &self.m_matWorldToDevice,

        self.m_fillMode

        ));*/

//

    // It's possible that we output no triangles.  For example, if we tried to fill a

    // line instead of stroke it.  Since we have no efficient way to detect all these cases

    // up front, we simply rasterize and see if we generated anything.

//

    if (self.m_pIGeometrySink.IsEmpty())

        hr = WGXHR_EMPTYFILL;

    RRETURN1!(hr, WGXHR_EMPTYFILL);

/*

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::SendGeometryModifiers

//

//  Synopsis:   Send an AA color source to the pipeline.

//

//-------------------------------------------------------------------------

fn SendGeometryModifiers(&self,

    pPipelineBuilder: &mut CHwPipelineBuilder

    ) -> HRESULT

    let hr = S_OK;

    let pAntiAliasColorSource = None;

    self.m_pDeviceNoRef.GetColorComponentSource(

        CHwColorComponentSource::Diffuse,

        &pAntiAliasColorSource

);

    IFC!(pPipelineBuilder.Set_AAColorSource(

        pAntiAliasColorSource

));

    return hr;

}*/

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::GenerateOutputAndClearCoverage

//

//  Synopsis:

//      Collapse output and generate span data

//

//-------------------------------------------------------------------------

fn

GenerateOutputAndClearCoverage<'a>(&mut self, coverageBuffer: &'a CCoverageBuffer<'a>,

    nSubpixelY: INT

    ) -> HRESULT

    let hr = S_OK;

    let nPixelY = nSubpixelY >> c_nShift;

    let pIntervalSpanStart: Ref<CCoverageInterval> = coverageBuffer.m_pIntervalStart.get();

    IFC!(self.m_pIGeometrySink.AddComplexScan(nPixelY, pIntervalSpanStart));

    coverageBuffer.Reset();

    return hr;

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::ComputeTrapezoidsEndScan

//

//  Synopsis:

//      This methods takes the current active edge list (and ycurrent)

//      and will determine:

//

//      1. Can we output some list of simple trapezoids for this active

//         edge list?  If the answer is no, then we simply return

//         nSubpixelYCurrent indicating this condition.

//

//      2. If we can output some set of trapezoids, then what is the

//         next ycurrent, i.e., how tall are our trapezoids.

//

//     Note that all trapezoids output for a particular active edge list

//     are all the same height.

//

//     To further understand the conditions for making this decision, it

//     is important to consider the simple trapezoid tessellation:

//

//           ___+_________________+___

//          /  +  /             \  +  \        '+' marks active edges

//         /  +  /               \  +  \

//        /  +  /                 \  +  \

//       /__+__/___________________\__+__\

//       1+1/m                         +

//

//      Note that 1+1/edge_slope is the required expand distance to ensure

//      that we cover all pixels required.

//

//      Now, we can fail to output any trapezoids under the following conditions:

//         1. The expand regions along the top edge of the trapezoid overlap.

//         2. The expand regions along the bottom edge of the trapezoid overlap

//            within the current scanline.  Note that if the bottom edges overlap

//            at some later point, we can shorten our trapezoid to remove the

//            overlapping.

//

//      The key to the algorithm at this point is to detect the above condition

//      in our active edge list and either update the returned end y position

//      or reject all together based on overlapping.

//

//-------------------------------------------------------------------------

fn ComputeTrapezoidsEndScan(&mut self,

    pEdgeCurrent: Ref<CEdge>,

    nSubpixelYCurrent: INT,

    nSubpixelYNextInactive: INT

    ) -> INT

    let mut nSubpixelYBottomTrapezoids;

    let mut pEdgeLeft: Ref<CEdge>;

    let mut pEdgeRight: Ref<CEdge>;

//

    // Trapezoids should always start at scanline boundaries

//

    assert!((nSubpixelYCurrent & c_nShiftMask) == 0);

//

    // If we are doing a winding mode fill, check that we can ignore mode and do an

    // alternating fill in OutputTrapezoids.  This condition occurs when winding is

    // equivalent to alternating which happens if the pairwise edges have different

    // winding directions.

//

    if (self.m_fillMode == MilFillMode::Winding)

        let mut pEdge = pEdgeCurrent;

        while pEdge.EndY != INT::MIN {

            // The active edge list always has an even number of edges which we actually

            // assert in ASSERTACTIVELIST.

            assert!(pEdge.Next.get().EndY != INT::MIN);

            // If not alternating winding direction, we can't fill with alternate mode

            if (pEdge.WindingDirection == pEdge.Next.get().WindingDirection)

                // Give up until we handle winding mode

                nSubpixelYBottomTrapezoids = nSubpixelYCurrent;

                return nSubpixelYBottomTrapezoids;

            pEdge = pEdge.Next.get().Next.get();

//

    // For each edge, we:

//

    //    1. Set the new trapezoid bottom to the min of the current

    //       one and the edge EndY

//

    //    2. Check if edges will intersect during trapezoidal shrink/expand

//

    nSubpixelYBottomTrapezoids = nSubpixelYNextInactive;

    let mut pEdge = pEdgeCurrent;

    while pEdge.EndY != INT::MIN {

//

        // Step 1

//

        // Updated nSubpixelYBottomTrapezoids based on edge EndY.

//

        // Since edges are clipped to the current clip rect y bounds, we also know

        // that pEdge->EndY <= nSubpixelYBottom so there is no need to check for that here.

//

        nSubpixelYBottomTrapezoids = nSubpixelYBottomTrapezoids.min(pEdge.EndY);

//

        // Step 2

//

        // Check that edges will not overlap during trapezoid shrink/expand.

//

        pEdgeLeft = pEdge;

        pEdgeRight = pEdge.Next.get();

        if (pEdgeRight.EndY != INT::MIN)

//

            //        __A__A'___________________B'_B__

            //        \  +  \                  /  +  /       '+' marks active edges

            //         \  +  \                /  +  /

            //          \  +  \              /  +  /

            //           \__+__\____________/__+__/

            //       1+1/m   C  C'         D' D

//

            // We need to determine if position A' <= position B' and that position C' <= position D'

            // in the above diagram.  So, we need to ensure that both the distance between

            // A and B and the distance between C and D is greater than or equal to:

//

            //    0.5 + |0.5/m1| + 0.5 + |0.5/m2|               (pixel space)

            //  = shiftsize + halfshiftsize*(|1/m1| + |1/m2|)   (subpixel space)

//

            // So, we'll start by computing this distance.  Note that we can compute a distance

            // that is too large here since the self-intersection detection is simply used to

            // recognize trapezoid opportunities and isn't required for visual correctness.

//

            let nSubpixelExpandDistanceUpperBound: INT =

                c_nShiftSize

                + ComputeDeltaUpperBound(&*pEdgeLeft, c_nHalfShiftSize)

                + ComputeDeltaUpperBound(&*pEdgeRight, c_nHalfShiftSize);

//

            // Compute a top edge distance that is <= to the distance between A' and B' as follows:

            //   lowerbound(distance(A, B)) - nSubpixelExpandDistanceUpperBound

//

            let nSubpixelXTopDistanceLowerBound: INT =

                ComputeDistanceLowerBound(&*pEdgeLeft, &*pEdgeRight) - nSubpixelExpandDistanceUpperBound;

//

            // Check if the top edges cross

//

            if (nSubpixelXTopDistanceLowerBound < 0)

                // The top edges have crossed, so we are out of luck.  We can't

                // start a trapezoid on this scanline

                nSubpixelYBottomTrapezoids = nSubpixelYCurrent;

                return nSubpixelYBottomTrapezoids;

//

            // If the edges are converging, we need to check if they cross at

            // nSubpixelYBottomTrapezoids

//

//

            //  1) \       /    2) \    \       3)   /   /

            //      \     /          \   \          /  /

            //       \   /             \  \        / /

//

            // The edges converge iff (dx1 > dx2 || (dx1 == dx2 && errorUp1/errorDown1 > errorUp2/errorDown2).

//

            // Note that in the case where the edges do not converge, the code below will end up computing

            // the DDA at the end points and checking for intersection again.  This code doesn't rely on

            // the fact that the edges don't converge, so we can be too conservative here.

//

            if (pEdgeLeft.Dx > pEdgeRight.Dx

                || ((pEdgeLeft.Dx == pEdgeRight.Dx)

                    && IsFractionGreaterThan(pEdgeLeft.ErrorUp, pEdgeLeft.ErrorDown, pEdgeRight.ErrorUp, pEdgeRight.ErrorDown)))

                let nSubpixelYAdvance: INT =  nSubpixelYBottomTrapezoids - nSubpixelYCurrent;

                assert!(nSubpixelYAdvance > 0);

//

                // Compute the edge position at nSubpixelYBottomTrapezoids

//

                let mut nSubpixelXLeftAdjustedBottom = 0;

                let mut nSubpixelErrorLeftBottom = 0;

                let mut nSubpixelXRightBottom = 0;

                let mut nSubpixelErrorRightBottom = 0;

                AdvanceDDAMultipleSteps(

                    &*pEdgeLeft,

                    &*pEdgeRight,

                    nSubpixelYAdvance,

                    &mut nSubpixelXLeftAdjustedBottom,

                    &mut nSubpixelErrorLeftBottom,

                    &mut nSubpixelXRightBottom,

                    &mut nSubpixelErrorRightBottom

);

//

                // Adjust the bottom left position by the expand distance for all the math

                // that follows.  Note that since we adjusted the top distance by that

                // same expand distance, this adjustment is equivalent to moving the edges

                // nSubpixelExpandDistanceUpperBound closer together.

//

                nSubpixelXLeftAdjustedBottom += nSubpixelExpandDistanceUpperBound;

//

                // Check if the bottom edge crosses.

//

                // To avoid checking error1/errDown1 and error2/errDown2, we assume the

                // edges cross if nSubpixelXLeftAdjustedBottom == nSubpixelXRightBottom

                // and thus produce a result that is too conservative.

//

                if (nSubpixelXLeftAdjustedBottom >= nSubpixelXRightBottom)

//

                    // At this point, we have the following scenario

//

                    //            ____d1____

                    //            \        /   |   |

                    //              \    /     h1  |

                    //                \/       |   | nSubpixelYAdvance

                    //               /  \          |

                    //             /__d2__\        |

//

                    // We want to compute h1.  We know that:

//

                    //     h1 / nSubpixelYAdvance = d1 / (d1 + d2)

                    //     h1 = nSubpixelYAdvance * d1 / (d1 + d2)

//

                    // Now, if we approximate d1 with some d1' <= d1, we get

//

                    //     h1 = nSubpixelYAdvance * d1 / (d1 + d2)

                    //     h1 >= nSubpixelYAdvance * d1' / (d1' + d2)

//

                    // Similarly, if we approximate d2 with some d2' >= d2, we get

//

                    //     h1 >= nSubpixelYAdvance * d1' / (d1' + d2)

                    //        >= nSubpixelYAdvance * d1' / (d1' + d2')

//

                    // Since we are allowed to be too conservative with h1 (it can be

                    // less than the actual value), we'll construct such approximations

                    // for simplicity.

//

                    // Note that d1' = nSubpixelXTopDistanceLowerBound which we have already

                    // computed.

//

                    //      d2 = (x1 + error1/errorDown1) - (x2 + error2/errorDown2)

                    //         = x1 - x2 + error1/errorDown1 - error2/errorDown2

                    //         <= x1 - x2 - error2/errorDown2   , since error1 < 0

                    //         <= x1 - x2 + 1                   , since error2 < 0

                    //         = nSubpixelXLeftAdjustedBottom - nSubpixelXRightBottom + 1

//

                    let nSubpixelXBottomDistanceUpperBound: INT = nSubpixelXLeftAdjustedBottom - nSubpixelXRightBottom + 1;

                    assert!(nSubpixelXTopDistanceLowerBound >= 0);

                    assert!(nSubpixelXBottomDistanceUpperBound > 0);

                    #[cfg(debug_assertions)]

                    let nDbgPreviousSubpixelXBottomTrapezoids: INT = nSubpixelYBottomTrapezoids;

                    nSubpixelYBottomTrapezoids =

                        nSubpixelYCurrent +

                        (nSubpixelYAdvance * nSubpixelXTopDistanceLowerBound) /

                        (nSubpixelXTopDistanceLowerBound + nSubpixelXBottomDistanceUpperBound);

                    #[cfg(debug_assertions)]

                    assert!(nDbgPreviousSubpixelXBottomTrapezoids >= nSubpixelYBottomTrapezoids);

                    if (nSubpixelYBottomTrapezoids < nSubpixelYCurrent + c_nShiftSize)

                        // We no longer have a trapezoid that is at least one scanline high, so

                        // abort

                        nSubpixelYBottomTrapezoids = nSubpixelYCurrent;

                        return nSubpixelYBottomTrapezoids;

        pEdge = pEdge.Next.get();

//

    // Snap to pixel boundary

//

    nSubpixelYBottomTrapezoids = nSubpixelYBottomTrapezoids & (!c_nShiftMask);

//

    // Ensure that we are never less than nSubpixelYCurrent

//

    assert!(nSubpixelYBottomTrapezoids >= nSubpixelYCurrent);

//

    // Return trapezoid end scan

//

//Cleanup:

    return nSubpixelYBottomTrapezoids;

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::OutputTrapezoids

//

//  Synopsis:

//      Given the current active edge list, output a list of

//      trapezoids.

//

//      _________________________

//     /     /             \     \

//    /     /               \     \

//   /     /                 \     \

//  /_____/___________________\_____\

//  1+1/m

//

// We output a trapezoid where the distance in X is 1+1/m slope on either edge.

// Note that we actually do a linear interpolation for coverage along the

// entire falloff region which comes within 12.5% error when compared to our

// 8x8 coverage output for complex scans.  What is happening here is

// that we are applying a linear approximation to the coverage function

// based on slope.  It is possible to get better linear interpolations

// by varying the expanded region, but it hasn't been necessary to apply

// these quality improvements yet.

//

//-------------------------------------------------------------------------

fn

OutputTrapezoids(&mut self,

    pEdgeCurrent: Ref<CEdge>,

    nSubpixelYCurrent: INT, // inclusive

    nSubpixelYNext: INT     // exclusive

    ) -> HRESULT

    let hr = S_OK;

    let nSubpixelYAdvance: INT;

    let mut rSubpixelLeftErrorDown: f32;

    let mut rSubpixelRightErrorDown: f32;

    let mut rPixelXLeft: f32;

    let mut rPixelXRight: f32;

    let mut rSubpixelLeftInvSlope: f32;

    let mut rSubpixelLeftAbsInvSlope: f32;

    let mut rSubpixelRightInvSlope: f32;

    let mut rSubpixelRightAbsInvSlope: f32;

    let mut rPixelXLeftDelta: f32;

    let mut rPixelXRightDelta: f32;

    let mut pEdgeLeft = pEdgeCurrent;

    let mut pEdgeRight = (*pEdgeCurrent).Next.get();

    assert!((nSubpixelYCurrent & c_nShiftMask) == 0);

    assert!(pEdgeLeft.EndY != INT::MIN);

    assert!(pEdgeRight.EndY != INT::MIN);

//

    // Compute the height our trapezoids

//

    nSubpixelYAdvance = nSubpixelYNext - nSubpixelYCurrent;

//

    // Output each trapezoid

//

    loop

//

        // Compute x/error for end of trapezoid

//

        let mut nSubpixelXLeftBottom: INT = 0;

        let mut nSubpixelErrorLeftBottom: INT = 0;

        let mut nSubpixelXRightBottom: INT = 0;

        let mut nSubpixelErrorRightBottom: INT = 0;

        AdvanceDDAMultipleSteps(

            &*pEdgeLeft,

            &*pEdgeRight,

            nSubpixelYAdvance,

            &mut nSubpixelXLeftBottom,

            &mut nSubpixelErrorLeftBottom,

            &mut nSubpixelXRightBottom,

            &mut nSubpixelErrorRightBottom

);

        // The above computation should ensure that we are a simple

        // trapezoid at this point

        assert!(nSubpixelXLeftBottom <= nSubpixelXRightBottom);

        // We know we have a simple trapezoid now.  Now, compute the end of our current trapezoid

        assert!(nSubpixelYAdvance > 0);

//

        // Computation of edge data

//

        rSubpixelLeftErrorDown  = pEdgeLeft.ErrorDown as f32;

        rSubpixelRightErrorDown = pEdgeRight.ErrorDown as f32;

        rPixelXLeft  = ConvertSubpixelXToPixel(pEdgeLeft.X.get(), pEdgeLeft.Error.get(), rSubpixelLeftErrorDown);

        rPixelXRight = ConvertSubpixelXToPixel(pEdgeRight.X.get(), pEdgeRight.Error.get(), rSubpixelRightErrorDown);

        rSubpixelLeftInvSlope     = pEdgeLeft.Dx as f32 + pEdgeLeft.ErrorUp as f32/rSubpixelLeftErrorDown;

        rSubpixelLeftAbsInvSlope  = rSubpixelLeftInvSlope.abs();

        rSubpixelRightInvSlope    = pEdgeRight.Dx as f32 + pEdgeRight.ErrorUp as f32/rSubpixelRightErrorDown;

        rSubpixelRightAbsInvSlope = rSubpixelRightInvSlope.abs();

        rPixelXLeftDelta  = 0.5 + 0.5 * rSubpixelLeftAbsInvSlope;

        rPixelXRightDelta = 0.5 + 0.5 * rSubpixelRightAbsInvSlope;

        let rPixelYTop         = ConvertSubpixelYToPixel(nSubpixelYCurrent);

        let rPixelYBottom      = ConvertSubpixelYToPixel(nSubpixelYNext);

        let rPixelXBottomLeft  = ConvertSubpixelXToPixel(

                                        nSubpixelXLeftBottom,

                                        nSubpixelErrorLeftBottom,

                                        pEdgeLeft.ErrorDown as f32

);

        let rPixelXBottomRight = ConvertSubpixelXToPixel(

                                        nSubpixelXRightBottom,

                                        nSubpixelErrorRightBottom,

                                        pEdgeRight.ErrorDown as f32

);

//

        // Output the trapezoid

//

        IFC!(self.m_pIGeometrySink.AddTrapezoid(

            rPixelYTop,              // In: y coordinate of top of trapezoid

            rPixelXLeft,             // In: x coordinate for top left

            rPixelXRight,            // In: x coordinate for top right

            rPixelYBottom,           // In: y coordinate of bottom of trapezoid

            rPixelXBottomLeft,       // In: x coordinate for bottom left

            rPixelXBottomRight,      // In: x coordinate for bottom right

            rPixelXLeftDelta,        // In: trapezoid expand radius for left edge

            rPixelXRightDelta        // In: trapezoid expand radius for right edge

));

//

        // Update the edge data

//

        //  no need to do this if edges are stale

        pEdgeLeft.X.set(nSubpixelXLeftBottom);

        pEdgeLeft.Error.set(nSubpixelErrorLeftBottom);

        pEdgeRight.X.set(nSubpixelXRightBottom);

        pEdgeRight.Error.set(nSubpixelErrorRightBottom);

//

        // Check for termination

//

        if (pEdgeRight.Next.get().EndY == INT::MIN)

            break;

//

        // Advance edge data

//

        pEdgeLeft  = pEdgeRight.Next.get();

        pEdgeRight = pEdgeLeft.Next.get();

    return hr;

//-------------------------------------------------------------------------

//

//  Function:   CHwRasterizer::RasterizeEdges

//

//  Synopsis:

//      Rasterize using trapezoidal AA

//

//-------------------------------------------------------------------------

fn

RasterizeEdges<'a, 'b>(&mut self,

    pEdgeActiveList: Ref<'a, CEdge<'a>>,

    mut pInactiveEdgeArray: &'a mut [CInactiveEdge<'a>],

    coverageBuffer: &'b CCoverageBuffer<'b>,

    mut nSubpixelYCurrent: INT,

    nSubpixelYBottom: INT

    ) -> HRESULT

    let hr: HRESULT = S_OK;

    let mut pEdgePrevious: Ref<CEdge>;

    let mut pEdgeCurrent: Ref<CEdge>;

    let mut nSubpixelYNextInactive: INT = 0;

    let mut nSubpixelYNext: INT;

    pInactiveEdgeArray = InsertNewEdges(

        pEdgeActiveList,

        nSubpixelYCurrent,

        pInactiveEdgeArray,

        &mut nSubpixelYNextInactive

);

    while (nSubpixelYCurrent < nSubpixelYBottom)

        ASSERTACTIVELIST!(pEdgeActiveList, nSubpixelYCurrent);

//

        // Detect trapezoidal case

//

        pEdgePrevious = pEdgeActiveList;

        pEdgeCurrent = pEdgeActiveList.Next.get();

        nSubpixelYNext = nSubpixelYCurrent;

        if (!IsTagEnabled!(tagDisableTrapezoids)

            && (nSubpixelYCurrent & c_nShiftMask) == 0

            && pEdgeCurrent.EndY != INT::MIN

            && nSubpixelYNextInactive >= nSubpixelYCurrent + c_nShiftSize

            // Edges are paired, so we can assert we have another one

            assert!(pEdgeCurrent.Next.get().EndY != INT::MIN);

//

            // Given an active edge list, we compute the furthest we can go in the y direction

            // without creating self-intersection or going past the edge EndY.  Note that if we

            // can't even go one scanline, then nSubpixelYNext == nSubpixelYCurrent

//

            nSubpixelYNext = self.ComputeTrapezoidsEndScan(Ref::new(&*pEdgeCurrent), nSubpixelYCurrent, nSubpixelYNextInactive);

            assert!(nSubpixelYNext >= nSubpixelYCurrent);

//

            // Attempt to output a trapezoid.  If it turns out we don't have any

            // potential trapezoids, then nSubpixelYNext == nSubpixelYCurent

            // indicating that we need to fall back to complex scans.

//

            if (nSubpixelYNext >= nSubpixelYCurrent + c_nShiftSize)

                IFC!(self.OutputTrapezoids(

                    pEdgeCurrent,

                    nSubpixelYCurrent,

                    nSubpixelYNext

));

//

        // Rasterize simple trapezoid or a complex scanline

//

        if (nSubpixelYNext > nSubpixelYCurrent)

            // If we advance, it must be by at least one scan line

            assert!(nSubpixelYNext - nSubpixelYCurrent >= c_nShiftSize);

            // Advance nSubpixelYCurrent

            nSubpixelYCurrent = nSubpixelYNext;

            // Remove stale edges.  Note that the DDA is incremented in OutputTrapezoids.

            while (pEdgeCurrent.EndY != INT::MIN)

                if (pEdgeCurrent.EndY <= nSubpixelYCurrent)

                    // Unlink and advance

                    pEdgeCurrent = pEdgeCurrent.Next.get();

                    pEdgePrevious.Next.set(pEdgeCurrent);

                else

                    // Advance

                    pEdgePrevious = pEdgeCurrent;

                    pEdgeCurrent = pEdgeCurrent.Next.get();

        else

//

            // Trapezoid rasterization failed, so

            //   1) Handle case with no active edges, or

            //   2) fall back to scan rasterization

//

            if (pEdgeCurrent.EndY == INT::MIN)

                nSubpixelYNext = nSubpixelYNextInactive;

            else

                nSubpixelYNext = nSubpixelYCurrent + 1;

                if (self.m_fillMode == MilFillMode::Alternate)

                    IFC!(coverageBuffer.FillEdgesAlternating(pEdgeActiveList, nSubpixelYCurrent));

                else

                    IFC!(coverageBuffer.FillEdgesWinding(pEdgeActiveList, nSubpixelYCurrent));

            // If the next scan is done, output what's there:

            if (nSubpixelYNext > (nSubpixelYCurrent | c_nShiftMask))

                IFC!(self.GenerateOutputAndClearCoverage(coverageBuffer, nSubpixelYCurrent));

            // Advance nSubpixelYCurrent

            nSubpixelYCurrent = nSubpixelYNext;

            // Advance DDA and update edge list

            AdvanceDDAAndUpdateActiveEdgeList(nSubpixelYCurrent, pEdgeActiveList);

//

        // Update edge list

//

        if (nSubpixelYCurrent == nSubpixelYNextInactive)

            pInactiveEdgeArray = InsertNewEdges(

                pEdgeActiveList,

                nSubpixelYCurrent,

                pInactiveEdgeArray,

                &mut nSubpixelYNextInactive

);

//

    // Output the last scanline that has partial coverage

//

    if ((nSubpixelYCurrent & c_nShiftMask) != 0)

        IFC!(self.GenerateOutputAndClearCoverage(coverageBuffer, nSubpixelYCurrent));

    RRETURN!(hr);