resource.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
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCUMM_RESOURCE_H
#define SCUMM_RESOURCE_H

#include "common/array.h"
#include "scumm/scumm.h"    // for ResType

namespace Scumm {

enum {
    OF_OWNER_MASK = 0x0F,
    OF_STATE_MASK = 0xF0,

    OF_STATE_SHL = 4
};

class ResourceIterator {
    uint32 _size;
    uint32 _pos;
    const byte *_ptr;
    bool _smallHeader;
public:
    ResourceIterator(const byte *searchin, bool smallHeader);
    const byte *findNext(uint32 tag);
};

enum : uint {
    RES_INVALID_OFFSET = 0xFFFFFFFF
};

class ScummEngine;

enum ResTypeMode {
    kDynamicResTypeMode = 0,    
    kStaticResTypeMode = 1,     
    kSoundResTypeMode = 2       
};

class ResourceManager {
    //friend class ScummDebugger;
    //friend class ScummEngine;
protected:
    ScummEngine *_vm;

public:
    class Resource {
    public:
        byte *_address;

        uint32 _size;

    protected:
        byte _flags;

        byte _status;

    public:
        byte _roomno;

        uint32 _roomoffs;

    public:
        Resource();
        ~Resource();

        void nuke();

        inline void setResourceCounter(byte counter);
        inline byte getResourceCounter() const;

        void lock();
        void unlock();
        bool isLocked() const;

        // HE specific
        void setModified();
        bool isModified() const;
        void setOffHeap();
        void setOnHeap();
        bool isOffHeap() const;
    };

    class ResTypeData : public Common::Array<Resource> {
    friend class ResourceManager;
    public:
        ResTypeMode _mode;

        uint32 _tag;

    public:
        ResTypeData();
        ~ResTypeData();
    };
    ResTypeData _types[rtLast + 1];

protected:
    uint32 _allocatedSize;
    uint32 _maxHeapThreshold, _minHeapThreshold;
    byte _expireCounter;

public:
    ResourceManager(ScummEngine *vm);
    ~ResourceManager();

    void setHeapThreshold(int min, int max);
    uint32 getHeapSize() { return _allocatedSize; }

    void allocResTypeData(ResType type, uint32 tag, int num, ResTypeMode mode);
    void freeResources();

    byte *createResource(ResType type, ResId idx, uint32 size);
    void nukeResource(ResType type, ResId idx);

//  inline Resource &getRes(ResType type, ResId idx) { return _types[type][idx]; }
//  inline const Resource &getRes(ResType type, ResId idx) const { return _types[type][idx]; }

    bool isResourceLoaded(ResType type, ResId idx) const;

    void lock(ResType type, ResId idx);
    void unlock(ResType type, ResId idx);
    bool isLocked(ResType type, ResId idx) const;

    // HE Specific
    void setModified(ResType type, ResId idx);
    bool isModified(ResType type, ResId idx) const;
    void setOffHeap(ResType type, ResId idx);
    bool isOffHeap(ResType type, ResId idx) const;
    void setOnHeap(ResType type, ResId idx);

    void increaseExpireCounter();

    void setResourceCounter(ResType type, ResId idx, byte counter);

    void increaseResourceCounters();

    void resourceStats();

//protected:
    bool validateResource(const char *str, ResType type, ResId idx) const;
protected:
    void expireResources(uint32 size);
};

} // End of namespace Scumm

#endif