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  ~GA_ATIIndexPair() override;
118 
119  /// Report memory used
120  int64 getMemoryUsage(bool inclusive) const override;
121 
122  void countMemory(UT_MemoryCounter &counter, bool inclusive) const override;
123 
125  GA_Offset nelements) override;
126 
127  /// @{
128  /// Interface for defragmentation
129  void defragment(const GA_Defragment &defrag) override;
130  /// @}
131 
132  /// Adding entries is thread-safe, so we're only subject to GA_DataArray
133  /// limitations.
135  { return WRITE_CONCURRENCE_PAGE; }
136 
137  const GA_AIFCopyData *getAIFCopyData() const override
138  { return myAIFCopyData; }
139  const GA_AIFIndexPair *getAIFIndexPair() const override
140  { return myAIFPair; }
141  const GA_AIFMerge *getAIFMerge() const override
142  { return myAIFMerge; }
143  const GA_AIFEdit *getAIFEdit() const override
144  { return myAIFEdit; }
145  const GA_AIFTuple *getAIFTuple() const override
146  { return myAIFTuple; }
147  const GA_AIFMath *getAIFMath() const override
148  { return myAIFMath; }
149  const GA_AIFInterp *getAIFInterp() const override
150  { return myAIFInterp; }
151  const GA_AIFCompare *getAIFCompare() const override
152  { return myAIFCompare; }
153 
154  /// @section JSON-GA_ATIIndexPair JSON Schema: GA_ATIIndexPair
155  /// @code
156  /// {
157  /// "name" : "GA_ATIIndexPair",
158  /// "description" : "An tuple array of indexed strings",
159  /// "type" : "orderedmap",
160  /// "properties": {
161  /// "idefault": {
162  /// "type" : {"$ref":"GA_Defaults"},
163  /// "description" : "Defaults for index values",
164  /// "optional" : true,
165  /// },
166  /// "vdefault": {
167  /// "type" : {"$ref":"GA_Defaults"},
168  /// "description" : "Defaults for values",
169  /// "optional" : true,
170  /// },
171  /// "entries": {
172  /// "type" : "integer",
173  /// "description" : "Number of entries for index/values tuples",
174  /// },
175  /// "istorage": {
176  /// "type" : "string",
177  /// "description" : "Storage type for index values",
178  /// "enum" : [ "int8", "int16", "int32", "int64" ],
179  /// },
180  /// "vstorage": {
181  /// "type" : "string",
182  /// "description" : "Storage type for values",
183  /// "enum" : [ "fpreal16", "fpreal32", "fpreal64" ],
184  /// },
185  /// "index": {
186  /// "type" : {"$ref":"GA_DataArrayTuple"},
187  /// "description" : "Index values.",
188  /// },
189  /// "value": {
190  /// "type" : {"$ref":"GA_DataArrayTuple"},
191  /// "description" : "Weight values.",
192  /// },
193  /// },
194  /// }
195  /// @endcode
196  /// @see @ref JSON_FileFormat
197  const GA_AIFJSON *getAIFJSON() const override { return myAIFJSON; }
198 
199  int getEntries() const { return myEntryCapacity.relaxedLoad(); }
200  /// setEntries() is NOT thread-safe. To concurrently grow the entry
201  /// capacity, use growEntriesTo(size, true).
202  bool setEntries(int size);
203  /// Use growEntriesTo() instead of setEntries() to ensure that the entry
204  /// capacity never shrinks. This is necessary for concurrent growing of
205  /// the entry capacity to properly handle the situation where one thread
206  /// tries to grow the entries less than another. Set the concurrent arg
207  /// if more than one thread can call this method concurrently.
208  bool growEntriesTo(int size, bool concurrent = false);
209 
210  bool setDataStorage(GA_Storage storage);
211  bool setIndexStorage(GA_Storage storage);
212 
213  const GA_Defaults &getValueDefaults() const { return myValueDefaults; }
215  { return myValueOperationalDefaults; }
216 
217  /// The size of the data tuple
218  int getDataTupleSize() const { return myTupleSize; }
219 
220  /// Grow or shrink the array size
221  bool setArraySize(GA_Offset new_size) override;
222 
223  /// Try to compress data pages
224  void tryCompressAllPages(
225  GA_Offset start_offset = GA_Offset(0),
226  GA_Offset end_offset = GA_INVALID_OFFSET) override;
227 
228  /// Harden data pages
229  void hardenAllPages(
230  GA_Offset start_offset = GA_Offset(0),
231  GA_Offset end_offset = GA_INVALID_OFFSET) override;
232 
233  /// Returns true iff that is an attribute whose content can be copied
234  /// from this without any type conversions. This is important to
235  /// avoid reallocation of an attribute if its storage type,
236  /// including tuple size, matches the source attribute exactly.
237  bool matchesStorage(const GA_Attribute *that) const override
238  {
239  if (!GA_Attribute::matchesStorage(that))
240  return false;
241  const GA_ATIIndexPair *thatn = UTverify_cast<const GA_ATIIndexPair *>(that);
242  if (getDataStorage() != thatn->getDataStorage())
243  return false;
244  if (myIndexStorage != thatn->myIndexStorage)
245  return false;
246  if (getDataTupleSize() != thatn->getDataTupleSize())
247  return false;
248  if (getEntries() != thatn->getEntries())
249  return false;
250  return true;
251  }
252  /// In the case that we're copying from an attribute whose storage
253  /// type matches this exactly, this function copies the metadata
254  /// not associated with the storage, e.g. myOptions,
255  /// *excluding* the name and the data ID.
256  void copyNonStorageMetadata(const GA_Attribute *that) override;
257 
258  /// This replaces the entirety of this attribute's content and non-
259  /// storage metadata (except the name) with that of the src attribute.
260  /// matchesStorage(src) should already return true.
261  /// This is primarily for use by GA_AttributeSet::replace().
262  /// NOTE: The internal content sizes may not match exactly if the
263  /// attribute type may overallocate, but the sizes should be such
264  /// that any real data will fit in the destination, so be careful
265  /// and deal with the myTailInitialize flag appropriately if
266  /// any extra elements aren't equal to the default.
267  void replace(const GA_Attribute &src) override;
268 
269 protected:
270  int getObjectSetCount() const;
271  void setObjectSetCount(int n);
272 
273  const GA_AIFIndexPairObjects *getObjectsConst(int s = 0) const;
274  GA_AIFIndexPairObjects *getObjects(int s = 0);
275 
276  bool hasSameProperties(const GA_ATIIndexPair *sattrib) const;
277  bool copyProperties(const GA_ATIIndexPair *sattrib);
278  bool mergeObjectValues(const GA_ATIIndexPair *sattrib, UT_IntArray &new_indices);
279 
280  bool setTupleSize(int size);
281  GA_Storage getDataStorage() const { return myDataStorage; }
282 #if GA_INDEX_PAIR_USE_PAGE_ARRAY
283  bool getIndex(GA_Offset ai, int entry, int32 &index) const { index = myIndex[entry]->get<int32>(ai); return true; }
284  bool getData(GA_Offset ai, int entry, fpreal32 &data, int data_component = 0) const { data = myData[entry]->get<fpreal32>(ai, data_component); return true; }
285  bool getData(GA_Offset ai, int entry, fpreal64 &data, int data_component = 0) const { data = myData[entry]->get<fpreal64>(ai, data_component); return true; }
286  bool getData(GA_Offset ai, int entry, int32 &data, int data_component = 0) const { data = myData[entry]->get<int32>(ai, data_component); return true; }
287  bool getData(GA_Offset ai, int entry, int64 &data, int data_component = 0) const { data = myData[entry]->get<int64>(ai, data_component); return true; }
288  bool setIndex(GA_Offset ai, int entry, int32 index) { myIndex[entry]->set(ai, index); return true; }
289  bool setIndex(const GA_Range &ai, int entry, int32 index) { myIndex[entry]->setConstant(ai, index); return true; }
290  bool setData(GA_Offset ai, int entry, fpreal32 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
291  bool setData(GA_Offset ai, int entry, fpreal64 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
292  bool setData(GA_Offset ai, int entry, int32 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
293  bool setData(GA_Offset ai, int entry, int64 data, int data_component = 0) { myData[entry]->set(ai, data_component, data); return true; }
294 #else
295  bool getIndex(GA_Offset ai, int entry, int32 &index) const { myIndex[entry]->get(ai, index); return true; }
296  bool getData(GA_Offset ai, int entry, fpreal32 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
297  bool getData(GA_Offset ai, int entry, fpreal64 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
298  bool getData(GA_Offset ai, int entry, int32 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
299  bool getData(GA_Offset ai, int entry, int64 &data, int data_component = 0) const { myData[entry]->getData(data_component)->get(ai, data); return true; }
300  bool setIndex(GA_Offset ai, int entry, int32 index) { myIndex[entry]->set(ai, index); return true; }
301  bool setIndex(const GA_Range &ai, int entry, int32 index) { myIndex[entry]->set(ai, index); return true; }
302  bool setData(GA_Offset ai, int entry, fpreal32 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
303  bool setData(GA_Offset ai, int entry, fpreal64 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
304  bool setData(GA_Offset ai, int entry, int32 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
305  bool setData(GA_Offset ai, int entry, int64 data, int data_component = 0) { myData[entry]->getData(data_component)->set(ai, data); return true; }
306 #endif
307 
308  bool removeIndex(int index);
309  void invalidateTrailingEntries(GA_Offset ai, int start_entry);
310  void invalidateTrailingEntries(const GA_Range &ai, int start_entry);
311 
312  /// @{
313  /// Copy Data AIF
314  bool copyData(GA_Offset di, const GA_ATIIndexPair &src,
315  GA_Offset si);
316  bool copyData(const GA_Range &di, const GA_ATIIndexPair &src,
317  const GA_Range &si);
318  /// @}
319 
320  /// @{
321  /// Compare AIF
322  bool isAlmostEqual(GA_Offset di, const GA_ATIIndexPair &src,
323  GA_Offset si, int ulps) const;
324  bool isAlmostEqual(const GA_Range &di, const GA_ATIIndexPair &src,
325  const GA_Range &si, int ulps) const;
326  /// @}
327 
328  /// @{ GA_AIFMerge
329  /// Base class implementation of GA_AIFMerge::destroyDestination()
330  void mergeDestroyDestination(const GA_MergeMap &map,
331  GA_Attribute *dattrib) const;
332  /// Base class implementation of GA_AIFMerge::addDestination()
333  GA_Attribute *mergeAddDestination(const GA_MergeMap &map,
334  GA_Attribute *dattrib) const;
335  /// Base class implementation of GA_AIFMerge::copyArray()
336  bool mergeAppendData(const GA_MergeMap &map,
337  const GA_Attribute *sattrib);
338  /// @}
339 
340  /// @{
341  /// GA_AIFTuple
342  /// The AIFTuple has a tuple with 2*getEntries() entries. The entries are
343  /// interleaved with ( index0, value0, index1, value1, ...)
344  int tupleGetSize() const
345  { return (myTupleSize + 1) * getEntries(); }
346  bool tupleSetSize(int size);
347  GA_Storage tupleGetStorage() const;
348  bool tupleSetStorage(GA_Storage storage);
349  bool isNan(GA_Offset ai) const;
350  bool isNan(const GA_Range &ai) const;
351  template <typename T> inline bool
352  tupleGet(GA_Offset ai, T &v, int index) const;
353  template <typename T> inline bool
354  tupleGet(GA_Offset ai, T *v, int count, int start) const;
355  template <typename T> inline bool
356  tupleSet(GA_Offset ai, T v, int vi);
357  template <typename T> inline bool
358  tupleSet(GA_Offset ai, const T *v, int count, int start);
359  template <typename T> inline bool
360  tupleSet(const GA_Range &di, T v, int vi);
361  template <typename T> inline bool
362  tupleSet(const GA_Range &di, const T *v, int count, int start);
363  inline bool tupleSet(GA_Offset di, const GA_ATIIndexPair &s,
364  GA_Offset si, int component);
365  inline bool tupleSet(const GA_Range &di, const GA_ATIIndexPair &s,
366  const GA_Range &si, int component);
367  /// @}
368 
369 protected:
370  // Protected Data
371  ga_IndexPairObjectSets *myObjects;
372 #if GA_INDEX_PAIR_USE_PAGE_ARRAY
373  UT_ConcurrentVector<GA_PageArray<void,1> *> myIndex;
374  UT_ConcurrentVector<GA_PageArray<> *> myData;
375 #else
376  UT_ConcurrentVector<GA_DataArray *> myIndex;
377  UT_ConcurrentVector<GA_DataArrayTuple *> myData;
378 #endif
379 
380  /// The tuple size of each GA_PageArray in myData.
381  /// At the moment, this is normally 1, but is 3 for the CAPTURE_WIRE
382  /// (wireCapture) case. The other cases are CAPTURE_BONE (boneCapture),
383  /// CAPTURE_META (metaCapture), CAPTURE_CLOTH (clothCapture), and
384  /// CAPTURE_MUSCLE (muscleCapture).
386 
394 
395  /// Scale all weights by the given amount (used in weighted sums)
396  void interpScale(GA_Offset di, fpreal scale);
397 
398 private:
399  GA_Attribute *doClone(const GA_IndexMap &index_map,
400  const UT_StringHolder &name) const override;
401 
402  /// @{ GA_AIFJSON
403  bool jsonSave(UT_JSONWriter &w, const GA_SaveMap &s) const;
404  bool jsonLoad(UT_JSONParser &p, const GA_LoadMap &l);
405  /// @}
406 
407  static GA_AIFIndexPair *myAIFPair;
408  static GA_AIFMerge *myAIFMerge;
409  static GA_AIFCopyData *myAIFCopyData;
410  static GA_AIFEdit *myAIFEdit;
411  static GA_AIFJSON *myAIFJSON;
412  static GA_AIFTuple *myAIFTuple;
413  static GA_AIFMath *myAIFMath;
414  static GA_AIFInterp *myAIFInterp;
415  static GA_AIFCompare *myAIFCompare;
416 
417  static const GA_AttributeType *theAttributeType;
418 
419  /// @cond INTERNAL_DOX
420  friend class ga_IndexPairAccess;
421  friend class ga_IndexPairMerge;
422  friend class ga_IndexPairEdit;
423  friend class ga_IndexPairEditDelta;
424  friend class ga_IndexPairEditSnapshot;
425  friend class ga_IndexPairJSON;
426  friend class ga_IndexPairTuple;
427  friend class ga_IndexPairMath;
428  friend class ga_IndexPairInterp;
429  friend class ga_IndexPairCopyData;
430  friend class ga_IndexPairCompare;
431  /// @endcond
432 };
433 
434 #endif
435 
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:196
UT_ConcurrentVector< GA_DataArrayTuple * > myData
GLsizeiptr size
Definition: glew.h:1681
GLenum src
Definition: glew.h:2410
int int32
Definition: SYS_Types.h:39
Generic Attribute Interface class to get/set data as index pairs.
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
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
const GA_Defaults & getValueDefaults() const
The merge map keeps track of information when merging details.
Definition: GA_MergeMap.h:53
virtual void reconstructElementBlock(GA_Offset offset, GA_Offset nelements)=0
const GA_AIFIndexPair * getAIFIndexPair() const override
Return the attribute's index pair interface or NULL.
JSON reader class which handles parsing of JSON or bJSON files.
Definition: UT_JSONParser.h:76
virtual bool setArraySize(GA_Offset size)=0
const GA_AIFTuple * getAIFTuple() const override
Return the attribute's tuple interface or NULL.
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:34
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:738
bool setData(GA_Offset ai, int entry, int64 data, int data_component=0)
UT_ConcurrentVector< GA_DataArray * > myIndex
float fpreal32
Definition: SYS_Types.h:200
virtual void tryCompressAllPages(GA_Offset start_offset=GA_Offset(0), GA_Offset end_offset=GA_INVALID_OFFSET)=0
GA_Defaults myValueDefaults
const GA_AIFEdit * getAIFEdit() const override
Return the attribute's edit interface or NULL.
int tupleGetSize() const
const GA_AIFJSON * getAIFJSON() const override
#define GA_INVALID_OFFSET
Definition: GA_Types.h:676
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
double fpreal64
Definition: SYS_Types.h:201
GA_Size GA_Offset
Definition: GA_Types.h:639
const GA_Defaults & getValueOperationalDefaults() const
GA_AttributeScope
Definition: GA_Types.h:141
static SYS_FORCE_INLINE GA_ATIIndexPair * cast(GA_Attribute *attrib)
const GA_AIFMerge * getAIFMerge() const override
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
#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
bool isNan(const float x)
Return true if x is a NaN (Not-A-Number) value.
Definition: Math.h:386
long long int64
Definition: SYS_Types.h:116
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
const GA_AIFInterp * getAIFInterp() const override
Return the attribute's interpolation interface or NULL.
WriteConcurrence getSupportedWriteConcurrence() const override
virtual void copyNonStorageMetadata(const GA_Attribute *that)
Definition: GA_Attribute.h:752
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)
bool matchesStorage(const GA_Attribute *that) const override
const GA_AttributeType & getType() const
Definition: GA_Attribute.h:204
const GA_AIFMath * getAIFMath() const override
Return the attribute's math interface or NULL.
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
const GA_AIFCopyData * getAIFCopyData() const override
Return the attribute's copy interface or NULL.
GLuint counter
Definition: glew.h:2740
fpreal64 fpreal
Definition: SYS_Types.h:277
bool getData(GA_Offset ai, int entry, fpreal64 &data, int data_component=0) const
bool setData(GA_Offset ai, int entry, fpreal64 data, int data_component=0)
bool getIndex(GA_Offset ai, int entry, int32 &index) const
Concurrent writes to separate pages supported.
Definition: GA_Attribute.h:364
GLuint GLuint GLsizei count
Definition: glew.h:1253
const GA_AIFCompare * getAIFCompare() const override
Return the attribute's comparison interface or NULL.
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
GA_Storage
Definition: GA_Types.h:49
GA_Storage myIndexStorage
GLintptr offset
Definition: glew.h:1682