wpf-gpu-raster 0.1.0

// 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.


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

use std::cell::Cell;

use typed_arena_nomut::Arena;

//
//  Description:
//      Coverage buffer implementation
#[cfg(debug_assertions)]
use crate::aarasterizer::AssertActiveList;
use crate::aarasterizer::CEdge;
use crate::nullable_ref::Ref;
use crate::types::*;
//struct CEdge;
//struct CInactiveEdge;

//-------------------------------------------------------------------------
//
// TrapezoidalAA only supports 8x8 mode, so the shifts/masks are all
// constants.  Also, since we must be symmetrical, x and y shifts are
// merged into one shift unlike the implementation in aarasterizer.
//
//-------------------------------------------------------------------------

pub const c_nShift: INT = 3; 
pub const c_nShiftSize: INT = 8; 
pub const c_nShiftSizeSquared: INT = c_nShiftSize * c_nShiftSize; 
pub const c_nHalfShiftSize: INT = 4; 
pub const c_nShiftMask: INT = 7; 
//pub const c_rShiftSize: f32 = 8.0;
//pub const c_rHalfShiftSize: f32 = 4.0;
pub const c_rInvShiftSize: f32 = 1.0/8.0;
pub const c_antiAliasMode: MilAntiAliasMode = MilAntiAliasMode::EightByEight;

//
// Interval coverage descriptor for our antialiased filler
//

pub struct CCoverageInterval<'a>
{
    pub m_pNext: Cell<Ref<'a, CCoverageInterval<'a>>>, // m_pNext interval (look for sentinel, not NULL)
    pub m_nPixelX: Cell<INT>,              // Interval's left edge (m_pNext->X is the right edge)
    pub m_nCoverage: Cell<INT>,            // Pixel coverage for interval
}

impl<'a> Default for CCoverageInterval<'a> {
    fn default() -> Self {
        Self { m_pNext: Cell::new(unsafe { Ref::null() } ), m_nPixelX: Default::default(), m_nCoverage: Default::default() }
    }
}

// Define our on-stack storage use.  The 'free' versions are nicely tuned
// to avoid allocations in most common scenarios, while at the same time
// not chewing up toooo much stack space.  
//
// We make the debug versions small so that we hit the 'grow' cases more
// frequently, for better testing:

#[cfg(debug_assertions)]
    // Must be at least 6 now: 4 for the "minus4" logic in hwrasterizer.*, and then 
    // 1 each for the head and tail sentinels (since their allocation doesn't use Grow).
    const INTERVAL_BUFFER_NUMBER: usize = 8;        
#[cfg(not(debug_assertions))]
    const INTERVAL_BUFFER_NUMBER: usize = 32;


//
// Allocator structure for the antialiased fill interval data
//

