Blender V5.3
GHOST_XrControllerModel.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2021-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cassert>
10
11#include <Eigen/Core>
12#include <Eigen/Geometry>
13
14#include "GHOST_Types.hh"
15#include "GHOST_XrException.hh"
16#include "GHOST_Xr_intern.hh"
17
19
20#include "GHOST_utildefines.hh"
21
22#define TINYGLTF_IMPLEMENTATION
23#define TINYGLTF_NO_STB_IMAGE
24#define TINYGLTF_NO_STB_IMAGE_WRITE
25#define STBIWDEF static inline
26#include "tiny_gltf.h"
27
33
34/* -------------------------------------------------------------------- */
40
42 std::vector<GHOST_XrControllerModelVertex> vertices;
43 std::vector<uint32_t> indices;
44};
45
50static void validate_accessor(const tinygltf::Accessor &accessor,
51 const tinygltf::BufferView &buffer_view,
52 const tinygltf::Buffer &buffer,
53 size_t byte_stride,
54 size_t element_size)
55{
56 /* Make sure the accessor does not go out of range of the buffer view. */
57 if (accessor.byteOffset + (accessor.count - 1) * byte_stride + element_size >
58 buffer_view.byteLength)
59 {
60 throw GHOST_XrException("glTF: Accessor goes out of range of bufferview.");
61 }
62
63 /* Make sure the buffer view does not go out of range of the buffer. */
64 if (buffer_view.byteOffset + buffer_view.byteLength > buffer.data.size()) {
65 throw GHOST_XrException("glTF: BufferView goes out of range of buffer.");
66 }
67}
68
69template<float (GHOST_XrControllerModelVertex::*field)[3]>
70static void read_vertices(const tinygltf::Accessor &accessor,
71 const tinygltf::BufferView &buffer_view,
72 const tinygltf::Buffer &buffer,
73 GHOST_XrPrimitive &primitive)
74{
75 if (accessor.type != TINYGLTF_TYPE_VEC3) {
77 "glTF: Accessor for primitive attribute has incorrect type (VEC3 expected).");
78 }
79
80 if (accessor.componentType != TINYGLTF_COMPONENT_TYPE_FLOAT) {
82 "glTF: Accessor for primitive attribute has incorrect component type (FLOAT expected).");
83 }
84
85 /* If stride is not specified, it is tightly packed. */
86 constexpr size_t packed_size = sizeof(float) * 3;
87 const size_t stride = buffer_view.byteStride == 0 ? packed_size : buffer_view.byteStride;
88 validate_accessor(accessor, buffer_view, buffer, stride, packed_size);
89
90 /* Resize the vertices vector, if necessary, to include room for the attribute data.
91 * If there are multiple attributes for a primitive, the first one will resize, and the
92 * subsequent will not need to. */
93 primitive.vertices.resize(accessor.count);
94
95 /* Copy the attribute value over from the glTF buffer into the appropriate vertex field. */
96 const uint8_t *buffer_ptr = buffer.data.data() + buffer_view.byteOffset + accessor.byteOffset;
97 for (size_t i = 0; i < accessor.count; i++, buffer_ptr += stride) {
98 memcpy(primitive.vertices[i].*field, buffer_ptr, stride);
99 }
100}
101
102static void load_attribute_accessor(const tinygltf::Model &gltf_model,
103 const std::string &attribute_name,
104 int accessor_id,
105 GHOST_XrPrimitive &primitive)
106{
107 const auto &accessor = gltf_model.accessors.at(accessor_id);
108
109 if (accessor.bufferView == -1) {
110 throw GHOST_XrException("glTF: Accessor for primitive attribute specifies no bufferview.");
111 }
112
113 const tinygltf::BufferView &buffer_view = gltf_model.bufferViews.at(accessor.bufferView);
114 if (!ELEM(buffer_view.target, TINYGLTF_TARGET_ARRAY_BUFFER, 0)) {
115 throw GHOST_XrException(
116 "glTF: Accessor for primitive attribute uses bufferview with invalid 'target' type.");
117 }
118
119 const tinygltf::Buffer &buffer = gltf_model.buffers.at(buffer_view.buffer);
120
121 if (attribute_name.compare("POSITION") == 0) {
123 accessor, buffer_view, buffer, primitive);
124 }
125 else if (attribute_name.compare("NORMAL") == 0) {
127 accessor, buffer_view, buffer, primitive);
128 }
129}
130
135template<typename TSrcIndex>
136static void read_indices(const tinygltf::Accessor &accessor,
137 const tinygltf::BufferView &buffer_view,
138 const tinygltf::Buffer &buffer,
139 GHOST_XrPrimitive &primitive)
140{
141
142 /* Allow 0 (not specified) even though spec doesn't seem to allow this (BoomBox GLB fails). */
143 if (!ELEM(buffer_view.target, TINYGLTF_TARGET_ELEMENT_ARRAY_BUFFER, 0)) {
144 throw GHOST_XrException(
145 "glTF: Accessor for indices uses bufferview with invalid 'target' type.");
146 }
147
148 constexpr size_t component_size_bytes = sizeof(TSrcIndex);
149 /* Index buffer must be packed per glTF spec. */
150 if (!ELEM(buffer_view.byteStride, 0, component_size_bytes)) {
151 throw GHOST_XrException(
152 "glTF: Accessor for indices uses bufferview with invalid 'byteStride'.");
153 }
154
155 validate_accessor(accessor, buffer_view, buffer, component_size_bytes, component_size_bytes);
156
157 /* Since only triangles are supported, enforce that the number of indices is divisible by 3. */
158 if ((accessor.count % 3) != 0) {
159 throw GHOST_XrException("glTF: Unexpected number of indices for triangle primitive");
160 }
161
162 const TSrcIndex *index_buffer = reinterpret_cast<const TSrcIndex *>(
163 buffer.data.data() + buffer_view.byteOffset + accessor.byteOffset);
164 for (uint32_t i = 0; i < accessor.count; i++) {
165 primitive.indices.push_back(*(index_buffer + i));
166 }
167}
168
172static void load_index_accessor(const tinygltf::Model &gltf_model,
173 const tinygltf::Accessor &accessor,
174 GHOST_XrPrimitive &primitive)
175{
176 if (accessor.type != TINYGLTF_TYPE_SCALAR) {
177 throw GHOST_XrException("glTF: Accessor for indices specifies invalid 'type'.");
178 }
179
180 if (accessor.bufferView == -1) {
181 throw GHOST_XrException("glTF: Index accessor without bufferView is currently not supported.");
182 }
183
184 const tinygltf::BufferView &buffer_view = gltf_model.bufferViews.at(accessor.bufferView);
185 const tinygltf::Buffer &buffer = gltf_model.buffers.at(buffer_view.buffer);
186
187 if (accessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE) {
188 read_indices<uint8_t>(accessor, buffer_view, buffer, primitive);
189 }
190 else if (accessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
191 read_indices<uint16_t>(accessor, buffer_view, buffer, primitive);
192 }
193 else if (accessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) {
194 read_indices<uint32_t>(accessor, buffer_view, buffer, primitive);
195 }
196 else {
197 throw GHOST_XrException("glTF: Accessor for indices specifies invalid 'componentType'.");
198 }
199}
200
201static GHOST_XrPrimitive read_primitive(const tinygltf::Model &gltf_model,
202 const tinygltf::Primitive &gltf_primitive)
203{
204 if (gltf_primitive.mode != TINYGLTF_MODE_TRIANGLES) {
205 throw GHOST_XrException(
206 "glTF: Unsupported primitive mode. Only TINYGLTF_MODE_TRIANGLES is supported.");
207 }
208
209 GHOST_XrPrimitive primitive;
210
211 /* glTF vertex data is stored in an attribute dictionary.Loop through each attribute and insert
212 * it into the GHOST_XrPrimitive. */
213 for (const auto &[attr_name, accessor_idx] : gltf_primitive.attributes) {
214 load_attribute_accessor(gltf_model, attr_name, accessor_idx, primitive);
215 }
216
217 if (gltf_primitive.indices != -1) {
218 /* If indices are specified for the glTF primitive, read them into the GHOST_XrPrimitive. */
219 load_index_accessor(gltf_model, gltf_model.accessors.at(gltf_primitive.indices), primitive);
220 }
221
222 return primitive;
223}
224
228static void calc_node_transforms(const tinygltf::Node &gltf_node,
229 const float parent_transform[4][4],
230 float r_local_transform[4][4],
231 float r_world_transform[4][4])
232{
233 /* A node may specify either a 4x4 matrix or TRS (Translation - Rotation - Scale) values, but not
234 * both. */
235 if (gltf_node.matrix.size() == 16) {
236 const std::vector<double> &dm = gltf_node.matrix;
237 float m[4][4] = {{float(dm[0]), float(dm[1]), float(dm[2]), float(dm[3])},
238 {float(dm[4]), float(dm[5]), float(dm[6]), float(dm[7])},
239 {float(dm[8]), float(dm[9]), float(dm[10]), float(dm[11])},
240 {float(dm[12]), float(dm[13]), float(dm[14]), float(dm[15])}};
241 memcpy(r_local_transform, m, sizeof(float[4][4]));
242 }
243 else {
244 /* No matrix is present, so construct a matrix from the TRS values (each one is optional). */
245 std::vector<double> translation = gltf_node.translation;
246 std::vector<double> rotation = gltf_node.rotation;
247 std::vector<double> scale = gltf_node.scale;
248 Eigen::Matrix4f &m = *(Eigen::Matrix4f *)r_local_transform;
249 Eigen::Quaternionf q;
250 Eigen::Matrix3f scalemat;
251
252 if (translation.size() != 3) {
253 translation.resize(3);
254 translation[0] = translation[1] = translation[2] = 0.0;
255 }
256 if (rotation.size() != 4) {
257 rotation.resize(4);
258 rotation[0] = rotation[1] = rotation[2] = 0.0;
259 rotation[3] = 1.0;
260 }
261 if (scale.size() != 3) {
262 scale.resize(3);
263 scale[0] = scale[1] = scale[2] = 1.0;
264 }
265
266 q.w() = float(rotation[3]);
267 q.x() = float(rotation[0]);
268 q.y() = float(rotation[1]);
269 q.z() = float(rotation[2]);
270 q.normalize();
271
272 scalemat.setIdentity();
273 scalemat(0, 0) = float(scale[0]);
274 scalemat(1, 1) = float(scale[1]);
275 scalemat(2, 2) = float(scale[2]);
276
277 m.setIdentity();
278 m.block<3, 3>(0, 0) = q.toRotationMatrix() * scalemat;
279 m.block<3, 1>(0, 3) = Eigen::Vector3f(
280 float(translation[0]), float(translation[1]), float(translation[2]));
281 }
282
283 *(Eigen::Matrix4f *)r_world_transform = *(Eigen::Matrix4f *)parent_transform *
284 *(Eigen::Matrix4f *)r_local_transform;
285}
286
287static void load_node(const tinygltf::Model &gltf_model,
288 int gltf_node_id,
289 int32_t parent_idx,
290 const float parent_transform[4][4],
291 const std::string &parent_name,
292 const std::vector<XrControllerModelNodePropertiesMSFT> &node_properties,
293 std::vector<GHOST_XrControllerModelVertex> &vertices,
294 std::vector<uint32_t> &indices,
295 std::vector<GHOST_XrControllerModelComponent> &components,
296 std::vector<GHOST_XrControllerModelNode> &nodes,
297 std::vector<int32_t> &node_state_indices)
298{
299 const tinygltf::Node &gltf_node = gltf_model.nodes.at(gltf_node_id);
300 float world_transform[4][4];
301
302 GHOST_XrControllerModelNode &node = nodes.emplace_back();
303 const int32_t node_idx = int32_t(nodes.size() - 1);
304 node.parent_idx = parent_idx;
305 calc_node_transforms(gltf_node, parent_transform, node.local_transform, world_transform);
306
307 for (size_t i = 0; i < node_properties.size(); ++i) {
308 if ((node_state_indices[i] < 0) && (parent_name == node_properties[i].parentNodeName) &&
309 (gltf_node.name == node_properties[i].nodeName))
310 {
311 node_state_indices[i] = node_idx;
312 break;
313 }
314 }
315
316 if (gltf_node.mesh != -1) {
317 const tinygltf::Mesh &gltf_mesh = gltf_model.meshes.at(gltf_node.mesh);
318
319 GHOST_XrControllerModelComponent &component = components.emplace_back();
320 node.component_idx = components.size() - 1;
321 memcpy(component.transform, world_transform, sizeof(component.transform));
322 component.vertex_offset = vertices.size();
323 component.index_offset = indices.size();
324
325 for (const tinygltf::Primitive &gltf_primitive : gltf_mesh.primitives) {
326 /* Read the primitive data from the glTF buffers. */
327 const GHOST_XrPrimitive primitive = read_primitive(gltf_model, gltf_primitive);
328
329 const size_t start_vertex = vertices.size();
330 size_t offset = start_vertex;
331 size_t count = primitive.vertices.size();
332 vertices.resize(offset + count);
333 memcpy(vertices.data() + offset,
334 primitive.vertices.data(),
335 count * sizeof(decltype(primitive.vertices)::value_type));
336
337 offset = indices.size();
338 count = primitive.indices.size();
339 indices.resize(offset + count);
340 for (size_t i = 0; i < count; i += 3) {
341 indices[offset + i + 0] = start_vertex + primitive.indices[i + 0];
342 indices[offset + i + 1] = start_vertex + primitive.indices[i + 2];
343 indices[offset + i + 2] = start_vertex + primitive.indices[i + 1];
344 }
345 }
346
347 component.vertex_count = vertices.size() - component.vertex_offset;
348 component.index_count = indices.size() - component.index_offset;
349 }
350
351 /* Recursively load all children. */
352 for (const int child_node_id : gltf_node.children) {
353 load_node(gltf_model,
354 child_node_id,
355 node_idx,
356 world_transform,
357 gltf_node.name,
358 node_properties,
359 vertices,
360 indices,
361 components,
362 nodes,
363 node_state_indices);
364 }
365}
366
368
369/* -------------------------------------------------------------------- */
373
374static PFN_xrGetControllerModelKeyMSFT g_xrGetControllerModelKeyMSFT = nullptr;
375static PFN_xrLoadControllerModelMSFT g_xrLoadControllerModelMSFT = nullptr;
376static PFN_xrGetControllerModelPropertiesMSFT g_xrGetControllerModelPropertiesMSFT = nullptr;
377static PFN_xrGetControllerModelStateMSFT g_xrGetControllerModelStateMSFT = nullptr;
378static XrInstance g_instance = XR_NULL_HANDLE;
379
380static void init_controller_model_extension_functions(XrInstance instance)
381{
382 if (instance != g_instance) {
383 g_instance = instance;
388 }
389
390 if (g_xrGetControllerModelKeyMSFT == nullptr) {
391 INIT_EXTENSION_FUNCTION(xrGetControllerModelKeyMSFT);
392 }
393 if (g_xrLoadControllerModelMSFT == nullptr) {
394 INIT_EXTENSION_FUNCTION(xrLoadControllerModelMSFT);
395 }
397 INIT_EXTENSION_FUNCTION(xrGetControllerModelPropertiesMSFT);
398 }
399 if (g_xrGetControllerModelStateMSFT == nullptr) {
400 INIT_EXTENSION_FUNCTION(xrGetControllerModelStateMSFT);
401 }
402}
403
405
406/* -------------------------------------------------------------------- */
410
412 const char *subaction_path_str)
413{
415
416 CHECK_XR(xrStringToPath(instance, subaction_path_str, &subaction_path_),
417 (std::string("Failed to get user path \"") + subaction_path_str + "\".").data());
418}
419
421{
422 if (load_task_.valid()) {
423 load_task_.wait();
424 }
425}
426
427void GHOST_XrControllerModel::load(XrSession session)
428{
429 if (data_loaded_ || load_task_.valid()) {
430 return;
431 }
432
433 /* Get model key. */
434 XrControllerModelKeyStateMSFT key_state{XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT};
435 CHECK_XR(g_xrGetControllerModelKeyMSFT(session, subaction_path_, &key_state),
436 "Failed to get controller model key state.");
437
438 if (key_state.modelKey != XR_NULL_CONTROLLER_MODEL_KEY_MSFT) {
439 model_key_ = key_state.modelKey;
440 /* Load asynchronously. */
441 load_task_ = std::async(std::launch::async,
442 [&, session = session]() { return loadControllerModel(session); });
443 }
444}
445
446void GHOST_XrControllerModel::loadControllerModel(XrSession session)
447{
448 /* Load binary buffers. */
449 uint32_t buf_size = 0;
450 CHECK_XR(g_xrLoadControllerModelMSFT(session, model_key_, 0, &buf_size, nullptr),
451 "Failed to get controller model buffer size.");
452
453 std::vector<uint8_t> buf((size_t(buf_size)));
454 CHECK_XR(g_xrLoadControllerModelMSFT(session, model_key_, buf_size, &buf_size, buf.data()),
455 "Failed to load controller model binary buffers.");
456
457 /* Convert to glTF model. */
458 tinygltf::TinyGLTF gltf_loader;
459 tinygltf::Model gltf_model;
460 std::string err_msg;
461 {
462 /* Workaround for TINYGLTF_NO_STB_IMAGE define. Set custom image loader to prevent failure when
463 * parsing image data. */
464 auto load_img_func = [](tinygltf::Image *img,
465 const int p0,
466 std::string *p1,
467 std::string *p2,
468 int p3,
469 int p4,
470 const uchar *p5,
471 int p6,
472 void *user_pointer) -> bool {
473 (void)img;
474 (void)p0;
475 (void)p1;
476 (void)p2;
477 (void)p3;
478 (void)p4;
479 (void)p5;
480 (void)p6;
481 (void)user_pointer;
482 return true;
483 };
484 gltf_loader.SetImageLoader(load_img_func, nullptr);
485 }
486
487 if (!gltf_loader.LoadBinaryFromMemory(&gltf_model, &err_msg, nullptr, buf.data(), buf_size)) {
488 throw GHOST_XrException(("Failed to load glTF controller model: " + err_msg).c_str());
489 }
490
491 /* Get node properties. */
492 XrControllerModelPropertiesMSFT model_properties{XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT};
493 model_properties.nodeCapacityInput = 0;
494 CHECK_XR(g_xrGetControllerModelPropertiesMSFT(session, model_key_, &model_properties),
495 "Failed to get controller model node properties count.");
496
497 std::vector<XrControllerModelNodePropertiesMSFT> node_properties(
498 model_properties.nodeCountOutput, {XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT});
499 model_properties.nodeCapacityInput = uint32_t(node_properties.size());
500 model_properties.nodeProperties = node_properties.data();
501 CHECK_XR(g_xrGetControllerModelPropertiesMSFT(session, model_key_, &model_properties),
502 "Failed to get controller model node properties.");
503
504 node_state_indices_.resize(node_properties.size(), -1);
505
506 /* Get mesh vertex data. */
507 const tinygltf::Scene &default_scene = gltf_model.scenes.at(
508 (gltf_model.defaultScene == -1) ? 0 : gltf_model.defaultScene);
509 const int32_t root_idx = -1;
510 const std::string root_name = "";
511 float root_transform[4][4] = {{0}};
512 root_transform[0][0] = root_transform[1][1] = root_transform[2][2] = root_transform[3][3] = 1.0f;
513
514 for (const int node_id : default_scene.nodes) {
515 load_node(gltf_model,
516 node_id,
517 root_idx,
518 root_transform,
519 root_name,
520 node_properties,
521 vertices_,
522 indices_,
523 components_,
524 nodes_,
525 node_state_indices_);
526 }
527
528 data_loaded_ = true;
529}
530
532{
533 if (!data_loaded_) {
534 return;
535 }
536
537 /* Get node states. */
538 XrControllerModelStateMSFT model_state{XR_TYPE_CONTROLLER_MODEL_STATE_MSFT};
539 model_state.nodeCapacityInput = 0;
540 CHECK_XR(g_xrGetControllerModelStateMSFT(session, model_key_, &model_state),
541 "Failed to get controller model node state count.");
542
543 const uint32_t count = model_state.nodeCountOutput;
544 std::vector<XrControllerModelNodeStateMSFT> node_states(
545 count, {XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT});
546 model_state.nodeCapacityInput = count;
547 model_state.nodeStates = node_states.data();
548 CHECK_XR(g_xrGetControllerModelStateMSFT(session, model_key_, &model_state),
549 "Failed to get controller model node states.");
550
551 /* Update node local transforms. */
552 assert(node_state_indices_.size() == count);
553
554 for (uint32_t state_idx = 0; state_idx < count; ++state_idx) {
555 const int32_t &node_idx = node_state_indices_[state_idx];
556 if (node_idx >= 0) {
557 const XrPosef &pose = node_states[state_idx].nodePose;
558 Eigen::Matrix4f &m = *(Eigen::Matrix4f *)nodes_[node_idx].local_transform;
559 Eigen::Quaternionf q(
560 pose.orientation.w, pose.orientation.x, pose.orientation.y, pose.orientation.z);
561 m.setIdentity();
562 m.block<3, 3>(0, 0) = q.toRotationMatrix();
563 m.block<3, 1>(0, 3) = Eigen::Vector3f(pose.position.x, pose.position.y, pose.position.z);
564 }
565 }
566
567 /* Calculate component transforms (in world space). */
568 std::vector<Eigen::Matrix4f> world_transforms(nodes_.size());
569 uint32_t i = 0;
570 for (const GHOST_XrControllerModelNode &node : nodes_) {
571 world_transforms[i] = (node.parent_idx >= 0) ? world_transforms[node.parent_idx] *
572 *(Eigen::Matrix4f *)node.local_transform :
573 *(Eigen::Matrix4f *)node.local_transform;
574 if (node.component_idx >= 0) {
575 memcpy(components_[node.component_idx].transform,
576 world_transforms[i].data(),
577 sizeof(components_[node.component_idx].transform));
578 }
579 ++i;
580 }
581}
582
583void GHOST_XrControllerModel::getData(GHOST_XrControllerModelData &r_data)
584{
585 if (data_loaded_) {
586 r_data.count_vertices = uint32_t(vertices_.size());
587 r_data.vertices = vertices_.data();
588 r_data.count_indices = uint32_t(indices_.size());
589 r_data.indices = indices_.data();
590 r_data.count_components = uint32_t(components_.size());
591 r_data.components = components_.data();
592 }
593 else {
594 r_data.count_vertices = 0;
595 r_data.vertices = nullptr;
596 r_data.count_indices = 0;
597 r_data.indices = nullptr;
598 r_data.count_components = 0;
599 r_data.components = nullptr;
600 }
601}
602
static void init_controller_model_extension_functions(XrInstance instance)
static void load_node(const tinygltf::Model &gltf_model, int gltf_node_id, int32_t parent_idx, const float parent_transform[4][4], const std::string &parent_name, const std::vector< XrControllerModelNodePropertiesMSFT > &node_properties, std::vector< GHOST_XrControllerModelVertex > &vertices, std::vector< uint32_t > &indices, std::vector< GHOST_XrControllerModelComponent > &components, std::vector< GHOST_XrControllerModelNode > &nodes, std::vector< int32_t > &node_state_indices)
static void read_vertices(const tinygltf::Accessor &accessor, const tinygltf::BufferView &buffer_view, const tinygltf::Buffer &buffer, GHOST_XrPrimitive &primitive)
static XrInstance g_instance
static void validate_accessor(const tinygltf::Accessor &accessor, const tinygltf::BufferView &buffer_view, const tinygltf::Buffer &buffer, size_t byte_stride, size_t element_size)
static PFN_xrLoadControllerModelMSFT g_xrLoadControllerModelMSFT
static void read_indices(const tinygltf::Accessor &accessor, const tinygltf::BufferView &buffer_view, const tinygltf::Buffer &buffer, GHOST_XrPrimitive &primitive)
static PFN_xrGetControllerModelPropertiesMSFT g_xrGetControllerModelPropertiesMSFT
static void load_index_accessor(const tinygltf::Model &gltf_model, const tinygltf::Accessor &accessor, GHOST_XrPrimitive &primitive)
static PFN_xrGetControllerModelStateMSFT g_xrGetControllerModelStateMSFT
static PFN_xrGetControllerModelKeyMSFT g_xrGetControllerModelKeyMSFT
static GHOST_XrPrimitive read_primitive(const tinygltf::Model &gltf_model, const tinygltf::Primitive &gltf_primitive)
static void calc_node_transforms(const tinygltf::Node &gltf_node, const float parent_transform[4][4], float r_local_transform[4][4], float r_world_transform[4][4])
static void load_attribute_accessor(const tinygltf::Model &gltf_model, const std::string &attribute_name, int accessor_id, GHOST_XrPrimitive &primitive)
#define INIT_EXTENSION_FUNCTION(name)
#define CHECK_XR(call, error_msg)
#define ELEM(...)
void updateComponents(XrSession session)
GHOST_XrControllerModel(XrInstance instance, const char *subaction_path)
void getData(GHOST_XrControllerModelData &r_data)
GHOST_XrException(const char *msg, int result=0)
constexpr int64_t size() const
#define assert(assertion)
unsigned int uchar
float3x3 scale(float3x3 mat, float2 scale)
unsigned int uint32_t
Definition BKE_text.h:81
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
std::vector< GHOST_XrControllerModelVertex > vertices
std::vector< uint32_t > indices