SkEmbossMaskFilter Class Reference

#include <SkEmbossMaskFilter.h>

Inheritance diagram for SkEmbossMaskFilter:

Classes
struct	Light

Public Member Functions
SkMask::Format	getFormat () const override
bool	filterMask (SkMaskBuilder *dst, const SkMask &src, const SkMatrix &, SkIPoint *margin) const override
SkMaskFilterBase::Type	type () const override
Public Member Functions inherited from SkMaskFilterBase
virtual void	computeFastBounds (const SkRect &src, SkRect *dest) const
virtual bool	asABlur (BlurRec *) const
virtual sk_sp< SkImageFilter >	asImageFilter (const SkMatrix &ctm) const
SkFlattenable::Type	getFlattenableType () const override
Public Member Functions inherited from SkMaskFilter
SkRect	approximateFilteredBounds (const SkRect &src) const
Public Member Functions inherited from SkFlattenable
	SkFlattenable ()
virtual Factory	getFactory () const =0
virtual const char *	getTypeName () const =0
sk_sp< SkData >	serialize (const SkSerialProcs *=nullptr) const
size_t	serialize (void *memory, size_t memory_size, const SkSerialProcs *=nullptr) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< SkMaskFilter >	Make (SkScalar blurSigma, const Light &light)
Static Public Member Functions inherited from SkMaskFilterBase
static SkFlattenable::Type	GetFlattenableType ()
Static Public Member Functions inherited from SkMaskFilter
static sk_sp< SkMaskFilter >	MakeBlur (SkBlurStyle style, SkScalar sigma, bool respectCTM=true)
static sk_sp< SkMaskFilter >	Deserialize (const void *data, size_t size, const SkDeserialProcs *procs=nullptr)
Static Public Member Functions inherited from SkFlattenable
static Factory	NameToFactory (const char name[])
static const char *	FactoryToName (Factory)
static void	Register (const char name[], Factory)
static sk_sp< SkFlattenable >	Deserialize (Type, const void *data, size_t length, const SkDeserialProcs *procs=nullptr)

Protected Member Functions
	SkEmbossMaskFilter (SkScalar blurSigma, const Light &light)
void	flatten (SkWriteBuffer &) const override
Protected Member Functions inherited from SkMaskFilterBase
	SkMaskFilterBase ()
virtual FilterReturn	filterRectsToNine (const SkRect[], int count, const SkMatrix &, const SkIRect &clipBounds, SkTLazy< NinePatch > *) const
virtual FilterReturn	filterRRectToNine (const SkRRect &, const SkMatrix &, const SkIRect &clipBounds, SkTLazy< NinePatch > *) const

Additional Inherited Members
Public Types inherited from SkMaskFilterBase
enum class	Type {   kBlur , kEmboss , kSDF , kShader ,   kTable }
Public Types inherited from SkFlattenable
enum	Type {   kSkColorFilter_Type , kSkBlender_Type , kSkDrawable_Type , kSkDrawLooper_Type ,   kSkImageFilter_Type , kSkMaskFilter_Type , kSkPathEffect_Type , kSkShader_Type }
typedef sk_sp< SkFlattenable >(*	Factory) (SkReadBuffer &)
Protected Types inherited from SkMaskFilterBase
enum	FilterReturn { kFalse_FilterReturn , kTrue_FilterReturn , kUnimplemented_FilterReturn }

Detailed Description

This mask filter creates a 3D emboss look, by specifying a light and blur amount.

Definition at line 30 of file SkEmbossMaskFilter.h.

Constructor & Destructor Documentation

SkEmbossMaskFilter()

SkEmbossMaskFilter::SkEmbossMaskFilter ( SkScalar  blurSigma, const Light &  light  )

protected

Definition at line 66 of file SkEmbossMaskFilter.cpp.

    : fLight(light), fBlurSigma(blurSigma)
{
    SkASSERT(fBlurSigma > 0);
    SkASSERT(SkIsFinite(fLight.fDirection, 3));
}

Member Function Documentation

filterMask()

bool SkEmbossMaskFilter::filterMask ( SkMaskBuilder *  dst, const SkMask &  src, const SkMatrix &  , SkIPoint *  margin  ) const

overridevirtual

Create a new mask by filter the src mask. If src.fImage == null, then do not allocate or create the dst image but do fill out the other fields in dstMask. If you do allocate a dst image, use SkMask::AllocImage() If this returns false, dst mask is ignored.

Parameters

