HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GEO_Face.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: Geometry Library (C++)
7  *
8  * COMMENTS:
9  * The className method is used for saving/loading so there should
10  * be no spaces in the name.
11  *
12  */
13 
14 #pragma once
15 
16 #ifndef __GEO_Face_H__
17 #define __GEO_Face_H__
18 
19 #include "GEO_TriMesh.h"
20 #include "GEO_API.h"
21 #include <UT/UT_Array.h>
22 #include <UT/UT_Span.h>
23 #include <iosfwd>
24 
25 class GA_Basis;
26 class GD_Face;
27 class GD_Detail;
28 class GEO_Detail;
29 class GEO_Vertex;
30 class GEO_PolyCounts;
31 class GU_RayInfoHit;
32 
33 template<typename T, bool B> class GA_EdgeT;
35 
37 {
38 protected:
39  /// NOTE: The constructor should only be called from subclass
40  /// constructors.
43  : GEO_TriMesh(d, offset)
44  {}
45 
46  /// NOTE: The destructor should only be called from subclass
47  /// destructors.
48  ~GEO_Face() override {}
49 
50 public:
51  // Calculate the normal of this face
52  UT_Vector3 computeNormal() const override;
53  UT_Vector3D computeNormalD() const override;
54 
55  // Accumulate the normal of this face onto its points
56  void normal(NormalComp &output) const override;
57  void normal(NormalCompD &output) const override;
58 
59  bool saveH9(std::ostream &os, bool binary,
60  const UT_Array<GA_AttribSaveDataH9> &prim_attribs,
61  const UT_Array<GA_AttribSaveDataH9> &vtx_attribs)
62  const override;
63  bool loadH9(UT_IStream &is,
64  const UT_Array<GA_AttribLoadDataH9> &prim_attribs,
65  const UT_Array<GA_AttribLoadDataH9> &vtx_attribs) override;
66 
67  void copyPrimitive(const GEO_Primitive *src) override;
68  GEO_Primitive *copy(int preserve_shared_pts = 0) const override;
69 
70  void copySubclassData(const GA_Primitive *source) override;
71 
72  bool isDegenerate() const override;
73 
74  virtual unsigned getOrder() const = 0;
75 
76  // Convert the real domain values of the primitive to unit values to be
77  // used in the evaluation methods below:
78  void realToUnitPair(float ureal, float vreal,
79  float &uunit, float &vunit) const override;
80  // and vice versa
81  void unitToRealPair(float uunit, float vunit,
82  float &ureal, float &vreal) const override;
83 
84  // Map the normalized length (distance value [0,1]) parameter to the unit
85  // parameterization of the primitve
86  void unitLengthToUnitPair(float ulength, float vlength,
87  float &uparm, float &vparm) const override;
88  void unitLengthToUnitPair(float ulength, float vlength,
89  float &uparm, float &vparm, float tolerance) const override;
90  void unitToUnitLengthPair(float uparm, float vparm,
91  float &ulength, float &vlength) const override;
92 
93  // Evaluate one point (when du=0), or the du-th derivative.
94  // Return 0 if successful, and -1 otherwise.
95  SYS_DEPRECATED_HDK(13.0)
96  bool evaluate(fpreal u, GEO_Vertex result,
98  int du=0, int uoffset=-1) const;
99  bool evaluate(fpreal u, GA_Offset result_vtx,
100  GA_AttributeRefMap &gah,
101  int du=0, int uoffset=-1) const
102  { return evaluateRefMap(u, result_vtx,
103  gah, du, uoffset); }
104  int evaluate(float u, UT_Vector4 &pos,
105  unsigned du=0, int uoffset=-1) const
106  { return evaluateV4(u, pos, du, uoffset); }
107 
108  // Evaluate the position or the derivative at domain point (u,v), where
109  // u and v MUST be in [0,1]. "v" and "dv" will be ignored here. Return 0 if
110  // OK and -1 otherwise.
111  // NB: evaluatePoint will return the normal to the face if dv is set.
112  int evaluateNormalVector(UT_Vector3 &nml, float u,
113  float v = 0, float w = 0) const override;
114 
115  // Evaluaes the frenet frame at the u parameter given. If accurate
116  // is zero, the normal of the face is used for the binormal as opposed
117  // to the correct value.
118  virtual int evaluateFrenetFrame(UT_Vector3 &x,
120  float u, int accurate = 1, int uoffset = -1)
121  const;
122 
123  // Fill in parameter values that interpolate breakpoints. The start
124  // and stop indices are breakpoint indices. lod specifies the number
125  // of isoparms to insert between breakpoints in each dimension.
126  void fillBreakParameters(UT_Array<float> &uvals,
127  int ustartidx, int ustopidx,
128  int ulod) const;
129 
130  // Evaluate the curve for the given parameter array. The provided
131  // result array should provide storage for uvals.entries() values.
132  virtual bool evaluateMesh(const UT_Span<const float> &uvals,
133  GA_Offset *results,
134  GA_AttributeRefMap &hlist, unsigned du=0) const;
135  virtual bool evaluateMesh(const UT_Span<const float> &uvals,
136  UT_Vector4 *pos, unsigned du=0) const;
137 
138  // Compute the location of the breakpoint. Return 0 if OK, else -1.
139  virtual int evaluateBreakpoint(int uidx, UT_Vector4 &pos,
140  int du=0) const = 0;
141 
142  // This method takes a start and a stop index in the valid domain, a lod
143  // representing number of points between every two breakpoints, an integer
144  // index, and return the value of the DOMAIN of point index after the
145  // domain has lod points inserted between breakpoints.
146  virtual float breakSegmIndexToDomain(int ustartidx, int ustopidx,
147  int lod, int index) const;
148 
149  // Remove all repeated vertices - (only gets consecutive vertices)
150  // checkorder refers to inspecting getOrder() and not removing repeated
151  // vertices until they exceed order in count. It has nothing to do
152  // with whether the vertices are checked in order. count_only means
153  // that we return the number of repeated vertices without removing them.
154  virtual GA_Size removeRepeatedVertices(
155  bool check_order = false,
156  bool count_only = false,
157  bool delete_orphaned_points = false);
158  virtual GA_Size removeRepeatedPoints(
159  float tol = 0.001F,
160  bool check_order = false,
161  bool count_only = false,
162  bool delete_orphaned_points = false);
163 
164  // Assuming the face is closed, "unroll" it so that the CVs that are
165  // shared to form a wrapped curve are made unique. Also, the face becomes
166  // open. The base class method only flips the open flag. If the face is
167  // not closed, the method returns -1. Otherwise it returns 0.
168  virtual int unroll(int append_pts = 1);
169 
170 
171  // Raise the number of CVs to match the newcount. The shape of the face
172  // (especially if parametric) should NOT change. Return 0 upon success
173  // and -1 otherwise. start and stop define which indices to examine
174  // if newcount is negative it is taken as a relative value.
175  virtual int loft(int newcount, int start=-1, int stop=-1) = 0;
176 
177 
178  // Given a parameter in the face domain, insert as many CVs as necessary
179  // to create a discontinuity at the corresponding point on the face. The
180  // shape of the face should NOT change. Return u's index upon success
181  // and -1 otherwise.
182  int subdivide(float u, GA_AttributeRefMap &map)
183  { return subdivideRefMap(u, map); }
184  int subdivide(float u)
185  { return subdivideFloat(u); }
186 
187  // Warp the curve at u by the given delta. Change 1 or 2 Cvs and possibly
188  // insert a knot once or more as well. If a knot is inserted or we happen
189  // to land exactly on a knot, we change only one CV. The bias makes sense
190  // only when changing 2 CVs, and will be ignored altogether if < 0.
191  // We return the index of the affected knot in the sequence, or -1 if
192  // there's an error.
193  virtual int warp(float u, const UT_Vector3 &delta,
194  GA_AttributeRefMap &map,
195  float sharpness = 0.0f, float bias = -1.0f) = 0;
196 
197  // Warp the face along its normal at u. Return the index of the afected
198  // knot in the sequence, or -1 if there's an error.
199  int warpAlongNormal(float u, float distance,
200  GA_AttributeRefMap &map,
201  float sharpness, float bias);
202 
203  // Append another face to us in one of two ways: blend the two endpoints
204  // or connect them straight or rounded. The bias ranges from 0 to 1 and is
205  // relevant only to blending. The tolerance for blending: if 0, the two
206  // endpoints will merge into one point with a discontinuity; if less than
207  // 1, we insert knots into the curves to minimize the affected areas; if 1,
208  // no refinement is done. For the non-blend case, the tolerance will
209  // generate a span whose shape goes from round to straight; 0 tolerance
210  // means straight connection. If unrefine is on, we'll try to reduce the
211  // complexity of the face if we're connecting rounded. We return 0 if OK
212  // and -1 if error. Both curves must be open and have the same order.
213  virtual int attach(const GEO_Face &face, int blend = 1,
214  float bias = 0.5f, float tolerance = 1.0f,
215  int unrefine=1, GA_PointGroup *ptgroup=0) = 0;
216 
217  // Build a planar (domain) face of the same type as us and with the same
218  // number of vertices. Copying the (x,y) values of our points to the planar
219  // face is optional.
220  virtual GD_Face *planar(GD_Detail &dgdp, int copyxy = 0) const = 0;
221 
222  // Go from a normalized domain ([0,1]) to the real domain or vice versa.
223  virtual float unitToRealDomain(float u_unit) const;
224  virtual float realToUnitDomain(float u_real) const;
225 
226  // Map the normalized length (distance value [0,1]) parameter to the unit
227  // parameterization of the primitve. The tolerance specifies max
228  // error of the returned value (cannot be 0.0f).
229  virtual float unitLengthToUnitDomain(float ulength,
230  float tolerance = 1e-04F) const;
231 
232  virtual float unitToUnitLengthDomain(float uparm ) const;
233 
234 
235  // Calculate the real domains for n consecutive operations on the domain
236  // given n normalized domains and the operation
237  // Here the real domain ranges from 0 to vertexcount - 1 + isClosed().
238  virtual void unitToRealSequence(float *uunit, float *ureal,
239  int ulen) const;
240  static void unitToRealAdjust(float *uunit, float *ureal,
241  int ulen, int num);
242 
243  // Return the bounds of the valid evaluation interval in domain space:
244  // For polygons this refers to cv indices.
245  virtual void validInterval(int &a, int &b) const;
246  virtual void validRange(float &ua, float &ub) const;
247 
249  {
250  return myVertexList.getExtraFlag();
251  }
252  /// NOTE: This won't update the basis for NURBS/Bezier curves!
253  /// It just sets the closed flag, so make sure the bases
254  /// get set afterward!
255  SYS_FORCE_INLINE void setClosed(bool isclosed)
256  {
257  myVertexList.setExtraFlag(isclosed);
258  }
259  virtual void close(int rounded = 1, int preserve_shape = 0);
260  virtual void open(int preserve_shape = 0, int safe = 0);
261 
262  bool hasEdge(const GA_Edge &edge) const override;
263 
264  // Methods to handle vertex attributes for the attribute dictionary
265  void iterateEdges(GA_IterateEdgesFunc apply_func) const override;
266  void iterateEdgesByVertex(GA_IterateEdgesByVertexFunc apply_func) const override;
267 
268  // Returns the number of edges on this face.
269  int getEdgeCount() const;
270 
271  // Reverses the vertices of a given face. It's virtual because some faces,
272  // such as rational splines, need to be aware of it.
273  void reverse() override;
274 
275  // Append n points equally spaced between the 1st and last vertex.
276  void sampleEnds(int n);
277 
278  // Shift the array of vertices by an offset and wrap around. The offset
279  // can be either negative or positive.
280  virtual int cycle(int amount, int = 1);
281 
282  // Find the center and radius of the face
283  float radius() const;
284 
285  // Finds which vertex#'s the given points have. The points should make
286  // an edge.
287  // Returns false if the points do not define an edge on this face,
288  // true if they do (in which case pidx0 and pidx1 are the vertex#'s)
289  bool findEdgePoints(GA_Offset pta, GA_Offset ptb,
290  GA_Size &pidx0, GA_Size &pidx1) const;
291  bool findEdgePoints(const GA_Edge &edge,
292  GA_Size &pidx0, GA_Size &pidx1) const;
293 
294 
295  // True if the directed edge a->b is in this face.
296  bool hasDEdge(GA_Offset a, GA_Offset b) const;
297 
298  /// True if both the directed edges a->b and b->a are inside this
299  /// face
300  bool isBridge(GA_Offset a, GA_Offset b) const;
301 
302  // Change the multiplicity of the domain value by inserting it after
303  // checking its current multiplicity. Return -1 if invalid, otherwise
304  // return the index of the inserted knot
305 
306  int refine(float k, GA_AttributeRefMap &gah, int r=1)
307  { return refineRefMap(k, gah, r); }
308  int refine (float k, int r=1)
309  { return refineInt(k, r); }
310 
311  // Find enclosing integral values(c1, c2) which validly enclose c
312  // and return the distance to c1
313  static fpreal getIndices(fpreal c, int &c1, int &c2,
314  int max_index, int wrap);
315 
316  // Halper function to compute real parameter values that interpolate
317  // breakpoints for curves.
318  static void fillBreakVals(const GA_Basis &ub,
319  UT_Array<float> &uvals,
320  int ustartidx,
321  int ustopidx,
322  int ulod, bool wrap);
323 
324  // Determine whether the values in `vals` are uniformly spaced in
325  // [idx,nextidx) and if so return true and store the spacing in `step`
326  static bool getUniformStep(const UT_Span<const float> &vals,
327  int idx, int nextidx,
328  fpreal &step);
329 
330  /// This method determines whether the point is inside or outside the
331  /// polygon. The point is assumed to be on the plane of the polygon.
332  /// Note that normal is a pointer to this primitive's normal which cannot
333  /// be NULL.
334  /// If the point is on the boundary of the face, it is reported as being
335  /// inside the face with -1 return.
336  virtual int pointInFace(const UT_Vector3 &pos,
337  const UT_Vector3 *normal) const;
338 
339  // Find distance in parameter space, aware of wrapping.
340  float uvDist(float u1, float v1, float u2, float v2) const override;
341 
342  // Do nothing for poly's
343  virtual void weights(unsigned short on_off);
344  virtual int breakCount() const = 0;
345 
346  fpreal calcVolume(const UT_Vector3 &refpt) const override;
347  fpreal calcArea() const override;
348  fpreal calcPerimeter() const override;
349 
350  // Intersect this with the other primitive, as a series of edges, not
351  // a filled face.
352  virtual int intersect(const GEO_Primitive &prim,
353  UT_Array<GU_RayInfoHit> &hit_list,
354  float tol = 0.01F, int ignoretrim=1) const =0;
355 
357  UT_Array<GA_Offset> &vtxlist, UT_Array<float> &weightlist,
358  fpreal u, fpreal v, fpreal w) const override;
359 
360 protected:
361  /// Builds faces using the specified range of point offsets,
362  /// as dictated by facesizelist and facepointnumbers, in parallel.
363  /// facepointnumbers lists the *offsets* of the points used by
364  /// each face *MINUS* startpt, i.e. they are offsets relative to startpt,
365  /// *not* indices relative to startpt. The offset of the first face is
366  /// returned, and the rest are at consecutive offsets. All
367  /// facepointnumbers must be between 0 (inclusive) and
368  /// npoints (exclusive).
369  ///
370  /// NOTE: Existing primitives *are* allowed to be using the points in
371  /// the specified range already, and the faces being created do not
372  /// need to use all of the points in the range. However,
373  /// these cases may impact performance.
374  ///
375  /// NOTE: If you can guarantee that no other primitives are using the
376  /// points and that the vertices of these new faces will be using the
377  /// points starting from startpt in order and continuing contiguously,
378  /// e.g. with independent curves whose points were allocated with
379  /// GA_Detail::appendPointBlock, pass in NULL for facepointnumbers.
380  /// This option should be used with caution.
381  /// @{
382  static GA_Offset buildBlock(
384  GA_Detail *detail,
385  const GA_Offset startpt,
386  const GA_Size npoints,
387  const GEO_PolyCounts &facesizelist,
388  const int *facepointnumbers,
389  const bool closed = true);
390  static GA_Offset buildBlock(
392  GA_Detail *detail,
393  const GA_Offset startpt,
394  const GA_Size npoints,
395  const GA_PolyCounts &facesizelist,
396  const int *facepointnumbers,
397  const bool closed = true);
398  /// @}
399 
400  template <typename T>
401  UT_Vector3T<T> internalComputeNormal() const;
402  template <typename T>
403  fpreal internalCalcVolume(const UT_Vector3T<T> &refpt) const;
404  template <typename T>
405  fpreal internalCalcArea() const;
406  template <typename T>
407  fpreal internalCalcPerimeter() const;
408 
410  {
411  return static_cast<GA_PrimitiveFamilyMask>(
414  );
415  }
416 
417  // Declare intrinsic attribute functions
418  GA_DECLARE_INTRINSICS(override);
419 
420  bool savePrivateH9(std::ostream &os, bool binary) const override= 0;
421  bool loadPrivateH9(UT_IStream &is) override = 0;
422 
423  // Check the validity of the data. Meant to be called especially at loading
424  // time. The method returns 1 if OK and 0 if trouble.
425  bool validate() const override;
426 
427  GA_Size getMinVertexCount() const override { return isClosed() ? 3:2; }
428 
429  bool evaluatePointRefMap(GA_Offset result_vtx,
430  GA_AttributeRefMap &vtxdata,
431  fpreal u, fpreal v=0,
432  uint du=0, uint dv=0) const override;
433  int evaluatePointV4(UT_Vector4 &pos, float u_unit, float=0,
434  unsigned du=0, unsigned dv = 0) const override;
435 
436  virtual bool evaluateRefMap(fpreal u, GA_Offset result_vtx,
437  GA_AttributeRefMap &gah,
438  int du=0, int uoffset=-1) const;
439  virtual int evaluateV4(float u, UT_Vector4 &pos,
440  unsigned du=0, int uoffset=-1) const;
441 
442  virtual int subdivideRefMap(float u, GA_AttributeRefMap &map);
443  virtual int subdivideFloat(float u);
444 
445  virtual int refineRefMap(float k, GA_AttributeRefMap &gah, int r=1);
446  virtual int refineInt(float k, int r=1);
447 
448 private:
449 
450  friend std::ostream &operator<<(std::ostream &os, const GEO_Face &d)
451  {
452  d.saveH9(os, 0,
455  return os;
456  }
458 };
460 #endif
fpreal calcPerimeter() const override
SYS_FORCE_INLINE GEO_Face(GA_Detail *d, GA_Offset offset=GA_INVALID_OFFSET)
Definition: GEO_Face.h:42
bool isDegenerate() const override
Is the primitive degenerate.
virtual GEO_Primitive * copy(int preserve_shared_pts=0) const
bool findEdgePoints(GA_Offset ptoff0, GA_Offset ptoff1, GA_Size &vtx0, GA_Size &vtx1) const
virtual void copyPrimitive(const GEO_Primitive *src)=0
#define GEO_FAMILY_FACE
Definition: GEO_PrimType.h:76
int subdivide(float u, GA_AttributeRefMap &map)
Definition: GEO_Face.h:182
int subdivide(float u)
Definition: GEO_Face.h:184
virtual void computeInteriorPointWeights(UT_Array< GA_Offset > &vtxlist, UT_Array< float > &weightlist, fpreal u, fpreal v, fpreal w) const
virtual UT_Vector3D computeNormalD() const =0
int evaluate(float u, UT_Vector4 &pos, unsigned du=0, int uoffset=-1) const
Definition: GEO_Face.h:104
const GLdouble * v
Definition: glcorearb.h:837
#define SYS_DEPRECATED_PUSH_DISABLE()
#define SYS_DEPRECATED_POP_DISABLE()
virtual void copySubclassData(const GA_Primitive *source)
Definition: GA_Primitive.h:508
GLuint start
Definition: glcorearb.h:475
const GLuint GLenum const void * binary
Definition: glcorearb.h:1924
fpreal calcVolume(const UT_Vector3 &) const override
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1222
void reverse() override=0
Reverse the order of vertices.
#define GA_DECLARE_INTRINSICS(OVERRIDE)
Definition: GA_Primitive.h:80
**But if you need a result
Definition: thread.h:613
void close() override
GLfloat GLfloat GLfloat v2
Definition: glcorearb.h:818
UT_Function< bool(const GA_Edge &edge)> GA_IterateEdgesFunc
Definition: GA_Primitive.h:73
~GEO_Face() override
Definition: GEO_Face.h:48
fpreal calcArea() const override
SYS_FORCE_INLINE bool isClosed() const
Definition: GEO_Face.h:248
virtual void realToUnitPair(float ureal, float vreal, float &uunit, float &vunit) const
GLdouble u1
Definition: glad.h:2676
exint GA_Size
Defines the bit width for index and offset types in GA.
Definition: GA_Types.h:235
GA_PrimitiveFamilyMask
virtual UT_Vector3 computeNormal() const =0
Return a normal vector for the primitive.
virtual bool loadPrivateH9(UT_IStream &is)=0
#define GA_INVALID_OFFSET
Definition: GA_Types.h:678
virtual void normal(NormalComp &output) const =0
GA_Size GA_Offset
Definition: GA_Types.h:641
vint4 blend(const vint4 &a, const vint4 &b, const vbool4 &mask)
Definition: simd.h:4784
bool hasEdge(const GA_Edge &edge) const override
Method to determine if a primitive has an edge (undirected).
GLdouble n
Definition: glcorearb.h:2008
GLfloat f
Definition: glcorearb.h:1926
GLintptr offset
Definition: glcorearb.h:665
int open(float queuesize) override
virtual bool savePrivateH9(std::ostream &os, bool binary) const =0
bool saveH9(std::ostream &os, bool binary, const UT_Array< GA_AttribSaveDataH9 > &prim_attribs, const UT_Array< GA_AttribSaveDataH9 > &vtx_attribs) const override
int refine(float k, GA_AttributeRefMap &gah, int r=1)
Definition: GEO_Face.h:306
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
GLsizei GLsizei GLchar * source
Definition: glcorearb.h:803
void unitToUnitLengthPair(float uparm, float vparm, float &ulength, float &vlength) const override
UT_Function< bool(GA_Size, GA_Size)> GA_IterateEdgesByVertexFunc
Definition: GA_Primitive.h:74
#define GEO_API
Definition: GEO_API.h:14
Bezier or NURBS basis classes which maintain knot vectors.
Definition: GA_Basis.h:49
A handle to simplify manipulation of multiple attributes.
virtual void iterateEdges(GA_IterateEdgesFunc apply_func) const
Definition: GA_Primitive.h:362
virtual float uvDist(float u1, float v1, float u2, float v2) const
#define SYS_DEPRECATED_HDK(__V__)
GLdouble GLdouble u2
Definition: glad.h:2676
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1222
GLint GLenum GLint x
Definition: glcorearb.h:409
GLdouble t
Definition: glad.h:2397
GA_Size getMinVertexCount() const override
Definition: GEO_Face.h:427
bool evaluatePointRefMap(GA_Offset result_vertex, GA_AttributeRefMap &hlist, fpreal u, fpreal v, uint du, uint dv) const override
bool loadH9(UT_IStream &is, const UT_Array< GA_AttribLoadDataH9 > &prim_attribs, const UT_Array< GA_AttribLoadDataH9 > &vtx_attribs) override
static const UT_Array< GA_AttribSaveDataH9 > & theEmptySaveAttribs
Convience objects to pass as arguments to saveH9()/loadH9().
fpreal64 fpreal
Definition: SYS_Types.h:277
GLuint index
Definition: glcorearb.h:786
virtual void unitToRealPair(float uunit, float vunit, float &ureal, float &vreal) const
IMATH_CONSTEXPR14 bool intersect(const Line3< T > &line, const Vec3< T > &v0, const Vec3< T > &v1, const Vec3< T > &v2, Vec3< T > &pt, Vec3< T > &barycentric, bool &front) IMATH_NOEXCEPT
Definition: ImathLineAlgo.h:80
friend std::ostream & operator<<(std::ostream &os, const GEO_Face &d)
Definition: GEO_Face.h:450
GLfloat GLfloat v1
Definition: glcorearb.h:817
virtual int evaluateNormalVector(UT_Vector3 &nml, float u, float v=0, float w=0) const
static GA_PrimitiveFamilyMask buildFamilyMask()
Definition: GEO_Face.h:409
Container class for all geometry.
Definition: GA_Detail.h:96
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
int refine(float k, int r=1)
Definition: GEO_Face.h:308
ImageBuf OIIO_API warp(const ImageBuf &src, const Imath::M33f &M, string_view filtername=string_view(), float filterwidth=0.0f, bool recompute_roi=false, ImageBuf::WrapMode wrap=ImageBuf::WrapDefault, ROI roi={}, int nthreads=0)
GLboolean r
Definition: glcorearb.h:1222
#define const
Definition: zconf.h:214
SIM_API const UT_StringHolder distance
virtual bool validate() const
type
Definition: core.h:1059
int evaluatePointV4(UT_Vector4 &pos, float u, float v=0, unsigned du=0, unsigned dv=0) const override
Definition: GEO_TriMesh.h:230
unsigned int uint
Definition: SYS_Types.h:45
GLint lod
Definition: glcorearb.h:2765
virtual void iterateEdgesByVertex(GA_IterateEdgesByVertexFunc apply_func) const
Definition: GA_Primitive.h:372
static GA_PrimitiveFamilyMask buildFamilyMask()
Definition: GEO_TriMesh.h:188
void unitLengthToUnitPair(float ulength, float vlength, float &uparm, float &vparm) const override
bool saveH9(std::ostream &os, bool binary, const UT_Array< GA_AttribSaveDataH9 > &prim_attribs, const UT_Array< GA_AttribSaveDataH9 > &vtx_attribs) const override
GLenum src
Definition: glcorearb.h:1793
SYS_FORCE_INLINE void setClosed(bool isclosed)
Definition: GEO_Face.h:255