Initial import of the work in progress MADE engine

svn-id: r31599

1 files changed, 178 insertions, 0 deletions

diff --git a/engines/made/resource.h b/engines/made/resource.h
new file mode 100644
index 0000000000..9b672a1c5d
--- /dev/null
+++ b/engines/made/resource.h
@@ -0,0 +1,178 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef MADE_RESOURCE_H
+#define MADE_RESOURCE_H
+
+#include "common/util.h"
+#include "common/file.h"
+#include "common/stream.h"
+#include "common/hashmap.h"
+#include "graphics/surface.h"
+#include "sound/audiostream.h"
+
+namespace Made {
+
+const int kMaxResourceCacheCount = 100;
+
+enum ResourceType {
+    kResARCH = MKID_BE('ARCH'),
+    kResFREE = MKID_BE('FREE'),
+    kResOMNI = MKID_BE('OMNI'),
+    kResFLEX = MKID_BE('FLEX'),
+    kResSNDS = MKID_BE('SNDS'),
+    kResANIM = MKID_BE('ANIM'),
+    kResMENU = MKID_BE('MENU')
+};
+
+struct ResourceSlot;
+
+class Resource {
+public:
+    ResourceSlot *slot;
+    virtual ~Resource();
+    virtual void load(byte *buffer, int size) = 0;
+};
+
+class PictureResource : public Resource {
+public:
+    PictureResource();
+    ~PictureResource();
+    void load(byte *source, int size);
+    Graphics::Surface *getPicture() const { return _picture; }
+    byte *getPalette() const { return _palette; }
+protected:
+	Graphics::Surface *_picture;
+	byte *_palette;
+};
+
+class AnimationResource : public Resource {
+public:
+    AnimationResource();
+    ~AnimationResource();
+    void load(byte *source, int size);
+    int getCount() const { return _frames.size(); }
+    Graphics::Surface *getFrame(int index) const { return _frames[index]; }
+    uint16 getFlags() const { return _flags; }
+    int16 getWidth() const { return _width; }
+    int16 getHeight() const { return _height; }
+protected:
+	Common::Array<Graphics::Surface*> _frames;
+	uint16 _flags;
+	int16 _width, _height;
+};
+
+class SoundResource : public Resource {
+public:
+    SoundResource();
+    ~SoundResource();
+    void load(byte *source, int size);
+    Audio::AudioStream *getAudioStream();
+protected:
+	byte *_soundData;
+	int _soundSize;
+};
+
+class MenuResource : public Resource {
+public:
+    MenuResource();
+    ~MenuResource();
+    void load(byte *source, int size);
+    int getCount() const { return _strings.size(); }
+    Common::String getString(int index) const { return _strings[index]; }
+protected:
+	Common::Array<Common::String> _strings;
+};
+
+struct ResourceSlot {
+    uint32 offs;
+    uint32 size;
+    Resource *res;
+    int refCount;
+    ResourceSlot() : offs(0), size(0), res(NULL), refCount(0) {
+    }
+    ResourceSlot(uint32 roffs, uint32 rsize) : offs(roffs), size(rsize), res(NULL), refCount(0) {
+    }
+};
+
+class ProjectReader {
+public:
+
+    ProjectReader();
+    ~ProjectReader();
+
+    void open(const char *filename);
+
+    PictureResource *getPicture(int index);
+    AnimationResource *getAnimation(int index);
+    SoundResource *getSound(int index);
+    MenuResource *getMenu(int index);
+
+    void freeResource(Resource *resource);
+
+protected:
+
+    Common::File *_fd;
+
+    typedef Common::Array<ResourceSlot> ResourceSlots;
+    typedef Common::HashMap<uint32, ResourceSlots*> ResMap;
+
+    ResMap _resSlots;
+    int _cacheCount;
+
+    void loadIndex(ResourceSlots *slots);
+
+    template <class T>
+    T *createResource(uint32 resType, int index) {
+        ResourceSlot *slot = getResourceSlot(resType, index);
+        if (!slot)
+            return NULL;
+        T *res = (T*)getResourceFromCache(slot);
+        if (!res) {
+            byte *buffer;
+            uint32 size;
+            if (loadResource(slot, buffer, size)) {
+                res = new T();
+                res->slot = slot;
+                res->load(buffer, size);
+                addResourceToCache(slot, res);
+                delete[] buffer;
+            }
+        }
+        return res;
+    }
+
+    bool loadResource(ResourceSlot *slot, byte *&buffer, uint32 &size);
+    ResourceSlot *getResourceSlot(uint32 resType, uint index);
+    Resource *getResourceFromCache(ResourceSlot *slot);
+    void addResourceToCache(ResourceSlot *slot, Resource *res);
+    void tossResourceFromCache(ResourceSlot *slot);
+    void purgeCache();
+
+};
+
+} // End of namespace Made
+
+#endif /* MADE_H */