static void SwapCells(CellAA a, CellAA b)
{
CellAA temp = a;
a = b;
b = temp;
}
public bool NotEqual(int ex, int ey, CellAA cell)
{
unchecked
{
return(((ex - X) | (ey - Y) | (Left - cell.Left) | (Right - cell.Right)) != 0);
}
}
public void Styles(int left, int right)
{
CellAA cell = new CellAA();
cell.Initial();
cell.Left = (short)left;
cell.Right = (short)right;
m_Rasterizer.Style(cell);
if (left >= 0 && left < m_min_style)
{
m_min_style = left;
}
if (left >= 0 && left > m_max_style)
{
m_max_style = left;
}
if (right >= 0 && right < m_min_style)
{
m_min_style = right;
}
if (right >= 0 && right > m_max_style)
{
m_max_style = right;
}
}
public void Set(CellAA cellB)
{
X = cellB.X;
Y = cellB.Y;
Cover = cellB.Cover;
Area = cellB.Area;
Left = cellB.Left;
Right = cellB.Right;
}
public void Sort(CellAA[] dataToSort, uint beg, uint end)
{
if (end == beg)
{
return;
}
else
{
uint pivot = GetPivotPoint(dataToSort, beg, end);
if (pivot > beg)
{
Sort(dataToSort, beg, pivot - 1);
}
if (pivot < end)
{
Sort(dataToSort, pivot + 1, end);
}
}
}
private uint GetPivotPoint(CellAA[] dataToSort, uint begPoint, uint endPoint)
{
uint pivot = begPoint;
uint m = begPoint+1;
uint n = endPoint;
while ((m < endPoint)
&& dataToSort[pivot].X >= dataToSort[m].X)
{
m++;
}
while ((n > begPoint) && (dataToSort[pivot].X <= dataToSort[n].X))
{
n--;
}
while (m < n)
{
CellAA temp = dataToSort[m];
dataToSort[m] = dataToSort[n];
dataToSort[n] = temp;
while ((m < endPoint) && (dataToSort[pivot].X >= dataToSort[m].X))
{
m++;
}
while ((n > begPoint) && (dataToSort[pivot].X <= dataToSort[n].X))
{
n--;
}
}
if (pivot != n)
{
CellAA temp2 = dataToSort[n];
dataToSort[n] = dataToSort[pivot];
dataToSort[pivot] = temp2;
}
return n;
}
static void SwapCells(CellAA a, CellAA b)
{
CellAA temp = a;
a = b;
b = temp;
}
public void ScanlineCells(uint y, out CellAA[] CellData, out uint Offset)
{
CellData = m_sorted_cells.Data();
Offset = m_sorted_y[(int)y - m_min_y].start;
}
public void Style(CellAA style_cell)
{
m_style_cell.Style(style_cell);
}
public bool NotEqual(int ex, int ey, CellAA cell)
{
unchecked
{
return ((ex - X) | (ey - Y) | (Left - cell.Left) | (Right - cell.Right)) != 0;
}
}
public void Style(CellAA cellB)
{
Left = cellB.Left;
Right = cellB.Right;
}
public void Set(CellAA cellB)
{
X = cellB.X;
Y = cellB.Y;
Cover = cellB.Cover;
Area = cellB.Area;
Left = cellB.Left;
Right = cellB.Right;
}
//--------------------------------------------------------------------
public bool SweepScanline(IScanlineCache sl)
{
#if use_timers
SweepSacanLine.Start();
#endif
for (; ;)
{
if (m_scan_y > m_outline.MaxY)
{
#if use_timers
SweepSacanLine.Stop();
#endif
return(false);
}
sl.ResetSpans();
uint scan_y_uint = 0; // it is going to get initialize to 0 anyway so make it clear.
if (m_scan_y > 0)
{
scan_y_uint = (uint)m_scan_y;
}
uint num_cells = m_outline.ScanlineNumCells(scan_y_uint);
CellAA[] cells;
uint Offset;
m_outline.ScanlineCells(scan_y_uint, out cells, out Offset);
int cover = 0;
while (num_cells != 0)
{
CellAA cur_cell = cells[Offset];
int x = cur_cell.X;
int area = cur_cell.Area;
uint alpha;
cover += cur_cell.Cover;
//accumulate all cells with the same X
while (--num_cells != 0)
{
Offset++;
cur_cell = cells[Offset];
if (cur_cell.X != x)
{
break;
}
area += cur_cell.Area;
cover += cur_cell.Cover;
}
if (area != 0)
{
alpha = CalculateAlpha((cover << ((int)poly_subpixel_scale_e.Shift + 1)) - area);
if (alpha != 0)
{
sl.AddCell(x, alpha);
}
x++;
}
if ((num_cells != 0) && (cur_cell.X > x))
{
alpha = CalculateAlpha(cover << ((int)poly_subpixel_scale_e.Shift + 1));
if (alpha != 0)
{
sl.AddSpan(x, (cur_cell.X - x), alpha);
}
}
}
if (sl.NumSpans != 0)
{
break;
}
++m_scan_y;
}
sl.Finalize(m_scan_y);
++m_scan_y;
#if use_timers
SweepSacanLine.Stop();
#endif
return(true);
}
// Sweeps one scanline with one style index. The style ID can be
// determined by calling style().
//template<class Scanline>
public bool SweepScanline(IScanlineCache sl, int style_idx)
{
int scan_y = m_scan_y - 1;
if (scan_y > m_Rasterizer.MaxY)
{
return(false);
}
sl.ResetSpans();
uint master_alpha = AAMask;
if (style_idx < 0)
{
style_idx = 0;
}
else
{
style_idx++;
master_alpha = m_master_alpha[(uint)(m_ast[(uint)style_idx] + m_min_style - 1)];
}
StyleInfo st = m_styles[m_ast[style_idx]];
int num_cells = (int)st.num_cells;
uint CellOffset = st.start_cell;
CellAA cell = m_cells[CellOffset];
int cover = 0;
while (num_cells-- != 0)
{
uint alpha;
int x = cell.X;
int area = cell.Area;
cover += cell.Cover;
cell = m_cells[++CellOffset];
if (area != 0)
{
alpha = CalculateAlpha((cover << (PolySubpixelShift + 1)) - area,
master_alpha);
sl.AddCell(x, alpha);
x++;
}
if (num_cells != 0 && cell.X > x)
{
alpha = CalculateAlpha(cover << (PolySubpixelShift + 1),
master_alpha);
if (alpha != 0)
{
sl.AddSpan(x, cell.X - x, alpha);
}
}
}
if (sl.NumSpans == 0)
{
return(false);
}
sl.Finalize(scan_y);
return(true);
}
public void Sort(CellAA[] dataToSort)
{
Sort(dataToSort, 0, (uint)(dataToSort.Length- 1));
}
public void Style(CellAA cellB)
{
Left = cellB.Left;
Right = cellB.Right;
}
public void Style(CellAA style_cell)
{
m_style_cell.Style(style_cell);
}
