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
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
|
/* 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.
*
*/
#ifndef BACKENDS_GRAPHICS_OPENGL_OPENGL_GRAPHICS_H
#define BACKENDS_GRAPHICS_OPENGL_OPENGL_GRAPHICS_H
#include "backends/graphics/opengl/opengl-sys.h"
#include "backends/graphics/graphics.h"
#include "common/frac.h"
#include "common/mutex.h"
namespace Graphics {
class Font;
} // End of namespace Graphics
namespace OpenGL {
// HACK: We use glColor in the OSD code. This might not be working on GL ES but
// we still enable it because Tizen already shipped with it. Also, the
// SurfaceSDL backend enables it and disabling it can cause issues in sdl.cpp.
#define USE_OSD 1
class Texture;
enum {
GFX_LINEAR = 0,
GFX_NEAREST = 1
};
class OpenGLGraphicsManager : virtual public GraphicsManager {
public:
OpenGLGraphicsManager();
virtual ~OpenGLGraphicsManager();
// GraphicsManager API
virtual bool hasFeature(OSystem::Feature f);
virtual void setFeatureState(OSystem::Feature f, bool enable);
virtual bool getFeatureState(OSystem::Feature f);
virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
virtual int getDefaultGraphicsMode() const;
virtual bool setGraphicsMode(int mode);
virtual int getGraphicsMode() const;
virtual void resetGraphicsScale() {}
#ifdef USE_RGB_COLOR
virtual Graphics::PixelFormat getScreenFormat() const;
virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const = 0;
#endif
virtual void beginGFXTransaction();
virtual OSystem::TransactionError endGFXTransaction();
virtual int getScreenChangeID() const;
virtual void initSize(uint width, uint height, const Graphics::PixelFormat *format);
virtual int16 getWidth();
virtual int16 getHeight();
virtual void copyRectToScreen(const void *buf, int pitch, int x, int y, int w, int h);
virtual void fillScreen(uint32 col);
virtual void setShakePos(int shakeOffset);
virtual void updateScreen();
virtual Graphics::Surface *lockScreen();
virtual void unlockScreen();
virtual void setFocusRectangle(const Common::Rect& rect);
virtual void clearFocusRectangle();
virtual int16 getOverlayWidth();
virtual int16 getOverlayHeight();
virtual void showOverlay();
virtual void hideOverlay();
virtual Graphics::PixelFormat getOverlayFormat() const;
virtual void copyRectToOverlay(const void *buf, int pitch, int x, int y, int w, int h);
virtual void clearOverlay();
virtual void grabOverlay(void *buf, int pitch);
virtual bool showMouse(bool visible);
virtual void warpMouse(int x, int y);
virtual void setMouseCursor(const void *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, bool dontScale, const Graphics::PixelFormat *format);
virtual void setCursorPalette(const byte *colors, uint start, uint num);
virtual void displayMessageOnOSD(const char *msg);
// PaletteManager interface
virtual void setPalette(const byte *colors, uint start, uint num);
virtual void grabPalette(byte *colors, uint start, uint num);
protected:
/**
* Set up the actual screen size available for the OpenGL code to do any
* drawing.
*
* @param width The width of the screen.
* @param height The height of the screen.
*/
void setActualScreenSize(uint width, uint height);
/**
* Notify the manager of a OpenGL context change. This should be the first
* thing to call when you create an OpenGL (ES) context!
*
* @param defaultFormat The new default format for the game screen
* (this is used for the CLUT8 game screens).
* @param defaultFromatAlpha The new default format with an alpha channel
* (this is used for the overlay and cursor).
*/
void notifyContextChange(const Graphics::PixelFormat &defaultFormat, const Graphics::PixelFormat &defaultFormatAlpha);
/**
* Adjust the physical mouse coordinates according to the currently visible screen.
*/
void adjustMousePosition(int16 &x, int16 &y);
/**
* Set up the mouse position for graphics output.
*
* @param x X coordinate in physical coordinates.
* @param y Y coordinate in physical coordinates.
*/
void setMousePosition(int x, int y) { _cursorX = x; _cursorY = y; }
/**
* Query the mouse position in physical coordinates.
*/
void getMousePosition(int16 &x, int16 &y) const { x = _cursorX; y = _cursorY; }
/**
* Set up the mouse position for the (event) system.
*
* @param x X coordinate in physical coordinates.
* @param y Y coordinate in physical coordinates.
*/
virtual void setInternalMousePosition(int x, int y) = 0;
private:
//
// Transaction support
//
struct VideoState {
VideoState() : valid(false), gameWidth(0), gameHeight(0),
#ifdef USE_RGB_COLOR
gameFormat(),
#endif
aspectRatioCorrection(false), graphicsMode(GFX_LINEAR) {
}
bool valid;
uint gameWidth, gameHeight;
#ifdef USE_RGB_COLOR
Graphics::PixelFormat gameFormat;
#endif
bool aspectRatioCorrection;
int graphicsMode;
bool operator==(const VideoState &right) {
return gameWidth == right.gameWidth && gameHeight == right.gameHeight
#ifdef USE_RGB_COLOR
&& gameFormat == right.gameFormat
#endif
&& aspectRatioCorrection == right.aspectRatioCorrection
&& graphicsMode == right.graphicsMode;
}
bool operator!=(const VideoState &right) {
return !(*this == right);
}
};
/**
* The currently setup video state.
*/
VideoState _currentState;
/**
* The old video state used when doing a transaction rollback.
*/
VideoState _oldState;
protected:
enum TransactionMode {
kTransactionNone = 0,
kTransactionActive = 1,
kTransactionRollback = 2
};
TransactionMode getTransactionMode() const { return _transactionMode; }
private:
/**
* The current transaction mode.
*/
TransactionMode _transactionMode;
/**
* The current screen change ID.
*/
int _screenChangeID;
protected:
/**
* Set up the requested video mode. This takes parameters which describe
* what resolution the game screen requests (this is possibly aspect ratio
* corrected!).
*
* A sub-class should take these parameters as hints. It might very well
* set up a mode which it thinks suites the situation best.
*
* @parma requestedWidth This is the requested actual game screen width.
* @param requestedHeight This is the requested actual game screen height.
* @param format This is the requested pixel format of the virtual game screen.
* @return true on success, false otherwise
*/
virtual bool loadVideoMode(uint requestedWidth, uint requestedHeight, const Graphics::PixelFormat &format) = 0;
/**
* Save a screenshot of the full display as BMP to the given file. This
* uses Common::DumpFile for writing the screenshot.
*
* @param filename The output filename.
*/
void saveScreenshot(const Common::String &filename) const;
private:
//
// OpenGL utilities
//
/**
* Try to determine the internal parameters for a given pixel format.
*
* @return true when the format can be used, false otherwise.
*/
bool getGLPixelFormat(const Graphics::PixelFormat &pixelFormat, GLenum &glIntFormat, GLenum &glFormat, GLenum &glType) const;
//
// Actual hardware screen
//
/**
* The width of the physical output.
*/
uint _outputScreenWidth;
/**
* The height of the physical output.
*/
uint _outputScreenHeight;
/**
* @return The desired aspect of the game screen.
*/
frac_t getDesiredGameScreenAspect() const;
/**
* Recalculates the area used to display the game screen.
*/
void recalculateDisplayArea();
/**
* The X coordinate of the game screen.
*/
uint _displayX;
/**
* The Y coordinate of the game screen.
*/
uint _displayY;
/**
* The width of the game screen in physical coordinates.
*/
uint _displayWidth;
/**
* The height of the game screen in physical coordinates.
*/
uint _displayHeight;
/**
* The default pixel format of the backend.
*/
Graphics::PixelFormat _defaultFormat;
/**
* The default pixel format with an alpha channel.
*/
Graphics::PixelFormat _defaultFormatAlpha;
//
// Game screen
//
/**
* The virtual game screen.
*/
Texture *_gameScreen;
/**
* The game palette if in CLUT8 mode.
*/
byte _gamePalette[3 * 256];
/**
* The offset by which the screen is moved vertically.
*/
int _gameScreenShakeOffset;
//
// Overlay
//
/**
* The overlay screen.
*/
Texture *_overlay;
/**
* Whether the overlay is visible or not.
*/
bool _overlayVisible;
//
// Cursor
//
/**
* Set up the correct cursor palette.
*/
void updateCursorPalette();
/**
* The cursor image.
*/
Texture *_cursor;
/**
* X coordinate of the cursor in phyiscal coordinates.
*/
uint _cursorX;
/**
* Y coordinate of the cursor in physical coordinates.
*/
uint _cursorY;
/**
* The X offset for the cursor hotspot in unscaled coordinates.
*/
uint _cursorHotspotX;
/**
* The Y offset for the cursor hotspot in unscaled coordinates.
*/
uint _cursorHotspotY;
/**
* Recalculate the cursor scaling. Scaling is always done according to
* the game screen.
*/
void recalculateCursorScaling();
/**
* The X offset for the cursor hotspot in scaled coordinates.
*/
uint _cursorHotspotXScaled;
/**
* The Y offset for the cursor hotspot in scaled coordinates.
*/
uint _cursorHotspotYScaled;
/**
* The width of the cursor scaled coordinates.
*/
uint _cursorWidthScaled;
/**
* The height of the cursor scaled coordinates.
*/
uint _cursorHeightScaled;
/**
* The key color.
*/
uint32 _cursorKeyColor;
/**
* Whether the cursor is actually visible.
*/
bool _cursorVisible;
/**
* Whether no cursor scaling should be applied.
*/
bool _cursorDontScale;
/**
* Whether the special cursor palette is enabled.
*/
bool _cursorPaletteEnabled;
/**
* The special cursor palette in case enabled.
*/
byte _cursorPalette[3 * 256];
#ifdef USE_OSD
//
// OSD
//
protected:
/**
* Returns the font used for on screen display
*/
virtual const Graphics::Font *getFontOSD();
private:
/**
* The OSD's contents.
*/
Texture *_osd;
/**
* Current opacity level of the OSD.
*/
uint8 _osdAlpha;
/**
* When fading the OSD has started.
*/
uint32 _osdFadeStartTime;
/**
* Mutex to allow displayMessageOnOSD to be used from the audio thread.
*/
Common::Mutex _osdMutex;
enum {
kOSDFadeOutDelay = 2 * 1000,
kOSDFadeOutDuration = 500,
kOSDInitialAlpha = 80
};
#endif
};
} // End of namespace OpenGL
#endif
|