image.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 Autodesk, Inc.
// All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//
//**************************************************************************/
// DESCRIPTION:
// CREATED: October 2008
//**************************************************************************/

#if !defined IMAGE_H_
#define IMAGE_H_

namespace mudbox {


class Image;
class SubdivisionLevel;
class TexturePool;

class MBDLL_DECL half_ {

// These member fcns are inlined for a reason; THESE ARE EXTREMELY PERFORMANCE CRITICAL!
// DO NOT change this file or "clean it up" by removing inlines. Unless you really know
// what you are doing, you will make it significantly slower.
//
private:
    unsigned short m_bits;
    void setBits(unsigned short newbits) { m_bits = newbits; }

public:
    half_ () {};
    half_ (float f)
    {
        unsigned int   x    = *(unsigned int *)&f;
        unsigned int   frac = (x >> 13) & 0x03ff;
        int            exp  = (int)((x >> 23) & 0xff) - 127;

        m_bits = (x >> 16) & 0x8000;  // extract the sign bit

        if (exp > 16) {      // handle overflows/underflows
            exp  = 16;
            frac = 0x03ff;
        } else if (exp <= -15) {
            frac = 0;
            exp  = -15;
        }

        m_bits |= ((exp + 15) << 10) | frac;
    }

public:
    // Conversion to float ~ 15 cycles
    #define ExponentBiasDelta (127-15)
    operator float () const
    {
        int           exp  = (m_bits >> 10) & 0x1f;
        unsigned int  f    = (m_bits & 0x8000) << 16; // extract the sign bit
        unsigned int  frac = (m_bits & 0x03ff) << 13;

        if (exp == 0x1f) {      // convert 16-bit FP inf/NaN to 32-bit inf/NaN value
            exp =  0xff - ExponentBiasDelta;
        } else if (exp == 0) {
            exp = -ExponentBiasDelta;  // convert 16-bit FP zero/denorm to 32-bit zero/denorm value
        }

        f |= ((exp + ExponentBiasDelta) << 23) | frac;
        return *(float *)&f;
    }

    half_ &operator = (float f)
    {
        *this = half_ (f);
        return *this;
    }
};

//------------------------------------------------------------------------------
typedef unsigned char  uInt8;
typedef unsigned short uInt16;


class uInt8Channel;
class uInt16Channel;
class float16Channel;
class float32Channel;

//------------------------------------------------------------------------------
class uInt8Channel {
private:
    uInt8 m_data;

public:
    inline uInt8Channel(const float32Channel &d);
    inline uInt8Channel(const float16Channel &d);
    inline uInt8Channel(const uInt16Channel  &d);
    uInt8Channel(const uInt8Channel   &d) { m_data = uInt8(d); }

    uInt8Channel(uInt8 d)  { m_data = (d); }
    uInt8Channel() {}

    inline uInt8Channel & operator = (const float32Channel &d);
    inline uInt8Channel & operator = (const float16Channel &d);
    inline uInt8Channel & operator = (const uInt16Channel  &d);
    inline uInt8Channel & operator = (const uInt8Channel   &d)
    {
        m_data = uInt8(d);
        return *this;
    }

    inline uInt8Channel & operator = (uInt8 d)
    {
        m_data = uInt8(d);
        return *this;
    }

    operator float ()  const { return m_data * (1.0f/255.0f); }
    operator half_ ()  const { return half_(m_data * (1.0f/255.0f)); }
    operator uInt16 () const { return (m_data << 8) + m_data; }
    operator uInt8 ()  const { return m_data; }
};


//------------------------------------------------------------------------------
class uInt16Channel {
private:
    uInt16 m_data;

public:
    inline uInt16Channel(const float32Channel &d);
    inline uInt16Channel(const float16Channel &d);
    uInt16Channel(const uInt16Channel  &d) { m_data = uInt16(d); }
    uInt16Channel(const uInt8Channel   &d) { m_data = uInt16(d); }
    uInt16Channel(uInt16 d)                { m_data = (d); }
    uInt16Channel() {}

    inline uInt16Channel & operator = (const float32Channel &d);
    inline uInt16Channel & operator = (const float16Channel &d);

    inline uInt16Channel & operator = (const uInt16Channel &d)
    {
        m_data = uInt16(d);
        return *this;
    }

    inline uInt16Channel & operator = (uInt16 d)
    {
        m_data = uInt16(d);
        return *this;
    }

    inline uInt16Channel & operator = (const uInt8Channel &d)
    {
        m_data = uInt16(d);
        return *this;
    }

    operator float ()  const { return m_data * (1.0f/65535.0f); }
    operator half_ ()  const { return half_(m_data * (1.0f/65535.0f)); }
    operator uInt16 () const { return m_data;               }
    operator uInt8 ()  const { return uInt8(m_data >> 8);   }
};


//------------------------------------------------------------------------------
// The data type for a 32 bit float image channel.
class float32Channel {
private:
    float m_data;

public:
    float32Channel(const float32Channel &d) { m_data = float(d); }
    inline float32Channel(const float16Channel &d);
    float32Channel(const uInt16Channel  &d) { m_data = float(d); }
    float32Channel(const uInt8Channel   &d) { m_data = float(d); }
    float32Channel(float                d)  { m_data = (d); }
    float32Channel() {}

    inline float32Channel & operator = (const float32Channel &d)
    {
        *(float *)this = *(float *)&d;
        return *this;
    }

    inline float32Channel & operator = (const float16Channel &d)
    {
        *this = float32Channel(d);
        return *this;
    }

    inline float32Channel & operator = (const uInt16Channel &d)
    {
        *this = float32Channel(d);
        return *this;
    }

    inline float32Channel & operator = (float d)
    {
        *this = float32Channel(d);
        return *this;
    }

    inline float32Channel & operator = (const uInt8Channel &d)
    {
        *this = float32Channel(d);
        return *this;
    }

    operator float ()  const { return m_data; }
    operator half_ ()  const { return half_(m_data); }
    operator uInt16 () const
        {
            if (m_data < 0.0f) return 0;
            if (m_data > 1.0f) return 65535;
            return uInt16(m_data * 65535.0f);
        }
    operator uInt8 ()  const
        {
            if (m_data < 0.0f) return 0;
            if (m_data > 1.0f) return 255;
            return uInt8(m_data * 255.0f);
        }
};


//------------------------------------------------------------------------------
class float16Channel {
private:
    half_ m_data;

public:
    float16Channel(const float32Channel &d) { m_data = float(d); }
    float16Channel(const float16Channel &d) { m_data = float(d); }
    float16Channel(const uInt16Channel  &d) { m_data = float(d); }
    float16Channel(const uInt8Channel   &d) { m_data = float(d); }
    float16Channel(const half_          &d) { m_data = (d); }
    float16Channel() {}

    inline float16Channel & operator = (const float32Channel &d)
    {
        *this = float16Channel(d);
        return *this;
    }

    inline float16Channel & operator = (const float16Channel &d)
    {
        *(uInt16 *)this = *(uInt16 *)&d;
        return *this;
    }

    inline float16Channel & operator = (const uInt16Channel &d)
    {
        *this = float16Channel(d);
        return *this;
    }

    inline float16Channel & operator = (const half_ &d)
    {
        *this = float16Channel(d);
        return *this;
    }

    inline float16Channel & operator = (const uInt8Channel &d)
    {
        *this = float16Channel(d);
        return *this;
    }

    operator float ()  const { return float(m_data); }
    operator half_ ()  const { return m_data; }

