bg0.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>
#include <sifteo/asset.h>

namespace Sifteo {

struct BG0Drawable {
    _SYSAttachedVideoBuffer sys;

    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();
    }

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

    void erase(const PinnedAssetImage &image) {
        erase(image.tile(sys.cube, 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);
    }

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

    uint16_t tile(UInt2 pos) {
        ASSERT(pos.x < tileWidth() && pos.y < tileHeight());
        return _SYS_INVERSE_TILE77(_SYS_vbuf_peek(&sys.vbuf, tileAddr(pos)));
    }
    
    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 span(UInt2 pos, unsigned width, const PinnedAssetImage &image)
    {
        span(pos, width, image.tile(sys.cube,0));
    }

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

    void fill(UInt2 topLeft, UInt2 size, const PinnedAssetImage &image)
    {
        fill(topLeft, size, image.tile(sys.cube, 0));
    }

    void image(UInt2 pos, const AssetImage &image, unsigned frame = 0)
    {
        _SYS_image_BG0Draw(&sys, image, tileAddr(pos), frame);
    }

    void image(UInt2 destXY, UInt2 size, const AssetImage &image, UInt2 srcXY, unsigned frame = 0)
    {
        _SYS_image_BG0DrawRect(&sys, image, tileAddr(destXY),
            frame, (_SYSInt2*) &srcXY, (_SYSInt2*) &size);
    }

    void text(Int2 topLeft, const AssetImage &font, const char *str, char firstChar = ' ')
    {
        unsigned addr = tileAddr(topLeft);
        unsigned lineAddr = addr;
        char c;

        while ((c = *str)) {
            if (c == '\n') {
                addr = (lineAddr += font.tileHeight() * tileWidth());
            } else {
                _SYS_image_BG0Draw(&sys, font, addr, c - firstChar);
                addr += font.tileWidth();
            }
            str++;
        }
    }

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

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

};  // namespace Sifteo