tileload.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * aint32 with this program; if not, write to the Free Software
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */
 
#ifndef SAGA2_TILELOAD_H
#define SAGA2_TILELOAD_H
 
namespace Saga2 {
 
const int           kMaxBanks = 64;          // 64 banks maximum
 
/* ============================================================================ *
   TileBank request bits
 * ============================================================================ */
 
//  To facilitate loading of tile banks on demand, a bit-array
//  is used to indicate which banks are needed for each metatile
//  to render.
 
class BankBits {
public:
    uint32 _b[kMaxBanks / 32];
 
    // constructors
    BankBits() {}
    BankBits(uint32 c, uint32 d) {
        _b[0] = c;
        _b[1] = d;
    }
 
    // BankBits operators
    friend BankBits operator+ (BankBits c, BankBits d) {
        return BankBits(c._b[0] + d._b[0], c._b[1] + d._b[1]);
    }
 
    friend BankBits operator- (BankBits c, BankBits d) {
        return BankBits(c._b[0] - d._b[0], c._b[1] - d._b[1]);
    }
 
    void operator>>=(int a) {
        bool c = (bool)(_b[0] & 1);
        _b[0] >>= (uint32)a;
        _b[1] >>= (uint32)a;
        _b[1] |= ((1 << 31) & (uint32)c);
    }
    void operator<<=(int a) {
        bool c = (bool)(_b[1] & (1 << 31));
        _b[0] >>= (uint32)a;
        _b[0] |= (1 & (uint32)c);
        _b[1] >>= (uint32)a;
    }
 
    friend BankBits operator& (BankBits c, BankBits d) {
        return BankBits(c._b[0] & d._b[0], c._b[1] & d._b[1]);
    }
 
    friend BankBits operator| (BankBits c, BankBits d) {
        return BankBits(c._b[0] | d._b[0], c._b[1] | d._b[1]);
    }
 
    friend BankBits operator|= (BankBits c, BankBits d) {
        return BankBits(c._b[0] |= d._b[0], c._b[1] |= d._b[1]);
    }
 
    friend bool operator!= (BankBits c, BankBits d) {
        return (c._b[0] != d._b[0] && c._b[1] != d._b[1]);
    }
 
    friend BankBits operator^ (BankBits c, BankBits d) {
        return BankBits(c._b[0] ^ d._b[0], c._b[1] ^ d._b[1]);
    }
 
    bool isSet(uint16 i) {
        return (bool)(_b[i >> 5] & ((uint32) 1 << (i & 31)));
    }
 
    void SetBit(int16 i) {
        _b[i / 32] |= ((uint32) 1 << (i % 32))  ;
    }
    void NotBit(int16 i) {
        _b[i / 32] &= ~((uint32) 1 << (i % 32));
    }
    void Reset(uint32 c, uint32 d) {
        _b[0] = c;
        _b[1] = d;
    }
    bool Test() {
        return (_b[0] || _b[1]);
    }
 
    // Point16 functions
 
};
 
class bitArray {
private:
    uint32  *_b;
    uint16  _size;
public:
    bitArray(uint16 newSize);
    ~bitArray();
 
    bool operator[](uint16 i) {
        if (i < _size) return (bool)(_b[i / 32] & (1 << (i % 32)));
        else return false;
    }
    void resize(uint16 newSize);
 
};
 
template<int size> class FixedBitArray {
private:
    enum {
        klWords = ((size + 31) / 32)
    };
 
    int16 WORDNUM(int n) {
        return (n >> 5);
    }
    int16 BITNUM(int n) {
        return (n & 31);
    }
    int16 BITMASK(int n) {
        return (1 << (n & 31));
    }
 
    uint32  _b[klWords];
 
    void clear() {
        memset(&_b, 0, sizeof _b);
    }
 
public:
 
    FixedBitArray() {
        clear();
    }
 
    uint32 getChunk(uint16 i) {
        return _b[i];
    }
 
    bool operator[](uint32 ind) {
        return (ind < size && (_b[WORDNUM(ind)] & BITMASK(ind)));
    }
 
    void Bit(uint32 ind, bool val) {
        if (ind < size) {
            if (val) _b[WORDNUM(ind)] |=  BITMASK(ind);
            else     _b[WORDNUM(ind)] &= ~BITMASK(ind);
        }
    }
 
    void clearAll() {
        clear();
    }
 
// Untested below here
 
    friend FixedBitArray operator& (FixedBitArray c, FixedBitArray d) {
        FixedBitArray   t;
 
        for (uint16 i = 0; i < klWords; i++)
            t._b[i] = c._b[i] & d._b[i];
        return t;
    }
 
    friend FixedBitArray operator| (FixedBitArray c, FixedBitArray d) {
        FixedBitArray t;
 
        for (uint16 i = 0; i < klWords; i++)
            t._b[i] = c._b[i] | d._b[i];
        return t;
    }
 
    friend FixedBitArray &operator|= (FixedBitArray c, FixedBitArray d) {
        for (uint16 i = 0; i < klWords; i++)
            c._b[i] |= d._b[i];
        return c;
    }
 
    friend bool operator!= (FixedBitArray c, FixedBitArray d) {
        for (uint16 i = 0; i < klWords; i++)
            if (c._b[i] != d._b[i]) return true;
        return false;
    }
 
    friend FixedBitArray operator^ (FixedBitArray c, FixedBitArray d) {
        FixedBitArray t;
 
        for (uint16 i = 0; i < klWords; i++)
            t._b[i] = c._b[i] ^ d._b[i];
        return t;
    }
};
 
} // end of namespace Saga2
 
#endif