unsafe void generate_alpha_mask(int cx, int cy)
{
m_alpha_buf = new byte[cx * cy];
fixed(byte *pAlphaBuffer = m_alpha_buf)
{
#if USE_CLIPPING_ALPHA_MASK
m_alpha_mask_rbuf.attach(pAlphaBuffer + 20 * cx + 20, (uint)cx - 40, (uint)cy - 40, cx, 1);
#else
m_alpha_mask_rbuf.attach(pAlphaBuffer, (uint)cx, (uint)cy, cx, 1);
#endif
FormatGray pixf = new FormatGray(m_alpha_mask_rbuf, new BlenderGray(), 1, 0);
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
ScanlinePacked8 sl = new ScanlinePacked8();
clippingProxy.Clear(new RGBA_Doubles(0));
VertexSource.Ellipse <T> ell = new AGG.VertexSource.Ellipse <T>();
System.Random randGenerator = new Random(1432);
int i;
int num = (int)m_num_cb.value().ToInt();
for (i = 0; i < num; i++)
{
if (i == num - 1)
{
ell.Init(width().Divide(2), height().Divide(2), M.New <T>(110), M.New <T>(110), 100);
g_rasterizer.AddPath(ell);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, sl, new RGBA_Bytes(0, 0, 0, 255));
ell.Init(ell.X, ell.Y, ell.RX.Subtract(10), ell.RY.Subtract(10), 100);
g_rasterizer.AddPath(ell);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, sl, new RGBA_Bytes(255, 0, 0, 255));
}
else
{
ell.Init(randGenerator.Next() % cx,
randGenerator.Next() % cy,
randGenerator.Next() % 100 + 20,
randGenerator.Next() % 100 + 20,
100);
// set the color to draw into the alpha channel.
// there is not very much reason to set the alpha as you will get the amount of
// transparency based on the color you draw. (you might want some type of different edeg effect but it will be minor).
g_rasterizer.AddPath(ell);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, sl, new RGBA_Bytes((uint)((float)i / (float)num * 255), 0, 0, 255));
}
}
m_alpha_mask_rbuf.dettachBuffer();
}
}
image_resample_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_gamma_lut = new GammaLut(2.0);
m_quad = new AGG.UI.polygon_ctrl <T>(4, 5.0);
m_trans_type = new AGG.UI.rbox_ctrl <T>(400, 5.0, 430 + 170.0, 100.0);
m_gamma = new AGG.UI.SliderWidget <T>(5.0, 5.0 + 15 * 0, 400 - 5, 10.0 + 15 * 0);
m_blur = new AGG.UI.SliderWidget <T>(5.0, 5.0 + 15 * 1, 400 - 5, 10.0 + 15 * 1);
m_old_gamma = M.New <T>(2);
g_rasterizer = new RasterizerScanlineAA <T>();
g_scanline = new ScanlineUnpacked8();
m_trans_type.text_size(7);
m_trans_type.add_item("Affine No Resample");
m_trans_type.add_item("Affine Resample");
m_trans_type.add_item("Perspective No Resample LERP");
m_trans_type.add_item("Perspective No Resample Exact");
m_trans_type.add_item("Perspective Resample LERP");
m_trans_type.add_item("Perspective Resample Exact");
m_trans_type.cur_item(4);
AddChild(m_trans_type);
m_gamma.range(0.5, 3.0);
m_gamma.value(2.0);
m_gamma.label("Gamma={0:F3}");
AddChild(m_gamma);
m_blur.range(0.5, 5.0);
m_blur.value(1.0);
m_blur.label("Blur={0:F3}");
AddChild(m_blur);
}
public rounded_rect_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_idx = (-1);
m_radius = new AGG.UI.SliderWidget <T>(10, 10, 600 - 10, 19);
m_gamma = new AGG.UI.SliderWidget <T>(10, 10 + 20, 600 - 10, 19 + 20);
m_offset = new AGG.UI.SliderWidget <T>(10, 10 + 40, 600 - 10, 19 + 40);
m_white_on_black = new cbox_ctrl <T>(10, 10 + 60, "White on black");
m_DrawAsOutlineCheckBox = new cbox_ctrl <T>(10 + 180, 10 + 60, "Fill Rounded Rect");
m_x[0] = M.New <T>(100); m_y[0] = M.New <T>(100);
m_x[1] = M.New <T>(500); m_y[1] = M.New <T>(350);
AddChild(m_radius);
AddChild(m_gamma);
AddChild(m_offset);
AddChild(m_white_on_black);
AddChild(m_DrawAsOutlineCheckBox);
m_gamma.label("gamma={0:F3}");
m_gamma.range(0.0, 3.0);
m_gamma.value(1.8);
m_radius.label("radius={0:F3}");
m_radius.range(0.0, 50.0);
m_radius.value(25.0);
m_offset.label("subpixel offset={0:F3}");
m_offset.range(-2.0, 3.0);
m_white_on_black.text_color(new RGBA_Bytes(127, 127, 127));
m_white_on_black.inactive_color(new RGBA_Bytes(127, 127, 127));
m_DrawAsOutlineCheckBox.text_color(new RGBA_Doubles(.5, .5, .5));
m_DrawAsOutlineCheckBox.inactive_color(new RGBA_Bytes(127, 127, 127));
}
public lion_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_AlphaSlider = new UI.SliderWidget <T>(M.New <T>(5), M.New <T>(5), M.New <T>(512 - 5), M.New <T>(12));
parse_lion();
AddChild(m_AlphaSlider);
m_AlphaSlider.SetTransform(MatrixFactory <T> .NewIdentity(VectorDimension.Two));
m_AlphaSlider.label("Alpha {0:F3}");
m_AlphaSlider.value(M.New <T>(0.1));
}
public component_rendering_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_alpha = new AGG.UI.SliderWidget <T>(5, 5, 320 - 5, 10 + 5);
m_UseBlackBackground = new UI.cbox_ctrl <T>(5, 5 + 18, "Draw Black Background");
m_alpha.label("Alpha={0:F0}");
m_alpha.range(0, 255);
m_alpha.value(255);
AddChild(m_alpha);
AddChild(m_UseBlackBackground);
m_UseBlackBackground.text_color(new RGBA_Bytes(127, 127, 127));
}
image1_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_angle = new AGG.UI.SliderWidget <T>(5, 5, 300, 12);
m_scale = new AGG.UI.SliderWidget <T>(5, 5 + 15, 300, 12 + 15);
AddChild(m_angle);
AddChild(m_scale);
m_angle.label("Angle={0:F2}");
m_scale.label("Scale={0:F2}");
m_angle.range(-180.0, 180.0);
m_angle.value(0.0);
m_scale.range(0.1, 5.0);
m_scale.value(1.0);
}
public lion_outline_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_width_slider = new AGG.UI.SliderWidget <T>(5, 5, 150, 12);
m_scanline = new AGG.UI.cbox_ctrl <T>(160, 5, "Use Scanline Rasterizer");
m_scanline.status(true);
parse_lion();
AddChild(m_width_slider);
m_width_slider.SetTransform(MatrixFactory <T> .NewIdentity(VectorDimension.Two));
m_width_slider.range(0.0, 4.0);
m_width_slider.value(1.0);
m_width_slider.label("Width {0:F2}");
AddChild(m_scanline);
m_scanline.SetTransform(MatrixFactory <T> .NewIdentity(VectorDimension.Two));
}
public override void OnDraw()
{
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
IPixelFormat pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
IAffineTransformMatrix <T> mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx.Translate(MatrixFactory <T> .CreateVector2D(g_base_dx.Negative(), g_base_dy.Negative()));
mtx.Scale(g_scale);
mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), g_angle.Add(Math.PI).ToDouble());
mtx.Shear(MatrixFactory <T> .CreateVector2D(g_skew_x.Divide(1000.0), g_skew_y.Divide(1000.0)));
mtx.Translate(MatrixFactory <T> .CreateVector2D(width / 2, height / 2));
if (m_scanline.status())
{
g_rasterizer.SetVectorClipBox(0, 0, width, height);
ConvStroke <T> stroke = new ConvStroke <T>(g_path);
stroke.Width = m_width_slider.value();
stroke.LineJoin = LineJoin.RoundJoin;
ConvTransform <T> trans = new ConvTransform <T>(stroke, mtx);
Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);
}
else
{
/*
* double w = m_width_slider.Value() * mtx.scale();
*
* line_profile_aa profile = new line_profile_aa(w, new gamma_none());
* renderer_outline_aa ren = new renderer_outline_aa(rb, profile);
* rasterizer_outline_aa ras = new rasterizer_outline_aa(ren);
*
* conv_transform trans = new conv_transform(g_path, mtx);
*
* ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths);
*/
}
base.OnDraw();
}
public alpha_mask2_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_alpha_mask_rbuf = new RasterBuffer();
#if USE_CLIPPING_ALPHA_MASK
m_alpha_mask = new AlphaMaskByteClipped(m_alpha_mask_rbuf, 1, 0);
#else
m_alpha_mask = new AlphaMaskByteUnclipped(m_alpha_mask_rbuf, 1, 0);
#endif
m_num_cb = new UI.SliderWidget <T>(5, 5, 150, 12);
m_slider_value = M.Zero <T>();
parse_lion();
AddChild(m_num_cb);
m_num_cb.range(5, 100);
m_num_cb.value(10);
m_num_cb.label("N={0:F3}");
m_num_cb.SetTransform(MatrixFactory <T> .NewIdentity(VectorDimension.Two));
}
gouraud_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_idx = (-1);
m_dilation = new AGG.UI.SliderWidget <T>(5, 5, 400 - 5, 11);
m_gamma = new AGG.UI.SliderWidget <T>(5, 5 + 15, 400 - 5, 11 + 15);
m_alpha = new AGG.UI.SliderWidget <T>(5, 5 + 30, 400 - 5, 11 + 30);
m_x[0] = M.New <T>(57); m_y[0] = M.New <T>(60);
m_x[1] = M.New <T>(369); m_y[1] = M.New <T>(170);
m_x[2] = M.New <T>(143); m_y[2] = M.New <T>(310);
AddChild(m_dilation);
AddChild(m_gamma);
AddChild(m_alpha);
m_dilation.label("Dilation={0:F2}");
m_gamma.label("Linear gamma={0:F2}");
m_alpha.label("Opacity={0:F2}");
m_dilation.value(0.175);
m_gamma.value(0.809);
m_alpha.value(1.0);
}
public override void OnDraw()
{
if (m_gamma.value().NotEqual(m_old_gamma))
{
m_gamma_lut.Gamma(m_gamma.value().ToDouble());
load_img(0, "spheres");
FormatRGB pixf_change_gamma = new FormatRGB(rbuf_img(0), new BlenderBGR());
//pixf_change_gamma.apply_gamma_dir(m_gamma_lut);
m_old_gamma = m_gamma.value();
}
#if SourceDepth24
pixfmt_alpha_blend_rgb pixf = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr());
pixfmt_alpha_blend_rgb pixf_pre = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr_pre());
#else
FormatRGBA pixf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
FormatRGBA pixf_pre = new FormatRGBA(rbuf_window(), new BlenderPreMultBGRA());
#endif
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
FormatClippingProxy clippingProxy_pre = new FormatClippingProxy(pixf_pre);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
if (m_trans_type.cur_item() < 2)
{
// For the IAffineTransformMatrix<T> parallelogram transformations we
// calculate the 4-th (implicit) point of the parallelogram
m_quad.SetXN(3, m_quad.xn(0).Add(m_quad.xn(2).Subtract(m_quad.xn(1))));
m_quad.SetYN(3, m_quad.yn(0).Add(m_quad.yn(2).Subtract(m_quad.yn(1))));
}
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.AddPath(m_quad);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0.3, 0.5, 0.1));
// Prepare the polygon to rasterize. Here we need to fill
// the destination (transformed) polygon.
g_rasterizer.SetVectorClipBox(0, 0, width().ToDouble(), height().ToDouble());
g_rasterizer.Reset();
int b = 0;
g_rasterizer.MoveToDbl(m_quad.xn(0).Subtract(b), m_quad.yn(0).Subtract(b));
g_rasterizer.LineToDbl(m_quad.xn(1).Add(b), m_quad.yn(1).Subtract(b));
g_rasterizer.LineToDbl(m_quad.xn(2).Add(b), m_quad.yn(2).Add(b));
g_rasterizer.LineToDbl(m_quad.xn(3).Subtract(b), m_quad.yn(3).Add(b));
//typedef agg::span_allocator<color_type> span_alloc_type;
SpanAllocator sa = new SpanAllocator();
ImageFilterBilinear <T> filter_kernel = new ImageFilterBilinear <T>();
ImageFilterLookUpTable <T> filter = new ImageFilterLookUpTable <T>(filter_kernel, true);
#if SourceDepth24
pixfmt_alpha_blend_rgb pixf_img = new pixfmt_alpha_blend_rgb(rbuf_img(0), new blender_bgr());
#else
FormatRGBA pixf_img = new FormatRGBA(rbuf_img(0), new BlenderBGRA());
#endif
RasterBufferAccessorClamp source = new RasterBufferAccessorClamp(pixf_img);
start_timer();
switch (m_trans_type.cur_item())
{
case 0:
{
/*
* agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
*
* typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
* interpolator_type interpolator(tr);
*
* typedef image_filter_2x2_type<source_type,
* interpolator_type> span_gen_type;
* span_gen_type sg(source, interpolator, filter);
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
*/
break;
}
case 1:
{
/*
* agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
*
* typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
* typedef image_resample_affine_type<source_type> span_gen_type;
*
* interpolator_type interpolator(tr);
* span_gen_type sg(source, interpolator, filter);
* sg.blur(m_blur.Value());
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
*/
break;
}
case 2:
{
/*
* agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
* if(tr.is_valid())
* {
* typedef agg::span_interpolator_linear_subdiv<agg::trans_perspective> interpolator_type;
* interpolator_type interpolator(tr);
*
* typedef image_filter_2x2_type<source_type,
* interpolator_type> span_gen_type;
* span_gen_type sg(source, interpolator, filter);
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
* }
*/
break;
}
case 3:
{
/*
* agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
* if(tr.is_valid())
* {
* typedef agg::span_interpolator_trans<agg::trans_perspective> interpolator_type;
* interpolator_type interpolator(tr);
*
* typedef image_filter_2x2_type<source_type,
* interpolator_type> span_gen_type;
* span_gen_type sg(source, interpolator, filter);
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
* }
*/
break;
}
case 4:
{
//typedef agg::span_interpolator_persp_lerp<> interpolator_type;
//typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type;
SpanInterpolatorPerspLerp <T> interpolator = new SpanInterpolatorPerspLerp <T>(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
SpanSubDivAdaptor <T> subdiv_adaptor = new SpanSubDivAdaptor <T>(interpolator);
if (interpolator.IsValid())
{
#if SourceDepth24
span_image_resample_rgb sg = new span_image_resample_rgb(source, subdiv_adaptor, filter);
#else
span_image_resample_rgba <T> sg = new span_image_resample_rgba <T>(source, subdiv_adaptor, filter);
#endif
sg.Blur = m_blur.value().ToDouble();
Renderer <T> .GenerateAndRender(g_rasterizer, g_scanline, clippingProxy_pre, sa, sg);
}
break;
}
case 5:
{
/*
* typedef agg::span_interpolator_persp_exact<> interpolator_type;
* typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type;
*
* interpolator_type interpolator(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
* subdiv_adaptor_type subdiv_adaptor(interpolator);
*
* if(interpolator.is_valid())
* {
* typedef image_resample_type<source_type,
* subdiv_adaptor_type> span_gen_type;
* span_gen_type sg(source, subdiv_adaptor, filter);
* sg.blur(m_blur.Value());
* agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
* }
*/
break;
}
}
double tm = elapsed_time();
//pixf.apply_gamma_inv(m_gamma_lut);
GsvText <T> t = new GsvText <T>();
t.SetFontSize(10.0);
ConvStroke <T> pt = new ConvStroke <T>(t);
pt.Width = M.New <T>(1.5);
string buf = string.Format("{0:F2} ms", tm);
t.StartPoint(10.0, 70.0);
t.Text = buf;
g_rasterizer.AddPath(pt);
Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0, 0));
//--------------------------
//m_trans_type.Render(g_rasterizer, g_scanline, clippingProxy);
//m_gamma.Render(g_rasterizer, g_scanline, clippingProxy);
//m_blur.Render(g_rasterizer, g_scanline, clippingProxy);
base.OnDraw();
}
public override void OnDraw()
{
#if use_timers
AllTimer.Start();
#endif
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
uint i;
for (i = 0; i < m_NumPaths; i++)
{
// g_colors[i].A_Byte = (byte)(m_AlphaSlider.value() * 255);
g_colors[i] = RGBA_Bytes.ModifyComponent(g_colors[i], Component.A, (byte)(m_AlphaSlider.value().ToDouble() * 255));
}
IAffineTransformMatrix <T> transform = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
transform.Translate(MatrixFactory <T> .CreateVector2D(g_base_dx.Negative(), g_base_dy.Negative()));
transform.Scale(MatrixFactory <T> .CreateVector2D(g_scale, g_scale));
transform.RotateAlong(MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>()), g_angle + Math.PI);
transform.Shear(MatrixFactory <T> .CreateVector2D(g_skew_x.Divide(1000.0), g_skew_y.Divide(1000.0)));
transform.Translate(MatrixFactory <T> .CreateVector2D(M.New <T>(width).Divide(2), M.New <T>(height).Divide(2)));
// This code renders the lion:
ConvTransform <T> transformedPathStorage = new ConvTransform <T>(g_PathStorage, transform);
#if use_timers
Lion50Timer.Start();
for (uint j = 0; j < 200; j++)
#endif
{
this.GetRenderer().Render(transformedPathStorage, g_colors, g_path_idx, m_NumPaths);
}
#if use_timers
Lion50Timer.Stop();
#endif
#if use_timers
AllTimer.Stop();
CExecutionTimer.Instance.AppendResultsToFile("TimingTest.txt", AllTimer.GetTotalSeconds());
CExecutionTimer.Instance.Reset();
#endif
base.OnDraw();
}
public override void OnDraw()
{
FormatRGB pf = new FormatRGB(rbuf_window(), new BlenderBGR());
FormatGray pfr = new FormatGray(rbuf_window(), new BlenderGray(), 3, 2);
FormatGray pfg = new FormatGray(rbuf_window(), new BlenderGray(), 3, 1);
FormatGray pfb = new FormatGray(rbuf_window(), new BlenderGray(), 3, 0);
FormatClippingProxy clippingProxy = new FormatClippingProxy(pf);
FormatClippingProxy clippingProxyRed = new FormatClippingProxy(pfr);
FormatClippingProxy clippingProxyGreen = new FormatClippingProxy(pfg);
FormatClippingProxy clippingProxyBlue = new FormatClippingProxy(pfb);
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ScanlinePacked8 sl = new ScanlinePacked8();
clippingProxy.Clear(m_UseBlackBackground.status() ? new RGBA_Doubles(0, 0, 0) : new RGBA_Doubles(1, 1, 1));
RGBA_Bytes FillColor = m_UseBlackBackground.status() ? new RGBA_Bytes(255, 255, 255, (uint)(m_alpha.value().ToInt())) : new RGBA_Bytes(0, 0, 0, (uint)(m_alpha.value().ToInt()));
VertexSource.Ellipse <T> er = new AGG.VertexSource.Ellipse <T>(width().Divide(2).Subtract(0.87 * 50), height().Divide(2).Subtract(0.5 * 50), M.New <T>(100), M.New <T>(100), 100);
ras.AddPath(er);
Renderer <T> .RenderSolid(clippingProxyRed, ras, sl, FillColor);
VertexSource.Ellipse <T> eg = new AGG.VertexSource.Ellipse <T>(width().Divide(2).Add(0.87 * 50), height().Divide(2).Subtract(0.5 * 50), M.New <T>(100), M.New <T>(100), 100);
ras.AddPath(eg);
Renderer <T> .RenderSolid(clippingProxyGreen, ras, sl, FillColor);
//renderer_scanlines.render_scanlines_aa_solid(ras, sl, rbg, new gray8(0, unsigned(m_alpha.Value())));
VertexSource.Ellipse <T> eb = new AGG.VertexSource.Ellipse <T>(width().Divide(2), height().Divide(2).Add(50), M.New <T>(100), M.New <T>(100), 100);
ras.AddPath(eb);
Renderer <T> .RenderSolid(clippingProxyBlue, ras, sl, FillColor);
//renderer_scanlines.render_scanlines_aa_solid(ras, sl, rbb, new gray8(0, unsigned(m_alpha.Value())));
//m_alpha.Render(ras, sl, clippingProxy);
//m_UseBlackBackground.Render(ras, sl, clippingProxy);
base.OnDraw();
}
//template<class Scanline, class Ras>
public void render_gouraud(IScanlineCache sl, IRasterizer <T> ras)
{
T alpha = m_alpha.value();
T brc = M.One <T>();
#if SourceDepth24
pixfmt_alpha_blend_rgb pf = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr());
#else
FormatRGBA pf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
#endif
FormatClippingProxy ren_base = new FormatClippingProxy(pf);
AGG.SpanAllocator span_alloc = new SpanAllocator();
SpanGouraudRgba <T> span_gen = new SpanGouraudRgba <T>();
ras.Gamma(new GammaLinear(0.0, m_gamma.value().ToDouble()));
T d = m_dilation.value();
// Six triangles
T xc = m_x[0].Add(m_x[1]).Add(m_x[2]).Divide(3.0);
T yc = m_y[0].Add(m_y[1]).Add(m_y[2]).Divide(3.0);
T x1 = m_x[1].Add(m_x[0]).Divide(2).Subtract(xc.Subtract(m_x[1].Add(m_x[0]).Divide(2)));
T y1 = m_y[1].Add(m_y[0]).Divide(2).Subtract(yc.Subtract(m_y[1].Add(m_y[0]).Divide(2)));
T x2 = m_x[2].Add(m_x[1]).Divide(2).Subtract(xc.Subtract(m_x[2].Add(m_x[1]).Divide(2)));
T y2 = m_y[2].Add(m_y[1]).Divide(2).Subtract(yc.Subtract(m_y[2].Add(m_y[1]).Divide(2)));
T x3 = m_x[0].Add(m_x[2]).Divide(2).Subtract(xc.Subtract(m_x[0].Add(m_x[2]).Divide(2)));
T y3 = m_y[0].Add(m_y[2]).Divide(2).Subtract(yc.Subtract(m_y[0].Add(m_y[2]).Divide(2)));
span_gen.Colors(new RGBA_Doubles(1, 0, 0, alpha.ToDouble()),
new RGBA_Doubles(0, 1, 0, alpha.ToDouble()),
new RGBA_Doubles(brc.ToDouble(), brc.ToDouble(), brc.ToDouble(), alpha.ToDouble()));
span_gen.Triangle(m_x[0], m_y[0], m_x[1], m_y[1], xc, yc, d);
ras.AddPath(span_gen);
Renderer <T> .GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
span_gen.Colors(new RGBA_Doubles(0, 1, 0, alpha.ToDouble()),
new RGBA_Doubles(0, 0, 1, alpha.ToDouble()),
new RGBA_Doubles(brc.ToDouble(), brc.ToDouble(), brc.ToDouble(), alpha.ToDouble()));
span_gen.Triangle(m_x[1], m_y[1], m_x[2], m_y[2], xc, yc, d);
ras.AddPath(span_gen);
Renderer <T> .GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
span_gen.Colors(new RGBA_Doubles(0, 0, 1, alpha.ToDouble()),
new RGBA_Doubles(1, 0, 0, alpha.ToDouble()),
new RGBA_Doubles(brc.ToDouble(), brc.ToDouble(), brc.ToDouble(), alpha.ToDouble()));
span_gen.Triangle(m_x[2], m_y[2], m_x[0], m_y[0], xc, yc, d);
ras.AddPath(span_gen);
Renderer <T> .GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
brc = M.One <T>().Subtract(brc);
span_gen.Colors(new RGBA_Doubles(1, 0, 0, alpha.ToDouble()),
new RGBA_Doubles(0, 1, 0, alpha.ToDouble()),
new RGBA_Doubles(brc.ToDouble(), brc.ToDouble(), brc.ToDouble(), alpha.ToDouble()));
span_gen.Triangle(m_x[0], m_y[0], m_x[1], m_y[1], x1, y1, d);
ras.AddPath(span_gen);
Renderer <T> .GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
span_gen.Colors(new RGBA_Doubles(0, 1, 0, alpha.ToDouble()),
new RGBA_Doubles(0, 0, 1, alpha.ToDouble()),
new RGBA_Doubles(brc.ToDouble(), brc.ToDouble(), brc.ToDouble(), alpha.ToDouble()));
span_gen.Triangle(m_x[1], m_y[1], m_x[2], m_y[2], x2, y2, d);
ras.AddPath(span_gen);
Renderer <T> .GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
span_gen.Colors(new RGBA_Doubles(0, 0, 1, alpha.ToDouble()),
new RGBA_Doubles(1, 0, 0, alpha.ToDouble()),
new RGBA_Doubles(brc.ToDouble(), brc.ToDouble(), brc.ToDouble(), alpha.ToDouble()));
span_gen.Triangle(m_x[2], m_y[2], m_x[0], m_y[0], x3, y3, d);
ras.AddPath(span_gen);
Renderer <T> .GenerateAndRender(ras, sl, ren_base, span_alloc, span_gen);
}
public override void OnDraw()
{
//typedef agg::renderer_base<pixfmt> renderer_base;
//typedef agg::renderer_base<pixfmt_pre> renderer_base_pre;
#if SourceDepth24
pixfmt_alpha_blend_rgb pixf = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr());
pixfmt_alpha_blend_rgb pixf_pre = new pixfmt_alpha_blend_rgb(rbuf_window(), new blender_bgr_pre());
#else
FormatRGBA pixf = new FormatRGBA(rbuf_window(), new BlenderBGRA());
FormatRGBA pixf_pre = new FormatRGBA(rbuf_window(), new BlenderPreMultBGRA());
#endif
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
FormatClippingProxy clippingProxy_pre = new FormatClippingProxy(pixf_pre);
clippingProxy.Clear(new RGBA_Doubles(1.0, 1.0, 1.0));
IAffineTransformMatrix <T> src_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Negative().Divide(2).Subtract(10), initial_height().Negative().Divide(2).Subtract(30)));
src_mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_angle.value().Multiply(Math.PI / 180.0).ToDouble());
src_mtx.Scale(m_scale.value());
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Divide(2), initial_height().Divide(2).Add(20)));
src_mtx.Multiply(trans_affine_resizing());
IAffineTransformMatrix <T> img_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
img_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Negative().Divide(2).Add(10), initial_height().Negative().Divide(2).Add(30)));
img_mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_angle.value().Multiply(Math.PI / 180.0).ToDouble());
img_mtx.Scale(m_scale.value());
img_mtx.Translate(MatrixFactory <T> .CreateVector2D(initial_width().Divide(2), initial_height().Divide(2).Add(20)));
img_mtx.Multiply(trans_affine_resizing());
img_mtx = img_mtx.Inverse;
AGG.SpanAllocator sa = new SpanAllocator();
SpanInterpolatorLinear <T> interpolator = new SpanInterpolatorLinear <T>(img_mtx);
#if SourceDepth24
pixfmt_alpha_blend_rgb img_pixf = new pixfmt_alpha_blend_rgb(rbuf_img(0), new blender_bgr());
#else
FormatRGBA img_pixf = new FormatRGBA(rbuf_img(0), new BlenderBGRA());
#endif
#if SourceDepth24
span_image_filter_rgb_bilinear_clip sg;
sg = new span_image_filter_rgb_bilinear_clip(img_pixf, rgba.rgba_pre(0, 0.4, 0, 0.5), interpolator);
#else
SpanImageFilterRgbaBilinearClip <T> sg;
RasterBufferAccessorClip source = new RasterBufferAccessorClip(img_pixf, RGBA_Doubles.RgbaPre(0, 0, 0, 0));
sg = new SpanImageFilterRgbaBilinearClip <T>(source, RGBA_Doubles.RgbaPre(0, 0.4, 0, 0.5), interpolator);
#endif
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ras.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), width(), height());
//agg.scanline_packed_8 sl = new scanline_packed_8();
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
T r = initial_width();
if (initial_height().Subtract(60).LessThan(r))
{
r = initial_height().Subtract(60);
}
Ellipse <T> ell = new Ellipse <T>(initial_width().Divide(2.0).Add(10),
initial_height().Divide(2.0).Add(30),
r.Divide(2.0).Add(16.0),
r.Divide(2.0).Add(16.0), 200);
ConvTransform <T> tr = new ConvTransform <T>(ell, src_mtx);
ras.AddPath(tr);
#if use_timers
for (uint j = 0; j < 10; j++)
{
Renderer.GenerateAndRender(ras, sl, clippingProxy_pre, sa, sg);
}
AllTimer.Start();
image1_100_Times.Start();
for (uint i = 0; i < 500; i++)
{
#endif
//clippingProxy_pre.SetClippingBox(30, 0, (int)width(), (int)height());
//clippingProxy.SetClippingBox(30, 0, (int)width(), (int)height());
Renderer <T> .GenerateAndRender(ras, sl, clippingProxy_pre, sa, sg);
#if use_timers
}
image1_100_Times.Stop();
#endif
//m_angle.SetTransform(trans_affine_resizing());
//m_scale.SetTransform(trans_affine_resizing());
#if use_timers
AllTimer.Stop();
CExecutionTimer.Instance.AppendResultsToFile("TimingTest.txt", AllTimer.GetTotalSeconds());
CExecutionTimer.Instance.Reset();
#endif
base.OnDraw();
}
public override void OnDraw()
{
GammaLut gamma = new GammaLut(m_gamma.value().ToDouble());
IBlender NormalBlender = new BlenderBGRA();
IBlender GammaBlender = new BlenderGammaBGRA(gamma);
FormatRGBA pixf = new FormatRGBA(rbuf_window(), NormalBlender);
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(m_white_on_black.status() ? new RGBA_Doubles(0, 0, 0) : new RGBA_Doubles(1, 1, 1));
RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>();
ScanlinePacked8 sl = new ScanlinePacked8();
Ellipse <T> e = new Ellipse <T>();
// TODO: If you drag the control circles below the bottom of the window we get an exception. This does not happen in AGG.
// It needs to be debugged. Turning on clipping fixes it. But standard agg works without clipping. Could be a bigger problem than this.
//ras.clip_box(0, 0, width(), height());
// Render two "control" circles
e.Init(m_x[0], m_y[0], M.New <T>(3), M.New <T>(3), 16);
ras.AddPath(e);
Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(127, 127, 127));
e.Init(m_x[1], m_y[1], M.New <T>(3), M.New <T>(3), 16);
ras.AddPath(e);
Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(127, 127, 127));
T d = m_offset.value();
// Creating a rounded rectangle
RoundedRect <T> r = new RoundedRect <T>(m_x[0].Add(d), m_y[0].Add(d), m_x[1].Add(d), m_y[1].Add(d), m_radius.value());
r.NormalizeRadius();
// Drawing as an outline
if (!m_DrawAsOutlineCheckBox.status())
{
ConvStroke <T> p = new ConvStroke <T>(r);
p.Width = M.One <T>();
ras.AddPath(p);
}
else
{
ras.AddPath(r);
}
pixf.Blender = GammaBlender;
Renderer <T> .RenderSolid(clippingProxy, ras, sl, m_white_on_black.status()?new RGBA_Bytes(1, 1, 1) : new RGBA_Bytes(0, 0, 0));
// this was in the original demo, but it does nothing because we changed the blender not the gamma function.
//ras.gamma(new gamma_none());
// so let's change the blender instead
pixf.Blender = NormalBlender;
// Render the controls
//m_radius.Render(ras, sl, clippingProxy);
//m_gamma.Render(ras, sl, clippingProxy);
//m_offset.Render(ras, sl, clippingProxy);
//m_white_on_black.Render(ras, sl, clippingProxy);
//m_DrawAsOutlineCheckBox.Render(ras, sl, clippingProxy);
base.OnDraw();
}
