PassRefPtr<SkImageFilter> FEColorMatrix::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace())); SkAutoTUnref<SkColorFilter> filter(createColorFilter(m_type, m_values.data())); SkImageFilter::CropRect rect = getCropRect(builder->cropOffset()); return adoptRef(SkColorFilterImageFilter::Create(filter, input.get(), &rect)); }
sk_sp<SkImageFilter> FEConvolveMatrix::createImageFilter() { if (!parametersValid()) return createTransparentBlack(); sk_sp<SkImageFilter> input( SkiaImageFilterBuilder::build(inputEffect(0), operatingColorSpace())); SkISize kernelSize( SkISize::Make(m_kernelSize.width(), m_kernelSize.height())); // parametersValid() above checks that the kernel area fits in int. int numElements = safeCast<int>(m_kernelSize.area()); SkScalar gain = SkFloatToScalar(1.0f / m_divisor); SkScalar bias = SkFloatToScalar(m_bias * 255); SkIPoint target = SkIPoint::Make(m_targetOffset.x(), m_targetOffset.y()); SkMatrixConvolutionImageFilter::TileMode tileMode = toSkiaTileMode(m_edgeMode); bool convolveAlpha = !m_preserveAlpha; std::unique_ptr<SkScalar[]> kernel = wrapArrayUnique(new SkScalar[numElements]); for (int i = 0; i < numElements; ++i) kernel[i] = SkFloatToScalar(m_kernelMatrix[numElements - 1 - i]); SkImageFilter::CropRect cropRect = getCropRect(); return SkMatrixConvolutionImageFilter::Make( kernelSize, kernel.get(), gain, bias, target, tileMode, convolveAlpha, std::move(input), &cropRect); }
PassRefPtr<SkImageFilter> FEOffset::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace())); Filter* filter = this->filter(); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); return adoptRef(SkOffsetImageFilter::Create(SkFloatToScalar(filter->applyHorizontalScale(m_dx)), SkFloatToScalar(filter->applyVerticalScale(m_dy)), input.get(), &cropRect)); }
sk_sp<SkImageFilter> FEFlood::createImageFilter() { Color color = floodColor().combineWithAlpha(floodOpacity()); SkImageFilter::CropRect rect = getCropRect(); return SkColorFilterImageFilter::Make( SkColorFilter::MakeModeFilter(color.rgb(), SkXfermode::kSrc_Mode), 0, &rect); }
PassRefPtr<SkImageFilter> FEBlend::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> foreground(builder->build(inputEffect(0), operatingColorSpace())); RefPtr<SkImageFilter> background(builder->build(inputEffect(1), operatingColorSpace())); RefPtr<SkXfermode> mode(adoptRef(SkXfermode::Create(WebCoreCompositeToSkiaComposite(CompositeSourceOver, m_mode)))); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); return adoptRef(SkXfermodeImageFilter::Create(mode.get(), background.get(), foreground.get(), &cropRect)); }
PassRefPtr<SkImageFilter> FEGaussianBlur::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace())); float stdX = filter()->applyHorizontalScale(m_stdX); float stdY = filter()->applyVerticalScale(m_stdY); SkImageFilter::CropRect rect = getCropRect(builder->cropOffset()); return adoptRef(SkBlurImageFilter::Create(SkFloatToScalar(stdX), SkFloatToScalar(stdY), input.get(), &rect)); }
PassRefPtr<SkImageFilter> FEFlood::createImageFilter(SkiaImageFilterBuilder& builder) { Color color = floodColor().combineWithAlpha(floodOpacity()); SkImageFilter::CropRect rect = getCropRect(); sk_sp<SkColorFilter> colorFilter = SkColorFilter::MakeModeFilter(color.rgb(), SkXfermode::kSrc_Mode); return adoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), 0, &rect)); }
PassRefPtr<SkImageFilter> FEFlood::createImageFilter(SkiaImageFilterBuilder* builder) { Color color = floodColor().combineWithAlpha(floodOpacity()); SkImageFilter::CropRect rect = getCropRect(builder->cropOffset()); SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(color.rgb(), SkXfermode::kSrc_Mode)); return adoptRef(SkColorFilterImageFilter::Create(cf, 0, &rect)); }
PassRefPtr<SkImageFilter> FEBlend::createImageFilter(SkiaImageFilterBuilder& builder) { RefPtr<SkImageFilter> foreground(builder.build(inputEffect(0), operatingColorSpace())); RefPtr<SkImageFilter> background(builder.build(inputEffect(1), operatingColorSpace())); sk_sp<SkXfermode> mode(SkXfermode::Make(WebCoreCompositeToSkiaComposite(CompositeSourceOver, m_mode))); SkImageFilter::CropRect cropRect = getCropRect(); return fromSkSp(SkXfermodeImageFilter::Make(std::move(mode), background.get(), foreground.get(), &cropRect)); }
sk_sp<SkImageFilter> FEOffset::createImageFilter() { Filter* filter = this->getFilter(); SkImageFilter::CropRect cropRect = getCropRect(); return SkOffsetImageFilter::Make( SkFloatToScalar(filter->applyHorizontalScale(m_dx)), SkFloatToScalar(filter->applyVerticalScale(m_dy)), SkiaImageFilterBuilder::build(inputEffect(0), operatingColorSpace()), &cropRect); }
sk_sp<SkImageFilter> FETurbulence::createImageFilter() { if (m_baseFrequencyX < 0 || m_baseFrequencyY < 0) return createTransparentBlack(); SkPaint paint; paint.setShader(createShader()); SkImageFilter::CropRect rect = getCropRect(); return SkPaintImageFilter::Make(paint, &rect); }
PassRefPtr<SkImageFilter> FEMorphology::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace())); SkScalar radiusX = SkFloatToScalar(filter()->applyHorizontalScale(m_radiusX)); SkScalar radiusY = SkFloatToScalar(filter()->applyVerticalScale(m_radiusY)); SkImageFilter::CropRect rect = getCropRect(builder->cropOffset()); if (m_type == FEMORPHOLOGY_OPERATOR_DILATE) return adoptRef(SkDilateImageFilter::Create(radiusX, radiusY, input.get(), &rect)); return adoptRef(SkErodeImageFilter::Create(radiusX, radiusY, input.get(), &rect)); }
sk_sp<SkImageFilter> FEMerge::createImageFilter() { unsigned size = numberOfEffectInputs(); std::unique_ptr<sk_sp<SkImageFilter>[]> inputRefs = wrapArrayUnique(new sk_sp<SkImageFilter>[size]); for (unsigned i = 0; i < size; ++i) inputRefs[i] = SkiaImageFilterBuilder::build(inputEffect(i), operatingColorSpace()); SkImageFilter::CropRect rect = getCropRect(); return SkMergeImageFilter::Make(inputRefs.get(), size, 0, &rect); }
PassRefPtr<SkImageFilter> FEDisplacementMap::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> color = builder->build(inputEffect(0), operatingColorSpace()); RefPtr<SkImageFilter> displ = builder->build(inputEffect(1), operatingColorSpace()); SkDisplacementMapEffect::ChannelSelectorType typeX = toSkiaMode(m_xChannelSelector); SkDisplacementMapEffect::ChannelSelectorType typeY = toSkiaMode(m_yChannelSelector); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); // FIXME : Only applyHorizontalScale is used and applyVerticalScale is ignored // This can be fixed by adding a 2nd scale parameter to SkDisplacementMapEffect return adoptRef(SkDisplacementMapEffect::Create(typeX, typeY, SkFloatToScalar(filter()->applyHorizontalScale(m_scale)), displ.get(), color.get(), &cropRect)); }
PassRefPtr<SkImageFilter> FEDropShadow::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace())); float dx = filter()->applyHorizontalScale(m_dx); float dy = filter()->applyVerticalScale(m_dy); float stdX = filter()->applyHorizontalScale(m_stdX); float stdY = filter()->applyVerticalScale(m_stdY); Color color = adaptColorToOperatingColorSpace(m_shadowColor.combineWithAlpha(m_shadowOpacity)); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); return adoptRef(SkDropShadowImageFilter::Create(SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(stdX), SkFloatToScalar(stdY), color.rgb(), input.get(), &cropRect)); }
PassRefPtr<SkImageFilter> FEComponentTransfer::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace())); unsigned char rValues[256], gValues[256], bValues[256], aValues[256]; getValues(rValues, gValues, bValues, aValues); SkAutoTUnref<SkColorFilter> colorFilter(SkTableColorFilter::CreateARGB(aValues, rValues, gValues, bValues)); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); return adoptRef(SkColorFilterImageFilter::Create(colorFilter, input.get(), &cropRect)); }
PassRefPtr<SkImageFilter> FEComposite::createImageFilterInternal(SkiaImageFilterBuilder* builder, bool requiresPMColorValidation) { RefPtr<SkImageFilter> foreground(builder->build(inputEffect(0), operatingColorSpace(), !mayProduceInvalidPreMultipliedPixels())); RefPtr<SkImageFilter> background(builder->build(inputEffect(1), operatingColorSpace(), !mayProduceInvalidPreMultipliedPixels())); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); RefPtr<SkXfermode> mode; if (m_type == FECOMPOSITE_OPERATOR_ARITHMETIC) mode = adoptRef(SkArithmeticMode::Create(SkFloatToScalar(m_k1), SkFloatToScalar(m_k2), SkFloatToScalar(m_k3), SkFloatToScalar(m_k4), requiresPMColorValidation)); else mode = adoptRef(SkXfermode::Create(toXfermode(m_type))); return adoptRef(SkXfermodeImageFilter::Create(mode.get(), background.get(), foreground.get(), &cropRect)); }
PassRefPtr<SkImageFilter> FEComposite::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> foreground(builder->build(inputEffect(0), operatingColorSpace())); RefPtr<SkImageFilter> background(builder->build(inputEffect(1), operatingColorSpace())); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); RefPtr<SkXfermode> mode; if (m_type == FECOMPOSITE_OPERATOR_ARITHMETIC) mode = adoptRef(SkArithmeticMode::Create(SkFloatToScalar(m_k1), SkFloatToScalar(m_k2), SkFloatToScalar(m_k3), SkFloatToScalar(m_k4))); else mode = adoptRef(SkXfermode::Create(toXfermode(m_type))); return adoptRef(new SkXfermodeImageFilter(mode.get(), background.get(), foreground.get(), &cropRect)); }
PassRefPtr<SkImageFilter> FEMerge::createImageFilter(SkiaImageFilterBuilder& builder) { unsigned size = numberOfEffectInputs(); OwnPtr<RefPtr<SkImageFilter>[]> inputRefs = adoptArrayPtr(new RefPtr<SkImageFilter>[size]); OwnPtr<SkImageFilter*[]> inputs = adoptArrayPtr(new SkImageFilter*[size]); for (unsigned i = 0; i < size; ++i) { inputRefs[i] = builder.build(inputEffect(i), operatingColorSpace()); inputs[i] = inputRefs[i].get(); } SkImageFilter::CropRect rect = getCropRect(builder.cropOffset()); return adoptRef(SkMergeImageFilter::Create(inputs.get(), size, 0, &rect)); }
sk_sp<SkImageFilter> FEDropShadow::createImageFilter() { sk_sp<SkImageFilter> input( SkiaImageFilterBuilder::build(inputEffect(0), operatingColorSpace())); float dx = getFilter()->applyHorizontalScale(m_dx); float dy = getFilter()->applyVerticalScale(m_dy); float stdX = getFilter()->applyHorizontalScale(m_stdX); float stdY = getFilter()->applyVerticalScale(m_stdY); Color color = adaptColorToOperatingColorSpace( m_shadowColor.combineWithAlpha(m_shadowOpacity)); SkImageFilter::CropRect cropRect = getCropRect(); return SkDropShadowImageFilter::Make( SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(stdX), SkFloatToScalar(stdY), color.rgb(), SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, std::move(input), &cropRect); }
PassRefPtr<SkImageFilter> FEConvolveMatrix::createImageFilter(SkiaImageFilterBuilder* builder) { RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace())); SkISize kernelSize(SkISize::Make(m_kernelSize.width(), m_kernelSize.height())); int numElements = kernelSize.width() * kernelSize.height(); SkScalar gain = SkFloatToScalar(1.0f / m_divisor); SkScalar bias = SkFloatToScalar(m_bias * 255); SkIPoint target = SkIPoint::Make(m_targetOffset.x(), m_targetOffset.y()); SkMatrixConvolutionImageFilter::TileMode tileMode = toSkiaTileMode(m_edgeMode); bool convolveAlpha = !m_preserveAlpha; OwnPtr<SkScalar[]> kernel = adoptArrayPtr(new SkScalar[numElements]); for (int i = 0; i < numElements; ++i) kernel[i] = SkFloatToScalar(m_kernelMatrix[numElements - 1 - i]); SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset()); return adoptRef(SkMatrixConvolutionImageFilter::Create(kernelSize, kernel.get(), gain, bias, target, tileMode, convolveAlpha, input.get(), &cropRect)); }
sk_sp<SkImageFilter> FEDisplacementMap::createImageFilter() { sk_sp<SkImageFilter> color = SkiaImageFilterBuilder::build(inputEffect(0), operatingColorSpace()); sk_sp<SkImageFilter> displ = SkiaImageFilterBuilder::build(inputEffect(1), operatingColorSpace()); SkDisplacementMapEffect::ChannelSelectorType typeX = toSkiaMode(m_xChannelSelector); SkDisplacementMapEffect::ChannelSelectorType typeY = toSkiaMode(m_yChannelSelector); SkImageFilter::CropRect cropRect = getCropRect(); // FIXME : Only applyHorizontalScale is used and applyVerticalScale is ignored // This can be fixed by adding a 2nd scale parameter to // SkDisplacementMapEffect. return SkDisplacementMapEffect::Make( typeX, typeY, SkFloatToScalar(getFilter()->applyHorizontalScale(m_scale)), std::move(displ), std::move(color), &cropRect); }
PassRefPtr<SkImageFilter> FELighting::createImageFilter(SkiaImageFilterBuilder* builder) { SkIRect rect = getCropRect(builder->cropOffset()); RefPtr<SkImageFilter> input(builder ? builder->build(inputEffect(0), operatingColorSpace()) : 0); switch (m_lightSource->type()) { case LS_DISTANT: { DistantLightSource* distantLightSource = static_cast<DistantLightSource*>(m_lightSource.get()); float azimuthRad = deg2rad(distantLightSource->azimuth()); float elevationRad = deg2rad(distantLightSource->elevation()); SkPoint3 direction(cosf(azimuthRad) * cosf(elevationRad), sinf(azimuthRad) * cosf(elevationRad), sinf(elevationRad)); if (m_specularConstant > 0) return adoptRef(SkLightingImageFilter::CreateDistantLitSpecular(direction, m_lightingColor.rgb(), m_surfaceScale, m_specularConstant, m_specularExponent, input.get(), &rect)); else return adoptRef(SkLightingImageFilter::CreateDistantLitDiffuse(direction, m_lightingColor.rgb(), m_surfaceScale, m_diffuseConstant, input.get(), &rect)); } case LS_POINT: { PointLightSource* pointLightSource = static_cast<PointLightSource*>(m_lightSource.get()); FloatPoint3D position = pointLightSource->position(); SkPoint3 skPosition(position.x(), position.y(), position.z()); if (m_specularConstant > 0) return adoptRef(SkLightingImageFilter::CreatePointLitSpecular(skPosition, m_lightingColor.rgb(), m_surfaceScale, m_specularConstant, m_specularExponent, input.get(), &rect)); else return adoptRef(SkLightingImageFilter::CreatePointLitDiffuse(skPosition, m_lightingColor.rgb(), m_surfaceScale, m_diffuseConstant, input.get(), &rect)); } case LS_SPOT: { SpotLightSource* spotLightSource = static_cast<SpotLightSource*>(m_lightSource.get()); SkPoint3 location(spotLightSource->position().x(), spotLightSource->position().y(), spotLightSource->position().z()); SkPoint3 target(spotLightSource->direction().x(), spotLightSource->direction().y(), spotLightSource->direction().z()); float specularExponent = spotLightSource->specularExponent(); float limitingConeAngle = spotLightSource->limitingConeAngle(); if (!limitingConeAngle || limitingConeAngle > 90 || limitingConeAngle < -90) limitingConeAngle = 90; if (m_specularConstant > 0) return adoptRef(SkLightingImageFilter::CreateSpotLitSpecular(location, target, specularExponent, limitingConeAngle, m_lightingColor.rgb(), m_surfaceScale, m_specularConstant, m_specularExponent, input.get(), &rect)); else return adoptRef(SkLightingImageFilter::CreateSpotLitDiffuse(location, target, specularExponent, limitingConeAngle, m_lightingColor.rgb(), m_surfaceScale, m_diffuseConstant, input.get(), &rect)); } default: ASSERT_NOT_REACHED(); return 0; } }
sk_sp<SkImageFilter> FilterEffect::createTransparentBlack() const { SkImageFilter::CropRect rect = getCropRect(); sk_sp<SkColorFilter> colorFilter = SkColorFilter::MakeModeFilter(0, SkBlendMode::kClear); return SkColorFilterImageFilter::Make(std::move(colorFilter), nullptr, &rect); }
PassRefPtr<SkImageFilter> FilterEffect::createTransparentBlack(SkiaImageFilterBuilder& builder) const { SkAutoTUnref<SkColorFilter> filter(SkColorFilter::CreateModeFilter(0, SkXfermode::kClear_Mode)); SkImageFilter::CropRect rect = getCropRect(builder.cropOffset()); return adoptRef(SkColorFilterImageFilter::Create(filter, nullptr, &rect)); }
PassRefPtr<SkImageFilter> FETurbulence::createImageFilter(SkiaImageFilterBuilder* builder) { SkAutoTUnref<SkShader> shader(createShader()); SkImageFilter::CropRect rect = getCropRect(builder->cropOffset()); return adoptRef(SkRectShaderImageFilter::Create(shader, &rect)); }