static bool setup_video(ext_t *ext, const video_info_t *video, const input_driver_t **input, void **input_data)
{
RARCH_LOG("Loaded driver: \"%s\"\n", ext->driver->ident ? ext->driver->ident : "Unknown");
if (RARCH_GRAPHICS_API_VERSION != ext->driver->api_version)
{
RARCH_ERR("API version mismatch detected.\n");
RARCH_ERR("Required API version: %d, Library version: %d\n", RARCH_GRAPHICS_API_VERSION, ext->driver->api_version);
return false;
}
const char *cg_shader = NULL;
const char *xml_shader = NULL;
enum rarch_shader_type type = g_settings.video.shader_type;
if ((type == RARCH_SHADER_CG || type == RARCH_SHADER_AUTO) && *g_settings.video.cg_shader_path)
cg_shader = g_settings.video.cg_shader_path;
else if ((type == RARCH_SHADER_BSNES || type == RARCH_SHADER_AUTO) && *g_settings.video.bsnes_shader_path)
xml_shader = g_settings.video.bsnes_shader_path;
int font_color_r = g_settings.video.msg_color_r * 255;
int font_color_g = g_settings.video.msg_color_g * 255;
int font_color_b = g_settings.video.msg_color_b * 255;
font_color_r = font_color_r > 255 ? 255 : (font_color_r < 0 ? 0 : font_color_r);
font_color_g = font_color_g > 255 ? 255 : (font_color_g < 0 ? 0 : font_color_g);
font_color_b = font_color_b > 255 ? 255 : (font_color_b < 0 ? 0 : font_color_b);
const char *font = NULL;
if (g_settings.video.font_enable)
{
#ifdef HAVE_FREETYPE
if (*g_settings.video.font_path)
font = g_settings.video.font_path;
else
font = font_renderer_get_default_font();
#else
font = *g_settings.video.font_path ?
g_settings.video.font_path : NULL;
#endif
}
char title_buf[128];
gfx_window_title_reset();
gfx_window_title(title_buf, sizeof(title_buf));
rarch_video_info_t info = {0};
info.width = video->width;
info.height = video->height;
info.fullscreen = video->fullscreen;
info.vsync = video->vsync;
info.force_aspect = video->force_aspect;
info.aspect_ratio = g_settings.video.aspect_ratio;
info.smooth = video->smooth;
info.input_scale = video->input_scale;
info.color_format = video->rgb32 ? RARCH_COLOR_FORMAT_ARGB8888 : RARCH_COLOR_FORMAT_XRGB1555;
info.xml_shader = xml_shader;
info.cg_shader = cg_shader;
info.ttf_font = font;
info.ttf_font_size = g_settings.video.font_size;
info.ttf_font_color = (font_color_r << 16) | (font_color_g << 8) | (font_color_b << 0);
info.title_hint = title_buf;
#ifdef HAVE_PYTHON
info.python_state_new = py_state_new;
info.python_state_get = py_state_get;
info.python_state_free = py_state_free;
#endif
const rarch_input_driver_t *input_driver = NULL;
ext->handle = ext->driver->init(&info, &input_driver);
if (!ext->handle)
return false;
*input = input_driver ? &input_ext : NULL;
if (input_driver)
*input_data = setup_input(ext, input_driver);
else
*input_data = NULL;
return true;
}
inline
pid_t
posix_start(const Executable& exe,
const Arguments& args,
const environment& env,
info_map& infoin,
info_map& infoout,
const posix_setup& setup)
{
pid_t pid = ::fork();
if (pid == -1) {
boost::throw_exception
(system_error("boost::process::detail::posix_start",
"fork(2) failed", errno));
} else if (pid == 0) {
#if defined(F_MAXFD)
int maxdescs = std::max(::fcntl(0, F_MAXFD), 128); // XXX
#else
int maxdescs = 128; // XXX
#endif
try {
boost::scoped_array< bool > closeflags(new bool[maxdescs]);
for (int i = 0; i < maxdescs; i++)
closeflags.get()[i] = true;
setup_input(infoin, closeflags.get(), maxdescs);
setup_output(infoout, closeflags.get(), maxdescs);
for (int i = 0; i < maxdescs; i++)
if (closeflags.get()[i])
::close(i);
setup();
} catch (const system_error& e) {
::write(STDERR_FILENO, e.what(), std::strlen(e.what()));
::write(STDERR_FILENO, "\n", 1);
::exit(EXIT_FAILURE);
}
std::pair< std::size_t, char** > argcv =
collection_to_posix_argv(args);
char** envp = environment_to_envp(env);
::execve(exe.c_str(), argcv.second, envp);
system_error e("boost::process::detail::posix_start",
"execve(2) failed", errno);
for (std::size_t i = 0; i < argcv.first; i++)
delete [] argcv.second[i];
delete [] argcv.second;
for (std::size_t i = 0; i < env.size(); i++)
delete [] envp[i];
delete [] envp;
::write(STDERR_FILENO, e.what(), std::strlen(e.what()));
::write(STDERR_FILENO, "\n", 1);
::exit(EXIT_FAILURE);
}
BOOST_ASSERT(pid > 0);
for (info_map::iterator iter = infoin.begin();
iter != infoin.end(); iter++) {
stream_info& si = (*iter).second;
if (si.m_type == stream_info::use_pipe)
si.m_pipe->rend().close();
}
for (info_map::iterator iter = infoout.begin();
iter != infoout.end(); iter++) {
stream_info& si = (*iter).second;
if (si.m_type == stream_info::use_pipe)
si.m_pipe->wend().close();
}
return pid;
}
int doinput(lpMcDrag mcdrag)
{
lpPostElement elements;
double dia, tmp;
int err;
elements = post_processelements(&err);
if (err < 0) return err;
/*
Get setup stuff
*/
setup_input(elements);
/*
check for input values...
*/
dia = post_asfloat(elements, DIA_STR);
dia = BRACKETDEF(dia, MIN_DIA, MAX_DIA, DEF_DIA);
mcdrag->dia = dia;
mcdrag->nsl = post_asfloat(elements, NSL_STR)/dia;
mcdrag->nsl = BRACKETDEF(mcdrag->nsl, MIN_NSL, MAX_NSL, DEF_NSL);
mcdrag->dmp = post_asfloat(elements, DMP_STR)/dia;
mcdrag->dmp = BRACKETDEF(mcdrag->dmp, MIN_DMP, MAX_DMP, DEF_DMP);
mcdrag->rad = post_asfloat(elements, RAD_STR);
mcdrag->rad = BRACKETDEF(mcdrag->rad, MIN_RAD, MAX_RAD, DEF_RAD);
mcdrag->btl = post_asfloat(elements, BTL_STR)/dia;
mcdrag->btl = BRACKETDEF(mcdrag->btl, MIN_BTL, MAX_BTL, DEF_BTL);
mcdrag->dba = post_asfloat(elements, DBA_STR)/dia;
mcdrag->dba = BRACKETDEF(mcdrag->dba, MIN_DBA, MAX_DBA, DEF_DBA);
mcdrag->tln = post_asfloat(elements, TLN_STR)/dia;
mcdrag->tln = BRACKETDEF(mcdrag->tln, MIN_TLN, MAX_TLN, DEF_TLN);
mcdrag->dbd = post_asfloat(elements, DBD_STR)/dia;
mcdrag->dbd = BRACKETDEF(mcdrag->dbd, MIN_DBD, MAX_DBD, DEF_DBD);
mcdrag->wgt = post_asfloat(elements, WGT_STR);
mcdrag->wgt = BRACKETDEF(mcdrag->wgt, MIN_WGT, MAX_WGT, DEF_WGT);
mcdrag->twt = post_asfloat(elements, TWT_STR);
mcdrag->twt = BRACKETDEF(mcdrag->twt, MIN_TWT, MAX_TWT, DEF_TWT);
mcdrag->spg = post_asfloat(elements, SPG_STR);
mcdrag->spg = BRACKETDEF(mcdrag->spg, MIN_SPG, MAX_SPG, DEF_SPG);
mcdrag->dgf = post_asint(elements, DGF_STR) - 1;
mcdrag->dgf = BRACKETDEF(mcdrag->dgf, g1, gi, g1);
mcdrag->nst = post_asint(elements, NST_STR) - 1;
mcdrag->nst = BRACKETDEF(mcdrag->nst, secant, conical, secant);
tmp = post_asfloat(elements, TP_STR);
mcdrag->atmos->temperature = BRACKETDEF(tmp, MIN_TP, MAX_TP, DEF_TP);
tmp = post_asfloat(elements, PR_STR);
mcdrag->atmos->pressure = BRACKETDEF(tmp, MIN_PR, MAX_PR, DEF_PR);
tmp = post_asfloat(elements, HU_STR);
mcdrag->atmos->humidity = BRACKETDEF(tmp, MIN_HU, MAX_HU, DEF_HU);
tmp = post_asfloat(elements, AL_STR);
mcdrag->atmos->altitude = BRACKETDEF(tmp, MIN_AL, MAX_AL, DEF_AL);
mcdrag->alc = post_ascheck(elements, ALC_STR);
mcdrag->shc = post_ascheck(elements, SHC_STR);
post_destroyelements(elements);
if (mcdrag->dba > 1.0) return ERROR_DRAG_INVALIDDBA;
if (mcdrag->dmp > 0.5) return ERROR_DRAG_INVALIDDMP;
if (mcdrag->nsl < 1.0) return ERROR_DRAG_INVALIDNSL;
if (mcdrag->rad < 1.0) return ERROR_DRAG_INVALIDRAD;
if (mcdrag->tln < mcdrag->nsl + mcdrag->btl) return ERROR_DRAG_INVALIDTLN;
return ERROR_DRAG_NOERROR;
}
/*
define arrays for default, maximum and minimum values...
*/
int doinput(lpTrajectory trajectory)
{
lpPostElement elements;
double tmp;
int chk;
int err;
elements = post_processelements(&err);
if (err < 0) return err;
/*
Setup
*/
setup_input(elements);
/*
check for input values...
*/
tmp = post_asfloat(elements, MV_STR);
trajectory->velocity = BRACKETDEF(tmp, MIN_MV, MAX_MV, DEF_MV);
tmp = post_asfloat(elements, WT_STR);
trajectory->weight = BRACKETDEF(tmp, MIN_WT, MAX_WT, DEF_WT);
tmp = post_asfloat(elements, WX_STR);
trajectory->wind.x = BRACKETDEF(tmp, MIN_WX, MAX_WX, DEF_WX);
tmp = post_asfloat(elements, WY_STR);
trajectory->wind.y = BRACKETDEF(tmp, MIN_WY, MAX_WY, DEF_WY);
tmp = post_asfloat(elements, WZ_STR);
trajectory->wind.z = BRACKETDEF(tmp, MIN_WZ, MAX_WZ, DEF_WZ);
tmp = post_asfloat(elements, XC_STR);
trajectory->chronodist = BRACKETDEF(tmp, MIN_XC, MAX_XC, DEF_XC);
tmp = post_asfloat(elements, SH_STR);
trajectory->sight_height = INTOFT(BRACKETDEF(tmp, MIN_SH, MAX_SH, DEF_SH));
tmp = post_asfloat(elements, SO_STR);
trajectory->sight_offset = INTOFT(BRACKETDEF(tmp, MIN_SO, MAX_SO, DEF_SO));
tmp = post_asfloat(elements, SP_STR);
trajectory->speed = MPHTOFPS(BRACKETDEF(tmp, MIN_SP, MAX_SP, DEF_SP));
tmp = post_asfloat(elements, SA_STR);
trajectory->speed_angle = RAD(BRACKETDEF(tmp, MIN_SA, MAX_SA, DEF_SA));
tmp = post_asfloat(elements, LA_STR);
trajectory->los_angle = RAD(BRACKETDEF(tmp, MIN_LA, MAX_LA, DEF_LA));
tmp = post_asfloat(elements, CA_STR);
trajectory->cant_angle = RAD(BRACKETDEF(tmp, MIN_CA, MAX_CA, DEF_CA));
tmp = post_asfloat(elements, RN_STR);
trajectory->range_min = BRACKETDEF(tmp, MIN_RN, MAX_RN, DEF_RN);
tmp = post_asfloat(elements, RX_STR);
trajectory->range_max = BRACKETDEF(tmp, MIN_RX, MAX_RX, DEF_RX);
tmp = post_asfloat(elements, RI_STR);
trajectory->range_inc = BRACKETDEF(tmp, MIN_RI, MAX_RI, DEF_RI);
tmp = post_asfloat(elements, RZ_STR);
trajectory->zero.x = BRACKETDEF(tmp, MIN_RZ, MAX_RZ, DEF_RZ);
tmp = post_asfloat(elements, ZY_STR);
trajectory->zero.y = BRACKETDEF(tmp, MIN_ZY, MAX_ZY, DEF_ZY);
tmp = post_asfloat(elements, ZZ_STR);
trajectory->zero.z = BRACKETDEF(tmp, MIN_ZZ, MAX_ZZ, DEF_ZZ);
tmp = post_asfloat(elements, BC_STR);
trajectory->bc->bc = BRACKETDEF(tmp, MIN_BC, MAX_BC, DEF_BC);
bc_setdragfunc(trajectory->bc, post_asint(elements, DF_STR) - 1);
tmp = post_asfloat(elements, TP_STR);
trajectory->atmos->temperature = BRACKETDEF(tmp, MIN_TP, MAX_TP, DEF_TP);
tmp = post_asfloat(elements, PR_STR);
trajectory->atmos->pressure = BRACKETDEF(tmp, MIN_PR, MAX_PR, DEF_PR);
tmp = post_asfloat(elements, HU_STR);
trajectory->atmos->humidity = BRACKETDEF(tmp, MIN_HU, MAX_HU, DEF_HU);
tmp = post_asfloat(elements, AL_STR);
trajectory->atmos->altitude = BRACKETDEF(tmp, MIN_AL, MAX_AL, DEF_AL);
tmp = post_asfloat(elements, AZ_STR);
trajectory->azimuth = RAD(BRACKETDEF(tmp, MIN_AZ, MAX_AZ, DEF_AZ)/60.0);
tmp = post_asfloat(elements, EL_STR);
trajectory->elevation = RAD(BRACKETDEF(tmp, MIN_EL, MAX_EL, DEF_EL)/60.0);
chk = post_ascheck(elements, AZC_STR);
options_setoption(trajectory->options, TRAJ_OPT_AZIM, chk);
chk = post_ascheck(elements, ELC_STR);
options_setoption(trajectory->options, TRAJ_OPT_ELEV, chk);
chk = post_ascheck(elements, ALC_STR);
options_setoption(trajectory->options, TRAJ_OPT_ALTI, chk);
chk = post_ascheck(elements, BS_STR);
options_setoption(trajectory->options, TRAJ_OPT_BASIC, chk);
switch (post_asint(elements, UN_STR))
{
case 1 :
options_setoption(trajectory->options, TRAJ_OPT_IN, 1);
break;
case 2 :
options_setoption(trajectory->options, TRAJ_OPT_MOA, 1);
break;
case 3 :
options_setoption(trajectory->options, TRAJ_OPT_MIL, 1);
break;
}
free(elements);
if (trajectory->range_min > trajectory->range_max)
return ERROR_TRAJ_INVALIDRANGEMIN;
return ERROR_TRAJ_NOERROR;
}
