bg0rom.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 BG0ROMDrawable {
    _SYSAttachedVideoBuffer sys;

    enum Palette {
        BLACK_ON_WHITE      = 0 << 10,
        BLUE_ON_WHITE       = 1 << 10,
        ORANGE_ON_WHITE     = 2 << 10,
        YELLOW_ON_BLUE      = 3 << 10,
        RED_ON_WHITE        = 4 << 10,
        GRAY_ON_WHITE       = 5 << 10,
        WHITE_ON_BLACK      = 6 << 10,
        WHITE_ON_BLUE       = 7 << 10,
        WHITE_ON_TEAL       = 8 << 10,
        BLACK_ON_YELLOW     = 9 << 10,
        DKGRAY_ON_LTGRAY    = 10 << 10,
        GREEN_ON_WHITE      = 11 << 10,
        WHITE_ON_GREEN      = 12 << 10,
        PURPLE_ON_WHITE     = 13 << 10,
        LTBLUE_ON_DKBLUE    = 14 << 10,
        GOLD_ON_WHITE       = 15 << 10,

        // Aliases for white background
        BLACK   = BLACK_ON_WHITE,
        BLUE    = BLUE_ON_WHITE,
        ORANGE  = ORANGE_ON_WHITE,
        RED     = RED_ON_WHITE,
        GRAY    = GRAY_ON_WHITE,
        GREEN   = GREEN_ON_WHITE,
        PURPLE  = PURPLE_ON_WHITE,
        GOLD    = GOLD_ON_WHITE,
    };

    enum Tiles {
        FONT_SPACE  = 0,        
        SOLID_BG    = 0,        
        SOLID_FG    = 104,      
        V_BARGRAPH  = 224,      
        H_BARGRAPH  = 231,      
        HEART       = 128,
        FROWN       = 136,
        SMILE       = 152,
        SMILE2      = 141,
        RIGHT_ARROW = 125, 
        LEFT_ARROW  = 126,
    };

    enum ColorMode {
        TWO_COLOR   = 0 << 9,
        FOUR_COLOR  = 1 << 9,
    };

    static unsigned tileWidth() {
        return _SYS_VRAM_BG0_WIDTH;
    }

    static unsigned tileHeight() {
        return _SYS_VRAM_BG0_WIDTH;
    }

    static UInt2 tileSize() {
        return vec(tileWidth(), tileHeight());
    }

    static unsigned pixelWidth() {
        return tileWidth() * 8;
    }

    static unsigned pixelHeight() {
        return tileHeight() * 8;
    }

    static UInt2 pixelSize() {
        return vec(pixelWidth(), pixelHeight());
    }

    static unsigned sizeInBytes() {
        return tileWidth() * tileHeight() * 2;
    }

    static unsigned sizeInWords() {
        return tileWidth() * tileHeight();
    }

    uint16_t tileAddr(UInt2 pos) {
        return pos.x + pos.y * tileWidth();
    }

    void erase(uint16_t index = 0) {
        _SYS_vbuf_fill(&sys.vbuf, 0, _SYS_TILE77(index), sizeInWords());
        setPanning(vec(0,0));
    }

    void setPanning(Int2 pixels) {
        _SYS_vbuf_poke(&sys.vbuf, offsetof(_SYSVideoRAM, bg0_x) / 2,
            umod(pixels.x, pixelWidth()) |
            (umod(pixels.y, pixelHeight()) << 8));
    }

    Int2 getPanning() const {
        unsigned word = _SYS_vbuf_peek(&sys.vbuf, offsetof(_SYSVideoRAM, bg0_x) / 2);
        return vec<int>(word & 0xFF, word >> 8);
    }

    static uint16_t charTile(char c, enum Palette palette = BLACK) {
        return palette ^ (c - ' ' + FONT_SPACE);
    }

    void plot(UInt2 pos, uint16_t tileIndex) {
        ASSERT(pos.x < tileWidth() && pos.y < tileHeight());
        _SYS_vbuf_poke(&sys.vbuf, tileAddr(pos), _SYS_TILE77(tileIndex));
    }

    void span(UInt2 pos, unsigned width, unsigned tileIndex)
    {
        ASSERT(pos.x <= tileWidth() && width <= tileWidth() &&
            (pos.x + width) <= tileWidth() && pos.y < tileHeight());
        _SYS_vbuf_fill(&sys.vbuf, tileAddr(pos), _SYS_TILE77(tileIndex), width);
    }

    void fill(UInt2 topLeft, UInt2 size, unsigned tileIndex)
    {
        while (size.y) {
            span(topLeft, size.x, tileIndex);
            size.y--;
            topLeft.y++;
        }
    }

    void hBargraph(Int2 topLeft, unsigned pixelWidth,
        enum Palette palette = BLACK, unsigned tileHeight = 1)
    {
        unsigned addr = tileAddr(topLeft);
        int wTiles = pixelWidth / 8;
        int wRemainder = pixelWidth % 8;

        while (tileHeight--) {
            _SYS_vbuf_fill(&sys.vbuf, addr,
                _SYS_TILE77(palette ^ SOLID_FG), wTiles);
            if (wRemainder)
                _SYS_vbuf_poke(&sys.vbuf, addr + wTiles,
                    _SYS_TILE77(palette ^ (H_BARGRAPH + wRemainder - 1)));
            addr += tileWidth();
        }
    }

    void text(Int2 topLeft, const char *str, enum Palette palette = BLACK)
    {
        unsigned addr = tileAddr(topLeft);
        unsigned lineAddr = addr;
        char c;

        while ((c = *str)) {
            if (c == '\n')
                addr = (lineAddr += tileWidth());
            else
                _SYS_vbuf_poke(&sys.vbuf, addr++, _SYS_TILE77(charTile(c, palette)));
            str++;
        }
    }

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

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

};  // namespace Sifteo