OpenVDB 13.0.1
Loading...
Searching...
No Matches
UT_VDBUtils.h
Go to the documentation of this file.
1// Copyright Contributors to the OpenVDB Project
2// SPDX-License-Identifier: Apache-2.0
3
4/*
5 * Copyright (c) Side Effects Software Inc.
6 *
7 * Produced by:
8 * Side Effects Software Inc.
9 * 123 Front Street West, Suite 1401
10 * Toronto, Ontario
11 * Canada M5J 2M2
12 * 416-366-4607
13 */
14
15#include <UT/UT_Version.h>
16
17#if !defined(SESI_OPENVDB) && !defined(SESI_OPENVDB_PRIM)
18
19#include <UT/UT_VDBUtils.h>
20
21#else
22
23#ifndef __HDK_UT_VDBUtils__
24#define __HDK_UT_VDBUtils__
25
26enum UT_VDBType
27{
28 UT_VDB_INVALID,
29 UT_VDB_FLOAT,
30 UT_VDB_DOUBLE,
31 UT_VDB_INT32,
32 UT_VDB_INT64,
33 UT_VDB_BOOL,
34 UT_VDB_VEC3F,
35 UT_VDB_VEC3D,
36 UT_VDB_VEC3I,
37 UT_VDB_POINTINDEX,
38 UT_VDB_POINTDATA,
39};
40
41#include <openvdb/openvdb.h>
42#include <openvdb/tools/PointIndexGrid.h>
43#include <openvdb/points/PointDataGrid.h>
44
45#include <UT/UT_Assert.h>
46#include <UT/UT_BoundingBox.h>
47#include <UT/UT_Matrix4.h>
48#include <UT/UT_Matrix3.h>
49#include <UT/UT_Matrix2.h>
50#include <SYS/SYS_Math.h>
51
52UT_API size_t
53UTformatBuffer(char *buffer, size_t buffer_size, const UT_VDBType &v);
54
55UT_API const char *UTvdbType(UT_VDBType t);
56UT_API UT_VDBType UTvdbType(const char *n);
57
58/// Calls openvdb::initialize()
59inline void UTvdbInitialize() { openvdb::initialize(); }
60
61/// Find the UT_VDBType from a grid
62inline UT_VDBType
63UTvdbGetGridType(const openvdb::GridBase &grid)
64{
65 using namespace openvdb;
66 using namespace openvdb::tools;
67 using namespace openvdb::points;
68
69 if (grid.isType<FloatGrid>())
70 return UT_VDB_FLOAT;
71 if (grid.isType<DoubleGrid>())
72 return UT_VDB_DOUBLE;
73 if (grid.isType<Int32Grid>())
74 return UT_VDB_INT32;
75 if (grid.isType<Int64Grid>())
76 return UT_VDB_INT64;
77 if (grid.isType<BoolGrid>())
78 return UT_VDB_BOOL;
79 if (grid.isType<Vec3fGrid>())
80 return UT_VDB_VEC3F;
81 if (grid.isType<Vec3dGrid>())
82 return UT_VDB_VEC3D;
83 if (grid.isType<Vec3IGrid>())
84 return UT_VDB_VEC3I;
85 if (grid.isType<Vec3IGrid>())
86 return UT_VDB_VEC3I;
87 if (grid.isType<PointIndexGrid>())
88 return UT_VDB_POINTINDEX;
89 if (grid.isType<PointDataGrid>())
90 return UT_VDB_POINTDATA;
91
92 return UT_VDB_INVALID;
93}
94
95/// Return the string representation of a grid's underlying value type
96inline const char *
97UTvdbGetGridTypeString(const openvdb::GridBase &grid)
98{
99 switch(UTvdbGetGridType(grid))
100 {
101 case UT_VDB_FLOAT:
102 return "float";
103 case UT_VDB_DOUBLE:
104 return "double";
105 case UT_VDB_INT32:
106 return "int32";
107 case UT_VDB_INT64:
108 return "int64";
109 case UT_VDB_BOOL:
110 return "bool";
111 case UT_VDB_VEC3F:
112 return "Vec3f";
113 case UT_VDB_VEC3D:
114 return "Vec3d";
115 case UT_VDB_VEC3I:
116 return "Vec3i";
117 case UT_VDB_POINTINDEX:
118 return "PointIndex";
119 case UT_VDB_POINTDATA:
120 return "PointData";
121 default:
122 return "invalid type";
123 }
124}
125
126/// Returns the tuple size of a grid given its value type.
127inline int
128UTvdbGetGridTupleSize(UT_VDBType type)
129{
130 switch(type)
131 {
132 case UT_VDB_FLOAT:
133 case UT_VDB_DOUBLE:
134 case UT_VDB_INT32:
135 case UT_VDB_INT64:
136 case UT_VDB_BOOL:
137 return 1;
138
139 case UT_VDB_VEC3F:
140 case UT_VDB_VEC3D:
141 case UT_VDB_VEC3I:
142 return 3;
143
144 case UT_VDB_POINTINDEX:
145 case UT_VDB_POINTDATA:
146 case UT_VDB_INVALID:
147 default:
148 break;
149 }
150
151 return 0;
152}
153
154/// Returns the tuple size of a grid
155inline int
156UTvdbGetGridTupleSize(const openvdb::GridBase &grid)
157{
158 return UTvdbGetGridTupleSize(UTvdbGetGridType(grid));
159}
160
161/// Special plusEqual class to avoid bool warnings
162/// @{
163template <typename T>
164struct UT_VDBMath
165{
166 static void plusEqual(T &lhs, const T &rhs)
167 { lhs += rhs; }
168};
169template <>
170struct UT_VDBMath<bool>
171{
172 static void plusEqual(bool &lhs, const bool &rhs)
173 { lhs = lhs | rhs; }
174};
175/// @}
176
177/// Helpers for downcasting to a specific grid type
178/// @{
179template <typename GridType>
180inline const GridType *
181UTvdbGridCast(const openvdb::GridBase *grid)
182 { return UTverify_cast<const GridType *>(grid); }
183
184template <typename GridType>
185inline GridType *
186UTvdbGridCast(openvdb::GridBase *grid)
187 { return UTverify_cast<GridType *>(grid); }
188
189template <typename GridType>
190inline const GridType &
191UTvdbGridCast(const openvdb::GridBase &grid)
192 { return *UTverify_cast<const GridType *>(&grid); }
193
194template <typename GridType>
195inline GridType &
196UTvdbGridCast(openvdb::GridBase &grid)
197 { return *UTverify_cast<GridType *>(&grid); }
198
199template <typename GridType>
200inline typename GridType::ConstPtr
201UTvdbGridCast(openvdb::GridBase::ConstPtr grid)
202 { return openvdb::gridConstPtrCast<GridType>(grid); }
203
204template <typename GridType>
205inline typename GridType::Ptr
206UTvdbGridCast(openvdb::GridBase::Ptr grid)
207 { return openvdb::gridPtrCast<GridType>(grid); }
208/// @}
209
210////////////////////////////////////////
211
212namespace UT_VDBUtils {
213
214// Helper function used internally by UTvdbProcessTypedGrid()
215// to instantiate a templated functor for a specific grid type
216// and then to call the functor with a grid of that type
217template<typename GridType, typename OpType, typename GridBaseType>
218inline void
219callTypedGrid(GridBaseType &grid, OpType& op)
220{
221 op.template operator()<GridType>(UTvdbGridCast<GridType>(grid));
222}
223
224} // namespace UT_VDBUtils
225
226////////////////////////////////////////
227
228
229/// @brief Utility function that, given a generic grid pointer,
230/// calls a functor on the fully-resolved grid
231///
232/// @par Example:
233/// @code
234/// using openvdb::Coord;
235/// using openvdb::CoordBBox;
236///
237/// struct FillOp {
238/// const CoordBBox bbox;
239///
240/// FillOp(const CoordBBox& b): bbox(b) {}
241///
242/// template<typename GridT>
243/// void operator()(GridT& grid) const {
244/// using ValueT = typename GridT::ValueType;
245/// grid.fill(bbox, ValueT(1));
246/// }
247/// };
248///
249/// GU_PrimVDB* vdb = ...;
250/// vdb->makeGridUnique();
251/// CoordBBox bbox(Coord(0,0,0), Coord(10,10,10));
252/// UTvdbProcessTypedGrid(vdb->getStorageType(), vdb->getGrid(), FillOp(bbox));
253/// @endcode
254///
255/// @return @c false if the grid type is unknown or unhandled.
256/// @{
257#define UT_VDB_DECL_PROCESS_TYPED_GRID(GRID_BASE_T) \
258template<typename OpType> \
259inline bool \
260UTvdbProcessTypedGrid(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
261{ \
262 using namespace openvdb; \
263 using namespace UT_VDBUtils; \
264 switch (grid_type) \
265 { \
266 case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
267 case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
268 case UT_VDB_INT32: callTypedGrid<Int32Grid>(grid, op); break; \
269 case UT_VDB_INT64: callTypedGrid<Int64Grid>(grid, op); break; \
270 case UT_VDB_VEC3F: callTypedGrid<Vec3SGrid>(grid, op); break; \
271 case UT_VDB_VEC3D: callTypedGrid<Vec3DGrid>(grid, op); break; \
272 case UT_VDB_VEC3I: callTypedGrid<Vec3IGrid>(grid, op); break; \
273 default: return false; \
274 } \
275 return true; \
276} \
277template<typename OpType> \
278inline bool \
279UTvdbProcessTypedGridTopology(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
280{ \
281 using namespace openvdb; \
282 using namespace UT_VDBUtils; \
283 switch (grid_type) \
284 { \
285 case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
286 case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
287 case UT_VDB_INT32: callTypedGrid<Int32Grid>(grid, op); break; \
288 case UT_VDB_INT64: callTypedGrid<Int64Grid>(grid, op); break; \
289 case UT_VDB_VEC3F: callTypedGrid<Vec3SGrid>(grid, op); break; \
290 case UT_VDB_VEC3D: callTypedGrid<Vec3DGrid>(grid, op); break; \
291 case UT_VDB_VEC3I: callTypedGrid<Vec3IGrid>(grid, op); break; \
292 case UT_VDB_BOOL: callTypedGrid<BoolGrid>(grid, op); break; \
293 default: return false; \
294 } \
295 return true; \
296} \
297template<typename OpType> \
298inline bool \
299UTvdbProcessTypedGridVec3(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
300{ \
301 using namespace openvdb; \
302 using namespace UT_VDBUtils; \
303 switch (grid_type) \
304 { \
305 case UT_VDB_VEC3F: callTypedGrid<Vec3SGrid>(grid, op); break; \
306 case UT_VDB_VEC3D: callTypedGrid<Vec3DGrid>(grid, op); break; \
307 case UT_VDB_VEC3I: callTypedGrid<Vec3IGrid>(grid, op); break; \
308 default: return false; \
309 } \
310 return true; \
311} \
312template<typename OpType> \
313inline bool \
314UTvdbProcessTypedGridScalar(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
315{ \
316 using namespace openvdb; \
317 using namespace UT_VDBUtils; \
318 switch (grid_type) \
319 { \
320 case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
321 case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
322 case UT_VDB_INT32: callTypedGrid<Int32Grid>(grid, op); break; \
323 case UT_VDB_INT64: callTypedGrid<Int64Grid>(grid, op); break; \
324 default: return false; \
325 } \
326 return true; \
327} \
328template<typename OpType> \
329inline bool \
330UTvdbProcessTypedGridReal(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
331{ \
332 using namespace openvdb; \
333 using namespace UT_VDBUtils; \
334 switch (grid_type) \
335 { \
336 case UT_VDB_FLOAT: callTypedGrid<FloatGrid>(grid, op); break; \
337 case UT_VDB_DOUBLE: callTypedGrid<DoubleGrid>(grid, op); break; \
338 default: return false; \
339 } \
340 return true; \
341} \
342template<typename OpType> \
343inline bool \
344UTvdbProcessTypedGridPoint(UT_VDBType grid_type, GRID_BASE_T grid, OpType& op) \
345{ \
346 using namespace openvdb; \
347 using namespace openvdb::tools; \
348 using namespace openvdb::points; \
349 using namespace UT_VDBUtils; \
350 switch (grid_type) \
351 { \
352 case UT_VDB_POINTINDEX: callTypedGrid<PointIndexGrid>(grid, op); break; \
353 case UT_VDB_POINTDATA: callTypedGrid<PointDataGrid>(grid, op); break; \
354 default: return false; \
355 } \
356 return true; \
357} \
358/**/
359UT_VDB_DECL_PROCESS_TYPED_GRID(const openvdb::GridBase &)
360UT_VDB_DECL_PROCESS_TYPED_GRID(const openvdb::GridBase *)
361UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase::ConstPtr)
362UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase &)
363UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase *)
364UT_VDB_DECL_PROCESS_TYPED_GRID(openvdb::GridBase::Ptr)
365
366/// @}
367
368
369// Helper macro for UTvdbCall* macros, do not outside of this file!
370#define UT_VDB_CALL(GRIDT, RETURN, FNAME, GRIDBASE, ...) \
371 { \
372 RETURN FNAME <GRIDT> (UTvdbGridCast<GRIDT>(GRIDBASE), __VA_ARGS__ ); \
373 } \
374 /**/
375
376//@{
377/// Macro to invoke the correct type of grid.
378/// Use like:
379/// @code
380/// UTvdbCallScalarType(grid_type, myfunction, grid, parms)
381/// @endcode
382/// to invoke
383/// @code
384/// template <typename GridType>
385/// static void
386/// myfunction(const GridType &grid, parms)
387/// { }
388/// @endcode
389
390#define UTvdbCallRealType(TYPE, FNAME, GRIDBASE, ...) \
391 if (TYPE == UT_VDB_FLOAT) \
392 UT_VDB_CALL(openvdb::FloatGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
393 else if (TYPE == UT_VDB_DOUBLE) \
394 UT_VDB_CALL(openvdb::DoubleGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
395 /**/
396#define UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, ...) \
397 UTvdbCallRealType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
398 else if (TYPE == UT_VDB_INT32) \
399 UT_VDB_CALL(openvdb::Int32Grid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
400 else if (TYPE == UT_VDB_INT64) \
401 UT_VDB_CALL(openvdb::Int64Grid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
402 /**/
403#define UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, ...) \
404 if (TYPE == UT_VDB_VEC3F) \
405 UT_VDB_CALL(openvdb::Vec3fGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
406 else if (TYPE == UT_VDB_VEC3D) \
407 UT_VDB_CALL(openvdb::Vec3dGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
408 else if (TYPE == UT_VDB_VEC3I) \
409 UT_VDB_CALL(openvdb::Vec3IGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
410 /**/
411#define UTvdbCallPointType(TYPE, FNAME, GRIDBASE, ...) \
412 if (TYPE == UT_VDB_POINTINDEX) \
413 UT_VDB_CALL(openvdb::tools::PointIndexGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
414 else if (TYPE == UT_VDB_POINTDATA) \
415 UT_VDB_CALL(openvdb::points::PointDataGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
416 /**/
417#define UTvdbCallBoolType(TYPE, FNAME, GRIDBASE, ...) \
418 if (TYPE == UT_VDB_BOOL) \
419 UT_VDB_CALL(openvdb::BoolGrid,(void),FNAME,GRIDBASE,__VA_ARGS__) \
420 /**/
421#define UTvdbCallAllType(TYPE, FNAME, GRIDBASE, ...) \
422 UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
423 else UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__); \
424 /**/
425#define UTvdbCallAllTopology(TYPE, FNAME, GRIDBASE, ...) \
426 UTvdbCallScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
427 else UTvdbCallVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
428 else UTvdbCallBoolType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
429 /**/
430//@}
431
432//@{
433/// Macro to invoke the correct type of grid.
434/// Use like:
435/// @code
436/// UTvdbReturnScalarType(grid_type, myfunction, grid, parms)
437/// @endcode
438/// to invoke
439/// @code
440/// return myfunction(grid, parms);
441/// @endcode
442/// via:
443/// @code
444/// template <typename GridType>
445/// static RESULT
446/// myfunction(const GridType &grid, parms)
447/// { }
448/// @endcode
449
450#define UTvdbReturnRealType(TYPE, FNAME, GRIDBASE, ...) \
451 if (TYPE == UT_VDB_FLOAT) \
452 UT_VDB_CALL(openvdb::FloatGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
453 else if (TYPE == UT_VDB_DOUBLE) \
454 UT_VDB_CALL(openvdb::DoubleGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
455 /**/
456#define UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, ...) \
457 UTvdbReturnRealType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
458 else if (TYPE == UT_VDB_INT32) \
459 UT_VDB_CALL(openvdb::Int32Grid,return,FNAME,GRIDBASE,__VA_ARGS__) \
460 else if (TYPE == UT_VDB_INT64) \
461 UT_VDB_CALL(openvdb::Int64Grid,return,FNAME,GRIDBASE,__VA_ARGS__) \
462 /**/
463#define UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, ...) \
464 if (TYPE == UT_VDB_VEC3F) \
465 UT_VDB_CALL(openvdb::Vec3fGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
466 else if (TYPE == UT_VDB_VEC3D) \
467 UT_VDB_CALL(openvdb::Vec3dGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
468 else if (TYPE == UT_VDB_VEC3I) \
469 UT_VDB_CALL(openvdb::Vec3IGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
470 /**/
471#define UTvdbReturnPointType(TYPE, FNAME, GRIDBASE, ...) \
472 if (TYPE == UT_VDB_POINTINDEX) \
473 UT_VDB_CALL(openvdb::tools::PointIndexGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
474 else if (TYPE == UT_VDB_POINTDATA) \
475 UT_VDB_CALL(openvdb::points::PointDataGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
476 /**/
477#define UTvdbReturnBoolType(TYPE, FNAME, GRIDBASE, ...) \
478 if (TYPE == UT_VDB_BOOL) \
479 UT_VDB_CALL(openvdb::BoolGrid,return,FNAME,GRIDBASE,__VA_ARGS__) \
480 /**/
481#define UTvdbReturnAllType(TYPE, FNAME, GRIDBASE, ...) \
482 UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
483 else UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__); \
484 /**/
485#define UTvdbReturnAllTopology(TYPE, FNAME, GRIDBASE, ...) \
486 UTvdbReturnScalarType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
487 else UTvdbReturnVec3Type(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
488 else UTvdbReturnBoolType(TYPE, FNAME, GRIDBASE, __VA_ARGS__) \
489 /**/
490//@}
491
492
493////////////////////////////////////////
494
495
496/// Matrix conversion from openvdb to UT
497// @{
498template <typename S>
499UT_Matrix4T<S>
500UTvdbConvert(const openvdb::math::Mat4<S> &src)
501{
502 return UT_Matrix4T<S>(src(0,0), src(0,1), src(0,2), src(0,3),
503 src(1,0), src(1,1), src(1,2), src(1,3),
504 src(2,0), src(2,1), src(2,2), src(2,3),
505 src(3,0), src(3,1), src(3,2), src(3,3));
506}
507
508template <typename S>
509UT_Matrix3T<S>
510UTvdbConvert(const openvdb::math::Mat3<S> &src)
511{
512 return UT_Matrix3T<S>(src(0,0), src(0,1), src(0,2),
513 src(1,0), src(1,1), src(1,2),
514 src(2,0), src(2,1), src(2,2));
515}
516
517template <typename S>
518UT_Matrix2T<S>
519UTvdbConvert(const openvdb::math::Mat2<S> &src)
520{
521 return UT_Matrix2T<S>(src(0,0), src(0,1),
522 src(1,0), src(1,1));
523}
524// @}
525
526/// Matrix conversion from UT to openvdb
527// @{
528template <typename S>
529openvdb::math::Mat4<S>
530UTvdbConvert(const UT_Matrix4T<S> &src)
531{
532 return openvdb::math::Mat4<S>(src(0,0), src(0,1), src(0,2), src(0,3),
533 src(1,0), src(1,1), src(1,2), src(1,3),
534 src(2,0), src(2,1), src(2,2), src(2,3),
535 src(3,0), src(3,1), src(3,2), src(3,3));
536}
537template <typename S>
538openvdb::math::Mat3<S>
539UTvdbConvert(const UT_Matrix3T<S> &src)
540{
541 return openvdb::math::Mat3<S>(src(0,0), src(0,1), src(0,2),
542 src(1,0), src(1,1), src(1,2),
543 src(2,0), src(2,1), src(2,2));
544}
545template <typename S>
546openvdb::math::Mat2<S>
547UTvdbConvert(const UT_Matrix2T<S> &src)
548{
549 return openvdb::math::Mat2<S>(src(0,0), src(0,1),
550 src(1,0), src(1,1));
551}
552// @}
553
554/// Vector conversion from openvdb to UT
555// @{
556template <typename S>
557UT_Vector4T<S>
558UTvdbConvert(const openvdb::math::Vec4<S> &src)
559{
560 return UT_Vector4T<S>(src.asPointer());
561}
562template <typename S>
563UT_Vector3T<S>
564UTvdbConvert(const openvdb::math::Vec3<S> &src)
565{
566 return UT_Vector3T<S>(src.asPointer());
567}
568template <typename S>
569UT_Vector2T<S>
570UTvdbConvert(const openvdb::math::Vec2<S> &src)
571{
572 return UT_Vector2T<S>(src.asPointer());
573}
574// @}
575
576/// Vector conversion from UT to openvdb
577// @{
578template <typename S>
579openvdb::math::Vec4<S>
580UTvdbConvert(const UT_Vector4T<S> &src)
581{
582 return openvdb::math::Vec4<S>(src.data());
583}
584template <typename S>
585openvdb::math::Vec3<S>
586UTvdbConvert(const UT_Vector3T<S> &src)
587{
588 return openvdb::math::Vec3<S>(src.data());
589}
590template <typename S>
591openvdb::math::Vec2<S>
592UTvdbConvert(const UT_Vector2T<S> &src)
593{
594 return openvdb::math::Vec2<S>(src.data());
595}
596// @}
597
598
599/// Bounding box conversion from openvdb to UT
600inline UT_BoundingBoxD
601UTvdbConvert(const openvdb::CoordBBox &bbox)
602{
603 return UT_BoundingBoxD(UTvdbConvert(bbox.getStart().asVec3d()),
604 UTvdbConvert(bbox.getEnd().asVec3d()));
605}
606
607/// Bounding box conversion from openvdb to UT
608inline openvdb::math::CoordBBox
609UTvdbConvert(const UT_BoundingBoxI &bbox)
610{
611 return openvdb::math::CoordBBox(
612 openvdb::math::Coord(bbox.xmin(), bbox.ymin(), bbox.zmin()),
613 openvdb::math::Coord(bbox.xmax(), bbox.ymax(), bbox.zmax()));
614}
615
616/// Utility method to construct a Transform that lines up with a
617/// cell-centered Houdini volume with specified origin and voxel size.
618inline openvdb::math::Transform::Ptr
619UTvdbCreateTransform(const UT_Vector3 &orig, const UT_Vector3 &voxsize)
620{
621 // Transforms only valid for square voxels.
622 UT_ASSERT(SYSalmostEqual(voxsize.minComponent(), voxsize.maxComponent()));
623 fpreal vs = voxsize.maxComponent();
624 openvdb::math::Transform::Ptr xform =
625 openvdb::math::Transform::createLinearTransform(vs);
626 // Ensure voxel centers line up.
627 xform->postTranslate(UTvdbConvert(orig) + vs / 2);
628 return xform;
629}
630
631template <typename T>
632inline openvdb::math::Vec4<T> SYSabs(const openvdb::math::Vec4<T> &v1)
633{ return openvdb::math::Vec4<T>( SYSabs(v1[0]),
634 SYSabs(v1[1]),
635 SYSabs(v1[2]),
636 SYSabs(v1[3])
637 );
638}
639template <typename T>
640inline openvdb::math::Vec3<T> SYSabs(const openvdb::math::Vec3<T> &v1)
641{ return openvdb::math::Vec3<T>( SYSabs(v1[0]),
642 SYSabs(v1[1]),
643 SYSabs(v1[2])
644 );
645}
646template <typename T>
647inline openvdb::math::Vec2<T> SYSabs(const openvdb::math::Vec2<T> &v1)
648{ return openvdb::math::Vec2<T>( SYSabs(v1[0]),
649 SYSabs(v1[1])
650 );
651}
652
653template <typename T>
654inline openvdb::math::Vec4<T> SYSmin(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2)
655{ return openvdb::math::Vec4<T>( SYSmin(v1[0], v2[0]),
656 SYSmin(v1[1], v2[1]),
657 SYSmin(v1[2], v2[2]),
658 SYSmin(v1[3], v2[3])
659 );
660}
661template <typename T>
662inline openvdb::math::Vec4<T> SYSmax(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2)
663{ return openvdb::math::Vec4<T>( SYSmax(v1[0], v2[0]),
664 SYSmax(v1[1], v2[1]),
665 SYSmax(v1[2], v2[2]),
666 SYSmax(v1[3], v2[3])
667 );
668}
669template <typename T>
670inline openvdb::math::Vec4<T> SYSmin(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2, const openvdb::math::Vec4<T> &v3)
671{ return openvdb::math::Vec4<T>( SYSmin(v1[0], v2[0], v3[0]),
672 SYSmin(v1[1], v2[1], v3[1]),
673 SYSmin(v1[2], v2[2], v3[2]),
674 SYSmin(v1[3], v2[3], v3[3])
675 );
676}
677template <typename T>
678inline openvdb::math::Vec4<T> SYSmax(const openvdb::math::Vec4<T> &v1, const openvdb::math::Vec4<T> &v2, const openvdb::math::Vec4<T> &v3)
679{ return openvdb::math::Vec4<T>( SYSmax(v1[0], v2[0], v3[0]),
680 SYSmax(v1[1], v2[1], v3[1]),
681 SYSmax(v1[2], v2[2], v3[2]),
682 SYSmax(v1[3], v2[3], v3[3])
683 );
684}
685template <typename T>
686inline openvdb::math::Vec3<T> SYSmin(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2)
687{ return openvdb::math::Vec3<T>( SYSmin(v1[0], v2[0]),
688 SYSmin(v1[1], v2[1]),
689 SYSmin(v1[2], v2[2])
690 );
691}
692template <typename T>
693inline openvdb::math::Vec3<T> SYSmax(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2)
694{ return openvdb::math::Vec3<T>( SYSmax(v1[0], v2[0]),
695 SYSmax(v1[1], v2[1]),
696 SYSmax(v1[2], v2[2])
697 );
698}
699template <typename T>
700inline openvdb::math::Vec3<T> SYSmin(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2, const openvdb::math::Vec3<T> &v3)
701{ return openvdb::math::Vec3<T>( SYSmin(v1[0], v2[0], v3[0]),
702 SYSmin(v1[1], v2[1], v3[1]),
703 SYSmin(v1[2], v2[2], v3[2])
704 );
705}
706template <typename T>
707inline openvdb::math::Vec3<T> SYSmax(const openvdb::math::Vec3<T> &v1, const openvdb::math::Vec3<T> &v2, const openvdb::math::Vec3<T> &v3)
708{ return openvdb::math::Vec3<T>( SYSmax(v1[0], v2[0], v3[0]),
709 SYSmax(v1[1], v2[1], v3[1]),
710 SYSmax(v1[2], v2[2], v3[2])
711 );
712}
713template <typename T>
714inline openvdb::math::Vec2<T> SYSmin(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2)
715{ return openvdb::math::Vec2<T>( SYSmin(v1[0], v2[0]),
716 SYSmin(v1[1], v2[1])
717 );
718}
719template <typename T>
720inline openvdb::math::Vec2<T> SYSmax(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2)
721{ return openvdb::math::Vec2<T>( SYSmax(v1[0], v2[0]),
722 SYSmax(v1[1], v2[1])
723 );
724}
725template <typename T>
726inline openvdb::math::Vec2<T> SYSmin(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2, const openvdb::math::Vec2<T> &v3)
727{ return openvdb::math::Vec2<T>( SYSmin(v1[0], v2[0], v3[0]),
728 SYSmin(v1[1], v2[1], v3[1])
729 );
730}
731template <typename T>
732inline openvdb::math::Vec2<T> SYSmax(const openvdb::math::Vec2<T> &v1, const openvdb::math::Vec2<T> &v2, const openvdb::math::Vec2<T> &v3)
733{ return openvdb::math::Vec2<T>( SYSmax(v1[0], v2[0], v3[0]),
734 SYSmax(v1[1], v2[1], v3[1])
735 );
736}
737
738#endif // __HDK_UT_VDBUtils__
739
740#endif // SESI_OPENVDB || SESI_OPENVDB_PRIM
PointDataGrid.h
Attribute-owned data structure for points. Point attributes are stored in leaf nodes and ordered by v...
PointIndexGrid.h
Space-partitioning acceleration structure for points. Partitions the points into voxels to accelerate...
openvdb::v13_0::GridBase
Abstract base class for typed grids.
Definition Grid.h:78
openvdb::v13_0::GridBase::isType
bool isType() const
Return true if this grid is of the same type as the template parameter.
Definition Grid.h:146
openvdb::v13_0::math::CoordBBox
Axis-aligned bounding box of signed integer coordinates.
Definition Coord.h:252
openvdb::v13_0::math::CoordBBox::getStart
Coord getStart() const
Return the minimum coordinate.
Definition Coord.h:336
openvdb::v13_0::math::CoordBBox::getEnd
Coord getEnd() const
Return the maximum coordinate plus one.
Definition Coord.h:339
openvdb::v13_0::math::Coord::asVec3d
Vec3d asVec3d() const
Definition Coord.h:144
nanovdb::GridType
GridType
List of types that are currently supported by NanoVDB.
Definition NanoVDB.h:219
openvdb::v13_0::points
Definition AttributeArray.h:42
openvdb::v13_0::tools
Definition Activate.h:25
openvdb::v13_0::Vec3dGrid
Vec3DGrid Vec3dGrid
Definition openvdb.h:86
openvdb::v13_0::initialize
void initialize()
Global registration of native Grid, Transform, Metadata and Point attribute types....
openvdb::v13_0::FloatGrid
Grid< FloatTree > FloatGrid
Definition openvdb.h:76
openvdb::v13_0::gridConstPtrCast
GridType::ConstPtr gridConstPtrCast(const GridBase::ConstPtr &grid)
Cast a generic const grid pointer to a const pointer to a grid of a concrete class.
Definition Grid.h:1016
openvdb::v13_0::BoolGrid
Grid< BoolTree > BoolGrid
Common grid types.
Definition openvdb.h:74
openvdb::v13_0::gridPtrCast
GridType::Ptr gridPtrCast(const GridBase::Ptr &grid)
Cast a generic grid pointer to a pointer to a grid of a concrete class.
Definition Grid.h:1000
openvdb::v13_0::Vec3fGrid
Vec3SGrid Vec3fGrid
Definition openvdb.h:87
openvdb::v13_0::Vec3IGrid
Grid< Vec3ITree > Vec3IGrid
Definition openvdb.h:82
openvdb::v13_0::Int64Grid
Grid< Int64Tree > Int64Grid
Definition openvdb.h:79
openvdb::v13_0::Int32Grid
Grid< Int32Tree > Int32Grid
Definition openvdb.h:78
openvdb::v13_0::DoubleGrid
Grid< DoubleTree > DoubleGrid
Definition openvdb.h:75
openvdb
Definition Exceptions.h:13