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