color.h

/* -*- mode: C; c-basic-offset: 4; intent-tabs-mode: nil -*-
 *
 * Sifteo SDK
 *
 * Copyright <c> 2012 Sifteo, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#pragma once
#ifdef NOT_USERSPACE
#   error This is a userspace-only header, not allowed by the current build.
#endif

#include <sifteo/abi.h>
#include <sifteo/macros.h>
#include <sifteo/math.h>

namespace Sifteo {

struct RGB565 {
    uint16_t value;

    static RGB565 from565(uint8_t r, uint8_t g, uint8_t b) {
        RGB565 result = { (r << 11) | (g << 5) | b };
        return result;
    }

    static RGB565 fromRGB(uint8_t r, uint8_t g, uint8_t b) {
        /*
         * Round to the nearest 5/6 bit color. Note that simple
         * bit truncation does NOT produce the best result!
         */
        return from565( ((unsigned)r * 31 + 128) / 255,
                        ((unsigned)g * 63 + 128) / 255,
                        ((unsigned)b * 31 + 128) / 255 );
    }

    static RGB565 fromRGB(float r, float g, float b) {
        return from565( r * 31.f + 0.5f,
                        g * 63.f + 0.5f,
                        b * 31.f + 0.5f );
    }

    static RGB565 fromRGB(uint32_t rgb) {
        return fromRGB((uint8_t)(rgb >> 16), (uint8_t)(rgb >> 8), (uint8_t)rgb);
    }

    uint8_t red5() const {
        return (value >> 11) & 0x1F;
    }

    uint8_t green6() const {
        return (value >> 5) & 0x3F;
    }

    uint8_t blue5() const {
        return value & 0x1F;
    }

    uint8_t red() const {
        /*
         * A good approximation is `(r5 << 3) | (r5 >> 2)`, but this
         * is still not quite as accurate as the implementation here.
         */
        return red5() * 255 / 31;
    }

    uint8_t green() const {
        return green6() * 255 / 63;
    }

    uint8_t blue() const {
        return blue5() * 255 / 31;
    }

    uint32_t packedRGB() const {
        return blue() | (green() << 8) | (red() << 16);
    }
    
    RGB565 lerp(RGB565 other, uint8_t alpha) const {
        unsigned A = alpha;
        unsigned invA = 0xff - A;
        return from565( (red5()   * invA + other.red5()   * A) / 0xff,
                        (green6() * invA + other.green6() * A) / 0xff,
                        (blue5()  * invA + other.blue5()  * A) / 0xff );
    }

    bool operator== (const RGB565 &other) const { return value == other.value; }

    bool operator!= (const RGB565 &other) const { return value != other.value; }
};


struct ColormapSlot {
    _SYSAttachedVideoBuffer *sys;
    unsigned index;

    void set(RGB565 color) const {
        _SYS_vbuf_poke(&sys->vbuf, _SYS_VA_COLORMAP / 2 + index, color.value);
    }

    void set(uint8_t r, uint8_t g, uint8_t b) const {
        set(RGB565::fromRGB(r, g, b));
    }

    void set(float r, float g, float b) const {
        set(RGB565::fromRGB(r, g, b));
    }

    void set(uint32_t rgb) const {
        set(RGB565::fromRGB(rgb));
    }

    const ColormapSlot& operator= (RGB565 color) const {
        set(color);
        return *this;
    }

    const ColormapSlot& operator= (uint32_t color) const {
        set(color);
        return *this;
    }

    RGB565 get() const {
        RGB565 result = { _SYS_vbuf_peek(&sys->vbuf, _SYS_VA_COLORMAP / 2 + index) };
        return result;
    }
};


struct Colormap {
    _SYSAttachedVideoBuffer sys;

    static const unsigned NUM_COLORS = 16;

    ColormapSlot operator[](unsigned index) {
        ASSERT(index < NUM_COLORS);
        ColormapSlot result = { &sys, index };
        return result;
    }

    void erase() {
        _SYS_vbuf_fill(&sys.vbuf, _SYS_VA_COLORMAP / 2, 0, NUM_COLORS);
    }

    void fill(RGB565 color) {
        _SYS_vbuf_fill(&sys.vbuf, _SYS_VA_COLORMAP / 2, color.value, NUM_COLORS);
    }

    void setRange(const RGB565 *colors, unsigned firstColor, unsigned numColors) {
        ASSERT(firstColor <= NUM_COLORS && numColors <= NUM_COLORS
            && (firstColor + numColors) <= NUM_COLORS);
        _SYS_vbuf_write(&sys.vbuf, _SYS_VA_COLORMAP / 2 + firstColor,
            &colors[0].value, numColors);
    }

    void set(const RGB565 *colors) {
        setRange(colors, 0, NUM_COLORS);
    }

    void setEGA() {
        static const RGB565 colors[] = {
            /*  0 */ { 0x0000 },
            /*  1 */ { 0x0015 },
            /*  2 */ { 0x0540 },
            /*  3 */ { 0x0555 },
            /*  4 */ { 0xa800 },
            /*  5 */ { 0xa815 },
            /*  6 */ { 0xaaa0 },
            /*  7 */ { 0xad55 },
            /*  8 */ { 0x52aa },
            /*  9 */ { 0x52bf },
            /* 10 */ { 0x57ea },
            /* 11 */ { 0x57ff },
            /* 12 */ { 0xfaaa },
            /* 13 */ { 0xfabf },
            /* 14 */ { 0xffea },
            /* 15 */ { 0xffff },
        };
        set(colors);
    }

    void setMono(RGB565 color0, RGB565 color1) {
        (*this)[0].set(color0);
        (*this)[1].set(color1);
    }

    void setMono(uint32_t color0, uint32_t color1) {
        (*this)[0].set(color0);
        (*this)[1].set(color1);
    }

    _SYSVideoBuffer &videoBuffer() {
        return sys.vbuf;
    }

    CubeID cube() const {
        return sys.cube;
    }
};

};  // namespace Sifteo