SkBitmap CCRenderSurfaceFilters::apply(const WebKit::WebFilterOperations& filters, unsigned textureId, const FloatSize& size, WebKit::WebGraphicsContext3D* context3D, GrContext* grContext) { if (!context3D || !grContext) return SkBitmap(); WebKit::WebFilterOperations optimizedFilters = optimize(filters); FilterBufferState state(grContext, size, textureId); if (!state.init(optimizedFilters.size())) return SkBitmap(); for (unsigned i = 0; i < optimizedFilters.size(); ++i) { const WebKit::WebFilterOperation& op = optimizedFilters.at(i); SkCanvas* canvas = state.canvas(); switch (op.type()) { case WebKit::WebFilterOperation::FilterTypeColorMatrix: { SkPaint paint; paint.setColorFilter(new SkColorMatrixFilter(op.matrix()))->unref(); canvas->drawBitmap(state.source(), 0, 0, &paint); break; } case WebKit::WebFilterOperation::FilterTypeBlur: { float stdDeviation = op.amount(); SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(stdDeviation, stdDeviation)); SkPaint paint; paint.setImageFilter(filter.get()); canvas->drawSprite(state.source(), 0, 0, &paint); break; } case WebKit::WebFilterOperation::FilterTypeDropShadow: { SkAutoTUnref<SkImageFilter> blurFilter(new SkBlurImageFilter(op.amount(), op.amount())); SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(op.dropShadowColor(), SkXfermode::kSrcIn_Mode)); SkPaint paint; paint.setImageFilter(blurFilter.get()); paint.setColorFilter(colorFilter.get()); paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); canvas->saveLayer(0, &paint); canvas->drawBitmap(state.source(), op.dropShadowOffset().x, -op.dropShadowOffset().y); canvas->restore(); canvas->drawBitmap(state.source(), 0, 0); break; } case WebKit::WebFilterOperation::FilterTypeBrightness: case WebKit::WebFilterOperation::FilterTypeContrast: case WebKit::WebFilterOperation::FilterTypeGrayscale: case WebKit::WebFilterOperation::FilterTypeSepia: case WebKit::WebFilterOperation::FilterTypeSaturate: case WebKit::WebFilterOperation::FilterTypeHueRotate: case WebKit::WebFilterOperation::FilterTypeInvert: case WebKit::WebFilterOperation::FilterTypeOpacity: ASSERT_NOT_REACHED(); break; } state.swap(); } context3D->flush(); return state.source(); }
SkPaint SkColorSpaceXformer::apply(const SkPaint& src) { const AutoCachePurge autoPurge(this); SkPaint dst = src; // All SkColorSpaces have the same black point. if (src.getColor() & 0xffffff) { dst.setColor(this->apply(src.getColor())); } if (auto shader = src.getShader()) { dst.setShader(this->apply(shader)); } if (auto cf = src.getColorFilter()) { dst.setColorFilter(this->apply(cf)); } if (auto looper = src.getDrawLooper()) { dst.setDrawLooper(looper->makeColorSpace(this)); } if (auto imageFilter = src.getImageFilter()) { dst.setImageFilter(this->apply(imageFilter)); } return dst; }
void onDraw(SkCanvas* canvas) override { SkLayerDrawLooper::Builder looperBuilder; { SkLayerDrawLooper::LayerInfo info; info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit | SkLayerDrawLooper::kColorFilter_Bit; info.fColorMode = SkXfermode::kSrc_Mode; info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0)); info.fPostTranslate = false; SkPaint* paint = looperBuilder.addLayerOnTop(info); SkMaskFilter* maskFilter = SkBlurMaskFilter::Create( kNormal_SkBlurStyle, SkBlurMask::ConvertRadiusToSigma(SK_ScalarHalf), SkBlurMaskFilter::kHighQuality_BlurFlag); paint->setMaskFilter(maskFilter)->unref(); SkColorFilter* colorFilter = SkColorFilter::CreateModeFilter( sk_tool_utils::color_to_565(SK_ColorLTGRAY), SkXfermode::kSrcIn_Mode); paint->setColorFilter(colorFilter)->unref(); paint->setColor(sk_tool_utils::color_to_565(SK_ColorGRAY)); } { SkLayerDrawLooper::LayerInfo info; looperBuilder.addLayerOnTop(info); } SkPaint paint; canvas->drawRect(fRRect.rect(), paint); paint.setLooper(looperBuilder.detachLooper())->unref(); paint.setColor(SK_ColorCYAN); paint.setAntiAlias(true); canvas->drawRRect(fRRect, paint); }
void onDraw(int loops, SkCanvas* canvas) override { SkLayerDrawLooper::Builder looperBuilder; { SkLayerDrawLooper::LayerInfo info; info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit | SkLayerDrawLooper::kColorFilter_Bit; info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc; info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0)); info.fPostTranslate = false; SkPaint* paint = looperBuilder.addLayerOnTop(info); paint->setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, SkBlurMask::ConvertRadiusToSigma(0.5), SkBlurMaskFilter::kHighQuality_BlurFlag)); paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorLTGRAY, SkBlendMode::kSrcIn)); paint->setColor(SK_ColorGRAY); } { SkLayerDrawLooper::LayerInfo info; looperBuilder.addLayerOnTop(info); } SkPaint dullPaint; dullPaint.setAntiAlias(true); SkPaint loopedPaint; loopedPaint.setLooper(looperBuilder.detach()); loopedPaint.setAntiAlias(true); loopedPaint.setColor(SK_ColorCYAN); for (int i = 0; i < loops; i++) { canvas->drawRect(fRRect.rect(), dullPaint); canvas->drawRRect(fRRect, loopedPaint); } }
bool SkColorFilterImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source, const Context& ctx, SkBitmap* result, SkIPoint* offset) const { SkBitmap src = source; SkIPoint srcOffset = SkIPoint::Make(0, 0); if (getInput(0) && !getInput(0)->filterImage(proxy, source, ctx, &src, &srcOffset)) { return false; } SkIRect bounds; if (!this->applyCropRect(ctx, src, srcOffset, &bounds)) { return false; } SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height())); if (NULL == device.get()) { return false; } SkCanvas canvas(device.get()); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrc_Mode); paint.setColorFilter(fColorFilter); canvas.drawSprite(src, srcOffset.fX - bounds.fLeft, srcOffset.fY - bounds.fTop, &paint); *result = device.get()->accessBitmap(false); offset->fX = bounds.fLeft; offset->fY = bounds.fTop; return true; }
void FEColorMatrix::applySoftware() { ImageBuffer* resultImage = createImageBufferResult(); if (!resultImage) return; FilterEffect* in = inputEffect(0); IntRect drawingRegion = drawingRegionOfInputImage(in->absolutePaintRect()); SkAutoTUnref<SkColorFilter> filter(createColorFilter(m_type, m_values.data())); RefPtr<Image> image = in->asImageBuffer()->copyImage(DontCopyBackingStore); RefPtr<NativeImageSkia> nativeImage = image->nativeImageForCurrentFrame(); if (!nativeImage) return; SkPaint paint; paint.setColorFilter(filter); paint.setXfermodeMode(SkXfermode::kSrc_Mode); resultImage->context()->drawBitmap(nativeImage->bitmap(), drawingRegion.x(), drawingRegion.y(), &paint); if (affectsTransparentPixels()) { IntRect fullRect = IntRect(IntPoint(), absolutePaintRect().size()); resultImage->context()->clipOut(drawingRegion); resultImage->context()->fillRect(fullRect, Color(m_values[4], m_values[9], m_values[14], m_values[19])); } return; }
bool SkColorFilterImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitmap& source, const Context& ctx, SkBitmap* result, SkIPoint* offset) const { SkBitmap src = source; SkIPoint srcOffset = SkIPoint::Make(0, 0); if (!this->filterInputDeprecated(0, proxy, source, ctx, &src, &srcOffset)) { return false; } SkIRect bounds; SkIRect srcBounds = src.bounds(); srcBounds.offset(srcOffset); if (!this->applyCropRect(ctx, srcBounds, &bounds)) { return false; } SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height())); if (nullptr == device.get()) { return false; } SkCanvas canvas(device.get()); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrc_Mode); paint.setColorFilter(fColorFilter); canvas.drawBitmap(src, SkIntToScalar(srcOffset.fX - bounds.fLeft), SkIntToScalar(srcOffset.fY - bounds.fTop), &paint); *result = device.get()->accessBitmap(false); offset->fX = bounds.fLeft; offset->fY = bounds.fTop; return true; }
void OsmAnd::MapRasterizer_P::rasterizePolylineShadow( const Context& context, SkCanvas& canvas, const SkPath& path, SkPaint& paint, const ColorARGB shadowColor, const float shadowRadius) { if (context.shadowMode == MapPresentationEnvironment::ShadowMode::BlurShadow && shadowRadius > 0.0f) { // simply draw shadow? difference from option 3 ? paint.setLooper(SkBlurDrawLooper::Create( shadowColor.toSkColor(), SkBlurMaskFilter::ConvertRadiusToSigma(shadowRadius), 0, 0))->unref(); canvas.drawPath(path, paint); } else if (context.shadowMode == MapPresentationEnvironment::ShadowMode::SolidShadow && shadowRadius > 0.0f) { paint.setLooper(nullptr); paint.setStrokeWidth(paint.getStrokeWidth() + shadowRadius * 2); paint.setColorFilter(SkColorFilter::CreateModeFilter( shadowColor.toSkColor(), SkXfermode::kSrcIn_Mode))->unref(); canvas.drawPath(path, paint); } }
bool SkColorFilterImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source, const SkMatrix& matrix, SkBitmap* result, SkIPoint* loc) { SkBitmap src = source; if (getInput(0) && !getInput(0)->filterImage(proxy, source, matrix, &src, loc)) { return false; } SkIRect bounds; src.getBounds(&bounds); if (!this->applyCropRect(&bounds, matrix)) { return false; } SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height())); if (NULL == device.get()) { return false; } SkCanvas canvas(device.get()); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrc_Mode); paint.setColorFilter(fColorFilter); canvas.drawSprite(src, -bounds.fLeft, -bounds.fTop, &paint); *result = device.get()->accessBitmap(false); loc->fX += bounds.fLeft; loc->fY += bounds.fTop; return true; }
void FEComponentTransfer::applySoftware() { FilterEffect* in = inputEffect(0); ImageBuffer* resultImage = createImageBufferResult(); if (!resultImage) return; RefPtr<Image> image = in->asImageBuffer()->copyImage(DontCopyBackingStore); RefPtr<NativeImageSkia> nativeImage = image->nativeImageForCurrentFrame(); if (!nativeImage) return; unsigned char rValues[256], gValues[256], bValues[256], aValues[256]; getValues(rValues, gValues, bValues, aValues); IntRect destRect = drawingRegionOfInputImage(in->absolutePaintRect()); SkPaint paint; paint.setColorFilter(SkTableColorFilter::CreateARGB(aValues, rValues, gValues, bValues))->unref(); paint.setXfermodeMode(SkXfermode::kSrc_Mode); resultImage->context()->drawBitmap(nativeImage->bitmap(), destRect.x(), destRect.y(), &paint); if (affectsTransparentPixels()) { IntRect fullRect = IntRect(IntPoint(), absolutePaintRect().size()); resultImage->context()->clipOut(destRect); resultImage->context()->fillRect(fullRect, Color(rValues[0], gValues[0], bValues[0], aValues[0])); } }
DEF_SIMPLE_GM_BG(overdraw_canvas, canvas, WIDTH, HEIGHT, SK_ColorWHITE) { // Set up the overdraw canvas. SkImageInfo offscreenInfo = SkImageInfo::MakeA8(WIDTH, HEIGHT); sk_sp<SkSurface> offscreen = SkSurface::MakeRaster(offscreenInfo); auto c = offscreen->getCanvas(); SkOverdrawCanvas overdrawCanvas(c); overdrawCanvas.drawRect(SkRect::MakeLTRB(10, 10, 200, 200), SkPaint()); overdrawCanvas.drawRect(SkRect::MakeLTRB(20, 20, 190, 190), SkPaint()); overdrawCanvas.drawRect(SkRect::MakeLTRB(30, 30, 180, 180), SkPaint()); overdrawCanvas.drawRect(SkRect::MakeLTRB(40, 40, 170, 170), SkPaint()); overdrawCanvas.drawRect(SkRect::MakeLTRB(50, 50, 160, 160), SkPaint()); overdrawCanvas.drawRect(SkRect::MakeLTRB(60, 60, 150, 150), SkPaint()); char text[] = "Ae_p"; overdrawCanvas.drawSimpleText(text, 4, SkTextEncoding::kUTF8, 300, 300, SkFont(), SkPaint()); sk_sp<SkImage> counts = offscreen->makeImageSnapshot(); // Draw overdraw colors to the canvas. The color filter will convert counts to colors. SkPaint paint; paint.setColorFilter(SkOverdrawColorFilter::Make(kOverdrawColors)); canvas->drawImage(counts.get(), 0.0f, 0.0f, &paint); canvas->drawString("This is some text:", 180, 300, SkFont(), SkPaint()); }
void FEDropShadow::applySoftware() { FilterEffect* in = inputEffect(0); ImageBuffer* resultImage = createImageBufferResult(); if (!resultImage) return; Filter* filter = this->filter(); FloatSize blurRadius(filter->applyHorizontalScale(m_stdX), filter->applyVerticalScale(m_stdY)); FloatSize offset(filter->applyHorizontalScale(m_dx), filter->applyVerticalScale(m_dy)); FloatRect drawingRegion = drawingRegionOfInputImage(in->absolutePaintRect()); GraphicsContext* resultContext = resultImage->context(); ASSERT(resultContext); Color color = adaptColorToOperatingColorSpace(m_shadowColor.combineWithAlpha(m_shadowOpacity)); SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(blurRadius.width(), blurRadius.height())); SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(color.rgb(), SkXfermode::kSrcIn_Mode)); SkPaint paint; paint.setImageFilter(blurFilter.get()); paint.setColorFilter(colorFilter.get()); paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); RefPtr<Image> image = in->asImageBuffer()->copyImage(DontCopyBackingStore); RefPtr<NativeImageSkia> nativeImage = image->nativeImageForCurrentFrame(); if (!nativeImage) return; resultContext->drawBitmap(nativeImage->bitmap(), drawingRegion.x() + offset.width(), drawingRegion.y() + offset.height(), &paint); resultContext->drawBitmap(nativeImage->bitmap(), drawingRegion.x(), drawingRegion.y()); }
void test(int loops, SkCanvas* canvas) { SkPaint paint; for (int i = 0; i < loops; i++) { SkAutoTUnref<SkColorFilter> colorCube( SkColorCubeFilter::Create(fCubeData, fCubeDimension)); paint.setColorFilter(colorCube); canvas->drawBitmap(fBitmap, 0, 0, &paint); } }
static void initPaint(SkPaint& paint) { // Make sure the paint is opaque, color, alpha, filter, etc. // will be applied later when compositing the alpha8 texture paint.setColor(SK_ColorBLACK); paint.setAlpha(255); paint.setColorFilter(NULL); paint.setMaskFilter(NULL); paint.setShader(NULL); SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrc_Mode); SkSafeUnref(paint.setXfermode(mode)); }
sk_sp<SkSpecialImage> SkDropShadowImageFilter::onFilterImage(SkSpecialImage* source, const Context& ctx, SkIPoint* offset) const { SkIPoint inputOffset = SkIPoint::Make(0, 0); sk_sp<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset)); if (!input) { return nullptr; } const SkIRect inputBounds = SkIRect::MakeXYWH(inputOffset.x(), inputOffset.y(), input->width(), input->height()); SkIRect bounds; if (!this->applyCropRect(ctx, inputBounds, &bounds)) { return nullptr; } const SkImageInfo info = SkImageInfo::MakeN32(bounds.width(), bounds.height(), kPremul_SkAlphaType); sk_sp<SkSpecialSurface> surf(source->makeSurface(info)); if (!surf) { return nullptr; } SkCanvas* canvas = surf->getCanvas(); SkASSERT(canvas); canvas->clear(0x0); SkVector sigma = SkVector::Make(fSigmaX, fSigmaY); ctx.ctm().mapVectors(&sigma, 1); sigma.fX = SkMaxScalar(0, sigma.fX); sigma.fY = SkMaxScalar(0, sigma.fY); SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(sigma.fX, sigma.fY)); SkPaint paint; paint.setImageFilter(blurFilter.get()); paint.setColorFilter(SkColorFilter::MakeModeFilter(fColor, SkXfermode::kSrcIn_Mode)); paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); SkVector offsetVec = SkVector::Make(fDx, fDy); ctx.ctm().mapVectors(&offsetVec, 1); canvas->translate(SkIntToScalar(inputOffset.fX - bounds.fLeft), SkIntToScalar(inputOffset.fY - bounds.fTop)); input->draw(canvas, offsetVec.fX, offsetVec.fY, &paint); if (fShadowMode == kDrawShadowAndForeground_ShadowMode) { input->draw(canvas, 0, 0, nullptr); } offset->fX = bounds.fLeft; offset->fY = bounds.fTop; return surf->makeImageSnapshot(); }
static SkPaint make_paint() { SkPaint paint; if (fuzz->exhausted()) { return paint; } paint.setHinting(make_paint_hinting()); paint.setAntiAlias(make_bool()); paint.setDither(make_bool()); paint.setLinearText(make_bool()); paint.setSubpixelText(make_bool()); paint.setLCDRenderText(make_bool()); paint.setEmbeddedBitmapText(make_bool()); paint.setAutohinted(make_bool()); paint.setVerticalText(make_bool()); paint.setFakeBoldText(make_bool()); paint.setDevKernText(make_bool()); paint.setFilterQuality(make_filter_quality()); paint.setStyle(make_paint_style()); paint.setColor(make_color()); paint.setStrokeWidth(make_number(false)); paint.setStrokeMiter(make_number(false)); paint.setStrokeCap(make_paint_cap()); paint.setStrokeJoin(make_paint_join()); paint.setColorFilter(make_color_filter()); paint.setBlendMode(make_blendmode()); paint.setPathEffect(make_path_effect()); paint.setMaskFilter(make_mask_filter()); if (false) { // our validating buffer does not support typefaces yet, so skip this for now paint.setTypeface(SkTypeface::MakeFromName(make_font_name().c_str(),make_typeface_style())); } SkLayerRasterizer::Builder rasterizerBuilder; SkPaint paintForRasterizer; if (make_bool()) { paintForRasterizer = make_paint(); } rasterizerBuilder.addLayer(paintForRasterizer); paint.setRasterizer(rasterizerBuilder.detach()); paint.setImageFilter(make_image_filter()); bool a, b, c; fuzz->next(&a, &b, &c); sk_sp<SkData> data(make_3Dlut(nullptr, a, b, c)); paint.setTextAlign(make_paint_align()); SkScalar d, e, f; fuzz->next(&d, &e, &f); paint.setTextSize(d); paint.setTextScaleX(e); paint.setTextSkewX(f); paint.setTextEncoding(make_paint_text_encoding()); return paint; }
static SkPaint make_paint() { SkPaint paint; paint.setHinting(make_paint_hinting()); paint.setAntiAlias(make_bool()); paint.setDither(make_bool()); paint.setLinearText(make_bool()); paint.setSubpixelText(make_bool()); paint.setLCDRenderText(make_bool()); paint.setEmbeddedBitmapText(make_bool()); paint.setAutohinted(make_bool()); paint.setVerticalText(make_bool()); paint.setUnderlineText(make_bool()); paint.setStrikeThruText(make_bool()); paint.setFakeBoldText(make_bool()); paint.setDevKernText(make_bool()); paint.setFilterQuality(make_filter_quality()); paint.setStyle(make_paint_style()); paint.setColor(make_color()); paint.setStrokeWidth(make_scalar()); paint.setStrokeMiter(make_scalar()); paint.setStrokeCap(make_paint_cap()); paint.setStrokeJoin(make_paint_join()); paint.setColorFilter(make_color_filter()); paint.setXfermodeMode(make_xfermode()); paint.setPathEffect(make_path_effect()); paint.setMaskFilter(make_mask_filter()); if (false) { // our validating buffer does not support typefaces yet, so skip this for now SkAutoTUnref<SkTypeface> typeface( SkTypeface::CreateFromName(make_font_name().c_str(), make_typeface_style())); paint.setTypeface(typeface); } SkLayerRasterizer::Builder rasterizerBuilder; SkPaint paintForRasterizer; if (R(2) == 1) { paintForRasterizer = make_paint(); } rasterizerBuilder.addLayer(paintForRasterizer); paint.setRasterizer(rasterizerBuilder.detach()); paint.setImageFilter(make_image_filter()); sk_sp<SkData> data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool())); paint.setTextAlign(make_paint_align()); paint.setTextSize(make_scalar()); paint.setTextScaleX(make_scalar()); paint.setTextSkewX(make_scalar()); paint.setTextEncoding(make_paint_text_encoding()); return paint; }
virtual void onDraw(SkCanvas* canvas) { if (!fInitialized) { this->make_bitmap(); this->make_3Dluts(); fInitialized = true; } canvas->clear(0x00000000); SkPaint paint; paint.setColorFilter(SkColorCubeFilter::Create(f3DLut4, 4))->unref(); canvas->drawBitmap(fBitmap, 10, 10, &paint); paint.setColorFilter(SkColorCubeFilter::Create(f3DLut8, 8))->unref(); canvas->drawBitmap(fBitmap, 110, 10, &paint); paint.setColorFilter(SkColorCubeFilter::Create(f3DLut16, 16))->unref(); canvas->drawBitmap(fBitmap, 210, 10, &paint); paint.setColorFilter(SkColorCubeFilter::Create(f3DLut32, 32))->unref(); canvas->drawBitmap(fBitmap, 310, 10, &paint); paint.setColorFilter(SkColorCubeFilter::Create(f3DLut64, 64))->unref(); canvas->drawBitmap(fBitmap, 410, 10, &paint); }
static void draw_into_canvas(SkCanvas* canvas) { const SkRect r = SkRect::MakeWH(50, 100); sk_sp<SkShader> (*shaders[])() { make_opaque_color, make_alpha_color }; SkColorFilter* (*filters[])() { make_cf_null, make_cf0, make_cf1, make_cf2 }; SkPaint paint; for (auto shProc : shaders) { paint.setShader(shProc()); for (auto cfProc : filters) { SkSafeUnref(paint.setColorFilter(cfProc())); canvas->drawRect(r, paint); canvas->translate(60, 0); } } }
bool SkColorFilterImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source, const SkMatrix& matrix, SkBitmap* result, SkIPoint* loc) { SkBitmap src = this->getInputResult(proxy, source, matrix, loc); SkAutoTUnref<SkDevice> device(proxy->createDevice(src.width(), src.height())); SkCanvas canvas(device.get()); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrc_Mode); paint.setColorFilter(fColorFilter); canvas.drawSprite(src, 0, 0, &paint); *result = device.get()->accessBitmap(false); return true; }
void onDraw(SkCanvas* canvas) override { SkPaint paint; SkBitmap bm = make_bm(); canvas->drawBitmap(bm, 10, 10, &paint); const SkScalar dir[] = { 1, 1, 1 }; paint.setMaskFilter(SkBlurMaskFilter::MakeEmboss(3, dir, 0.3f, 0.1f)); canvas->translate(bm.width() + SkIntToScalar(10), 0); canvas->drawBitmap(bm, 10, 10, &paint); // this combination of emboss+colorfilter used to crash -- so we exercise it to // confirm that we have a fix. paint.setColorFilter(SkColorFilter::MakeModeFilter(0xFFFF0000, SkBlendMode::kSrcATop)); canvas->translate(bm.width() + SkIntToScalar(10), 0); canvas->drawBitmap(bm, 10, 10, &paint); }
bool SkDropShadowImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source, const Context& ctx, SkBitmap* result, SkIPoint* offset) const { SkBitmap src = source; SkIPoint srcOffset = SkIPoint::Make(0, 0); if (!this->filterInput(0, proxy, source, ctx, &src, &srcOffset)) return false; SkIRect srcBounds = src.bounds(); srcBounds.offset(srcOffset); SkIRect bounds; if (!this->applyCropRect(ctx, srcBounds, &bounds)) { return false; } SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height())); if (nullptr == device.get()) { return false; } SkCanvas canvas(device.get()); SkVector sigma = SkVector::Make(fSigmaX, fSigmaY); ctx.ctm().mapVectors(&sigma, 1); sigma.fX = SkMaxScalar(0, sigma.fX); sigma.fY = SkMaxScalar(0, sigma.fY); SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(sigma.fX, sigma.fY)); SkAutoTUnref<SkColorFilter> colorFilter( SkColorFilter::CreateModeFilter(fColor, SkXfermode::kSrcIn_Mode)); SkPaint paint; paint.setImageFilter(blurFilter.get()); paint.setColorFilter(colorFilter.get()); paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); SkVector offsetVec = SkVector::Make(fDx, fDy); ctx.ctm().mapVectors(&offsetVec, 1); canvas.translate(SkIntToScalar(srcOffset.fX - bounds.fLeft), SkIntToScalar(srcOffset.fY - bounds.fTop)); canvas.drawBitmap(src, offsetVec.fX, offsetVec.fY, &paint); if (fShadowMode == kDrawShadowAndForeground_ShadowMode) { canvas.drawBitmap(src, 0, 0); } *result = device->accessBitmap(false); offset->fX = bounds.fLeft; offset->fY = bounds.fTop; return true; }
bool SVGPaintContext::paintForLayoutObject( const PaintInfo& paintInfo, const ComputedStyle& style, const LayoutObject& layoutObject, LayoutSVGResourceMode resourceMode, SkPaint& paint, const AffineTransform* additionalPaintServerTransform) { if (paintInfo.isRenderingClipPathAsMaskImage()) { if (resourceMode == ApplyToStrokeMode) return false; paint.setColor(SVGComputedStyle::initialFillPaintColor().rgb()); paint.setShader(nullptr); return true; } SVGPaintServer paintServer = SVGPaintServer::requestForLayoutObject(layoutObject, style, resourceMode); if (!paintServer.isValid()) return false; if (additionalPaintServerTransform && paintServer.isTransformDependent()) paintServer.prependTransform(*additionalPaintServerTransform); const SVGComputedStyle& svgStyle = style.svgStyle(); float paintAlpha = resourceMode == ApplyToFillMode ? svgStyle.fillOpacity() : svgStyle.strokeOpacity(); paintServer.applyToSkPaint(paint, paintAlpha); // We always set filter quality to 'low' here. This value will only have an // effect for patterns, which are SkPictures, so using high-order filter // should have little effect on the overall quality. paint.setFilterQuality(kLow_SkFilterQuality); // TODO(fs): The color filter can set when generating a picture for a mask - // due to color-interpolation. We could also just apply the // color-interpolation property from the the shape itself (which could mean // the paintserver if it has it specified), since that would be more in line // with the spec for color-interpolation. For now, just steal it from the GC // though. // Additionally, it's not really safe/guaranteed to be correct, as // something down the paint pipe may want to farther tweak the color // filter, which could yield incorrect results. (Consider just using // saveLayer() w/ this color filter explicitly instead.) paint.setColorFilter(sk_ref_sp(paintInfo.context.getColorFilter())); return true; }
void DrawLooperBuilder::addShadow(const FloatSize& offset, float blur, const Color& color, ShadowTransformMode shadowTransformMode, ShadowAlphaMode shadowAlphaMode) { // Negative blurs are not allowed, so just pin the value to 0 if (blur < 0) blur = 0; // Detect when there's no effective shadow. if (!color.alpha()) return; SkColor skColor = color.rgb(); SkLayerDrawLooper::LayerInfo info; switch (shadowAlphaMode) { case ShadowRespectsAlpha: info.fColorMode = SkXfermode::kDst_Mode; break; case ShadowIgnoresAlpha: info.fColorMode = SkXfermode::kSrc_Mode; break; default: ASSERT_NOT_REACHED(); } if (blur) info.fPaintBits |= SkLayerDrawLooper::kMaskFilter_Bit; // our blur info.fPaintBits |= SkLayerDrawLooper::kColorFilter_Bit; info.fOffset.set(offset.width(), offset.height()); info.fPostTranslate = (shadowTransformMode == ShadowIgnoresTransforms); SkPaint* paint = m_skDrawLooperBuilder.addLayerOnTop(info); if (blur) { const SkScalar sigma = skBlurRadiusToSigma(blur); uint32_t mfFlags = SkBlurMaskFilter::kHighQuality_BlurFlag; if (shadowTransformMode == ShadowIgnoresTransforms) mfFlags |= SkBlurMaskFilter::kIgnoreTransform_BlurFlag; RefPtr<SkMaskFilter> mf = adoptRef(SkBlurMaskFilter::Create(kNormal_SkBlurStyle, sigma, mfFlags)); paint->setMaskFilter(mf.get()); } RefPtr<SkColorFilter> cf = adoptRef(SkColorFilter::CreateModeFilter(skColor, SkXfermode::kSrcIn_Mode)); paint->setColorFilter(cf.get()); }
// Create a 1-tier drawlooper sk_sp<SkDrawLooper> create1Looper(SkScalar xOff, SkScalar yOff, SkColor color) { SkLayerDrawLooper::Builder looperBuilder; SkLayerDrawLooper::LayerInfo info; info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit | SkLayerDrawLooper::kMaskFilter_Bit; info.fColorMode = SkXfermode::kSrc_Mode; info.fOffset.set(xOff, yOff); info.fPostTranslate = false; SkPaint* paint = looperBuilder.addLayer(info); paint->setMaskFilter(this->createBlur())->unref(); paint->setColorFilter(SkColorFilter::MakeModeFilter(color, SkXfermode::kSrcIn_Mode)); return looperBuilder.detach(); }
// Create a 1-tier drawlooper sk_sp<SkDrawLooper> create1Looper(SkScalar xOff, SkScalar yOff, SkColor color) { SkLayerDrawLooper::Builder looperBuilder; SkLayerDrawLooper::LayerInfo info; info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit | SkLayerDrawLooper::kMaskFilter_Bit; info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc; info.fOffset.set(xOff, yOff); info.fPostTranslate = false; SkPaint* paint = looperBuilder.addLayer(info); paint->setMaskFilter(MakeBlur()); paint->setColorFilter(SkColorFilter::MakeModeFilter(color, SkBlendMode::kSrcIn)); return looperBuilder.detach(); }
void DrawLooperBuilder::addShadow(const FloatSize& offset, float blur, const Color& color, ShadowTransformMode shadowTransformMode, ShadowAlphaMode shadowAlphaMode) { // Detect when there's no effective shadow. if (!color.alpha()) return; SkColor skColor = color.rgb(); SkLayerDrawLooper::LayerInfo info; switch (shadowAlphaMode) { case ShadowRespectsAlpha: info.fColorMode = SkBlendMode::kDst; break; case ShadowIgnoresAlpha: info.fColorMode = SkBlendMode::kSrc; break; default: ASSERT_NOT_REACHED(); } if (blur) info.fPaintBits |= SkLayerDrawLooper::kMaskFilter_Bit; // our blur info.fPaintBits |= SkLayerDrawLooper::kColorFilter_Bit; info.fOffset.set(offset.width(), offset.height()); info.fPostTranslate = (shadowTransformMode == ShadowIgnoresTransforms); SkPaint* paint = m_skDrawLooperBuilder.addLayerOnTop(info); if (blur) { const SkScalar sigma = RadiusToSigma(blur / 2); uint32_t mfFlags = SkBlurMaskFilter::kHighQuality_BlurFlag; if (shadowTransformMode == ShadowIgnoresTransforms) mfFlags |= SkBlurMaskFilter::kIgnoreTransform_BlurFlag; paint->setMaskFilter( SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma, mfFlags)); } paint->setColorFilter( SkColorFilter::MakeModeFilter(skColor, SkBlendMode::kSrcIn)); }
static void draw_scene(SkCanvas* canvas, const SkHighContrastConfig& config) { SkRect bounds = SkRect::MakeLTRB(0.0f, 0.0f, 1.0f, 1.0f); SkPaint xferPaint; xferPaint.setColorFilter(SkHighContrastFilter::Make(config)); canvas->saveLayer(&bounds, &xferPaint); SkPaint paint; bounds = SkRect::MakeLTRB(0.1f, 0.2f, 0.9f, 0.4f); paint.setARGB(0xff, 0x66, 0x11, 0x11); canvas->drawRect(bounds, paint); SkFont font; font.setSize(0.15f); font.setEdging(SkFont::Edging::kAlias); paint.setARGB(0xff, 0xbb, 0x77, 0x77); canvas->drawString("A", 0.15f, 0.35f, font, paint); bounds = SkRect::MakeLTRB(0.1f, 0.8f, 0.9f, 1.0f); paint.setARGB(0xff, 0xcc, 0xcc, 0xff); canvas->drawRect(bounds, paint); paint.setARGB(0xff, 0x88, 0x88, 0xbb); canvas->drawString("Z", 0.75f, 0.95f, font, paint); bounds = SkRect::MakeLTRB(0.1f, 0.4f, 0.9f, 0.6f); SkPoint pts[] = { { 0, 0 }, { 1, 0 } }; SkColor colors[] = { SK_ColorWHITE, SK_ColorBLACK }; SkScalar pos[] = { 0.2f, 0.8f }; paint.setShader(SkGradientShader::MakeLinear( pts, colors, pos, SK_ARRAY_COUNT(colors), SkTileMode::kClamp)); canvas->drawRect(bounds, paint); bounds = SkRect::MakeLTRB(0.1f, 0.6f, 0.9f, 0.8f); SkColor colors2[] = { SK_ColorGREEN, SK_ColorWHITE }; paint.setShader(SkGradientShader::MakeLinear( pts, colors2, pos, SK_ARRAY_COUNT(colors2), SkTileMode::kClamp)); canvas->drawRect(bounds, paint); canvas->restore(); }
void updateCard(int ci, int curFrame) { // updating card's translation Y sp<RenderNode> card = mCards[ci]; card->setPropertyFieldsDirty(RenderNode::Y); card->mutateStagingProperties().setTranslationY(curFrame % 150); // re-recording card's canvas, not necessary but to add some burden to CPU std::unique_ptr<Canvas> cardcanvas(Canvas::create_recording_canvas( card->stagingProperties().getWidth(), card->stagingProperties().getHeight(), card.get())); sp<RenderNode> image = mImages[ci]; sp<RenderNode> infoArea = mInfoAreas[ci]; cardcanvas->drawRenderNode(infoArea.get()); if (useOverlay()) { cardcanvas->drawRenderNode(image.get()); // re-recording card overlay's canvas, animating overlay color alpha sp<RenderNode> overlay = mOverlays[ci]; std::unique_ptr<Canvas> canvas( Canvas::create_recording_canvas(overlay->stagingProperties().getWidth(), overlay->stagingProperties().getHeight(), overlay.get())); canvas->drawColor((curFrame % 150) << 24, SkBlendMode::kSrcOver); overlay->setStagingDisplayList(canvas->finishRecording()); cardcanvas->drawRenderNode(overlay.get()); } else { // re-recording image node's canvas, animating ColorFilter std::unique_ptr<Canvas> canvas(Canvas::create_recording_canvas( image->stagingProperties().getWidth(), image->stagingProperties().getHeight(), image.get())); SkPaint paint; sk_sp<SkColorFilter> filter( SkColorFilter::MakeModeFilter((curFrame % 150) << 24, SkBlendMode::kSrcATop)); paint.setColorFilter(filter); sk_sp<Bitmap> bitmap = mCachedBitmaps[ci]; canvas->drawBitmap(*bitmap, 0, 0, &paint); image->setStagingDisplayList(canvas->finishRecording()); cardcanvas->drawRenderNode(image.get()); } card->setStagingDisplayList(cardcanvas->finishRecording()); }
sk_sp<SkSpecialImage> SkColorFilterImageFilter::onFilterImage(SkSpecialImage* source, const Context& ctx, SkIPoint* offset) const { SkIPoint inputOffset = SkIPoint::Make(0, 0); sk_sp<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset)); if (!input) { return nullptr; } SkIRect bounds; const SkIRect inputBounds = SkIRect::MakeXYWH(inputOffset.fX, inputOffset.fY, input->width(), input->height()); if (!this->applyCropRect(ctx, inputBounds, &bounds)) { return nullptr; } SkImageInfo info = SkImageInfo::MakeN32(bounds.width(), bounds.height(), kPremul_SkAlphaType); sk_sp<SkSpecialSurface> surf(source->makeSurface(info)); if (!surf) { return nullptr; } SkCanvas* canvas = surf->getCanvas(); SkASSERT(canvas); // TODO: it seems like this clear shouldn't be necessary (see skbug.com/5075) canvas->clear(0x0); SkPaint paint; paint.setXfermodeMode(SkXfermode::kSrc_Mode); paint.setColorFilter(fColorFilter); input->draw(canvas, SkIntToScalar(inputOffset.fX - bounds.fLeft), SkIntToScalar(inputOffset.fY - bounds.fTop), &paint); offset->fX = bounds.fLeft; offset->fY = bounds.fTop; return surf->makeImageSnapshot(); }