bg1.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 BG1Mask {
    // Matches the memory layout of BG1, but uses faster 32-bit arithmetic.
    uint32_t row10;
    uint32_t row32;
    uint32_t row54;
    uint32_t row76;
    uint32_t row98;
    uint32_t rowBA;
    uint32_t rowDC;
    uint32_t rowFE;

    static BG1Mask empty() {
        BG1Mask result = { 0, 0, 0, 0, 0, 0, 0, 0 };
        return result;
    }

    static BG1Mask filled(UInt2 topLeft, UInt2 size) {
        unsigned xBits = ((1 << size.x) - 1) << topLeft.x;
        unsigned yBits = ((1 << size.y) - 1) << topLeft.y;

        unsigned row0 = yBits & 0x0001 ? xBits : 0;
        unsigned row1 = yBits & 0x0002 ? xBits : 0;
        unsigned row2 = yBits & 0x0004 ? xBits : 0;
        unsigned row3 = yBits & 0x0008 ? xBits : 0;
        unsigned row4 = yBits & 0x0010 ? xBits : 0;
        unsigned row5 = yBits & 0x0020 ? xBits : 0;
        unsigned row6 = yBits & 0x0040 ? xBits : 0;
        unsigned row7 = yBits & 0x0080 ? xBits : 0;
        unsigned row8 = yBits & 0x0100 ? xBits : 0;
        unsigned row9 = yBits & 0x0200 ? xBits : 0;
        unsigned rowA = yBits & 0x0400 ? xBits : 0;
        unsigned rowB = yBits & 0x0800 ? xBits : 0;
        unsigned rowC = yBits & 0x1000 ? xBits : 0;
        unsigned rowD = yBits & 0x2000 ? xBits : 0;
        unsigned rowE = yBits & 0x4000 ? xBits : 0;
        unsigned rowF = yBits & 0x8000 ? xBits : 0;

        BG1Mask result = {
            (row1 << 16) | row0,
            (row3 << 16) | row2,
            (row5 << 16) | row4,
            (row7 << 16) | row6,
            (row9 << 16) | row8,
            (rowB << 16) | rowA,
            (rowD << 16) | rowC,
            (rowF << 16) | rowE,
        };
        return result;
    }

    void clear() {
        _SYS_memset32(&row10, 0, 8);
    }

    uint16_t *rows() {
        return (uint16_t*) this;
    }
    const uint16_t *rows() const {
        return (const uint16_t*) this;
    }

    void plot(unsigned x, unsigned y) {
        ASSERT(x < 16 && y < 16);
        rows()[y] |= 1 << x;
    }

    void plot(UInt2 pos) {
        plot(pos.x, pos.y);
    }

    void fill(UInt2 topLeft, UInt2 size) {
        for (unsigned y = 0; y < size.y; y++)
            for (unsigned x = 0; x < size.x; x++)
                plot(topLeft.x + x, topLeft.y + y);
    }

    BG1Mask & operator|= (BG1Mask other) {
        row10 |= other.row10;
        row32 |= other.row32;
        row54 |= other.row54;
        row76 |= other.row76;
        row98 |= other.row98;
        rowBA |= other.rowBA;
        rowDC |= other.rowDC;
        rowFE |= other.rowFE;
        return *this;
    }

    BG1Mask & operator&= (BG1Mask other) {
        row10 &= other.row10;
        row32 &= other.row32;
        row54 &= other.row54;
        row76 &= other.row76;
        row98 &= other.row98;
        rowBA &= other.rowBA;
        rowDC &= other.rowDC;
        rowFE &= other.rowFE;
        return *this;
    }

    BG1Mask & operator^= (BG1Mask other) {
        row10 ^= other.row10;
        row32 ^= other.row32;
        row54 ^= other.row54;
        row76 ^= other.row76;
        row98 ^= other.row98;
        rowBA ^= other.rowBA;
        rowDC ^= other.rowDC;
        rowFE ^= other.rowFE;
        return *this;
    }

    BG1Mask operator| (BG1Mask other) const {
         BG1Mask result = {
             row10 | other.row10,
             row32 | other.row32,
             row54 | other.row54,
             row76 | other.row76,
             row98 | other.row98,
             rowBA | other.rowBA,
             rowDC | other.rowDC,
             rowFE | other.rowFE,
        };
        return result;
    }

    BG1Mask operator& (BG1Mask other) const {
         BG1Mask result = {
             row10 & other.row10,
             row32 & other.row32,
             row54 & other.row54,
             row76 & other.row76,
             row98 & other.row98,
             rowBA & other.rowBA,
             rowDC & other.rowDC,
             rowFE & other.rowFE,
        };
        return result;
    }

    BG1Mask operator^ (BG1Mask other) const {
         BG1Mask result = {
             row10 ^ other.row10,
             row32 ^ other.row32,
             row54 ^ other.row54,
             row76 ^ other.row76,
             row98 ^ other.row98,
             rowBA ^ other.rowBA,
             rowDC ^ other.rowDC,
             rowFE ^ other.rowFE,
        };
        return result;
    }

    BG1Mask operator~ () const {
         BG1Mask result = {
             ~row10,
             ~row32,
             ~row54,
             ~row76,
             ~row98,
             ~rowBA,
             ~rowDC,
             ~rowFE,
        };
        return result;
    }
};


