CoCalc -- variant

GitHub Repository: godotengine/godot
Path: blob/master/core/variant/variant_setget.h
⁹⁹⁰³ views
1
/**************************************************************************/
2
/*  variant_setget.h                                                      */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
#pragma once
32

33
#include "variant.h"
34

35
#include "core/debugger/engine_debugger.h"
36
#include "core/object/class_db.h"
37
#include "core/variant/variant_internal.h"
38

39
/**** NAMED SETTERS AND GETTERS ****/
40

41
#define SETGET_STRUCT(m_base_type, m_member_type, m_member)                                                                          \
42
	struct VariantSetGet_##m_base_type##_##m_member {                                                                                \
43
		static void get(const Variant *base, Variant *member) {                                                                      \
44
			VariantTypeAdjust<m_member_type>::adjust(member);                                                                        \
45
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member;    \
46
		}                                                                                                                            \
47
		static inline void validated_get(const Variant *base, Variant *member) {                                                     \
48
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member;    \
49
		}                                                                                                                            \
50
		static void ptr_get(const void *base, void *member) {                                                                        \
51
			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                                  \
52
		}                                                                                                                            \
53
		static void set(Variant *base, const Variant *value, bool &valid) {                                                          \
54
			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                     \
55
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
56
				valid = true;                                                                                                        \
57
			} else {                                                                                                                 \
58
				valid = false;                                                                                                       \
59
			}                                                                                                                        \
60
		}                                                                                                                            \
61
		static inline void validated_set(Variant *base, const Variant *value) {                                                      \
62
			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value);     \
63
		}                                                                                                                            \
64
		static void ptr_set(void *base, const void *member) {                                                                        \
65
			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                    \
66
			b.m_member = PtrToArg<m_member_type>::convert(member);                                                                   \
67
			PtrToArg<m_base_type>::encode(b, base);                                                                                  \
68
		}                                                                                                                            \
69
		static Variant::Type get_type() {                                                                                            \
70
			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                         \
71
		}                                                                                                                            \
72
	};
73

74
#define SETGET_NUMBER_STRUCT(m_base_type, m_member_type, m_member)                                                                \
75
	struct VariantSetGet_##m_base_type##_##m_member {                                                                             \
76
		static void get(const Variant *base, Variant *member) {                                                                   \
77
			VariantTypeAdjust<m_member_type>::adjust(member);                                                                     \
78
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
79
		}                                                                                                                         \
80
		static inline void validated_get(const Variant *base, Variant *member) {                                                  \
81
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member; \
82
		}                                                                                                                         \
83
		static void ptr_get(const void *base, void *member) {                                                                     \
84
			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_member, member);                               \
85
		}                                                                                                                         \
86
		static void set(Variant *base, const Variant *value, bool &valid) {                                                       \
87
			if (value->get_type() == Variant::FLOAT) {                                                                            \
88
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<double>::get_ptr(value);     \
89
				valid = true;                                                                                                     \
90
			} else if (value->get_type() == Variant::INT) {                                                                       \
91
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<int64_t>::get_ptr(value);    \
92
				valid = true;                                                                                                     \
93
			} else {                                                                                                              \
94
				valid = false;                                                                                                    \
95
			}                                                                                                                     \
96
		}                                                                                                                         \
97
		static inline void validated_set(Variant *base, const Variant *value) {                                                   \
98
			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_member = *VariantGetInternalPtr<m_member_type>::get_ptr(value);  \
99
		}                                                                                                                         \
100
		static void ptr_set(void *base, const void *member) {                                                                     \
101
			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                 \
102
			b.m_member = PtrToArg<m_member_type>::convert(member);                                                                \
103
			PtrToArg<m_base_type>::encode(b, base);                                                                               \
104
		}                                                                                                                         \
105
		static Variant::Type get_type() {                                                                                         \
106
			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                      \
107
		}                                                                                                                         \
108
	};
109

110
#define SETGET_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                                         \
111
	struct VariantSetGet_##m_base_type##_##m_member {                                                                                \
112
		static void get(const Variant *base, Variant *member) {                                                                      \
113
			VariantTypeAdjust<m_member_type>::adjust(member);                                                                        \
114
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom;    \
115
		}                                                                                                                            \
116
		static inline void validated_get(const Variant *base, Variant *member) {                                                     \
117
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom;    \
118
		}                                                                                                                            \
119
		static void ptr_get(const void *base, void *member) {                                                                        \
120
			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                                  \
121
		}                                                                                                                            \
