video.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/cube.h>
#include <sifteo/math.h>
#include <sifteo/video/color.h>
#include <sifteo/video/sprite.h>
#include <sifteo/video/framebuffer.h>
#include <sifteo/video/bg0rom.h>
#include <sifteo/video/bg0.h>
#include <sifteo/video/bg1.h>
#include <sifteo/video/bg2.h>
#include <sifteo/video/tilebuffer.h>

namespace Sifteo {

static const unsigned LCD_width = 128;   
static const unsigned LCD_height = 128;  
static const unsigned TILE = 8;          

static const Int2 LCD_size = { LCD_width, LCD_height };

static const Int2 LCD_center = { LCD_width / 2, LCD_height / 2 };


enum VideoMode {
    POWERDOWN_MODE = _SYS_VM_POWERDOWN,   
    BG0_ROM        = _SYS_VM_BG0_ROM,     
    SOLID_MODE     = _SYS_VM_SOLID,       
    FB32           = _SYS_VM_FB32,        
    FB64           = _SYS_VM_FB64,        
    FB128          = _SYS_VM_FB128,       
    BG0            = _SYS_VM_BG0,         
    BG0_BG1        = _SYS_VM_BG0_BG1,     
    BG0_SPR_BG1    = _SYS_VM_BG0_SPR_BG1, 
    BG2            = _SYS_VM_BG2,         
    STAMP          = _SYS_VM_STAMP,       
};


enum Rotation {
    ROT_NORMAL              = 0,
    ROT_LEFT_90_MIRROR      = _SYS_VF_XY_SWAP,
    ROT_MIRROR              = _SYS_VF_X_FLIP,
    ROT_LEFT_90             = _SYS_VF_XY_SWAP | _SYS_VF_Y_FLIP,
    ROT_180_MIRROR          = _SYS_VF_Y_FLIP,
    ROT_RIGHT_90            = _SYS_VF_XY_SWAP | _SYS_VF_X_FLIP,
    ROT_180                 = _SYS_VF_X_FLIP | _SYS_VF_Y_FLIP,
    ROT_RIGHT_90_MIRROR     = _SYS_VF_XY_SWAP | _SYS_VF_X_FLIP | _SYS_VF_Y_FLIP
};


struct VideoBuffer {
    union {
        _SYSAttachedVideoBuffer sys;
        SpriteLayer             sprites;    
        Colormap                colormap;   
        FB32Drawable            fb32;       
        FB64Drawable            fb64;       
        FB128Drawable           fb128;      
        BG0ROMDrawable          bg0rom;     
        BG0Drawable             bg0;        
        BG1Drawable             bg1;        
        BG2Drawable             bg2;        
        StampDrawable           stamp;      
    };

    // Implicit conversions
    operator _SYSVideoBuffer* () { return &sys.vbuf; }
    operator const _SYSVideoBuffer* () const { return &sys.vbuf; }
    operator _SYSAttachedVideoBuffer* () { return &sys; }
    operator const _SYSAttachedVideoBuffer* () const { return &sys; }

    operator _SYSCubeID () const {
        return sys.cube;
    }

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

    void setWindow(uint8_t firstLine, uint8_t numLines) {
        poke(offsetof(_SYSVideoRAM, first_line) / 2, firstLine | (numLines << 8));
    }

    void setDefaultWindow() {
        setWindow(0, LCD_height);
    }

    void setWindowFirstLine(uint8_t firstLine) {
        pokeb(offsetof(_SYSVideoRAM, first_line), firstLine);
    }

    void setWindowNumLines(uint8_t numLines) {
        pokeb(offsetof(_SYSVideoRAM, num_lines), numLines);
    }
    
    uint8_t windowFirstLine() const {
        return peekb(offsetof(_SYSVideoRAM, first_line));
    }

    uint8_t windowNumLines() const {
        return peekb(offsetof(_SYSVideoRAM, num_lines));
    }

    void setRotation(Rotation r) {
        const uint8_t mask = _SYS_VF_XY_SWAP | _SYS_VF_X_FLIP | _SYS_VF_Y_FLIP;
        uint8_t flags = peekb(offsetof(_SYSVideoRAM, flags));

        // Must do this atomically; the asynchronous paint controller can
        // modify other bits within this flags byte.
        xorb(offsetof(_SYSVideoRAM, flags), (r ^ flags) & mask);
    }

    Rotation rotation() const {
        const uint8_t mask = _SYS_VF_XY_SWAP | _SYS_VF_X_FLIP | _SYS_VF_Y_FLIP;
        uint8_t flags = peekb(offsetof(_SYSVideoRAM, flags));
        return Rotation(mask & flags);
    }

    Side orientation() const {
        switch (rotation()) {
            case ROT_NORMAL:    return TOP;
            case ROT_LEFT_90:   return LEFT;
            case ROT_180:       return BOTTOM;
            case ROT_RIGHT_90:  return RIGHT;
            default:            return NO_SIDE;
        }
    }

