Stop using PassRefPtr in platform/graphics
[WebKit-https.git] / Source / WebCore / svg / SVGFEDiffuseLightingElement.cpp
1 /*
2  * Copyright (C) 2005 Oliver Hunt <ojh16@student.canterbury.ac.nz>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21 #include "SVGFEDiffuseLightingElement.h"
22
23 #include "FEDiffuseLighting.h"
24 #include "FilterEffect.h"
25 #include "RenderStyle.h"
26 #include "SVGFELightElement.h"
27 #include "SVGFilterBuilder.h"
28 #include "SVGNames.h"
29 #include "SVGParserUtilities.h"
30
31 namespace WebCore {
32
33 // Animated property definitions
34 DEFINE_ANIMATED_STRING(SVGFEDiffuseLightingElement, SVGNames::inAttr, In1, in1)
35 DEFINE_ANIMATED_NUMBER(SVGFEDiffuseLightingElement, SVGNames::diffuseConstantAttr, DiffuseConstant, diffuseConstant)
36 DEFINE_ANIMATED_NUMBER(SVGFEDiffuseLightingElement, SVGNames::surfaceScaleAttr, SurfaceScale, surfaceScale)
37 DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEDiffuseLightingElement, SVGNames::kernelUnitLengthAttr, kernelUnitLengthXIdentifier(), KernelUnitLengthX, kernelUnitLengthX)
38 DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEDiffuseLightingElement, SVGNames::kernelUnitLengthAttr, kernelUnitLengthYIdentifier(), KernelUnitLengthY, kernelUnitLengthY)
39
40 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGFEDiffuseLightingElement)
41     REGISTER_LOCAL_ANIMATED_PROPERTY(in1)
42     REGISTER_LOCAL_ANIMATED_PROPERTY(diffuseConstant)
43     REGISTER_LOCAL_ANIMATED_PROPERTY(surfaceScale)
44     REGISTER_LOCAL_ANIMATED_PROPERTY(kernelUnitLengthX)
45     REGISTER_LOCAL_ANIMATED_PROPERTY(kernelUnitLengthY)
46     REGISTER_PARENT_ANIMATED_PROPERTIES(SVGFilterPrimitiveStandardAttributes)
47 END_REGISTER_ANIMATED_PROPERTIES
48
49 inline SVGFEDiffuseLightingElement::SVGFEDiffuseLightingElement(const QualifiedName& tagName, Document& document)
50     : SVGFilterPrimitiveStandardAttributes(tagName, document)
51     , m_diffuseConstant(1)
52     , m_surfaceScale(1)
53 {
54     ASSERT(hasTagName(SVGNames::feDiffuseLightingTag));
55     registerAnimatedPropertiesForSVGFEDiffuseLightingElement();
56 }
57
58 Ref<SVGFEDiffuseLightingElement> SVGFEDiffuseLightingElement::create(const QualifiedName& tagName, Document& document)
59 {
60     return adoptRef(*new SVGFEDiffuseLightingElement(tagName, document));
61 }
62
63 const AtomicString& SVGFEDiffuseLightingElement::kernelUnitLengthXIdentifier()
64 {
65     static NeverDestroyed<AtomicString> s_identifier("SVGKernelUnitLengthX", AtomicString::ConstructFromLiteral);
66     return s_identifier;
67 }
68
69 const AtomicString& SVGFEDiffuseLightingElement::kernelUnitLengthYIdentifier()
70 {
71     static NeverDestroyed<AtomicString> s_identifier("SVGKernelUnitLengthY", AtomicString::ConstructFromLiteral);
72     return s_identifier;
73 }
74
75 void SVGFEDiffuseLightingElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
76 {
77     if (name == SVGNames::inAttr) {
78         setIn1BaseValue(value);
79         return;
80     }
81
82     if (name == SVGNames::surfaceScaleAttr) {
83         setSurfaceScaleBaseValue(value.toFloat());
84         return;
85     }
86
87     if (name == SVGNames::diffuseConstantAttr) {
88         setDiffuseConstantBaseValue(value.toFloat());
89         return;
90     }
91
92     if (name == SVGNames::kernelUnitLengthAttr) {
93         float x, y;
94         if (parseNumberOptionalNumber(value, x, y)) {
95             setKernelUnitLengthXBaseValue(x);
96             setKernelUnitLengthYBaseValue(y);
97         }
98         return;
99     }
100
101     SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
102 }
103
104 bool SVGFEDiffuseLightingElement::setFilterEffectAttribute(FilterEffect* effect, const QualifiedName& attrName)
105 {
106     FEDiffuseLighting* diffuseLighting = static_cast<FEDiffuseLighting*>(effect);
107
108     if (attrName == SVGNames::lighting_colorAttr) {
109         RenderObject* renderer = this->renderer();
110         ASSERT(renderer);
111         return diffuseLighting->setLightingColor(renderer->style().svgStyle().lightingColor());
112     }
113     if (attrName == SVGNames::surfaceScaleAttr)
114         return diffuseLighting->setSurfaceScale(surfaceScale());
115     if (attrName == SVGNames::diffuseConstantAttr)
116         return diffuseLighting->setDiffuseConstant(diffuseConstant());
117
118     auto& lightSource = const_cast<LightSource&>(diffuseLighting->lightSource());
119     const SVGFELightElement* lightElement = SVGFELightElement::findLightElement(this);
120     ASSERT(lightElement);
121
122     if (attrName == SVGNames::azimuthAttr)
123         return lightSource.setAzimuth(lightElement->azimuth());
124     if (attrName == SVGNames::elevationAttr)
125         return lightSource.setElevation(lightElement->elevation());
126     if (attrName == SVGNames::xAttr)
127         return lightSource.setX(lightElement->x());
128     if (attrName == SVGNames::yAttr)
129         return lightSource.setY(lightElement->y());
130     if (attrName == SVGNames::zAttr)
131         return lightSource.setZ(lightElement->z());
132     if (attrName == SVGNames::pointsAtXAttr)
133         return lightSource.setPointsAtX(lightElement->pointsAtX());
134     if (attrName == SVGNames::pointsAtYAttr)
135         return lightSource.setPointsAtY(lightElement->pointsAtY());
136     if (attrName == SVGNames::pointsAtZAttr)
137         return lightSource.setPointsAtZ(lightElement->pointsAtZ());
138     if (attrName == SVGNames::specularExponentAttr)
139         return lightSource.setSpecularExponent(lightElement->specularExponent());
140     if (attrName == SVGNames::limitingConeAngleAttr)
141         return lightSource.setLimitingConeAngle(lightElement->limitingConeAngle());
142
143     ASSERT_NOT_REACHED();
144     return false;
145 }
146
147 void SVGFEDiffuseLightingElement::svgAttributeChanged(const QualifiedName& attrName)
148 {
149     if (attrName == SVGNames::surfaceScaleAttr || attrName == SVGNames::diffuseConstantAttr || attrName == SVGNames::kernelUnitLengthAttr || attrName == SVGNames::lighting_colorAttr) {
150         InstanceInvalidationGuard guard(*this);
151         primitiveAttributeChanged(attrName);
152         return;
153     }
154
155     if (attrName == SVGNames::inAttr) {
156         InstanceInvalidationGuard guard(*this);
157         invalidate();
158         return;
159     }
160
161     SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
162 }
163
164 void SVGFEDiffuseLightingElement::lightElementAttributeChanged(const SVGFELightElement* lightElement, const QualifiedName& attrName)
165 {
166     if (SVGFELightElement::findLightElement(this) != lightElement)
167         return;
168
169     // The light element has different attribute names.
170     primitiveAttributeChanged(attrName);
171 }
172
173 RefPtr<FilterEffect> SVGFEDiffuseLightingElement::build(SVGFilterBuilder* filterBuilder, Filter& filter)
174 {
175     FilterEffect* input1 = filterBuilder->getEffectById(in1());
176
177     if (!input1)
178         return nullptr;
179
180     auto lightSource = SVGFELightElement::findLightSource(this);
181     if (!lightSource)
182         return nullptr;
183
184     RenderObject* renderer = this->renderer();
185     if (!renderer)
186         return nullptr;
187
188     const Color& color = renderer->style().svgStyle().lightingColor();
189
190     RefPtr<FilterEffect> effect = FEDiffuseLighting::create(filter, color, surfaceScale(), diffuseConstant(), kernelUnitLengthX(), kernelUnitLengthY(), lightSource.releaseNonNull());
191     effect->inputEffects().append(input1);
192     return effect;
193 }
194
195 }