OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2006 The Android Open Source Project | 3 * Copyright 2006 The Android Open Source Project |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 | 9 |
10 #include "SkXfermode.h" | 10 #include "SkXfermode.h" |
(...skipping 658 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
669 /////////////////////////////////////////////////////////////////////////////// | 669 /////////////////////////////////////////////////////////////////////////////// |
670 | 670 |
671 bool SkXfermode::asCoeff(Coeff* src, Coeff* dst) const { | 671 bool SkXfermode::asCoeff(Coeff* src, Coeff* dst) const { |
672 return false; | 672 return false; |
673 } | 673 } |
674 | 674 |
675 bool SkXfermode::asMode(Mode* mode) const { | 675 bool SkXfermode::asMode(Mode* mode) const { |
676 return false; | 676 return false; |
677 } | 677 } |
678 | 678 |
679 bool SkXfermode::asNewEffect(GrEffect** effect, GrTexture* background) const { | 679 bool SkXfermode::asFragmentProcessor(GrFragmentProcessor**, GrTexture*) const { |
680 return false; | 680 return false; |
681 } | 681 } |
682 | 682 |
683 bool SkXfermode::AsNewEffectOrCoeff(SkXfermode* xfermode, | 683 bool SkXfermode::asFragmentProcessorOrCoeff(SkXfermode* xfermode, GrFragmentProc
essor** fp, |
684 GrEffect** effect, | 684 Coeff* src, Coeff* dst, GrTexture* b
ackground) { |
685 Coeff* src, | |
686 Coeff* dst, | |
687 GrTexture* background) { | |
688 if (NULL == xfermode) { | 685 if (NULL == xfermode) { |
689 return ModeAsCoeff(kSrcOver_Mode, src, dst); | 686 return ModeAsCoeff(kSrcOver_Mode, src, dst); |
690 } else if (xfermode->asCoeff(src, dst)) { | 687 } else if (xfermode->asCoeff(src, dst)) { |
691 return true; | 688 return true; |
692 } else { | 689 } else { |
693 return xfermode->asNewEffect(effect, background); | 690 return xfermode->asFragmentProcessor(fp, background); |
694 } | 691 } |
695 } | 692 } |
696 | 693 |
697 SkPMColor SkXfermode::xferColor(SkPMColor src, SkPMColor dst) const{ | 694 SkPMColor SkXfermode::xferColor(SkPMColor src, SkPMColor dst) const{ |
698 // no-op. subclasses should override this | 695 // no-op. subclasses should override this |
699 return dst; | 696 return dst; |
700 } | 697 } |
701 | 698 |
702 void SkXfermode::xfer32(SkPMColor* SK_RESTRICT dst, | 699 void SkXfermode::xfer32(SkPMColor* SK_RESTRICT dst, |
703 const SkPMColor* SK_RESTRICT src, int count, | 700 const SkPMColor* SK_RESTRICT src, int count, |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
771 dst[i] = SkToU8(A); | 768 dst[i] = SkToU8(A); |
772 } | 769 } |
773 } | 770 } |
774 } | 771 } |
775 } | 772 } |
776 | 773 |
777 ////////////////////////////////////////////////////////////////////////////// | 774 ////////////////////////////////////////////////////////////////////////////// |
778 | 775 |
779 #if SK_SUPPORT_GPU | 776 #if SK_SUPPORT_GPU |
780 | 777 |
781 #include "GrEffect.h" | 778 #include "GrProcessor.h" |
782 #include "GrCoordTransform.h" | 779 #include "GrCoordTransform.h" |
783 #include "GrEffectUnitTest.h" | 780 #include "GrProcessorUnitTest.h" |
784 #include "GrTBackendEffectFactory.h" | 781 #include "GrTBackendProcessorFactory.h" |
785 #include "gl/GrGLEffect.h" | 782 #include "gl/GrGLProcessor.h" |
786 #include "gl/builders/GrGLProgramBuilder.h" | 783 #include "gl/builders/GrGLProgramBuilder.h" |
787 | 784 |
788 /** | 785 /** |
789 * GrEffect that implements the all the separable xfer modes that cannot be expr
essed as Coeffs. | 786 * GrProcessor that implements the all the separable xfer modes that cannot be e
xpressed as Coeffs. |
790 */ | 787 */ |
791 class XferEffect : public GrEffect { | 788 class XferEffect : public GrFragmentProcessor { |
792 public: | 789 public: |
793 static bool IsSupportedMode(SkXfermode::Mode mode) { | 790 static bool IsSupportedMode(SkXfermode::Mode mode) { |
794 return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMod
e; | 791 return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMod
e; |
795 } | 792 } |
796 | 793 |
797 static GrEffect* Create(SkXfermode::Mode mode, GrTexture* background) { | 794 static GrFragmentProcessor* Create(SkXfermode::Mode mode, GrTexture* backgro
und) { |
798 if (!IsSupportedMode(mode)) { | 795 if (!IsSupportedMode(mode)) { |
799 return NULL; | 796 return NULL; |
800 } else { | 797 } else { |
801 return SkNEW_ARGS(XferEffect, (mode, background)); | 798 return SkNEW_ARGS(XferEffect, (mode, background)); |
802 } | 799 } |
803 } | 800 } |
804 | 801 |
805 virtual void getConstantColorComponents(GrColor* color, | 802 virtual void getConstantColorComponents(GrColor* color, |
806 uint32_t* validFlags) const SK_OVERR
IDE { | 803 uint32_t* validFlags) const SK_OVERR
IDE { |
807 *validFlags = 0; | 804 *validFlags = 0; |
808 } | 805 } |
809 | 806 |
810 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { | 807 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE { |
811 return GrTBackendEffectFactory<XferEffect>::getInstance(); | 808 return GrTBackendFragmentProcessorFactory<XferEffect>::getInstance(); |
812 } | 809 } |
813 | 810 |
814 static const char* Name() { return "XferEffect"; } | 811 static const char* Name() { return "XferEffect"; } |
815 | 812 |
816 SkXfermode::Mode mode() const { return fMode; } | 813 SkXfermode::Mode mode() const { return fMode; } |
817 const GrTextureAccess& backgroundAccess() const { return fBackgroundAccess;
} | 814 const GrTextureAccess& backgroundAccess() const { return fBackgroundAccess;
} |
818 | 815 |
819 class GLEffect : public GrGLEffect { | 816 class GLProcessor : public GrGLFragmentProcessor { |
820 public: | 817 public: |
821 GLEffect(const GrBackendEffectFactory& factory, const GrEffect&) | 818 GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&
) |
822 : GrGLEffect(factory) { | 819 : INHERITED(factory) { |
823 } | 820 } |
824 virtual void emitCode(GrGLProgramBuilder* builder, | 821 virtual void emitCode(GrGLProgramBuilder* builder, |
825 const GrEffect& effect, | 822 const GrFragmentProcessor& fp, |
826 const GrEffectKey& key, | 823 const GrProcessorKey& key, |
827 const char* outputColor, | 824 const char* outputColor, |
828 const char* inputColor, | 825 const char* inputColor, |
829 const TransformedCoordsArray& coords, | 826 const TransformedCoordsArray& coords, |
830 const TextureSamplerArray& samplers) SK_OVERRIDE { | 827 const TextureSamplerArray& samplers) SK_OVERRIDE { |
831 SkXfermode::Mode mode = effect.cast<XferEffect>().mode(); | 828 SkXfermode::Mode mode = fp.cast<XferEffect>().mode(); |
832 const GrTexture* backgroundTex = | 829 const GrTexture* backgroundTex = |
833 effect.cast<XferEffect>().backgroundAccess().getTexture(); | 830 fp.cast<XferEffect>().backgroundAccess().getTexture(); |
834 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBui
lder(); | 831 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBui
lder(); |
835 const char* dstColor; | 832 const char* dstColor; |
836 if (backgroundTex) { | 833 if (backgroundTex) { |
837 dstColor = "bgColor"; | 834 dstColor = "bgColor"; |
838 fsBuilder->codeAppendf("\t\tvec4 %s = ", dstColor); | 835 fsBuilder->codeAppendf("\t\tvec4 %s = ", dstColor); |
839 fsBuilder->appendTextureLookup(samplers[0], coords[0].c_str(), c
oords[0].getType()); | 836 fsBuilder->appendTextureLookup(samplers[0], coords[0].c_str(), c
oords[0].getType()); |
840 fsBuilder->codeAppendf(";\n"); | 837 fsBuilder->codeAppendf(";\n"); |
841 } else { | 838 } else { |
842 dstColor = fsBuilder->dstColor(); | 839 dstColor = fsBuilder->dstColor(); |
843 } | 840 } |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
964 fsBuilder->codeAppendf("\t\t%s.rgb += (1.0 - %s.a) * %s.rgb
+ (1.0 - %s.a) * %s.rgb;\n", | 961 fsBuilder->codeAppendf("\t\t%s.rgb += (1.0 - %s.a) * %s.rgb
+ (1.0 - %s.a) * %s.rgb;\n", |
965 outputColor, inputColor, dstColor, ds
tColor, inputColor); | 962 outputColor, inputColor, dstColor, ds
tColor, inputColor); |
966 break; | 963 break; |
967 } | 964 } |
968 default: | 965 default: |
969 SkFAIL("Unknown XferEffect mode."); | 966 SkFAIL("Unknown XferEffect mode."); |
970 break; | 967 break; |
971 } | 968 } |
972 } | 969 } |
973 | 970 |
974 static inline void GenKey(const GrEffect& effect, const GrGLCaps&, | 971 static inline void GenKey(const GrProcessor& proc, const GrGLCaps&, |
975 GrEffectKeyBuilder* b) { | 972 GrProcessorKeyBuilder* b) { |
976 // The background may come from the dst or from a texture. | 973 // The background may come from the dst or from a texture. |
977 uint32_t key = effect.numTextures(); | 974 uint32_t key = proc.numTextures(); |
978 SkASSERT(key <= 1); | 975 SkASSERT(key <= 1); |
979 key |= effect.cast<XferEffect>().mode() << 1; | 976 key |= proc.cast<XferEffect>().mode() << 1; |
980 b->add32(key); | 977 b->add32(key); |
981 } | 978 } |
982 | 979 |
983 private: | 980 private: |
984 static void HardLight(GrGLFragmentShaderBuilder* fsBuilder, | 981 static void HardLight(GrGLFragmentShaderBuilder* fsBuilder, |
985 const char* final, | 982 const char* final, |
986 const char* src, | 983 const char* src, |
987 const char* dst) { | 984 const char* dst) { |
988 static const char kComponents[] = {'r', 'g', 'b'}; | 985 static const char kComponents[] = {'r', 'g', 'b'}; |
989 for (size_t i = 0; i < SK_ARRAY_COUNT(kComponents); ++i) { | 986 for (size_t i = 0; i < SK_ARRAY_COUNT(kComponents); ++i) { |
(...skipping 200 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1190 getFunction.c_str(), helpFunc, helpFunc, helpFunc
, helpFunc, | 1187 getFunction.c_str(), helpFunc, helpFunc, helpFunc
, helpFunc, |
1191 helpFunc, helpFunc); | 1188 helpFunc, helpFunc); |
1192 fsBuilder->emitFunction(kVec3f_GrSLType, | 1189 fsBuilder->emitFunction(kVec3f_GrSLType, |
1193 "set_saturation", | 1190 "set_saturation", |
1194 SK_ARRAY_COUNT(setSatArgs), setSatArgs, | 1191 SK_ARRAY_COUNT(setSatArgs), setSatArgs, |
1195 setSatBody.c_str(), | 1192 setSatBody.c_str(), |
1196 setSatFunction); | 1193 setSatFunction); |
1197 | 1194 |
1198 } | 1195 } |
1199 | 1196 |
1200 typedef GrGLEffect INHERITED; | 1197 typedef GrGLFragmentProcessor INHERITED; |
1201 }; | 1198 }; |
1202 | 1199 |
1203 GR_DECLARE_EFFECT_TEST; | 1200 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
1204 | 1201 |
1205 private: | 1202 private: |
1206 XferEffect(SkXfermode::Mode mode, GrTexture* background) | 1203 XferEffect(SkXfermode::Mode mode, GrTexture* background) |
1207 : fMode(mode) { | 1204 : fMode(mode) { |
1208 if (background) { | 1205 if (background) { |
1209 fBackgroundTransform.reset(kLocal_GrCoordSet, background); | 1206 fBackgroundTransform.reset(kLocal_GrCoordSet, background); |
1210 this->addCoordTransform(&fBackgroundTransform); | 1207 this->addCoordTransform(&fBackgroundTransform); |
1211 fBackgroundAccess.reset(background); | 1208 fBackgroundAccess.reset(background); |
1212 this->addTextureAccess(&fBackgroundAccess); | 1209 this->addTextureAccess(&fBackgroundAccess); |
1213 } else { | 1210 } else { |
1214 this->setWillReadDstColor(); | 1211 this->setWillReadDstColor(); |
1215 } | 1212 } |
1216 } | 1213 } |
1217 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { | 1214 virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE { |
1218 const XferEffect& s = other.cast<XferEffect>(); | 1215 const XferEffect& s = other.cast<XferEffect>(); |
1219 return fMode == s.fMode && | 1216 return fMode == s.fMode && |
1220 fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture(
); | 1217 fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture(
); |
1221 } | 1218 } |
1222 | 1219 |
1223 SkXfermode::Mode fMode; | 1220 SkXfermode::Mode fMode; |
1224 GrCoordTransform fBackgroundTransform; | 1221 GrCoordTransform fBackgroundTransform; |
1225 GrTextureAccess fBackgroundAccess; | 1222 GrTextureAccess fBackgroundAccess; |
1226 | 1223 |
1227 typedef GrEffect INHERITED; | 1224 typedef GrFragmentProcessor INHERITED; |
1228 }; | 1225 }; |
1229 | 1226 |
1230 GR_DEFINE_EFFECT_TEST(XferEffect); | 1227 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(XferEffect); |
1231 GrEffect* XferEffect::TestCreate(SkRandom* rand, | 1228 GrFragmentProcessor* XferEffect::TestCreate(SkRandom* rand, |
1232 GrContext*, | 1229 GrContext*, |
1233 const GrDrawTargetCaps&, | 1230 const GrDrawTargetCaps&, |
1234 GrTexture*[]) { | 1231 GrTexture*[]) { |
1235 int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLas
tSeparableMode); | 1232 int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLas
tSeparableMode); |
1236 | 1233 |
1237 return SkNEW_ARGS(XferEffect, (static_cast<SkXfermode::Mode>(mode), NULL)); | 1234 return SkNEW_ARGS(XferEffect, (static_cast<SkXfermode::Mode>(mode), NULL)); |
1238 } | 1235 } |
1239 | 1236 |
1240 #endif | 1237 #endif |
1241 | 1238 |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1373 A = SkAlphaBlend(A, dstA, SkAlpha255To256(a)); | 1370 A = SkAlphaBlend(A, dstA, SkAlpha255To256(a)); |
1374 } | 1371 } |
1375 dst[i] = SkToU8(A); | 1372 dst[i] = SkToU8(A); |
1376 } | 1373 } |
1377 } | 1374 } |
1378 } | 1375 } |
1379 } | 1376 } |
1380 } | 1377 } |
1381 | 1378 |
1382 #if SK_SUPPORT_GPU | 1379 #if SK_SUPPORT_GPU |
1383 bool SkProcCoeffXfermode::asNewEffect(GrEffect** effect, GrTexture* background)
const { | 1380 bool SkProcCoeffXfermode::asFragmentProcessor(GrFragmentProcessor** fp, |
| 1381 GrTexture* background) const { |
1384 if (XferEffect::IsSupportedMode(fMode)) { | 1382 if (XferEffect::IsSupportedMode(fMode)) { |
1385 if (effect) { | 1383 if (fp) { |
1386 *effect = XferEffect::Create(fMode, background); | 1384 *fp = XferEffect::Create(fMode, background); |
1387 SkASSERT(*effect); | 1385 SkASSERT(*fp); |
1388 } | 1386 } |
1389 return true; | 1387 return true; |
1390 } | 1388 } |
1391 return false; | 1389 return false; |
1392 } | 1390 } |
1393 #endif | 1391 #endif |
1394 | 1392 |
1395 const char* SkXfermode::ModeName(Mode mode) { | 1393 const char* SkXfermode::ModeName(Mode mode) { |
1396 SkASSERT((unsigned) mode <= (unsigned)kLastMode); | 1394 SkASSERT((unsigned) mode <= (unsigned)kLastMode); |
1397 const char* gModeStrings[] = { | 1395 const char* gModeStrings[] = { |
(...skipping 559 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1957 } else { | 1955 } else { |
1958 proc16 = rec.fProc16_General; | 1956 proc16 = rec.fProc16_General; |
1959 } | 1957 } |
1960 } | 1958 } |
1961 return proc16; | 1959 return proc16; |
1962 } | 1960 } |
1963 | 1961 |
1964 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode) | 1962 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode) |
1965 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode) | 1963 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode) |
1966 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 1964 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |