+++ /dev/null
-/*
- * Copyright 2014 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#include "Benchmark.h"
-#include "SkCanvas.h"
-#include "SkColorCubeFilter.h"
-#include "SkGradientShader.h"
-#include "SkTemplates.h"
-
-class ColorCubeBench : public Benchmark {
- SkISize fSize;
- int fCubeDimension;
- sk_sp<SkData> fCubeData;
- SkBitmap fBitmap;
-
-public:
- ColorCubeBench() : fCubeDimension(0) {
- fSize = SkISize::Make(2880, 1800); // 2014 Macbook Pro resolution
- }
-
-protected:
- const char* onGetName() override {
- return "colorcube";
- }
-
- void onDelayedSetup() override {
- if (!SkToBool(fCubeData)) {
- this->makeCubeData();
- this->make_bitmap();
- }
- }
-
- void onDraw(int loops, SkCanvas* canvas) override {
- this->test(loops, canvas);
- }
-
- SkIPoint onGetSize() override {
- return SkIPoint::Make(fSize.width(), fSize.height());
- }
-
-private:
- static sk_sp<SkShader> MakeLinear(const SkISize& size) {
- const SkPoint pts[2] = {
- { 0, 0 },
- { SkIntToScalar(size.width()), SkIntToScalar(size.height()) }
- };
- static const SkColor colors[] = { SK_ColorYELLOW, SK_ColorBLUE };
- return SkGradientShader::MakeLinear(
- pts, colors, nullptr, 2, SkShader::kRepeat_TileMode, 0, &SkMatrix::I());
- }
-
- void make_bitmap() {
- fBitmap.allocN32Pixels(fSize.width(), fSize.height());
- SkCanvas canvas(fBitmap);
- canvas.clear(0x00000000);
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setShader(MakeLinear(fSize));
- SkRect r = { 0, 0, SkIntToScalar(fSize.width()), SkIntToScalar(fSize.height()) };
- canvas.drawRect(r, paint);
- }
-
- void makeCubeData() {
- fCubeDimension = 32;
- fCubeData = SkData::MakeUninitialized(sizeof(SkColor) *
- fCubeDimension * fCubeDimension * fCubeDimension);
- SkColor* pixels = (SkColor*)(fCubeData->writable_data());
- SkAutoTMalloc<uint8_t> lutMemory(fCubeDimension);
- uint8_t* lut = lutMemory.get();
- const int maxIndex = fCubeDimension - 1;
- for (int i = 0; i < fCubeDimension; ++i) {
- // Make an invert lut, but the content of
- // the lut shouldn't affect performance.
- lut[i] = ((maxIndex - i) * 255) / maxIndex;
- }
- for (int r = 0; r < fCubeDimension; ++r) {
- for (int g = 0; g < fCubeDimension; ++g) {
- for (int b = 0; b < fCubeDimension; ++b) {
- pixels[(fCubeDimension * ((fCubeDimension * b) + g)) + r] =
- SkColorSetARGB(0xFF, lut[r], lut[g], lut[b]);
- }
- }
- }
- }
-
- void test(int loops, SkCanvas* canvas) {
- SkPaint paint;
- for (int i = 0; i < loops; i++) {
- paint.setColorFilter(SkColorCubeFilter::Make(fCubeData, fCubeDimension));
- canvas->drawBitmap(fBitmap, 0, 0, &paint);
- }
- }
-
- typedef Benchmark INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-DEF_BENCH( return new ColorCubeBench(); )
#include "SkBlurImageFilter.h"
#include "SkBlurMaskFilter.h"
#include "SkCanvas.h"
-#include "SkColorCubeFilter.h"
#include "SkColorFilter.h"
#include "SkColorFilterImageFilter.h"
#include "SkColorMatrixFilter.h"
return filter;
}
- enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
+ enum { ALPHA_THRESHOLD, MERGE, COLOR, BLUR, MAGNIFIER,
BLENDMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
: nullptr;
break;
}
- case LUT3D: {
- int cubeDimension;
- bool a, b, c;
- fuzz->next(&a, &b, &c);
- sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, a, b, c));
- sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(std::move(lut3D), cubeDimension));
- filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
- : nullptr;
- break;
- }
case BLUR: {
SkScalar sX = make_number(true);
SkScalar sY = make_number(true);
+++ /dev/null
-/*
- * Copyright 2014 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "gm.h"
-#include "SkColorCubeFilter.h"
-#include "SkData.h"
-#include "SkGradientShader.h"
-#include "SkTemplates.h"
-
-namespace skiagm {
-
-static sk_sp<SkShader> MakeLinear() {
- constexpr SkPoint pts[2] = {
- { 0, 0 },
- { SkIntToScalar(80), SkIntToScalar(80) }
- };
- constexpr SkColor colors[] = { SK_ColorYELLOW, SK_ColorBLUE };
- return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kRepeat_TileMode, 0,
- &SkMatrix::I());
-}
-
-class ColorCubeGM : public GM {
-public:
- ColorCubeGM() : fInitialized(false) {
- this->setBGColor(0xFF000000);
- }
-
-protected:
- SkString onShortName() override {
- return SkString("colorcube");
- }
-
- void make_3Dluts() {
- make_3Dlut(&f3DLut4, 4, true, false, false);
- make_3Dlut(&f3DLut8, 8, false, true, false);
- make_3Dlut(&f3DLut16, 16, false, true, true);
- make_3Dlut(&f3DLut32, 32, true, true, false);
- make_3Dlut(&f3DLut64, 64, true, false, true);
- }
-
- void make_bitmap() {
- fBitmap.allocN32Pixels(80, 80);
- SkCanvas canvas(fBitmap);
- canvas.clear(0x00000000);
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setShader(MakeLinear());
- canvas.drawRect(SkRect::MakeWH(80, 80), paint);
- }
-
- void make_3Dlut(sk_sp<SkData>* data, int size, bool invR, bool invG, bool invB) {
- *data = SkData::MakeUninitialized(sizeof(SkColor) * size * size * size);
- SkColor* pixels = (SkColor*)((*data)->writable_data());
- SkAutoTMalloc<uint8_t> lutMemory(size);
- SkAutoTMalloc<uint8_t> invLutMemory(size);
- uint8_t* lut = lutMemory.get();
- uint8_t* invLut = invLutMemory.get();
- const int maxIndex = size - 1;
- for (int i = 0; i < size; i++) {
- lut[i] = (i * 255) / maxIndex;
- invLut[i] = ((maxIndex - i) * 255) / maxIndex;
- }
- for (int r = 0; r < size; ++r) {
- for (int g = 0; g < size; ++g) {
- for (int b = 0; b < size; ++b) {
- pixels[(size * ((size * b) + g)) + r] = sk_tool_utils::color_to_565(
- SkColorSetARGB(0xFF,
- invR ? invLut[r] : lut[r],
- invG ? invLut[g] : lut[g],
- invB ? invLut[b] : lut[b]));
- }
- }
- }
- }
-
- SkISize onISize() override {
- return SkISize::Make(500, 100);
- }
-
- void onDraw(SkCanvas* canvas) override {
- if (!fInitialized) {
- this->make_bitmap();
- this->make_3Dluts();
- fInitialized = true;
- }
- canvas->clear(0x00000000);
- SkPaint paint;
- paint.setColorFilter(SkColorCubeFilter::Make(f3DLut4, 4));
- canvas->drawBitmap(fBitmap, 10, 10, &paint);
-
- paint.setColorFilter(SkColorCubeFilter::Make(f3DLut8, 8));
- canvas->drawBitmap(fBitmap, 110, 10, &paint);
-
- paint.setColorFilter(SkColorCubeFilter::Make(f3DLut16, 16));
- canvas->drawBitmap(fBitmap, 210, 10, &paint);
-
- paint.setColorFilter(SkColorCubeFilter::Make(f3DLut32, 32));
- canvas->drawBitmap(fBitmap, 310, 10, &paint);
-
- paint.setColorFilter(SkColorCubeFilter::Make(f3DLut64, 64));
- canvas->drawBitmap(fBitmap, 410, 10, &paint);
- }
-
-private:
- typedef GM INHERITED;
- bool fInitialized;
- SkBitmap fBitmap;
- sk_sp<SkData> f3DLut4;
- sk_sp<SkData> f3DLut8;
- sk_sp<SkData> f3DLut16;
- sk_sp<SkData> f3DLut32;
- sk_sp<SkData> f3DLut64;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-static GM* MyFactory(void*) { return new ColorCubeGM; }
-static GMRegistry reg(MyFactory);
-
-}
"$_bench/CmapBench.cpp",
"$_bench/CodecBench.cpp",
"$_bench/ColorCodecBench.cpp",
- "$_bench/ColorCubeBench.cpp",
"$_bench/ColorFilterBench.cpp",
"$_bench/ColorPrivBench.cpp",
"$_bench/ControlBench.cpp",
"$_src/effects/SkBlurMask.cpp",
"$_src/effects/SkBlurMask.h",
"$_src/effects/SkBlurMaskFilter.cpp",
- "$_src/effects/SkColorCubeFilter.cpp",
"$_src/effects/SkColorFilterImageFilter.cpp",
"$_src/effects/SkColorMatrix.cpp",
"$_src/effects/SkColorMatrixFilter.cpp",
"$_include/effects/SkBlurDrawLooper.h",
"$_include/effects/SkBlurImageFilter.h",
"$_include/effects/SkBlurMaskFilter.h",
- "$_include/effects/SkColorCubeFilter.h",
"$_include/effects/SkColorFilterImageFilter.h",
"$_include/effects/SkColorMatrix.h",
"$_include/effects/SkColorMatrixFilter.h",
"$_gm/clipdrawdraw.cpp",
"$_gm/clippedbitmapshaders.cpp",
"$_gm/color4f.cpp",
- "$_gm/colorcube.cpp",
"$_gm/coloremoji.cpp",
"$_gm/colorfilteralpha8.cpp",
"$_gm/colorfilterimagefilter.cpp",
+++ /dev/null
-/*
- * Copyright 2014 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkColorCubeFilter_DEFINED
-#define SkColorCubeFilter_DEFINED
-
-#include "SkColorFilter.h"
-#include "SkData.h"
-#include "../private/SkOnce.h"
-#include "../private/SkTemplates.h"
-
-class SK_API SkColorCubeFilter : public SkColorFilter {
-public:
- /** cubeData must containt a 3D data in the form of cube of the size:
- * cubeDimension * cubeDimension * cubeDimension * sizeof(SkColor)
- * This cube contains a transform where (x,y,z) maps to the (r,g,b).
- * The alpha components of the colors must be 0xFF.
- */
- static sk_sp<SkColorFilter> Make(sk_sp<SkData> cubeData, int cubeDimension);
-
- void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override;
- uint32_t getFlags() const override;
-
-#if SK_SUPPORT_GPU
- sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*, SkColorSpace*) const override;
-#endif
-
- SK_TO_STRING_OVERRIDE()
- SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorCubeFilter)
-
-protected:
- SkColorCubeFilter(sk_sp<SkData> cubeData, int cubeDimension);
- void flatten(SkWriteBuffer&) const override;
-
-private:
- /** The cache is initialized on-demand when getProcessingLuts is called.
- */
- class ColorCubeProcesingCache {
- public:
- ColorCubeProcesingCache(int cubeDimension);
-
- void getProcessingLuts(const int* (*colorToIndex)[2],
- const SkScalar* (*colorToFactors)[2],
- const SkScalar** colorToScalar);
-
- int cubeDimension() const { return fCubeDimension; }
-
- private:
- // Working pointers. If any of these is NULL,
- // we need to recompute the corresponding cache values.
- int* fColorToIndex[2];
- SkScalar* fColorToFactors[2];
- SkScalar* fColorToScalar;
-
- SkAutoTMalloc<uint8_t> fLutStorage;
-
- const int fCubeDimension;
-
- // Make sure we only initialize the caches once.
- SkOnce fLutsInitOnce;
-
- static void initProcessingLuts(ColorCubeProcesingCache* cache);
- };
-
- sk_sp<SkData> fCubeData;
- int32_t fUniqueID;
-
- mutable ColorCubeProcesingCache fCache;
-
- typedef SkColorFilter INHERITED;
-};
-
-#endif
#include "SkBlurImageFilter.h"
#include "SkBlurMaskFilter.h"
#include "SkCanvas.h"
-#include "SkColorCubeFilter.h"
#include "SkColorFilter.h"
#include "SkColorFilterImageFilter.h"
#include "SkColorMatrixFilter.h"
return filter;
}
- enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
+ enum { ALPHA_THRESHOLD, MERGE, COLOR, BLUR, MAGNIFIER,
XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
: nullptr;
break;
}
- case LUT3D: {
- int cubeDimension;
- sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
- sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(std::move(lut3D), cubeDimension));
- filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
- : nullptr;
- break;
- }
case BLUR:
filter = SkBlurImageFilter::Make(make_scalar(true),
make_scalar(true),
make_image_filter())
: SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0),
make_point(), make_scalar(),
- make_scalar(), make_color(),
+ make_scalar(), make_color(),
make_scalar(), make_scalar(),
SkIntToScalar(R(10)),
make_image_filter());
- [SkGradientShader](http://skia-doc.commondatastorage.googleapis.com/doxygen/doxygen/html/classSkGradientShader.html)
- [SkTransparentShader](http://skia-doc.commondatastorage.googleapis.com/doxygen/doxygen/html/classSkTransparentShader.html)
* [SkColorFilter](http://skia-doc.commondatastorage.googleapis.com/doxygen/doxygen/html/classSkColorFilter.html)
- - [SkColorCubeFilter](http://skia-doc.commondatastorage.googleapis.com/doxygen/doxygen/html/classSkColorCubeFilter.html)
- [SkColorMatrixFilter](http://skia-doc.commondatastorage.googleapis.com/doxygen/doxygen/html/classSkColorMatrixFilter.html)
- [SkLumaColorFilter](http://skia-doc.commondatastorage.googleapis.com/doxygen/doxygen/html/classSkLumaColorFilter.html)
- [SkModeColorFilter](http://skia-doc.commondatastorage.googleapis.com/doxygen/doxygen/html/classSkModeColorFilter.html)
#include "SkBlitRow_opts.h"
#include "SkBlurImageFilter_opts.h"
#include "SkChecksum_opts.h"
-#include "SkColorCubeFilter_opts.h"
#include "SkMorphologyImageFilter_opts.h"
#include "SkRasterPipeline_opts.h"
#include "SkSwizzler_opts.h"
// They'll still get a chance to be replaced with even better ones, e.g. using SSE4.1.
#define DEFINE_DEFAULT(name) decltype(name) name = SK_OPTS_NS::name
DEFINE_DEFAULT(create_xfermode);
- DEFINE_DEFAULT(color_cube_filter_span);
DEFINE_DEFAULT(box_blur_xx);
DEFINE_DEFAULT(box_blur_xy);
extern void (*blit_row_color32)(SkPMColor*, const SkPMColor*, int, SkPMColor);
extern void (*blit_row_s32a_opaque)(SkPMColor*, const SkPMColor*, int, U8CPU);
- // This function is an optimized version of SkColorCubeFilter::filterSpan
- extern void (*color_cube_filter_span)(const SkPMColor[],
- int,
- SkPMColor[],
- const int * [2],
- const SkScalar * [2],
- int,
- const SkColor*);
-
// Swizzle input into some sort of 8888 pixel, {premul,unpremul} x {rgba,bgra}.
typedef void (*Swizzle_8888)(uint32_t*, const void*, int);
extern Swizzle_8888 RGBA_to_BGRA, // i.e. just swap RB
+++ /dev/null
-/*
- * Copyright 2014 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkColorCubeFilter.h"
-#include "SkColorPriv.h"
-#include "SkOnce.h"
-#include "SkOpts.h"
-#include "SkReadBuffer.h"
-#include "SkUnPreMultiply.h"
-#include "SkWriteBuffer.h"
-#if SK_SUPPORT_GPU
-#include "GrContext.h"
-#include "GrCoordTransform.h"
-#include "GrInvariantOutput.h"
-#include "GrTexturePriv.h"
-#include "SkGr.h"
-#include "glsl/GrGLSLFragmentProcessor.h"
-#include "glsl/GrGLSLFragmentShaderBuilder.h"
-#include "glsl/GrGLSLProgramDataManager.h"
-#include "glsl/GrGLSLUniformHandler.h"
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-namespace {
-
-int32_t SkNextColorCubeUniqueID() {
- static int32_t gColorCubeUniqueID;
- // do a loop in case our global wraps around, as we never want to return a 0
- int32_t genID;
- do {
- genID = sk_atomic_inc(&gColorCubeUniqueID) + 1;
- } while (0 == genID);
- return genID;
-}
-
-} // end namespace
-
-static const int MIN_CUBE_SIZE = 4;
-static const int MAX_CUBE_SIZE = 64;
-
-static bool is_valid_3D_lut(SkData* cubeData, int cubeDimension) {
- size_t minMemorySize = sizeof(uint8_t) * 4 * cubeDimension * cubeDimension * cubeDimension;
- return (cubeDimension >= MIN_CUBE_SIZE) && (cubeDimension <= MAX_CUBE_SIZE) &&
- (nullptr != cubeData) && (cubeData->size() >= minMemorySize);
-}
-
-sk_sp<SkColorFilter> SkColorCubeFilter::Make(sk_sp<SkData> cubeData, int cubeDimension) {
- if (!is_valid_3D_lut(cubeData.get(), cubeDimension)) {
- return nullptr;
- }
-
- return sk_sp<SkColorFilter>(new SkColorCubeFilter(std::move(cubeData), cubeDimension));
-}
-
-SkColorCubeFilter::SkColorCubeFilter(sk_sp<SkData> cubeData, int cubeDimension)
- : fCubeData(std::move(cubeData))
- , fUniqueID(SkNextColorCubeUniqueID())
- , fCache(cubeDimension)
-{}
-
-uint32_t SkColorCubeFilter::getFlags() const {
- return this->INHERITED::getFlags() | kAlphaUnchanged_Flag;
-}
-
-SkColorCubeFilter::ColorCubeProcesingCache::ColorCubeProcesingCache(int cubeDimension)
- : fCubeDimension(cubeDimension) {
- fColorToIndex[0] = fColorToIndex[1] = nullptr;
- fColorToFactors[0] = fColorToFactors[1] = nullptr;
- fColorToScalar = nullptr;
-}
-
-void SkColorCubeFilter::ColorCubeProcesingCache::getProcessingLuts(
- const int* (*colorToIndex)[2], const SkScalar* (*colorToFactors)[2],
- const SkScalar** colorToScalar) {
- fLutsInitOnce(SkColorCubeFilter::ColorCubeProcesingCache::initProcessingLuts, this);
-
- SkASSERT((fColorToIndex[0] != nullptr) &&
- (fColorToIndex[1] != nullptr) &&
- (fColorToFactors[0] != nullptr) &&
- (fColorToFactors[1] != nullptr) &&
- (fColorToScalar != nullptr));
- (*colorToIndex)[0] = fColorToIndex[0];
- (*colorToIndex)[1] = fColorToIndex[1];
- (*colorToFactors)[0] = fColorToFactors[0];
- (*colorToFactors)[1] = fColorToFactors[1];
- (*colorToScalar) = fColorToScalar;
-}
-
-void SkColorCubeFilter::ColorCubeProcesingCache::initProcessingLuts(
- SkColorCubeFilter::ColorCubeProcesingCache* cache) {
- static const SkScalar inv8bit = SkScalarInvert(SkIntToScalar(255));
-
- // We need 256 int * 2 for fColorToIndex, so a total of 512 int.
- // We need 256 SkScalar * 2 for fColorToFactors and 256 SkScalar
- // for fColorToScalar, so a total of 768 SkScalar.
- cache->fLutStorage.reset(512 * sizeof(int) + 768 * sizeof(SkScalar));
- uint8_t* storage = cache->fLutStorage.get();
- cache->fColorToIndex[0] = (int*)storage;
- cache->fColorToIndex[1] = cache->fColorToIndex[0] + 256;
- cache->fColorToFactors[0] = (SkScalar*)(storage + (512 * sizeof(int)));
- cache->fColorToFactors[1] = cache->fColorToFactors[0] + 256;
- cache->fColorToScalar = cache->fColorToFactors[1] + 256;
-
- SkScalar size = SkIntToScalar(cache->fCubeDimension);
- SkScalar scale = (size - SK_Scalar1) * inv8bit;
-
- for (int i = 0; i < 256; ++i) {
- SkScalar index = scale * i;
- cache->fColorToIndex[0][i] = SkScalarFloorToInt(index);
- cache->fColorToIndex[1][i] = cache->fColorToIndex[0][i] + 1;
- cache->fColorToScalar[i] = inv8bit * i;
- if (cache->fColorToIndex[1][i] < cache->fCubeDimension) {
- cache->fColorToFactors[1][i] = index - SkIntToScalar(cache->fColorToIndex[0][i]);
- cache->fColorToFactors[0][i] = SK_Scalar1 - cache->fColorToFactors[1][i];
- } else {
- cache->fColorToIndex[1][i] = cache->fColorToIndex[0][i];
- cache->fColorToFactors[0][i] = SK_Scalar1;
- cache->fColorToFactors[1][i] = 0;
- }
- }
-}
-
-void SkColorCubeFilter::filterSpan(const SkPMColor src[], int count, SkPMColor dst[]) const {
- const int* colorToIndex[2];
- const SkScalar* colorToFactors[2];
- const SkScalar* colorToScalar;
- fCache.getProcessingLuts(&colorToIndex, &colorToFactors, &colorToScalar);
-
- SkOpts::color_cube_filter_span(src, count, dst, colorToIndex,
- colorToFactors, fCache.cubeDimension(),
- (const SkColor*)fCubeData->data());
-}
-
-sk_sp<SkFlattenable> SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) {
- int cubeDimension = buffer.readInt();
- auto cubeData(buffer.readByteArrayAsData());
- if (!buffer.validate(is_valid_3D_lut(cubeData.get(), cubeDimension))) {
- return nullptr;
- }
- return Make(std::move(cubeData), cubeDimension);
-}
-
-void SkColorCubeFilter::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
- buffer.writeInt(fCache.cubeDimension());
- buffer.writeDataAsByteArray(fCubeData.get());
-}
-
-#ifndef SK_IGNORE_TO_STRING
-void SkColorCubeFilter::toString(SkString* str) const {
- str->append("SkColorCubeFilter ");
-}
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-#if SK_SUPPORT_GPU
-
-class GrColorCubeEffect : public GrFragmentProcessor {
-public:
- static sk_sp<GrFragmentProcessor> Make(GrTexture* colorCube) {
- return (nullptr != colorCube) ? sk_sp<GrFragmentProcessor>(new GrColorCubeEffect(colorCube))
- : nullptr;
- }
-
- virtual ~GrColorCubeEffect();
-
- const char* name() const override { return "ColorCube"; }
-
- int colorCubeSize() const { return fColorCubeSampler.texture()->width(); }
-
-
- void onComputeInvariantOutput(GrInvariantOutput*) const override;
-
- class GLSLProcessor : public GrGLSLFragmentProcessor {
- public:
- void emitCode(EmitArgs&) override;
-
- static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
-
- protected:
- void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
-
- private:
- GrGLSLProgramDataManager::UniformHandle fColorCubeSizeUni;
- GrGLSLProgramDataManager::UniformHandle fColorCubeInvSizeUni;
-
- typedef GrGLSLFragmentProcessor INHERITED;
- };
-
-private:
- virtual void onGetGLSLProcessorKey(const GrShaderCaps& caps,
- GrProcessorKeyBuilder* b) const override;
-
- GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
-
- bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
-
- GrColorCubeEffect(GrTexture* colorCube);
-
- TextureSampler fColorCubeSampler;
-
- typedef GrFragmentProcessor INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-GrColorCubeEffect::GrColorCubeEffect(GrTexture* colorCube)
- : fColorCubeSampler(colorCube, GrSamplerParams::kBilerp_FilterMode) {
- this->initClassID<GrColorCubeEffect>();
- this->addTextureSampler(&fColorCubeSampler);
-}
-
-GrColorCubeEffect::~GrColorCubeEffect() {
-}
-
-void GrColorCubeEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
- GrProcessorKeyBuilder* b) const {
- GLSLProcessor::GenKey(*this, caps, b);
-}
-
-GrGLSLFragmentProcessor* GrColorCubeEffect::onCreateGLSLInstance() const {
- return new GLSLProcessor;
-}
-
-void GrColorCubeEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void GrColorCubeEffect::GLSLProcessor::emitCode(EmitArgs& args) {
- if (nullptr == args.fInputColor) {
- args.fInputColor = "vec4(1)";
- }
-
- GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
- fColorCubeSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
- "Size");
- const char* colorCubeSizeUni = uniformHandler->getUniformCStr(fColorCubeSizeUni);
- fColorCubeInvSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
- "InvSize");
- const char* colorCubeInvSizeUni = uniformHandler->getUniformCStr(fColorCubeInvSizeUni);
-
- const char* nonZeroAlpha = "nonZeroAlpha";
- const char* unPMColor = "unPMColor";
- const char* cubeIdx = "cubeIdx";
- const char* cCoords1 = "cCoords1";
- const char* cCoords2 = "cCoords2";
-
- // Note: if implemented using texture3D in OpenGL ES older than OpenGL ES 3.0,
- // the shader might need "#extension GL_OES_texture_3D : enable".
-
- GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-
- // Unpremultiply color
- fragBuilder->codeAppendf("\tfloat %s = max(%s.a, 0.00001);\n", nonZeroAlpha, args.fInputColor);
- fragBuilder->codeAppendf("\tvec4 %s = vec4(%s.rgb / %s, %s);\n",
- unPMColor, args.fInputColor, nonZeroAlpha, nonZeroAlpha);
-
- // Fit input color into the cube.
- fragBuilder->codeAppendf(
- "vec3 %s = vec3(%s.rg * vec2((%s - 1.0) * %s) + vec2(0.5 * %s), %s.b * (%s - 1.0));\n",
- cubeIdx, unPMColor, colorCubeSizeUni, colorCubeInvSizeUni, colorCubeInvSizeUni,
- unPMColor, colorCubeSizeUni);
-
- // Compute y coord for for texture fetches.
- fragBuilder->codeAppendf("vec2 %s = vec2(%s.r, (floor(%s.b) + %s.g) * %s);\n",
- cCoords1, cubeIdx, cubeIdx, cubeIdx, colorCubeInvSizeUni);
- fragBuilder->codeAppendf("vec2 %s = vec2(%s.r, (ceil(%s.b) + %s.g) * %s);\n",
- cCoords2, cubeIdx, cubeIdx, cubeIdx, colorCubeInvSizeUni);
-
- // Apply the cube.
- fragBuilder->codeAppendf("%s = vec4(mix(", args.fOutputColor);
- fragBuilder->appendTextureLookup(args.fTexSamplers[0], cCoords1);
- fragBuilder->codeAppend(".bgr, ");
- fragBuilder->appendTextureLookup(args.fTexSamplers[0], cCoords2);
-
- // Premultiply color by alpha. Note that the input alpha is not modified by this shader.
- fragBuilder->codeAppendf(".bgr, fract(%s.b)) * vec3(%s), %s.a);\n",
- cubeIdx, nonZeroAlpha, args.fInputColor);
-}
-
-void GrColorCubeEffect::GLSLProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
- const GrProcessor& proc) {
- const GrColorCubeEffect& colorCube = proc.cast<GrColorCubeEffect>();
- SkScalar size = SkIntToScalar(colorCube.colorCubeSize());
- pdman.set1f(fColorCubeSizeUni, SkScalarToFloat(size));
- pdman.set1f(fColorCubeInvSizeUni, SkScalarToFloat(SkScalarInvert(size)));
-}
-
-void GrColorCubeEffect::GLSLProcessor::GenKey(const GrProcessor& proc,
- const GrShaderCaps&, GrProcessorKeyBuilder* b) {
-}
-
-sk_sp<GrFragmentProcessor> SkColorCubeFilter::asFragmentProcessor(GrContext* context,
- SkColorSpace*) const {
- static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
- GrUniqueKey key;
- GrUniqueKey::Builder builder(&key, kDomain, 2);
- builder[0] = fUniqueID;
- builder[1] = fCache.cubeDimension();
- builder.finish();
-
- GrSurfaceDesc desc;
- desc.fWidth = fCache.cubeDimension();
- desc.fHeight = fCache.cubeDimension() * fCache.cubeDimension();
- desc.fConfig = kRGBA_8888_GrPixelConfig;
- desc.fIsMipMapped = false;
-
- sk_sp<GrTexture> textureCube(context->textureProvider()->findAndRefTextureByUniqueKey(key));
- if (!textureCube) {
- textureCube.reset(context->textureProvider()->createTexture(
- desc, SkBudgeted::kYes, fCubeData->data(), 0));
- if (textureCube) {
- context->textureProvider()->assignUniqueKeyToTexture(key, textureCube.get());
- } else {
- return nullptr;
- }
- }
-
- return sk_sp<GrFragmentProcessor>(GrColorCubeEffect::Make(textureCube.get()));
-}
-#endif
+++ /dev/null
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef SkColorCubeFilter_opts_DEFINED
-#define SkColorCubeFilter_opts_DEFINED
-
-#include "SkColor.h"
-#include "SkNx.h"
-#include "SkUnPreMultiply.h"
-
-namespace SK_OPTS_NS {
-
-static void color_cube_filter_span(const SkPMColor src[],
- int count,
- SkPMColor dst[],
- const int* colorToIndex[2],
- const SkScalar* colorToFactors[2],
- int dim,
- const SkColor* colorCube) {
- uint8_t r, g, b, a;
-
- for (int i = 0; i < count; ++i) {
- const SkPMColor input = src[i];
- a = input >> SK_A32_SHIFT;
-
- if (a != 255) {
- const SkColor source = SkUnPreMultiply::PMColorToColor(input);
- r = SkColorGetR(source);
- g = SkColorGetG(source);
- b = SkColorGetB(source);
- } else {
- r = SkGetPackedR32(input);
- g = SkGetPackedG32(input);
- b = SkGetPackedB32(input);
- }
-
- const SkScalar g0 = colorToFactors[0][g],
- g1 = colorToFactors[1][g],
- b0 = colorToFactors[0][b],
- b1 = colorToFactors[1][b];
-
- const Sk4f g0b0(g0*b0),
- g0b1(g0*b1),
- g1b0(g1*b0),
- g1b1(g1*b1);
-
- const int i00 = (colorToIndex[0][g] + colorToIndex[0][b] * dim) * dim;
- const int i01 = (colorToIndex[0][g] + colorToIndex[1][b] * dim) * dim;
- const int i10 = (colorToIndex[1][g] + colorToIndex[0][b] * dim) * dim;
- const int i11 = (colorToIndex[1][g] + colorToIndex[1][b] * dim) * dim;
-
- Sk4f color(0.5f); // Starting from 0.5f gets us rounding for free.
- for (int x = 0; x < 2; ++x) {
- const int ix = colorToIndex[x][r];
-
- const SkColor lutColor00 = colorCube[ix + i00];
- const SkColor lutColor01 = colorCube[ix + i01];
- const SkColor lutColor10 = colorCube[ix + i10];
- const SkColor lutColor11 = colorCube[ix + i11];
-
- Sk4f sum = SkNx_cast<float>(Sk4b::Load(&lutColor00)) * g0b0;
- sum = sum + SkNx_cast<float>(Sk4b::Load(&lutColor01)) * g0b1;
- sum = sum + SkNx_cast<float>(Sk4b::Load(&lutColor10)) * g1b0;
- sum = sum + SkNx_cast<float>(Sk4b::Load(&lutColor11)) * g1b1;
- color = color + sum * Sk4f((float)colorToFactors[x][r]);
- }
- if (a != 255) {
- color = color * Sk4f(a * (1.0f/255));
- }
-
- // color is BGRA (SkColor order), dst is SkPMColor order, so may need to swap R+B.
- #if defined(SK_PMCOLOR_IS_RGBA)
- color = SkNx_shuffle<2,1,0,3>(color);
- #endif
- uint8_t* dstBytes = (uint8_t*)(dst+i);
- SkNx_cast<uint8_t>(color).store(dstBytes);
- dstBytes[SK_A32_SHIFT/8] = a;
- }
-}
-
-} // namespace SK_OPTS NS
-
-#endif // SkColorCubeFilter_opts_DEFINED
#include "SkOpts.h"
#define SK_OPTS_NS ssse3
#include "SkBlitMask_opts.h"
-#include "SkColorCubeFilter_opts.h"
#include "SkSwizzler_opts.h"
#include "SkXfermode_opts.h"
void Init_ssse3() {
create_xfermode = ssse3::create_xfermode;
blit_mask_d32_a8 = ssse3::blit_mask_d32_a8;
- color_cube_filter_span = ssse3::color_cube_filter_span;
RGBA_to_BGRA = ssse3::RGBA_to_BGRA;
RGBA_to_rgbA = ssse3::RGBA_to_rgbA;
#include "SkBlurDrawLooper.h"
#include "SkBlurImageFilter.h"
#include "SkBlurMaskFilter.h"
-#include "SkColorCubeFilter.h"
#include "SkColorFilterImageFilter.h"
#include "SkColorMatrixFilterRowMajor255.h"
#include "SkComposeImageFilter.h"
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLayerRasterizer)
// ColorFilter
- SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkColorCubeFilter)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkColorMatrixFilterRowMajor255)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLumaColorFilter)
SkAlphaThresholdFilter::InitializeFlattenables();
projects / platform / upstream / libSkiaSharp.git / commitdiff