    operator uInt16 () const
        {   float d = float(m_data);
            if (d < 0.0f) return 0;
            if (d > 1.0f) return 65535;
            return uInt16(d * 65535.0f);
        }
    operator uInt8 ()  const
        {   float d = float(m_data);
            if (d < 0.0f) return 0;
            if (d > 1.0f) return 255;
            return uInt8(d * 255.0f);
        }
};


//------------------------------------------------------------------------------
inline uInt8Channel::uInt8Channel(const float32Channel &d) { m_data = uInt8(d); }
inline uInt8Channel::uInt8Channel(const float16Channel &d) { m_data = uInt8(d); }
inline uInt8Channel::uInt8Channel(const uInt16Channel  &d) { m_data = uInt8(d); }

//------------------------------------------------------------------------------
inline uInt8Channel & uInt8Channel::operator = (const float32Channel &d)
{
    m_data = uInt8(d);
    return *this;
}

//------------------------------------------------------------------------------
inline uInt8Channel & uInt8Channel::operator = (const float16Channel &d)
{
    m_data = uInt8(d);
    return *this;
}

//------------------------------------------------------------------------------
inline uInt8Channel & uInt8Channel::operator = (const uInt16Channel &d)
{
    m_data = uInt8(d);
    return *this;
}


//------------------------------------------------------------------------------
inline uInt16Channel::uInt16Channel(const float32Channel &d) { m_data = uInt16(d); }
inline uInt16Channel::uInt16Channel(const float16Channel &d) { m_data = uInt16(d); }

//------------------------------------------------------------------------------
inline uInt16Channel & uInt16Channel::operator = (const float32Channel &d)
{
    m_data = uInt16(d);
    return *this;
}

//------------------------------------------------------------------------------
inline uInt16Channel & uInt16Channel::operator = (const float16Channel &d)
{
    m_data = uInt16(d);
    return *this;
}


//------------------------------------------------------------------------------
inline float32Channel::float32Channel(const float16Channel &d) { m_data = float(d); }

//----------------------------------------------------------------------------------
// Now we define the pixel types -- 1, 2, 3, and 4 channels. templated by
// one of the above channel types -- the channel types handle converting between
// each other, and the pixel types handle converting between them.
// 1 -> 3  or 4 channel -- replicates the single channel through the target channels
// 3 -> 4 channel copies the rgb, and sets the a to 1.0. 4 -> 3 channel copies the
// RGB. 4 & 3 -> 1 channel takes the luminance of the rgb channels and stores it
// in the single channel.
//

template <class ChanType, const unsigned char NumChans>
class MBDLL_TEMPLATE_DECL PixelType {

    // allow the various instantiations of this class to
    // access each others private data members... Also has the
    // beneficial side effect of causing a compile error if
    // someone tries to instantiate one that is not listed here.
    friend class PixelType<uInt8Channel,   1>;
    friend class PixelType<uInt8Channel,   2>;
    friend class PixelType<uInt8Channel,   3>;
    friend class PixelType<uInt8Channel,   4>;
    friend class PixelType<uInt16Channel,  1>;
    friend class PixelType<uInt16Channel,  2>;
    friend class PixelType<uInt16Channel,  3>;
    friend class PixelType<uInt16Channel,  4>;
    friend class PixelType<float16Channel, 1>;
    friend class PixelType<float16Channel, 2>;
    friend class PixelType<float16Channel, 3>;
    friend class PixelType<float16Channel, 4>;
    friend class PixelType<float32Channel, 1>;
    friend class PixelType<float32Channel, 2>;
    friend class PixelType<float32Channel, 3>;
    friend class PixelType<float32Channel, 4>;

private:
    ChanType m_pixel[NumChans];

public:

    PixelType<ChanType, NumChans> &swapRB() {
        if (NumChans > 2) { // conditional will be resolved at compile time.
            ChanType t = m_pixel[0];
            m_pixel[0] = m_pixel[2];
            m_pixel[2] = t;
        }
        return *this;
    }

