Divide Framework 0.1
A free and open-source 3D Framework under heavy development
Loading...
Searching...
No Matches
EditorComponent.cpp
Go to the documentation of this file.
1
2
3#include "Headers/EditorComponent.h"
4
5#include "Core/Headers/ByteBuffer.h"
6#include "Core/Headers/PlatformContext.h"
7#include "Core/Headers/StringHelper.h"
8
9#include "Editor/Headers/Editor.h"
10#include "Core/Math/BoundingVolumes/Headers/BoundingSphere.h"
11#include "Geometry/Material/Headers/Material.h"
12#include "ECS/Components/Headers/TransformComponent.h"
13
14namespace Divide {
15 constexpr U16 BYTE_BUFFER_VERSION = 1u;
16
17 namespace {
18 std::string GetFullFieldName(const char* componentName, const Str<32>& fieldName)
19 {
20 return std::string{ Util::StringFormat<string>("{}.{}", componentName, Util::MakeXMLSafe(fieldName)).c_str() };
21 }
22 }
23
24 namespace TypeUtil
25 {
26 const char* ComponentTypeToString(const ComponentType compType) noexcept
27 {
28 for (U32 i = 1u; i < to_U32(ComponentType::COUNT) + 1; ++i)
29 {
30 if (1u << i == to_base(compType))
31 {
32 return Names::componentType[i - 1u];
33 }
34 }
35
36 return Names::componentType[to_base(ComponentType::COUNT)];
37 }
38
39 ComponentType StringToComponentType(const std::string_view name)
40 {
41 for (U32 i = 1u; i < to_U32(ComponentType::COUNT) + 1; ++i)
42 {
43 if (name == Names::componentType[i - 1u] )
44 {
45 return static_cast<ComponentType>(1 << i);
46 }
47 }
48
49 return ComponentType::COUNT;
50 }
51 }
52
53 EditorComponent::EditorComponent( PlatformContext& context, const ComponentType type, const std::string_view name)
54 : PlatformContextComponent(context)
55 , GUIDWrapper()
56 , _name(name)
57 , _componentType(type)
58 {
59 }
60
61 EditorComponent::~EditorComponent()
62 {
63 if constexpr(Config::Build::ENABLE_EDITOR)
64 {
65 Attorney::EditorEditorComponent::onRemoveComponent(context().editor(), *this);
66 }
67 }
68
69 void EditorComponent::registerField(EditorComponentField&& field)
70 {
71 dvd_erase_if(_fields, [&field](const EditorComponentField& it) { return it._name.compare(field._name) == 0 && it._type == field._type; });
72 assert(field._basicTypeSize == PushConstantSize::DWORD || field.supportsByteCount());
73
74 _fields.push_back(field);
75 }
76
77 void EditorComponent::onChanged(const EditorComponentField& field) const
78 {
79 if (_onChangedCbk)
80 {
81 _onChangedCbk(field._name.c_str());
82 }
83 }
84
85 // May be wrong endpoint
86 bool EditorComponent::saveCache(ByteBuffer& outputBuffer) const
87 {
88 outputBuffer << BYTE_BUFFER_VERSION;
89 NOP();
90 return true;
91 }
92
93 // May be wrong endpoint
94 bool EditorComponent::loadCache(ByteBuffer& inputBuffer)
95 {
96 auto tempVer = decltype(BYTE_BUFFER_VERSION){0};
97 inputBuffer >> tempVer;
98 if (tempVer == BYTE_BUFFER_VERSION )
99 {
100 NOP();
101 return true;
102 }
103
104 return false;
105 }
106
107 void EditorComponent::saveToXML(boost::property_tree::ptree& pt) const
108 {
109 pt.put(_name.c_str(), "");
110
111 for (const EditorComponentField& field : _fields)
112 {
113 auto entryName = GetFullFieldName(_name.c_str(), field._name);
114 if (!field._serialise)
115 {
116 continue;
117 }
118
119 switch(field._type)
120 {
121 case EditorComponentFieldType::SLIDER_TYPE:
122 case EditorComponentFieldType::PUSH_TYPE:
123 {
124 saveFieldToXML(field, pt);
125 } break;
126 case EditorComponentFieldType::TRANSFORM:
127 {
128 const TransformComponent* transform = field.getPtr<TransformComponent>();
129
130 const vec3<F32> scale = transform->getLocalScale();
131 const vec3<F32> position = transform->getLocalPosition();
132
133 vec3<Angle::DEGREES<F32>> orientationEuler;
134 const Quaternion<F32> orientation = transform->getLocalOrientation();
135 orientationEuler = Angle::to_DEGREES(orientation.getEuler());
136
137 pt.put(entryName + ".position.<xmlattr>.x", position.x);
138 pt.put(entryName + ".position.<xmlattr>.y", position.y);
139 pt.put(entryName + ".position.<xmlattr>.z", position.z);
140
141 pt.put(entryName + ".orientation.<xmlattr>.x", orientationEuler.pitch);
142 pt.put(entryName + ".orientation.<xmlattr>.y", orientationEuler.yaw);
143 pt.put(entryName + ".orientation.<xmlattr>.z", orientationEuler.roll);
144
145 pt.put(entryName + ".scale.<xmlattr>.x", scale.x);
146 pt.put(entryName + ".scale.<xmlattr>.y", scale.y);
147 pt.put(entryName + ".scale.<xmlattr>.z", scale.z);
148 }break;
149 case EditorComponentFieldType::MATERIAL:
150 {
151 field.getPtr<Material>()->saveToXML(entryName, pt);
152 }break;
153 default:
154 case EditorComponentFieldType::BUTTON:
155 {
156 //Skip
157 } break;
158 case EditorComponentFieldType::BOUNDING_BOX:
159 {
160 BoundingBox bb = {};
161 field.get<BoundingBox>(bb);
162
163 pt.put(entryName + ".aabb.min.<xmlattr>.x", bb.getMin().x);
164 pt.put(entryName + ".aabb.min.<xmlattr>.y", bb.getMin().y);
165 pt.put(entryName + ".aabb.min.<xmlattr>.z", bb.getMin().z);
166 pt.put(entryName + ".aabb.max.<xmlattr>.x", bb.getMax().x);
167 pt.put(entryName + ".aabb.max.<xmlattr>.y", bb.getMax().y);
168 pt.put(entryName + ".aabb.max.<xmlattr>.z", bb.getMax().z);
169 } break;
170 case EditorComponentFieldType::ORIENTED_BOUNDING_BOX:
171 {
172 // We don't save this to XML!
173 }break;
174 case EditorComponentFieldType::BOUNDING_SPHERE:
175 {
176 BoundingSphere bs = {};
177 field.get<BoundingSphere>(bs);
178
179 pt.put(entryName + ".aabb.center.<xmlattr>.x", bs.getCenter().x);
180 pt.put(entryName + ".aabb.center.<xmlattr>.y", bs.getCenter().y);
181 pt.put(entryName + ".aabb.center.<xmlattr>.z", bs.getCenter().z);
182 pt.put(entryName + ".aabb.radius", bs.getRadius());
183 }break;
184 }
185 }
186 }
187
188 void EditorComponent::loadFromXML(const boost::property_tree::ptree& pt)
189 {
190 if (!pt.get(_name.c_str(), "").empty())
191 {
192 for (EditorComponentField& field : _fields)
193 {
194 auto entryName = GetFullFieldName(_name.c_str(), field._name);
195 if (!field._serialise)
196 {
197 continue;
198 }
199
200 switch (field._type)
201 {
202 case EditorComponentFieldType::SLIDER_TYPE:
203 case EditorComponentFieldType::PUSH_TYPE:
204 {
205 loadFieldFromXML(field, pt);
206 } break;
207 case EditorComponentFieldType::TRANSFORM:
208 {
209 TransformComponent* transform = field.getPtr<TransformComponent>();
210
211 vec3<F32> scale;
212 vec3<F32> position;
213 vec3<Angle::DEGREES<F32>> orientationEuler;
214
215 position.set(pt.get<F32>(entryName + ".position.<xmlattr>.x", 0.0f),
216 pt.get<F32>(entryName + ".position.<xmlattr>.y", 0.0f),
217 pt.get<F32>(entryName + ".position.<xmlattr>.z", 0.0f));
218
219 orientationEuler.pitch = pt.get<F32>(entryName + ".orientation.<xmlattr>.x", 0.0f);
220 orientationEuler.yaw = pt.get<F32>(entryName + ".orientation.<xmlattr>.y", 0.0f);
221 orientationEuler.roll = pt.get<F32>(entryName + ".orientation.<xmlattr>.z", 0.0f);
222
223 scale.set(pt.get<F32>(entryName + ".scale.<xmlattr>.x", 1.0f),
224 pt.get<F32>(entryName + ".scale.<xmlattr>.y", 1.0f),
225 pt.get<F32>(entryName + ".scale.<xmlattr>.z", 1.0f));
226
227 Quaternion<F32> rotation;
228 rotation.fromEuler(orientationEuler);
229 transform->setScale(scale);
230 transform->setRotation(rotation);
231 transform->setPosition(position);
232 transform->resetCache();
233 } break;
234 case EditorComponentFieldType::MATERIAL:
235 {
236 Material* mat = field.getPtr<Material>();
237 mat->loadFromXML(entryName, pt);
238 } break;
239 default:
240 case EditorComponentFieldType::DROPDOWN_TYPE:
241 case EditorComponentFieldType::BUTTON:
242 {
243 // Skip
244 } break;
245 case EditorComponentFieldType::BOUNDING_BOX:
246 {
247 BoundingBox bb = {};
248 bb.setMin(
249 {
250 pt.get<F32>(entryName + ".aabb.min.<xmlattr>.x", -1.0f),
251 pt.get<F32>(entryName + ".aabb.min.<xmlattr>.y", -1.0f),
252 pt.get<F32>(entryName + ".aabb.min.<xmlattr>.z", -1.0f)
253 });
254 bb.setMax(
255 {
256 pt.get<F32>(entryName + ".aabb.max.<xmlattr>.x", 1.0f),
257 pt.get<F32>(entryName + ".aabb.max.<xmlattr>.y", 1.0f),
258 pt.get<F32>(entryName + ".aabb.max.<xmlattr>.z", 1.0f)
259 });
260 field.set<BoundingBox>(bb);
261 } break;
262 case EditorComponentFieldType::ORIENTED_BOUNDING_BOX:
263 {
264 // We don't load this from XML!
265 }break;
266 case EditorComponentFieldType::BOUNDING_SPHERE:
267 {
268 BoundingSphere bs = {};
269 bs.setCenter(
270 {
271 pt.get<F32>(entryName + ".aabb.center.<xmlattr>.x", 0.f),
272 pt.get<F32>(entryName + ".aabb.center.<xmlattr>.y", 0.f),
273 pt.get<F32>(entryName + ".aabb.center.<xmlattr>.z", 0.f)
274 });
275 bs.setRadius(pt.get<F32>(entryName + ".aabb.radius", 1.0f));
276 field.set<BoundingSphere>(bs);
277 } break;
278 }
279 }
280 }
281 }
282
283 namespace
284 {
285 template<typename T>
286 T GetClamped(const EditorComponentField& field, const boost::property_tree::ptree& pt, const char* name)
287 {
288 T val = pt.get(name, field.get<T>());
289 if (field._range.max - field._range.min > 1.f)
290 {
291 CLAMP(val, static_cast<T>(field._range.min), static_cast<T>(field._range.max));
292 }
293
294 return val;
295 }
296
297 template<typename T, size_t num_comp>
298 void saveVector(const std::string& entryName, const EditorComponentField& field, boost::property_tree::ptree& pt)
299 {
300 T data = {};
301 field.get<T>(data);
302
303 pt.put((entryName + ".<xmlattr>.x").c_str(), data.x);
304 pt.put((entryName + ".<xmlattr>.y").c_str(), data.y);
305 if constexpr (num_comp > 2)
306 {
307 pt.put((entryName + ".<xmlattr>.z").c_str(), data.z);
308 if constexpr(num_comp > 3)
309 {
310 pt.put((entryName + ".<xmlattr>.w").c_str(), data.w);
311 }
312 }
313 }
314
315 template<typename T, size_t num_comp>
316 void loadVector(const std::string& entryName, EditorComponentField& field, const boost::property_tree::ptree& pt)
317 {
318 T data = field.get<T>();
319
320 data.x = pt.get((entryName + ".<xmlattr>.x").c_str(), data.x);
321 data.y = pt.get((entryName + ".<xmlattr>.y").c_str(), data.y);
322
323 if constexpr(num_comp > 2)
324 {
325 data.z = pt.get((entryName + ".<xmlattr>.z").c_str(), data.z);
326 if constexpr(num_comp > 3)
327 {
328 data.w = pt.get((entryName + ".<xmlattr>.w").c_str(), data.w);
329 }
330 }
331
332 if (field._range.max - field._range.min > 1.f)
333 {
334 using U = decltype(data.x);
335
336 CLAMP(data.x, static_cast<U>(field._range.min), static_cast<U>(field._range.max));
337 CLAMP(data.y, static_cast<U>(field._range.min), static_cast<U>(field._range.max));
338 if constexpr(num_comp > 2)
339 {
340 CLAMP(data.z, static_cast<U>(field._range.min), static_cast<U>(field._range.max));
341 if constexpr(num_comp > 3)
342 {
343 CLAMP(data.w, static_cast<U>(field._range.min), static_cast<U>(field._range.max));
344 }
345 }
346 }
347
348 field.set<T>(data);
349 }
350
351 template<typename T, size_t num_rows>
352 void saveMatrix(const std::string& entryName, const EditorComponentField& field, boost::property_tree::ptree& pt)
353 {
354 T data = {};
355 field.get<T>(data);
356
357 pt.put((entryName + ".<xmlattr>.00").c_str(), data.m[0][0]);
358 pt.put((entryName + ".<xmlattr>.01").c_str(), data.m[0][1]);
359 pt.put((entryName + ".<xmlattr>.10").c_str(), data.m[1][0]);
360 pt.put((entryName + ".<xmlattr>.11").c_str(), data.m[1][1]);
361
362 if constexpr(num_rows > 2)
363 {
364 pt.put((entryName + ".<xmlattr>.02").c_str(), data.m[0][2]);
365 pt.put((entryName + ".<xmlattr>.12").c_str(), data.m[1][2]);
366 pt.put((entryName + ".<xmlattr>.20").c_str(), data.m[2][0]);
367 pt.put((entryName + ".<xmlattr>.21").c_str(), data.m[2][1]);
368 pt.put((entryName + ".<xmlattr>.22").c_str(), data.m[2][2]);
369
370 if constexpr(num_rows > 3)
371 {
372 pt.put((entryName + ".<xmlattr>.03").c_str(), data.m[0][3]);
373 pt.put((entryName + ".<xmlattr>.13").c_str(), data.m[1][3]);
374 pt.put((entryName + ".<xmlattr>.23").c_str(), data.m[2][3]);
375 pt.put((entryName + ".<xmlattr>.30").c_str(), data.m[3][0]);
376 pt.put((entryName + ".<xmlattr>.31").c_str(), data.m[3][1]);
377 pt.put((entryName + ".<xmlattr>.32").c_str(), data.m[3][2]);
378 pt.put((entryName + ".<xmlattr>.33").c_str(), data.m[3][3]);
379 }
380 }
381 }
382
383 template<typename T, size_t num_rows>
384 void loadMatrix(const std::string& entryName, EditorComponentField& field, const boost::property_tree::ptree& pt)
385 {
386 T data = field.get<T>();
387
388 data.m[0][0] = pt.get((entryName + ".<xmlattr>.00").c_str(), data.m[0][0]);
389 data.m[0][1] = pt.get((entryName + ".<xmlattr>.01").c_str(), data.m[0][1]);
390 data.m[1][0] = pt.get((entryName + ".<xmlattr>.10").c_str(), data.m[1][0]);
391 data.m[1][1] = pt.get((entryName + ".<xmlattr>.11").c_str(), data.m[1][1]);
392
393 if constexpr(num_rows > 2)
394 {
395 data.m[0][2] = pt.get((entryName + ".<xmlattr>.02").c_str(), data.m[0][2]);
396 data.m[1][2] = pt.get((entryName + ".<xmlattr>.12").c_str(), data.m[1][2]);
397 data.m[2][0] = pt.get((entryName + ".<xmlattr>.20").c_str(), data.m[2][0]);
398 data.m[2][1] = pt.get((entryName + ".<xmlattr>.21").c_str(), data.m[2][1]);
399 data.m[2][2] = pt.get((entryName + ".<xmlattr>.22").c_str(), data.m[2][2]);
400
401 if constexpr(num_rows > 3)
402 {
403 data.m[0][3] = pt.get((entryName + ".<xmlattr>.03").c_str(), data.m[0][3]);
404 data.m[1][3] = pt.get((entryName + ".<xmlattr>.13").c_str(), data.m[1][3]);
405 data.m[2][3] = pt.get((entryName + ".<xmlattr>.23").c_str(), data.m[2][3]);
406 data.m[3][0] = pt.get((entryName + ".<xmlattr>.30").c_str(), data.m[3][0]);
407 data.m[3][1] = pt.get((entryName + ".<xmlattr>.31").c_str(), data.m[3][1]);
408 data.m[3][2] = pt.get((entryName + ".<xmlattr>.32").c_str(), data.m[3][2]);
409 data.m[3][3] = pt.get((entryName + ".<xmlattr>.33").c_str(), data.m[3][3]);
410 }
411 }
412
413 if (field._range.max - field._range.min > 1.f)
414 {
415 using U = typename std::remove_reference<decltype(T::mat[0])>::type;
416 for (U8 i = 0u; i < num_rows * num_rows; ++i)
417 {
418 CLAMP(data.mat[i], static_cast<U>(field._range.min), static_cast<U>(field._range.max));
419 }
420 }
421
422 field.set<T>(data);
423 }
424 }
425
426 void EditorComponent::saveFieldToXML(const EditorComponentField& field, boost::property_tree::ptree& pt) const
427 {
428 auto entryName = GetFullFieldName(_name.c_str(), field._name);
429
430 switch (field._basicType)
431 {
432 case PushConstantType::BOOL:
433 {
434 pt.put(entryName.c_str(), field.get<bool>());
435 } break;
436 case PushConstantType::INT:
437 {
438 switch (field._basicTypeSize)
439 {
440 case PushConstantSize::QWORD: pt.put(entryName.c_str(), field.get<I64>()); break;
441 case PushConstantSize::DWORD: pt.put(entryName.c_str(), field.get<I32>()); break;
442 case PushConstantSize::WORD: pt.put(entryName.c_str(), field.get<I16>()); break;
443 case PushConstantSize::BYTE: pt.put(entryName.c_str(), field.get<I8>()); break;
444 default: DIVIDE_UNEXPECTED_CALL(); break;
445 }
446 } break;
447 case PushConstantType::UINT:
448 {
449 switch (field._basicTypeSize)
450 {
451 case PushConstantSize::QWORD: pt.put(entryName.c_str(), field.get<U64>()); break;
452 case PushConstantSize::DWORD: pt.put(entryName.c_str(), field.get<U32>()); break;
453 case PushConstantSize::WORD: pt.put(entryName.c_str(), field.get<U16>()); break;
454 case PushConstantSize::BYTE: pt.put(entryName.c_str(), field.get<U8>()); break;
455 default: DIVIDE_UNEXPECTED_CALL(); break;
456 }
457 } break;
458 case PushConstantType::FLOAT:
459 {
460 pt.put(entryName.c_str(), field.get<F32>());
461 } break;
462 case PushConstantType::DOUBLE:
463 {
464 pt.put(entryName.c_str(), field.get<D64>());
465 } break;
466 case PushConstantType::IVEC2:
467 {
468 switch (field._basicTypeSize)
469 {
470 case PushConstantSize::QWORD:
471 {
472 saveVector<vec2<I64>, 2>(entryName, field, pt);
473 } break;
474 case PushConstantSize::DWORD:
475 {
476 saveVector<vec2<I32>, 2>(entryName, field, pt);
477 } break;
478 case PushConstantSize::WORD:
479 {
480 saveVector<vec2<I16>, 2>(entryName, field, pt);
481 } break;
482 case PushConstantSize::BYTE:
483 {
484 saveVector<vec2<I8>, 2>(entryName, field, pt);
485 } break;
486 default: DIVIDE_UNEXPECTED_CALL(); break;
487 }
488 } break;
489 case PushConstantType::IVEC3:
490 {
491 switch (field._basicTypeSize)
492 {
493 case PushConstantSize::QWORD:
494 {
495 saveVector<vec3<I64>, 3>(entryName, field, pt);
496 } break;
497 case PushConstantSize::DWORD:
498 {
499 saveVector<vec3<I32>, 3>(entryName, field, pt);
500 } break;
501 case PushConstantSize::WORD:
502 {
503 saveVector<vec3<I16>, 3>(entryName, field, pt);
504 } break;
505 case PushConstantSize::BYTE:
506 {
507 saveVector<vec3<I8>, 3>(entryName, field, pt);
508 } break;
509 default: DIVIDE_UNEXPECTED_CALL(); break;
510 }
511 } break;
512 case PushConstantType::IVEC4:
513 {
514 switch (field._basicTypeSize)
515 {
516 case PushConstantSize::QWORD:
517 {
518 saveVector<vec4<I64>, 4>(entryName, field, pt);
519 } break;
520 case PushConstantSize::DWORD:
521 {
522 saveVector<vec4<I32>, 4>(entryName, field, pt);
523 } break;
524 case PushConstantSize::WORD:
525 {
526 saveVector<vec4<I16>, 4>(entryName, field, pt);
527 } break;
528 case PushConstantSize::BYTE:
529 {
530 saveVector<vec4<I8>, 4>(entryName, field, pt);
531 } break;
532 default: DIVIDE_UNEXPECTED_CALL(); break;
533 }
534 } break;
535 case PushConstantType::UVEC2:
536 {
537 switch (field._basicTypeSize)
538 {
539 case PushConstantSize::QWORD:
540 {
541 saveVector<vec2<U64>, 2>(entryName, field, pt);
542 } break;
543 case PushConstantSize::DWORD:
544 {
545 saveVector<vec2<U32>, 2>(entryName, field, pt);
546 } break;
547 case PushConstantSize::WORD:
548 {
549 saveVector<vec2<U16>, 2>(entryName, field, pt);
550 } break;
551 case PushConstantSize::BYTE:
552 {
553 saveVector<vec2<U8>, 2>(entryName, field, pt);
554 } break;
555 default: DIVIDE_UNEXPECTED_CALL(); break;
556 }
557 } break;
558 case PushConstantType::UVEC3:
559 {
560 switch (field._basicTypeSize)
561 {
562 case PushConstantSize::QWORD:
563 {
564 saveVector<vec3<U64>, 3>(entryName, field, pt);
565 } break;
566 case PushConstantSize::DWORD:
567 {
568 saveVector<vec3<U32>, 3>(entryName, field, pt);
569 } break;
570 case PushConstantSize::WORD:
571 {
572 saveVector<vec3<U16>, 3>(entryName, field, pt);
573 } break;
574 case PushConstantSize::BYTE:
575 {
576 saveVector<vec3<U8>, 3>(entryName, field, pt);
577 } break;
578 default: DIVIDE_UNEXPECTED_CALL(); break;
579 }
580 } break;
581 case PushConstantType::UVEC4:
582 {
583 switch (field._basicTypeSize)
584 {
585 case PushConstantSize::QWORD:
586 {
587 saveVector<vec4<U64>, 4>(entryName, field, pt);
588 } break;
589 case PushConstantSize::DWORD:
590 {
591 saveVector<vec4<U32>, 4>(entryName, field, pt);
592 } break;
593 case PushConstantSize::WORD:
594 {
595 saveVector<vec4<U16>, 4>(entryName, field, pt);
596 } break;
597 case PushConstantSize::BYTE:
598 {
599 saveVector<vec4<U8>, 4>(entryName, field, pt);
600 } break;
601 default: DIVIDE_UNEXPECTED_CALL(); break;
602 }
603 } break;
604 case PushConstantType::VEC2:
605 {
606 saveVector<vec2<F32>, 2>(entryName, field, pt);
607 } break;
608 case PushConstantType::VEC3:
609 {
610 saveVector<vec3<F32>, 3>(entryName, field, pt);
611 } break;
612 case PushConstantType::VEC4:
613 {
614 saveVector<vec4<F32>, 4>(entryName, field, pt);
615 } break;
616 case PushConstantType::DVEC2:
617 {
618 saveVector<vec2<D64>, 2>(entryName, field, pt);
619 } break;
620 case PushConstantType::DVEC3:
621 {
622 saveVector<vec3<D64>, 3>(entryName, field, pt);
623 } break;
624 case PushConstantType::DVEC4:
625 {
626 saveVector<vec4<D64>, 4>(entryName, field, pt);
627 } break;
628 case PushConstantType::IMAT2:
629 {
630 switch (field._basicTypeSize) {
631 case PushConstantSize::QWORD:
632 {
633 saveMatrix<mat2<I64>, 2>(entryName, field, pt);
634 } break;
635 case PushConstantSize::DWORD:
636 {
637 saveMatrix<mat2<I32>, 2>(entryName, field, pt);
638 } break;
639 case PushConstantSize::WORD:
640 {
641 saveMatrix<mat2<I16>, 2>(entryName, field, pt);
642 } break;
643 case PushConstantSize::BYTE:
644 {
645 saveMatrix<mat2<I8>, 2>(entryName, field, pt);
646 } break;
647 default: DIVIDE_UNEXPECTED_CALL(); break;
648 }
649 } break;
650 case PushConstantType::IMAT3:
651 {
652 switch (field._basicTypeSize)
653 {
654 case PushConstantSize::QWORD:
655 {
656 saveMatrix<mat3<I64>, 3>(entryName, field, pt);
657 } break;
658 case PushConstantSize::DWORD:
659 {
660 saveMatrix<mat3<I32>, 3>(entryName, field, pt);
661 } break;
662 case PushConstantSize::WORD:
663 {
664 saveMatrix<mat3<I16>, 3>(entryName, field, pt);
665 } break;
666 case PushConstantSize::BYTE:
667 {
668 saveMatrix<mat3<I8>, 3>(entryName, field, pt);
669 } break;
670 default: DIVIDE_UNEXPECTED_CALL(); break;
671 }
672 } break;
673 case PushConstantType::IMAT4:
674 {
675 switch (field._basicTypeSize)
676 {
677 case PushConstantSize::QWORD:
678 {
679 saveMatrix<mat4<I64>, 4>(entryName, field, pt);
680 } break;
681 case PushConstantSize::DWORD:
682 {
683 saveMatrix<mat4<I32>, 4>(entryName, field, pt);
684 } break;
685 case PushConstantSize::WORD:
686 {
687 saveMatrix<mat4<I16>, 4>(entryName, field, pt);
688 } break;
689 case PushConstantSize::BYTE:
690 {
691 saveMatrix<mat4<I8>, 4>(entryName, field, pt);
692 } break;
693 default: DIVIDE_UNEXPECTED_CALL(); break;
694 }
695 } break;
696 case PushConstantType::UMAT2:
697 {
698 switch (field._basicTypeSize)
699 {
700 case PushConstantSize::QWORD:
701 {
702 saveMatrix<mat2<U64>, 2>(entryName, field, pt);
703 } break;
704 case PushConstantSize::DWORD:
705 {
706 saveMatrix<mat2<U32>, 2>(entryName, field, pt);
707 } break;
708 case PushConstantSize::WORD:
709 {
710 saveMatrix<mat2<U16>, 2>(entryName, field, pt);
711 } break;
712 case PushConstantSize::BYTE:
713 {
714 saveMatrix<mat2<U8>, 2>(entryName, field, pt);
715 } break;
716 default: DIVIDE_UNEXPECTED_CALL(); break;
717 }
718 } break;
719 case PushConstantType::UMAT3:
720 {
721 switch (field._basicTypeSize)
722 {
723 case PushConstantSize::QWORD:
724 {
725 saveMatrix<mat3<U64>, 3>(entryName, field, pt);
726 } break;
727 case PushConstantSize::DWORD:
728 {
729 saveMatrix<mat3<U32>, 3>(entryName, field, pt);
730 } break;
731 case PushConstantSize::WORD:
732 {
733 saveMatrix<mat3<U16>, 3>(entryName, field, pt);
734 } break;
735 case PushConstantSize::BYTE:
736 {
737 saveMatrix<mat3<U8>, 3>(entryName, field, pt);
738 } break;
739 default: DIVIDE_UNEXPECTED_CALL(); break;
740 }
741 } break;
742 case PushConstantType::UMAT4:
743 {
744 switch (field._basicTypeSize)
745 {
746 case PushConstantSize::QWORD:
747 {
748 saveMatrix<mat4<U64>, 4>(entryName, field, pt);
749 } break;
750 case PushConstantSize::DWORD:
751 {
752 saveMatrix<mat4<U32>, 4>(entryName, field, pt);
753 } break;
754 case PushConstantSize::WORD:
755 {
756 saveMatrix<mat4<U16>, 4>(entryName, field, pt);
757 } break;
758 case PushConstantSize::BYTE:
759 {
760 saveMatrix<mat4<U8>, 4>(entryName, field, pt);
761 } break;
762 default: DIVIDE_UNEXPECTED_CALL(); break;
763 }
764 } break;
765 case PushConstantType::MAT2:
766 {
767 saveMatrix<mat2<F32>, 2>(entryName, field, pt);
768 } break;
769 case PushConstantType::MAT3:
770 {
771 saveMatrix<mat3<F32>, 3>(entryName, field, pt);
772 } break;
773 case PushConstantType::MAT4:
774 {
775 saveMatrix<mat4<F32>, 4>(entryName, field, pt);
776 } break;
777 case PushConstantType::DMAT2:
778 {
779 saveMatrix<mat2<D64>, 2>(entryName, field, pt);
780 } break;
781 case PushConstantType::DMAT3:
782 {
783 saveMatrix<mat3<D64>, 3>(entryName, field, pt);
784 } break;
785 case PushConstantType::DMAT4:
786 {
787 saveMatrix<mat4<D64>, 4>(entryName, field, pt);
788 } break;
789 case PushConstantType::FCOLOUR3:
790 {
791 FColour3 data = {};
792 field.get<FColour3>(data);
793 pt.put((entryName + ".<xmlattr>.r").c_str(), data.r);
794 pt.put((entryName + ".<xmlattr>.g").c_str(), data.g);
795 pt.put((entryName + ".<xmlattr>.b").c_str(), data.b);
796 } break;
797 case PushConstantType::FCOLOUR4:
798 {
799 FColour4 data = {};
800 field.get<FColour4>(data);
801 pt.put((entryName + ".<xmlattr>.r").c_str(), data.r);
802 pt.put((entryName + ".<xmlattr>.g").c_str(), data.g);
803 pt.put((entryName + ".<xmlattr>.b").c_str(), data.b);
804 pt.put((entryName + ".<xmlattr>.a").c_str(), data.a);
805 } break;
806 default: break;
807 }
808 }
809
810 void EditorComponent::loadFieldFromXML(EditorComponentField& field, const boost::property_tree::ptree& pt)
811 {
812 auto entryName = GetFullFieldName(_name.c_str(), field._name);
813
814 switch (field._basicType)
815 {
816 case PushConstantType::BOOL:
817 {
818 bool val = pt.get(entryName.c_str(), field.get<bool>());
819 field.set<bool>(val);
820 } break;
821 case PushConstantType::INT:
822 {
823 switch (field._basicTypeSize)
824 {
825 case PushConstantSize::QWORD: field.set<I64>(GetClamped<I64>(field, pt, entryName.c_str())); break;
826 case PushConstantSize::DWORD: field.set<I32>(GetClamped<I32>(field, pt, entryName.c_str())); break;
827 case PushConstantSize::WORD: field.set<I16>(GetClamped<I16>(field, pt, entryName.c_str())); break;
828 case PushConstantSize::BYTE: field.set<I8>(GetClamped<I8>(field, pt, entryName.c_str())); break;
829 default: DIVIDE_UNEXPECTED_CALL(); break;
830 }
831 } break;
832 case PushConstantType::UINT:
833 {
834 switch (field._basicTypeSize)
835 {
836 case PushConstantSize::QWORD: field.set<U64>(GetClamped<U64>(field, pt, entryName.c_str())); break;
837 case PushConstantSize::DWORD: field.set<U32>(GetClamped<U32>(field, pt, entryName.c_str())); break;
838 case PushConstantSize::WORD: field.set<U16>(GetClamped<U16>(field, pt, entryName.c_str())); break;
839 case PushConstantSize::BYTE: field.set<U8>(GetClamped<U8>(field, pt, entryName.c_str())); break;
840 default: DIVIDE_UNEXPECTED_CALL(); break;
841 }
842 } break;
843 case PushConstantType::FLOAT:
844 {
845 field.set<F32>(GetClamped<F32>(field, pt, entryName.c_str()));
846 } break;
847 case PushConstantType::DOUBLE:
848 {
849 field.set<D64>(GetClamped<D64>(field, pt, entryName.c_str()));
850 } break;
851 case PushConstantType::IVEC2:
852 {
853 switch (field._basicTypeSize)
854 {
855 case PushConstantSize::QWORD: loadVector<vec2<I64>, 2>(entryName, field, pt); break;
856 case PushConstantSize::DWORD: loadVector<vec2<I32>, 2>(entryName, field, pt); break;
857 case PushConstantSize::WORD: loadVector<vec2<I16>, 2>(entryName, field, pt); break;
858 case PushConstantSize::BYTE: loadVector<vec2<I8>, 2>(entryName, field, pt); break;
859
860 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
861 }
862 } break;
863 case PushConstantType::IVEC3:
864 {
865 switch (field._basicTypeSize)
866 {
867 case PushConstantSize::QWORD: loadVector<vec3<I64>, 3>(entryName, field, pt); break;
868 case PushConstantSize::DWORD: loadVector<vec3<I32>, 3>(entryName, field, pt); break;
869 case PushConstantSize::WORD: loadVector<vec3<I16>, 3>(entryName, field, pt); break;
870 case PushConstantSize::BYTE: loadVector<vec3<I8>, 3>(entryName, field, pt); break;
871
872 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
873 }
874 } break;
875 case PushConstantType::IVEC4:
876 {
877 switch (field._basicTypeSize)
878 {
879 case PushConstantSize::QWORD: loadVector<vec4<I64>, 4>(entryName, field, pt); break;
880 case PushConstantSize::DWORD: loadVector<vec4<I32>, 5>(entryName, field, pt); break;
881 case PushConstantSize::WORD: loadVector<vec4<I16>, 4>(entryName, field, pt); break;
882 case PushConstantSize::BYTE: loadVector<vec4<I8>, 4>(entryName, field, pt); break;
883
884 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
885 }
886 } break;
887 case PushConstantType::UVEC2:
888 {
889 switch (field._basicTypeSize)
890 {
891 case PushConstantSize::QWORD: loadVector<vec2<U64>, 2>(entryName, field, pt); break;
892 case PushConstantSize::DWORD: loadVector<vec2<U32>, 2>(entryName, field, pt); break;
893 case PushConstantSize::WORD: loadVector<vec2<U16>, 2>(entryName, field, pt); break;
894 case PushConstantSize::BYTE: loadVector<vec2<U8>, 2>(entryName, field, pt); break;
895
896 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
897 }
898 } break;
899 case PushConstantType::UVEC3:
900 {
901 switch (field._basicTypeSize)
902 {
903 case PushConstantSize::QWORD: loadVector<vec3<U64>, 3>(entryName, field, pt); break;
904 case PushConstantSize::DWORD: loadVector<vec3<U32>, 3>(entryName, field, pt); break;
905 case PushConstantSize::WORD: loadVector<vec3<U16>, 3>(entryName, field, pt); break;
906 case PushConstantSize::BYTE: loadVector<vec3<U8>, 3>(entryName, field, pt); break;
907
908 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
909 }
910 } break;
911 case PushConstantType::UVEC4:
912 {
913 switch (field._basicTypeSize)
914 {
915 case PushConstantSize::QWORD: loadVector<vec4<U64>, 4>(entryName, field, pt); break;
916 case PushConstantSize::DWORD: loadVector<vec4<U32>, 4>(entryName, field, pt); break;
917 case PushConstantSize::WORD: loadVector<vec4<U16>, 4>(entryName, field, pt); break;
918 case PushConstantSize::BYTE: loadVector<vec4<U8>, 4>(entryName, field, pt); break;
919
920 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
921 }
922 } break;
923 case PushConstantType::VEC2:
924 {
925 loadVector<vec2<F32>, 2>(entryName, field, pt);
926 } break;
927 case PushConstantType::VEC3:
928 {
929 loadVector<vec3<F32>, 3>(entryName, field, pt);
930 } break;
931 case PushConstantType::VEC4:
932 {
933 loadVector<vec4<F32>, 4>(entryName, field, pt);
934 } break;
935 case PushConstantType::DVEC2:
936 {
937 loadVector<vec2<D64>, 2>(entryName, field, pt);
938 } break;
939 case PushConstantType::DVEC3:
940 {
941 loadVector<vec3<D64>, 3>(entryName, field, pt);
942 } break;
943 case PushConstantType::DVEC4:
944 {
945 loadVector<vec4<D64>, 4>(entryName, field, pt);
946 } break;
947 case PushConstantType::IMAT2:
948 {
949 switch (field._basicTypeSize)
950 {
951 case PushConstantSize::QWORD: loadMatrix<mat2<I64>, 2>(entryName, field, pt); break;
952 case PushConstantSize::DWORD: loadMatrix<mat2<I32>, 2>(entryName, field, pt); break;
953 case PushConstantSize::WORD: loadMatrix<mat2<I16>, 2>(entryName, field, pt); break;
954 case PushConstantSize::BYTE: loadMatrix<mat2<I8>, 2>(entryName, field, pt); break;
955
956 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
957 }
958 } break;
959 case PushConstantType::IMAT3:
960 {
961 switch (field._basicTypeSize)
962 {
963 case PushConstantSize::QWORD: loadMatrix<mat3<I64>, 3>(entryName, field, pt); break;
964 case PushConstantSize::DWORD: loadMatrix<mat3<I32>, 3>(entryName, field, pt); break;
965 case PushConstantSize::WORD: loadMatrix<mat3<I16>, 3>(entryName, field, pt); break;
966 case PushConstantSize::BYTE: loadMatrix<mat3<I8>, 3>(entryName, field, pt); break;
967
968 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
969 }
970 } break;
971 case PushConstantType::IMAT4:
972 {
973 switch (field._basicTypeSize)
974 {
975 case PushConstantSize::QWORD: loadMatrix<mat4<I64>, 4>(entryName, field, pt); break;
976 case PushConstantSize::DWORD: loadMatrix<mat4<I32>, 4>(entryName, field, pt); break;
977 case PushConstantSize::WORD: loadMatrix<mat4<I16>, 4>(entryName, field, pt); break;
978 case PushConstantSize::BYTE: loadMatrix<mat4<I8>, 4>(entryName, field, pt); break;
979
980 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
981 }
982 } break;
983 case PushConstantType::UMAT2:
984 {
985 switch (field._basicTypeSize)
986 {
987 case PushConstantSize::QWORD: loadMatrix<mat2<U64>, 2>(entryName, field, pt); break;
988 case PushConstantSize::DWORD: loadMatrix<mat2<U32>, 2>(entryName, field, pt); break;
989 case PushConstantSize::WORD: loadMatrix<mat2<U16>, 2>(entryName, field, pt); break;
990 case PushConstantSize::BYTE: loadMatrix<mat2<U8>, 2>(entryName, field, pt); break;
991
992 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
993 }
994 } break;
995 case PushConstantType::UMAT3:
996 {
997 switch (field._basicTypeSize)
998 {
999 case PushConstantSize::QWORD: loadMatrix<mat3<U64>, 3>(entryName, field, pt); break;
1000 case PushConstantSize::DWORD: loadMatrix<mat3<U32>, 3>(entryName, field, pt); break;
1001 case PushConstantSize::WORD: loadMatrix<mat3<U16>, 3>(entryName, field, pt); break;
1002 case PushConstantSize::BYTE: loadMatrix<mat3<U8>, 3>(entryName, field, pt); break;
1003
1004 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
1005 }
1006 } break;
1007 case PushConstantType::UMAT4:
1008 {
1009 switch (field._basicTypeSize)
1010 {
1011 case PushConstantSize::QWORD: loadMatrix<mat4<U64>, 4>(entryName, field, pt); break;
1012 case PushConstantSize::DWORD: loadMatrix<mat4<U32>, 4>(entryName, field, pt); break;
1013 case PushConstantSize::WORD: loadMatrix<mat4<U16>, 4>(entryName, field, pt); break;
1014 case PushConstantSize::BYTE: loadMatrix<mat4<U8>, 4>(entryName, field, pt); break;
1015
1016 case PushConstantSize::COUNT: DIVIDE_UNEXPECTED_CALL(); break;
1017 }
1018 } break;
1019 case PushConstantType::MAT2:
1020 {
1021 loadMatrix<mat2<F32>, 2>(entryName, field, pt);
1022 } break;
1023 case PushConstantType::MAT3:
1024 {
1025 loadMatrix<mat3<F32>, 3>(entryName, field, pt);
1026 } break;
1027 case PushConstantType::MAT4:
1028 {
1029 loadMatrix<mat4<F32>, 4>(entryName, field, pt);
1030 } break;
1031 case PushConstantType::DMAT2:
1032 {
1033 loadMatrix<mat2<D64>, 2>(entryName, field, pt);
1034 } break;
1035 case PushConstantType::DMAT3:
1036 {
1037 loadMatrix<mat3<D64>, 3>(entryName, field, pt);
1038 } break;
1039 case PushConstantType::DMAT4:
1040 {
1041 loadMatrix<mat4<D64>, 4>(entryName, field, pt);
1042 } break;
1043 case PushConstantType::FCOLOUR3:
1044 {
1045 FColour3 data = field.get<FColour3>();
1046 data.set(pt.get((entryName + ".<xmlattr>.r").c_str(), data.r),
1047 pt.get((entryName + ".<xmlattr>.g").c_str(), data.g),
1048 pt.get((entryName + ".<xmlattr>.b").c_str(), data.b));
1049 field.set<FColour3>(data);
1050 } break;
1051 case PushConstantType::FCOLOUR4:
1052 {
1053 FColour4 data = field.get<FColour4>();
1054 data.set(pt.get((entryName + ".<xmlattr>.r").c_str(), data.r),
1055 pt.get((entryName + ".<xmlattr>.g").c_str(), data.g),
1056 pt.get((entryName + ".<xmlattr>.b").c_str(), data.b),
1057 pt.get((entryName + ".<xmlattr>.a").c_str(), data.a));
1058 field.set<FColour4>(data);
1059 } break;
1060 default: break;
1061 }
1062 }
1063} //namespace Divide
DIVIDE_UNEXPECTED_CALL
#define DIVIDE_UNEXPECTED_CALL()
Definition: PlatformDefines.h:737
NOP
#define NOP()
Definition: PlatformDefines.h:458
Divide::Attorney::EditorEditorComponent::onRemoveComponent
static void onRemoveComponent(const Editor &editor, const EditorComponent &comp)
Definition: Editor.h:756
Divide::BoundingBox::setMin
void setMin(const vec3< F32 > &min) noexcept
Definition: BoundingBox.inl:179
Divide::BoundingBox::getMax
const vec3< F32 > & getMax() const noexcept
Definition: BoundingBox.inl:141
Divide::BoundingBox::getMin
const vec3< F32 > & getMin() const noexcept
Definition: BoundingBox.inl:137
Divide::BoundingBox::setMax
void setMax(const vec3< F32 > &max) noexcept
Definition: BoundingBox.inl:183
Divide::BoundingSphere::getCenter
const vec3< F32 > & getCenter() const noexcept
Definition: BoundingSphere.inl:139
Divide::BoundingSphere::setRadius
void setRadius(F32 radius) noexcept
Definition: BoundingSphere.inl:131
Divide::BoundingSphere::getRadius
F32 getRadius() const noexcept
Definition: BoundingSphere.inl:141
Divide::BoundingSphere::setCenter
void setCenter(const vec3< F32 > &center) noexcept
Definition: BoundingSphere.inl:135
Divide::EditorComponent::saveToXML
void saveToXML(boost::property_tree::ptree &pt) const
Definition: EditorComponent.cpp:107
Divide::EditorComponent::loadFromXML
void loadFromXML(const boost::property_tree::ptree &pt)
Definition: EditorComponent.cpp:188
Divide::EditorComponent::loadCache
bool loadCache(ByteBuffer &inputBuffer)
Definition: EditorComponent.cpp:94
Divide::EditorComponent::saveCache
bool saveCache(ByteBuffer &outputBuffer) const
Definition: EditorComponent.cpp:86
Divide::EditorComponent::saveFieldToXML
void saveFieldToXML(const EditorComponentField &field, boost::property_tree::ptree &pt) const
Definition: EditorComponent.cpp:426
Divide::EditorComponent::_fields
vector< EditorComponentField > _fields
Definition: EditorComponent.h:205
Divide::EditorComponent::_onChangedCbk
DELEGATE< void, std::string_view > _onChangedCbk
Definition: EditorComponent.h:204
Divide::EditorComponent::registerField
void registerField(EditorComponentField &&field)
Definition: EditorComponent.cpp:69
Divide::EditorComponent::loadFieldFromXML
void loadFieldFromXML(EditorComponentField &field, const boost::property_tree::ptree &pt)
Definition: EditorComponent.cpp:810
Divide::EditorComponent::onChanged
void onChanged(const EditorComponentField &field) const
Definition: EditorComponent.cpp:77
Divide::EditorComponent::EditorComponent
EditorComponent(PlatformContext &context, ComponentType type, std::string_view name)
Definition: EditorComponent.cpp:53
Divide::GUIDWrapper
Utility class that adds basic GUID management to objects.
Definition: GUIDWrapper.h:44
Divide::Material::loadFromXML
void loadFromXML(const std::string &entryName, const boost::property_tree::ptree &pt)
Definition: Material.cpp:1192
Divide::PlatformContextComponent::context
PlatformContext & context() noexcept
Definition: PlatformContextComponent.h:48
Divide::Quaternion::getEuler
vec3< Angle::RADIANS< T > > getEuler() const noexcept
Definition: Quaternion.inl:478
Divide::Quaternion::fromEuler
void fromEuler(const vec3< Angle::DEGREES< T > > &v) noexcept
Definition: Quaternion.inl:316
Divide::TransformComponent::setPosition
void setPosition(const vec3< F32 > &position) override
Component <-> Transform interface.
Definition: TransformComponent.cpp:137
Divide::TransformComponent::setRotation
void setRotation(const vec3< F32 > &axis, Angle::DEGREES< F32 > degrees) override
Definition: TransformComponent.cpp:178
Divide::TransformComponent::getLocalPosition
vec3< F32 > getLocalPosition() const
Return the local position.
Definition: TransformComponent.cpp:766
Divide::TransformComponent::setScale
void setScale(const vec3< F32 > &amount) override
Set the local X,Y and Z scale factors.
Definition: TransformComponent.cpp:152
Divide::TransformComponent::getLocalScale
vec3< F32 > getLocalScale() const
Return the local scale factor.
Definition: TransformComponent.cpp:772
Divide::TransformComponent::getLocalOrientation
Quaternion< F32 > getLocalOrientation() const
Return the local orientation quaternion.
Definition: TransformComponent.cpp:778
Divide::vec3::set
void set(const T *v) noexcept
set the 3 components of the vector manually using a source pointer to a (large enough) array
Definition: MathVectors.h:707
Divide::vec4::set
void set(const T *v) noexcept
set the 4 components of the vector manually using a source pointer to a (large enough) array
Definition: MathVectors.h:1241
Divide::Angle::to_DEGREES
constexpr DEGREES< T > to_DEGREES(RADIANS< T > angle) noexcept
Definition: MathHelper.inl:380
Divide::Config::Build::ENABLE_EDITOR
constexpr bool ENABLE_EDITOR
Definition: config.h:66
Divide::Names::componentType
static const char * componentType[]
Definition: EditorComponent.h:74
Divide::TypeUtil::StringToComponentType
ComponentType StringToComponentType(const std::string_view name)
Definition: EditorComponent.cpp:39
Divide::TypeUtil::ComponentTypeToString
const char * ComponentTypeToString(const ComponentType compType) noexcept
Definition: EditorComponent.cpp:26
Divide::Util::MakeXMLSafe
string MakeXMLSafe(std::string_view subject)
Definition: StringHelper.inl:199
Divide::anonymous_namespace{EditorComponent.cpp}::loadVector
void loadVector(const std::string &entryName, EditorComponentField &field, const boost::property_tree::ptree &pt)
Definition: EditorComponent.cpp:316
Divide::anonymous_namespace{EditorComponent.cpp}::saveMatrix
void saveMatrix(const std::string &entryName, const EditorComponentField &field, boost::property_tree::ptree &pt)
Definition: EditorComponent.cpp:352
Divide::anonymous_namespace{EditorComponent.cpp}::saveVector
void saveVector(const std::string &entryName, const EditorComponentField &field, boost::property_tree::ptree &pt)
Definition: EditorComponent.cpp:298
Divide::anonymous_namespace{EditorComponent.cpp}::GetFullFieldName
std::string GetFullFieldName(const char *componentName, const Str< 32 > &fieldName)
Definition: EditorComponent.cpp:18
Divide::anonymous_namespace{EditorComponent.cpp}::loadMatrix
void loadMatrix(const std::string &entryName, EditorComponentField &field, const boost::property_tree::ptree &pt)
Definition: EditorComponent.cpp:384
Divide::anonymous_namespace{EditorComponent.cpp}::GetClamped
T GetClamped(const EditorComponentField &field, const boost::property_tree::ptree &pt, const char *name)
Definition: EditorComponent.cpp:286
Divide
Handle console commands that start with a forward slash.
Definition: AIProcessor.cpp:7
Divide::to_U32
constexpr U32 to_U32(const T value)
Definition: PlatformDataTypes.h:262
Divide::I32
int32_t I32
Definition: PlatformDataTypes.h:50
Divide::U8
uint8_t U8
Definition: PlatformDataTypes.h:44
Divide::I16
int16_t I16
Definition: PlatformDataTypes.h:49
Divide::BYTE_BUFFER_VERSION
constexpr U16 BYTE_BUFFER_VERSION
Definition: EditorComponent.cpp:15
Divide::U16
uint16_t U16
Definition: PlatformDataTypes.h:45
Divide::D64
double D64
Definition: PlatformDataTypes.h:83
Divide::CLAMP
::value constexpr void CLAMP(T &n, T min, T max) noexcept
Clamps value n between min and max.
Definition: MathHelper.inl:114
Divide::dvd_erase_if
bool dvd_erase_if(eastl::vector< T, A > &vec, Predicate &&pred)
Definition: Vector.h:109
Divide::I64
int64_t I64
Definition: PlatformDataTypes.h:51
Divide::U32
uint32_t U32
Definition: PlatformDataTypes.h:46
Divide::U64
uint64_t U64
Definition: PlatformDataTypes.h:47
Divide::EditorComponentFieldType::DROPDOWN_TYPE
@ DROPDOWN_TYPE
Only U8 types supported!
Divide::to_base
constexpr auto to_base(const Type value) -> Type
Definition: PlatformDataTypes.h:228
Divide::EditorComponentField::set
void set(const T &dataIn)
Definition: EditorComponent.inl:76
Divide::EditorComponentField::_range
vec2< F32 > _range
Used by slider_type as a min / max range or dropdown as selected_index / count.
Definition: EditorComponent.h:127
Divide::EditorComponentField::_type
EditorComponentFieldType _type
Definition: EditorComponent.h:134