dst	the result of the filter. If src.fImage == null, dst should not allocate its image
src	the original image to be filtered.
matrix	the CTM
margin	if not null, return the buffer dx/dy need when calculating the effect. Used when drawing a clipped object to know how much larger to allocate the src before applying the filter. If returning false, ignore this parameter.

Returns

true if the dst mask was correctly created.

Implements SkMaskFilterBase.

Definition at line 77 of file SkEmbossMaskFilter.cpp.

                                                                                    {
    if (src.fFormat != SkMask::kA8_Format) {
        return false;
    }
 
    SkScalar sigma = matrix.mapRadius(fBlurSigma);
 
    if (!SkBlurMask::BoxBlur(dst, src, sigma, kInner_SkBlurStyle)) {
        return false;
    }
 
    dst->format() = SkMask::k3D_Format;
    if (margin) {
        margin->set(SkScalarCeilToInt(3*sigma), SkScalarCeilToInt(3*sigma));
    }
 
    if (src.fImage == nullptr) {
        return true;
    }
 
    // create a larger buffer for the other two channels (should force fBlur to do this for us)
 
    {
        uint8_t* alphaPlane = dst->image();
        size_t   planeSize = dst->computeImageSize();
        if (0 == planeSize) {
            return false;   // too big to allocate, abort
        }
        dst->image() = SkMaskBuilder::AllocImage(planeSize * 3);
        memcpy(dst->image(), alphaPlane, planeSize);
        SkMaskBuilder::FreeImage(alphaPlane);
    }
 
    // run the light direction through the matrix...
    Light   light = fLight;
    matrix.mapVectors((SkVector*)(void*)light.fDirection,
                      (SkVector*)(void*)fLight.fDirection, 1);
 
    // now restore the length of the XY component
    // cast to SkVector so we can call setLength (this double cast silences alias warnings)
    SkVector* vec = (SkVector*)(void*)light.fDirection;
    vec->setLength(light.fDirection[0],
                   light.fDirection[1],
                   SkPoint::Length(fLight.fDirection[0], fLight.fDirection[1]));
 
    SkEmbossMask::Emboss(dst, light);
 
    // restore original alpha
    memcpy(dst->image(), src.fImage, src.computeImageSize());
 
    return true;
}

flatten()

void SkEmbossMaskFilter::flatten ( SkWriteBuffer &  ) const

overrideprotectedvirtual

Override this if your subclass needs to record data that it will need to recreate itself from its CreateProc (returned by getFactory()).

DEPRECATED public : will move to protected ... use serialize() instead

Reimplemented from SkFlattenable.

Definition at line 141 of file SkEmbossMaskFilter.cpp.

                                                            {
    Light tmpLight = fLight;
    tmpLight.fPad = 0;    // for the font-cache lookup to be clean
    buffer.writeByteArray(&tmpLight, sizeof(tmpLight));
    buffer.writeScalar(fBlurSigma);
}

getFormat()

SkMask::Format SkEmbossMaskFilter::getFormat ( ) const

overridevirtual

Returns the format of the resulting mask that this subclass will return when its filterMask() method is called.

Implements SkMaskFilterBase.

Definition at line 73 of file SkEmbossMaskFilter.cpp.

                                                 {
    return SkMask::k3D_Format;
}

Make()

sk_sp< SkMaskFilter > SkEmbossMaskFilter::Make ( SkScalar  blurSigma, const Light &  light  )

static

Definition at line 27 of file SkEmbossMaskFilter.cpp.

                                                                                   {
    if (!SkIsFinite(blurSigma) || blurSigma <= 0) {
        return nullptr;
    }
 
    SkPoint3 lightDir{light.fDirection[0], light.fDirection[1], light.fDirection[2]};
    if (!lightDir.normalize()) {
        return nullptr;
    }
    Light newLight = light;
    newLight.fDirection[0] = lightDir.x();
    newLight.fDirection[1] = lightDir.y();
    newLight.fDirection[2] = lightDir.z();
 
    return sk_sp<SkMaskFilter>(new SkEmbossMaskFilter(blurSigma, newLight));
}

type()

SkMaskFilterBase::Type SkEmbossMaskFilter::type ( ) const

inlineoverridevirtual

Implements SkMaskFilterBase.

Definition at line 47 of file SkEmbossMaskFilter.h.

{ return SkMaskFilterBase::Type::kEmboss; }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/effects/SkEmbossMaskFilter.h
• third_party/skia/src/effects/SkEmbossMaskFilter.cpp