Line data Source code
1 : /**
2 : Copyright (c) 2023-2024 Stappler LLC <admin@stappler.dev>
3 :
4 : Permission is hereby granted, free of charge, to any person obtaining a copy
5 : of this software and associated documentation files (the "Software"), to deal
6 : in the Software without restriction, including without limitation the rights
7 : to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 : copies of the Software, and to permit persons to whom the Software is
9 : furnished to do so, subject to the following conditions:
10 :
11 : The above copyright notice and this permission notice shall be included in
12 : all copies or substantial portions of the Software.
13 :
14 : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 : IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 : FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 : AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 : LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 : OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 : THE SOFTWARE.
21 : **/
22 :
23 : #ifndef CORE_GEOM_SPGEOM_H_
24 : #define CORE_GEOM_SPGEOM_H_
25 :
26 : #include "SPCommon.h"
27 :
28 : namespace STAPPLER_VERSIONIZED stappler::geom {
29 :
30 : namespace {
31 :
32 : template <typename T>
33 : struct _StructFieldCount {
34 : static constexpr size_t Count = T::Dimansions;
35 : };
36 :
37 : template <>
38 : struct _StructFieldCount<float> {
39 : static constexpr size_t Count = 1;
40 : };
41 :
42 : template <typename T>
43 : struct _ApplyTrait {
44 : using Bitset = std::bitset<_StructFieldCount<T>::Count>;
45 :
46 : template <typename Functor>
47 150 : static constexpr T apply(const T &t, const Functor &f) {
48 150 : return T(t, f);
49 : }
50 :
51 : template <typename Functor>
52 : static constexpr T apply(const T &t1, const T &t2, const Functor &f) {
53 : return T(t1, t2, f);
54 : }
55 :
56 : template <typename Functor>
57 : static constexpr Bitset bitop(const T &t, const Functor &f) {
58 : return T::bitop(t, f);
59 : }
60 :
61 : template <typename Functor>
62 : static constexpr Bitset bitop(const T &t1, const T &t2, const Functor &f) {
63 : return T::bitop(t1, t2, f);
64 : }
65 : };
66 :
67 : template <>
68 : struct _ApplyTrait<float> {
69 : using Bitset = std::bitset<_StructFieldCount<float>::Count>;
70 :
71 : template <typename Functor>
72 50 : static constexpr float apply(const float &t, const Functor &f) {
73 50 : return f(t);
74 : }
75 :
76 : template <typename Functor>
77 : static constexpr float apply(const float &t1, const float &t2, const Functor &f) {
78 : return f(t1, t2);
79 : }
80 :
81 : template <typename Functor>
82 : static constexpr Bitset bitop(const float &t, const Functor &f) {
83 : Bitset ret;
84 : ret.set(0, f(t));
85 : return ret;
86 : }
87 :
88 : template <typename Functor>
89 : static constexpr Bitset bitop(const float &t1, const float &t2, const Functor &f) {
90 : Bitset ret;
91 : ret.set(0, f(t1, t2));
92 : return ret;
93 : }
94 : };
95 :
96 : }
97 :
98 : template <typename T>
99 : inline constexpr T fill(float v) {
100 : return T::fill(v);
101 : }
102 :
103 : inline constexpr float fill(float v) {
104 : return v;
105 : }
106 :
107 : template <typename T, typename Functor>
108 200 : inline constexpr T apply(const T &t, const Functor &f) {
109 200 : return _ApplyTrait<T>::apply(t, f);
110 : }
111 :
112 : template <typename T, typename Functor>
113 : inline constexpr T apply(const T &t1, const T &t2, const Functor &f) {
114 : return _ApplyTrait<T>::apply(t1, t2, f);
115 : }
116 :
117 : template <typename T, typename Functor>
118 : inline constexpr auto bitop(const T &t, const Functor &f) -> std::bitset<_StructFieldCount<T>::Count> {
119 : return _ApplyTrait<T>::bitop(t, f);
120 : }
121 :
122 : template <typename T, typename Functor>
123 : inline constexpr auto bitop(const T &t1, const T &t2, const Functor &f) -> std::bitset<_StructFieldCount<T>::Count> {
124 : return _ApplyTrait<T>::bitop(t1, t2, f);
125 : }
126 :
127 : template <typename T>
128 100 : inline constexpr T _abs(const T &t) {
129 350 : return apply(t, [] (float v) { return std::abs(v); });
130 : }
131 :
132 : template <typename T>
133 : inline constexpr T _ceil(const T &t) {
134 : return apply(t, [] (float v) { return std::ceil(v); });
135 : }
136 :
137 : template <typename T>
138 100 : inline constexpr T _floor(const T &t) {
139 350 : return apply(t, [] (float v) { return std::floor(v); });
140 : }
141 :
142 : template <typename T>
143 : inline constexpr T _trunc(const T &t) {
144 : return apply(t, [] (float v) { return std::trunc(v); });
145 : }
146 :
147 : template <typename T>
148 : inline constexpr T _fract(const T &t) {
149 : return apply(t, [] (float v) {
150 : float tmp;
151 : return std::modf(v, &tmp);
152 : });
153 : }
154 :
155 : template <typename T>
156 : inline constexpr T _round(const T &t) {
157 : return apply(t, [] (float v) { return std::round(v); });
158 : }
159 :
160 : template <typename T>
161 : inline constexpr T _sign(const T &t) {
162 : return apply(t, [] (float v) { return std::copysign(1.0f, v); });
163 : }
164 :
165 : template <typename T>
166 : inline constexpr T _inversesqrt(const T &t) {
167 : return apply(t, [] (float v) { return 1.0f / std::sqrt(v); });
168 : }
169 :
170 : template <typename T>
171 : inline constexpr T _max(const T &t1, const T &t2) {
172 : return apply(t1, t2, [] (float v1, float v2) { return std::max(v1, v2); });
173 : }
174 :
175 : template <typename T>
176 : inline constexpr T _min(const T &t1, const T &t2) {
177 : return apply(t1, t2, [] (float v1, float v2) { return std::min(v1, v2); });
178 : }
179 :
180 : template <typename T>
181 : inline constexpr T _mod(const T &t1, const T &t2) {
182 : return apply(t1, t2, [] (float x, float y) { return x - y * std::floor(x / y); });
183 : }
184 :
185 : template <typename T>
186 : inline constexpr T _step(const T &t1, const T &t2) {
187 : return apply(t1, t2, [] (float edge, float x) { return (x < edge) ? 0.0f : 1.0f; });
188 : }
189 :
190 : template <typename T>
191 : inline constexpr auto _equal(const T &l, const T &r) {
192 : return bitop(l, r, [] (float lv, float rv) { return lv == rv; });
193 : }
194 :
195 : template <typename T>
196 : inline constexpr auto _greaterThan(const T &l, const T &r) {
197 : return bitop(l, r, [] (float lv, float rv) { return lv > rv; });
198 : }
199 :
200 : template <typename T>
201 : inline constexpr auto _greaterThanEqual(const T &l, const T &r) {
202 : return bitop(l, r, [] (float lv, float rv) { return lv >= rv; });
203 : }
204 :
205 : template <typename T>
206 : inline constexpr auto _lessThan(const T &l, const T &r) {
207 : return bitop(l, r, [] (float lv, float rv) { return lv < rv; });
208 : }
209 :
210 : template <typename T>
211 : inline constexpr auto _lessThanEqual(const T &l, const T &r) {
212 : return bitop(l, r, [] (float lv, float rv) { return lv <= rv; });
213 : }
214 :
215 : template <typename T>
216 : inline constexpr auto _notEqual(const T &l, const T &r) {
217 : return bitop(l, r, [] (float lv, float rv) { return lv != rv; });
218 : }
219 :
220 : template <typename T>
221 : inline constexpr auto _isinf(const T &t) {
222 : return bitop(t, [] (float v) { return std::isinf(v); });
223 : }
224 :
225 : template <typename T>
226 : inline constexpr auto _isnan(const T &t) {
227 : return bitop(t, [] (float v) { return std::isnan(v); });
228 : }
229 :
230 : }
231 :
232 : #endif /* CORE_GEOM_SPGEOM_H_ */
|
