sksg Namespace Reference

Classes
class	BlenderEffect
class	BlurImageFilter
class	ClipEffect
class	Color
class	ColorFilter
class	CustomRenderNode
class	DashEffect
class	Draw
class	DropShadowImageFilter
class	EffectNode
class	ExternalColorFilter
class	ExternalImageFilter
class	GeometryEffect
class	GeometryNode
class	GeometryTransform
class	Gradient
class	GradientColorFilter
class	Group
class	Image
class	ImageFilter
class	ImageFilterEffect
class	InvalidationController
class	LayerEffect
class	LinearGradient
class	MaskEffect
class	MaskShaderEffect
class	Matrix
class	Merge
class	ModeColorFilter
class	Node
class	NodePriv
class	OffsetEffect
class	OpacityEffect
class	PaintNode
class	Path
class	Plane
class	RadialGradient
class	Rect
class	RenderNode
class	RoundEffect
class	RRect
class	Scene
class	Shader
class	ShaderEffect
class	ShaderPaint
class	Text
class	Transform
class	TransformEffect
class	TransformPriv
class	TrimEffect

Functions
static bool	is_inverted (sksg::MaskEffect::Mode mode)
static bool	is_luma (sksg::MaskEffect::Mode mode)
static SkPathOp	mode_to_op (Merge::Mode mode)
static SkAlpha	ScaleAlpha (SkAlpha alpha, float opacity)
static sk_sp< SkShader >	LocalShader (const sk_sp< SkShader > &shader, const SkMatrix &base, const SkMatrix &ctm)

Function Documentation

is_inverted()

static bool sksg::is_inverted ( sksg::MaskEffect::Mode  mode )

static

Definition at line 24 of file SkSGMaskEffect.cpp.

                                                 {
    return static_cast<uint32_t>(mode) & 1;
}

is_luma()

static bool sksg::is_luma ( sksg::MaskEffect::Mode  mode )

static

Definition at line 28 of file SkSGMaskEffect.cpp.

                                             {
    return static_cast<uint32_t>(mode) & 2;
}

LocalShader()

static sk_sp< SkShader > sksg::LocalShader ( const sk_sp< SkShader > &  shader, const SkMatrix &  base, const SkMatrix &  ctm  )

static

Definition at line 65 of file SkSGRenderNode.cpp.

                                                        {
    // Mask filters / shaders are declared to operate under a specific transform, but due to the
    // deferral mechanism, other transformations might have been pushed to the state.
    // We want to undo these transforms (T):
    //
    //   baseCTM x T = ctm
    //
    //   =>  T = Inv(baseCTM) x ctm
    //
    //   =>  Inv(T) = Inv(Inv(baseCTM) x ctm)
    //
    //   =>  Inv(T) = Inv(ctm) x baseCTM
 
    SkMatrix lm;
    if (base != ctm && ctm.invert(&lm)) {
        lm.preConcat(base);
    } else {
        lm = SkMatrix::I();
    }
 
    // Note: this doesn't play ball with existing shader local matrices (what we really want is
    // SkShader::makeWithPostLocalMatrix).  Probably a good signal that the whole mechanism is
    // contrived and should be redesigned (use SkCanvas::clipShader when available, drop shader
    // "effects" completely, etc).
    return shader->makeWithLocalMatrix(lm);
}

mode_to_op()

static SkPathOp sksg::mode_to_op ( Merge::Mode  mode )

static

Definition at line 51 of file SkSGMerge.cpp.

                                           {
    switch (mode) {
    case Merge::Mode::kUnion:
        return kUnion_SkPathOp;
    case Merge::Mode::kIntersect:
        return kIntersect_SkPathOp;
    case Merge::Mode::kDifference:
        return kDifference_SkPathOp;
    case Merge::Mode::kReverseDifference:
        return kReverseDifference_SkPathOp;
    case Merge::Mode::kXOR:
        return kXOR_SkPathOp;
    default:
        break;
    }
 
    return kUnion_SkPathOp;
}

ScaleAlpha()

static SkAlpha sksg::ScaleAlpha ( SkAlpha  alpha, float  opacity  )

static

Definition at line 61 of file SkSGRenderNode.cpp.

                                                        {
   return SkToU8(sk_float_round2int(alpha * opacity));
}