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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
/* 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 SCI_GFX_GFX_RESMAN_H
#define SCI_GFX_GFX_RESMAN_H
#include "common/hashmap.h"
#include "common/rect.h"
// FIXME/TODO: The name "(Graphics) resource manager", and the associated
// filenames, are misleading. This should be renamed to "Graphics manager"
// or something like that.
#include "sci/gfx/gfx_resource.h"
#include "sci/resource.h"
namespace Sci {
struct gfx_bitmap_font_t;
class ResourceManager;
class SciGuiPalette;
enum gfx_resource_type_t {
GFX_RESOURCE_TYPE_VIEW = 0,
GFX_RESOURCE_TYPE_PIC,
GFX_RESOURCE_TYPE_FONT,
GFX_RESOURCE_TYPE_CURSOR,
GFX_RESOURCE_TYPE_PALETTE,
/* FIXME: Add PAL resource */
GFX_RESOURCE_TYPES_NR /**< Number of resource types that are to be supported */
};
#define GFX_RESOURCE_TYPE_0 GFX_RESOURCE_TYPE_VIEW
#define GFXR_RES_ID(type, index) ((type) << 16 | (index))
#define GFXR_RES_TYPE(id) (id >> 16)
#define GFXR_RES_NR(id) (id & 0xffff)
/** Graphics resource */
struct gfx_resource_t {
int ID; /**< Resource ID */
int lock_sequence_nr; /**< See description of lock_counter in GfxResManager */
/** Scaled pic */
union {
gfx_pixmap_t *pointer;
gfxr_view_t *view;
gfx_bitmap_font_t *font;
gfxr_pic_t *pic;
} scaled_data;
/** Original pic */
union {
gfx_pixmap_t *pointer;
gfxr_view_t *view;
gfx_bitmap_font_t *font;
gfxr_pic_t *pic;
} unscaled_data;
};
struct gfx_options_t;
typedef Common::HashMap<int, gfx_resource_t *> IntResMap;
/** Graphics resource manager */
class GfxResManager {
public:
GfxResManager(GfxDriver *driver, ResourceManager *resMan, SciGuiScreen *screen, SciGuiPalette *palette, Common::Rect portBounds);
~GfxResManager();
/**
* 'Tags' all resources for deletion.
*
* Tagged resources are untagged if they are referenced.
*/
void tagResources() { _tagLockCounter++; }
/**
* Retrieves a font.
*
* @param[in] num The font number
* @param[in] scaled Whether the font should be font-scaled
* @return The appropriate font, or NULL on error
*/
gfx_bitmap_font_t *getFont(int num, bool scaled = false);
/**
* Retrieves a translated view cel.
*
* @param[in] nr The view number
* @param[in] loop Pointer to a variable containing the loop number
* @param[in] cel Pointer to a variable containing the cel number
* @param[in] palette The palette to use
* @return The relevant view, or NULL if nr was invalid
* loop and cel are given as pointers in order to
* allow the underlying variables to be modified
* if they are invalid (this is relevant for SCI
* version 0, where invalid loop and cel numbers
* have to be interpreted as 'maximum' or 'minimum'
* by the interpreter)
*/
gfxr_view_t *getView(int nr, int *loop, int *cel, int palette);
/**
* Retrieves a displayable (translated) pic resource.
*
* @param[in] num Number of the pic resource
* @param[in] maps The maps to translate (ORred GFX_MASK_*)
* @param[in] flags Interpreter-dependant pic flags
* @param[in] default_palette The default palette to use for drawing
* (if applicable)
* @param[in] scaled Whether to return the scaled maps, or
* the unscaled ones (which may be
* identical) for some special operations.
* @return The appropriate pic resource with all
* maps as index (but not neccessarily
* translated) data.
*/
gfxr_pic_t *getPic(int num, int maps, int flags, int default_palette,
bool scaled = false);
/**
* Retrieves a displayable (translated) pic resource written ontop of
* an existing pic.
*
* This function invalidates the cached pic pointed to by old_nr in the
* cache. While subsequent addToPic() writes will still modify the
* 'invalidated' pic, gfxr_get_pic() operations will cause it to be
* removed from the cache and to be replaced by a clean version.
*
* @param[in] old_nr Number of the pic resource to write on
* @param[in] new_nr Number of the pic resource that is to
* be added
* @param[in] flags Interpreter-dependant pic flags
* @param[in] old_default_palette The default palette of the pic before
* translation
* @param[in] default_palette The default palette to use for drawing
* (if applicable)
* @return The appropriate pic resource with all
* maps as index (but not neccessarily
* translated) data.
*/
gfxr_pic_t *addToPic(int old_nr, int new_nr, int flags,
int old_default_palette, int default_palette);
/**
* Calculate a picture
*
* @param[in] scaled_pic The pic structure that is to be
* written to
* @param[in] unscaled_pic The pic structure the unscaled pic is
* to be written to, or NULL if it isn't
* needed.
* @param[in] flags Pic drawing flags (interpreter
* dependant)
* @param[in] default_palette The default palette to use for pic
* drawing (interpreter dependant)
* @param[in] nr pic resource number
*/
void calculatePic(gfxr_pic_t *scaled_pic, gfxr_pic_t *unscaled_pic,
int flags, int default_palette, int nr);
/**
* Frees all resources currently allocated.
*
* This function is intended to be used primarily for debugging.
*/
void freeAllResources();
/**
* Frees all tagged resources.
*
* Resources are tagged by calling gfx_tag_resources(), and untagged by
* calling the approprate dereferenciation function.
* Note that this function currently only affects view resources, as
* pic resources are treated differently, while font and cursor
* resources are relatively rare.
*/
void freeTaggedResources();
/**
* Frees a previously allocated resource manager, and all allocated
* resources.
*/
void freeResManager();
/**
* Retrieves a color from the static palette
*/
const PaletteEntry &getColor(int color) {
return _staticPalette->getColor(color);
}
/**
* Set static palette and merge it into the global palette
*/
void setStaticPalette(Palette *newPalette);
/**
* Sets the picture port bounds
*/
void changePortBounds(int x1, int y1, int x2, int y2) {
_portBounds = Common::Rect(x1, y1, x2, y2);
}
#if 0
void setPaletteIntensity(int16 from, int16 to, int16 intensity) {
Palette *pal = _staticPalette->getref();
for (uint16 i = 0; i < _driver->getMode()->palette->size(); i++) {
byte r = pal->getColor(i).r * intensity / 100;
byte g = pal->getColor(i).g * intensity / 100;
byte b = pal->getColor(i).b * intensity / 100;
pal->makeSystemColor(i, PaletteEntry(r, g, b));
}
pal->mergeInto(_driver->getMode()->palette);
_driver->install_palette(_driver, pal);
pal->unmerge();
pal->free();
}
#endif
/**
* Gets the number of colors in the static palette.
*
* @return Number of pallete entries
*/
int getColorCount() {
return _staticPalette ? _staticPalette->size() : 0;
}
private:
GfxDriver *_driver;
Palette *_staticPalette;
int _lockCounter; /**< Global lock counter; increased for each new
* resource allocated. The newly allocated resource will
* then be assigned the new value of the lock_counter,
* as will any resources referenced afterwards. */
int _tagLockCounter; /**< lock counter value at tag time */
Common::Rect _portBounds;
IntResMap _resourceMaps[GFX_RESOURCE_TYPES_NR];
ResourceManager *_resMan;
SciGuiScreen *_screen;
SciGuiPalette *_palette;
};
} // End of namespace Sci
#endif // SCI_GFX_GFX_RESMAN_H
|
