path: root/saga/sysgfx.cpp

/* ScummVM - Scumm Interpreter
 * Copyright (C) 2004 The ScummVM project
 *
 * The ReInherit Engine is (C)2000-2003 by Daniel Balsom.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Header$
 *
 */

#include "reinherit.h"

#include <SDL.h>
#include <limits.h>

#include "sysgfx.h"

namespace Saga {

R_SYSGFX_MODULE SGfxModule;

static SDL_Color cur_pal[R_PAL_ENTRIES];

int SYSGFX_Init(R_SYSGFX_INIT *gfx_init) {
	SDL_Surface *sdl_screen;
	R_SURFACE r_screen;
	SDL_Surface *sdl_back_buf;
	R_SURFACE r_back_buf;

	int result;
	Uint32 flags;

	assert(gfx_init != NULL);

	flags = SDL_HWPALETTE;

	// Test video mode availability */
	result = SDL_VideoModeOK(gfx_init->screen_w, gfx_init->screen_h, gfx_init->screen_bpp, flags);
	if (result == 0) {
		R_printf(R_STDERR, "Requested video mode (%d x %d @ %d bpp) is unavailable.\n", gfx_init->screen_w,
				gfx_init->screen_h, gfx_init->screen_bpp);
		return R_FAILURE;
	}

	// Set the video mode
	sdl_screen = SDL_SetVideoMode(gfx_init->screen_w, gfx_init->screen_h, gfx_init->screen_bpp, flags);
	if (sdl_screen == NULL) {
		R_printf(R_STDERR, "Unable to set video mode (%d x %d @ %d bpp).\n", gfx_init->screen_w,
				gfx_init->screen_h, gfx_init->screen_bpp);
		R_printf(R_STDERR, "SDL reports: %s\n", SDL_GetError());
		return R_FAILURE;
	}

	R_printf(R_STDOUT, "Set video mode: (%d x %d @ %d bpp)\n", sdl_screen->w, sdl_screen->h,
			sdl_screen->format->BitsPerPixel);

	// Convert sdl surface data to R surface data
	r_screen.buf = (byte *)sdl_screen->pixels;
	r_screen.buf_w = sdl_screen->w;
	r_screen.buf_h = sdl_screen->h;
	r_screen.buf_pitch = sdl_screen->pitch;
	r_screen.bpp = gfx_init->screen_bpp;

	r_screen.clip_rect.left = 0;
	r_screen.clip_rect.top = 0;
	r_screen.clip_rect.right = sdl_screen->w - 1;
	r_screen.clip_rect.bottom = sdl_screen->h - 1;

	r_screen.impl_src = sdl_screen;

	// Create the back buffer
	sdl_back_buf = SDL_CreateRGBSurface(SDL_SWSURFACE, gfx_init->backbuf_w,
										gfx_init->backbuf_h, gfx_init->backbuf_bpp, 0, 0, 0, 0);
	if (sdl_back_buf == NULL) {
		R_printf(R_STDERR, "Unable to create back buffer (%d x %d @ %d bpp).\n", gfx_init->backbuf_w,
				gfx_init->backbuf_h, gfx_init->backbuf_bpp);
		R_printf(R_STDERR, "SDL reports: %s.\n", SDL_GetError());
		return R_FAILURE;
	}

	// Convert sdl surface data to R surface data
	r_back_buf.buf = (byte *)sdl_back_buf->pixels;
	r_back_buf.buf_w = sdl_back_buf->w;
	r_back_buf.buf_h = sdl_back_buf->h;
	r_back_buf.buf_pitch = sdl_back_buf->pitch;
	r_back_buf.bpp = gfx_init->backbuf_bpp;

	r_back_buf.clip_rect.left = 0;
	r_back_buf.clip_rect.top = 0;
	r_back_buf.clip_rect.right = sdl_back_buf->w - 1;
	r_back_buf.clip_rect.bottom = sdl_back_buf->h - 1;

	r_back_buf.impl_src = sdl_back_buf;

	// Set module data
	SGfxModule.sdl_screen = sdl_screen;
	SGfxModule.r_screen = r_screen;
	SGfxModule.sdl_back_buf = sdl_back_buf;
	SGfxModule.r_back_buf = r_back_buf;
	SGfxModule.init = 1;

	return R_SUCCESS;
}

R_SURFACE *SYSGFX_GetScreenSurface() {
	return &SGfxModule.r_screen;
}

R_SURFACE *SYSGFX_GetBackBuffer() {
	return &SGfxModule.r_back_buf;
}

int SYSGFX_LockSurface(R_SURFACE *surface) {
	int result;

	assert(surface != NULL);

	result = SDL_LockSurface((SDL_Surface *) surface->impl_src);

	return (result == 0) ? R_SUCCESS : R_FAILURE;
}

int SYSGFX_UnlockSurface(R_SURFACE *surface) {
	assert(surface != NULL);

	SDL_UnlockSurface((SDL_Surface *) surface->impl_src);

	return R_SUCCESS;
}

int SYSGFX_GetWhite(void) {
	return SGfxModule.white_index;
}

int SYSGFX_GetBlack(void) {
	return SGfxModule.black_index;
}

int SYSGFX_MatchColor(unsigned long colormask) {
	int i;
	int red = (colormask & 0x0FF0000UL) >> 16;
	int green = (colormask & 0x000FF00UL) >> 8;
	int blue = colormask & 0x00000FFUL;
	int dr;
	int dg;
	int db;
	long color_delta;
	long best_delta = LONG_MAX;
	int best_index = 0;

	for (i = 0; i < R_PAL_ENTRIES; i++) {
		dr = cur_pal[i].r - red;
		dr = ABS(dr);
		dg = cur_pal[i].g - green;
		dg = ABS(dg);
		db = cur_pal[i].b - blue;
		db = ABS(db);

#if R_COLORSEARCH_SQUARE
		color_delta = (long)((dr * dr) * R_RED_WEIGHT + (dg * dg) * R_GREEN_WEIGHT + (db * db) * R_BLUE_WEIGHT);
#else
		color_delta = (long)(dr * R_RED_WEIGHT + dg * R_GREEN_WEIGHT + db * R_BLUE_WEIGHT);
#endif
		if (color_delta == 0) {
			return i;
		}

		if (color_delta < best_delta) {
			best_delta = color_delta;
			best_index = i;
		}
	}

	return best_index;
}

int SYSGFX_SetPalette(R_SURFACE *surface, PALENTRY *pal) {
	byte red;
	byte green;
	byte blue;
	int color_delta;
	int best_wdelta = 0;
	int best_windex = 0;
	int best_bindex = 0;
	int best_bdelta = 1000;
	int i;

	for (i = 0; i < R_PAL_ENTRIES; i++) {
		red = pal[i].red;
		cur_pal[i].r = red;
		color_delta = red;
		green = pal[i].green;
		cur_pal[i].g = green;
		color_delta += green;
		blue = pal[i].blue;
		cur_pal[i].b = blue;
		color_delta += blue;

		if (color_delta < best_bdelta) {
			best_bindex = i;
			best_bdelta = color_delta;
		}

		if (color_delta > best_wdelta) {
			best_windex = i;
			best_wdelta = color_delta;
		}
	}

	// Set whitest and blackest color indices
	SGfxModule.white_index = best_windex;
	SGfxModule.black_index = best_bindex;

	// If the screen surface is palettized, set the screen palette.
	// If the screen surface is not palettized, set the palette of 
	// the surface parameter
	if (SGfxModule.r_screen.bpp < 16) {
		SDL_SetColors(SGfxModule.sdl_screen, cur_pal, 0, R_PAL_ENTRIES);
	} else {
		SDL_SetColors((SDL_Surface *) surface->impl_src, cur_pal, 0, R_PAL_ENTRIES);
	}

	return R_SUCCESS;
}

int SYSGFX_GetCurrentPal(PALENTRY *src_pal) {
	int i;

	for (i = 0; i < R_PAL_ENTRIES; i++) {
		src_pal[i].red = cur_pal[i].r;
		src_pal[i].green = cur_pal[i].g;
		src_pal[i].blue = cur_pal[i].b;
	}

	return R_SUCCESS;
}

int SYSGFX_PalToBlack(R_SURFACE *surface, PALENTRY *src_pal, double percent) {
	int i;
	//int fade_max = 255;
	int new_entry;

	double fpercent;

	if (percent > 1.0) {
		percent = 1.0;
	}

	// Exponential fade
	fpercent = percent * percent;

	fpercent = 1.0 - fpercent;

	// Use the correct percentage change per frame for each palette entry 
	for (i = 0; i < R_PAL_ENTRIES; i++) {
		new_entry = (int)(src_pal[i].red * fpercent);

		if (new_entry < 0) {
			cur_pal[i].r = 0;
		} else {
			cur_pal[i].r = (byte) new_entry;
		}

		new_entry = (int)(src_pal[i].green * fpercent);

		if (new_entry < 0) {
			cur_pal[i].g = 0;
		} else {
			cur_pal[i].g = (byte) new_entry;
		}

		new_entry = (int)(src_pal[i].blue * fpercent);

		if (new_entry < 0) {
			cur_pal[i].b = 0;
		} else {
			cur_pal[i].b = (byte) new_entry;
		}
	}

	// If the screen surface is palettized, set the screen palette.
	// If the screen surface is not palettized, set the palette of 
	// the surface parameter
	if (SGfxModule.r_screen.bpp < 16) {
		SDL_SetColors(SGfxModule.sdl_screen, cur_pal, 0, R_PAL_ENTRIES);
	} else {
		SDL_SetColors((SDL_Surface *) surface->impl_src, cur_pal, 0, R_PAL_ENTRIES);
	}

	return R_SUCCESS;
}

int SYSGFX_BlackToPal(R_SURFACE *surface, PALENTRY *src_pal, double percent) {
	int new_entry;
	double fpercent;
	int color_delta;
	int best_wdelta = 0;
	int best_windex = 0;
	int best_bindex = 0;
	int best_bdelta = 1000;
	int i;

	if (percent > 1.0) {
		percent = 1.0;
	}

	// Exponential fade
	fpercent = percent * percent;

	fpercent = 1.0 - fpercent;

	// Use the correct percentage change per frame for each palette entry
	for (i = 0; i < R_PAL_ENTRIES; i++) {
		new_entry = (int)(src_pal[i].red - src_pal[i].red * fpercent);

		if (new_entry < 0) {
			cur_pal[i].r = 0;
		} else {
			cur_pal[i].r = (byte) new_entry;
		}

		new_entry = (int)(src_pal[i].green - src_pal[i].green * fpercent);

		if (new_entry < 0) {
			cur_pal[i].g = 0;
		} else {
			cur_pal[i].g = (byte) new_entry;
		}

		new_entry = (int)(src_pal[i].blue - src_pal[i].blue * fpercent);

		if (new_entry < 0) {
			cur_pal[i].b = 0;
		} else {
			cur_pal[i].b = (byte) new_entry;
		}
	}

	// Find the best white and black color indices again
	if (percent >= 1.0) {
		for (i = 0; i < R_PAL_ENTRIES; i++) {
			color_delta = cur_pal[i].r;
			color_delta += cur_pal[i].g;
			color_delta += cur_pal[i].b;

			if (color_delta < best_bdelta) {
				best_bindex = i;
				best_bdelta = color_delta;
			}

			if (color_delta > best_wdelta) {
				best_windex = i;
				best_wdelta = color_delta;
			}
		}
	}

	// If the screen surface is palettized, set the screen palette.
	// If the screen surface is not palettized, set the palette of 
	// the surface parameter
	if (SGfxModule.r_screen.bpp < 16) {
		SDL_SetColors(SGfxModule.sdl_screen, cur_pal, 0, R_PAL_ENTRIES);
	} else {
		SDL_SetColors((SDL_Surface *) surface->impl_src, cur_pal, 0, R_PAL_ENTRIES);
	}

	return R_SUCCESS;
}

} // End of namespace Saga