composecolorfilter.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkImage.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkGradientShader.h"
#include "include/effects/SkImageFilters.h"
#include "include/effects/SkLumaColorFilter.h"
#include "include/effects/SkPerlinNoiseShader.h"
#include "include/effects/SkRuntimeEffect.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "tools/Resources.h"
#include <math.h>

Go to the source code of this file.

Functions
static sk_sp< SkColorFilter >	MakeTintColorFilter (SkColor lo, SkColor hi, bool useSkSL)
	DEF_SIMPLE_GM (composeCF, canvas, 200, 200)
	DEF_SIMPLE_GM (composeCFIF, canvas, 604, 200)

Function Documentation

DEF_SIMPLE_GM() [1/2]

DEF_SIMPLE_GM	(	composeCF	,
		canvas	,
		200	,
		200
	)

Definition at line 81 of file composecolorfilter.cpp.

                                           {
    // This GM draws a simple color-filter network, using the existing "makeComposed" API, and also
    // using a runtime color filter that does the same thing.
    SkPaint paint;
    const SkColor gradient_colors[] = {SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED};
    paint.setShader(SkGradientShader::MakeSweep(
            50, 50, gradient_colors, nullptr, std::size(gradient_colors)));
 
    canvas->save();
    for (bool useSkSL : {false, true}) {
        auto cf0 = MakeTintColorFilter(0xff300000, 0xffa00000, useSkSL);  // red tint
        auto cf1 = MakeTintColorFilter(0xff003000, 0xff00a000, useSkSL);  // green tint
 
        paint.setColorFilter(cf0);
        canvas->drawRect({0, 0, 100, 100}, paint);
        canvas->translate(100, 0);
 
        paint.setColorFilter(cf1);
        canvas->drawRect({0, 0, 100, 100}, paint);
 
        canvas->restore();
        canvas->translate(0, 100);
    }
}

DEF_SIMPLE_GM() [2/2]

DEF_SIMPLE_GM	(	composeCFIF	,
		canvas	,
		604	,
		200
	)

Definition at line 106 of file composecolorfilter.cpp.

                                             {
    // This GM draws a ::Shader image filter composed with a ::ColorFilter image filter in two
    // ways (direct and via ::Compose). This ensures the use (or non-use in this case) of the source
    // image is the same across both means of composition.
    auto cf = MakeTintColorFilter(0xff300000, 0xffa00000, /*useSkSL=*/false);
    auto shader = SkShaders::MakeTurbulence(0.01f, 0.01f, 2, 0.f);
 
    auto shaderIF = SkImageFilters::Shader(shader, SkImageFilters::Dither::kNo);
    auto directCompose = SkImageFilters::ColorFilter(cf, shaderIF);
    auto indirectCompose = SkImageFilters::Compose(
            /*outer=*/SkImageFilters::ColorFilter(cf, nullptr),
            /*inner=*/shaderIF);
 
    { // Directly draw the shader composed with the color filter
        canvas->save();
            canvas->clipRect({0, 0, 200, 200});
            SkPaint p;
            p.setShader(shader);
            p.setColorFilter(cf);
            canvas->drawPaint(p);
        canvas->restore();
    }
    canvas->translate(202, 0);
    { // Draw with the directly composed image filter
        canvas->save();
            canvas->clipRect({0, 0, 200, 200});
            SkPaint p;
            p.setImageFilter(directCompose);
            canvas->drawPaint(p);
        canvas->restore();
    }
    canvas->translate(202, 0);
    {
        // Draw with the indirectly composed image filter
        canvas->save();
            canvas->clipRect({0, 0, 200, 200});
            SkPaint p;
            p.setImageFilter(indirectCompose);
            canvas->drawPaint(p);
        canvas->restore();
    }
}

MakeTintColorFilter()

static sk_sp< SkColorFilter > MakeTintColorFilter ( SkColor  lo, SkColor  hi, bool  useSkSL  )

static

Definition at line 37 of file composecolorfilter.cpp.

                                                                                      {
    const auto r_lo = SkColorGetR(lo),
    g_lo = SkColorGetG(lo),
    b_lo = SkColorGetB(lo),
    a_lo = SkColorGetA(lo),
    r_hi = SkColorGetR(hi),
    g_hi = SkColorGetG(hi),
    b_hi = SkColorGetB(hi),
    a_hi = SkColorGetA(hi);
 
    // We map component-wise:
    //
    //   r' = lo.r + (hi.r - lo.r) * luma
    //   g' = lo.g + (hi.g - lo.g) * luma
    //   b' = lo.b + (hi.b - lo.b) * luma
    //   a' = lo.a + (hi.a - lo.a) * luma
    //
    // The input luminance is stored in the alpha channel
    // (and RGB are cleared -- see SkLumaColorFilter). Thus:
    const float tint_matrix[] = {
        0, 0, 0, (r_hi - r_lo) / 255.0f, SkIntToScalar(r_lo) / 255.0f,
        0, 0, 0, (g_hi - g_lo) / 255.0f, SkIntToScalar(g_lo) / 255.0f,
        0, 0, 0, (b_hi - b_lo) / 255.0f, SkIntToScalar(b_lo) / 255.0f,
        0, 0, 0, (a_hi - a_lo) / 255.0f, SkIntToScalar(a_lo) / 255.0f,
    };
 
    sk_sp<SkColorFilter> inner = SkLumaColorFilter::Make(),
                         outer = SkColorFilters::Matrix(tint_matrix);
 
    // Prove that we can implement compose-color-filter using runtime effects
    if (useSkSL) {
        auto [effect, error] = SkRuntimeEffect::MakeForColorFilter(SkString(R"(
            uniform colorFilter inner;
            uniform colorFilter outer;
            half4 main(half4 c) { return outer.eval(inner.eval(c)); }
        )"));
        SkASSERT(effect);
        sk_sp<SkColorFilter> children[] = { inner, outer };
        return effect->makeColorFilter(nullptr, children, std::size(children));
    } else {
        return outer->makeComposed(inner);
    }
}