void gfxr_free_pic(gfxr_pic_t *pic) {
gfx_free_pixmap(pic->visual_map);
gfx_free_pixmap(pic->priority_map);
gfx_free_pixmap(pic->control_map);
pic->visual_map = NULL;
pic->priority_map = NULL;
pic->control_map = NULL;
if (pic->priorityTable)
free(pic->priorityTable);
pic->priorityTable = NULL;
if (pic->undithered_buffer)
free(pic->undithered_buffer);
pic->undithered_buffer = 0;
free(pic);
}
static void
gfx_box_text(gfx_driver_t *gfx_driver, rect_t box, gfx_bitmap_font_t* font, gfx_pixmap_color_t fgc, gfx_pixmap_color_t bgc, const char* text, int center)
{
int width;
int height;
gfx_pixmap_t* pixmap;
text_fragment_t *textsplits;
int meas_width;
int meas_height;
int meas_line;
int margin_x = 0;
int margin_y = 0;
int line_height;
int last_offset;
if (center != 0)
{
textsplits = gfxr_font_calculate_size(font, box.xl, text, &meas_width, &meas_height, &meas_line, &line_height, &last_offset, GFXR_FONT_FLAG_NO_NEWLINES | GFXR_FONT_FLAG_COUNT_WHITESPACE);
if (textsplits != NULL)
{
free(textsplits);
}
margin_x = (box.xl - meas_width) / 2;
margin_y = (box.yl - meas_height) / 2;
}
box.x *= gfx_driver->mode->xfact;
box.y *= gfx_driver->mode->yfact;
box.xl *= gfx_driver->mode->xfact;
box.yl *= gfx_driver->mode->yfact;
margin_x *= gfx_driver->mode->xfact;
margin_y *= gfx_driver->mode->yfact;
pixmap = gfxr_draw_font(font, text, strlen(text), &fgc, &fgc, NULL);
if (pixmap != NULL)
{
pixmap->xoffset = 0;
pixmap->yoffset = 0;
gfx_xlate_pixmap(gfx_pixmap_alloc_data(pixmap, gfx_driver->mode), gfx_driver->mode, GFX_XLATE_FILTER_NONE);
width = pixmap->index_xl * gfx_driver->mode->xfact;
height = pixmap->index_yl * gfx_driver->mode->yfact;
if (width > box.xl)
width = box.xl;
if (gfx_driver->draw_pixmap(gfx_driver, pixmap, GFX_NO_PRIORITY, gfx_rect(0, 0, width, height), gfx_rect(box.x + margin_x, box.y + margin_y, width, height), GFX_BUFFER_BACK) != GFX_OK)
{
GFXERROR("Error occured while drawing pixmap.\n");
}
gfx_free_pixmap(gfx_driver, pixmap);
}
}
static void gfxr_free_loop(gfxr_loop_t *loop) {
int i;
if (loop->cels) {
for (i = 0; i < loop->cels_nr; i++)
if (loop->cels[i])
gfx_free_pixmap(loop->cels[i]);
free(loop->cels);
}
}
gfx_pixmap_t *GfxResManager::getCursor(int num) {
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 = _resManager->findResource(ResourceId(kResourceTypeCursor, num), 0);
if (!cursorRes || !cursorRes->data)
return NULL;
if (_version >= SCI_VERSION_1_1) {
warning("[GFX] Attempt to retrieve cursor in SCI1.1 or later");
return NULL;
}
gfx_pixmap_t *cursor = gfxr_draw_cursor(GFXR_RES_ID(GFX_RESOURCE_TYPE_CURSOR, num),
cursorRes->data, cursorRes->size, _version != SCI_VERSION_0);
if (!cursor)
return NULL;
if (!res) {
res = (gfx_resource_t *)malloc(sizeof(gfx_resource_t));
res->scaled_data.pointer = NULL;
res->ID = GFXR_RES_ID(GFX_RESOURCE_TYPE_CURSOR, num);
res->lock_sequence_nr = _tagLockCounter;
res->mode = hash;
resMap[num] = res;
} else {
gfx_free_pixmap(res->unscaled_data.pointer);
}
#ifdef CUSTOM_GRAPHICS_OPTIONS
gfx_get_res_config(_options, cursor);
gfx_xlate_pixmap(cursor, _driver->getMode(), _options->cursor_xlate_filter);
#else
gfx_xlate_pixmap(cursor, _driver->getMode(), GFX_XLATE_FILTER_NONE);
#endif
res->unscaled_data.pointer = cursor;
return cursor;
} else {
res->lock_sequence_nr = _tagLockCounter; // Update lock counter
return res->unscaled_data.pointer;
}
}
static void
scummvm_exit(struct _gfx_driver *drv)
{
int i;
if (S) {
for (i = 0; i < 2; i++) {
gfx_free_pixmap(drv, S->priority[i]);
S->priority[i] = NULL;
}
for (i = 0; i < 3; i++) {
delete[] S->visual[i];
S->visual[i] = NULL;
}
for (i = 0; i < 2; i++)
if (S->pointer_data[i]) {
delete[] S->pointer_data[i];
S->pointer_data[i] = NULL;
}
delete S;
}
}
gfx_pixmap_t *
gfxr_draw_cel0(int id, int loop, int cel, byte *resource, int size, gfxr_view_t *view, int mirrored)
{
int xl = get_int_16(resource);
int yl = get_int_16(resource + 2);
int xhot = ((signed char *) resource)[4];
int yhot = ((signed char *) resource)[5];
int color_key = resource[6];
int pos = 7;
int writepos = mirrored? xl : 0;
int pixmap_size = xl * yl;
int line_base = 0;
gfx_pixmap_t *retval = gfx_pixmap_alloc_index_data(gfx_new_pixmap(xl, yl, id, loop, cel));
byte *dest = retval->index_data;
retval->color_key = 255; /* Pick something larger than 15 */
retval->xoffset = mirrored? xhot : -xhot;
retval->yoffset = -yhot;
if (view) {
retval->colors = view->colors;
retval->colors_nr = view->colors_nr;
retval->flags |= GFX_PIXMAP_FLAG_EXTERNAL_PALETTE;
} else
{
retval->colors = gfx_sci0_image_colors[sci0_palette];
retval->colors_nr = GFX_SCI0_IMAGE_COLORS_NR;
retval->flags |= GFX_PIXMAP_FLAG_EXTERNAL_PALETTE;
}
if (xl <= 0 || yl <= 0) {
gfx_free_pixmap(NULL, retval);
GFXERROR("View %02x:(%d/%d) has invalid xl=%d or yl=%d\n", id, loop, cel, xl, yl);
return NULL;
}
if (mirrored) {
while (yl && pos < size) {
int op = resource[pos++];
int count = op >> 4;
int color = op & 0xf;
if (view->flags & GFX_PIXMAP_FLAG_PALETTIZED)
color = view->translation[color];
if (color == color_key)
color = retval->color_key;
while (count) {
int pixels = writepos - line_base;
if (pixels > count)
pixels = count;
writepos -= pixels;
memset(dest + writepos, color, pixels);
count -= pixels;
if (writepos == line_base) {
yl--;
writepos += (xl << 1);
line_base += xl;
}
}
}
} else {
while (writepos < pixmap_size && pos < size) {
