bool THRawBitmap::_checkScaled(THRenderTarget* pCanvas, SDL_Rect& rcDest)
{
float fFactor;
if(!pCanvas->shouldScaleBitmaps(&fFactor))
return false;
int iScaledWidth = (int)((float)m_pBitmap->w * fFactor);
if(!m_pCachedScaledBitmap || m_pCachedScaledBitmap->w != iScaledWidth)
{
SDL_FreeSurface(m_pCachedScaledBitmap);
Uint32 iRMask, iGMask, iBMask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
iRMask = 0xff000000;
iGMask = 0x00ff0000;
iBMask = 0x0000ff00;
#else
iRMask = 0x000000ff;
iGMask = 0x0000ff00;
iBMask = 0x00ff0000;
#endif
m_pCachedScaledBitmap = SDL_CreateRGBSurface(SDL_SWSURFACE, iScaledWidth, (int)((float)m_pBitmap->h * fFactor), 24, iRMask, iGMask, iBMask, 0);
SDL_LockSurface(m_pCachedScaledBitmap);
SDL_LockSurface(m_pBitmap);
typedef agg::pixfmt_rgb24_pre pixfmt_pre_t;
typedef agg::renderer_base<pixfmt_pre_t> renbase_pre_t;
typedef image_accessor_clip_rgb24_pal8<pixfmt_pre_t> imgsrc_t;
typedef agg::span_interpolator_linear<> interpolator_t;
typedef agg::span_image_filter_rgb_2x2<imgsrc_t, interpolator_t> span_gen_type;
agg::scanline_p8 sl;
agg::span_allocator<pixfmt_pre_t::color_type> sa;
agg::image_filter<agg::image_filter_bilinear> filter;
agg::trans_affine_scaling img_mtx(1.0 / fFactor);
agg::rendering_buffer rbuf_src(m_pData, m_pBitmap->w, m_pBitmap->h, m_pBitmap->pitch);
imgsrc_t img_src(rbuf_src, *m_pPalette, agg::rgba(0.0, 0.0, 0.0));
interpolator_t interpolator(img_mtx);
span_gen_type sg(img_src, interpolator, filter);
agg::rendering_buffer rbuf(reinterpret_cast<unsigned char*>(m_pCachedScaledBitmap->pixels), m_pCachedScaledBitmap->w, m_pCachedScaledBitmap->h, m_pCachedScaledBitmap->pitch);
pixfmt_pre_t pixf_pre(rbuf);
renbase_pre_t rbase_pre(pixf_pre);
rasterizer_scanline_rect ras(0, 0, rbuf.width(), rbuf.height());
rbase_pre.clear(agg::rgba(1.0,0,0,0));
agg::render_scanlines_aa(ras, sl, rbase_pre, sa, sg);
SDL_UnlockSurface(m_pBitmap);
SDL_UnlockSurface(m_pCachedScaledBitmap);
}
rcDest.x = (Sint16)((float)rcDest.x * fFactor);
rcDest.y = (Sint16)((float)rcDest.y * fFactor);
return true;
}
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::renderer_base<agg::pixfmt_bgra32> ren_base;
typedef agg::renderer_base<agg::pixfmt_bgra32_pre> ren_base_pre;
agg::gamma_lut<agg::int8u, agg::int8u> lut(2.0);
agg::pixfmt_bgra32 pixf(rbuf_window());
ren_base renb(pixf);
agg::pixfmt_bgra32_pre pixf_pre(rbuf_window());
ren_base_pre renb_pre(pixf_pre);
// Clear the window with a gradient
agg::pod_vector<agg::rgba8> gr(pixf_pre.width());
unsigned i;
for(i = 0; i < pixf.width(); i++)
{
gr.add(agg::rgba8(255, 255, 0).gradient(agg::rgba8(0, 255, 255),
double(i) / pixf.width()));
}
for(i = 0; i < pixf.height(); i++)
{
renb.copy_color_hspan(0, i, pixf.width(), &gr[0]);
}
pixf.apply_gamma_dir(lut);
agg::rasterizer_scanline_aa<> ras;
agg::rasterizer_compound_aa<agg::rasterizer_sl_clip_dbl> rasc;
agg::scanline_u8 sl;
agg::span_allocator<agg::rgba8> alloc;
// Draw two triangles
ras.move_to_d(0, 0);
ras.line_to_d(width(), 0);
ras.line_to_d(width(), height());
agg::render_scanlines_aa_solid(ras, sl, renb,
agg::rgba8(lut.dir(0),
lut.dir(100),
lut.dir(0)));
ras.move_to_d(0, 0);
ras.line_to_d(0, height());
ras.line_to_d(width(), 0);
agg::render_scanlines_aa_solid(ras, sl, renb,
agg::rgba8(lut.dir(0),
lut.dir(100),
lut.dir(100)));
agg::trans_affine mtx;
mtx *= agg::trans_affine_scaling(4.0);
mtx *= agg::trans_affine_translation(150, 100);
agg::conv_transform<agg::path_storage> trans(m_path, mtx);
agg::conv_curve<agg::conv_transform<agg::path_storage> > curve(trans);
agg::conv_stroke
<agg::conv_curve
<agg::conv_transform
<agg::path_storage> > > stroke(curve);
compose_path();
agg::rgba8 styles[4];
if(m_invert_order.status())
{
rasc.layer_order(agg::layer_inverse);
}
else
{
rasc.layer_order(agg::layer_direct);
}
styles[3] = agg::rgba8(lut.dir(255),
lut.dir(0),
lut.dir(108),
200).premultiply();
styles[2] = agg::rgba8(lut.dir(51),
lut.dir(0),
lut.dir(151),
180).premultiply();
styles[1] = agg::rgba8(lut.dir(143),
lut.dir(90),
lut.dir(6),
200).premultiply();
styles[0] = agg::rgba8(lut.dir(0),
lut.dir(0),
lut.dir(255),
220).premultiply();
style_handler sh(styles, 4);
stroke.width(m_width.value());
rasc.reset();
rasc.master_alpha(3, m_alpha1.value());
rasc.master_alpha(2, m_alpha2.value());
rasc.master_alpha(1, m_alpha3.value());
rasc.master_alpha(0, m_alpha4.value());
agg::ellipse ell(220.0, 180.0, 120.0, 10.0, 128, false);
agg::conv_stroke<agg::ellipse> str_ell(ell);
str_ell.width(m_width.value() / 2);
rasc.styles(3, -1);
rasc.add_path(str_ell);
rasc.styles(2, -1);
rasc.add_path(ell);
rasc.styles(1, -1);
rasc.add_path(stroke);
rasc.styles(0, -1);
rasc.add_path(curve);
agg::render_scanlines_compound_layered(rasc, sl, renb_pre, alloc, sh);
agg::render_ctrl(ras, sl, renb, m_width);
agg::render_ctrl(ras, sl, renb, m_alpha1);
agg::render_ctrl(ras, sl, renb, m_alpha2);
agg::render_ctrl(ras, sl, renb, m_alpha3);
agg::render_ctrl(ras, sl, renb, m_alpha4);
agg::render_ctrl(ras, sl, renb, m_invert_order);
pixf.apply_gamma_inv(lut);
}
void reproject_and_scale_raster(raster & target, raster const& source,
proj_transform const& prj_trans,
double offset_x, double offset_y,
unsigned mesh_size,
double filter_radius,
scaling_method_e scaling_method)
{
CoordTransform ts(source.data_.width(), source.data_.height(),
source.ext_);
CoordTransform tt(target.data_.width(), target.data_.height(),
target.ext_, offset_x, offset_y);
unsigned i, j;
unsigned mesh_nx = ceil(source.data_.width()/double(mesh_size)+1);
unsigned mesh_ny = ceil(source.data_.height()/double(mesh_size)+1);
ImageData<double> xs(mesh_nx, mesh_ny);
ImageData<double> ys(mesh_nx, mesh_ny);
// Precalculate reprojected mesh
for(j=0; j<mesh_ny; j++) {
for (i=0; i<mesh_nx; i++) {
xs(i,j) = i*mesh_size;
ys(i,j) = j*mesh_size;
ts.backward(&xs(i,j), &ys(i,j));
}
}
prj_trans.backward(xs.getData(), ys.getData(), NULL, mesh_nx*mesh_ny);
// Initialize AGG objects
typedef agg::pixfmt_rgba32 pixfmt;
typedef pixfmt::color_type color_type;
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::pixfmt_rgba32_pre pixfmt_pre;
typedef agg::renderer_base<pixfmt_pre> renderer_base_pre;
agg::rasterizer_scanline_aa<> rasterizer;
agg::scanline_u8 scanline;
agg::rendering_buffer buf((unsigned char*)target.data_.getData(),
target.data_.width(),
target.data_.height(),
target.data_.width()*4);
pixfmt_pre pixf_pre(buf);
renderer_base_pre rb_pre(pixf_pre);
rasterizer.clip_box(0, 0, target.data_.width(), target.data_.height());
agg::rendering_buffer buf_tile(
(unsigned char*)source.data_.getData(),
source.data_.width(),
source.data_.height(),
source.data_.width() * 4);
pixfmt pixf_tile(buf_tile);
typedef agg::image_accessor_clone<pixfmt> img_accessor_type;
img_accessor_type ia(pixf_tile);
agg::span_allocator<color_type> sa;
// Initialize filter
agg::image_filter_lut filter;
switch(scaling_method)
{
case SCALING_NEAR: break;
case SCALING_BILINEAR8: // TODO - impl this or remove?
case SCALING_BILINEAR:
filter.calculate(agg::image_filter_bilinear(), true); break;
case SCALING_BICUBIC:
filter.calculate(agg::image_filter_bicubic(), true); break;
case SCALING_SPLINE16:
filter.calculate(agg::image_filter_spline16(), true); break;
case SCALING_SPLINE36:
filter.calculate(agg::image_filter_spline36(), true); break;
case SCALING_HANNING:
filter.calculate(agg::image_filter_hanning(), true); break;
case SCALING_HAMMING:
filter.calculate(agg::image_filter_hamming(), true); break;
case SCALING_HERMITE:
filter.calculate(agg::image_filter_hermite(), true); break;
case SCALING_KAISER:
filter.calculate(agg::image_filter_kaiser(), true); break;
case SCALING_QUADRIC:
filter.calculate(agg::image_filter_quadric(), true); break;
case SCALING_CATROM:
filter.calculate(agg::image_filter_catrom(), true); break;
case SCALING_GAUSSIAN:
filter.calculate(agg::image_filter_gaussian(), true); break;
case SCALING_BESSEL:
filter.calculate(agg::image_filter_bessel(), true); break;
case SCALING_MITCHELL:
filter.calculate(agg::image_filter_mitchell(), true); break;
case SCALING_SINC:
filter.calculate(agg::image_filter_sinc(filter_radius), true); break;
case SCALING_LANCZOS:
filter.calculate(agg::image_filter_lanczos(filter_radius), true); break;
case SCALING_BLACKMAN:
filter.calculate(agg::image_filter_blackman(filter_radius), true); break;
}
// Project mesh cells into target interpolating raster inside each one
for(j=0; j<mesh_ny-1; j++) {
for (i=0; i<mesh_nx-1; i++) {
double polygon[8] = {xs(i,j), ys(i,j),
xs(i+1,j), ys(i+1,j),
xs(i+1,j+1), ys(i+1,j+1),
xs(i,j+1), ys(i,j+1)};
tt.forward(polygon+0, polygon+1);
tt.forward(polygon+2, polygon+3);
tt.forward(polygon+4, polygon+5);
tt.forward(polygon+6, polygon+7);
rasterizer.reset();
rasterizer.move_to_d(polygon[0]-1, polygon[1]-1);
rasterizer.line_to_d(polygon[2]+1, polygon[3]-1);
rasterizer.line_to_d(polygon[4]+1, polygon[5]+1);
rasterizer.line_to_d(polygon[6]-1, polygon[7]+1);
unsigned x0 = i * mesh_size;
unsigned y0 = j * mesh_size;
unsigned x1 = (i+1) * mesh_size;
unsigned y1 = (j+1) * mesh_size;
agg::trans_affine tr(polygon, x0, y0, x1, y1);
if (tr.is_valid())
{
typedef agg::span_interpolator_linear<agg::trans_affine>
interpolator_type;
interpolator_type interpolator(tr);
if (scaling_method == SCALING_NEAR) {
typedef agg::span_image_filter_rgba_nn
<img_accessor_type, interpolator_type>
span_gen_type;
span_gen_type sg(ia, interpolator);
agg::render_scanlines_aa(rasterizer, scanline, rb_pre,
sa, sg);
} else {
typedef mapnik::span_image_resample_rgba_affine
<img_accessor_type> span_gen_type;
span_gen_type sg(ia, interpolator, filter);
agg::render_scanlines_aa(rasterizer, scanline, rb_pre,
sa, sg);
}
}
}
}
}
virtual void on_draw()
{
pixfmt pixf(rbuf_window());
pixfmt_pre pixf_pre(rbuf_window());
renderer_base rb(pixf);
renderer_base_pre rb_pre(pixf_pre);
if(!m_test_flag)
{
rb.clear(agg::rgba(1, 1, 1));
}
if(m_trans_type.cur_item() == 0)
{
// For the affine parallelogram transformations we
// calculate the 4-th (implicit) point of the parallelogram
m_quad.xn(3) = m_quad.xn(0) + (m_quad.xn(2) - m_quad.xn(1));
m_quad.yn(3) = m_quad.yn(0) + (m_quad.yn(2) - m_quad.yn(1));
}
if(!m_test_flag)
{
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.add_path(m_quad);
agg::render_scanlines_aa_solid(g_rasterizer, g_scanline, rb, agg::rgba(0, 0.3, 0.5, 0.6));
//--------------------------
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_trans_type);
}
// Prepare the polygon to rasterize. Here we need to fill
// the destination (transformed) polygon.
g_rasterizer.clip_box(0, 0, width(), height());
g_rasterizer.reset();
g_rasterizer.move_to_d(m_quad.xn(0), m_quad.yn(0));
g_rasterizer.line_to_d(m_quad.xn(1), m_quad.yn(1));
g_rasterizer.line_to_d(m_quad.xn(2), m_quad.yn(2));
g_rasterizer.line_to_d(m_quad.xn(3), m_quad.yn(3));
typedef agg::span_allocator<color_type> span_alloc_type;
span_alloc_type sa;
agg::image_filter<agg::image_filter_hanning> filter;
typedef agg::wrap_mode_reflect_auto_pow2 remainder_type;
typedef agg::image_accessor_wrap<pixfmt,
remainder_type,
remainder_type> img_source_type;
pixfmt img_pixf(rbuf_img(0));
img_source_type img_src(img_pixf);
enum subdiv_shift_e { subdiv_shift = 2 };
switch(m_trans_type.cur_item())
{
case 0:
{
// Note that we consruct an affine matrix that transforms
// a parallelogram to a rectangle, i.e., it's inverted.
// It's actually the same as:
// tr(g_x1, g_y1, g_x2, g_y2, m_triangle.polygon());
// tr.invert();
agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
// Also note that we can use the linear interpolator instead of
// arbitrary span_interpolator_trans. It works much faster,
// but the transformations must be linear and parellel.
typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
interpolator_type interpolator(tr);
typedef span_image_filter_2x2<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(img_src, interpolator, filter);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
break;
}
case 1:
{
agg::trans_bilinear tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
if(tr.is_valid())
{
typedef agg::span_interpolator_linear<agg::trans_bilinear> interpolator_type;
interpolator_type interpolator(tr);
typedef span_image_filter_2x2<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(img_src, interpolator, filter);
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, 8> interpolator_type;
interpolator_type interpolator(tr);
typedef span_image_filter_2x2<img_source_type,
interpolator_type> span_gen_type;
span_gen_type sg(img_src, interpolator, filter);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
}
break;
}
}
}
//------------------------------------------------------------------------
virtual void on_draw()
{
double width = rbuf_window().width();
double height = rbuf_window().height();
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 polygon_mtx;
polygon_mtx *= agg::trans_affine_translation(-m_polygon_cx, -m_polygon_cy);
polygon_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() * agg::pi / 180.0);
polygon_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
polygon_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
double r = initial_width() / 3.0 - 8.0;
create_star(m_polygon_cx, m_polygon_cy, r, r / 1.45, 14);
agg::conv_transform<agg::path_storage> tr(m_ps, polygon_mtx);
typedef agg::wrap_mode_reflect_auto_pow2 wrap_x_type;
typedef agg::wrap_mode_reflect_auto_pow2 wrap_y_type;
typedef agg::image_accessor_wrap<pixfmt,
wrap_x_type,
wrap_y_type> img_source_type;
typedef agg::span_pattern_rgba<img_source_type> span_gen_type;
unsigned offset_x = 0;
unsigned offset_y = 0;
if(m_tie_pattern.status())
{
offset_x = unsigned(width-m_polygon_cx);
offset_y = unsigned(height-m_polygon_cy);
}
agg::span_allocator<color_type> sa;
pixfmt img_pixf(m_pattern_rbuf);
img_source_type img_src(img_pixf);
span_gen_type sg(img_src, offset_x, offset_y);
// Alpha is meaningful for RGB only because RGBA has its own
sg.alpha(span_gen_type::value_type(m_pattern_alpha.value() * 255.0));
m_ras.add_path(tr);
agg::render_scanlines_aa(m_ras, m_sl, rb_pre, sa, sg);
agg::render_ctrl(m_ras, m_sl, rb, m_polygon_angle);
agg::render_ctrl(m_ras, m_sl, rb, m_polygon_scale);
agg::render_ctrl(m_ras, m_sl, rb, m_pattern_angle);
agg::render_ctrl(m_ras, m_sl, rb, m_pattern_size);
agg::render_ctrl(m_ras, m_sl, rb, m_pattern_alpha);
agg::render_ctrl(m_ras, m_sl, rb, m_rotate_polygon);
agg::render_ctrl(m_ras, m_sl, rb, m_rotate_pattern);
agg::render_ctrl(m_ras, m_sl, rb, m_tie_pattern);
}
void Display::impl::draw()
{
SDL_PumpEvents();
pixfmt pixf(rbwindow);
pixfmt pixf_pre(rbwindow);
base_renderer rb(pixf);
base_renderer rb_pre(pixf_pre);
solid_renderer rs(rb);
renderer_bin rbin(rb);
agg::scanline_u8 sl;
agg::rasterizer_scanline_aa<> pf;
if (fondo)
SDL_BlitSurface(fondo.get(), 0, window.get(), 0);
else
rb.clear(agg::rgba(0, 0, 0));
agg::glyph_rendering gren = agg::glyph_ren_agg_gray8;
if(m_feng.load_font("timesi.ttf", 0, gren)) {
m_feng.hinting(1);
m_feng.flip_y(1);
for (impl::it_tsprites it = textSprites.begin()
,end = textSprites.end()
;it!= end
;++it)
{
TextSprite::impl* tsimpl = *it;
if (tsimpl->visible) {
m_feng.height(tsimpl->size);
m_feng.width(tsimpl->size);
m_contour.width(-tsimpl->size * tsimpl->size * 0.05);
double x = tsimpl->x;
double y0 = tsimpl->y + tsimpl->size;
double y = y0;
for (std::string::iterator letra = tsimpl->caption.begin(), last = tsimpl->caption.end(); letra != last; ++letra) {
const agg::glyph_cache* glyph = m_fman.glyph(*letra);
if (glyph) {
m_fman.init_embedded_adaptors(glyph, x, y);
rs.color(agg::rgba8(0, 0, 0));
agg::render_scanlines(m_fman.gray8_adaptor(),
m_fman.gray8_scanline(),
rs);
x += glyph->advance_x;
y += glyph->advance_y;
}
}
}
}
}
for (impl::it_sprites it = sprites.begin()
,end = sprites.end()
;it!= end
;++it)
{
Sprite::impl* simpl = *it;
if (simpl->visible)
{
agg::rendering_buffer buffer((unsigned char*)simpl->surface->pixels,
simpl->surface->w, simpl->surface->h, simpl->surface->pitch);
interpolator_type interpolator;
span_alloc_type sa;
span_gen_type sg(sa, buffer, agg::rgba_pre(0, 0, 0, 0), interpolator);
renderer_type ri;
agg::rounded_rect rec(0, 0, buffer.width(), buffer.height(), 0);
agg::trans_affine src_mtx;
src_mtx *= agg::trans_affine_translation(simpl->x, simpl->y);
agg::trans_affine img_mtx = src_mtx;
img_mtx.invert();
interpolator.transformer(img_mtx);
ri.attach(rb_pre, sg);
agg::rounded_rect rrect(0, 0, buffer.width(), buffer.height(), 0);
agg::conv_transform<agg::rounded_rect> tr(rrect, src_mtx);
pf.add_path(tr);
agg::render_scanlines(pf, sl, ri);
}
}
SDL_BlitSurface(window.get(), 0, screen, 0);
SDL_Flip(screen);
}
void transform_image(double angle)
{
double width = rbuf_img(0).width();
double height = rbuf_img(0).height();
pixfmt pixf(rbuf_img(0));
pixfmt_pre pixf_pre(rbuf_img(0));
renderer_base rb(pixf);
renderer_base_pre rb_pre(pixf_pre);
rb.clear(agg::rgba(1.0, 1.0, 1.0));
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
agg::span_allocator<color_type> sa;
agg::trans_affine src_mtx;
src_mtx *= agg::trans_affine_translation(-width/2.0, -height/2.0);
src_mtx *= agg::trans_affine_rotation(angle * agg::pi / 180.0);
src_mtx *= agg::trans_affine_translation(width/2.0, height/2.0);
agg::trans_affine img_mtx = src_mtx;
img_mtx.invert();
double r = width;
if(height < r) r = height;
r *= 0.5;
r -= 4.0;
agg::ellipse ell(width / 2.0,
height / 2.0,
r, r, 200);
agg::conv_transform<agg::ellipse> tr(ell, src_mtx);
m_num_pix += r * r * agg::pi;
typedef agg::span_interpolator_linear<> interpolator_type;
interpolator_type interpolator(img_mtx);
agg::image_filter_lut filter;
bool norm = m_normalize.status();
switch(m_filters.cur_item())
{
case 0:
{
typedef agg::span_image_filter_nn<color_type,
#ifdef AGG_COMPONENT_ORDER
component_order,
#endif
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base_pre,
span_gen_type> renderer_type;
span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator);
renderer_type ri(rb_pre, sg);
ras.add_path(tr);
agg::render_scanlines(ras, sl, ri);
}
break;
case 1:
{
typedef agg::span_image_filter_bilinear<color_type,
#ifdef AGG_COMPONENT_ORDER
component_order,
#endif
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base_pre,
span_gen_type> renderer_type;
span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator);
renderer_type ri(rb_pre, sg);
ras.add_path(tr);
agg::render_scanlines(ras, sl, ri);
}
break;
case 5:
case 6:
case 7:
{
switch(m_filters.cur_item())
{
case 5: filter.calculate(agg::image_filter_hanning(), norm); break;
case 6: filter.calculate(agg::image_filter_hamming(), norm); break;
case 7: filter.calculate(agg::image_filter_hermite(), norm); break;
}
typedef agg::span_image_filter_2x2<color_type,
#ifdef AGG_COMPONENT_ORDER
component_order,
#endif
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base_pre,
span_gen_type> renderer_type;
span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator, filter);
renderer_type ri(rb_pre, sg);
ras.add_path(tr);
agg::render_scanlines(ras, sl, ri);
}
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(agg::image_filter_bicubic(), norm); break;
case 3: filter.calculate(agg::image_filter_spline16(), norm); break;
case 4: filter.calculate(agg::image_filter_spline36(), norm); break;
case 8: filter.calculate(agg::image_filter_kaiser(), norm); break;
case 9: filter.calculate(agg::image_filter_quadric(), norm); break;
case 10: filter.calculate(agg::image_filter_catrom(), norm); break;
case 11: filter.calculate(agg::image_filter_gaussian(), norm); break;
case 12: filter.calculate(agg::image_filter_bessel(), norm); break;
case 13: filter.calculate(agg::image_filter_mitchell(), norm); break;
case 14: filter.calculate(agg::image_filter_sinc(m_radius.value()), norm); break;
case 15: filter.calculate(agg::image_filter_lanczos(m_radius.value()), norm); break;
case 16: filter.calculate(agg::image_filter_blackman(m_radius.value()), norm); break;
}
typedef agg::span_image_filter<color_type,
#ifdef AGG_COMPONENT_ORDER
component_order,
#endif
interpolator_type> span_gen_type;
typedef agg::renderer_scanline_aa<renderer_base_pre,
span_gen_type> renderer_type;
span_gen_type sg(sa, rbuf_img(1), agg::rgba(0,0,0,0), interpolator, filter);
renderer_type ri(rb_pre, sg);
ras.add_path(tr);
agg::render_scanlines(ras, sl, ri);
}
break;
}
}
virtual void on_draw()
{
if(m_gamma.value() != m_old_gamma)
{
m_gamma_lut.gamma(m_gamma.value());
load_img(0, "spheres");
pixfmt pixf(rbuf_img(0));
pixf.apply_gamma_dir(m_gamma_lut);
m_old_gamma = m_gamma.value();
}
pixfmt pixf(rbuf_window());
pixfmt_pre pixf_pre(rbuf_window());
renderer_base rb(pixf);
renderer_base_pre rb_pre(pixf_pre);
renderer_solid r(rb);
rb.clear(agg::rgba(1, 1, 1));
if(m_trans_type.cur_item() < 2)
{
// For the affine parallelogram transformations we
// calculate the 4-th (implicit) point of the parallelogram
m_quad.xn(3) = m_quad.xn(0) + (m_quad.xn(2) - m_quad.xn(1));
m_quad.yn(3) = m_quad.yn(0) + (m_quad.yn(2) - m_quad.yn(1));
}
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.add_path(m_quad);
r.color(agg::rgba(0, 0.3, 0.5, 0.1));
agg::render_scanlines(g_rasterizer, g_scanline, r);
// Prepare the polygon to rasterize. Here we need to fill
// the destination (transformed) polygon.
g_rasterizer.clip_box(0, 0, width(), height());
g_rasterizer.reset();
int b = 0;
g_rasterizer.move_to_d(m_quad.xn(0)-b, m_quad.yn(0)-b);
g_rasterizer.line_to_d(m_quad.xn(1)+b, m_quad.yn(1)-b);
g_rasterizer.line_to_d(m_quad.xn(2)+b, m_quad.yn(2)+b);
g_rasterizer.line_to_d(m_quad.xn(3)-b, m_quad.yn(3)+b);
typedef agg::span_allocator<color_type> span_alloc_type;
span_alloc_type sa;
agg::image_filter_bilinear filter_kernel;
agg::image_filter_lut filter(filter_kernel, true);
pixfmt pixf_img(rbuf_img(0));
typedef agg::image_accessor_clone<pixfmt> source_type;
source_type source(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;
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;
}
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);
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, 70.0);
t.text(buf);
g_rasterizer.add_path(pt);
r.color(agg::rgba(0,0,0));
agg::render_scanlines(g_rasterizer, g_scanline, r);
//--------------------------
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_trans_type);
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_gamma);
agg::render_ctrl(g_rasterizer, g_scanline, rb, m_blur);
}