tilebuffer.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/memory.h>
#include <sifteo/cube.h>

namespace Sifteo {

template <unsigned tW, unsigned tH, unsigned tF = 1>
struct TileBuffer {
    struct {
        _SYSAssetImage image;
        _SYSCubeID cube;
    } sys;
    uint16_t tiles[tW * tH * tF];

    // Implicit conversion to AssetImage base class
    operator const AssetImage& () const { return *reinterpret_cast<const AssetImage*>(&sys.image); }
    operator AssetImage& () { return *reinterpret_cast<AssetImage*>(&sys.image); }
    operator const AssetImage* () const { return reinterpret_cast<const AssetImage*>(&sys.image); }
    operator AssetImage* () { return reinterpret_cast<AssetImage*>(&sys.image); }

    // Implicit conversion to FlatAssetImage
    operator const FlatAssetImage& () const { return *reinterpret_cast<const FlatAssetImage*>(&sys.image); }
    operator FlatAssetImage& () { return *reinterpret_cast<FlatAssetImage*>(&sys.image); }
    operator const FlatAssetImage* () const { return reinterpret_cast<const FlatAssetImage*>(&sys.image); }
    operator FlatAssetImage* () { return reinterpret_cast<FlatAssetImage*>(&sys.image); }

    // Implicit conversion to system object
    operator const _SYSAssetImage& () const { return sys.image; }
    operator _SYSAssetImage& () { return sys.image; }
    operator const _SYSAssetImage* () const { return sys.image; }
    operator _SYSAssetImage* () { return sys.image; }

    CubeID cube() const {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        return sys.cube;
    }

    void setCube(CubeID cube) {
        sys.cube = cube;
    }

    void init() {
        sys.cube = _SYS_CUBE_ID_INVALID;
        bzero(sys.image);
        sys.image.width = tW;
        sys.image.height = tH;
        sys.image.frames = tF;
        sys.image.format = _SYS_AIF_FLAT;
        sys.image.pData = reinterpret_cast<uint32_t>(&tiles[0]);
    }

    TileBuffer() {
        init();
    }

    TileBuffer(CubeID cube) {
        init();

        sys.cube = cube;
    }

    static unsigned tileWidth() {
        return tW;
    }

    static unsigned tileHeight() {
        return tH;
    }

    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 int numFrames() {
        return tF;
    }

    static int numTilesPerFrame() {
        return tileWidth() * tileHeight();
    }

    static int numTiles() {
        return numFrames() * numTilesPerFrame();
    }

    static unsigned sizeInBytes() {
        return numTiles() * 2;
    }

    static unsigned sizeInWords() {
        return numTiles();
    }

    void erase(uint16_t index = 0) {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        memset16(&tiles[0], index, sizeInWords());
    }

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

    uint16_t tileAddr(UInt2 pos, unsigned frame = 0) const {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        return pos.x + (pos.y + frame * tileHeight()) * tileWidth();
    }

    void plot(unsigned i, uint16_t tileIndex) {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        ASSERT(i < numTiles());
        tiles[i] = tileIndex;
    }

    void plot(UInt2 pos, uint16_t tileIndex, unsigned frame = 0) {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        ASSERT(pos.x < tileWidth() && pos.y < tileHeight() && frame < numFrames());
        tiles[tileAddr(pos, frame)] = tileIndex;
    }

    uint16_t tile(unsigned i) const {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        ASSERT(i < numTiles());
        return tiles[i];
    }

    uint16_t tile(UInt2 pos, unsigned frame = 0) const {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        ASSERT(pos.x < tileWidth() && pos.y < tileHeight() && frame < numFrames());
        return tiles[tileAddr(pos, frame)];
    }

    void span(UInt2 pos, unsigned width, unsigned tileIndex, unsigned frame = 0)
    {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        ASSERT(pos.x <= tileWidth() && width <= tileWidth() &&
            (pos.x + width) <= tileWidth() && pos.y < tileHeight());
        memset16(&tiles[tileAddr(pos, frame)], tileIndex, width);
    }

    void span(UInt2 pos, unsigned width, const PinnedAssetImage &image, unsigned frame = 0)
    {
        span(pos, width, image.tile(sys.cube, 0), frame);
    }

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

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

