HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
RE_OGLTexture.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: RE_OGLTexture.h ( RE Library, C++)
7  *
8  * COMMENTS:
9  * Base class for various OpenGL texture types: 1D, 2D, 3D, Cube,
10  * 2D rectangles, 1D arrays and 2D arrays.
11  *
12  */
13 #ifndef RE_OGLTexture_h
14 #define RE_OGLTexture_h
15 
16 class RE_Render;
17 class RE_TextureMap;
18 
19 #include <UT/UT_ValArray.h>
20 #include <UT/UT_Rect.h>
21 
22 #include "RE_CachedObject.h"
23 #include "RE_Types.h"
24 #include "RE_TextureTypes.h"
25 #include "RE_TextureFilter.h"
26 #include <IMG/IMG_FileTypes.h>
27 
28 #include <iosfwd>
29 #include <time.h>
30 
32 {
33 public:
34  ~RE_OGLTexture() override;
35 
36  /// Returns the amount of main memory (NOT graphics memory!)
37  /// owned by this RE_OGLTexture.
38  int64 getMemoryUsage(bool inclusive) const override;
39 
40  virtual const char *className() const;
41 
42  // Texture type (dimensions)
43  RE_TextureDimension getTextureType() const;
44 
45  // Returns true if this texture type is supported.
46  virtual bool hasTextureSupport(RE_Render *r);
47 
48  // True if this texture type supports mipmapping (all but tex rectangles)
49  virtual bool hasMipMapSupport(RE_Render *);
50 
51  // Returns the maximum size of a texture edge of the given texture type
52  virtual int getMaxTextureSize(RE_Render *r) = 0;
53 
54  // Returns the maximum index that can be used for arrays and cube maps
55  virtual int getMaxTextureIndex(RE_Render *r);
56 
57  // True if GL can compress textures itself.
58  bool hasAutoCompression(RE_Render *r);
59 
60  // true if this has a valid texture created for it.
61  virtual bool isValid() const;
62 
63  // true if the texture res, format, mip levels can be changed on the fly
64  bool isMutable() const { return myMutableFlag; }
65 
66  // Texture identifier - opaque handle.
67  RE_TextureID getID() const;
68 
69  // Releases the texture on the GPU; this object becomes invalid.
70  virtual void free();
71 
72  // Returns a new texture with no attributes of the given type.
73  static RE_OGLTexture *newTexture(RE_TextureDimension t);
74 
75  // Returns a new, blank texture with the same attributes as this texture.
76  RE_OGLTexture *copyAttributes() const;
77 
78  // -----------------------------------------------------------------
79  // Basic Texture data (modifying will invalidate texture,
80  // requiring a setTexture() call)
81 
82  // The texture type can be color, stencil, or depth. Stencil and depth
83  // textures are more restrictive with the types that can be sent to them.
84  // They must be single channel textures; depth can be FLOAT16,24 or 32,
85  // while stencil must be UINT1,2,4,8 or 16. The default is Color.
86  // This must be set before calling setFormat().
87  void setDataType(RE_TextureDataType type);
88  RE_TextureDataType getDataType() const;
89 
90  // The data type is the CPU-side data format, vectorsize can be 1-4.
91  // To use leaner GPU-side data formats, set a texture compression.
92  void setFormat(RE_GPUType data, int vectorsize,
93  RE_TextureFormatExtra format_extra =
95  RE_GPUType getFormatType() const;
96  int getFormatSize() const;
97  RE_TextureFormatExtra getFormatExtra() const;
98 
99  // returns the GL internal format of the texture (ie, RGBA8).
100  int getInternalFormat() const { return myGLInternal; }
101 
102  // You can pass the data in a different format than the texture type.
103  // This must be called after setFormat().
104  void setClientFormat(RE_GPUType data, int vectorsize);
105 
106  // Compress the texture on the GPU, default is to use the same format as
107  // the CPU format (RE_COMPRESS_NONE). If auto_compress is false, it is
108  // assumed that the data passed to this texture object is already
109  // compressed.
110  void setCompression(RE_TextureCompress comp,
111  bool auto_compress);
112  RE_TextureCompress getCompression() const;
113  bool getAutoCompression() const;
114 
115  // Texture Resolution
116  // Height/depth may not be required, depending on texture dimension.
117  void setResolution(int w, int h = 1, int depth = 1,
118  bool force_pow2 = false);
119  int getWidth() const;
120  int getHeight() const;
121  int getDepth() const;
122 
123  // GL may differ from getWidth/Height/Depth if GPU requires pow2 textures
124  // These sizes will never be smaller than the above sizes.
125  int getGLWidth() const;
126  int getGLHeight() const;
127  int getGLDepth() const;
128 
129  // If the texture size differs from the GL size, this will return a value
130  // less than 1 to represent the coord where the image ends in the texture
131  float getTexS() const;
132  float getTexT() const;
133  float getTexR() const;
134 
135  // For multisample textures (2D)
136  virtual void setSamples(int samples);
137  int getSamples() const;
138 
139  // Enables mipmapping and auto-generation of mipmaps. Not all texture data
140  // formats can be mipmapped (specifically floating point). This also sets
141  // the minify filter to RE_FILT_LINEAR_MIPMAP_LINEAR if not set to a MIPMAP
142  // filter and it is enabled, or back to RE_FILT_LINEAR if disabled.
143  void setMipMap(bool m, bool autogen = true);
144  bool getMipMap() const;
145  bool getMipMapAutoGenerate() const;
146 
147  // Returns true if the texture actually is mipmapped, not just requested
148  // to be (some formats don't mipmap).
149  bool isMipMapped() const;
150 
151  // This can be called before the texture is created to determine if it's
152  // possible to use. Returns false if it's not possible to create. If the
153  // texture is already created, it returns the actual OpenGL texture values.
154  // 'format' is an internal OpenGL format specification (like GL_RGBA8).
155  bool queryTextureStats(RE_Render *r,
156  int *width, int *height, int *depth,
157  int *format);
158 
159  void setLabel(RE_Render *r, const char *label);
160 
161 
162  // ---------------------------------------------------------------------
163  // Texture transfer methods (CPU/GPU).
164 
165  // set/getTexture() writes or reads the entire texture.
166  // It is assumed that data points to a chunk of memory large enough for the
167  // texture. A set method must be called afterwards to reinitialize the
168  // texture if the above parameters are changed.
169  // If non-pow2 textures are not supported and you set the resolution to a
170  // non-pow2 size, you still pass in non-pow2 data and it will be written
171  // properly (do not pad to pow2). If you do not wish this to be the case,
172  // set a pow2 resolution insteead. When rendering a non-pow2 emulated
173  // texture, use the getTexS/T/R() methods to determine the edge of the data.
174 
175  // 'level' is the texture mipmap level.Must be -1 if mipmapping is disabled.
176  // 'index' varies by texture type; face for cube maps and index for arrays.
177  // 'proxy' does a texture proxy call, merely seeing if the texture can be
178  // created without generating any errors.
179  virtual void setTexture(RE_Render *r, const void *data,
180  int level=-1, int index=-1,
181  bool proxy=false) = 0;
182 
183  // How large a block is required to initialize or fetch this texture.
184  virtual int64 getSizeBytes() const;
185 
186  // The size of one scanline in the image. The second version using sublen
187  // instead of GLwidth
188  int64 getScanBytes() const;
189  int64 getScanBytes(int sublen) const;
190 
191  // Number of bits in a full pixel (ie, fp16 RGB has 48b).
192  int64 getBitsPerPixel() const;
193 
194  // Actual size of texture in GPU mem.
195  int64 getTextureSize() const;
196 
197  // Write to or read from a portion of the texture. Not all dimensions may
198  // be used. See derived classes for the meaning of 'z'. These can only be
199  // used after setTexture(), though it can be called with data=nullptr to set
200  // up the texture for setSubTexture().
201  virtual void setSubTexture(RE_Render *r,
202  const void *data, int level,
203  int xoffset, int xsize,
204  int yoffset=0, int ysize=1,
205  int zoffset=0, int zsize=1) = 0;
206 
207  // Reads the entire texture at 'level' back into 'data'. 'data' must point
208  // to a block of at least 'getSizeBytes()' in size.
209  // Note that a non-pow2 emulated texture will return the entire GL pow2
210  // size, since there is no way to read a portion of a texture.
211  virtual void getTexture(RE_Render *r, void *data,
212  int level=0, int index=-1) const;
213  static void getTextureRaw2D(RE_Render *r, int id,
214  int width, int height,
215  RE_TextureDataType datatype,
216  RE_GPUType format, int vectorsize,
217  void *data);
218 
219  // copies 'area' block of pixels from the read buffer to this texture,
220  // in screen coords (if nullptr, the entire area) at offset (x,y,z) and
221  // miplevel 'level'. The pixels are converted to this texture's data format
222  virtual bool copyFromBuffer(RE_Render *r, int x, int y, int z = 0,
223  const UT_DimRect *bufferarea = nullptr,
224  int level = 0) = 0;
225 
226  // Copy a subregion from a source texture to this texture. The x,y,z and
227  // width, height, depth parameters have different meanings depending on the
228  // source and destination texture types (eg, depth in cubemap is the face,
229  // height in a 1D array is the index). Requires RE_EXT_TEXTURE_COPY (GL4.3)
230  // Buffer textures cannot be copied to or from.
231  bool copyFromTexture(RE_Render *r,
232  const RE_OGLTexture *src_texture,
233  int src_x, int src_y, int src_z,
234  int dst_x, int dst_y, int dst_z,
235  int width = -1, // -1 = full src width
236  int height = -1,
237  int depth = -1,
238  int mip_level = 0);
239 
240 
241  // Build mip-maps from mip level 0 of the texture. Useful for
242  // filtering render-to-texture targets. Returns true if mipmaps were
243  // generated.
244  bool generateMipMaps(RE_Render *r);
245 
246  // ---------------------------------------------------------------------
247  // Texture Parameters (changing will modify, does not require setTexture)
248 
249  // Filter to use when displaying the texture at less than 100% zoom
250  void setMinFilter( RE_Render *r, RE_TexFiltType t );
251  RE_TexFiltType getMinFilter() const;
252 
253  // Filter to use when displaying the texture at greater than 100% zoom
254  void setMagFilter( RE_Render *r, RE_TexFiltType t );
255  RE_TexFiltType getMagFilter() const;
256 
257  void setMaxAnisotropy(RE_Render *r, int atf);
258  int getMaxAnisotropy() const;
259 
260  // Fixed bias value that is added to the level-of-detail parameter for
261  // the texture before texture sampling (when mipmapping).
262  void setLodBias(RE_Render *r, float bias);
263  float getLodBias() const;
264 
265  // Texture wrapping - clamp or repeat. Not all dimension may be used.
266  void setTextureWrap(RE_Render *r,
267  RE_TexClampType clamp_s,
268  RE_TexClampType clamp_t = RE_CLAMP_EDGE,
269  RE_TexClampType clamp_r = RE_CLAMP_EDGE);
270  bool getWrapS() const;
271  bool getWrapT() const;
272  bool getWrapR() const;
273 
274  void setBorder(RE_Render *r,
276  const UT_Vector4F *color_alpha = nullptr);
277  UT_Vector4F getBorderColor() const;
278 
279  // Sets all of the above in one go.
280  void setTextureFilter(RE_Render *r,
281  const RE_TextureFilter &filter);
282 
283  // When on, depth comparison is used. When used in a shader, a shadow
284  // sampler must be used. If disabled, the raw depth value is returned and
285  // a normal texture sampler must be used. 'compare' can be set to a
286  // negative, positive or zero value, indicating less/equal, greater/equal or
287  // equal compare mode.
288  void setDepthCompareMode(RE_Render *r, bool enabled,
291 
292  // If RE_EXT_TEXTURE_SWIZZLE is supported, texture components can be
293  // shuffled about or set to a constant 0 or 1 value.
294  bool setTextureSwizzle(RE_Render *r,
299 
300  void setAlphaInfo(IMG_FileAlphaInfo a) { myAlphaInfo = a; }
301  IMG_FileAlphaInfo getAlphaInfo() const { return myAlphaInfo;}
302 
303  // --------------------------------------------------------------------
304  // Bindless Textures (requires RE_EXT_TEXTURE_BINDLESS)
305 
306  // Creates a bindless handle for the texture. Once this is done, the texture
307  // is immutable - its texel contents can change, but nothing else.
308  // Will return false if bindless texture is unsupported.
309  bool createTextureHandle(RE_Render *r);
310 
311  // returns the bindless texture handle. createTextureHandle() must be called
312  // first. If bindless is unsupported or create was not called, returns 0.
313  uint64 getTextureHandle() const { return myBindlessHandle; }
314 
315  // Before a bindless texture can be used, it must be made resident.
316  bool makeResidentTexture(RE_Render *r);
317 
318  // When a bindless texture is no longer needed, it should be removed from
319  // resident status to free up resources.
320  bool removeResidentTexture(RE_Render *r);
321 
322 
323 
324  // --------------------------------------------------------------------
325 
326  static int getGLTextureType(RE_TextureDimension t);
327  static RE_TextureDimension getRETextureType(int gl_type);
328  static RE_OGLTexture *findTextureWithID(RE_TextureID id);
329 
330  // Mostly for debug, this writes the texture out to a file (any supported
331  // image format, determined by the extension). 3D textures are best written
332  // as deep raster formats, like .pic.
333  bool writeToFile(RE_Render *r, const char *name,
334  int level = 0) const;
335 
336  // Expands a 2D multisample texture into a 2D texture with dimensions
337  // increased by the sampling factor: 2x (2,1), 4x (2,2), 6x (3,2), 8x (4,2)
338  RE_OGLTexture * expandMultisampleTexture(RE_Render *r) const;
339 
340  static void adjustPow2(int &w, int &h, int &d);
341 
342 
343  // References on this texture by other objects
344  void addReference(void (*cb)(void *, RE_OGLTexture *),
345  void *ref_obj);
346  void removeReference(void *ref_obj);
347 
348  void setFileModTime(time_t time) { myModTime = time; }
349  bool hasFileModTime() const { return myModTime != 0; }
350  time_t getFileModTime() const { return myModTime; }
351 
352 
353  void invalidateCache();
354 
355  // print a summary of this texture. If os is nullptr, use std::cerr.
356  void print(std::ostream *os = nullptr);
357 
358  // Dump all textures currently in use by Houdini. If min_tex_size is
359  // specified, only those textures >= the size will be printed. The summary
360  // line will always include stats from all textures.
361  static void dumpTextureTable(std::ostream &os,
362  int64 min_tex_size = -1);
363 protected:
364 
366 
367  void deleteObject();
368  void setupTextureParameters(RE_Render *r, bool force);
369  void validate();
370 
371  // These return various GL types (ie, GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D,
372  // GL_TEXTURE_BINDING_2D)
373  virtual int getGLType() const = 0;
374  virtual int getGLProxy() const = 0;
375  virtual int getGLTypeBinding() const = 0;
376  virtual int getGLCreateType() const { return getGLType(); }
377 
378  // These methods must be called from within a locked context
379  virtual bool buildMipMaps(RE_Render *r, const void *data) = 0;
380 
381  bool createTextureID();
382 
383  RE_GPUType getClientType() const;
384 
385  // returns a malloc'ed image with the compressed data, which must be freed.
386  // If no compression is necessary, this will return nullptr.
387  void * compressTexData(const void *src, int &w, int &h);
388  void determineCompressionInternal();
389  void determineTextureSize(RE_Render *r);
390 
391  // OpenGL data
393  int myGLType;
399  time_t myModTime;
401 
402  void updateTextureWrap(RE_Render *r, bool force);
403  void updateFilters(RE_Render *r, bool force);
404 
405 private:
406  void buildFormatTable();
407 
408  // RE data
409  RE_TextureDataType myTextureDataType;
410  RE_GPUType myDataType;
411  RE_GPUType myClientType;
412  RE_TextureFormatExtra myFormatExtra;
413  RE_TextureDimension myTexDimension;
414  int myVectorSize;
415  int myWidth;
416  int myHeight;
417  int myDepth;
418  RE_TextureCompress myCompression;
419  bool myMipMapFlag;
420  bool myMipMapAutoGenFlag;
421  bool myAutoCompressFlag;
422  bool myCompressFlag;
423  bool myValidFlag;
424  bool myMutableFlag;
425  RE_TextureFilter myCurrentFilterState;
426  RE_TextureFilter myFilter;
427  int64 myTexSize;
428  IMG_FileAlphaInfo myAlphaInfo;
429  UT_ValArray<void *> myReferences;
431 
432  uint64 myBindlessHandle;
433  int myResidentCount;
434 
435 protected:
437  friend class RE_OGLRender;
438  friend class RE_OGLFramebuffer;
439  friend class RE_TextureMap;
440 };
441 
442 inline RE_TextureDimension
444 {
445  return myTexDimension;
446 }
447 
448 inline void
450 {
451  myTextureDataType = type;
452 
453  if(myVectorSize > 0)
454  setFormat(myDataType, myVectorSize, myFormatExtra);
455 }
456 
457 inline RE_TextureDataType
459 {
460  return myTextureDataType;
461 }
462 
463 inline bool
465 {
466  return myID != 0 && myValidFlag;
467 }
468 
469 inline RE_TextureID
471 {
472  return myID;
473 }
474 
475 inline RE_GPUType
477 {
478  return myDataType;
479 }
480 
481 inline RE_GPUType
483 {
484  return myClientType;
485 }
486 
487 inline int
489 {
490  return myVectorSize;
491 }
492 
495 {
496  return myFormatExtra;
497 }
498 
499 inline int
501 {
502  return myWidth;
503 }
504 
505 inline int
507 {
508  return myHeight;
509 }
510 
511 inline int
513 {
514  return myDepth;
515 }
516 
517 inline int
519 {
520  return myGLWidth;
521 }
522 
523 inline int
525 {
526  return myGLHeight;
527 }
528 
529 inline int
531 {
532  return myGLDepth;
533 }
534 
535 inline RE_TextureCompress
537 {
538  return myCompression;
539 }
540 
541 inline bool
543 {
544  return myAutoCompressFlag;
545 }
546 
547 inline bool
549 {
550  return true;
551 }
552 
553 inline bool
555 {
556  return myMipMapFlag;
557 }
558 
559 inline bool
561 {
562  return myMipMapFlag && myCanMipMap;
563 }
564 
565 inline bool
567 {
568  return myMipMapAutoGenFlag;
569 }
570 
571 inline RE_TexFiltType
573 {
574  return myCurrentFilterState.getMinFilter();
575 }
576 
577 inline RE_TexFiltType
579 {
580  return myCurrentFilterState.getMagFilter();
581 }
582 
583 inline float
585 {
586  return myCurrentFilterState.getLodBias();
587 }
588 
589 inline int
591 {
592  return myCurrentFilterState.getMaxAnisotropy();
593 }
594 
595 inline bool
597 {
598  return myCurrentFilterState.getWrapS();
599 }
600 
601 inline bool
603 {
604  return myCurrentFilterState.getWrapT();
605 }
606 
607 inline bool
609 {
610  return myCurrentFilterState.getWrapR();
611 }
612 
613 inline const char *
615 {
616  return "RE_OGLTexture";
617 }
618 
619 inline bool
621 {
622  return true;
623 }
624 
625 inline void
627 {
628  myValidFlag = true;
629 }
630 
631 inline int
633 {
634  return 1;
635 }
636 
637 inline float
639 {
640  return float(myWidth) / float(myGLWidth);
641 }
642 
643 inline float
645 {
646  return float(myHeight) / float(myGLHeight);
647 }
648 
649 inline float
651 {
652  return float(myDepth) / float(myGLDepth);
653 }
654 
655 inline int64
657 {
658  return myTexSize;
659 }
660 
661 inline int64
663 {
664  return getScanBytes(myGLWidth);
665 }
666 
667 
668 #endif
int getGLHeight() const
void setFileModTime(time_t time)
virtual int getMaxTextureIndex(RE_Render *r)
float getTexR() const
bool isMipMapped() const
GLint GLint GLint yoffset
Definition: glcorearb.h:412
bool getMipMapAutoGenerate() const
int getGLDepth() const
RE_GPUType getClientType() const
GLuint GLsizei const GLchar * label
Definition: glcorearb.h:2545
bool getWrapS() const
virtual const char * className() const
#define RE_API
Definition: RE_API.h:10
int64 getMemoryUsage(bool inclusive) const override
int64 getTextureSize() const
GT_API const UT_StringHolder time
RE_TextureFormatExtra getFormatExtra() const
RE_TextureSwizzle
int getWidth() const
GLdouble GLdouble GLdouble z
Definition: glcorearb.h:848
RE_TexFiltType getMagFilter() const
RE_TextureID myID
GLint level
Definition: glcorearb.h:108
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1222
GLint y
Definition: glcorearb.h:103
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glcorearb.h:2539
RE_TextureDimension
bool getAutoCompression() const
unsigned long long uint64
Definition: SYS_Types.h:117
int getDepth() const
int getMaxAnisotropy() const
float getLodBias() const
virtual int getGLCreateType() const
virtual bool hasMipMapSupport(RE_Render *)
RE_TexFiltType getMagFilter() const
int getInternalFormat() const
RE_TextureDimension getTextureType() const
RE_TexFiltType
bool hasFileModTime() const
CompareResults OIIO_API compare(const ImageBuf &A, const ImageBuf &B, float failthresh, float warnthresh, ROI roi={}, int nthreads=0)
RE_GPUType
Definition: RE_Types.h:44
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
bool getWrapR() const
RE_TextureID getID() const
RE_TextureCompress myCompression
unsigned int RE_TextureID
bool getWrapT() const
time_t getFileModTime() const
RE_TextureFormatExtra
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
GLfloat green
Definition: glcorearb.h:112
RE_TexClampType
int getFormatSize() const
long long int64
Definition: SYS_Types.h:116
virtual bool hasTextureSupport(RE_Render *r)
GLfloat GLfloat GLfloat alpha
Definition: glcorearb.h:112
RE_TextureCompress getCompression() const
RE_TextureBorder
int64 getScanBytes() const
GLint GLint xoffset
Definition: glcorearb.h:411
GLuint const GLchar * name
Definition: glcorearb.h:786
int getMaxAnisotropy() const
int getHeight() const
GLint GLenum GLint x
Definition: glcorearb.h:409
GLdouble t
Definition: glad.h:2397
RE_TexFiltType getMinFilter() const
GLsizei samples
Definition: glcorearb.h:1298
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glcorearb.h:476
uint64 getTextureHandle() const
IMG_FileAlphaInfo
RE_TextureDataType
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2002
virtual bool isValid() const
Cached object implementation for RE_TextureCache.
float getTexS() const
float getLodBias() const
GLint GLint GLsizei GLint border
Definition: glcorearb.h:108
SIM_API const UT_StringHolder force
RE_TexClampType getWrapR() const
RE_TexClampType getWrapS() const
RE_TextureDataType getDataType() const
GLuint index
Definition: glcorearb.h:786
RE_GPUType getFormatType() const
RE_TexFiltType getMinFilter() const
void setAlphaInfo(IMG_FileAlphaInfo a)
GLint GLsizei width
Definition: glcorearb.h:103
IMG_FileAlphaInfo getAlphaInfo() const
int getGLWidth() const
void setDataType(RE_TextureDataType type)
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
float getTexT() const
GLboolean r
Definition: glcorearb.h:1222
GLfloat GLfloat blue
Definition: glcorearb.h:112
RE_TextureCompress
RE_TexClampType getWrapT() const
type
Definition: core.h:1059
FMT_INLINE void print(format_string< T...> fmt, T &&...args)
Definition: core.h:2976
bool getMipMap() const
RE_TextureCompare
png_structrp int png_fixed_point red
Definition: png.h:1083
bool isMutable() const
Definition: RE_OGLTexture.h:64
GLint GLint GLint GLint zoffset
Definition: glcorearb.h:477
void setFormat(RE_GPUType data, int vectorsize, RE_TextureFormatExtra format_extra=RE_TEXTURE_FORMAT_EXTRA_NONE)
Definition: format.h:895
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297
GLenum src
Definition: glcorearb.h:1793