75f24c4e267a8374a8a2880842c4d6c79ce639ca
[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     LightSource* lightSource = const_cast<LightSource*>(diffuseLighting->lightSource());
119     const SVGFELightElement* lightElement = SVGFELightElement::findLightElement(this);
120     ASSERT(lightSource);
121     ASSERT(lightElement);
122
123     if (attrName == SVGNames::azimuthAttr)
124         return lightSource->setAzimuth(lightElement->azimuth());
125     if (attrName == SVGNames::elevationAttr)
126         return lightSource->setElevation(lightElement->elevation());
127     if (attrName == SVGNames::xAttr)
128         return lightSource->setX(lightElement->x());
129     if (attrName == SVGNames::yAttr)
130         return lightSource->setY(lightElement->y());
131     if (attrName == SVGNames::zAttr)
132         return lightSource->setZ(lightElement->z());
133     if (attrName == SVGNames::pointsAtXAttr)
134         return lightSource->setPointsAtX(lightElement->pointsAtX());
135     if (attrName == SVGNames::pointsAtYAttr)
136         return lightSource->setPointsAtY(lightElement->pointsAtY());
137     if (attrName == SVGNames::pointsAtZAttr)
138         return lightSource->setPointsAtZ(lightElement->pointsAtZ());
139     if (attrName == SVGNames::specularExponentAttr)
140         return lightSource->setSpecularExponent(lightElement->specularExponent());
141     if (attrName == SVGNames::limitingConeAngleAttr)
142         return lightSource->setLimitingConeAngle(lightElement->limitingConeAngle());
143
144     ASSERT_NOT_REACHED();
145     return false;
146 }
147
148 void SVGFEDiffuseLightingElement::svgAttributeChanged(const QualifiedName& attrName)
149 {
150     if (attrName == SVGNames::surfaceScaleAttr || attrName == SVGNames::diffuseConstantAttr || attrName == SVGNames::kernelUnitLengthAttr || attrName == SVGNames::lighting_colorAttr) {
151         InstanceInvalidationGuard guard(*this);
152         primitiveAttributeChanged(attrName);
153         return;
154     }
155
156     if (attrName == SVGNames::inAttr) {
157         InstanceInvalidationGuard guard(*this);
158         invalidate();
159         return;
160     }
161
162     SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
163 }
164
165 void SVGFEDiffuseLightingElement::lightElementAttributeChanged(const SVGFELightElement* lightElement, const QualifiedName& attrName)
166 {
167     if (SVGFELightElement::findLightElement(this) != lightElement)
168         return;
169
170     // The light element has different attribute names.
171     primitiveAttributeChanged(attrName);
172 }
173
174 RefPtr<FilterEffect> SVGFEDiffuseLightingElement::build(SVGFilterBuilder* filterBuilder, Filter& filter)
175 {
176     FilterEffect* input1 = filterBuilder->getEffectById(in1());
177
178     if (!input1)
179         return nullptr;
180
181     auto lightSource = SVGFELightElement::findLightSource(this);
182     if (!lightSource)
183         return nullptr;
184
185     RenderObject* renderer = this->renderer();
186     if (!renderer)
187         return nullptr;
188
189     const Color& color = renderer->style().svgStyle().lightingColor();
190
191     RefPtr<FilterEffect> effect = FEDiffuseLighting::create(filter, color, surfaceScale(), diffuseConstant(),
192                                                                 kernelUnitLengthX(), kernelUnitLengthY(), WTFMove(lightSource));
193     effect->inputEffects().append(input1);
194     return effect;
195 }
196
197 }