Revision control
Copy as Markdown
Other Tools
// 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 std::cell::Cell;
use crate::aacoverage::c_nShift;
use crate::bezier::CMILBezier;
use crate::helpers::Int32x32To64;
use crate::matrix::CMILMatrix;
use crate::nullable_ref::Ref;
use crate::real::CFloatFPU;
//use crate::types::PathPointType::*;
use crate::types::*;
use typed_arena_nomut::Arena;
const S_OK: HRESULT = 0;
#[cfg(debug_assertions)]
macro_rules! EDGE_STORE_STACK_NUMBER {
() => {
10
};
}
#[cfg(debug_assertions)]
macro_rules! EDGE_STORE_ALLOCATION_NUMBER { () => { 11 }; }
#[cfg(debug_assertions)]
macro_rules! INACTIVE_LIST_NUMBER { () => { 12 }; }
#[cfg(debug_assertions)]
macro_rules! ENUMERATE_BUFFER_NUMBER { () => { 15 }; }
#[cfg(not(debug_assertions))]
macro_rules! EDGE_STORE_STACK_NUMBER { () => { (1600 / std::mem::size_of::<CEdge>()) }; }
#[cfg(not(debug_assertions))]
macro_rules! EDGE_STORE_ALLOCATION_NUMBER { () => { (4032 / std::mem::size_of::<CEdge>()) as u32 }; }
#[cfg(not(debug_assertions))]
macro_rules! INACTIVE_LIST_NUMBER { () => { EDGE_STORE_STACK_NUMBER!() }; }
#[cfg(not(debug_assertions))]
macro_rules! ENUMERATE_BUFFER_NUMBER { () => { 32 }; }
macro_rules! ASSERTACTIVELIST {
($list: expr, $y: expr) => {
// make sure we use y even in non debug builds
_ = $y;
#[cfg(debug_assertions)]
AssertActiveList($list, $y);
};
}
pub struct CEdge<'a> {
pub Next: Cell<Ref<'a, CEdge<'a>>>, // Next active edge (don't check for NULL,
// look for tail sentinel instead)
pub X: Cell<INT>, // Current X location
pub Dx: INT, // X increment
pub Error: Cell<INT>, // Current DDA error
pub ErrorUp: INT, // Error increment
pub ErrorDown: INT, // Error decrement when the error rolls over
pub StartY: INT, // Y-row start
pub EndY: INT, // Y-row end
pub WindingDirection: INT, // -1 or 1
}
impl<'a> std::default::Default for CEdge<'a> {
fn default() -> Self {
Self {
Next: Cell::new(unsafe { Ref::null() }),
X: Default::default(),
Dx: Default::default(),
Error: Default::default(),
ErrorUp: Default::default(),
ErrorDown: Default::default(),
StartY: Default::default(),
EndY: Default::default(),
WindingDirection: Default::default(),
}
}
}
// We the inactive-array separate from the edge allocations so that
// we can more easily do in-place sorts on it:
#[derive(Clone)]
pub struct CInactiveEdge<'a> {
Edge: Ref<'a, CEdge<'a>>, // Associated edge
Yx: LONGLONG, // Sorting key, StartY and X packed into an lword
}
impl<'a> Default for CInactiveEdge<'a> {
fn default() -> Self {
Self {
Edge: unsafe { Ref::null() },
Yx: Default::default(),
}
}
}
macro_rules! ASSERTACTIVELISTORDER {
($list: expr) => {
#[cfg(debug_assertions)]
AssertActiveListOrder($list)
};
}
/**************************************************************************\
*
* Function Description:
*
* Advance DDA and update active edge list
*
* Created:
*
* 06/20/2003 ashrafm
*
\**************************************************************************/
pub fn AdvanceDDAAndUpdateActiveEdgeList(nSubpixelYCurrent: INT, pEdgeActiveList: Ref<CEdge>) {
let mut outOfOrder = false;
let mut pEdgePrevious: Ref<CEdge> = pEdgeActiveList;
let mut pEdgeCurrent: Ref<CEdge> = pEdgeActiveList.Next.get();
let mut prevX = pEdgePrevious.X.get();
// Advance DDA and update edge list
loop {
if (pEdgeCurrent.EndY <= nSubpixelYCurrent) {
// If we've hit the sentinel, our work here is done:
if (pEdgeCurrent.EndY == INT::MIN) {
break; // ============>
}
// This edge is stale, remove it from the list:
pEdgeCurrent = pEdgeCurrent.Next.get();
pEdgePrevious.Next.set(pEdgeCurrent);
continue; // ============>
}
// Advance the DDA:
let mut x = pEdgeCurrent.X.get() + pEdgeCurrent.Dx;
let mut error = pEdgeCurrent.Error.get() + pEdgeCurrent.ErrorUp;
if (error >= 0) {
error -= pEdgeCurrent.ErrorDown;
x += 1;
}
pEdgeCurrent.X.set(x);
pEdgeCurrent.Error.set(error);
// Is this entry out-of-order with respect to the previous one?
outOfOrder |= (prevX > x);
// Advance:
pEdgePrevious = pEdgeCurrent;
pEdgeCurrent = pEdgeCurrent.Next.get();
prevX = x;
}
// It turns out that having any out-of-order edges at this point
// is extremely rare in practice, so only call the bubble-sort
// if it's truly needed.
//
// NOTE: If you're looking at this code trying to fix a bug where
// the edges are out of order when the filler is called, do
// NOT simply change the code to always do the bubble-sort!
// Instead, figure out what caused our 'outOfOrder' logic
// above to get messed up.
if (outOfOrder) {
SortActiveEdges(pEdgeActiveList);
}
ASSERTACTIVELISTORDER!(pEdgeActiveList);
}
//+----------------------------------------------------------------------------
//
//
// Description: Code for rasterizing the fill of a path.
//
// >>>> Note that some of this code is duplicated in hw\hwrasterizer.cpp,
// >>>> so changes to this file may need to propagate.
//
// pursue reduced code duplication
//
// This option may potentially increase performance for many
// paths that have edges adjacent at their top point and cover
// more than one span. The code has been tested, but performance
// has not been thoroughly investigated.
const SORT_EDGES_INCLUDING_SLOPE: bool = false;
/////////////////////////////////////////////////////////////////////////
// The x86 C compiler insists on making a divide and modulus operation
// into two DIVs, when it can in fact be done in one. So we use this
// macro.
//
// Note: QUOTIENT_REMAINDER implicitly takes unsigned arguments.
//
// QUOTIENT_REMAINDER_64_32 takes a 64-bit numerator and produces 32-bit
// results.
macro_rules! QUOTIENT_REMAINDER {
($ulNumerator: ident, $ulDenominator: ident, $ulQuotient: ident, $ulRemainder: ident) => {
$ulQuotient = (($ulNumerator as ULONG) / ($ulDenominator as ULONG)) as _;
$ulRemainder = (($ulNumerator as ULONG) % ($ulDenominator as ULONG)) as _;
};
}
macro_rules! QUOTIENT_REMAINDER_64_32 {
($ulNumerator: ident, $ulDenominator: ident, $ulQuotient: ident, $ulRemainder: ident) => {
$ulQuotient = (($ulNumerator as ULONGLONG) / (($ulDenominator as ULONG) as ULONGLONG)) as _;
$ulRemainder =
(($ulNumerator as ULONGLONG) % (($ulDenominator as ULONG) as ULONGLONG)) as _;
};
}
// SWAP macro:
macro_rules! SWAP {
($temp: ident, $a: expr, $b: expr) => {
$temp = $a;
$a = $b;
$b = $temp;
};
}
struct CEdgeAllocation {
Next: *mut CEdgeAllocation, // Next allocation batch (may be NULL)
/*__field_range(<=, EDGE_STORE_ALLOCATION_NUMBER)*/ Count: UINT,
EdgeArray: [CEdge<'static>; EDGE_STORE_STACK_NUMBER!()],
}
impl Default for CEdgeAllocation {
fn default() -> Self {
Self { Next: NULL(), Count: Default::default(), EdgeArray: [(); EDGE_STORE_STACK_NUMBER!()].map(|_| Default::default()) }
}
}
/*
pub struct CEdgeStore {
/* __field_range(<=, UINT_MAX - 2) */ TotalCount: UINT, // Total edge count in store
/* __field_range(<=, CurrentBuffer->Count) */
CurrentRemaining: UINT, // How much room remains in current buffer
CurrentBuffer: *mut CEdgeAllocation, // Current buffer
CurrentEdge: *mut CEdge<'static>, // Current edge in current buffer
Enumerator: *mut CEdgeAllocation, // For enumerating all the edges
EdgeHead: CEdgeAllocation, // Our built-in allocation
}
impl Default for CEdgeStore {
fn default() -> Self {
Self { TotalCount: Default::default(), CurrentRemaining: Default::default(), CurrentBuffer: NULL(), CurrentEdge: NULL(), Enumerator: NULL(), EdgeHead: Default::default() }
}
}
impl CEdgeStore {
pub fn init(&mut self) {
self.TotalCount = 0;
self.CurrentBuffer = NULL();
self.CurrentEdge = NULL();
self.Enumerator = NULL();
self.CurrentRemaining = EDGE_STORE_STACK_NUMBER!() as u32;
self.EdgeHead = CEdgeAllocation {
Count: EDGE_STORE_STACK_NUMBER!() as u32,
// hack to work around limited Default implementation for arrays
EdgeArray: [(); EDGE_STORE_STACK_NUMBER!()].map(|_| Default::default()),
Next: NULL(),
};
self.CurrentBuffer = &mut self.EdgeHead;
self.CurrentEdge = &mut self.EdgeHead.EdgeArray[0];
}
}
impl Drop for CEdgeStore {
fn drop(&mut self) {
// Free our allocation list, skipping the head, which is not
// dynamically allocated:
let mut allocation: *mut CEdgeAllocation = self.EdgeHead.Next;
while (allocation != NULL()) {
let next = unsafe { (*allocation).Next };
drop(unsafe { Box::from_raw(allocation) });
allocation = next;
}
}
}
impl CEdgeStore {
pub fn StartEnumeration(&mut self) -> UINT {
unsafe {
self.Enumerator = &mut self.EdgeHead;
// Update the count and make sure nothing more gets added (in
// part because this Count would have to be re-computed):
(*self.CurrentBuffer).Count -= self.CurrentRemaining;
// This will never overflow because NextAddBuffer always ensures that TotalCount has
// space remaining to describe the capacity of all new buffers added to the edge list.
self.TotalCount += (*self.CurrentBuffer).Count;
// Prevent this from being called again, because bad things would
// happen:
self.CurrentBuffer = NULL();
return self.TotalCount;
}
}
fn Enumerate(
&mut self,
/*__deref_out_ecount(*ppEndEdge - *ppStartEdge)*/ ppStartEdge: &mut *mut CEdge,
/* __deref_out_ecount(0) */ ppEndEdge: &mut *mut CEdge,
) -> bool {
/*
unsafe {
let enumerator: *mut CEdgeAllocation = self.Enumerator;
// Might return startEdge == endEdge:
*ppStartEdge = &mut (*enumerator).EdgeArray[0];
*ppEndEdge = (*ppStartEdge).offset((*enumerator).Count as isize);
self.Enumerator = (*enumerator).Next;
return (self.Enumerator != NULL());
}*/
return true;
}
fn StartAddBuffer(
&self,
/*__deref_out_ecount(*puRemaining)*/ ppCurrentEdge: &mut *mut CEdge,
/* __deref_out_range(==, (this->CurrentRemaining)) */ puRemaining: &mut UINT,
) {
panic!()
// *ppCurrentEdge = self.CurrentEdge;
// *puRemaining = self.CurrentRemaining;
}
fn EndAddBuffer(
&mut self,
/*__in_ecount(remaining) */ pCurrentEdge: *mut CEdge,
/* __range(0, (this->CurrentBuffer->Count)) */ remaining: UINT,
) {
panic!();
//self.CurrentEdge = pCurrentEdge;
//self.CurrentRemaining = remaining;
}
// Disable instrumentation checks within all methods of this class
//SET_MILINSTRUMENTATION_FLAGS(MILINSTRUMENTATIONFLAGS_DONOTHING);
}
/**************************************************************************\
*
* Function Description:
*
* The edge initializer is out of room in its current 'store' buffer;
* get it a new one.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
impl CEdgeStore {
fn NextAddBuffer(
&mut self,
/*__deref_out_ecount(*puRemaining)*/ ppCurrentEdge: &mut *mut CEdge,
puRemaining: &mut UINT,
) -> HRESULT {
panic!()
/*
unsafe {
let hr = S_OK;
let mut cNewTotalCount: u32 = 0;
// The caller has completely filled up this chunk:
assert!(*puRemaining == 0);
// Check to make sure that "TotalCount" will be able to represent the current capacity
cNewTotalCount = self.TotalCount + (*self.CurrentBuffer).Count;
if (cNewTotalCount < self.TotalCount) {
return WINCODEC_ERR_VALUEOVERFLOW;
}
// And that it can represent the new capacity as well, with at least 2 to spare.
// This "magic" 2 comes from the fact that the usage pattern of this class has callers
// needing to allocate space for TotalCount + 2 edges.
if (cNewTotalCount + ((EDGE_STORE_ALLOCATION_NUMBER!() + 2) as UINT) < cNewTotalCount) {
return WINCODEC_ERR_VALUEOVERFLOW;
}
// We have to grow our data structure by adding a new buffer
// and adding it to the list:
let newBuffer: *mut CEdgeAllocation = Box::into_raw(Box::<CEdgeAllocation>::new(Default::default()));/*static_cast<CEdgeAllocation*>
(GpMalloc(Mt(MAARasterizerEdge),
sizeof(CEdgeAllocation) +
sizeof(CEdge) * (EDGE_STORE_ALLOCATION_NUMBER
- EDGE_STORE_STACK_NUMBER)));*/
IFCOOM!(newBuffer);
(*newBuffer).Next = NULL();
(*newBuffer).Count = EDGE_STORE_STACK_NUMBER!() as u32;//EDGE_STORE_ALLOCATION_NUMBER!() as u32;
self.TotalCount = cNewTotalCount;
(*self.CurrentBuffer).Next = newBuffer;
self.CurrentBuffer = newBuffer;
self.CurrentEdge = &mut (*newBuffer).EdgeArray[0];
*ppCurrentEdge = panic!();//self.CurrentEdge;
self.CurrentRemaining = EDGE_STORE_STACK_NUMBER!() as u32;//EDGE_STORE_ALLOCATION_NUMBER!();
*puRemaining = EDGE_STORE_STACK_NUMBER!() as u32; //EDGE_STORE_ALLOCATION_NUMBER!();
return hr;
}*/
}
}
*/
/**************************************************************************\
*
* Function Description:
*
* Some debug code for verifying the state of the active edge list.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
pub fn AssertActiveList(mut list: Ref<CEdge>, yCurrent: INT) -> bool {
let mut b = true;
let mut activeCount = 0;
assert!((*list).X.get() == INT::MIN);
b &= ((*list).X.get() == INT::MIN);
// Skip the head sentinel:
list = (*list).Next.get();
while ((*list).X.get() != INT::MAX) {
assert!((*list).X.get() != INT::MIN);
b &= ((*list).X.get() != INT::MIN);
assert!((*list).X <= (*(*list).Next.get()).X);
b &= ((*list).X <= (*(*list).Next.get()).X);
assert!(((*list).StartY <= yCurrent) && (yCurrent < (*list).EndY));
b &= (((*list).StartY <= yCurrent) && (yCurrent < (*list).EndY));
activeCount += 1;
list = (*list).Next.get();
}
assert!((*list).X.get() == INT::MAX);
b &= ((*list).X.get() == INT::MAX);
// There should always be a multiple of 2 edges in the active list.
//
// NOTE: If you hit this assert, do NOT simply comment it out!
// It usually means that all the edges didn't get initialized
// properly. For every scan-line, there has to be a left edge
// and a right edge (or a multiple thereof). So if you give
// even a single bad edge to the edge initializer (or you miss
// one), you'll probably hit this assert.
assert!((activeCount & 1) == 0);
b &= ((activeCount & 1) == 0);
return (b);
}
/**************************************************************************\
*
* Function Description:
*
* Some debug code for verifying the state of the active edge list.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
fn AssertActiveListOrder(mut list: Ref<CEdge>) {
assert!((*list).X.get() == INT::MIN);
// Skip the head sentinel:
list = (*list).Next.get();
while ((*list).X.get() != INT::MAX) {
assert!((*list).X.get() != INT::MIN);
assert!((*list).X <= (*(*list).Next.get()).X);
list = (*list).Next.get();
}
assert!((*list).X.get() == INT::MAX);
}
/**************************************************************************\
*
* Function Description:
*
* Clip the edge vertically.
*
* We've pulled this routine out-of-line from InitializeEdges mainly
* because it needs to call inline Asm, and when there is in-line
* Asm in a routine the compiler generally does a much less efficient
* job optimizing the whole routine. InitializeEdges is rather
* performance critical, so we avoid polluting the whole routine
* by having this functionality out-of-line.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
fn ClipEdge(edgeBuffer: &mut CEdge, yClipTopInteger: INT, dMOriginal: INT) {
let mut xDelta: INT;
let mut error: INT;
// Cases where bigNumerator will exceed 32-bits in precision
// will be rare, but could happen, and we can't fall over
// in those cases.
let dN: INT = edgeBuffer.ErrorDown;
let mut bigNumerator: LONGLONG = Int32x32To64(dMOriginal, yClipTopInteger - edgeBuffer.StartY)
+ (edgeBuffer.Error.get() + dN) as LONGLONG;
if (bigNumerator >= 0) {
QUOTIENT_REMAINDER_64_32!(bigNumerator, dN, xDelta, error);
} else {
bigNumerator = -bigNumerator;
QUOTIENT_REMAINDER_64_32!(bigNumerator, dN, xDelta, error);
xDelta = -xDelta;
if (error != 0) {
xDelta -= 1;
error = dN - error;
}
}
// Update the edge data structure with the results:
edgeBuffer.StartY = yClipTopInteger;
edgeBuffer.X.set(edgeBuffer.X.get() + xDelta);
edgeBuffer.Error.set(error - dN); // Renormalize error
}
pub fn CheckValidRange28_4(x: f32, y: f32) -> bool {
//
// We want coordinates in the 28.4 range in the end. The matrix we get
// as input includes the scale by 16 to get to 28.4, so we want to
// ensure that we are in integer range. Assuming a sign bit and
// five bits for the rasterizer working range, we want coordinates in the
// -2^26 to 2^26.
//
// Note that the 5-bit requirement comes from the
// implementation of InitializeEdges.
// (See line with "error -= dN * (16 - (xStart & 15))")
//
// Anti-aliasing uses another c_nShift bits, so we get a
// desired range of -2^(26-c_nShift) to 2^(26-c_nShift)
//
let rPixelCoordinateMax = (1 << (26 - c_nShift)) as f32;
let rPixelCoordinateMin = -rPixelCoordinateMax;
return x <= rPixelCoordinateMax && x >= rPixelCoordinateMin
&& y <= rPixelCoordinateMax && y >= rPixelCoordinateMin;
}
//+-----------------------------------------------------------------------------
//
// Function: TransformRasterizerPointsTo28_4
//
// Synopsis:
// Transform rasterizer points to 28.4. If overflow occurs, return that
// information.
//
//------------------------------------------------------------------------------
fn TransformRasterizerPointsTo28_4(
pmat: &CMILMatrix,
// Transform to take us to 28.4
mut pPtsSource: &[MilPoint2F],
// Source points
mut cPoints: UINT,
// Count of points
mut pPtsDest: &mut [POINT], // Destination points
) -> HRESULT {
let hr = S_OK;
debug_assert!(cPoints > 0);
while {
//
// Transform coordinates
//
let rPixelX =
(pmat.GetM11() * pPtsSource[0].X) + (pmat.GetM21() * pPtsSource[0].Y) + pmat.GetDx();
let rPixelY =
(pmat.GetM12() * pPtsSource[0].X) + (pmat.GetM22() * pPtsSource[0].Y) + pmat.GetDy();
//
// Check for NaNs or overflow
//
if !CheckValidRange28_4(rPixelX, rPixelY) {
return WGXERR_BADNUMBER;
}
//
// Assign coordinates
//
pPtsDest[0].x = CFloatFPU::Round(rPixelX);
pPtsDest[0].y = CFloatFPU::Round(rPixelY);
pPtsDest = &mut pPtsDest[1..];
pPtsSource = &pPtsSource[1..];
cPoints -= 1;
cPoints != 0
} {}
return hr;
}
pub fn AppendScaleToMatrix(pmat: &mut CMILMatrix, scaleX: REAL, scaleY: REAL) {
pmat.SetM11(pmat.GetM11() * scaleX);
pmat.SetM21(pmat.GetM21() * scaleX);
pmat.SetM12(pmat.GetM12() * scaleY);
pmat.SetM22(pmat.GetM22() * scaleY);
pmat.SetDx(pmat.GetDx() * scaleX);
pmat.SetDy(pmat.GetDy() * scaleY);
}
/**************************************************************************\
*
* Function Description:
*
* Add edges to the edge list.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
pub struct CInitializeEdgesContext<'a> {
pub MaxY: INT, // Maximum 'y' found, should be INT_MIN on
// first call to 'InitializeEdges'
pub ClipRect: Option<&'a RECT>, // Bounding clip rectangle in 28.4 format
pub Store: &'a Arena<CEdge<'a>>, // Where to stick the edges
pub AntiAliasMode: MilAntiAliasMode,
}
impl<'a> CInitializeEdgesContext<'a> {
pub fn new(store: &'a Arena<CEdge<'a>>) -> Self {
CInitializeEdgesContext { MaxY: Default::default(), ClipRect: Default::default(), Store: store, AntiAliasMode: MilAntiAliasMode::None }
}
}
fn InitializeEdges(
pEdgeContext: &mut CInitializeEdgesContext,
/*__inout_ecount(vertexCount)*/
mut pointArray: &mut [POINT], // Points to a 28.4 array of size 'vertexCount'
// Note that we may modify the contents!
/*__in_range(>=, 2)*/ vertexCount: UINT,
) -> HRESULT {
// Disable instrumentation checks for this function
//SET_MILINSTRUMENTATION_FLAGS(MILINSTRUMENTATIONFLAGS_DONOTHING);
let hr = S_OK;
let mut xStart;
let mut yStart;
let mut yStartInteger;
let mut yEndInteger;
let mut dMOriginal;
let mut dM: i32;
let mut dN: i32;
let mut dX: i32;
let mut errorUp: i32;
let mut quotient: i32;
let mut remainder: i32;
let mut error: i32;
let mut windingDirection;
//let mut edgeBuffer: *mut CEdge = NULL();
let bufferCount: UINT = 0;
let mut yClipTopInteger;
let mut yClipTop;
let mut yClipBottom;
let mut xClipLeft;
let mut xClipRight;
let mut yMax = pEdgeContext.MaxY;
let _store = &mut pEdgeContext.Store;
let clipRect = pEdgeContext.ClipRect;
let mut edgeCount = vertexCount - 1;
assert!(edgeCount >= 1);
if let Some(clipRect) = clipRect {
yClipTopInteger = clipRect.top >> 4;
yClipTop = clipRect.top;
yClipBottom = clipRect.bottom;
xClipLeft = clipRect.left;
xClipRight = clipRect.right;
assert!(yClipBottom > 0);
assert!(yClipTop <= yClipBottom);
} else {
yClipBottom = 0;
yClipTopInteger = INT::MIN >> c_nShift;
// These 3 values are only used when clipRect is non-NULL
yClipTop = 0;
xClipLeft = 0;
xClipRight = 0;
}
if (pEdgeContext.AntiAliasMode != MilAntiAliasMode::None) {
// If antialiasing, apply the supersampling scaling here before we
// calculate the DDAs. We do this here and not in the Matrix
// transform we give to FixedPointPathEnumerate mainly so that the
// Bezier flattener can continue to operate in its optimal 28.4
// format.
//
// PS#856364-2003/07/01-JasonHa Remove pixel center fixup
//
// We also apply a half-pixel offset here so that the antialiasing
// code can assume that the pixel centers are at half-pixel
// coordinates, not on the integer coordinates.
let mut point = &mut *pointArray;
let mut i = vertexCount;
while {
point[0].x = (point[0].x + 8) << c_nShift;
point[0].y = (point[0].y + 8) << c_nShift;
point = &mut point[1..];
i -= 1;
i != 0
} {}
yClipTopInteger <<= c_nShift;
yClipTop <<= c_nShift;
yClipBottom <<= c_nShift;
xClipLeft <<= c_nShift;
xClipRight <<= c_nShift;
}
// Make 'yClipBottom' inclusive by subtracting off one pixel
// (keeping in mind that we're in 28.4 device space):
yClipBottom -= 16;
// Warm up the store where we keep the edge data:
//store.StartAddBuffer(&mut edgeBuffer, &mut bufferCount);
'outer: loop { loop {
// Handle trivial rejection:
if (yClipBottom >= 0) {
// Throw out any edges that are above or below the clipping.
// This has to be a precise check, because we assume later
// on that every edge intersects in the vertical dimension
// with the clip rectangle. That asssumption is made in two
// places:
//
// 1. When we sort the edges, we assume either zero edges,
// or two or more.
// 2. When we start the DDAs, we assume either zero edges,
// or that there's at least one scan of DDAs to output.
//
// Plus, of course, it's less efficient if we let things
// through.
//
// Note that 'yClipBottom' is inclusive:
let clipHigh = ((pointArray[0]).y <= yClipTop) && ((pointArray[1]).y <= yClipTop);
let clipLow = ((pointArray[0]).y > yClipBottom) && ((pointArray[1]).y > yClipBottom);
#[cfg(debug_assertions)]
{
let (mut yRectTop, mut yRectBottom, y0, y1, yTop, yBottom);
// Getting the trivial rejection code right is tricky.
// So on checked builds let's verify that we're doing it
// correctly, using a different approach:
let mut clipped = false;
if let Some(clipRect) = clipRect {
yRectTop = clipRect.top >> 4;
yRectBottom = clipRect.bottom >> 4;
if (pEdgeContext.AntiAliasMode != MilAntiAliasMode::None) {
yRectTop <<= c_nShift;
yRectBottom <<= c_nShift;
}
y0 = ((pointArray[0]).y + 15) >> 4;
y1 = ((pointArray[1]).y + 15) >> 4;
yTop = y0.min(y1);
yBottom = y0.max(y1);
clipped = ((yTop >= yRectBottom) || (yBottom <= yRectTop));
}
assert!(clipped == (clipHigh || clipLow));
}
if (clipHigh || clipLow) {
break; // ======================>
}
if (edgeCount > 1) {
// Here we'll collapse two edges down to one if both are
// to the left or to the right of the clipping rectangle.
if (((pointArray[0]).x < xClipLeft)
&& ((pointArray[1]).x < xClipLeft)
&& ((pointArray[2]).x < xClipLeft))
{
// Note this is one reason why 'pointArray' can't be 'const':
pointArray[1] = pointArray[0];
break; // ======================>
}
if (((pointArray[0]).x > xClipRight)
&& ((pointArray[1]).x > xClipRight)
&& ((pointArray[2]).x > xClipRight))
{
// Note this is one reason why 'pointArray' can't be 'const':
pointArray[1] = pointArray[0];
break; // ======================>
}
}
}
dM = (pointArray[1]).x - (pointArray[0]).x;
dN = (pointArray[1]).y - (pointArray[0]).y;
if (dN >= 0) {
// The vector points downward:
xStart = (pointArray[0]).x;
yStart = (pointArray[0]).y;
yStartInteger = (yStart + 15) >> 4;
yEndInteger = ((pointArray[1]).y + 15) >> 4;
windingDirection = 1;
} else {
// The vector points upward, so we have to essentially
// 'swap' the end points:
dN = -dN;
dM = -dM;
xStart = (pointArray[1]).x;
yStart = (pointArray[1]).y;
yStartInteger = (yStart + 15) >> 4;
yEndInteger = ((pointArray[0]).y + 15) >> 4;
windingDirection = -1;
}
// The edgeBuffer must span an integer y-value in order to be
// added to the edgeBuffer list. This serves to get rid of
// horizontal edges, which cause trouble for our divides.
if (yEndInteger > yStartInteger) {
yMax = yMax.max(yEndInteger);
dMOriginal = dM;
if (dM < 0) {
dM = -dM;
if (dM < dN)
// Can't be '<='
{
dX = -1;
errorUp = dN - dM;
} else {
QUOTIENT_REMAINDER!(dM, dN, quotient, remainder);
dX = -quotient;
errorUp = remainder;
if (remainder > 0) {
dX = -quotient - 1;
errorUp = dN - remainder;
}
}
} else {
if (dM < dN) {
dX = 0;
errorUp = dM;
} else {
QUOTIENT_REMAINDER!(dM, dN, quotient, remainder);
dX = quotient;
errorUp = remainder;
}
}
error = -1; // Error is initially zero (add dN - 1 for
// the ceiling, but subtract off dN so that
// we can check the sign instead of comparing
// to dN)
if ((yStart & 15) != 0) {
// Advance to the next integer y coordinate
let mut i = 16 - (yStart & 15);
while i != 0 {
xStart += dX;
error += errorUp;
if (error >= 0)
{
error -= dN;
xStart += 1;
}
i -= 1;
}
}
if ((xStart & 15) != 0) {
error -= dN * (16 - (xStart & 15));
xStart += 15; // We'll want the ceiling in just a bit...
}
xStart >>= 4;
error >>= 4;
if (bufferCount == 0) {
//IFC!(store.NextAddBuffer(&mut edgeBuffer, &mut bufferCount));
}
let mut edge = CEdge {
Next: Cell::new(unsafe { Ref::null() } ),
X: Cell::new(xStart),
Dx: dX,
Error: Cell::new(error),
ErrorUp: errorUp,
ErrorDown: dN,
WindingDirection: windingDirection,
StartY: yStartInteger,
EndY: yEndInteger,// Exclusive of end
};
assert!(error < 0);
// Here we handle the case where the edge starts above the
// clipping rectangle, and we need to jump down in the 'y'
// direction to the first unclipped scan-line.
//
// Consequently, we advance the DDA here:
if (yClipTopInteger > yStartInteger) {
assert!(edge.EndY > yClipTopInteger);
ClipEdge(&mut edge, yClipTopInteger, dMOriginal);
}
// Advance to handle the next edge:
//edgeBuffer = unsafe { edgeBuffer.offset(1) };
pEdgeContext.Store.alloc(edge);
//bufferCount -= 1;
}
break;
}
pointArray = &mut pointArray[1..];
edgeCount -= 1;
if edgeCount == 0 {
break 'outer;
}
}
// We're done with this batch. Let the store know how many edges
// we ended up with:
//store.EndAddBuffer(edgeBuffer, bufferCount);
pEdgeContext.MaxY = yMax;
return hr;
}
/**************************************************************************\
*
* Function Description:
*
* Does complete parameter checking on the 'types' array of a path.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
fn ValidatePathTypes(typesArray: &[BYTE], mut count: INT) -> bool {
let mut types = typesArray;
if (count == 0) {
return (true);
}
loop {
// The first point in every subpath has to be an unadorned
// 'start' point:
if ((types[0] & PathPointTypePathTypeMask) != PathPointTypeStart) {
TraceTag!((tagMILWarning, "Bad subpath start"));
return (false);
}
// Advance to the first point after the 'start' point:
count -= 1;
if (count == 0) {
TraceTag!((tagMILWarning, "Path ended after start-path"));
return (false);
}
if ((types[1] & PathPointTypePathTypeMask) == PathPointTypeStart) {
TraceTag!((tagMILWarning, "Can't have a start followed by a start!"));
return (false);
}
// Process runs of lines and Bezier curves:
loop {
match (types[1] & PathPointTypePathTypeMask) {
PathPointTypeLine => {
types = &types[1..];
count -= 1;
if (count == 0) {
return (true);
}
}
PathPointTypeBezier => {
if (count < 3) {
TraceTag!((
tagMILWarning,
"Path ended before multiple of 3 Bezier points"
));
return (false);
}
if ((types[1] & PathPointTypePathTypeMask) != PathPointTypeBezier) {
TraceTag!((tagMILWarning, "Bad subpath start"));
return (false);
}
types = &types[1..];
count -= 3;
if (count == 0) {
return (true);
}
}
_ => {
TraceTag!((tagMILWarning, "Illegal type"));
return (false);
}
}
// A close-subpath marker or a start-subpath marker marks the
// end of a subpath:
if !(!((types[0] & PathPointTypeCloseSubpath) != 0)
&& ((types[1] & PathPointTypePathTypeMask) != PathPointTypeStart)) {
types = &types[1..];
break;
}
}
}
}
/**************************************************************************\
*
* Function Description:
*
* Some debug code for verifying the path.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
macro_rules! ASSERTPATH {
($types: expr, $points: expr) => {
#[cfg(debug_assertions)]
AssertPath($types, $points)
};
}
fn AssertPath(rgTypes: &[BYTE], cPoints: UINT) {
// Make sure that the 'types' array is well-formed, otherwise we
// may fall over in the FixedPointPathEnumerate function.
//
// NOTE: If you hit this assert, DO NOT SIMPLY COMMENT THIS Assert OUT!
//
// Instead, fix the ValidatePathTypes code if it's letting through
// valid paths, or (more likely) fix the code that's letting bogus
// paths through. The FixedPointPathEnumerate routine has some
// subtle assumptions that require the path to be perfectly valid!
//
// No internal code should be producing invalid paths, and all
// paths created by the application must be parameter checked!
assert!(ValidatePathTypes(rgTypes, cPoints as INT));
}
//+----------------------------------------------------------------------------
//
// Member:
// FixedPointPathEnumerate
//
// Synopsis:
//
// Enumerate the path.
//
// NOTE: The 'enumerateFunction' function is allowed to modify the
// contents of our call-back buffer! (This is mainly done to allow
// 'InitializeEdges' to be simpler for some clipping trivial
// rejection cases.)
//
// NOTICE-2006/03/22-milesc This function was initially built to be a
// general path enumeration function. However, we were only using it for
// one specific purpose... for Initializing edges of a path to be filled.
// In doing security work, I simplified this function to just do edge
// initialization. The name is therefore now overly general. I have kept
// the name to be a reminder that this function has been written to be
// more general than would otherwise be evident.
//
pub fn FixedPointPathEnumerate(
rgpt: &[POINT],
rgTypes: &[BYTE],
cPoints: UINT,
_matrix: &CMILMatrix,
clipRect: Option<&RECT>, // In scaled 28.4 format
enumerateContext: &mut CInitializeEdgesContext,
) -> HRESULT {
let hr = S_OK;
let mut bufferStart: [POINT; ENUMERATE_BUFFER_NUMBER!()] = [(); ENUMERATE_BUFFER_NUMBER!()].map(|_| Default::default());
let mut bezierBuffer: [POINT; 4] = Default::default();
let mut buffer: &mut [POINT];
let mut bufferSize: usize;
let mut startFigure: [POINT; 1] = Default::default();
// The current point offset in rgpt
let mut iPoint: usize;
// The current type offset in rgTypes
let mut iType: usize;
let mut runSize: usize;
let mut thisCount: usize;
let mut isMore: bool = false;
let mut xLast: INT;
let mut yLast: INT;
ASSERTPATH!(rgTypes, cPoints);
// Every valid subpath has at least two vertices in it, hence the
// check of 'cPoints - 1':
iPoint = 0;
iType = 0;
assert!(cPoints > 1);
while (iPoint < cPoints as usize - 1) {
assert!((rgTypes[iType] & PathPointTypePathTypeMask) == PathPointTypeStart);
assert!((rgTypes[iType + 1] & PathPointTypePathTypeMask) != PathPointTypeStart);
// Add the start point to the beginning of the batch, and
// remember it for handling the close figure:
startFigure[0] = rgpt[iPoint];
bufferStart[0].x = startFigure[0].x;
bufferStart[0].y = startFigure[0].y;
let bufferStartPtr = bufferStart.as_ptr();
buffer = &mut bufferStart[1..];
bufferSize = ENUMERATE_BUFFER_NUMBER!() - 1;
// We need to enter our loop with 'iType' pointing one past
// the start figure:
iPoint += 1;
iType += 1;
while {
// Try finding a run of lines:
if ((rgTypes[iType] & PathPointTypePathTypeMask) == PathPointTypeLine) {
runSize = 1;
while ((iPoint + runSize < cPoints as usize)
&& ((rgTypes[iType + runSize] & PathPointTypePathTypeMask) == PathPointTypeLine))
{
runSize += 1;
}
// Okay, we've found a run of lines. Break it up into our
// buffer size:
loop {
thisCount = bufferSize.min(runSize);
buffer[0 .. thisCount].copy_from_slice(&rgpt[iPoint .. iPoint + thisCount]);
__analysis_assume!(
buffer + bufferSize == bufferStart + ENUMERATE_BUFFER_NUMBER
);
assert!(buffer.as_ptr().wrapping_offset(bufferSize as isize) == bufferStartPtr.wrapping_offset(ENUMERATE_BUFFER_NUMBER!()) );
iPoint += thisCount;
iType += thisCount;
buffer = &mut buffer[thisCount..];
runSize -= thisCount;
bufferSize -= thisCount;
if (bufferSize > 0) {
break;
}
xLast = bufferStart[ENUMERATE_BUFFER_NUMBER!() - 1].x;
yLast = bufferStart[ENUMERATE_BUFFER_NUMBER!() - 1].y;
IFR!(InitializeEdges(
enumerateContext,
&mut bufferStart,
ENUMERATE_BUFFER_NUMBER!()
));
// Continue the last vertex as the first in the new batch:
bufferStart[0].x = xLast;
bufferStart[0].y = yLast;
buffer = &mut bufferStart[1..];
bufferSize = ENUMERATE_BUFFER_NUMBER!() - 1;
if !(runSize != 0) {
break;
}
}
} else {
assert!(iPoint + 3 <= cPoints as usize);
assert!((rgTypes[iType] & PathPointTypePathTypeMask) == PathPointTypeBezier);
bezierBuffer.copy_from_slice(&rgpt[(iPoint - 1) .. iPoint + 3]);
// Prepare for the next iteration:
iPoint += 3;
iType += 1;
// Process the Bezier:
let mut bezier = CMILBezier::new(&bezierBuffer, clipRect);
loop {
thisCount = bezier.Flatten(buffer, &mut isMore) as usize;
__analysis_assume!(
buffer + bufferSize == bufferStart + ENUMERATE_BUFFER_NUMBER!()
);
assert!(buffer.as_ptr().wrapping_offset(bufferSize as isize) == bufferStartPtr.wrapping_offset(ENUMERATE_BUFFER_NUMBER!()));
buffer = &mut buffer[thisCount..];
bufferSize -= thisCount;
if (bufferSize > 0) {
break;
}
xLast = bufferStart[ENUMERATE_BUFFER_NUMBER!() - 1].x;
yLast = bufferStart[ENUMERATE_BUFFER_NUMBER!() - 1].y;
IFR!(InitializeEdges(
enumerateContext,
&mut bufferStart,
ENUMERATE_BUFFER_NUMBER!()
));
// Continue the last vertex as the first in the new batch:
bufferStart[0].x = xLast;
bufferStart[0].y = yLast;
buffer = &mut bufferStart[1..];
bufferSize = ENUMERATE_BUFFER_NUMBER!() - 1;
if !isMore {
break;
}
}
}
((iPoint < cPoints as usize)
&& ((rgTypes[iType] & PathPointTypePathTypeMask) != PathPointTypeStart))
} {}
// Okay, the subpath is done. But we still have to handle the
// 'close figure' (which is implicit for a fill):
// Add the close-figure point:
buffer[0].x = startFigure[0].x;
buffer[0].y = startFigure[0].y;
bufferSize -= 1;
// We have to flush anything we might have in the batch, unless
// there's only one vertex in there! (The latter case may happen
// for the stroke case with no close figure if we just flushed a
// batch.)
// If we're flattening, we must call the one additional time to
// correctly handle closing the subpath, even if there is only
// one entry in the batch. The flattening callback handles the
// one point case and closes the subpath properly without adding
// extraneous points.
let verticesInBatch = ENUMERATE_BUFFER_NUMBER!() - bufferSize;
if (verticesInBatch > 1) {
IFR!(InitializeEdges(
enumerateContext,
&mut bufferStart,
(verticesInBatch) as UINT
));
}
}
return hr;
}
/**************************************************************************\
*
* Function Description:
*
* We want to sort in the inactive list; the primary key is 'y', and
* the secondary key is 'x'. This routine creates a single LONGLONG
* key that represents both.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
fn YX(x: INT, y: INT, p: &mut LONGLONG) {
// Bias 'x' by INT_MAX so that it's effectively unsigned:
/*
reinterpret_cast<LARGE_INTEGER*>(p)->HighPart = y;
reinterpret_cast<LARGE_INTEGER*>(p)->LowPart = x + INT_MAX;
*/
*p = (((y as u64) << 32) | (((x as i64 + i32::MAX as i64) as u64) & 0xffffffff)) as i64;
}
/**************************************************************************\
*
* Function Description:
*
* Recursive function to quick-sort our inactive edge list. Note that
* for performance, the results are not completely sorted; an insertion
* sort has to be run after the quicksort in order to do a lighter-weight
* sort of the subtables.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
const QUICKSORT_THRESHOLD: isize = 8;
fn QuickSortEdges(inactive: &mut [CInactiveEdge],
/*__inout_xcount(f - l + 1 elements)*/ f: usize,
/*__inout_xcount(array starts at f)*/ l: usize,
) {
let mut e: Ref<CEdge>;
let mut y: LONGLONG;
let mut first: LONGLONG;
let mut second: LONGLONG;
let mut last: LONGLONG;
// Find the median of the first, middle, and last elements:
let m = f + ((l - f) >> 1);
SWAP!(y, inactive[f + 1].Yx, inactive[m].Yx);
SWAP!(e, inactive[f + 1].Edge, inactive[m].Edge);
if {second = inactive[f + 1].Yx; second > {last = inactive[l].Yx; last}} {
inactive[f + 1].Yx = last;
inactive[l].Yx = second;
SWAP!(e, inactive[f + 1].Edge, inactive[l].Edge);
}
if {first = inactive[f].Yx; first} > {last = inactive[l].Yx; last} {
inactive[f].Yx = last;
inactive[l].Yx = first;
SWAP!(e, inactive[f].Edge, inactive[l].Edge);
}
if {second = inactive[f + 1].Yx; second} > {first = inactive[f].Yx; first} {
inactive[f + 1].Yx = first;
inactive[f].Yx = second;
SWAP!(e, inactive[f + 1].Edge, inactive[f].Edge);
}
// f->Yx is now the desired median, and (f + 1)->Yx <= f->Yx <= l->Yx
debug_assert!((inactive[f + 1].Yx <= inactive[f].Yx) && (inactive[f].Yx <= inactive[l].Yx));
let median = inactive[f].Yx;
let mut i = f + 2;
while (inactive[i].Yx < median) {
i += 1;
}
let mut j = l - 1;
while (inactive[j].Yx > median) {
j -= 1;
}
while (i < j) {
SWAP!(y, inactive[i].Yx, inactive[j].Yx);
SWAP!(e, inactive[i].Edge, inactive[j].Edge);
while {
i = i + 1;
inactive[i].Yx < median
} {}
while {
j = j - 1 ;
inactive[j].Yx > median
} {}
}
SWAP!(y, inactive[f].Yx, inactive[j].Yx);
SWAP!(e, inactive[f].Edge, inactive[j].Edge);
let a = j - f;
let b = l - j;
// Use less stack space by recursing on the shorter subtable. Also,
// have the less-overhead insertion-sort handle small subtables.
if (a <= b) {
if (a > QUICKSORT_THRESHOLD as usize) {
// 'a' is the smallest, so do it first:
QuickSortEdges(inactive, f, j - 1);
QuickSortEdges(inactive, j + 1, l);
} else if (b > QUICKSORT_THRESHOLD as usize) {
QuickSortEdges(inactive, j + 1, l);
}
} else {
if (b > QUICKSORT_THRESHOLD as usize) {
// 'b' is the smallest, so do it first:
QuickSortEdges(inactive, j + 1 , l);
QuickSortEdges(inactive, f, j + 1);
} else if (a > QUICKSORT_THRESHOLD as usize) {
QuickSortEdges(inactive, f, j -1);
}
}
}
/**************************************************************************\
*
* Function Description:
*
* Do a sort of the inactive table using an insertion-sort. Expects
* large tables to have already been sorted via quick-sort.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
fn InsertionSortEdges(
/* __inout_xcount(count forward & -1 back)*/ mut inactive: &mut [CInactiveEdge],
mut count: INT,
) {
let mut e: Ref<CEdge>;
let mut y: LONGLONG;
let mut yPrevious: LONGLONG;
assert!(inactive[0].Yx == i64::MIN);
assert!(count >= 2);
//inactive = &mut inactive[1..];
let mut indx = 2; // Skip first entry (by definition it's already in order!)
count -= 1;
while {
let mut p = indx;
// Copy the current stuff to temporary variables to make a hole:
e = (inactive[indx]).Edge;
y = (inactive[indx]).Yx;
// Shift everything one slot to the right (effectively moving
// the hole one position to the left):
while (y < {yPrevious = inactive[p-1].Yx; yPrevious}) {
inactive[p].Yx = yPrevious;
inactive[p].Edge = inactive[p-1].Edge;
p -= 1;
}
// Drop the temporary stuff into the final hole:
inactive[p].Yx = y;
inactive[p].Edge = e;
// The quicksort should have ensured that we don't have to move
// any entry terribly far:
assert!((indx - p) <= QUICKSORT_THRESHOLD as usize);
indx += 1;
count -= 1;
count != 0
} {}
}
/**************************************************************************\
*
* Function Description:
*
* Assert the state of the inactive array.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
macro_rules! ASSERTINACTIVEARRAY {
($inactive: expr, $count: expr) => {
#[cfg(debug_assertions)]
AssertInactiveArray($inactive, $count);
};
}
fn AssertInactiveArray(
/*__in_ecount(count)*/
mut inactive: &[CInactiveEdge], // Annotation should allow the -1 element
mut count: INT,
) {
// Verify the head:
/*#if !ANALYSIS*/
// #if needed because prefast don't know that the -1 element is avaliable
assert!(inactive[0].Yx == i64::MIN);
/*#endif*/
assert!(inactive[1].Yx != i64::MIN);
while {
let mut yx: LONGLONG = 0;
YX((*inactive[1].Edge).X.get(), (*inactive[1].Edge).StartY, &mut yx);
assert!(inactive[1].Yx == yx);
/*#if !ANALYSIS*/
// #if needed because tools don't know that the -1 element is avaliable
assert!(inactive[1].Yx >= inactive[0].Yx);
/*#endif*/
inactive = &inactive[1..];
count -= 1;
count != 0
} {}
// Verify that the tail is setup appropriately:
assert!((*inactive[1].Edge).StartY == INT::MAX);
}
/**************************************************************************\
*
* Function Description:
*
* Initialize and sort the inactive array.
*
* Returns:
*
* 'y' value of topmost edge.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
pub fn InitializeInactiveArray<'a>(
pEdgeStore: &'a Arena<CEdge<'a>>,
/*__in_ecount(count+2)*/ rgInactiveArray: &mut [CInactiveEdge<'a>],
count: UINT,
tailEdge: Ref<'a, CEdge<'a>> // Tail sentinel for inactive list
) -> INT {
let rgInactiveArrayPtr = rgInactiveArray.as_mut_ptr();
// First initialize the inactive array. Skip the first entry,
// which we reserve as a head sentinel for the insertion sort:
let mut pInactiveEdge = &mut rgInactiveArray[1..];
for e in pEdgeStore.iter() {
pInactiveEdge[0].Edge = Ref::new(e);
YX(e.X.get(), e.StartY, &mut pInactiveEdge[0].Yx);
pInactiveEdge = &mut pInactiveEdge[1..];
}
assert!(unsafe { pInactiveEdge.as_mut_ptr().offset_from(rgInactiveArrayPtr) } as UINT == count + 1);
// Add the tail, which is used when reading back the array. This
// is why we had to allocate the array as 'count + 1':
pInactiveEdge[0].Edge = tailEdge;
// Add the head, which is used for the insertion sort. This is why
// we had to allocate the array as 'count + 2':
rgInactiveArray[0].Yx = i64::MIN;
// Only invoke the quicksort routine if it's worth the overhead:
if (count as isize > QUICKSORT_THRESHOLD) {
// Quick-sort this, skipping the first and last elements,
// which are sentinels.
//
// We do 'inactiveArray + count' to be inclusive of the last
// element:
QuickSortEdges(rgInactiveArray, 1, count as usize);
}
// Do a quick sort to handle the mostly sorted result:
InsertionSortEdges(rgInactiveArray, count as i32);
ASSERTINACTIVEARRAY!(rgInactiveArray, count as i32);
// Return the 'y' value of the topmost edge:
return (*rgInactiveArray[1].Edge).StartY;
}
/**************************************************************************\
*
* Function Description:
*
* Insert edges into the active edge list.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
pub fn InsertNewEdges<'a>(
mut pActiveList: Ref<'a, CEdge<'a>>,
iCurrentY: INT,
/*__deref_inout_xcount(array terminated by an edge with StartY != iCurrentY)*/
ppInactiveEdge: &'a mut [CInactiveEdge<'a>],
pYNextInactive: &mut INT, // will be INT_MAX when no more
) -> &'a mut [CInactiveEdge<'a>] {
let mut inactive: &mut [CInactiveEdge] = ppInactiveEdge;
assert!((*inactive[0].Edge).StartY == iCurrentY);
while {
let newActive: Ref<CEdge> = inactive[0].Edge;
// The activeList edge list sentinel has X = INT_MAX, so this always
// terminates:
while ((*(*pActiveList).Next.get()).X < (*newActive).X) {
pActiveList = (*pActiveList).Next.get();
}
if SORT_EDGES_INCLUDING_SLOPE {
// The activeList edge list sentinel has Dx = INT_MAX, so this always
// terminates:
while (((*(*pActiveList).Next.get()).X == (*newActive).X) && ((*(*pActiveList).Next.get()).Dx < (*newActive).Dx)) {
pActiveList = (*pActiveList).Next.get();
}
}
(*newActive).Next.set((*pActiveList).Next.get());
(*pActiveList).Next.set(newActive);
inactive = &mut inactive[1..];
(*(inactive[0]).Edge).StartY == iCurrentY
} {}
*pYNextInactive = (*(inactive[0]).Edge).StartY;
return inactive;
}
/**************************************************************************\
*
* Function Description:
*
* Sort the edges so that they're in ascending 'x' order.
*
* We use a bubble-sort for this stage, because edges maintain good
* locality and don't often switch ordering positions.
*
* Created:
*
* 03/25/2000 andrewgo
*
\**************************************************************************/
fn SortActiveEdges(list: Ref<CEdge>) {
let mut swapOccurred: bool;
let mut tmp: Ref<CEdge>;
// We should never be called with an empty active edge list:
assert!((*(*list).Next.get()).X.get() != INT::MAX);
while {
swapOccurred = false;
let mut previous = list;
let mut current = (*list).Next.get();
let mut next = (*current).Next.get();
let mut nextX = (*next).X.get();
while {
if (nextX < (*current).X.get()) {
swapOccurred = true;
(*previous).Next.set(next);
(*current).Next.set((*next).Next.get());
(*next).Next.set(current);
SWAP!(tmp, next, current);
}
previous = current;
current = next;
next = (*next).Next.get();
nextX = (*next).X.get();
nextX != INT::MAX
} {}
swapOccurred
} {}
}