IMG/IMG_FileTTMap.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:
 *      Andrew Clinton
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        IMG_FileTTMap.h ( IMG Library, C++)
 *
 * COMMENTS:    Tiled Texture Maps
 */

#ifndef __IMG_FileTTMap__
#define __IMG_FileTTMap__

#include <UT/UT_Vector4.h>
#include <UT/UT_FilterType.h>
#include <UT/UT_Filter.h>
#include "IMG_API.h"
#include "IMG_File.h"

class UT_Filter;
class UT_FilterWindow;
class UT_Options;
class IMG_TTMipSampler;
class IMG_Raster;
class TBF_Channel;

class img_DSMPixelHandle;

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

typedef enum {
        IMG_TT_DEEP_DISCRETE = 0,       // Step interpolation of z samples
        IMG_TT_DEEP_LINEAR = 1          // Linear interpolation of z samples
} IMG_TT_DEEP_INTERP;

class IMG_API IMG_TTFilterInfo {
public:
     IMG_TTFilterInfo();
     IMG_TTFilterInfo(const IMG_TTFilterInfo &rhs);
    ~IMG_TTFilterInfo();


    /// Get the channel name (i.e. the plane name)
    const char          *getChannelName() const { return myChannelName; }
    /// Get the channel index (i.e. the plane index).  The index is considered
    /// uninitialized if its value is < 0.
    int                  getChannelIndex() const { return myChannelIndex; }
    /// Set the channel name.  If this is different than the previous value,
    /// the channel index will be reset to -1.
    void                 setChannelName(const char *channel);
    /// Once the channel index has be resolved, stash the value here.
    void                 setChannelIndex(int i) { myChannelIndex = i; }

    void                 setFilter(UT_FilterType ftype,
                                   float x, float y);
    void                 setXFilter(UT_FilterType ftype);
    void                 setYFilter(UT_FilterType ftype);
    void                 setFilterWidths(float x, float y);
    void                 setFilterBlurs(float x, float y);
    void                 setMipInterpolate(int onoff);
    void                 setWrap(UT_FilterWrap uwrap, UT_FilterWrap vwrap,
                                 const UT_Vector4 &border);
    void                 setDeepInterp(IMG_TT_DEEP_INTERP interp);
    void                 setZSkew(float zskew)  { myZSkew = zskew; }
    void                 swapBorder(UT_Vector4 &b, int ncomponents=4);

    const UT_Filter     *getXFilter() const     { return myXFilter; }
    const UT_Filter     *getYFilter() const     { return myYFilter; }

    bool                 getMipInterpolate() const { return myInterp; }
    fpreal               getXWidth() const      { return myXWidth; }
    fpreal               getYWidth() const      { return myYWidth; }
    fpreal               getXBlur() const       { return myXBlur; }
    fpreal               getYBlur() const       { return myYBlur; }

    float                getXsupport() const { return myXFilter->getSupport(); }
    float                getYsupport() const { return myYFilter->getSupport(); }
    float                zskew() const { return myZSkew; }

public:
    UT_String            myChannelName;
    UT_Filter           *myXFilter, *myYFilter;
    float                myXWidth, myYWidth;
    UT_FilterWrap        myUWrap, myVWrap;
    UT_Vector4           myBorder;
    int                  myInterp;
    IMG_TT_DEEP_INTERP   myDeepInterp;
    int                  myChannelIndex;
    float                myXBlur, myYBlur;
    float                myZSkew;
    bool                 myOwnFilter;
};

/// An IMG_TTChannel is used to retrieve pixel data from the image.
/// Each image owns an array of IMG_TTChannel objects that could 
/// represent environment map rasters or mipmap levels.
class IMG_API IMG_TTChannel {
public:
             IMG_TTChannel();
    virtual ~IMG_TTChannel();

    virtual void         filterPixels(float *rgba, int nchan, 
                                      int first_x, int first_y, 
                                      const UT_Vector3 &zeqn,
                                      const float *xweights,
                                      const float *yweights,
                                      int usize, int vsize,
                                      IMG_TT_DEEP_INTERP interp) = 0;

    virtual void         getPixel(float *rgba, int nchan, int iu, int iv) = 0;

    /// This method returns the raw pixel data.
    virtual void         getPixel(void *pixel, int iu, int iv) = 0;

    /// This method is called when the channel is destructed
    virtual void         closeChannel() {};
};

/// A IMG_TTMap represents a tiled texture format that can be
/// sampled for texture mapping or for environment mapping.  This class 
/// supports methods for sampling and filtering the texture data.  
/// This class is pure virtual and so derived classes must override the 
/// image file and format operations.
class IMG_API IMG_FileTTMap : public IMG_File {
public:
             IMG_FileTTMap();
    virtual ~IMG_FileTTMap();

    virtual const char  *className() const { return "IMG_FileTTMap"; }

    int                          getOGLRaster(void *data, int xres, int yres,
                                      IMG_ColorModel cm, IMG_DataType dt,
                                      int raster_number=0);

