color.h

Go to the documentation of this file.

/*
 * color.h
 *
 * Copyright 2010 Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * colors -- used just about everywhere
 */

#ifndef WAVEPACKET_COLOR_H__
#define WAVEPACKET_COLOR_H__

// includes --------------------------------------------------------------------
#include "common/common.h"


////////////////////////////////////////////////////////////////////////////////
//
// \ingroup geometric
// \defgroup color Basic Color Definitions
//
// These are basic color definitions used by a variety of libraries.  Includes
// 24-bit (8-bit per channel) and floating point (each channel is 0.0 - 1.0).
//
////////////////////////////////////////////////////////////////////////////////
/*@{*/

/// standard 4-byte color value for images.  Byte ranges 0-255
struct img_color_t {
        // constants
        enum eConstants {
                eMaxComponent   = 255   ///< max byte value for a color
        };

        // constructors
        img_color_t(void) throw() { }
        /// see caveats about the int-based setter
        img_color_t(IN int r, IN int g, IN int b, IN int a = eMaxComponent) throw()
                { this->set(r, g, b, a); }
        img_color_t(IN const img_color_t& c) throw() { *this = c; }

        // getters and setters
        const img_color_t& operator=(IN const img_color_t& c) throw() {
                        red = c.red;
                        green = c.green;
                        blue = c.blue;
                        alpha = c.alpha;
                        return *this;
                }

        /// could be inefficient!  If you are calling this a lot, consider
        ///     setting the byte values directly and doing your own validation.
        void set(IN int r, IN int g, IN int b, IN int a = eMaxComponent) throw() {
                        ASSERT(0 <= r && r <= eMaxComponent, "bad red: %d", r);
                        ASSERT(0 <= g && g <= eMaxComponent, "bad green: %d", g);
                        ASSERT(0 <= b && b <= eMaxComponent, "bad blue: %d", b);
                        ASSERT(0 <= a && a <= eMaxComponent, "bad alpha: %d", a);
                        red = r;
                        green = g;
                        blue = b;
                        alpha = a;
                }

        /// this will set the color to solid (opaque) black
        void clear(void) throw() {
                        red = green = blue = 0;
                        alpha = eMaxComponent;
                }

        /// for debugging
        void dump(IN const char * title) const throw() {
                        DPRINTF("%s: r=%d, g=%d, b=%d, a=%d",
                            title, red, green, blue, alpha);
                }

        // data
        byte_t          red;
        byte_t          green;
        byte_t          blue;
        byte_t          alpha;
};



/// colors used for GLUT (OpenGL utility library).  0-127 max component values
struct glut_color_t {
        // constructors
        glut_color_t(void) throw() { }

        /// see caveats about the setter
        glut_color_t(IN float r, IN float g, IN float b, IN float a = 1.0) throw()
                { this->set(r, g, b, a); }
        glut_color_t(IN const glut_color_t& c) throw() { *this = c; }

        // getters and setters
        const glut_color_t& operator=(IN const glut_color_t& c) throw() {
                        red = c.red;
                        green = c.green;
                        blue = c.blue;
                        alpha = c.alpha;
                        return *this;
                }

        /// could be inefficient!  If you are calling this a lot, consider
        ///     setting the byte values directly and doing your own validation.
        void set(IN float r, IN float g, IN float b, IN float a = 1.0) throw() {
                        ASSERT(0 <= r && r <= 1.0, "Bad red: %f", r);
                        ASSERT(0 <= g && g <= 1.0, "Bad green: %f", g);
                        ASSERT(0 <= b && b <= 1.0, "Bad blue: %f", b);
                        ASSERT(0 <= a && a <= 1.0, "Bad alpha: %f", a);
                        red = r;
                        green = g;
                        blue = b;
                        alpha = a;
                }

        /// this will set the color to solid (opaque) black
        void clear(void) throw() {
                        red = green = blue = 0;
                        alpha = 1.0;
                }

        /// for debugging
        void dump(IN const char * title) const throw() {
                        DPRINTF("%s: r=%5.3f, g=%5.3f, b=%5.3f, a=%5.3f",
                            title, red, green, blue, alpha);
                }

        // data
        float   red;
        float   green;
        float   blue;
        float   alpha;
};



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

void getImgColorFromString(IN const char * text,
                        OUT img_color_t& color);



#endif  // WAVEPACKET_COLOR_H__