struct CCoverageIntervalBuffer<'a>
{
    m_pNext: Cell<Option<& 'a CCoverageIntervalBuffer<'a>>>,
    m_interval: [CCoverageInterval<'a>; INTERVAL_BUFFER_NUMBER],
}

impl<'a>  Default for CCoverageIntervalBuffer<'a> {
    fn default() -> Self {
        Self { m_pNext: Cell::new(None), m_interval: Default::default() }
    }
}

//------------------------------------------------------------------------------
//
//  Class: CCoverageBuffer
//
//  Description:
//      Coverage buffer implementation that maintains coverage information
//      for one scanline.  
//
//      This implementation will maintain a linked list of intervals consisting
//      of x value in pixel space and a coverage value that applies for all pixels
//      between pInterval->X and pInterval->Next->X.
//
//      For example, if we add the following interval (assuming 8x8 anti-aliasing)
//      to the coverage buffer:
//       _____ _____ _____ _____
//      |     |     |     |     |
//      |  -------------------  |
//      |_____|_____|_____|_____|
//    (0,0) (1,0) (2,0) (3,0) (4,0)
//
//      Then we will get the following coverage buffer:
//
//     m_nPixelX: INT_MIN  |  0  |  1  |  3  |  4  | INT_MAX
//   m_nCoverage: 0        |  4  |  8  |  4  |  0  | 0xdeadbeef
//       m_pNext: -------->|---->|---->|---->|---->| NULL
//              
//------------------------------------------------------------------------------
pub struct CCoverageBuffer<'a>
{
    /*
public:
    //
    // Init/Destroy methods
    //

    VOID Initialize();
    VOID Destroy();

    //
    // Setup the buffer so that it can accept another scanline
    //

    VOID Reset();

    //
    // Add a subpixel interval to the coverage buffer
    //

    HRESULT FillEdgesAlternating(
        __in_ecount(1) const CEdge *pEdgeActiveList,
        INT nSubpixelYCurrent
        );

    HRESULT FillEdgesWinding(
        __in_ecount(1) const CEdge *pEdgeActiveList,
        INT nSubpixelYCurrent
        );

    HRESULT AddInterval(INT nSubpixelXLeft, INT nSubpixelXRight);

private:

    HRESULT Grow(
        __deref_out_ecount(1) CCoverageInterval **ppIntervalNew, 
        __deref_out_ecount(1) CCoverageInterval **ppIntervalEndMinus4
        );

public:*/
    pub m_pIntervalStart: Cell<Ref<'a, CCoverageInterval<'a>>>,           // Points to list head entry

//private:
    m_pIntervalNew: Cell<Ref<'a, CCoverageInterval<'a>>>,
    interval_new_index: Cell<usize>,

    // The Minus4 in the below variable refers to the position at which
    // we need to Grow the buffer.  The buffer is grown once before an
    // AddInterval, so the Grow has to ensure that there are enough 
    // intervals for the AddInterval worst case which is the following:
    //
    //  1     2           3     4
    //  *_____*_____ _____*_____* 
    //  |     |     |     |     |
    //  |  ---|-----------|---  |
    //  |_____|_____|_____|_____|
    //
    // Note that the *'s above mark potentional insert points in the list,
    // so we need to ensure that at least 4 intervals can be allocated.
    //

    m_pIntervalEndMinus4:  Cell<Ref<'a, CCoverageInterval<'a>>>,

    // Cache the next-to-last added interval to accelerate insertion.
    m_pIntervalLast: Cell<Ref<'a, CCoverageInterval<'a>>>,

    m_pIntervalBufferBuiltin: CCoverageIntervalBuffer<'a>,
    m_pIntervalBufferCurrent: Cell<Ref<'a, CCoverageIntervalBuffer<'a>>>,

    arena: Arena<CCoverageIntervalBuffer<'a>>
       
