Further objectification of the graphics resource manager

svn-id: r39621

1 files changed, 77 insertions, 105 deletions

diff --git a/engines/sci/gfx/gfx_resmgr.cpp b/engines/sci/gfx/gfx_resmgr.cpp
index 890e5842d2..6ab69e6ecf 100644
--- a/engines/sci/gfx/gfx_resmgr.cpp
+++ b/engines/sci/gfx/gfx_resmgr.cpp
@@ -49,53 +49,43 @@ struct param_struct {
 };
 
 #define DRAW_PIC01(pic, picStyle, isSci1) \
-	gfxr_draw_pic01((pic), flags, default_palette, res->size, res->data, (picStyle), res->id, (isSci1), state->static_palette);
+	gfxr_draw_pic01((pic), flags, default_palette, res->size, res->data, (picStyle), res->id, (isSci1), _staticPalette);
 
 #define DRAW_PIC11(pic, picStyle) \
-	gfxr_draw_pic11((pic), flags, default_palette, res->size, res->data, (picStyle), res->id, state->static_palette);
-
-/* Calculate a picture
-** Parameters: (gfx_resstate_t *) state: The resource state, containing options and version information
-**             (gfxr_pic_t *) scaled_pic: The pic structure that is to be written to
-**             (gfxr_pic_t *) unscaled_pic: The pic structure the unscaled pic is to be written to,
-**                                          or NULL if it isn't needed.
-**             (int) flags: Pic drawing flags (interpreter dependant)
-**             (int) default_palette: The default palette to use for pic drawing (interpreter dependant)
-**             (int) nr: pic resource number
-** Returns   : (int) GFX_ERROR if the resource could not be found, GFX_OK otherwise
-*/
-int calculatePic(gfx_resstate_t *state, gfxr_pic_t *scaled_pic, gfxr_pic_t *unscaled_pic, int flags, int default_palette, int nr) {
-	Resource *res = state->resManager->findResource(kResourceTypePic, nr, 0);
+	gfxr_draw_pic11((pic), flags, default_palette, res->size, res->data, (picStyle), res->id, _staticPalette);
+
+int GfxResManager::calculatePic(gfxr_pic_t *scaled_pic, gfxr_pic_t *unscaled_pic, int flags, int default_palette, int nr) {
+	Resource *res = _resManager->findResource(kResourceTypePic, nr, 0);
 	int need_unscaled = unscaled_pic != NULL;
 	gfxr_pic0_params_t style, basic_style;
 
 	basic_style.line_mode = GFX_LINE_MODE_CORRECT;
 	basic_style.brush_mode = GFX_BRUSH_MODE_SCALED;
-	basic_style.pic_port_bounds = state->options->pic_port_bounds;
+	basic_style.pic_port_bounds = _options->pic_port_bounds;
 
-	style.line_mode = state->options->pic0_line_mode;
-	style.brush_mode = state->options->pic0_brush_mode;
-	style.pic_port_bounds = state->options->pic_port_bounds;
+	style.line_mode = _options->pic0_line_mode;
+	style.brush_mode = _options->pic0_brush_mode;
+	style.pic_port_bounds = _options->pic_port_bounds;
 
 	if (!res || !res->data)
 		return GFX_ERROR;
 
 	if (need_unscaled) {
-		if (state->version == SCI_VERSION_1_1)
+		if (_version == SCI_VERSION_1_1)
 			DRAW_PIC11(unscaled_pic, &basic_style)
 		else
-			DRAW_PIC01(unscaled_pic, &basic_style, state->version >= SCI_VERSION_01_VGA)
+			DRAW_PIC01(unscaled_pic, &basic_style, _version >= SCI_VERSION_01_VGA)
 	}
 
 	if (scaled_pic && scaled_pic->undithered_buffer)
 		memcpy(scaled_pic->visual_map->index_data, scaled_pic->undithered_buffer, scaled_pic->undithered_buffer_size);
 
-	if (state->version == SCI_VERSION_1_1)
+	if (_version == SCI_VERSION_1_1)
 		DRAW_PIC11(scaled_pic, &style)
 	else
-		DRAW_PIC01(scaled_pic, &style, state->version >= SCI_VERSION_01_VGA)
+		DRAW_PIC01(scaled_pic, &style, _version >= SCI_VERSION_01_VGA)
 
-	if (state->version < SCI_VERSION_01_VGA) {
+	if (_version < SCI_VERSION_01_VGA) {
 		if (need_unscaled)
 			gfxr_remove_artifacts_pic0(scaled_pic, unscaled_pic);
 
@@ -104,7 +94,7 @@ int calculatePic(gfx_resstate_t *state, gfxr_pic_t *scaled_pic, gfxr_pic_t *unsc
 
 		memcpy(scaled_pic->undithered_buffer, scaled_pic->visual_map->index_data, scaled_pic->undithered_buffer_size);
 
-		gfxr_dither_pic0(scaled_pic, state->options->pic0_dither_mode, state->options->pic0_dither_pattern);
+		gfxr_dither_pic0(scaled_pic, _options->pic0_dither_mode, _options->pic0_dither_pattern);
 	}
 
 	// Mark default palettes
@@ -117,20 +107,6 @@ int calculatePic(gfx_resstate_t *state, gfxr_pic_t *scaled_pic, gfxr_pic_t *unsc
 	return GFX_OK;
 }
 
-gfx_resstate_t *gfxr_new_resource_manager(int version, gfx_options_t *options, gfx_driver_t *driver, ResourceManager *resManager) {
-	gfx_resstate_t *state = new gfx_resstate_t();
-
-	state->version = version;
-	state->options = options;
-	state->driver = driver;
-	state->resManager = resManager;
-	state->static_palette = 0;
-
-	state->tag_lock_counter = state->lock_counter = 0;
-
-	return state;
-}
-
 int GfxResManager::getOptionsHash(gfx_resource_type_t type) {
 	switch (type) {
 	case GFX_RESOURCE_TYPE_VIEW:
@@ -138,12 +114,12 @@ int GfxResManager::getOptionsHash(gfx_resource_type_t type) {
 		error("getOptionsHash called on a VIEW resource");
 
 	case GFX_RESOURCE_TYPE_PIC:
-		if (_state->version >= SCI_VERSION_01_VGA)
-			return _state->options->pic_port_bounds.y;
+		if (_version >= SCI_VERSION_01_VGA)
+			return _options->pic_port_bounds.y;
 		else
-			return (_state->options->pic0_unscaled) ? 0x10000 : (_state->options->pic0_dither_mode << 12)
-			       | (_state->options->pic0_dither_pattern << 8) | (_state->options->pic0_brush_mode << 4) 
-				   | (_state->options->pic0_line_mode);
+			return (_options->pic0_unscaled) ? 0x10000 : (_options->pic0_dither_mode << 12)
+			       | (_options->pic0_dither_pattern << 8) | (_options->pic0_brush_mode << 4) 
+				   | (_options->pic0_line_mode);
 
 	case GFX_RESOURCE_TYPE_FONT:
 	case GFX_RESOURCE_TYPE_CURSOR:
@@ -195,7 +171,7 @@ void gfxr_free_resource(gfx_resource_t *resource, int type) {
 
 void GfxResManager::freeAllResources() {
 	for (int type = 0; type < GFX_RESOURCE_TYPES_NR; ++type) {
-		for (IntResMap::iterator iter = _state->_resourceMaps[type].begin(); iter != _state->_resourceMaps[type].end(); ++iter) {
+		for (IntResMap::iterator iter = _resourceMaps[type].begin(); iter != _resourceMaps[type].end(); ++iter) {
 			gfxr_free_resource(iter->_value, type);
 			iter->_value = 0;
 		}
@@ -204,7 +180,7 @@ void GfxResManager::freeAllResources() {
 
 void GfxResManager::freeResManager() {
 	freeAllResources();
-	delete _state;
+	_lockCounter = _tagLockCounter = 0;
 }
 
 void GfxResManager::freeTaggedResources() {
@@ -212,10 +188,10 @@ void GfxResManager::freeTaggedResources() {
 
 	IntResMap::iterator iter;
 	int type;
-	const int tmp = _state->tag_lock_counter;
+	const int tmp = _tagLockCounter;
 
 	type = GFX_RESOURCE_TYPE_VIEW;
-	for (iter = _state->_resourceMaps[type].begin(); iter != _state->_resourceMaps[type].end(); ++iter) {
+	for (iter = _resourceMaps[type].begin(); iter != _resourceMaps[type].end(); ++iter) {
 		gfx_resource_t *resource = iter->_value;
 
 		if (resource) {
@@ -229,7 +205,7 @@ void GfxResManager::freeTaggedResources() {
 	}
 
 	type = GFX_RESOURCE_TYPE_PIC;
-	for (iter = _state->_resourceMaps[type].begin(); iter != _state->_resourceMaps[type].end(); ++iter) {
+	for (iter = _resourceMaps[type].begin(); iter != _resourceMaps[type].end(); ++iter) {
 		gfx_resource_t *resource = iter->_value;
 
 		if (resource) {
@@ -242,7 +218,7 @@ void GfxResManager::freeTaggedResources() {
 		}
 	}
 
-	_state->tag_lock_counter = 0;
+	_tagLockCounter = 0;
 }
 
 #define XLATE_AS_APPROPRIATE(key, entry) \
@@ -273,11 +249,11 @@ static gfxr_pic_t *gfxr_pic_xlate_common(gfx_resource_t *res, int maps, int scal
 
 gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_palette, bool scaled) {
 	gfxr_pic_t *npic = NULL;
-	IntResMap &resMap = _state->_resourceMaps[GFX_RESOURCE_TYPE_PIC];
+	IntResMap &resMap = _resourceMaps[GFX_RESOURCE_TYPE_PIC];
 	gfx_resource_t *res = NULL;
 	int hash = getOptionsHash(GFX_RESOURCE_TYPE_PIC);
 	int must_post_process_pic = 0;
-	int need_unscaled = (_state->driver->mode->xfact != 1 || _state->driver->mode->yfact != 1);
+	int need_unscaled = (_driver->mode->xfact != 1 || _driver->mode->yfact != 1);
 
 	hash |= (flags << 20) | ((default_palette & 0x7) << 28);
 
@@ -287,11 +263,11 @@ gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_pale
 		gfxr_pic_t *pic;
 		gfxr_pic_t *unscaled_pic = NULL;
 
-		if (_state->options->pic0_unscaled) {
+		if (_options->pic0_unscaled) {
 			need_unscaled = 0;
-			pic = gfxr_init_pic(&mode_1x1_color_index, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _state->version >= SCI_VERSION_01_VGA);
+			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(_state->driver->mode, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _state->version >= SCI_VERSION_01_VGA);
+			pic = gfxr_init_pic(_driver->mode, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _version >= SCI_VERSION_01_VGA);
 		if (!pic) {
 			GFXERROR("Failed to allocate scaled pic!\n");
 			return NULL;
@@ -300,14 +276,14 @@ gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_pale
 		gfxr_clear_pic0(pic, SCI_TITLEBAR_SIZE);
 
 		if (need_unscaled) {
-			unscaled_pic = gfxr_init_pic(&mode_1x1_color_index, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _state->version >= SCI_VERSION_01_VGA);
+			unscaled_pic = gfxr_init_pic(&mode_1x1_color_index, GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num), _version >= SCI_VERSION_01_VGA);
 			if (!unscaled_pic) {
 				GFXERROR("Failed to allocate unscaled pic!\n");
 				return NULL;
 			}
 			gfxr_clear_pic0(pic, SCI_TITLEBAR_SIZE);
 		}
-		if (calculatePic(_state, pic, unscaled_pic, flags, default_palette, num)) {
+		if (calculatePic(pic, unscaled_pic, flags, default_palette, num)) {
 			gfxr_free_pic(pic);
 			if (unscaled_pic)
 				gfxr_free_pic(unscaled_pic);
@@ -316,7 +292,7 @@ gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_pale
 		if (!res) {
 			res = (gfx_resource_t *)sci_malloc(sizeof(gfx_resource_t));
 			res->ID = GFXR_RES_ID(GFX_RESOURCE_TYPE_PIC, num);
-			res->lock_sequence_nr = _state->options->buffer_pics_nr;
+			res->lock_sequence_nr = _options->buffer_pics_nr;
 			resMap[num] = res;
 		} else {
 			gfxr_free_pic(res->scaled_data.pic);
@@ -328,18 +304,18 @@ gfxr_pic_t *GfxResManager::getPic(int num, int maps, int flags, int default_pale
 		res->scaled_data.pic = pic;
 		res->unscaled_data.pic = unscaled_pic;
 	} else {
-		res->lock_sequence_nr = _state->options->buffer_pics_nr; // Update lock counter
+		res->lock_sequence_nr = _options->buffer_pics_nr; // Update lock counter
 	}
 
 	must_post_process_pic = res->scaled_data.pic->visual_map->data == NULL;
 	// If the pic was only just drawn, we'll have to endianness-adjust it now
 
-	npic = gfxr_pic_xlate_common(res, maps, scaled || _state->options->pic0_unscaled, 0, _state->driver->mode,
-	                             _state->options->pic_xlate_filter, 0, _state->options);
+	npic = gfxr_pic_xlate_common(res, maps, scaled || _options->pic0_unscaled, 0, _driver->mode,
+	                             _options->pic_xlate_filter, 0, _options);
 
 
 	if (must_post_process_pic) {
-		gfxr_endianness_adjust(npic->visual_map, _state->driver->mode);
+		gfxr_endianness_adjust(npic->visual_map, _driver->mode);
 	}
 
 	return npic;
@@ -393,20 +369,16 @@ static void _gfxr_unscale_pixmap_index_data(gfx_pixmap_t *pxm, gfx_mode_t *mode)
 }
 
 gfxr_pic_t *GfxResManager::addToPic(int old_nr, int new_nr, int flags, int old_default_palette, int default_palette) {
-	IntResMap &resMap = _state->_resourceMaps[GFX_RESOURCE_TYPE_PIC];
+	IntResMap &resMap = _resourceMaps[GFX_RESOURCE_TYPE_PIC];
 	gfxr_pic_t *pic = NULL;
 	gfx_resource_t *res = NULL;
 	int hash = getOptionsHash(GFX_RESOURCE_TYPE_PIC);
-	int need_unscaled = !(_state->options->pic0_unscaled) && (_state->driver->mode->xfact != 1 || _state->driver->mode->yfact != 1);
+	int need_unscaled = !(_options->pic0_unscaled) && (_driver->mode->xfact != 1 || _driver->mode->yfact != 1);
 
 	res = resMap.contains(old_nr) ? resMap[old_nr] : NULL;
 
 	if (!res || (res->mode != MODE_INVALID && res->mode != hash)) {
-		// FIXME: the initialization of the GFX resource manager should
-		// be pushed up, and it shouldn't occur here
-		GfxResManager *_gfx = new GfxResManager(_state);
-		_gfx->getPic(old_nr, 0, flags, old_default_palette, 1);
-		delete _gfx;
+		getPic(old_nr, 0, flags, old_default_palette, 1);
 
 		res = resMap.contains(old_nr) ? resMap[old_nr] : NULL;
 
@@ -416,22 +388,22 @@ gfxr_pic_t *GfxResManager::addToPic(int old_nr, int new_nr, int flags, int old_d
 		}
 	}
 
-	if (_state->options->pic0_unscaled) // Unscale priority map, if we scaled it earlier
-		_gfxr_unscale_pixmap_index_data(res->scaled_data.pic->priority_map, _state->driver->mode);
+	if (_options->pic0_unscaled) // Unscale priority map, if we scaled it earlier
+		_gfxr_unscale_pixmap_index_data(res->scaled_data.pic->priority_map, _driver->mode);
 
 	// The following two operations are needed when returning scaled maps (which is always the case here)
-	res->lock_sequence_nr = _state->options->buffer_pics_nr;
-	calculatePic(_state, res->scaled_data.pic, need_unscaled ? res->unscaled_data.pic : NULL,
+	res->lock_sequence_nr = _options->buffer_pics_nr;
+	calculatePic(res->scaled_data.pic, need_unscaled ? res->unscaled_data.pic : NULL,
 		                               flags | DRAWPIC01_FLAG_OVERLAID_PIC, default_palette, new_nr);
 
 	res->mode = MODE_INVALID; // Invalidate
 
-	if (_state->options->pic0_unscaled) // Scale priority map again, if needed
-		res->scaled_data.pic->priority_map = gfx_pixmap_scale_index_data(res->scaled_data.pic->priority_map, _state->driver->mode);
+	if (_options->pic0_unscaled) // Scale priority map again, if needed
+		res->scaled_data.pic->priority_map = gfx_pixmap_scale_index_data(res->scaled_data.pic->priority_map, _driver->mode);
 	{
 		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 optoins work properly
-		pic = gfxr_pic_xlate_common(res, GFX_MASK_VISUAL, 1, 1, _state->driver->mode, _state->options->pic_xlate_filter, 1, _state->options);
+		pic = gfxr_pic_xlate_common(res, GFX_MASK_VISUAL, 1, 1, _driver->mode, _options->pic_xlate_filter, 1, _options);
 		set_pic_id(res, old_ID);
 	}
 
@@ -441,7 +413,7 @@ gfxr_pic_t *GfxResManager::addToPic(int old_nr, int new_nr, int flags, int old_d
 gfxr_view_t *gfxr_draw_view11(int id, byte *resource, int size);
 
 gfxr_view_t *GfxResManager::getView(int nr, int *loop, int *cel, int palette) {
-	IntResMap &resMap = _state->_resourceMaps[GFX_RESOURCE_TYPE_VIEW];
+	IntResMap &resMap = _resourceMaps[GFX_RESOURCE_TYPE_VIEW];
 	gfx_resource_t *res = NULL;
 	int hash = palette;
 	gfxr_view_t *view = NULL;
@@ -451,32 +423,32 @@ gfxr_view_t *GfxResManager::getView(int nr, int *loop, int *cel, int palette) {
 	res = resMap.contains(nr) ? resMap[nr] : NULL;
 
 	if (!res || res->mode != hash) {
-		Resource *viewRes = _state->resManager->findResource(kResourceTypeView, nr, 0);
+		Resource *viewRes = _resManager->findResource(kResourceTypeView, nr, 0);
 		if (!viewRes || !viewRes->data)
 			return NULL;
 
 		int resid = GFXR_RES_ID(GFX_RESOURCE_TYPE_VIEW, nr);
 
-		if (_state->version < SCI_VERSION_01)
+		if (_version < SCI_VERSION_01)
 			view = gfxr_draw_view0(resid, viewRes->data, viewRes->size, -1);
-		else if (_state->version == SCI_VERSION_01)
+		else if (_version == SCI_VERSION_01)
 			view = gfxr_draw_view0(resid, viewRes->data, viewRes->size, palette);
-		else if (_state->version >= SCI_VERSION_01_VGA && _state->version <= SCI_VERSION_1_LATE)
-			view = gfxr_draw_view1(resid, viewRes->data, viewRes->size, _state->static_palette);
-		else if (_state->version >= SCI_VERSION_1_1)
+		else if (_version >= SCI_VERSION_01_VGA && _version <= SCI_VERSION_1_LATE)
+			view = gfxr_draw_view1(resid, viewRes->data, viewRes->size, _staticPalette);
+		else if (_version >= SCI_VERSION_1_1)
 			view = gfxr_draw_view11(resid, viewRes->data, viewRes->size);
 
-		if (_state->version >= SCI_VERSION_01_VGA) {
+		if (_version >= SCI_VERSION_01_VGA) {
 			if (!view->palette) {
-				view->palette = new Palette(_state->static_palette->size());
+				view->palette = new Palette(_staticPalette->size());
 				view->palette->name = "interpreter_get_view";
 			}
 			
 			// Palettize view
-			for (unsigned i = 0; i < MIN(view->palette->size(), _state->static_palette->size()); i++) {
+			for (unsigned i = 0; i < MIN(view->palette->size(), _staticPalette->size()); i++) {
 				const PaletteEntry& vc = view->palette->getColor(i);
 				if (vc.r == 0 && vc.g == 0 && vc.b == 0) {
-					const PaletteEntry& sc = _state->static_palette->getColor(i);
+					const PaletteEntry& sc = _staticPalette->getColor(i);
 					view->palette->setColor(i, sc.r, sc.g, sc.b);
 				}
 			}
@@ -487,7 +459,7 @@ gfxr_view_t *GfxResManager::getView(int nr, int *loop, int *cel, int palette) {
 			res = (gfx_resource_t *)sci_malloc(sizeof(gfx_resource_t));
 			res->scaled_data.view = NULL;
 			res->ID = GFXR_RES_ID(GFX_RESOURCE_TYPE_VIEW, nr);
-			res->lock_sequence_nr = _state->tag_lock_counter;
+			res->lock_sequence_nr = _tagLockCounter;
 			res->mode = hash;
 			resMap[nr] = res;
 		} else {
@@ -498,7 +470,7 @@ gfxr_view_t *GfxResManager::getView(int nr, int *loop, int *cel, int palette) {
 		res->unscaled_data.view = view;
 
 	} else {
-		res->lock_sequence_nr = _state->tag_lock_counter; // Update lock counter
+		res->lock_sequence_nr = _tagLockCounter; // Update lock counter
 		view = res->unscaled_data.view;
 	}
 
@@ -529,23 +501,23 @@ gfxr_view_t *GfxResManager::getView(int nr, int *loop, int *cel, int palette) {
 	}
 
 	if (!cel_data->data) {
-		gfx_get_res_config(_state->options, cel_data);
-		gfx_xlate_pixmap(cel_data, _state->driver->mode, _state->options->view_xlate_filter);
-		gfxr_endianness_adjust(cel_data, _state->driver->mode);
+		gfx_get_res_config(_options, cel_data);
+		gfx_xlate_pixmap(cel_data, _driver->mode, _options->view_xlate_filter);
+		gfxr_endianness_adjust(cel_data, _driver->mode);
 	}
 
 	return view;
 }
 
 gfx_bitmap_font_t *GfxResManager::getFont(int num, bool scaled) {
-	IntResMap &resMap = _state->_resourceMaps[GFX_RESOURCE_TYPE_FONT];
+	IntResMap &resMap = _resourceMaps[GFX_RESOURCE_TYPE_FONT];
 	gfx_resource_t *res = NULL;
 	int hash = getOptionsHash(GFX_RESOURCE_TYPE_FONT);
 
 	res = resMap.contains(num) ? resMap[num] : NULL;
 
 	if (!res || res->mode != hash) {
-		Resource *fontRes = _state->resManager->findResource(kResourceTypeFont, num, 0);
+		Resource *fontRes = _resManager->findResource(kResourceTypeFont, num, 0);
 		if (!fontRes || !fontRes->data)
 			return NULL;
 
@@ -555,7 +527,7 @@ gfx_bitmap_font_t *GfxResManager::getFont(int num, bool scaled) {
 			res = (gfx_resource_t *)sci_malloc(sizeof(gfx_resource_t));
 			res->scaled_data.font = NULL;
 			res->ID = GFXR_RES_ID(GFX_RESOURCE_TYPE_FONT, num);
-			res->lock_sequence_nr = _state->tag_lock_counter;
+			res->lock_sequence_nr = _tagLockCounter;
 			res->mode = hash;
 			resMap[num] = res;
 		} else {
@@ -566,7 +538,7 @@ gfx_bitmap_font_t *GfxResManager::getFont(int num, bool scaled) {
 
 		return font;
 	} else {
-		res->lock_sequence_nr = _state->tag_lock_counter; // Update lock counter
+		res->lock_sequence_nr = _tagLockCounter; // Update lock counter
 		if (res->unscaled_data.pointer)
 			return res->unscaled_data.font;
 		else
@@ -575,24 +547,24 @@ gfx_bitmap_font_t *GfxResManager::getFont(int num, bool scaled) {
 }
 
 gfx_pixmap_t *GfxResManager::getCursor(int num) {
-	IntResMap &resMap = _state->_resourceMaps[GFX_RESOURCE_TYPE_CURSOR];
+	IntResMap &resMap = _resourceMaps[GFX_RESOURCE_TYPE_CURSOR];
 	gfx_resource_t *res = NULL;
 	int hash = getOptionsHash(GFX_RESOURCE_TYPE_CURSOR);
 
 	res = resMap.contains(num) ? resMap[num] : NULL;
 
 	if (!res || res->mode != hash) {
-		Resource *cursorRes = _state->resManager->findResource(kResourceTypeCursor, num, 0);
+		Resource *cursorRes = _resManager->findResource(kResourceTypeCursor, num, 0);
 		if (!cursorRes || !cursorRes->data)
 			return NULL;
 
-		if (_state->version >= SCI_VERSION_1_1) {
+		if (_version >= SCI_VERSION_1_1) {
 			GFXWARN("Attempt to retrieve cursor in SCI1.1 or later\n");
 			return NULL;
 		}
 
 		gfx_pixmap_t *cursor = gfxr_draw_cursor(GFXR_RES_ID(GFX_RESOURCE_TYPE_CURSOR, num), 
-										cursorRes->data, cursorRes->size, _state->version != SCI_VERSION_0);
+										cursorRes->data, cursorRes->size, _version != SCI_VERSION_0);
 
 		if (!cursor)
 			return NULL;
@@ -601,21 +573,21 @@ gfx_pixmap_t *GfxResManager::getCursor(int num) {
 			res = (gfx_resource_t *)sci_malloc(sizeof(gfx_resource_t));
 			res->scaled_data.pointer = NULL;
 			res->ID = GFXR_RES_ID(GFX_RESOURCE_TYPE_CURSOR, num);
-			res->lock_sequence_nr = _state->tag_lock_counter;
+			res->lock_sequence_nr = _tagLockCounter;
 			res->mode = hash;
 			resMap[num] = res;
 		} else {
 			gfx_free_pixmap(res->unscaled_data.pointer);
 		}
-		gfx_get_res_config(_state->options, cursor);
-		gfx_xlate_pixmap(cursor, _state->driver->mode, _state->options->cursor_xlate_filter);
-		gfxr_endianness_adjust(cursor, _state->driver->mode);
+		gfx_get_res_config(_options, cursor);
+		gfx_xlate_pixmap(cursor, _driver->mode, _options->cursor_xlate_filter);
+		gfxr_endianness_adjust(cursor, _driver->mode);
 
 		res->unscaled_data.pointer = cursor;
 
 		return cursor;
 	} else {
-		res->lock_sequence_nr = _state->tag_lock_counter; // Update lock counter
+		res->lock_sequence_nr = _tagLockCounter; // Update lock counter
 		return res->unscaled_data.pointer;
 	}
 }