virtual void on_draw() { agg::rasterizer_scanline_aa<> pf; agg::scanline_p8 sl; typedef agg::renderer_base<pixfmt> renderer_base; pixfmt pixf(rbuf_window()); renderer_base rb(pixf); rb.clear(agg::rgba(1, 1, 1)); agg::ellipse e1; agg::conv_transform<agg::ellipse> t1(e1, trans_affine_resizing()); unsigned i; unsigned n_drawn = 0; for (i = 0; i < m_num_points; i++) { double z = m_points[i].z; double alpha = 1.0; if (z < m_scale_ctrl_z.value1()) { alpha = 1.0 - (m_scale_ctrl_z.value1() - z) * m_slider_ctrl_sel.value() * 100.0; } if (z > m_scale_ctrl_z.value2()) { alpha = 1.0 - (z - m_scale_ctrl_z.value2()) * m_slider_ctrl_sel.value() * 100.0; } if (alpha > 1.0) alpha = 1.0; if (alpha < 0.0) alpha = 0.0; if (alpha > 0.0) { e1.init(m_points[i].x, m_points[i].y, m_slider_ctrl_size.value() * 5.0, m_slider_ctrl_size.value() * 5.0, 8); pf.add_path(t1); agg::render_scanlines_aa_solid( pf, sl, rb, agg::rgba(m_points[i].color.r, m_points[i].color.g, m_points[i].color.b, alpha)); n_drawn++; } } agg::render_ctrl(pf, sl, rb, m_scale_ctrl_z); agg::render_ctrl(pf, sl, rb, m_slider_ctrl_sel); agg::render_ctrl(pf, sl, rb, m_slider_ctrl_size); char buf[10]; sprintf(buf, "%08u", n_drawn); agg::gsv_text txt; txt.size(15.0); txt.text(buf); txt.start_point(10.0, initial_height() - 20.0); agg::gsv_text_outline<> txt_o(txt, trans_affine_resizing()); pf.add_path(txt_o); agg::render_scanlines_aa_solid(pf, sl, rb, agg::rgba(0, 0, 0)); }
virtual void on_mouse_button_down(int x, int y, unsigned flags) { if (flags & agg::mouse_left) { m_mouse_x = x; m_mouse_y = y; trans_affine_resizing().inverse_transform(&m_mouse_x, &m_mouse_y); force_redraw(); } }
void radial_shape(RenBase& rbase, const ColorRamp& colors, double x1, double y1, double x2, double y2) { typedef RenBase renderer_base_type; typedef agg::gradient_radial gradient_func_type; typedef ColorRamp color_func_type; typedef agg::span_interpolator_linear<> interpolator_type; typedef agg::span_allocator<color> span_allocator_type; typedef agg::span_gradient<color, interpolator_type, gradient_func_type, color_func_type> span_gradient_type; gradient_func_type gradient_func; // The gradient function agg::trans_affine gradient_mtx; interpolator_type span_interpolator(gradient_mtx); // Span interpolator span_allocator_type span_allocator; // Span Allocator span_gradient_type span_gradient(span_interpolator, gradient_func, colors, 0, 100); double cx = (x1 + x2) / 2.0; double cy = (y1 + y2) / 2.0; double r = 0.5 * (((x2 - x1) < (y2 - y1)) ? (x2 - x1) : (y2 - y1)); gradient_mtx *= agg::trans_affine_scaling(r / 100.0); gradient_mtx *= agg::trans_affine_translation(cx, cy); gradient_mtx *= trans_affine_resizing(); gradient_mtx.invert(); agg::ellipse ell(cx, cy, r, r, 100); agg::conv_transform<agg::ellipse> trans(ell, trans_affine_resizing()); m_ras.add_path(trans); agg::render_scanlines_aa(m_ras, m_sl, rbase, span_allocator, span_gradient); }
unsigned render_sbool(Rasterizer& ras1, Rasterizer& ras2) { pixfmt pf(rbuf_window()); agg::renderer_base<pixfmt> rb(pf); agg::renderer_scanline_aa_solid<agg::renderer_base<pixfmt> > ren(rb); agg::scanline_p8 sl; ras1.filling_rule(m_fill_rule.cur_item() ? agg::fill_non_zero : agg::fill_even_odd); ras2.filling_rule(m_fill_rule.cur_item() ? agg::fill_non_zero : agg::fill_even_odd); switch(m_polygons.cur_item()) { case 0: { //------------------------------------ // Two simple paths // agg::path_storage ps1; agg::path_storage ps2; double x = m_x - initial_width()/2 + 100; double y = m_y - initial_height()/2 + 100; ps1.move_to(x+140, y+145); ps1.line_to(x+225, y+44); ps1.line_to(x+296, y+219); ps1.close_polygon(); ps1.line_to(x+226, y+289); ps1.line_to(x+82, y+292); ps1.move_to(x+220, y+222); ps1.line_to(x+363, y+249); ps1.line_to(x+265, y+331); ps1.move_to(x+242, y+243); ps1.line_to(x+325, y+261); ps1.line_to(x+268, y+309); ps1.move_to(x+259, y+259); ps1.line_to(x+273, y+288); ps1.line_to(x+298, y+266); ps2.move_to(100+32, 100+77); ps2.line_to(100+473, 100+263); ps2.line_to(100+351, 100+290); ps2.line_to(100+354, 100+374); ras1.reset(); ras1.add_path(ps1); ren.color(agg::rgba(0, 0, 0, 0.1)); agg::render_scanlines(ras1, sl, ren); ras2.reset(); ras2.add_path(ps2); ren.color(agg::rgba(0, 0.6, 0, 0.1)); agg::render_scanlines(ras2, sl, ren); render_scanline_boolean(ras1, ras2); } break; case 1: { //------------------------------------ // Closed stroke // agg::path_storage ps1; agg::path_storage ps2; agg::conv_stroke<agg::path_storage> stroke(ps2); stroke.width(15.0); double x = m_x - initial_width()/2 + 100; double y = m_y - initial_height()/2 + 100; ps1.move_to(x+140, y+145); ps1.line_to(x+225, y+44); ps1.line_to(x+296, y+219); ps1.close_polygon(); ps1.line_to(x+226, y+289); ps1.line_to(x+82, y+292); ps1.move_to(x+220-50, y+222); ps1.line_to(x+363-50, y+249); ps1.line_to(x+265-50, y+331); ps1.close_polygon(); ps2.move_to(100+32, 100+77); ps2.line_to(100+473, 100+263); ps2.line_to(100+351, 100+290); ps2.line_to(100+354, 100+374); ps2.close_polygon(); ras1.reset(); ras1.add_path(ps1); ren.color(agg::rgba(0, 0, 0, 0.1)); agg::render_scanlines(ras1, sl, ren); ras2.reset(); ras2.add_path(stroke); ren.color(agg::rgba(0, 0.6, 0, 0.1)); agg::render_scanlines(ras2, sl, ren); render_scanline_boolean(ras1, ras2); } break; case 2: { //------------------------------------ // Great Britain and Arrows // agg::path_storage gb_poly; agg::path_storage arrows; make_gb_poly(gb_poly); make_arrows(arrows); agg::trans_affine mtx1; agg::trans_affine mtx2; mtx1 *= agg::trans_affine_translation(-1150, -1150); mtx1 *= agg::trans_affine_scaling(2.0); mtx2 = mtx1; mtx2 *= agg::trans_affine_translation(m_x - initial_width()/2, m_y - initial_height()/2); agg::conv_transform<agg::path_storage> trans_gb_poly(gb_poly, mtx1); agg::conv_transform<agg::path_storage> trans_arrows(arrows, mtx2); ras2.add_path(trans_gb_poly); ren.color(agg::rgba(0.5, 0.5, 0, 0.1)); agg::render_scanlines(ras2, sl, ren); agg::conv_stroke<agg::conv_transform<agg::path_storage> > stroke_gb_poly(trans_gb_poly); stroke_gb_poly.width(0.1); ras1.add_path(stroke_gb_poly); ren.color(agg::rgba(0, 0, 0)); agg::render_scanlines(ras1, sl, ren); ras2.add_path(trans_arrows); ren.color(agg::rgba(0.0, 0.5, 0.5, 0.1)); agg::render_scanlines(ras2, sl, ren); ras1.reset(); ras1.add_path(trans_gb_poly); render_scanline_boolean(ras1, ras2); } break; case 3: { //------------------------------------ // Great Britain and a Spiral // spiral sp(m_x, m_y, 10, 150, 30, 0.0); agg::conv_stroke<spiral> stroke(sp); stroke.width(15.0); agg::path_storage gb_poly; make_gb_poly(gb_poly); agg::trans_affine mtx; mtx *= agg::trans_affine_translation(-1150, -1150); mtx *= agg::trans_affine_scaling(2.0); mtx *= trans_affine_resizing(); agg::conv_transform<agg::path_storage> trans_gb_poly(gb_poly, mtx); ras1.add_path(trans_gb_poly); ren.color(agg::rgba(0.5, 0.5, 0, 0.1)); agg::render_scanlines(ras1, sl, ren); agg::conv_stroke<agg::conv_transform<agg::path_storage> > stroke_gb_poly(trans_gb_poly); stroke_gb_poly.width(0.1); ras1.reset(); ras1.add_path(stroke_gb_poly); ren.color(agg::rgba(0, 0, 0)); agg::render_scanlines(ras1, sl, ren); ras2.reset(); ras2.add_path(stroke); ren.color(agg::rgba(0.0, 0.5, 0.5, 0.1)); agg::render_scanlines(ras2, sl, ren); ras1.reset(); ras1.add_path(trans_gb_poly); render_scanline_boolean(ras1, ras2); } break; case 4: { //------------------------------------ // Spiral and glyph // spiral sp(m_x, m_y, 10, 150, 30, 0.0); agg::conv_stroke<spiral> stroke(sp); stroke.width(15.0); agg::path_storage glyph; glyph.move_to(28.47, 6.45); glyph.curve3(21.58, 1.12, 19.82, 0.29); glyph.curve3(17.19, -0.93, 14.21, -0.93); glyph.curve3(9.57, -0.93, 6.57, 2.25); glyph.curve3(3.56, 5.42, 3.56, 10.60); glyph.curve3(3.56, 13.87, 5.03, 16.26); glyph.curve3(7.03, 19.58, 11.99, 22.51); glyph.curve3(16.94, 25.44, 28.47, 29.64); glyph.line_to(28.47, 31.40); glyph.curve3(28.47, 38.09, 26.34, 40.58); glyph.curve3(24.22, 43.07, 20.17, 43.07); glyph.curve3(17.09, 43.07, 15.28, 41.41); glyph.curve3(13.43, 39.75, 13.43, 37.60); glyph.line_to(13.53, 34.77); glyph.curve3(13.53, 32.52, 12.38, 31.30); glyph.curve3(11.23, 30.08, 9.38, 30.08); glyph.curve3(7.57, 30.08, 6.42, 31.35); glyph.curve3(5.27, 32.62, 5.27, 34.81); glyph.curve3(5.27, 39.01, 9.57, 42.53); glyph.curve3(13.87, 46.04, 21.63, 46.04); glyph.curve3(27.59, 46.04, 31.40, 44.04); glyph.curve3(34.28, 42.53, 35.64, 39.31); glyph.curve3(36.52, 37.21, 36.52, 30.71); glyph.line_to(36.52, 15.53); glyph.curve3(36.52, 9.13, 36.77, 7.69); glyph.curve3(37.01, 6.25, 37.57, 5.76); glyph.curve3(38.13, 5.27, 38.87, 5.27); glyph.curve3(39.65, 5.27, 40.23, 5.62); glyph.curve3(41.26, 6.25, 44.19, 9.18); glyph.line_to(44.19, 6.45); glyph.curve3(38.72, -0.88, 33.74, -0.88); glyph.curve3(31.35, -0.88, 29.93, 0.78); glyph.curve3(28.52, 2.44, 28.47, 6.45); glyph.close_polygon(); glyph.move_to(28.47, 9.62); glyph.line_to(28.47, 26.66); glyph.curve3(21.09, 23.73, 18.95, 22.51); glyph.curve3(15.09, 20.36, 13.43, 18.02); glyph.curve3(11.77, 15.67, 11.77, 12.89); glyph.curve3(11.77, 9.38, 13.87, 7.06); glyph.curve3(15.97, 4.74, 18.70, 4.74); glyph.curve3(22.41, 4.74, 28.47, 9.62); glyph.close_polygon(); agg::trans_affine mtx; mtx *= agg::trans_affine_scaling(4.0); mtx *= agg::trans_affine_translation(220, 200); agg::conv_transform<agg::path_storage> trans(glyph, mtx); agg::conv_curve<agg::conv_transform<agg::path_storage> > curve(trans); ras1.reset(); ras1.add_path(stroke); ren.color(agg::rgba(0, 0, 0, 0.1)); agg::render_scanlines(ras1, sl, ren); ras2.reset(); ras2.add_path(curve); ren.color(agg::rgba(0, 0.6, 0, 0.1)); agg::render_scanlines(ras2, sl, ren); render_scanline_boolean(ras1, ras2); } break; } return 0; }
virtual void on_draw() { double ewidth = initial_width() / 2 - 10; double ecenter = initial_width() / 2; typedef agg::renderer_base<pixfmt> ren_base; pixfmt pixf(rbuf_window()); ren_base rb(pixf); agg::rgba8 color; rb.clear(agg::rgba(1, 1, 1)); g_ctrl.text_size(10.0, 12.0); agg::rasterizer_scanline_aa<> ras; agg::scanline_p8 sl; agg::render_ctrl(ras, sl, rb, g_ctrl); ras.gamma(g_ctrl); agg::ellipse ellipse; agg::conv_stroke<agg::ellipse> poly(ellipse); agg::conv_transform<agg::conv_stroke<agg::ellipse> > tpoly(poly, trans_affine_resizing()); color = agg::rgba8(0, 0, 0); ellipse.init(ecenter, 220, ewidth, 15, 100); poly.width(2.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 220, 11, 11, 100); poly.width(2.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); color = agg::rgba8(127, 127, 127); ellipse.init(ecenter, 260, ewidth, 15, 100); poly.width(2.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 260, 11, 11, 100); poly.width(2.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); color = agg::rgba8(192, 192, 192); ellipse.init(ecenter, 300, ewidth, 15, 100); poly.width(2.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 300, 11, 11, 100); poly.width(2.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); color = agg::rgba(0.0, 0.0, 0.4); ellipse.init(ecenter, 340, ewidth, 15.5, 100); poly.width(1.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 340, 10.5, 10.5, 100); poly.width(1.0); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 380, ewidth, 15.5, 100); poly.width(0.4); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 380, 10.5, 10.5, 100); poly.width(0.4); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 420, ewidth, 15.5, 100); poly.width(0.1); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); ellipse.init(ecenter, 420, 10.5, 10.5, 100); poly.width(0.1); ras.add_path(tpoly, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); agg::trans_affine mtx; mtx *= agg::trans_affine_skewing(0.15, 0.0); mtx *= trans_affine_resizing(); agg::gsv_text text; agg::gsv_text_outline<agg::trans_affine> text1(text, mtx); text.text("Text 2345"); text.size(50, 20); text1.width(2.0); text.start_point(320, 10); color = agg::rgba(0.0, 0.5, 0.0); ras.add_path(text1, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); color = agg::rgba(0.5, 0.0, 0.0); agg::path_storage path; path.move_to(30, -1.0); path.line_to(60, 0.0); path.line_to(30, 1.0); path.move_to(27, -1.0); path.line_to(10, 0.0); path.line_to(27, 1.0); agg::conv_transform<agg::path_storage> trans(path, mtx); for(int i = 0; i < 35; i++) { mtx.reset(); mtx *= agg::trans_affine_rotation(double(i) / 35.0 * agg::pi * 2.0); mtx *= agg::trans_affine_translation(400, 130); mtx *= trans_affine_resizing(); ras.add_path(trans, 0); agg::render_scanlines_aa_solid(ras, sl, rb, color); } }
virtual void on_draw() { typedef agg::pixfmt_bgr24 pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid; pixfmt pixf(rbuf_window()); renderer_base rb(pixf); renderer_solid rs(rb); rb.clear(agg::rgba(1, 1, 1)); agg::trans_affine mtx; agg::conv_transform<agg::path_storage, agg::trans_affine> trans(g_path, mtx); mtx *= agg::trans_affine_translation(-g_base_dx, -g_base_dy); mtx *= agg::trans_affine_scaling(g_scale, g_scale); mtx *= agg::trans_affine_rotation(g_angle + agg::pi); mtx *= agg::trans_affine_skewing(g_skew_x/1000.0, g_skew_y/1000.0); mtx *= agg::trans_affine_translation(initial_width()/4, initial_height()/2); mtx *= trans_affine_resizing(); agg::rasterizer_scanline_aa<> ras2; agg::scanline_p8 sl; agg::scanline_u8 sl2; agg::render_all_paths(ras2, sl, rs, trans, g_colors, g_path_idx, g_npaths); mtx *= ~trans_affine_resizing(); mtx *= agg::trans_affine_translation(initial_width()/2, 0); mtx *= trans_affine_resizing(); agg::line_profile_aa profile; profile.width(1.0); agg::renderer_outline_aa<renderer_base> rp(rb, profile); agg::rasterizer_outline_aa<agg::renderer_outline_aa<renderer_base> > ras(rp); ras.round_cap(true); ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths); agg::ellipse ell(m_cx, m_cy, 100.0, 100.0, 100); agg::conv_stroke<agg::ellipse> ell_stroke1(ell); ell_stroke1.width(6.0); agg::conv_stroke<agg::conv_stroke<agg::ellipse> > ell_stroke2(ell_stroke1); ell_stroke2.width(2.0); rs.color(agg::rgba(0,0.2,0)); ras2.add_path(ell_stroke2); agg::render_scanlines(ras2, sl, rs); typedef agg::span_simple_blur_rgb24<agg::order_bgr> span_blur_gen; typedef agg::span_allocator<span_blur_gen::color_type> span_blur_alloc; span_blur_alloc sa; span_blur_gen sg; sg.source_image(rbuf_img(0)); ras2.add_path(ell); copy_window_to_img(0); agg::render_scanlines_aa(ras2, sl2, rb, sa, sg); // More blur if desired :-) //copy_window_to_img(0); //agg::render_scanlines(ras2, sl2, rblur); //copy_window_to_img(0); //agg::render_scanlines(ras2, sl2, rblur); //copy_window_to_img(0); //agg::render_scanlines(ras2, sl2, rblur); }
virtual void on_draw() { pixfmt pixf(rbuf_window()); renderer_base rb(pixf); renderer_solid rs(rb); rb.clear(agg::rgba(1, 1, 1)); // When Gamma changes rebuild the gamma and gradient LUTs //------------------ if(m_old_gamma != m_gamma.value()) { m_gamma_lut.gamma(m_gamma.value()); build_gradient_lut(); m_old_gamma = m_gamma.value(); } // Gradient center. All gradient functions assume the // center being in the origin (0,0) and you can't // change it. But you can apply arbitrary transformations // to the gradient (see below). //------------------ double cx = initial_width() / 2; double cy = initial_height() / 2; double r = 100; // Focal center. Defined in the gradient coordinates, // that is, with respect to the origin (0,0) //------------------ double fx = m_mouse_x - cx; double fy = m_mouse_y - cy; gradient_func_type gradient_func(r, fx, fy); gradient_adaptor_type gradient_adaptor(gradient_func); agg::trans_affine gradient_mtx; // Making the affine matrix. Move to (cx,cy), // apply the resizing transformations and invert // the matrix. Gradients and images always assume the // inverse transformations. //------------------ gradient_mtx.translate(cx, cy); gradient_mtx *= trans_affine_resizing(); gradient_mtx.invert(); interpolator_type span_interpolator(gradient_mtx); span_gradient_type span_gradient(span_interpolator, gradient_adaptor, m_gradient_lut, 0, r); // Form the simple rectangle //------------------ m_rasterizer.reset(); m_rasterizer.move_to_d(0,0); m_rasterizer.line_to_d(width(), 0); m_rasterizer.line_to_d(width(), height()); m_rasterizer.line_to_d(0, height()); // Render the gradient to the whole screen and measure the time //------------------ start_timer(); agg::render_scanlines_aa(m_rasterizer, m_scanline, rb, m_alloc, span_gradient); double tm = elapsed_time(); // Draw the transformed circle that shows the gradient boundary //------------------ agg::ellipse e(cx, cy, r, r); agg::conv_stroke<agg::ellipse> estr(e); agg::conv_transform< agg::conv_stroke< agg::ellipse> > etrans(estr, trans_affine_resizing()); m_rasterizer.add_path(etrans); agg::render_scanlines_aa_solid(m_rasterizer, m_scanline, rb, agg::rgba(1,1,1)); // Show the gradient time //------------------ char buf[64]; agg::gsv_text t; t.size(10.0); agg::conv_stroke<agg::gsv_text> pt(t); pt.width(1.5); sprintf(buf, "%3.2f ms", tm); t.start_point(10.0, 35.0); t.text(buf); m_rasterizer.add_path(pt); agg::render_scanlines_aa_solid(m_rasterizer, m_scanline, rb, agg::rgba(0,0,0)); #if !LINEAR_RGB // Show the controls //------------------ agg::render_ctrl(m_rasterizer, m_scanline, rb, m_gamma); // Apply the inverse gamma to the whole buffer // (transform the colors to the perceptually uniform space) //------------------ pixf.apply_gamma_inv(m_gamma_lut); #endif }
virtual void on_draw() { typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_base<pixfmt_pre> renderer_base_pre; pixfmt pixf(rbuf_window()); pixfmt_pre pixf_pre(rbuf_window()); renderer_base rb(pixf); renderer_base_pre rb_pre(pixf_pre); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-initial_width()/2 - 10, -initial_height()/2 - 20 - 10); src_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); src_mtx *= agg::trans_affine_scaling(m_scale.value()); src_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2 + 20); src_mtx *= trans_affine_resizing(); agg::trans_affine img_mtx; img_mtx *= agg::trans_affine_translation(-initial_width()/2 + 10, -initial_height()/2 + 20 + 10); img_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); img_mtx *= agg::trans_affine_scaling(m_scale.value()); img_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2 + 20); img_mtx *= trans_affine_resizing(); img_mtx.invert(); agg::span_allocator<color_type> sa; typedef agg::span_interpolator_linear<> interpolator_type; interpolator_type interpolator(img_mtx); typedef agg::image_accessor_clip<pixfmt> img_source_type; pixfmt img_pixf(rbuf_img(0)); img_source_type img_src(img_pixf, agg::rgba_pre(0, 0.4, 0, 0.5)); /* // Version without filtering (nearest neighbor) //------------------------------------------ typedef agg::span_image_filter_rgb_nn<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator); //------------------------------------------ */ // Version with "hardcoded" bilinear filter and without // image_accessor (direct filter, the old variant) //------------------------------------------ typedef agg::span_image_filter_rgb_bilinear_clip<pixfmt, interpolator_type> span_gen_type; span_gen_type sg(img_pixf, agg::rgba_pre(0, 0.4, 0, 0.5), interpolator); //------------------------------------------ /* // Version with arbitrary 2x2 filter //------------------------------------------ typedef agg::span_image_filter_rgb_2x2<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_kaiser> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ /* // Version with arbitrary filter //------------------------------------------ typedef agg::span_image_filter_rgb<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_spline36> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ agg::rasterizer_scanline_aa<> ras; ras.clip_box(0, 0, width(), height()); agg::scanline_u8 sl; double r = initial_width(); if(initial_height() - 60 < r) r = initial_height() - 60; agg::ellipse ell(initial_width() / 2.0 + 10, initial_height() / 2.0 + 20 + 10, r / 2.0 + 16.0, r / 2.0 + 16.0, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); ras.add_path(tr); agg::render_scanlines_aa(ras, sl, rb_pre, sa, sg); agg::render_ctrl(ras, sl, rb, m_angle); agg::render_ctrl(ras, sl, rb, m_scale); }
virtual void on_draw() { typedef agg::pixfmt_bgr24 pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid; pixfmt pixf(rbuf_window()); renderer_base rb(pixf); renderer_solid rs(rb); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::rasterizer_scanline_aa<> ras; agg::scanline_p8 sl; double x_start = 125.0; double x_end = initial_width() - 15.0; double y_start = 10.0; double y_end = initial_height() - 10.0; double x_center = (x_start + x_end) / 2; unsigned i; agg::path_storage p; agg::conv_stroke<agg::path_storage> pl(p); agg::conv_transform<agg::conv_stroke<agg::path_storage> > tr(pl, trans_affine_resizing()); for(i = 0; i <= 16; i++) { double x = x_start + (x_end - x_start) * i / 16.0; p.remove_all(); p.move_to(x+0.5, y_start); p.line_to(x+0.5, y_end); ras.add_path(tr); rs.color(agg::rgba8(0, 0, 0, i == 8 ? 255 : 100)); agg::render_scanlines(ras, sl, rs); } double ys = y_start + (y_end - y_start) / 6.0; p.remove_all(); p.move_to(x_start, ys); p.line_to(x_end, ys); ras.add_path(tr); rs.color(agg::rgba8(0, 0, 0)); agg::render_scanlines(ras, sl, rs); pl.width(1.0); for(i = 0; i < m_num_filters; i++) { if(m_filters[i]->status()) { m_filter_func[i]->set_radius(m_radius.value()); unsigned j; double radius = m_filter_func[i]->radius(); unsigned n = unsigned(radius * 256 * 2); double dy = y_end - ys; double xs = (x_end + x_start)/2.0 - (radius * (x_end - x_start) / 16.0); double dx = (x_end - x_start) * radius / 8.0; p.remove_all(); p.move_to(xs+0.5, ys + dy * m_filter_func[i]->calc_weight(-radius)); for(j = 1; j < n; j++) { p.line_to(xs + dx * j / n + 0.5, ys + dy * m_filter_func[i]->calc_weight(j / 256.0 - radius)); } ras.add_path(tr); rs.color(agg::rgba8(100, 0, 0)); agg::render_scanlines(ras, sl, rs); p.remove_all(); unsigned xint; int ir = int(ceil(radius) + 0.1); for(xint = 0; xint < 256; xint++) { int xfract; double sum = 0; for(xfract = -ir; xfract < ir; xfract++) { double xf = xint/256.0 + xfract; if(xf >= -radius || xf <= radius) { sum += m_filter_func[i]->calc_weight(xf); } } double x = x_center + ((-128.0 + xint) / 128.0) * radius * (x_end - x_start) / 16.0; double y = ys + sum * 256 - 256; if(xint == 0) p.move_to(x, y); else p.line_to(x, y); } ras.add_path(tr); rs.color(agg::rgba8(0, 100, 0)); agg::render_scanlines(ras, sl, rs); agg::image_filter_lut normalized(*m_filter_func[i]); const agg::int16* weights = normalized.weight_array(); xs = (x_end + x_start)/2.0 - (normalized.diameter() * (x_end - x_start) / 32.0); unsigned nn = normalized.diameter() * 256; p.remove_all(); p.move_to(xs+0.5, ys + dy * weights[0] / agg::image_filter_scale); for(j = 1; j < nn; j++) { p.line_to(xs + dx * j / n + 0.5, ys + dy * weights[j] / agg::image_filter_scale); } ras.add_path(tr); rs.color(agg::rgba8(0, 0, 100, 255)); agg::render_scanlines(ras, sl, rs); } } for(i = 0; i < m_num_filters; i++) { agg::render_ctrl(ras, sl, rb, *m_filters[i]); } if(m_sinc.status() || m_lanczos.status() || m_blackman.status()) { agg::render_ctrl(ras, sl, rb, m_radius); } }
virtual void on_draw() { typedef agg::pixfmt_bgr24 pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; pixfmt pixf(rbuf_window()); renderer_base rb(pixf); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-initial_width()/2, -initial_height()/2); src_mtx *= agg::trans_affine_rotation(10.0 * agg::pi / 180.0); src_mtx *= agg::trans_affine_translation(initial_width()/2, initial_height()/2); src_mtx *= trans_affine_resizing(); agg::trans_affine img_mtx = src_mtx; img_mtx.invert(); typedef agg::span_allocator<agg::rgba8> span_alloc; unsigned i; unsigned char brightness_alpha_array[agg::span_conv_brightness_alpha_rgb8::array_size]; for(i = 0; i < agg::span_conv_brightness_alpha_rgb8::array_size; i++) { brightness_alpha_array[i] = agg::int8u(m_alpha.value(double(i) / double(agg::span_conv_brightness_alpha_rgb8::array_size)) * 255.0); } agg::span_conv_brightness_alpha_rgb8 color_alpha(brightness_alpha_array); typedef agg::image_accessor_clip<pixfmt> img_source_type; typedef agg::span_interpolator_linear<> interpolator_type; typedef agg::span_image_filter_rgb_bilinear<img_source_type, interpolator_type> span_gen; typedef agg::span_converter<span_gen, agg::span_conv_brightness_alpha_rgb8> span_conv; span_alloc sa; interpolator_type interpolator(img_mtx); pixfmt img_pixf(rbuf_img(0)); img_source_type img_src(img_pixf, agg::rgba(0,0,0,0)); span_gen sg(img_src, interpolator); span_conv sc(sg, color_alpha); agg::ellipse ell; agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; for(i = 0; i < 50; i++) { ell.init(m_x[i], m_y[i], m_rx[i], m_ry[i], 50); ras.add_path(ell); agg::render_scanlines_aa_solid(ras, sl, rb, m_colors[i]); } ell.init(initial_width() / 2.0, initial_height() / 2.0, initial_width() / 1.9, initial_height() / 1.9, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); ras.add_path(tr); agg::render_scanlines_aa(ras, sl, rb, sa, sc); agg::render_ctrl(ras, sl, rb, m_alpha); }
virtual void on_draw() { double img_width = rbuf_img(0).width(); double img_height = rbuf_img(0).height(); typedef agg::pixfmt_bgr24 pixfmt; typedef agg::renderer_base<pixfmt> renderer_base; pixfmt pixf(rbuf_window()); pixfmt img_pixf(rbuf_img(0)); renderer_base rb(pixf); rb.clear(agg::rgba(1.0, 1.0, 1.0)); agg::trans_affine src_mtx; src_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); src_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); src_mtx *= agg::trans_affine_translation(img_width/2 + 10, img_height/2 + 10 + 40); src_mtx *= trans_affine_resizing(); agg::trans_affine img_mtx; img_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); img_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); img_mtx *= agg::trans_affine_scaling(m_scale.value()); img_mtx *= agg::trans_affine_translation(img_width/2 + 10, img_height/2 + 10 + 40); img_mtx *= trans_affine_resizing(); img_mtx.invert(); typedef agg::span_allocator<agg::rgba8> span_alloc_type; span_alloc_type sa; typedef agg::span_interpolator_adaptor<agg::span_interpolator_linear<>, periodic_distortion> interpolator_type; periodic_distortion* dist = 0; distortion_wave dist_wave; distortion_swirl dist_swirl; distortion_wave_swirl dist_wave_swirl; distortion_swirl_wave dist_swirl_wave; switch(m_distortion.cur_item()) { case 0: dist = &dist_wave; break; case 1: dist = &dist_swirl; break; case 2: dist = &dist_wave_swirl; break; case 3: dist = &dist_swirl_wave; break; } dist->period(m_period.value()); dist->amplitude(m_amplitude.value()); dist->phase(m_phase); double cx = m_center_x; double cy = m_center_y; img_mtx.transform(&cx, &cy); dist->center(cx, cy); interpolator_type interpolator(img_mtx, *dist); typedef agg::image_accessor_clip<pixfmt> img_source_type; img_source_type img_src(img_pixf, agg::rgba(1,1,1)); /* // Version without filtering (nearest neighbor) //------------------------------------------ typedef agg::span_image_filter_rgb_nn<img_source_type, interpolator_type> span_gen_type; span_gen_type sg(img_src, interpolator); //------------------------------------------ */ // Version with "hardcoded" bilinear filter and without // image_accessor (direct filter, the old variant) //------------------------------------------ typedef agg::span_image_filter_rgb_bilinear_clip<pixfmt, interpolator_type> span_gen_type; span_gen_type sg(img_pixf, agg::rgba(1,1,1), interpolator); //------------------------------------------ /* // Version with arbitrary 2x2 filter //------------------------------------------ typedef agg::span_image_filter_rgb_2x2<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_kaiser> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ /* // Version with arbitrary filter //------------------------------------------ typedef agg::span_image_filter_rgb<img_source_type, interpolator_type> span_gen_type; agg::image_filter<agg::image_filter_spline36> filter; span_gen_type sg(img_src, interpolator, filter); //------------------------------------------ */ agg::rasterizer_scanline_aa<> ras; agg::scanline_u8 sl; double r = img_width; if(img_height < r) r = img_height; agg::ellipse ell(img_width / 2.0, img_height / 2.0, r / 2.0 - 20.0, r / 2.0 - 20.0, 200); agg::conv_transform<agg::ellipse> tr(ell, src_mtx); ras.add_path(tr); agg::render_scanlines_aa(ras, sl, rb, sa, sg); src_mtx *= ~trans_affine_resizing(); src_mtx *= agg::trans_affine_translation(img_width - img_width/10, 0.0); src_mtx *= trans_affine_resizing(); ras.add_path(tr); agg::render_scanlines_aa_solid(ras, sl, rb, agg::rgba8(0,0,0)); typedef agg::span_gradient<agg::rgba8, interpolator_type, agg::gradient_circle, color_array_type> gradient_span_gen; agg::gradient_circle gradient_function; color_array_type gradient_colors(m_gradient_colors); gradient_span_gen span_gradient(interpolator, gradient_function, gradient_colors, 0, 180); agg::trans_affine gr1_mtx; gr1_mtx *= agg::trans_affine_translation(-img_width/2, -img_height/2); gr1_mtx *= agg::trans_affine_scaling(0.8); gr1_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); gr1_mtx *= agg::trans_affine_translation(img_width - img_width/10 + img_width/2 + 10, img_height/2 + 10 + 40); gr1_mtx *= trans_affine_resizing(); agg::trans_affine gr2_mtx; gr2_mtx *= agg::trans_affine_rotation(m_angle.value() * agg::pi / 180.0); gr2_mtx *= agg::trans_affine_scaling(m_scale.value()); gr2_mtx *= agg::trans_affine_translation(img_width - img_width/10 + img_width/2 + 10 + 50, img_height/2 + 10 + 40 + 50); gr2_mtx *= trans_affine_resizing(); gr2_mtx.invert(); cx = m_center_x + img_width - img_width/10; cy = m_center_y; gr2_mtx.transform(&cx, &cy); dist->center(cx, cy); interpolator.transformer(gr2_mtx); agg::conv_transform<agg::ellipse> tr2(ell, gr1_mtx); ras.add_path(tr2); agg::render_scanlines_aa(ras, sl, rb, sa, span_gradient); agg::render_ctrl(ras, sl, rb, m_angle); agg::render_ctrl(ras, sl, rb, m_scale); agg::render_ctrl(ras, sl, rb, m_amplitude); agg::render_ctrl(ras, sl, rb, m_period); agg::render_ctrl(ras, sl, rb, m_distortion); }
//------------------------------------------------------------------------ int platform_support::run() { SDL_Event event; bool ev_flag = false; for(;;) { if(m_specific->m_update_flag) { on_draw(); update_window(); m_specific->m_update_flag = false; } ev_flag = false; if(m_wait_mode) { SDL_WaitEvent(&event); ev_flag = true; } else { if(SDL_PollEvent(&event)) { ev_flag = true; } else { on_idle(); } } if(ev_flag) { if(event.type == SDL_QUIT) { break; } int y; unsigned flags = 0; switch (event.type) { case SDL_VIDEORESIZE: if(!init(event.resize.w, event.resize.h, m_window_flags)) return false; on_resize(m_rbuf_window.width(), m_rbuf_window.height()); trans_affine_resizing(event.resize.w, event.resize.h); m_specific->m_update_flag = true; break; case SDL_KEYDOWN: { flags = 0; if(event.key.keysym.mod & KMOD_SHIFT) flags |= kbd_shift; if(event.key.keysym.mod & KMOD_CTRL) flags |= kbd_ctrl; bool left = false; bool up = false; bool right = false; bool down = false; switch(event.key.keysym.sym) { case key_left: left = true; break; case key_up: up = true; break; case key_right: right = true; break; case key_down: down = true; break; } if(m_ctrls.on_arrow_keys(left, right, down, up)) { on_ctrl_change(); force_redraw(); } else { on_key(m_specific->m_cur_x, m_specific->m_cur_y, event.key.keysym.sym, flags); } } break; case SDL_MOUSEMOTION: y = m_flip_y ? m_rbuf_window.height() - event.motion.y : event.motion.y; m_specific->m_cur_x = event.motion.x; m_specific->m_cur_y = y; flags = 0; if(event.motion.state & SDL_BUTTON(1)) flags |= mouse_left; if(event.motion.state & SDL_BUTTON(3)) flags |= mouse_right; if(m_ctrls.on_mouse_move(m_specific->m_cur_x, m_specific->m_cur_y, (flags & mouse_left) != 0)) { on_ctrl_change(); force_redraw(); } else { on_mouse_move(m_specific->m_cur_x, m_specific->m_cur_y, flags); } SDL_Event eventtrash; while (SDL_PeepEvents(&eventtrash, 1, SDL_GETEVENT, SDL_EVENTMASK(SDL_MOUSEMOTION))!=0){;} break; case SDL_MOUSEBUTTONDOWN: y = m_flip_y ? m_rbuf_window.height() - event.motion.y : event.motion.y; m_specific->m_cur_x = event.motion.x; m_specific->m_cur_y = y; flags = 0; if(event.button.button == SDL_BUTTON_LEFT) flags = mouse_left; if(event.button.button == SDL_BUTTON_RIGHT) flags = mouse_right; if(flags & mouse_left) { if(m_ctrls.on_mouse_button_down(m_specific->m_cur_x, m_specific->m_cur_y)) { m_ctrls.set_cur(m_specific->m_cur_x, m_specific->m_cur_y); on_ctrl_change(); force_redraw(); } else { if(m_ctrls.in_rect(m_specific->m_cur_x, m_specific->m_cur_y)) { if(m_ctrls.set_cur(m_specific->m_cur_x, m_specific->m_cur_y)) { on_ctrl_change(); force_redraw(); } } else { on_mouse_button_down(m_specific->m_cur_x, m_specific->m_cur_y, flags); } } } if(flags & mouse_right) { on_mouse_button_down(m_specific->m_cur_x, m_specific->m_cur_y, flags); } break; case SDL_MOUSEBUTTONUP: y = m_flip_y ? m_rbuf_window.height() - event.motion.y : event.motion.y; m_specific->m_cur_x = event.motion.x; m_specific->m_cur_y = y; flags = 0; if(m_ctrls.on_mouse_button_up(m_specific->m_cur_x, m_specific->m_cur_y)) { on_ctrl_change(); force_redraw(); } on_mouse_button_up(m_specific->m_cur_x, m_specific->m_cur_y, flags); break; } } } return 0; }
//------------------------------------------------------------------------ int platform_support::run() { SDL_Event event; bool ev_flag = false; for(;;) { if(m_specific->m_update_flag) { on_draw(); update_window(); m_specific->m_update_flag = false; } ev_flag = false; if(m_wait_mode) { SDL_WaitEvent(&event); ev_flag = true; } else { if(SDL_PollEvent(&event)) { ev_flag = true; } else { on_idle(); } } if(ev_flag) { if(event.type == SDL_QUIT) { break; } int y; unsigned flags = 0; switch (event.type) { int event_x; int event_y; case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_RESIZED: ERROR_PRINT("SDL_WINDOWEVENT_RESIZED %d,%d\n", event.window.data1, event.window.data2); #ifndef __ANDROID__ if(!init(event.window.data1, event.window.data2, m_window_flags)) return false; on_resize(m_rbuf_window.width(), m_rbuf_window.height()); trans_affine_resizing(event.window.data1, event.window.data2); #endif m_specific->m_update_flag = true; break; default: DEBUG_PRINT("unknown win event type %d\n", event.window.event); break; } break; case SDL_APP_DIDENTERFOREGROUND: DEBUG_PRINT("SDL_APP_DIDENTERFOREGROUND"); enter_foreground(); break; case SDL_APP_WILLENTERFOREGROUND: DEBUG_PRINT("SDL_APP_WILLENTERFOREGROUND"); break; case SDL_APP_DIDENTERBACKGROUND: DEBUG_PRINT("SDL_APP_DIDENTERBACKGROUND"); enter_background(); break; case SDL_APP_WILLENTERBACKGROUND: DEBUG_PRINT("SDL_APP_WILLENTERBACKGROUND"); break; case SDL_KEYDOWN: { flags = 0; if(event.key.keysym.mod & KMOD_SHIFT) flags |= kbd_shift; if(event.key.keysym.mod & KMOD_CTRL) flags |= kbd_ctrl; bool left = false; bool up = false; bool right = false; bool down = false; switch(event.key.keysym.sym) { case key_left: left = true; break; case key_up: up = true; break; case key_right: right = true; break; case key_down: down = true; break; } if(m_ctrls.on_arrow_keys(left, right, down, up)) { on_ctrl_change(); force_redraw(); } else { on_key(m_specific->m_cur_x, m_specific->m_cur_y, event.key.keysym.sym, flags); } } break; case SDL_MOUSEMOTION: event_x = (double)event.button.x*width_factor; event_y = (double)event.button.y*hight_factor; y = m_flip_y ? m_rbuf_window.height() - event_y : event_y; m_specific->m_cur_x = event_x; m_specific->m_cur_y = y; flags = 0; if(event.motion.state & SDL_BUTTON_LMASK) flags |= mouse_left; if(event.motion.state & SDL_BUTTON_RMASK) flags |= mouse_right; if(m_ctrls.on_mouse_move(m_specific->m_cur_x, m_specific->m_cur_y, (flags & mouse_left) != 0)) { on_ctrl_change(); force_redraw(); } else { on_mouse_move(m_specific->m_cur_x, m_specific->m_cur_y, flags); } SDL_Event eventtrash; while (SDL_PeepEvents(&eventtrash, 1, SDL_GETEVENT, SDL_MOUSEMOTION, SDL_MOUSEMOTION)!=0){;} break; case SDL_MOUSEBUTTONDOWN: event_x = (double)event.button.x*width_factor; event_y = (double)event.button.y*hight_factor; DEBUG_PRINT("mouse down: %d,%d %d,%d\n", event.button.x,event.button.y, event_x,event_y); y = m_flip_y ? m_rbuf_window.height() - event_y : event_y; m_specific->m_cur_x = event_x; m_specific->m_cur_y = y; flags = 0; DEBUG_PRINT("mouse down: %d,%d w %d,%d\n", event_x,y, m_rbuf_window.width(), m_rbuf_window.height()); switch(event.button.button) { case SDL_BUTTON_LEFT: { flags = mouse_left; if(m_ctrls.on_mouse_button_down(m_specific->m_cur_x, m_specific->m_cur_y)) { m_ctrls.set_cur(m_specific->m_cur_x, m_specific->m_cur_y); on_ctrl_change(); force_redraw(); } else { if(m_ctrls.in_rect(m_specific->m_cur_x, m_specific->m_cur_y)) { if(m_ctrls.set_cur(m_specific->m_cur_x, m_specific->m_cur_y)) { on_ctrl_change(); force_redraw(); } } else { on_mouse_button_down(m_specific->m_cur_x, m_specific->m_cur_y, flags); } } } break; case SDL_BUTTON_RIGHT: DEBUG_PRINT("SDL_BUTTON_RIGHT"); flags = mouse_right; on_mouse_button_down(m_specific->m_cur_x, m_specific->m_cur_y, flags); break; } //switch(event.button.button) break; case SDL_MOUSEBUTTONUP: event_x = (double)event.button.x*width_factor; event_y = (double)event.button.y*hight_factor; y = m_flip_y ? m_rbuf_window.height() - event_y : event_y; m_specific->m_cur_x = event_x; m_specific->m_cur_y = y; flags = 0; if(m_ctrls.on_mouse_button_up(m_specific->m_cur_x, m_specific->m_cur_y)) { on_ctrl_change(); force_redraw(); } on_mouse_button_up(m_specific->m_cur_x, m_specific->m_cur_y, flags); break; case SDL_MOUSEWHEEL: break; case SDL_FINGERDOWN: case SDL_FINGERUP: case SDL_FINGERMOTION: DEBUG_PRINT("Finger: x=%f, y=%f dx=%f, dy=%f, %d\n", event.tfinger.x, event.tfinger.y, event.tfinger.dx, event.tfinger.dy, (int)event.tfinger.fingerId); on_touch_event( event.tfinger.x, m_flip_y ? 1-event.tfinger.y: event.tfinger.y, event.tfinger.dx, event.tfinger.dy, (int)event.tfinger.fingerId, !(event.type == SDL_FINGERUP)); break; case SDL_MULTIGESTURE: DEBUG_PRINT("Multi Gesture: x = %f, y = %f, dAng = %f, dR = %f numDownTouch = %i\n", event.mgesture.x, event.mgesture.y, event.mgesture.dTheta, event.mgesture.dDist, event.mgesture.numFingers); on_multi_gesture( event.mgesture.x, event.mgesture.y, event.mgesture.dTheta, event.mgesture.dDist, event.mgesture.numFingers); break; default: DEBUG_PRINT("unknown event type %d\n", event.type); break; } } } return 0; }