122
		static void set(Variant *base, const Variant *value, bool &valid) {                                                          \
123
			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                     \
124
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value); \
125
				valid = true;                                                                                                        \
126
			} else {                                                                                                                 \
127
				valid = false;                                                                                                       \
128
			}                                                                                                                        \
129
		}                                                                                                                            \
130
		static inline void validated_set(Variant *base, const Variant *value) {                                                      \
131
			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value);     \
132
		}                                                                                                                            \
133
		static void ptr_set(void *base, const void *member) {                                                                        \
134
			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                    \
135
			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                                   \
136
			PtrToArg<m_base_type>::encode(b, base);                                                                                  \
137
		}                                                                                                                            \
138
		static Variant::Type get_type() {                                                                                            \
139
			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                         \
140
		}                                                                                                                            \
141
	};
142

143
#define SETGET_NUMBER_STRUCT_CUSTOM(m_base_type, m_member_type, m_member, m_custom)                                               \
144
	struct VariantSetGet_##m_base_type##_##m_member {                                                                             \
145
		static void get(const Variant *base, Variant *member) {                                                                   \
146
			VariantTypeAdjust<m_member_type>::adjust(member);                                                                     \
147
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
148
		}                                                                                                                         \
149
		static inline void validated_get(const Variant *base, Variant *member) {                                                  \
150
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom; \
151
		}                                                                                                                         \
152
		static void ptr_get(const void *base, void *member) {                                                                     \
153
			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_custom, member);                               \
154
		}                                                                                                                         \
155
		static void set(Variant *base, const Variant *value, bool &valid) {                                                       \
156
			if (value->get_type() == Variant::FLOAT) {                                                                            \
157
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<double>::get_ptr(value);     \
158
				valid = true;                                                                                                     \
159
			} else if (value->get_type() == Variant::INT) {                                                                       \
160
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<int64_t>::get_ptr(value);    \
161
				valid = true;                                                                                                     \
162
			} else {                                                                                                              \
163
				valid = false;                                                                                                    \
164
			}                                                                                                                     \
165
		}                                                                                                                         \
166
		static inline void validated_set(Variant *base, const Variant *value) {                                                   \
167
			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_custom = *VariantGetInternalPtr<m_member_type>::get_ptr(value);  \
168
		}                                                                                                                         \
169
		static void ptr_set(void *base, const void *member) {                                                                     \
170
			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                 \
171
			b.m_custom = PtrToArg<m_member_type>::convert(member);                                                                \
172
			PtrToArg<m_base_type>::encode(b, base);                                                                               \
173
		}                                                                                                                         \
174
		static Variant::Type get_type() {                                                                                         \
175
			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                      \
176
		}                                                                                                                         \
177
	};
178

179
#define SETGET_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                                \
180
	struct VariantSetGet_##m_base_type##_##m_member {                                                                               \
181
		static void get(const Variant *base, Variant *member) {                                                                     \
182
			VariantTypeAdjust<m_member_type>::adjust(member);                                                                       \
183
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
184
		}                                                                                                                           \
185
		static inline void validated_get(const Variant *base, Variant *member) {                                                    \
186
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
187
		}                                                                                                                           \
188
		static void ptr_get(const void *base, void *member) {                                                                       \
189
			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                               \
190
		}                                                                                                                           \
191
		static void set(Variant *base, const Variant *value, bool &valid) {                                                         \
192
			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                    \
193
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
194
				valid = true;                                                                                                       \
195
			} else {                                                                                                                \
196
				valid = false;                                                                                                      \
197
			}                                                                                                                       \
198
		}                                                                                                                           \
199
		static inline void validated_set(Variant *base, const Variant *value) {                                                     \
200
			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
201
		}                                                                                                                           \
202
		static void ptr_set(void *base, const void *member) {                                                                       \
203
			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                   \
204
			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                                   \
205
			PtrToArg<m_base_type>::encode(b, base);                                                                                 \
206
		}                                                                                                                           \
207
		static Variant::Type get_type() {                                                                                           \
208
			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                        \
209
		}                                                                                                                           \
210
	};
211

212
#define SETGET_NUMBER_STRUCT_FUNC(m_base_type, m_member_type, m_member, m_setter, m_getter)                                         \
213
	struct VariantSetGet_##m_base_type##_##m_member {                                                                               \
214
		static void get(const Variant *base, Variant *member) {                                                                     \
215
			VariantTypeAdjust<m_member_type>::adjust(member);                                                                       \
216
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
217
		}                                                                                                                           \
