UT/UT_Pixel.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_Pixel.h ( UT Library, C++)
 *
 * COMMENTS:    Contains useful classes for representing pixels in a raster
 */

#ifndef __UT_Pixel__
#define __UT_Pixel__

#include "UT_API.h"
#include <SYS/SYS_Types.h>

class UT_Color;
class UT_BIG_RGBA;

class UT_API UT_RGBA {
public:
    UT_RGBA()   {}
    UT_RGBA(char cr, char cg, char cb, char ca)
            { a = (unsigned char)ca; b = (unsigned char)cb; 
              g = (unsigned char)cg; r = (unsigned char)cr; }

    UT_RGBA(const UT_BIG_RGBA &rgba) { *this = rgba; }

    UT_RGBA     &operator=(const UT_BIG_RGBA &big);
    UT_RGBA     &operator=(const UT_RGBA &mysmall);

    unsigned char       r, g, b, a;
};

class UT_API UT_BIG_RGBA {
public:
    UT_BIG_RGBA()       {}
    UT_BIG_RGBA(unsigned short cr, unsigned short cg,
                unsigned short cb, unsigned short ca)
    { a = ca; b = cb; g = cg; r = cr; }

    UT_BIG_RGBA(const UT_RGBA &rgba) { *this = rgba; }

    UT_BIG_RGBA &operator=(const UT_RGBA &mysmall);
    UT_BIG_RGBA &operator=(const UT_BIG_RGBA &big);

    unsigned short      r, g, b, a;
};

//
// This is a 16 bit pixel held in a signed 32 bit value. This allows 
// a pixel to have a negative value or a value of more than the channel
// brightness
//

class UT_RGBA;
class UT_BIG_RGBA;

class UT_API UT_LONG_RGBA
{
public:
    UT_LONG_RGBA() { a = b = g = r = 0; }
    UT_LONG_RGBA(unsigned short cr, unsigned short cg,
                 unsigned short cb, unsigned short ca)
                  { a = (long)ca; b = (long)cb; g = (long)cg; r = (long)cr; }

    UT_LONG_RGBA(const UT_RGBA     &rgba) { *this = rgba; }
    UT_LONG_RGBA(const UT_BIG_RGBA &rgba) { *this = rgba; }

    UT_LONG_RGBA        &operator=(const UT_RGBA     &mysmall);
    UT_LONG_RGBA        &operator=(const UT_BIG_RGBA &big);

    void        scale (fpreal);
    void        offset(fpreal);

    long        a, b, g, r;
};

class UT_API UT_HSVA {
public:
    UT_HSVA()           {}
    UT_HSVA(unsigned short ch, unsigned short cs, char cv, char ca)
    { h = (short)ch; s = (short)cs; 
      v = (unsigned short)((cv << 8) | cv); 
      a = (unsigned short)((ca << 8) | cv); }

    UT_HSVA(unsigned short ch, unsigned short cs,
            unsigned short cv, unsigned short ca)
    { h = (short)ch; s = (short)cs; v = cv; a = ca; }

    UT_HSVA(const UT_RGBA &rgba)     { *this = rgba; }
    UT_HSVA(const UT_BIG_RGBA &rgba) { *this = rgba; }
    UT_HSVA(const UT_HSVA &hsva)     { *this = hsva; }

    UT_HSVA     &operator=(const UT_RGBA     &rgba);
    UT_HSVA     &operator=(const UT_BIG_RGBA &rgba);
    UT_HSVA     &operator=(const UT_HSVA     &hsva);
    UT_HSVA     &operator=(const UT_Color    &c);

    operator    UT_RGBA()     const;
    operator    UT_BIG_RGBA() const;

    // Returns previous value:
    static int  enableAlphaDivide(int state);
    static int     getAlphaDivide() { return hsvDoAlphaDivide; }

    short               h, s;
    unsigned short      v, a;

private:
    static char         hsvDoAlphaDivide;
};

class UT_API UT_BUMP {
public:
    UT_BUMP() {}
    UT_BUMP(short u, short v)   { du = u; dv = v; }

    short       du, dv;
};

class UT_API UT_BIG_BUMP {
public:
    UT_BIG_BUMP() {}
    UT_BIG_BUMP(long u, long v) { du = (int)u; dv = (int)v; }

    int         du, dv;
};

#endif

---