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