HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TIL_TextureMap.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: UT library (C++)
7  *
8  * COMMENTS: There are two classes defined here. If you're using one,
9  * you'll use the other:
10  * TIL_TextureMap - a texture map. It knows how to lookup
11  * it's raster for you.
12  * TIL_TextureCache - The cache control specifies parameters
13  * used in the internal cache for
14  * texture maps
15  * This class is simply a verb class which
16  * accesses an internal class.
17  *
18  * The only way to get at the texture cache is through a
19  * TIL_TextureMap. This allows the cache to keep a good
20  * record of references. The rasters are loaded on demand
21  * which means that unless you look up a color, you don't
22  * load the raster.
23  *
24  */
25 
26 #ifndef _TIL_TextureMap_h_
27 #define _TIL_TextureMap_h_
28 
29 #include "TIL_API.h"
30 #include <IMG/IMG_FileTypes.h>
31 #include <IMG/IMG_TextureFilter.h>
32 #include <UT/UT_FilterType.h>
33 #include <UT/UT_JSONWriter.h>
34 #include <UT/UT_NonCopyable.h>
35 #include <UT/UT_Options.h>
36 #include <UT/UT_Rect.h>
37 #include <UT/UT_Set.h>
38 #include <UT/UT_SharedPtr.h>
39 #include <UT/UT_String.h>
40 #include <UT/UT_Vector4.h>
41 
42 class TIL_Raster;
43 class TIL_TextureMap;
44 class TIL_Cdf2D;
45 class IMG_TTFilterInfo;
46 class IMG_File;
47 class IMG_FileTTMap;
48 class UT_Options;
49 class til_Map; // Internal structure
50 class til_Lookup; // Internal structure
51 class TIL_TextureRaster; // Not exposed through HDK
52 class UT_Filter;
53 class UT_OpCaller;
54 
55 //
56 // An enum for bump map computation type
57 //
58 
60 {
67 };
68 
70 {
71  TIL_PTEX_COMPLEMENT_S = 0x01, // Complement the S coordinate
72  TIL_PTEX_COMPLEMENT_T = 0x02, // Complement the T coordinate
73  TIL_PTEX_SWAP_ST = 0x04, // Swap S/T coordinates
74 
75  // Orientation matching http://ptex.us
77 
78  // The following are based on experimental evidence and may not be correct
79  // Mudbox has the t coordinate flipped and the ST coordinats swapped
81 };
82 
84 {
85 public:
86  /// Callback for missing texture
88  virtual ~TIL_MissingTexture();
90 
91  /// Callback invoked when a texture can't be found. It's possible @c
92  /// filename may be a @c nullptr.
93  virtual void missingTexture(const char *filename) const {};
94 
95  /// Callback invoked when a texture is converted internally to a .rat
96  virtual void convertToRat(const char *filename) const {};
97 };
98 
100 public:
101  const char *myFilename; // Filename for the raster
102  int myXres, myYres; // Resolution
104  int myImageCount; // Image count...
106  int myOwnership; // If it's a COP, this will be 0
107 };
108 
110 public:
112  : myOptions(NULL)
113  , myShared()
114  { }
116  : myOptions(options)
117  , myShared()
118  { }
121  : myOptions(options)
122  , myShared(shared)
123  { }
125  : myOptions(opts.myOptions)
126  , myShared(opts.myShared)
127  { }
129 
131  {
132  if (&src != this)
133  {
134  myShared = src.myShared;
135  myOptions = src.myOptions;
136  }
137  return *this;
138  }
139 
140  const UT_Options *get() const { return myOptions; }
141 
142 private:
143  const UT_Options *myOptions;
144  UT_SharedPtr<UT_Options> myShared;
145 };
146 
147 //
148 // The texture cache control class
149 //
151 {
152 public:
153 //
154 // Limit the raster size of a texture map to the size specified
155  static int getMaxWidth();
156  static int getMaxHeight();
157  static void setMaxSize(int w=256, int h=256);
158 
159 //
160 // Limit the maximum number of maps in core at once
161  static int getCacheSize();
162  static void setCacheSize(int size=100);
163 
164 // Limit the maps to max amount of memory (in Mb)
165  static int64 getCacheMemSize();
166  static void setCacheMemSize(int64 sizeinmb);
167 
168 //
169 // Query methods for the cache.
170  static void getImageStat(UT_Array<TIL_TextureMapStat> &stats);
171 
172  // Simple method to get memory usage
173  static int64 getMemoryUsage();
174 
175  static void getConversionStats(exint &num_conversions,
176  exint &current_memory,
177  exint &peak_memory);
178 
179  static void storeTexture(const UT_StringHolder &name,
181  static void eraseTexture(const UT_StringHolder &name);
182 
184  {
186 
187  int max_open_files = 0;
188  float max_memory_MB = 0;
189  int autotile = 0;
190  int autoscanline = 0;
191  int automip = 0;
192  int forcefloat = 0;
193  int accept_untiled = 0;
194  int accept_unmipped = 0;
195  int deduplicate = 0;
196  int unassociatedalpha = 0;
197  int failure_retries = 0;
198  int max_errors_per_file = 0;
199  int trust_file_extensions = 0;
200  int max_mip_res = 0;
201 
202  // Read-only options
203  int64 cache_memory_used = 0;
204  int tiles_created = 0;
205  int tiles_current = 0;
206  int tiles_peak = 0;
207  int open_files_created = 0;
208  int open_files_current = 0;
209  int open_files_peak = 0;
210 
211  int64 image_size = 0; // total size
212  int64 file_size = 0; // total size on disk
213  int64 bytes_read = 0; // bytes read
214  int unique_files = 0;
215  float fileio_time = 0;
216  float fileopen_time = 0;
217  };
218  static bool getOIIOStats(OIIOStats &stats);
219 
220  static UT_StringHolder getOIIOStats(int level=1);
221 
223  {
231  };
232  static void getPtexStats(PtexStats &stats);
233 
234  // List of all invalid textures since the cache was last cleared
236  : public UT_NonCopyable
237  {
238  ErrorFiles();
239  ~ErrorFiles();
240 
242  };
243  static ErrorFiles getErrorFiles();
244 
245 //
246 // The version of the cache updates everytime something in it changes
247 // or is removed. This way we can clear display lists, etc.
248  static int getVersion();
249 
250  static void bumpVersion();
251 
252 //
253 // Flush all maps out of core.
254  static void clearCache(int only_out_of_date=0);
255 
256 //
257 // Flush a map by name.
258  static void clearCache(const UT_StringRef &mapname);
259 
260 //
261 // Set auto-flushing of the cache. That is, as soon as the map is
262 // dereferenced completely, flush it from the cache. This can slow
263 // some applications down.
264  static int getAutoFlush();
265  static void setAutoFlush(int onOff);
266 
267 //
268 // Inform the cache of any deleted rasters that it may be referencing
269  static void rasterDied(TIL_Raster *raster);
270  static void imageDataDied(void *imagedata); // for COPs 1.
271 
272 //
273 // If a texture map is not a .rat file, exit with an error on load.
274  static void setNonRATError(bool on);
275  static bool getNonRATError();
276 };
277 
278 class til_PtexData;
279 class til_OIIOData;
280 
282 {
283 public:
285  : myLookup(0)
286  , myPtex()
287  , myOIIO()
288  {
289  }
290 
291  bool isPtex() const { return myPtex != nullptr; }
292  bool isOIIO() const { return myOIIO != nullptr; }
293 
294  const til_Lookup *lookup() const { return myLookup.get(); }
295  const til_PtexData *ptexData() const { return myPtex.get(); }
296  const til_OIIOData *oiioData() const { return myOIIO.get(); }
297 
298 private:
302 
303  UT_SharedPtr<til_Lookup> myLookup;
306  friend class TIL_TextureMap;
307 };
308 
310 {
311 public:
312  // Information about a texture
313  struct TextureInfo
314  {
315  void dump() const;
316 
317  bool isValid() const { return myMipMapRes.size() > 0; }
318  bool mipMapped() const { return myMipMapRes.size() > 1; }
319  int mipCount() const { return myMipMapRes.size(); }
320 
322  PXL_DataFormat myDataFormat = PXL_INT8;
323  int myChannelCount = 0;
324  int myMipOffset = 0;
325  };
326 
328  {
329  forceDiskCache(bool enable=true)
330  : myEnable(enable)
331  {
332  }
333  bool myEnable;
334  };
335 
337  const char *relativeTo = nullptr,
338  TIL_Raster *rp = nullptr);
339 
340  TIL_TextureMap(const UT_StringHolder &mapname, const forceDiskCache &);
341 
342  virtual ~TIL_TextureMap();
343 
345 
346  /// Returns whether a filename has UDIM formatting characters
347  static bool hasUDIM(const char *format);
348 
349  /// Expand a file containing %(UDIM)d, %(U)d or %(V)d formatting characters
350  /// The @c iu and @c iv parameters passed in are the zero-based coordinates
351  /// (i.e. UDIM == (1000 + iu+1+ 10*iv) and U == iu+1).
352  ///
353  /// For example: expandUDIM("%s/%s_%(UDIM)%d_%(U)02d_%(V)d.rat", 3, 7)
354  /// will return "%s/%s_1074_04_8.rat"
355  static UT_StringHolder expandUDIM(const char *format, int iu, int iv);
356 
357  /// Set the callback for missing textures. This returns the previous
358  /// callback.
359  static const TIL_MissingTexture *setMissingTexture(
360  const TIL_MissingTexture *m);
361 
362  /// Access the missing texture callback without having to set it
363  static const TIL_MissingTexture *getMissingTexture();
364 
365  /// Check existence of a texture map.
366  static bool mapExists(const UT_StringRef &name);
367 
368  /// Check existence of a UDIM directory. The path passed in should be the
369  /// expanded UDIM texture path. This allows you to check for paths where
370  /// the <UDIM> token is in the directory name (rather than the filename).
371  ///
372  /// If the directory is missing, this will print a warning and notify the
373  /// missing texture callback.
374  static bool validUDIMDirectory(const UT_StringRef &udim_name);
375 
376  void setOpCaller(UT_OpCaller *c) { myCaller = c; }
377  void setMap(const UT_StringHolder &name,
378  const char *relativeTo,
379  TIL_Raster *rp = nullptr,
380  bool always_resolve = true,
381  bool force_disk_cache = false);
382  const UT_StringHolder &getMap() const;
383 
384  void clearRaster();
385  void forceReload();
386  const TIL_Raster *getOGLRaster();
387  TIL_TextureOptions getTextureOptions() const;
388  void getResolution(int &x, int &y)
389  { getResolution(getLookupHandle(), x, y); }
390  int getNChannels() const;
391 
392  // The color channel name may be NULL representing the default channel
393  void setColorChannelName(const UT_StringHolder &n);
394  const UT_StringHolder &getColorChannelName() const;
395 
396  // Set the face index
397  void setFaceIndex(int index);
398  int getFaceIndex() const { return myFaceIndex; }
399  // Set the subimage for OIIO lookup
400  void setSubimage(int i) { mySubimage = i; }
401  int getSubimage() const { return mySubimage; }
402  // Set the channel offset (offset into the tuple data)
403  void setPtexChannel(int index);
404  int getPtexChannel() const { return myPtexChannel; }
405 
406  // ptexture orientation
407  TIL_PtexOrient ptexOrient() const { return myPtexOrient; }
408  void setPtexOrient(TIL_PtexOrient o) { myPtexOrient = o; }
409 
410  void setFilter(UT_FilterType filter, float xw, float yw);
411  void setXFilter(UT_FilterType filter);
412  void setYFilter(UT_FilterType filter);
413  void setFilterWidths(float xwidth, float ywidth);
414  void setFilterBlurs(float xblur, float yblur);
415  void setMipInterpolate(int onoff);
416  void setWrapMode(UT_FilterWrap uwrap, UT_FilterWrap vwrap,
417  const UT_Vector4 &border);
418  void setDeepInterp(IMG_DeepInterp interp);
419  void setBeerLambert(bool beerlambert);
420  void setSourceColorSpace(IMG_ColorSpace convert);
421  void setFilterMode(IMG_TextureFilter::FilterMode m);
422  void setZSkew(float zskew);
423  // IES normalization- 0: none 1: max value (default) 2: preserve energy
425  {
426  myIESNormalization = mode;
427  }
428  void setIESAngleScale(float scale) { myIESAngleScale = scale; }
429 
430  const UT_Filter *getXFilter() const { return myFilter.getXFilter(); };
431  const UT_Filter *getYFilter() const { return myFilter.getYFilter(); };
432  float getXFilterWidth() const { return myFilter.getXWidth(); }
433  float getYFilterWidth() const { return myFilter.getYWidth(); }
434 
435 //
436 // Functions used to set the color lookup behaviour of the map
437  void setColorLookup(bool interp = true,
438  bool needalpha = true)
439  {
440  myInterpRequired = interp;
441  myAlphaRequired = needalpha;
442  }
443  void setBumpLookup(bool interp = false,
445  {
446  myInterpRequired = interp;
447  myBumpType = type;
448  }
449 
450  UT_FilterWrap getUWrap() const { return myFilter.getXWrap(); }
451  UT_FilterWrap getVWrap() const { return myFilter.getYWrap(); }
452  const UT_Vector4 &getBorder() const { return myFilter.getBorder(); }
453 
454  // If the texture failed to load, this method will tell us whether it
455  // is using the default lookup functionality.
456  bool isDefault() const;
457  int isTTMap() const;
458  int isDSM() const;
459  bool isPtex() const;
460  bool isOIIO() const;
461  int isIES() const;
462 
463 //
464 // Lookup a single sample of the image, interpreting the map as a color
465 // When specifying four corners of the map, the order of the coordinates
466 // is very important:
467 //
468 // BAD GOOD GOOD
469 // 2--3 3--2 2--3
470 // \/ | | | |
471 // /\ | | | |
472 // 0--1 0--1 1--0
473 
474  /// When performing multiple texture evaluations, this allows the texture
475  /// class to pre-compute some common values rather than performing the
476  /// computation on every lookup.
477  TIL_TextureHandle getLookupHandle() const;
478 
479  /// @{
480  /// Evaluate using an automatic lookup handle
481  template <typename T>
482  inline void colorLookup(float u, float v, UT_Vector4T<T> &clr) const
483  {
484  TIL_TextureHandle h = getLookupHandle();
485  colorLookup(h, u, v, clr);
486  }
487  template <typename T>
488  inline void colorLookup(const float u[4], const float v[4],
489  UT_Vector4T<T> &clr) const
490  {
491  TIL_TextureHandle h = getLookupHandle();
492  colorLookup(h, u, v, clr);
493  }
494  fpreal depthLookup(float u, float v,
495  float farvalue=1E6) const
496  {
497  TIL_TextureHandle h = getLookupHandle();
498  return depthLookup(h, u, v, farvalue);
499  }
500  template <typename T>
501  void bumpLookup(float u, float v,
502  T &du, T &dv) const
503  {
504  TIL_TextureHandle h = getLookupHandle();
505  bumpLookup(h, u, v, du, dv);
506  }
507 
508  template <typename T>
509  inline void envLookup(const UT_Vector3T<T> &R, fpreal angle,
510  UT_Vector4T<T> &clr) const
511  {
512  TIL_TextureHandle h = getLookupHandle();
513  envLookup(h, R, angle, clr);
514  }
515 
516  template <typename T>
517  inline void envLookup(const UT_Vector3T<T> &r00, const UT_Vector3T<T> &r10,
518  const UT_Vector3T<T> &r11, const UT_Vector3T<T> &r01,
519  UT_Vector4T<T> &clr) const
520  {
521  TIL_TextureHandle h = getLookupHandle();
522  envLookup(h, r00, r10, r11, r01, clr);
523  }
524  /// @}
525 
526  /// @{
527  /// Evaluate using a lookup handle
528  void colorLookup(TIL_TextureHandle &h,
529  float u, float v, UT_Vector4F &clr) const;
530  void colorLookup(TIL_TextureHandle &h,
531  float u, float v, UT_Vector4D &clr) const;
532  void colorLookup(TIL_TextureHandle &h,
533  const float u[4], const float v[4],
534  UT_Vector4F &clr) const;
535  void colorLookup(TIL_TextureHandle &h,
536  const float u[4], const float v[4],
537  UT_Vector4D &clr) const;
538  float depthLookup(TIL_TextureHandle &h,
539  float u, float v,
540  float farvalue=1E6) const;
541  void bumpLookup(TIL_TextureHandle &h,
542  float u, float v,
543  fpreal32 &du, fpreal32 &dv) const;
544  void bumpLookup(TIL_TextureHandle &h,
545  float u, float v,
546  fpreal64 &du, fpreal64 &dv) const;
547 
548  void envLookup(TIL_TextureHandle &h,
549  const UT_Vector3F &R, fpreal angle,
550  UT_Vector4F &clr) const;
551  void envLookup(TIL_TextureHandle &h,
552  const UT_Vector3D &R, fpreal angle,
553  UT_Vector4D &clr) const;
554 
555  void envLookup(TIL_TextureHandle &h,
556  const UT_Vector3F &r00, const UT_Vector3F &r10,
557  const UT_Vector3F &r11, const UT_Vector3F &r01,
558  UT_Vector4 &clr) const;
559  void envLookup(TIL_TextureHandle &h,
560  const UT_Vector3D &r00, const UT_Vector3D &r10,
561  const UT_Vector3D &r11, const UT_Vector3D &r01,
562  UT_Vector4D &clr) const;
563  void getResolution(const TIL_TextureHandle &h,
564  int &x, int &y);
565  /// @}
566 
567  /// @{
568  /// Deep shadow lookup will fall back to regular depth map lookups
569  /// if this map is not a deep shadow map.
570  void deepLookup(TIL_TextureHandle &h,
571  UT_Vector3F &clr,
572  const UT_Vector3F &p,
573  const UT_Vector3F &du,
574  const UT_Vector3F &dv,
575  float quality, int maxsamples);
576  void deepLookup(TIL_TextureHandle &h,
577  UT_Vector3D &clr,
578  const UT_Vector3D &p,
579  const UT_Vector3D &du,
580  const UT_Vector3D &dv,
581  float quality, int maxsamples);
582  /// @}
583 
584  /// Query filter information
585  const IMG_TextureFilter &getFilter() const { return myFilter; }
586  IMG_TextureFilter &getFilter() { return myFilter; }
587 
588  // Adjust scales should only be called internally.
590  {
591  return myBumpType;
592  }
593 
594  bool getInterpRequired() const { return myInterpRequired; }
595  bool getAlphaRequired() const { return myAlphaRequired; }
596 
597  /// Get the OCIO color space associated with the file
598  const UT_StringHolder &ocioColorSpace() const;
599 
600  /// Lookup the wrap mode in metadata on the image. Returns false if
601  /// there's no metadata.
602  void wrapMode(UT_StringHolder &swrap,
603  UT_StringHolder &twrap) const;
604 
605  /// Load information about texture and MIP levels
606  bool textureInfo(TextureInfo &info) const;
607 
608  /// Load the raster for a given MIP level, possibly converting the data
609  bool loadMipRaster(int mip_level,
610  const TextureInfo &tinfo,
611  const UT_DimRect &region,
612  void *data);
613 
614  // Returns true if the texture is volatile (ie, sourced from a COP). It
615  // needs to be checked every time it's accessed to se if it's been updated.
616  bool isVolatileTexture() const;
617 
618  // Returns true if a volatile texture has changed, and optionally returns
619  // the new raster in the newraster parm.
620  bool hasTextureChanged(const TIL_Raster **newraster = 0);
621 
622  // Return the IMG File used (for TT maps). This may contain filters.
623  IMG_File *getFile();
624 
625  // Returns the unfiltered TT map.
626  IMG_FileTTMap *getTTMap();
627 
628  /// Return a 2d CDF for sampling
629  const TIL_Cdf2D *getCDF(int maxres=512);
630 
631  // Look up the color channel index
632  int getColorChannelIndex(IMG_FileTTMap *map) const;
633 
634 private:
635  void resolveHandles();
636  float shadowLookup(const UT_Vector3 &p,
637  const UT_Vector3 &du,
638  const UT_Vector3 &dv,
639  float quality, int maxsamples) const;
640 
641  // This version of the shadow lookup is used when there are no
642  // derivatives available (for non-shading contexts)
643  float shadowLookup(const UT_Vector3 &Ps,
644  float du, float dv,
645  float quality, int maxsamples) const;
646 
647  void updateHandles();
648 
649 private:
650  void updateFilter()
651  {
652  if (myOIIO || myPtex)
653  doUpdateFilter();
654  }
655  void doUpdateFilter();
656 
657  til_Map *myMap;
660  UT_OpCaller *myCaller;
661  IMG_TextureFilter myFilter;
662  UT_StringHolder myColorChannel;
663 
664  int myFaceIndex;
665  int mySubimage;
666  int myPtexChannel;
667  TIL_BUMP_COMPUTE_TYPE myBumpType;
668  TIL_PtexOrient myPtexOrient;
669  int myIESNormalization;
670  float myIESAngleScale;
671  bool myInterpRequired;
672  bool myAlphaRequired;
673 };
674 
675 #endif
type
Definition: core.h:556
TIL_TextureOptions(const UT_Options *options)
int getVersion(int version)
Definition: ImfVersion.h:99
bool isPtex() const
GT_API const UT_StringHolder filename
bool isOIIO() const
UT_FilterWrap getVWrap() const
virtual void convertToRat(const char *filename) const
Callback invoked when a texture is converted internally to a .rat.
const UT_Set< UT_StringHolder > * myFileList
TIL_BUMP_COMPUTE_TYPE getBumpCompute() const
const til_PtexData * ptexData() const
SIM_API const UT_StringHolder angle
const UT_Filter * getYFilter() const
const GLdouble * v
Definition: glcorearb.h:837
void colorLookup(float u, float v, UT_Vector4T< T > &clr) const
void colorLookup(const float u[4], const float v[4], UT_Vector4T< T > &clr) const
float getXFilterWidth() const
forceDiskCache(bool enable=true)
TIL_PtexOrient ptexOrient() const
int64 exint
Definition: SYS_Types.h:125
GLint level
Definition: glcorearb.h:108
TIL_MissingTexture()
Callback for missing texture.
UT_FilterWrap
Definition: UT_FilterType.h:40
int getFaceIndex() const
int getPtexChannel() const
GLint y
Definition: glcorearb.h:103
Tto convert(const Tfrom &source)
3D Vector class.
UT_FilterType
Definition: UT_FilterType.h:16
float fpreal32
Definition: SYS_Types.h:200
UT_Array< UT_Vector2i > myMipMapRes
fpreal depthLookup(float u, float v, float farvalue=1E6) const
void setPtexOrient(TIL_PtexOrient o)
int getSubimage() const
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:39
double fpreal64
Definition: SYS_Types.h:201
const IMG_TextureFilter & getFilter() const
Query filter information.
IMG_DeepInterp
GA_API const UT_StringHolder scale
GLdouble n
Definition: glcorearb.h:2008
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:108
IMG_TextureFilter & getFilter()
float getYFilterWidth() const
void setIESNormalization(int mode)
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:36
TIL_BUMP_COMPUTE_TYPE
OIIO_UTIL_API uint64_t file_size(string_view path) noexcept
TIL_TextureOptions(const TIL_TextureOptions &opts)
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
TIL_TextureOptions(const UT_Options *options, UT_SharedPtr< UT_Options > shared)
TIL_PtexOrient
#define UT_NON_COPYABLE(CLASS)
Define deleted copy constructor and assignment operator inside a class.
void setColorLookup(bool interp=true, bool needalpha=true)
const UT_Vector4 & getBorder() const
HUSD_API const char * raster()
long long int64
Definition: SYS_Types.h:116
const TIL_TextureOptions & operator=(const TIL_TextureOptions &src)
GLuint const GLchar * name
Definition: glcorearb.h:786
UT_FilterWrap getUWrap() const
const char * myFilename
PXL_DataFormat
Definition: PXL_Common.h:20
void setSubimage(int i)
void getResolution(int &x, int &y)
GLint GLenum GLint x
Definition: glcorearb.h:409
Modes for filtering.
GLenum mode
Definition: glcorearb.h:99
GLsizeiptr size
Definition: glcorearb.h:664
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2002
A map of string to various well defined value types.
Definition: UT_Options.h:84
GLint GLint GLsizei GLint border
Definition: glcorearb.h:108
bool getInterpRequired() const
const UT_Filter * getXFilter() const
fpreal64 fpreal
Definition: SYS_Types.h:278
GLuint index
Definition: glcorearb.h:786
void envLookup(const UT_Vector3T< T > &r00, const UT_Vector3T< T > &r10, const UT_Vector3T< T > &r11, const UT_Vector3T< T > &r01, UT_Vector4T< T > &clr) const
const til_OIIOData * oiioData() const
void envLookup(const UT_Vector3T< T > &R, fpreal angle, UT_Vector4T< T > &clr) const
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
OutGridT XformOp bool bool shared
IMG_ColorSpace
Modes for how to translate colors in images for texture lookups.
OIIO_API size_t max_open_files()
Get the maximum number of open file handles allowed on this system.
void bumpLookup(float u, float v, T &du, T &dv) const
#define TIL_API
Definition: TIL_API.h:10
void setBumpLookup(bool interp=false, TIL_BUMP_COMPUTE_TYPE type=TIL_BUMP_PRECOMPUTE)
bool getAlphaRequired() const
void setIESAngleScale(float scale)
Definition: format.h:1821
const til_Lookup * lookup() const
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297
GLenum src
Definition: glcorearb.h:1793