sprite.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 SpriteRef {
    _SYSAttachedVideoBuffer *sys;
    unsigned id;

    void setImage(uint16_t tile) const {
        uint16_t word = _SYS_TILE77(tile);
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].tile)/2 +
                          sizeof(_SYSSpriteInfo)/2 * id );
        _SYS_vbuf_poke(&sys->vbuf, addr, word);
    }

    void setImage(const PinnedAssetImage &asset, int frame = 0) const {
        setImage(asset.tile(sys->cube, vec(0,0), frame));
        resize(asset.pixelSize());
    }

    unsigned width() const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].mask_x) +
                          sizeof(_SYSSpriteInfo) * id );
        return -(int8_t)_SYS_vbuf_peekb(&sys->vbuf, addr);
    }

    unsigned height() const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].mask_y) +
                          sizeof(_SYSSpriteInfo) * id );
        return -(int8_t)_SYS_vbuf_peekb(&sys->vbuf, addr);
    }

    UByte2 size() const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].mask_y)/2 +
                          sizeof(_SYSSpriteInfo)/2 * id );
        uint16_t word = _SYS_vbuf_peek(&sys->vbuf, addr);
        return vec<uint8_t>(-(int8_t)(word >> 8), -(int8_t)word);
    }

    void setWidth(unsigned pixels) const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].mask_x) +
                          sizeof(_SYSSpriteInfo) * id );
        _SYS_vbuf_pokeb(&sys->vbuf, addr, -(int8_t)pixels);
    }

    void setHeight(unsigned pixels) const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].mask_y) +
                          sizeof(_SYSSpriteInfo) * id );
        _SYS_vbuf_pokeb(&sys->vbuf, addr, -(int8_t)pixels);
    }

    void resize(unsigned x, unsigned y) const {
        // Size must be a power of two in current firmwares.
        ASSERT((x & (x - 1)) == 0 && (y & (y - 1)) == 0);

        _SYS_vbuf_spr_resize(&sys->vbuf, id, x, y);
    }

    void resize(UInt2 size) const {
        resize(size.x, size.y);
    }

    bool isHidden() const {
        return height() == 0;
    }

    void hide() const {
        setHeight(0);
    }

    void move(int x, int y) const {
        _SYS_vbuf_spr_move(&sys->vbuf, id, x, y);
    }

    void move(Int2 pos) const {
        move(pos.x, pos.y);
    }

    void move(Float2 pos) const {
        Int2 i = pos.round();
        move(i.x, i.y);
    }

    unsigned x() const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].pos_x) +
                          sizeof(_SYSSpriteInfo) * id );
        return -(int8_t)_SYS_vbuf_peekb(&sys->vbuf, addr);
    }

    unsigned y() const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].pos_y) +
                          sizeof(_SYSSpriteInfo) * id );
        return -(int8_t)_SYS_vbuf_peekb(&sys->vbuf, addr);
    }

    Byte2 position() const {
        uint16_t addr = ( offsetof(_SYSVideoRAM, spr[0].pos_y)/2 +
                          sizeof(_SYSSpriteInfo)/2 * id );
        uint16_t word = _SYS_vbuf_peek(&sys->vbuf, addr);
        return vec<int8_t>(-(int8_t)(word >> 8), -(int8_t)word);
    }

    // Next sprite ID
    SpriteRef operator++ () {
        ++id;
        return *this;
    }

    // Next sprite ID
    SpriteRef operator++ (int) {
        SpriteRef result = *this;
        ++id;
        return result;
    }

    // Previous sprite ID
    SpriteRef operator-- () {
        --id;
        return *this;
    }

    // Previous sprite ID
    SpriteRef operator-- (int) {
        SpriteRef result = *this;
        --id;
        return result;
    }

    // Calculate a new SpriteRef with an ID relative to this one
    SpriteRef operator[] (int index) {
        SpriteRef result = *this;
        result.id += index;
        return result;
    }
};


struct SpriteLayer {
    _SYSAttachedVideoBuffer sys;

    static const unsigned NUM_SPRITES = _SYS_VRAM_SPRITES;

    SpriteRef operator[](unsigned id) {
        ASSERT(id < NUM_SPRITES);
        SpriteRef result = { &sys, id };
        return result;
    }

    void erase() {
        _SYS_vbuf_fill(&sys.vbuf, _SYS_VA_SPR / 2, 0,
            sizeof(_SYSSpriteInfo) / 2 * NUM_SPRITES);
    }
    
    _SYSVideoBuffer &videoBuffer() {
        return sys.vbuf;
    }

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

};  // namespace Sifteo