HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GU_RayPrimitive.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 library (C++)
7  *
8  * COMMENTS: Ray info - cached information for each primitive type
9  *
10  */
11 
12 #ifndef __GU_RayPrimInfo_h__
13 #define __GU_RayPrimInfo_h__
14 
15 #include "GU_API.h"
16 #include "GU_NURBPyramid.h"
17 #include "GU_RayRBezCurve.h"
18 #include "GU_RayRBezSurf.h"
19 #include <GEO/GEO_Detail.h>
20 #include <GEO/GEO_PrimitiveP.h>
21 #include <GEO/GEO_PrimNURBCurve.h>
22 #include <GEO/GEO_PrimNURBSurf.h>
23 #include <GEO/GEO_PrimRBezCurve.h>
24 #include <GEO/GEO_PrimRBezSurf.h>
25 #include <GEO/GEO_PrimVolume.h>
26 #include <GA/GA_KnotVector.h>
27 #include <GA/GA_NUBBasis.h>
28 #include <GA/GA_Types.h>
29 #include <TS/TS_Expression.h>
30 
31 #include <UT/UT_BoundingBox.h>
32 #include <UT/UT_Matrix3.h>
33 #include <UT/UT_Matrix4.h>
35 #include <UT/UT_UniquePtr.h>
36 #include <UT/UT_VDBUtils.h>
37 #include <UT/UT_Vector3.h>
38 #include <UT/UT_Vector4Array.h>
39 #include <UT/UT_VoxelArray.h>
40 #include <SYS/SYS_Inline.h>
41 
42 #ifdef OPENVDB_ENABLED
43 #include <openvdb/openvdb.h>
44 #endif
45 
46 class GU_Detail;
47 class GU_MinInfo;
48 class GU_RayInfo;
49 class GU_RayIntersect;
50 class GEO_Primitive;
51 class GEO_PrimRBezSurf;
52 
54 {
55 public:
56  GU_Ray(const UT_Vector3 &o, const UT_Vector3 &d, const UT_Matrix4 *mat = 0);
57 
58  float globalDist(float t) const { return t / tscale; }
59  float localDist(float t) const { return t * tscale; }
60 
62  float tscale;
63 };
64 
65 // Finds intersection of ray & quad.
66 int
68  const UT_Vector3 &dir,
69  const UT_Vector3 &A, const UT_Vector3 &B,
70  const UT_Vector3 &C, const UT_Vector3 &D,
71  const UT_Vector3 &norm,
72  float &t, float &u, float &v, float &d2);
73 //________________________________________________________
74 //
75 // Base class for primitive info
76 //________________________________________________________
77 //
79 {
80 public:
81  GU_RayPrimInfo(GEO_ConstPrimitiveP prim, int serialidx);
82 
83  // TODO: Make pure virtual when compiler allows us
84  virtual int intersect(
85  const GEO_Detail &geo,
86  const UT_Vector3 &org,
87  const UT_Vector3 &dir,
88  GU_RayInfo &hitinfo)
89  {
90  return 0;
91  }
92  virtual int minimum(
93  const GEO_Detail &geo,
94  const UT_Vector3 &p,
95  GU_MinInfo &mininfo)
96  {
97  return 0;
98  }
99 
100  // NB: "t" value is position on this, (u,v,w) position
101  // on passed in primitive.
102  virtual int intersectPrim(
103  const GEO_Detail &geo,
104  const GEO_Detail &prim_geo,
105  GU_RayPrimInfo *prim,
106  GU_RayInfo &hitinfo)
107  {
108  return -1;
109  }
110  virtual int minimumPrim(
111  const GEO_Detail &geo,
112  const GEO_Detail &prim_geo,
113  GU_RayPrimInfo *prim,
114  GU_MinInfo &mininfo)
115  {
116  return 0;
117  }
118 
119  virtual UT_Vector3 getNormal(const UT_Vector3 &uvw) const
120  {
121  return UT_Vector3(0,0,0);
122  }
123 
124  void bumpRefCount(int dir);
125  static void getXYProjection(const UT_Vector3 &nml, int &x, int &y);
126 
127  // Checks the dirty bit, if set, initializes.
128  void ensureClean(const GEO_Detail &geo);
129  // Initializes.
130  virtual void init(const GEO_Detail &geo)
131  {
132  }
133 
136  {
137  return GEO_ConstPrimitiveP(&geo, myPrimOffset);
138  }
139 
140  /// Report approximate memory usage.
141  virtual int64 getMemoryUsage(bool inclusive) const = 0;
142 
143 protected:
144  void initBBox(GEO_ConstPrimitiveP prim);
145 
146 public:
149  float sortValue;
150  int mySerialIdx; // Our index into a serial table
151 
153  // it is cute how we carefully conserve bits here, when you consider
154  // things like the UT_BoundingBox and what shows up in the
155  // subclasses!
156  bool degenerate:1;
157  //bool subclassflag:1;
158  volatile int myDirty;
159 
160 protected:
161  virtual ~GU_RayPrimInfo();
162 };
163 
164 //________________________________________________________
165 //
166 // Quadric ray intersection class
167 //________________________________________________________
168 //
170 {
171 public:
172  GU_RayQuadricInfo(GEO_ConstPrimitiveP prim, int serialidx);
173  ~GU_RayQuadricInfo() override;
174 
175  int intersect(
176  const GEO_Detail &geo,
177  const UT_Vector3 &org,
178  const UT_Vector3 &dir,
179  GU_RayInfo &hitinfo) override;
180  int minimum(
181  const GEO_Detail &geo,
182  const UT_Vector3 &p,
183  GU_MinInfo &mininfo) override;
184 
185  int64 getMemoryUsage(bool inclusive) const override
186  {
187  int64 mem = inclusive ? sizeof(*this) : 0;
188  return mem;
189  }
190 
191 public:
192  static int circle(
193  GEO_ConstPrimitiveP prim,
194  const GU_Ray &ray,
195  GU_RayInfo &hi,
196  UT_Vector3 &nml);
197  static int sphere(
198  GEO_ConstPrimitiveP prim,
199  const GU_Ray &ray,
200  GU_RayInfo &hi,
201  UT_Vector3 &nml);
202  static int tube(
203  GEO_ConstPrimitiveP prim,
204  const GU_Ray &ray,
205  GU_RayInfo &hi,
206  UT_Vector3 &nml);
207 
208  static void minCircle(const UT_Vector3 &p, UT_Vector3 &minpt);
209  static void minSphere(const UT_Vector3 &p, UT_Vector3 &minpt);
210  static void minTube(
211  GEO_ConstPrimitiveP prim,
212  const UT_Vector3 &p,
213  UT_Vector3 &minpt,
214  float &u,
215  float &v);
216 
217  UT_Matrix4 xform; // Ray transform
218  UT_Matrix3 nmlXform; // Normal transform
219 };
220 
221 //________________________________________________________
222 //
223 // Triangle ray intersection class
224 //________________________________________________________
225 //
226 template<bool ISTET=false>
228 {
229 public:
230  GU_RayTriangleInfo(GEO_ConstPrimitiveP prim, int serialidx,
231  GA_Offset p0, GA_Offset p1,
232  GA_Offset p2, float w=0.0f);
233  ~GU_RayTriangleInfo() override;
234 
235  void init(const GEO_Detail &geo) override;
236 
237  int intersect(
238  const GEO_Detail &geo,
239  const UT_Vector3 &org,
240  const UT_Vector3 &dir,
241  GU_RayInfo &hitinfo) override;
242  int minimum(
243  const GEO_Detail &geo,
244  const UT_Vector3 &p,
245  GU_MinInfo &mininfo) override;
246 
247  UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
248  {
249  return nml;
250  }
251 
252  int64 getMemoryUsage(bool inclusive) const override
253  {
254  int64 mem = inclusive ? sizeof(*this) : 0;
255  return mem;
256  }
257 
258 public:
259  GA_Offset myV[3]; // Three corner vertices
260  UT_Vector3 nml; // Surface normal
261  float D; // Plane eqn constant
262  int x, y; // Oriented to projected plane
263  const float myW;
264 };
265 
266 // These are hardened triangles:
267 template<bool ISTET=false>
269 {
270 public:
271  GU_RayHTriangleInfo(GEO_ConstPrimitiveP prim, int serialidx,
272  const UT_Vector3 &p1, const UT_Vector3 &p2,
273  const UT_Vector3 &p3, float w=0.0f);
274  ~GU_RayHTriangleInfo() override;
275 
276  void init(const GEO_Detail &geo) override;
277 
278  int intersect(
279  const GEO_Detail &geo,
280  const UT_Vector3 &org,
281  const UT_Vector3 &dir,
282  GU_RayInfo &hitinfo) override;
283  int minimum(
284  const GEO_Detail &geo,
285  const UT_Vector3 &p,
286  GU_MinInfo &mininfo) override;
287 
288  UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
289  {
290  return nml;
291  }
292 
293  int64 getMemoryUsage(bool inclusive) const override
294  {
295  int64 mem = inclusive ? sizeof(*this) : 0;
296  return mem;
297  }
298 
299 public:
300  UT_Vector3 myV[3]; // Three corner verices
301  UT_Vector3 nml; // Surface normal
302  float D; // Plane eqn constant
303  int x, y; // Oriented to projected plane
304  const float myW;
305 };
306 
307 //________________________________________________________
308 //
309 // Tetrahedron ray intersection class
310 //________________________________________________________
311 //
312 
313 /// Checks if query is inside the tet specified by ps.
314 /// If the tet is inverted and it's inside, negated will be set to true.
315 /// It computes normals, areas, and sub tet volumes already, so that they
316 /// can be used afterward.
317 GU_API bool
319  const UT_Vector3 &query,
320  const UT_Vector3 *ps,
321  UT_Vector3 n[4],
322  bool &negated,
323  float dots[4],
324  float A[4]) noexcept;
325 
326 /// Computes the uvw coordinates of a query point inside a tet, based on
327 /// the values computed by GUisPointInsideTet.
330  float dots[4],
331  const float A[4]) noexcept;
332 
334 {
335 public:
336  GU_RayTetInfo(GEO_ConstPrimitiveP prim, int serialidx,
337  GA_Offset p0, GA_Offset p1,
338  GA_Offset p2, GA_Offset p3);
339  ~GU_RayTetInfo() override;
340 
341  int intersect(
342  const GEO_Detail &geo,
343  const UT_Vector3 &org,
344  const UT_Vector3 &dir,
345  GU_RayInfo &hitinfo) override;
346  int minimum(
347  const GEO_Detail &geo,
348  const UT_Vector3 &p,
349  GU_MinInfo &mininfo) override;
350 
351  int64 getMemoryUsage(bool inclusive) const override
352  {
353  int64 mem = inclusive ? sizeof(*this) : 0;
354  return mem;
355  }
356 
357 public:
358  GA_Offset myV[4]; // Four corner vertices
359 };
360 
361 // These are hardened triangles:
363 {
364 public:
365  GU_RayHTetInfo(GEO_ConstPrimitiveP prim, int serialidx,
366  const UT_Vector3 &p1, const UT_Vector3 &p2,
367  const UT_Vector3 &p3, const UT_Vector3 &p4);
368  ~GU_RayHTetInfo() override;
369 
370  int intersect(
371  const GEO_Detail &geo,
372  const UT_Vector3 &org,
373  const UT_Vector3 &dir,
374  GU_RayInfo &hitinfo) override;
375  int minimum(
376  const GEO_Detail &geo,
377  const UT_Vector3 &p,
378  GU_MinInfo &mininfo) override;
379 
380  int64 getMemoryUsage(bool inclusive) const override
381  {
382  int64 mem = inclusive ? sizeof(*this) : 0;
383  return mem;
384  }
385 
386 public:
387  UT_Vector3 myV[4]; // Four corner verices
388 };
389 
390 //________________________________________________________
391 //
392 // Hexahedron ray intersection class
393 //________________________________________________________
394 //
395 
397 {
398 public:
399  GU_RayHexInfo(GEO_ConstPrimitiveP prim, int serialidx,
400  GA_Offset p0, GA_Offset p1,
401  GA_Offset p2, GA_Offset p3,
402  GA_Offset p4, GA_Offset p5,
403  GA_Offset p6, GA_Offset p7);
404  ~GU_RayHexInfo() override;
405 
406  int intersect(
407  const GEO_Detail &geo,
408  const UT_Vector3 &org,
409  const UT_Vector3 &dir,
410  GU_RayInfo &hitinfo) override;
411  int minimum(
412  const GEO_Detail &geo,
413  const UT_Vector3 &p,
414  GU_MinInfo &mininfo) override;
415 
416  int64 getMemoryUsage(bool inclusive) const override
417  {
418  int64 mem = inclusive ? sizeof(*this) : 0;
419  return mem;
420  }
421 
422 public:
423  GA_Offset myV[8]; // Eight corner vertices
424 };
425 
426 // These are hardened hexahedra:
428 {
429 public:
430  GU_RayHHexInfo(GEO_ConstPrimitiveP prim, int serialidx,
431  const UT_Vector3 &p1, const UT_Vector3 &p2,
432  const UT_Vector3 &p3, const UT_Vector3 &p4,
433  const UT_Vector3 &p5, const UT_Vector3 &p6,
434  const UT_Vector3 &p7, const UT_Vector3 &p8);
435  ~GU_RayHHexInfo() override;
436 
437  int intersect(
438  const GEO_Detail &geo,
439  const UT_Vector3 &org,
440  const UT_Vector3 &dir,
441  GU_RayInfo &hitinfo) override;
442  int minimum(
443  const GEO_Detail &geo,
444  const UT_Vector3 &p,
445  GU_MinInfo &mininfo) override;
446 
447  int64 getMemoryUsage(bool inclusive) const override
448  {
449  int64 mem = inclusive ? sizeof(*this) : 0;
450  return mem;
451  }
452 
453 public:
454  UT_Vector3 myV[8]; // Eight corner vertices
455 };
456 
457 
458 //___________________________________________________________________________
459 //
460 // Quad ray intersection classes - HQuad is for hardened points (i.e. NURBS)
461 //___________________________________________________________________________
462 //
463 template<bool ISHEX=false>
465 {
466 public:
467  GU_RayQuadInfo(GEO_ConstPrimitiveP prim, int serialidx,
468  GA_Offset p0, GA_Offset p1,
469  GA_Offset p2, GA_Offset p3,
470  float ustart = 0.0F, float ulength = 1.0F,
471  float vstart = 0.0F, float vlength = 1.0F,
472  float w=0.0f);
473  ~GU_RayQuadInfo() override;
474 
475  void init(const GEO_Detail &geo) override;
476 
477  int intersect(
478  const GEO_Detail &geo,
479  const UT_Vector3 &org,
480  const UT_Vector3 &dir,
481  GU_RayInfo &hitinfo) override;
482  int minimum(
483  const GEO_Detail &geo,
484  const UT_Vector3 &p,
485  GU_MinInfo &mininfo) override;
486 
487  UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
488  {
489  return nml;
490  }
491 
492  int64 getMemoryUsage(bool inclusive) const override
493  {
494  int64 mem = inclusive ? sizeof(*this) : 0;
495  return mem;
496  }
497 
498 public:
499  GA_Offset myV[4]; // Four corner vertices
500  UT_Vector3 nml; // Surface normal
501 
502  //float D; // Plane eqn constant
503  //int x, y; // Oriented to projected plane
504  float myUStart, myULength;
505  float myVStart, myVLength;
506  const float myW;
507 };
508 
509 template<bool ISHEX=false>
511 {
512 public:
513  GU_RayHQuadInfo(GEO_ConstPrimitiveP prim, int serialidx,
514  const UT_Vector3 &p0, const UT_Vector3 &p1,
515  const UT_Vector3 &p2, const UT_Vector3 &p3,
516  float ustart = 0.0f, float ulen = 1.0f,
517  float vstart = 0.0f, float vlen = 1.0f,
518  bool revnml = false, float w=0.0f);
519  ~GU_RayHQuadInfo() override;
520 
521  void init(const GEO_Detail &geo) override;
522 
523  int intersect(
524  const GEO_Detail &geo,
525  const UT_Vector3 &org,
526  const UT_Vector3 &dir,
527  GU_RayInfo &hitinfo) override;
528  int minimum(
529  const GEO_Detail &geo,
530  const UT_Vector3 &p,
531  GU_MinInfo &mininfo) override;
532 
533  UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
534  {
535  return nml;
536  }
537 
538  int64 getMemoryUsage(bool inclusive) const override
539  {
540  int64 mem = inclusive ? sizeof(*this) : 0;
541  return mem;
542  }
543 
544 public:
545  UT_Vector3 myV[4]; // Four corner vertices
546  UT_Vector3 nml; // Surface normal
547  bool myRevNml; // Do we reverse the normal?
548 
549  // These numbers aren't needed by the bilinear code.
550  //float D; // Plane eqn constant
551  //int x, y; // Oriented to projected plane
552 
553  float myUStart, myULength;
554  float myVStart, myVLength;
555  const float myW;
556 };
557 
558 
559 //________________________________________________________
560 //
561 // General Face ray intersection class
562 //________________________________________________________
563 //
565 {
566 public:
567  GU_RayPolyInfo(GEO_ConstPrimitiveP prim, int serialidx,
568  const UT_Array<GA_Offset> &ipts, float w=0.0f);
569  ~GU_RayPolyInfo() override;
570 
571  int intersect(
572  const GEO_Detail &geo,
573  const UT_Vector3 &org,
574  const UT_Vector3 &dir,
575  GU_RayInfo &hitinfo) override;
576  int minimum(
577  const GEO_Detail &geo,
578  const UT_Vector3 &p,
579  GU_MinInfo &mininfo) override;
580 
581  UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
582  {
583  return nml;
584  }
585 
586  int64 getMemoryUsage(bool inclusive) const override
587  {
588  int64 mem = inclusive ? sizeof(*this) : 0;
589  return mem;
590  }
591 
592 public:
594  float D;
595  int x, y;
597  const float myW;
598 };
599 
601 {
602 public:
604  GEO_ConstPrimitiveP prim,
605  int serialidx,
606  const UT_Vector4Array &p,
607  float w = 0.0f);
609  GEO_ConstPrimitiveP prim,
610  int serialidx,
611  const UT_Array<UT_Vector3> &p,
612  float w = 0.0f);
613  ~GU_RayHPolyInfo() override;
614 
615  template<typename ARRAY_TYPE>
616  void initPoly(GEO_ConstPrimitiveP p, const ARRAY_TYPE &pts);
617  int intersect(
618  const GEO_Detail &geo,
619  const UT_Vector3 &org,
620  const UT_Vector3 &dir,
621  GU_RayInfo &hitinfo) override;
622  int minimum(
623  const GEO_Detail &geo,
624  const UT_Vector3 &p,
625  GU_MinInfo &mininfo) override;
626 
627  UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
628  {
629  return nml;
630  }
631 
632  int64 getMemoryUsage(bool inclusive) const override
633  {
634  int64 mem = inclusive ? sizeof(*this) : 0;
635  if (xval)
636  mem += npts * sizeof(xval[0]);
637  if (yval)
638  mem += npts * sizeof(yval[0]);
639  return mem;
640  }
641 
642 public:
644 
645  int npts;
649  float D;
650  int x, y;
651  const float myW;
652 };
653 
654 //________________________________________________________
655 //
656 // Meta-surface ray intersection class
657 //________________________________________________________
658 //
660 {
661 public:
662  GU_RayMetaInfo(const TS_MetaExpressionPtr &expr, int serialidx);
663  ~GU_RayMetaInfo() override;
664 
665  int intersect(
666  const GEO_Detail &geo,
667  const UT_Vector3 &org,
668  const UT_Vector3 &dir,
669  GU_RayInfo &hitinfo) override;
670 
671  int64 getMemoryUsage(bool inclusive) const override;
672 
673 public:
676 };
677 
678 //________________________________________________________
679 //
680 // VDB intersection class
681 //________________________________________________________
683 {
684 public:
685  GU_RayVDBInfo(GEO_ConstPrimitiveP vdb, int serialidx);
686  ~GU_RayVDBInfo() override;
687 
688  int intersect(
689  const GEO_Detail &geo,
690  const UT_Vector3 &org,
691  const UT_Vector3 &dir,
692  GU_RayInfo &hitinfo) override;
693 
694  int64 getMemoryUsage(bool inclusive) const override;
695 
696 public:
698  float myStepSize;
700  bool myFailed;
702 #ifdef OPENVDB_ENABLED
703  const openvdb::GridBase *myGridRawPtr;
704 #endif
705 
706 };
707 
708 //________________________________________________________
709 //
710 // HeightField intersection class
711 //________________________________________________________
713 {
714 public:
715  GU_RayHeightFieldInfo(const GEO_PrimVolume *vdb, int serialidx);
716  ~GU_RayHeightFieldInfo() override;
717 
718  int intersect(
719  const GEO_Detail &geo,
720  const UT_Vector3 &org,
721  const UT_Vector3 &dir,
722  GU_RayInfo &hitinfo) override;
723 
724  template<bool farthest,bool rm_backface,bool reverse,bool bidirectional,typename FUNCTOR>
725  bool intersect(
726  const UT_Vector3 &org,
727  const UT_Vector3 &dir,
728  const UT_Vector3 &inverse_dir,
729  int max_dir,
730  const UT_Vector3 &N0,
731  const UT_Vector3 &N1,
732  float &outer_tmin,
733  float &outer_tmax,
734  uint bvh_index,
735  FUNCTOR &functor) const;
736 
737  int minimum(
738  const GEO_Detail &geo,
739  const UT_Vector3 &p,
740  GU_MinInfo &mininfo) override;
741 
742  int64 getMemoryUsage(bool inclusive) const override;
743 
744 public:
745  int myAxis, myA1, myA2;
746  int myDim[3];
748  bool myFailed;
749  float myScale, myInvScale;
753 };
754 
755 //________________________________________________________
756 //
757 // Packed primitive intersection class
758 //________________________________________________________
759 
761 {
762 public:
763  GU_RayPackedInfo(GEO_ConstPrimitiveP prim, int serialidx, int picking,
764  int polyline, int harden, bool solidtet);
765  ~GU_RayPackedInfo() override;
766 
767  void init(const GEO_Detail &geo) override;
768 
769  int intersect(
770  const GEO_Detail &geo,
771  const UT_Vector3 &org,
772  const UT_Vector3 &dir,
773  GU_RayInfo &hitinfo) override;
774  int minimum(
775  const GEO_Detail &geo,
776  const UT_Vector3 &p,
777  GU_MinInfo &mininfo) override;
778 
779  int64 getMemoryUsage(bool inclusive) const override;
780 
781  void unpack(const GEO_Detail &geo);
782 
783 private:
784  const int myPicking;
785  const int myPolyLine;
786  const int myHarden;
787  const int mySolidTet;
788 
789  UT_UniquePtr<GEO_Detail> myUnpackedGdp;
790  UT_UniquePtr<GU_RayIntersect> myUnpackedIntersect;
791 };
792 
793 //________________________________________________________
794 //
795 // Polyline intersection class
796 //________________________________________________________
797 //
799 {
800 public:
802  GEO_ConstPrimitiveP prim,
803  int serialidx,
804  int span, int len);
805  ~GU_RayPolyLineInfo() override;
806 
807  int intersect(
808  const GEO_Detail &geo,
809  const UT_Vector3 &org,
810  const UT_Vector3 &dir,
811  GU_RayInfo &hitinfo) override;
812  int minimum(
813  const GEO_Detail &geo,
814  const UT_Vector3 &p,
815  GU_MinInfo &mininfo) override;
816  int intersectPrim(
817  const GEO_Detail &geo,
818  const GEO_Detail &prim_geo,
819  GU_RayPrimInfo *prim,
820  GU_RayInfo &hitInfo) override;
821  int minimumPrim(
822  const GEO_Detail &geo,
823  const GEO_Detail &prim_geo,
824  GU_RayPrimInfo *prim,
825  GU_MinInfo &mininfo) override;
826 
827  int64 getMemoryUsage(bool inclusive) const override
828  {
829  int64 mem = inclusive ? sizeof(*this) : 0;
830  return mem;
831  }
832 
833 public:
834  int mySpan; // What part of the poly
835  int myLen; // we are responsible for
836 };
837 
838 //________________________________________________________
839 //
840 // Curve intersection class
841 //
842 // Note: working in homogeneous coordinate
843 //________________________________________________________
844 //
845 
847 {
848 public:
850  GEO_ConstPrimitiveP curve,
851  int serialidx,
852  bool is_first_span,
853  bool is_last_span)
854  : GU_RayPrimInfo(curve, serialidx)
855  , myFirstSpanFlag(is_first_span)
856  , myLastSpanFlag(is_last_span)
857  {
858  }
859  ~GU_RayCurveInfo() override {}
860 
861 protected:
862  // checks the proximity of the ray to the end points of the curve,
863  // and compares it with the tolerance given in hit_info,
864  // but only for these endpoints
865  // of the curve for which first/last span flags (the member data) are true.
866  // If ray passes within the given tolerance, in the hemispherical cup
867  // at the end of the curve, that "seals" the cylidrical zone around
868  // the curve, it is considered as a hit, and 1 is returned.
869  // INPUTS:
870  // org, dir - the origin and direction of the ray
871  // curve - the curve endpoints we investigate
872  // hit_info - its tolerance is treated as a radius of a hemisphere at the
873  // endpoints, within which to test the ray's presence
874  // OUTPUT
875  // hit_info - if hit, a hit is added
876  // RETURN:
877  // 1 if hit: ray passes within tolerance radius of endpoint(s), otherwise 0
878  int intersectEndPointZone(
879  const GEO_Detail &geo,
880  const UT_Vector3 &org,
881  const UT_Vector3 &dir,
882  const GU_RayRBezCurve* curve,
883  GU_RayInfo &hit_info) const;
884 
885 public:
886  // usually a curve primitive is subdivided into several spans, whose
887  // info is encoded in GU_RayRBezCurveInfo and GU_RayNURBCurveInfo.
888  // Following flags indicate if this span is first or last on the curve.
889  bool myFirstSpanFlag : 1, // 1 if it's firsrt span on curve
890  myLastSpanFlag : 1; // 1 if it's last span on curve
891 };
892 
893 class GEO_PrimRBezCurve;
894 
896 {
897 public:
899  const GEO_PrimRBezCurve *curve,
900  int serialidx,
901  bool is_first_span,
902  bool is_last_span,
903  int span,
904  int nvtx,
905  int ord);
906  ~GU_RayRBezCurveInfo() override;
907 
908  static int count(const GEO_PrimRBezCurve *bezcurve)
909  {
910  const GA_KnotVector &knots = bezcurve->getBasis()->getVector();
911  return knots.size() - 1;
912  }
913  template<typename FUNCTOR>
914  static void build(const FUNCTOR &functor, const GEO_PrimRBezCurve *bezcurve, int *pinfonum=nullptr)
915  {
916  const int ord = bezcurve->getOrder();
917  const GA_KnotVector &knots = bezcurve->getBasis()->getVector();
918  const int last = knots.size() - 2;
919  const int s = bezcurve->getVertexCount();
920 
921  for (int j = last; j >= 0; --j)
922  {
923  const bool is_first = (j == 0);
924  const bool is_last = (j == last);
925  functor(new GU_RayRBezCurveInfo(bezcurve, (pinfonum ? *pinfonum : 0),
926  is_first, is_last, j, s, ord));
927  if (pinfonum)
928  ++(*pinfonum);
929  }
930  }
931 
932  int intersect(
933  const GEO_Detail &geo,
934  const UT_Vector3 &org,
935  const UT_Vector3 &dir,
936  GU_RayInfo &hitinfo) override;
937  int minimum(
938  const GEO_Detail &geo,
939  const UT_Vector3 &p,
940  GU_MinInfo &mininfo) override;
941  int intersectPrim(
942  const GEO_Detail &geo,
943  const GEO_Detail &prim_geo,
944  GU_RayPrimInfo *prim,
945  GU_RayInfo &hitInfo) override;
946  int minimumPrim(
947  const GEO_Detail &geo,
948  const GEO_Detail &prim_geo,
949  GU_RayPrimInfo *prim,
950  GU_MinInfo &mininfo) override;
951 
952  void init(const GEO_Detail &geo) override;
953  GU_RayRBezCurve *buildCurve(const GEO_Detail &geo);
954 
955  int64 getMemoryUsage(bool inclusive) const override
956  {
957  int64 mem = inclusive ? sizeof(*this) : 0;
958  if (myCurve)
959  mem += myCurve->getMemoryUsage(true);
960  return mem;
961  }
962 
963 public:
964  int mySpan;
966 };
967 
969 {
970 public:
972  GEO_ConstPrimitiveP curve,
973  int serialidx,
974  UT_Interval u,
975  const UT_RefMatrix<UT_Vector4> &patch_cv,
976  int ord,
977  bool is_rational);
978  ~GU_RayNURBCurveInfo() override;
979 
980  template<typename FUNCTOR>
981  static void build(const FUNCTOR &functor, const GEO_PrimNURBCurve *nurbcurve, int *pinfonum=nullptr)
982  {
983  const GA_NUBBasis *ub = (const GA_NUBBasis *)nurbcurve->getBasis();
984  const int ord = ub->getOrder();
985  GA_PwHandleRO h(nurbcurve->getDetail());
986  GU_NURBPyramid<0> pyramid(ub, nurbcurve, h);
987  const bool rational = nurbcurve->isRational();
988 
989  bool first = true;
990  for (pyramid.rewind(ub); !pyramid.atEnd(); pyramid.advance())
991  {
992  GU_RayNURBCurveInfo *nurbcurveinfo = new GU_RayNURBCurveInfo(
993  nurbcurve, (pinfonum ? *pinfonum : 0),
994  pyramid.getInterval(), pyramid.getResult(),
995  ord, rational);
996  nurbcurveinfo->myFirstSpanFlag = first;
997  functor(nurbcurveinfo);
998 
999  if (pinfonum)
1000  ++(*pinfonum);
1001 
1002  first = false;
1003  }
1004  }
1005 
1006  int intersect(
1007  const GEO_Detail &geo,
1008  const UT_Vector3 &org,
1009  const UT_Vector3 &dir,
1010  GU_RayInfo &hitinfo) override;
1011  int minimum(
1012  const GEO_Detail &geo,
1013  const UT_Vector3 &p,
1014  GU_MinInfo &mininfo) override;
1015  int intersectPrim(
1016  const GEO_Detail &geo,
1017  const GEO_Detail &prim_geo,
1018  GU_RayPrimInfo *prim,
1019  GU_RayInfo &hitInfo) override;
1020  int minimumPrim(
1021  const GEO_Detail &geo,
1022  const GEO_Detail &prim_geo,
1023  GU_RayPrimInfo *prim,
1024  GU_MinInfo &mininfo) override;
1025 
1026  int64 getMemoryUsage(bool inclusive) const override
1027  {
1028  int64 mem = inclusive ? sizeof(*this) : 0;
1029  mem += myCurve.getMemoryUsage(false);
1030  return mem;
1031  }
1032 
1033 public:
1035 };
1036 
1037 
1038 //________________________________________________________
1039 //
1040 // Surface intersection class
1041 //
1042 // Note: working in homogeneous coordinate
1043 //________________________________________________________
1044 //
1046 {
1047 public:
1049  const GEO_PrimRBezSurf *surf, int serialidx,
1050  int u_span, int v_span,
1051  int u_ord, int v_ord,
1052  float u_start, float u_length,
1053  float v_start, float v_length,
1054  int u_beg, int v_beg,
1055  int u_num, int v_num,
1056  bool is_rational);
1057  ~GU_RayRBezSurfInfo() override;
1058 
1059  static exint count(const GEO_PrimRBezSurf *bezsurf)
1060  {
1061  const GA_KnotVector &uknots = bezsurf->getUBasis()->getVector();
1062  const GA_KnotVector &vknots = bezsurf->getVBasis()->getVector();
1063  return exint(vknots.size()-1)*(uknots.size()-1);
1064  }
1065 
1066  template<typename FUNCTOR>
1067  static void build(const FUNCTOR &functor, const GEO_PrimRBezSurf *bezsurf, int *pinfonum=nullptr)
1068  {
1069  const int uord = bezsurf->getUOrder();
1070  const int vord = bezsurf->getVOrder();
1071  const GA_KnotVector &uknots = bezsurf->getUBasis()->getVector();
1072  const GA_KnotVector &vknots = bezsurf->getVBasis()->getVector();
1073  const int cols = bezsurf->getNumCols();
1074  const int rows = bezsurf->getNumRows();
1075  const bool rational = bezsurf->isRational();
1076 
1077  for (int r = vknots.size()-2; r >= 0; r--)
1078  {
1079  const int r1 = (vord-1)*r;
1080  for (int c = uknots.size()-2; c >= 0; c--)
1081  {
1082  const int c1 = (uord-1)*c;
1083  functor(new GU_RayRBezSurfInfo(
1084  bezsurf, (pinfonum ? *pinfonum : 0),
1085  c, r,
1086  uord, vord,
1087  uknots(c), uknots(c+1)-uknots(c),
1088  vknots(r), vknots(r+1)-vknots(r),
1089  c1, r1,
1090  cols, rows,
1091  rational));
1092 
1093  if (pinfonum)
1094  ++(*pinfonum);
1095  }
1096  }
1097  }
1098 
1099  int intersect(
1100  const GEO_Detail &geo,
1101  const UT_Vector3 &org,
1102  const UT_Vector3 &dir,
1103  GU_RayInfo &hitinfo) override;
1104  int minimum(
1105  const GEO_Detail &geo,
1106  const UT_Vector3 &p,
1107  GU_MinInfo &mininfo) override;
1108 
1109  int intersectPrim(
1110  const GEO_Detail &geo,
1111  const GEO_Detail &prim_geo,
1112  GU_RayPrimInfo *prim,
1113  GU_RayInfo &hitinfo) override;
1114  int minimumPrim(
1115  const GEO_Detail &geo,
1116  const GEO_Detail &prim_geo,
1117  GU_RayPrimInfo *prim,
1118  GU_MinInfo &hitinfo) override;
1119 
1120  void init(const GEO_Detail &geo) override;
1121  virtual GU_RayRBezSurf *buildSurf(const GEO_Detail &geo);
1122 
1123  int64 getMemoryUsage(bool inclusive) const override
1124  {
1125  int64 mem = inclusive ? sizeof(*this) : 0;
1126  if (mySurf)
1127  mem += mySurf->getMemoryUsage(true);
1128  return mem;
1129  }
1130 
1131 public:
1132  int myUSpan, myVSpan;
1134 };
1135 
1137 {
1138 public:
1140  GEO_ConstPrimitiveP surf, int serialidx,
1141  int u_ord, int v_ord,
1143  const UT_RefMatrix<UT_Vector4> &patch_cv,
1144  bool is_rational);
1145  ~GU_RayNURBSurfInfo() override;
1146 
1147  template<typename FUNCTOR>
1148  static void build(const FUNCTOR &functor, const GEO_PrimNURBSurf *nurbsurf, int *pinfonum=nullptr)
1149  {
1150  const GA_NUBBasis *ub = (const GA_NUBBasis *)nurbsurf->getUBasis();
1151  const GA_NUBBasis *vb = (const GA_NUBBasis *)nurbsurf->getVBasis();
1152  const int uOrd = ub->getOrder();
1153  const int vOrd = vb->getOrder();
1154  GA_PwHandleRO h(nurbsurf->getDetail());
1155  GU_NURBPyramid<0> uPyramid(ub, nurbsurf, h);
1156  GU_NURBPyramid<1> vPyramid(vb, &uPyramid.getResult());
1157  const bool rational = nurbsurf->isRational();
1158 
1159  for (uPyramid.rewind(ub); !uPyramid.atEnd(); uPyramid.advance())
1160  {
1161  const UT_Interval &u = uPyramid.getInterval();
1162  for (vPyramid.rewind(vb); !vPyramid.atEnd(); vPyramid.advance())
1163  {
1164  functor(new GU_RayNURBSurfInfo(nurbsurf,
1165  (pinfonum ? *pinfonum : 0),
1166  uOrd, vOrd,
1167  u, vPyramid.getInterval(),
1168  vPyramid.getResult(),
1169  rational));
1170 
1171  if (pinfonum)
1172  ++(*pinfonum);
1173  }
1174  }
1175  }
1176 
1177  int intersect(
1178  const GEO_Detail &geo,
1179  const UT_Vector3 &org,
1180  const UT_Vector3 &dir,
1181  GU_RayInfo &hitinfo) override;
1182  int minimum(
1183  const GEO_Detail &geo,
1184  const UT_Vector3 &p,
1185  GU_MinInfo &mininfo) override;
1186  int intersectPrim(
1187  const GEO_Detail &geo,
1188  const GEO_Detail &prim_geo,
1189  GU_RayPrimInfo *prim,
1190  GU_RayInfo &hitinfo) override;
1191  int minimumPrim(
1192  const GEO_Detail &geo,
1193  const GEO_Detail &prim_geo,
1194  GU_RayPrimInfo *prim,
1195  GU_MinInfo &hitinfo) override;
1196 
1197  int64 getMemoryUsage(bool inclusive) const override
1198  {
1199  int64 mem = inclusive ? sizeof(*this) : 0;
1200  mem += mySurf.getMemoryUsage(false);
1201  return mem;
1202  }
1203 
1204 public:
1206 };
1207 
1208 //___________________________________________________________________________
1209 //
1210 // Moving triangle ray intersection classes
1211 // - HTriangle is for hardened points
1212 //___________________________________________________________________________
1213 //
1215 {
1216 public:
1218  GEO_ConstPrimitiveP prim0, int serialidx,
1219  GA_Offset p00, GA_Offset p01,
1220  GA_Offset p02,
1221  GEO_ConstPrimitiveP prim1,
1222  GA_Offset p10, GA_Offset p11,
1223  GA_Offset p12);
1224  ~GU_RayMovingTriangleInfo() override;
1225 
1226  void init(const GEO_Detail &geo) override;
1227 
1228  int intersect(
1229  const GEO_Detail &geo,
1230  const UT_Vector3 &org,
1231  const UT_Vector3 &dir,
1232  GU_RayInfo &hitinfo) override;
1233 
1234  int64 getMemoryUsage(bool inclusive) const override
1235  {
1236  int64 mem = inclusive ? sizeof(*this) : 0;
1237  return mem;
1238  }
1239 
1240 private:
1241  int insertHit(
1242  const GEO_Detail &geo,
1243  const UT_Vector3 &org,
1244  const UT_Vector3 &dir,
1245  GU_RayInfo &hitinfo,
1246  float t,
1247  float nt);
1248 
1249 public:
1251  GA_Offset myV0[3]; // Three corner vertices at t = 0
1252  GA_Offset myV1[3]; // Three corner vertices at t = 1
1253 
1254  double a2, a1, a0; // Coefficients of x comp of normal
1255  double b2, b1, b0; // Coefficients of y comp of normal
1256  double c2, c1, c0; // Coefficients of z comp of normal
1257 };
1258 
1259 
1260 #endif
GLenum query
Definition: glad.h:2772
GLint first
Definition: glcorearb.h:405
UT_VDBType myVDBType
TS_MetaExpressionPtr myExprRef
SYS_FORCE_INLINE GA_Detail & getDetail() const
Definition: GA_Primitive.h:141
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
static void build(const FUNCTOR &functor, const GEO_PrimNURBSurf *nurbsurf, int *pinfonum=nullptr)
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
UT_UniquePtr< float[]> FloatPtrArray
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
int isRational() const
SYS_FORCE_INLINE GA_Size getVertexCount() const
Return the number of vertices used by this primitive.
Definition: GA_Primitive.h:232
UT_BoundingBox bbox
const float myW
UT_VoxelArrayF myMinMap
volatile int myDirty
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
const UT_Array< GA_Offset > pts
const GLdouble * v
Definition: glcorearb.h:837
virtual int minimum(const GEO_Detail &geo, const UT_Vector3 &p, GU_MinInfo &mininfo)
UT_UniquePtr< GU_RayRBezCurve > myCurve
virtual void init(const GEO_Detail &geo)
UT_Vector3T< float > UT_Vector3
UT_ThreadSpecificValue< TS_MetaExpressionPtr > myMetaExprCopies
Definition: span.h:73
virtual int minimumPrim(const GEO_Detail &geo, const GEO_Detail &prim_geo, GU_RayPrimInfo *prim, GU_MinInfo &mininfo)
int64 exint
Definition: SYS_Types.h:125
virtual int intersectPrim(const GEO_Detail &geo, const GEO_Detail &prim_geo, GU_RayPrimInfo *prim, GU_RayInfo &hitinfo)
GLdouble s
Definition: glad.h:3009
GEO_PrimVolumeXform myXform
GU_RayCurveInfo(GEO_ConstPrimitiveP curve, int serialidx, bool is_first_span, bool is_last_span)
GLint y
Definition: glcorearb.h:103
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
UT_VDBType
Definition: UT_VDBUtils.h:11
unsigned getVOrder() const
Definition: GEO_TPSurf.h:389
float tscale
exint size() const
Definition: UT_Array.h:646
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
int GU_getBilinearQuadIntersection(const UT_Vector3 &org, const UT_Vector3 &dir, const UT_Vector3 &A, const UT_Vector3 &B, const UT_Vector3 &C, const UT_Vector3 &D, const UT_Vector3 &norm, float &t, float &u, float &v, float &d2)
float globalDist(float t) const
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:39
static void build(const FUNCTOR &functor, const GEO_PrimRBezSurf *bezsurf, int *pinfonum=nullptr)
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
GA_Size GA_Offset
Definition: GA_Types.h:641
UT_UniquePtr< GU_RayRBezSurf > mySurf
GU_API bool GUisPointInsideTet(const UT_Vector3 &query, const UT_Vector3 *ps, UT_Vector3 n[4], bool &negated, float dots[4], float A[4]) noexcept
static int count(const GEO_PrimRBezCurve *bezcurve)
GLdouble n
Definition: glcorearb.h:2008
GLfloat f
Definition: glcorearb.h:1926
UT_Vector3 org
int isRational() const
const openvdb::GridBase * myGridRawPtr
GU_RayRBezSurf mySurf
virtual UT_Vector3 getNormal(const UT_Vector3 &uvw) const
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
static void build(const FUNCTOR &functor, const GEO_PrimRBezCurve *bezcurve, int *pinfonum=nullptr)
SYS_FORCE_INLINE int getNumRows() const
Definition: GEO_Hull.h:368
GEO_ConstPrimitiveP myPrim2
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
GA_PrimitiveP_T< const GEO_Primitive, const GEO_Detail > GEO_ConstPrimitiveP
NURBS basis classes which maintain knot vectors.
Definition: GA_NUBBasis.h:44
long long int64
Definition: SYS_Types.h:116
float localDist(float t) const
const float myW
#define GU_API
Definition: GU_API.h:14
UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
GLint GLenum GLint x
Definition: glcorearb.h:409
const UT_VoxelArrayF * mySamples
GLdouble t
Definition: glad.h:2397
SYS_FORCE_INLINE GEO_ConstPrimitiveP primP(const GEO_Detail &geo) const
UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
GEO_PrimVolumeXform myXform
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
const GA_Basis * getBasis() const
Definition: GEO_Curve.h:310
UT_VoxelMipMapF myMinMM
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
GLint j
Definition: glad.h:2733
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2002
FloatPtrArray yval
static void build(const FUNCTOR &functor, const GEO_PrimNURBCurve *nurbcurve, int *pinfonum=nullptr)
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
GU_API UT_Vector3 GUfindPointInsideTet(float dots[4], const float A[4]) noexcept
FloatPtrArray xval
const GA_KnotVector & getVector() const
Definition: GA_Basis.h:372
unsigned getOrder() const override
~GU_RayCurveInfo() override
GA_Offset myPrimOffset
virtual int64 getMemoryUsage(bool inclusive) const =0
Report approximate memory usage.
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
SYS_FORCE_INLINE int getNumCols() const
Definition: GEO_Hull.h:375
UT_ThreadSpecificValue< void * > myCache
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
GU_RayRBezCurve myCurve
GLboolean r
Definition: glcorearb.h:1222
static exint count(const GEO_PrimRBezSurf *bezsurf)
unsigned getUOrder() const
Definition: GEO_TPSurf.h:388
SYS_AtomicCounter refCount
unsigned int uint
Definition: SYS_Types.h:45
GA_Basis * getUBasis() const
Definition: GEO_TPSurf.h:384
int64 getMemoryUsage(bool inclusive) const override
Report approximate memory usage.
int getOrder() const
Return the order of the basis.
Definition: GA_Basis.h:80
virtual int intersect(const GEO_Detail &geo, const UT_Vector3 &org, const UT_Vector3 &dir, GU_RayInfo &hitinfo)
UT_Vector3 getNormal(const UT_Vector3 &uvw) const override
GA_Basis * getVBasis() const
Definition: GEO_TPSurf.h:385
UT_Vector3 getNormal(const UT_Vector3 &uvw) const override