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