    void image(UInt2 pos, const AssetImage &image, unsigned srcFrame = 0, unsigned destFrame = 0)
    {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        ASSERT(pos.x < tileWidth() && pos.x + image.tileWidth() <= tileWidth() &&
               pos.y < tileHeight() && pos.y + image.tileHeight() <= tileHeight() &&
               destFrame < numFrames());
        _SYS_image_memDraw(&tiles[tileAddr(pos, destFrame)], sys.cube, image, tileWidth(), srcFrame);
    }

    void image(UInt2 destXY, UInt2 size, const AssetImage &image, UInt2 srcXY,
        unsigned srcFrame = 0, unsigned destFrame = 0)
    {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        ASSERT(destXY.x < tileWidth() && destXY.x + size.x <= tileWidth() &&
               destXY.y < tileHeight() && destXY.y + size.y <= tileHeight() &&
               destFrame < numFrames());
        _SYS_image_memDrawRect(&tiles[tileAddr(destXY, destFrame)], sys.cube,
            image, tileWidth(), srcFrame, (_SYSInt2*) &srcXY, (_SYSInt2*) &size);
    }

    void text(Int2 topLeft, const AssetImage &font, const char *str,
        unsigned destFrame = 0, char firstChar = ' ')
    {
        ASSERT(sys.cube != _SYS_CUBE_ID_INVALID);
        uint16_t *addr = &tiles[tileAddr(topLeft, destFrame)];
        uint16_t *lineAddr = addr;
        char c;

        while ((c = *str)) {
            if (c == '\n') {
                addr = (lineAddr += tileWidth());
            } else {
                ASSERT(font.tileWidth() + (font.tileHeight() - 1) * tileWidth() + addr
                    <= numTiles() + tiles);
                _SYS_image_memDraw(addr, sys.cube, font, tileWidth(), c - firstChar);
                addr += font.tileWidth();
            }
            str++;
        }
    }
};


template <unsigned tW, unsigned tH, unsigned tF = 1>
struct RelocatableTileBuffer {
    _SYSAssetImage sys;
    uint16_t tiles[tW * tH * tF];

    operator const AssetImage& () const { return *reinterpret_cast<const AssetImage*>(&sys); }
    operator AssetImage& () { return *reinterpret_cast<AssetImage*>(&sys); }
    operator const AssetImage* () const { return reinterpret_cast<const AssetImage*>(&sys); }
    operator AssetImage* () { return reinterpret_cast<AssetImage*>(&sys); }

    operator const FlatAssetImage& () const { return *reinterpret_cast<const FlatAssetImage*>(&sys); }
    operator FlatAssetImage& () { return *reinterpret_cast<FlatAssetImage*>(&sys); }
    operator const FlatAssetImage* () const { return reinterpret_cast<const FlatAssetImage*>(&sys); }
    operator FlatAssetImage* () { return reinterpret_cast<FlatAssetImage*>(&sys); }

    operator const _SYSAssetImage& () const { return sys; }
    operator _SYSAssetImage& () { return sys; }
    operator const _SYSAssetImage* () const { return sys; }
    operator _SYSAssetImage* () { return sys; }

    void init() {
        bzero(sys);
        sys.width = tW;
        sys.height = tH;
        sys.frames = tF;
        sys.format = _SYS_AIF_FLAT;
        sys.pData = reinterpret_cast<uint32_t>(&tiles[0]);
    }

    RelocatableTileBuffer() {
        init();
    }

    static unsigned tileWidth() {
        return tW;
    }

    static unsigned tileHeight() {
        return tH;
    }

    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 int numFrames() {
        return tF;
    }

    static int numTilesPerFrame() {
        return tileWidth() * tileHeight();
    }

    static int numTiles() {
        return numFrames() * numTilesPerFrame();
    }

    static unsigned sizeInBytes() {
        return numTiles() * 2;
    }

    static unsigned sizeInWords() {
        return numTiles();
    }

    void setAssetGroup(AssetGroup &group) {
        uint32_t pAssetGroup = reinterpret_cast<uint32_t>(&group.sys);
        ASSERT(sys.pAssetGroup == 0 || sys.pAssetGroup == pAssetGroup);
        sys.pAssetGroup = pAssetGroup;
    }

