public void RenderScanline(
IImageReaderWriter dest,
ScanlineRasterizer sclineRas,
Scanline scline,
Color color)
{
#if DEBUG
int dbugMinScanlineCount = 0;
#endif
//1. ensure single line buffer width
_grayScaleLine.EnsureLineStride(dest.Width + 4);
//2. setup vars
byte[] dest_buffer = dest.GetBuffer();
int dest_w = dest.Width;
int dest_h = dest.Height;
int dest_stride = dest.Stride;
int src_w = dest_w;
int src_stride = dest_stride;
//*** set color before call Blend()
this._color = color;
byte color_alpha = color.alpha;
//---------------------------
//3. loop, render single scanline with subpixel rendering
byte[] lineBuff = _grayScaleLine.GetInternalBuffer();
while (sclineRas.SweepScanline(scline))
{
//3.1. clear
_grayScaleLine.Clear();
//3.2. write grayscale span to temp buffer
//3.3 convert to subpixel value and write to dest buffer
//render solid single scanline
int num_spans = scline.SpanCount;
byte[] covers = scline.GetCovers();
//render each span in the scanline
for (int i = 1; i <= num_spans; ++i)
{
ScanlineSpan span = scline.GetSpan(i);
if (span.len > 0)
{
//positive len
_grayScaleLine.SubPixBlendSolidHSpan(span.x, span.len, color_alpha, covers, span.cover_index);
}
else
{
//fill the line, same coverage area
int x = span.x;
int x2 = (x - span.len - 1);
_grayScaleLine.SubPixBlendHL(x, x2, color_alpha, covers[span.cover_index]);
}
}
BlendScanline(dest_buffer, dest_stride, scline.Y, src_w, src_stride, lineBuff);
#if DEBUG
dbugMinScanlineCount++;
#endif
}
}
/// <summary>
/// for fill shape
/// </summary>
/// <param name="sclineRas"></param>
/// <param name="scline"></param>
/// <param name="color"></param>
/// <param name="shapeHint"></param>
public void FillWithColor(GLScanlineRasterizer sclineRas,
GLScanline scline,
PixelFarm.Drawing.Color color)
{
//early exit
if (color.A == 0)
{
return;
}
if (!sclineRas.RewindScanlines())
{
return;
}
//-----------------------------------------------
scline.ResetSpans(sclineRas.MinX, sclineRas.MaxX);
//-----------------------------------------------
var lineBuff = this.myLineBuffer;
lineBuff.Clear();
while (sclineRas.SweepScanline(scline))
{
int y = scline.Y;
lineBuff.BeginNewLine(y);
int num_spans = scline.SpanCount;
byte[] covers = scline.GetCovers();
//copy data from scanline to lineBuff
//TODO: move linebuf built into the scanline?
for (int i = 1; i <= num_spans; ++i)
{
ScanlineSpan span = scline.GetSpan(i);
if (span.len > 0)
{
//outline
GLBlendSolidHSpan(span.x, span.len, true, lineBuff, color.A, covers, span.cover_index);
}
else
{
//fill
int x = span.x;
int x2 = (x - span.len - 1);
GLBlendHLine(x, x2, true, lineBuff, color.A, covers[span.cover_index]);
}
}
lineBuff.CloseLine();
}
//----------------------------------
int nelements = myLineBuffer.Count;
if (nelements > 0)
{
this.scanlineShader.AggDrawLines(myLineBuffer, nelements, color);
}
}
public void RenderWithColor(IImageReaderWriter dest,
ScanlineRasterizer sclineRas,
Scanline scline,
Color color)
{
if (!sclineRas.RewindScanlines())
{
return;
} //early exit
//-----------------------------------------------
scline.ResetSpans(sclineRas.MinX, sclineRas.MaxX);
switch (this.ScanlineRenderMode)
{
default:
{
while (sclineRas.SweepScanline(scline))
{
//render solid single scanline
int y = scline.Y;
int num_spans = scline.SpanCount;
byte[] covers = scline.GetCovers();
//render each span in the scanline
for (int i = 1; i <= num_spans; ++i)
{
ScanlineSpan span = scline.GetSpan(i);
if (span.len > 0)
{
//positive len
dest.BlendSolidHSpan(span.x, y, span.len, color, covers, span.cover_index);
}
else
{
//fill the line, same coverage area
int x = span.x;
int x2 = (x - span.len - 1);
dest.BlendHL(x, y, x2, color, covers[span.cover_index]);
}
}
}
}
break;
case Agg.ScanlineRenderMode.SubPixelRendering:
{
scSubPixRas.RenderScanline(dest, sclineRas, scline, color);
}
break;
case Agg.ScanlineRenderMode.Custom:
{
while (sclineRas.SweepScanline(scline))
{
CustomRenderSingleScanLine(dest, scline, color);
}
}
break;
}
}
public void RenderWithSpan(IImageReaderWriter dest,
ScanlineRasterizer sclineRas,
Scanline scline,
ISpanGenerator spanGenerator)
{
if (!sclineRas.RewindScanlines())
{
return;
} //early exit
//-----------------------------------------------
scline.ResetSpans(sclineRas.MinX, sclineRas.MaxX);
spanGenerator.Prepare();
if (dest.Stride / 4 > (tempSpanColors.AllocatedSize))
{
//if not enough -> alloc more
tempSpanColors.Clear(dest.Stride / 4);
}
ColorRGBA[] colorArray = tempSpanColors.Array;
while (sclineRas.SweepScanline(scline))
{
//render single scanline
int y = scline.Y;
int num_spans = scline.SpanCount;
byte[] covers = scline.GetCovers();
for (int i = 1; i <= num_spans; ++i)
{
ScanlineSpan span = scline.GetSpan(i);
int x = span.x;
int span_len = span.len;
bool firstCoverForAll = false;
if (span_len < 0)
{
span_len = -span_len;
firstCoverForAll = true;
} //make absolute value
//1. generate colors -> store in colorArray
spanGenerator.GenerateColors(colorArray, 0, x, y, span_len);
//2. blend color in colorArray to destination image
dest.BlendColorHSpan(x, y, span_len,
colorArray, 0,
covers, span.cover_index,
firstCoverForAll);
}
}
}
public override void ResetSpans(int min_x, int max_x)
{
int max_len = max_x - min_x + 2;
if (max_len > m_spans.Length)
{
m_spans = new ScanlineSpan[max_len];
m_covers = new byte[max_len];
}
last_x = 0x7FFFFFF0;
minX = min_x;
last_span_index = 0;
}
public override void ResetSpans(int min_x, int max_x)
{
int max_len = max_x - min_x + 3;
if (max_len > m_spans.Length)
{
m_spans = new ScanlineSpan[max_len];
m_covers = new byte[max_len];
}
last_x = 0x7FFFFFF0;
m_cover_index = 0; //make it ready for next add
last_span_index = 0;
m_spans[last_span_index].len = 0;
}
/// <summary>
/// for fill shape
/// </summary>
/// <param name="sclineRas"></param>
/// <param name="scline"></param>
/// <param name="color"></param>
/// <param name="shapeHint"></param>
public void FillWithColor(GLScanlineRasterizer sclineRas,
GLScanline scline,
PixelFarm.Drawing.Color color)
{
//early exit
if (color.A == 0)
{
return;
}
if (!sclineRas.RewindScanlines())
{
return;
}
//-----------------------------------------------
scline.ResetSpans(sclineRas.MinX, sclineRas.MaxX);
//-----------------------------------------------
this.mySinglePixelBuffer.Clear();
this.myLineBuffer.Clear();
while (sclineRas.SweepScanline(scline))
{
int y = scline.Y;
int num_spans = scline.SpanCount;
byte[] covers = scline.GetCovers();
for (int i = 1; i <= num_spans; ++i)
{
ScanlineSpan span = scline.GetSpan(i);
if (span.len > 0)
{
//outline
GLBlendSolidHSpan(span.x, y, span.len, color, covers, span.cover_index);
}
else
{
//fill
int x = span.x;
int x2 = (x - span.len - 1);
GLBlendHLine(x, y, x2, color, covers[span.cover_index]);
}
}
}
DrawPointAndLineWithVertices();
}
public override void AddCell(int x, int cover)
{
x -= minX;
m_covers[x] = (byte)cover;
if (x == last_x + 1)
{
m_spans[last_span_index].len++;
}
else
{
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan(x + minX, x);
}
last_x = x;
}
public override void AddCell(int x, int cover)
{
m_covers[m_cover_index] = (byte)cover;
if (x == last_x + 1 && m_spans[last_span_index].len > 0)
{
m_spans[last_span_index].len++;
}
else
{
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan((short)x, m_cover_index);
}
last_x = x;
m_cover_index++;
}
public override void ResetSpans(int min_x, int max_x)
{
int max_len = max_x - min_x + 3;
if (max_len > m_spans.Length)
{
m_spans = new ScanlineSpan[max_len];
m_covers = new byte[max_len];
}
last_x = 0x7FFFFFF0;
m_cover_index = 0; //make it ready for next add
last_span_index = 0;
m_spans[last_span_index].len = 0;
}
public override void AddCell(int x, int cover)
{
m_covers[m_cover_index] = (byte)cover;
if (x == last_x + 1 && m_spans[last_span_index].len > 0)
{
//append to last cell
m_spans[last_span_index].len++;
}
else
{
//start new
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan((short)x, m_cover_index);
}
last_x = x;
m_cover_index++; //make it ready for next add
}
public override void AddSpan(int x, int len, int cover)
{
if (x == last_x + 1 &&
m_spans[last_span_index].len < 0 &&
cover == m_spans[last_span_index].cover_index)
{
m_spans[last_span_index].len -= (short)len;
}
else
{
m_covers[m_cover_index] = (byte)cover;
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan((short)x, (short)(-len), m_cover_index++);
}
last_x = x + len - 1;
}
public override void AddCell(int x, int cover)
{
m_covers[m_cover_index] = (byte)cover;
if (x == last_x + 1 && m_spans[last_span_index].len > 0)
{
//append to last cell
m_spans[last_span_index].len++;
}
else
{
//start new
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan((short)x, m_cover_index);
}
last_x = x;
m_cover_index++; //make it ready for next add
}
public override void AddSpan(int x, int len, int cover)
{
x -= minX;
for (int i = 0; i < len; i++)
{
m_covers[x + i] = (byte)cover;
}
if (x == last_x + 1)
{
m_spans[last_span_index].len += (short)len;
}
else
{
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan(x + minX, len, x);
}
last_x = x + (int)len - 1;
}
public override void AddSpan(int x, int len, int cover)
{
int backupCover = cover;
if (x == last_x + 1 &&
m_spans[last_span_index].len < 0 &&
cover == m_spans[last_span_index].cover_index)
{
//just append data to latest span ***
m_spans[last_span_index].len -= (short)len;
}
else
{
m_covers[m_cover_index] = (byte)cover;
last_span_index++;
//---------------------------------------------------
//start new
m_spans[last_span_index] = new ScanlineSpan((short)x, (short)(-len), m_cover_index);
m_cover_index++; //make it ready for next add
}
last_x = x + len - 1;
}
public override void AddSpan(int x, int len, int cover)
{
x -= minX;
for (int i = 0; i < len; i++)
{
m_covers[x + i] = (byte)cover;
}
if (x == last_x + 1)
{
m_spans[last_span_index].len += (short)len;
}
else
{
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan(x + minX, len, x);
}
last_x = x + (int)len - 1;
}
public override void AddSpan(int x, int len, int cover)
{
int backupCover = cover;
if (x == last_x + 1
&& m_spans[last_span_index].len < 0
&& cover == m_spans[last_span_index].cover_index)
{
//just append data to latest span ***
m_spans[last_span_index].len -= (short)len;
}
else
{
m_covers[m_cover_index] = (byte)cover;
last_span_index++;
//---------------------------------------------------
//start new
m_spans[last_span_index] = new ScanlineSpan((short)x, (short)(-len), m_cover_index);
m_cover_index++; //make it ready for next add
}
last_x = x + len - 1;
}
void SubPixRender(IImageReaderWriter dest, Scanline scanline, ColorRGBA color)
{
byte[] covers = scanline.GetCovers();
int num_spans = scanline.SpanCount;
int y = scanline.Y;
byte[] buffer = dest.GetBuffer();
IPixelBlender blender = dest.GetRecieveBlender();
int last_x = int.MinValue;
int prev_cover = 0;
int bufferOffset = 0;
ColorRGBA prevColor = ColorRGBA.White;
for (int i = 1; i <= num_spans; ++i)
{
//render span by span
ScanlineSpan span = scanline.GetSpan(i);
if (span.x != last_x + 1)
{
bufferOffset = dest.GetBufferOffsetXY(span.x, y);
//when skip then reset
prev_cover = 0;
prevColor = ColorRGBA.White;
}
last_x = span.x;
int num_pix = span.len;
if (num_pix < 0)
{
//special encode***
num_pix = -num_pix; //make it positive value
last_x += (num_pix - 1);
//long span with coverage
int coverageValue = covers[span.cover_index];
//-------------------------------------------
if (coverageValue >= 255)
{
//100% cover
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
ColorRGBA newc = prevColor = new ColorRGBA(color.red, color.green, color.blue);
ColorRGBA todrawColor = new ColorRGBA(newc, a);
prev_cover = 255;//full
while (num_pix > 0)
{
blender.BlendPixel(buffer, bufferOffset, todrawColor);
bufferOffset += 4; //1 pixel 4 bytes
--num_pix;
}
}
else
{
prev_cover = coverageValue;
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
ColorRGBA newc = prevColor = new ColorRGBA(color.red, color.green, color.blue);
ColorRGBA todrawColor = new ColorRGBA(newc, a);
while (num_pix > 0)
{
blender.BlendPixel(buffer, bufferOffset, todrawColor);
bufferOffset += 4; //1 pixel 4 bytes
--num_pix;
}
}
}
else
{
int coverIndex = span.cover_index;
last_x += (num_pix - 1);
while (num_pix > 0)
{
int coverageValue = covers[coverIndex++];
if (coverageValue >= 255)
{
//100% cover
ColorRGBA newc = new ColorRGBA(color.red, color.green, color.blue);
prevColor = newc;
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
prev_cover = 255;//full
}
else
{
//check direction :
bool isLeftToRight = coverageValue >= prev_cover;
prev_cover = coverageValue;
byte c_r, c_g, c_b;
float subpix_percent = ((float)(coverageValue) / 256f);
if (coverageValue < cover_1_3)
{
if (isLeftToRight)
{
c_r = 255;
c_g = 255;
c_b = (byte)(255 - (255f * (subpix_percent)));
}
else
{
c_r = (byte)(255 - (255f * (subpix_percent)));
c_g = 255;
c_b = 255;
}
ColorRGBA newc = prevColor = new ColorRGBA(c_r, c_g, c_b);
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
}
else if (coverageValue < cover_2_3)
{
if (isLeftToRight)
{
c_r = prevColor.blue;
c_g = (byte)(255 - (255f * (subpix_percent)));
c_b = color.blue;
}
else
{
c_r = color.blue;
c_g = (byte)(255 - (255f * (subpix_percent)));
c_b = 255;
}
ColorRGBA newc = prevColor = new ColorRGBA(c_r, c_g, c_b);
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
}
else
{
//cover > 2/3 but not full
if (isLeftToRight)
{
c_r = (byte)(255 - (255f * (subpix_percent)));
c_g = color.green;
c_b = color.blue;
}
else
{
c_r = prevColor.green;
c_g = prevColor.blue;
c_b = (byte)(255 - (255f * (subpix_percent)));
}
ColorRGBA newc = prevColor = new ColorRGBA(c_r, c_g, c_b);
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, new ColorRGBA(newc, a));
}
}
bufferOffset += 4; //1 pixel 4 bits
--num_pix;
}
}
}
}
public override void AddCell(int x, int cover)
{
x -= minX;
m_covers[x] = (byte)cover;
if (x == last_x + 1)
{
m_spans[last_span_index].len++;
}
else
{
last_span_index++;
m_spans[last_span_index] = new ScanlineSpan(x + minX, x);
}
last_x = x;
}
public override void ResetSpans(int min_x, int max_x)
{
int max_len = max_x - min_x + 2;
if (max_len > m_spans.Length)
{
m_spans = new ScanlineSpan[max_len];
m_covers = new byte[max_len];
}
last_x = 0x7FFFFFF0;
minX = min_x;
last_span_index = 0;
}
