X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-core%2Ftrunk%2Fsrc%2Fsynfig%2Flayer_pastecanvas.cpp;h=b161412a5c796ee718917ed30b42bf1e7523bee3;hb=756c0d29ac1742f231e6615f9a577e574e35a4af;hp=19941621948d57e5c5a632b5c5ce59b9a7b2d110;hpb=90adfcbf050afec62c21522db0ff94fdd71e260f;p=synfig.git diff --git a/synfig-core/trunk/src/synfig/layer_pastecanvas.cpp b/synfig-core/trunk/src/synfig/layer_pastecanvas.cpp index 1994162..b161412 100644 --- a/synfig-core/trunk/src/synfig/layer_pastecanvas.cpp +++ b/synfig-core/trunk/src/synfig/layer_pastecanvas.cpp @@ -6,7 +6,7 @@ ** ** \legal ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley -** Copyright (c) 2007 Chris Moore +** Copyright (c) 2007, 2008 Chris Moore ** ** This package is free software; you can redistribute it and/or ** modify it under the terms of the GNU General Public License as @@ -85,7 +85,8 @@ Layer_PasteCanvas::Layer_PasteCanvas(): origin(0,0), depth(0), zoom(0), - time_offset(0) + time_offset(0), + extra_reference(false) { children_lock=false; muck_with_time_=true; @@ -103,6 +104,7 @@ Layer_PasteCanvas::~Layer_PasteCanvas() set_sub_canvas(0); //if(canvas && (canvas->is_inline() || !get_canvas() || get_canvas()->get_root()!=canvas->get_root())) + //if(extra_reference) // canvas->unref(); } @@ -186,7 +188,8 @@ Layer_PasteCanvas::set_sub_canvas(etl::handle x) if(canvas && muck_with_time_) remove_child(canvas.get()); - if(canvas && (canvas->is_inline() || !get_canvas() || get_canvas()->get_root()!=canvas->get_root())) + // if(canvas && (canvas->is_inline() || !get_canvas() || get_canvas()->get_root()!=canvas->get_root())) + if (extra_reference) canvas->unref(); child_changed_connection.disconnect(); @@ -202,13 +205,19 @@ Layer_PasteCanvas::set_sub_canvas(etl::handle x) ); */ if(canvas) - bounds=(canvas->get_context().get_full_bounding_rect()-canvas->rend_desc().get_focus())*exp(zoom)+origin+canvas->rend_desc().get_focus(); + bounds = ((canvas->get_context().get_full_bounding_rect() - canvas->rend_desc().get_focus()) * exp(zoom) + + origin + canvas->rend_desc().get_focus()); if(canvas && muck_with_time_) add_child(canvas.get()); if(canvas && (canvas->is_inline() || !get_canvas() || get_canvas()->get_root()!=canvas->get_root())) + { canvas->ref(); + extra_reference = true; + } + else + extra_reference = false; if(canvas) on_canvas_set(); @@ -333,11 +342,56 @@ Layer_PasteCanvas::accelerated_render(Context context,Surface *surface,int quali Color::BlendMethod blend_method(get_blend_method()); const Rect full_bounding_rect(canvas->get_context().get_full_bounding_rect()); - if(context->empty() || - !etl::intersect(context.get_full_bounding_rect(),full_bounding_rect+origin)) + bool blend_using_straight = false; // use 'straight' just for the central blit + + // sometimes the user changes the parameters while we're + // rendering, causing our pasted canvas' bounding box to shrink + // and no longer overlap with our tile. if that has happened, + // let's just stop now - we'll be refreshing soon anyway + //! \todo shouldn't a mutex ensure this isn't needed? + // http://synfig.org/images/d/d2/Bbox-change.sifz is an example + // that shows this happening - open the encapsulation, select the + // 'shade', and toggle the 'invert' parameter quickly. + // Occasionally you'll see: + // error: Context::accelerated_render(): Layer "shade" threw a bad_alloc exception! + // where the shade layer tries to allocate itself a canvas of + // negative proportions, due to changing bounding boxes. + if (!etl::intersect(desc.get_rect(), full_bounding_rect)) { + warning("%s:%d bounding box shrank while rendering?", __FILE__, __LINE__); + return true; + } + + // we have rendered what's under us, if necessary + if(context->empty()) + { + // if there's nothing under us, and we're blending 'onto', then we've finished if (Color::is_onto(blend_method)) return true; - if (blend_method==Color::BLEND_COMPOSITE) blend_method=Color::BLEND_STRAIGHT; + + // there's nothing under us, so using straight blending is + // faster than and equivalent to using composite, but we don't + // want to blank the surrounding areas + if (blend_method==Color::BLEND_COMPOSITE) blend_using_straight = true; + } + + if (!etl::intersect(context.get_full_bounding_rect(),full_bounding_rect+origin)) + { + // if there's no intersection between the context and our surface, and we're rendering 'onto', then we're done + if (Color::is_onto(blend_method)) return true; + + /* 'straight' is faster than 'composite' and has the same + * effect if the affected area of the lower layer is + * transparent; however, if we're not clipping the blit to + * just the bounding rectangle, the affected area is the whole + * tile, so we can't use this optimisation. if we are + * clipping, then we can use 'straight' to blit the clipped + * rectangle, but we shouldn't set blend_method to 'straight', + * or the surrounding areas will be blanked, which we don't + * want. + */ +#ifdef SYNFIG_CLIP_PASTECANVAS + if (blend_method==Color::BLEND_COMPOSITE) blend_using_straight = true; +#endif // SYNFIG_CLIP_PASTECANVAS } #ifdef SYNFIG_CLIP_PASTECANVAS @@ -354,6 +408,9 @@ Layer_PasteCanvas::accelerated_render(Context context,Surface *surface,int quali const int w( ceil_to_int((max[0] - desc.get_tl()[0]) / desc.get_pw()) - x); const int h( ceil_to_int((max[1] - desc.get_tl()[1]) / desc.get_ph()) - y); + const int tw = desc.get_w(); + const int th = desc.get_h(); + desc.set_subwindow(x,y,w,h); // \todo this used to also have "area.area()<=0.000001 || " - is it useful? @@ -363,6 +420,56 @@ Layer_PasteCanvas::accelerated_render(Context context,Surface *surface,int quali if(cb && !cb->amount_complete(10000,10000)) return false; return true; } + + // SYNFIG_CLIP_PASTECANVAS is defined, so we are only touching the + // pixels within the affected rectangle. If the blend method is + // 'straight', then we need to blend transparent pixels with the + // clipped areas of this tile, because with the 'straight' blend + // method, even transparent pixels have an effect on the layers below + if (Color::is_straight(blend_method)) + { + Surface clearsurface; + + Surface::alpha_pen apen(surface->begin()); + apen.set_alpha(get_amount()); + + // the area we're about to blit is transparent, so it doesn't + // matter whether we use 'straight' or 'straight onto' here + if (blend_method == Color::BLEND_ALPHA_BRIGHTEN) + apen.set_blend_method(blend_method); + else + apen.set_blend_method(Color::BLEND_STRAIGHT); + + /* This represents the area we're pasting into the tile, + * within the tile as a whole. Areas (A), (B), (C) and (D) + * need blending with the underlying context if they're not + * zero-sized: + * + * 0 x x+w tw + * 0 +------------------------+ + * | | + * | (A) | + * | | + * y | - - +----------+ - - - | + * | | | | + * | (C) | w by h | (D) | + * | | | | + * y+h | - - +----------+ - - - | + * | | + * | (B) | + * | | + * tw +------------------------+ + */ + + if (y > 0) // draw the full-width strip above the rectangle (A) + { apen.move_to(0,0); clearsurface.set_wh(tw,y); clearsurface.clear(); clearsurface.blit_to(apen); } + if (y+h < th) // draw the full-width strip below the rectangle (B) + { apen.move_to(0,y+h); clearsurface.set_wh(tw,th-(y+h)); clearsurface.clear(); clearsurface.blit_to(apen); } + if (x > 0) // draw the box directly left of the rectangle (C) + { apen.move_to(0,y); clearsurface.set_wh(x,h); clearsurface.clear(); clearsurface.blit_to(apen); } + if (x+w < tw) // draw the box directly right of the rectangle (D) + { apen.move_to(x+w,y); clearsurface.set_wh(tw-(x+w),h); clearsurface.clear(); clearsurface.blit_to(apen); } + } #endif // SYNFIG_CLIP_PASTECANVAS // render the canvas to be pasted onto pastesurface @@ -377,7 +484,7 @@ Layer_PasteCanvas::accelerated_render(Context context,Surface *surface,int quali #endif // SYNFIG_CLIP_PASTECANVAS apen.set_alpha(get_amount()); - apen.set_blend_method(blend_method); + apen.set_blend_method(blend_using_straight ? Color::BLEND_STRAIGHT : blend_method); pastesurface.blit_to(apen); if(cb && !cb->amount_complete(10000,10000)) return false;