FBCALL FB_WCHAR *fb_WstrTrim ( const FB_WCHAR *src )
{
FB_WCHAR *dst;
const FB_WCHAR *p;
ssize_t chars;
if( src == NULL )
return NULL;
chars = fb_wstr_Len( src );
if( chars <= 0 )
return NULL;
p = fb_wstr_SkipCharRev( src, chars, _LC(' ') );
chars = fb_wstr_CalcDiff( src, p );
if( chars <= 0 )
return NULL;
p = fb_wstr_SkipChar( src, chars, _LC(' ') );
chars -= fb_wstr_CalcDiff( src, p );
if( chars <= 0 )
return NULL;
/* alloc temp string */
dst = fb_wstr_AllocTemp( chars );
if( dst != NULL )
{
/* simple copy */
fb_wstr_Copy( dst, p, chars );
}
return dst;
}
void uPinMode(uint8_t pin, uint8_t mode)
{
if (pin < NUM_DIGITAL_PINS) // standart IO
{
pinMode( pin, mode );
return;
}
if ( pin > Q7) //we can,t change pinMode on GPUX on addr 0x20 or more
{
return;
}
else
{
if (mode != OUTPUT)
lcdPinMode |= 1 << ( _LC(pin) );
else
lcdPinMode &= ~(1 << ( _LC(pin) ));
Wire.begin();
Wire.beginTransmission(LCD_TWI_ADDR);
Wire.write(WIRE_IO_CONFIG_MODE); // i/o config mode
Wire.write(lcdPinMode); //
Wire.endTransmission();
}
}
/*:::::*/
static FB_WCHAR *hBin ( unsigned int num, int len, int digits )
{
FB_WCHAR *dst, *buf;
int i, totdigs;
unsigned int mask;
if( digits > 0 )
{
totdigs = (digits < len << 3? digits: len << 3);
if( digits > len << 3 )
digits = len << 3;
}
else
totdigs = len << 3;
/* alloc temp string, chars won't be above 127 */
dst = fb_wstr_AllocTemp( totdigs );
if( dst == NULL )
return NULL;
/* convert */
buf = dst;
if( num == 0 )
{
if( digits <= 0 )
digits = 1;
while( digits-- )
*buf++ = _LC('0');
}
else
{
mask = 1UL << (totdigs-1);
for( i = 0; i < totdigs; i++, num <<= 1 )
if( num & mask )
break;
if( digits > 0 )
{
digits -= totdigs - i;
while( digits-- )
*buf++ = _LC('0');
}
for( ; i < totdigs; i++, num <<= 1 )
if( num & mask )
*buf++ = _LC('1');
else
*buf++ = _LC('0');
}
/* add null-term */
*buf = _LC('\0');
return dst;
}
int fb_DevFileReadLineEncodWstr( FB_FILE *handle, FB_WCHAR *dst, ssize_t max_chars )
{
int res;
FB_LOCK();
FILE* fp = (FILE *)handle->opaque;
if( fp == stdout || fp == stderr )
fp = stdin;
if( fp == NULL ) {
FB_UNLOCK();
return fb_ErrorSetNum( FB_RTERROR_ILLEGALFUNCTIONCALL );
}
/* Clear string first, we're only using += concat assign below... */
dst[0] = _LC('\0');
/* Read one byte at a time until CR and/or LF is found.
The fb_FileGetDataEx() will handle the decoding. The length to read
is specified in wchars, not bytes, because we're passing TRUE for
is_unicode. */
while( TRUE ) {
FB_WCHAR c[2];
size_t len;
res = fb_FileGetDataEx( handle, 0, c, 1, &len, FALSE, TRUE );
if( (res != FB_RTERROR_OK) || (len == 0) )
break;
/* CR? Check for following LF too, and skip it if it's there */
if( c[0] == _LC('\r') ) {
res = fb_FileGetDataEx( handle, 0, c, 1, &len, FALSE, TRUE );
if( (res != FB_RTERROR_OK) || (len == 0) )
break;
/* No LF? Ok then, don't skip it yet */
if( c[0] != _LC('\n') )
fb_FilePutBackEx( handle, c, 1 );
break;
}
/* LF? */
if( c[0] == _LC('\n') ) {
break;
}
/* Any other char? Append to string, and continue... */
c[1] = _LC('\0');
fb_WstrConcatAssign( dst, max_chars, c );
}
FB_UNLOCK();
return res;
}
void uDigitalWrite(uint8_t pin, uint8_t val)
{
if (pin < NUM_DIGITAL_PINS) // standart IO
{
digitalWrite( pin, val );
return;
}
if ( pin > LAST_PIN) //NOT ON PIN
{
return;
}
if ( pin > Q7) //led or button
{
if ( pin > LS3 )
{
uint8_t curPin = pin - LS0;
(val) ? ledState |= 1 << curPin : ledState &= ~(1 << curPin);
twiWriteOut(GPUX_TWI_ADDR, ledState);
}
return;
}
else // pin>=Q0 && pin<=Q7
{
uint8_t curPin = _LC(pin);
(val) ? lcdPinState |= 1 << curPin : lcdPinState &= ~(1 << curPin);
twiWriteOut(LCD_TWI_ADDR, lcdPinState);
}
}
/*:::::*/
int fb_FileGetWstrEx( FB_FILE *handle, fb_off_t pos, FB_WCHAR *dst, int dst_chars, size_t *bytesread )
{
int res;
if( bytesread )
*bytesread = 0;
if( !FB_HANDLE_USED(handle) )
return fb_ErrorSetNum( FB_RTERROR_ILLEGALFUNCTIONCALL );
/* perform call ... but only if there's data ... */
if( (dst != NULL) && (dst_chars > 0) )
{
size_t chars;
res = fb_FileGetDataEx( handle, pos, (void *)dst, dst_chars, &chars, TRUE, TRUE );
/* add the null-term */
if( res == FB_RTERROR_OK )
dst[chars] = _LC('\0');
if( bytesread )
*bytesread = chars;
}
else
res = fb_ErrorSetNum( FB_RTERROR_ILLEGALFUNCTIONCALL );
return res;
}
/*:::::*/
void fb_PrintPadWstrEx
(
FB_FILE *handle,
int mask
)
{
#ifdef FB_NATIVE_TAB
FB_PRINTWSTR_EX( handle, _LC("\t"), 1, mask );
#else
FB_FILE *tmp_handle;
int old_x;
int new_x;
fb_DevScrnInit_WriteWstr( );
tmp_handle = FB_HANDLE_DEREF(handle);
old_x = tmp_handle->line_length + 1;
new_x = old_x + FB_TAB_WIDTH - 1;
new_x /= FB_TAB_WIDTH;
new_x *= FB_TAB_WIDTH;
new_x += 1;
if (tmp_handle->width!=0)
{
unsigned dev_width = tmp_handle->width;
if (new_x > (dev_width - FB_TAB_WIDTH))
{
new_x = 1;
}
}
fb_hPrintPadWstrEx( handle, mask, old_x, new_x );
#endif
}
/* dst_chars == room in dst buffer without null terminator. Thus, the dst buffer
must be at least (dst_chars + 1) * sizeof(FB_WCHAR).
src must be null-terminated.
result = number of chars written, excluding null terminator that is always written */
ssize_t fb_wstr_ConvFromA(FB_WCHAR *dst, ssize_t dst_chars, const char *src)
{
if (src == NULL) {
*dst = _LC('\0');
return 0;
}
#if defined HOST_DOS
ssize_t chars = strlen(src);
if (chars > dst_chars)
chars = dst_chars;
memcpy(dst, src, chars + 1);
return chars;
#else
/* plus the null-term (note: "n" in chars, not bytes!) */
ssize_t chars = mbstowcs(dst, src, dst_chars + 1);
/* worked? */
if (chars >= 0) {
/* a null terminator won't be added if there was not
enough space, so do it manually (this will cut off the last
char, but what can you do) */
if (chars == (dst_chars + 1)) {
dst[dst_chars] = _LC('\0');
return dst_chars - 1;
}
return chars;
}
/* mbstowcs() failed; translate at least ASCII chars
and write out '?' for the others */
FB_WCHAR *origdst = dst;
FB_WCHAR *dstlimit = dst + dst_chars;
while (dst < dstlimit) {
unsigned char c = *src++;
if (c == 0)
break;
if (c > 127)
c = '?';
*dst++ = c;
}
*dst = _LC('\0');
return dst - origdst;
#endif
}
/*:::::*/
static FB_WCHAR hSkipWhiteSpc
(
FB_INPUTCTX *ctx
)
{
FB_WCHAR c;
/* skip white space */
do
{
c = hReadChar( ctx );
if( c == WEOF )
break;
} while( (c == _LC(' ')) || (c == _LC('\t')) );
return c;
}
/*:::::*/
static void hSkipDelimiter
(
FB_INPUTCTX *ctx,
FB_WCHAR c
)
{
/* skip white space */
while( (c == _LC(' ')) || (c == _LC('\t')) )
c = hReadChar( ctx );
switch( c )
{
case _LC(','):
case WEOF:
break;
case _LC('\n'):
break;
case _LC('\r'):
if( (c = hReadChar( ctx )) != _LC('\n') )
hUnreadChar( ctx, c );
break;
default:
hUnreadChar( ctx, c );
break;
}
}
static void fb_hPrintPadWstrEx
(
FB_FILE *handle,
int mask,
int current_x,
int new_x
)
{
#ifdef FB_NATIVE_TAB
FB_PRINTWSTR_EX( handle, _LC("\t"), 1, mask );
#else
FB_WCHAR tab_char_buffer[FB_TAB_WIDTH+1];
if (new_x <= current_x)
{
FB_PRINTWSTR_EX( handle,
FB_NEWLINE_WSTR,
sizeof( FB_NEWLINE_WSTR ) / sizeof( FB_WCHAR ) - 1,
mask );
}
else
{
size_t i, count = new_x - current_x;
for( i = 0; i < count; i++ )
tab_char_buffer[i] = _LC(' ');
/* the terminating NUL shouldn't be required but it makes
* debugging easier */
tab_char_buffer[count] = 0;
FB_PRINTWSTR_EX( handle, tab_char_buffer, count, mask );
}
#endif
}
FBCALL FB_WCHAR *fb_WstrUcase2( const FB_WCHAR *src, int mode )
{
FB_WCHAR *dst, *d;
const FB_WCHAR *s;
FB_WCHAR c;
int chars, i;
if( src == NULL )
return NULL;
chars = fb_wstr_Len( src );
/* alloc temp string */
dst = fb_wstr_AllocTemp( chars );
if( dst == NULL )
return NULL;
s = src;
d = dst;
if( mode == 1 ) {
for( i = 0; i < chars; i++ ) {
c = *s++;
if( (c >= 97) && (c <= 122) )
c -= 97 - 65;
*d++ = c;
}
} else {
for( i = 0; i < chars; i++ ) {
c = *s++;
if( fb_wstr_IsLower( c ) )
c = fb_wstr_ToUpper( c );
*d++ = c;
}
}
/* null char */
*d = _LC('\0');
return dst;
}
FBCALL void fb_DataReadWstr( FB_WCHAR *dst, int dst_size )
{
FB_LOCK();
if( __fb_data_ptr ) {
if( __fb_data_ptr->len == FB_DATATYPE_OFS ) {
/* !!!WRITEME!!! */
} else if( __fb_data_ptr->len & FB_DATATYPE_WSTR ) {
fb_WstrAssign( dst, dst_size, __fb_data_ptr->wstr );
} else {
fb_WstrAssignFromA( dst, dst_size, __fb_data_ptr->zstr, __fb_data_ptr->len );
}
} else {
/* no more DATA, return empty string */
fb_WstrAssign( dst, dst_size, _LC("") );
}
fb_DataNext( );
FB_UNLOCK();
}
void RoR::GUI::GameSettings::Draw()
{
bool is_visible = true;
const int flags = ImGuiWindowFlags_NoCollapse;
ImGui::SetNextWindowSize(ImVec2(600.f, 400.f), ImGuiSetCond_FirstUseEver);
ImGui::SetNextWindowPosCenter(ImGuiSetCond_Appearing);
ImGui::Begin(_LC("GameSettings", "Game settings"), &is_visible, flags);
if (! is_visible)
{
this->SetVisible(false);
if (App::app_state.GetActive() == RoR::AppState::MAIN_MENU)
{
App::GetGuiManager()->SetVisible_GameMainMenu(true);
}
ImGui::End();
return;
}
// 'Tabs' buttons
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(4.f, 8.f));
if (ImGui::Button(_LC("GameSettings", "Render System"))) { m_tab = SettingsTab::RENDER_SYSTEM; }
ImGui::SameLine();
if (ImGui::Button(_LC("GameSettings", "General"))) { m_tab = SettingsTab::GENERAL; }
ImGui::SameLine();
if (ImGui::Button(_LC("GameSettings", "Graphics"))) { m_tab = SettingsTab::GRAPHICS; }
ImGui::SameLine();
#ifdef USE_OPENAL
if (ImGui::Button(_LC("GameSettings", "Audio"))) { m_tab = SettingsTab::AUDIO; }
ImGui::SameLine();
#endif // USE_OPENAL
if (ImGui::Button(_LC("GameSettings", "Controls"))) { m_tab = SettingsTab::CONTROL; }
ImGui::SameLine();
if (ImGui::Button(_LC("GameSettings", "Diagnostic"))) { m_tab = SettingsTab::DIAG; }
ImGui::SameLine();
if (ImGui::Button(_LC("GameSettings", "Update cache")))
{
App::app_force_cache_udpate.SetActive(true);
}
ImGui::PopStyleVar(1);
ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 4.f);
ImGui::Separator();
if (m_tab == SettingsTab::RENDER_SYSTEM)
{
ImGui::TextDisabled(_LC("GameSettings", "Render system (changes require a restart)"));
const auto ogre_root = App::GetOgreSubsystem()->GetOgreRoot();
const auto render_systems = ogre_root->getAvailableRenderers();
std::string render_system_names;
for (auto rs : render_systems)
{
render_system_names += rs->getName() + '\0';
}
const auto ro = ogre_root->getRenderSystemByName(App::app_rendersys_override.GetActive());
const auto rs = ro ? ro : ogre_root->getRenderSystem();
const auto it = std::find(render_systems.begin(), render_systems.end(), rs);
int render_id = it != render_systems.end() ? std::distance(render_systems.begin(), it) : 0;
/* Combobox for selecting the Render System*/
if (ImGui::Combo(_LC ("GameSettings", "Render System"), &render_id, render_system_names.c_str()))
{
App::app_rendersys_override.SetActive(render_systems[render_id]->getName().c_str());
}
const auto config_options = ogre_root->getRenderSystem()->getConfigOptions();
std::set<std::string> filter = {"Allow NVPerfHUD", "Colour Depth", "Fixed Pipeline Enabled",
"Floating-point mode", "Resource Creation Policy", "VSync Interval", "sRGB Gamma Conversion"};
for (auto opt : config_options)
{
auto co = opt.second;
if (co.immutable)
continue;
if (co.possibleValues.empty())
continue;
if (filter.find(co.name) != filter.end())
continue;
std::sort(co.possibleValues.rbegin(), co.possibleValues.rend());
std::string option_values;
for (auto value : co.possibleValues)
{
option_values += value + '\0';
}
const auto it = std::find(co.possibleValues.begin(), co.possibleValues.end(), opt.second.currentValue);
int option_id = it != co.possibleValues.end() ? std::distance(co.possibleValues.begin(), it) : 0;
if (ImGui::Combo(co.name.c_str(), &option_id, option_values.c_str()))
{
rs->setConfigOption(co.name, co.possibleValues[option_id]);
if (rs->validateConfigOptions().empty())
{
ogre_root->saveConfig();
}
}
}
}
else if (m_tab == SettingsTab::GENERAL)
{
ImGui::TextDisabled(_LC("GameSettings", "Application settings"));
#ifndef NOLANG
std::vector<std::pair<std::string, std::string>> languages = LanguageEngine::getSingleton().getLanguages();
std::string lang_values;
for (auto value : languages)
{
lang_values += value.first + '\0';
}
const auto it = std::find_if(languages.begin(), languages.end(),
[](const std::pair<std::string, std::string>& l) { return l.second == App::app_language.GetActive(); });
int lang_selection = it != languages.end() ? std::distance(languages.begin(), it) : 0;
if (ImGui::Combo(_LC("GameSettings", "Language"), &lang_selection, lang_values.c_str()))
{
App::app_language.SetActive(languages[lang_selection].second.c_str());
LanguageEngine::getSingleton().setup();
}
#endif
// Country selection
static Ogre::FileInfoListPtr fl = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo("FlagsRG", "*");
if (!fl->empty())
{
static std::vector<std::string> countries;
if (countries.empty())
{
for (auto& file : *fl)
{
std::string country = Ogre::StringUtil::replaceAll(file.filename, ".png", "");
if (country.size() == 2) // RoR protocol limitation
{
countries.push_back(country);
}
}
std::sort(countries.begin(), countries.end());
}
std::string country_values;
for (auto value : countries)
{
country_values += value + '\0';
}
const auto it = std::find(countries.begin(), countries.end(), std::string(App::app_country.GetActive()));
int country_selection = it != countries.end() ? std::distance(countries.begin(), it) : 0;
if (ImGui::Combo(_LC("GameSettings", "Country"), &country_selection, country_values.c_str()))
{
App::app_country.SetActive(countries[country_selection].c_str());
}
}
int sshot_select = (std::strcmp(App::app_screenshot_format.GetActive(),"jpg") == 0) ? 1 : 0; // Hardcoded; TODO: list available formats.
/* Screenshot format: Can be png or jpg*/
if (ImGui::Combo(_LC("GameSettings", "Screenshot format"), &sshot_select, "png\0jpg\0\0"))
{
App::app_screenshot_format.SetActive((sshot_select == 1) ? "jpg" : "png");
}
DrawGTextEdit(App::app_extra_mod_path, _LC("GameSettings", "Extra mod path"), m_buf_app_extra_mod_dir);
DrawGCheckbox(App::app_skip_main_menu, _LC("GameSettings", "Skip main menu"));
DrawGCheckbox(App::app_async_physics, _LC("GameSettings", "Async physics"));
DrawGCheckbox(App::app_disable_online_api, _LC("GameSettings", "Disable online api"));
ImGui::Separator();
ImGui::TextDisabled(_LC("GameSettings", "Simulation settings"));
DrawGCombo(App::sim_gearbox_mode, _LC("GameSettings", "Gearbox mode"),
"Automatic shift\0"
"Manual shift - Auto clutch\0"
"Fully Manual: sequential shift\0"
"Fully manual: stick shift\0"
"Fully Manual: stick shift with ranges\00");
DrawGCheckbox(App::gfx_speedo_digital, _LC("GameSettings", "Digital speedometer"));
DrawGCheckbox(App::gfx_speedo_imperial, _LC("GameSettings", "Imperial speedometer"));
//DrawGCheckbox(App::gfx_flexbody_lods, "Enable flexbody LODs");
//DrawGCheckbox(App::gfx_flexbody_cache, "Enable flexbody cache");
DrawGCheckbox(App::sim_spawn_running, _LC("GameSettings", "Engines spawn running"));
DrawGCheckbox(App::sim_replay_enabled, _LC("GameSettings", "Replay mode"));
if (App::sim_replay_enabled.GetActive())
{
DrawGIntBox(App::sim_replay_length, _LC("GameSettings", "Replay length"));
DrawGIntBox(App::sim_replay_stepping, _LC("GameSettings", "Replay stepping"));
}
DrawGCheckbox(App::sim_realistic_commands, _LC("GameSettings", "Realistic forward commands"));
DrawGCheckbox(App::sim_races_enabled, _LC("GameSettings", "Enable races"));
DrawGCheckbox(App::sim_direction_arrow, _LC("GameSettings", "Direction arrow"));
DrawGCheckbox(App::sim_no_self_collisions, _LC("GameSettings", "No intra truck collisions"));
DrawGCheckbox(App::sim_no_collisions, _LC("GameSettings", "No inter truck collisions"));
}
#ifdef USE_OPENAL
else if (m_tab == SettingsTab::AUDIO)
{
ImGui::TextDisabled(_LC("GameSettings", "Audio settings"));
static const ALCchar *devices = alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
const ALCchar *device = devices, *next = devices + 1;
std::vector<std::string> audio_devices;
while (device && *device != '\0' && next && *next != '\0')
{
audio_devices.push_back(device);
size_t len = strlen(device);
device += (len + 1);
next += (len + 2);
}
const auto it = std::find(audio_devices.begin(), audio_devices.end(), App::audio_device_name.GetActive());
int device_id = it != audio_devices.end() ? std::distance(audio_devices.begin(), it) : 0;
if (ImGui::Combo(_LC("GameSettings", "Audio device"), &device_id, devices))
{
App::audio_device_name.SetActive(audio_devices[device_id].c_str());
}
DrawGCheckbox(App::audio_enable_creak, _LC("GameSettings", "Creak sound"));
DrawGCheckbox(App::audio_menu_music, _LC("GameSettings", "Main menu music"));
DrawGFloatSlider(App::audio_master_volume, _LC("GameSettings", "Master volume"), 0, 1);
}
#endif // USE_OPENAL
else if (m_tab == SettingsTab::GRAPHICS)
{
ImGui::TextDisabled(_LC("GameSettings", "Video settings"));
DrawGCombo(App::gfx_flares_mode, _LC("GameSettings", "Lights"),
"None (fastest)\0"
"No light sources\0"
"Only current vehicle, main lights\0"
"All vehicles, main lights\0"
"All vehicles, all lights\0\0");
DrawGCombo(App::gfx_shadow_type, _LC("GameSettings", "Shadow type"),
"Disabled\0"
"Texture\0"
"PSSM\0\0");
if (App::gfx_shadow_type.GetActive() != GfxShadowType::NONE)
{
DrawGCheckbox(App::gfx_reduce_shadows, _LC("GameSettings", "Shadow optimizations"));
if (App::gfx_shadow_type.GetActive() == GfxShadowType::PSSM)
{
DrawGIntSlider(App::gfx_shadow_quality, _LC("GameSettings", "Shadow quality"), 0, 3);
}
}
DrawGCombo(App::gfx_sky_mode, "Sky gfx",
"Sandstorm (fastest)\0"
"Caelum (best looking, slower)\0"
"SkyX (best looking, slower)\0\0");
DrawGIntSlider(App::gfx_sight_range, _LC("GameSettings", "Sight range (meters)"), 100, 5000);
DrawGCombo(App::gfx_texture_filter , _LC("GameSettings", "Texture filtering"),
"None\0"
"Bilinear\0"
"Trilinear\0"
"Anisotropic\0\0");
if (App::gfx_texture_filter.GetActive() == GfxTexFilter::ANISOTROPIC)
{
int anisotropy = Ogre::Math::Clamp(App::gfx_anisotropy.GetActive(), 1, 16);
int selection = std::log2(anisotropy);
if (ImGui::Combo(_LC("GameSettings", "Anisotropy"), &selection, "1\0""2\0""4\0""8\0""16\0\0"))
{
App::gfx_anisotropy.SetActive(std::pow(2, selection));
}
}
DrawGCombo(App::gfx_vegetation_mode, _LC("GameSettings", "Vegetation density"),
"None\0"
"20%\0"
"50%\0"
"Full\0\0");
DrawGCombo(App::gfx_water_mode, _LC("GameSettings", "Water gfx"),
"None\0"
"Basic (fastest)\0"
"Reflection\0"
"Reflection + refraction (speed optimized)\0"
"Reflection + refraction (quality optimized)\0"
"HydraX\0\0");
DrawGIntSlider(App::gfx_fps_limit, _LC("GameSettings", "FPS limit"), 0, 240);
DrawGIntCheck(App::gfx_particles_mode, _LC("GameSettings", "Enable particle gfx"));
DrawGIntCheck(App::gfx_skidmarks_mode, _LC("GameSettings", "Enable skidmarks"));
DrawGCheckbox(App::gfx_envmap_enabled, _LC("GameSettings", "Realtime reflections"));
if (App::gfx_envmap_enabled.GetActive())
{
ImGui::PushItemWidth(125.f); // Width includes [+/-] buttons
DrawGIntSlider(App::gfx_envmap_rate, _LC("GameSettings", "Realtime refl. update rate"), 0, 6);
ImGui::PopItemWidth();
}
DrawGCheckbox(App::gfx_enable_videocams, _LC("GameSettings", "Render video cameras"));
DrawGCheckbox(App::gfx_surveymap_icons, _LC("GameSettings", "Overview map icons"));
if (App::gfx_surveymap_icons.GetActive())
{
DrawGCheckbox(App::gfx_declutter_map, _LC("GameSettings", "Declutter overview map"));
}
DrawGCheckbox(App::gfx_water_waves, _LC("GameSettings", "Waves on water"));
DrawGCombo(App::gfx_extcam_mode, "Exterior camera mode",
"None\0"
"Static\0"
"Pitching\0\0");
DrawGIntSlider(App::gfx_camera_height, _LC("GameSettings", "Static camera height (meters)"), 1, 50);
DrawGIntSlider(App::gfx_fov_external, _LC("GameSettings", "Exterior field of view"), 10, 120);
DrawGIntSlider(App::gfx_fov_internal, _LC("GameSettings", "Interior field of view"), 10, 120);
}
else if (m_tab == SettingsTab::DIAG)
{
ImGui::TextDisabled(_LC("GameSettings", "Diagnostic options"));
int physics_fps = std::round(1.0f / App::diag_physics_dt.GetActive());
if (ImGui::SliderInt(_LC("GameSettings", "Physics frames per second"), &physics_fps, 2000, 10000))
{
App::diag_physics_dt.SetActive(Ogre::Math::Clamp(1.0f / physics_fps, 0.0001f, 0.0005f));
}
DrawGTextEdit(App::diag_preset_terrain, _LC("GameSettings", "Preselected terrain"), m_buf_diag_preset_terrain, false);
DrawGTextEdit(App::diag_preset_vehicle, _LC("GameSettings", "Preselected vehicle"), m_buf_diag_preset_vehicle, true);
DrawGTextEdit(App::diag_preset_veh_config, _LC("GameSettings", "Presel. veh. config"), m_buf_diag_preset_veh_config);
DrawGCheckbox(App::diag_preset_veh_enter, _LC("GameSettings", "Enter preselected vehicle"));
DrawGCheckbox(App::diag_auto_spawner_report, _LC("GameSettings", "Auto actor spawner report"));
DrawGCheckbox(App::diag_rig_log_node_import, _LC("GameSettings", "Log node import (spawn)"));
DrawGCheckbox(App::diag_rig_log_node_stats, _LC("GameSettings", "Log node stats (spawn)"));
DrawGCheckbox(App::diag_rig_log_messages, _LC("GameSettings", "Log messages (spawn)"));
DrawGCheckbox(App::diag_camera, _LC("GameSettings", "Debug camera (rails)"));
DrawGCheckbox(App::diag_collisions, _LC("GameSettings", "Debug collisions"));
DrawGCheckbox(App::diag_truck_mass, _LC("GameSettings", "Debug actor mass"));
DrawGCheckbox(App::diag_envmap, _LC("GameSettings", "Debug realtime reflections"));
DrawGCheckbox(App::diag_videocameras, _LC("GameSettings", "Debug videocameras"));
DrawGCheckbox(App::diag_warning_texture, _LC("GameSettings", "Debug textures"));
DrawGCheckbox(App::diag_hide_broken_beams, _LC("GameSettings", "Hide broken beams"));
DrawGCheckbox(App::diag_hide_wheel_info, _LC("GameSettings", "Hide wheel info"));
DrawGCheckbox(App::diag_hide_wheels, _LC("GameSettings", "Hide wheels"));
DrawGCheckbox(App::diag_hide_nodes, _LC("GameSettings", "Hide nodes"));
DrawGCheckbox(App::diag_log_console_echo, _LC("GameSettings", "Echo log to console"));
DrawGCheckbox(App::diag_log_beam_break, _LC("GameSettings", "Log beam breaking"));
DrawGCheckbox(App::diag_log_beam_deform, _LC("GameSettings", "Log beam deforming"));
DrawGCheckbox(App::diag_log_beam_trigger, _LC("GameSettings", "Log beam triggers"));
if (ImGui::Button(_LC("GameSettings", "Rebuild cache")))
{
App::app_force_cache_purge.SetActive(true);
}
}
else if (m_tab == SettingsTab::CONTROL)
{
ImGui::TextDisabled(_LC("GameSettings", "Controller options"));
DrawGCombo(App::io_input_grab_mode, _LC("GameSettings", "Input grab mode"),
"None\0"
"All\0"
"Dynamic\0\0");
DrawGFloatSlider(App::io_analog_smoothing, _LC("GameSettings", "Analog Input Smoothing"), 0.5f, 2.0f);
DrawGFloatSlider(App::io_analog_sensitivity, _LC("GameSettings", "Analog Input Sensitivity"), 0.5f, 2.0f);
DrawGCheckbox(App::io_arcade_controls, _LC("GameSettings", "Use arcade controls"));
DrawGCheckbox(App::io_ffb_enabled, _LC("GameSettings", "Enable ForceFeedback"));
if (App::io_ffb_enabled.GetActive())
{
ImGui::PushItemWidth(125.f);
DrawGFloatBox(App::io_ffb_camera_gain, _LC("GameSettings", "FFB camera gain"));
DrawGFloatBox(App::io_ffb_center_gain, _LC("GameSettings", "FFB center gain"));
DrawGFloatBox(App::io_ffb_master_gain, _LC("GameSettings", "FFB master gain"));
DrawGFloatBox(App::io_ffb_stress_gain, _LC("GameSettings", "FFB stress gain"));
ImGui::PopItemWidth();
}
DrawGIntCheck(App::io_outgauge_mode, _LC("GameSettings", "Enable OutGauge protocol"));
if (App::io_outgauge_mode.GetActive())
{
DrawGTextEdit(App::io_outgauge_ip, _LC("GameSettings", "OutGauge IP"), m_buf_io_outgauge_ip);
ImGui::PushItemWidth(125.f);
DrawGIntBox(App::io_outgauge_port, _LC("GameSettings", "OutGauge port"));
DrawGIntBox(App::io_outgauge_id, _LC("GameSettings", "OutGauge ID"));
DrawGFloatBox(App::io_outgauge_delay, _LC("GameSettings", "OutGauge delay"));
ImGui::PopItemWidth();
}
}
ImGui::End();
}
/*:::::*/
void fb_FileInputNextTokenWstr
(
FB_WCHAR *buffer,
int max_chars,
int is_string
)
{
/* max_chars does not include the null terminator, the buffer is
assumed to be big enough to hold at least the null terminator */
int len, isquote, skipdelim;
FB_WCHAR c;
FB_INPUTCTX *ctx = FB_TLSGETCTX( INPUT );
/* */
skipdelim = TRUE;
isquote = 0;
len = 0;
c = hSkipWhiteSpc( ctx );
while( (c != WEOF) && (len < max_chars) )
{
switch( c )
{
case _LC('\n'):
skipdelim = FALSE;
goto exit;
case _LC('\r'):
if( (c = hReadChar( ctx )) != _LC('\n') )
hUnreadChar( ctx, c );
skipdelim = FALSE;
goto exit;
case _LC('"'):
if( !isquote )
{
if( len == 0 )
isquote = 1;
else
goto savechar;
}
else
{
isquote = 0;
if( is_string )
{
c = hReadChar( ctx );
goto exit;
}
}
break;
case _LC(','):
if( !isquote )
{
skipdelim = FALSE;
goto exit;
}
goto savechar;
case _LC('\t'):
case _LC(' '):
if( !isquote )
{
if( !is_string )
{
goto exit;
}
}
default:
savechar:
*buffer++ = c;
++len;
break;
}
c = hReadChar( ctx );
}
exit:
*buffer = _LC('\0');
/* skip comma or newline */
if( skipdelim )
hSkipDelimiter( ctx, c );
}
void fb_ConsolePrintBufferWstrEx( const FB_WCHAR *buffer, size_t chars, int mask )
{
size_t avail, avail_len;
char *temp;
if( !__fb_con.inited )
{
/* !!!FIXME!!! is this ok or should it be converted to UTF-8 too? */
fwrite( buffer, sizeof( FB_WCHAR ), chars, stdout );
fflush( stdout );
return;
}
temp = alloca( chars * 4 + 1 );
/* ToDo: handle scrolling for internal characters/attributes buffer? */
avail = (__fb_con.w * __fb_con.h) - (((__fb_con.cur_y - 1) * __fb_con.w) + __fb_con.cur_x - 1);
avail_len = chars;
if (avail < avail_len)
avail_len = avail;
/* !!!FIXME!!! to support unicode the char_buffer would have to be a wchar_t,
slowing down non-unicode printing.. */
fb_wstr_ConvToA( temp, buffer, avail_len );
memcpy( __fb_con.char_buffer + ((__fb_con.cur_y - 1) * __fb_con.w) + __fb_con.cur_x - 1,
temp,
avail_len );
memset( __fb_con.attr_buffer + ((__fb_con.cur_y - 1) * __fb_con.w) + __fb_con.cur_x - 1,
__fb_con.fg_color | (__fb_con.bg_color << 4),
avail_len );
/* convert wchar_t to UTF-8 */
int bytes;
fb_WCharToUTF( FB_FILE_ENCOD_UTF8, buffer, chars, temp, &bytes );
/* add null-term */
temp[bytes] = '\0';
fputs( ENTER_UTF8, stdout );
fputs( temp, stdout );
fputs( EXIT_UTF8, stdout );
/* update x and y coordinates.. */
for( ; chars; chars--, buffer++ )
{
++__fb_con.cur_x;
if( (*buffer == _LC('\n')) || (__fb_con.cur_x >= __fb_con.w) )
{
__fb_con.cur_x = 1;
++__fb_con.cur_y;
if( __fb_con.cur_y > __fb_con.h )
__fb_con.cur_y = __fb_con.h;
}
}
fflush( stdout );
}
FBCALL FB_WCHAR *fb_FileWstrInput( ssize_t chars, int fnum )
{
FB_FILE *handle;
FB_WCHAR *dst;
size_t len;
int res = FB_RTERROR_OK;
fb_DevScrnInit_ReadWstr( );
FB_LOCK();
handle = FB_FILE_TO_HANDLE(fnum);
if( !FB_HANDLE_USED(handle) )
{
FB_UNLOCK();
return NULL;
}
dst = fb_wstr_AllocTemp( chars );
if( dst != NULL )
{
ssize_t read_chars = 0;
if( FB_HANDLE_IS_SCREEN(handle) )
{
while( read_chars != chars )
{
res = fb_FileGetDataEx( handle,
0,
(void *)&dst[read_chars],
chars - read_chars,
&len,
TRUE,
TRUE );
if( res != FB_RTERROR_OK )
break;
read_chars += len;
}
}
else
{
res = fb_FileGetDataEx( handle,
0,
(void *)dst,
chars,
&len,
TRUE,
TRUE );
read_chars = chars;
}
if( res == FB_RTERROR_OK )
{
dst[read_chars] = _LC('\0');
}
else
{
fb_wstr_Del( dst );
dst = NULL;
}
}
else
res = FB_RTERROR_OUTOFMEM;
FB_UNLOCK();
return dst;
}
