SkColorFilter.h

/*
 * Copyright 2006 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkColorFilter_DEFINED
#define SkColorFilter_DEFINED

#include "SkColor.h"
#include "SkFlattenable.h"
#include "SkRefCnt.h"
#include "SkXfermode.h"

class GrContext;
class GrFragmentProcessor;
class SkBitmap;
class SkRasterPipeline;

class SK_API SkColorFilter : public SkFlattenable {
public:
    virtual bool asColorMode(SkColor* color, SkXfermode::Mode* mode) const;

    virtual bool asColorMatrix(SkScalar matrix[20]) const;

    virtual bool asComponentTable(SkBitmap* table) const;

    virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) const = 0;

    virtual void filterSpan4f(const SkPM4f src[], int count, SkPM4f result[]) const;

    bool appendStages(SkRasterPipeline*) const;

    enum Flags {
        kAlphaUnchanged_Flag = 1 << 0,
    };

    virtual uint32_t getFlags() const { return 0; }

    virtual sk_sp<SkColorFilter> makeComposed(sk_sp<SkColorFilter>) const { return nullptr; }

    SkColor filterColor(SkColor) const;

    SkColor4f filterColor4f(const SkColor4f&) const;

    static sk_sp<SkColorFilter> MakeModeFilter(SkColor c, SkXfermode::Mode mode);

    static sk_sp<SkColorFilter> MakeComposeFilter(sk_sp<SkColorFilter> outer,
                                                  sk_sp<SkColorFilter> inner);

    static sk_sp<SkColorFilter> MakeMatrixFilterRowMajor255(const SkScalar array[20]);

#ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR
    static SkColorFilter* CreateModeFilter(SkColor c, SkXfermode::Mode mode) {
        return MakeModeFilter(c, mode).release();
    }
    static SkColorFilter* CreateComposeFilter(SkColorFilter* outer, SkColorFilter* inner) {
        return MakeComposeFilter(sk_ref_sp(outer), sk_ref_sp(inner)).release();
    }
    static SkColorFilter* CreateMatrixFilterRowMajor255(const SkScalar array[20]) {
        return MakeMatrixFilterRowMajor255(array).release();
    }
    virtual SkColorFilter* newComposed(const SkColorFilter* inner) const {
        return this->makeComposed(sk_ref_sp(const_cast<SkColorFilter*>(inner))).release();
    }
#endif

#if SK_SUPPORT_GPU

    virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*) const;
#endif

    bool affectsTransparentBlack() const {
        return this->filterColor(0) != 0;
    }

    SK_TO_STRING_PUREVIRT()

    SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
    SK_DEFINE_FLATTENABLE_TYPE(SkColorFilter)

protected:
    SkColorFilter() {}

    virtual bool onAppendStages(SkRasterPipeline*) const;

private:
    /*
     *  Returns 1 if this is a single filter (not a composition of other filters), otherwise it
     *  reutrns the number of leaf-node filters in a composition. This should be the same value
     *  as the number of GrFragmentProcessors returned by asFragmentProcessors's array parameter.
     *
     *  e.g. compose(filter, compose(compose(filter, filter), filter)) --> 4
     */
    virtual int privateComposedFilterCount() const { return 1; }
    friend class SkComposeColorFilter;

    typedef SkFlattenable INHERITED;
};

#endif