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

namespace Sifteo {

struct AssetGroup {
    _SYSAssetGroup sys;
    _SYSAssetGroupCube cubes[CUBE_ALLOCATION];

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

    ALWAYS_INLINE const _SYSAssetGroupHeader *sysHeader(bool requireConst=false) const
    {
        // AssetGroups are typically in RAM, but we want the static
        // initializer data so that our return value is known at compile time.
        _SYSAssetGroup *G = (_SYSAssetGroup*)
            _SYS_lti_initializer(reinterpret_cast<const void*>(&sys), requireConst);
        return reinterpret_cast<const _SYSAssetGroupHeader*>(G->pHdr);
    }

    unsigned numTiles() const {
        return sysHeader()->numTiles;
    }

    unsigned tileAllocation() const {
        return roundup<unsigned>(numTiles(), _SYS_ASSET_GROUP_SIZE_UNIT);
    }

    unsigned compressedSize() const {
        return sysHeader()->dataSize;
    }

    uint16_t baseAddress(_SYSCubeID cube) const {
        ASSERT(cube < CUBE_ALLOCATION);
        return cubes[cube].baseAddr;
    }

    bool isInstalled(_SYSCubeIDVector vec) {
        return _SYS_asset_findInCache(*this, vec) == vec;
    }

    bool isInstalled(_SYSCubeID cube) {
        return isInstalled(_SYSCubeIDVector(0x80000000 >> cube));
    }
};


class AssetSlot {
public:
    _SYSAssetSlot sys;

    explicit AssetSlot(_SYSAssetSlot sys) : sys(sys) {}

    AssetSlot(const AssetSlot &other) : sys(other.sys) {}

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

    ALWAYS_INLINE static AssetSlot allocate() {
        return AssetSlot(_SYS_lti_counter("Sifteo.AssetGroupSlot", 0));
    }

    unsigned tilesFree(_SYSCubeIDVector cubes = -1) const {
        return _SYS_asset_slotTilesFree(*this, cubes);
    }

    bool hasRoomFor(const AssetGroup &group, _SYSCubeIDVector cubes = -1) const {
        return tilesFree(cubes) >= group.tileAllocation();
    }

    void erase(_SYSCubeIDVector cubes = -1) const {
        _SYS_asset_slotErase(*this, cubes);
    }

    ALWAYS_INLINE AssetSlot bootstrap(AssetGroup &group) const {
        // _SYSMetadataBootAsset
        _SYS_lti_metadata(_SYS_METADATA_BOOT_ASSET, "IBBBB",
            group.sysHeader(true), sys, 0, 0, 0);

        // Update base address from the cache. Make sure it was successful.
        _SYSCubeIDVector vec = _SYS_asset_findInCache(group, -1);
        ASSERT(vec != 0);

        return *this;
    }
};

};  // namespace Sifteo