Home | History | Annotate | Download | only in effects 
      1 /*
      2  * Copyright 2011 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "SkBlurDrawLooper.h"
      9 #include "SkBlurMask.h"     // just for SkBlurMask::ConvertRadiusToSigma
     10 #include "SkBlurMaskFilter.h"
     11 #include "SkCanvas.h"
     12 #include "SkColorFilter.h"
     13 #include "SkReadBuffer.h"
     14 #include "SkWriteBuffer.h"
     15 #include "SkMaskFilter.h"
     16 #include "SkPaint.h"
     17 #include "SkString.h"
     18 #include "SkStringUtils.h"
     19 
     20 SkBlurDrawLooper::SkBlurDrawLooper(SkColor color, SkScalar sigma,
     21                                    SkScalar dx, SkScalar dy, uint32_t flags) {
     22     this->init(sigma, dx, dy, color, flags);
     23 }
     24 
     25 // only call from constructor
     26 void SkBlurDrawLooper::initEffects() {
     27     SkASSERT(fBlurFlags <= kAll_BlurFlag);
     28     if (fSigma > 0) {
     29         uint32_t flags = fBlurFlags & kIgnoreTransform_BlurFlag ?
     30                             SkBlurMaskFilter::kIgnoreTransform_BlurFlag :
     31                             SkBlurMaskFilter::kNone_BlurFlag;
     32 
     33         flags |= fBlurFlags & kHighQuality_BlurFlag ?
     34                     SkBlurMaskFilter::kHighQuality_BlurFlag :
     35                     SkBlurMaskFilter::kNone_BlurFlag;
     36 
     37         fBlur = SkBlurMaskFilter::Create(kNormal_SkBlurStyle, fSigma, flags);
     38     } else {
     39         fBlur = NULL;
     40     }
     41 
     42     if (fBlurFlags & kOverrideColor_BlurFlag) {
     43         // Set alpha to 1 for the override since transparency will already
     44         // be baked into the blurred mask.
     45         SkColor opaqueColor = SkColorSetA(fBlurColor, 255);
     46         //The SrcIn xfer mode will multiply 'color' by the incoming alpha
     47         fColorFilter = SkColorFilter::CreateModeFilter(opaqueColor,
     48                                                        SkXfermode::kSrcIn_Mode);
     49     } else {
     50         fColorFilter = NULL;
     51     }
     52 }
     53 
     54 void SkBlurDrawLooper::init(SkScalar sigma, SkScalar dx, SkScalar dy,
     55                             SkColor color, uint32_t flags) {
     56     fSigma = sigma;
     57     fDx = dx;
     58     fDy = dy;
     59     fBlurColor = color;
     60     fBlurFlags = flags;
     61 
     62     this->initEffects();
     63 }
     64 
     65 SkFlattenable* SkBlurDrawLooper::CreateProc(SkReadBuffer& buffer) {
     66     const SkColor color = buffer.readColor();
     67     const SkScalar sigma = buffer.readScalar();
     68     const SkScalar dx = buffer.readScalar();
     69     const SkScalar dy = buffer.readScalar();
     70     const uint32_t flags = buffer.read32();
     71     return Create(color, sigma, dx, dy, flags);
     72 }
     73 
     74 void SkBlurDrawLooper::flatten(SkWriteBuffer& buffer) const {
     75     buffer.writeColor(fBlurColor);
     76     buffer.writeScalar(fSigma);
     77     buffer.writeScalar(fDx);
     78     buffer.writeScalar(fDy);
     79     buffer.write32(fBlurFlags);
     80 }
     81 
     82 SkBlurDrawLooper::~SkBlurDrawLooper() {
     83     SkSafeUnref(fBlur);
     84     SkSafeUnref(fColorFilter);
     85 }
     86 
     87 bool SkBlurDrawLooper::asABlurShadow(BlurShadowRec* rec) const {
     88     if (fSigma <= 0 || (fBlurFlags & fBlurFlags & kIgnoreTransform_BlurFlag)) {
     89         return false;
     90     }
     91 
     92     if (rec) {
     93         rec->fSigma = fSigma;
     94         rec->fColor = fBlurColor;
     95         rec->fOffset.set(fDx, fDy);
     96         rec->fStyle = kNormal_SkBlurStyle;
     97         rec->fQuality = (fBlurFlags & kHighQuality_BlurFlag) ?
     98                         kHigh_SkBlurQuality : kLow_SkBlurQuality;
     99     }
    100     return true;
    101 }
    102 
    103 ////////////////////////////////////////////////////////////////////////////////////////
    104 
    105 SkDrawLooper::Context* SkBlurDrawLooper::createContext(SkCanvas*, void* storage) const {
    106     return SkNEW_PLACEMENT_ARGS(storage, BlurDrawLooperContext, (this));
    107 }
    108 
    109 SkBlurDrawLooper::BlurDrawLooperContext::BlurDrawLooperContext(
    110         const SkBlurDrawLooper* looper)
    111     : fLooper(looper), fState(SkBlurDrawLooper::kBeforeEdge) {}
    112 
    113 bool SkBlurDrawLooper::BlurDrawLooperContext::next(SkCanvas* canvas,
    114                                                    SkPaint* paint) {
    115     switch (fState) {
    116         case kBeforeEdge:
    117             // we do nothing if a maskfilter is already installed
    118             if (paint->getMaskFilter()) {
    119                 fState = kDone;
    120                 return false;
    121             }
    122 #ifdef SK_BUILD_FOR_ANDROID
    123             SkColor blurColor;
    124             blurColor = fLooper->fBlurColor;
    125             if (SkColorGetA(blurColor) == 255) {
    126                 blurColor = SkColorSetA(blurColor, paint->getAlpha());
    127             }
    128             paint->setColor(blurColor);
    129 #else
    130             paint->setColor(fLooper->fBlurColor);
    131 #endif
    132             paint->setMaskFilter(fLooper->fBlur);
    133             paint->setColorFilter(fLooper->fColorFilter);
    134             canvas->save();
    135             if (fLooper->fBlurFlags & kIgnoreTransform_BlurFlag) {
    136                 SkMatrix transform(canvas->getTotalMatrix());
    137                 transform.postTranslate(fLooper->fDx, fLooper->fDy);
    138                 canvas->setMatrix(transform);
    139             } else {
    140                 canvas->translate(fLooper->fDx, fLooper->fDy);
    141             }
    142             fState = kAfterEdge;
    143             return true;
    144         case kAfterEdge:
    145             canvas->restore();
    146             fState = kDone;
    147             return true;
    148         default:
    149             SkASSERT(kDone == fState);
    150             return false;
    151     }
    152 }
    153 
    154 #ifndef SK_IGNORE_TO_STRING
    155 void SkBlurDrawLooper::toString(SkString* str) const {
    156     str->append("SkBlurDrawLooper: ");
    157 
    158     str->append("dx: ");
    159     str->appendScalar(fDx);
    160 
    161     str->append(" dy: ");
    162     str->appendScalar(fDy);
    163 
    164     str->append(" color: ");
    165     str->appendHex(fBlurColor);
    166 
    167     str->append(" flags: (");
    168     if (kNone_BlurFlag == fBlurFlags) {
    169         str->append("None");
    170     } else {
    171         bool needsSeparator = false;
    172         SkAddFlagToString(str, SkToBool(kIgnoreTransform_BlurFlag & fBlurFlags), "IgnoreTransform",
    173                           &needsSeparator);
    174         SkAddFlagToString(str, SkToBool(kOverrideColor_BlurFlag & fBlurFlags), "OverrideColor",
    175                           &needsSeparator);
    176         SkAddFlagToString(str, SkToBool(kHighQuality_BlurFlag & fBlurFlags), "HighQuality",
    177                           &needsSeparator);
    178     }
    179     str->append(")");
    180 
    181     // TODO: add optional "fBlurFilter->toString(str);" when SkMaskFilter::toString is added
    182     // alternatively we could cache the radius in SkBlurDrawLooper and just add it here
    183 }
    184 #endif
    185