HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
GA_Topology.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: GA_Topology.h ( GA Library, C++)
7  *
8  * COMMENTS: This class keeps track of the topological attributes attached
9  * to a piece of geometry.
10  */
11 
12 #ifndef __GA_Topology__
13 #define __GA_Topology__
14 
15 #include "GA_API.h"
16 #include "GA_Types.h"
17 #include "GA_ElementGroup.h"
18 #include "GA_ATITopology.h"
19 
20 class GA_Detail;
21 class GA_MergeMap;
22 class GA_Attribute;
23 class GA_ATITopology;
24 class UT_JSONWriter;
25 class UT_JSONParser;
26 class GA_SaveMap;
27 class GA_LoadMap;
28 class GA_Defragment;
29 class UT_MemoryCounter;
30 
32 {
33 public:
34  GA_Topology(GA_Detail &detail);
35  ~GA_Topology();
36 
37  // We store topology as 16 bit values for small geometry. As the geometry
38  // grows, we switch to 32 bit values, eventually switching to 64 bit values if
39  // the geometry grows very large. We do this by walking up and down through
40  // this table.
41 
43  {
44  public:
45  ga_StorageSwitch(GA_Storage store, GA_Size lo_water, GA_Size hi_water) :
46  myStorage(store), myLowWater(lo_water), myHighWater(hi_water)
47  {
48  }
49 
50  bool downShift(GA_Size size) const
51  {
52  return size <= myLowWater;
53  }
54  bool upShift(GA_Size size) const
55  {
56  return size >= myHighWater;
57  }
59  {
60  return myStorage;
61  }
62 
63  private:
64  GA_Storage myStorage;
65  GA_Size myLowWater;
66  GA_Size myHighWater;
67  };
68 
69  #define NUM_STORAGE_LEVELS 3
70 
71  static inline int
72  computeStorageDownShift(int storage_level, GA_Size size)
73  {
74  int change = 0;
75  while (storage_level > 0
76  && theStorageLevels[storage_level].downShift(size))
77  {
78  --change;
79  --storage_level;
80  }
81 
82  return change;
83  }
84 
85  static inline int
86  computeStorageUpShift(int storage_level, GA_Size size)
87  {
88  int change = 0;
89  while (storage_level < (NUM_STORAGE_LEVELS - 1)
90  && theStorageLevels[storage_level].upShift(size))
91  {
92  ++change;
93  ++storage_level;
94  }
95 
96  return change;
97  }
98 
99  static inline GA_Storage
101  {
102  return theStorageLevels[level].getStorage();
103  }
104 
105  /// Return the data ID for the topology attributes.
106  int64 getDataId() const;
107 
108 
109  /// Test whether all required attributes built
110  bool isFull() const;
111 
112  /// This method constructs the topology attributes for the detail. It
113  /// should only be called by GA_Detail. Please use rebuildTopology() from
114  /// other code.
115  void makeFull() // Build the topological attributes
116  {
117  if (!myPointRef)
118  makePointRef();
119  if (!myPrimitiveRef)
120  makePrimitiveRef();
121  if (!myVertexRef || !myVertexPrevRef || !myVertexNextRef)
122  makeVertexRef();
123  }
124 
125  /// Re-create the topology links. This method will re-create all the
126  /// topological information. If the <tt>rebuild_topology</tt> option is
127  /// true, then any missing attributes will be created. If support_hedge is
128  /// true, then half-edge topology attributes are constructed.
129  void rebuildTopology(bool rebuild_topology=true,
130  bool support_hedge = false);
131 
132  /// makeMinimal() deletes the non-essential topology attributes. All
133  /// optional attributes (the options which allow reverse lookup of
134  /// elements) are deleted. The attribute to map vertex to point
135  /// (myPointRef) remains untouched.
136  void makeMinimal();
137 
138  /// The topology attributes try to store minimal amounts of information.
139  /// That is, if there are only 4 points in the geometry, we won't store the
140  /// indices as 64-bit integers. This method will change the storage
141  /// attributes if needed.
142  bool checkStorageChange();
143 
144  /// @{
145  /// Called by GA_Detail::defragment when defragmenting offset lists
146  ///
147  /// NOTE: defragmentLinks will bump the data ID of myPointRef,
148  /// myVertexRef, or myPrimitiveRef if any of those are
149  /// modified, because they are modified when defragmenting
150  /// an index map that is different from their owner,
151  /// i.e. their *link* owner's index map.
152  /// defragmentElements does NOT bump any data IDs.
153  void defragmentElements(const GA_Defragment &defrag);
154  void defragmentLinks(const GA_Defragment &defrag);
155  /// @}
156 
157  /// Functions to maintain topological information
159  { return addVertexBlock(vtx, 1); }
161  { return addPointBlock(pt, 1); }
162  void addVertexBlock(GA_Offset vtx, GA_Size nvertices);
163  void addPointBlock(GA_Offset pt, GA_Size npoints);
164  void delPoint(GA_Offset pt);
165  void delVertex(GA_Offset vtx);
166 
167  /// @note When hedge attributes are present wireVertexPoint has to
168  /// try to fix the changes to hedge equivalence classes that take place
169  /// when a vertex is wired to a new point, namely, the two hedges
170  /// incident to the given vertex must be unlinked from their previous
171  /// equivalence classes and must be linked into respective new ones.
172  /// This means that a search on the incident primitives of the new
173  /// point must be carried out to determine the new associations. This
174  /// is where having hedges costs the most. If the caller has access to
175  /// the classes to other hedges from the classes into which the affected
176  /// hedges must be linked, it must call wireVertexPointAndLinkHedges
177  /// which runs in constant time.
178  /// Alternatively, if the caller knows that no hedge information
179  /// needs to be changed, wireVertexPointAndIgnoreHedges can be called.
180  /// @see wireVertexPointAndRelinkHedges
181  /// @see wireVertexPointAndIgnoreHedges
182  void wireVertexPoint(GA_Offset vtx, GA_Offset pt);
183 
184  /// Wires vertex to the point and links the the hedges whose head
185  /// and tail vertices are vtx into prev_into_src_vtx and next_into_src_vtx
186  /// respectively.
187  ///
188  /// @note This method is used to avoid the search that is performed by
189  /// the standard wireVertexPoint to *find* hedges equivalent to those
190  /// incident to vtx. It's useful when these hedges are known in advance.
191  void wireVertexPointAndRelinkHedges(GA_Offset vtx, GA_Offset pt,
192  GA_Offset prev_into_src_vtx,
193  GA_Offset next_into_src_vtx);
194 
195  /// Wires vertex to the point and completely ignores the affected hedges.
196  ///
197  /// This is equivalent to wireVertexPoint before hedges were introduced,
198  /// or when hedge attributes do not exist. Note that if hedge attributes
199  /// are present, this should be called at the risk of violating hedge
200  /// invariants. It is useful, for example, if all the vertices wired to a
201  /// point are being wired to another point and therefore there is no need
202  /// to update hedge attributes.
203  void wireVertexPointAndIgnoreHedges(GA_Offset vtx, GA_Offset pt);
204 
205  void wireVertexPrimitive(GA_Offset vtx, GA_Offset prim);
206 
207  /// Test to see whether a point is used
208  bool isPointUsed(GA_Offset pt) const;
209  /// Test to see whether a point is used by more than one vertex
210  bool isPointShared(GA_Offset pt) const;
211 
212  /// Make the attribute to store vertex->point reference (mandatory)
213  void makePointRef();
214  /// Make the attribute to store vertex->primitive reference (optional)
215  void makePrimitiveRef();
216  /// Make the attributes to store point->vertex references (optional)
217  /// Note: This method will create 3 attributes
218  void makeVertexRef();
219 
221  const GA_ATITopology *getPointRef() const { return myPointRef; }
223  const GA_ATITopology *getPrimitiveRef() const { return myPrimitiveRef; }
225  const GA_ATITopology *getVertexRef() const { return myVertexRef; }
227  const GA_ATITopology *getVertexPrevRef() const { return myVertexPrevRef; }
229  const GA_ATITopology *getVertexNextRef() const { return myVertexNextRef; }
231  GA_ATITopology *getPointRef() { return myPointRef; }
233  GA_ATITopology *getPrimitiveRef() { return myPrimitiveRef; }
235  GA_ATITopology *getVertexRef() { return myVertexRef; }
237  GA_ATITopology *getVertexPrevRef() { return myVertexPrevRef; }
239  GA_ATITopology *getVertexNextRef() { return myVertexNextRef; }
240 
241  bool jsonSavePointRef(UT_JSONWriter &w, const GA_SaveMap &s) const;
242  bool jsonLoadPointRef(UT_JSONParser &p, const GA_LoadMap &s);
243 
244  /// Make any changes to the topology attributes to accommodate the new data
245  /// (i.e. change their sizes if need be). This method is called before the
246  /// merge begins.
247  void mergeRebuild(const GA_MergeMap &map);
248  void mergeGrowCheckStorageChange(GA_Size sz);
249 
250  /// Verify that the topologies are constructed correctly
251  /// This is just for debugging purposes, and so may call printf
252  bool validate() const;
253 
254  /// Returns the next and previous boundary vertices of a given vertex in
255  /// its primitive.
256  /// @param vtx input vertex
257  /// @param prev_vtx reference into which previous boundary vertex of
258  /// vtx will be written
259  /// @param next_vtx reference into which next boundary vertex of vtx
260  /// will be written
261  void getAdjacentBoundaryVertices(GA_Offset vtx,
262  GA_Offset &prev_vtx,
263  GA_Offset &next_vtx) const;
264 
265  /// Returns true if hedge topology is maintained
266  ///
267  /// A *hedge* (short for half-edge) embodies the notion of an edge
268  /// localised to a primitive incident to it. An edge incident to k
269  /// primitives therefore leads to k distinct hedges, one belonging to
270  /// each of the primitives. Unlike edges, hedges are oriented and therefore
271  /// have distinct *tail* and *head* vertices. The points wired to the tail
272  /// and head vertices of a hedge are respectively called its tail and head
273  /// points and together make up the *endpoints* of the given hedge. Two
274  /// hedges are called *equivalent* if and only if their endpoints (as sets)
275  /// coincide, i.e. if and only if either they both have the same tail point
276  /// and the same head point, or the head point of one is the same as the
277  /// tail point of another and vice versa. Equivalence of hedges puts them
278  /// into *equivalence classes*.
279  bool isHedgeFull() const
280  { return (myHedgePrevRef != 0); }
281 
282  /// Creates hedge topology attributes if they don't already exist
283  /// @see createHedgeTopologyLinks
284  /// @see rebuildHedgeTopologyLinks
286  {
287  if (!myHedgePrevRef || !myHedgeNextRef || !mySecondaryHedges)
288  makeHedgeRef();
289  }
290 
291  /// Creates the hedge topology attributes
292  ///
293  /// @note This method will create 2 vertex topology attributes and 1 vertex group
294  void makeHedgeRef();
295 
296  /// Creates hedge topology attributes and computes them for the existing detail
297  void createHedgeTopologyLinks();
298 
299  /// Destroys the hedge topology attributes
300  void destroyHedgeTopologyLinks();
301 
302  /// Return true if the argument is the tail vertex of a "valid" hedge.
303  ///
304  /// A hedge is *valid* if and only if (1) it belongs to a primitive that
305  /// supports hedges and (2) the primitive returns a non-negative vertex
306  /// offset for its next boundary vertex. A valid hedge is *singleton* if
307  /// it is not linked up with any other hedges into an equivalence class.
308  /// NOTE 1: The validity of a hedge has *nothing* to do with its vertices
309  /// being wired to points.
310  /// NOTE 2: All valid hedges with unwired vertices are singletons.
311  /// The next and previous hedge references of an invalid hedge must be
312  /// GA_INVALID_OFFSET and those of a singleton hedge must be the hedge
313  /// itself. This will be how we distinguish valid hedges from invalid ones.
314  bool isValidHedge(GA_Offset src_vtx) const;
315 
316  /// Returns true if the input hedge is a *primary* hedge.
317  /// @note This method doesn't check for validity of the hedge. It returns
318  /// true as long as the vertex is not marked as being secondary to another
319  /// hedge.
320  ///
321  /// Each equivalence class of hedges (linked into a circular linked list
322  /// using myHedgePrevRef and myHedgeNextRef) must have exactly one *primary*
323  /// hedge. All other hedges in the class are marked secondary by being
324  /// added to the group mySecondaryHedges. This is an invariant maintained
325  /// at all times.
326  /// @note The primary hedge of a class is elected arbitrarily. It stays
327  /// primary until it is unlinked from the class, at which time another hedge
328  /// becomes the primary hedge in that class. A singleton hedge is the
329  /// primary of its own class.
330  bool isPrimaryHedge(GA_Offset src_vtx) const
331  { return !mySecondaryHedges->containsOffset(src_vtx); }
332 
333  /// Returns the previous hedge in the equivalence class of the given hedge.
334  ///
335  /// The equivalence class of a hedge consists of all hedges whose two
336  /// endpoints coincide with those of the hedge in question (although they
337  /// may be reversely paired). By *endpoints* of a hedge we mean the two
338  /// points into which the tail and head vertex of a hedge are respectively
339  /// wired.
340  /// @note Starting with any valid hedge, repeated calls to hedgeToPrevHedge
341  /// or hedgeToNextHedge traverses all hedges to the original one and
342  /// ultimately wraps around.
344  { return myHedgePrevRef->getLink(src_vtx); }
345 
346  /// Returns the next hedge in the equivalence class of the given hedge.
347  /// @see hedgeToPrevHedge
349  { return myHedgeNextRef->getLink(src_vtx); }
350 
351  /// returns the primary hedge in the equivalence class of a given hedge
352  GA_Offset hedgeToPrimaryHedge(GA_Offset vtx);
353 
354  /// Same as linkHedge, but first unlinks hedge before calling linkHedge.
355  /// @see linkHedge
356  void relinkHedge(GA_Offset src_vtx,
357  GA_Offset dst_vtx,
358  GA_Offset into_src_vtx = GA_INVALID_OFFSET);
359 
360  /// This is equivalent to calling relinkHedge on both of the hedges that
361  /// are incident to a vtx.
362  void relinkVertexHedges(GA_Offset vtx);
363 
364  /// This is equivalent to calling relinkHedge on both of the hedges that
365  /// are incident to a vtx. Instead of searching for equivalent hedges to
366  /// link into, it respectively links the the hedges whose head and tail
367  /// vertices are vtx into prev_into_src_vtx and next_into_src_vtx.
368  void relinkVertexHedges(GA_Offset vtx,
369  GA_Offset prev_into_src_vtx,
370  GA_Offset next_into_src_vtx);
371 
372  /// Tosses out existing topology links and rebuilds the whole thing from
373  /// scratch.
374  /// @see createHedgeTopologyLinks
375  void rebuildHedgeTopologyLinks();
376 
377  /// This counts memory using the given UT_MemoryCounter.
378  /// NOTE: GA_Topology doesn't own any of the memory it points to,
379  /// so there's not much to count.
380  void countMemory(UT_MemoryCounter &counter, bool inclusive) const;
381 
382  /// Returns the current storage level as an int.
383  /// Call GA_Topology::getStorage(topology.getStorageLevel())
384  /// to get the GA_Storage.
385  int getStorageLevel() const
386  { return myStorageLevel; }
387 
388 private:
389 
390  /// Unlinks a hedge from the circular linked list that represents its
391  /// equivalence class.
392  ///
393  /// @note We always want to maintain the invariant that at any given
394  /// time each hedge be linked to other hedges in its equivalence class.
395  /// Therefore, unlinking should only be used either right ahead of
396  /// relinking into another class or when a hedge turns into a singleton
397  /// class of its own.
398  /// @note This method must not be called if hedge topology attributes are
399  /// not created
400  /// @see isHedgeFull
401  void unlinkHedge(GA_Offset tailv);
402 
403 
404  /// Links a hedge into the equivalence class of hedges that share its
405  /// endpoints.
406  /// @param src_vtx The tail vertex of the hedge to be linked
407  /// @param dst_vtx The head vertex of the hedge to be linked. This is
408  /// made mandatory even though it can be found by querying the primitive
409  /// because it has to be done anyway and most often the caller has it
410  /// figured out before calling this method. dst_vtx equal to -1 makes
411  /// the hedge invalid.
412  /// @param into_src_vtx (Optional) the tail vertex of an already known
413  /// hedge from the equivalence class. If specified, no searching takes
414  /// place and the given hedge is simply linked into the class of the hedge
415  /// determined by into_src_vtx. Note that no checks are made to ensure
416  /// that the hedge truly belongs to the class. If into_src_vtx is not
417  /// specified, we search for a hedge in the target equivalence class. The
418  /// running time in this case is at least proportional to the number of
419  /// vertices wired to the same point as src_vtx.
420  ///
421  /// @note No unlinking of any hedges is applied before linking them up
422  /// into new ones. The caller must make sure the hedge to be linked is
423  /// already unlinked from any class into which it might have been
424  /// previously linked.
425  ///
426  /// @note It is OK if the hedge determined by src_vtx or the one
427  /// determined by into_src_vtx are invalid (have negative previous
428  /// and next hedge references) although this generally should be avoided.
429  /// If invalid, they are first made valid before linking them into each
430  /// other.
431  void linkHedge(GA_Offset src_vtx,
432  GA_Offset dst_vtx,
433  GA_Offset into_src_vtx = GA_INVALID_OFFSET);
434 
435  /// Called by defragmentation
436  void swapElements(GA_AttributeOwner owner,
438  void moveElements(GA_AttributeOwner owner,
440  /// NOTE: This will bump the data ID of myPointRef, myVertexRef,
441  /// or myPrimitiveRef if any of those are modified,
442  /// because they are modified when defragmenting
443  /// an index map that is different from their owner,
444  /// i.e. their *link* owner's index map.
445  void swapLinks(GA_AttributeOwner owner, const GA_Defragment &d);
446  static void swapTopologyElements(GA_ATITopology *atr,
448  static void moveTopologyElements(GA_ATITopology *atr,
450  static void swapTopologyLinks(GA_ATITopology *atr,
451  const GA_Defragment &defrag);
452  bool checkStorageChange(GA_Size nvertex,
453  GA_Size npoints,
454  GA_Size nprimitives);
455  void rebuildTopologyLinks(bool do_prim, bool do_vertex);
456  void mergeResolvePendingVertexRefs(const GA_MergeMap &map);
457 
458  void unlinkVertex(GA_Offset point, GA_Offset vertex);
459  void linkVertex(GA_Offset point, GA_Offset vertex);
460  void shiftStorage(int change); // Lower storage requirements
461 
462  // GA_Detail::replace needs access to replaceStorageLevel.
463  friend GA_Detail;
464 
465  void replaceStorageLevel(const int storage_level)
466  {
467  myStorageLevel = storage_level;
468 
469  // The topology attributes should already have been replaced.
470  UT_IF_ASSERT_P(GA_Storage storage = theStorageLevels[myStorageLevel].getStorage();)
471  UT_ASSERT_P(!myPointRef || myPointRef->getStorage() == storage);
472  UT_ASSERT_P(!myPrimitiveRef || myPrimitiveRef->getStorage() == storage);
473  UT_ASSERT_P(!myVertexRef || myVertexRef->getStorage() == storage);
474  UT_ASSERT_P(!myVertexPrevRef || myVertexPrevRef->getStorage() == storage);
475  UT_ASSERT_P(!myVertexNextRef || myVertexNextRef->getStorage() == storage);
476  UT_ASSERT_P(!myHedgePrevRef || myHedgePrevRef->getStorage() == storage);
477  UT_ASSERT_P(!myHedgeNextRef || myHedgeNextRef->getStorage() == storage);
478  }
479 
480  /// Traversing equivalent hedges without use of hedge topology attributes
481  /// @note for validation of hedge topology references
482  GA_Offset hedgeToNextHedgeSlow(GA_Offset tailvertex) const;
483 
484 
485  static const ga_StorageSwitch theStorageLevels[NUM_STORAGE_LEVELS];
486 
487  GA_Detail &myDetail; // Reference to detail
488 
489  GA_ATITopology *myPointRef; // Vertex->point edge
490  GA_ATITopology *myPrimitiveRef; // Vertex->primitive edge
491  GA_ATITopology *myVertexRef; // Point->vertex edge
492  GA_ATITopology *myVertexPrevRef; // Vertex->Vertex linked list
493  GA_ATITopology *myVertexNextRef; // Vertex->Vertex linked list
494 
495  GA_ATITopology *myHedgePrevRef; // Hedge->Hedge circular linked list
496  GA_ATITopology *myHedgeNextRef; // Hedge->Hedge circular linked list
497  GA_VertexGroup *mySecondaryHedges; // secondary (non-primary) hedge marker
498 
499  int myStorageLevel; // Storage level
500 };
501 
502 #endif
Definition of a geometry attribute.
Definition: GA_Attribute.h:189
Used to pass options and map offset values during saving.
Definition: GA_SaveMap.h:48
int getStorageLevel() const
Definition: GA_Topology.h:385
bool downShift(GA_Size size) const
Definition: GA_Topology.h:50
GA_Storage getStorage() const
Definition: GA_Topology.h:58
GA_Offset hedgeToNextHedge(GA_Offset src_vtx) const
Definition: GA_Topology.h:348
The merge map keeps track of information when merging details.
Definition: GA_MergeMap.h:53
GLint level
Definition: glcorearb.h:107
SYS_FORCE_INLINE GA_ATITopology * getPrimitiveRef()
Definition: GA_Topology.h:233
void addPoint(GA_Offset pt)
Definition: GA_Topology.h:160
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1221
void makeHedgeFull()
Definition: GA_Topology.h:285
JSON reader class which handles parsing of JSON or bJSON files.
Definition: UT_JSONParser.h:72
#define GA_API
Definition: GA_API.h:12
Class which writes ASCII or binary JSON streams.
Definition: UT_JSONWriter.h:32
SYS_FORCE_INLINE GA_ATITopology * getPointRef()
Definition: GA_Topology.h:231
bool isHedgeFull() const
Definition: GA_Topology.h:279
exint GA_Size
Defines the bit width for index and offset types in GA.
Definition: GA_Types.h:211
GLsizeiptr size
Definition: glcorearb.h:663
#define GA_INVALID_OFFSET
Definition: GA_Types.h:654
#define UT_ASSERT_P(ZZ)
Definition: UT_Assert.h:101
#define NUM_STORAGE_LEVELS
Definition: GA_Topology.h:69
#define UT_IF_ASSERT_P(ZZ)
Definition: UT_Assert.h:128
GA_Size GA_Offset
Definition: GA_Types.h:617
static int computeStorageDownShift(int storage_level, GA_Size size)
Definition: GA_Topology.h:72
long long int64
Definition: SYS_Types.h:100
static GA_Storage getStorage(int level)
Definition: GA_Topology.h:100
GLdouble n
Definition: glcorearb.h:2007
SYS_FORCE_INLINE GA_ATITopology * getVertexPrevRef()
Definition: GA_Topology.h:237
static int computeStorageUpShift(int storage_level, GA_Size size)
Definition: GA_Topology.h:86
SYS_FORCE_INLINE const GA_ATITopology * getVertexNextRef() const
Definition: GA_Topology.h:229
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
bool upShift(GA_Size size) const
Definition: GA_Topology.h:54
SYS_FORCE_INLINE GA_ATITopology * getVertexNextRef()
Definition: GA_Topology.h:239
Options during loading.
Definition: GA_LoadMap.h:42
Defragmentation of IndexMaps.
Definition: GA_Defragment.h:45
void makeFull()
Definition: GA_Topology.h:115
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1221
SYS_FORCE_INLINE const GA_ATITopology * getPrimitiveRef() const
Definition: GA_Topology.h:223
void addVertex(GA_Offset vtx)
Functions to maintain topological information.
Definition: GA_Topology.h:158
GA_Offset hedgeToPrevHedge(GA_Offset src_vtx) const
Definition: GA_Topology.h:343
bool rebuildTopology(GA_Detail &gdp, bool create_attributes=false) const
SYS_FORCE_INLINE const GA_ATITopology * getVertexPrevRef() const
Definition: GA_Topology.h:227
GA_AttributeOwner
Definition: GA_Types.h:33
SYS_FORCE_INLINE const GA_ATITopology * getVertexRef() const
Definition: GA_Topology.h:225
SYS_FORCE_INLINE GA_ATITopology * getVertexRef()
Definition: GA_Topology.h:235
getOption("OpenEXR.storage") storage
Definition: HDK_Image.dox:276
Container class for all geometry.
Definition: GA_Detail.h:96
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:856
bool isPrimaryHedge(GA_Offset src_vtx) const
Definition: GA_Topology.h:330
SYS_FORCE_INLINE const GA_ATITopology * getPointRef() const
Definition: GA_Topology.h:221
GA_Storage
Definition: GA_Types.h:48
ga_StorageSwitch(GA_Storage store, GA_Size lo_water, GA_Size hi_water)
Definition: GA_Topology.h:45