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 Render(IVertexSource <T> vertexSource, uint pathIndexToRender, RGBA_Bytes colorBytes) { #if use_timers OpenGLRenderTimer.Start(); #endif PushOrthoProjection(); vertexSource.Rewind(pathIndexToRender); RGBA_Doubles color = colorBytes.GetAsRGBA_Doubles(); Gl.glColor4d(color.R, color.G, color.B, color.A); IAffineTransformMatrix <T> transform = GetTransform(); if (!transform.Equals(MatrixFactory <T> .NewIdentity(VectorDimension.Two))) { vertexSource = new ConvTransform <T>(vertexSource, transform); } if (m_ForceTexturedEdgeAntiAliasing) { DrawAAShape(vertexSource); } else { SendShapeToTeselator(m_RenderNowTesselator, vertexSource); } PopOrthoProjection(); #if use_timers OpenGLRenderTimer.Stop(); #endif }
protected override void DoDraw(RendererBase <T> destRenderer) { IAffineTransformMatrix <T> Final = MatrixFactory <T> .NewIdentity(VectorDimension.Two); Final.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_Rotation.ToDouble()); Final.Translate(m_Position); ConvTransform <T> TransformedShip = new ConvTransform <T>(m_PlayerToDraw, Final); destRenderer.Render(TransformedShip, new RGBA_Bytes(.9, .4, .2, 1)); }
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)); }
// format - see enum pix_format_e {}; // flip_y - true if you want to have the Y-axis flipped vertically. public PlatformSupportAbstract(PixelFormats format, ERenderOrigin RenderOrigin) { m_format = format; m_bpp = GetBitDepthForPixelFormat(format); m_RenderOrigin = RenderOrigin; m_initial_width = 10; m_initial_height = 10; m_resize_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two); m_rbuf_img = new List <RasterBuffer>(); }
public override void Render(IVertexSource<T> vertexSource, uint pathIndexToRender, RGBA_Bytes colorBytes) { m_Rasterizer.Reset(); IAffineTransformMatrix<T> transform = GetTransform(); if (!transform.Equals(MatrixFactory<T>.NewIdentity(VectorDimension.Two))) { vertexSource = new ConvTransform<T>(vertexSource, transform); } m_Rasterizer.AddPath(vertexSource, pathIndexToRender); Renderer<T>.RenderSolid(m_PixelFormat, m_Rasterizer, m_ScanlineCache, colorBytes); }
//------------------------------------------------------------------- public IAffineTransformMatrix <T> ToAffine() { //Affine mtx = Affine.NewTranslation(-m_wx1, -m_wy1); //mtx *= Affine.NewScaling(m_kx, m_ky); //mtx *= Affine.NewTranslation(m_dx1, m_dy1); //return mtx; IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(VectorDimension.Two); a.Translate(MatrixFactory <T> .CreateVector2D(m_wx1.Negative(), m_wy1.Negative())); a.Scale(MatrixFactory <T> .CreateVector2D(m_kx, m_ky)); a.Scale(MatrixFactory <T> .CreateVector2D(m_dx1, m_dy1)); return(a); }
public void TransformTest() { IAffineTransformMatrix <DoubleComponent> a = MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two); a.Translate(MatrixFactory <DoubleComponent> .CreateVector2D(10, 20)); DoubleComponent x = 10; DoubleComponent y = 20; DoubleComponent newx = 0; DoubleComponent newy = 0; a.Transform(ref newx, ref newy); Assert.AreEqual((double)x, (double)newx, .001); Assert.AreEqual((double)y, (double)newy, .001); }
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)); }
//used to Transform the sweepers vertices prior to rendering public void WorldTransform(List <IVector <T> > sweeper) { ////create the world transformation matrix //Matrix4X4 matTransform = new Matrix4X4(); ////scale //matTransform.Scale(m_dScale, m_dScale, 1); ////rotate //matTransform.AddRotate(2, (double)m_dRotation); ////and translate //matTransform.AddTranslate(m_vPosition.x, m_vPosition.y, 0); ////now Transform the ships vertices //for (int i = 0; i < sweeper.Count; i++) //{ // Vector3D Temp = sweeper[i]; // matTransform.TransformVector(ref Temp); // sweeper[i] = Temp; //} //create the world transformation matrix IAffineTransformMatrix <T> matTransform = MatrixFactory <T> .NewIdentity(VectorDimension.Three); //scale matTransform.Scale(MatrixFactory <T> .CreateVector3D(m_dScale, m_dScale, M.One <T>())); //rotate //matTransform.AddRotate(2, (double)m_dRotation); IVector <T> axis = null;/// need to work out which axis this should be matTransform.RotateAlong(axis, m_dRotation); //and translate matTransform.Translate(MatrixFactory <T> .CreateVector3D(m_vPosition[0], m_vPosition[1], M.Zero <T>())); //now Transform the ships vertices for (int i = 0; i < sweeper.Count; i++) { IVector <T> Temp = sweeper[i]; Temp = matTransform.TransformVector(Temp); sweeper[i] = Temp; } }
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)); }
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 void WorldTransform(List <IVector <T> > VBuffer, IVector <T> vPos) { //create the world transformation matrix //Matrix4X4 matTransform = new Matrix4X4(); IAffineTransformMatrix <T> matTransform = MatrixFactory <T> .NewIdentity(VectorDimension.Three); //scale matTransform.Scale(MatrixFactory <T> .CreateVector2D(m_MineScale, m_MineScale)); //translate matTransform.Translate(MatrixFactory <T> .CreateVector2D(vPos[0], vPos[1])); //Transform the ships vertices for (int i = 0; i < VBuffer.Count; i++) { IVector <T> Temp = VBuffer[i]; Temp = matTransform.TransformVector(Temp); VBuffer[i] = Temp; } }
public void InvertTest() { //Affine a = Affine.NewIdentity(); IAffineTransformMatrix <DoubleComponent> a = MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two); a.Translate( MatrixFactory <DoubleComponent> .CreateVector2D( M.New <DoubleComponent>(10), M.New <DoubleComponent>(10))); IAffineTransformMatrix <DoubleComponent> b = MatrixFactory <DoubleComponent> .CreateAffine(a); b = b.Inverse; DoubleComponent x = 100; DoubleComponent y = 100; DoubleComponent newx = x; DoubleComponent newy = y; IVector <DoubleComponent> v1 = MatrixFactory <DoubleComponent> .CreateVector2D( M.New <DoubleComponent>(100), M.New <DoubleComponent>(100)); IVector <DoubleComponent> v2 = a.TransformVector(v1); IVector <DoubleComponent> v3 = b.TransformVector(v2); //a.Transform(ref newx, ref newy); //b.Transform(ref newx, ref newy); Assert.AreEqual((double)v1[0], (double)v3[0], .001); Assert.AreEqual((double)v1[1], (double)v3[1], .001); }
public RendererBase() { TextPath = new GsvText <T>(); StrockedText = new ConvStroke <T>(TextPath); m_AffineTransformStack.Push(MatrixFactory <T> .NewIdentity(VectorDimension.Two)); }
public blur_application(PixelFormats format, ERenderOrigin RenderOrigin) : base(format, RenderOrigin) { m_rbuf2 = new RasterBuffer(); m_shape_bounds = new RectDouble <T>(); m_method = new rbox_ctrl <T>(10.0, 10.0, 130.0, 70.0); m_radius = new SliderWidget <T>(130 + 10.0, 10.0 + 4.0, 130 + 300.0, 10.0 + 8.0 + 4.0); m_shadow_ctrl = new polygon_ctrl <T>(4); m_channel_r = new cbox_ctrl <T>(10.0, 80.0, "Red"); m_channel_g = new cbox_ctrl <T>(10.0, 95.0, "Green"); m_channel_b = new cbox_ctrl <T>(10.0, 110.0, "Blue"); m_FlattenCurves = new cbox_ctrl <T>(10, 315, "Convert And Flatten Curves"); m_FlattenCurves.status(true); AddChild(m_method); m_method.text_size(8); m_method.add_item("Stack Blur"); m_method.add_item("Recursive Blur"); m_method.add_item("Channels"); m_method.cur_item(1); AddChild(m_radius); m_radius.range(0.0, 40.0); m_radius.value(15.0); m_radius.label("Blur Radius={0:F2}"); AddChild(m_shadow_ctrl); AddChild(m_channel_r); AddChild(m_channel_g); AddChild(m_channel_b); AddChild(m_FlattenCurves); m_channel_g.status(true); m_sl = new ScanlinePacked8(); m_path = new PathStorage <T>(); m_shape = new ConvCurve <T>(m_path); m_path.RemoveAll(); m_path.MoveTo(28.47, 6.45); m_path.Curve3(21.58, 1.12, 19.82, 0.29); m_path.Curve3(17.19, -0.93, 14.21, -0.93); m_path.Curve3(9.57, -0.93, 6.57, 2.25); m_path.Curve3(3.56, 5.42, 3.56, 10.60); m_path.Curve3(3.56, 13.87, 5.03, 16.26); m_path.Curve3(7.03, 19.58, 11.99, 22.51); m_path.Curve3(16.94, 25.44, 28.47, 29.64); m_path.LineTo(28.47, 31.40); m_path.Curve3(28.47, 38.09, 26.34, 40.58); m_path.Curve3(24.22, 43.07, 20.17, 43.07); m_path.Curve3(17.09, 43.07, 15.28, 41.41); m_path.Curve3(13.43, 39.75, 13.43, 37.60); m_path.LineTo(13.53, 34.77); m_path.Curve3(13.53, 32.52, 12.38, 31.30); m_path.Curve3(11.23, 30.08, 9.38, 30.08); m_path.Curve3(7.57, 30.08, 6.42, 31.35); m_path.Curve3(5.27, 32.62, 5.27, 34.81); m_path.Curve3(5.27, 39.01, 9.57, 42.53); m_path.Curve3(13.87, 46.04, 21.63, 46.04); m_path.Curve3(27.59, 46.04, 31.40, 44.04); m_path.Curve3(34.28, 42.53, 35.64, 39.31); m_path.Curve3(36.52, 37.21, 36.52, 30.71); m_path.LineTo(36.52, 15.53); m_path.Curve3(36.52, 9.13, 36.77, 7.69); m_path.Curve3(37.01, 6.25, 37.57, 5.76); m_path.Curve3(38.13, 5.27, 38.87, 5.27); m_path.Curve3(39.65, 5.27, 40.23, 5.62); m_path.Curve3(41.26, 6.25, 44.19, 9.18); m_path.LineTo(44.19, 6.45); m_path.Curve3(38.72, -0.88, 33.74, -0.88); m_path.Curve3(31.35, -0.88, 29.93, 0.78); m_path.Curve3(28.52, 2.44, 28.47, 6.45); m_path.ClosePolygon(); m_path.MoveTo(28.47, 9.62); m_path.LineTo(28.47, 26.66); m_path.Curve3(21.09, 23.73, 18.95, 22.51); m_path.Curve3(15.09, 20.36, 13.43, 18.02); m_path.Curve3(11.77, 15.67, 11.77, 12.89); m_path.Curve3(11.77, 9.38, 13.87, 7.06); m_path.Curve3(15.97, 4.74, 18.70, 4.74); m_path.Curve3(22.41, 4.74, 28.47, 9.62); m_path.ClosePolygon(); IAffineTransformMatrix <T> shape_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two); shape_mtx.Scale(M.New <T>(4.0)); shape_mtx.Translate(MatrixFactory <T> .CreateVector2D(150, 100)); m_path.Transform(shape_mtx); BoundingRect <T> .BoundingRectSingle(m_shape, 0, ref m_shape_bounds); m_shadow_ctrl.SetXN(0, m_shape_bounds.x1); m_shadow_ctrl.SetYN(0, m_shape_bounds.y1); m_shadow_ctrl.SetXN(1, m_shape_bounds.x2); m_shadow_ctrl.SetYN(1, m_shape_bounds.y1); m_shadow_ctrl.SetXN(2, m_shape_bounds.x2); m_shadow_ctrl.SetYN(2, m_shape_bounds.y2); m_shadow_ctrl.SetXN(3, m_shape_bounds.x1); m_shadow_ctrl.SetYN(3, m_shape_bounds.y2); m_shadow_ctrl.line_color(new RGBA_Doubles(0, 0.3, 0.5, 0.3)); }
//-------------------------------------------------------------------- public SpanInterpolatorPerspLerp() { m_trans_dir = MatrixFactory <T> .NewIdentity(VectorDimension.Two); // new Transform.Perspective(); m_trans_inv = MatrixFactory <T> .NewIdentity(VectorDimension.Two); //new Transform.Perspective(); }
public override void OnDraw() { int width = (int)rbuf_window().Width; int height = (int)rbuf_window().Height; if (m_num_cb.value().NotEqual(m_slider_value)) { generate_alpha_mask(width, height); m_slider_value = m_num_cb.value(); } g_rasterizer.SetVectorClipBox(0, 0, width, height); IPixelFormat pf = new FormatRGB(rbuf_window(), new BlenderBGR()); unsafe { fixed(byte *pAlphaBuffer = m_alpha_buf) { m_alpha_mask_rbuf.attach(pAlphaBuffer, (uint)width, (uint)height, width, 1); AGG.PixelFormat.AlphaMaskAdaptor pixFormatAlphaMaskAdaptor = new AGG.PixelFormat.AlphaMaskAdaptor(pf, m_alpha_mask); FormatClippingProxy alphaMaskClippingProxy = new FormatClippingProxy(pixFormatAlphaMaskAdaptor); FormatClippingProxy clippingProxy = new FormatClippingProxy(pf); 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)); clippingProxy.Clear(new RGBA_Doubles(1, 1, 1)); // draw a background to show how the mask is working better int RectWidth = 30; for (int i = 0; i < 40; i++) { for (int j = 0; j < 40; j++) { if ((i + j) % 2 != 0) { VertexSource.RoundedRect <T> rect = new VertexSource.RoundedRect <T>(i * RectWidth, j * RectWidth, (i + 1) * RectWidth, (j + 1) * RectWidth, 0); rect.NormalizeRadius(); // Drawing as an outline g_rasterizer.AddPath(rect); Renderer <T> .RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(.9, .9, .9)); } } } //int x, y; // Render the lion ConvTransform <T> trans = new ConvTransform <T>(g_path, mtx); Renderer <T> .RenderSolidAllPaths(alphaMaskClippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths); /* * // Render random Bresenham lines and markers * agg::renderer_markers<amask_ren_type> m(r); * for(i = 0; i < 50; i++) * { * m.line_color(agg::rgba8(randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * (randGenerator.Next() & 0x7F) + 0x7F)); * m.fill_color(agg::rgba8(randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * (randGenerator.Next() & 0x7F) + 0x7F)); * * m.line(m.coord(randGenerator.Next() % width), m.coord(randGenerator.Next() % height), * m.coord(randGenerator.Next() % width), m.coord(randGenerator.Next() % height)); * * m.marker(randGenerator.Next() % width, randGenerator.Next() % height, randGenerator.Next() % 10 + 5, * agg::marker_e(randGenerator.Next() % agg::end_of_markers)); * } * * * // Render random anti-aliased lines * double w = 5.0; * agg::line_profile_aa profile; * profile.width(w); * * typedef agg::renderer_outline_aa<amask_ren_type> renderer_type; * renderer_type ren(r, profile); * * typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type; * rasterizer_type ras(ren); * ras.round_cap(true); * * for(i = 0; i < 50; i++) * { * ren.Color = agg::rgba8(randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * //255)); * (randGenerator.Next() & 0x7F) + 0x7F); * ras.move_to_d(randGenerator.Next() % width, randGenerator.Next() % height); * ras.line_to_d(randGenerator.Next() % width, randGenerator.Next() % height); * ras.render(false); * } * * * // Render random circles with gradient * typedef agg::gradient_linear_color<color_type> grad_color; * typedef agg::gradient_circle grad_func; * typedef agg::span_interpolator_linear<> interpolator_type; * typedef agg::span_gradient<color_type, * interpolator_type, * grad_func, * grad_color> span_grad_type; * * agg::trans_affine grm; * grad_func grf; * grad_color grc(agg::rgba8(0,0,0), agg::rgba8(0,0,0)); * agg::ellipse ell; * agg::span_allocator<color_type> sa; * interpolator_type inter(grm); * span_grad_type sg(inter, grf, grc, 0, 10); * agg::renderer_scanline_aa<amask_ren_type, * agg::span_allocator<color_type>, * span_grad_type> rg(r, sa, sg); * for(i = 0; i < 50; i++) * { * x = randGenerator.Next() % width; * y = randGenerator.Next() % height; * double r = randGenerator.Next() % 10 + 5; * grm.reset(); * grm *= agg::trans_affine_scaling(r / 10.0); * grm *= agg::trans_affine_translation(x, y); * grm.invert(); * grc.colors(agg::rgba8(255, 255, 255, 0), * agg::rgba8(randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * randGenerator.Next() & 0x7F, * 255)); * sg.color_function(grc); * ell.init(x, y, r, r, 32); * g_rasterizer.add_path(ell); * agg::render_scanlines(g_rasterizer, g_scanline, rg); * } */ //m_num_cb.Render(g_rasterizer, g_scanline, clippingProxy); } m_alpha_mask_rbuf.dettachBuffer(); } 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(); }
void transform_image(double angle) { double width = rbuf_img(0).Width; double height = rbuf_img(0).Height; #if SourceDepth24 FormatRGB pixf = new FormatRGB(rbuf_img(0), new BlenderBGR()); FormatRGB pixf_pre = new FormatRGB(rbuf_img(0), new BlenderPreMultBGR()); #else pixfmt_alpha_blend_rgba32 pixf = new pixfmt_alpha_blend_rgba32(rbuf_img(0), new blender_bgra32()); pixfmt_alpha_blend_rgba32 pixf_pre = new pixfmt_alpha_blend_rgba32(rbuf_img(0), new blender_bgra_pre()); #endif FormatClippingProxy rb = new FormatClippingProxy(pixf); FormatClippingProxy rb_pre = new FormatClippingProxy(pixf_pre); rb.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(-width / 2.0, -height / 2.0)); src_mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), angle * Math.PI / 180.0); src_mtx.Translate(MatrixFactory <T> .CreateVector2D(width / 2.0, height / 2.0)); IAffineTransformMatrix <T> img_mtx = MatrixFactory <T> .CreateAffine(src_mtx); img_mtx = img_mtx.Inverse; double r = width; if (height < r) { r = height; } r *= 0.5; r -= 4.0; VertexSource.Ellipse <T> ell = new AGG.VertexSource.Ellipse <T>(width / 2.0, height / 2.0, r, r, 200); ConvTransform <T> tr = new ConvTransform <T>(ell, src_mtx); m_num_pix += r * r * Math.PI; SpanInterpolatorLinear <T> interpolator = new SpanInterpolatorLinear <T>(img_mtx); ImageFilterLookUpTable <T> filter = new ImageFilterLookUpTable <T>(); bool norm = m_normalize.status(); #if SourceDepth24 FormatRGB pixf_img = new FormatRGB(rbuf_img(1), new BlenderBGR()); #else pixfmt_alpha_blend_rgba32 pixf_img = new pixfmt_alpha_blend_rgba32(rbuf_img(1), new blender_bgra32()); #endif RasterBufferAccessorClip source = new RasterBufferAccessorClip(pixf_img, RGBA_Doubles.RgbaPre(0, 0, 0, 0)); switch (m_filters.cur_item()) { case 0: { #if SourceDepth24 SpanImageFilterRgbNN <T> sg = new SpanImageFilterRgbNN <T>(source, interpolator); #else span_image_filter_rgba_nn sg = new span_image_filter_rgba_nn(source, interpolator); #endif m_Rasterizer.AddPath(tr); Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg); } break; case 1: { #if SourceDepth24 //span_image_filter_rgb_bilinear_clip sg = new span_image_filter_rgb_bilinear_clip(pixf_img, rgba.rgba_pre(0, 0.4, 0, 0.5), interpolator); SpanImageFilterRgbBilinear <T> sg = new SpanImageFilterRgbBilinear <T>(source, interpolator); #else //span_image_filter_rgba_bilinear_clip sg = new span_image_filter_rgba_bilinear_clip(pixf_img, rgba.rgba_pre(0, 0, 0, 0), interpolator); span_image_filter_rgba_bilinear sg = new span_image_filter_rgba_bilinear(source, interpolator); #endif m_Rasterizer.AddPath(tr); Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg); } break; case 5: case 6: case 7: { switch (m_filters.cur_item()) { case 5: filter.Calculate(new ImageFilterHanning <T>(), norm); break; case 6: filter.Calculate(new ImageFilterHamming <T>(), norm); break; case 7: filter.Calculate(new ImageFilterHermite <T>(), norm); break; } SpanImageFilterRgb2x2 <T> sg = new SpanImageFilterRgb2x2 <T>(source, interpolator, filter); m_Rasterizer.AddPath(tr); Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg); } break; case 2: case 3: case 4: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: { switch (m_filters.cur_item()) { case 2: filter.Calculate(new ImageFilterBicubic <T>(), norm); break; case 3: filter.Calculate(new ImageFilterSpline16 <T>(), norm); break; case 4: filter.Calculate(new ImageFilterSpline36 <T>(), norm); break; case 8: filter.Calculate(new ImageFilterKaiser <T>(), norm); break; case 9: filter.Calculate(new ImageFilterQuadric <T>(), norm); break; case 10: filter.Calculate(new ImageFilterCatrom <T>(), norm); break; case 11: filter.Calculate(new ImageFilterGaussian <T>(), norm); break; case 12: filter.Calculate(new ImageFilterBessel <T>(), norm); break; case 13: filter.Calculate(new ImageFilterMitchell <T>(), norm); break; case 14: filter.Calculate(new ImageFilterSinc <T>(m_radius.value()), norm); break; case 15: filter.Calculate(new ImageFilterLanczos <T>(m_radius.value()), norm); break; case 16: filter.Calculate(new ImageFilterBlackman <T>(m_radius.value()), norm); break; } #if SourceDepth24 SpanImageFilterRgb <T> sg = new SpanImageFilterRgb <T>(source, interpolator, filter); #else span_image_filter_rgb sg = new span_image_filter_rgba(source, interpolator, filter); #endif m_Rasterizer.AddPath(tr); Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg); } break; } }
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(); }