| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2012, Google Inc. All rights reserved. | |
| 3 * | |
| 4 * Redistribution and use in source and binary forms, with or without | |
| 5 * modification, are permitted provided that the following conditions are | |
| 6 * met: | |
| 7 * | |
| 8 * * Redistributions of source code must retain the above copyright | |
| 9 * notice, this list of conditions and the following disclaimer. | |
| 10 * * Redistributions in binary form must reproduce the above | |
| 11 * copyright notice, this list of conditions and the following disclaimer | |
| 12 * in the documentation and/or other materials provided with the | |
| 13 * distribution. | |
| 14 * * Neither the name of Google Inc. nor the names of its | |
| 15 * contributors may be used to endorse or promote products derived from | |
| 16 * this software without specific prior written permission. | |
| 17 * | |
| 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 */ | |
| 30 | |
| 31 #include "config.h" | |
| 32 | |
| 33 #include "core/platform/graphics/skia/OpaqueRegionSkia.h" | |
| 34 | |
| 35 #include "core/platform/graphics/GraphicsContext.h" | |
| 36 | |
| 37 #include "SkColorFilter.h" | |
| 38 #include "SkShader.h" | |
| 39 | |
| 40 namespace WebCore { | |
| 41 | |
| 42 OpaqueRegionSkia::OpaqueRegionSkia() | |
| 43 : m_opaqueRect(SkRect::MakeEmpty()) | |
| 44 { | |
| 45 } | |
| 46 | |
| 47 IntRect OpaqueRegionSkia::asRect() const | |
| 48 { | |
| 49 // Returns the largest enclosed rect. | |
| 50 int left = SkScalarCeil(m_opaqueRect.fLeft); | |
| 51 int top = SkScalarCeil(m_opaqueRect.fTop); | |
| 52 int right = SkScalarFloor(m_opaqueRect.fRight); | |
| 53 int bottom = SkScalarFloor(m_opaqueRect.fBottom); | |
| 54 return IntRect(left, top, right-left, bottom-top); | |
| 55 } | |
| 56 | |
| 57 // Returns true if the xfermode will force the dst to be opaque, regardless of t
he current dst. | |
| 58 static inline bool xfermodeIsOpaque(const SkPaint& paint, bool srcIsOpaque) | |
| 59 { | |
| 60 if (!srcIsOpaque) | |
| 61 return false; | |
| 62 | |
| 63 SkXfermode* xfermode = paint.getXfermode(); | |
| 64 if (!xfermode) | |
| 65 return true; // default to kSrcOver_Mode | |
| 66 SkXfermode::Mode mode; | |
| 67 if (!xfermode->asMode(&mode)) | |
| 68 return false; | |
| 69 | |
| 70 switch (mode) { | |
| 71 case SkXfermode::kSrc_Mode: // source | |
| 72 case SkXfermode::kSrcOver_Mode: // source + dest - source*dest | |
| 73 case SkXfermode::kDstOver_Mode: // source + dest - source*dest | |
| 74 case SkXfermode::kDstATop_Mode: // source | |
| 75 case SkXfermode::kPlus_Mode: // source+dest | |
| 76 default: // the rest are all source + dest - source*dest | |
| 77 return true; | |
| 78 case SkXfermode::kClear_Mode: // 0 | |
| 79 case SkXfermode::kDst_Mode: // dest | |
| 80 case SkXfermode::kSrcIn_Mode: // source * dest | |
| 81 case SkXfermode::kDstIn_Mode: // dest * source | |
| 82 case SkXfermode::kSrcOut_Mode: // source * (1-dest) | |
| 83 case SkXfermode::kDstOut_Mode: // dest * (1-source) | |
| 84 case SkXfermode::kSrcATop_Mode: // dest | |
| 85 case SkXfermode::kXor_Mode: // source + dest - 2*(source*dest) | |
| 86 return false; | |
| 87 } | |
| 88 } | |
| 89 | |
| 90 // Returns true if the xfermode will keep the dst opaque, assuming the dst is al
ready opaque. | |
| 91 static inline bool xfermodePreservesOpaque(const SkPaint& paint, bool srcIsOpaqu
e) | |
| 92 { | |
| 93 SkXfermode* xfermode = paint.getXfermode(); | |
| 94 if (!xfermode) | |
| 95 return true; // default to kSrcOver_Mode | |
| 96 SkXfermode::Mode mode; | |
| 97 if (!xfermode->asMode(&mode)) | |
| 98 return false; | |
| 99 | |
| 100 switch (mode) { | |
| 101 case SkXfermode::kDst_Mode: // dest | |
| 102 case SkXfermode::kSrcOver_Mode: // source + dest - source*dest | |
| 103 case SkXfermode::kDstOver_Mode: // source + dest - source*dest | |
| 104 case SkXfermode::kSrcATop_Mode: // dest | |
| 105 case SkXfermode::kPlus_Mode: // source+dest | |
| 106 default: // the rest are all source + dest - source*dest | |
| 107 return true; | |
| 108 case SkXfermode::kClear_Mode: // 0 | |
| 109 case SkXfermode::kSrcOut_Mode: // source * (1-dest) | |
| 110 case SkXfermode::kDstOut_Mode: // dest * (1-source) | |
| 111 case SkXfermode::kXor_Mode: // source + dest - 2*(source*dest) | |
| 112 return false; | |
| 113 case SkXfermode::kSrc_Mode: // source | |
| 114 case SkXfermode::kSrcIn_Mode: // source * dest | |
| 115 case SkXfermode::kDstIn_Mode: // dest * source | |
| 116 case SkXfermode::kDstATop_Mode: // source | |
| 117 return srcIsOpaque; | |
| 118 } | |
| 119 } | |
| 120 | |
| 121 // Returns true if all pixels painted will be opaque. | |
| 122 static inline bool paintIsOpaque(const SkPaint& paint, OpaqueRegionSkia::DrawTyp
e drawType, const SkBitmap* bitmap) | |
| 123 { | |
| 124 if (paint.getAlpha() < 0xFF) | |
| 125 return false; | |
| 126 bool checkFillOnly = drawType != OpaqueRegionSkia::FillOrStroke; | |
| 127 if (!checkFillOnly && paint.getStyle() != SkPaint::kFill_Style && paint.isAn
tiAlias()) | |
| 128 return false; | |
| 129 SkShader* shader = paint.getShader(); | |
| 130 if (shader && !shader->isOpaque()) | |
| 131 return false; | |
| 132 if (bitmap && !bitmap->isOpaque()) | |
| 133 return false; | |
| 134 if (paint.getLooper()) | |
| 135 return false; | |
| 136 if (paint.getImageFilter()) | |
| 137 return false; | |
| 138 if (paint.getMaskFilter()) | |
| 139 return false; | |
| 140 SkColorFilter* colorFilter = paint.getColorFilter(); | |
| 141 if (colorFilter && !(colorFilter->getFlags() & SkColorFilter::kAlphaUnchange
d_Flag)) | |
| 142 return false; | |
| 143 return true; | |
| 144 } | |
| 145 | |
| 146 // Returns true if there is a rectangular clip, with the result in |deviceClipRe
ct|. | |
| 147 static inline bool getDeviceClipAsRect(const GraphicsContext* context, SkRect& d
eviceClipRect) | |
| 148 { | |
| 149 // Get the current clip in device coordinate space. | |
| 150 if (context->canvas()->getClipType() != SkCanvas::kRect_ClipType) | |
| 151 return false; | |
| 152 | |
| 153 SkIRect deviceClipIRect; | |
| 154 if (context->canvas()->getClipDeviceBounds(&deviceClipIRect)) | |
| 155 deviceClipRect.set(deviceClipIRect); | |
| 156 else | |
| 157 deviceClipRect.setEmpty(); | |
| 158 | |
| 159 return true; | |
| 160 } | |
| 161 | |
| 162 void OpaqueRegionSkia::pushCanvasLayer(const SkPaint* paint) | |
| 163 { | |
| 164 CanvasLayerState state; | |
| 165 if (paint) | |
| 166 state.paint = *paint; | |
| 167 m_canvasLayerStack.append(state); | |
| 168 } | |
| 169 | |
| 170 void OpaqueRegionSkia::popCanvasLayer(const GraphicsContext* context) | |
| 171 { | |
| 172 ASSERT(!m_canvasLayerStack.isEmpty()); | |
| 173 if (m_canvasLayerStack.isEmpty()) | |
| 174 return; | |
| 175 | |
| 176 const CanvasLayerState& canvasLayer = m_canvasLayerStack.last(); | |
| 177 SkRect layerOpaqueRect = canvasLayer.opaqueRect; | |
| 178 SkPaint layerPaint = canvasLayer.paint; | |
| 179 | |
| 180 // Apply the image mask. | |
| 181 if (canvasLayer.hasImageMask && !layerOpaqueRect.intersect(canvasLayer.image
OpaqueRect)) | |
| 182 layerOpaqueRect.setEmpty(); | |
| 183 | |
| 184 m_canvasLayerStack.removeLast(); | |
| 185 | |
| 186 applyOpaqueRegionFromLayer(context, layerOpaqueRect, layerPaint); | |
| 187 } | |
| 188 | |
| 189 void OpaqueRegionSkia::setImageMask(const SkRect& imageOpaqueRect) | |
| 190 { | |
| 191 ASSERT(!m_canvasLayerStack.isEmpty()); | |
| 192 m_canvasLayerStack.last().hasImageMask = true; | |
| 193 m_canvasLayerStack.last().imageOpaqueRect = imageOpaqueRect; | |
| 194 } | |
| 195 | |
| 196 void OpaqueRegionSkia::didDrawRect(const GraphicsContext* context, const SkRect&
fillRect, const SkPaint& paint, const SkBitmap* sourceBitmap) | |
| 197 { | |
| 198 // Any stroking may put alpha in pixels even if the filling part does not. | |
| 199 if (paint.getStyle() != SkPaint::kFill_Style) { | |
| 200 bool fillsBounds = false; | |
| 201 | |
| 202 if (!paint.canComputeFastBounds()) | |
| 203 didDrawUnbounded(context, paint, FillOrStroke); | |
| 204 else { | |
| 205 SkRect strokeRect; | |
| 206 strokeRect = paint.computeFastBounds(fillRect, &strokeRect); | |
| 207 didDraw(context, strokeRect, paint, sourceBitmap, fillsBounds, FillO
rStroke); | |
| 208 } | |
| 209 } | |
| 210 | |
| 211 bool fillsBounds = paint.getStyle() != SkPaint::kStroke_Style; | |
| 212 didDraw(context, fillRect, paint, sourceBitmap, fillsBounds, FillOnly); | |
| 213 } | |
| 214 | |
| 215 void OpaqueRegionSkia::didDrawPath(const GraphicsContext* context, const SkPath&
path, const SkPaint& paint) | |
| 216 { | |
| 217 SkRect rect; | |
| 218 if (path.isRect(&rect)) { | |
| 219 didDrawRect(context, rect, paint, 0); | |
| 220 return; | |
| 221 } | |
| 222 | |
| 223 bool fillsBounds = false; | |
| 224 | |
| 225 if (!paint.canComputeFastBounds()) | |
| 226 didDrawUnbounded(context, paint, FillOrStroke); | |
| 227 else { | |
| 228 rect = paint.computeFastBounds(path.getBounds(), &rect); | |
| 229 didDraw(context, rect, paint, 0, fillsBounds, FillOrStroke); | |
| 230 } | |
| 231 } | |
| 232 | |
| 233 void OpaqueRegionSkia::didDrawPoints(const GraphicsContext* context, SkCanvas::P
ointMode mode, int numPoints, const SkPoint points[], const SkPaint& paint) | |
| 234 { | |
| 235 if (!numPoints) | |
| 236 return; | |
| 237 | |
| 238 SkRect rect; | |
| 239 rect.fLeft = points[0].fX; | |
| 240 rect.fRight = points[0].fX + 1; | |
| 241 rect.fTop = points[0].fY; | |
| 242 rect.fBottom = points[0].fY + 1; | |
| 243 | |
| 244 for (int i = 1; i < numPoints; ++i) { | |
| 245 rect.fLeft = std::min(rect.fLeft, points[i].fX); | |
| 246 rect.fRight = std::max(rect.fRight, points[i].fX + 1); | |
| 247 rect.fTop = std::min(rect.fTop, points[i].fY); | |
| 248 rect.fBottom = std::max(rect.fBottom, points[i].fY + 1); | |
| 249 } | |
| 250 | |
| 251 bool fillsBounds = false; | |
| 252 | |
| 253 if (!paint.canComputeFastBounds()) | |
| 254 didDrawUnbounded(context, paint, FillOrStroke); | |
| 255 else { | |
| 256 rect = paint.computeFastBounds(rect, &rect); | |
| 257 didDraw(context, rect, paint, 0, fillsBounds, FillOrStroke); | |
| 258 } | |
| 259 } | |
| 260 | |
| 261 void OpaqueRegionSkia::didDrawBounded(const GraphicsContext* context, const SkRe
ct& bounds, const SkPaint& paint) | |
| 262 { | |
| 263 bool fillsBounds = false; | |
| 264 | |
| 265 if (!paint.canComputeFastBounds()) | |
| 266 didDrawUnbounded(context, paint, FillOrStroke); | |
| 267 else { | |
| 268 SkRect rect; | |
| 269 rect = paint.computeFastBounds(bounds, &rect); | |
| 270 didDraw(context, rect, paint, 0, fillsBounds, FillOrStroke); | |
| 271 } | |
| 272 } | |
| 273 | |
| 274 void OpaqueRegionSkia::didDraw(const GraphicsContext* context, const SkRect& rec
t, const SkPaint& paint, const SkBitmap* sourceBitmap, bool fillsBounds, DrawTyp
e drawType) | |
| 275 { | |
| 276 SkRect targetRect = rect; | |
| 277 | |
| 278 // Apply the transform to device coordinate space. | |
| 279 SkMatrix canvasTransform = context->canvas()->getTotalMatrix(); | |
| 280 if (!canvasTransform.mapRect(&targetRect)) | |
| 281 fillsBounds = false; | |
| 282 | |
| 283 // Apply the current clip. | |
| 284 SkRect deviceClipRect; | |
| 285 if (!getDeviceClipAsRect(context, deviceClipRect)) | |
| 286 fillsBounds = false; | |
| 287 else if (!targetRect.intersect(deviceClipRect)) | |
| 288 return; | |
| 289 | |
| 290 bool drawsOpaque = paintIsOpaque(paint, drawType, sourceBitmap); | |
| 291 bool xfersOpaque = xfermodeIsOpaque(paint, drawsOpaque); | |
| 292 bool preservesOpaque = xfermodePreservesOpaque(paint, drawsOpaque); | |
| 293 | |
| 294 if (fillsBounds && xfersOpaque) | |
| 295 markRectAsOpaque(targetRect); | |
| 296 else if (!preservesOpaque) | |
| 297 markRectAsNonOpaque(targetRect); | |
| 298 } | |
| 299 | |
| 300 void OpaqueRegionSkia::didDrawUnbounded(const GraphicsContext* context, const Sk
Paint& paint, DrawType drawType) | |
| 301 { | |
| 302 bool drawsOpaque = paintIsOpaque(paint, drawType, 0); | |
| 303 bool preservesOpaque = xfermodePreservesOpaque(paint, drawsOpaque); | |
| 304 | |
| 305 if (preservesOpaque) | |
| 306 return; | |
| 307 | |
| 308 SkRect deviceClipRect; | |
| 309 getDeviceClipAsRect(context, deviceClipRect); | |
| 310 markRectAsNonOpaque(deviceClipRect); | |
| 311 } | |
| 312 | |
| 313 void OpaqueRegionSkia::applyOpaqueRegionFromLayer(const GraphicsContext* context
, const SkRect& layerOpaqueRect, const SkPaint& paint) | |
| 314 { | |
| 315 SkRect deviceClipRect; | |
| 316 bool deviceClipIsARect = getDeviceClipAsRect(context, deviceClipRect); | |
| 317 | |
| 318 if (deviceClipRect.isEmpty()) | |
| 319 return; | |
| 320 | |
| 321 SkRect sourceOpaqueRect = layerOpaqueRect; | |
| 322 // Save the opaque area in the destination, so we can preserve the parts of
it under the source opaque area if possible. | |
| 323 SkRect destinationOpaqueRect = currentTrackingOpaqueRect(); | |
| 324 | |
| 325 bool outsideSourceOpaqueRectPreservesOpaque = xfermodePreservesOpaque(paint,
false); | |
| 326 if (!outsideSourceOpaqueRectPreservesOpaque) | |
| 327 markRectAsNonOpaque(deviceClipRect); | |
| 328 | |
| 329 if (!deviceClipIsARect) | |
| 330 return; | |
| 331 if (!sourceOpaqueRect.intersect(deviceClipRect)) | |
| 332 return; | |
| 333 | |
| 334 bool sourceOpaqueRectDrawsOpaque = paintIsOpaque(paint, FillOnly, 0); | |
| 335 bool sourceOpaqueRectXfersOpaque = xfermodeIsOpaque(paint, sourceOpaqueRectD
rawsOpaque); | |
| 336 bool sourceOpaqueRectPreservesOpaque = xfermodePreservesOpaque(paint, source
OpaqueRectDrawsOpaque); | |
| 337 | |
| 338 // If the layer's opaque area is being drawn opaque in the layer below, then
mark it opaque. Otherwise, | |
| 339 // if it preserves opaque then keep the intersection of the two. | |
| 340 if (sourceOpaqueRectXfersOpaque) | |
| 341 markRectAsOpaque(sourceOpaqueRect); | |
| 342 else if (sourceOpaqueRectPreservesOpaque && sourceOpaqueRect.intersect(desti
nationOpaqueRect)) | |
| 343 markRectAsOpaque(sourceOpaqueRect); | |
| 344 } | |
| 345 | |
| 346 void OpaqueRegionSkia::markRectAsOpaque(const SkRect& rect) | |
| 347 { | |
| 348 // We want to keep track of an opaque region but bound its complexity at a c
onstant size. | |
| 349 // We keep track of the largest rectangle seen by area. If we can add the ne
w rect to this | |
| 350 // rectangle then we do that, as that is the cheapest way to increase the ar
ea returned | |
| 351 // without increasing the complexity. | |
| 352 | |
| 353 SkRect& opaqueRect = currentTrackingOpaqueRect(); | |
| 354 | |
| 355 if (rect.isEmpty()) | |
| 356 return; | |
| 357 if (opaqueRect.contains(rect)) | |
| 358 return; | |
| 359 if (rect.contains(opaqueRect)) { | |
| 360 opaqueRect = rect; | |
| 361 return; | |
| 362 } | |
| 363 | |
| 364 if (rect.fTop <= opaqueRect.fTop && rect.fBottom >= opaqueRect.fBottom) { | |
| 365 if (rect.fLeft < opaqueRect.fLeft && rect.fRight >= opaqueRect.fLeft) | |
| 366 opaqueRect.fLeft = rect.fLeft; | |
| 367 if (rect.fRight > opaqueRect.fRight && rect.fLeft <= opaqueRect.fRight) | |
| 368 opaqueRect.fRight = rect.fRight; | |
| 369 } else if (rect.fLeft <= opaqueRect.fLeft && rect.fRight >= opaqueRect.fRigh
t) { | |
| 370 if (rect.fTop < opaqueRect.fTop && rect.fBottom >= opaqueRect.fTop) | |
| 371 opaqueRect.fTop = rect.fTop; | |
| 372 if (rect.fBottom > opaqueRect.fBottom && rect.fTop <= opaqueRect.fBottom
) | |
| 373 opaqueRect.fBottom = rect.fBottom; | |
| 374 } | |
| 375 | |
| 376 long opaqueArea = (long)opaqueRect.width() * (long)opaqueRect.height(); | |
| 377 long area = (long)rect.width() * (long)rect.height(); | |
| 378 if (area > opaqueArea) | |
| 379 opaqueRect = rect; | |
| 380 } | |
| 381 | |
| 382 void OpaqueRegionSkia::markRectAsNonOpaque(const SkRect& rect) | |
| 383 { | |
| 384 // We want to keep as much of the current opaque rectangle as we can, so fin
d the one largest | |
| 385 // rectangle inside m_opaqueRect that does not intersect with |rect|. | |
| 386 | |
| 387 SkRect& opaqueRect = currentTrackingOpaqueRect(); | |
| 388 | |
| 389 if (!SkRect::Intersects(rect, opaqueRect)) | |
| 390 return; | |
| 391 if (rect.contains(opaqueRect)) { | |
| 392 markAllAsNonOpaque(); | |
| 393 return; | |
| 394 } | |
| 395 | |
| 396 int deltaLeft = rect.fLeft - opaqueRect.fLeft; | |
| 397 int deltaRight = opaqueRect.fRight - rect.fRight; | |
| 398 int deltaTop = rect.fTop - opaqueRect.fTop; | |
| 399 int deltaBottom = opaqueRect.fBottom - rect.fBottom; | |
| 400 | |
| 401 // horizontal is the larger of the two rectangles to the left or to the righ
t of |rect| and inside opaqueRect. | |
| 402 // vertical is the larger of the two rectangles above or below |rect| and in
side opaqueRect. | |
| 403 SkRect horizontal = opaqueRect; | |
| 404 if (deltaTop > deltaBottom) | |
| 405 horizontal.fBottom = rect.fTop; | |
| 406 else | |
| 407 horizontal.fTop = rect.fBottom; | |
| 408 SkRect vertical = opaqueRect; | |
| 409 if (deltaLeft > deltaRight) | |
| 410 vertical.fRight = rect.fLeft; | |
| 411 else | |
| 412 vertical.fLeft = rect.fRight; | |
| 413 | |
| 414 if ((long)horizontal.width() * (long)horizontal.height() > (long)vertical.wi
dth() * (long)vertical.height()) | |
| 415 opaqueRect = horizontal; | |
| 416 else | |
| 417 opaqueRect = vertical; | |
| 418 } | |
| 419 | |
| 420 void OpaqueRegionSkia::markAllAsNonOpaque() | |
| 421 { | |
| 422 SkRect& opaqueRect = currentTrackingOpaqueRect(); | |
| 423 opaqueRect.setEmpty(); | |
| 424 } | |
| 425 | |
| 426 SkRect& OpaqueRegionSkia::currentTrackingOpaqueRect() | |
| 427 { | |
| 428 // If we are drawing into a canvas layer, then track the opaque rect in that
layer. | |
| 429 return m_canvasLayerStack.isEmpty() ? m_opaqueRect : m_canvasLayerStack.last
().opaqueRect; | |
| 430 } | |
| 431 | |
| 432 } // namespace WebCore | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 99103006:
Moving GraphicsContext and dependencies from core to platform. (Closed)
Base URL: svn://svn.chromium.org/blink/trunk