Quelle  hwrasterizer.rs

// 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(&e='color:red'>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);
}

}