TIL/TIL_TextureMap.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        UT library (C++)
 *
 * COMMENTS:    There are two classes defined here.  If you're using one,
 *              you'll use the other:
 *                 TIL_TextureMap   - a texture map.  It knows how to lookup
 *                                      it's raster for you.
 *                 TIL_TextureCache - The cache control specifies parameters
 *                                      used in the internal cache for
 *                                      texture maps
 *                                   This class is simply a verb class which
 *                                      accesses an internal class.
 *
 *              The only way to get at the texture cache is through a
 *              TIL_TextureMap.  This allows the cache to keep a good
 *              record of references.  The rasters are loaded on demand
 *              which means that unless you look up a color, you don't
 *              load the raster.
 *
 */

#ifndef _TIL_TextureMap_h_
#define _TIL_TextureMap_h_

#include "TIL_API.h"
#include <iostream.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_FilterType.h>
#include <UT/UT_String.h>
#include <IMG/IMG_FileTypes.h>

class TIL_Raster;
class TIL_TextureMap;
class IMG_TTFilterInfo;
class IMG_FileTTMap;
class UT_Vector3;
class UT_Options;
class ut_Map;                   // Internal structure
class UT_Filter;
class UT_OpCaller;

//
//  An enum for bump map computation type
//

typedef enum {
        TIL_BUMP_PRECOMPUTE,
        TIL_BUMP_COMPUTE_R,
        TIL_BUMP_COMPUTE_G,
        TIL_BUMP_COMPUTE_B,
        TIL_BUMP_COMPUTE_A,
        TIL_BUMP_COMPUTE_LUM
} TIL_BUMP_COMPUTE_TYPE;

// WARNING:  These enums should match the enums in IMG_FileTTMap.h

typedef enum {
        IMG_DEEP_DISCRETE = 0,
        IMG_DEEP_LINEAR = 1
} IMG_DEEP_INTERP;

//
//  Lookup function definitions
typedef void    (*TIL_COLORLUF)(const TIL_TextureMap *map, void *data,
                                float u, float v, float *result, int validate);
typedef void    (*TIL_AACOLORLUF)(const TIL_TextureMap *map, void *data,
                                float u[4], float v[4], float *result,
                                int ns, int);
typedef void    (*TIL_DEPTHLUF)(const TIL_TextureMap *map, void *data,
                                float u, float v, float *result,
                                float farVal, int validate);
typedef void    (*TIL_BUMPLUF)(const TIL_TextureMap *map, void *data,
                                float u, float v, float *dx, float *dy,
                                int validate);


typedef void    *(*TIL_AllocateFunc)(int size);
typedef void     (*TIL_FreeFunc)(void *data);
typedef int      (*TIL_TexRenderIndexFunc)();
typedef void     (*TIL_TexRenderAllocateFunc)(int idx, TIL_Raster *rp);
typedef void     (*TIL_TexRenderFreeFunc)(int idx);

class TIL_API TIL_TextureMapStat {
public:
    const char          *myFilename;            // Filename for the raster
    int                  myXres, myYres;        // Resolution
    int                  myRampNodes;
    int                  myImageCount;          // Image count...
    int                  myMemory;
    int                  myOwnership;           // If it's a COP, this will be 0
};

//
//  The texture cache control class
//

class TIL_API TIL_TextureCache
{
public:
//
//  Limit the raster size of a texture map to the size specified
    static int          getMaxWidth(void);
    static int          getMaxHeight(void);
    static void         setMaxSize(int w=256, int h=256);

//
//  Limit the maximum number of maps in core at once
    static int          getCacheSize(void);
    static void         setCacheSize(int size=100);

//  Limit the maps to max amount of memory (in Mb)
    static int          getCacheMemSize();
    static void         setCacheMemSize(int sizeinmb);

//
//  Query methods for the cache.  When getting the stats, the stat array should
//  be at least as large as the image count.
    static int           getImageCount();
    static int           getImageStat(TIL_TextureMapStat stats[]);

