cube.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/limits.h>
#include <sifteo/macros.h>
#include <sifteo/math.h>
#include <sifteo/array.h>

namespace Sifteo {

enum Side {
    TOP = 0,            
    LEFT,               
    BOTTOM,             
    RIGHT,              
    NUM_SIDES,          
    NO_SIDE = -1        
};

typedef _SYSCubeID PCubeID;

struct CubeID {
    _SYSCubeID sys;

    static const _SYSCubeID NUM_SLOTS = _SYS_NUM_CUBE_SLOTS;

    static const _SYSCubeID UNDEFINED = _SYS_CUBE_ID_INVALID;

    CubeID() : sys(UNDEFINED) {}

    CubeID(_SYSCubeID sys) : sys(sys) {}

    operator _SYSCubeID() const {
        return sys;
    }

    _SYSCubeIDVector bit() const {
        return 0x80000000 >> sys;
    }
    
    bool isDefined() const {
        return sys != UNDEFINED;
    }

    Byte3 accel() const {
        ASSERT(sys < NUM_SLOTS);
        _SYSByte4 v;
        v.value = _SYS_getAccel(*this);
        return vec(v.x, v.y, v.z);
    }

    bool isTouching() const {
        ASSERT(sys < NUM_SLOTS);
        return _SYS_isTouching(*this);
    }
    
    uint64_t hwID() const {
        ASSERT(sys < NUM_SLOTS);
        return _SYS_getCubeHWID(*this);
    }

    void detachVideoBuffer() const {
        ASSERT(sys < NUM_SLOTS);
        _SYS_finish();
        _SYS_setVideoBuffer(*this, 0);
    }

    void detachMotionBuffer() const {
        ASSERT(sys < NUM_SLOTS);
        _SYS_setMotionBuffer(*this, 0);
    }

    float batteryLevel() const {
        ASSERT(sys < NUM_SLOTS);
        return _SYS_cubeBatteryLevel(*this) / float(_SYS_BATTERY_MAX);
    }

    void unpair() const {
        ASSERT(sys < NUM_SLOTS);
        _SYS_unpair(*this);
    }

    CubeID operator ++() { return ++sys; }
    CubeID operator ++(int) { return sys++; }
    CubeID operator --() { return --sys; }
    CubeID operator --(int) { return sys--; }
};


class CubeSet : public BitArray<_SYS_NUM_CUBE_SLOTS> {
public:
    operator _SYSCubeIDVector() const {
        return words[0];
    }

    CubeSet(const BitArray<_SYS_NUM_CUBE_SLOTS> &bits) : BitArray<_SYS_NUM_CUBE_SLOTS>(bits) {}

    explicit CubeSet() : BitArray<_SYS_NUM_CUBE_SLOTS>() {}

    explicit CubeSet(CubeID cube) : BitArray<_SYS_NUM_CUBE_SLOTS>(cube) {}

    explicit CubeSet(CubeID begin, CubeID end) : BitArray<_SYS_NUM_CUBE_SLOTS>(begin, end) {}

     uint32_t mask() const { 
         return words[0]; 
     }
     
      void setMask(uint32_t mask) {
          ASSERT( (mask & ((1<<(32-CUBE_ALLOCATION))-1)) == 0 );
          words[0] = mask;
      }

    static CubeSet connected() {
        CubeSet result;
        result.words[0] = _SYS_getConnectedCubes();
        return result;
    }
};


struct NeighborID {
    _SYSNeighborID sys;

    NeighborID() : sys(_SYS_NEIGHBOR_NONE) {}

    NeighborID(_SYSNeighborID sys) : sys(sys) {}

    operator _SYSNeighborID() const {
        return sys;
    }

    bool isCube() const {
        return sys < _SYS_NUM_CUBE_SLOTS;
    }

    bool isBase() const {
        return (sys & _SYS_NEIGHBOR_TYPE_MASK) == _SYS_NEIGHBOR_BASE;
    }

    bool isEmpty() const {
        return sys == _SYS_NEIGHBOR_NONE;
    }

    CubeID cube() const {
        return isCube() ? CubeID(sys) : CubeID();
    }
};


struct Neighborhood {
    _SYSNeighborState sys;

    Neighborhood() {}
    
    Neighborhood(_SYSNeighborState sys) : sys(sys) {}

    operator _SYSNeighborState& () {
        return sys;
    }

    Neighborhood(CubeID cube) {
        ASSERT(cube < cube.NUM_SLOTS);
        sys.value = _SYS_getNeighbors(cube);
    }

    NeighborID neighborAt(Side side) const {
        ASSERT(side >= 0 && side < NUM_SIDES);
        return sys.sides[side];
    }

    CubeID cubeAt(Side side) const {
        return neighborAt(side).cube();
    }

    bool hasNeighborAt(Side side) const {
        return !neighborAt(side).isEmpty();
    }

    bool hasCubeAt(Side side) const {
        return neighborAt(side).isCube();
    }

    Side sideOf(CubeID cube) const {
        for (Side side = (Side)0; side < NUM_SIDES; ++side)
            if (sys.sides[side] == cube)
                return side;
        return NO_SIDE;
    }
};

};  // namespace Sifteo