IMG_TextureFilter.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.
 *
 * NAME:        IMG_TextureFilter.h ( IMG Library, C++)
 *
 * COMMENTS:    This class holds filter information required for texture
 *              evaluation.
 */

#ifndef __IMG_TextureFilter__
#define __IMG_TextureFilter__

#include "IMG_API.h"
#include <UT/UT_Vector4.h>
#include <UT/UT_String.h>
#include <UT/UT_FilterType.h>
#include <UT/UT_Filter.h>
#include <PXL/PXL_Common.h>

class UT_Filter;
class UT_FilterWindow;

enum IMG_DeepInterp
{
    IMG_DEEP_DISCRETE = 0,      // Step interpolation of z samples
    IMG_DEEP_LINEAR = 1         // Linear interpolation of z samples
};

/// Modes for how to translate colors in images for texture lookups
enum IMG_ColorSpace
{
    IMG_COLORSPACE_AUTO,        // Determine automatically
    IMG_COLORSPACE_LINEAR,      // Direct linear translation
    IMG_COLORSPACE_SRGB,        // sRGB
    IMG_COLORSPACE_REC709,      // Rec709
    IMG_COLORSPACE_GAMMA22,     // Gamma 2.2
};

IMG_API extern const char       *IMGcolorSpace(IMG_ColorSpace cs);
IMG_API extern IMG_ColorSpace    IMGcolorSpace(const char *cs);
IMG_API extern IMG_ColorSpace    IMGcolorSpaceFromPXL(PXL_ColorSpace cs);
IMG_API extern PXL_ColorSpace    PXLcolorSpaceFromIMG(IMG_ColorSpace cs);

/// Modes for filtering
class IMG_API IMG_TextureFilter
{
public:
    enum FilterMode
    {
        IMG_UTFILTER,   // Use UT_Filter for evaluation
        IMG_BILINEAR,           // Bilinear interpolation
        IMG_BIQUADRATIC,        // Biquadratic interpolation
        IMG_BICUBIC,            // Bicubic interpolation
    };

     IMG_TextureFilter();
     IMG_TextureFilter(const IMG_TextureFilter &rhs);
    ~IMG_TextureFilter();

    IMG_TextureFilter   &operator=(const IMG_TextureFilter &rhs);

    /// 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; }

    // Returns true if the filter or widths changed
    bool                 setFilter(UT_FilterType ftype,
                                   float x, float y);
    bool                 setXFilter(UT_FilterType ftype);
    bool                 setYFilter(UT_FilterType ftype);
    bool                 setFilterWidths(float x, float y);
    bool                 setFilterBlurs(float x, float y);
    bool                 setMipInterpolate(int onoff);
    bool                 setWrap(UT_FilterWrap uwrap, UT_FilterWrap vwrap,
                                 const UT_Vector4 &border);
    bool                 setDeepInterp(IMG_DeepInterp interp);
    bool                 setSourceColorSpace(IMG_ColorSpace convert);
    bool                 setZSkew(float zskew);
    bool                 setZWidth(float z);
    void                 swapBorder(UT_Vector4 &b, int ncomponents=4);

    FilterMode           filterMode() const { return myFilterMode; }
    bool                 setFilterMode(FilterMode m);
    const UT_Filter     *getXFilter() const { return myXFilter; }
    const UT_Filter     *getYFilter() const { return myYFilter; }

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

    UT_FilterWrap        getXWrap() const       { return myXWrap; }
    UT_FilterWrap        getYWrap() const       { return myYWrap; }
    const UT_Vector4    &getBorder() const      { return myBorder; }

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

    bool                 setBeerLambert(bool b);
    bool                 beerLambert() const { return myBeerLambert; }

    void        dump() const;

public:
    UT_String            myChannelName;
    UT_Filter           *myXFilter, *myYFilter;
    float                myXWidth, myYWidth;
    UT_FilterWrap        myXWrap, myYWrap;
    UT_Vector4           myBorder;
    int                  myInterp;
    IMG_DeepInterp       myDeepInterp;
    IMG_ColorSpace       mySourceColorSpace;
    FilterMode           myFilterMode;
    int                  myChannelIndex;
    float                myXBlur, myYBlur;
    UT_Vector3           myZEqn;
    float                myZSkew;
    float                myZWidth;
    bool                 myBeerLambert;
    bool                 myOwnFilter;
};

#endif