218
		static inline void validated_get(const Variant *base, Variant *member) {                                                    \
219
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(); \
220
		}                                                                                                                           \
221
		static void ptr_get(const void *base, void *member) {                                                                       \
222
			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(), member);                               \
223
		}                                                                                                                           \
224
		static void set(Variant *base, const Variant *value, bool &valid) {                                                         \
225
			if (value->get_type() == Variant::FLOAT) {                                                                              \
226
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<double>::get_ptr(value));        \
227
				valid = true;                                                                                                       \
228
			} else if (value->get_type() == Variant::INT) {                                                                         \
229
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<int64_t>::get_ptr(value));       \
230
				valid = true;                                                                                                       \
231
			} else {                                                                                                                \
232
				valid = false;                                                                                                      \
233
			}                                                                                                                       \
234
		}                                                                                                                           \
235
		static inline void validated_set(Variant *base, const Variant *value) {                                                     \
236
			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(*VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
237
		}                                                                                                                           \
238
		static void ptr_set(void *base, const void *member) {                                                                       \
239
			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                   \
240
			b.m_setter(PtrToArg<m_member_type>::convert(member));                                                                   \
241
			PtrToArg<m_base_type>::encode(b, base);                                                                                 \
242
		}                                                                                                                           \
243
		static Variant::Type get_type() {                                                                                           \
244
			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                        \
245
		}                                                                                                                           \
246
	};
247

248
#define SETGET_STRUCT_FUNC_INDEX(m_base_type, m_member_type, m_member, m_setter, m_getter, m_index)                                          \
249
	struct VariantSetGet_##m_base_type##_##m_member {                                                                                        \
250
		static void get(const Variant *base, Variant *member) {                                                                              \
251
			VariantTypeAdjust<m_member_type>::adjust(member);                                                                                \
252
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index);   \
253
		}                                                                                                                                    \
254
		static inline void validated_get(const Variant *base, Variant *member) {                                                             \
255
			*VariantGetInternalPtr<m_member_type>::get_ptr(member) = VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_getter(m_index);   \
256
		}                                                                                                                                    \
257
		static void ptr_get(const void *base, void *member) {                                                                                \
258
			PtrToArg<m_member_type>::encode(PtrToArg<m_base_type>::convert(base).m_getter(m_index), member);                                 \
259
		}                                                                                                                                    \
260
		static void set(Variant *base, const Variant *value, bool &valid) {                                                                  \
261
			if (value->get_type() == GetTypeInfo<m_member_type>::VARIANT_TYPE) {                                                             \
262
				VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value)); \
263
				valid = true;                                                                                                                \
264
			} else {                                                                                                                         \
265
				valid = false;                                                                                                               \
266
			}                                                                                                                                \
267
		}                                                                                                                                    \
268
		static inline void validated_set(Variant *base, const Variant *value) {                                                              \
269
			VariantGetInternalPtr<m_base_type>::get_ptr(base)->m_setter(m_index, *VariantGetInternalPtr<m_member_type>::get_ptr(value));     \
270
		}                                                                                                                                    \
271
		static void ptr_set(void *base, const void *member) {                                                                                \
272
			m_base_type b = PtrToArg<m_base_type>::convert(base);                                                                            \
273
			b.m_setter(m_index, PtrToArg<m_member_type>::convert(member));                                                                   \
274
			PtrToArg<m_base_type>::encode(b, base);                                                                                          \
275
		}                                                                                                                                    \
276
		static Variant::Type get_type() {                                                                                                    \
277
			return GetTypeInfo<m_member_type>::VARIANT_TYPE;                                                                                 \
278
		}                                                                                                                                    \
279
	};
280

281
SETGET_NUMBER_STRUCT(Vector2, double, x)
282
SETGET_NUMBER_STRUCT(Vector2, double, y)
283

284
SETGET_NUMBER_STRUCT(Vector2i, int64_t, x)
285
SETGET_NUMBER_STRUCT(Vector2i, int64_t, y)
286

287
SETGET_NUMBER_STRUCT(Vector3, double, x)
288
SETGET_NUMBER_STRUCT(Vector3, double, y)
289
SETGET_NUMBER_STRUCT(Vector3, double, z)
290

291
SETGET_NUMBER_STRUCT(Vector3i, int64_t, x)
292
SETGET_NUMBER_STRUCT(Vector3i, int64_t, y)
293
SETGET_NUMBER_STRUCT(Vector3i, int64_t, z)
294

