bg2.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>
#include <sifteo/video/color.h>

namespace Sifteo {

struct BG2Drawable {
    _SYSAttachedVideoBuffer sys;

    static unsigned tileWidth() {
        return _SYS_VRAM_BG2_WIDTH;
    }

    static unsigned tileHeight() {
        return _SYS_VRAM_BG2_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());
    }

    void erase(const PinnedAssetImage &image) {
        erase(image.tile(sys.cube, 0));
    }
    
    void setBorder(RGB565 color) {
        _SYS_vbuf_poke(&sys.vbuf, offsetof(_SYSVideoRAM, bg2_border) / 2,
            color.value);
    }

    RGB565 getBorder() const {
        RGB565 result = { _SYS_vbuf_peek(&sys.vbuf, offsetof(_SYSVideoRAM, bg2_border)) };
        return result;
    }

    void setMatrix(const AffineMatrix &m) {
        _SYSAffine a = {
            // Round to fixed-point
            256.0f * m.cx + 0.5f,
            256.0f * m.cy + 0.5f,
            256.0f * m.xx + 0.5f,
            256.0f * m.xy + 0.5f,
            256.0f * m.yx + 0.5f,
            256.0f * m.yy + 0.5f,
        };
        _SYS_vbuf_write(&sys.vbuf, offsetof(_SYSVideoRAM, bg2_affine)/2,
                        (const uint16_t *)&a, 6);
    }

    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 image(UInt2 pos, const AssetImage &image, unsigned frame = 0)
    {
        _SYS_image_BG2Draw(&sys, image, tileAddr(pos), frame);
    }

    void image(UInt2 destXY, UInt2 size, const AssetImage &image, UInt2 srcXY, unsigned frame = 0)
    {
        _SYS_image_BG2DrawRect(&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_BG2Draw(&sys, font, addr, c - firstChar);
                addr += font.tileWidth();
            }
            str++;
        }
    }

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

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

};  // namespace Sifteo