lib/icon_pixel.h

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#ifndef LIB_ICON_PIXEL_H
#define LIB_ICON_PIXEL_H

#include <lib/ac/math.h>
#include <string>


class icon_pixel
{
public:
    ~icon_pixel(){}

    static const icon_pixel black;
    static const icon_pixel white;
    static const icon_pixel transparent;

    typedef double real_type;
    typedef unsigned short short_type;
    typedef unsigned char byte_type;

    icon_pixel() :
        red_real(0),
        red_short(0),
        green_real(0),
        green_short(0),
        blue_real(0),
        blue_short(0),
        alpha_real(0),
        alpha_short(0),
        real_valid(true),
        short_valid(true)
    {
    }

    icon_pixel(short_type rr, short_type gg, short_type bb) :
        red_real(0),
        red_short(rr),
        green_real(0),
        green_short(gg),
        blue_real(0),
        blue_short(bb),
        alpha_real(1.),
        alpha_short(65535),
        real_valid(false),
        short_valid(true)
    {
    }

    icon_pixel(short_type rr, short_type gg, short_type bb, short_type aa) :
        red_real(0),
        red_short(aa ? rr : 0),
        green_real(0),
        green_short(aa ? gg : 0),
        blue_real(0),
        blue_short(aa ? bb : 0),
        alpha_real(0),
        alpha_short(aa),
        real_valid(false),
        short_valid(true)
    {
    }

    icon_pixel(real_type rr, real_type gg, real_type bb) :
        red_real(rr),
        red_short(0),
        green_real(gg),
        green_short(0),
        blue_real(bb),
        blue_short(0),
        alpha_real(1.0),
        alpha_short(65535),
        real_valid(true),
        short_valid(false)
    {
    }

    icon_pixel(real_type rr, real_type gg, real_type bb, real_type aa) :
        red_real(aa > 0 ? rr : 0),
        red_short(0),
        green_real(aa > 0 ? gg : 0),
        green_short(0),
        blue_real(aa > 0 ? bb : 0),
        blue_short(0),
        alpha_real(aa),
        alpha_short(0),
        real_valid(true),
        short_valid(false)
    {
    }

    icon_pixel(const icon_pixel &arg) :
        red_real(arg.red_real),
        red_short(arg.red_short),
        green_real(arg.green_real),
        green_short(arg.green_short),
        blue_real(arg.blue_real),
        blue_short(arg.blue_short),
        alpha_real(arg.alpha_real),
        alpha_short(arg.alpha_short),
        real_valid(arg.real_valid),
        short_valid(arg.short_valid)
    {
    }

    icon_pixel &
    operator=(const icon_pixel &arg)
    {
        if (this != &arg)
        {
            red_real = arg.red_real;
            red_short = arg.red_short;
            green_real = arg.green_real;
            green_short = arg.green_short;
            blue_real = arg.blue_real;
            blue_short = arg.blue_short;
            alpha_real = arg.alpha_real;
            alpha_short = arg.alpha_short;
            real_valid = arg.real_valid;
            short_valid = arg.short_valid;
        }
        return *this;
    }

    bool
    is_transparent(void)
        const
    {
        return (short_valid ? (alpha_short == 0) : (alpha_real < 0.002));
    }

    bool
    is_opaque(void)
        const
    {
        return (short_valid ? (alpha_short >= 65408) : (alpha_real >= 1.0));
    }

    icon_pixel
    invert(void)
        const
    {
        return
            (
                real_valid
            ?
                icon_pixel
                (
                    1. - red_real,
                    1. - green_real,
                    1. - blue_real,
                    alpha_real
                )
            :
                icon_pixel
                (
                    short_type(65535 - red_short),
                    short_type(65535 - green_short),
                    short_type(65535 - blue_short),
                    alpha_short
                )
            );
    }

    real_type
    get_red(void)
        const
    {
        if (!real_valid)
            convert_short_to_real();
        return red_real;
    }

    real_type
    get_green(void)
        const
    {
        if (!real_valid)
            convert_short_to_real();
        return green_real;
    }

    real_type
    get_blue(void)
        const
    {
        if (!real_valid)
            convert_short_to_real();
        return blue_real;
    }

    real_type
    get_alpha(void)
        const
    {
        if (!real_valid)
            convert_short_to_real();
        return alpha_real;
    }

    short_type
    get_red_short(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return red_short;
    }

    byte_type
    get_red_byte(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return (red_short >> 8);
    }

    short_type
    get_green_short(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return green_short;
    }

    byte_type
    get_green_byte(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return (green_short >> 8);
    }

    short_type
    get_blue_short(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return blue_short;
    }

    byte_type
    get_blue_byte(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return (blue_short >> 8);
    }

    short_type
    get_alpha_short(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return alpha_short;
    }

    byte_type
    get_alpha_byte(void)
        const
    {
        if (!short_valid)
            convert_real_to_short();
        return (alpha_short >> 8);
    }

    std::string representation(void) const;

    bool operator==(const icon_pixel &rhs) const;

    bool
    operator!=(const icon_pixel &rhs)
        const
    {
        return !operator==(rhs);
    }

    void operator*=(const icon_pixel &rhs);

    icon_pixel operator*(const icon_pixel &rhs) const;

    void operator*=(double);

    icon_pixel operator*(double) const;

    icon_pixel monochrome(void) const;

    real_type get_intensity(void) const;

    static short_type
    short_from_byte(byte_type x)
    {
        return ((short_type(x) << 8) | short_type(x));
    }

private:
    mutable real_type red_real;

    mutable short_type red_short;

    mutable real_type green_real;

    mutable short_type green_short;

    mutable real_type blue_real;

    mutable short_type blue_short;

    mutable real_type alpha_real;

    mutable short_type alpha_short;

    mutable bool real_valid;

    mutable bool short_valid;

    static short_type
    convert_channel_real_to_short(real_type x)
    {
        // multiply by 65535 is slow, so break it up
        unsigned n = x * 65536;
        n -= (n >> 16);
        return n;
    }

    void
    convert_real_to_short(void)
        const
    {
        red_short = convert_channel_real_to_short(red_real);
        green_short = convert_channel_real_to_short(green_real);
        blue_short = convert_channel_real_to_short(blue_real);
        alpha_short = convert_channel_real_to_short(alpha_real);
        short_valid = true;
    }

    static real_type
    convert_channel_short_to_real(short_type x)
    {
        if (x >= 65535)
            return 1;
        return ldexp(real_type(x), -16);
    }

    void
    convert_short_to_real(void)
        const
    {
        red_real = convert_channel_short_to_real(red_short);
        green_real = convert_channel_short_to_real(green_short);
        blue_real = convert_channel_short_to_real(blue_short);
        alpha_real = convert_channel_short_to_real(alpha_short);
        real_valid = true;
    }
};

#endif // LIB_ICON_PIXEL_H