public override void Draw(Painter p)
{
//this specific for agg
if (p is AggPainter)
{
AggPainter p2 = (AggPainter)p;
AggRenderSurface aggsx = p2.RenderSurface;
PixelProcessing.SubBitmapBlender subImg = PixelProcessing.BitmapBlenderExtension.CreateSubBitmapBlender(aggsx.DestBitmapBlender, aggsx.GetClippingRect());
//TODO: review here again
PixelBlenderBGRA blenderWithGamma = new PixelProcessing.PixelBlenderBGRA();
SubBitmapBlender rasterGamma = new SubBitmapBlender(subImg, blenderWithGamma);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(subImg);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
ScanlineRasterizer rasterizer = aggsx.ScanlineRasterizer;
var sl = new ScanlineUnpacked8();
int size_mul = this.PixelSize;
var sclineToBmpEn2 = new CustomRas_EnlargeV2(size_mul, aggsx.DestBitmap);
rasterizer.Reset();
rasterizer.MoveTo(_x[0] / size_mul, _y[0] / size_mul);
rasterizer.LineTo(_x[1] / size_mul, _y[1] / size_mul);
rasterizer.LineTo(_x[2] / size_mul, _y[2] / size_mul);
sclineToBmpEn2.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
DestBitmapRasterizer bmpRas = aggsx.BitmapRasterizer;
bmpRas.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//-----------------------------------------------------------------------------------------------------------
rasterizer.ResetGamma(new GammaNone());
using (VxsTemp.Borrow(out var v1, out var v2))
using (VectorToolBox.Borrow(v1, out PathWriter ps))
{
ps.Clear();
ps.MoveTo(_x[0], _y[0]);
ps.LineTo(_x[1], _y[1]);
ps.LineTo(_x[2], _y[2]);
ps.LineTo(_x[0], _y[0]);
rasterizer.AddPath((new Stroke(2)).MakeVxs(v1, v2));
bmpRas.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
}
}
}
public override void Draw(PixelFarm.Drawing.Painter p)
{
//specific for agg
if (!(p is AggPainter))
{
return;
}
AggPainter p2 = (AggPainter)p;
AggRenderSurface asx = p2.RenderSurface;
if (asx.DestBitmapBlender != null)
{
IBitmapBlender backBuffer = asx.DestBitmapBlender;
//use different pixel blender
var redImageBuffer = new SubBitmapBlender(backBuffer, new PixelBlenderGrey());
var greenImageBuffer = new SubBitmapBlender(backBuffer, new PixelBlenderGrey());
var blueImageBuffer = new SubBitmapBlender(backBuffer, new PixelBlenderGrey());
ClipProxyImage clippingProxy = new ClipProxyImage(backBuffer);
ClipProxyImage clippingProxyRed = new ClipProxyImage(redImageBuffer);
ClipProxyImage clippingProxyGreen = new ClipProxyImage(greenImageBuffer);
ClipProxyImage clippingProxyBlue = new ClipProxyImage(blueImageBuffer);
//
ScanlineRasterizer sclineRas = asx.ScanlineRasterizer;
ScanlinePacked8 scline = asx.ScanlinePacked8;
Drawing.Color clearColor = this.UseBlackBlackground ? Drawing.Color.FromArgb(0, 0, 0) : Drawing.Color.FromArgb(255, 255, 255);
clippingProxy.Clear(clearColor);
Drawing.Color fillColor = this.UseBlackBlackground ?
new Drawing.Color((byte)(this.AlphaValue), 255, 255, 255) :
new Drawing.Color((byte)(this.AlphaValue), 0, 0, 0);
DestBitmapRasterizer bmpRas = asx.BitmapRasterizer;
using (VectorToolBox.Borrow(out Ellipse ellipse))
using (VxsTemp.Borrow(out var v1))
{
ellipse.Set(Width / 2 - 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
sclineRas.AddPath(ellipse.MakeVxs(v1));
v1.Clear();//**
bmpRas.RenderWithColor(clippingProxyRed, sclineRas, scline, fillColor);
////
ellipse.Set(Width / 2 + 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
sclineRas.AddPath(ellipse.MakeVxs(v1));
v1.Clear();//***
bmpRas.RenderWithColor(clippingProxyGreen, sclineRas, scline, fillColor);
//
ellipse.Set(Width / 2, Height / 2 + 50, 100, 100, 100);
sclineRas.AddPath(ellipse.MakeVxs(v1));
v1.Clear(); //***
bmpRas.RenderWithColor(clippingProxyBlue, sclineRas, scline, fillColor);
}
}
// else if (graphics2D.DestImageFloat != null)
// {
//#if false
// IImageFloat backBuffer = graphics2D.DestImageFloat;
// int distBetween = backBuffer.GetFloatsBetweenPixelsInclusive();
// ImageBufferFloat redImageBuffer = new ImageBufferFloat();
// redImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 2, 8);
// ImageBufferFloat greenImageBuffer = new ImageBufferFloat();
// greenImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 1, 8);
// ImageBufferFloat blueImageBuffer = new ImageBufferFloat();
// blueImageBuffer.Attach(backBuffer, new blender_gray(distBetween), distBetween, 0, 8);
// ImageClippingProxy clippingProxy = new ImageClippingProxy(backBuffer);
// ImageClippingProxy clippingProxyRed = new ImageClippingProxy(redImageBuffer);
// ImageClippingProxy clippingProxyGreen = new ImageClippingProxy(greenImageBuffer);
// ImageClippingProxy clippingProxyBlue = new ImageClippingProxy(blueImageBuffer);
// ScanlineRasterizer ras = new ScanlineRasterizer();
// ScanlineCachePacked8 sl = new ScanlineCachePacked8();
// RGBA_Bytes clearColor = useBlackBackgroundCheckbox.Checked ? new RGBA_Bytes(0, 0, 0) : new RGBA_Bytes(255, 255, 255);
// clippingProxy.clear(clearColor);
// alphaSlider.View.BackGroundColor = clearColor;
// RGBA_Bytes FillColor = useBlackBackgroundCheckbox.Checked ? new RGBA_Bytes(255, 255, 255, (int)(alphaSlider.Value)) : new RGBA_Bytes(0, 0, 0, (int)(alphaSlider.Value));
// VertexSource.Ellipse er = new AGG.VertexSource.Ellipse(Width / 2 - 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
// ras.add_path(er);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyRed, ras, sl, FillColor);
// VertexSource.Ellipse eg = new AGG.VertexSource.Ellipse(Width / 2 + 0.87 * 50, Height / 2 - 0.5 * 50, 100, 100, 100);
// ras.add_path(eg);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyGreen, ras, sl, FillColor);
// VertexSource.Ellipse eb = new AGG.VertexSource.Ellipse(Width / 2, Height / 2 + 50, 100, 100, 100);
// ras.add_path(eb);
// agg_renderer_scanline.Default.render_scanlines_aa_solid(clippingProxyBlue, ras, sl, FillColor);
//#endif
// }
}
public override void Render(PixelFarm.Drawing.Painter p)
{
int strokeWidth = 1;
int width = p.Width;
int height = p.Height;
Affine affTx = Affine.NewMatix(
AffinePlan.Translate(-_spriteShape.Center.x, -_spriteShape.Center.y),
AffinePlan.Scale(_spriteScale, _spriteScale),
AffinePlan.Rotate(_angle + Math.PI),
AffinePlan.Skew(_skewX / 1000.0, _skewY / 1000.0),
AffinePlan.Translate(width / 2, height / 2));
var p1 = p as AggPainter;
if (p1 == null)
{
//TODO: review here
_spriteShape.Paint(p, affTx);
//int j = lionShape.NumPaths;
//int[] pathList = lionShape.PathIndexList;
//Drawing.Color[] colors = lionShape.Colors;
////graphics2D.UseSubPixelRendering = true;
//var vxs = GetFreeVxs();
//affTx.TransformToVxs(lionShape.Vxs, vxs);
//p.StrokeWidth = 1;
//for (int i = 0; i < j; ++i)
//{
// p.StrokeColor = colors[i];
// p.Draw(new PixelFarm.Drawing.VertexStoreSnap(vxs, pathList[i]));
//}
////not agg
//Release(ref vxs);
//return; //**
}
if (UseBitmapExt)
{
p.RenderQuality = Drawing.RenderQuality.Fast;
p.Clear(Drawing.Color.White);
p.StrokeWidth = 1;
//-------------------------
_spriteShape.DrawOutline(p);
}
else
{
p.RenderQuality = Drawing.RenderQuality.HighQuality;
}
//-----------------------
AggRenderSurface aggsx = p1.RenderSurface;
//-----------------------
//TODO: make this reusable ...
//
SubBitmapBlender widgetsSubImage = BitmapBlenderExtension.CreateSubBitmapBlender(aggsx.DestBitmapBlender, aggsx.GetClippingRect());
SubBitmapBlender clippedSubImage = new SubBitmapBlender(widgetsSubImage, new PixelBlenderBGRA());
ClipProxyImage imageClippingProxy = new ClipProxyImage(clippedSubImage);
imageClippingProxy.Clear(PixelFarm.Drawing.Color.White);
AggPainter aggPainter = (AggPainter)p;
if (RenderAsScanline)
{
//a low-level example, expose scanline rasterizer
ScanlineRasterizer rasterizer = aggsx.ScanlineRasterizer;
rasterizer.SetClipBox(0, 0, width, height);
//lionShape.ApplyTransform(affTx);
//---------------------
using (VgPaintArgsPool.Borrow(aggPainter, out VgPaintArgs paintArgs))
{
paintArgs._currentTx = affTx;
paintArgs.PaintVisitHandler = (vxs, painterA) =>
{
//use external painter handler
//draw only outline with its fill-color.
rasterizer.Reset();
rasterizer.AddPath(vxs);
aggsx.BitmapRasterizer.RenderWithColor(
imageClippingProxy, rasterizer,
aggsx.ScanlinePacked8,
aggPainter.FillColor); //draw line with external drawing handler
};
_spriteShape.Paint(paintArgs);
}
//----------------------------
//lionShape.ResetTransform();
}
else
{
if (UseBuiltInAggOutlineAATech)
{
aggPainter.StrokeWidth = 1;
aggPainter.LineRenderingTech = AggPainter.LineRenderingTechnique.OutlineAARenderer;
//------
using (VgPaintArgsPool.Borrow(aggPainter, out VgPaintArgs paintArgs))
{
paintArgs._currentTx = affTx;
paintArgs.PaintVisitHandler = (vxs, painterA) =>
{
//use external painter handler
//draw only outline with its fill-color.
Drawing.Painter m_painter = paintArgs.P;
Drawing.Color prevStrokeColor = m_painter.StrokeColor;
m_painter.StrokeColor = m_painter.FillColor;
m_painter.Draw(vxs);
m_painter.StrokeColor = prevStrokeColor;
};
_spriteShape.Paint(paintArgs);
}
}
else
{
//low-level implementation
aggPainter.StrokeWidth = 1;
//-------------------------
//Draw with LineProfile:
//LineProfileAnitAlias lineProfile = new LineProfileAnitAlias(strokeWidth * affTx.GetScale(), new GammaNone()); //with gamma
LineProfileAnitAlias lineProfile = new LineProfileAnitAlias(strokeWidth * affTx.GetScale(), null);
OutlineRenderer outlineRenderer = new OutlineRenderer(imageClippingProxy, new PixelBlenderBGRA(), lineProfile);
outlineRenderer.SetClipBox(0, 0, this.Width, this.Height);
OutlineAARasterizer rasterizer = new OutlineAARasterizer(outlineRenderer);
rasterizer.LineJoin = (RenderAccurateJoins ?
OutlineAARasterizer.OutlineJoin.AccurateJoin
: OutlineAARasterizer.OutlineJoin.Round);
rasterizer.RoundCap = true;
//lionShape.ApplyTransform(affTx);
//----------------------------
using (VgPaintArgsPool.Borrow(aggPainter, out VgPaintArgs paintArgs))
{
paintArgs._currentTx = affTx;
paintArgs.PaintVisitHandler = (vxs, painterA) =>
{
//use external painter handler
//draw only outline with its fill-color.
rasterizer.RenderVertexSnap(
vxs,
painterA.P.FillColor);
};
_spriteShape.Paint(paintArgs);
}
//----------------------------
//lionShape.ResetTransform();
}
}
}
// Create
//--------------------------------------------------------------------
public void Create(IBitmapSrc src)
{
// we are going to create a dialated image for filtering
// we add m_dilation pixels to every side of the image and then copy the image in the x
// dirrection into each end so that we can sample into this image to get filtering on x repeating
// if the original image look like this
//
// 123456
//
// the new image would look like this
//
// 0000000000
// 0000000000
// 5612345612
// 0000000000
// 0000000000
_height = (int)AggMath.uceil(src.Height);
_width = (int)AggMath.uceil(src.Width);
_width_hr = (int)AggMath.uround(src.Width * LineAA.SUBPIXEL_SCALE);
_half_height_hr = (int)AggMath.uround(src.Height * LineAA.SUBPIXEL_SCALE / 2);
_offset_y_hr = _dilation_hr + _half_height_hr - LineAA.SUBPIXEL_SCALE / 2;
_half_height_hr += LineAA.SUBPIXEL_SCALE / 2;
int bufferWidth = _width + _dilation * 2;
int bufferHeight = _height + _dilation * 2;
int bytesPerPixel = src.BitDepth / 8;
int newSizeInBytes = bufferWidth * bufferHeight * bytesPerPixel;
if (_DataSizeInBytes < newSizeInBytes)
{
_DataSizeInBytes = newSizeInBytes;
_data.Dispose();
IntPtr nativeBuff = System.Runtime.InteropServices.Marshal.AllocHGlobal(_DataSizeInBytes);
_data = new TempMemPtr(nativeBuff, _DataSizeInBytes);
}
_buf = new PixelProcessing.SubBitmapBlender(_data, 0, bufferWidth, bufferHeight, bufferWidth * bytesPerPixel, src.BitDepth, bytesPerPixel);
unsafe
{
using (TempMemPtr destMemPtr = _buf.GetBufferPtr())
using (TempMemPtr srcMemPtr = src.GetBufferPtr())
{
int *destBuffer = (int *)destMemPtr.Ptr;
int *srcBuffer = (int *)srcMemPtr.Ptr;
// copy the image into the middle of the dest
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
int sourceOffset = src.GetBufferOffsetXY32(x, y);
int destOffset = _buf.GetBufferOffsetXY32(_dilation, y + _dilation);
destBuffer[destOffset] = srcBuffer[sourceOffset];
}
}
// copy the first two pixels form the end into the begining and from the begining into the end
for (int y = 0; y < _height; y++)
{
int s1Offset = src.GetBufferOffsetXY32(0, y);
int d1Offset = _buf.GetBufferOffsetXY32(_dilation + _width, y);
int s2Offset = src.GetBufferOffsetXY32(_width - _dilation, y);
int d2Offset = _buf.GetBufferOffsetXY32(0, y);
for (int x = 0; x < _dilation; x++)
{
destBuffer[d1Offset++] = srcBuffer[s1Offset++];
destBuffer[d2Offset++] = srcBuffer[s2Offset++];
}
}
}
}
}
