protected override void OnReadyForInitGLShaderProgram()
{
SvgRenderVx svgRenderVx = SvgRenderVxLoader.CreateSvgRenderVxFromFile("d:\\WImageTest\\lion.svg");
lionShape = new SpriteShape(svgRenderVx);
//flip this lion vertically before use with openGL
PixelFarm.Agg.Transform.Affine aff = PixelFarm.Agg.Transform.Affine.NewMatix(
PixelFarm.Agg.Transform.AffinePlan.Scale(1, -1),
PixelFarm.Agg.Transform.AffinePlan.Translate(0, 600));
lionShape.ApplyTransform(aff);
}
private void _quadControl_ShapeUpdated(QuadWidgetControl sender, EventArgs arg)
{
//update shape of sprite
//transform from original lionBounds to quadPolygon
Quad2f quadCorners = _quadControl.GetQuadCorners();
_quadCorners[0] = quadCorners.left_top_x;
_quadCorners[1] = quadCorners.left_top_y;
_quadCorners[2] = quadCorners.right_top_x;
_quadCorners[3] = quadCorners.right_top_y;
_quadCorners[4] = quadCorners.right_bottom_x;
_quadCorners[5] = quadCorners.right_bottom_y;
_quadCorners[6] = quadCorners.left_bottom_x;
_quadCorners[7] = quadCorners.left_bottom_y;
//this is bilinear transformation
if (_useBilinear)
{
Bilinear txBilinear = Bilinear.RectToQuad(
_lionBounds.Left,
_lionBounds.Top,
_lionBounds.Right,
_lionBounds.Bottom,
_quadCorners);
if (txBilinear.IsValid)
{
SpriteShape spriteShape = _mySprite.GetSpriteShape();
spriteShape.ResetTransform();
spriteShape.ApplyTransform(txBilinear);
}
}
else
{
Perspective perspective = new Perspective(
_lionBounds.Left,
_lionBounds.Top,
_lionBounds.Right,
_lionBounds.Bottom,
_quadCorners);
if (perspective.IsValid)
{
SpriteShape spriteShape = _mySprite.GetSpriteShape();
spriteShape.ResetTransform();
spriteShape.ApplyTransform(perspective);
}
}
}
public override void Draw(PixelFarm.Drawing.Painter p)
{
int strokeWidth = 1;
int width = p.Width;
int height = p.Height;
Affine affTx = Affine.NewMatix(
AffinePlan.Translate(-lionShape.Center.x, -lionShape.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
lionShape.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.RenderQualtity.Fast;
p.Clear(Drawing.Color.White);
p.StrokeWidth = 1;
//-------------------------
lionShape.DrawOutline(p);
}
else
{
p.RenderQuality = Drawing.RenderQualtity.HighQuality;
}
//-----------------------
AggRenderSurface aggsx = p1.RenderSurface;
//var widgetsSubImage = ImageHelper.CreateChildImage(graphics2D.DestImage, graphics2D.GetClippingRect());
//int width = widgetsSubImage.Width;
//int height = widgetsSubImage.Height;
SubImageRW widgetsSubImage = ImageHelper.CreateSubImgRW(aggsx.DestImage, aggsx.GetClippingRect());
SubImageRW clippedSubImage = new SubImageRW(widgetsSubImage, new PixelBlenderBGRA());
ClipProxyImage imageClippingProxy = new ClipProxyImage(clippedSubImage);
imageClippingProxy.Clear(PixelFarm.Drawing.Color.White);
if (RenderAsScanline)
{
ScanlineRasterizer rasterizer = aggsx.ScanlineRasterizer;
rasterizer.SetClipBox(0, 0, width, height);
//Stroke stroke = new Stroke(strokeWidth);
//stroke.LineJoin = LineJoin.Round;
lionShape.ApplyTransform(affTx);
DrawAsScanline(imageClippingProxy, aggsx, rasterizer, aggsx.ScanlineRasToDestBitmap);
lionShape.ResetTransform();
}
else
{
//LineProfileAnitAlias lineProfile = new LineProfileAnitAlias(strokeWidth * affTx.GetScale(), new GammaNone());
LineProfileAnitAlias lineProfile = new LineProfileAnitAlias(strokeWidth * affTx.GetScale(), null);
OutlineRenderer outlineRenderer = new OutlineRenderer(imageClippingProxy, new PixelBlenderBGRA(), lineProfile);
OutlineAARasterizer rasterizer = new OutlineAARasterizer(outlineRenderer);
rasterizer.LineJoin = (RenderAccurateJoins ?
OutlineAARasterizer.OutlineJoin.AccurateJoin
: OutlineAARasterizer.OutlineJoin.Round);
rasterizer.RoundCap = true;
SvgRenderVx renderVx = lionShape.GetRenderVx();
lionShape.ApplyTransform(affTx);
DrawWithLineProfile(rasterizer);
lionShape.ResetTransform();
}
base.Draw(p);
}
public override void Draw(Painter p)
{
Painter painter = p;
if (!didInit)
{
didInit = true;
OnInitialize();
}
//-----------------------------------
painter.Clear(Drawing.Color.White);
//IImageReaderWriter backBuffer = ImageHelper.CreateChildImage(gx.DestImage, gx.GetClippingRect());
//ChildImage image;
//if (backBuffer.BitDepth == 32)
//{
// image = new ChildImage(backBuffer, new PixelBlenderBGRA());
//}
//else
//{
// if (backBuffer.BitDepth != 24)
// {
// throw new System.NotSupportedException();
// }
// image = new ChildImage(backBuffer, new PixelBlenderBGR());
//}
//ClipProxyImage dest = new ClipProxyImage(image);
//gx.Clear(ColorRGBA.White);
//gx.SetClippingRect(new RectInt(0, 0, Width, Height));
//ScanlineRasToDestBitmapRenderer sclineRasToBmp = gx.ScanlineRasToDestBitmap;
if (this.PerspectiveTransformType == Sample_Perspective.PerspectiveTransformType.Bilinear)
{
var bound = lionShape.Bounds;
Bilinear txBilinear = Bilinear.RectToQuad(bound.Left,
bound.Bottom,
bound.Right,
bound.Top,
quadPolygonControl.GetInnerCoords());
if (txBilinear.IsValid)
{
VectorToolBox.GetFreeVxs(out var v3);
lionShape.ApplyTransform(txBilinear);
lionShape.Paint(painter);
RectD lionBound = lionShape.Bounds;
Ellipse ell = new Ellipse((lionBound.Left + lionBound.Right) * 0.5,
(lionBound.Bottom + lionBound.Top) * 0.5,
(lionBound.Right - lionBound.Left) * 0.5,
(lionBound.Top - lionBound.Bottom) * 0.5,
200);
VectorToolBox.ReleaseVxs(ref v3);
//
VectorToolBox.GetFreeVxs(out var v1, out var trans_ell);
txBilinear.TransformToVxs(ell.MakeVxs(v1), trans_ell);
painter.FillColor = ColorEx.Make(0.5f, 0.3f, 0.0f, 0.3f);
painter.Fill(trans_ell);
//-------------------------------------------------------------
//outline
double prevStrokeWidth = painter.StrokeWidth;
painter.StrokeWidth = 3;
painter.StrokeColor = ColorEx.Make(0.0f, 0.3f, 0.2f, 1.0f);
painter.Draw(trans_ell);
painter.StrokeWidth = prevStrokeWidth;
VectorToolBox.ReleaseVxs(ref v1, ref trans_ell);
}
}
else
{
RectD r = lionShape.Bounds;
var txPerspective = new Perspective(
r.Left, r.Bottom, r.Right, r.Top,
quadPolygonControl.GetInnerCoords());
if (txPerspective.IsValid)
{
lionShape.Paint(p, txPerspective); //transform -> paint
//painter.PaintSeries(txPerspective.TransformToVxs(lionShape.Vxs, v1),
// lionShape.Colors,
// lionShape.PathIndexList,
// lionShape.NumPaths);
//--------------------------------------------------------------------------------------
//filled Ellipse
//1. create original fill ellipse
RectD lionBound = lionShape.Bounds;
var filledEllipse = new Ellipse((lionBound.Left + lionBound.Right) * 0.5,
(lionBound.Bottom + lionBound.Top) * 0.5,
(lionBound.Right - lionBound.Left) * 0.5,
(lionBound.Top - lionBound.Bottom) * 0.5,
200);
VectorToolBox.GetFreeVxs(out var v2, out var transformedEll);
txPerspective.TransformToVxs(filledEllipse.MakeVxs(v2), transformedEll);
painter.FillColor = ColorEx.Make(0.5f, 0.3f, 0.0f, 0.3f);
painter.Fill(transformedEll);
//--------------------------------------------------------
var prevStrokeW = painter.StrokeWidth;
painter.StrokeWidth = 3;
painter.StrokeColor = ColorEx.Make(0.0f, 0.3f, 0.2f, 1.0f);
painter.Draw(transformedEll);
painter.StrokeWidth = prevStrokeW;
VectorToolBox.ReleaseVxs(ref v2, ref transformedEll);
}
}
//--------------------------
// Render the "quad" tool and controls
painter.FillColor = ColorEx.Make(0f, 0.3f, 0.5f, 0.6f);
VectorToolBox.GetFreeVxs(out var v4);
painter.Fill(quadPolygonControl.MakeVxs(v4));
VectorToolBox.ReleaseVxs(ref v4);
}