    // Simple method to get memory usage
    static int64         getMemoryUsage();
    
//
// The version of the cache updates everytime something in it changes
// or is removed.  This way we can clear display lists, etc.
    static int           getVersion();


//
//  Flush all maps out of core.
    static void clearCache(int only_out_of_date=0);

//
//  Flush a map  by name.
    static void clearCache(const char *mapname);

//
//  Set auto-flushing of the cache.  That is, as soon as the map is
//      dereferenced completely, flush it from the cache.  This can slow
//      some applications down.
    static int          getAutoFlush(void);
    static void         setAutoFlush(int onOff);

//
//  Set an output stream for errors
    static void         setVerbose(ostream *os);

//
//  Here's where we define our code to define stuff for a renderer
    static void         setRenderAllocator(TIL_TexRenderIndexFunc mapper,
                                   TIL_TexRenderAllocateFunc allocfunc,
                                   TIL_TexRenderFreeFunc freefunc);

//
// Inform the cache of any deleted rasters that it may be referencing
    static void         rasterDied(TIL_Raster *raster);
    static void         imageDataDied(void *imagedata); // for COPs 1.

//
// Release all the bound texture indices.  This will bump the version if any
// indices are released, invalidating all display lists.
    static void         clearRenderIndices();

// Set a flag to indicate that textures should be converted to .rat format
// on load.
    static void          setRATConvert(bool on);
    static bool          getRATConvert();

};


class TIL_API TIL_TextureMap {
public:
             TIL_TextureMap(const char *mapname = 0, const char *relativeTo = 0,
                            TIL_Raster *rp = 0);
    virtual ~TIL_TextureMap();

    void                 setOpCaller(UT_OpCaller *c)    { myCaller = c; }
    void                 setMap(const char *name, const char *relativeTo,
                                TIL_Raster *rp = 0, bool always_resolve = true);

    // Set a flag indicating whether the map should be rendered or not.
    void                 setRenderFlag(int on) { myRenderFlag = on; }

    void                 clearRaster();
    void                 forceReload(void);
    const char          *getMap(void) const;
    TIL_Raster          *getOGLRaster();
    const UT_Options    *getTextureOptions() const;
    int                  getRenderIndex();
    void                 clearRenderIndex();
    int                  queryCurrentRenderIndex() const;
    int                  getIdealSamples(float du, float dv);
    void                 getResolution(int &x, int &y);
    int                  getNChannels() const;

    // The color channel name may be NULL representing the default channel
    void                 setColorChannelName(const char *name);
    const char          *getColorChannelName() const;

    void                 setFilter(UT_FilterType filter, float xw, float yw);
    void                 setXFilter(UT_FilterType filter);
    void                 setYFilter(UT_FilterType filter);
    void                 setFilterWidths(float xwidth, float ywidth);
    void                 setFilterBlurs(float xblur, float yblur);
    void                 setMipInterpolate(int onoff);
    void                 setWrapMode(UT_FilterWrap uwrap, UT_FilterWrap vwrap,
                                        const UT_Vector4 &border);
    void                 setDeepInterp(IMG_DEEP_INTERP interp);
    void                 setZSkew(float zskew);


    const UT_Filter       *getXFilter() const           { return myXFilter; };
    const UT_Filter       *getYFilter() const           { return myYFilter; };
    float                  getXFilterWidth() const      { return myFilterX; }
    float                  getYFilterWidth() const      { return myFilterY; }

//
//  Functions used to set the color lookup behaviour of the map
    void                setColorLookup(int nointerp = 0, int needAlpha = 1)
                        {
                            myInterpRequired = !nointerp;
                            myAlphaRequired = needAlpha;
                            myColorLookup = 0;
                            myAAColorLookup = 0;
                        }
    void                setBumpLookup(int interp = 1,
                                TIL_BUMP_COMPUTE_TYPE type=TIL_BUMP_PRECOMPUTE)
                        {
                            myInterpRequired = !interp;
                            myBumpType = type;
                            myBumpLookup = 0;
                        }

// For depth or bump maps, the color model should be abgr otherwise it
// should be rgba
    void                setColorModel(int abgr=0);

//
//  Lookup a single sample of the image, interpreting the map as a color
//  When specifying four corners of the map, the order of the coordinates
//  is very important:
//
//      BAD                     GOOD                    GOOD
//      2--3                    3--2                    2--3
//       \/                     |  |                    |  |
//       /\                     |  |                    |  |
//      0--1                    0--1                    1--0

