src/third_party/skia/src/effects/gradients/SkSweepGradient.cpp

   1
   2 /*
   3  * Copyright 2012 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 #include "SkSweepGradient.h"
  10
  11 SkSweepGradient::SkSweepGradient(SkScalar cx, SkScalar cy, const Descriptor& desc)
  12     : SkGradientShaderBase(desc)
  13     , fCenter(SkPoint::Make(cx, cy))
  14 {
  15     fPtsToUnit.setTranslate(-cx, -cy);
  16
  17     // overwrite the tilemode to a canonical value (since sweep ignores it)
  18     fTileMode = SkShader::kClamp_TileMode;
  19 }
  20
  21 SkShader::BitmapType SkSweepGradient::asABitmap(SkBitmap* bitmap,
  22     SkMatrix* matrix, SkShader::TileMode* xy) const {
  23     if (bitmap) {
  24         this->getGradientTableBitmap(bitmap);
  25     }
  26     if (matrix) {
  27         *matrix = fPtsToUnit;
  28     }
  29     if (xy) {
  30         xy[0] = fTileMode;
  31         xy[1] = kClamp_TileMode;
  32     }
  33     return kSweep_BitmapType;
  34 }
  35
  36 SkShader::GradientType SkSweepGradient::asAGradient(GradientInfo* info) const {
  37     if (info) {
  38         commonAsAGradient(info);
  39         info->fPoint[0] = fCenter;
  40     }
  41     return kSweep_GradientType;
  42 }
  43
  44 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
  45 SkSweepGradient::SkSweepGradient(SkReadBuffer& buffer)
  46     : INHERITED(buffer),
  47       fCenter(buffer.readPoint()) {
  48 }
  49 #endif
  50
  51 SkFlattenable* SkSweepGradient::CreateProc(SkReadBuffer& buffer) {
  52     DescriptorScope desc;
  53     if (!desc.unflatten(buffer)) {
  54         return NULL;
  55     }
  56     const SkPoint center = buffer.readPoint();
  57     return SkGradientShader::CreateSweep(center.x(), center.y(), desc.fColors, desc.fPos,
  58                                          desc.fCount, desc.fGradFlags, desc.fLocalMatrix);
  59 }
  60
  61 void SkSweepGradient::flatten(SkWriteBuffer& buffer) const {
  62     this->INHERITED::flatten(buffer);
  63     buffer.writePoint(fCenter);
  64 }
  65
  66 size_t SkSweepGradient::contextSize() const {
  67     return sizeof(SweepGradientContext);
  68 }
  69
  70 SkShader::Context* SkSweepGradient::onCreateContext(const ContextRec& rec, void* storage) const {
  71     return SkNEW_PLACEMENT_ARGS(storage, SweepGradientContext, (*this, rec));
  72 }
  73
  74 SkSweepGradient::SweepGradientContext::SweepGradientContext(
  75         const SkSweepGradient& shader, const ContextRec& rec)
  76     : INHERITED(shader, rec) {}
  77
  78 //  returns angle in a circle [0..2PI) -> [0..255]
  79 static unsigned SkATan2_255(float y, float x) {
  80     //    static const float g255Over2PI = 255 / (2 * SK_ScalarPI);
  81     static const float g255Over2PI = 40.584510488433314f;
  82
  83     float result = sk_float_atan2(y, x);
  84     if (result < 0) {
  85         result += 2 * SK_ScalarPI;
  86     }
  87     SkASSERT(result >= 0);
  88     // since our value is always >= 0, we can cast to int, which is faster than
  89     // calling floorf()
  90     int ir = (int)(result * g255Over2PI);
  91     SkASSERT(ir >= 0 && ir <= 255);
  92     return ir;
  93 }
  94
  95 void SkSweepGradient::SweepGradientContext::shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC,
  96                                                       int count) {
  97     SkMatrix::MapXYProc proc = fDstToIndexProc;
  98     const SkMatrix&     matrix = fDstToIndex;
  99     const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
 100     int                 toggle = init_dither_toggle(x, y);
 101     SkPoint             srcPt;
 102
 103     if (fDstToIndexClass != kPerspective_MatrixClass) {
 104         proc(matrix, SkIntToScalar(x) + SK_ScalarHalf,
 105                      SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
 106         SkScalar dx, fx = srcPt.fX;
 107         SkScalar dy, fy = srcPt.fY;
 108
 109         if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
 110             SkFixed storage[2];
 111             (void)matrix.fixedStepInX(SkIntToScalar(y) + SK_ScalarHalf,
 112                                       &storage[0], &storage[1]);
 113             dx = SkFixedToScalar(storage[0]);
 114             dy = SkFixedToScalar(storage[1]);
 115         } else {
 116             SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
 117             dx = matrix.getScaleX();
 118             dy = matrix.getSkewY();
 119         }
 120
 121         for (; count > 0; --count) {
 122             *dstC++ = cache[toggle + SkATan2_255(fy, fx)];
 123             fx += dx;
 124             fy += dy;
 125             toggle = next_dither_toggle(toggle);
 126         }
 127     } else {  // perspective case
 128         for (int stop = x + count; x < stop; x++) {
 129             proc(matrix, SkIntToScalar(x) + SK_ScalarHalf,
 130                          SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
 131             *dstC++ = cache[toggle + SkATan2_255(srcPt.fY, srcPt.fX)];
 132             toggle = next_dither_toggle(toggle);
 133         }
 134     }
 135 }
 136
 137 void SkSweepGradient::SweepGradientContext::shadeSpan16(int x, int y, uint16_t* SK_RESTRICT dstC,
 138                                                         int count) {
 139     SkMatrix::MapXYProc proc = fDstToIndexProc;
 140     const SkMatrix&     matrix = fDstToIndex;
 141     const uint16_t* SK_RESTRICT cache = fCache->getCache16();
 142     int                 toggle = init_dither_toggle16(x, y);
 143     SkPoint             srcPt;
 144
 145     if (fDstToIndexClass != kPerspective_MatrixClass) {
 146         proc(matrix, SkIntToScalar(x) + SK_ScalarHalf,
 147                      SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
 148         SkScalar dx, fx = srcPt.fX;
 149         SkScalar dy, fy = srcPt.fY;
 150
 151         if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
 152             SkFixed storage[2];
 153             (void)matrix.fixedStepInX(SkIntToScalar(y) + SK_ScalarHalf,
 154                                       &storage[0], &storage[1]);
 155             dx = SkFixedToScalar(storage[0]);
 156             dy = SkFixedToScalar(storage[1]);
 157         } else {
 158             SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
 159             dx = matrix.getScaleX();
 160             dy = matrix.getSkewY();
 161         }
 162
 163         for (; count > 0; --count) {
 164             int index = SkATan2_255(fy, fx) >> (8 - kCache16Bits);
 165             *dstC++ = cache[toggle + index];
 166             toggle = next_dither_toggle16(toggle);
 167             fx += dx;
 168             fy += dy;
 169         }
 170     } else {  // perspective case
 171         for (int stop = x + count; x < stop; x++) {
 172             proc(matrix, SkIntToScalar(x) + SK_ScalarHalf,
 173                          SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
 174
 175             int index = SkATan2_255(srcPt.fY, srcPt.fX);
 176             index >>= (8 - kCache16Bits);
 177             *dstC++ = cache[toggle + index];
 178             toggle = next_dither_toggle16(toggle);
 179         }
 180     }
 181 }
 182
 183 /////////////////////////////////////////////////////////////////////
 184
 185 #if SK_SUPPORT_GPU
 186
 187 #include "GrTBackendProcessorFactory.h"
 188 #include "gl/builders/GrGLProgramBuilder.h"
 189 #include "SkGr.h"
 190
 191 class GrGLSweepGradient : public GrGLGradientEffect {
 192 public:
 193
 194     GrGLSweepGradient(const GrBackendProcessorFactory& factory,
 195                       const GrProcessor&) : INHERITED (factory) { }
 196     virtual ~GrGLSweepGradient() { }
 197
 198     virtual void emitCode(GrGLFPBuilder*,
 199                           const GrFragmentProcessor&,
 200                           const GrProcessorKey&,
 201                           const char* outputColor,
 202                           const char* inputColor,
 203                           const TransformedCoordsArray&,
 204                           const TextureSamplerArray&) SK_OVERRIDE;
 205
 206     static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcessorKeyBuilder* b) {
 207         b->add32(GenBaseGradientKey(processor));
 208     }
 209
 210 private:
 211
 212     typedef GrGLGradientEffect INHERITED;
 213
 214 };
 215
 216 /////////////////////////////////////////////////////////////////////
 217
 218 class GrSweepGradient : public GrGradientEffect {
 219 public:
 220     static GrFragmentProcessor* Create(GrContext* ctx, const SkSweepGradient& shader,
 221                                        const SkMatrix& m) {
 222         return SkNEW_ARGS(GrSweepGradient, (ctx, shader, m));
 223     }
 224     virtual ~GrSweepGradient() { }
 225
 226     static const char* Name() { return "Sweep Gradient"; }
 227     virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
 228         return GrTBackendFragmentProcessorFactory<GrSweepGradient>::getInstance();
 229     }
 230
 231     typedef GrGLSweepGradient GLProcessor;
 232
 233 private:
 234     GrSweepGradient(GrContext* ctx,
 235                     const SkSweepGradient& shader,
 236                     const SkMatrix& matrix)
 237     : INHERITED(ctx, shader, matrix, SkShader::kClamp_TileMode) { }
 238     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 239
 240     typedef GrGradientEffect INHERITED;
 241 };
 242
 243 /////////////////////////////////////////////////////////////////////
 244
 245 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSweepGradient);
 246
 247 GrFragmentProcessor* GrSweepGradient::TestCreate(SkRandom* random,
 248                                                  GrContext* context,
 249                                                  const GrDrawTargetCaps&,
 250                                                  GrTexture**) {
 251     SkPoint center = {random->nextUScalar1(), random->nextUScalar1()};
 252
 253     SkColor colors[kMaxRandomGradientColors];
 254     SkScalar stopsArray[kMaxRandomGradientColors];
 255     SkScalar* stops = stopsArray;
 256     SkShader::TileMode tmIgnored;
 257     int colorCount = RandomGradientParams(random, colors, &stops, &tmIgnored);
 258     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateSweep(center.fX, center.fY,
 259                                                                 colors, stops, colorCount));
 260     SkPaint paint;
 261     GrFragmentProcessor* fp;
 262     GrColor paintColor;
 263     SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));
 264     return fp;
 265 }
 266
 267 /////////////////////////////////////////////////////////////////////
 268
 269 void GrGLSweepGradient::emitCode(GrGLFPBuilder* builder,
 270                                  const GrFragmentProcessor&,
 271                                  const GrProcessorKey& key,
 272                                  const char* outputColor,
 273                                  const char* inputColor,
 274                                  const TransformedCoordsArray& coords,
 275                                  const TextureSamplerArray& samplers) {
 276     uint32_t baseKey = key.get32(0);
 277     this->emitUniforms(builder, baseKey);
 278     SkString coords2D = builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0);
 279     const GrGLContextInfo ctxInfo = builder->ctxInfo();
 280     SkString t;
 281     // 0.1591549430918 is 1/(2*pi), used since atan returns values [-pi, pi]
 282     // On Intel GPU there is an issue where it reads the second arguement to atan "- %s.x" as an int
 283     // thus must us -1.0 * %s.x to work correctly
 284     if (kIntel_GrGLVendor != ctxInfo.vendor()){
 285         t.printf("atan(- %s.y, - %s.x) * 0.1591549430918 + 0.5",
 286                  coords2D.c_str(), coords2D.c_str());
 287     } else {
 288         t.printf("atan(- %s.y, -1.0 * %s.x) * 0.1591549430918 + 0.5",
 289                  coords2D.c_str(), coords2D.c_str());
 290     }
 291     this->emitColor(builder, t.c_str(), baseKey, outputColor, inputColor, samplers);
 292 }
 293
 294 /////////////////////////////////////////////////////////////////////
 295
 296 bool SkSweepGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
 297                                           const SkMatrix* localMatrix, GrColor* paintColor,
 298                                           GrFragmentProcessor** effect)  const {
 299
 300     SkMatrix matrix;
 301     if (!this->getLocalMatrix().invert(&matrix)) {
 302         return false;
 303     }
 304     if (localMatrix) {
 305         SkMatrix inv;
 306         if (!localMatrix->invert(&inv)) {
 307             return false;
 308         }
 309         matrix.postConcat(inv);
 310     }
 311     matrix.postConcat(fPtsToUnit);
 312
 313     *effect = GrSweepGradient::Create(context, *this, matrix);
 314     *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
 315
 316     return true;
 317 }
 318
 319 #else
 320
 321 bool SkSweepGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix*, GrColor*,
 322                                           GrFragmentProcessor**)  const {
 323     SkDEBUGFAIL("Should not call in GPU-less build");
 324     return false;
 325 }
 326
 327 #endif
 328
 329 #ifndef SK_IGNORE_TO_STRING
 330 void SkSweepGradient::toString(SkString* str) const {
 331     str->append("SkSweepGradient: (");
 332
 333     str->append("center: (");
 334     str->appendScalar(fCenter.fX);
 335     str->append(", ");
 336     str->appendScalar(fCenter.fY);
 337     str->append(") ");
 338
 339     this->INHERITED::toString(str);
 340
 341     str->append(")");
 342 }
 343 #endif