    void setOrientation(Side topSide) {
        // Tiny lookup table in a uint32
        const uint32_t sideToRotation =
            (ROT_NORMAL     << 0)  |
            (ROT_LEFT_90    << 8)  |
            (ROT_180        << 16) |
            (ROT_RIGHT_90   << 24) ;

        ASSERT(topSide >= 0 && topSide < 4);
        uint8_t r = sideToRotation >> (topSide * 8);
        setRotation(Rotation(r));
    }

    void orientTo(const Neighborhood &thisN, const VideoBuffer &src, const Neighborhood &srcN) {
        int srcSide = srcN.sideOf(cube());
        int dstSide = thisN.sideOf(src.cube());
        if(srcSide != NO_SIDE && dstSide != NO_SIDE) {
            setOrientation(Side(umod(2 + dstSide - srcSide + src.orientation(), NUM_SIDES)));
        }
        
    }

    void orientTo(const VideoBuffer &src) {
        orientTo(Neighborhood(cube()), src, Neighborhood(src.cube()));
    }

    static Side physicalToVirtual(Side side, Side rot) {
        if (side == NO_SIDE) { return NO_SIDE; }
        ASSERT(side >= 0 && side < 4 && rot != NO_SIDE);
        return Side(umod(side - rot, NUM_SIDES));
    }

    static Side virtualToPhysical(Side side, Side rot) {
        if (side == NO_SIDE) { return NO_SIDE; }
        ASSERT(side >= 0 && side < 4 && rot != NO_SIDE);
        return Side(umod(side + rot, NUM_SIDES));
    }

    Side physicalToVirtual(Side side) const {
        return physicalToVirtual(side, orientation());
    }

    Side virtualToPhysical(Side side) const {
        return virtualToPhysical(side, orientation());
    }

    static Neighborhood physicalToVirtual(Neighborhood nb, Side rot) {
        Neighborhood result;
        result.sys.sides[0] = nb.sys.sides[virtualToPhysical(Side(0), rot)];
        result.sys.sides[1] = nb.sys.sides[virtualToPhysical(Side(1), rot)];
        result.sys.sides[2] = nb.sys.sides[virtualToPhysical(Side(2), rot)];
        result.sys.sides[3] = nb.sys.sides[virtualToPhysical(Side(3), rot)];
        return result;
    }

    static Neighborhood virtualToPhysical(Neighborhood nb, Side rot) {
        Neighborhood result;
        result.sys.sides[0] = nb.sys.sides[physicalToVirtual(Side(0), rot)];
        result.sys.sides[1] = nb.sys.sides[physicalToVirtual(Side(1), rot)];
        result.sys.sides[2] = nb.sys.sides[physicalToVirtual(Side(2), rot)];
        result.sys.sides[3] = nb.sys.sides[physicalToVirtual(Side(3), rot)];
        return result;
    }

    Neighborhood physicalToVirtual(Neighborhood nb) const {
        return physicalToVirtual(nb, orientation());
    }

    Neighborhood virtualToPhysical(Neighborhood nb) const {
        return virtualToPhysical(nb, orientation());
    }

    Neighborhood physicalNeighbors() const {
        return Neighborhood(cube());
    }

    Neighborhood virtualNeighbors() const {
        return physicalToVirtual(Neighborhood(cube()));
    }

    Byte3 physicalAccel() const {
        return cube().accel();
    }

    Byte3 virtualAccel() const {
        return cube().accel().zRotateI(orientation());
    }

    void setMode(VideoMode m) {
        pokeb(offsetof(_SYSVideoRAM, mode), m);
    }

    VideoMode mode() const {
        return VideoMode(peekb(offsetof(_SYSVideoRAM, mode)));
    }
    
    void erase() {
        _SYS_vbuf_fill(*this, 0, 0, _SYS_VA_FIRST_LINE / 2);
    }

    void initMode(VideoMode m, unsigned firstLine = 0, unsigned numLines = LCD_height) {
        _SYS_finish();
        erase();
        setWindow(firstLine, numLines);
        setRotation(ROT_NORMAL);
        setMode(m);
    }

    void attach(_SYSCubeID id) {
        _SYS_finish();
        sys.cube = id;
        _SYS_vbuf_init(*this);
        _SYS_setVideoBuffer(*this, *this);
    }

    void lock(uint16_t addr) {
        _SYS_vbuf_lock(*this, addr);
    }

    void unlock() {
        _SYS_vbuf_unlock(*this);
    }

    void touch() {
        lock(_SYS_VA_FLAGS);
    }

    void poke(uint16_t addr, uint16_t word) {
        _SYS_vbuf_poke(*this, addr, word);
    }

    void pokeb(uint16_t addr, uint8_t byte) {
        _SYS_vbuf_pokeb(*this, addr, byte);
    }

    void pokei(uint16_t addr, uint16_t index) {
        _SYS_vbuf_poke(*this, addr, _SYS_TILE77(index));
    }

    void xorb(uint16_t addr, uint8_t byte) {
        _SYS_vbuf_xorb(*this, addr, byte);
    }

    uint16_t peek(uint16_t addr) const {
        return _SYS_vbuf_peek(*this, addr);
    }

    uint8_t peekb(uint16_t addr) const {
        return _SYS_vbuf_peekb(*this, addr);
    }
};

};  // namespace Sifteo