mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-15 06:08:35 +00:00
Objectified the graphics driver
svn-id: r41214
This commit is contained in:
Filippos Karapetis
parent
93375bddf0
commit
8033a39128
@ -963,8 +963,7 @@ bool Console::cmdUpdateZone(int argc, const char **argv) {
|
||||
int width = atoi(argv[3]);
|
||||
int height = atoi(argv[4]);
|
||||
|
||||
g_EngineState->gfx_state->driver->update(g_EngineState->gfx_state->driver, gfx_rect(x, y, width, height),
|
||||
Common::Point(x, y), GFX_BUFFER_FRONT);
|
||||
g_EngineState->gfx_state->driver->update(gfx_rect(x, y, width, height), Common::Point(x, y), GFX_BUFFER_FRONT);
|
||||
|
||||
return false;
|
||||
}
|
||||
@ -1389,12 +1388,12 @@ bool Console::cmdShowMap(int argc, const char **argv) {
|
||||
break;
|
||||
|
||||
case 1:
|
||||
gfx_xlate_pixmap(g_EngineState->gfx_state->pic->priority_map, g_EngineState->gfx_state->driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(g_EngineState->gfx_state->pic->priority_map, g_EngineState->gfx_state->driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
gfxop_draw_pixmap(g_EngineState->gfx_state, g_EngineState->gfx_state->pic->priority_map, gfx_rect(0, 0, 320, 200), Common::Point(0, 0));
|
||||
break;
|
||||
|
||||
case 2:
|
||||
gfx_xlate_pixmap(g_EngineState->gfx_state->control_map, g_EngineState->gfx_state->driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(g_EngineState->gfx_state->control_map, g_EngineState->gfx_state->driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
gfxop_draw_pixmap(g_EngineState->gfx_state, g_EngineState->gfx_state->control_map, gfx_rect(0, 0, 320, 200), Common::Point(0, 0));
|
||||
break;
|
||||
|
||||
|
||||
@ -3328,9 +3328,9 @@ reg_t kShowMovie(EngineState *s, int funct_nr, int argc, reg_t *argv) {
|
||||
gfx_pixmap_t *pixmap = seq.getFrame(play);
|
||||
|
||||
if (frameNr++ == 0)
|
||||
pixmap->palette->forceInto(s->gfx_state->driver->mode->palette);
|
||||
pixmap->palette->forceInto(s->gfx_state->driver->getMode()->palette);
|
||||
|
||||
gfx_xlate_pixmap(pixmap, s->gfx_state->driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(pixmap, s->gfx_state->driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
GFX_ASSERT(gfxop_draw_pixmap(s->gfx_state, pixmap, gfx_rect(0, 0, 320, 200), Common::Point(pixmap->xoffset, pixmap->yoffset)));
|
||||
gfxop_update_box(s->gfx_state, gfx_rect(0, 0, 320, 200));
|
||||
gfx_free_pixmap(pixmap);
|
||||
|
||||
@ -33,66 +33,43 @@
|
||||
|
||||
namespace Sci {
|
||||
|
||||
struct _scummvm_driver_state {
|
||||
gfx_pixmap_t *priority[2];
|
||||
byte *visual[2];
|
||||
int xsize, ysize;
|
||||
};
|
||||
|
||||
#define S ((struct _scummvm_driver_state *)(drv->state))
|
||||
|
||||
static int scummvm_init(gfx_driver_t *drv, int xfact, int yfact, int bytespp) {
|
||||
GfxDriver::GfxDriver(int xfact, int yfact, int bytespp) {
|
||||
int i;
|
||||
|
||||
if (!drv->state) // = S
|
||||
drv->state = new _scummvm_driver_state;
|
||||
if (!drv->state)
|
||||
return GFX_FATAL;
|
||||
|
||||
S->xsize = xfact * 320;
|
||||
S->ysize = yfact * 200;
|
||||
|
||||
//S->buckystate = 0;
|
||||
Graphics::PixelFormat format = { bytespp, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
_mode = gfx_new_mode(xfact, yfact, format, new Palette(256), 0);
|
||||
_mode->xsize = xfact * 320;
|
||||
_mode->ysize = yfact * 200;
|
||||
|
||||
for (i = 0; i < 2; i++) {
|
||||
S->priority[i] = gfx_pixmap_alloc_index_data(gfx_new_pixmap(S->xsize, S->ysize, GFX_RESID_NONE, -i, -777));
|
||||
if (!S->priority[i]) {
|
||||
printf("Out of memory: Could not allocate priority maps! (%dx%d)\n", S->xsize, S->ysize);
|
||||
return GFX_FATAL;
|
||||
_priority[i] = gfx_pixmap_alloc_index_data(gfx_new_pixmap(_mode->xsize, _mode->ysize, GFX_RESID_NONE, -i, -777));
|
||||
if (!_priority[i]) {
|
||||
error("Out of memory: Could not allocate priority maps! (%dx%d)\n", _mode->xsize, _mode->ysize);
|
||||
}
|
||||
}
|
||||
// create the visual buffers
|
||||
for (i = 0; i < 2; i++) {
|
||||
S->visual[i] = NULL;
|
||||
S->visual[i] = new byte[S->xsize * S->ysize];
|
||||
if (!S->visual[i]) {
|
||||
printf("Out of memory: Could not allocate visual buffers! (%dx%d)\n", S->xsize, S->ysize);
|
||||
return GFX_FATAL;
|
||||
_visual[i] = NULL;
|
||||
_visual[i] = new byte[_mode->xsize * _mode->ysize];
|
||||
if (!_visual[i]) {
|
||||
error("Out of memory: Could not allocate visual buffers! (%dx%d)\n", _mode->xsize, _mode->ysize);
|
||||
}
|
||||
memset(S->visual[i], 0, S->xsize * S->ysize);
|
||||
memset(_visual[i], 0, _mode->xsize * _mode->ysize);
|
||||
}
|
||||
|
||||
Graphics::PixelFormat format = { bytespp, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
drv->mode = gfx_new_mode(xfact, yfact, format, new Palette(256), 0);
|
||||
drv->mode->palette->name = "global";
|
||||
|
||||
return GFX_OK;
|
||||
_mode->palette->name = "global";
|
||||
}
|
||||
|
||||
static void scummvm_exit(gfx_driver_t *drv) {
|
||||
GfxDriver::~GfxDriver() {
|
||||
int i;
|
||||
if (S) {
|
||||
for (i = 0; i < 2; i++) {
|
||||
gfx_free_pixmap(S->priority[i]);
|
||||
S->priority[i] = NULL;
|
||||
}
|
||||
for (i = 0; i < 2; i++) {
|
||||
gfx_free_pixmap(_priority[i]);
|
||||
_priority[i] = NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < 2; i++) {
|
||||
delete[] S->visual[i];
|
||||
S->visual[i] = NULL;
|
||||
}
|
||||
|
||||
delete S;
|
||||
for (i = 0; i < 2; i++) {
|
||||
delete[] _visual[i];
|
||||
_visual[i] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@ -100,18 +77,18 @@ static void scummvm_exit(gfx_driver_t *drv) {
|
||||
// Drawing operations
|
||||
|
||||
static void drawProc(int x, int y, int c, void *data) {
|
||||
gfx_driver_t *drv = (gfx_driver_t *)data;
|
||||
uint8 *p = S->visual[0];
|
||||
p[y * 320*drv->mode->xfact + x] = c;
|
||||
GfxDriver *drv = (GfxDriver *)data;
|
||||
uint8 *p = drv->getVisual0();
|
||||
p[y * 320* drv->getMode()->xfact + x] = c;
|
||||
}
|
||||
|
||||
static int scummvm_draw_line(gfx_driver_t *drv, Common::Point start, Common::Point end,
|
||||
gfx_color_t color, gfx_line_mode_t line_mode, gfx_line_style_t line_style) {
|
||||
int GfxDriver::drawLine(Common::Point start, Common::Point end, gfx_color_t color,
|
||||
gfx_line_mode_t line_mode, gfx_line_style_t line_style) {
|
||||
uint32 scolor = color.visual.parent_index;
|
||||
int xfact = (line_mode == GFX_LINE_MODE_FINE)? 1: drv->mode->xfact;
|
||||
int yfact = (line_mode == GFX_LINE_MODE_FINE)? 1: drv->mode->yfact;
|
||||
int xsize = S->xsize;
|
||||
int ysize = S->ysize;
|
||||
int xfact = (line_mode == GFX_LINE_MODE_FINE)? 1: _mode->xfact;
|
||||
int yfact = (line_mode == GFX_LINE_MODE_FINE)? 1: _mode->yfact;
|
||||
int xsize = _mode->xsize;
|
||||
int ysize = _mode->ysize;
|
||||
|
||||
if (color.mask & GFX_MASK_VISUAL) {
|
||||
Common::Point nstart, nend;
|
||||
@ -124,10 +101,10 @@ static int scummvm_draw_line(gfx_driver_t *drv, Common::Point start, Common::Poi
|
||||
nend.x = CLIP<int16>(end.x + xc, 0, xsize - 1);
|
||||
nend.y = CLIP<int16>(end.y + yc, 0, ysize - 1);
|
||||
|
||||
Graphics::drawLine(nstart.x, nstart.y, nend.x, nend.y, scolor, drawProc, drv);
|
||||
Graphics::drawLine(nstart.x, nstart.y, nend.x, nend.y, scolor, drawProc, this);
|
||||
|
||||
if (color.mask & GFX_MASK_PRIORITY) {
|
||||
gfx_draw_line_pixmap_i(S->priority[0], nstart, nend, color.priority);
|
||||
gfx_draw_line_pixmap_i(_priority[0], nstart, nend, color.priority);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -136,24 +113,23 @@ static int scummvm_draw_line(gfx_driver_t *drv, Common::Point start, Common::Poi
|
||||
return GFX_OK;
|
||||
}
|
||||
|
||||
static int scummvm_draw_filled_rect(gfx_driver_t *drv, rect_t rect, gfx_color_t color1, gfx_color_t color2,
|
||||
int GfxDriver::drawFilledRect(rect_t rect, gfx_color_t color1, gfx_color_t color2,
|
||||
gfx_rectangle_fill_t shade_mode) {
|
||||
if (color1.mask & GFX_MASK_VISUAL) {
|
||||
for (int i = rect.y; i < rect.y + rect.height; i++) {
|
||||
memset(S->visual[0] + i * S->xsize + rect.x, color1.visual.parent_index, rect.width);
|
||||
memset(_visual[0] + i * _mode->xsize + rect.x, color1.visual.parent_index, rect.width);
|
||||
}
|
||||
}
|
||||
|
||||
if (color1.mask & GFX_MASK_PRIORITY)
|
||||
gfx_draw_box_pixmap_i(S->priority[0], rect, color1.priority);
|
||||
gfx_draw_box_pixmap_i(_priority[0], rect, color1.priority);
|
||||
|
||||
return GFX_OK;
|
||||
}
|
||||
|
||||
// Pixmap operations
|
||||
|
||||
static int scummvm_draw_pixmap(gfx_driver_t *drv, gfx_pixmap_t *pxm, int priority,
|
||||
rect_t src, rect_t dest, gfx_buffer_t buffer) {
|
||||
int GfxDriver::drawPixmap(gfx_pixmap_t *pxm, int priority, rect_t src, rect_t dest, gfx_buffer_t buffer) {
|
||||
int bufnr = (buffer == GFX_BUFFER_STATIC) ? 1 : 0;
|
||||
|
||||
if (dest.width != src.width || dest.height != src.height) {
|
||||
@ -161,13 +137,13 @@ static int scummvm_draw_pixmap(gfx_driver_t *drv, gfx_pixmap_t *pxm, int priorit
|
||||
return GFX_ERROR;
|
||||
}
|
||||
|
||||
gfx_crossblit_pixmap(drv->mode, pxm, priority, src, dest, S->visual[bufnr], S->xsize,
|
||||
S->priority[bufnr]->index_data, S->priority[bufnr]->index_width, 1, 0);
|
||||
gfx_crossblit_pixmap(_mode, pxm, priority, src, dest, _visual[bufnr], _mode->xsize,
|
||||
_priority[bufnr]->index_data, _priority[bufnr]->index_width, 1, 0);
|
||||
|
||||
return GFX_OK;
|
||||
}
|
||||
|
||||
static int scummvm_grab_pixmap(gfx_driver_t *drv, rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map) {
|
||||
int GfxDriver::grabPixmap(rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map) {
|
||||
if (src.x < 0 || src.y < 0) {
|
||||
printf("Attempt to grab pixmap from invalid coordinates (%d,%d)\n", src.x, src.y);
|
||||
return GFX_ERROR;
|
||||
@ -184,7 +160,7 @@ static int scummvm_grab_pixmap(gfx_driver_t *drv, rect_t src, gfx_pixmap_t *pxm,
|
||||
pxm->width = src.width;
|
||||
pxm->height = src.height;
|
||||
for (int i = 0; i < src.height; i++) {
|
||||
memcpy(pxm->data + i * src.width, S->visual[0] + (i + src.y) * S->xsize + src.x, src.width);
|
||||
memcpy(pxm->data + i * src.width, _visual[0] + (i + src.y) * _mode->xsize + src.x, src.width);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -202,7 +178,7 @@ static int scummvm_grab_pixmap(gfx_driver_t *drv, rect_t src, gfx_pixmap_t *pxm,
|
||||
|
||||
// Buffer operations
|
||||
|
||||
static int scummvm_update(gfx_driver_t *drv, rect_t src, Common::Point dest, gfx_buffer_t buffer) {
|
||||
int GfxDriver::update(rect_t src, Common::Point dest, gfx_buffer_t buffer) {
|
||||
//TODO
|
||||
|
||||
/*
|
||||
@ -216,15 +192,15 @@ static int scummvm_update(gfx_driver_t *drv, rect_t src, Common::Point dest, gfx
|
||||
switch (buffer) {
|
||||
case GFX_BUFFER_BACK:
|
||||
for (int i = 0; i < src.height; i++) {
|
||||
memcpy(S->visual[0] + (dest.y + i) * S->xsize + dest.x,
|
||||
S->visual[1] + (src.y + i) * S->xsize + src.x, src.width);
|
||||
memcpy(_visual[0] + (dest.y + i) * _mode->xsize + dest.x,
|
||||
_visual[1] + (src.y + i) * _mode->xsize + src.x, src.width);
|
||||
}
|
||||
|
||||
if ((src.x == dest.x) && (src.y == dest.y))
|
||||
gfx_copy_pixmap_box_i(S->priority[0], S->priority[1], src);
|
||||
gfx_copy_pixmap_box_i(_priority[0], _priority[1], src);
|
||||
break;
|
||||
case GFX_BUFFER_FRONT:
|
||||
g_system->copyRectToScreen(S->visual[0] + src.x + src.y * S->xsize, S->xsize, dest.x, dest.y, src.width, src.height);
|
||||
g_system->copyRectToScreen(_visual[0] + src.x + src.y * _mode->xsize, _mode->xsize, dest.x, dest.y, src.width, src.height);
|
||||
g_system->updateScreen();
|
||||
break;
|
||||
default:
|
||||
@ -235,9 +211,9 @@ static int scummvm_update(gfx_driver_t *drv, rect_t src, Common::Point dest, gfx
|
||||
return GFX_OK;
|
||||
}
|
||||
|
||||
static int scummvm_set_static_buffer(gfx_driver_t *drv, gfx_pixmap_t *pic, gfx_pixmap_t *priority) {
|
||||
memcpy(S->visual[1], pic->data, S->xsize * S->ysize);
|
||||
gfx_copy_pixmap_box_i(S->priority[1], priority, gfx_rect(0, 0, S->xsize, S->ysize));
|
||||
int GfxDriver::setStaticBuffer(gfx_pixmap_t *pic, gfx_pixmap_t *priority) {
|
||||
memcpy(_visual[1], pic->data, _mode->xsize * _mode->ysize);
|
||||
gfx_copy_pixmap_box_i(_priority[1], priority, gfx_rect(0, 0, _mode->xsize, _mode->ysize));
|
||||
|
||||
return GFX_OK;
|
||||
}
|
||||
@ -245,13 +221,12 @@ static int scummvm_set_static_buffer(gfx_driver_t *drv, gfx_pixmap_t *pic, gfx_p
|
||||
// Mouse pointer operations
|
||||
|
||||
// Scale cursor and map its colors to the global palette
|
||||
static uint8 *create_cursor(gfx_driver_t *drv, gfx_pixmap_t *pointer, int mode)
|
||||
{
|
||||
byte *GfxDriver::createCursor(gfx_pixmap_t *pointer) {
|
||||
int linewidth = pointer->width;
|
||||
int lines = pointer->height;
|
||||
uint8 *data = new uint8[linewidth*lines];
|
||||
uint8 *linebase = data, *pos;
|
||||
uint8 *src = pointer->index_data;
|
||||
byte *data = new uint8[linewidth*lines];
|
||||
byte *linebase = data, *pos;
|
||||
byte *src = pointer->index_data;
|
||||
|
||||
for (int yc = 0; yc < pointer->index_height; yc++) {
|
||||
pos = linebase;
|
||||
@ -262,24 +237,24 @@ static uint8 *create_cursor(gfx_driver_t *drv, gfx_pixmap_t *pointer, int mode)
|
||||
// Note that some cursors don't have a palette in SQ5
|
||||
if (pointer->palette && color < pointer->palette->size())
|
||||
color = pointer->palette->getColor(color).parent_index;
|
||||
for (int scalectr = 0; scalectr < drv->mode->xfact; scalectr++) {
|
||||
for (int scalectr = 0; scalectr < _mode->xfact; scalectr++) {
|
||||
*pos++ = color;
|
||||
}
|
||||
src++;
|
||||
}
|
||||
for (int scalectr = 1; scalectr < drv->mode->yfact; scalectr++)
|
||||
for (int scalectr = 1; scalectr < _mode->yfact; scalectr++)
|
||||
memcpy(linebase + linewidth * scalectr, linebase, linewidth);
|
||||
linebase += linewidth * drv->mode->yfact;
|
||||
linebase += linewidth * _mode->yfact;
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
static int scummvm_set_pointer(gfx_driver_t *drv, gfx_pixmap_t *pointer, Common::Point *hotspot) {
|
||||
int GfxDriver::setPointer(gfx_pixmap_t *pointer, Common::Point *hotspot) {
|
||||
if ((pointer == NULL) || (hotspot == NULL)) {
|
||||
g_system->showMouse(false);
|
||||
} else {
|
||||
uint8 *cursorData = create_cursor(drv, pointer, 1);
|
||||
uint8 *cursorData = createCursor(pointer);
|
||||
|
||||
// FIXME: The palette size check is a workaround for cursors using non-palette colour GFX_CURSOR_TRANSPARENT
|
||||
// Note that some cursors don't have a palette in SQ5
|
||||
@ -301,18 +276,4 @@ static int scummvm_set_pointer(gfx_driver_t *drv, gfx_pixmap_t *pointer, Common:
|
||||
return GFX_OK;
|
||||
}
|
||||
|
||||
gfx_driver_t gfx_driver_scummvm = {
|
||||
NULL,
|
||||
scummvm_init,
|
||||
scummvm_exit,
|
||||
scummvm_draw_line,
|
||||
scummvm_draw_filled_rect,
|
||||
scummvm_draw_pixmap,
|
||||
scummvm_grab_pixmap,
|
||||
scummvm_update,
|
||||
scummvm_set_static_buffer,
|
||||
scummvm_set_pointer,
|
||||
NULL
|
||||
};
|
||||
|
||||
} // End of namespace Sci
|
||||
|
||||
@ -62,18 +62,13 @@ enum gfx_buffer_t {
|
||||
** must use a reasonable default value.
|
||||
*/
|
||||
|
||||
// FIXME: Turn this into a class, or get rid of it completely.
|
||||
struct gfx_driver_t { /* Graphics driver */
|
||||
|
||||
gfx_mode_t *mode; /* Currently active mode, NULL if no mode is active */
|
||||
|
||||
class GfxDriver {
|
||||
public:
|
||||
/*** Initialization ***/
|
||||
|
||||
int (*init)(gfx_driver_t *drv, int xres, int yres,
|
||||
int bytespp);
|
||||
GfxDriver(int xfact, int yfact, int bytespp);
|
||||
/* Attempts to initialize a specific graphics mode
|
||||
** Parameters: (gfx_driver_t *) drv: The affected driver
|
||||
** (int x int) xres, yres: Horizontal and vertical scaling
|
||||
** Parameters: (int x int) xres, yres: Horizontal and vertical scaling
|
||||
** factors
|
||||
** (int) bytespp: Any of GFX_COLOR_MODE_*. GFX_COLOR_MODE_INDEX
|
||||
** implies color index mode.
|
||||
@ -83,14 +78,12 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
** and is used for internal representation of graphical data. The physical
|
||||
** resolution set by the graphics driver may be different for practical
|
||||
** reasons.
|
||||
** Must also set drv->mode, preferably with the gfx_new_mode() function
|
||||
** Must also set _mode, preferably with the gfx_new_mode() function
|
||||
** specified in gfx_tools.h.
|
||||
*/
|
||||
|
||||
void (*exit)(gfx_driver_t *drv);
|
||||
~GfxDriver();
|
||||
/* Uninitializes the current graphics mode
|
||||
** Paramters: (gfx_driver_t *) drv: The driver to uninitialize
|
||||
** Return : (void)
|
||||
** This function frees all memory allocated by the graphics driver,
|
||||
** including mode and palette information, uninstalls all console commands
|
||||
** introduced by preceeding init() or init_specific() commands, and does any
|
||||
@ -101,13 +94,10 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
|
||||
/*** Drawing operations ***/
|
||||
|
||||
int (*draw_line)(gfx_driver_t *drv,
|
||||
Common::Point start, Common::Point end,
|
||||
gfx_color_t color,
|
||||
gfx_line_mode_t line_mode, gfx_line_style_t line_style);
|
||||
int drawLine(Common::Point start, Common::Point end, gfx_color_t color,
|
||||
gfx_line_mode_t line_mode, gfx_line_style_t line_style);
|
||||
/* Draws a single line to the back buffer.
|
||||
** Parameters: (gfx_driver_t *) drv: The driver affected
|
||||
** (Common::Point) start: Starting point of the line to draw
|
||||
** Parameters: (Common::Point) start: Starting point of the line to draw
|
||||
** (Common::Point) end: End point of the line to draw
|
||||
** (gfx_color_t *) color: The color to draw with
|
||||
** (int) line_mode: Any of the line modes
|
||||
@ -122,12 +112,10 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
** set.
|
||||
*/
|
||||
|
||||
int (*draw_filled_rect)(gfx_driver_t *drv, rect_t rect,
|
||||
gfx_color_t color1, gfx_color_t color2,
|
||||
gfx_rectangle_fill_t shade_mode);
|
||||
int drawFilledRect(rect_t rect, gfx_color_t color1, gfx_color_t color2,
|
||||
gfx_rectangle_fill_t shade_mode);
|
||||
/* Draws a single filled and possibly shaded rectangle to the back buffer.
|
||||
** Parameters: (gfx_driver_t *) drv: The driver affected
|
||||
** (rect_t *) rect: The rectangle to draw
|
||||
** Parameters: (rect_t *) rect: The rectangle to draw
|
||||
** (gfx_color_t *) color1, color2: The colors to draw with
|
||||
** (int) shade_mode: Any of GFX_SHADE_*.
|
||||
** Returns : (int) GFX_OK or GFX_FATAL
|
||||
@ -139,11 +127,10 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
|
||||
/*** Pixmap operations ***/
|
||||
|
||||
int (*draw_pixmap)(gfx_driver_t *drv, gfx_pixmap_t *pxm, int priority,
|
||||
rect_t src, rect_t dest, gfx_buffer_t buffer);
|
||||
int drawPixmap(gfx_pixmap_t *pxm, int priority,
|
||||
rect_t src, rect_t dest, gfx_buffer_t buffer);
|
||||
/* Draws part of a pixmap to the static or back buffer
|
||||
** Parameters: (gfx_driver_t *) drv: The affected driver
|
||||
** (gfx_pixmap_t *) pxm: The pixmap to draw
|
||||
** Parameters: (gfx_pixmap_t *) pxm: The pixmap to draw
|
||||
** (int) priority: The priority to draw with, or GFX_NO_PRIORITY
|
||||
** to draw on top of everything without setting the
|
||||
** priority back buffer
|
||||
@ -154,11 +141,9 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
** (but should have been) registered.
|
||||
*/
|
||||
|
||||
int (*grab_pixmap)(gfx_driver_t *drv, rect_t src, gfx_pixmap_t *pxm,
|
||||
gfx_map_mask_t map);
|
||||
int grabPixmap(rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map);
|
||||
/* Grabs an image from the visual or priority back buffer
|
||||
** Parameters: (gfx_driver_t *) drv: The affected driver
|
||||
** (rect_t) src: The rectangle to grab
|
||||
** Parameters: (rect_t) src: The rectangle to grab
|
||||
** (gfx_pixmap_t *) pxm: The pixmap structure the data is to
|
||||
** be written to
|
||||
** (int) map: GFX_MASK_VISUAL or GFX_MASK_PRIORITY
|
||||
@ -171,11 +156,9 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
|
||||
/*** Buffer operations ***/
|
||||
|
||||
int (*update)(gfx_driver_t *drv, rect_t src, Common::Point dest,
|
||||
gfx_buffer_t buffer);
|
||||
int update(rect_t src, Common::Point dest, gfx_buffer_t buffer);
|
||||
/* Updates the front buffer or the back buffers
|
||||
** Parameters: (gfx_driver_t *) drv: The affected driver
|
||||
** (rect_t) src: Source rectangle
|
||||
** Parameters: (rect_t) src: Source rectangle
|
||||
** (Common::Point) dest: Destination point
|
||||
** (int) buffer: One of GFX_BUFFER_FRONT or GFX_BUFFER_BACK
|
||||
** Returns : (int) GFX_OK, GFX_ERROR or GFX_FATAL
|
||||
@ -187,11 +170,9 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
** If they aren't, the priority map will not be required to be copied.
|
||||
*/
|
||||
|
||||
int (*set_static_buffer)(gfx_driver_t *drv, gfx_pixmap_t *pic,
|
||||
gfx_pixmap_t *priority);
|
||||
int setStaticBuffer(gfx_pixmap_t *pic, gfx_pixmap_t *priority);
|
||||
/* Sets the contents of the static visual and priority buffers
|
||||
** Parameters: (gfx_driver_t *) drv: The affected driver
|
||||
** (gfx_pixmap_t *) pic: The image defining the new content
|
||||
** Parameters: (gfx_pixmap_t *) pic: The image defining the new content
|
||||
** of the visual back buffer
|
||||
** (gfx_pixmap_t *) priority: The priority map containing
|
||||
** the new content of the priority back buffer
|
||||
@ -209,10 +190,9 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
|
||||
/*** Mouse pointer operations ***/
|
||||
|
||||
int (*set_pointer)(gfx_driver_t *drv, gfx_pixmap_t *pointer, Common::Point *hotspot);
|
||||
int setPointer(gfx_pixmap_t *pointer, Common::Point *hotspot);
|
||||
/* Sets a new mouse pointer.
|
||||
** Parameters: (gfx_driver_t *) drv: The driver to modify
|
||||
** (gfx_pixmap_t *) pointer: The pointer to set, or NULL to set
|
||||
** Parameters: (gfx_pixmap_t *) pointer: The pointer to set, or NULL to set
|
||||
** no pointer
|
||||
** (Common::Point *) hotspot: The coordinates of the hotspot,
|
||||
** or NULL to set no pointer
|
||||
@ -224,9 +204,15 @@ struct gfx_driver_t { /* Graphics driver */
|
||||
** 0, 1, and GFX_COLOR_INDEX_TRANSPARENT are used.
|
||||
*/
|
||||
|
||||
gfx_mode_t *getMode() { return _mode; }
|
||||
byte *getVisual0() { return _visual[0]; }
|
||||
|
||||
void *state; /* Reserved for internal use */
|
||||
private:
|
||||
byte *createCursor(gfx_pixmap_t *pointer);
|
||||
|
||||
gfx_pixmap_t *_priority[2];
|
||||
byte *_visual[2];
|
||||
gfx_mode_t *_mode; /* Currently active mode, NULL if no mode is active */
|
||||
};
|
||||
|
||||
} // End of namespace Sci
|
||||
|
||||
@ -46,10 +46,10 @@ namespace Sci {
|
||||
|
||||
struct param_struct {
|
||||
int args[4];
|
||||
gfx_driver_t *driver;
|
||||
GfxDriver *driver;
|
||||
};
|
||||
|
||||
GfxResManager::GfxResManager(int version, bool isVGA, gfx_options_t *options, gfx_driver_t *driver, ResourceManager *resManager) :
|
||||
GfxResManager::GfxResManager(int version, bool isVGA, gfx_options_t *options, GfxDriver *driver, ResourceManager *resManager) :
|
||||
_version(version), _isVGA(isVGA), _options(options), _driver(driver), _resManager(resManager),
|
||||
_lockCounter(0), _tagLockCounter(0), _staticPalette(0) {
|
||||
gfxr_init_static_palette();
|
||||
@ -268,7 +268,7 @@ void GfxResManager::setStaticPalette(Palette *newPalette)
|
||||
_staticPalette = newPalette;
|
||||
_staticPalette->name = "static palette";
|
||||
|
||||
_staticPalette->mergeInto(_driver->mode->palette);
|
||||
_staticPalette->mergeInto(_driver->getMode()->palette);
|
||||
}
|
||||
|
||||
#if 0
|
||||
@ -313,7 +313,7 @@ gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_pale
|
||||
IntResMap &resMap = _resourceMaps[GFX_RESOURCE_TYPE_PIC];
|
||||
gfx_resource_t *res = NULL;
|
||||
int hash = getOptionsHash(GFX_RESOURCE_TYPE_PIC);
|
||||
int need_unscaled = (_driver->mode->xfact != 1 || _driver->mode->yfact != 1);
|
||||
int need_unscaled = (_driver->getMode()->xfact != 1 || _driver->getMode()->yfact != 1);
|
||||
|
||||
hash |= (flags << 20) | ((default_palette & 0x7) << 28);
|
||||
|
||||
@ -328,7 +328,7 @@ gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_pale
|
||||
need_unscaled = 0;
|
||||
pic = gfxr_init_pic(&mode_1x1_color_index, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _version >= SCI_VERSION_01_VGA);
|
||||
} else
|
||||
pic = gfxr_init_pic(_driver->mode, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _version >= SCI_VERSION_01_VGA);
|
||||
pic = gfxr_init_pic(_driver->getMode(), GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _version >= SCI_VERSION_01_VGA);
|
||||
#else
|
||||
need_unscaled = 0;
|
||||
pic = gfxr_init_pic(&mode_1x1_color_index, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _version >= SCI_VERSION_01_VGA);
|
||||
@ -382,10 +382,10 @@ gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_pale
|
||||
}
|
||||
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
npic = gfxr_pic_xlate_common(res, maps, scaled || _options->pic0_unscaled, 0, _driver->mode,
|
||||
npic = gfxr_pic_xlate_common(res, maps, scaled || _options->pic0_unscaled, 0, _driver->getMode(),
|
||||
_options->pic_xlate_filter, _options);
|
||||
#else
|
||||
npic = gfxr_pic_xlate_common(res, maps, 1, 0, _driver->mode,
|
||||
npic = gfxr_pic_xlate_common(res, maps, 1, 0, _driver->getMode(),
|
||||
GFX_XLATE_FILTER_NONE, _options);
|
||||
#endif
|
||||
|
||||
@ -446,7 +446,7 @@ gfxr_pic_t *GfxResManager::addToPic(int old_nr, int new_nr, int flags, int old_d
|
||||
gfx_resource_t *res = NULL;
|
||||
int hash = getOptionsHash(GFX_RESOURCE_TYPE_PIC);
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
int need_unscaled = !(_options->pic0_unscaled) && (_driver->mode->xfact != 1 || _driver->mode->yfact != 1);
|
||||
int need_unscaled = !(_options->pic0_unscaled) && (_driver->getMode()->xfact != 1 || _driver->getMode()->yfact != 1);
|
||||
#else
|
||||
int need_unscaled = 1;
|
||||
#endif
|
||||
@ -467,7 +467,7 @@ gfxr_pic_t *GfxResManager::addToPic(int old_nr, int new_nr, int flags, int old_d
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
if (_options->pic0_unscaled) // Unscale priority map, if we scaled it earlier
|
||||
#endif
|
||||
_gfxr_unscale_pixmap_index_data(res->scaled_data.pic->priority_map, _driver->mode);
|
||||
_gfxr_unscale_pixmap_index_data(res->scaled_data.pic->priority_map, _driver->getMode());
|
||||
|
||||
// The following two operations are needed when returning scaled maps (which is always the case here)
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
@ -483,15 +483,15 @@ gfxr_pic_t *GfxResManager::addToPic(int old_nr, int new_nr, int flags, int old_d
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
if (_options->pic0_unscaled) // Scale priority map again, if needed
|
||||
#endif
|
||||
res->scaled_data.pic->priority_map = gfx_pixmap_scale_index_data(res->scaled_data.pic->priority_map, _driver->mode);
|
||||
res->scaled_data.pic->priority_map = gfx_pixmap_scale_index_data(res->scaled_data.pic->priority_map, _driver->getMode());
|
||||
|
||||
{
|
||||
int old_ID = get_pic_id(res);
|
||||
set_pic_id(res, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, new_nr)); // To ensure that our graphical translation options work properly
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
pic = gfxr_pic_xlate_common(res, GFX_MASK_VISUAL, 1, 1, _driver->mode, _options->pic_xlate_filter, _options);
|
||||
pic = gfxr_pic_xlate_common(res, GFX_MASK_VISUAL, 1, 1, _driver->getMode(), _options->pic_xlate_filter, _options);
|
||||
#else
|
||||
pic = gfxr_pic_xlate_common(res, GFX_MASK_VISUAL, 1, 1, _driver->mode, GFX_XLATE_FILTER_NONE, _options);
|
||||
pic = gfxr_pic_xlate_common(res, GFX_MASK_VISUAL, 1, 1, _driver->getMode(), GFX_XLATE_FILTER_NONE, _options);
|
||||
#endif
|
||||
set_pic_id(res, old_ID);
|
||||
}
|
||||
@ -590,9 +590,9 @@ gfxr_view_t *GfxResManager::getView(int nr, int *loop, int *cel, int palette) {
|
||||
if (!cel_data->data) {
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
gfx_get_res_config(_options, cel_data);
|
||||
gfx_xlate_pixmap(cel_data, _driver->mode, _options->view_xlate_filter);
|
||||
gfx_xlate_pixmap(cel_data, _driver->getMode(), _options->view_xlate_filter);
|
||||
#else
|
||||
gfx_xlate_pixmap(cel_data, _driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(cel_data, _driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -671,9 +671,9 @@ gfx_pixmap_t *GfxResManager::getCursor(int num) {
|
||||
}
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
gfx_get_res_config(_options, cursor);
|
||||
gfx_xlate_pixmap(cursor, _driver->mode, _options->cursor_xlate_filter);
|
||||
gfx_xlate_pixmap(cursor, _driver->getMode(), _options->cursor_xlate_filter);
|
||||
#else
|
||||
gfx_xlate_pixmap(cursor, _driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(cursor, _driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
#endif
|
||||
|
||||
res->unscaled_data.pointer = cursor;
|
||||
|
||||
@ -88,7 +88,7 @@ typedef Common::HashMap<int, gfx_resource_t *> IntResMap;
|
||||
|
||||
class GfxResManager {
|
||||
public:
|
||||
GfxResManager(int version, bool isVGA, gfx_options_t *options, gfx_driver_t *driver, ResourceManager *resManager);
|
||||
GfxResManager(int version, bool isVGA, gfx_options_t *options, GfxDriver *driver, ResourceManager *resManager);
|
||||
|
||||
~GfxResManager();
|
||||
|
||||
@ -239,13 +239,13 @@ public:
|
||||
void setPaletteIntensity(int16 from, int16 to, int16 intensity) {
|
||||
Palette *pal = _staticPalette->getref();
|
||||
|
||||
for (uint16 i = 0; i < _driver->mode->palette->size(); i++) {
|
||||
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->mode->palette);
|
||||
pal->mergeInto(_driver->getMode()->palette);
|
||||
_driver->install_palette(_driver, pal);
|
||||
pal->unmerge();
|
||||
pal->free();
|
||||
@ -258,7 +258,7 @@ private:
|
||||
int _version;
|
||||
bool _isVGA;
|
||||
gfx_options_t *_options;
|
||||
gfx_driver_t *_driver;
|
||||
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
|
||||
|
||||
@ -60,6 +60,7 @@ namespace Sci {
|
||||
struct gfx_mode_t {
|
||||
|
||||
int xfact, yfact; /* Horizontal and vertical scaling factors */
|
||||
int xsize, ysize; /* Horizontal and vertical size */
|
||||
int bytespp; /* Bytes per pixel */
|
||||
|
||||
uint32 flags; /* GFX_MODE_FLAG_* Flags- see above */
|
||||
|
||||
@ -409,7 +409,7 @@ GfxBox::GfxBox(GfxState *state, rect_t area, gfx_color_t color1, gfx_color_t col
|
||||
|
||||
_flags |= GFXW_FLAG_VISIBLE;
|
||||
|
||||
if ((_color1.mask & GFX_MASK_VISUAL) && ((state && (state->driver->mode->palette)) || (!_color1.alpha && !_color2.alpha)))
|
||||
if ((_color1.mask & GFX_MASK_VISUAL) && ((state && (state->driver->getMode()->palette)) || (!_color1.alpha && !_color2.alpha)))
|
||||
_flags |= GFXW_FLAG_OPAQUE;
|
||||
|
||||
_gfxw_set_ops_BOX(this);
|
||||
|
||||
@ -69,7 +69,7 @@ if (!state) { \
|
||||
}
|
||||
|
||||
// How to determine whether colors have to be allocated
|
||||
#define PALETTE_MODE state->driver->mode->palette
|
||||
#define PALETTE_MODE state->driver->getMode()->palette
|
||||
|
||||
//#define GFXOP_DEBUG_DIRTY
|
||||
|
||||
@ -124,13 +124,13 @@ int _gfxop_clip(rect_t *rect, rect_t clipzone) {
|
||||
static int _gfxop_grab_pixmap(GfxState *state, gfx_pixmap_t **pxmp, int x, int y,
|
||||
int xl, int yl, int priority, rect_t *zone) {
|
||||
// Returns 1 if the resulting data size was zero, GFX_OK or an error code otherwise */
|
||||
int xfact = state->driver->mode->xfact;
|
||||
int yfact = state->driver->mode->yfact;
|
||||
int xfact = state->driver->getMode()->xfact;
|
||||
int yfact = state->driver->getMode()->yfact;
|
||||
int unscaled_xl = (xl + xfact - 1) / xfact;
|
||||
int unscaled_yl = (yl + yfact - 1) / yfact;
|
||||
*zone = gfx_rect(x, y, xl, yl);
|
||||
|
||||
if (_gfxop_clip(zone, gfx_rect(0, 0, 320 * state->driver->mode->xfact, 200 * state->driver->mode->yfact)))
|
||||
if (_gfxop_clip(zone, gfx_rect(0, 0, 320 * state->driver->getMode()->xfact, 200 * state->driver->getMode()->yfact)))
|
||||
return GFX_ERROR;
|
||||
|
||||
if (!*pxmp)
|
||||
@ -144,9 +144,9 @@ static int _gfxop_grab_pixmap(GfxState *state, gfx_pixmap_t **pxmp, int x, int y
|
||||
if (!(*pxmp)->data) {
|
||||
(*pxmp)->index_width = unscaled_xl + 1;
|
||||
(*pxmp)->index_height = unscaled_yl + 1;
|
||||
gfx_pixmap_alloc_data(*pxmp, state->driver->mode);
|
||||
gfx_pixmap_alloc_data(*pxmp, state->driver->getMode());
|
||||
}
|
||||
return state->driver->grab_pixmap(state->driver, *zone, *pxmp, priority ? GFX_MASK_PRIORITY : GFX_MASK_VISUAL);
|
||||
return state->driver->grabPixmap(*zone, *pxmp, priority ? GFX_MASK_PRIORITY : GFX_MASK_VISUAL);
|
||||
}
|
||||
|
||||
#define DRAW_LOOP(condition) \
|
||||
@ -192,24 +192,24 @@ DRAW_LOOP(map->index_data[offset] < color) // Draw only lower priority
|
||||
|
||||
#undef DRAW_LOOP
|
||||
|
||||
static int _gfxop_install_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm) {
|
||||
if (!driver->mode->palette) return GFX_OK;
|
||||
static int _gfxop_install_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm) {
|
||||
if (!driver->getMode()->palette) return GFX_OK;
|
||||
if (!pxm->palette) return GFX_OK;
|
||||
|
||||
pxm->palette->mergeInto(driver->mode->palette);
|
||||
assert(pxm->palette->getParent() == driver->mode->palette);
|
||||
pxm->palette->mergeInto(driver->getMode()->palette);
|
||||
assert(pxm->palette->getParent() == driver->getMode()->palette);
|
||||
|
||||
if (pxm->palette_revision != pxm->palette->getRevision())
|
||||
gfx_xlate_pixmap(pxm, driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(pxm, driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
|
||||
if (!driver->mode->palette->isDirty()) return GFX_OK;
|
||||
if (!driver->getMode()->palette->isDirty()) return GFX_OK;
|
||||
|
||||
// TODO: We probably want to only update the colours used by this pixmap
|
||||
// here. This will require updating the 'dirty' system.
|
||||
uint8 paletteData[4*256];
|
||||
const uint paletteSize = driver->mode->palette->size();
|
||||
const uint paletteSize = driver->getMode()->palette->size();
|
||||
for (uint i = 0; i < paletteSize; ++i) {
|
||||
const PaletteEntry& c = (*driver->mode->palette)[i];
|
||||
const PaletteEntry& c = (*driver->getMode()->palette)[i];
|
||||
paletteData[4*i+0] = c.r;
|
||||
paletteData[4*i+1] = c.g;
|
||||
paletteData[4*i+2] = c.b;
|
||||
@ -217,18 +217,18 @@ static int _gfxop_install_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm) {
|
||||
}
|
||||
|
||||
g_system->setPalette(paletteData, 0, paletteSize);
|
||||
driver->mode->palette->markClean();
|
||||
driver->getMode()->palette->markClean();
|
||||
|
||||
return GFX_OK;
|
||||
}
|
||||
|
||||
static int _gfxop_draw_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm, int priority, int control,
|
||||
static int _gfxop_draw_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm, int priority, int control,
|
||||
rect_t src, rect_t dest, rect_t clip, int static_buf, gfx_pixmap_t *control_map, gfx_pixmap_t *priority_map) {
|
||||
int err;
|
||||
rect_t clipped_dest = gfx_rect(dest.x, dest.y, dest.width, dest.height);
|
||||
|
||||
if (control >= 0 || priority >= 0) {
|
||||
Common::Point original_pos = Common::Point(dest.x / driver->mode->xfact, dest.y / driver->mode->yfact);
|
||||
Common::Point original_pos = Common::Point(dest.x / driver->getMode()->xfact, dest.y / driver->getMode()->yfact);
|
||||
|
||||
if (control >= 0)
|
||||
_gfxop_draw_control(control_map, pxm, control, original_pos);
|
||||
@ -251,10 +251,10 @@ static int _gfxop_draw_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm, int prior
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
DDIRTY(stderr, "\\-> Drawing to actual %d %d %d %d\n", clipped_dest.x / driver->mode->xfact,
|
||||
clipped_dest.y / driver->mode->yfact, clipped_dest.width / driver->mode->xfact, clipped_dest.height / driver->mode->yfact);
|
||||
DDIRTY(stderr, "\\-> Drawing to actual %d %d %d %d\n", clipped_dest.x / driver->getMode()->xfact,
|
||||
clipped_dest.y / driver->getMode()->yfact, clipped_dest.width / driver->getMode()->xfact, clipped_dest.height / driver->getMode()->yfact);
|
||||
|
||||
err = driver->draw_pixmap(driver, pxm, priority, src, clipped_dest, static_buf ? GFX_BUFFER_STATIC : GFX_BUFFER_BACK);
|
||||
err = driver->drawPixmap(pxm, priority, src, clipped_dest, static_buf ? GFX_BUFFER_STATIC : GFX_BUFFER_BACK);
|
||||
|
||||
if (err) {
|
||||
GFXERROR("driver->draw_pixmap() returned err!\n");
|
||||
@ -266,8 +266,8 @@ static int _gfxop_draw_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm, int prior
|
||||
|
||||
static void _gfxop_full_pointer_refresh(GfxState *state) {
|
||||
Common::Point mousePoint = g_system->getEventManager()->getMousePos();
|
||||
state->pointer_pos.x = mousePoint.x / state->driver->mode->xfact;
|
||||
state->pointer_pos.y = mousePoint.y / state->driver->mode->yfact;
|
||||
state->pointer_pos.x = mousePoint.x / state->driver->getMode()->xfact;
|
||||
state->pointer_pos.y = mousePoint.y / state->driver->getMode()->yfact;
|
||||
}
|
||||
|
||||
static int _gfxop_buffer_propagate_box(GfxState *state, rect_t box, gfx_buffer_t buffer);
|
||||
@ -298,7 +298,7 @@ gfx_pixmap_t *_gfxr_get_cel(GfxState *state, int nr, int *loop, int *cel, int pa
|
||||
|
||||
static int _gfxop_update_box(GfxState *state, rect_t box) {
|
||||
int retval;
|
||||
_gfxop_scale_rect(&box, state->driver->mode);
|
||||
_gfxop_scale_rect(&box, state->driver->getMode());
|
||||
|
||||
if ((retval = _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_FRONT))) {
|
||||
GFXERROR("Error occured while propagating box (%d,%d,%d,%d) to front buffer\n", box.x, box.y, box.width, box.height);
|
||||
@ -430,15 +430,7 @@ int gfxop_init(int version, bool isVGA, GfxState *state, gfx_options_t *options,
|
||||
state->pic_port_bounds = gfx_rect(0, 10, 320, 190);
|
||||
state->_dirtyRects.clear();
|
||||
|
||||
do {
|
||||
if (!state->driver->init(state->driver, xfact, yfact, color_depth))
|
||||
initialized = 1;
|
||||
else
|
||||
color_depth++;
|
||||
} while (!initialized && color_depth < 9 && !bpp);
|
||||
|
||||
if (!initialized)
|
||||
return GFX_FATAL;
|
||||
state->driver = new GfxDriver(xfact, yfact, bpp);
|
||||
|
||||
state->gfxResMan = new GfxResManager(version, isVGA, state->options, state->driver, resManager);
|
||||
|
||||
@ -471,7 +463,7 @@ int gfxop_exit(GfxState *state) {
|
||||
state->static_priority_map = NULL;
|
||||
}
|
||||
|
||||
state->driver->exit(state->driver);
|
||||
delete state->driver;
|
||||
|
||||
return GFX_OK;
|
||||
}
|
||||
@ -532,8 +524,8 @@ int gfxop_set_clip_zone(GfxState *state, rect_t zone) {
|
||||
|
||||
DDIRTY(stderr, "-- Setting clip zone %d %d %d %d\n", GFX_PRINT_RECT(zone));
|
||||
|
||||
xfact = state->driver->mode->xfact;
|
||||
yfact = state->driver->mode->yfact;
|
||||
xfact = state->driver->getMode()->xfact;
|
||||
yfact = state->driver->getMode()->yfact;
|
||||
|
||||
if (zone.x < MIN_X) {
|
||||
zone.width -= (zone.x - MIN_X);
|
||||
@ -582,7 +574,7 @@ int gfxop_set_color(GfxState *state, gfx_color_t *color, int r, int g, int b, in
|
||||
color->alpha = a;
|
||||
|
||||
if (PALETTE_MODE) {
|
||||
color->visual.parent_index = state->driver->mode->palette->findNearbyColor(r,g,b,true);
|
||||
color->visual.parent_index = state->driver->getMode()->palette->findNearbyColor(r,g,b,true);
|
||||
}
|
||||
}
|
||||
|
||||
@ -606,12 +598,12 @@ int gfxop_set_system_color(GfxState *state, unsigned int index, gfx_color_t *col
|
||||
if (!PALETTE_MODE)
|
||||
return GFX_OK;
|
||||
|
||||
if (index >= state->driver->mode->palette->size()) {
|
||||
if (index >= state->driver->getMode()->palette->size()) {
|
||||
GFXERROR("Attempt to set invalid color index %02x as system color\n", color->visual.parent_index);
|
||||
return GFX_ERROR;
|
||||
}
|
||||
|
||||
state->driver->mode->palette->makeSystemColor(index, color->visual);
|
||||
state->driver->getMode()->palette->makeSystemColor(index, color->visual);
|
||||
|
||||
return GFX_OK;
|
||||
}
|
||||
@ -716,11 +708,11 @@ static void draw_line_to_control_map(GfxState *state, Common::Point start, Commo
|
||||
gfx_draw_line_pixmap_i(state->control_map, start, end, color.control);
|
||||
}
|
||||
|
||||
static int simulate_stippled_line_draw(gfx_driver_t *driver, int skipone, Common::Point start, Common::Point end, gfx_color_t color, gfx_line_mode_t line_mode) {
|
||||
static int simulate_stippled_line_draw(GfxDriver *driver, int skipone, Common::Point start, Common::Point end, gfx_color_t color, gfx_line_mode_t line_mode) {
|
||||
// Draws a stippled line if this isn't supported by the driver (skipone is ignored ATM)
|
||||
int xl = end.x - start.x;
|
||||
int yl = end.y - start.y;
|
||||
int stepwidth = (xl) ? driver->mode->xfact : driver->mode->yfact;
|
||||
int stepwidth = (xl) ? driver->getMode()->xfact : driver->getMode()->yfact;
|
||||
int dbl_stepwidth = 2 * stepwidth;
|
||||
int linelength = (line_mode == GFX_LINE_MODE_FINE) ? stepwidth - 1 : 0;
|
||||
int16 *posvar;
|
||||
@ -759,7 +751,7 @@ static int simulate_stippled_line_draw(gfx_driver_t *driver, int skipone, Common
|
||||
int retval;
|
||||
Common::Point nextpos = Common::Point(start.x + xl, start.y + yl);
|
||||
|
||||
if ((retval = driver->draw_line(driver, start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) {
|
||||
if ((retval = driver->drawLine(start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) {
|
||||
GFXERROR("Failed to draw partial stippled line (%d,%d) -- (%d,%d)\n", start.x, start.y, nextpos.x, nextpos.y);
|
||||
return retval;
|
||||
}
|
||||
@ -781,7 +773,7 @@ static int simulate_stippled_line_draw(gfx_driver_t *driver, int skipone, Common
|
||||
|
||||
nextpos = Common::Point(start.x + xl, start.y + yl);
|
||||
|
||||
if ((retval = driver->draw_line(driver, start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) {
|
||||
if ((retval = driver->drawLine(start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) {
|
||||
GFXERROR("Failed to draw partial stippled line (%d,%d) -- (%d,%d)\n", start.x, start.y, nextpos.x, nextpos.y);
|
||||
return retval;
|
||||
}
|
||||
@ -809,7 +801,7 @@ static int _gfxop_draw_line_clipped(GfxState *state, Common::Point start, Common
|
||||
|| start.y < state->clip_zone.y
|
||||
|| end.x >= (state->clip_zone.x + state->clip_zone.width)
|
||||
|| end.y >= (state->clip_zone.y + state->clip_zone.height))
|
||||
if (point_clip(&start, &end, state->clip_zone, state->driver->mode->xfact - 1, state->driver->mode->yfact - 1))
|
||||
if (point_clip(&start, &end, state->clip_zone, state->driver->getMode()->xfact - 1, state->driver->getMode()->yfact - 1))
|
||||
return GFX_OK; // Clipped off
|
||||
|
||||
if (line_style == GFX_LINE_STYLE_STIPPLED) {
|
||||
@ -820,7 +812,7 @@ static int _gfxop_draw_line_clipped(GfxState *state, Common::Point start, Common
|
||||
return simulate_stippled_line_draw(state->driver, skipone, start, end, color, line_mode);
|
||||
}
|
||||
|
||||
if ((retval = state->driver->draw_line(state->driver, start, end, color, line_mode, line_style))) {
|
||||
if ((retval = state->driver->drawLine(start, end, color, line_mode, line_style))) {
|
||||
GFXERROR("Failed to draw line (%d,%d) -- (%d,%d)\n", start.x, start.y, end.x, end.y);
|
||||
return retval;
|
||||
}
|
||||
@ -835,13 +827,13 @@ int gfxop_draw_line(GfxState *state, Common::Point start, Common::Point end,
|
||||
BASIC_CHECKS(GFX_FATAL);
|
||||
_gfxop_add_dirty_x(state, gfx_rect(start.x, start.y, end.x - start.x, end.y - start.y));
|
||||
|
||||
xfact = state->driver->mode->xfact;
|
||||
yfact = state->driver->mode->yfact;
|
||||
xfact = state->driver->getMode()->xfact;
|
||||
yfact = state->driver->getMode()->yfact;
|
||||
|
||||
draw_line_to_control_map(state, start, end, color);
|
||||
|
||||
_gfxop_scale_point(&start, state->driver->mode);
|
||||
_gfxop_scale_point(&end, state->driver->mode);
|
||||
_gfxop_scale_point(&start, state->driver->getMode());
|
||||
_gfxop_scale_point(&end, state->driver->getMode());
|
||||
|
||||
if (line_mode == GFX_LINE_MODE_FINE) {
|
||||
start.x += xfact >> 1;
|
||||
@ -866,8 +858,8 @@ int gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color, gfx_li
|
||||
BASIC_CHECKS(GFX_FATAL);
|
||||
_gfxop_full_pointer_refresh(state);
|
||||
|
||||
xfact = state->driver->mode->xfact;
|
||||
yfact = state->driver->mode->yfact;
|
||||
xfact = state->driver->getMode()->xfact;
|
||||
yfact = state->driver->getMode()->yfact;
|
||||
|
||||
int offset = line_mode == GFX_LINE_MODE_FINE ? 1 : 0;
|
||||
x = rect.x * xfact + (xfact - 1) * offset;
|
||||
@ -908,7 +900,7 @@ int gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color, gfx_li
|
||||
#define COLOR_MIX(type, dist) ((color1.type * dist) + (color2.type * (1.0 - dist)))
|
||||
|
||||
int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t color2, gfx_box_shade_t shade_type) {
|
||||
gfx_driver_t *drv = state->driver;
|
||||
GfxDriver *drv = state->driver;
|
||||
int reverse = 0; // switch color1 and color2
|
||||
float mod_offset = 0.0, mod_breadth = 1.0; // 0.0 to 1.0: Color adjustment
|
||||
gfx_rectangle_fill_t driver_shade_type;
|
||||
@ -930,7 +922,7 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t
|
||||
gfx_draw_box_pixmap_i(state->control_map, new_box, color1.control);
|
||||
}
|
||||
|
||||
_gfxop_scale_rect(&box, state->driver->mode);
|
||||
_gfxop_scale_rect(&box, state->driver->getMode());
|
||||
|
||||
if (!(color1.mask & (GFX_MASK_VISUAL | GFX_MASK_PRIORITY)))
|
||||
return GFX_OK;
|
||||
@ -981,7 +973,7 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t
|
||||
color1.control = 0;
|
||||
if (color1.visual.parent_index == GFX_COLOR_INDEX_UNMAPPED)
|
||||
gfxop_set_color(state, &color1, color1);
|
||||
return drv->draw_filled_rect(drv, new_box, color1, color1, GFX_SHADE_FLAT);
|
||||
return drv->drawFilledRect(new_box, color1, color1, GFX_SHADE_FLAT);
|
||||
} else {
|
||||
if (PALETTE_MODE) {
|
||||
GFXWARN("Attempting to draw shaded box in palette mode!\n");
|
||||
@ -1010,9 +1002,9 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t
|
||||
draw_color2.alpha = (uint8) COLOR_MIX(alpha, mod_offset);
|
||||
}
|
||||
if (reverse)
|
||||
return drv->draw_filled_rect(drv, new_box, draw_color2, draw_color1, driver_shade_type);
|
||||
return drv->drawFilledRect(new_box, draw_color2, draw_color1, driver_shade_type);
|
||||
else
|
||||
return drv->draw_filled_rect(drv, new_box, draw_color1, draw_color2, driver_shade_type);
|
||||
return drv->drawFilledRect(new_box, draw_color1, draw_color2, driver_shade_type);
|
||||
}
|
||||
}
|
||||
#undef COLOR_MIX
|
||||
@ -1024,10 +1016,10 @@ int gfxop_fill_box(GfxState *state, rect_t box, gfx_color_t color) {
|
||||
static int _gfxop_buffer_propagate_box(GfxState *state, rect_t box, gfx_buffer_t buffer) {
|
||||
int err;
|
||||
|
||||
if (_gfxop_clip(&box, gfx_rect(0, 0, 320 * state->driver->mode->xfact, 200 * state->driver->mode->yfact)))
|
||||
if (_gfxop_clip(&box, gfx_rect(0, 0, 320 * state->driver->getMode()->xfact, 200 * state->driver->getMode()->yfact)))
|
||||
return GFX_OK;
|
||||
|
||||
if ((err = state->driver->update(state->driver, box, Common::Point(box.x, box.y), buffer))) {
|
||||
if ((err = state->driver->update(box, Common::Point(box.x, box.y), buffer))) {
|
||||
GFXERROR("Error occured while updating region (%d,%d,%d,%d) in buffer %d\n", box.x, box.y, box.width, box.height, buffer);
|
||||
return err;
|
||||
}
|
||||
@ -1049,7 +1041,7 @@ int gfxop_clear_box(GfxState *state, rect_t box) {
|
||||
gfx_copy_pixmap_box_i(state->priority_map, state->static_priority_map, box);
|
||||
#endif
|
||||
|
||||
_gfxop_scale_rect(&box, state->driver->mode);
|
||||
_gfxop_scale_rect(&box, state->driver->getMode());
|
||||
|
||||
return _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_BACK);
|
||||
}
|
||||
@ -1094,7 +1086,7 @@ int gfxop_update(GfxState *state) {
|
||||
if (state->fullscreen_override) {
|
||||
// We've been asked to re-draw the active full-screen image, essentially.
|
||||
rect_t rect = gfx_rect(0, 0, 320, 200);
|
||||
gfx_xlate_pixmap(state->fullscreen_override, state->driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(state->fullscreen_override, state->driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
gfxop_draw_pixmap(state, state->fullscreen_override, rect, Common::Point(0, 0));
|
||||
retval |= _gfxop_update_box(state, rect);
|
||||
}
|
||||
@ -1174,8 +1166,8 @@ static int _gfxop_set_pointer(GfxState *state, gfx_pixmap_t *pxm, Common::Point
|
||||
// from this pxm at that point. (An alternative might be to ensure the
|
||||
// cursor only uses colours in the static part of the palette?)
|
||||
if (pxm && pxm->palette)
|
||||
pxm->palette->mergeInto(state->driver->mode->palette);
|
||||
state->driver->set_pointer(state->driver, pxm, hotspot);
|
||||
pxm->palette->mergeInto(state->driver->getMode()->palette);
|
||||
state->driver->setPointer(pxm, hotspot);
|
||||
|
||||
return GFX_OK;
|
||||
}
|
||||
@ -1237,7 +1229,7 @@ int gfxop_set_pointer_position(GfxState *state, Common::Point pos) {
|
||||
return 0; // Not fatal
|
||||
}
|
||||
|
||||
g_system->warpMouse(pos.x * state->driver->mode->xfact, pos.y * state->driver->mode->yfact);
|
||||
g_system->warpMouse(pos.x * state->driver->getMode()->xfact, pos.y * state->driver->getMode()->yfact);
|
||||
|
||||
_gfxop_full_pointer_refresh(state);
|
||||
return 0;
|
||||
@ -1352,7 +1344,7 @@ static int _gfxop_numlockify(int c) {
|
||||
}
|
||||
}
|
||||
|
||||
static sci_event_t scummvm_get_event(gfx_driver_t *drv) {
|
||||
static sci_event_t scummvm_get_event(GfxDriver *drv) {
|
||||
static int _modifierStates = 0; // FIXME: Avoid non-const global vars
|
||||
sci_event_t input = { SCI_EVT_NONE, 0, 0, 0 };
|
||||
|
||||
@ -1726,8 +1718,8 @@ static int _gfxop_draw_cel_buffer(GfxState *state, int nr, int loop, int cel, Co
|
||||
old_x = pos.x -= pxm->xoffset;
|
||||
old_y = pos.y -= pxm->yoffset;
|
||||
|
||||
pos.x *= state->driver->mode->xfact;
|
||||
pos.y *= state->driver->mode->yfact;
|
||||
pos.x *= state->driver->getMode()->xfact;
|
||||
pos.y *= state->driver->getMode()->yfact;
|
||||
|
||||
if (!static_buf)
|
||||
_gfxop_add_dirty(state, gfx_rect(old_x, old_y, pxm->index_width, pxm->index_height));
|
||||
@ -1746,7 +1738,7 @@ int gfxop_draw_cel_static(GfxState *state, int nr, int loop, int cel, Common::Po
|
||||
rect_t oldclip = state->clip_zone;
|
||||
|
||||
state->clip_zone = gfx_rect_fullscreen;
|
||||
_gfxop_scale_rect(&(state->clip_zone), state->driver->mode);
|
||||
_gfxop_scale_rect(&(state->clip_zone), state->driver->getMode());
|
||||
retval = gfxop_draw_cel_static_clipped(state, nr, loop, cel, pos, color, palette);
|
||||
// Except that the area it's clipped against is... unusual ;-)
|
||||
state->clip_zone = oldclip;
|
||||
@ -1769,14 +1761,14 @@ static int _gfxop_set_pic(GfxState *state) {
|
||||
// FIXME: The _gfxop_install_pixmap call below updates the OSystem palette.
|
||||
// This is too soon, since it causes brief palette corruption until the
|
||||
// screen is updated too. (Possibly related: EngineState::pic_not_valid .)
|
||||
state->pic->visual_map->palette->forceInto(state->driver->mode->palette);
|
||||
state->pic->visual_map->palette->forceInto(state->driver->getMode()->palette);
|
||||
_gfxop_install_pixmap(state->driver, state->pic->visual_map);
|
||||
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
if (state->options->pic0_unscaled)
|
||||
#endif
|
||||
state->pic->priority_map = gfx_pixmap_scale_index_data(state->pic->priority_map, state->driver->mode);
|
||||
return state->driver->set_static_buffer(state->driver, state->pic->visual_map, state->pic->priority_map);
|
||||
state->pic->priority_map = gfx_pixmap_scale_index_data(state->pic->priority_map, state->driver->getMode());
|
||||
return state->driver->setStaticBuffer(state->pic->visual_map, state->pic->priority_map);
|
||||
}
|
||||
|
||||
int *gfxop_get_pic_metainfo(GfxState *state) {
|
||||
@ -1791,7 +1783,7 @@ int gfxop_new_pic(GfxState *state, int nr, int flags, int default_palette) {
|
||||
state->palette_nr = default_palette;
|
||||
state->pic = state->gfxResMan->getPic(nr, GFX_MASK_VISUAL, flags, default_palette, true);
|
||||
|
||||
if (state->driver->mode->xfact == 1 && state->driver->mode->yfact == 1) {
|
||||
if (state->driver->getMode()->xfact == 1 && state->driver->getMode()->yfact == 1) {
|
||||
state->pic_unscaled = state->pic;
|
||||
} else {
|
||||
state->pic = state->gfxResMan->getPic(nr, GFX_MASK_VISUAL, flags, default_palette, false);
|
||||
@ -2003,9 +1995,9 @@ int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
|
||||
return GFX_OK;
|
||||
}
|
||||
|
||||
_gfxop_scale_rect(&zone, state->driver->mode);
|
||||
_gfxop_scale_rect(&zone, state->driver->getMode());
|
||||
|
||||
line_height = handle->line_height * state->driver->mode->yfact;
|
||||
line_height = handle->line_height * state->driver->getMode()->yfact;
|
||||
|
||||
pos.y = zone.y;
|
||||
|
||||
@ -2033,9 +2025,9 @@ int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
|
||||
|
||||
if (!pxm->data) {
|
||||
#ifdef CUSTOM_GRAPHICS_OPTIONS
|
||||
gfx_xlate_pixmap(pxm, state->driver->mode, state->options->text_xlate_filter);
|
||||
gfx_xlate_pixmap(pxm, state->driver->getMode(), state->options->text_xlate_filter);
|
||||
#else
|
||||
gfx_xlate_pixmap(pxm, state->driver->mode, GFX_XLATE_FILTER_NONE);
|
||||
gfx_xlate_pixmap(pxm, state->driver->getMode(), GFX_XLATE_FILTER_NONE);
|
||||
#endif
|
||||
}
|
||||
if (!pxm) {
|
||||
@ -2082,7 +2074,7 @@ gfx_pixmap_t *gfxop_grab_pixmap(GfxState *state, rect_t area) {
|
||||
BASIC_CHECKS(NULL);
|
||||
_gfxop_full_pointer_refresh(state);
|
||||
|
||||
_gfxop_scale_rect(&area, state->driver->mode);
|
||||
_gfxop_scale_rect(&area, state->driver->getMode());
|
||||
if (_gfxop_grab_pixmap(state, &pixmap, area.x, area.y, area.width, area.height, 0, &resultzone))
|
||||
return NULL; // area CUT the visual screen had a null or negative size
|
||||
|
||||
@ -2109,11 +2101,11 @@ int gfxop_draw_pixmap(GfxState *state, gfx_pixmap_t *pxm, rect_t zone, Common::P
|
||||
return GFX_ERROR;
|
||||
}
|
||||
|
||||
_gfxop_scale_rect(&zone, state->driver->mode);
|
||||
_gfxop_scale_rect(&target, state->driver->mode);
|
||||
_gfxop_scale_rect(&zone, state->driver->getMode());
|
||||
_gfxop_scale_rect(&target, state->driver->getMode());
|
||||
|
||||
return _gfxop_draw_pixmap(state->driver, pxm, -1, -1, zone, target, gfx_rect(0, 0, 320*state->driver->mode->xfact,
|
||||
200*state->driver->mode->yfact), 0, NULL, NULL);
|
||||
return _gfxop_draw_pixmap(state->driver, pxm, -1, -1, zone, target, gfx_rect(0, 0, 320*state->driver->getMode()->xfact,
|
||||
200*state->driver->getMode()->yfact), 0, NULL, NULL);
|
||||
}
|
||||
|
||||
int gfxop_free_pixmap(GfxState *state, gfx_pixmap_t *pxm) {
|
||||
|
||||
@ -98,7 +98,7 @@ struct GfxState {
|
||||
rect_t clip_zone_unscaled; /* The current UNSCALED clipping zone */
|
||||
rect_t clip_zone; /* The current SCALED clipping zone; a cached scaled version of clip_zone_unscaled */
|
||||
|
||||
gfx_driver_t *driver;
|
||||
GfxDriver *driver;
|
||||
|
||||
int visible_map;
|
||||
|
||||
|
||||
@ -40,7 +40,7 @@
|
||||
|
||||
namespace Sci {
|
||||
|
||||
extern gfx_driver_t gfx_driver_scummvm;
|
||||
class GfxDriver;
|
||||
|
||||
const char *versionNames[9] = {
|
||||
"Autodetected",
|
||||
@ -194,10 +194,9 @@ Common::Error SciEngine::run() {
|
||||
script_set_gamestate_save_dir(_gamestate, "/");
|
||||
|
||||
GfxState gfx_state;
|
||||
gfx_state.driver = &gfx_driver_scummvm;
|
||||
_gamestate->gfx_state = &gfx_state;
|
||||
|
||||
_gamestate->animation_granularity = 4;
|
||||
_gamestate->gfx_state = &gfx_state;
|
||||
|
||||
// Default config:
|
||||
gfx_options_t gfx_options;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user