public override void OnDraw() { #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); ren_base.Clear(new RGBA_Doubles(1.0, 1.0, 1.0)); ScanlineUnpacked8 sl = new ScanlineUnpacked8(); RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>(); #if true render_gouraud(sl, ras); #else agg.span_allocator span_alloc = new span_allocator(); span_gouraud_rgba span_gen = new span_gouraud_rgba(new rgba8(255, 0, 0, 255), new rgba8(0, 255, 0, 255), new rgba8(0, 0, 255, 255), 320, 220, 100, 100, 200, 100, 0); span_gouraud test_sg = new span_gouraud(new rgba8(0, 0, 0, 255), new rgba8(0, 0, 0, 255), new rgba8(0, 0, 0, 255), 320, 220, 100, 100, 200, 100, 0); ras.add_path(test_sg); renderer_scanlines.render_scanlines_aa(ras, sl, ren_base, span_alloc, span_gen); //renderer_scanlines.render_scanlines_aa_solid(ras, sl, ren_base, new rgba8(0, 0, 0, 255)); #endif ras.Gamma(new GammaNone()); m_dilation.SetTransform(trans_affine_resizing()); //m_dilation.Render(ras, sl, ren_base); m_gamma.SetTransform(trans_affine_resizing()); //m_gamma.Render(ras, sl, ren_base); m_alpha.SetTransform(trans_affine_resizing()); //m_alpha.Render(ras, sl, ren_base); base.OnDraw(); }
public override void OnInitialize() { g_x1 = M.Zero <T>(); g_y1 = M.Zero <T>(); g_x2 = M.New <T>(rbuf_img(0).Width); g_y2 = M.New <T>(rbuf_img(0).Height); T x1 = g_x1; // * 100.0; T y1 = g_y1; // * 100.0; T x2 = g_x2; // * 100.0; T y2 = g_y2; // * 100.0; T dx = width().Divide(2.0).Subtract(x2.Subtract(x1).Divide(2.0)); T dy = height().Divide(2.0).Subtract(y2.Subtract(y1).Divide(2.0)); m_quad.SetXN(0, x1.Add(dx).Floor()); m_quad.SetYN(0, y1.Add(dy).Floor()); // - 150; m_quad.SetXN(1, x2.Add(dx).Floor()); m_quad.SetYN(1, y1.Add(dy).Floor()); // - 110; m_quad.SetXN(2, x2.Add(dx).Floor()); m_quad.SetYN(2, y2.Add(dy).Floor()); // - 300; m_quad.SetXN(3, x1.Add(dx).Floor()); m_quad.SetYN(3, y2.Add(dy).Floor()); // - 200; #if SourceDepth24 pixfmt_alpha_blend_rgb pixf = new pixfmt_alpha_blend_rgb(rbuf_img(0), new blender_bgr()); #else FormatRGBA pixf = new FormatRGBA(rbuf_img(0), new BlenderBGRA()); #endif //pixf.apply_gamma_dir(m_gamma_lut); base.OnInitialize(); }
public static void CreateContext(RasterBuffer renderingBuffer) { // set the rendering buffer and all the GL default states (this is also where you can new anything you need) s_RenderingBuffer = renderingBuffer; s_Rasterizer.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), M.New <T>(s_RenderingBuffer.Width), M.New <T>(s_RenderingBuffer.Height)); s_PixelFormt = new FormatRGBA(s_RenderingBuffer, new BlenderBGRA()); s_ClippingPixelFormatProxy = new FormatClippingProxy(s_PixelFormt); //s_ClippingPixelFormatProxy = s_PixelFormt; m_CurAccumulatedMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); // new Matrix4X4(); m_ModelviewMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); // new Matrix4X4(); m_ProjectionMatrix = MatrixFactory <T> .NewIdentity(VectorDimension.Three); //new Matrix4X4(); m_pVertexCache = new VertexCachItem[m_MaxVertexCacheItems]; for (int i = 0; i < m_MaxVertexCacheItems; i++) { m_pVertexCache[i] = new VertexCachItem(); } m_LastSetColor = new RGBA_Doubles(1, 1, 1, 1); m_LastSetNormal = MatrixFactory <T> .CreateZeroVector(VectorDimension.Three); // new Vector3D(); m_LastSetTextureCoordinate = MatrixFactory <T> .CreateZeroVector(VectorDimension.Two); // new Vector2D(); }
public override void OnDraw() { #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 clippingProxy = new FormatClippingProxy(pf); clippingProxy.Clear(new RGBA_Doubles(0, 0, 0)); RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>(); ScanlineUnpacked8 sl = new ScanlineUnpacked8(); ScanlineBin sl_bin = new ScanlineBin(); RasterizerCompoundAA <T> rasc = new RasterizerCompoundAA <T>(); SpanAllocator alloc = new SpanAllocator(); uint i; styles_gouraud styles = new styles_gouraud(m_mesh, m_gamma); start_timer(); rasc.Reset(); //rasc.clip_box(40, 40, width() - 40, height() - 40); for (i = 0; i < m_mesh.num_edges(); i++) { mesh_edge e = m_mesh.edge(i); mesh_point p1 = m_mesh.vertex(e.p1); mesh_point p2 = m_mesh.vertex(e.p2); rasc.Styles(e.tl, e.tr); rasc.MoveToDbl(p1.x, p1.y); rasc.LineToDbl(p2.x, p2.y); } Renderer <T> .RenderCompound(rasc, sl, sl_bin, clippingProxy, alloc, styles); double tm = elapsed_time(); GsvText <T> t = new GsvText <T>(); t.SetFontSize(10.0); ConvStroke <T> pt = new ConvStroke <T>(t); pt.Width = M.New <T>(1.5); pt.LineCap = LineCap.Round; pt.LineJoin = LineJoin.RoundJoin; string buf = string.Format("{0:F2} ms, {1} triangles, {2:F0} tri/sec", tm, m_mesh.num_triangles(), m_mesh.num_triangles() / tm * 1000.0); t.StartPoint(10.0, 10.0); t.Text = buf; ras.AddPath(pt); Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(1, 1, 1).GetAsRGBA_Bytes()); if (m_gamma.Gamma() != 1.0) { pf.ApplyGammaInv(m_gamma); } }
internal ImageRenderer(Image <T> owner) : base() { m_Owner = owner; RasterizerScanlineAA <T> rasterizer = new RasterizerScanlineAA <T>(); IPixelFormat imagePixelFormat = new FormatRGBA(new RasterBuffer(), new BlenderBGRA()); FormatClippingProxy imageClippingProxy = new FormatClippingProxy(imagePixelFormat); Initialize(imageClippingProxy, rasterizer); ScanlineCache = new ScanlinePacked8(); }
public static void glClear(int mask) { if ((mask & GL_COLOR_BUFFER_BIT) != 0) { FormatRGBA pf = new FormatRGBA(s_RenderingBuffer, new BlenderBGRA()); FormatClippingProxy renderBase = new FormatClippingProxy(pf); RasterizerScanlineAA <T> rasterizer = new RasterizerScanlineAA <T>(); ScanlinePacked8 scanline = new ScanlinePacked8(); renderBase.Clear(s_ClearColor); } if ((mask & GL_DEPTH_BUFFER_BIT) != 0) { } }
public override bool init(uint width, uint height, uint flags) { bool good = base.init(width, height, flags); IPixelFormat screenPixelFormat; FormatClippingProxy screenClippingProxy; RasterizerScanlineAA <T> rasterizer = new RasterizerScanlineAA <T>(); ScanlinePacked8 scanlinePacked = new ScanlinePacked8(); if (rbuf_window().BitsPerPixel == 24) { screenPixelFormat = new FormatRGB(rbuf_window(), new BlenderBGR()); } else { screenPixelFormat = new FormatRGBA(rbuf_window(), new BlenderBGRA()); } screenClippingProxy = new FormatClippingProxy(screenPixelFormat); return(good); }
public override void OnInitialize() { IPixelFormat screenPixelFormat; FormatClippingProxy screenClippingProxy; AntiAliasedScanlineRasterizer rasterizer = new AntiAliasedScanlineRasterizer(); Scanline scanlinePacked = new Scanline(); if (RenderBufferWindow.BitsPerPixel == 24) { screenPixelFormat = new FormatRGB(RenderBufferWindow, new BlenderBGR()); } else { screenPixelFormat = new FormatRGBA(RenderBufferWindow, new BlenderBGRA()); } screenClippingProxy = new FormatClippingProxy(screenPixelFormat); m_ScreenRenderer = new Renderer(screenClippingProxy, rasterizer, scanlinePacked); m_ScreenRenderer.Rasterizer.SetVectorClipBox(0, 0, Width, Height); base.OnInitialize(); }
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() { IPixelFormat pixf; if (this.bpp() == 32) { pixf = new FormatRGBA(rbuf_window(), new BlenderBGRA()); //pixf = new pixfmt_alpha_blend_rgba32(rbuf_window(), new blender_rgba32()); } else { if (bpp() != 24) { throw new System.NotSupportedException(); } pixf = new FormatRGB(rbuf_window(), new BlenderBGR()); } FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf); clippingProxy.Clear(new RGBA_Doubles(1, 1, 1)); g_rasterizer.SetVectorClipBox(M.Zero <T>(), M.Zero <T>(), width(), height()); if (m_trans_type.cur_item() == 0) { Bilinear <T> tr = new Bilinear <T>(g_x1, g_y1, g_x2, g_y2, m_quad.polygon()); if (tr.IsValid()) { //-------------------------- // Render transformed lion // ConvTransform <T> trans = new ConvTransform <T>(g_path, tr); Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths); //-------------------------- //-------------------------- // Render transformed ellipse // VertexSource.Ellipse <T> ell = new AGG.VertexSource.Ellipse <T>(g_x1.Add(g_x2).Multiply(0.5), g_y1.Add(g_y2).Multiply(0.5), g_x2.Subtract(g_x1).Multiply(0.5), g_y2.Subtract(g_y1).Multiply(0.5), 200); ConvStroke <T> ell_stroke = new ConvStroke <T>(ell); ell_stroke.Width = M.New <T>(3.0); ConvTransform <T> trans_ell = new ConvTransform <T>(ell, tr); ConvTransform <T> trans_ell_stroke = new ConvTransform <T>(ell_stroke, tr); g_rasterizer.AddPath(trans_ell); Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.5, 0.3, 0.0, 0.3)); g_rasterizer.AddPath(trans_ell_stroke); Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.0, 0.3, 0.2, 1.0)); } } else { Perspective <T> tr = new Perspective <T>(g_x1, g_y1, g_x2, g_y2, m_quad.polygon()); if (tr.IsValid()) { // Render transformed lion ConvTransform <T> trans = new ConvTransform <T>(g_path, tr); Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths); // Render transformed ellipse VertexSource.Ellipse <T> FilledEllipse = new AGG.VertexSource.Ellipse <T>(g_x1.Add(g_x2).Multiply(0.5), g_y1.Add(g_y2).Multiply(0.5), g_x2.Subtract(g_x1).Multiply(0.5), g_y2.Subtract(g_y1).Multiply(0.5), 200); ConvStroke <T> EllipseOutline = new ConvStroke <T>(FilledEllipse); EllipseOutline.Width = M.New <T>(3.0); ConvTransform <T> TransformedFilledEllipse = new ConvTransform <T>(FilledEllipse, tr); ConvTransform <T> TransformedEllipesOutline = new ConvTransform <T>(EllipseOutline, tr); g_rasterizer.AddPath(TransformedFilledEllipse); Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.5, 0.3, 0.0, 0.3)); g_rasterizer.AddPath(TransformedEllipesOutline); Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0.0, 0.3, 0.2, 1.0)); } } //-------------------------- // 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.6)); //m_trans_type.Render(g_rasterizer, g_scanline, clippingProxy); base.OnDraw(); }
public override void OnDraw() { RasterizerScanlineAA <T> ras = new RasterizerScanlineAA <T>(); ScanlineUnpacked8 sl = new ScanlineUnpacked8(); #if SourceDepth24 FormatRGB pixf = new FormatRGB(rbuf_window(), new BlenderBGR()); #else FormatRGBA pixf = new FormatRGBA(rbuf_window(), new blender_bgra32()); #endif FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf); clippingProxy.Clear(new RGBA_Doubles(0, 0, 0)); m_profile.text_size(8.0); //m_profile.Render(ras, sl, clippingProxy); //m_spline_r.Render(ras, sl, clippingProxy); //m_spline_g.Render(ras, sl, clippingProxy); //m_spline_b.Render(ras, sl, clippingProxy); //m_spline_a.Render(ras, sl, clippingProxy); //m_GradTypeRBox.Render(ras, sl, clippingProxy); //m_GradWrapRBox.Render(ras, sl, clippingProxy); // draw a background to show how the alpha is working int RectWidth = 32; int xoffset = 238; int yoffset = 171; for (int i = 0; i < 7; i++) { for (int j = 0; j < 7; j++) { if ((i + j) % 2 != 0) { VertexSource.RoundedRect <T> rect = new VertexSource.RoundedRect <T>(i * RectWidth + xoffset, j * RectWidth + yoffset, (i + 1) * RectWidth + xoffset, (j + 1) * RectWidth + yoffset, 2); rect.NormalizeRadius(); // Drawing as an outline ras.AddPath(rect); Renderer <T> .RenderSolid(clippingProxy, ras, sl, new RGBA_Bytes(.9, .9, .9)); } } } double ini_scale = 1.0; IAffineTransformMatrix <T> mtx1 = MatrixFactory <T> .NewIdentity(VectorDimension.Two); mtx1.Scale(MatrixFactory <T> .CreateVector2D(ini_scale, ini_scale)); mtx1.Translate(MatrixFactory <T> .CreateVector2D(center_x, center_y)); mtx1.Add(trans_affine_resizing()); VertexSource.Ellipse <T> e1 = new AGG.VertexSource.Ellipse <T>(); e1.Init(0.0, 0.0, 110.0, 110.0, 64); IAffineTransformMatrix <T> mtx_g1 = MatrixFactory <T> .NewIdentity(VectorDimension.Two); mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(ini_scale, ini_scale)); mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(m_SaveData.m_scale, m_SaveData.m_scale)); mtx_g1.Scale(MatrixFactory <T> .CreateVector2D(m_scale_x, m_scale_y)); mtx_g1.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_SaveData.m_angle.ToDouble()); mtx_g1.Translate(MatrixFactory <T> .CreateVector2D(m_SaveData.m_center_x, m_SaveData.m_center_y)); mtx_g1.Add(trans_affine_resizing()); mtx_g1 = mtx_g1.Inverse; RGBA_Bytes[] color_profile = new RGBA_Bytes[256]; // color_type is defined in pixel_formats.h for (int i = 0; i < 256; i++) { color_profile[i] = new RGBA_Bytes(m_spline_r.spline()[i].ToInt(), m_spline_g.spline()[i].ToInt(), m_spline_b.spline()[i].ToInt(), m_spline_a.spline()[i].ToInt()); } ConvTransform <T> t1 = new ConvTransform <T>(e1, mtx1); IGradient innerGradient = null; switch (m_GradTypeRBox.cur_item()) { case 0: innerGradient = new GradientRadial(); break; case 1: innerGradient = new GradientDiamond(); break; case 2: innerGradient = new GradientX(); break; case 3: innerGradient = new GradientXY(); break; case 4: innerGradient = new GradientSqrtXY(); break; case 5: innerGradient = new GradientConic(); break; } IGradient outerGradient = null; switch (m_GradWrapRBox.cur_item()) { case 0: outerGradient = new GradientReflectAdaptor(innerGradient); break; case 1: outerGradient = new GradientRepeatAdaptor(innerGradient); break; case 2: outerGradient = new GradientClampAdaptor(innerGradient); break; } SpanAllocator span_alloc = new SpanAllocator(); ColorFunctionProfile colors = new ColorFunctionProfile(color_profile, m_profile.gamma()); SpanInterpolatorLinear <T> inter = new SpanInterpolatorLinear <T>(mtx_g1); SpanGradient <T> span_gen = new SpanGradient <T>(inter, outerGradient, colors, 0, 150); ras.AddPath(t1); Renderer <T> .GenerateAndRender(ras, sl, clippingProxy, span_alloc, span_gen); 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); }
/* * void draw_curve(Pattern patt, IRasterizer ras, Renderer ren, PatternSource src, IVertexSource vs) * { * patt.create(src); * ren.scale_x(m_scale_x.value()); * ren.start_x(m_start_x.value()); * ras.add_path(vs); * } */ public override void OnDraw() { #if SourceDepth24 FormatRGB pf = new FormatRGB(rbuf_window(), new BlenderBGR()); #else FormatRGBA pf = new FormatRGBA(rbuf_window(), new BlenderBGRA()); #endif FormatClippingProxy ren_base = new FormatClippingProxy(pf); ren_base.clear(new RGBA_Doubles(1.0, 1.0, .95)); rasterizer_scanline_aa ras = new rasterizer_scanline_aa(); scanline_packed_8 sl = new scanline_packed_8(); // Pattern source. Must have an interface: // width() const // height() const // pixel(int x, int y) const // Any agg::renderer_base<> or derived // is good for the use as a source. //----------------------------------- pattern_src_brightness_to_alpha_RGBA_Bytes p1 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(0)); pattern_src_brightness_to_alpha_RGBA_Bytes p2 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(1)); pattern_src_brightness_to_alpha_RGBA_Bytes p3 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(2)); pattern_src_brightness_to_alpha_RGBA_Bytes p4 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(3)); pattern_src_brightness_to_alpha_RGBA_Bytes p5 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(4)); pattern_src_brightness_to_alpha_RGBA_Bytes p6 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(5)); pattern_src_brightness_to_alpha_RGBA_Bytes p7 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(6)); pattern_src_brightness_to_alpha_RGBA_Bytes p8 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(7)); pattern_src_brightness_to_alpha_RGBA_Bytes p9 = new pattern_src_brightness_to_alpha_RGBA_Bytes(rbuf_img(8)); //pattern_filter_bilinear_rgba pattern_filter_bilinear_RGBA_Bytes fltr; // Filtering functor // agg::line_image_pattern is the main container for the patterns. It creates // a copy of the patterns extended according to the needs of the filter. // agg::line_image_pattern can operate with arbitrary image width, but if the // width of the pattern is power of 2, it's better to use the modified // version agg::line_image_pattern_pow2 because it works about 15-25 percent // faster than agg::line_image_pattern (because of using simple masking instead // of expensive '%' operation). //typedef agg::line_image_pattern<agg::pattern_filter_bilinear_RGBA_Bytes> pattern_type; //typedef agg::renderer_base<pixfmt> base_ren_type; //typedef agg::renderer_outline_image<base_ren_type, pattern_type> renderer_type; //typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type; //-- Create with specifying the source //pattern_type patt(fltr, src); //-- Create uninitialized and set the source line_image_pattern patt = new line_image_pattern(new pattern_filter_bilinear_RGBA_Bytes()); //renderer_outline_image ren_img = new renderer_outline_image(, patt); /* * renderer_type ren_img(ren_base, patt); * rasterizer_type ras_img(ren_img); * * draw_curve(patt, ras_img, ren_img, p1, m_curve1.curve()); * draw_curve(patt, ras_img, ren_img, p2, m_curve2.curve()); * draw_curve(patt, ras_img, ren_img, p3, m_curve3.curve()); * draw_curve(patt, ras_img, ren_img, p4, m_curve4.curve()); * draw_curve(patt, ras_img, ren_img, p5, m_curve5.curve()); * draw_curve(patt, ras_img, ren_img, p6, m_curve6.curve()); * draw_curve(patt, ras_img, ren_img, p7, m_curve7.curve()); * draw_curve(patt, ras_img, ren_img, p8, m_curve8.curve()); * draw_curve(patt, ras_img, ren_img, p9, m_curve9.curve()); */ base.OnDraw(); }
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(); }