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; }