    PixelType<ChanType, NumChans>(const PixelType<uInt8Channel, 4> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = p.m_pixel[3]; // intentional fall through.
        case 1: m_pixel[0] = ChanType(uInt16Channel((uInt8)p.m_pixel[0]*77  +
                                                    (uInt8)p.m_pixel[1]*150 +
                                                    (uInt8)p.m_pixel[2]*28));
        break;
        // cppcheck mistakenly warns about array bounds here -- ignore it.
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2]; m_pixel[3] = p.m_pixel[3];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<uInt8Channel, 3> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType( float32Channel( 1.0f ) ); // intentional fall through.
        case 1: m_pixel[0] = ChanType(uInt16Channel((uInt8)p.m_pixel[0]*77  +
                                                    (uInt8)p.m_pixel[1]*150 +
                                                    (uInt8)p.m_pixel[2]*28));
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
                m_pixel[3] = ChanType(float32Channel(1.0f));
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<uInt8Channel, 2> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 2: m_pixel[0] = p.m_pixel[0]; 
                m_pixel[1] = p.m_pixel[1]; 
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
                m_pixel[3] = p.m_pixel[1];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<uInt8Channel, 1> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType( float32Channel( 1.0f ) ); // intentional fall through.
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0]; m_pixel[3] = ChanType(float32Channel(1.0f)); ;
        break;
        }
    }


    PixelType<ChanType, NumChans>(const PixelType<uInt16Channel, 4> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time

        case 2: m_pixel[1] = p.m_pixel[3]; // intentional fallthrough.
        case 1: m_pixel[0] = ChanType(uInt16Channel((((uInt16)p.m_pixel[0]*19660)>>16) +
                                                    (((uInt16)p.m_pixel[1]*38666)>>16) +
                                                    (((uInt16)p.m_pixel[2]*7209 )>>16)));
        break;
        
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2]; m_pixel[3] = p.m_pixel[3];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<uInt16Channel, 3> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType(float32Channel(1.0f)); // intentional fallthrough
        case 1: m_pixel[0] = ChanType(uInt16Channel((((uInt16)p.m_pixel[0]*19660)>>16) +
                                                    (((uInt16)p.m_pixel[1]*38666)>>16) +
                                                    (((uInt16)p.m_pixel[2]*7209 )>>16)));
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
                m_pixel[3] = ChanType(float32Channel(1.0f));
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<uInt16Channel, 2> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 2: m_pixel[0] = p.m_pixel[0]; 
                m_pixel[1] = p.m_pixel[1]; 
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
                m_pixel[3] = p.m_pixel[1];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<uInt16Channel, 1> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType(float32Channel(1.0f)); // intentional fallthrough
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0]; m_pixel[3] = ChanType(float32Channel(1.0f));
        break;
        }
    }


    PixelType<ChanType, NumChans>(const PixelType<float16Channel, 4> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = p.m_pixel[1];
        case 1: m_pixel[0] = ChanType(float32Channel(((float)p.m_pixel[0]*0.30f) +
                                                     ((float)p.m_pixel[1]*0.59f) +
                                                     ((float)p.m_pixel[2]*0.11f)));
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2]; m_pixel[3] = p.m_pixel[3];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<float16Channel, 3> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType(float32Channel(1.0f));
        case 1: m_pixel[0] = ChanType(float32Channel(((float)p.m_pixel[0]*0.30f) +
                                                     ((float)p.m_pixel[1]*0.59f) +
                                                     ((float)p.m_pixel[2]*0.11f)));
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
                m_pixel[3] = ChanType(float32Channel(1.0f));
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<float16Channel, 2> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 2: m_pixel[0] = p.m_pixel[0]; 
                m_pixel[1] = p.m_pixel[1]; 
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
                m_pixel[3] = p.m_pixel[1];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<float16Channel, 1> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType(float32Channel(1.0f));
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0]; m_pixel[3] = ChanType(float32Channel(1.0f));
        break;
        }
    }


    PixelType<ChanType, NumChans>(const PixelType<float32Channel, 4> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = p.m_pixel[3];
        case 1: m_pixel[0] = ChanType(float32Channel(((float)p.m_pixel[0]*0.30f) +
                                                     ((float)p.m_pixel[1]*0.59f) +
                                                     ((float)p.m_pixel[2]*0.11f)));
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2]; m_pixel[3] = p.m_pixel[3];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<float32Channel, 3> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType(float32Channel(1.0f));
        case 1: m_pixel[0] = ChanType(float32Channel(((float)p.m_pixel[0]*0.30f) +
                                                     ((float)p.m_pixel[1]*0.59f) +
                                                     ((float)p.m_pixel[2]*0.11f)));
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[1];
                m_pixel[2] = p.m_pixel[2];
                m_pixel[3] = ChanType(float32Channel(1.0f));
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<float32Channel, 2> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 2: m_pixel[0] = p.m_pixel[0]; 
                m_pixel[1] = p.m_pixel[1]; 
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
                m_pixel[3] = p.m_pixel[1];
        break;
        }
    }

    PixelType<ChanType, NumChans>(const PixelType<float32Channel, 1> &p)
    {
        switch (NumChans) { // this switch gets resolved at compile time
        case 2: m_pixel[1] = ChanType(float32Channel(1.0f));
        case 1: m_pixel[0] = p.m_pixel[0];
        break;
        case 3: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0];
        break;
        case 4: m_pixel[0] = p.m_pixel[0]; m_pixel[1] = p.m_pixel[0];
                m_pixel[2] = p.m_pixel[0]; m_pixel[3] = ChanType(float32Channel(1.0f));
        break;
        }
    }

    void SetLuminance(const PixelType<uInt8Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(((uInt8)p.m_pixel[0]*77  +
                                                 (uInt8)p.m_pixel[1]*150 +
                                                 (uInt8)p.m_pixel[2]*28)));
        }
    }

    void SetLuminance(const PixelType<uInt8Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(((uInt8)p.m_pixel[0]*77  +
                                                 (uInt8)p.m_pixel[1]*150 +
                                                 (uInt8)p.m_pixel[2]*28)));
        }
    }

    void SetLuminance(const PixelType<uInt16Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(((((uInt16)p.m_pixel[0]*19660)>>16) +
                                                 (((uInt16)p.m_pixel[1]*38666)>>16) +
                                                 (((uInt16)p.m_pixel[2]*7209 )>>16))));
        }
    }

    void SetLuminance(const PixelType<uInt16Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(((((uInt16)p.m_pixel[0]*19660)>>16) +
                                                 (((uInt16)p.m_pixel[1]*38666)>>16) +
                                                 (((uInt16)p.m_pixel[2]*7209 )>>16))));
        }
    }


    void SetLuminance(const PixelType<float16Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel((((float)p.m_pixel[0]*0.30f) +
                                                  ((float)p.m_pixel[1]*0.59f) +
                                                  ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetLuminance(const PixelType<float16Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel((((float)p.m_pixel[0]*0.30f) +
                                                  ((float)p.m_pixel[1]*0.59f) +
                                                  ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetLuminance(const PixelType<float32Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel((((float)p.m_pixel[0]*0.30f) +
                                                  ((float)p.m_pixel[1]*0.59f) +
                                                  ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetLuminance(const PixelType<float32Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel((((float)p.m_pixel[0]*0.30f) +
                                                  ((float)p.m_pixel[1]*0.59f) +
                                                  ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetLuminance(const PixelType<float32Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(1.0f - ((float)p.m_pixel[0])));
        }
    }

    void SetLuminance(const PixelType<float16Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(((float)p.m_pixel[0])));
        }
    }

    void SetLuminance(const PixelType<uInt16Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(((uInt16)p.m_pixel[0])));
        }
    }

    void SetLuminance(const PixelType<uInt8Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt8Channel(((uInt8)p.m_pixel[0])));
        }
    }


    void SetInvLuminance(const PixelType<uInt8Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(65535 -
                                                ((uInt8)p.m_pixel[0]*77  +
                                                 (uInt8)p.m_pixel[1]*150 +
                                                 (uInt8)p.m_pixel[2]*28)));
        }
    }

    void SetInvLuminance(const PixelType<uInt8Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(65535 -
                                                ((uInt8)p.m_pixel[0]*77  +
                                                 (uInt8)p.m_pixel[1]*150 +
                                                 (uInt8)p.m_pixel[2]*28)));
        }
    }

    void SetInvLuminance(const PixelType<uInt16Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(65535 -
                                                ((((uInt16)p.m_pixel[0]*19660)>>16) +
                                                 (((uInt16)p.m_pixel[1]*38666)>>16) +
                                                 (((uInt16)p.m_pixel[2]*7209 )>>16))));
        }
    }

    void SetInvLuminance(const PixelType<uInt16Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(65535 -
                                                ((((uInt16)p.m_pixel[0]*19660)>>16) +
                                                 (((uInt16)p.m_pixel[1]*38666)>>16) +
                                                 (((uInt16)p.m_pixel[2]*7209 )>>16))));
        }
    }


    void SetInvLuminance(const PixelType<float16Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(1.0f -
                                                 (((float)p.m_pixel[0]*0.30f) +
                                                  ((float)p.m_pixel[1]*0.59f) +
                                                  ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetInvLuminance(const PixelType<float16Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(1.0f -
                                                 (((float)p.m_pixel[0]*0.30f) +
                                                  ((float)p.m_pixel[1]*0.59f) +
                                                  ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetInvLuminance(const PixelType<float32Channel, 4> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(1.0f -
                                                 (((float)p.m_pixel[0]*0.30f) +
                                                  ((float)p.m_pixel[1]*0.59f) +
                                                  ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetInvLuminance(const PixelType<float32Channel, 3> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(1.0f - (((float)p.m_pixel[0]*0.30f) +
                                                         ((float)p.m_pixel[1]*0.59f) +
                                                         ((float)p.m_pixel[2]*0.11f))));
        }
    }

    void SetInvLuminance(const PixelType<float32Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(1.0f - ((float)p.m_pixel[0])));
        }
    }

    void SetInvLuminance(const PixelType<float16Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(float32Channel(1.0f - ((float)p.m_pixel[0])));
        }
    }

    void SetInvLuminance(const PixelType<uInt16Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt16Channel(65535 - ((uInt16)p.m_pixel[0])));
        }
    }

    void SetInvLuminance(const PixelType<uInt8Channel, 1> &p)
    {
        if (NumChans == 4) {
            m_pixel[0] = m_pixel[1] = m_pixel[2] = 
            m_pixel[3] = ChanType(uInt8Channel(255 - ((uInt8)p.m_pixel[0])));
        }
    }
};


//------------------------------------------------------------------------------
class MBDLL_DECL ImgTile
{
public:
    int  x;   
    int  y;   
    int  nx;  
    int  ny;  
    inline ImgTile() : x(0), y(0), nx(0), ny(0) {}

    inline ImgTile(int X, int Y, int NX, int NY) : x(X), y(Y), nx(NX), ny(NY) {}

    #if !defined MAX
    #define MAX(a_, b_) (((a_) > (b_)) ? (a_) : (b_))
    #endif
    #if !defined MIN
    #define MIN(a_, b_) (((a_) < (b_)) ? (a_) : (b_))
    #endif

    ImgTile(const ImgTile &a, const ImgTile &b)
    {
        x  = MAX(a.x, b.x);
        y  = MAX(a.y, b.y);
        nx = MIN(a.x+a.nx, b.x+b.nx) - x;
        ny = MIN(a.y+a.ny, b.y+b.ny) - y;
        if (nx <= 0 || ny <= 0) x = y = nx = ny = 0;
    }

    inline bool isEqualTile(const ImgTile &t) const
    { return x == t.x && y == t.y && nx == t.nx && ny == t.ny; }

    inline bool operator ==(const ImgTile &t) const
    { return x == t.x && y == t.y && nx == t.nx && ny == t.ny; }

    inline bool operator !=(const ImgTile &t) const
    { return !(t == *this); }

    inline bool isEmpty() const { return nx <= 0 || ny <= 0; }

    inline void setEmpty() { x = y = nx = ny = 0; }

    inline bool contains(const ImgTile &a) const
    { return x <= a.x && a.x+a.nx <= x+nx &&
             y <= a.y && a.y+a.ny <= y+ny;
    }

    inline bool contains(int x_, int y_) const
    { return x <= x_ && x_ < x+nx && y <= y_ && y_ < y+ny;
    }

    void clipPositive()
    {
        if (x < 0) {
            nx += x; x = 0;
            if (nx < 0) x = y = nx = ny = 0;
        }
        if (y < 0) {
            ny += y; y = 0;
            if (ny < 0) x = y = nx = ny = 0;
        }
    }

    void ExpandToInclude(int x_, int y_)
    {
        if (isEmpty()) {
            x = x_; y = y_; nx = 1; ny = 1;
        } else {
            if (x_ < x) { nx += (x - x_); x = x_; }
            if (y_ < y) { ny += (y - y_); y = y_; }

            if (x + nx < x_) nx = (x_ - x) + 1;
            if (y + ny < y_) ny = (y_ - y) + 1;
        }
    }

    void Expand(int numPixels = 1)
    {
        x  -= numPixels; y  -= numPixels;
        numPixels <<= 1;
        nx += numPixels; ny += numPixels;
    }

    int numPixels() const { return isEmpty() ? 0 : nx * ny; }
};


//------------------------------------------------------------------------------
#define MAX_DIRTY_REGION          8192    // same as max texture size...
#define DIRTY_REGION_GRANULARITY  128     // make this a power of 2.
#define DIRTY_REGION_MASK         (DIRTY_REGION_GRANULARITY-1)
#define DIRTY_REGION_SHIFT        7
#define DIRTY_REGION_XY_SIZE      ( MAX_DIRTY_REGION / DIRTY_REGION_GRANULARITY )

//------------------------------------------------------------------------------
class MBDLL_DECL ImgDirtyRegion {  // should be 4K + 16 bytes when the max texture size is 8Kx8K texels
private:
    // each char in this array represents a 128x128 pixel region of an image
    // using char as it is guaranteed to be 1 byte. bool is not.
    char     m_DirtyChunks[DIRTY_REGION_XY_SIZE * DIRTY_REGION_XY_SIZE];
    int      m_ChunksSet;
    int      m_NumTiles;
    ImgTile *m_DirtyTiles;
    ImgTile  m_DirtyTotalChunks;
    int      m_InTileCount;

    void     ComputeDirtyTiles();

    // this just clears the output tile list, not the bit-map.
    void     ClearDirtyTiles() 
    {
        if (m_DirtyTiles) delete [] m_DirtyTiles;
        m_NumTiles = 0; m_DirtyTiles = 0;
    }

    // compute the address of the byte for a chunk at the given chunk coordinates
    char *Index(int x, int y)
    {
        return &m_DirtyChunks[(y * DIRTY_REGION_XY_SIZE) + x];
    }

    // set the value at the specified image coordinates to 1, return the old value.
    char Set(int x, int y)  { char c = *Index(x, y); *Index(x, y) = 1; return c; }

    // return the value at the specified  chunk coordinates.
    char Get(int x, int y)  { return *Index(x, y); }

public:
    ImgDirtyRegion()  { m_DirtyTiles = 0; ClearDirtyRegion(); }
    ~ImgDirtyRegion() { ClearDirtyTiles();  }

    void AddToDirtyRegion(const ImgTile &dirtyTile);

    void ClearDirtyRegion()
    {
        ClearDirtyTiles();
        memset(m_DirtyChunks, 0, DIRTY_REGION_XY_SIZE * DIRTY_REGION_XY_SIZE);
        m_ChunksSet = 0;
        m_DirtyTotalChunks.setEmpty();
        m_InTileCount = 0;
    }

    int numTiles() 
    {
        if (!m_DirtyTiles) ComputeDirtyTiles();
        return m_NumTiles;
    }

    ImgTile Tile(int i)
    {
        return m_DirtyTiles[i];
    }

    ImgTile GetTotalBounds() const
    {
        return m_DirtyTotalChunks; 
    }

    bool isEmpty() const { return m_DirtyTotalChunks.isEmpty(); }

    void Union(const ImgDirtyRegion &other);

    void DumpToLog();

    ImgDirtyRegion& operator= ( const ImgDirtyRegion& cOther );
};


//------------------------------------------------------------------------------
class MBDLL_DECL ImgTile_AoutB_Iter : public ImgTile {
private:
    int            ax1, ax2, bx1, bx2;
    int            ay1, ay2, by1, by2;
    signed char    state;
    bool           ad,  bd;

public:
    ImgTile_AoutB_Iter(const ImgTile &A, const ImgTile &B) :
        ax1   (A.x), ax2 (A.x + A.nx - 1),
        bx1   (B.x), bx2 (B.x + B.nx - 1),
        ay1   (A.y), ay2 (A.y + A.ny - 1),
        by1   (B.y), by2 (B.y + B.ny - 1),
        state (0),
        ad    (A.nx <= 0 || A.ny <= 0),
        bd    (B.nx <= 0 || B.ny <= 0) {}

    virtual bool next();
};


//-----------------------------------------------------------------------------
class MBDLL_DECL ImgTileUnion : public ImgTile {
public:
    ImgTileUnion(const ImgTile &A, const ImgTile &B);
};


class MBDLL_DECL ImgPageIterator : public ImgTile {
protected:
    void    *m_BlindData;
    Image   *m_Image;
    int      m_Type;
    void    *m_PixelData;
    ImgTile  m_SrcTile;


public:
    ImgPageIterator(Image *img, const ImgTile *srcTile = 0, bool writing = false);
    virtual ~ImgPageIterator();
    virtual bool  next();
    void         *dataPtr() { return m_PixelData; }
};


//------------------------------------------------------------------------------
class MBDLL_DECL ImgLockPageIterator : public ImgPageIterator {
public:
    typedef enum {
        ReadOnly,   
        ReadWrite,  
        WriteOnly   
    } AccessMode;

protected:
    bool        m_SmartImage;
    AccessMode  m_Mode;

public:
    ImgLockPageIterator(Image *img, const ImgTile *srcTile = 0, AccessMode mode = ReadOnly);
    ~ImgLockPageIterator();

    virtual bool  next();
    void         *dataPtr();
};

//------------------------------------------------------------------------------
class PixelDescriptor {
public:
    typedef enum {
        uChar   = 0,  
        uShort  = 1,  
        sHalf   = 2,  
        sFloat  = 3,  
        sChar   = 4,  
        sShort  = 5,  
        uInt    = 6,  
        sInt    = 7,  
        sDouble = 8   
    } ChannelType;

    typedef enum {
        orderNONE = 0, 
        orderRGBA = 1, 
        orderABGR = 2, 
        orderBGRA = 3, 
        orderARGB = 4, 
        orderRGB  = 5, 
        orderBGR  = 6  
    } MemoryChannelOrder;

protected:
    char                m_cCount;        
    ChannelType         m_channelType;   
    MemoryChannelOrder  m_channelOrder;  
    bool                m_PreMultiplied; 
public:

    PixelDescriptor(char                cCount,
                    ChannelType         channelType,
                    MemoryChannelOrder  channelOrder,
                    bool                PreMultiplied)
        : m_cCount       (cCount)
        , m_channelType  (channelType)
        , m_channelOrder (channelOrder)
        , m_PreMultiplied(PreMultiplied) {}

    int channelSize() const {
        static const unsigned char s_channelByteCount[] = {1, 2, 2, 4, 1, 2, 4, 4, 8};
        return s_channelByteCount[m_channelType];
    }

    int channelBitSize() const {
        return channelSize() * 8;
    }

    int pixelSize() const {
        return channelSize() * m_cCount;
    }

    int pixelBitSize() const {
        return pixelSize() * 8;
    }

    ChannelType channelType() const { return m_channelType; }

    MemoryChannelOrder channelOrder() const { return m_channelOrder; }

    bool premultiplied() const { return m_PreMultiplied; }

    int channelCount() const   { return m_cCount; }

    void setChannelCount(int c) { m_cCount = c; }

    bool operator == (const PixelDescriptor &pd) const
    { return (m_cCount         == pd.m_cCount        &&
              m_channelType    == pd.m_channelType   &&
              m_channelOrder   == pd.m_channelOrder  &&
              m_PreMultiplied  == pd.m_PreMultiplied);
    }
};



//------------------------------------------------------------------------------
class ImageDescriptor : public PixelDescriptor {

public:
    enum ResUnit { k_PixelsPerInch       = 1, 
                   k_PixelsPerCentimeter = 2  
    };

protected:
    ImgTile   m_Bounds; 
    float     m_xResolution;      
    float     m_yResolution;      
    ResUnit   m_ResolutionUnits;  
public:

    ImageDescriptor(int x, int y, int nx, int ny,
                    MemoryChannelOrder order = orderRGBA,
                    bool premult = true,
                    char nc = 4, ChannelType ct = uChar) :
        PixelDescriptor(nc, ct, order, premult),
        m_Bounds(x, y, nx, ny),
        m_xResolution(100.0f), m_yResolution(100.0f),
        m_ResolutionUnits(k_PixelsPerInch) {}

    ImageDescriptor(int nx, int ny,
                    MemoryChannelOrder order = orderRGBA,
                    bool premult = true,
                    char nc = 4, ChannelType ct = uChar) :
        PixelDescriptor(nc, ct, order, premult),
        m_Bounds(0, 0, nx, ny) {}

    ImageDescriptor() :
        PixelDescriptor(4, uChar,  orderRGBA, true),
        m_Bounds(0,0,0,0) {}

    int numBytes() const    { return m_Bounds.nx * m_Bounds.ny * pixelSize(); }

    int strideBytes() const { return m_Bounds.nx * pixelSize(); }

    int xSize() const { return m_Bounds.nx;  }

    int ySize() const { return m_Bounds.ny;  }

    int cSize() const { return m_cCount; }

    bool sizeEqual(const ImageDescriptor &o) const
        { return ((xSize() == o.xSize()) && (ySize() == o.ySize())); }

    void setSize(int nx, int ny) { m_Bounds.nx = nx; m_Bounds.ny = ny; }

    const ImgTile &getBounds() const { return m_Bounds; }

    void getResolutionInfo(float &xRes, float &yRes, ResUnit &unit) const
    {
        xRes = m_xResolution; yRes = m_yResolution, unit = m_ResolutionUnits;
    }

    void setResolutionInfo(float xRes, float yRes, ResUnit unit)
    {
        m_xResolution = xRes; m_yResolution = yRes, m_ResolutionUnits = unit;
    }

    friend class Image;                                                                    
};


//------------------------------------------------------------------------------
typedef bool (*ProxyInterruptFunction)(void);

#define MAX_PROXY_LEVEL 4

//------------------------------------------------------------------------------

class MBDLL_DECL Image : public Node
{

    DECLARE_CLASS;

    friend class ImgPageIterator;
    friend class ImgLockPageIterator;


public:
    typedef enum {
        Type_Invalid = 0,
        Type_Memory,       
        Type_Virtual       
    } ImageType;

    enum Format
    {
        e8integer = 0,
        e16integer,
        e32integer,
        e16float,
        e32float,
        e16depth,
        e24depth,
        e32depth,
        eUnknown,
        eInvalid,
    };

    virtual ~Image( void );

protected:

    Image( void );

    unsigned char    m_FillPixel[16]; // fill color -- largest supported pixel is 16 bytes.
    ImageDescriptor  m_Descriptor;    // how to interpret the pixel data

    ImageType        m_ImageType;

    unsigned char    m_ProxyLevel;
    Image           *m_pProxyImages[MAX_PROXY_LEVEL+1];
    bool             m_bDownsampleProxyTo8Bit;

    ProxyInterruptFunction  m_pProxyIntFcn;

    void             markProxyDirty() 
    { 
        for (int i = 0; i < MAX_PROXY_LEVEL+1; ++i) {
            if (m_pProxyImages[i]) {
                delete m_pProxyImages[i]; m_pProxyImages[i] = 0;
            }
        }
    }

    virtual bool     regenerateProxy();
    bool             isProxyDirty() const 
        { return (m_ProxyLevel > 0) ? (m_pProxyImages[m_ProxyLevel] == 0) : false; }


    // Generate a downsampled proxy of this image. The targetImg is created,
    // and populated. Current levels supported are 1, 2, and 3.
    // (representing 1/2, 1/4, and 1/8 size proxies)
    // This function only works on tiled images.
    // Works on 1, 2, and 4 channel images. (not 3 channel)
    // uchar, ushort, half, and float images are supported on input. 
    // Output will be uchar by default, but if you set DownsampleTo8Bits 
    // to false, the output image will have the same channel datatype
    // as the input image. With float images, no clamping will take place
    // when not downsampling to 8 bit per channel.

    virtual bool GenerateProxy(Image *targetImg, int level, bool DownsampleTo8Bits = true);


public:

    void UnitTest(int iterations);

    virtual bool isAllocated() const;

    // Return a list of all extensions from all of our descendent classes.
    //
    static QString  AllSupportedExtensions( bool bRGBAOnly = false, 
                                            bool bRead     = true, 
                                            bool bDesc     = false,
                                            bool bPSD      = true,
                                            QString sDelimiter = ";");

    ImageType getType() const { return m_ImageType; }

    const ImageDescriptor  &getDescriptor() const  { return m_Descriptor; }


    void   setProxyDownsampleTo8Bit(bool downsampleTo8Bit = true) 
    { 
        if (m_bDownsampleProxyTo8Bit != downsampleTo8Bit) {
            m_bDownsampleProxyTo8Bit = downsampleTo8Bit; 
            markProxyDirty();
        }
    }

    bool   getProxyDownsampleTo8Bit() const { return m_bDownsampleProxyTo8Bit; }

    void   clearProxyImages() { markProxyDirty(); }

    void SetProxyInterruptFunction(ProxyInterruptFunction fcnPtr = 0)
    { m_pProxyIntFcn = fcnPtr; }


    unsigned char   getProxyLevel() const { return m_ProxyLevel; }

    bool        setProxyLevel(unsigned char newLevel) { 
        if ( xSize()>>newLevel == 0 || ySize()>>newLevel == 0 )
            return false;
        if (newLevel > MAX_PROXY_LEVEL) newLevel = MAX_PROXY_LEVEL;
        if (newLevel != m_ProxyLevel) {
            m_ProxyLevel = newLevel;
        }

        return true;
    }

    Image         *getProxyImage() 
    {
        if (m_ProxyLevel == 0) return this;
        
        if ( m_pProxyImages[m_ProxyLevel] ) return m_pProxyImages[m_ProxyLevel];
        
        bool generated = regenerateProxy();
        if (!generated && m_pProxyImages[m_ProxyLevel] != 0) {
            delete m_pProxyImages[m_ProxyLevel];
            m_pProxyImages[m_ProxyLevel] = 0;
        }
        return m_pProxyImages[m_ProxyLevel];
    }

    int            xSize() const { return m_Descriptor.xSize(); }

    int            ySize() const { return m_Descriptor.ySize(); }

    int            cSize() const { return m_Descriptor.cSize(); }

    int            curWidth()  const { return Width() >> getProxyLevel(); }

    int            curHeight() const { return Height() >> getProxyLevel(); }

    ImageDescriptor::MemoryChannelOrder channelOrder() const { return m_Descriptor.m_channelOrder; }

    const ImgTile  &getBounds() const { return m_Descriptor.getBounds(); }

    //====================================================================
    void  getFillColor(void *fillPixel, const PixelDescriptor *pd = 0) const;

    //====================================================================
    void  setFillColor(const void *fillPixel, const PixelDescriptor *pd = 0);

    //====================================================================
    void  getTile(int x, int y, int nx, int ny, void *data,
                  const PixelDescriptor *pd = 0)
       { getTile(ImgTile(x, y, nx, ny), data, pd); }


    //====================================================================
    void  getSubTile(int x,  int y,  int nx,  int ny, void *data,
                     int dx, int dy, int dnx, int dny,
                     const PixelDescriptor *pd = 0)
       { getSubTile(ImgTile(x, y, nx, ny), data, ImgTile(dx, dy, dnx, dny), pd); }


    //====================================================================
    void getTile(const ImgTile &srcTile, void *data,
                 const PixelDescriptor *pd = 0)
       { getSubTile(srcTile, data, srcTile, pd); }

    //====================================================================
    virtual void getSubTile(const ImgTile &srcTile, void *data,
                            const ImgTile &targetBounds,
                            const PixelDescriptor *pd = 0);


    //====================================================================
    void setTile(int x, int y, int nx, int ny, void *data,
                 const PixelDescriptor *pd = 0)
       { setTile(ImgTile(x, y, nx, ny), data, pd); }

    //====================================================================
    void setSubTile(int x,  int y,  int nx,  int ny, const void *data,
                    int dx, int dy, int dnx, int dny,
                    const PixelDescriptor *pd = 0)
       { setSubTile(ImgTile(x, y, nx, ny), data, ImgTile(dx, dy, dnx, dny), pd); }

    //====================================================================
    void setTile(const ImgTile &dstTile, const void *data,
                 const PixelDescriptor *pd = 0)
       { setSubTile(dstTile, data, dstTile, pd); }

    //====================================================================
    virtual void setSubTile(const ImgTile &dstTile, const void *data,
                            const ImgTile &sourceBounds,
                            const PixelDescriptor *pd = 0);

    //====================================================================
    void copyTile(int x, int y, int nx, int ny, Image &fromImg,
                  int ox, int oy)
       { copyTile(ImgTile(x, y, nx, ny), fromImg, ox, oy); }


    //====================================================================
    virtual void copyTile(const ImgTile &dstTile, Image &fromImg,
                          int ox, int oy);

    //====================================================================
    virtual void copyAll(Image &fromImg)
    {
        ImgTile srcBounds(fromImg.getBounds());
        copyTile(srcBounds, fromImg, srcBounds.x, srcBounds.y);
    }

    virtual void Clear();

    //====================================================================
    void fillTile(int x, int y, int nx, int ny, void *pixelData,
                  const PixelDescriptor *pd       = 0,
                  const ImgTile         *maskTile = 0)
    { fillTile(ImgTile(x, y, nx, ny), pixelData, pd, maskTile); }

    //====================================================================
    void fillTile(const ImgTile &dstTile, const void *pixelData,
                  const PixelDescriptor *pd,
                  const ImgTile         *maskTile);

    //====================================================================
    virtual void fillTile(const ImgTile         &dstTile,
                          const void            *pixelData,
                          const PixelDescriptor *pd = 0);

    //====================================================================
    virtual void getPageSize(int &nx, int &ny);

    //====================================================================
    ImgPageIterator *getPageIterator(int x, int y, int nx, int ny)
    { return getPageIterator(ImgTile(x, y, nx, ny)); }

    //====================================================================
    virtual ImgPageIterator *getPageIterator(const ImgTile &srcTile);

    //====================================================================
    ImgLockPageIterator *lockPageSet(int x, int y, int nx, int ny,
                                     ImgLockPageIterator::AccessMode mode)
    { return lockPageSet(ImgTile(x, y, nx, ny), mode); }

    //====================================================================
    virtual ImgLockPageIterator *lockPageSet(const ImgTile &srcTile,
                                             ImgLockPageIterator::AccessMode mode);

    static ImageDescriptor::MemoryChannelOrder optimizedChannelOrder();

    static void ConvertPixels(void *dst, const void *src, int numPix,
                              const PixelDescriptor &dstDesc,
                              const PixelDescriptor *srcDesc = 0);

    void CopyInverseLuminance(const Image &srcImage);

    void CopyLuminance(const Image &srcImage);

    virtual QString SupportedExtensions( bool bRGBAOnly = false,
                                        bool bRead     = true,
                                        bool bDesc     = false,
                                        bool bPSD      = true,
                                        QString sDelimiter = ";") const;

    virtual void Create( unsigned int iWidth, unsigned int iHeight,
                         unsigned int iChannelCount, Format eFormat = e8integer,
                         bool Tiled = false,
                        ImageDescriptor::MemoryChannelOrder eOrder = ImageDescriptor::orderRGBA);

    virtual void Load( const QString &sFileName, int iLayerIndex = 0, bool tiled = false );

    virtual bool GetPSDLayerMeta ( void *pPSDFile, int iLayerIndex, 
                                   QString &layerName, int &blendMode,
                                   float &opacity, bool &locked, 
                                   bool &visible, bool &transLocked);

    virtual bool LoadPSDLayer ( void *pPSDFile,
                                int   iLayerIndex,
                                bool  Tiled = false,
                                bool  premult = true );


    virtual Image *ComputeDifferenceMask(Image *otherImg, int expansionRadius,
                                         int AARadius, bool &anyDiffs);

    virtual bool SavePSDLayerMeta ( void         *pPSDFile,
                                    int           iLayerIndex,
                                    const QString&pLayerName,
                                    float         opacity = 1.0f,
                                    bool          visible = true,
                                    bool          locked  = false,
                                    int           xOff    = 0,
                                    int           yOff    = 0,
                                    int           blendMode = -1);

    virtual bool SavePSDLayer ( void         *pPSDFile,
                                int           iLayerIndex,
                                const QString&pLayerName,
                                float         opacity = 1.0f,
                                bool          visible = true,
                                bool          locked  = false,
                                bool          needs_unpremult = true,
                                int           xOff    = 0,
                                int           yOff    = 0);

    virtual void *OpenPSDFile(const QString &pFileName, bool writing = false);

    virtual bool  GetPSDFileInfo(void *psdFile, int *width, int *height, int *numChannels,
                                 int *bitDepth, int *numLayers, int *curLayer);

    virtual bool  SetPSDFileInfo(void *psdFile, int width, int height, int numChannels,
                                 int bitDepth, int numLayers, int curLayer);

    virtual bool ClosePSDFile(void *psdFile);


    virtual void Save( const QString &sFileName, bool bForce = true,
                       Material *pMaterial = NULL,
                       float uStart = 0.0f, float vStart = 0.0f,
                       bool force_1_Channel_To_4_Channel = false);

    virtual unsigned int Width( void ) const;

    virtual unsigned int Height( void ) const;

    virtual Format Format( void ) const;

    virtual unsigned int ChannelCount( void ) const;

    virtual unsigned int BytesPerPixel( void ) const;

    unsigned int         curBytesPerPixel() const { return (getProxyLevel() != 0) ? ChannelCount() : BytesPerPixel(); }

    virtual unsigned int TotalBytes( void ) const;

    unsigned int         curTotalBytes(void) const { return curWidth() * curHeight() * curBytesPerPixel(); }

    virtual void SetValueAt( unsigned int iXPos, unsigned int iYPos,
                             unsigned int iChannel, float fValue );

    virtual float ValueAt( unsigned int iXPos, unsigned int iYPos,
                           unsigned int iChannel ) const;

    virtual float ValueAt( float fXPos, float fYPos, unsigned int iChannel ) const;

    virtual void SetColorAt( unsigned int iXPos, unsigned int iYPos,
                             const Color &cColor );

    virtual Color ColorAt( unsigned int iXPos, unsigned int iYPos ) const;

    virtual Color ColorAt( float fXPos, float fYPos ) const;

    virtual QImage *ConvertToQImage( );

    virtual void ConvertFromQImage( QImage &qImg, bool tiled = false);

    virtual bool Fragmented() const;

    virtual bool Tiled() const;

    bool Versioned() const { return Tiled(); }

    virtual bool NewVersion();

    virtual bool PrevVersion();

    virtual bool NextVersion();

    virtual int  NumVersions();

    virtual bool MergeOldestVersions();

    virtual bool PurgeNewerVersions();

    virtual bool PurgeAllButCurrentVersion();

    virtual void *Data( int iRow = -1, bool writing = true );
    virtual const void *Data( int iRow = -1, bool writing = false ) const;


    virtual void DrawUVs(Material *pMaterial,
                         float uStart = 0.0f, float vStart = 0.0f,
                         bool baseLevel = true);


    virtual void scaleTileBilinear_4Chan_uchar(float x, float y, float nx, float ny, // src tile (from this image)
                                               unsigned int *data,                   // target buffer 
                                               int dx, int dy, int dnx, int dny,     // target location and size of target buffer
                                               float xScale, float yScale) const;    // scale factors



    virtual void GenerateUpscaled(Image *targetImg, int factor);


    static void MultiplyRGBByAlpha_uc4(unsigned char *buffer, int numPixels);

    virtual bool   isDirty() const;

    virtual void   setDirty();

    virtual void   setClean();

    virtual void   VerticalFlip(); 

    virtual void   AdjustImageCacheSize();

    virtual void   ConvertTo4Channel();

};

//------------------------------------------------------------------------------
MBDLL_DECL AttributeWidget *CreateNewImageWidget( QWidget *pParent, int iWidth,
                                                  AttributePointer<Image> *pImage );
template <> inline
AttributeWidget *AttributePointer<Image>::CreateEditorWidget( QWidget *pParent, int iWidth )
{ return CreateNewImageWidget( pParent, iWidth, this ); };

class MBDLL_DECL EnvironmentMap : public Node
{
    DECLARE_CLASS;

protected:

    EnvironmentMap( void );

public:
    virtual bool Load( const QString &sFileName );
    virtual unsigned int ConvertToOpenGLTexture( void );
};


//------------------------------------------------------------------------------

// these are just shorthand -- they're undefined later in this file
#define cu_int  const unsigned int
#define u_int   unsigned int
#define u_short unsigned short
#define u_char  unsigned char

#define inline __forceinline

template <class ChannelType, cu_int nch>
class MBDLL_TEMPLATE_DECL ImageAccessorBase
{
private:
    u_int        m_Stride;
    u_int        m_Height;
    u_int        m_chans;
    Image       *m_Image;
    ChannelType *m_pData;

public:
    ImageAccessorBase(Image *parent)
    {
        m_Stride = parent->Width();
        m_Height = parent->Height();
        m_chans  = parent->ChannelCount();
        m_Image  = parent;
        m_pData  = (ChannelType *)parent->Data();
    }

    u_int Width()        const { return m_Stride; }
    u_int Height()       const { return m_Height; }
    u_int ChannelCount() const { return m_chans;  }

    inline void  SetValueAt(u_int X, u_int Y, u_int Ch, float fVal);

    inline float ValueAt(u_int X, u_int Y, u_int Ch) const;

    inline void  SetColorAt( u_int X, u_int Y, const Color &cColor );

    inline void *AddrAt(u_int X, u_int Y, u_int Ch);
};

//------------------------------------------------------------------------------
template <class ChannelType, cu_int nch>
class MBDLL_TEMPLATE_DECL ImageAccessor : public ImageAccessorBase<ChannelType, nch>
{
public:
    ImageAccessor(Image *parent) : ImageAccessorBase<ChannelType, nch>(parent)
    {
    }

    inline Color ColorAt( u_int X, u_int Y ) const;
};


//------------------------------------------------------------------------------
template <class ChannelType>
class ImageAccessor<ChannelType, 3> : public ImageAccessorBase<ChannelType, 3>
{
public:
    ImageAccessor(Image *parent) : ImageAccessorBase<ChannelType, 3>(parent)
    {
    }

    inline Color ColorAt( u_int X, u_int Y ) const
    {
        return Color(
                ImageAccessorBase<ChannelType, 3>::ValueAt(X,Y,0),
                ImageAccessorBase<ChannelType, 3>::ValueAt(X,Y,1),
                ImageAccessorBase<ChannelType, 3>::ValueAt(X,Y,2),
                1);
    }
};

//------------------------------------------------------------------------------
template <class ChannelType>
class MBDLL_TEMPLATE_DECL ImageAccessor<ChannelType, 2> : public ImageAccessorBase<ChannelType, 2>
{
public:
    ImageAccessor(Image *parent) : ImageAccessorBase<ChannelType, 2>(parent)
    {
    }

    inline Color ColorAt( u_int X, u_int Y ) const
    {
        return Color(
                ImageAccessorBase<ChannelType, 2>::ValueAt(X,Y,0),
                ImageAccessorBase<ChannelType, 2>::ValueAt(X,Y,1),
                0, 1);
    }
};

//------------------------------------------------------------------------------
template <class ChannelType>
class MBDLL_TEMPLATE_DECL ImageAccessor<ChannelType, 1> : public ImageAccessorBase<ChannelType, 1>
{
public:
    ImageAccessor(Image *parent) : ImageAccessorBase<ChannelType, 1>(parent)
    {
    }

    inline Color ColorAt( u_int X, u_int Y ) const
    {
        return Color(ImageAccessorBase<ChannelType, 1>::ValueAt(X,Y,0), 0, 0, 1);
    }
};

//------------------------------------------------------------------------------
template <>
inline void *ImageAccessorBase<u_char, 1>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y)    )]; }
template <>
inline void *ImageAccessorBase<u_char, 2>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 2)]; }
template <>
inline void *ImageAccessorBase<u_char, 3>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 3)]; }
template <>
inline void *ImageAccessorBase<u_char, 4>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 4)]; }

