[Scummvm-cvs-logs] SF.net SVN: scummvm:[41214] scummvm/trunk/engines/sci
thebluegr at users.sourceforge.net
thebluegr at users.sourceforge.net
Sat Jun 6 12:21:48 CEST 2009
Revision: 41214
http://scummvm.svn.sourceforge.net/scummvm/?rev=41214&view=rev
Author: thebluegr
Date: 2009-06-06 10:21:48 +0000 (Sat, 06 Jun 2009)
Log Message:
-----------
Objectified the graphics driver
Modified Paths:
--------------
scummvm/trunk/engines/sci/console.cpp
scummvm/trunk/engines/sci/engine/kgraphics.cpp
scummvm/trunk/engines/sci/gfx/gfx_driver.cpp
scummvm/trunk/engines/sci/gfx/gfx_driver.h
scummvm/trunk/engines/sci/gfx/gfx_resmgr.cpp
scummvm/trunk/engines/sci/gfx/gfx_resmgr.h
scummvm/trunk/engines/sci/gfx/gfx_system.h
scummvm/trunk/engines/sci/gfx/gfx_widgets.cpp
scummvm/trunk/engines/sci/gfx/operations.cpp
scummvm/trunk/engines/sci/gfx/operations.h
scummvm/trunk/engines/sci/sci.cpp
Modified: scummvm/trunk/engines/sci/console.cpp
===================================================================
--- scummvm/trunk/engines/sci/console.cpp 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/console.cpp 2009-06-06 10:21:48 UTC (rev 41214)
@@ -963,8 +963,7 @@
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 @@
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;
Modified: scummvm/trunk/engines/sci/engine/kgraphics.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/kgraphics.cpp 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/engine/kgraphics.cpp 2009-06-06 10:21:48 UTC (rev 41214)
@@ -3328,9 +3328,9 @@
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);
Modified: scummvm/trunk/engines/sci/gfx/gfx_driver.cpp
===================================================================
--- scummvm/trunk/engines/sci/gfx/gfx_driver.cpp 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/gfx_driver.cpp 2009-06-06 10:21:48 UTC (rev 41214)
@@ -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;
+ 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;
- S->xsize = xfact * 320;
- S->ysize = yfact * 200;
-
- //S->buckystate = 0;
-
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
// 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 @@
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
Modified: scummvm/trunk/engines/sci/gfx/gfx_driver.h
===================================================================
--- scummvm/trunk/engines/sci/gfx/gfx_driver.h 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/gfx_driver.h 2009-06-06 10:21:48 UTC (rev 41214)
@@ -62,18 +62,13 @@
** 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 @@
** 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 @@
/*** 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 @@
** 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 @@
/*** 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 @@
** (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 @@
/*** 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 @@
** 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 @@
/*** 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 @@
** 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
Modified: scummvm/trunk/engines/sci/gfx/gfx_resmgr.cpp
===================================================================
--- scummvm/trunk/engines/sci/gfx/gfx_resmgr.cpp 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/gfx_resmgr.cpp 2009-06-06 10:21:48 UTC (rev 41214)
@@ -46,10 +46,10 @@
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 @@
_staticPalette = newPalette;
_staticPalette->name = "static palette";
- _staticPalette->mergeInto(_driver->mode->palette);
+ _staticPalette->mergeInto(_driver->getMode()->palette);
}
#if 0
@@ -313,7 +313,7 @@
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 @@
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 @@
}
#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 @@
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 @@
#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 @@
#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 @@
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 @@
}
#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;
Modified: scummvm/trunk/engines/sci/gfx/gfx_resmgr.h
===================================================================
--- scummvm/trunk/engines/sci/gfx/gfx_resmgr.h 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/gfx_resmgr.h 2009-06-06 10:21:48 UTC (rev 41214)
@@ -88,7 +88,7 @@
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 @@
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 @@
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
Modified: scummvm/trunk/engines/sci/gfx/gfx_system.h
===================================================================
--- scummvm/trunk/engines/sci/gfx/gfx_system.h 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/gfx_system.h 2009-06-06 10:21:48 UTC (rev 41214)
@@ -60,6 +60,7 @@
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 */
Modified: scummvm/trunk/engines/sci/gfx/gfx_widgets.cpp
===================================================================
--- scummvm/trunk/engines/sci/gfx/gfx_widgets.cpp 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/gfx_widgets.cpp 2009-06-06 10:21:48 UTC (rev 41214)
@@ -409,7 +409,7 @@
_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);
Modified: scummvm/trunk/engines/sci/gfx/operations.cpp
===================================================================
--- scummvm/trunk/engines/sci/gfx/operations.cpp 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/operations.cpp 2009-06-06 10:21:48 UTC (rev 41214)
@@ -69,7 +69,7 @@
}
// 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 @@
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 @@
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 @@
#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 @@
}
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 @@
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 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 @@
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,16 +430,8 @@
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);
+ state->driver = new GfxDriver(xfact, yfact, bpp);
- if (!initialized)
- return GFX_FATAL;
-
state->gfxResMan = new GfxResManager(version, isVGA, state->options, state->driver, resManager);
gfxop_set_clip_zone(state, gfx_rect(0, 0, 320, 200));
@@ -471,7 +463,7 @@
state->static_priority_map = NULL;
}
- state->driver->exit(state->driver);
+ delete state->driver;
return GFX_OK;
}
@@ -532,8 +524,8 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
|| 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 @@
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 @@
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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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) {
Modified: scummvm/trunk/engines/sci/gfx/operations.h
===================================================================
--- scummvm/trunk/engines/sci/gfx/operations.h 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/gfx/operations.h 2009-06-06 10:21:48 UTC (rev 41214)
@@ -98,7 +98,7 @@
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;
Modified: scummvm/trunk/engines/sci/sci.cpp
===================================================================
--- scummvm/trunk/engines/sci/sci.cpp 2009-06-06 08:41:03 UTC (rev 41213)
+++ scummvm/trunk/engines/sci/sci.cpp 2009-06-06 10:21:48 UTC (rev 41214)
@@ -40,7 +40,7 @@
namespace Sci {
-extern gfx_driver_t gfx_driver_scummvm;
+class GfxDriver;
const char *versionNames[9] = {
"Autodetected",
@@ -194,10 +194,9 @@
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;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list