    void erase(uint16_t index = 0) {
        memset16(&tiles[0], index, sizeInWords());
    }

    void erase(const PinnedAssetImage &image) {
        setAssetGroup(image.assetGroup());
        erase(image.tile(0));
    }

    uint16_t tileAddr(UInt2 pos, unsigned frame = 0) {
        return pos.x + (pos.y + frame * tileHeight()) * tileWidth();
    }

    void plot(unsigned i, uint16_t tileIndex) {
        ASSERT(i < numTiles());
        tiles[i] = tileIndex;
    }

    void plot(UInt2 pos, uint16_t tileIndex, unsigned frame = 0) {
        ASSERT(pos.x < tileWidth() && pos.y < tileHeight() && frame < numFrames());
        tiles[tileAddr(pos, frame)] = tileIndex;
    }

    uint16_t tile(unsigned i) const {
        ASSERT(i < numTiles());
        return tiles[i];
    }

    uint16_t tile(UInt2 pos, unsigned frame = 0) const {
        ASSERT(pos.x < tileWidth() && pos.y < tileHeight() && frame < numFrames());
        return tiles[tileAddr(pos, frame)];
    }

    void span(UInt2 pos, unsigned width, unsigned tileIndex, unsigned frame = 0)
    {
        ASSERT(pos.x <= tileWidth() && width <= tileWidth() &&
            (pos.x + width) <= tileWidth() && pos.y < tileHeight());
        memset16(&tiles[tileAddr(pos, frame)], tileIndex, width);
    }

    void span(UInt2 pos, unsigned width, const PinnedAssetImage &image, unsigned frame = 0)
    {
        setAssetGroup(image.assetGroup());
        span(pos, width, image.tile(0), frame);
    }

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

    void fill(UInt2 topLeft, UInt2 size, const PinnedAssetImage &image, unsigned frame = 0)
    {
        setAssetGroup(image.assetGroup());
        fill(topLeft, size, image.tile(0), frame);
    }

    void image(UInt2 pos, const AssetImage &image, unsigned srcFrame = 0, unsigned destFrame = 0)
    {
        setAssetGroup(image.assetGroup());
        ASSERT(pos.x < tileWidth() && pos.x + image.tileWidth() <= tileWidth() &&
               pos.y < tileHeight() && pos.y + image.tileHeight() <= tileHeight() &&
               destFrame < numFrames());
        _SYS_image_memDraw(&tiles[tileAddr(pos, destFrame)],
            _SYS_CUBE_ID_INVALID, image, tileWidth(), srcFrame);
    }

    void image(UInt2 destXY, UInt2 size, const AssetImage &image, UInt2 srcXY,
        unsigned srcFrame = 0, unsigned destFrame = 0)
    {
        setAssetGroup(image.assetGroup());
        ASSERT(destXY.x < tileWidth() && destXY.x + size.x <= tileWidth() &&
               destXY.y < tileHeight() && destXY.y + size.y <= tileHeight() &&
               destFrame < numFrames());
        _SYS_image_memDrawRect(&tiles[tileAddr(destXY, destFrame)],
            _SYS_CUBE_ID_INVALID, image, tileWidth(), srcFrame,
            (_SYSInt2*) &srcXY, (_SYSInt2*) &size);
    }

    void text(Int2 topLeft, const AssetImage &font, const char *str,
        unsigned destFrame = 0, char firstChar = ' ')
    {
        setAssetGroup(font.assetGroup());
        uint16_t *addr = &tiles[tileAddr(topLeft, destFrame)];
        uint16_t *lineAddr = addr;
        char c;

        while ((c = *str)) {
            if (c == '\n') {
                addr = (lineAddr += tileWidth());
            } else {
                ASSERT(font.tileWidth() + (font.tileHeight() - 1) * tileWidth() + addr
                    <= numTiles() + tiles);
                _SYS_image_memDraw(addr, _SYS_CUBE_ID_INVALID, font, tileWidth(), c - firstChar);
                addr += font.tileWidth();
            }
            str++;
        }
    }
};


};  // namespace Sifteo