    // Disable instrumentation checks within all methods of this class
    //SET_MILINSTRUMENTATION_FLAGS(MILINSTRUMENTATIONFLAGS_DONOTHING);
}

impl<'a> Default for CCoverageBuffer<'a> {
    fn default() -> Self {
        Self {
            m_pIntervalStart: Cell::new(unsafe { Ref::null() }),
            m_pIntervalNew: Cell::new(unsafe { Ref::null() }),
            m_pIntervalEndMinus4: Cell::new(unsafe { Ref::null() }),
            m_pIntervalLast: Cell::new(unsafe { Ref::null() }),
            m_pIntervalBufferBuiltin: Default::default(),
            m_pIntervalBufferCurrent: unsafe { Cell::new(Ref::null()) },
            arena: Arena::new(),
            interval_new_index: Cell::new(0),
        }
    }
}


//
// Inlines
//
impl<'a> CCoverageBuffer<'a> {
//-------------------------------------------------------------------------
//
//  Function:   CCoverageBuffer::AddInterval
//
//  Synopsis:   Add a subpixel resolution interval to the coverage buffer
// 
//-------------------------------------------------------------------------
pub fn AddInterval(&'a self, nSubpixelXLeft: INT, nSubpixelXRight: INT) -> HRESULT
{
    let hr: HRESULT = S_OK;
    let mut nPixelXNext: INT;
    let nPixelXLeft: INT;
    let nPixelXRight: INT;
    let nCoverageLeft: INT;  // coverage from right edge of pixel for interval start
    let nCoverageRight: INT; // coverage from left edge of pixel for interval end

    let mut pInterval = self.m_pIntervalStart.get();
    let mut pIntervalNew = self.m_pIntervalNew.get();
    let mut interval_new_index = self.interval_new_index.get();
    let mut pIntervalEndMinus4 = self.m_pIntervalEndMinus4.get();

    // Make sure we have enough room to add two intervals if
    // necessary:

    if (pIntervalNew >= pIntervalEndMinus4)
    {
        IFC!(self.Grow(&mut pIntervalNew, &mut pIntervalEndMinus4, &mut interval_new_index));
    }

    // Convert interval to pixel space so that we can insert it 
    // into the coverage buffer

    debug_assert!(nSubpixelXLeft < nSubpixelXRight);
    nPixelXLeft = nSubpixelXLeft >> c_nShift;
    nPixelXRight = nSubpixelXRight >> c_nShift; 

    // Try to resume searching from the last searched interval.
    if self.m_pIntervalLast.get().m_nPixelX.get() < nPixelXLeft {
        pInterval = self.m_pIntervalLast.get();
    }

    // Skip any intervals less than 'nPixelLeft':

    loop {
        let nextInterval = pInterval.m_pNext.get();
        nPixelXNext = nextInterval.m_nPixelX.get();
        if !(nPixelXNext < nPixelXLeft) { break }

        pInterval = nextInterval;
    }

    // Remember the found interval.
    self.m_pIntervalLast.set(pInterval);

    // Insert a new interval if necessary:

    if (nPixelXNext != nPixelXLeft)
    {
        pIntervalNew.m_nPixelX.set(nPixelXLeft);
        pIntervalNew.m_nCoverage.set(pInterval.m_nCoverage.get());

        pIntervalNew.m_pNext.set(pInterval.m_pNext.get());
        pInterval.m_pNext.set(pIntervalNew);

        pInterval = pIntervalNew;

        interval_new_index += 1;
        pIntervalNew = Ref::new(&Ref::get_ref(self.m_pIntervalBufferCurrent.get()).m_interval[interval_new_index])

    }
    else
    {
        pInterval = (*pInterval).m_pNext.get();
    }

    //
    // Compute coverage for left segment as shown by the *'s below
    //
    //  |_____|_____|_____|_
    //  |     |     |     |
    //  |  ***----------  |
    //  |_____|_____|_____|
    //

    nCoverageLeft = c_nShiftSize - (nSubpixelXLeft & c_nShiftMask);

    // If nCoverageLeft == 0, then the value of nPixelXLeft is wrong
    // and should have been equal to nPixelXLeft+1.
    debug_assert!(nCoverageLeft > 0);

    // If we have partial coverage, then ensure that we have a position
    // for the end of the pixel 

    if ((nCoverageLeft < c_nShiftSize || (nPixelXLeft == nPixelXRight))
        && nPixelXLeft + 1 != pInterval.m_pNext.get().m_nPixelX.get())
    {
        pIntervalNew.m_nPixelX.set(nPixelXLeft + 1);
        pIntervalNew.m_nCoverage.set(pInterval.m_nCoverage.get());

        pIntervalNew.m_pNext.set(pInterval.m_pNext.get());
        pInterval.m_pNext.set(pIntervalNew);

        interval_new_index += 1;
        pIntervalNew = Ref::new(&Ref::get_ref(self.m_pIntervalBufferCurrent.get()).m_interval[interval_new_index])
    }
    
    //
    // If the interval only includes one pixel, then the coverage is
    // nSubpixelXRight - nSubpixelXLeft
    //

    if (nPixelXLeft == nPixelXRight)
    {
        pInterval.m_nCoverage.set(pInterval.m_nCoverage.get() + nSubpixelXRight - nSubpixelXLeft);
        debug_assert!(pInterval.m_nCoverage.get() <= c_nShiftSize*c_nShiftSize);
        //goto Cleanup;

        //Cleanup:
        // Update the coverage buffer new interval
        self.interval_new_index.set(interval_new_index);
        self.m_pIntervalNew.set(pIntervalNew);
        return hr;
    }

    // Update coverage of current interval
    pInterval.m_nCoverage.set(pInterval.m_nCoverage.get() + nCoverageLeft);
    debug_assert!(pInterval.m_nCoverage.get() <= c_nShiftSize*c_nShiftSize);

    // Increase the coverage for any intervals between 'nPixelXLeft'
    // and 'nPixelXRight':

    loop {
        let nextInterval = pInterval.m_pNext.get();
        (nPixelXNext = nextInterval.m_nPixelX.get());
    
        if !(nPixelXNext < nPixelXRight) {
            break;
        }
        pInterval = nextInterval;
        pInterval.m_nCoverage.set(pInterval.m_nCoverage.get() + c_nShiftSize);
        debug_assert!(pInterval.m_nCoverage.get() <= c_nShiftSize*c_nShiftSize);
    }

    // Remember the found interval.
    self.m_pIntervalLast.set(pInterval);

    // Insert another new interval if necessary:

    if (nPixelXNext != nPixelXRight)
    {
        pIntervalNew.m_nPixelX.set(nPixelXRight);
        pIntervalNew.m_nCoverage.set(pInterval.m_nCoverage.get() - c_nShiftSize);

        pIntervalNew.m_pNext.set(pInterval.m_pNext.get());
        pInterval.m_pNext.set(pIntervalNew);

        pInterval = pIntervalNew;

        interval_new_index += 1;
        pIntervalNew = Ref::new(&Ref::get_ref(self.m_pIntervalBufferCurrent.get()).m_interval[interval_new_index])
    }
    else
    {
        pInterval = pInterval.m_pNext.get();
    }

    //
    // Compute coverage for right segment as shown by the *'s below
    //
    //  |_____|_____|_____|_
    //  |     |     |     |
    //  |  ---------****  |
    //  |_____|_____|_____|
    //

    nCoverageRight = nSubpixelXRight & c_nShiftMask;
    if (nCoverageRight > 0)
    {
        if (nPixelXRight + 1 != (*(*pInterval).m_pNext.get()).m_nPixelX.get())
        {
            pIntervalNew.m_nPixelX.set(nPixelXRight + 1);
            pIntervalNew.m_nCoverage.set(pInterval.m_nCoverage.get());

            pIntervalNew.m_pNext.set(pInterval.m_pNext.get());
            pInterval.m_pNext.set(pIntervalNew);

            interval_new_index += 1;
            pIntervalNew = Ref::new(&Ref::get_ref(self.m_pIntervalBufferCurrent.get()).m_interval[interval_new_index])
        }

        pInterval.m_nCoverage.set((*pInterval).m_nCoverage.get() + nCoverageRight);
        debug_assert!(pInterval.m_nCoverage.get() <= c_nShiftSize*c_nShiftSize);
    }

//Cleanup:
    // Update the coverage buffer new interval
    self.interval_new_index.set(interval_new_index);
    self.m_pIntervalNew.set(pIntervalNew);

    return hr;
}


//-------------------------------------------------------------------------
//
//  Function:   CCoverageBuffer::FillEdgesAlternating
//
//  Synopsis:   
//      Given the active edge list for the current scan, do an alternate-mode
//      antialiased fill.
//
//-------------------------------------------------------------------------
pub fn FillEdgesAlternating(&'a self,
    pEdgeActiveList: Ref<CEdge>,
    nSubpixelYCurrent: INT
    ) -> HRESULT
{

    let hr: HRESULT = S_OK;
    let mut pEdgeStart: Ref<CEdge> = (*pEdgeActiveList).Next.get();
    let mut pEdgeEnd: Ref<CEdge>;
    let mut nSubpixelXLeft: INT;
    let mut nSubpixelXRight: INT;

    ASSERTACTIVELIST!(pEdgeActiveList, nSubpixelYCurrent);

    while (pEdgeStart.X.get() != INT::MAX)
    {
        pEdgeEnd = pEdgeStart.Next.get();

        // We skip empty pairs:
        (nSubpixelXLeft = pEdgeStart.X.get());
        if (nSubpixelXLeft != pEdgeEnd.X.get())
        {
            // We now know we have a non-empty interval.  Skip any
            // empty interior pairs:

            while ({(nSubpixelXRight = pEdgeEnd.X.get()); pEdgeEnd.X == pEdgeEnd.Next.get().X})
            {
                pEdgeEnd = pEdgeEnd.Next.get().Next.get();
            }

            debug_assert!((nSubpixelXLeft < nSubpixelXRight) && (nSubpixelXRight < INT::MAX));

            IFC!(self.AddInterval(nSubpixelXLeft, nSubpixelXRight));
        }

        // Prepare for the next iteration:
        pEdgeStart = pEdgeEnd.Next.get();
    }

//Cleanup:
    return hr

}

//-------------------------------------------------------------------------
//
//  Function:   CCoverageBuffer::FillEdgesWinding
//
//  Synopsis:   
//      Given the active edge list for the current scan, do an alternate-mode
//      antialiased fill.
//
//-------------------------------------------------------------------------
pub fn FillEdgesWinding(&'a self,
    pEdgeActiveList: Ref<CEdge>,
    nSubpixelYCurrent: INT
    ) -> HRESULT
{

    let hr: HRESULT = S_OK;
    let mut pEdgeStart: Ref<CEdge> = pEdgeActiveList.Next.get();
    let mut pEdgeEnd: Ref<CEdge>;
    let mut nSubpixelXLeft: INT;
    let mut nSubpixelXRight: INT;
    let mut nWindingValue: INT;

    ASSERTACTIVELIST!(pEdgeActiveList, nSubpixelYCurrent);

    while (pEdgeStart.X.get() != INT::MAX)
    {
        pEdgeEnd = pEdgeStart.Next.get();

        nWindingValue = pEdgeStart.WindingDirection;
        while ({nWindingValue += pEdgeEnd.WindingDirection; nWindingValue != 0})
        {
            pEdgeEnd = pEdgeEnd.Next.get();
        }

        debug_assert!(pEdgeEnd.X.get() != INT::MAX);

        // We skip empty pairs:

        if ({nSubpixelXLeft = pEdgeStart.X.get(); nSubpixelXLeft != pEdgeEnd.X.get()})
        {
            // We now know we have a non-empty interval.  Skip any
            // empty interior pairs:

            while ({nSubpixelXRight = pEdgeEnd.X.get(); nSubpixelXRight == pEdgeEnd.Next.get().X.get()})
            {
                pEdgeStart = pEdgeEnd.Next.get();
                pEdgeEnd = pEdgeStart.Next.get();

                nWindingValue = pEdgeStart.WindingDirection;
                while ({nWindingValue += pEdgeEnd.WindingDirection; nWindingValue != 0})
                {
                    pEdgeEnd = pEdgeEnd.Next.get();
                }
            }

            debug_assert!((nSubpixelXLeft < nSubpixelXRight) && (nSubpixelXRight < INT::MAX));

            IFC!(self.AddInterval(nSubpixelXLeft, nSubpixelXRight));
        }

        // Prepare for the next iteration:

        pEdgeStart = pEdgeEnd.Next.get();
    } 

//Cleanup:
    return hr;//RRETURN(hr);
}

//-------------------------------------------------------------------------
//
//  Function:   CCoverageBuffer::Initialize
//
//  Synopsis:   Set the coverage buffer to a valid initial state
// 
//-------------------------------------------------------------------------
pub fn Initialize(&'a self) 
{
    self.m_pIntervalBufferBuiltin.m_interval[0].m_nPixelX.set(INT::MIN);
    self.m_pIntervalBufferBuiltin.m_interval[0].m_nCoverage.set(0);
    self.m_pIntervalBufferBuiltin.m_interval[0].m_pNext.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[1]));

    self.m_pIntervalBufferBuiltin.m_interval[1].m_nPixelX.set(INT::MAX);
    self.m_pIntervalBufferBuiltin.m_interval[1].m_nCoverage.set(0xdeadbeef);
    self.m_pIntervalBufferBuiltin.m_interval[1].m_pNext.set(unsafe { Ref::null() });

    self.m_pIntervalBufferBuiltin.m_pNext.set(None);
    self.m_pIntervalBufferCurrent.set(Ref::new(&self.m_pIntervalBufferBuiltin));

    self.m_pIntervalStart.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[0]));
    self.m_pIntervalNew.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[2]));
    self.interval_new_index.set(2);
    self.m_pIntervalEndMinus4.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[INTERVAL_BUFFER_NUMBER - 4]));
    self.m_pIntervalLast.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[1]));
}