template <>
inline void *ImageAccessorBase<u_short, 1>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y)    )]; }
template <>
inline void *ImageAccessorBase<u_short, 2>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 2)]; }
template <>
inline void *ImageAccessorBase<u_short, 3>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 3)]; }
template <>
inline void *ImageAccessorBase<u_short, 4>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 4)]; }


template <>
inline void *ImageAccessorBase<float, 1>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y)    )]; }
template <>
inline void *ImageAccessorBase<float, 2>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 2)]; }
template <>
inline void *ImageAccessorBase<float, 3>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 3)]; }
template <>
inline void *ImageAccessorBase<float, 4>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 4)]; }

template <>
inline void *ImageAccessorBase<half_, 1>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y)    )]; }
template <>
inline void *ImageAccessorBase<half_, 2>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 2)]; }
template <>
inline void *ImageAccessorBase<half_, 3>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 3)]; }
template <>
inline void *ImageAccessorBase<half_, 4>::AddrAt(u_int X, u_int Y, u_int Ch)
{ return (void *)&m_pData[Ch + ((X + m_Stride * Y) * 4)]; }

// implement the inline member fcns with specialization...
template <>
inline void ImageAccessorBase<u_char, 1>::SetValueAt(u_int X, u_int Y, u_int Ch, float fVal)
{ m_pData[Ch + ((X + m_Stride * Y)    )] = (u_char)(255.0f * fVal); }
template <>
inline void ImageAccessorBase<u_char, 2>::SetValueAt(u_int X, u_int Y, u_int Ch, float fVal)
{ m_pData[Ch + ((X + m_Stride * Y) * 2)] = (u_char)(255.0f * fVal); }
template <>
inline void ImageAccessorBase<u_char, 3>::SetValueAt(u_int X, u_int Y, u_int Ch, float fVal)
{ m_pData[Ch + ((X + m_Stride * Y) * 3)] = (u_char)(255.0f * fVal); }
template <>
inline void ImageAccessorBase<u_char, 4>::SetValueAt(u_int X, u_int Y, u_int Ch, float fVal)
{ m_pData[Ch + ((X + m_Stride * Y) * 4)] = (u_char)(255.0f * fVal); }

