char *fs_emu_theme_get_resource(const char *name) {
if (fs_path_exists(name)) {
return fs_strdup(name);
}
char *path, *p;
p = fs_path_join(g_fs_emu_theme.path, name, NULL);
if (fs_path_exists(p)) {
return p;
}
free(p);
p = fs_path_join(g_fs_emu_theme.name, name, NULL);
path = fs_get_program_data_file(p);
free(p);
if (path) {
return path;
}
//p = fs_path_join("default", name, NULL);
path = fs_get_program_data_file(name);
//free(p);
if (path) {
return path;
}
return NULL;
}
char *fs_emu_theme_get_resource_path(const char *name)
{
printf("WARNING: fs_emu_theme_get_resource_path (%s) is deprecated\n",
name);
if (fs_path_exists(name)) {
return g_strdup(name);
}
char *path, *p;
p = g_build_filename(g_fs_emu_theme.path, name, NULL);
if (fs_path_exists(p)) {
return p;
}
free(p);
p = g_build_filename(g_fs_emu_theme.name, name, NULL);
path = fs_get_program_data_file(p);
free(p);
if (path) {
return path;
}
//p = g_build_filename("default", name, NULL);
path = fs_get_program_data_file(name);
//free(p);
if (path) {
return path;
}
return NULL;
}
void fs_uae_set_uae_paths() {
fs_log("fs_uae_set_uae_paths\n");
amiga_set_paths(g_paths[FS_UAE_ROM_PATHS].path,
g_paths[FS_UAE_FLOPPY_PATHS].path,
g_paths[FS_UAE_CD_PATHS].path,
g_paths[FS_UAE_HD_PATHS].path);
static const char *library_dirs[2];
library_dirs[0] = fs_uae_plugins_dir();
library_dirs[1] = NULL; // terminates the list
amiga_set_native_library_dirs(library_dirs);
// find path for built-in drive sounds
char *path = fs_get_program_data_file("floppy_sounds");
if (path) {
fs_log("found \"built-in\" driveclick directory at %s\n", path);
amiga_set_builtin_driveclick_path(path);
free(path);
}
else {
fs_log("did not find \"built-in\" driveclick directory\n");
}
// find path for custom drive sounds
path = g_build_filename(fs_uae_base_dir(), "Floppy Sounds", NULL);
amiga_set_floppy_sounds_dir(path);
free(path);
}
void fse_init_theme()
{
fs_log("THEME: Init\n");
fs_emu_theme_overlay* o = g_fs_emu_theme.overlays;
o[FS_EMU_TOP_LEFT_OVERLAY].name = g_strdup("top_left_overlay");
o[FS_EMU_TOP_RIGHT_OVERLAY].name = g_strdup("top_right_overlay");
o[FS_EMU_TOP_RIGHT_OVERLAY].anchor = FS_EMU_ANCHOR_TOP_RIGHT;
o[FS_EMU_BOTTOM_RIGHT_OVERLAY].name = g_strdup("bottom_right_overlay");
o[FS_EMU_BOTTOM_RIGHT_OVERLAY].anchor = FS_EMU_ANCHOR_BOTTOM_RIGHT;
o[FS_EMU_BOTTOM_LEFT_OVERLAY].name = g_strdup("bottom_left_overlay");
o[FS_EMU_BOTTOM_LEFT_OVERLAY].anchor = FS_EMU_ANCHOR_BOTTOM_LEFT;
o[FS_EMU_AUDIO_LED_OVERLAY].name = g_strdup("audio_led");
o[FS_EMU_FPS_LED_OVERLAY].name = g_strdup("fps_led");
o[FS_EMU_VSYNC_LED_OVERLAY].name = g_strdup("vsync_led");
o[FS_EMU_FPS_D0_OVERLAY].name = g_strdup("fps_d0");
o[FS_EMU_FPS_D1_OVERLAY].name = g_strdup("fps_d1");
const char *theme = fs_config_get_const_string("theme");
if (theme) {
g_fs_emu_theme.name = g_strdup(theme);
// first try to find the theme in the user's theme dir
const char *themes_dir = fs_config_get_const_string("themes_dir");
if (themes_dir) {
g_fs_emu_theme.path = g_build_filename(themes_dir,
g_fs_emu_theme.name, NULL);
if (!fs_path_exists(g_fs_emu_theme.path)) {
free(g_fs_emu_theme.path);
g_fs_emu_theme.path = NULL;
}
}
// or by direct path lookup
if (!g_fs_emu_theme.path) {
if (fs_path_exists(theme)) {
g_fs_emu_theme.path = g_strdup(theme);
}
}
// then try to find a bundled / installed theme
if (!g_fs_emu_theme.path) {
g_fs_emu_theme.path = fs_get_program_data_file(
g_fs_emu_theme.name);
}
if (g_fs_emu_theme.path) {
fs_log("theme found at %s\n", g_fs_emu_theme.path);
} else {
fs_emu_warning(_("Theme not found: %s"), g_fs_emu_theme.name);
free(g_fs_emu_theme.name);
// resources will not be found, but path should not be NULL...
g_fs_emu_theme.path = g_strdup("");
}
} else {
g_fs_emu_theme.name = g_strdup("");
g_fs_emu_theme.path = g_strdup("");
}
load_defaults();
load_theme();
}
static char *find_shader(const char *name) {
//char *path = g_strdup(name);
fs_log("checking shader %s\n", name);
if (fs_path_exists(name)) {
return g_strdup(name);
}
char *name2 = g_strconcat(name, ".shader", NULL);
char *path = g_build_filename("shaders", name2, NULL);
g_free(name2);
fs_log("checking shader (share)/%s\n", path);
char *path2 = fs_get_program_data_file(path);
g_free(path);
if (path2) {
return path2;
}
return NULL;
}
fs_image *load_font_from_file(const char *name) {
char *full_name = g_strconcat(name, ".png", NULL);
//char *path = g_build_filename(fs_emu_get_share_dir(), full_name, NULL);
char *path = fs_get_program_data_file(full_name);
if (path == NULL) {
fs_emu_warning("Could not find font %s", full_name);
return NULL;
}
fs_emu_log("loading image \"%s\"\n", path);
fs_image *image = fs_image_new_from_file(path);
g_free(path);
if (image == NULL) {
fs_emu_warning("Error loading font from %s", full_name);
g_free(full_name);
return NULL;
}
g_free(full_name);
// convert to premultiplied alpha
if (image->format == FS_IMAGE_FORMAT_RGBA) {
int num_pixels = image->width * image->height;
unsigned char *pixels = image->data;
for (int i = 0; i < num_pixels; i++) {
unsigned char alpha = pixels[3];
// should really divide by 255, but 256 is faster...
//pixels[0] = ((int) pixels[0]) * alpha / 256;
//pixels[1] = ((int) pixels[1]) * alpha / 256;
//pixels[2] = ((int) pixels[2]) * alpha / 256;
pixels[0] = ((int) pixels[0]) * alpha / 255;
pixels[1] = ((int) pixels[1]) * alpha / 255;
pixels[2] = ((int) pixels[2]) * alpha / 255;
//pixels[0] = (unsigned char) ((pixels[0] * alpha + 0.5) / 255.0);
//pixels[1] = (unsigned char) ((pixels[1] * alpha + 0.5) / 255.0);
//pixels[2] = (unsigned char) ((pixels[2] * alpha + 0.5) / 255.0);
pixels += 4;
}
}
return image;
}
fs_emu_texture *fs_emu_texture_new_from_file(const char *name) {
char *full_name;
char *path;
if (fs_path_exists(name)) {
full_name = fs_strdup(name);
path = fs_strdup(name);
}
else {
full_name = fs_strconcat(name, ".png", NULL);
path = fs_get_program_data_file(full_name);
if (path == NULL) {
fs_emu_warning("Could not find texture %s\n", full_name);
return NULL;
}
}
fs_image *image = fs_image_new_from_file(path);
fs_emu_log("loading texture \"%s\"\n", path);
free(path);
if (image == NULL) {
fs_emu_warning("Could not load texture from %s\n", full_name);
free(full_name);
return NULL;
}
free(full_name);
if (fs_emu_get_video_format() == FS_EMU_VIDEO_FORMAT_BGRA) {
// convert to premultiplied alpha
if (image->format == FS_IMAGE_FORMAT_RGBA) {
int num_pixels = image->width * image->height;
unsigned char *pixels = image->data;
for (int i = 0; i < num_pixels; i++) {
unsigned char alpha = pixels[3];
unsigned char temp = pixels[2];
pixels[2] = ((int) pixels[0]) * alpha / 255;
pixels[1] = ((int) pixels[1]) * alpha / 255;
pixels[0] = ((int) temp) * alpha / 255;
pixels += 4;
}
}
else {
// FIXME: should swap R and B here...
}
}
else {
// convert to premultiplied alpha
if (image->format == FS_IMAGE_FORMAT_RGBA) {
int num_pixels = image->width * image->height;
unsigned char *pixels = image->data;
for (int i = 0; i < num_pixels; i++) {
unsigned char alpha = pixels[3];
// should really divide by 255, but 256 is faster...
//pixels[0] = ((int) pixels[0]) * alpha / 256;
//pixels[1] = ((int) pixels[1]) * alpha / 256;
//pixels[2] = ((int) pixels[2]) * alpha / 256;
pixels[0] = ((int) pixels[0]) * alpha / 255;
pixels[1] = ((int) pixels[1]) * alpha / 255;
pixels[2] = ((int) pixels[2]) * alpha / 255;
//pixels[0] = (unsigned char) ((pixels[0] * alpha + 0.5) / 255.0);
//pixels[1] = (unsigned char) ((pixels[1] * alpha + 0.5) / 255.0);
//pixels[2] = (unsigned char) ((pixels[2] * alpha + 0.5) / 255.0);
pixels += 4;
}
}
}
fs_emu_texture *texture = fs_new(fs_emu_texture, 1);
texture->width = image->width;
texture->height = image->height;
texture->image = image;
load_texture(texture);
fs_emu_set_texture(texture);
fs_gl_add_context_notification(context_notification_handler, texture);
return texture;
}
