HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GA_ATIIndexPair.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_ATIIndexPair.h ( GA Library, C++)
7  *
8  * COMMENTS: Index Pair ATI (Attribute Type Implementation)
9  *
10  * Currently implemented with two data array tuples,
11  * one for the indices, and one for the values.
12  *
13  * We should support a single index mapping to a value tuple,
14  * instead of just a single value. The basic GA_Attribute
15  * interface simply accesses the first entry in any value
16  * tuple.
17  *
18  * The GA_Attribute level tuple size refers to the number of
19  * index pair entries. However, the defaults set at the base
20  * class are the defaults for a single entry, and so should match
21  * the tuple size of the value tuple.
22  *
23  * // TODO: Turn the base GA_Attribute interface into a sparse
24  * // array interface. getTupleSize() would return an
25  * // upper bound on the index and the get/set methods
26  * // would function implement an abstract
27  * // maximum index
28  */
29 
30 #pragma once
31 
32 #ifndef __GA_ATIIndexPair
33 #define __GA_ATIIndexPair
34 
35 #define GA_INDEX_PAIR_USE_PAGE_ARRAY 0
36 
37 #include "GA_API.h"
38 #include "GA_Attribute.h"
39 #include "GA_AttributeType.h"
40 #if !GA_INDEX_PAIR_USE_PAGE_ARRAY
41 #include "GA_DataArray.h"
42 #include "GA_DataArrayTuple.h"
43 #endif
44 #include "GA_Defaults.h"
45 #if GA_INDEX_PAIR_USE_PAGE_ARRAY
46 #include "GA_PageArray.h"
47 #endif
48 #include "GA_Range.h"
49 #include "GA_Types.h"
50 
51 #include <UT/UT_ConcurrentVector.h>
52 #include <UT/UT_Lock.h>
53 #include <UT/UT_StringHolder.h>
54 #include <UT/UT_VectorTypes.h>
55 
56 #include <SYS/SYS_AtomicInt.h>
57 #include <SYS/SYS_Types.h>
58 
59 
60 class GA_AIFCompare;
61 class GA_AIFCopyData;
62 class GA_AIFEdit;
63 class GA_AIFIndexPair;
65 class GA_AIFInterp;
66 class GA_AIFJSON;
67 class GA_AIFMath;
68 class GA_AIFMerge;
69 class GA_AIFTuple;
70 class GA_Defragment;
71 class GA_IndexMap;
72 class GA_LoadMap;
73 class GA_MergeMap;
74 class GA_SaveMap;
75 class ga_IndexPairObjectSets;
76 
77 class UT_JSONParser;
78 class UT_JSONWriter;
79 
80 
82 {
83 public:
84  static void registerType();
86  static const UT_StringHolder &getTypeName()
87  { return theAttributeType->getTypeName(); }
89  static const GA_AttributeType &getType() { return *theAttributeType; }
90 
92  static bool isType(const GA_Attribute *attrib)
93  {
94  return attrib && &attrib->getType() == theAttributeType;
95  }
98  {
99  if (attrib && &attrib->getType() == theAttributeType)
100  return static_cast<GA_ATIIndexPair *>(attrib);
101  return NULL;
102  }
104  static const GA_ATIIndexPair *cast(const GA_Attribute *attrib)
105  {
106  if (attrib && &attrib->getType() == theAttributeType)
107  return static_cast<const GA_ATIIndexPair *>(attrib);
108  return NULL;
109  }
110 
112  const GA_IndexMap &index_map, GA_AttributeScope scope,
113  const UT_StringHolder &name,
114  GA_Storage value_store, int entries, int tuple_size,
115  const GA_Defaults &index_default,
116  const GA_Defaults &value_defaults);
117  virtual ~GA_ATIIndexPair();
118 
119  /// Report memory used
120  virtual int64 getMemoryUsage(bool inclusive) const;
121 
122  virtual void countMemory(UT_MemoryCounter &counter, bool inclusive) const;
123 
124  virtual void reconstructElementBlock(GA_Offset offset, GA_Offset nelements);
125 
126  /// @{
127  /// Interface for defragmentation
128  virtual void defragment(const GA_Defragment &defrag);
129  /// @}
130 
131  /// Adding entries is thread-safe, so we're only subject to GA_DataArray
132  /// limitations.
134  { return WRITE_CONCURRENCE_PAGE; }
135 
136  virtual const GA_AIFCopyData *getAIFCopyData() const
137  { return myAIFCopyData; }
138  virtual const GA_AIFIndexPair *getAIFIndexPair() const
139  { return myAIFPair; }
140  virtual const GA_AIFMerge *getAIFMerge() const
141  { return myAIFMerge; }
142  virtual const GA_AIFEdit *getAIFEdit() const
143  { return myAIFEdit; }
144  virtual const GA_AIFTuple *getAIFTuple() const
145  { return myAIFTuple; }
146  virtual const GA_AIFMath *getAIFMath() const
147  { return myAIFMath; }
148  virtual const GA_AIFInterp *getAIFInterp() const
149  { return myAIFInterp; }
150  virtual const GA_AIFCompare *getAIFCompare() const
151  { return myAIFCompare; }
152 
153  /// @section JSON-GA_ATIIndexPair JSON Schema: GA_ATIIndexPair
154  /// @code
155  /// {
156  /// "name" : "GA_ATIIndexPair",
157  /// "description" : "An tuple array of indexed strings",
158  /// "type" : "orderedmap",
159  /// "properties": {
160  /// "idefault": {
161  /// "type" : {"$ref":"GA_Defaults"},
162  /// "description" : "Defaults for index values",
163  /// "optional" : true,
164  /// },
165  /// "vdefault": {
166  /// "type" : {"$ref":"GA_Defaults"},
167  /// "description" : "Defaults for values",
168  /// "optional" : true,
169  /// },
170  /// "entries": {
171  /// "type" : "integer",
172  /// "description" : "Number of entries for index/values tuples",
173  /// },
174  /// "istorage": {
175  /// "type" : "string",
176  /// "description" : "Storage type for index values",
177  /// "enum" : [ "int8", "int16", "int32", "int64" ],
178  /// },
179  /// "vstorage": {
180  /// "type" : "string",
181  /// "description" : "Storage type for values",
182  /// "enum" : [ "fpreal16", "fpreal32", "fpreal64" ],
183  /// },
184  /// "index": {
185  /// "type" : {"$ref":"GA_DataArrayTuple"},
186  /// "description" : "Index values.",
187  /// },
188  /// "value": {
189  /// "type" : {"$ref":"GA_DataArrayTuple"},
190  /// "description" : "Weight values.",
191  /// },
192  /// },
193  /// }
194  /// @endcode
195  /// @see @ref JSON_FileFormat
196  virtual const GA_AIFJSON *getAIFJSON() const { return myAIFJSON; }
197 
198  int getEntries() const { return myEntryCapacity.relaxedLoad(); }
199  /// setEntries() is NOT thread-safe. To concurrently grow the entry
200  /// capacity, use growEntriesTo(size, true).
201  bool setEntries(int size);
202  /// Use growEntriesTo() instead of setEntries() to ensure that the entry
203  /// capacity never shrinks. This is necessary for concurrent growing of
204  /// the entry capacity to properly handle the situation where one thread
205  /// tries to grow the entries less than another. Set the concurrent arg
206  /// if more than one thread can call this method concurrently.
207  bool growEntriesTo(int size, bool concurrent = false);
208 
209  bool setDataStorage(GA_Storage storage);
210  bool setIndexStorage(GA_Storage storage);
211 
212  const GA_Defaults &getValueDefaults() const { return myValueDefaults; }
214  { return myValueOperationalDefaults; }
215 
216  /// The size of the data tuple
217  int getDataTupleSize() const { return myTupleSize; }
218 
219  /// Grow or shrink the array size
220  virtual bool setArraySize(GA_Offset new_size);
221 
222  /// Try to compress data pages
223  virtual void tryCompressAllPages(
224  GA_Offset start_offset = GA_Offset(0),
225  GA_Offset end_offset = GA_INVALID_OFFSET);
226 
227  /// Harden data pages
228  virtual void hardenAllPages(
229  GA_Offset start_offset = GA_Offset(0),
230  GA_Offset end_offset = GA_INVALID_OFFSET);
231 
232  /// Returns true iff that is an attribute whose content can be copied
233  /// from this without any type conversions. This is important to
234  /// avoid reallocation of an attribute if its storage type,
235  /// including tuple size, matches the source attribute exactly.
236  virtual bool matchesStorage(const GA_Attribute *that) const
237  {
238  if (!GA_Attribute::matchesStorage(that))
239  return false;
240  const GA_ATIIndexPair *thatn = UTverify_cast<const GA_ATIIndexPair *>(that);
241  if (getDataStorage() != thatn->getDataStorage())
242  return false;
243  if (myIndexStorage != thatn->myIndexStorage)
244  return false;
245  if (getDataTupleSize() != thatn->getDataTupleSize())
246  return false;
247  if (getEntries() != thatn->getEntries())
248  return false;
249  return true;
250  }
251  /// In the case that we're copying from an attribute whose storage
252  /// type matches this exactly, this function copies the metadata
253  /// not associated with the storage, e.g. myOptions,
254  /// *excluding* the name and the data ID.
255  virtual void copyNonStorageMetadata(const GA_Attribute *that);
256 
257  /// This replaces the entirety of this attribute's content and non-
258  /// storage metadata (except the name) with that of the src attribute.
259  /// matchesStorage(src) should already return true.
260  /// This is primarily for use by GA_AttributeSet::replace().
261  /// NOTE: The internal content sizes may not match exactly if the
262  /// attribute type may overallocate, but the sizes should be such
263  /// that any real data will fit in the destination, so be careful
264  /// and deal with the myTailInitialize flag appropriately if
265  /// any extra elements aren't equal to the default.
266  virtual void replace(const GA_Attribute &src);
267 
268 protected:
269  int getObjectSetCount() const;
270  void setObjectSetCount(int n);
271 
272  const GA_AIFIndexPairObjects *getObjectsConst(int s = 0) const;
273  GA_AIFIndexPairObjects *getObjects(int s = 0);
274 
275  bool hasSameProperties(const GA_ATIIndexPair *sattrib) const;
276  bool copyProperties(const GA_ATIIndexPair *sattrib);
277  bool mergeObjectValues(const GA_ATIIndexPair *sattrib, UT_IntArray &new_indices);
278 
279  bool setTupleSize(int size);
280  GA_Storage getDataStorage() const { return myDataStorage; }
281 #if GA_INDEX_PAIR_USE_PAGE_ARRAY
282  bool getIndex(GA_Offset ai, int entry, int32 &index) const { index = myIndex[entry]->get<int32>(ai); return true; }
283  bool getData(GA_Offset ai, int entry, fpreal32 &data, int data_component = 0) const { data = myData[entry]->get<fpreal32>(ai, data_component); return true; }
284  bool getData(GA_Offset ai, int entry, fpreal64 &data, int data_component = 0) const { data = myData[entry]->get<fpreal64>(ai, data_component); return true; }
285  bool getData(GA_Offset ai, int entry, int32 &data, int data_component = 0) const { data = myData[entry]->get<int32>(ai, data_component); return true; }
286  bool getData(GA_Offset ai, int entry, int64 &data, int data_component = 0) const { data = myData[entry]->get<int64>(ai, data_component); return true; }
287  bool setIndex(GA_Offset ai, int entry, int32 index) { myIndex[entry]->set(ai, index); return true; }
288  bool setIndex(const GA_Range &ai, int entry, int32 index) { myIndex[entry]->setConstant(ai, index); return true; }
289  bool setData(GA_Offset ai, int entry, fpreal32 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
290  bool setData(GA_Offset ai, int entry, fpreal64 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
291  bool setData(GA_Offset ai, int entry, int32 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
292  bool setData(GA_Offset ai, int entry, int64 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
293 #else
294  bool getIndex(GA_Offset ai, int entry, int32 &index) const { myIndex[entry]->get(ai, index); return true; }
295  bool getData(GA_Offset ai, int entry, fpreal32 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
296  bool getData(GA_Offset ai, int entry, fpreal64 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
297  bool getData(GA_Offset ai, int entry, int32 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
298  bool getData(GA_Offset ai, int entry, int64 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
299  bool setIndex(GA_Offset ai, int entry, int32 index) { myIndex[entry]->set(ai, index); return true; }
300  bool setIndex(const GA_Range &ai, int entry, int32 index) { myIndex[entry]->set(ai, index); return true; }
301  bool setData(GA_Offset ai, int entry, fpreal32 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
302  bool setData(GA_Offset ai, int entry, fpreal64 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
303  bool setData(GA_Offset ai, int entry, int32 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
304  bool setData(GA_Offset ai, int entry, int64 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
305 #endif
306 
307  bool removeIndex(int index);
308  void invalidateTrailingEntries(GA_Offset ai, int start_entry);
309  void invalidateTrailingEntries(const GA_Range &ai, int start_entry);
310 
311  /// @{
312  /// Copy Data AIF
313  bool copyData(GA_Offset di, const GA_ATIIndexPair &src,
314  GA_Offset si);
315  bool copyData(const GA_Range &di, const GA_ATIIndexPair &src,
316  const GA_Range &si);
317  /// @}
318 
319  /// @{
320  /// Compare AIF
321  bool isAlmostEqual(GA_Offset di, const GA_ATIIndexPair &src,
322  GA_Offset si, int ulps) const;
323  bool isAlmostEqual(const GA_Range &di, const GA_ATIIndexPair &src,
324  const GA_Range &si, int ulps) const;
325  /// @}
326 
327  /// @{ GA_AIFMerge
328  /// Base class implementation of GA_AIFMerge::destroyDestination()
329  void mergeDestroyDestination(const GA_MergeMap &map,
330  GA_Attribute *dattrib) const;
331  /// Base class implementation of GA_AIFMerge::addDestination()
332  GA_Attribute *mergeAddDestination(const GA_MergeMap &map,
333  GA_Attribute *dattrib) const;
334  /// Base class implementation of GA_AIFMerge::copyArray()
335  bool mergeAppendData(const GA_MergeMap &map,
336  const GA_Attribute *sattrib);
337  /// @}
338 
339  /// @{
340  /// GA_AIFTuple
341  /// The AIFTuple has a tuple with 2*getEntries() entries. The entries are
342  /// interleaved with ( index0, value0, index1, value1, ...)
343  int tupleGetSize() const
344  { return (myTupleSize + 1) * getEntries(); }
345  bool tupleSetSize(int size);
346  GA_Storage tupleGetStorage() const;
347  bool tupleSetStorage(GA_Storage storage);
348  bool isNan(GA_Offset ai) const;
349  bool isNan(const GA_Range &ai) const;
350  template <typename T> inline bool
351  tupleGet(GA_Offset ai, T &v, int index) const;
352  template <typename T> inline bool
353  tupleGet(GA_Offset ai, T *v, int count, int start) const;
354  template <typename T> inline bool
355  tupleSet(GA_Offset ai, T v, int vi);
356  template <typename T> inline bool
357  tupleSet(GA_Offset ai, const T *v, int count, int start);
358  template <typename T> inline bool
359  tupleSet(const GA_Range &di, T v, int vi);
360  template <typename T> inline bool
361  tupleSet(const GA_Range &di, const T *v, int count, int start);
362  inline bool tupleSet(GA_Offset di, const GA_ATIIndexPair &s,
363  GA_Offset si, int component);
364  inline bool tupleSet(const GA_Range &di, const GA_ATIIndexPair &s,
365  const GA_Range &si, int component);
366  /// @}
367 
368 protected:
369  // Protected Data
370  ga_IndexPairObjectSets *myObjects;
371 #if GA_INDEX_PAIR_USE_PAGE_ARRAY
372  UT_ConcurrentVector<GA_PageArray<void,1> *> myIndex;
373  UT_ConcurrentVector<GA_PageArray<> *> myData;
374 #else
375  UT_ConcurrentVector<GA_DataArray *> myIndex;
376  UT_ConcurrentVector<GA_DataArrayTuple *> myData;
377 #endif
378 
379  /// The tuple size of each GA_PageArray in myData.
380  /// At the moment, this is normally 1, but is 3 for the CAPTURE_WIRE
381  /// (wireCapture) case. The other cases are CAPTURE_BONE (boneCapture),
382  /// CAPTURE_META (metaCapture), CAPTURE_CLOTH (clothCapture), and
383  /// CAPTURE_MUSCLE (muscleCapture).
385 
393 
394  /// Scale all weights by the given amount (used in weighted sums)
395  void interpScale(GA_Offset di, fpreal scale);
396 
397 private:
398  virtual GA_Attribute *doClone(const GA_IndexMap &index_map,
399  const UT_StringHolder &name) const;
400 
401  /// @{ GA_AIFJSON
402  bool jsonSave(UT_JSONWriter &w, const GA_SaveMap &s) const;
403  bool jsonLoad(UT_JSONParser &p, const GA_LoadMap &l);
404  /// @}
405 
406  static GA_AIFIndexPair *myAIFPair;
407  static GA_AIFMerge *myAIFMerge;
408  static GA_AIFCopyData *myAIFCopyData;
409  static GA_AIFEdit *myAIFEdit;
410  static GA_AIFJSON *myAIFJSON;
411  static GA_AIFTuple *myAIFTuple;
412  static GA_AIFMath *myAIFMath;
413  static GA_AIFInterp *myAIFInterp;
414  static GA_AIFCompare *myAIFCompare;
415 
416  static const GA_AttributeType *theAttributeType;
417 
418  /// @cond INTERNAL_DOX
419  friend class ga_IndexPairAccess;
420  friend class ga_IndexPairMerge;
421  friend class ga_IndexPairEdit;
422  friend class ga_IndexPairEditDelta;
423  friend class ga_IndexPairEditSnapshot;
424  friend class ga_IndexPairJSON;
425  friend class ga_IndexPairTuple;
426  friend class ga_IndexPairMath;
427  friend class ga_IndexPairInterp;
428  friend class ga_IndexPairCopyData;
429  friend class ga_IndexPairCompare;
430  /// @endcond
431 };
432 
433 #endif
434 
virtual const GA_AIFCopyData * getAIFCopyData() const
Return the attribute's copy interface or NULL.
GLdouble s
Definition: glew.h:1390
A class to manage an ordered array which has fixed offset handles.
Definition: GA_IndexMap.h:63
SYS_AtomicInt32 myEntryCapacity
Definition of a geometry attribute.
Definition: GA_Attribute.h:190
UT_ConcurrentVector< GA_DataArrayTuple * > myData
GLsizeiptr size
Definition: glew.h:1681
GLenum src
Definition: glew.h:2410
Generic Attribute Interface class to get/set data as index pairs.
virtual const GA_AIFEdit * getAIFEdit() const
Return the attribute's edit interface or NULL.
GLuint const GLchar * name
Definition: glew.h:1814
Used to pass options and map offset values during saving.
Definition: GA_SaveMap.h:48
bool getData(GA_Offset ai, int entry, int64 &data, int data_component=0) const
virtual bool matchesStorage(const GA_Attribute *that) const
Class which stores the default values for a GA_Attribute.
Definition: GA_Defaults.h:35
GA_Storage getDataStorage() const
Attribute Interface class to perform numeric operations on attributes.
Definition: GA_AIFMath.h:88
GLuint index
Definition: glew.h:1814
static SYS_FORCE_INLINE const GA_AttributeType & getType()
GLenum GLenum GLenum GLenum GLenum scale
Definition: glew.h:13880
virtual const GA_AIFCompare * getAIFCompare() const
Return the attribute's comparison interface or NULL.
virtual const GA_AIFJSON * getAIFJSON() const
virtual const GA_AIFTuple * getAIFTuple() const
Return the attribute's tuple interface or NULL.
const GA_Defaults & getValueDefaults() const
The merge map keeps track of information when merging details.
Definition: GA_MergeMap.h:53
JSON reader class which handles parsing of JSON or bJSON files.
Definition: UT_JSONParser.h:75
virtual bool setArraySize(GA_Offset size)=0
bool setIndex(const GA_Range &ai, int entry, int32 index)
#define GA_API
Definition: GA_API.h:12
GLdouble l
Definition: glew.h:9122
Class which writes ASCII or binary JSON streams.
Definition: UT_JSONWriter.h:32
const GLdouble * v
Definition: glew.h:1391
SYS_FORCE_INLINE TO_T UTverify_cast(FROM_T from)
Definition: UT_Assert.h:208
virtual void countMemory(UT_MemoryCounter &counter, bool inclusive) const =0
int getDataTupleSize() const
The size of the data tuple.
virtual int64 getMemoryUsage(bool inclusive) const =0
virtual bool matchesStorage(const GA_Attribute *that) const
Definition: GA_Attribute.h:728
bool setData(GA_Offset ai, int entry, int64 data, int data_component=0)
UT_ConcurrentVector< GA_DataArray * > myIndex
virtual void tryCompressAllPages(GA_Offset start_offset=GA_Offset(0), GA_Offset end_offset=GA_INVALID_OFFSET)=0
GA_Defaults myValueDefaults
int tupleGetSize() const
#define GA_INVALID_OFFSET
Definition: GA_Types.h:674
static SYS_FORCE_INLINE const GA_ATIIndexPair * cast(const GA_Attribute *attrib)
GA_Storage myDataStorage
A range of elements in an index-map.
Definition: GA_Range.h:42
GA_Defaults myValueOperationalDefaults
GA_Size GA_Offset
Definition: GA_Types.h:637
long long int64
Definition: SYS_Types.h:111
const GA_Defaults & getValueOperationalDefaults() const
GA_AttributeScope
Definition: GA_Types.h:139
static SYS_FORCE_INLINE GA_ATIIndexPair * cast(GA_Attribute *attrib)
virtual const GA_AIFMerge * getAIFMerge() const
Return the attribute's merge interface or NULL.
bool setData(GA_Offset ai, int entry, fpreal32 data, int data_component=0)
int getEntries() const
virtual void replace(const GA_Attribute &src)=0
Attribute Interface for merging attribute data between details.
Definition: GA_AIFMerge.h:56
GLint GLenum GLsizei GLint GLsizei const void * data
Definition: glew.h:1379
GA_Defaults myIndexDefault
double fpreal64
Definition: SYS_Types.h:196
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
GLubyte GLubyte GLubyte GLubyte w
Definition: glew.h:1890
bool getData(GA_Offset ai, int entry, int32 &data, int data_component=0) const
GLsizei n
Definition: glew.h:4040
ga_IndexPairObjectSets * myObjects
virtual const GA_AIFInterp * getAIFInterp() const
Return the attribute's interpolation interface or NULL.
bool isNan(const float x)
Return true if x is a NaN (Not-A-Number) value.
Definition: Math.h:366
Attribute Interface class to perform comparisons on attributes.
Definition: GA_AIFCompare.h:27
Options during loading.
Definition: GA_LoadMap.h:42
Defragmentation of IndexMaps.
Definition: GA_Defragment.h:45
int int32
Definition: SYS_Types.h:39
virtual void copyNonStorageMetadata(const GA_Attribute *that)
Definition: GA_Attribute.h:742
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
static SYS_FORCE_INLINE const UT_StringHolder & getTypeName()
GLuint start
Definition: glew.h:1253
bool setData(GA_Offset ai, int entry, int32 data, int data_component=0)
const GA_AttributeType & getType() const
Definition: GA_Attribute.h:198
static SYS_FORCE_INLINE bool isType(const GA_Attribute *attrib)
bool setIndex(GA_Offset ai, int entry, int32 index)
GLfloat GLfloat p
Definition: glew.h:16321
double fpreal
Definition: SYS_Types.h:276
GLuint counter
Definition: glew.h:2740
bool getData(GA_Offset ai, int entry, fpreal64 &data, int data_component=0) const
virtual WriteConcurrence getSupportedWriteConcurrence() const
bool setData(GA_Offset ai, int entry, fpreal64 data, int data_component=0)
bool getIndex(GA_Offset ai, int entry, int32 &index) const
virtual const GA_AIFMath * getAIFMath() const
Return the attribute's math interface or NULL.
Concurrent writes to separate pages supported.
Definition: GA_Attribute.h:358
GLuint GLuint GLsizei count
Definition: glew.h:1253
getOption("OpenEXR.storage") storage
Definition: HDK_Image.dox:276
Attribute Interface class to copy attribute data.
Attribute Interface for file I/O.
Definition: GA_AIFJSON.h:39
UT_Lock myEntryGrowthLock
AIF to record changes to attribute values.
Definition: GA_AIFEdit.h:397
virtual void hardenAllPages(GA_Offset start_offset=GA_Offset(0), GA_Offset end_offset=GA_INVALID_OFFSET)=0
virtual void defragment(const GA_Defragment &defrag)=0
Generic Attribute Interface class to access an attribute as a tuple.
Definition: GA_AIFTuple.h:32
bool getData(GA_Offset ai, int entry, fpreal32 &data, int data_component=0) const
float fpreal32
Definition: SYS_Types.h:195
GA_Storage
Definition: GA_Types.h:49
GA_Storage myIndexStorage
virtual const GA_AIFIndexPair * getAIFIndexPair() const
Return the attribute's index pair interface or NULL.
GLintptr offset
Definition: glew.h:1682
virtual void reconstructElementBlock(GA_Offset offset, GA_Offset nelements)