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 
324  };
325 
327  {
328  forceDiskCache(bool enable=true)
329  : myEnable(enable)
330  {
331  }
332  bool myEnable;
333  };
334 
336  const char *relativeTo = nullptr,
337  TIL_Raster *rp = nullptr);
338 
339  TIL_TextureMap(const UT_StringHolder &mapname, const forceDiskCache &);
340 
341  virtual ~TIL_TextureMap();
342 
344 
345  /// Returns whether a filename has UDIM formatting characters
346  static bool hasUDIM(const char *format);
347 
348  /// Expand a file containing %(UDIM)d, %(U)d or %(V)d formatting characters
349  /// The @c iu and @c iv parameters passed in are the zero-based coordinates
350  /// (i.e. UDIM == (1000 + iu+1+ 10*iv) and U == iu+1).
351  ///
352  /// For example: expandUDIM("%s/%s_%(UDIM)%d_%(U)02d_%(V)d.rat", 3, 7)
353  /// will return "%s/%s_1074_04_8.rat"
354  static UT_StringHolder expandUDIM(const char *format, int iu, int iv);
355 
356  /// Set the callback for missing textures. This returns the previous
357  /// callback.
358  static const TIL_MissingTexture *setMissingTexture(
359  const TIL_MissingTexture *m);
360 
361  /// Access the missing texture callback without having to set it
362  static const TIL_MissingTexture *getMissingTexture();
363 
364  /// Check existence of a texture map.
365  static bool mapExists(const UT_StringRef &name);
366 
367  /// Check existence of a UDIM directory. The path passed in should be the
368  /// expanded UDIM texture path. This allows you to check for paths where
369  /// the <UDIM> token is in the directory name (rather than the filename).
370  ///
371  /// If the directory is missing, this will print a warning and notify the
372  /// missing texture callback.
373  static bool validUDIMDirectory(const UT_StringRef &udim_name);
374 
375  void setOpCaller(UT_OpCaller *c) { myCaller = c; }
376  void setMap(const UT_StringHolder &name,
377  const char *relativeTo,
378  TIL_Raster *rp = nullptr,
379  bool always_resolve = true,
380  bool force_disk_cache = false);
381  const UT_StringHolder &getMap() const;
382 
383  void clearRaster();
384  void forceReload();
385  const TIL_Raster *getOGLRaster();
386  TIL_TextureOptions getTextureOptions() const;
387  void getResolution(int &x, int &y)
388  { getResolution(getLookupHandle(), x, y); }
389  int getNChannels() const;
390 
391  // The color channel name may be NULL representing the default channel
392  void setColorChannelName(const UT_StringHolder &n);
393  const UT_StringHolder &getColorChannelName() const;
394 
395  // Set the face index
396  void setFaceIndex(int index);
397  int getFaceIndex() const { return myFaceIndex; }
398  // Set the subimage for OIIO lookup
399  void setSubimage(int i) { mySubimage = i; }
400  int getSubimage() const { return mySubimage; }
401  // Set the channel offset (offset into the tuple data)
402  void setPtexChannel(int index);
403  int getPtexChannel() const { return myPtexChannel; }
404 
405  // ptexture orientation
406  TIL_PtexOrient ptexOrient() const { return myPtexOrient; }
407  void setPtexOrient(TIL_PtexOrient o) { myPtexOrient = o; }
408 
409  void setFilter(UT_FilterType filter, float xw, float yw);
410  void setXFilter(UT_FilterType filter);
411  void setYFilter(UT_FilterType filter);
412  void setFilterWidths(float xwidth, float ywidth);
413  void setFilterBlurs(float xblur, float yblur);
414  void setMipInterpolate(int onoff);
415  void setWrapMode(UT_FilterWrap uwrap, UT_FilterWrap vwrap,
416  const UT_Vector4 &border);
417  void setDeepInterp(IMG_DeepInterp interp);
418  void setBeerLambert(bool beerlambert);
419  void setSourceColorSpace(IMG_ColorSpace convert);
420  void setFilterMode(IMG_TextureFilter::FilterMode m);
421  void setZSkew(float zskew);
422  // IES normalization- 0: none 1: max value (default) 2: preserve energy
424  {
425  myIESNormalization = mode;
426  }
427  void setIESAngleScale(float scale) { myIESAngleScale = scale; }
428 
429  const UT_Filter *getXFilter() const { return myFilter.getXFilter(); };
430  const UT_Filter *getYFilter() const { return myFilter.getYFilter(); };
431  float getXFilterWidth() const { return myFilter.getXWidth(); }
432  float getYFilterWidth() const { return myFilter.getYWidth(); }
433 
434 //
435 // Functions used to set the color lookup behaviour of the map
436  void setColorLookup(bool interp = true,
437  bool needalpha = true)
438  {
439  myInterpRequired = interp;
440  myAlphaRequired = needalpha;
441  }
442  void setBumpLookup(bool interp = false,
444  {
445  myInterpRequired = interp;
446  myBumpType = type;
447  }
448 
449  UT_FilterWrap getUWrap() const { return myFilter.getXWrap(); }
450  UT_FilterWrap getVWrap() const { return myFilter.getYWrap(); }
451  const UT_Vector4 &getBorder() const { return myFilter.getBorder(); }
452 
453  // If the texture failed to load, this method will tell us whether it
454  // is using the default lookup functionality.
455  bool isDefault() const;
456  int isTTMap() const;
457  int isDSM() const;
458  bool isPtex() const;
459  bool isOIIO() const;
460  int isIES() const;
461 
462 //
463 // Lookup a single sample of the image, interpreting the map as a color
464 // When specifying four corners of the map, the order of the coordinates
465 // is very important:
466 //
467 // BAD GOOD GOOD
468 // 2--3 3--2 2--3
469 // \/ | | | |
470 // /\ | | | |
471 // 0--1 0--1 1--0
472 
473  /// When performing multiple texture evaluations, this allows the texture
474  /// class to pre-compute some common values rather than performing the
475  /// computation on every lookup.
476  TIL_TextureHandle getLookupHandle() const;
477 
478  /// @{
479  /// Evaluate using an automatic lookup handle
480  template <typename T>
481  inline void colorLookup(float u, float v, UT_Vector4T<T> &clr) const
482  {
483  TIL_TextureHandle h = getLookupHandle();
484  colorLookup(h, u, v, clr);
485  }
486  template <typename T>
487  inline void colorLookup(const float u[4], const float v[4],
488  UT_Vector4T<T> &clr) const
489  {
490  TIL_TextureHandle h = getLookupHandle();
491  colorLookup(h, u, v, clr);
492  }
493  fpreal depthLookup(float u, float v,
494  float farvalue=1E6) const
495  {
496  TIL_TextureHandle h = getLookupHandle();
497  return depthLookup(h, u, v, farvalue);
498  }
499  template <typename T>
500  void bumpLookup(float u, float v,
501  T &du, T &dv) const
502  {
503  TIL_TextureHandle h = getLookupHandle();
504  bumpLookup(h, u, v, du, dv);
505  }
506 
507  template <typename T>
508  inline void envLookup(const UT_Vector3T<T> &R, fpreal angle,
509  UT_Vector4T<T> &clr) const
510  {
511  TIL_TextureHandle h = getLookupHandle();
512  envLookup(h, R, angle, clr);
513  }
514 
515  template <typename T>
516  inline void envLookup(const UT_Vector3T<T> &r00, const UT_Vector3T<T> &r10,
517  const UT_Vector3T<T> &r11, const UT_Vector3T<T> &r01,
518  UT_Vector4T<T> &clr) const
519  {
520  TIL_TextureHandle h = getLookupHandle();
521  envLookup(h, r00, r10, r11, r01, clr);
522  }
523  /// @}
524 
525  /// @{
526  /// Evaluate using a lookup handle
527  void colorLookup(TIL_TextureHandle &h,
528  float u, float v, UT_Vector4F &clr) const;
529  void colorLookup(TIL_TextureHandle &h,
530  float u, float v, UT_Vector4D &clr) const;
531  void colorLookup(TIL_TextureHandle &h,
532  const float u[4], const float v[4],
533  UT_Vector4F &clr) const;
534  void colorLookup(TIL_TextureHandle &h,
535  const float u[4], const float v[4],
536  UT_Vector4D &clr) const;
537  float depthLookup(TIL_TextureHandle &h,
538  float u, float v,
539  float farvalue=1E6) const;
540  void bumpLookup(TIL_TextureHandle &h,
541  float u, float v,
542  fpreal32 &du, fpreal32 &dv) const;
543  void bumpLookup(TIL_TextureHandle &h,
544  float u, float v,
545  fpreal64 &du, fpreal64 &dv) const;
546 
547  void envLookup(TIL_TextureHandle &h,
548  const UT_Vector3F &R, fpreal angle,
549  UT_Vector4F &clr) const;
550  void envLookup(TIL_TextureHandle &h,
551  const UT_Vector3D &R, fpreal angle,
552  UT_Vector4D &clr) const;
553 
554  void envLookup(TIL_TextureHandle &h,
555  const UT_Vector3F &r00, const UT_Vector3F &r10,
556  const UT_Vector3F &r11, const UT_Vector3F &r01,
557  UT_Vector4 &clr) const;
558  void envLookup(TIL_TextureHandle &h,
559  const UT_Vector3D &r00, const UT_Vector3D &r10,
560  const UT_Vector3D &r11, const UT_Vector3D &r01,
561  UT_Vector4D &clr) const;
562  void getResolution(const TIL_TextureHandle &h,
563  int &x, int &y);
564  /// @}
565 
566  /// @{
567  /// Deep shadow lookup will fall back to regular depth map lookups
568  /// if this map is not a deep shadow map.
569  void deepLookup(TIL_TextureHandle &h,
570  UT_Vector3F &clr,
571  const UT_Vector3F &p,
572  const UT_Vector3F &du,
573  const UT_Vector3F &dv,
574  float quality, int maxsamples);
575  void deepLookup(TIL_TextureHandle &h,
576  UT_Vector3D &clr,
577  const UT_Vector3D &p,
578  const UT_Vector3D &du,
579  const UT_Vector3D &dv,
580  float quality, int maxsamples);
581  /// @}
582 
583  /// Query filter information
584  const IMG_TextureFilter &getFilter() const { return myFilter; }
585  IMG_TextureFilter &getFilter() { return myFilter; }
586 
587  // Adjust scales should only be called internally.
589  {
590  return myBumpType;
591  }
592 
593  bool getInterpRequired() const { return myInterpRequired; }
594  bool getAlphaRequired() const { return myAlphaRequired; }
595 
596  /// Get the OCIO color space associated with the file
597  const UT_StringHolder &ocioColorSpace() const;
598 
599  /// Lookup the wrap mode in metadata on the image. Returns false if
600  /// there's no metadata.
601  void wrapMode(UT_StringHolder &swrap,
602  UT_StringHolder &twrap) const;
603 
604  /// Load information about texture and MIP levels
605  bool textureInfo(TextureInfo &info) const;
606 
607  /// Load the raster for a given MIP level, possibly converting the data
608  bool loadMipRaster(int mip_level,
609  const UT_DimRect &region,
610  void *data);
611 
612  // Returns true if the texture is volatile (ie, sourced from a COP). It
613  // needs to be checked every time it's accessed to se if it's been updated.
614  bool isVolatileTexture() const;
615 
616  // Returns true if a volatile texture has changed, and optionally returns
617  // the new raster in the newraster parm.
618  bool hasTextureChanged(const TIL_Raster **newraster = 0);
619 
620  // Return the IMG File used (for TT maps). This may contain filters.
621  IMG_File *getFile();
622 
623  // Returns the unfiltered TT map.
624  IMG_FileTTMap *getTTMap();
625 
626  /// Return a 2d CDF for sampling
627  const TIL_Cdf2D *getCDF(int maxres=512);
628 
629  // Look up the color channel index
630  int getColorChannelIndex(IMG_FileTTMap *map) const;
631 
632 private:
633  void resolveHandles();
634  float shadowLookup(const UT_Vector3 &p,
635  const UT_Vector3 &du,
636  const UT_Vector3 &dv,
637  float quality, int maxsamples) const;
638 
639  // This version of the shadow lookup is used when there are no
640  // derivatives available (for non-shading contexts)
641  float shadowLookup(const UT_Vector3 &Ps,
642  float du, float dv,
643  float quality, int maxsamples) const;
644 
645  void updateHandles();
646 
647 private:
648  void updateFilter()
649  {
650  if (myOIIO || myPtex)
651  doUpdateFilter();
652  }
653  void doUpdateFilter();
654 
655  til_Map *myMap;
658  UT_OpCaller *myCaller;
659  IMG_TextureFilter myFilter;
660  UT_StringHolder myColorChannel;
661 
662  int myFaceIndex;
663  int mySubimage;
664  int myPtexChannel;
665  TIL_BUMP_COMPUTE_TYPE myBumpType;
666  TIL_PtexOrient myPtexOrient;
667  int myIESNormalization;
668  float myIESAngleScale;
669  bool myInterpRequired;
670  bool myAlphaRequired;
671 };
672 
673 #endif
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
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:277
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
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
type
Definition: core.h:1059
#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:895
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