HDK
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GU_BVH.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * NAME: GU_BVH.h (GU Library, C++)
7  *
8  * COMMENTS: Bounding Volume Hierarchy (BVH) implementation for GEO_Detail.
9  */
10 
11 #pragma once
12 
13 #include "GU_API.h"
14 #include <GEO/GEO_BVH.h>
15 #include <GA/GA_Handle.h>
16 #include <GA/GA_Types.h>
17 #include <UT/UT_ArrayMap.h>
18 #include <UT/UT_UniquePtr.h>
19 #include <UT/UT_Vector3.h>
20 #include <VM/VM_SIMD.h>
21 #include <limits>
22 
23 class UT_Lock;
24 class GU_PackedImpl;
25 class GU_RayPrimInfo;
27 
28 namespace GU {
29 
30 template<uint NAXES,typename SUBCLASS>
32 
33 class GU_API BVH : public BVHBase<3, BVH>
34 {
35  using Base = BVHBase<3, BVH>;
36  friend Base;
37  static constexpr uint NAXES = 3;
38 
39  static constexpr bool theHasPrimitives = true;
40  static constexpr bool theReordersPositions = false;
41 
42  enum OtherPrimType : uint
43  {
44  OTHERPRIM_BVHXLATESCALE,
45  OTHERPRIM_BVHUNIFORM,
46  OTHERPRIM_BVHFULLXFORM,
47  OTHERPRIM_RAYPRIMINFO,
48  OTHERPRIM_HEIGHTFIELD,
49  OTHERPRIM_SEGMENT,
50  OTHERPRIM_NGON_TRI,
51  OTHERPRIM_NGON_QUAD
52  };
53 
54  struct TranslateScale
55  {
57  double inverse_scale;
58 
59  SYS_FORCE_INLINE void transformPosition(UT_Vector3D &position) const
60  {
61  position = position/inverse_scale + translate;
62  }
63  SYS_FORCE_INLINE void inverseTransformPosition(UT_Vector3D &position) const
64  {
65  position = (position - translate)*inverse_scale;
66  }
67  SYS_FORCE_INLINE void transformDirection(UT_Vector3D &vector) const
68  {
69  // Nothing to do, since we'd just normalize out the scale anyway
70  }
71  SYS_FORCE_INLINE void inverseTransformDirection(UT_Vector3D &vector) const
72  {
73  // Nothing to do, since we'd just normalize out the scale anyway
74  }
75  SYS_FORCE_INLINE void transformVector(UT_Vector3D &vector) const
76  {
77  vector /= inverse_scale;
78  }
79  SYS_FORCE_INLINE float scaleT(float t) const
80  {
81  return t/inverse_scale;
82  }
83  SYS_FORCE_INLINE float inverseScaleT(float t) const
84  {
85  return t*inverse_scale;
86  }
87  };
88  struct UniformTransform
89  {
90  /// This is scaled by sqrt(inverse_scale), so that if we do
91  /// rotation.conjugate()*P*rotation, without normalizing,
92  /// it'll automatically apply the inverse scale.
95  double scale;
96 
97  SYS_FORCE_INLINE void transformPosition(UT_Vector3D &position) const
98  {
99  // NOTE: UT_QuaternionT::rotate assumes that rotation is normalized.
100  // We're using the fact that it's not, to our advantage,
101  // to automatically apply the scale.
102  position = (rotation*scale).rotate(position) + translate;
103  }
104  SYS_FORCE_INLINE void inverseTransformPosition(UT_Vector3D &position) const
105  {
106  // NOTE: UT_QuaternionT::rotateInverse assumes that rotation is normalized.
107  // We're using the fact that it's not, to our advantage,
108  // to automatically apply the inverse scale.
109  position = rotation.rotateInverse(position - translate);
110  }
111  SYS_FORCE_INLINE void transformDirection(UT_Vector3D &vector) const
112  {
113  vector = rotation.rotate(vector);
114  // NOTE: UT_QuaternionT::rotate assumes that rotation is normalized,
115  // but it's not, so we need to normalize vector.
116  vector.normalize();
117  }
118  SYS_FORCE_INLINE void inverseTransformDirection(UT_Vector3D &vector) const
119  {
120  vector = rotation.rotateInverse(vector);
121  // NOTE: UT_QuaternionT::rotateInverse assumes that rotation is normalized,
122  // but it's not, so we need to normalize vector.
123  vector.normalize();
124  }
125  SYS_FORCE_INLINE void transformVector(UT_Vector3D &vector) const
126  {
127  vector = rotation.rotate(vector);
128  }
129  SYS_FORCE_INLINE float scaleT(float t) const
130  {
131  return t*scale;
132  }
133  SYS_FORCE_INLINE float inverseScaleT(float t) const
134  {
135  return t/scale;
136  }
137  };
138 
139  struct PrimData
140  {
141  GA_Offset myPrimOff;
142  union {
143  const BVH *myBVHPtr;
144  /// NOTE: This might be nullptr if the GU_RayPrimInfo was degenerate,
145  /// even if myOtherType is OTHERPRIM_RAYPRIMINFO.
146  GU_RayPrimInfo *myRayPrimPtr;
147  void *myDataPtr;
148  uint myDataInts[2];
149  /// NOTE: This can't be GA_Offset, since on strict types builds,
150  /// GA_Offset has a non-trivial default constructor.
151  GA_Size myPt0Off;
152  };
153  union {
154  struct {
155  /// Used for triangles
156  float myN[NAXES];
157  /// Used for w component of polygons in polygon soups
158  float myF;
159  };
160  struct {
161  union {
162  /// Used if myOtherType is not OTHERPRIM_RAYPRIMITIVE
163  void *myOtherTransform;
164 
165  /// Used if myOtherType is OTHERPRIM_RAYPRIMITIVE
166  const GEO_Detail *myDetail;
167 
168  /// Used if myOtherType is OTHERPRIM_SEGMENT
169  /// NOTE: This can't be GA_Offset, since on strict types builds,
170  /// GA_Offset has a non-trivial default constructor.
171  GA_Size myPt1Off;
172  };
173  /// Used if in the "other" primitive range
174  OtherPrimType myOtherType;
175 
176  /// Used if myOtherType is OTHERPRIM_SEGMENT
177  uint mySegment;
178  };
179  struct {
180  /// Used for mesh primitives
181  uint myCols;
182  uint myRows;
183  };
184  };
185  };
186 
187  struct NGonTri
188  {
189  UT_Vector3 myN;
190  char myNGonXAxis;
191  char myNGonYAxis;
192  GA_Offset myPtOffs[3];
193  float myNGonCentreX;
194  float myNGonCentreY;
195  };
196  struct NGonQuad
197  {
198  GA_Offset myPtOffs[4];
199  float myNGonCentreX;
200  float myNGonCentreY;
201  char myNGonXAxis;
202  char myNGonYAxis;
203  };
204 
205  /// Point offsets for triangles
206  /// This array actually contains myQuadPoints and myTetPoints, too.
207  UT_UniquePtr<GA_Offset[]> myTriPoints;
208  /// Point offsets for quads
209  /// This is actually a pointer into myTriPoints.
210  GA_Offset *myQuadPoints;
211  /// Point offsets for tets
212  /// This is actually a pointer into myTriPoints.
213  GA_Offset *myTetPoints;
214  /// Point offsets for hexes
215  /// This is actually a pointer into myTriPoints.
216  GA_Offset *myHexPoints;
217 
218  GA_Size myTriStart;
219  GA_Size myQuadStart;
220  GA_Size myTetStart;
221  GA_Size myHexStart;
222  GA_Size myOtherPrimStart;
223  GA_Size myNItems;
224 
225  GA_DataId myTopologyDataId;
226  GA_DataId myPrimitiveListDataId;
227 
228  /// Additional data for primitives, especially primitives that are not
229  /// triangles, quads, or tets.
230  UT_UniquePtr<PrimData[]> myPrimData;
231 
232  /// These are for managing packed primitives.
233  /// We share trees for common details, and we share details for common
234  /// packed primitive implementations that don't directly provide a detail.
235  /// @{
238  SecondaryTreeMap mySecondaryTrees;
239  SecondaryDetailMap mySecondaryDetails;
240  /// @}
241 
242  bool myHasSecondary;
243 
244 public:
246  : Base()
247  , myTriPoints(nullptr)
248  , myQuadPoints(nullptr)
249  , myTetPoints(nullptr)
250  , myHexPoints(nullptr)
251  , myTriStart(0)
252  , myQuadStart(0)
253  , myTetStart(0)
254  , myHexStart(0)
255  , myOtherPrimStart(0)
256  , myNItems(0)
257  , myTopologyDataId(GA_INVALID_DATAID)
258  , myPrimitiveListDataId(GA_INVALID_DATAID)
259  , myPrimData(nullptr)
260  , myHasSecondary(false)
261  {}
263  {
264  clear();
265  }
266 
267  SYS_FORCE_INLINE GA_Offset primitiveOffset(exint prim_index) const noexcept
268  {
269  return myPrimData[prim_index].myPrimOff;
270  }
271 
272  void clear() noexcept;
273 
274  SYS_FORCE_INLINE GA_Size numItems() const noexcept
275  {
276  return myNItems;
277  }
278 
279  GA_DataId topologyId() const { return myTopologyDataId; }
280  GA_DataId primlistId() const { return myPrimitiveListDataId; }
281 
282  struct Options
283  {
285  {
288  ALL_POINTS
289  };
290 
291  PointStyle points = NO_POINTS;
292 
293  const GA_Range *point_range = nullptr;
294  const GA_Range *prim_range = nullptr;
295  bool just_edges = false;
296 
297  /// If true, only triangles on the unshared surface of tetrahedra will
298  /// be added, not the solid tetrahedra themselves. findClosest will
299  /// find the closest surface point, and sendRay will only intersect the
300  /// surface.
301  ///
302  /// If false, only the solid tetrahedra will be added. findClosest will
303  /// find the current point if it's inside a tetrahedron, else the
304  /// closest surface point, and sendRay will intersect the current point
305  /// if it's inside a tetrahedron, else the first surface intersected.
306  bool tet_surface = false;
307  };
308 
309  /// NOTE: If options is different from what it was before, you must set
310  /// force_rebalance to true.
311  /// NOTE: With this signature, radscale scales the pscale attribute
312  /// if it's a valid attribute, else it's the point radius.
313  void init(const GEO_Detail &detail,
314  const GA_ROHandleT<VectorType> &P,
315  const Options &options,
316  const GA_ROHandleF &pscale,
317  const float radscale = 1.0f,
318  const bool force_rebalance=false,
319  SecondaryTreeMap *secondary_trees=nullptr,
320  SecondaryDetailMap *secondary_details=nullptr,
321  UT_Lock *secondary_lock=nullptr) noexcept;
322 
323  /// NOTE: With this signature, radius is the point radius.
324  void init(const GEO_Detail &detail,
325  const GA_ROHandleT<VectorType> &P,
326  const Options &options,
327  const float radius = 0.0f,
328  const bool force_rebalance=false) noexcept
329  {
330  init(detail, P, options, GA_ROHandleF(), radius, force_rebalance);
331  }
332 
333  SYS_FORCE_INLINE bool
334  isNGon(exint index) const noexcept
335  {
336  if (index < myOtherPrimStart)
337  return false;
338  exint prim_index = index - myTriStart;
339  OtherPrimType type = myPrimData[prim_index].myOtherType;
340  return type == OTHERPRIM_NGON_TRI || type == OTHERPRIM_NGON_QUAD;
341  }
342 
343  /// The UVWs returned for n-gons are for the sub-polygons,
344  /// so we need to compute the true UVWs from the positions.
345  UT_Vector3 findNGonUVW(exint index, const UT_Vector3 &position, const GEO_Detail &detail) const noexcept;
346 
347  SYS_FORCE_INLINE bool
348  isPacked(exint index) const noexcept
349  {
350  if (index < myOtherPrimStart)
351  return false;
352  exint prim_index = index - myTriStart;
353  OtherPrimType type = myPrimData[prim_index].myOtherType;
354  return type == OTHERPRIM_BVHUNIFORM || type == OTHERPRIM_BVHXLATESCALE || type == OTHERPRIM_BVHFULLXFORM;
355  }
356 
357 protected:
358  /// These are just used in the init function to change the decision about
359  /// clearing after some things have been initialized.
360  /// @{
361  void clearPrimDataAllocations() noexcept;
362  void clearSecondary() noexcept;
363  /// @}
364 
365  template<bool farthest,bool rm_backface,bool reverse,typename FUNCTOR>
366  bool intersectPrim(
367  uint index, const VectorType &origin, const VectorType &direction,
368  const VectorType &inverse_direction,
369  int &max_dir, VectorType &N0, VectorType &N1,
370  float &outer_tmax, float &outer_tmin, FUNCTOR &hit_info) const noexcept;
371  template<bool farthest>
372  void closestPrim(
373  uint index, const VectorType &origin, float &max_dist_squared,
374  exint &hit_index, UT_Vector3 &hit_uvw, VectorType &hit_position,
375  const UT_FixedVector<v4uf,NAXES> &vorigin,
376  UT_Array<exint> *nesting_array,
377  exint nesting_array_base) const noexcept;
378  template<bool normalize>
379  VectorType primGeometricNormal(const CommonHitInfo &hit_info) const noexcept;
380  SYS_FORCE_INLINE void primDerivs(const CommonHitInfo &hit_info, VectorType &dP_du, VectorType &dP_dv) const noexcept;
381  template<GA_AttributeOwner owner,typename T,typename DEST_T>
382  SYS_FORCE_INLINE bool primAttribute(const CommonHitInfo &hit_info, const GA_ROHandleT<T> &attrib, const GEO_Detail &detail, DEST_T &value) const noexcept;
383 
384  template<bool farthest,bool rm_backface,bool reverse,bool bidirectional=false,typename FUNCTOR>
385  static SYS_FORCE_INLINE bool intersectQuad(
386  const UT_Vector3 &origin,
387  const UT_Vector3 &inverse_direction,
388  const UT_Vector3 pos[4],
389  const int max_dir,
390  const UT_Vector3 &N0,
391  const UT_Vector3 &N1,
392  const PrimData &prim_data,
393  float &outer_tmin,
394  float &outer_tmax,
395  const uint index,
396  FUNCTOR &hit_info);
397 
398  template<bool farthest,bool rm_backface,bool reverse,bool bidirectional=false,typename FUNCTOR>
399  static SYS_FORCE_INLINE bool intersectTet(
400  const UT_Vector3 &origin,
401  const UT_Vector3 &inverse_direction,
402  const UT_Vector3 pos[4],
403  const PrimData &prim_data,
404  float &outer_tmin,
405  float &outer_tmax,
406  const uint index,
407  FUNCTOR &hit_info);
408 
409  template<bool farthest,bool rm_backface,bool reverse,typename FUNCTOR>
410  static SYS_FORCE_INLINE bool intersectHex(
411  const UT_Vector3 &origin,
412  const UT_Vector3 &direction,
413  const UT_Vector3 &inverse_direction,
414  const UT_Vector3 pos[8],
415  int &max_dir,
416  UT_Vector3 &N0,
417  UT_Vector3 &N1,
418  const PrimData &prim_data,
419  float &outer_tmin,
420  float &outer_tmax,
421  const uint index,
422  FUNCTOR &hit_info);
423 
424  template<bool farthest>
425  static SYS_FORCE_INLINE bool triClosestPoint(
426  uint index,
427  const VectorType &origin,
428  const VectorType pos[3],
429  const PrimData &prim_data,
430  const UT_Vector3 &normal,
431  float &max_dist_squared,
432  exint &hit_index,
433  UT_Vector3 &hit_uvw,
434  UT_Vector3 &hit_position);
435 
436  template<bool farthest>
437  static SYS_FORCE_INLINE bool quadClosestPoint(
438  uint index,
439  const VectorType &origin,
440  const UT_FixedVector<v4uf,3> &vorigin,
441  const VectorType pos[4],
442  const PrimData &prim_data,
443  float &max_dist_squared,
444  exint &hit_index,
445  UT_Vector3 &hit_uvw,
446  UT_Vector3 &hit_position);
447 
448  static bool hexClosestPoint(
449  uint index,
450  const VectorType &origin,
451  const UT_FixedVector<v4uf,3> &vorigin,
452  const VectorType pos[8],
453  float &max_dist_squared,
454  exint &hit_index, UT_Vector3 &hit_uvw, UT_Vector3 &hit_position);
455 
456  template<typename V3_ARRAY>
457  SYS_FORCE_INLINE static void addTriangleData(
458  GA_Offset *&tri_points,
459  const V3_ARRAY &positions,
460  const GA_ROHandleT<VectorType> &posattrib,
461  PrimData *primdata,
462  SingleBoxType *prim_box_start,
463  exint &tri_primnum,
464  GA_Offset primoff,
465  int data_int = -1,
466  float data_float = 0) noexcept;
467 
468  template<typename V3_ARRAY>
469  SYS_FORCE_INLINE static void addQuadData(
470  GA_Offset *&quad_points,
471  const V3_ARRAY &positions,
472  const GA_ROHandleT<VectorType> &posattrib,
473  PrimData *primdata,
474  SingleBoxType *prim_box_start,
475  exint &quad_primnum,
476  GA_Offset primoff,
477  int data_int = -1,
478  float data_float = 0) noexcept;
479 
480  SYS_FORCE_INLINE static void addRayPrimInfo(
481  PrimData &primdata,
482  GA_Offset primoff,
483  SingleBoxType &primbox,
484  GU_RayPrimInfo *rayprim,
485  exint &other_primnum,
486  const GEO_Detail &detail,
487  float w = 0) noexcept;
488 
489 public:
490  // NOTE: These are only public to work around a compile error.
491  using BVHBase::SingleHitAndNormalFunctor;
492  using BVHBase::AllHitsAndNormalsFunctor;
493 
494  template<bool farthest,bool rm_backface,bool reverse,bool bidirectional,typename FUNCTOR>
496 protected:
497 
498  // We must specify that this is at global scope because we're inside a
499  // namepspace here.
500  friend class ::GU_RayHeightFieldInfo;
501 };
502 
503 #if 0
504 class GU_API BVH_2D : public BVHBase<2, BVH_2D>
505 {
506  using Base = BVHBase<2, BVH_2D>;
507  friend class Base;
508  static constexpr uint NAXES = 2;
509 
510  static constexpr bool theHasPrimitives = true;
511 
512  struct PrimData
513  {
514  GA_Offset myPrimOff;
515  union {
516  void *myDataPtr;
517  uint myDataInts[2];
518  };
519  VectorType myN;
520  float myF;
521  };
522 
523  /// Point offsets for segments
524  UT_UniquePtr<GA_Offset[]> mySegmentPoints;
525 
526  GA_Size myOtherPrimStart;
527 
528  /// Additional data for primitives.
529  UT_UniquePtr<PrimData[]> myPrimData;
530 
531 public:
532  SYS_FORCE_INLINE BVH_2D() noexcept
533  : Base()
534  , mySegmentPoints(nullptr)
535  {}
536 
537  SYS_FORCE_INLINE GA_Offset primitiveOffset(exint prim_index) const noexcept
538  {
539  return myPrimData[prim_index].myPrimOff;
540  }
541 
542  SYS_FORCE_INLINE void clear() noexcept
543  {
544  Base::clear();
545  mySegmentPoints.reset();
546  myPrimData.reset();
547  }
548 
549  struct Options
550  {
551  enum PointStyle
552  {
553  NO_POINTS,
554  DISCONNECTED_POINTS,
555  ALL_POINTS
556  };
557 
558  PointStyle points = NO_POINTS;
559 
560  const GA_Range *point_range = nullptr;
561  const GA_Range *prim_range = nullptr;
562  bool just_edges = false;
563  };
564 
565  void init(const GA_Detail &detail,
566  const GA_ROHandleT<VectorType> &P,
567  const Options &options,
569  const bool force_rebalance=false) noexcept;
570 
571 protected:
572  template<bool farthest,bool rm_backface,bool reverse>
573  SYS_FORCE_INLINE bool intersectPrim(
574  uint index, const VectorType &origin, const VectorType &direction,
575  const VectorType &inverse_direction,
576  int &max_dir, VectorType &N0, VectorType &N1,
577  float &outer_tmax, float &outer_tmin, exint &hit_index, UT_Vector3 &hit_uvw) const noexcept;
578  template<bool farthest>
579  SYS_FORCE_INLINE void closestPrim(
580  uint index, const VectorType &origin, float &max_dist_squared,
581  exint &hit_index, UT_Vector3 &hit_uvw, VectorType &hit_position,
582  const UT_FixedVector<v4uf,NAXES> &vorigin,
583  UT_Array<exint> *nesting_array,
584  exint nesting_array_base) const noexcept;
585  template<bool normalize>
586  SYS_FORCE_INLINE VectorType primGeometricNormal(const CommonHitInfo &hit_info) const noexcept;
587  SYS_FORCE_INLINE void primDerivs(const CommonHitInfo &hit_info, VectorType &dP_du, VectorType &dP_dv) const noexcept;
588  template<GA_AttributeOwner owner,typename T,typename DEST_T>
589  SYS_FORCE_INLINE bool primAttribute(const CommonHitInfo &hit_info, const GA_ROHandleT<T> &attrib, const GEO_Detail &detail, DEST_T &value) const noexcept;
590 };
591 #endif
592 
593 } // GU namespace
594 
595 using GU_BVH = GU::BVH;
596 
GLdouble GLdouble GLint GLint const GLdouble * points
Definition: glad.h:2676
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the and then *wait for them to all complete We provide a helper class
Definition: thread.h:623
int64 GA_DataId
Definition: GA_Types.h:696
GA_DataId topologyId() const
Definition: GU_BVH.h:279
IMF_EXPORT IMATH_NAMESPACE::V3f direction(const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V2f &pixelPosition)
int64 exint
Definition: SYS_Types.h:125
Definition: GU_BVH.h:33
void reverse(I begin, I end)
Definition: pugixml.cpp:7190
#define GA_INVALID_DATAID
Definition: GA_Types.h:697
exint GA_Size
Defines the bit width for index and offset types in GA.
Definition: GA_Types.h:236
SYS_FORCE_INLINE bool isPacked(exint index) const noexcept
Definition: GU_BVH.h:348
SYS_FORCE_INLINE bool isNGon(exint index) const noexcept
Definition: GU_BVH.h:334
A range of elements in an index-map.
Definition: GA_Range.h:42
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:39
GA_Size GA_Offset
Definition: GA_Types.h:646
GA_API const UT_StringHolder scale
GLfloat f
Definition: glcorearb.h:1926
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
GA_ROHandleT< fpreal32 > GA_ROHandleF
Definition: GA_Handle.h:1354
Definition: VM_SIMD.h:188
SYS_FORCE_INLINE GA_Offset primitiveOffset(exint prim_index) const noexcept
Definition: GU_BVH.h:267
SIM_API const UT_StringHolder rotation
#define GU_API
Definition: GU_API.h:14
ImageBuf OIIO_API rotate(const ImageBuf &src, float angle, string_view filtername=string_view(), float filterwidth=0.0f, bool recompute_roi=false, ROI roi={}, int nthreads=0)
GLdouble t
Definition: glad.h:2397
SYS_FORCE_INLINE ~BVH() noexcept
Definition: GU_BVH.h:262
GA_AttributeOwner
Definition: GA_Types.h:35
typename SYS_SelectType< UT_Vector2, UT_Vector3, NAXES==3 >::type VectorType
Definition: GEO_BVH.h:39
GLuint index
Definition: glcorearb.h:786
SIM_API const UT_StringHolder position
SYS_FORCE_INLINE BVH() noexcept
Definition: GU_BVH.h:245
GA_API const UT_StringHolder pscale
Container class for all geometry.
Definition: GA_Detail.h:96
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
Definition: core.h:1131
SYS_FORCE_INLINE UT_StorageMathFloat_t< T > normalize() noexcept
Definition: UT_Vector3.h:376
GA_DataId primlistId() const
Definition: GU_BVH.h:280
PUGI__FN char_t * translate(char_t *buffer, const char_t *from, const char_t *to, size_t to_length)
Definition: pugixml.cpp:8352
type
Definition: core.h:1059
unsigned int uint
Definition: SYS_Types.h:45
constexpr T normalize(UT_FixedVector< T, D > &a) noexcept