template <>
inline void ImageAccessorBase<u_short, 1>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y)    )] = (u_short)(65535.0f * fVal); }
template <>
inline void ImageAccessorBase<u_short, 2>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 2)] = (u_short)(65535.0f * fVal); }
template <>
inline void ImageAccessorBase<u_short, 3>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 3)] = (u_short)(65535.0f * fVal); }
template <>
inline void ImageAccessorBase<u_short, 4>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 4)] = (u_short)(65535.0f * fVal); }

//template <class ChannelType, cu_int nch>
template <>
inline void ImageAccessorBase<u_int, 1>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y)    )] = (u_int)(0xffffffff * fVal); }
template <>
inline void ImageAccessorBase<u_int, 2>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 2)] = (u_int)(0xffffffff * fVal); }
template <>
inline void ImageAccessorBase<u_int, 3>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 3)] = (u_int)(0xffffffff * fVal); }
template <>
inline void ImageAccessorBase<u_int, 4>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 4)] = (u_int)(0xffffffff * fVal); }

template <>
inline void ImageAccessorBase<float, 1>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y)    )] = fVal; }
template <>
inline void ImageAccessorBase<float, 2>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 2)] = fVal; }
template <>
inline void ImageAccessorBase<float, 3>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 3)] = fVal; }
template <>
inline void ImageAccessorBase<float, 4>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 4)] = fVal; }

