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