Extended Color: ColorMatrix should support smaller matrices and be constexpr
[WebKit-https.git] / Source / WebCore / platform / graphics / ColorComponents.h
1 /*
2  * Copyright (C) 2017, 2020 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include <algorithm>
29 #include <array>
30 #include <math.h>
31 #include <tuple>
32
33 namespace WebCore {
34
35 template<typename T>
36 struct ColorComponents {
37     constexpr static size_t Size = 4;
38
39     constexpr ColorComponents(T a = 0, T b = 0, T c = 0, T d = 0)
40         : components { a, b, c, d }
41     {
42     }
43
44     constexpr ColorComponents& operator+=(const ColorComponents&);
45
46     constexpr ColorComponents operator+(T) const;
47     constexpr ColorComponents operator/(T) const;
48     constexpr ColorComponents operator*(T) const;
49
50     constexpr ColorComponents abs() const;
51
52     template<std::size_t N>
53     constexpr T get() const;
54
55     std::array<T, Size> components;
56 };
57
58 template<typename T>
59 constexpr ColorComponents<T>& ColorComponents<T>::operator+=(const ColorComponents& rhs)
60 {
61     components[0] += rhs.components[0];
62     components[1] += rhs.components[1];
63     components[2] += rhs.components[2];
64     components[3] += rhs.components[3];
65     return *this;
66 }
67
68 template<typename T>
69 constexpr ColorComponents<T> ColorComponents<T>::operator+(T rhs) const
70 {
71     return {
72         components[0] + rhs,
73         components[1] + rhs,
74         components[2] + rhs,
75         components[3] + rhs
76     };
77 }
78
79 template<typename T>
80 constexpr ColorComponents<T> ColorComponents<T>::operator/(T denominator) const
81 {
82     return {
83         components[0] / denominator,
84         components[1] / denominator,
85         components[2] / denominator,
86         components[3] / denominator
87     };
88 }
89
90 template<typename T>
91 constexpr ColorComponents<T> ColorComponents<T>::operator*(T factor) const
92 {
93     return {
94         components[0] * factor,
95         components[1] * factor,
96         components[2] * factor,
97         components[3] * factor
98     };
99 }
100
101 template<typename T>
102 constexpr ColorComponents<T> ColorComponents<T>::abs() const
103 {
104     return {
105         std::abs(components[0]),
106         std::abs(components[1]),
107         std::abs(components[2]),
108         std::abs(components[3])
109     };
110 }
111
112 template<typename T>
113 template<std::size_t N>
114 constexpr T ColorComponents<T>::get() const
115 {
116     return components[N];
117 }
118
119 template<typename T>
120 constexpr ColorComponents<T> perComponentMax(const ColorComponents<T>& a, const ColorComponents<T>& b)
121 {
122     return {
123         std::max(a.components[0], b.components[0]),
124         std::max(a.components[1], b.components[1]),
125         std::max(a.components[2], b.components[2]),
126         std::max(a.components[3], b.components[3])
127     };
128 }
129
130 template<typename T>
131 constexpr ColorComponents<T> perComponentMin(const ColorComponents<T>& a, const ColorComponents<T>& b)
132 {
133     return {
134         std::min(a.components[0], b.components[0]),
135         std::min(a.components[1], b.components[1]),
136         std::min(a.components[2], b.components[2]),
137         std::min(a.components[3], b.components[3])
138     };
139 }
140
141 template<typename T>
142 constexpr bool operator==(const ColorComponents<T>& a, const ColorComponents<T>& b)
143 {
144     return a.components == b.components;
145 }
146
147 template<typename T>
148 constexpr bool operator!=(const ColorComponents<T>& a, const ColorComponents<T>& b)
149 {
150     return !(a == b);
151 }
152
153 } // namespace WebCore
154
155 namespace std {
156
157 template<typename T>
158 class tuple_size<WebCore::ColorComponents<T>> : public std::integral_constant<std::size_t, WebCore::ColorComponents<T>::Size> {
159 };
160
161 template<std::size_t N, typename T>
162 class tuple_element<N, WebCore::ColorComponents<T>> {
163 public:
164     using type = T;
165 };
166
167 }