template <>
inline float ImageAccessorBase<u_char, 1>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y)    )] * (1.0f/255.0f); }
template <>
inline float ImageAccessorBase<u_char, 2>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 2)] * (1.0f/255.0f); }
template <>
inline float ImageAccessorBase<u_char, 3>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 3)] * (1.0f/255.0f); }
template <>
inline float ImageAccessorBase<u_char, 4>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 4)] * (1.0f/255.0f); }

template <>
inline float ImageAccessorBase<u_short, 1>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y)    )] * (1.0f/65535.0f); }
template <>
inline float ImageAccessorBase<u_short, 2>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 2)] * (1.0f/65535.0f); }
template <>
inline float ImageAccessorBase<u_short, 3>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 3)] * (1.0f/65535.0f); }
template <>
inline float ImageAccessorBase<u_short, 4>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 4)] * (1.0f/65535.0f); }

template <>
inline float ImageAccessorBase<u_int, 1>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y)    )] * (1.0f/float(0xffffffff)); }
template <>
inline float ImageAccessorBase<u_int, 2>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 2)] * (1.0f/float(0xffffffff)); }
template <>
inline float ImageAccessorBase<u_int, 3>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 3)] * (1.0f/float(0xffffffff)); }
template <>
inline float ImageAccessorBase<u_int, 4>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 4)] * (1.0f/float(0xffffffff)); }

