Home | History | Annotate | Download | only in effects 
      1 /*
      2  * Copyright 2013 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "SkLumaColorFilter.h"
      9 #include "SkPM4f.h"
     10 #include "SkColorPriv.h"
     11 #include "SkRasterPipeline.h"
     12 #include "SkString.h"
     13 
     14 #if SK_SUPPORT_GPU
     15 #include "GrContext.h"
     16 #include "glsl/GrGLSLFragmentProcessor.h"
     17 #include "glsl/GrGLSLFragmentShaderBuilder.h"
     18 #endif
     19 
     20 void SkLumaColorFilter::onAppendStages(SkRasterPipeline* p,
     21                                        SkColorSpace* dst,
     22                                        SkArenaAlloc* scratch,
     23                                        bool shaderIsOpaque) const {
     24     p->append(SkRasterPipeline::luminance_to_alpha);
     25 }
     26 
     27 sk_sp<SkColorFilter> SkLumaColorFilter::Make() {
     28     return sk_sp<SkColorFilter>(new SkLumaColorFilter);
     29 }
     30 
     31 SkLumaColorFilter::SkLumaColorFilter() : INHERITED() {}
     32 
     33 sk_sp<SkFlattenable> SkLumaColorFilter::CreateProc(SkReadBuffer&) {
     34     return Make();
     35 }
     36 
     37 void SkLumaColorFilter::flatten(SkWriteBuffer&) const {}
     38 
     39 #ifndef SK_IGNORE_TO_STRING
     40 void SkLumaColorFilter::toString(SkString* str) const {
     41     str->append("SkLumaColorFilter ");
     42 }
     43 #endif
     44 
     45 #if SK_SUPPORT_GPU
     46 class LumaColorFilterEffect : public GrFragmentProcessor {
     47 public:
     48     static sk_sp<GrFragmentProcessor> Make() {
     49         return sk_sp<GrFragmentProcessor>(new LumaColorFilterEffect);
     50     }
     51 
     52     const char* name() const override { return "Luminance-to-Alpha"; }
     53 
     54     class GLSLProcessor : public GrGLSLFragmentProcessor {
     55     public:
     56         static void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*) {}
     57 
     58         void emitCode(EmitArgs& args) override {
     59             if (nullptr == args.fInputColor) {
     60                 args.fInputColor = "vec4(1)";
     61             }
     62 
     63             GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
     64             fragBuilder->codeAppendf("\tfloat luma = dot(vec3(%f, %f, %f), %s.rgb);\n",
     65                                      SK_ITU_BT709_LUM_COEFF_R,
     66                                      SK_ITU_BT709_LUM_COEFF_G,
     67                                      SK_ITU_BT709_LUM_COEFF_B,
     68                                      args.fInputColor);
     69             fragBuilder->codeAppendf("\t%s = vec4(0, 0, 0, luma);\n",
     70                                      args.fOutputColor);
     71 
     72         }
     73 
     74     private:
     75         typedef GrGLSLFragmentProcessor INHERITED;
     76     };
     77 
     78 private:
     79     LumaColorFilterEffect() : INHERITED(kConstantOutputForConstantInput_OptimizationFlag) {
     80         this->initClassID<LumaColorFilterEffect>();
     81     }
     82 
     83     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
     84         return new GLSLProcessor;
     85     }
     86 
     87     virtual void onGetGLSLProcessorKey(const GrShaderCaps& caps,
     88                                        GrProcessorKeyBuilder* b) const override {
     89         GLSLProcessor::GenKey(*this, caps, b);
     90     }
     91 
     92     bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
     93 
     94     GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
     95         float luma = SK_ITU_BT709_LUM_COEFF_R * input.fRGBA[0] +
     96                      SK_ITU_BT709_LUM_COEFF_G * input.fRGBA[1] +
     97                      SK_ITU_BT709_LUM_COEFF_B * input.fRGBA[2];
     98         return GrColor4f(0, 0, 0, luma);
     99     }
    100 
    101     typedef GrFragmentProcessor INHERITED;
    102 };
    103 
    104 sk_sp<GrFragmentProcessor> SkLumaColorFilter::asFragmentProcessor(GrContext*, SkColorSpace*) const {
    105     return LumaColorFilterEffect::Make();
    106 }
    107 #endif
    108