int can_open(can_device_p dev) {
if (!dev->comm_dev)
dev->comm_dev = malloc(sizeof(can_cpc_device_t));
if (!dev->num_references) {
dev->num_sent = 0;
dev->num_received = 0;
if (can_cpc_open(dev->comm_dev,
config_get_string(&dev->config, CAN_CPC_PARAMETER_DEVICE)) ||
can_cpc_setup(dev->comm_dev,
config_get_int(&dev->config, CAN_CPC_PARAMETER_BITRATE),
config_get_int(&dev->config, CAN_CPC_PARAMETER_QUANTA_PER_BIT),
config_get_float(&dev->config, CAN_CPC_PARAMETER_SAMPLING_POINT),
config_get_float(&dev->config, CAN_CPC_PARAMETER_TIMEOUT))) {
free(dev->comm_dev);
dev->comm_dev = 0;
return CAN_ERROR_OPEN;
}
}
++dev->num_references;
return CAN_ERROR_NONE;
}
void era_init(era_arm_p arm, can_device_p can_dev, era_config_p config) {
era_config_init_default(&arm->config, &era_config_default);
if (config)
era_config_set(&arm->config, config);
era_motors_init(&arm->motors, can_dev, &arm->config.joints);
era_security_init(&arm->security,
config_get_int(&arm->config.arm, ERA_PARAMETER_ARM_SECURITY_FUNC),
config_get_int(&arm->config.arm, ERA_PARAMETER_ARM_ESTOP_CHANNEL),
config_get_int(&arm->config.arm, ERA_PARAMETER_ARM_SWITCH_CHANNEL));
era_joint_state_t min_state, max_state, state_margin;
era_velocity_state_t max_vel;
era_acceleration_state_t min_accel, max_accel;
era_geometry_init(&arm->geometry,
config_get_float(&arm->config.arm, ERA_PARAMETER_ARM_UPPER_LENGTH),
config_get_float(&arm->config.arm, ERA_PARAMETER_ARM_LOWER_LENGTH),
config_get_float(&arm->config.arm, ERA_PARAMETER_ARM_TOOL_LENGTH));
era_kinematics_limits_init(&arm->kin_limits,
(era_joint_state_p)era_config_joint_get_rad(&arm->config,
ERA_PARAMETER_JOINT_MIN_POSITION, (double*)&min_state),
(era_joint_state_p)era_config_joint_get_rad(&arm->config,
ERA_PARAMETER_JOINT_MAX_POSITION, (double*)&max_state),
(era_joint_state_p)era_config_joint_get_rad(&arm->config,
ERA_PARAMETER_JOINT_POSITION_MARGIN, (double*)&state_margin));
era_dynamics_limits_init(&arm->dyn_limits,
(era_velocity_state_p)era_config_joint_get_rad(&arm->config,
ERA_PARAMETER_JOINT_MAX_VELOCITY, (double*)&max_vel),
(era_acceleration_state_p)era_config_joint_get_rad(&arm->config,
ERA_PARAMETER_JOINT_MIN_ACCELERATION, (double*)&min_accel),
(era_acceleration_state_p)era_config_joint_get_rad(&arm->config,
ERA_PARAMETER_JOINT_MAX_ACCELERATION, (double*)&max_accel));
}
void epos_init(epos_node_p node, can_device_p can_dev, config_p config) {
if (!can_dev) {
can_dev = malloc(sizeof(can_device_t));
can_init(can_dev, 0);
}
config_init_default(&node->config, &epos_default_config);
if (config)
config_set(&node->config, config);
epos_device_init(&node->dev, can_dev,
config_get_int(&node->config, EPOS_PARAMETER_ID),
config_get_int(&node->config, EPOS_PARAMETER_RESET));
epos_sensor_init(&node->sensor, &node->dev,
config_get_int(&node->config, EPOS_PARAMETER_SENSOR_TYPE),
config_get_int(&node->config, EPOS_PARAMETER_SENSOR_POLARITY),
config_get_int(&node->config, EPOS_PARAMETER_SENSOR_PULSES),
config_get_int(&node->config, EPOS_PARAMETER_SENSOR_SUPERVISION));
epos_motor_init(&node->motor, &node->dev,
config_get_int(&node->config, EPOS_PARAMETER_MOTOR_TYPE),
config_get_float(&node->config, EPOS_PARAMETER_MOTOR_CURRENT));
epos_gear_init(&node->gear, &node->sensor,
config_get_float(&node->config, EPOS_PARAMETER_GEAR_TRANSMISSION));
epos_input_init(&node->input, &node->dev);
epos_control_init(&node->control, &node->dev,
config_get_int(&node->config, EPOS_PARAMETER_CONTROL_TYPE));
}
void collider_config_deserialize(TypeConfig* super, Config* config, char* table) {
ColliderConfig* self = (ColliderConfig*)super;
self->layer = collider_layer_parse(config_get_string(config, table, "layer"));
self->offset = config_get_Vec2(config, table, "offset");
char* volumeStr = config_try_get_string(config, table, "type", NULL);
self->type = BOUNDING_VOLUME_AA_BOX;
if (volumeStr) {
self->type = bounding_volume_type_parse(volumeStr);
}
switch (self->type) {
default:
case BOUNDING_VOLUME_AA_BOX:
self->width = config_get_float(config, table, "width");
self->height = config_get_float(config, table, "height");
break;
case BOUNDING_VOLUME_O_BOX:
self->width = config_get_float(config, table, "width");
self->height = config_get_float(config, table, "height");
self->orientation = config_try_get_float(config, table, "orientation", 0.f);
break;
case BOUNDING_VOLUME_CIRCLE:
self->radius = config_get_float(config, table, "radius");
break;
}
}
void tween_config_deserialize(TypeConfig* super, Config* config, char* table) {
TweenConfig* self = (TweenConfig*)super;
char* tweenFuncName = config_get_string(config, table, "function");
self->function = tween_parse(tweenFuncName);
self->start = config_get_float(config, table, "start");
self->end = config_get_float(config, table, "end");
self->duration = config_get_float(config, table, "duration");
self->timescale = config_try_get_float(config, table, "timescale", 1.f);
self->loops = config_try_get_int(config, table, "loops", TWEEN_LOOP_INFINITE);
}
static int softfilter_get_float(void *userdata, const char *key_str, float *value, float default_value)
{
struct softfilter_userdata *filt = (struct softfilter_userdata*)userdata;
char key[2][256];
snprintf(key[0], sizeof(key[0]), "%s_%s", filt->prefix[0], key_str);
snprintf(key[1], sizeof(key[1]), "%s_%s", filt->prefix[1], key_str);
bool got = config_get_float(filt->conf, key[0], value);
got = got || config_get_float(filt->conf, key[1], value);
if (!got)
*value = default_value;
return got;
}
/**
* video_shader_set_current_parameters:
* @conf : Preset file to read from.
* @shader : Shader passes handle.
*
* Reads the current value for all parameters from config file.
*
* Returns: true (1) if successful, otherwise false (0).
**/
bool video_shader_resolve_current_parameters(config_file_t *conf,
struct video_shader *shader)
{
char parameters[4096];
const char *id = NULL;
char *save = NULL;
if (!conf)
return false;
parameters[0] = '\0';
/* Read in parameters which override the defaults. */
if (!config_get_array(conf, "parameters",
parameters, sizeof(parameters)))
return true;
for (id = strtok_r(parameters, ";", &save); id;
id = strtok_r(NULL, ";", &save))
{
struct video_shader_parameter *parameter = (struct video_shader_parameter*)
video_shader_parse_find_parameter(shader->parameters, shader->num_parameters, id);
if (!parameter)
{
RARCH_WARN("[CGP/GLSLP]: Parameter %s is set in the preset, but no shader uses this parameter, ignoring.\n", id);
continue;
}
if (!config_get_float(conf, id, ¶meter->current))
RARCH_WARN("[CGP/GLSLP]: Parameter %s is not set in preset.\n", id);
}
return true;
}
int config_userdata_get_float(void *userdata, const char *key_str,
float *value, float default_value)
{
bool got;
char key[2][256];
struct config_file_userdata *usr = (struct config_file_userdata*)userdata;
fill_pathname_join_delim(key[0], usr->prefix[0], key_str, '_', sizeof(key[0]));
fill_pathname_join_delim(key[1], usr->prefix[1], key_str, '_', sizeof(key[1]));
got = config_get_float (usr->conf, key[0], value);
got = got || config_get_float(usr->conf, key[1], value);
if (!got)
*value = default_value;
return got;
}
static void video_update_quality(void) {
int vw, vh;
video_get_viewport_size(&vw,&vh);
float q = (float)vh / SCREEN_H;
float fg = q * config_get_float(CONFIG_FG_QUALITY);
float bg = q * config_get_float(CONFIG_BG_QUALITY);
float text = q * config_get_float(CONFIG_TEXT_QUALITY);
log_debug("q:%f, fg:%f, bg:%f, text:%f", q, fg, bg, text);
reinit_fbo(&resources.fbo.bg[0], bg, GL_RGB);
reinit_fbo(&resources.fbo.bg[1], bg, GL_RGB);
reinit_fbo(&resources.fbo.fg[0], fg, GL_RGB);
reinit_fbo(&resources.fbo.fg[1], fg, GL_RGB);
reinit_fbo(&resources.fbo.rgba[0], fg, GL_RGBA);
reinit_fbo(&resources.fbo.rgba[1], fg, GL_RGBA);
reload_fonts(text);
}
int epos_home(epos_node_p node, double timeout) {
epos_home_t home;
epos_home_init(&home,
config_get_int(&node->config, EPOS_PARAMETER_HOME_METHOD),
config_get_float(&node->config, EPOS_PARAMETER_HOME_CURRENT),
deg_to_rad(config_get_float(&node->config, EPOS_PARAMETER_HOME_VELOCITY)),
deg_to_rad(config_get_float(&node->config,
EPOS_PARAMETER_HOME_ACCELERATION)),
deg_to_rad(config_get_float(&node->config, EPOS_PARAMETER_HOME_POSITION)));
home.type = config_get_int(&node->config, EPOS_PARAMETER_HOME_TYPE);
home.offset = deg_to_rad(config_get_float(&node->config,
EPOS_PARAMETER_HOME_OFFSET));
if (!epos_home_start(node, &home)) {
epos_home_wait(node, timeout);
return EPOS_ERROR_NONE;
}
else
return EPOS_ERROR_HOME;
}
int era_move_home(era_arm_p arm, double vel_factor) {
int i;
era_joint_state_t home_state;
double* home_state_a = (double*)&home_state;
config_p config_a = (config_p)&arm->config.joints;
for (i = 0; i < sizeof(era_joint_state_t)/sizeof(double); ++i)
home_state_a[i] = deg_to_rad(config_get_float(&config_a[i],
EPOS_PARAMETER_HOME_POSITION));
return era_move_joints(arm, &home_state, vel_factor);
}
int game_init(void)
{
DEBUG(1, "Initializing game core\n");
level = NULL;
quit = 0;
accel = config_get_float("accel");
drag = config_get_float("drag");
turnaccel = config_get_float("turnaccel");
turndrag = config_get_float("turndrag");
move_forward = move_backward = slide_left =
slide_right = slide_up = slide_down =
turn_left = turn_right = pitch_up =
pitch_down = roll_left = roll_right = 0;
input_register_func("forward", move_forward_func);
input_register_func("reverse", move_backward_func);
input_register_func("slide_left", slide_left_func);
input_register_func("slide_right", slide_right_func);
input_register_func("slide_up", slide_up_func);
input_register_func("slide_down", slide_down_func);
input_register_func("move_x", move_x_func);
input_register_func("move_y", move_y_func);
input_register_func("move_z", move_z_func);
input_register_func("turn_left", turn_left_func);
input_register_func("turn_right", turn_right_func);
input_register_func("pitch_up", pitch_up_func);
input_register_func("pitch_down", pitch_down_func);
input_register_func("roll_left", roll_left_func);
input_register_func("roll_right", roll_right_func);
input_register_func("turn", turn_x_func);
input_register_func("pitch", turn_y_func);
input_register_func("roll", turn_z_func);
input_register_func("rotatexy", turn_xy_func);
input_register_func("exit", quit_func);
input->set_mouse_mode(MOUSE_POINTER);
cam_vel.x = 0.0f;
cam_vel.y = 0.0f;
cam_vel.z = 0.0f;
quat_make_aa(&gfx->get_scene()->camera.orient, 1.0f, 0.0f, 1.0f, 0.0f);
return 0;
}
int main(int argc, char **argv) {
config_parser_t parser;
epos_node_t node;
epos_velocity_t velocity;
config_parser_init_default(&parser, &epos_velocity_default_arguments, 0,
"Start EPOS controller in velocity mode",
"Establish the communication with a connected EPOS device and attempt to "
"start the controller in velocity mode. The controller will be stopped "
"if SIGINT is received. The communication interface depends on the "
"momentarily selected alternative of the underlying CANopen library.");
epos_node_init_config_parse(&node, &parser, 0, argc, argv,
config_parser_exit_error);
float target_value = config_get_float(&parser.arguments,
EPOS_VELOCITY_PARAMETER_VELOCITY);
signal(SIGINT, epos_signaled);
epos_node_connect(&node);
error_exit(&node.error);
epos_velocity_init(&velocity, target_value);
epos_velocity_start(&node, &velocity);
error_exit(&node.dev.error);
while (!quit) {
float actual_value = epos_node_get_velocity(&node);
error_exit(&node.error);
fprintf(stdout, "\rAngular velocity: %8.2f deg/s",
rad_to_deg(actual_value));
fflush(stdout);
}
fprintf(stdout, "\n");
epos_velocity_stop(&node);
error_exit(&node.dev.error);
epos_node_disconnect(&node);
error_exit(&node.error);
epos_node_destroy(&node);
config_parser_destroy(&parser);
return 0;
}
static bool input_overlay_load_overlay(input_overlay_t *ol, config_file_t *conf, const char *config_path,
struct overlay *overlay, unsigned index)
{
size_t i;
char overlay_path_key[64];
char overlay_name_key[64];
char overlay_path[PATH_MAX];
char overlay_resolved_path[PATH_MAX];
snprintf(overlay_path_key, sizeof(overlay_path_key), "overlay%u_overlay", index);
if (config_get_path(conf, overlay_path_key, overlay_path, sizeof(overlay_path)))
{
struct texture_image img = {0};
fill_pathname_resolve_relative(overlay_resolved_path, config_path,
overlay_path, sizeof(overlay_resolved_path));
if (texture_image_load(&img, overlay_resolved_path))
overlay->image = img;
else
{
RARCH_ERR("[Overlay]: Failed to load image: %s.\n", overlay_resolved_path);
return false;
}
}
snprintf(overlay_name_key, sizeof(overlay_name_key), "overlay%u_name", index);
config_get_array(conf, overlay_name_key, overlay->name, sizeof(overlay->name));
// By default, we stretch the overlay out in full.
overlay->x = overlay->y = 0.0f;
overlay->w = overlay->h = 1.0f;
char overlay_rect_key[64];
snprintf(overlay_rect_key, sizeof(overlay_rect_key), "overlay%u_rect", index);
char overlay_rect[256];
if (config_get_array(conf, overlay_rect_key, overlay_rect, sizeof(overlay_rect)))
{
struct string_list *list = string_split(overlay_rect, ", ");
if (list->size < 4)
{
RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n", overlay_rect);
return false;
}
overlay->x = (float)strtod(list->elems[0].data, NULL);
overlay->y = (float)strtod(list->elems[1].data, NULL);
overlay->w = (float)strtod(list->elems[2].data, NULL);
overlay->h = (float)strtod(list->elems[3].data, NULL);
string_list_free(list);
}
char overlay_full_screen_key[64];
snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key),
"overlay%u_full_screen", index);
overlay->full_screen = false;
config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen);
char overlay_descs_key[64];
snprintf(overlay_descs_key, sizeof(overlay_descs_key), "overlay%u_descs", index);
unsigned descs = 0;
if (!config_get_uint(conf, overlay_descs_key, &descs))
{
RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n", overlay_descs_key);
return false;
}
overlay->descs = (struct overlay_desc*)calloc(descs, sizeof(*overlay->descs));
if (!overlay->descs)
{
RARCH_ERR("[Overlay]: Failed to allocate descs.\n");
return false;
}
overlay->size = descs;
char conf_key[64];
bool normalized = false;
snprintf(conf_key, sizeof(conf_key),
"overlay%u_normalized", index);
config_get_bool(conf, conf_key, &normalized);
float alpha_mod = 1.0f;
snprintf(conf_key, sizeof(conf_key), "overlay%u_alpha_mod", index);
config_get_float(conf, conf_key, &alpha_mod);
float range_mod = 1.0f;
snprintf(conf_key, sizeof(conf_key), "overlay%u_range_mod", index);
config_get_float(conf, conf_key, &range_mod);
for (i = 0; i < overlay->size; i++)
{
if (!input_overlay_load_desc(ol, conf, &overlay->descs[i], index, i,
overlay->image.width, overlay->image.height,
normalized, alpha_mod, range_mod))
{
RARCH_ERR("[Overlay]: Failed to load overlay descs for overlay #%u.\n", (unsigned)i);
return false;
}
}
// Precache load image array for simplicity.
overlay->load_images = (struct texture_image*)calloc(1 + overlay->size, sizeof(struct texture_image));
if (!overlay->load_images)
{
RARCH_ERR("[Overlay]: Failed to allocate load_images.\n");
return false;
}
if (overlay->image.pixels)
overlay->load_images[overlay->load_images_size++] = overlay->image;
for (i = 0; i < overlay->size; i++)
{
if (overlay->descs[i].image.pixels)
{
overlay->descs[i].image_index = overlay->load_images_size;
overlay->load_images[overlay->load_images_size++] = overlay->descs[i].image;
}
}
// Assume for now that scaling center is in the middle.
// TODO: Make this configurable.
overlay->block_scale = false;
overlay->center_x = overlay->x + 0.5f * overlay->w;
overlay->center_y = overlay->y + 0.5f * overlay->h;
return true;
}
static bool input_overlay_load_desc(input_overlay_t *ol, config_file_t *conf, struct overlay_desc *desc,
unsigned ol_index, unsigned desc_index,
unsigned width, unsigned height,
bool normalized, float alpha_mod, float range_mod)
{
bool ret = true;
char overlay_desc_key[64];
snprintf(overlay_desc_key, sizeof(overlay_desc_key), "overlay%u_desc%u", ol_index, desc_index);
char overlay_desc_image_key[64];
snprintf(overlay_desc_image_key, sizeof(overlay_desc_image_key),
"overlay%u_desc%u_overlay", ol_index, desc_index);
char image_path[PATH_MAX];
if (config_get_path(conf, overlay_desc_image_key, image_path, sizeof(image_path)))
{
char path[PATH_MAX];
fill_pathname_resolve_relative(path, ol->overlay_path, image_path, sizeof(path));
struct texture_image img = {0};
if (texture_image_load(&img, path))
desc->image = img;
}
char overlay_desc_normalized_key[64];
snprintf(overlay_desc_normalized_key, sizeof(overlay_desc_normalized_key),
"overlay%u_desc%u_normalized", ol_index, desc_index);
config_get_bool(conf, overlay_desc_normalized_key, &normalized);
bool by_pixel = !normalized;
if (by_pixel && (width == 0 || height == 0))
{
RARCH_ERR("[Overlay]: Base overlay is not set and not using normalized coordinates.\n");
return false;
}
char overlay[256];
if (!config_get_array(conf, overlay_desc_key, overlay, sizeof(overlay)))
{
RARCH_ERR("[Overlay]: Didn't find key: %s.\n", overlay_desc_key);
return false;
}
struct string_list *list = string_split(overlay, ", ");
if (!list)
{
RARCH_ERR("[Overlay]: Failed to split overlay desc.\n");
return false;
}
if (list->size < 6)
{
string_list_free(list);
RARCH_ERR("[Overlay]: Overlay desc is invalid. Requires at least 6 tokens.\n");
return false;
}
const char *x = list->elems[1].data;
const char *y = list->elems[2].data;
const char *box = list->elems[3].data;
char *key = list->elems[0].data;
char *save;
desc->key_mask = 0;
if (strcmp(key, "analog_left") == 0)
desc->type = OVERLAY_TYPE_ANALOG_LEFT;
else if (strcmp(key, "analog_right") == 0)
desc->type = OVERLAY_TYPE_ANALOG_RIGHT;
else if (strstr(key, "retrok_") == key)
{
desc->type = OVERLAY_TYPE_KEYBOARD;
desc->key_mask = input_translate_str_to_rk(key + 7);
}
else
{
const char *tmp;
desc->type = OVERLAY_TYPE_BUTTONS;
for (tmp = strtok_r(key, "|", &save); tmp; tmp = strtok_r(NULL, "|", &save))
{
if (strcmp(tmp, "nul") != 0)
desc->key_mask |= UINT64_C(1) << input_translate_str_to_bind_id(tmp);
}
if (desc->key_mask & (UINT64_C(1) << RARCH_OVERLAY_NEXT))
{
char overlay_target_key[64];
snprintf(overlay_target_key, sizeof(overlay_target_key), "overlay%u_desc%u_next_target", ol_index, desc_index);
config_get_array(conf, overlay_target_key, desc->next_index_name, sizeof(desc->next_index_name));
}
}
float width_mod = by_pixel ? (1.0f / width) : 1.0f;
float height_mod = by_pixel ? (1.0f / height) : 1.0f;
desc->x = (float)strtod(x, NULL) * width_mod;
desc->y = (float)strtod(y, NULL) * height_mod;
if (!strcmp(box, "radial"))
desc->hitbox = OVERLAY_HITBOX_RADIAL;
else if (!strcmp(box, "rect"))
desc->hitbox = OVERLAY_HITBOX_RECT;
else
{
RARCH_ERR("[Overlay]: Hitbox type (%s) is invalid. Use \"radial\" or \"rect\".\n", box);
ret = false;
goto end;
}
if (desc->type == OVERLAY_TYPE_ANALOG_LEFT || desc->type == OVERLAY_TYPE_ANALOG_RIGHT)
{
if (desc->hitbox != OVERLAY_HITBOX_RADIAL)
{
RARCH_ERR("[Overlay]: Analog hitbox type must be \"radial\".\n");
ret = false;
goto end;
}
char overlay_analog_saturate_key[64];
snprintf(overlay_analog_saturate_key, sizeof(overlay_analog_saturate_key), "overlay%u_desc%u_saturate_pct", ol_index, desc_index);
if (!config_get_float(conf, overlay_analog_saturate_key, &desc->analog_saturate_pct))
desc->analog_saturate_pct = 1.0f;
}
desc->range_x = (float)strtod(list->elems[4].data, NULL) * width_mod;
desc->range_y = (float)strtod(list->elems[5].data, NULL) * height_mod;
desc->mod_x = desc->x - desc->range_x;
desc->mod_w = 2.0f * desc->range_x;
desc->mod_y = desc->y - desc->range_y;
desc->mod_h = 2.0f * desc->range_y;
char conf_key[64];
snprintf(conf_key, sizeof(conf_key), "overlay%u_desc%u_alpha_mod", ol_index, desc_index);
desc->alpha_mod = alpha_mod;
config_get_float(conf, conf_key, &desc->alpha_mod);
snprintf(conf_key, sizeof(conf_key), "overlay%u_desc%u_range_mod", ol_index, desc_index);
desc->range_mod = range_mod;
config_get_float(conf, conf_key, &desc->range_mod);
snprintf(conf_key, sizeof(conf_key), "overlay%u_desc%u_movable", ol_index, desc_index);
desc->movable = false;
desc->delta_x = 0.0f;
desc->delta_y = 0.0f;
config_get_bool(conf, conf_key, &desc->movable);
desc->range_x_mod = desc->range_x;
desc->range_y_mod = desc->range_y;
end:
if (list)
string_list_free(list);
return ret;
}
/**
* video_shader_parse_pass:
* @conf : Preset file to read from.
* @pass : Shader passes handle.
* @i : Index of shader pass.
*
* Parses shader pass from preset file.
*
* Returns: true (1) if successful, otherwise false (0).
**/
static bool video_shader_parse_pass(config_file_t *conf,
struct video_shader_pass *pass, unsigned i)
{
char shader_name[64];
char filter_name_buf[64];
char wrap_name_buf[64];
char wrap_mode[64];
char frame_count_mod_buf[64];
char srgb_output_buf[64];
char fp_fbo_buf[64];
char mipmap_buf[64];
char alias_buf[64];
char scale_name_buf[64];
char attr_name_buf[64];
char scale_type[64];
char scale_type_x[64];
char scale_type_y[64];
char frame_count_mod[64];
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
char *tmp_str = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *tmp_path = NULL;
struct gfx_fbo_scale *scale = NULL;
bool tmp_bool = false;
float fattr = 0.0f;
int iattr = 0;
fp_fbo_buf[0] = mipmap_buf[0] = alias_buf[0] =
scale_name_buf[0] = attr_name_buf[0] = scale_type[0] =
scale_type_x[0] = scale_type_y[0] = frame_count_mod[0] =
tmp_str[0] = shader_name[0] = filter_name_buf[0] =
wrap_name_buf[0] = wrap_mode[0] = frame_count_mod_buf[0] = '\0';
srgb_output_buf[0] = '\0';
/* Source */
snprintf(shader_name, sizeof(shader_name), "shader%u", i);
if (!config_get_path(conf, shader_name, tmp_str, path_size))
{
RARCH_ERR("Couldn't parse shader source (%s).\n", shader_name);
goto error;
}
tmp_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
strlcpy(tmp_path, tmp_str, path_size);
path_resolve_realpath(tmp_path, path_size);
if (!filestream_exists(tmp_path))
strlcpy(pass->source.path, tmp_str, sizeof(pass->source.path));
else
strlcpy(pass->source.path, tmp_path, sizeof(pass->source.path));
free(tmp_path);
/* Smooth */
snprintf(filter_name_buf, sizeof(filter_name_buf), "filter_linear%u", i);
if (config_get_bool(conf, filter_name_buf, &tmp_bool))
{
bool smooth = tmp_bool;
pass->filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST;
}
else
pass->filter = RARCH_FILTER_UNSPEC;
/* Wrapping mode */
snprintf(wrap_name_buf, sizeof(wrap_name_buf), "wrap_mode%u", i);
if (config_get_array(conf, wrap_name_buf, wrap_mode, sizeof(wrap_mode)))
pass->wrap = wrap_str_to_mode(wrap_mode);
/* Frame count mod */
snprintf(frame_count_mod_buf, sizeof(frame_count_mod_buf), "frame_count_mod%u", i);
if (config_get_array(conf, frame_count_mod_buf,
frame_count_mod, sizeof(frame_count_mod)))
pass->frame_count_mod = (unsigned)strtoul(frame_count_mod, NULL, 0);
/* FBO types and mipmapping */
snprintf(srgb_output_buf, sizeof(srgb_output_buf), "srgb_framebuffer%u", i);
if (config_get_bool(conf, srgb_output_buf, &tmp_bool))
pass->fbo.srgb_fbo = tmp_bool;
snprintf(fp_fbo_buf, sizeof(fp_fbo_buf), "float_framebuffer%u", i);
if (config_get_bool(conf, fp_fbo_buf, &tmp_bool))
pass->fbo.fp_fbo = tmp_bool;
snprintf(mipmap_buf, sizeof(mipmap_buf), "mipmap_input%u", i);
if (config_get_bool(conf, mipmap_buf, &tmp_bool))
pass->mipmap = tmp_bool;
snprintf(alias_buf, sizeof(alias_buf), "alias%u", i);
if (!config_get_array(conf, alias_buf, pass->alias, sizeof(pass->alias)))
*pass->alias = '\0';
/* Scale */
scale = &pass->fbo;
snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type%u", i);
config_get_array(conf, scale_name_buf, scale_type, sizeof(scale_type));
snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_x%u", i);
config_get_array(conf, scale_name_buf, scale_type_x, sizeof(scale_type_x));
snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_y%u", i);
config_get_array(conf, scale_name_buf, scale_type_y, sizeof(scale_type_y));
if (!*scale_type && !*scale_type_x && !*scale_type_y)
{
free(tmp_str);
return true;
}
if (*scale_type)
{
strlcpy(scale_type_x, scale_type, sizeof(scale_type_x));
strlcpy(scale_type_y, scale_type, sizeof(scale_type_y));
}
scale->valid = true;
scale->type_x = RARCH_SCALE_INPUT;
scale->type_y = RARCH_SCALE_INPUT;
scale->scale_x = 1.0;
scale->scale_y = 1.0;
if (*scale_type_x)
{
if (string_is_equal(scale_type_x, "source"))
scale->type_x = RARCH_SCALE_INPUT;
else if (string_is_equal(scale_type_x, "viewport"))
scale->type_x = RARCH_SCALE_VIEWPORT;
else if (string_is_equal(scale_type_x, "absolute"))
scale->type_x = RARCH_SCALE_ABSOLUTE;
else
{
RARCH_ERR("Invalid attribute.\n");
goto error;
}
}
if (*scale_type_y)
{
if (string_is_equal(scale_type_y, "source"))
scale->type_y = RARCH_SCALE_INPUT;
else if (string_is_equal(scale_type_y, "viewport"))
scale->type_y = RARCH_SCALE_VIEWPORT;
else if (string_is_equal(scale_type_y, "absolute"))
scale->type_y = RARCH_SCALE_ABSOLUTE;
else
{
RARCH_ERR("Invalid attribute.\n");
goto error;
}
}
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i);
if (scale->type_x == RARCH_SCALE_ABSOLUTE)
{
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_x = iattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_x = iattr;
}
}
else
{
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_x = fattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_x = fattr;
}
}
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i);
if (scale->type_y == RARCH_SCALE_ABSOLUTE)
{
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_y = iattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_y = iattr;
}
}
else
{
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_y = fattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_y = fattr;
}
}
free(tmp_str);
return true;
error:
free(tmp_str);
return false;
}
static bool input_overlay_load_desc(config_file_t *conf, struct overlay_desc *desc,
unsigned ol_index, unsigned desc_index,
unsigned width, unsigned height)
{
bool ret = true;
char overlay_desc_key[64];
snprintf(overlay_desc_key, sizeof(overlay_desc_key), "overlay%u_desc%u", ol_index, desc_index);
char overlay[256];
if (!config_get_array(conf, overlay_desc_key, overlay, sizeof(overlay)))
{
RARCH_ERR("[Overlay]: Didn't find key: %s.\n", overlay_desc_key);
return false;
}
struct string_list *list = string_split(overlay, ", ");
if (!list)
{
RARCH_ERR("[Overlay]: Failed to split overlay desc.\n");
return false;
}
if (list->size < 6)
{
string_list_free(list);
RARCH_ERR("[Overlay]: Overlay desc is invalid. Requires at least 6 tokens.\n");
return false;
}
const char *x = list->elems[1].data;
const char *y = list->elems[2].data;
const char *box = list->elems[3].data;
char *key = list->elems[0].data;
char *save;
desc->key_mask = 0;
if (strcmp(key, "analog_left") == 0)
desc->type = OVERLAY_TYPE_ANALOG_LEFT;
else if (strcmp(key, "analog_right") == 0)
desc->type = OVERLAY_TYPE_ANALOG_RIGHT;
else
{
desc->type = OVERLAY_TYPE_BUTTONS;
for (const char *tmp = strtok_r(key, "|", &save); tmp; tmp = strtok_r(NULL, "|", &save))
desc->key_mask |= UINT64_C(1) << input_str_to_bind(tmp);
if (desc->key_mask & (UINT64_C(1) << RARCH_OVERLAY_NEXT))
{
char overlay_target_key[64];
snprintf(overlay_target_key, sizeof(overlay_target_key), "overlay%u_desc%u_next_target", ol_index, desc_index);
config_get_array(conf, overlay_target_key, desc->next_index_name, sizeof(desc->next_index_name));
}
}
desc->x = strtod(x, NULL) / width;
desc->y = strtod(y, NULL) / height;
if (!strcmp(box, "radial"))
desc->hitbox = OVERLAY_HITBOX_RADIAL;
else if (!strcmp(box, "rect"))
desc->hitbox = OVERLAY_HITBOX_RECT;
else
{
RARCH_ERR("[Overlay]: Hitbox type (%s) is invalid. Use \"radial\" or \"rect\".\n", box);
ret = false;
goto end;
}
if (desc->type != OVERLAY_TYPE_BUTTONS)
{
if (desc->hitbox != OVERLAY_HITBOX_RADIAL)
{
RARCH_ERR("[Overlay]: Analog hitbox type must be \"radial\".\n");
ret = false;
goto end;
}
char overlay_analog_saturate_key[64];
snprintf(overlay_analog_saturate_key, sizeof(overlay_analog_saturate_key), "overlay%u_desc%u_saturate_pct", ol_index, desc_index);
if (!config_get_float(conf, overlay_analog_saturate_key, &desc->analog_saturate_pct))
desc->analog_saturate_pct = 1.0f;
}
desc->range_x = strtod(list->elems[4].data, NULL) / width;
desc->range_y = strtod(list->elems[5].data, NULL) / height;
end:
if (list)
string_list_free(list);
return ret;
}
static void turn_xy_func(const struct input_event *event)
{
mouseturn_x = event->x * config_get_float("mousesensx");
mouseturn_y = event->y * config_get_float("mousesensy");
}
/**
* video_shader_parse_pass:
* @conf : Preset file to read from.
* @pass : Shader passes handle.
* @i : Index of shader pass.
*
* Parses shader pass from preset file.
*
* Returns: true (1) if successful, otherwise false (0).
**/
static bool video_shader_parse_pass(config_file_t *conf, struct video_shader_pass *pass, unsigned i)
{
char shader_name[64] = {0};
char filter_name_buf[64] = {0};
char wrap_name_buf[64] = {0};
char wrap_mode[64] = {0};
char frame_count_mod_buf[64] = {0};
char srgb_output_buf[64] = {0};
char fp_fbo_buf[64] = {0};
char mipmap_buf[64] = {0};
char alias_buf[64] = {0};
char scale_name_buf[64] = {0};
char attr_name_buf[64] = {0};
char scale_type[64] = {0};
char scale_type_x[64] = {0};
char scale_type_y[64] = {0};
char frame_count_mod[64] = {0};
struct gfx_fbo_scale *scale = NULL;
bool smooth = false;
float fattr = 0.0f;
int iattr = 0;
/* Source */
snprintf(shader_name, sizeof(shader_name), "shader%u", i);
if (!config_get_path(conf, shader_name, pass->source.path, sizeof(pass->source.path)))
{
RARCH_ERR("Couldn't parse shader source (%s).\n", shader_name);
return false;
}
/* Smooth */
snprintf(filter_name_buf, sizeof(filter_name_buf), "filter_linear%u", i);
if (config_get_bool(conf, filter_name_buf, &smooth))
pass->filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST;
else
pass->filter = RARCH_FILTER_UNSPEC;
/* Wrapping mode */
snprintf(wrap_name_buf, sizeof(wrap_name_buf), "wrap_mode%u", i);
if (config_get_array(conf, wrap_name_buf, wrap_mode, sizeof(wrap_mode)))
pass->wrap = wrap_str_to_mode(wrap_mode);
/* Frame count mod */
snprintf(frame_count_mod_buf, sizeof(frame_count_mod_buf), "frame_count_mod%u", i);
if (config_get_array(conf, frame_count_mod_buf,
frame_count_mod, sizeof(frame_count_mod)))
pass->frame_count_mod = strtoul(frame_count_mod, NULL, 0);
/* FBO types and mipmapping */
snprintf(srgb_output_buf, sizeof(srgb_output_buf), "srgb_framebuffer%u", i);
config_get_bool(conf, srgb_output_buf, &pass->fbo.srgb_fbo);
snprintf(fp_fbo_buf, sizeof(fp_fbo_buf), "float_framebuffer%u", i);
config_get_bool(conf, fp_fbo_buf, &pass->fbo.fp_fbo);
snprintf(mipmap_buf, sizeof(mipmap_buf), "mipmap_input%u", i);
config_get_bool(conf, mipmap_buf, &pass->mipmap);
snprintf(alias_buf, sizeof(alias_buf), "alias%u", i);
if (!config_get_array(conf, alias_buf, pass->alias, sizeof(pass->alias)))
*pass->alias = '\0';
/* Scale */
scale = &pass->fbo;
snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type%u", i);
config_get_array(conf, scale_name_buf, scale_type, sizeof(scale_type));
snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_x%u", i);
config_get_array(conf, scale_name_buf, scale_type_x, sizeof(scale_type_x));
snprintf(scale_name_buf, sizeof(scale_name_buf), "scale_type_y%u", i);
config_get_array(conf, scale_name_buf, scale_type_y, sizeof(scale_type_y));
if (!*scale_type && !*scale_type_x && !*scale_type_y)
return true;
if (*scale_type)
{
strlcpy(scale_type_x, scale_type, sizeof(scale_type_x));
strlcpy(scale_type_y, scale_type, sizeof(scale_type_y));
}
scale->valid = true;
scale->type_x = RARCH_SCALE_INPUT;
scale->type_y = RARCH_SCALE_INPUT;
scale->scale_x = 1.0;
scale->scale_y = 1.0;
if (*scale_type_x)
{
uint32_t scale_type_x_hash = djb2_calculate(scale_type_x);
switch (scale_type_x_hash)
{
case SCALE_TYPE_SOURCE:
scale->type_x = RARCH_SCALE_INPUT;
break;
case SCALE_TYPE_VIEWPORT:
scale->type_x = RARCH_SCALE_VIEWPORT;
break;
case SCALE_TYPE_ABSOLUTE:
scale->type_x = RARCH_SCALE_ABSOLUTE;
break;
default:
RARCH_ERR("Invalid attribute.\n");
return false;
}
}
if (*scale_type_y)
{
uint32_t scale_type_y_hash = djb2_calculate(scale_type_y);
switch (scale_type_y_hash)
{
case SCALE_TYPE_SOURCE:
scale->type_y = RARCH_SCALE_INPUT;
break;
case SCALE_TYPE_VIEWPORT:
scale->type_y = RARCH_SCALE_VIEWPORT;
break;
case SCALE_TYPE_ABSOLUTE:
scale->type_y = RARCH_SCALE_ABSOLUTE;
break;
default:
RARCH_ERR("Invalid attribute.\n");
return false;
}
}
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i);
if (scale->type_x == RARCH_SCALE_ABSOLUTE)
{
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_x = iattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_x = iattr;
}
}
else
{
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_x = fattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_x%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_x = fattr;
}
}
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale%u", i);
if (scale->type_y == RARCH_SCALE_ABSOLUTE)
{
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_y = iattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_y = iattr;
}
}
else
{
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_y = fattr;
else
{
snprintf(attr_name_buf, sizeof(attr_name_buf), "scale_y%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_y = fattr;
}
}
return true;
}
/* reads and parses configuration file */
static int
process_configfile(char *configfile)
{
debug(RPT_DEBUG, "%s()", __FUNCTION__);
/* Read server settings*/
if (config_read_file(configfile) != 0) {
report(RPT_CRIT, "Could not read config file: %s", configfile);
return -1;
}
if (bind_port == UNSET_INT)
bind_port = config_get_int("Server", "Port", 0, UNSET_INT);
if (strcmp(bind_addr, UNSET_STR) == 0)
strncpy(bind_addr, config_get_string("Server", "Bind", 0, UNSET_STR), sizeof(bind_addr));
if (strcmp(user, UNSET_STR) == 0)
strncpy(user, config_get_string("Server", "User", 0, UNSET_STR), sizeof(user));
if (default_duration == UNSET_INT) {
default_duration = (config_get_float("Server", "WaitTime", 0, 0) * 1e6 / TIME_UNIT);
if (default_duration == 0)
default_duration = UNSET_INT;
else if (default_duration * TIME_UNIT < 2e6) {
report(RPT_WARNING, "Waittime should be at least 2 (seconds). Set to 2 seconds.");
default_duration = 2e6 / TIME_UNIT;
}
}
if (foreground_mode == UNSET_INT) {
int fg = config_get_bool("Server", "Foreground", 0, UNSET_INT);
if (fg != UNSET_INT)
foreground_mode = fg;
}
if (rotate_server_screen == UNSET_INT) {
rotate_server_screen = config_get_tristate("Server", "ServerScreen", 0, "blank", UNSET_INT);
}
if (backlight == UNSET_INT) {
backlight = config_get_tristate("Server", "Backlight", 0, "open", UNSET_INT);
}
if (heartbeat == UNSET_INT) {
heartbeat = config_get_tristate("Server", "Heartbeat", 0, "open", UNSET_INT);
}
if (autorotate == UNSET_INT) {
autorotate = config_get_bool("Server", "AutoRotate", 0, DEFAULT_AUTOROTATE);
}
if (titlespeed == UNSET_INT) {
int speed = config_get_int("Server", "TitleSpeed", 0, DEFAULT_TITLESPEED);
/* set titlespeed */
titlespeed = (speed <= TITLESPEED_NO)
? TITLESPEED_NO
: min(speed, TITLESPEED_MAX);
}
if (report_dest == UNSET_INT) {
int rs = config_get_bool("Server", "ReportToSyslog", 0, UNSET_INT);
if (rs != UNSET_INT)
report_dest = (rs) ? RPT_DEST_SYSLOG : RPT_DEST_STDERR;
}
if (report_level == UNSET_INT) {
report_level = config_get_int("Server", "ReportLevel", 0, UNSET_INT);
}
/* Read drivers */
/* If drivers have been specified on the command line, then do not
* use the driver list from the config file.
*/
if (num_drivers == 0) {
/* loop over all the Driver= directives to read the driver names */
while (1) {
const char *s = config_get_string("Server", "Driver", num_drivers, NULL);
if (s == NULL)
break;
if (s[0] != '\0') {
drivernames[num_drivers] = strdup(s);
if (drivernames[num_drivers] == NULL) {
report(RPT_ERR, "alloc error storing driver name: %s", s);
exit(EXIT_FAILURE);
}
num_drivers++;
}
}
}
return 0;
}
// CGP
static bool shader_parse_pass(config_file_t *conf, struct gfx_shader_pass *pass, unsigned i)
{
// Source
char shader_name[64];
print_buf(shader_name, "shader%u", i);
if (!config_get_path(conf, shader_name, pass->source.path, sizeof(pass->source.path)))
{
RARCH_ERR("Couldn't parse shader source (%s).\n", shader_name);
return false;
}
// Smooth
char filter_name_buf[64];
print_buf(filter_name_buf, "filter_linear%u", i);
bool smooth = false;
if (config_get_bool(conf, filter_name_buf, &smooth))
pass->filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST;
else
pass->filter = RARCH_FILTER_UNSPEC;
// Wrapping mode
char wrap_name_buf[64];
print_buf(wrap_name_buf, "wrap_mode%u", i);
char wrap_mode[64];
if (config_get_array(conf, wrap_name_buf, wrap_mode, sizeof(wrap_mode)))
pass->wrap = wrap_str_to_mode(wrap_mode);
// Frame count mod
char frame_count_mod[64] = {0};
char frame_count_mod_buf[64];
print_buf(frame_count_mod_buf, "frame_count_mod%u", i);
if (config_get_array(conf, frame_count_mod_buf, frame_count_mod, sizeof(frame_count_mod)))
pass->frame_count_mod = strtoul(frame_count_mod, NULL, 0);
// FBO types and mipmapping
char srgb_output_buf[64];
print_buf(srgb_output_buf, "srgb_framebuffer%u", i);
config_get_bool(conf, srgb_output_buf, &pass->fbo.srgb_fbo);
char fp_fbo_buf[64];
print_buf(fp_fbo_buf, "float_framebuffer%u", i);
config_get_bool(conf, fp_fbo_buf, &pass->fbo.fp_fbo);
char mipmap_buf[64];
print_buf(mipmap_buf, "mipmap_input%u", i);
config_get_bool(conf, mipmap_buf, &pass->mipmap);
// Scale
struct gfx_fbo_scale *scale = &pass->fbo;
char scale_type[64] = {0};
char scale_type_x[64] = {0};
char scale_type_y[64] = {0};
char scale_name_buf[64];
print_buf(scale_name_buf, "scale_type%u", i);
config_get_array(conf, scale_name_buf, scale_type, sizeof(scale_type));
print_buf(scale_name_buf, "scale_type_x%u", i);
config_get_array(conf, scale_name_buf, scale_type_x, sizeof(scale_type_x));
print_buf(scale_name_buf, "scale_type_y%u", i);
config_get_array(conf, scale_name_buf, scale_type_y, sizeof(scale_type_y));
if (!*scale_type && !*scale_type_x && !*scale_type_y)
return true;
if (*scale_type)
{
strlcpy(scale_type_x, scale_type, sizeof(scale_type_x));
strlcpy(scale_type_y, scale_type, sizeof(scale_type_y));
}
char attr_name_buf[64];
float fattr = 0.0f;
int iattr = 0;
scale->valid = true;
scale->type_x = RARCH_SCALE_INPUT;
scale->type_y = RARCH_SCALE_INPUT;
scale->scale_x = 1.0;
scale->scale_y = 1.0;
if (*scale_type_x)
{
if (strcmp(scale_type_x, "source") == 0)
scale->type_x = RARCH_SCALE_INPUT;
else if (strcmp(scale_type_x, "viewport") == 0)
scale->type_x = RARCH_SCALE_VIEWPORT;
else if (strcmp(scale_type_x, "absolute") == 0)
scale->type_x = RARCH_SCALE_ABSOLUTE;
else
{
RARCH_ERR("Invalid attribute.\n");
return false;
}
}
if (*scale_type_y)
{
if (strcmp(scale_type_y, "source") == 0)
scale->type_y = RARCH_SCALE_INPUT;
else if (strcmp(scale_type_y, "viewport") == 0)
scale->type_y = RARCH_SCALE_VIEWPORT;
else if (strcmp(scale_type_y, "absolute") == 0)
scale->type_y = RARCH_SCALE_ABSOLUTE;
else
{
RARCH_ERR("Invalid attribute.\n");
return false;
}
}
if (scale->type_x == RARCH_SCALE_ABSOLUTE)
{
print_buf(attr_name_buf, "scale%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_x = iattr;
else
{
print_buf(attr_name_buf, "scale_x%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_x = iattr;
}
}
else
{
print_buf(attr_name_buf, "scale%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_x = fattr;
else
{
print_buf(attr_name_buf, "scale_x%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_x = fattr;
}
}
if (scale->type_y == RARCH_SCALE_ABSOLUTE)
{
print_buf(attr_name_buf, "scale%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_y = iattr;
else
{
print_buf(attr_name_buf, "scale_y%u", i);
if (config_get_int(conf, attr_name_buf, &iattr))
scale->abs_y = iattr;
}
}
else
{
print_buf(attr_name_buf, "scale%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_y = fattr;
else
{
print_buf(attr_name_buf, "scale_y%u", i);
if (config_get_float(conf, attr_name_buf, &fattr))
scale->scale_y = fattr;
}
}
return true;
}
/**
* video_shader_resolve_parameters:
* @conf : Preset file to read from.
* @shader : Shader passes handle.
*
* Resolves all shader parameters belonging to shaders.
*
* Returns: true (1) if successful, otherwise false (0).
**/
bool video_shader_resolve_parameters(config_file_t *conf,
struct video_shader *shader)
{
unsigned i;
struct video_shader_parameter *param =
&shader->parameters[shader->num_parameters];
shader->num_parameters = 0;
/* Find all parameters in our shaders. */
for (i = 0; i < shader->passes; i++)
{
char line[4096] = {0};
FILE *file = fopen(shader->pass[i].source.path, "r");
if (!file)
continue;
while (shader->num_parameters < ARRAY_SIZE(shader->parameters)
&& fgets(line, sizeof(line), file))
{
int ret = sscanf(line,
"#pragma parameter %63s \"%63[^\"]\" %f %f %f %f",
param->id, param->desc, ¶m->initial,
¶m->minimum, ¶m->maximum, ¶m->step);
if (ret < 5)
continue;
param->id[63] = '\0';
param->desc[63] = '\0';
if (ret == 5)
param->step = 0.1f * (param->maximum - param->minimum);
RARCH_LOG("Found #pragma parameter %s (%s) %f %f %f %f\n",
param->desc, param->id, param->initial,
param->minimum, param->maximum, param->step);
param->current = param->initial;
shader->num_parameters++;
param++;
}
fclose(file);
}
if (conf)
{
/* Read in parameters which override the defaults. */
char parameters[4096] = {0};
const char *id = NULL;
char *save = NULL;
if (!config_get_array(conf, "parameters",
parameters, sizeof(parameters)))
return true;
for (id = strtok_r(parameters, ";", &save); id;
id = strtok_r(NULL, ";", &save))
{
struct video_shader_parameter *parameter = (struct video_shader_parameter*)
video_shader_parse_find_parameter(shader->parameters, shader->num_parameters, id);
if (!parameter)
{
RARCH_WARN("[CGP/GLSLP]: Parameter %s is set in the preset, but no shader uses this parameter, ignoring.\n", id);
continue;
}
if (!config_get_float(conf, id, ¶meter->current))
RARCH_WARN("[CGP/GLSLP]: Parameter %s is not set in preset.\n", id);
}
}
return true;
}
bool input_overlay_load_overlays(input_overlay_t *ol)
{
unsigned i;
config_file_t *conf = NULL;
if (!ol)
return false;
conf = config_file_new(ol->overlay_path);
if (!conf)
{
RARCH_ERR("Failed to load config file: %s.\n", ol->overlay_path);
return false;
}
if (!config_get_uint(conf, "overlays", &ol->config.overlays.size))
{
RARCH_ERR("overlays variable not defined in config.\n");
goto error;
}
if (!ol->config.overlays.size)
goto error;
ol->overlays = (struct overlay*)calloc(
ol->config.overlays.size, sizeof(*ol->overlays));
if (!ol->overlays)
goto error;
ol->size = ol->config.overlays.size;
ol->pos = 0;
ol->resolve_pos = 0;
for (i = 0; i < ol->size; i++)
{
char conf_key[64];
char overlay_full_screen_key[64];
struct overlay *overlay = &ol->overlays[i];
if (!overlay)
continue;
snprintf(overlay->config.descs.key,
sizeof(overlay->config.descs.key), "overlay%u_descs", i);
if (!config_get_uint(conf, overlay->config.descs.key, &overlay->config.descs.size))
{
RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n",
overlay->config.descs.key);
goto error;
}
overlay->descs = (struct overlay_desc*)
calloc(overlay->config.descs.size, sizeof(*overlay->descs));
if (!overlay->descs)
{
RARCH_ERR("[Overlay]: Failed to allocate descs.\n");
goto error;
}
overlay->size = overlay->config.descs.size;
snprintf(overlay_full_screen_key, sizeof(overlay_full_screen_key),
"overlay%u_full_screen", i);
overlay->full_screen = false;
config_get_bool(conf, overlay_full_screen_key, &overlay->full_screen);
overlay->config.normalized = false;
overlay->config.alpha_mod = 1.0f;
overlay->config.range_mod = 1.0f;
snprintf(conf_key, sizeof(conf_key),
"overlay%u_normalized", i);
config_get_bool(conf, conf_key, &overlay->config.normalized);
snprintf(conf_key, sizeof(conf_key), "overlay%u_alpha_mod", i);
config_get_float(conf, conf_key, &overlay->config.alpha_mod);
snprintf(conf_key, sizeof(conf_key), "overlay%u_range_mod", i);
config_get_float(conf, conf_key, &overlay->config.range_mod);
/* Precache load image array for simplicity. */
overlay->load_images = (struct texture_image*)
calloc(1 + overlay->size, sizeof(struct texture_image));
if (!overlay->load_images)
{
RARCH_ERR("[Overlay]: Failed to allocate load_images.\n");
goto error;
}
snprintf(overlay->config.paths.key, sizeof(overlay->config.paths.key),
"overlay%u_overlay", i);
config_get_path(conf, overlay->config.paths.key,
overlay->config.paths.path, sizeof(overlay->config.paths.path));
if (overlay->config.paths.path[0] != '\0')
{
char overlay_resolved_path[PATH_MAX_LENGTH];
struct texture_image img = {0};
fill_pathname_resolve_relative(overlay_resolved_path, ol->overlay_path,
overlay->config.paths.path, sizeof(overlay_resolved_path));
if (!texture_image_load(&img, overlay_resolved_path))
{
RARCH_ERR("[Overlay]: Failed to load image: %s.\n",
overlay_resolved_path);
ol->loading_status = OVERLAY_IMAGE_TRANSFER_ERROR;
goto error;
}
overlay->image = img;
}
snprintf(overlay->config.names.key, sizeof(overlay->config.names.key),
"overlay%u_name", i);
config_get_array(conf, overlay->config.names.key,
overlay->name, sizeof(overlay->name));
/* By default, we stretch the overlay out in full. */
overlay->x = overlay->y = 0.0f;
overlay->w = overlay->h = 1.0f;
snprintf(overlay->config.rect.key, sizeof(overlay->config.rect.key),
"overlay%u_rect", i);
if (config_get_array(conf, overlay->config.rect.key,
overlay->config.rect.array, sizeof(overlay->config.rect.array)))
{
struct string_list *list = string_split(overlay->config.rect.array, ", ");
if (!list || list->size < 4)
{
RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n",
overlay->config.rect.array);
string_list_free(list);
goto error;
}
overlay->x = (float)strtod(list->elems[0].data, NULL);
overlay->y = (float)strtod(list->elems[1].data, NULL);
overlay->w = (float)strtod(list->elems[2].data, NULL);
overlay->h = (float)strtod(list->elems[3].data, NULL);
string_list_free(list);
}
/* Assume for now that scaling center is in the middle.
* TODO: Make this configurable. */
overlay->block_scale = false;
overlay->center_x = overlay->x + 0.5f * overlay->w;
overlay->center_y = overlay->y + 0.5f * overlay->h;
}
ol->state = OVERLAY_STATUS_DEFERRED_LOADING;
config_file_free(conf);
return true;
error:
config_file_free(conf);
ol->state = OVERLAY_STATUS_DEFERRED_ERROR;
return false;
}