template <>
inline float ImageAccessorBase<float, 1>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y)    )]; }
template <>
inline float ImageAccessorBase<float, 2>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 2)]; }
template <>
inline float ImageAccessorBase<float, 3>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 3)]; }
template <>
inline float ImageAccessorBase<float, 4>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return m_pData[Ch + ((X + m_Stride * Y) * 4)]; }



//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<float, 4>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), ValueAt(X,Y,3));
};

//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<u_char, 4>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), ValueAt(X,Y,3));
};

//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<u_short, 4>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), ValueAt(X,Y,3));
};

//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<u_short, 3>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), 1.0f);
};

//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<float, 3>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), 1.0f);
};

//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<u_char, 3>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), 1.0f);
};

//------------------------------------------------------------------------------
template <>
inline float ImageAccessorBase<half_, 3>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return float(m_pData[Ch + ((X + m_Stride * Y) * 3)]); }

//------------------------------------------------------------------------------
template <>
inline float ImageAccessorBase<half_, 4>::ValueAt( u_int X, u_int Y, u_int Ch ) const
{ return float(m_pData[Ch + ((X + m_Stride * Y) * 4)]); }

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<half_, 3>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 3)] = fVal; }

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<half_, 4>::SetValueAt( u_int X, u_int Y, u_int Ch, float fVal )
{ m_pData[Ch + ((X + m_Stride * Y) * 4)] = fVal; }


