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