struct BG1Drawable {
    _SYSAttachedVideoBuffer sys;

    static unsigned tileWidth() {
        return _SYS_VRAM_BG1_WIDTH;
    }

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

    void erase(uint16_t index = 0) {
        eraseMask();
        _SYS_vbuf_fill(&sys.vbuf, _SYS_VA_BG1_TILES / 2,
            _SYS_TILE77(index), numTiles());
        setPanning(vec(0,0));
    }

    void erase(const PinnedAssetImage &image) {
        erase(image.tile(sys.cube, 0));
    }

    void fill(uint16_t index = 0) {
        _SYS_vbuf_fill(&sys.vbuf, _SYS_VA_BG1_TILES / 2,
            _SYS_TILE77(index), numTiles());
    }

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

    void eraseMask() {
        _SYS_finish();
        _SYS_vbuf_fill(&sys.vbuf, _SYS_VA_BG1_BITMAP/2, 0, _SYS_VRAM_BG1_WIDTH);
    }

    void setMask(const BG1Mask &mask) {
        _SYS_finish();
        _SYS_vbuf_write(&sys.vbuf, offsetof(_SYSVideoRAM, bg1_bitmap)/2,
            mask.rows(), 16);
    }

    void fillMask(UInt2 topLeft, UInt2 size) {
        _SYS_finish();
        _SYS_vbuf_fill(&sys.vbuf,
            offsetof(_SYSVideoRAM, bg1_bitmap)/2 + topLeft.y,
            ((1 << size.x) - 1) << topLeft.x, size.y);
    }

    void setPanning(Int2 pixels) {
        unsigned x = pixels.x & 0xFF;
        unsigned y = pixels.y & 0xFF;
        _SYS_vbuf_poke(&sys.vbuf, offsetof(_SYSVideoRAM, bg1_x) / 2, x | (y << 8));
    }

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

    void plot(unsigned locationIndex, uint16_t tileIndex) {
        ASSERT(locationIndex < numTiles());
        _SYS_vbuf_poke(&sys.vbuf, _SYS_VA_BG1_TILES / 2 + locationIndex,
            _SYS_TILE77(tileIndex));
    }

    void span(unsigned locationIndex, unsigned count, unsigned tileIndex)
    {
        ASSERT(locationIndex <= numTiles() && count <= numTiles() &&
            (locationIndex + count) < numTiles());
        _SYS_vbuf_fill(&sys.vbuf, _SYS_VA_BG1_TILES / 2 + locationIndex,
            _SYS_TILE77(tileIndex), count);
    }

    void image(UInt2 pos, const AssetImage &image, unsigned frame = 0)
    {
        _SYS_image_BG1Draw(&sys, image, (_SYSInt2*) &pos, frame);
    }

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

    void maskedImage(const AssetImage &image, const PinnedAssetImage &key,
        unsigned frame = 0)
    {
        _SYS_finish();
        _SYS_image_BG1MaskedDraw(&sys, image, key.tile(sys.cube, 0), frame);
    }

    void maskedImage(UInt2 size, const AssetImage &image,
        const PinnedAssetImage &key, UInt2 srcXY,
        unsigned frame = 0)
    {
        _SYS_finish();
        _SYS_image_BG1MaskedDrawRect(&sys, image, key.tile(sys.cube, 0), frame,
            (_SYSInt2*) &srcXY, (_SYSInt2*) &size);
    }

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

        while ((c = *str)) {
            if (c == '\n') {
                pos.x = topLeft.x;
                pos.y += font.tileHeight();
            } else {
                _SYS_image_BG1Draw(&sys, font, (_SYSInt2*) &pos, c - firstChar);
                pos.x += font.tileWidth();
            }
            str++;
        }
    }

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

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

};  // namespace Sifteo