/// <summary>
/// we do NOT store vxs
/// </summary>
/// <param name="vxs"></param>
/// <param name="spanGen"></param>
void Render(VertexStore vxs, ISpanGenerator spanGen)
{
sclineRas.AddPath(vxs);
sclineRasToBmp.RenderWithSpan(
destImageReaderWriter,
sclineRas,
sclinePack8,
spanGen);
}
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);
}
}
}
//=====================================================render_scanlines_aa
public static void GenerateAndRender(IRasterizer ras, IScanline sl, IPixelFormat ren,
SpanAllocator alloc, ISpanGenerator span_gen)
{
if(ras.RewindScanlines())
{
sl.Reset(ras.MinX(), ras.MaxX());
span_gen.Prepare();
while(ras.SweepScanline(sl))
{
GenerateAndRenderSingleScanline(sl, ren, alloc, span_gen);
}
}
}
private void DrawImage(ISpanGenerator spanImageFilter, Affine destRectTransform)
{
if (destImageByte.OriginOffset.X != 0 || destImageByte.OriginOffset.Y != 0)
{
destRectTransform *= Affine.NewTranslation(-destImageByte.OriginOffset.X, -destImageByte.OriginOffset.Y);
}
var transformedRect = new VertexSourceApplyTransform(drawImageRectPath, destRectTransform);
Rasterizer.add_path(transformedRect);
{
var destImageWithClipping = new ImageClippingProxy(destImageByte);
scanlineRenderer.GenerateAndRender(Rasterizer, drawImageScanlineCache, destImageWithClipping, destImageSpanAllocatorCache, spanImageFilter);
}
}
/// <summary>
/// we do NOT store vxs
/// </summary>
/// <param name="vxs"></param>
/// <param name="spanGen"></param>
public void Render(VertexStore vxs, ISpanGenerator spanGen)
{
float offset_x = _sclineRas.OffsetOriginX;
float offset_y = _sclineRas.OffsetOriginY;
_sclineRas.OffsetOriginX = _sclineRas.OffsetOriginY = 0;
_sclineRas.AddPath(vxs);
_bmpRasterizer.RenderWithSpan(
_destBitmapBlender,
_sclineRas,
_sclinePack8,
spanGen);
_sclineRas.OffsetOriginX = offset_x;
_sclineRas.OffsetOriginY = offset_y;
}
//======================================================render_scanline_aa
private static void GenerateAndRenderSingleScanline(IScanline sl, IPixelFormat ren,
SpanAllocator alloc, ISpanGenerator span_gen)
{
int y = sl.y();
uint num_spans = sl.NumberOfSpans;
ScanlineSpan scanlineSpan = sl.Begin;
byte[] ManagedCoversArray = sl.GetCovers();
unsafe
{
fixed (byte* pCovers = ManagedCoversArray)
{
for (; ; )
{
int x = scanlineSpan.x;
int len = scanlineSpan.len;
if(len < 0) len = -len;
if(tempSpanColors.Capacity() < len)
{
tempSpanColors.Allocate((uint)(len));
}
fixed (RGBA_Bytes* pColors = tempSpanColors.Array)
{
span_gen.Generate(pColors, x, y, (uint)len);
#if use_timers
blend_color_hspan.Start();
#endif
ren.BlendHorizontalColorSpan(x, y, (uint)len, pColors, (scanlineSpan.len < 0) ? null : &pCovers[scanlineSpan.cover_index], pCovers[scanlineSpan.cover_index]);
#if use_timers
blend_color_hspan.Stop();
#endif
}
if (--num_spans == 0) break;
scanlineSpan = sl.GetNextScanlineSpan();
}
}
}
}
//======================================================render_scanline_aa
private static void GenerateAndRenderSingleScanline(IScanline sl, IPixelFormat ren,
SpanAllocator alloc, ISpanGenerator span_gen)
{
int y = sl.y();
uint num_spans = sl.NumberOfSpans;
ScanlineSpan scanlineSpan = sl.Begin;
byte[] ManagedCoversArray = sl.GetCovers();
unsafe
{
fixed (byte* pCovers = ManagedCoversArray)
{
for (; ; )
{
int x = scanlineSpan.x;
int len = scanlineSpan.len;
if(len < 0) len = -len;
if(tempSpanColors.Capacity() < len)
{
tempSpanColors.Allocate((uint)(len));
}
fixed (RGBA_Bytes* pColors = tempSpanColors.Array)
{
span_gen.Generate(pColors, x, y, (uint)len);
#if use_timers
blend_color_hspan.Start();
#endif
ren.BlendHorizontalColorSpan(x, y, (uint)len, pColors, (scanlineSpan.len < 0) ? null : &pCovers[scanlineSpan.cover_index], pCovers[scanlineSpan.cover_index]);
#if use_timers
blend_color_hspan.Stop();
#endif
}
if (--num_spans == 0) break;
scanlineSpan = sl.GetNextScanlineSpan();
}
}
}
}
public void GenerateAndRender(IRasterizer rasterizer, IScanlineCache scanlineCache, IImageByte destImage, span_allocator spanAllocator, ISpanGenerator spanGenerator)
{
if (rasterizer.rewind_scanlines())
{
scanlineCache.reset(rasterizer.min_x(), rasterizer.max_x());
spanGenerator.prepare();
while (rasterizer.sweep_scanline(scanlineCache))
{
GenerateAndRenderSingleScanline(scanlineCache, destImage, spanAllocator, spanGenerator);
}
}
}
//=====================================================render_scanlines_aa
public static void GenerateAndRender(IRasterizer ras, IScanline sl, IPixelFormat ren,
SpanAllocator alloc, ISpanGenerator span_gen)
{
if(ras.RewindScanlines())
{
sl.Reset(ras.MinX(), ras.MaxX());
span_gen.Prepare();
while(ras.SweepScanline(sl))
{
GenerateAndRenderSingleScanline(sl, ren, alloc, span_gen);
}
}
}
public abstract void Fill(VertexStore vxs, ISpanGenerator spanGen);
public void Fill(VertexStore vxs, ISpanGenerator spanGen)
{
this.sclineRas.AddPath(vxs);
sclineRasToBmp.RenderWithSpan(this.gx.DestImage, sclineRas, scline, spanGen);
}
private void DrawImage(IImageByte sourceImage, ISpanGenerator spanImageFilter, Affine destRectTransform)
{
if (destImageByte.OriginOffset.x != 0 || destImageByte.OriginOffset.y != 0)
{
destRectTransform *= Affine.NewTranslation(-destImageByte.OriginOffset.x, -destImageByte.OriginOffset.y);
}
VertexSourceApplyTransform transformedRect = new VertexSourceApplyTransform(drawImageRectPath, destRectTransform);
Rasterizer.add_path(transformedRect);
{
ImageClippingProxy destImageWithClipping = new ImageClippingProxy(destImageByte);
scanlineRenderer.GenerateAndRender(Rasterizer, drawImageScanlineCache, destImageWithClipping, destImageSpanAllocatorCache, spanImageFilter);
}
}
/// <summary>
/// we do NOT store vxs
/// </summary>
/// <param name="vxs"></param>
/// <param name="spanGen"></param>
public void Fill(VertexStore vxs, ISpanGenerator spanGen)
{
this.sclineRas.AddPath(vxs);
sclineRasToBmp.RenderWithSpan(this.gx.DestImage, sclineRas, scline, spanGen);
}
/// <summary>
/// we do NOT store vxs
/// </summary>
/// <param name="vxs"></param>
/// <param name="spanGen"></param>
void Render(VertexStore vxs, ISpanGenerator spanGen)
{
sclineRas.AddPath(vxs);
sclineRasToBmp.RenderWithSpan(
destImageReaderWriter,
sclineRas,
sclinePack8,
spanGen);
}
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);
}
Color[] 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);
}
}
}
private void GenerateAndRenderSingleScanline(IScanlineCache scanLineCache, IImageByte destImage, span_allocator alloc, ISpanGenerator span_gen)
{
int y = scanLineCache.y();
int num_spans = scanLineCache.num_spans();
ScanlineSpan scanlineSpan = scanLineCache.begin();
byte[] ManagedCoversArray = scanLineCache.GetCovers();
for (; ; )
{
int x = scanlineSpan.x;
int len = scanlineSpan.len;
if (len < 0) len = -len;
if (tempSpanColors.Capacity() < len)
{
tempSpanColors.Capacity(len);
}
span_gen.generate(tempSpanColors.Array, 0, x, y, len);
bool useFirstCoverForAll = scanlineSpan.len < 0;
destImage.blend_color_hspan(x, y, len, tempSpanColors.Array, 0, ManagedCoversArray, scanlineSpan.cover_index, useFirstCoverForAll);
if (--num_spans == 0) break;
scanlineSpan = scanLineCache.GetNextScanlineSpan();
}
}
/// <summary>
/// we do NOT store vxs
/// </summary>
/// <param name="vxs"></param>
/// <param name="spanGen"></param>
public void Fill(VertexStore vxs, ISpanGenerator spanGen)
{
this.sclineRas.AddPath(vxs);
_bmpRasterizer.RenderWithSpan(this._aggsx.DestImage, sclineRas, scline, spanGen);
}
public void GenerateAndRender(IRasterizer rasterizer, IScanlineCache scanlineCache, IImageByte destImage, span_allocator spanAllocator, ISpanGenerator spanGenerator)
{
if (rasterizer.rewind_scanlines())
{
scanlineCache.reset(rasterizer.min_x(), rasterizer.max_x());
spanGenerator.prepare();
while (rasterizer.sweep_scanline(scanlineCache))
{
GenerateAndRenderSingleScanline(scanlineCache, destImage, spanAllocator, spanGenerator);
}
}
}
private void GenerateAndRenderSingleScanline(IScanlineCache scanLineCache, IImageByte destImage, span_allocator alloc, ISpanGenerator span_gen)
{
int y = scanLineCache.y();
int num_spans = scanLineCache.num_spans();
ScanlineSpan scanlineSpan = scanLineCache.begin();
byte[] ManagedCoversArray = scanLineCache.GetCovers();
for (; ;)
{
int x = scanlineSpan.x;
int len = scanlineSpan.len;
if (len < 0)
{
len = -len;
}
if (tempSpanColors.Capacity() < len)
{
tempSpanColors.Capacity(len);
}
span_gen.generate(tempSpanColors.Array, 0, x, y, len);
bool useFirstCoverForAll = scanlineSpan.len < 0;
destImage.blend_color_hspan(x, y, len, tempSpanColors.Array, 0, ManagedCoversArray, scanlineSpan.cover_index, useFirstCoverForAll);
if (--num_spans == 0)
{
break;
}
scanlineSpan = scanLineCache.GetNextScanlineSpan();
}
}
public override void Fill(VertexStore vxs, ISpanGenerator spanGen)
{
//fill with ispan generator
throw new NotImplementedException();
}
