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  virtual ~GA_ATINumeric();
87 
88  virtual int64 getMemoryUsage(bool inclusive) const;
89 
90  virtual void countMemory(UT_MemoryCounter &counter, bool inclusive) const;
91 
92  /// @{
93  /// Interface for defragmentation
94  virtual void defragment(const GA_Defragment &defrag);
95  /// @}
96 
97  virtual void reconstructElementBlock(GA_Offset offset, GA_Offset nelements);
98 
99  /// Data is paged, so concurrent writes to separate pages supported.
101  { return WRITE_CONCURRENCE_PAGE; }
102 
103  virtual const GA_AIFCopyData *getAIFCopyData() const {return myAIFCopyData;}
104  virtual const GA_AIFDelta *getAIFDelta() const { return myAIFDelta; }
105  virtual const GA_AIFEdit *getAIFEdit() const { return myAIFEdit; }
106  virtual const GA_AIFTuple *getAIFTuple() const { return myAIFTuple; }
107  virtual const GA_AIFMath *getAIFMath() const
108  { return myDoMath ? myAIFMath:myAIFNoMath; }
109  virtual const GA_AIFMerge *getAIFMerge() const { return myAIFMerge; }
110  virtual const GA_AIFInterp *getAIFInterp() const { return myAIFInterp; }
111  virtual const GA_AIFCompare *getAIFCompare() const { return myAIFCompare; }
112 
113  /// @section JSON-GA_ATINumeric JSON Schema: GA_ATINumeric
114  /// @code
115  /// {
116  /// "name" : "GA_ATINumeric",
117  /// "description" : "An tuple array of numeric data",
118  /// "type" : "orderedmap",
119  /// "properties": {
120  /// "size": {
121  /// "type" : "integer",
122  /// "minimum" : 1,
123  /// "description" : "Tuple size",
124  /// },
125  /// "storage": {
126  /// "type" : "string",
127  /// "description" : "Tuple storage",
128  /// "enum" : [ "uint8","int8","int16","int32","int64",
129  /// "fpreal16", "fpreal32", "fpreal64" ],
130  /// },
131  /// "defaults": {
132  /// "type" : { "$ref" : "GA_Defaults" }
133  /// "description" : "Default values",
134  /// },
135  /// "values": {
136  /// "type" : {"$ref":"GA_DataArrayTuple"},
137  /// "description" : "Numeric values.",
138  /// },
139  /// },
140  /// }
141  /// @endcode
142  /// @see @ref JSON_FileFormat
143  virtual const GA_AIFJSON *getAIFJSON() const { return myAIFJSON; }
144 
145  /// Called during JSON load
146  bool jsonLoad(UT_JSONParser &p,
147  const GA_LoadMap &map,
148  const GA_Defaults &defs,
149  int tuple_size,
151 
152  const GA_Defaults &getDefaults() const { return myDefaults; }
153 
154  int getTupleSize() const { return myData.getTupleSize(); }
155  GA_Storage getStorage() const { return myData.getStorage(); }
156 
157  bool setTupleSize(int size);
158  bool setStorage(GA_Storage storage);
159 
160  /// Checks if an attribute should be treated as a texture coordinate attribute.
161  /// Ideally, we could rely on the type info being GA_TYPE_TEXTURE_COORD,
162  /// but old files don't have this, and various importers don't set this.
163  /// If a float[3] (optionnally float[2]) attribute's name starts with "uv"
164  /// and is followed by zero or more digits (and nothing else), it's probably
165  /// safe to assume that it should be treated as a texture attribute.
166  bool shouldInterpretAsTexCoord(bool allow_float2=false) const
167  {
168  if (getTupleSize() != 3 && (!allow_float2 || getTupleSize() != 2))
169  return false;
170 
171  // If it's not a float type, it's probably not a texture coordinate,
172  // even if its typeinfo says otherwise.
173  GA_Storage storage = getStorage();
174  if (storage != GA_STORE_REAL16 && storage != GA_STORE_REAL32 && storage != GA_STORE_REAL64)
175  return false;
176 
177  // If it's marked as texture coord, go with that.
178  // If it's not that and not void, it's not texture coord.
179  GA_TypeInfo typeinfo = getTypeInfo();
180  if (typeinfo != GA_TYPE_VOID)
181  return (typeinfo == GA_TYPE_TEXTURE_COORD);
182 
183  // Void type info; check name next.
184  const char *name = getName().c_str();
185  if (name[0] != 'u' || name[1] != 'v')
186  return false;
187 
188  // Name starts with "uv". Check if everything else is digits.
189  for (name += 2; *name; ++name)
190  {
191  if (*name < '0' || *name > '9')
192  return false;
193  }
194  return true;
195  }
196 
197  /// Some types, especially integers, may not want to be lerped
198  bool isNonArithmetic() const { return !myDoMath; }
199 
200  /// Debug code
201  virtual bool debugValidateArrayCapacity(GA_Offset sz) const;
202 
203  /// Grow or shrink the array size
204  virtual bool setArraySize(GA_Offset new_size);
205 
206  /// Try to compress data pages
207  virtual void tryCompressAllPages(
208  GA_Offset start_offset = GA_Offset(0),
209  GA_Offset end_offset = GA_INVALID_OFFSET);
210  /// Harden data pages
211  virtual void hardenAllPages(
212  GA_Offset start_offset = GA_Offset(0),
213  GA_Offset end_offset = GA_INVALID_OFFSET);
214 
215  /// Returns true iff that is an attribute whose content can be copied
216  /// from this without any type conversions. This is important to
217  /// avoid reallocation of an attribute if its storage type,
218  /// including tuple size, matches the source attribute exactly.
219  virtual bool matchesStorage(const GA_Attribute *that) const
220  {
221  if (!GA_Attribute::matchesStorage(that))
222  return false;
223  const GA_ATINumeric *thatn = UTverify_cast<const GA_ATINumeric *>(that);
224  if (getStorage() != thatn->getStorage())
225  return false;
226  if (getTupleSize() != thatn->getTupleSize())
227  return false;
228  return true;
229  }
230  /// In the case that we're copying from an attribute whose storage
231  /// type matches this exactly, this function copies the metadata
232  /// not associated with the storage, e.g. myOptions,
233  /// *excluding* the name and the data ID.
234  virtual void copyNonStorageMetadata(const GA_Attribute *that)
235  {
237  const GA_ATINumeric *thatn = UTverify_cast<const GA_ATINumeric *>(that);
238  myDoMath = thatn->myDoMath;
239  myDefaults = thatn->myDefaults;
240  }
241 
242  /// This replaces the entirety of this attribute's content and non-
243  /// storage metadata (except the name) with that of the src attribute.
244  /// matchesStorage(src) should already return true.
245  /// This is primarily for use by GA_AttributeSet::replace().
246  /// NOTE: The internal content sizes may not match exactly if the
247  /// attribute type may overallocate, but the sizes should be such
248  /// that any real data will fit in the destination, so be careful
249  /// and deal with the myTailInitialize flag appropriately if
250  /// any extra elements aren't equal to the default.
251  virtual void replace(const GA_Attribute &src);
252 
253  /// Copy attribute values for a single element.
254  /// @{
255  virtual bool copy(GA_Offset desti, GA_Offset srci) final
256  {
257  return tupleSet(desti, *this, srci, -1);
258  }
259  virtual bool copy(GA_Offset desti, const GA_Attribute &src, GA_Offset srci) final
260  {
261  if (!GA_ATINumeric::isType(&src))
262  return false;
263  return tupleSet(desti, *UTverify_cast<const GA_ATINumeric*>(&src), srci, -1);
264  }
265  bool copy(GA_Offset desti, const GA_ATINumeric &src, GA_Offset srci)
266  {
267  return tupleSet(desti, src, srci, -1);
268  }
269  /// @}
270 
271  /// Copy attribute values for a range of elements.
272  /// WARNING: These do not support overlapping ranges within a single attribute!
273  /// @{
274  virtual bool copy(const GA_Range &destrange, const GA_Range &srcrange) final
275  {
276  return tupleSet(destrange, *this, srcrange, -1);
277  }
278  virtual bool copy(const GA_Range &destrange, const GA_Attribute &src, const GA_Range &srcrange) final
279  {
280  if (!GA_ATINumeric::isType(&src))
281  return false;
282  return tupleSet(destrange, *UTverify_cast<const GA_ATINumeric*>(&src), srcrange, -1);
283  }
284  bool copy(const GA_Range &destrange, const GA_ATINumeric &src, const GA_Range &srcrange)
285  {
286  return tupleSet(destrange, src, srcrange, -1);
287  }
288  /// @}
289 
290  /// Assign all elements of a range from a single attribute value.
291  /// @{
292  virtual bool fill(const GA_Range &destrange, GA_Offset srci) final;
293  virtual bool fill(const GA_Range &destrange, const GA_Attribute &src, GA_Offset srci) final;
294  bool fill(const GA_Range &destrange, const GA_ATINumeric &src, GA_Offset srci);
295  /// @}
296 
297  typedef GA_PageArray<void, -1, true, false> DataType;
298 
299  /// @{
300  /// Provide access to data
301  const DataType &getData() const { return myData; }
302  DataType &getData() { return myData; }
303  /// @}
304 
305  /// Returns true iff the specified page is constant-compressed,
306  /// where a single value is stored to represent GA_PAGE_SIZE
307  /// values in the page, (or possibly fewer if only one page).
309  {
310  return myData.isPageConstant(pagenum);
311  }
312  /// Sets all components of all elements of the specified page to
313  /// the given values.
314  /// NOTE: The length of values must be equal to the tuple size.
315  template<typename SRC_DATA_T>
316  SYS_FORCE_INLINE void setPageConstant(GA_PageNum pagenum, const SRC_DATA_T *values)
317  {
318  myData.setPageConstant(pagenum, values);
319  }
320 
321 protected:
324  bool myDoMath; // Off for non-arithmetic integer
325 
331  static const GA_AIFMath *myAIFNoMath;
333  static GA_AIFInterp *myAIFInterp;
336 
338 
339 private:
340  void updateIntegerTypeInfo();
341 
342  virtual GA_Attribute *doClone(const GA_IndexMap &index_map,
343  const UT_StringHolder &name) const;
344 
345  /// @{ GA_AIFTuple
346  template <typename T> inline bool
347  tupleGet(GA_Offset di, T &v, int vi) const;
348  template <typename T> inline bool
349  tupleGet(GA_Offset di, T *v, int count, int start) const;
350 
351  template <typename T> inline bool
352  tupleSet(GA_Offset di, T v, int vi);
353  template <typename T> inline bool
354  tupleSet(GA_Offset di, const T *v, int count, int start);
355  template <typename T> inline bool
356  tupleSet(const GA_Range &di, T v, int vi);
357  template <typename T> inline bool
358  tupleSet(const GA_Range &di, const T *v, int count, int start);
359  bool tupleSet(GA_Offset di, const GA_ATINumeric &s,
360  GA_Offset si, int component);
361  /// WARNING: These do not support overlapping ranges within a single attribute!
362  bool tupleSet(const GA_Range &di, const GA_ATINumeric &s,
363  const GA_Range &si, int component);
364 
365  template <typename T> inline bool
366  makeConstant(T v, int vi);
367  template <typename T> inline bool
368  makeConstant(const T *v, int count, int start);
369 
370  bool isNan(GA_Offset ai) const;
371  bool isNan(const GA_Range &ai) const;
372  /// @}
373 
374  /// @{ GA_AIFInterp
375  bool interpLerp(GA_Offset di,
376  const GA_ATINumeric &a, GA_Offset ai,
377  const GA_ATINumeric &b, GA_Offset bi,
378  fpreal t);
379  bool interpLerp(const GA_Range &di,
380  const GA_ATINumeric &a, const GA_Range &ai,
381  const GA_ATINumeric &b, const GA_Range &bi,
382  fpreal t);
383  bool interpSmooth(GA_Offset di, fpreal min, fpreal max,
384  const GA_ATINumeric &a, GA_Offset ai);
385  bool interpSmooth(const GA_Range &di, fpreal min, fpreal max,
386  const GA_ATINumeric &a, const GA_Range &ai);
387  bool interpFit(GA_Offset di, const GA_ATINumeric &a, GA_Offset ai,
388  fpreal omin, fpreal omax,
389  fpreal nmin, fpreal nmax);
390  bool interpFit(const GA_Range &di,
391  const GA_ATINumeric &a, const GA_Range &ai,
392  fpreal omin, fpreal omax,
393  fpreal nmin, fpreal nmax);
394  /// @}
395 
396  /// @{ GA_AIFMerge
397  void mergeDestroyDestination(const GA_MergeMap &map,
398  GA_Attribute *dattrib) const;
399  GA_Attribute *mergeAddDestination(const GA_MergeMap &map,
400  GA_Attribute *dattrib) const;
401  void mergeGrowArray(const GA_MergeMap &map,
402  const GA_ATINumeric &s);
403  bool mergeAppendData(const GA_MergeMap &map,
404  const GA_Attribute *sattrib);
405  /// @}
406 
407  /// @{ GA_AIFJSON
408  /// Save data to a JSON stream.
409  bool jsonSave(UT_JSONWriter &w, const GA_SaveMap &s) const;
410  /// @}
411 
412  /// @cond INTERNAL_DOX
413  friend class ga_NumericCopyData;
414  friend class ga_NumericDelta;
415  friend class ga_NumericEdit;
416  template <typename T> friend class ga_NumericEditDelta;
417  template <typename T> friend class ga_NumericEditSnapshot;
418  friend class ga_NumericInterp;
419  friend class ga_NumericJSON;
420  friend class ga_NumericMarshal;
421  friend class ga_NumericMath;
422  friend class ga_NumericMerge;
423  friend class ga_NumericTuple;
424  friend class ga_NumericCompare;
425 
426  template <typename T> friend class binderScalar;
427  template <typename T> friend class binderVector;
428  template <typename T, typename TB> friend class binderPage;
429  /// @endcond
430 };
431 
432 #endif
433 
A class to manage an ordered array which has fixed offset handles.
Definition: GA_IndexMap.h:63
Definition of a geometry attribute.
Definition: GA_Attribute.h:190
Data has no numeric representation.
Definition: GA_Types.h:83
bool isNonArithmetic() const
Some types, especially integers, may not want to be lerped.
virtual bool matchesStorage(const GA_Attribute *that) const
GA_PageArray< void,-1, true, false > DataType
Used to pass options and map offset values during saving.
Definition: GA_SaveMap.h:48
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
const GLdouble * v
Definition: glcorearb.h:836
GLuint start
Definition: glcorearb.h:474
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
int getTupleSize() const
The merge map keeps track of information when merging details.
Definition: GA_MergeMap.h:53
virtual const GA_AIFJSON * getAIFJSON() const
virtual const GA_AIFDelta * getAIFDelta() const
Return the attribute's delta interface or NULL.
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1221
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:75
virtual bool setArraySize(GA_Offset size)=0
#define GA_API
Definition: GA_API.h:12
bool isNan(const Tuple< SIZE, T > &t)
Return true if a Nan is present in the tuple.
Definition: Tuple.h:243
DataType myData
Class which writes ASCII or binary JSON streams.
Definition: UT_JSONWriter.h:32
static GA_AIFCompare * myAIFCompare
SYS_FORCE_INLINE TO_T UTverify_cast(FROM_T from)
Definition: UT_Assert.h:199
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:677
const UT_StringHolder & getName() const
Definition: GA_Attribute.h:251
virtual const GA_AIFTuple * getAIFTuple() const
Return the attribute's tuple interface or NULL.
virtual void tryCompressAllPages(GA_Offset start_offset=GA_Offset(0), GA_Offset end_offset=GA_INVALID_OFFSET)=0
GLsizeiptr size
Definition: glcorearb.h:663
#define GA_INVALID_OFFSET
Definition: GA_Types.h:654
A range of elements in an index-map.
Definition: GA_Range.h:42
GA_Size GA_Offset
Definition: GA_Types.h:617
virtual bool fill(const GA_Range &destrange, GA_Offset srci)
Definition: GA_Attribute.h:743
long long int64
Definition: SYS_Types.h:107
GA_AttributeScope
Definition: GA_Types.h:121
static const GA_AttributeType * theAttributeType
virtual const GA_AIFInterp * getAIFInterp() const
Return the attribute's interpolation interface or NULL.
static GA_AIFTuple * myAIFTuple
virtual void replace(const GA_Attribute &src)=0
static GA_AIFInterp * myAIFInterp
Attribute Interface for merging attribute data between details.
Definition: GA_AIFMerge.h:56
const std::enable_if<!VecTraits< T >::IsVec, T >::type & max(const T &a, const T &b)
Definition: Composite.h:133
static SYS_FORCE_INLINE GA_ATINumeric * cast(GA_Attribute *attrib)
Definition: GA_ATINumeric.h:65
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
virtual bool copy(const GA_Range &destrange, const GA_Attribute &src, const GA_Range &srcrange) final
GLintptr offset
Definition: glcorearb.h:664
virtual WriteConcurrence getSupportedWriteConcurrence() const
Data is paged, so concurrent writes to separate pages supported.
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
GLenum GLsizei GLsizei GLint * values
Definition: glcorearb.h:1601
Defragmentation of IndexMaps.
Definition: GA_Defragment.h:45
static GA_AIFEdit * myAIFEdit
virtual const GA_AIFMath * getAIFMath() const
Return the attribute's math interface or NULL.
GLuint const GLchar * name
Definition: glcorearb.h:785
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1221
virtual void copyNonStorageMetadata(const GA_Attribute *that)
virtual void copyNonStorageMetadata(const GA_Attribute *that)
Definition: GA_Attribute.h:691
GLint GLsizei count
Definition: glcorearb.h:404
GA_TypeInfo
Definition: GA_Types.h:80
SYS_FORCE_INLINE bool isPageConstant(GA_PageNum pagenum) const
const GA_AttributeType & getType() const
Definition: GA_Attribute.h:198
double fpreal
Definition: SYS_Types.h:270
static const GA_AIFMath * myAIFNoMath
virtual const GA_AIFEdit * getAIFEdit() const
Return the attribute's edit interface or NULL.
SYS_FORCE_INLINE GA_TypeInfo getTypeInfo() const
Definition: GA_Attribute.h:220
virtual bool copy(GA_Offset desti, GA_Offset srci) final
GA_Size GA_PageNum
Definition: GA_Types.h:620
Concurrent writes to separate pages supported.
Definition: GA_Attribute.h:335
static SYS_FORCE_INLINE const GA_AttributeType & getType()
Definition: GA_ATINumeric.h:57
static GA_AIFDelta * myAIFDelta
SYS_FORCE_INLINE void setPageConstant(GA_PageNum pagenum, const SRC_DATA_T *values)
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
virtual const GA_AIFMerge * getAIFMerge() const
Return the attribute's merge interface or NULL.
getOption("OpenEXR.storage") storage
Definition: HDK_Image.dox:276
static GA_AIFJSON * myAIFJSON
Attribute Interface class to copy attribute data.
DataType & getData()
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:856
virtual bool copy(GA_Offset desti, const GA_Attribute &src, GA_Offset srci) final
Attribute Interface for file I/O.
Definition: GA_AIFJSON.h:39
bool shouldInterpretAsTexCoord(bool allow_float2=false) const
static SYS_FORCE_INLINE const GA_ATINumeric * cast(const GA_Attribute *attrib)
Definition: GA_ATINumeric.h:72
virtual const GA_AIFCopyData * getAIFCopyData() const
Return the attribute's copy interface or NULL.
virtual const GA_AIFCompare * getAIFCompare() const
Return the attribute's comparison interface or NULL.
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)
const std::enable_if<!VecTraits< T >::IsVec, T >::type & min(const T &a, const T &b)
Definition: Composite.h:129
AIF to record changes to attribute values.
Definition: GA_AIFEdit.h:393
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
virtual bool copy(const GA_Range &destrange, const GA_Range &srcrange) final
GA_Storage
Definition: GA_Types.h:48
static GA_AIFCopyData * myAIFCopyData
const GA_Defaults & getDefaults() const
bool copy(const GA_Range &destrange, const GA_ATINumeric &src, const GA_Range &srcrange)
GLenum src
Definition: glcorearb.h:1792
GA_Storage getStorage() const
static GA_AIFMerge * myAIFMerge
virtual void reconstructElementBlock(GA_Offset offset, GA_Offset nelements)