//-------------------------------------------------------------------------
//
//  Function:   CCoverageBuffer::Destroy
//
//  Synopsis:   Free all allocated buffers
// 
//-------------------------------------------------------------------------
pub fn Destroy(&mut self)
{
    // Free the linked-list of allocations (skipping 'm_pIntervalBufferBuiltin',
    // which is built into the class):


}


//-------------------------------------------------------------------------
//
//  Function:   CCoverageBuffer::Reset
//
//  Synopsis:   Reset the coverage buffer
// 
//-------------------------------------------------------------------------
pub fn Reset(&'a self)
{
    // Reset our coverage structure.  Point the head back to the tail,
    // and reset where the next new entry will be placed:

    self.m_pIntervalBufferBuiltin.m_interval[0].m_pNext.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[1]));

    self.m_pIntervalBufferCurrent.set(Ref::new(&self.m_pIntervalBufferBuiltin));
    self.m_pIntervalNew.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[2]));
    self.interval_new_index.set(2);
    self.m_pIntervalEndMinus4.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[INTERVAL_BUFFER_NUMBER - 4]));
    self.m_pIntervalLast.set(Ref::new(&self.m_pIntervalBufferBuiltin.m_interval[1]));
}

//-------------------------------------------------------------------------
//
//  Function:   CCoverageBuffer::Grow
//
//  Synopsis:   
//      Grow our interval buffer.
//
//-------------------------------------------------------------------------
fn Grow(&'a self,
    ppIntervalNew: &mut Ref<'a, CCoverageInterval<'a>>, 
    ppIntervalEndMinus4: &mut Ref<'a, CCoverageInterval<'a>>,
    interval_new_index: &mut usize
    ) -> HRESULT
{
    let hr: HRESULT = S_OK;
    let pIntervalBufferNew = (*self.m_pIntervalBufferCurrent.get()).m_pNext.get();

    let pIntervalBufferNew = pIntervalBufferNew.unwrap_or_else(||
    {
        let pIntervalBufferNew = self.arena.alloc(Default::default());

        (*pIntervalBufferNew).m_pNext.set(None);
        (*self.m_pIntervalBufferCurrent.get()).m_pNext.set(Some(pIntervalBufferNew));
        pIntervalBufferNew
    });

    self.m_pIntervalBufferCurrent.set(Ref::new(pIntervalBufferNew));

    self.m_pIntervalNew.set(Ref::new(&(*pIntervalBufferNew).m_interval[2]));
    self.interval_new_index.set(2);
    self.m_pIntervalEndMinus4.set(Ref::new(&(*pIntervalBufferNew).m_interval[INTERVAL_BUFFER_NUMBER - 4]));

    *ppIntervalNew = self.m_pIntervalNew.get();
    *ppIntervalEndMinus4 = self.m_pIntervalEndMinus4.get();
    *interval_new_index = 2;

    return hr;
}

}
/* 
impl<'a> Drop for CCoverageBuffer<'a> {
    fn drop(&mut self) {
        self.Destroy();
    }
}*/