    UT_FilterWrap        getUWrap() const        { return myUWrap; }
    UT_FilterWrap        getVWrap() const        { return myVWrap; }
    const UT_Vector4    &getBorderColor() const  { return myBorderColor; }
    const UT_Vector4    &getBorderBase() const   { return myBaseBorder; }

    // If the texture failed to load, this method will tell us whether it
    // is using the default lookup functionality.
    bool                isDefault() const;
    int                 isRAT() const;
    int                 isDSM() const;

    void                colorLookup(float u, float v, UT_Vector4 &clr,
                                        int validate=1) const;
    void                colorLookup(float u[4], float v[4], int maxsamples,
                                UT_Vector4 &clr, int validate=1) const;
    float               depthLookup(float u, float v, float farValue=1E6,
                                    int validate=1) const;
    void                bumpLookup(float u, float v,
                                    float *du, float *dv, int validate=1) const;

    void                envLookup(const UT_Vector3 &R, UT_Vector4 &clr,
                                    float uscale=1, float vscale=1,
                                    int validate=1) const;

    void                envLookup(const UT_Vector3 &r00, const UT_Vector3 &r10,
                                  const UT_Vector3 &r11, const UT_Vector3 &r01,
                                  UT_Vector4 &clr, int maxsamples,
                                  float uscale=1, float vscale=1,
                                  int validate=1) const;

    /// Deep shadow lookup will fall back to regular depth map lookups
    /// if this map is not a deep shadow map.
    void                deepLookup(UT_Vector3 &clr, 
                                   const UT_Vector3 &p,
                                   const UT_Vector3 &du,
                                   const UT_Vector3 &dv,
                                   float quality, int maxsamples,
                                   int validate);
    void                deepLookup(UT_Vector3 &clr, 
                                   const UT_Vector3 &p, 
                                   float du, float dv,
                                   float quality, int maxsamples, 
                                   int validate);

    const IMG_TTFilterInfo      &getFilterInfo() const  { return *myRATFilter; }

    // Adjust scales should only be called internally.
    void                         adjustScales(float scale);
    TIL_BUMP_COMPUTE_TYPE        getBumpCompute() const
                                 {
                                     return myBumpType;
                                 }

    int          getInterpRequired() const      { return myInterpRequired; }
    int          getAlphaRequired() const       { return myAlphaRequired; }

    // Returns true if the texture is volatile (ie, sourced from a COP). It
    // needs to be checked every time it's accessed to se if it's been updated.
    bool         isVolatileTexture() const;

    // Returns true if a volatile texture has changed, and optionally returns
    // the new raster in the newraster parm.
    bool         hasTextureChanged(const TIL_Raster **newraster = 0);

    // Returns the raw texture map (may be NULL).
    IMG_FileTTMap       *getRawTexture();

    // Look up the color channel index
    int                  getColorChannelIndex(IMG_FileTTMap *map) const;

private:
    float               shadowLookup(const UT_Vector3 &p,
                                     const UT_Vector3 &du,
                                     const UT_Vector3 &dv,
                                     float quality, int maxsamples,
                                     int validate) const;

    // This version of the shadow lookup is used when there are no 
    // derivatives available (for non-shading contexts)
    float               shadowLookup(const UT_Vector3 &Ps,
                                     float du, float dv, 
                                     float quality, int maxsamples, 
                                     int validate) const;
    
private:
    ut_Map                      *myMap;
    UT_OpCaller                 *myCaller;
    TIL_COLORLUF                 myColorLookup;
    TIL_AACOLORLUF               myAAColorLookup;
    TIL_DEPTHLUF                 myDepthLookup;
    TIL_BUMPLUF                  myBumpLookup;

    IMG_TTFilterInfo            *myRATFilter;
    UT_Filter                   *myXFilter, *myYFilter;
    float                        myFilterX, myFilterY;  // Filter Radius
    UT_FilterType                myXFilterType, myYFilterType;
    UT_Vector4                   myBorderColor;
    UT_Vector4                   myBaseBorder;

    int                          myInterpRequired, myAlphaRequired;
    TIL_BUMP_COMPUTE_TYPE        myBumpType;
    UT_FilterWrap                myUWrap, myVWrap;
    UT_String                    myColorChannel;
    int                          myRenderFlag;
    short                        myBorderScaled;
    friend class                 ut_Map;
};


#endif

---