HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GA_ATINumeric.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_ATINumeric.h (GA Library, C++)
7  *
8  * COMMENTS: Numeric ATI (Attribute Type Implementation)
9  */
10 
11 #pragma once
12 
13 #ifndef __GA_ATINumeric
14 #define __GA_ATINumeric
15 
16 #include "GA_API.h"
17 #include "GA_Attribute.h"
18 #include "GA_PageArray.h"
19 #include "GA_Defaults.h"
20 #include "GA_AttributeType.h" // for GA_AttributeType
21 #include "GA_Range.h" // for GA_Range
22 #include "GA_Types.h" // for GA_Offset, etc
23 
24 #include <UT/UT_Assert.h>
25 #include <UT/UT_StringHolder.h>
26 #include <SYS/SYS_Inline.h> // for SYS_FORCE_INLINE
27 #include <SYS/SYS_Types.h> // for fpreal32, fpreal64, fpreal, etc
28 
29 
30 class GA_AIFCompare;
31 class GA_AIFCopyData;
32 class GA_AIFDelta;
33 class GA_AIFEdit;
34 class GA_AIFInterp;
35 class GA_AIFJSON;
36 class GA_AIFMath;
37 class GA_AIFMerge;
38 class GA_AIFTuple;
39 class GA_Defragment;
40 class GA_IndexMap;
41 class GA_LoadMap;
42 class GA_MergeMap;
43 class GA_SaveMap;
44 class UT_JSONParser;
45 class UT_JSONWriter;
46 class UT_MemoryCounter;
47 
48 
50 {
51 public:
52  static void registerType();
54  static const UT_StringHolder &getTypeName()
55  { return theAttributeType->getTypeName(); }
57  static const GA_AttributeType &getType() { return *theAttributeType; }
58 
60  static bool isType(const GA_Attribute *attrib)
61  {
62  return attrib && &attrib->getType() == theAttributeType;
63  }
65  static GA_ATINumeric *cast(GA_Attribute *attrib)
66  {
67  if (attrib && &attrib->getType() == theAttributeType)
68  return static_cast<GA_ATINumeric *>(attrib);
69  return nullptr;
70  }
72  static const GA_ATINumeric *cast(const GA_Attribute *attrib)
73  {
74  if (attrib && &attrib->getType() == theAttributeType)
75  return static_cast<const GA_ATINumeric *>(attrib);
76  return nullptr;
77  }
78 
80  const GA_IndexMap &index_map,
81  GA_AttributeScope scope,
82  const UT_StringHolder &name,
83  GA_Storage store,
84  int tuple_size,
85  const GA_Defaults &defaults);
86  ~GA_ATINumeric() override;
87 
88  int64 getMemoryUsage(bool inclusive) const override;
89 
90  void countMemory(UT_MemoryCounter &counter, bool inclusive) const override;
91 
92  /// @{
93  /// Interface for defragmentation
94  void defragment(const GA_Defragment &defrag) override;
95  /// @}
96 
97  void reconstructElementBlock(GA_Offset offset, GA_Offset nelements) override;
98 
99  /// Data is paged, so concurrent writes to separate pages supported.
101  { return WRITE_CONCURRENCE_PAGE; }
102 
103  const GA_AIFCopyData *getAIFCopyData() const override
104  { return myAIFCopyData; }
105  const GA_AIFDelta *getAIFDelta() const override
106  { return myAIFDelta; }
107  const GA_AIFEdit *getAIFEdit() const override
108  { return myAIFEdit; }
109  const GA_AIFTuple *getAIFTuple() const override
110  { return myAIFTuple; }
111  const GA_AIFMath *getAIFMath() const override
112  { return myDoMath ? myAIFMath:myAIFNoMath; }
113  const GA_AIFMerge *getAIFMerge() const override
114  { return myAIFMerge; }
115  const GA_AIFInterp *getAIFInterp() const override
116  { return myAIFInterp; }
117  const GA_AIFCompare *getAIFCompare() const override
118  { return myAIFCompare; }
119 
120  /// @section JSON-GA_ATINumeric JSON Schema: GA_ATINumeric
121  /// @code
122  /// {
123  /// "name" : "GA_ATINumeric",
124  /// "description" : "An tuple array of numeric data",
125  /// "type" : "orderedmap",
126  /// "properties": {
127  /// "size": {
128  /// "type" : "integer",
129  /// "minimum" : 1,
130  /// "description" : "Tuple size",
131  /// },
132  /// "storage": {
133  /// "type" : "string",
134  /// "description" : "Tuple storage",
135  /// "enum" : [ "uint8","int8","int16","int32","int64",
136  /// "fpreal16", "fpreal32", "fpreal64" ],
137  /// },
138  /// "defaults": {
139  /// "type" : { "$ref" : "GA_Defaults" }
140  /// "description" : "Default values",
141  /// },
142  /// "values": {
143  /// "type" : {"$ref":"GA_DataArrayTuple"},
144  /// "description" : "Numeric values.",
145  /// },
146  /// },
147  /// }
148  /// @endcode
149  /// @see @ref JSON_FileFormat
150  const GA_AIFJSON *getAIFJSON() const override { return myAIFJSON; }
151 
152  /// Called during JSON load
153  bool jsonLoad(UT_JSONParser &p,
154  const GA_LoadMap &map,
155  const GA_Defaults &defs,
156  int tuple_size,
158 
159  const GA_Defaults &getDefaults() const { return myDefaults; }
160 
161  int getTupleSize() const { return myData.getTupleSize(); }
162  GA_Storage getStorage() const { return myData.getStorage(); }
163 
164  bool setTupleSize(int size);
165  bool setStorage(GA_Storage storage);
166 
167  /// Checks if an attribute should be treated as a texture coordinate attribute.
168  /// Ideally, we could rely on the type info being GA_TYPE_TEXTURE_COORD,
169  /// but old files don't have this, and various importers don't set this.
170  /// If a float[3] (optionnally float[2]) attribute's name starts with "uv"
171  /// and is followed by zero or more digits (and nothing else), it's probably
172  /// safe to assume that it should be treated as a texture attribute.
173  bool shouldInterpretAsTexCoord(bool allow_float2=false) const
174  {
175  if (getTupleSize() != 3 && (!allow_float2 || getTupleSize() != 2))
176  return false;
177 
178  // If it's not a float type, it's probably not a texture coordinate,
179  // even if its typeinfo says otherwise.
180  GA_Storage storage = getStorage();
181  if (storage != GA_STORE_REAL16 && storage != GA_STORE_REAL32 && storage != GA_STORE_REAL64)
182  return false;
183 
184  // If it's marked as texture coord, go with that.
185  // If it's not that and not void, it's not texture coord.
186  GA_TypeInfo typeinfo = getTypeInfo();
187  if (typeinfo != GA_TYPE_VOID)
188  return (typeinfo == GA_TYPE_TEXTURE_COORD);
189 
190  // Void type info; check name next.
191  const char *name = getName().c_str();
192  if (name[0] != 'u' || name[1] != 'v')
193  return false;
194 
195  // Name starts with "uv". Check if everything else is digits.
196  for (name += 2; *name; ++name)
197  {
198  if (*name < '0' || *name > '9')
199  return false;
200  }
201  return true;
202  }
203 
204  /// Some types, especially integers, may not want to be lerped
205  bool isNonArithmetic() const { return !myDoMath; }
206 
207  /// Debug code
208  bool debugValidateArrayCapacity(GA_Offset sz) const override;
209 
210  /// Grow or shrink the array size
211  bool setArraySize(GA_Offset new_size) override;
212 
213  /// Try to compress data pages
214  void tryCompressAllPages(
215  GA_Offset start_offset = GA_Offset(0),
216  GA_Offset end_offset = GA_INVALID_OFFSET) override;
217  /// Harden data pages
218  void hardenAllPages(
219  GA_Offset start_offset = GA_Offset(0),
220  GA_Offset end_offset = GA_INVALID_OFFSET) override;
221 
222  /// Returns true iff that is an attribute whose content can be copied
223  /// from this without any type conversions. This is important to
224  /// avoid reallocation of an attribute if its storage type,
225  /// including tuple size, matches the source attribute exactly.
226  bool matchesStorage(const GA_Attribute *that) const override
227  {
228  if (!GA_Attribute::matchesStorage(that))
229  return false;
230  const GA_ATINumeric *thatn = UTverify_cast<const GA_ATINumeric *>(that);
231  if (getStorage() != thatn->getStorage())
232  return false;
233  if (getTupleSize() != thatn->getTupleSize())
234  return false;
235  return true;
236  }
237  /// In the case that we're copying from an attribute whose storage
238  /// type matches this exactly, this function copies the metadata
239  /// not associated with the storage, e.g. myOptions,
240  /// *excluding* the name and the data ID.
241  void copyNonStorageMetadata(const GA_Attribute *that) override
242  {
244  const GA_ATINumeric *thatn = UTverify_cast<const GA_ATINumeric *>(that);
245  myDoMath = thatn->myDoMath;
246  myDefaults = thatn->myDefaults;
247  }
248 
249  /// This replaces the entirety of this attribute's content and non-
250  /// storage metadata (except the name) with that of the src attribute.
251  /// matchesStorage(src) should already return true.
252  /// This is primarily for use by GA_AttributeSet::replace().
253  /// NOTE: The internal content sizes may not match exactly if the
254  /// attribute type may overallocate, but the sizes should be such
255  /// that any real data will fit in the destination, so be careful
256  /// and deal with the myTailInitialize flag appropriately if
257  /// any extra elements aren't equal to the default.
258  void replace(const GA_Attribute &src) override;
259 
260  /// Copy attribute values for a single element.
261  /// @{
262  bool copy(GA_Offset desti, GA_Offset srci) override final
263  {
264  return tupleSet(desti, *this, srci, -1);
265  }
266  bool copy(GA_Offset desti,
267  const GA_Attribute &src, GA_Offset srci) override final
268  {
269  if (!GA_ATINumeric::isType(&src))
270  return false;
271  return tupleSet(desti, *UTverify_cast<const GA_ATINumeric*>(&src), srci, -1);
272  }
273  bool copy(GA_Offset desti, const GA_ATINumeric &src, GA_Offset srci)
274  {
275  return tupleSet(desti, src, srci, -1);
276  }
277  /// @}
278 
279  /// Copy attribute values for a range of elements.
280  /// WARNING: These do not support overlapping ranges within a single attribute!
281  /// @{
282  bool copy(const GA_Range &destrange,
283  const GA_Range &srcrange) override final
284  {
285  return tupleSet(destrange, *this, srcrange, -1);
286  }
287  bool copy(const GA_Range &destrange,
288  const GA_Attribute &src, const GA_Range &srcrange) override final
289  {
290  if (!GA_ATINumeric::isType(&src))
291  return false;
292  return tupleSet(destrange, *UTverify_cast<const GA_ATINumeric*>(&src), srcrange, -1);
293  }
294  bool copy(const GA_Range &destrange, const GA_ATINumeric &src, const GA_Range &srcrange)
295  {
296  return tupleSet(destrange, src, srcrange, -1);
297  }
298  /// @}
299 
300  /// Assign all elements of a range from a single attribute value.
301  /// @{
302  bool fill(const GA_Range &destrange, GA_Offset srci) override final;
303  bool fill(const GA_Range &destrange,
304  const GA_Attribute &src, GA_Offset srci) override final;
305  bool fill(const GA_Range &destrange, const GA_ATINumeric &src, GA_Offset srci);
306  /// @}
307 
308  typedef GA_PageArray<void, -1, true, false> DataType;
309 
310  /// @{
311  /// Provide access to data
312  const DataType &getData() const { return myData; }
313  DataType &getData() { return myData; }
314  /// @}
315 
316  /// Returns true iff the specified page is constant-compressed,
317  /// where a single value is stored to represent GA_PAGE_SIZE
318  /// values in the page, (or possibly fewer if only one page).
320  {
321  return myData.isPageConstant(pagenum);
322  }
323  /// Sets all components of all elements of the specified page to
324  /// the given values.
325  /// NOTE: The length of values must be equal to the tuple size.
326  template<typename SRC_DATA_T>
327  SYS_FORCE_INLINE void setPageConstant(GA_PageNum pagenum, const SRC_DATA_T *values)
328  {
329  myData.setPageConstant(pagenum, values);
330  }
331 
332 protected:
335  bool myDoMath; // Off for non-arithmetic integer
336 
342  static const GA_AIFMath *myAIFNoMath;
344  static GA_AIFInterp *myAIFInterp;
347 
349 
350 private:
351  void updateIntegerTypeInfo();
352 
353  GA_Attribute *doClone(const GA_IndexMap &index_map,
354  const UT_StringHolder &name
355  ) const override;
356 
357  /// @{ GA_AIFTuple
358  template <typename T> inline bool
359  tupleGet(GA_Offset di, T &v, int vi) const;
360  template <typename T> inline bool
361  tupleGet(GA_Offset di, T *v, int count, int start) const;
362 
363  template <typename T> inline bool
364  tupleSet(GA_Offset di, T v, int vi);
365  template <typename T> inline bool
366  tupleSet(GA_Offset di, const T *v, int count, int start);
367  template <typename T> inline bool
368  tupleSet(const GA_Range &di, T v, int vi);
369  template <typename T> inline bool
370  tupleSet(const GA_Range &di, const T *v, int count, int start);
371  bool tupleSet(GA_Offset di, const GA_ATINumeric &s,
372  GA_Offset si, int component);
373  /// WARNING: These do not support overlapping ranges within a single attribute!
374  bool tupleSet(const GA_Range &di, const GA_ATINumeric &s,
375  const GA_Range &si, int component);
376 
377  template <typename T> inline bool
378  makeConstant(T v, int vi);
379  template <typename T> inline bool
380  makeConstant(const T *v, int count, int start);
381 
382  bool isNan(GA_Offset ai) const;
383  bool isNan(const GA_Range &ai) const;
384  /// @}
385 
386  /// @{ GA_AIFInterp
387  bool interpLerp(GA_Offset di,
388  const GA_ATINumeric &a, GA_Offset ai,
389  const GA_ATINumeric &b, GA_Offset bi,
390  fpreal t);
391  bool interpLerp(const GA_Range &di,
392  const GA_ATINumeric &a, const GA_Range &ai,
393  const GA_ATINumeric &b, const GA_Range &bi,
394  fpreal t);
395  bool interpSmooth(GA_Offset di, fpreal min, fpreal max,
396  const GA_ATINumeric &a, GA_Offset ai);
397  bool interpSmooth(const GA_Range &di, fpreal min, fpreal max,
398  const GA_ATINumeric &a, const GA_Range &ai);
399  bool interpFit(GA_Offset di, const GA_ATINumeric &a, GA_Offset ai,
400  fpreal omin, fpreal omax,
401  fpreal nmin, fpreal nmax);
402  bool interpFit(const GA_Range &di,
403  const GA_ATINumeric &a, const GA_Range &ai,
404  fpreal omin, fpreal omax,
405  fpreal nmin, fpreal nmax);
406  /// @}
407 
408  /// @{ GA_AIFMerge
409  void mergeDestroyDestination(const GA_MergeMap &map,
410  GA_Attribute *dattrib) const;
411  GA_Attribute *mergeAddDestination(const GA_MergeMap &map,
412  GA_Attribute *dattrib) const;
413  void mergeGrowArray(const GA_MergeMap &map,
414  const GA_ATINumeric &s);
415  bool mergeAppendData(const GA_MergeMap &map,
416  const GA_Attribute *sattrib);
417  /// @}
418 
419  /// @{ GA_AIFJSON
420  /// Save data to a JSON stream.
421  bool jsonSave(UT_JSONWriter &w, const GA_SaveMap &s) const;
422  /// @}
423 
424  /// @cond INTERNAL_DOX
425  friend class ga_NumericCopyData;
426  friend class ga_NumericDelta;
427  friend class ga_NumericEdit;
428  template <typename T> friend class ga_NumericEditDelta;
429  template <typename T> friend class ga_NumericEditSnapshot;
430  friend class ga_NumericInterp;
431  friend class ga_NumericJSON;
432  friend class ga_NumericMarshal;
433  friend class ga_NumericMath;
434  friend class ga_NumericMerge;
435  friend class ga_NumericTuple;
436  friend class ga_NumericCompare;
437 
438  template <typename T> friend class binderScalar;
439  template <typename T> friend class binderVector;
440  template <typename T, typename TB> friend class binderPage;
441  /// @endcond
442 };
443 
445 
447 
448 #endif
449 
GLdouble s
Definition: glew.h:1390
A class to manage an ordered array which has fixed offset handles.
Definition: GA_IndexMap.h:63
vint4 max(const vint4 &a, const vint4 &b)
Definition: simd.h:4703
Definition of a geometry attribute.
Definition: GA_Attribute.h:196
Data has no numeric representation.
Definition: GA_Types.h:102
bool isNonArithmetic() const
Some types, especially integers, may not want to be lerped.
GLsizeiptr size
Definition: glew.h:1681
GLenum src
Definition: glew.h:2410
GA_PageArray< void,-1, true, false > DataType
UT_UniquePtr< const GA_ATINumeric > GA_ConstATINumericUPtr
GLuint const GLchar * name
Definition: glew.h:1814
Used to pass options and map offset values during saving.
Definition: GA_SaveMap.h:48
const GA_AIFCompare * getAIFCompare() const override
Return the attribute's comparison interface or NULL.
void copyNonStorageMetadata(const GA_Attribute *that) override
const GA_AIFInterp * getAIFInterp() const override
Return the attribute's interpolation interface or NULL.
static SYS_FORCE_INLINE bool isType(const GA_Attribute *attrib)
Definition: GA_ATINumeric.h:60
Class which stores the default values for a GA_Attribute.
Definition: GA_Defaults.h:35
Attribute Interface class to perform numeric operations on attributes.
Definition: GA_AIFMath.h:88
int getTupleSize() const
Size of the AIFTuple, if it exists. If it doesn't, 1.
const DataType & getData() const
int getTupleSize() const
GLboolean GLboolean GLboolean GLboolean a
Definition: glew.h:9477
GLint GLsizei const GLuint64 * values
Definition: glew.h:3612
const GA_AIFMerge * getAIFMerge() const override
Return the attribute's merge interface or NULL.
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
static SYS_FORCE_INLINE const UT_StringHolder & getTypeName()
Definition: GA_ATINumeric.h:54
GA_Defaults myDefaults
JSON reader class which handles parsing of JSON or bJSON files.
Definition: UT_JSONParser.h:76
virtual bool setArraySize(GA_Offset size)=0
#define GA_API
Definition: GA_API.h:12
DataType myData
Class which writes ASCII or binary JSON streams.
Definition: UT_JSONWriter.h:34
const GLdouble * v
Definition: glew.h:1391
static GA_AIFCompare * myAIFCompare
SYS_FORCE_INLINE TO_T UTverify_cast(FROM_T from)
Definition: UT_Assert.h:208
static GA_AIFMath * myAIFMath
virtual void countMemory(UT_MemoryCounter &counter, bool inclusive) const =0
virtual int64 getMemoryUsage(bool inclusive) const =0
virtual bool matchesStorage(const GA_Attribute *that) const
Definition: GA_Attribute.h:738
bool copy(const GA_Range &destrange, const GA_Range &srcrange) overridefinal
const UT_StringHolder & getName() const
Definition: GA_Attribute.h:280
virtual void tryCompressAllPages(GA_Offset start_offset=GA_Offset(0), GA_Offset end_offset=GA_INVALID_OFFSET)=0
#define GA_INVALID_OFFSET
Definition: GA_Types.h:676
A range of elements in an index-map.
Definition: GA_Range.h:42
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:33
GA_Size GA_Offset
Definition: GA_Types.h:639
virtual bool fill(const GA_Range &destrange, GA_Offset srci)
Definition: GA_Attribute.h:808
const GA_AIFEdit * getAIFEdit() const override
Return the attribute's edit interface or NULL.
GA_AttributeScope
Definition: GA_Types.h:141
static const GA_AttributeType * theAttributeType
const GA_AIFTuple * getAIFTuple() const override
Return the attribute's tuple interface or NULL.
static GA_AIFTuple * myAIFTuple
virtual void replace(const GA_Attribute &src)=0
static GA_AIFInterp * myAIFInterp
bool copy(GA_Offset desti, GA_Offset srci) overridefinal
Attribute Interface for merging attribute data between details.
Definition: GA_AIFMerge.h:56
const GA_AIFCopyData * getAIFCopyData() const override
Return the attribute's copy interface or NULL.
static SYS_FORCE_INLINE GA_ATINumeric * cast(GA_Attribute *attrib)
Definition: GA_ATINumeric.h:65
bool copy(const GA_Range &destrange, const GA_Attribute &src, const GA_Range &srcrange) overridefinal
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
GLubyte GLubyte GLubyte GLubyte w
Definition: glew.h:1890
void
Definition: png.h:1083
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
SYS_FORCE_INLINE const char * c_str() const
Defragmentation of IndexMaps.
Definition: GA_Defragment.h:45
static GA_AIFEdit * myAIFEdit
virtual void copyNonStorageMetadata(const GA_Attribute *that)
Definition: GA_Attribute.h:752
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
bool matchesStorage(const GA_Attribute *that) const override
GLuint start
Definition: glew.h:1253
const GA_AIFJSON * getAIFJSON() const override
GA_TypeInfo
Definition: GA_Types.h:99
SYS_FORCE_INLINE bool isPageConstant(GA_PageNum pagenum) const
const GA_AttributeType & getType() const
Definition: GA_Attribute.h:204
GLdouble GLdouble GLdouble b
Definition: glew.h:9122
const GA_AIFDelta * getAIFDelta() const override
Return the attribute's delta interface or NULL.
GLfloat GLfloat p
Definition: glew.h:16321
static const GA_AIFMath * myAIFNoMath
GLuint counter
Definition: glew.h:2740
SYS_FORCE_INLINE GA_TypeInfo getTypeInfo() const
Definition: GA_Attribute.h:249
fpreal64 fpreal
Definition: SYS_Types.h:277
GA_Size GA_PageNum
Definition: GA_Types.h:642
bool copy(GA_Offset desti, const GA_Attribute &src, GA_Offset srci) overridefinal
Concurrent writes to separate pages supported.
Definition: GA_Attribute.h:364
WriteConcurrence getSupportedWriteConcurrence() const override
Data is paged, so concurrent writes to separate pages supported.
static SYS_FORCE_INLINE const GA_AttributeType & getType()
Definition: GA_ATINumeric.h:57
GLuint GLuint GLsizei count
Definition: glew.h:1253
static GA_AIFDelta * myAIFDelta
SYS_FORCE_INLINE void setPageConstant(GA_PageNum pagenum, const SRC_DATA_T *values)
getOption("OpenEXR.storage") storage
Definition: HDK_Image.dox:276
static GA_AIFJSON * myAIFJSON
Attribute Interface class to copy attribute data.
DataType & getData()
Attribute Interface for file I/O.
Definition: GA_AIFJSON.h:39
bool shouldInterpretAsTexCoord(bool allow_float2=false) const
vint4 min(const vint4 &a, const vint4 &b)
Definition: simd.h:4694
static SYS_FORCE_INLINE const GA_ATINumeric * cast(const GA_Attribute *attrib)
Definition: GA_ATINumeric.h:72
virtual bool debugValidateArrayCapacity(GA_Offset sz) const
Debug validation of allocated array size.
bool copy(GA_Offset desti, const GA_ATINumeric &src, GA_Offset srci)
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
GA_Storage
Definition: GA_Types.h:49
GLdouble GLdouble t
Definition: glew.h:1398
static GA_AIFCopyData * myAIFCopyData
UT_UniquePtr< GA_ATINumeric > GA_ATINumericUPtr
const GA_Defaults & getDefaults() const
const GA_AIFMath * getAIFMath() const override
Return the attribute's math interface or NULL.
bool copy(const GA_Range &destrange, const GA_ATINumeric &src, const GA_Range &srcrange)
GA_Storage getStorage() const
static GA_AIFMerge * myAIFMerge
GLintptr offset
Definition: glew.h:1682