Index: src/effects/SkFlattenableUtils.cpp |
diff --git a/src/effects/SkFlattenableUtils.cpp b/src/effects/SkFlattenableUtils.cpp |
new file mode 100644 |
index 0000000000000000000000000000000000000000..8d1641f88ae51dbf7210edda1ecef2d6ae795dc7 |
--- /dev/null |
+++ b/src/effects/SkFlattenableUtils.cpp |
@@ -0,0 +1,288 @@ |
+/* |
+ * Copyright 2013 Google Inc. |
+ * |
+ * Use of this source code is governed by a BSD-style license that can be |
+ * found in the LICENSE file. |
+ */ |
+ |
+#include "SkFlattenableUtils.h" |
+#include "Sk1DPathEffect.h" |
+#include "Sk2DPathEffect.h" |
+#include "SkAnnotation.h" |
+#include "SkArithmeticMode.h" |
+#include "SkAvoidXfermode.h" |
+#include "SkBicubicImageFilter.h" |
+#include "SkBitmapProcShader.h" |
+#include "SkBitmapSource.h" |
+#include "SkBlurDrawLooper.h" |
+#include "SkBlurImageFilter.h" |
+#include "SkBlurMaskFilter.h" |
+#include "SkColorFilterImageFilter.h" |
+#include "SkColorMatrixFilter.h" |
+#include "SkColorShader.h" |
+#include "SkColorTable.h" |
+#include "SkComposeImageFilter.h" |
+#include "SkComposeShader.h" |
+#include "SkCornerPathEffect.h" |
+#include "SkData.h" |
+#include "SkDataSet.h" |
+#include "SkDataTable.h" |
+#include "SkDiscretePathEffect.h" |
+#include "SkDisplacementMapEffect.h" |
+#include "SkDropShadowImageFilter.h" |
+#include "SkEmbossMaskFilter.h" |
+#include "SkEmptyShader.h" |
+#include "SkFilterShader.h" |
+#include "SkImageRef_GlobalPool.h" |
+#include "SkKernel33MaskFilter.h" |
+#include "SkLayerDrawLooper.h" |
+#include "SkLayerRasterizer.h" |
+#include "SkLerpXfermode.h" |
+#include "SkLightingImageFilter.h" |
+#include "SkLumaXfermode.h" |
+#include "SkMagnifierImageFilter.h" |
+#include "SkMallocPixelRef.h" |
+#include "SkMatrixConvolutionImageFilter.h" |
+#include "SkMergeImageFilter.h" |
+#include "SkMorphologyImageFilter.h" |
+#include "SkOffsetImageFilter.h" |
+#include "SkPathEffect.h" |
+#include "SkPerlinNoiseShader.h" |
+#include "SkPixelXorXfermode.h" |
+#include "SkRectShaderImageFilter.h" |
+#include "SkStippleMaskFilter.h" |
+#include "SkTableColorFilter.h" |
+#include "SkTableMaskFilter.h" |
+#include "SkTestImageFilters.h" |
+#include "SkTransparentShader.h" |
+#include "SkUnitMappers.h" |
+#include "SkXfermode.h" |
+#include "SkXfermodeImageFilter.h" |
+#include "gradients/SkLinearGradient.h" |
+#include "gradients/SkRadialGradient.h" |
+#include "gradients/SkSweepGradient.h" |
+#include "gradients/SkTwoPointConicalGradient.h" |
+#include "gradients/SkTwoPointRadialGradient.h" |
+ |
+namespace { |
+ |
+struct TypeFunctions { |
+ TypeFunctions() : fFactory(0), fTypeCheck(0) {} |
+ TypeFunctions(SkFlattenable::Factory factory, SkFlattenable::TypeCheck typeCheck) : |
+ fFactory(factory), fTypeCheck(typeCheck) {} |
+ SkFlattenable::Factory fFactory; |
+ SkFlattenable::TypeCheck fTypeCheck; |
+}; |
+ |
+const TypeFunctions& GetFunctions(SkFlattenable::Type type) { |
mtklein
2013/09/24 22:52:18
We're going to have to come up with some way to ma
sugoi1
2013/09/25 21:15:27
Agreed. I'll try to think of a way to make the cod
|
+ static TypeFunctions typeFunctions[SkFlattenable::kTypeCount]; |
+ static bool init = false; |
+ if (!init) { |
+ // SkFlattenable::kNone : nothing to do |
+ // SkFlattenable::kSkFlattenable : nothing to do |
+ // SkFlattenable::kBATShader : not implemented - TODO |
+ typeFunctions[SkFlattenable::kSk2DPathEffect] = |
+ TypeFunctions(Sk2DPathEffect::CreateProc, Sk2DPathEffect::IsA); |
+ // SkFlattenable::kSk3DShader : local to SkBlitter.cpp - TODO |
+ typeFunctions[SkFlattenable::kSkAnnotation] = |
+ TypeFunctions(SkAnnotation::CreateProc, SkAnnotation::IsA); |
+ typeFunctions[SkFlattenable::kSkArithmeticMode_scalar] = TypeFunctions( |
+ SkArithmeticMode::GetFactory(SkFlattenable::kSkArithmeticMode_scalar), |
+ SkArithmeticMode::GetTypeCheck(SkFlattenable::kSkArithmeticMode_scalar)); |
+ typeFunctions[SkFlattenable::kSkAvoidXfermode] = |
+ TypeFunctions(SkAvoidXfermode::CreateProc, SkAvoidXfermode::IsA); |
+ typeFunctions[SkFlattenable::kSkBicubicImageFilter] = |
+ TypeFunctions(SkBicubicImageFilter::CreateProc, SkBicubicImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkBitmapProcShader] = |
+ TypeFunctions(SkBitmapProcShader::CreateProc, SkBitmapProcShader::IsA); |
+ typeFunctions[SkFlattenable::kSkBitmapSource] = |
+ TypeFunctions(SkBitmapSource::CreateProc, SkBitmapSource::IsA); |
+ typeFunctions[SkFlattenable::kSkBlurDrawLooper] = |
+ TypeFunctions(SkBlurDrawLooper::CreateProc, SkBlurDrawLooper::IsA); |
+ typeFunctions[SkFlattenable::kSkBlurImageFilter] = |
+ TypeFunctions(SkBlurImageFilter::CreateProc, SkBlurImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkBlurMaskFilterImpl] = TypeFunctions( |
+ SkBlurMaskFilter::GetFactory(SkFlattenable::kSkBlurMaskFilterImpl), |
+ SkBlurMaskFilter::GetTypeCheck(SkFlattenable::kSkBlurMaskFilterImpl)); |
+ typeFunctions[SkFlattenable::kSkClearXfermode] = TypeFunctions( |
+ SkProcXfermode::GetFactory(SkFlattenable::kSkClearXfermode), |
+ SkProcXfermode::GetTypeCheck(SkFlattenable::kSkClearXfermode)); |
+ typeFunctions[SkFlattenable::kSkColorFilterImageFilter] = |
+ TypeFunctions(SkColorFilterImageFilter::CreateProc, SkColorFilterImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkColorMatrixFilter] = |
+ TypeFunctions(SkColorMatrixFilter::CreateProc, SkColorMatrixFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkColorShader] = |
+ TypeFunctions(SkColorShader::CreateProc, SkColorShader::IsA); |
+ typeFunctions[SkFlattenable::kSkColorTable] = |
+ TypeFunctions(SkColorTable::CreateProc, SkColorTable::IsA); |
+ typeFunctions[SkFlattenable::kSkComposeImageFilter] = |
+ TypeFunctions(SkComposeImageFilter::CreateProc, SkComposeImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkComposePathEffect] = |
+ TypeFunctions(SkComposePathEffect::CreateProc, SkComposePathEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkComposeShader] = |
+ TypeFunctions(SkComposeShader::CreateProc, SkComposeShader::IsA); |
+ typeFunctions[SkFlattenable::kSkCornerPathEffect] = |
+ TypeFunctions(SkCornerPathEffect::CreateProc, SkCornerPathEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkCosineMapper] = |
+ TypeFunctions(SkCosineMapper::CreateProc, SkCosineMapper::IsA); |
+ typeFunctions[SkFlattenable::kSkData] = |
+ TypeFunctions(SkData::CreateProc, SkData::IsA); |
+ // SkFlattenable::kSkDataPixelRef : in image library - skip |
+ typeFunctions[SkFlattenable::kSkDataSet] = |
+ TypeFunctions(SkDataSet::CreateProc, SkDataSet::IsA); |
+ typeFunctions[SkFlattenable::kSkDataTable] = |
+ TypeFunctions(SkDataTable::CreateProc, SkDataTable::IsA); |
+ typeFunctions[SkFlattenable::kSkDiffuseLightingImageFilter] = TypeFunctions( |
+ SkLightingImageFilter::GetFactory(SkFlattenable::kSkDiffuseLightingImageFilter), |
+ SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkDiffuseLightingImageFilter)); |
+ typeFunctions[SkFlattenable::kSkDilateImageFilter] = |
+ TypeFunctions(SkDilateImageFilter::CreateProc, SkDilateImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkDiscreteMapper] = |
+ TypeFunctions(SkDiscreteMapper::CreateProc, SkDiscreteMapper::IsA); |
+ typeFunctions[SkFlattenable::kSkDiscretePathEffect] = |
+ TypeFunctions(SkDiscretePathEffect::CreateProc, SkDiscretePathEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkDisplacementMapEffect] = |
+ TypeFunctions(SkDisplacementMapEffect::CreateProc, SkDisplacementMapEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkDistantLight] = TypeFunctions( |
+ SkLightingImageFilter::GetFactory(SkFlattenable::kSkDistantLight), |
+ SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkDistantLight)); |
+ typeFunctions[SkFlattenable::kSkDownSampleImageFilter] = |
+ TypeFunctions(SkDownSampleImageFilter::CreateProc, SkDownSampleImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkDropShadowImageFilter] = |
+ TypeFunctions(SkDropShadowImageFilter::CreateProc, SkDropShadowImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkDstInXfermode] = TypeFunctions( |
+ SkProcXfermode::GetFactory(SkFlattenable::kSkDstInXfermode), |
+ SkProcXfermode::GetTypeCheck(SkFlattenable::kSkDstInXfermode)); |
+ typeFunctions[SkFlattenable::kSkDstOutXfermode] = TypeFunctions( |
+ SkProcXfermode::GetFactory(SkFlattenable::kSkDstOutXfermode), |
+ SkProcXfermode::GetTypeCheck(SkFlattenable::kSkDstOutXfermode)); |
+ typeFunctions[SkFlattenable::kSkEmbossMaskFilter] = |
+ TypeFunctions(SkEmbossMaskFilter::CreateProc, SkEmbossMaskFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkEmptyShader] = |
+ TypeFunctions(SkEmptyShader::CreateProc, SkEmptyShader::IsA); |
+ typeFunctions[SkFlattenable::kSkErodeImageFilter] = |
+ TypeFunctions(SkErodeImageFilter::CreateProc, SkErodeImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkFilterShader] = |
+ TypeFunctions(SkFilterShader::CreateProc, SkFilterShader::IsA); |
+ typeFunctions[SkFlattenable::kSkImageRef_GlobalPool] = |
+ TypeFunctions(SkImageRef_GlobalPool::CreateProc, SkImageRef_GlobalPool::IsA); |
+ typeFunctions[SkFlattenable::kSkKernel33MaskFilter] = |
+ TypeFunctions(SkKernel33MaskFilter::CreateProc, SkKernel33MaskFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkLayerDrawLooper] = |
+ TypeFunctions(SkLayerDrawLooper::CreateProc, SkLayerDrawLooper::IsA); |
+ typeFunctions[SkFlattenable::kSkLayerRasterizer] = |
+ TypeFunctions(SkLayerRasterizer::CreateProc, SkLayerRasterizer::IsA); |
+ typeFunctions[SkFlattenable::kSkLerpXfermode] = |
+ TypeFunctions(SkLerpXfermode::CreateProc, SkLerpXfermode::IsA); |
+ typeFunctions[SkFlattenable::kSkLightingColorFilter] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter)); |
+ typeFunctions[SkFlattenable::kSkLightingColorFilter_JustAdd] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_JustAdd), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_JustAdd)); |
+ typeFunctions[SkFlattenable::kSkLightingColorFilter_JustMul] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_JustMul), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_JustMul)); |
+ typeFunctions[SkFlattenable::kSkLightingColorFilter_NoPin] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_NoPin), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_NoPin)); |
+ typeFunctions[SkFlattenable::kSkLightingColorFilter_SingleMul] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_SingleMul), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_SingleMul)); |
+ typeFunctions[SkFlattenable::kSkLinearGradient] = |
+ TypeFunctions(SkLinearGradient::CreateProc, SkLinearGradient::IsA); |
+ typeFunctions[SkFlattenable::kSkLine2DPathEffect] = |
+ TypeFunctions(SkLine2DPathEffect::CreateProc, SkLine2DPathEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkLumaMaskXfermode] = |
+ TypeFunctions(SkLumaMaskXfermode::CreateProc, SkLumaMaskXfermode::IsA); |
+ // SkFlattenable::kSkLumaMaskXfermodeSrcOver : local to SkLumaXfermode.cpp - TODO |
+ typeFunctions[SkFlattenable::kSkMagnifierImageFilter] = |
+ TypeFunctions(SkMagnifierImageFilter::CreateProc, SkMagnifierImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkMallocPixelRef] = |
+ TypeFunctions(SkMallocPixelRef::CreateProc, SkMallocPixelRef::IsA); |
+ typeFunctions[SkFlattenable::kSkMatrixConvolutionImageFilter] = |
+ TypeFunctions(SkMatrixConvolutionImageFilter::CreateProc, SkMatrixConvolutionImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkMergeImageFilter] = |
+ TypeFunctions(SkMergeImageFilter::CreateProc, SkMergeImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkModeColorFilter] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSkModeColorFilter), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSkModeColorFilter)); |
+ typeFunctions[SkFlattenable::kSkOffsetImageFilter] = |
+ TypeFunctions(SkOffsetImageFilter::CreateProc, SkOffsetImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkPath1DPathEffect] = |
+ TypeFunctions(SkPath1DPathEffect::CreateProc, SkPath1DPathEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkPath2DPathEffect] = |
+ TypeFunctions(SkPath2DPathEffect::CreateProc, SkPath2DPathEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkPerlinNoiseShader] = |
+ TypeFunctions(SkPerlinNoiseShader::CreateProc, SkPerlinNoiseShader::IsA); |
+ typeFunctions[SkFlattenable::kSkPixelXorXfermode] = |
+ TypeFunctions(SkPixelXorXfermode::CreateProc, SkPixelXorXfermode::IsA); |
+ typeFunctions[SkFlattenable::kSkPointLight] = TypeFunctions( |
+ SkLightingImageFilter::GetFactory(SkFlattenable::kSkPointLight), |
+ SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkPointLight)); |
+ typeFunctions[SkFlattenable::kSkProcCoeffXfermode] = TypeFunctions( |
+ SkProcXfermode::GetFactory(SkFlattenable::kSkProcCoeffXfermode), |
+ SkProcXfermode::GetTypeCheck(SkFlattenable::kSkProcCoeffXfermode)); |
+ typeFunctions[SkFlattenable::kSkProcXfermode] = |
+ TypeFunctions(SkProcXfermode::CreateProc, SkProcXfermode::IsA); |
+ typeFunctions[SkFlattenable::kSkRadialGradient] = |
+ TypeFunctions(SkRadialGradient::CreateProc, SkRadialGradient::IsA); |
+ typeFunctions[SkFlattenable::kSkRectShaderImageFilter] = |
+ TypeFunctions(SkRectShaderImageFilter::CreateProc, SkRectShaderImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkSpecularLightingImageFilter] = TypeFunctions( |
+ SkLightingImageFilter::GetFactory(SkFlattenable::kSkSpecularLightingImageFilter), |
+ SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkSpecularLightingImageFilter)); |
+ typeFunctions[SkFlattenable::kSkSpotLight] = TypeFunctions( |
+ SkLightingImageFilter::GetFactory(SkFlattenable::kSkSpotLight), |
+ SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkSpotLight)); |
+ typeFunctions[SkFlattenable::kSkSrcXfermode] = TypeFunctions( |
+ SkProcXfermode::GetFactory(SkFlattenable::kSkSrcXfermode), |
+ SkProcXfermode::GetTypeCheck(SkFlattenable::kSkSrcXfermode)); |
+ typeFunctions[SkFlattenable::kSkStippleMaskFilter] = |
+ TypeFunctions(SkStippleMaskFilter::CreateProc, SkStippleMaskFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkSumPathEffect] = |
+ TypeFunctions(SkSumPathEffect::CreateProc, SkSumPathEffect::IsA); |
+ typeFunctions[SkFlattenable::kSkSweepGradient] = |
+ TypeFunctions(SkSweepGradient::CreateProc, SkSweepGradient::IsA); |
+ typeFunctions[SkFlattenable::kSkTable_ColorFilter] = TypeFunctions( |
+ SkTableColorFilter::GetFactory(SkFlattenable::kSkTable_ColorFilter), |
+ SkTableColorFilter::GetTypeCheck(SkFlattenable::kSkTable_ColorFilter)); |
+ typeFunctions[SkFlattenable::kSkTableMaskFilter] = |
+ TypeFunctions(SkTableMaskFilter::CreateProc, SkTableMaskFilter::IsA); |
+ typeFunctions[SkFlattenable::kSkTransparentShader] = |
+ TypeFunctions(SkTransparentShader::CreateProc, SkTransparentShader::IsA); |
+ // SkFlattenable::kSkTriColorShader : not implemented - TODO |
+ typeFunctions[SkFlattenable::kSkTwoPointConicalGradient] = |
+ TypeFunctions(SkTwoPointConicalGradient::CreateProc, SkTwoPointConicalGradient::IsA); |
+ typeFunctions[SkFlattenable::kSkTwoPointRadialGradient] = |
+ TypeFunctions(SkTwoPointRadialGradient::CreateProc, SkTwoPointRadialGradient::IsA); |
+ typeFunctions[SkFlattenable::kSkXfermodeImageFilter] = |
+ TypeFunctions(SkXfermodeImageFilter::CreateProc, SkXfermodeImageFilter::IsA); |
+ typeFunctions[SkFlattenable::kSrc_SkModeColorFilter] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSrc_SkModeColorFilter), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSrc_SkModeColorFilter)); |
+ typeFunctions[SkFlattenable::kSrcOver_SkModeColorFilter] = TypeFunctions( |
+ SkColorFilter::GetFactory(SkFlattenable::kSrcOver_SkModeColorFilter), |
+ SkColorFilter::GetTypeCheck(SkFlattenable::kSrcOver_SkModeColorFilter)); |
+ |
+ init = true; |
+ } |
+ return typeFunctions[(type < SkFlattenable::kTypeCount) ? type : SkFlattenable::kNone]; |
+} |
+ |
+} // end namespace |
+ |
+namespace SkFlattenableUtils { |
+ |
+// Returns the factory function required to create the given type |
+SkFlattenable::Factory TypeToFactory(SkFlattenable::Type type) { |
+ return GetFunctions(type).fFactory; |
+} |
+ |
+// Checks if typeA is a typeB |
+bool TypeIsA(SkFlattenable::Type typeA, SkFlattenable::Type typeB) { |
+ SkFlattenable::TypeCheck typeCheck = GetFunctions(typeA).fTypeCheck; |
+ return typeCheck ? (*typeCheck)(typeB) : false; |
+} |
+ |
+} // end SkFlattenableUtils namespace |