pixel_t operator()( const vector2_t& p, const vector2_t& du, const vector2_t& dv) const
{
RAMEN_ASSERT( has_top_sampler_);
int y = math::fast_float_floor( p.y);
if( y < src_area().min.y || y > src_area().max.y)
return pixel_t( 0, 0, 0, 0);
int x = math::fast_float_floor( p.x);
if( x < src_area().min.x || x > src_area().max.x)
return pixel_t( 0, 0, 0, 0);
float max_width = std::max( Imath::Math<float>::fabs( du.x), std::max( Imath::Math<float>::fabs( du.y),
std::max( Imath::Math<float>::fabs( dv.x), Imath::Math<float>::fabs( dv.y))));
float width = 2.0f * max_width;
float fract;
int level = find_level_and_fract( width, fract);
image::pixel_t result = sample_level( level, p);
if( fract != 0.0f)
{
RAMEN_ASSERT( level < num_levels() - 1);
image::pixel_t tmp = sample_level( level + 1, p);
result = lerp_pixels( tmp, result, fract);
}
return result;
}
corner_pin_node_t::matrix3_type corner_pin_node_t::do_calc_transform_matrix_at_frame( float frame, int subsample) const
{
Imath::Box2i src_area( input_as<image_node_t>()->format());
src_area.max.x++;
src_area.max.y++;
boost::array<Imath::V2d, 4> src_pts;
src_pts[0].x = src_area.min.x;
src_pts[0].y = src_area.min.y;
src_pts[1].x = src_area.max.x;
src_pts[1].y = src_area.min.y;
src_pts[2].x = src_area.max.x;
src_pts[2].y = src_area.max.y;
src_pts[3].x = src_area.min.x;
src_pts[3].y = src_area.max.y;
boost::array<Imath::V2d, 4> dst_pts;
get_corners_at_frame( dst_pts, frame, 1.0f / subsample);
if( quad_is_convex( dst_pts))
{
boost::optional<matrix3_type> m( quadToQuadMatrix( src_pts, dst_pts));
if( m)
return m.get();
}
return matrix3_type( 0, 0, 0,
0, 0, 0,
0, 0, 0);
}
void resize_catrom( const image::const_image_view_t& src, const Imath::Box2i& src_defined,
const image::image_view_t& dst, const Imath::Box2i& dst_area,
const Imath::V2i& center, const Imath::V2f& scale)
{
Imath::Box2i src_area( resize_box( dst_area, center, scale.x, scale.y));
Imath::Box2i tmp_area( calc_tmp_area<lanczos3_filter_t>( src_area, dst_area, scale.y));
image::buffer_t tmp( tmp_area, 4);
resize_catrom_( src, src_defined, src_area, tmp.rgba_view(), tmp_area, dst, dst_area, center, scale);
}
/**
* Copy tile area into clipboard.
*
* @param tile Northern tile of the area to copy.
* @param flags Command flags.
* @param p1 Various bits:
* \li bits 0..1 [2] - clipboard buffer index
* \li bits 2..31 [30] - [ unused ]
* @param p2 Various bits:
* \li bits 0..5 [6] - width of area to copy
* \li bits 6..11 [6] - height of area to copy
* \li bits 12..31 [20] - [ unused ]
* @param text Unused.
* @return The cost of this operation or an error.
*/
CommandCost CmdCopyToClipboard(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
/* clipboard is available only in a sigle player game and only to the local company */
if (_networking || !IsLocalCompany()) return CMD_ERROR;
/* extract and validate clipboard buffer index */
uint index = GB(p1, 0, 2);
if (index >= NUM_CLIPBOARD_BUFFERS || index == INSTANT_COPY_PASTE_BUFFER) return CMD_ERROR;
/* calculate and validate source area */
TileArea src_area(tile, GB(p2, 0, 6), GB(p2, 6, 6));
CommandCost ret = ValParamCopyPasteArea(src_area);
if (ret.Failed()) return ret;
/* copy to clipboard only when executing (DC_EXEC) */
if (flags & DC_EXEC) CopyToClipboard(GetClipboardBuffer(index), src_area);
/* return the cost */
return CommandCost(INVALID_EXPENSES, 0);
}
boost::optional<Imath::M33d> corner_pin_node_t::do_calc_transform_matrix_at_time( float time, int subsample) const
{
Imath::Box2i src_area( input()->domain());
boost::array<Imath::V2d, 4> src_pts;
src_pts[0].x = src_area.min.x;
src_pts[0].y = src_area.min.y;
src_pts[1].x = src_area.max.x;
src_pts[1].y = src_area.min.y;
src_pts[2].x = src_area.max.x;
src_pts[2].y = src_area.max.y;
src_pts[3].x = src_area.min.x;
src_pts[3].y = src_area.max.y;
boost::array<Imath::V2d, 4> dst_pts;
get_corners_at_time( dst_pts, time);
boost::optional<Imath::M33d> m;
if( quad_is_convex( dst_pts))
m = quadToQuadMatrix( src_pts, dst_pts);
return m;
}
void operator()(unsigned begin, unsigned end)
{
using color = agg::rgba8;
using order = agg::order_rgba;
using const_rendering_buffer = util::rendering_buffer<image_rgba8>;
using blender_type = agg::comp_op_adaptor_rgba_pre<color, order>;
using pixfmt_type = agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer>;
using renderer_type = agg::renderer_base<pixfmt_type>;
agg::rendering_buffer dst_buffer(
dst.bytes(),
safe_cast<unsigned>(dst.width()),
safe_cast<unsigned>(dst.height()),
safe_cast<int>(dst.row_size()));
const_rendering_buffer src_buffer(src);
pixfmt_type pixf(dst_buffer);
pixf.comp_op(static_cast<agg::comp_op_e>(mode));
agg::pixfmt_alpha_blend_rgba<agg::blender_rgba32_pre,
const_rendering_buffer,
agg::pixel32_type> pixf_mask(src_buffer);
renderer_type ren(pixf);
agg::rect_i src_area(0, begin, src.width() - 1, end - 1);
ren.blend_from(pixf_mask, &src_area, dx, dy, safe_cast<agg::cover_type>(255 * opacity));
}
