1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
/* 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 MOHAWK_GRAPHICS_H
#define MOHAWK_GRAPHICS_H
#include "mohawk/bitmap.h"
#include "common/file.h"
#include "common/hashmap.h"
#include "graphics/pict.h"
#include "graphics/video/codecs/mjpeg.h"
namespace Mohawk {
class MohawkEngine;
class MohawkEngine_Myst;
class MohawkEngine_Riven;
class MohawkEngine_LivingBooks;
class MohawkBitmap;
class MystBitmap;
enum RectState{
kRectEnabled,
kRectDisabled,
kRectUnreachable
};
class MohawkSurface {
public:
MohawkSurface();
MohawkSurface(Graphics::Surface *surface, byte *palette = NULL, int offsetX = 0, int offsetY = 0);
~MohawkSurface();
// getSurface() returns the surface in the current format
// This will be the initial format unless convertToTrueColor() is called
Graphics::Surface *getSurface() const { return _surface; }
byte *getPalette() const { return _palette; }
// Convert the 8bpp image to the current screen format
// Does nothing if _surface is already >8bpp
void convertToTrueColor();
// Functions for OldMohawkBitmap offsets
// They both default to 0
int getOffsetX() const { return _offsetX; }
int getOffsetY() const { return _offsetY; }
void setOffsetX(int x) { _offsetX = x; }
void setOffsetY(int y) { _offsetY = y; }
private:
Graphics::Surface *_surface;
byte *_palette;
int _offsetX, _offsetY;
};
class GraphicsManager {
public:
GraphicsManager();
virtual ~GraphicsManager();
// Free all surfaces in the cache
void clearCache();
void preloadImage(uint16 image);
virtual void setPalette(uint16 id);
void copyAnimImageToScreen(uint16 image, int left = 0, int top = 0);
void copyAnimImageSectionToScreen(uint16 image, Common::Rect src, Common::Rect dest);
protected:
// findImage will search the cache to find the image.
// If not found, it will call decodeImage to get a new one.
MohawkSurface *findImage(uint16 id);
// decodeImage will always return a new image.
virtual MohawkSurface *decodeImage(uint16 id) = 0;
virtual MohawkEngine *getVM() = 0;
private:
// An image cache that stores images until clearCache() is called
Common::HashMap<uint16, MohawkSurface*> _cache;
};
class MystGraphics : public GraphicsManager {
public:
MystGraphics(MohawkEngine_Myst*);
~MystGraphics();
void loadExternalPictureFile(uint16 stack);
void copyImageSectionToScreen(uint16 image, Common::Rect src, Common::Rect dest);
void copyImageToScreen(uint16 image, Common::Rect dest);
void updateScreen();
void runTransition(uint16 type, Common::Rect rect, uint16 steps, uint16 delay);
void drawRect(Common::Rect rect, RectState state);
protected:
MohawkSurface *decodeImage(uint16 id);
MohawkEngine *getVM() { return (MohawkEngine *)_vm; }
private:
MohawkEngine_Myst *_vm;
MystBitmap *_bmpDecoder;
Graphics::PictDecoder *_pictDecoder;
Graphics::JPEGDecoder *_jpegDecoder;
struct PictureFile {
uint32 pictureCount;
struct PictureEntry {
uint32 offset;
uint32 size;
uint16 id;
uint16 type;
uint16 width;
uint16 height;
} *entries;
Common::File picFile;
} _pictureFile;
Graphics::Surface *_mainScreen;
Common::Array<Common::Rect> _dirtyRects;
Graphics::PixelFormat _pixelFormat;
};
struct SFXERecord {
// Record values
uint16 frameCount;
Common::Rect rect;
uint16 speed;
Common::Array<Common::SeekableReadStream*> frameScripts;
// Cur frame
uint16 curFrame;
uint32 lastFrameTime;
};
class RivenGraphics : public GraphicsManager {
public:
RivenGraphics(MohawkEngine_Riven *vm);
~RivenGraphics();
void copyImageToScreen(uint16, uint32, uint32, uint32, uint32);
void updateScreen();
bool _updatesEnabled;
Common::Array<uint16> _activatedPLSTs;
void drawPLST(uint16 x);
void drawRect(Common::Rect rect, bool active);
void drawImageRect(uint16 id, Common::Rect srcRect, Common::Rect dstRect);
void drawExtrasImage(uint16 id, Common::Rect dstRect);
// Water Effect
void scheduleWaterEffect(uint16);
void clearWaterEffects();
bool runScheduledWaterEffects();
// Transitions
void scheduleTransition(uint16 id, Common::Rect rect = Common::Rect(0, 0, 608, 392));
void runScheduledTransition();
// Inventory
void showInventory();
void hideInventory();
protected:
MohawkSurface *decodeImage(uint16 id);
MohawkEngine *getVM() { return (MohawkEngine *)_vm; }
private:
MohawkEngine_Riven *_vm;
MohawkBitmap *_bitmapDecoder;
// Water Effects
Common::Array<SFXERecord> _waterEffects;
// Transitions
int16 _scheduledTransition;
Common::Rect _transitionRect;
// Inventory
void clearInventoryArea();
void drawInventoryImage(uint16 id, const Common::Rect *rect);
bool _inventoryDrawn;
// Screen Related
Graphics::Surface *_mainScreen;
bool _dirtyScreen;
Graphics::PixelFormat _pixelFormat;
};
class LBGraphics : public GraphicsManager {
public:
LBGraphics(MohawkEngine_LivingBooks *vm, uint16 width, uint16 height);
~LBGraphics();
void setPalette(uint16 id);
void copyOffsetAnimImageToScreen(uint16 image, int left = 0, int top = 0);
bool imageIsTransparentAt(uint16 image, bool useOffsets, int x, int y);
protected:
MohawkSurface *decodeImage(uint16 id);
MohawkEngine *getVM() { return (MohawkEngine *)_vm; }
private:
MohawkBitmap *_bmpDecoder;
MohawkEngine_LivingBooks *_vm;
};
} // End of namespace Mohawk
#endif
|