    // Perform unfiltered evaluation at a specified uv.  This operation
    // will not even perform filtering on pixels, so the caller is
    // responsible for all filtering and antialiasing.
    void        unfilteredSample(
                        float *result, int tuple_size, float u, float v,
                        const IMG_TTFilterInfo &info,
                        int channel, int raster);

    // Perform a box filtering at the specified u/v.  The box filter is one
    // pixel wide.
    void        bilerp(float *result, int tuple_size, float u, float v,
                        const IMG_TTFilterInfo &info,
                        int channel, int raster);


    //  Sample the map within a quadrilateral in texture space.  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
    void        sample(float *result, float &visible, int tuple_size,
                        const float u[4], const float v[4],
                        int nsamples, float quality,
                        const IMG_TTFilterInfo &info,
                        const UT_Vector3 &zeqn,
                        int channel, int raster);
    void        sample(float *result, float &visible, int tuple_size,
                        const float u[4], const float v[4],
                        int nsamples, float quality,
                        const IMG_TTFilterInfo &info,
                        int channel, int raster)
                {
                    sample(result, visible,
                            tuple_size, u, v, nsamples, quality,
                            info, UT_Vector3(), channel, raster);
                }
    void        sample(float *result, int tuple_size,
                        const float u[4], const float v[4],
                        int nsamples, float quality,
                        const IMG_TTFilterInfo &info,
                        const UT_Vector3 &zeqn,
                        int channel, int raster)
                {
                    float       visible;
                    sample(result, visible,
                            tuple_size, u, v, nsamples, quality,
                            info, zeqn, channel, raster);
                }
    void        sample(float *result, int tuple_size,
                        const float u[4], const float v[4],
                        int nsamples, float quality,
                        const IMG_TTFilterInfo &info,
                        int channel, int raster)
                {
                    float       visible;
                    sample(result, visible,
                            tuple_size, u, v, nsamples, quality,
                            info, UT_Vector3(), channel, raster);
                }

    // Only call the envLookup functions if this RAT is really a cubic
    // environment map.
    void        envLookup(float *result, int tuple_size, const UT_Vector3 &r,
                          int channel);

    void        envLookup(float *result, int tuple_size,
                          const UT_Vector3 &r00, const UT_Vector3 &r01,
                          const UT_Vector3 &r11, const UT_Vector3 &r10,
                          const IMG_TTFilterInfo &info,
                          int channel);

    fpreal      getUPixelSize() const   { return myDx; }
    fpreal      getVPixelSize() const   { return myDy; }

    // New virtual methods for tiled textures
    virtual UT_Options  *getTextureOptions();

    // getChannelCount() is replaced with getChannelTupleSize()
    virtual int                  getRasterCount() const { return 0; }
    int                          getChannelTupleSize(int ch) const;
    virtual int                  getNumChannels() const { return 0; }
    virtual int                  findChannelIndex(const char *name,
                                        int raster_index) const
                                 {
                                     // Return first channel by default
                                     return 0;
                                 }
    
    virtual int                  isReflMap() const { return 0; }
    virtual int                  isDSM() const { return 0; }

    // API for raw DSM access.  Methos will fail if the map is not a DSM
    virtual void        dsmResolution(int &xres, int &yres);
    virtual int         dsmGetChannels(UT_PtrArray<TBF_Channel *>&channels);
    virtual img_DSMPixelHandle  *dsmGetReadHandle();
    virtual bool        dsmOpenRawPixel(img_DSMPixelHandle &h, int x, int y);
    virtual void        dsmDeleteReadHandle(img_DSMPixelHandle *h);
    virtual int         dsmDepthComplexity(const img_DSMPixelHandle &h);
    virtual bool        dsmPixelData(const img_DSMPixelHandle &h,
                                        int channel, fpreal *data,
                                        int data_size);

protected:
    void                         initialize(int xres, int yres,
                                            const fpreal *cscale,
                                            const int *csize,
                                            int mipcount,
                                            IMG_TTChannel **channels);

    virtual int                  closeFile();

protected:
    // Mipmap level to start reading from the file.
    int                   myMipRead;

private:
    //
    // Data used in lookup of pixel values.  These members MUST be 
    // initialized by derived classes before this class is used for 
    // sampling, by calling the initialize() method above.
    //
    void                  clearMips();

    // We have MIPs for each channel and raster
    int                   getMipOffset(int channel, int raster)
                          {
                                channel *= getRasterCount();
                                channel += raster;
                                return myMipCount * channel;
                          }

    float                 myDx, myDy;   // Inverse pixel sizes

    // Color scale is the inverse of the maximum value that a channel
    // element could take on.  For example, a byte would have 
    // myColorScale = 1.0F/255.0
    fpreal              *myColorScale;
    int                 *myColorSize;

    // Mipmap samplers are stored as an array of pointers, with each
    // entry representing one mipmap level.  If this class is an 
    // environment map, multiple sets of mipmaps may be stored sequentially
    // in this array.
    int                   myMipCount;
    IMG_TTMipSampler    **myMips;       // Mip Maps
};

#endif

---