//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<half_, 4>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), ValueAt(X,Y,3));
};

//------------------------------------------------------------------------------
template <>
inline Color ImageAccessor<half_, 3>::ColorAt(u_int X, u_int Y) const
{
    return Color(ValueAt(X,Y,0), ValueAt(X,Y,1), ValueAt(X,Y,2), 1.0f);
};


//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<float, 4>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
    SetValueAt(X, Y, 3, c.a);
};

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<float, 3>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
};

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<half_, 4>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
    SetValueAt(X, Y, 3, c.a);
};

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<half_, 3>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
};

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<u_short, 4>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
    SetValueAt(X, Y, 3, c.a);
};

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<u_short, 3>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
};

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<u_char, 4>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
    SetValueAt(X, Y, 3, c.a);
};

//------------------------------------------------------------------------------
template <>
inline void ImageAccessorBase<u_char, 3>::SetColorAt(u_int X, u_int Y, const Color &c)
{
    SetValueAt(X, Y, 0, c.r);
    SetValueAt(X, Y, 1, c.g);
    SetValueAt(X, Y, 2, c.b);
};



//------------------------------------------------------------------------------
static inline void SnapOutTile(ImgTile &t)
{
    static const int TILE_SNAP  = (128-1); // must be ((2^i)-1). 
    t.nx  += t.x - 1;    t.ny  += t.y - 1;
    t.x   &= ~TILE_SNAP; t.y   &= ~TILE_SNAP;
    t.nx  +=  TILE_SNAP; t.ny  +=  TILE_SNAP;
    t.nx  &= ~TILE_SNAP; t.ny  &= ~TILE_SNAP;
    t.nx  -= t.x;        t.ny  -= t.y;
}


//------------------------------------------------------------------------------
#undef cu_int
#undef u_int
#undef u_short
#undef u_char
#undef inline

//------------------------------------------------------------------------------

}; // end of namespace mudbox
#endif