295
SETGET_NUMBER_STRUCT(Vector4, double, x)
296
SETGET_NUMBER_STRUCT(Vector4, double, y)
297
SETGET_NUMBER_STRUCT(Vector4, double, z)
298
SETGET_NUMBER_STRUCT(Vector4, double, w)
299

300
SETGET_NUMBER_STRUCT(Vector4i, int64_t, x)
301
SETGET_NUMBER_STRUCT(Vector4i, int64_t, y)
302
SETGET_NUMBER_STRUCT(Vector4i, int64_t, z)
303
SETGET_NUMBER_STRUCT(Vector4i, int64_t, w)
304

305
SETGET_STRUCT(Rect2, Vector2, position)
306
SETGET_STRUCT(Rect2, Vector2, size)
307
SETGET_STRUCT_FUNC(Rect2, Vector2, end, set_end, get_end)
308

309
SETGET_STRUCT(Rect2i, Vector2i, position)
310
SETGET_STRUCT(Rect2i, Vector2i, size)
311
SETGET_STRUCT_FUNC(Rect2i, Vector2i, end, set_end, get_end)
312

313
SETGET_STRUCT(AABB, Vector3, position)
314
SETGET_STRUCT(AABB, Vector3, size)
315
SETGET_STRUCT_FUNC(AABB, Vector3, end, set_end, get_end)
316

317
SETGET_STRUCT_CUSTOM(Transform2D, Vector2, x, columns[0])
318
SETGET_STRUCT_CUSTOM(Transform2D, Vector2, y, columns[1])
319
SETGET_STRUCT_CUSTOM(Transform2D, Vector2, origin, columns[2])
320

321
SETGET_NUMBER_STRUCT_CUSTOM(Plane, double, x, normal.x)
322
SETGET_NUMBER_STRUCT_CUSTOM(Plane, double, y, normal.y)
323
SETGET_NUMBER_STRUCT_CUSTOM(Plane, double, z, normal.z)
324
SETGET_STRUCT(Plane, Vector3, normal)
325
SETGET_NUMBER_STRUCT(Plane, double, d)
326

327
SETGET_NUMBER_STRUCT(Quaternion, double, x)
328
SETGET_NUMBER_STRUCT(Quaternion, double, y)
329
SETGET_NUMBER_STRUCT(Quaternion, double, z)
330
SETGET_NUMBER_STRUCT(Quaternion, double, w)
331

332
SETGET_STRUCT_FUNC_INDEX(Basis, Vector3, x, set_column, get_column, 0)
333
SETGET_STRUCT_FUNC_INDEX(Basis, Vector3, y, set_column, get_column, 1)
334
SETGET_STRUCT_FUNC_INDEX(Basis, Vector3, z, set_column, get_column, 2)
335

336
SETGET_STRUCT(Transform3D, Basis, basis)
337
SETGET_STRUCT(Transform3D, Vector3, origin)
338

339
SETGET_STRUCT_CUSTOM(Projection, Vector4, x, columns[0])
340
SETGET_STRUCT_CUSTOM(Projection, Vector4, y, columns[1])
341
SETGET_STRUCT_CUSTOM(Projection, Vector4, z, columns[2])
342
SETGET_STRUCT_CUSTOM(Projection, Vector4, w, columns[3])
343

344
SETGET_NUMBER_STRUCT(Color, double, r)
345
SETGET_NUMBER_STRUCT(Color, double, g)
346
SETGET_NUMBER_STRUCT(Color, double, b)
347
SETGET_NUMBER_STRUCT(Color, double, a)
348

349
SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, r8, set_r8, get_r8)
350
SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, g8, set_g8, get_g8)
351
SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, b8, set_b8, get_b8)
352
SETGET_NUMBER_STRUCT_FUNC(Color, int64_t, a8, set_a8, get_a8)
353

354
SETGET_NUMBER_STRUCT_FUNC(Color, double, h, set_h, get_h)
355
SETGET_NUMBER_STRUCT_FUNC(Color, double, s, set_s, get_s)
356
SETGET_NUMBER_STRUCT_FUNC(Color, double, v, set_v, get_v)
357

358
SETGET_NUMBER_STRUCT_FUNC(Color, double, ok_hsl_h, set_ok_hsl_h, get_ok_hsl_h)
359
SETGET_NUMBER_STRUCT_FUNC(Color, double, ok_hsl_s, set_ok_hsl_s, get_ok_hsl_s)
360
SETGET_NUMBER_STRUCT_FUNC(Color, double, ok_hsl_l, set_ok_hsl_l, get_ok_hsl_l)
361

362
Product

Resources

Company
