5f29e0fa41b477e283050aa44551eba92736ca24
[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     ColorComponents(T a = 0, T b = 0, T c = 0, T d = 0)
38         : components { a, b, c, d }
39     {
40     }
41
42     ColorComponents(const std::array<T, 4>& values)
43         : components { values }
44     {
45     }
46
47     ColorComponents& operator+=(const ColorComponents& rhs)
48     {
49         components[0] += rhs.components[0];
50         components[1] += rhs.components[1];
51         components[2] += rhs.components[2];
52         components[3] += rhs.components[3];
53         return *this;
54     }
55
56     ColorComponents operator+(T rhs) const
57     {
58         return {
59             components[0] + rhs,
60             components[1] + rhs,
61             components[2] + rhs,
62             components[3] + rhs
63         };
64     }
65
66     ColorComponents operator/(T denominator) const
67     {
68         return {
69             components[0] / denominator,
70             components[1] / denominator,
71             components[2] / denominator,
72             components[3] / denominator
73         };
74     }
75
76     ColorComponents operator*(T factor) const
77     {
78         return {
79             components[0] * factor,
80             components[1] * factor,
81             components[2] * factor,
82             components[3] * factor
83         };
84     }
85
86     ColorComponents abs() const
87     {
88         return {
89             std::abs(components[0]),
90             std::abs(components[1]),
91             std::abs(components[2]),
92             std::abs(components[3])
93         };
94     }
95
96     template<std::size_t N>
97     T get() const
98     {
99         return components[N];
100     }
101
102     std::array<T, 4> components;
103 };
104
105
106 template<typename T>
107 inline ColorComponents<T> perComponentMax(const ColorComponents<T>& a, const ColorComponents<T>& b)
108 {
109     return {
110         std::max(a.components[0], b.components[0]),
111         std::max(a.components[1], b.components[1]),
112         std::max(a.components[2], b.components[2]),
113         std::max(a.components[3], b.components[3])
114     };
115 }
116
117 template<typename T>
118 inline ColorComponents<T> perComponentMin(const ColorComponents<T>& a, const ColorComponents<T>& b)
119 {
120     return {
121         std::min(a.components[0], b.components[0]),
122         std::min(a.components[1], b.components[1]),
123         std::min(a.components[2], b.components[2]),
124         std::min(a.components[3], b.components[3])
125     };
126 }
127
128 template<typename T>
129 inline bool operator==(const ColorComponents<T>& a, const ColorComponents<T>& b)
130 {
131     return a.components == b.components;
132 }
133
134 template<typename T>
135 inline bool operator!=(const ColorComponents<T>& a, const ColorComponents<T>& b)
136 {
137     return !(a == b);
138 }
139
140 } // namespace WebCore
141
142 namespace std {
143
144 template<typename T>
145 class tuple_size<WebCore::ColorComponents<T>> : public std::integral_constant<std::size_t, 4> {
146 };
147
148 template<std::size_t N, typename T>
149 class tuple_element<N, WebCore::ColorComponents<T>> {
150 public:
151     using type = T;
152 };
153
154 }