mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-03-22 15:05:03 +01:00
1514 lines
50 KiB
C++
1514 lines
50 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
/*
|
|
MaSzyna EU07 locomotive simulator
|
|
Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others
|
|
|
|
*/
|
|
#include "stdafx.h"
|
|
#include "Globals.h"
|
|
|
|
#include "simulation.h"
|
|
#include "simulationenvironment.h"
|
|
#include "Driver.h"
|
|
#include "Logs.h"
|
|
#include "Console.h"
|
|
#include "PyInt.h"
|
|
#include "Timer.h"
|
|
#include "vao.h"
|
|
|
|
void
|
|
global_settings::LoadIniFile(std::string asFileName) {
|
|
|
|
// initialize season data in case the main config file doesn't
|
|
std::time_t timenow = std::time( 0 );
|
|
std::tm *localtime = std::localtime( &timenow );
|
|
fMoveLight = localtime->tm_yday + 1; // numer bieżącego dnia w roku
|
|
simulation::Environment.compute_season( fMoveLight );
|
|
|
|
cParser parser(asFileName, cParser::buffer_FILE);
|
|
ConfigParse(parser);
|
|
};
|
|
|
|
void
|
|
global_settings::ConfigParse(cParser &Parser) {
|
|
|
|
std::string token;
|
|
do
|
|
{
|
|
token = "";
|
|
Parser.getTokens();
|
|
Parser >> token;
|
|
|
|
if( ConfigParse_gfx( Parser, token ) ) {
|
|
continue;
|
|
}
|
|
else if (token == "sceneryfile")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> SceneryFile;
|
|
}
|
|
else if (token == "humanctrlvehicle")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> local_start_vehicle;
|
|
}
|
|
else if (token == "async.trains")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> trainAsyncProcessing;
|
|
}
|
|
else if (token == "fieldofview")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> FieldOfView;
|
|
// guard against incorrect values
|
|
FieldOfView = clamp(FieldOfView, 10.0f, 75.0f);
|
|
}
|
|
else if (token == "width")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> window_size.x;
|
|
}
|
|
else if (token == "height")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> window_size.y;
|
|
}
|
|
else if (token == "heightbase")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> fDistanceFactor;
|
|
}
|
|
else if (token == "targetfps")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> targetfps;
|
|
}
|
|
else if (token == "basedrawrange")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> BaseDrawRange;
|
|
}
|
|
else if (token == "fullscreen")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> bFullScreen;
|
|
}
|
|
else if (token == "fullscreenmonitor")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> fullscreen_monitor;
|
|
}
|
|
else if (token == "fullscreenwindowed")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> fullscreen_windowed;
|
|
}
|
|
else if (token == "vsync")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> VSync;
|
|
}
|
|
else if (token == "freefly")
|
|
{ // Mczapkie-130302
|
|
Parser.getTokens();
|
|
Parser >> FreeFlyModeFlag;
|
|
Parser.getTokens(3, false);
|
|
Parser >> FreeCameraInit[0].x, FreeCameraInit[0].y, FreeCameraInit[0].z;
|
|
}
|
|
else if (token == "wireframe")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> bWireFrame;
|
|
}
|
|
else if (token == "debugmode")
|
|
{ // McZapkie! - DebugModeFlag uzywana w mover.pas,
|
|
// warto tez blokowac cheaty gdy false
|
|
Parser.getTokens();
|
|
Parser >> DebugModeFlag;
|
|
}
|
|
else if (token == "soundenabled")
|
|
{ // McZapkie-040302 - blokada dzwieku - przyda
|
|
// sie do debugowania oraz na komp. bez karty
|
|
// dzw.
|
|
Parser.getTokens();
|
|
Parser >> bSoundEnabled;
|
|
}
|
|
else if (token == "sound.openal.renderer")
|
|
{
|
|
// selected device for audio renderer
|
|
AudioRenderer = Parser.getToken<std::string>(false); // case-sensitive
|
|
}
|
|
else if (token == "sound.volume")
|
|
{
|
|
// selected device for audio renderer
|
|
Parser.getTokens();
|
|
Parser >> AudioVolume;
|
|
AudioVolume = clamp(AudioVolume, 0.f, 2.f);
|
|
}
|
|
else if (token == "sound.volume.radio")
|
|
{
|
|
// selected device for audio renderer
|
|
Parser.getTokens();
|
|
Parser >> DefaultRadioVolume;
|
|
DefaultRadioVolume = clamp(DefaultRadioVolume, 0.f, 1.f);
|
|
}
|
|
else if (token == "sound.maxsources") {
|
|
Parser.getTokens();
|
|
Parser >> audio_max_sources;
|
|
}
|
|
else if( token == "sound.volume.vehicle" ) {
|
|
Parser.getTokens();
|
|
Parser >> VehicleVolume;
|
|
VehicleVolume = clamp(VehicleVolume, 0.f, 1.f);
|
|
}
|
|
else if (token == "sound.volume.positional")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> EnvironmentPositionalVolume;
|
|
EnvironmentPositionalVolume = clamp(EnvironmentPositionalVolume, 0.f, 1.f);
|
|
}
|
|
else if (token == "sound.volume.ambient")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> EnvironmentAmbientVolume;
|
|
EnvironmentAmbientVolume = clamp(EnvironmentAmbientVolume, 0.f, 1.f);
|
|
}
|
|
// else if (str==AnsiString("renderalpha")) //McZapkie-1312302 - dwuprzebiegowe renderowanie
|
|
// bRenderAlpha=(GetNextSymbol().LowerCase()==AnsiString("yes"));
|
|
else if (token == "physicslog")
|
|
{ // McZapkie-030402 - logowanie parametrow
|
|
// fizycznych dla kazdego pojazdu z maszynista
|
|
Parser.getTokens();
|
|
Parser >> WriteLogFlag;
|
|
}
|
|
else if (token == "fullphysics")
|
|
{ // McZapkie-291103 - usypianie fizyki
|
|
Parser.getTokens();
|
|
Parser >> FullPhysics;
|
|
}
|
|
else if (token == "debuglog")
|
|
{
|
|
// McZapkie-300402 - wylaczanie log.txt
|
|
Parser.getTokens();
|
|
Parser >> token;
|
|
if (token == "yes")
|
|
{
|
|
iWriteLogEnabled = 3;
|
|
}
|
|
else if (token == "no")
|
|
{
|
|
iWriteLogEnabled = 0;
|
|
}
|
|
else
|
|
{
|
|
iWriteLogEnabled = stol_def(token, 3);
|
|
}
|
|
}
|
|
else if (token == "multiplelogs")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> MultipleLogs;
|
|
}
|
|
else if (token == "shakefactor")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> ShakingMultiplierBF;
|
|
Parser.getTokens();
|
|
Parser >> ShakingMultiplierRL;
|
|
Parser.getTokens();
|
|
Parser >> ShakingMultiplierUD;
|
|
}
|
|
else if (token == "logs.filter")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> DisabledLogTypes;
|
|
}
|
|
else if (token == "mousescale")
|
|
{
|
|
// McZapkie-060503 - czulosc ruchu myszy (krecenia glowa)
|
|
Parser.getTokens(2, false);
|
|
Parser >> fMouseXScale >> fMouseYScale;
|
|
}
|
|
else if (token == "mousecontrol")
|
|
{
|
|
// whether control pick mode can be activated
|
|
Parser.getTokens();
|
|
Parser >> InputMouse;
|
|
}
|
|
else if (token == "enabletraction")
|
|
{
|
|
// Winger 040204 - 'zywe' patyki dostosowujace sie do trakcji; Ra 2014-03: teraz łamanie
|
|
Parser.getTokens();
|
|
Parser >> bEnableTraction;
|
|
}
|
|
else if (token == "loadtraction")
|
|
{
|
|
// Winger 140404 - ladowanie sie trakcji
|
|
Parser.getTokens();
|
|
Parser >> bLoadTraction;
|
|
}
|
|
else if (token == "friction")
|
|
{ // mnożnik tarcia - KURS90
|
|
Parser.getTokens(1, false);
|
|
Parser >> fFriction;
|
|
}
|
|
else if (token == "livetraction")
|
|
{
|
|
// Winger 160404 - zaleznosc napiecia loka od trakcji;
|
|
// Ra 2014-03: teraz prąd przy braku sieci
|
|
Parser.getTokens();
|
|
Parser >> bLiveTraction;
|
|
}
|
|
else if (token == "skyenabled")
|
|
{
|
|
// youBy - niebo
|
|
Parser.getTokens();
|
|
Parser >> token;
|
|
asSky = (token == "yes" ? "1" : "0");
|
|
}
|
|
else if (token == "defaultext")
|
|
{
|
|
// ShaXbee - domyslne rozszerzenie tekstur
|
|
Parser.getTokens();
|
|
Parser >> token;
|
|
if (token == "tga")
|
|
{
|
|
// domyślnie od TGA
|
|
szDefaultExt = szTexturesTGA;
|
|
}
|
|
else
|
|
{
|
|
szDefaultExt = (token[0] == '.' ? token : "." + token);
|
|
}
|
|
}
|
|
else if (token == "newaircouplers")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> bnewAirCouplers;
|
|
}
|
|
else if (token == "anisotropicfiltering")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> AnisotropicFiltering;
|
|
if (AnisotropicFiltering < 1.0f)
|
|
AnisotropicFiltering = 1.0f;
|
|
}
|
|
else if (token == "usevbo")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> bUseVBO;
|
|
}
|
|
else if (token == "feedbackmode")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> iFeedbackMode;
|
|
}
|
|
else if (token == "feedbackport")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> iFeedbackPort;
|
|
}
|
|
else if (token == "multiplayer")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> iMultiplayer;
|
|
}
|
|
else if (token == "isolatedtrainnumber")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> bIsolatedTrainName;
|
|
}
|
|
else if (token == "maxtexturesize")
|
|
{
|
|
// wymuszenie przeskalowania tekstur
|
|
Parser.getTokens(1, false);
|
|
int size;
|
|
Parser >> size;
|
|
iMaxTextureSize = clamp_power_of_two(size, 64, 8192);
|
|
}
|
|
else if (token == "maxcabtexturesize")
|
|
{
|
|
// wymuszenie przeskalowania tekstur
|
|
Parser.getTokens(1, false);
|
|
int size;
|
|
Parser >> size;
|
|
iMaxCabTextureSize = clamp_power_of_two(size, 512, 8192);
|
|
}
|
|
else if (token == "movelight")
|
|
{
|
|
// numer dnia w roku albo -1
|
|
Parser.getTokens(1, false);
|
|
Parser >> fMoveLight;
|
|
if (fMoveLight == 0.f)
|
|
{ // pobranie daty z systemu
|
|
std::time_t timenow = std::time(0);
|
|
std::tm *localtime = std::localtime(&timenow);
|
|
fMoveLight = localtime->tm_yday + 1; // numer bieżącego dnia w roku
|
|
}
|
|
simulation::Environment.compute_season(fMoveLight);
|
|
}
|
|
else if (token == "dynamiclights")
|
|
{
|
|
// number of dynamic lights in the scene
|
|
Parser.getTokens(1, false);
|
|
Parser >> DynamicLightCount;
|
|
// clamp the light number
|
|
// max 8 lights per opengl specs, minus one used for sun. at least one light for
|
|
// controlled vehicle
|
|
DynamicLightCount = clamp(DynamicLightCount, 0, 7);
|
|
}
|
|
else if (token == "scenario.time.override")
|
|
{
|
|
// shift (in hours) applied to train timetables
|
|
Parser.getTokens(1, false);
|
|
std::string token;
|
|
Parser >> token;
|
|
std::istringstream stream(token);
|
|
if (token.find(':') != -1)
|
|
{
|
|
float a, b;
|
|
char s;
|
|
stream >> a >> s >> b;
|
|
ScenarioTimeOverride = a + b / 60.0;
|
|
}
|
|
else
|
|
stream >> ScenarioTimeOverride;
|
|
ScenarioTimeOverride = clamp(ScenarioTimeOverride, 0.f, 24 * 1439 / 1440.f);
|
|
}
|
|
else if (token == "scenario.time.offset")
|
|
{
|
|
// shift (in hours) applied to train timetables
|
|
Parser.getTokens(1, false);
|
|
Parser >> ScenarioTimeOffset;
|
|
}
|
|
else if (token == "scenario.time.current")
|
|
{
|
|
// sync simulation time with local clock
|
|
Parser.getTokens(1, false);
|
|
Parser >> ScenarioTimeCurrent;
|
|
}
|
|
else if (token == "scenario.weather.temperature")
|
|
{
|
|
// selected device for audio renderer
|
|
Parser.getTokens();
|
|
Parser >> AirTemperature;
|
|
AirTemperature = clamp(AirTemperature, -15.f, 45.f);
|
|
}
|
|
else if (token == "scalespeculars")
|
|
{
|
|
// whether strength of specular highlights should be adjusted (generally needed for
|
|
// legacy 3d models)
|
|
Parser.getTokens();
|
|
Parser >> ScaleSpecularValues;
|
|
}
|
|
else if (token == "gfxrenderer")
|
|
{
|
|
// shadow render toggle
|
|
Parser.getTokens();
|
|
Parser >> GfxRenderer;
|
|
if (GfxRenderer == "full")
|
|
{
|
|
GfxRenderer = "default";
|
|
}
|
|
if (GfxRenderer == "experimental")
|
|
{
|
|
NvRenderer = true;
|
|
GfxRenderer = "experimental";
|
|
}
|
|
BasicRenderer = (GfxRenderer == "simple");
|
|
LegacyRenderer = !NvRenderer && (GfxRenderer != "default");
|
|
}
|
|
else if (token == "shadows")
|
|
{
|
|
// shadow render toggle
|
|
Parser.getTokens();
|
|
Parser >> RenderShadows;
|
|
}
|
|
else if (token == "shadowtune")
|
|
{
|
|
Parser.getTokens(4, false);
|
|
float discard;
|
|
Parser >> shadowtune.map_size >> discard >> shadowtune.range >> discard;
|
|
shadowtune.map_size = clamp_power_of_two<unsigned int>(shadowtune.map_size, 512, 8192);
|
|
// make sure we actually make effective use of all csm stages
|
|
shadowtune.range =
|
|
std::max((shadowtune.map_size <= 2048 ? 75.f : 75.f * shadowtune.map_size / 2048),
|
|
shadowtune.range);
|
|
}
|
|
else if (token == "smoothtraction")
|
|
{
|
|
// podwójna jasność ambient
|
|
Parser.getTokens();
|
|
Parser >> bSmoothTraction;
|
|
}
|
|
else if (token == "splinefidelity")
|
|
{
|
|
// segment size during spline->geometry conversion
|
|
float splinefidelity;
|
|
Parser.getTokens();
|
|
Parser >> splinefidelity;
|
|
SplineFidelity = clamp(splinefidelity, 1.f, 4.f);
|
|
}
|
|
else if (token == "rendercab")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> render_cab;
|
|
}
|
|
else if (token == "createswitchtrackbeds")
|
|
{
|
|
// podwójna jasność ambient
|
|
Parser.getTokens();
|
|
Parser >> CreateSwitchTrackbeds;
|
|
}
|
|
else if (token == "timespeed")
|
|
{
|
|
// przyspieszenie czasu, zmienna do testów
|
|
Parser.getTokens(1, false);
|
|
Parser >> default_timespeed;
|
|
fTimeSpeed = default_timespeed;
|
|
}
|
|
else if (token == "deltaoverride")
|
|
{
|
|
// for debug
|
|
Parser.getTokens(1, false);
|
|
float deltaoverride;
|
|
Parser >> deltaoverride;
|
|
Timer::set_delta_override(1.0f / deltaoverride);
|
|
}
|
|
else if (token == "multisampling")
|
|
{
|
|
// tryb antyaliasingu: 0=brak,1=2px,2=4px
|
|
Parser.getTokens(1, false);
|
|
Parser >> iMultisampling;
|
|
iMultisampling = clamp(iMultisampling, 0, 3);
|
|
}
|
|
else if (token == "latitude")
|
|
{
|
|
// szerokość geograficzna
|
|
Parser.getTokens(1, false);
|
|
Parser >> fLatitudeDeg;
|
|
}
|
|
else if (token == "convertmodels")
|
|
{
|
|
// tworzenie plików binarnych
|
|
Parser.getTokens(1, false);
|
|
Parser >> iConvertModels;
|
|
}
|
|
else if (token == "convertindexrange")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> iConvertIndexRange;
|
|
}
|
|
else if (token == "file.binary.terrain")
|
|
{
|
|
// binary terrain (de)serialization
|
|
Parser.getTokens(1, false);
|
|
Parser >> file_binary_terrain;
|
|
}
|
|
else if (token == "inactivepause")
|
|
{
|
|
// automatyczna pauza, gdy okno nieaktywne
|
|
Parser.getTokens();
|
|
Parser >> bInactivePause;
|
|
}
|
|
else if (token == "slowmotion")
|
|
{
|
|
// tworzenie plików binarnych
|
|
Parser.getTokens(1, false);
|
|
Parser >> iSlowMotionMask;
|
|
}
|
|
else if (token == "hideconsole")
|
|
{
|
|
// hunter-271211: ukrywanie konsoli
|
|
Parser.getTokens();
|
|
Parser >> bHideConsole;
|
|
}
|
|
else if (token == "rollfix")
|
|
{
|
|
// Ra: poprawianie przechyłki, aby wewnętrzna szyna była "pozioma"
|
|
Parser.getTokens();
|
|
Parser >> bRollFix;
|
|
}
|
|
else if (token == "fpsaverage")
|
|
{
|
|
// oczekiwana wartość FPS
|
|
Parser.getTokens(1, false);
|
|
Parser >> fFpsAverage;
|
|
}
|
|
else if (token == "fpsdeviation")
|
|
{
|
|
// odchylenie standardowe FPS
|
|
Parser.getTokens(1, false);
|
|
Parser >> fFpsDeviation;
|
|
}
|
|
else if (token == "calibratein")
|
|
{
|
|
// parametry kalibracji wejść
|
|
Parser.getTokens(1, false);
|
|
int in;
|
|
Parser >> in;
|
|
if ((in < 0) || (in > 5))
|
|
{
|
|
in = 5; // na ostatni, bo i tak trzeba pominąć wartości
|
|
}
|
|
Parser.getTokens(4, false);
|
|
Parser >> fCalibrateIn[in][0] // wyraz wolny
|
|
>> fCalibrateIn[in][1] // mnożnik
|
|
>> fCalibrateIn[in][2] // mnożnik dla kwadratu
|
|
>> fCalibrateIn[in][3]; // mnożnik dla sześcianu
|
|
fCalibrateIn[in][4] = 0.0; // mnożnik 4 potęgi
|
|
fCalibrateIn[in][5] = 0.0; // mnożnik 5 potęgi
|
|
}
|
|
else if (token == "calibrate5din")
|
|
{
|
|
// parametry kalibracji wejść
|
|
Parser.getTokens(1, false);
|
|
int in;
|
|
Parser >> in;
|
|
if ((in < 0) || (in > 5))
|
|
{
|
|
in = 5; // na ostatni, bo i tak trzeba pominąć wartości
|
|
}
|
|
Parser.getTokens(6, false);
|
|
Parser >> fCalibrateIn[in][0] // wyraz wolny
|
|
>> fCalibrateIn[in][1] // mnożnik
|
|
>> fCalibrateIn[in][2] // mnożnik dla kwadratu
|
|
>> fCalibrateIn[in][3] // mnożnik dla sześcianu
|
|
>> fCalibrateIn[in][4] // mnożnik 4 potęgi
|
|
>> fCalibrateIn[in][5]; // mnożnik 5 potęgi
|
|
}
|
|
else if (token == "calibrateout")
|
|
{
|
|
// parametry kalibracji wyjść
|
|
Parser.getTokens(1, false);
|
|
int out;
|
|
Parser >> out;
|
|
if ((out < 0) || (out > 6))
|
|
{
|
|
out = 6; // na ostatni, bo i tak trzeba pominąć wartości
|
|
}
|
|
Parser.getTokens(4, false);
|
|
Parser >> fCalibrateOut[out][0] // wyraz wolny
|
|
>> fCalibrateOut[out][1] // mnożnik liniowy
|
|
>> fCalibrateOut[out][2] // mnożnik dla kwadratu
|
|
>> fCalibrateOut[out][3]; // mnożnik dla sześcianu
|
|
fCalibrateOut[out][4] = 0.0; // mnożnik dla 4 potęgi
|
|
fCalibrateOut[out][5] = 0.0; // mnożnik dla 5 potęgi
|
|
}
|
|
else if (token == "calibrate5dout")
|
|
{
|
|
// parametry kalibracji wyjść
|
|
Parser.getTokens(1, false);
|
|
int out;
|
|
Parser >> out;
|
|
if ((out < 0) || (out > 6))
|
|
{
|
|
out = 6; // na ostatni, bo i tak trzeba pominąć wartości
|
|
}
|
|
Parser.getTokens(6, false);
|
|
Parser >> fCalibrateOut[out][0] // wyraz wolny
|
|
>> fCalibrateOut[out][1] // mnożnik liniowy
|
|
>> fCalibrateOut[out][2] // mnożnik dla kwadratu
|
|
>> fCalibrateOut[out][3] // mnożnik dla sześcianu
|
|
>> fCalibrateOut[out][4] // mnożnik dla 4 potęgi
|
|
>> fCalibrateOut[out][5]; // mnożnik dla 5 potęgi
|
|
}
|
|
else if (token == "calibrateoutmaxvalues")
|
|
{
|
|
// maksymalne wartości jakie można wyświetlić na mierniku
|
|
Parser.getTokens(7, false);
|
|
Parser >> fCalibrateOutMax[0] >> fCalibrateOutMax[1] >> fCalibrateOutMax[2] >>
|
|
fCalibrateOutMax[3] >> fCalibrateOutMax[4] >> fCalibrateOutMax[5] >>
|
|
fCalibrateOutMax[6];
|
|
}
|
|
else if (token == "calibrateoutdebuginfo")
|
|
{
|
|
// wyjście z info o przebiegu kalibracji
|
|
Parser.getTokens(1, false);
|
|
Parser >> iCalibrateOutDebugInfo;
|
|
}
|
|
else if (token == "pwm")
|
|
{
|
|
// zmiana numerów wyjść PWM
|
|
Parser.getTokens(2, false);
|
|
int pwm_out, pwm_no;
|
|
Parser >> pwm_out >> pwm_no;
|
|
iPoKeysPWM[pwm_out] = pwm_no;
|
|
}
|
|
else if (token == "brakestep")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> fBrakeStep;
|
|
}
|
|
else if (token == "brakespeed")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> brake_speed;
|
|
}
|
|
else if (token == "joinduplicatedevents")
|
|
{
|
|
// czy grupować eventy o tych samych nazwach
|
|
Parser.getTokens();
|
|
Parser >> bJoinEvents;
|
|
}
|
|
else if (token == "hiddenevents")
|
|
{
|
|
// czy łączyć eventy z torami poprzez nazwę toru
|
|
Parser.getTokens(1, false);
|
|
Parser >> iHiddenEvents;
|
|
}
|
|
else if (token == "ai.trainman")
|
|
{
|
|
// czy łączyć eventy z torami poprzez nazwę toru
|
|
Parser.getTokens(1, false);
|
|
Parser >> AITrainman;
|
|
}
|
|
else if (token == "pause")
|
|
{
|
|
// czy po wczytaniu ma być pauza?
|
|
Parser.getTokens();
|
|
Parser >> token;
|
|
iPause |= (token == "yes" ? 1 : 0);
|
|
}
|
|
else if (token == "priorityloadtext3d")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> token;
|
|
priorityLoadText3D = (token == "yes" ? true : false);
|
|
}
|
|
else if (token == "lang")
|
|
{
|
|
// domyślny język - http://tools.ietf.org/html/bcp47
|
|
Parser.getTokens(1, false);
|
|
Parser >> asLang;
|
|
}
|
|
else if( token == "python.updatetime" )
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> PythonScreenUpdateRate;
|
|
}
|
|
else if (token == "uitextcolor")
|
|
{
|
|
// color of the ui text. NOTE: will be obsolete once the real ui is in place
|
|
Parser.getTokens(3, false);
|
|
Parser >> UITextColor.r >> UITextColor.g >> UITextColor.b;
|
|
glm::clamp(UITextColor, 0.f, 255.f);
|
|
UITextColor = UITextColor / 255.f;
|
|
UITextColor.a = 1.f;
|
|
}
|
|
else if (token == "ui.bg.opacity")
|
|
{
|
|
// czy grupować eventy o tych samych nazwach
|
|
Parser.getTokens();
|
|
Parser >> UIBgOpacity;
|
|
UIBgOpacity = clamp(UIBgOpacity, 0.f, 1.f);
|
|
}
|
|
else if (token == "input.gamepad")
|
|
{
|
|
// czy grupować eventy o tych samych nazwach
|
|
Parser.getTokens();
|
|
Parser >> InputGamepad;
|
|
}
|
|
else if (token == "motiontelemetry")
|
|
{
|
|
Parser.getTokens(8);
|
|
Global.motiontelemetry_conf.enable = true;
|
|
Parser >> Global.motiontelemetry_conf.proto;
|
|
Parser >> Global.motiontelemetry_conf.address;
|
|
Parser >> Global.motiontelemetry_conf.port;
|
|
Parser >> Global.motiontelemetry_conf.updatetime;
|
|
Parser >> Global.motiontelemetry_conf.includegravity;
|
|
Parser >> Global.motiontelemetry_conf.fwdposbased;
|
|
Parser >> Global.motiontelemetry_conf.latposbased;
|
|
Parser >> Global.motiontelemetry_conf.axlebumpscale;
|
|
}
|
|
if (token == "screenshotsdir")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> Global.screenshot_dir;
|
|
}
|
|
#ifdef WITH_UART
|
|
else if (token == "uart")
|
|
{
|
|
uart_conf.enable = true;
|
|
Parser.getTokens(3, false);
|
|
Parser
|
|
>> uart_conf.port
|
|
>> uart_conf.baud
|
|
>> uart_conf.updatetime;
|
|
}
|
|
else if (token == "uarttune")
|
|
{
|
|
Parser.getTokens(18);
|
|
Parser
|
|
>> uart_conf.mainbrakemin >> uart_conf.mainbrakemax
|
|
>> uart_conf.localbrakemin >> uart_conf.localbrakemax
|
|
>> uart_conf.tankmax >> uart_conf.tankuart
|
|
>> uart_conf.pipemax >> uart_conf.pipeuart
|
|
>> uart_conf.brakemax >> uart_conf.brakeuart
|
|
>> uart_conf.pantographmax >> uart_conf.pantographuart
|
|
>> uart_conf.hvmax >> uart_conf.hvuart
|
|
>> uart_conf.currentmax >> uart_conf.currentuart
|
|
>> uart_conf.lvmax >> uart_conf.lvuart;
|
|
}
|
|
else if (token == "uarttachoscale")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> uart_conf.tachoscale;
|
|
}
|
|
else if (token == "uartfeature")
|
|
{
|
|
Parser.getTokens(1);
|
|
std::string firstToken = Parser.peek();
|
|
|
|
if(firstToken.find('|') != std::string::npos || firstToken == "none" || uartfeatures_map.count(firstToken)) {
|
|
// new format (features delimited by pipe)
|
|
|
|
// all settings should be disabled initially
|
|
for(auto const &x : uartfeatures_map) {
|
|
*(x.second) = false;
|
|
}
|
|
|
|
// and only defined should be enabled
|
|
std::string key;
|
|
std::stringstream firstTokenStream = std::stringstream(firstToken);
|
|
|
|
while(!firstTokenStream.eof()) {
|
|
std::getline(firstTokenStream, key, '|');
|
|
|
|
if(uartfeatures_map.count(key)) {
|
|
*(uartfeatures_map[key]) = true;
|
|
}
|
|
}
|
|
} else {
|
|
// legacy format
|
|
|
|
// first token is already parsed
|
|
Parser >> uart_conf.mainenable;
|
|
|
|
// the rest tokens must be fetched
|
|
Parser.getTokens(3);
|
|
Parser
|
|
>> uart_conf.scndenable
|
|
>> uart_conf.trainenable
|
|
>> uart_conf.localenable;
|
|
}
|
|
}
|
|
else if( token == "uartdebug" ) {
|
|
Parser.getTokens( 1 );
|
|
Parser >> uart_conf.debug;
|
|
}
|
|
else if (token == "uartmainpercentage")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> uart_conf.mainpercentage;
|
|
}
|
|
#endif
|
|
#ifdef WITH_ZMQ
|
|
else if( token == "zmq.address" ) {
|
|
Parser.getTokens( 1 );
|
|
Parser >> zmq_address;
|
|
}
|
|
#endif
|
|
#ifdef USE_EXTCAM_CAMERA
|
|
else if( token == "extcam.cmd" ) {
|
|
Parser.getTokens( 1 );
|
|
Parser >> extcam_cmd;
|
|
}
|
|
else if( token == "extcam.rec" ) {
|
|
Parser.getTokens( 1 );
|
|
Parser >> extcam_rec;
|
|
}
|
|
else if( token == "extcam.res" ) {
|
|
Parser.getTokens( 2 );
|
|
Parser >> extcam_res.x >> extcam_res.y;
|
|
}
|
|
#endif
|
|
else if (token == "loadinglog") {
|
|
Parser.getTokens( 1 );
|
|
Parser >> loading_log;
|
|
}
|
|
else if (token == "ddsupperorigin") {
|
|
Parser.getTokens( 1 );
|
|
Parser >> dds_upper_origin;
|
|
}
|
|
else if (token == "captureonstart") {
|
|
Parser.getTokens( 1 );
|
|
Parser >> captureonstart;
|
|
}
|
|
else if (token == "gui.defaultwindows") {
|
|
Parser.getTokens(1);
|
|
Parser >> gui_defaultwindows;
|
|
}
|
|
else if (token == "gui.showtranscripts") {
|
|
Parser.getTokens(1);
|
|
Parser >> gui_showtranscripts;
|
|
}
|
|
else if (token == "gui.trainingdefault") {
|
|
Parser.getTokens(1);
|
|
Parser >> gui_trainingdefault;
|
|
}
|
|
else if (token == "gfx.angleplatform")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_angleplatform;
|
|
}
|
|
else if (token == "gfx.gldebug")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_gldebug;
|
|
}
|
|
else if (token == "ui.fontsize")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> ui_fontsize;
|
|
}
|
|
else if (token == "ui.scale")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> ui_scale;
|
|
}
|
|
else if (token == "python.enabled")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> python_enabled;
|
|
}
|
|
else if (token == "python.displaywindows")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> python_displaywindows;
|
|
}
|
|
else if (token == "python.threadedupload")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> python_threadedupload;
|
|
}
|
|
else if (token == "python.sharectx")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> python_sharectx;
|
|
}
|
|
else if (token == "python.uploadmain")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> python_uploadmain;
|
|
}
|
|
else if (token == "python.fpslimit")
|
|
{
|
|
Parser.getTokens(1);
|
|
float fpslimit;
|
|
Parser >> fpslimit;
|
|
python_minframetime = std::chrono::duration<float>(1.0f / fpslimit);
|
|
}
|
|
else if (token == "python.vsync")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> python_vsync;
|
|
}
|
|
else if (token == "python.mipmaps")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> python_mipmaps;
|
|
}
|
|
else if (token == "python.viewport")
|
|
{
|
|
Parser.getTokens(8, false);
|
|
|
|
pythonviewport_config conf;
|
|
Parser >> conf.surface >> conf.monitor;
|
|
Parser >> conf.size.x >> conf.size.y;
|
|
Parser >> conf.offset.x >> conf.offset.y;
|
|
Parser >> conf.scale.x >> conf.scale.y;
|
|
|
|
python_viewports.push_back(conf);
|
|
}
|
|
else if (token == "extraviewport")
|
|
{
|
|
Parser.getTokens(3 + 12, false);
|
|
|
|
extraviewport_config conf;
|
|
Parser >> conf.monitor >> conf.width >> conf.height;
|
|
Parser >> conf.draw_range;
|
|
|
|
Parser >> conf.projection.pa.x >> conf.projection.pa.y >> conf.projection.pa.z;
|
|
Parser >> conf.projection.pb.x >> conf.projection.pb.y >> conf.projection.pb.z;
|
|
Parser >> conf.projection.pc.x >> conf.projection.pc.y >> conf.projection.pc.z;
|
|
Parser >> conf.projection.pe.x >> conf.projection.pe.y >> conf.projection.pe.z;
|
|
|
|
extra_viewports.push_back(conf);
|
|
if (gl::vao::use_vao && conf.monitor != "MAIN") {
|
|
gl::vao::use_vao = false;
|
|
WriteLog("using multiple windows, disabling vao!");
|
|
}
|
|
}
|
|
else if (token == "map.highlightdistance") {
|
|
Parser.getTokens(1);
|
|
Parser >> map_highlight_distance;
|
|
}
|
|
else if (token == "headtrack") {
|
|
Parser.getTokens(14);
|
|
Parser >> headtrack_conf.joy;
|
|
Parser >> headtrack_conf.magic_window;
|
|
Parser >> headtrack_conf.move_axes[0] >> headtrack_conf.move_axes[1] >> headtrack_conf.move_axes[2];
|
|
Parser >> headtrack_conf.move_mul[0] >> headtrack_conf.move_mul[1] >> headtrack_conf.move_mul[2];
|
|
Parser >> headtrack_conf.rot_axes[0] >> headtrack_conf.rot_axes[1] >> headtrack_conf.rot_axes[2];
|
|
Parser >> headtrack_conf.rot_mul[0] >> headtrack_conf.rot_mul[1] >> headtrack_conf.rot_mul[2];
|
|
}
|
|
else if (token == "vr.enabled") {
|
|
Parser.getTokens(1);
|
|
Parser >> vr;
|
|
}
|
|
else if (token == "vr.backend") {
|
|
Parser.getTokens(1);
|
|
Parser >> vr_backend;
|
|
}
|
|
else if (token == "compresstex")
|
|
{
|
|
Parser.getTokens(1);
|
|
if (false == gfx_usegles)
|
|
{
|
|
// ogl es use requires compression to be disabled
|
|
Parser >> compress_tex;
|
|
}
|
|
}
|
|
else if (token == "fpslimit")
|
|
{
|
|
Parser.getTokens(1);
|
|
float fpslimit;
|
|
Parser >> fpslimit;
|
|
minframetime = std::chrono::duration<float>(1.0f / fpslimit);
|
|
}
|
|
else if (token == "randomseed")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> Global.random_seed;
|
|
}
|
|
else if (token == "network.server")
|
|
{
|
|
Parser.getTokens(2);
|
|
|
|
std::string backend;
|
|
std::string conf;
|
|
Parser >> backend >> conf;
|
|
|
|
network_servers.push_back(std::make_pair(backend, conf));
|
|
}
|
|
else if (token == "network.client")
|
|
{
|
|
Parser.getTokens(2);
|
|
|
|
network_client.emplace();
|
|
Parser >> network_client->first;
|
|
Parser >> network_client->second;
|
|
}
|
|
else if (token == "execonexit") {
|
|
Parser.getTokens(1);
|
|
Parser >> exec_on_exit;
|
|
std::replace(std::begin(exec_on_exit), std::end(exec_on_exit), '_', ' ');
|
|
}
|
|
else if (token == "map.manualswitchcontrol") {
|
|
Parser.getTokens(1);
|
|
Parser >> map_manualswitchcontrol;
|
|
}
|
|
else if (token == "prepend_scn") {
|
|
Parser.getTokens(1);
|
|
Parser >> prepend_scn;
|
|
}
|
|
else if (token == "crashdamage") {
|
|
Parser.getTokens(1);
|
|
Parser >> crash_damage;
|
|
}
|
|
|
|
} while ((token != "") && (token != "endconfig")); //(!Parser->EndOfFile)
|
|
// na koniec trochę zależności
|
|
if (!bLoadTraction) // wczytywanie drutów i słupów
|
|
{ // tutaj wyłączenie, bo mogą nie być zdefiniowane w INI
|
|
bEnableTraction = false; // false = pantograf się nie połamie
|
|
bLiveTraction = false; // false = pantografy zawsze zbierają 95% MaxVoltage
|
|
}
|
|
if (vr) {
|
|
gfx_skippipeline = false;
|
|
VSync = false;
|
|
}
|
|
/*
|
|
fFpsMin = fFpsAverage -
|
|
fFpsDeviation; // dolna granica FPS, przy której promień scenerii będzie
|
|
zmniejszany fFpsMax = fFpsAverage + fFpsDeviation; // górna granica FPS, przy której promień
|
|
scenerii będzie zwiększany
|
|
*/
|
|
if (iPause)
|
|
iTextMode = GLFW_KEY_F1; // jak pauza, to pokazać zegar
|
|
|
|
#ifndef WITH_PYTHON
|
|
python_enabled = false;
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
Console::ModeSet(iFeedbackMode, iFeedbackPort); // tryb pracy konsoli sterowniczej
|
|
#endif
|
|
}
|
|
|
|
bool
|
|
global_settings::ConfigParse_gfx( cParser &Parser, std::string_view const Token ) {
|
|
|
|
// TODO: move other graphics switches here
|
|
auto tokenparsed { true };
|
|
|
|
if (Token == "gfx.shadows.cab.range")
|
|
{
|
|
// shadow render toggle
|
|
Parser.getTokens();
|
|
Parser >> RenderCabShadowsRange;
|
|
}
|
|
else if (Token == "gfx.smoke")
|
|
{
|
|
// smoke visualization toggle
|
|
Parser.getTokens();
|
|
Parser >> Smoke;
|
|
}
|
|
else if (Token == "gfx.smoke.fidelity")
|
|
{
|
|
// smoke visualization fidelity
|
|
float smokefidelity;
|
|
Parser.getTokens();
|
|
Parser >> smokefidelity;
|
|
SmokeFidelity = clamp(smokefidelity, 1.f, 4.f);
|
|
}
|
|
else if (Token == "gfx.resource.sweep")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> ResourceSweep;
|
|
}
|
|
else if (Token == "gfx.resource.move")
|
|
{
|
|
Parser.getTokens();
|
|
Parser >> ResourceMove;
|
|
}
|
|
else if (Token == "gfx.reflections.framerate")
|
|
{
|
|
auto const updatespersecond{std::abs(Parser.getToken<double>())};
|
|
reflectiontune.update_interval = 1.0 / updatespersecond;
|
|
}
|
|
else if (Token == "gfx.reflections.fidelity")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> reflectiontune.fidelity;
|
|
reflectiontune.fidelity = clamp(reflectiontune.fidelity, 0, 2);
|
|
}
|
|
else if (Token == "gfx.reflections.range_instances")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> reflectiontune.range_instances;
|
|
}
|
|
else if (Token == "gfx.reflections.range_vehicles")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> reflectiontune.range_vehicles;
|
|
}
|
|
else if (Token == "gfx.framebuffer.width")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> gfx_framebuffer_width;
|
|
}
|
|
else if (Token == "gfx.framebuffer.height")
|
|
{
|
|
Parser.getTokens(1, false);
|
|
Parser >> gfx_framebuffer_height;
|
|
}
|
|
else if (Token == "gfx.shadowmap.enabled")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_shadowmap_enabled;
|
|
}
|
|
else if (Token == "gfx.envmap.enabled")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_envmap_enabled;
|
|
}
|
|
else if (Token == "gfx.postfx.motionblur.enabled")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_postfx_motionblur_enabled;
|
|
}
|
|
else if (Token == "gfx.postfx.motionblur.shutter")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_postfx_motionblur_shutter;
|
|
}
|
|
else if (Token == "gfx.postfx.motionblur.format")
|
|
{
|
|
Parser.getTokens(1);
|
|
std::string value;
|
|
Parser >> value;
|
|
if (value == "rg16f")
|
|
gfx_postfx_motionblur_format = GL_RG16F;
|
|
else if (value == "rg32f")
|
|
gfx_postfx_motionblur_format = GL_RG32F;
|
|
}
|
|
else if (Token == "gfx.postfx.chromaticaberration.enabled")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_postfx_chromaticaberration_enabled;
|
|
}
|
|
else if (Token == "gfx.format.color")
|
|
{
|
|
Parser.getTokens(1);
|
|
std::string value;
|
|
Parser >> value;
|
|
if (value == "rgb8")
|
|
gfx_format_color = GL_RGB8;
|
|
else if (value == "rgb16f")
|
|
gfx_format_color = GL_RGB16F;
|
|
else if (value == "rgb32f")
|
|
gfx_format_color = GL_RGB32F;
|
|
else if (value == "r11f_g11f_b10f")
|
|
gfx_format_color = GL_R11F_G11F_B10F;
|
|
}
|
|
else if (Token == "gfx.format.depth")
|
|
{
|
|
Parser.getTokens(1);
|
|
std::string value;
|
|
Parser >> value;
|
|
if (value == "z16")
|
|
gfx_format_depth = GL_DEPTH_COMPONENT16;
|
|
else if (value == "z24")
|
|
gfx_format_depth = GL_DEPTH_COMPONENT24;
|
|
else if (value == "z32")
|
|
gfx_format_depth = GL_DEPTH_COMPONENT32;
|
|
else if (value == "z32f")
|
|
gfx_format_depth = GL_DEPTH_COMPONENT32F;
|
|
}
|
|
else if (Token == "gfx.skiprendering")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_skiprendering;
|
|
}
|
|
else if (Token == "gfx.skippipeline")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_skippipeline;
|
|
}
|
|
else if (Token == "gfx.extraeffects")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_extraeffects;
|
|
}
|
|
else if (Token == "gfx.usegles")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_usegles;
|
|
}
|
|
else if (Token == "gfx.shadergamma")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_shadergamma;
|
|
}
|
|
else if (Token == "gfx.drawrange.factor.max")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_distance_factor_max;
|
|
}
|
|
else if (Token == "gfx.shadow.angle.min")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_shadow_angle_min;
|
|
// variable internally uses negative values, but is presented as positive in settings
|
|
// so it's likely it'll be supplied as positive number by external launcher
|
|
if( gfx_shadow_angle_min > 0 ) {
|
|
gfx_shadow_angle_min *= -1;
|
|
}
|
|
gfx_shadow_angle_min = clamp(gfx_shadow_angle_min, -1.f, -0.2f);
|
|
}
|
|
else if (Token == "gfx.shadow.rank.cutoff")
|
|
{
|
|
Parser.getTokens(1);
|
|
Parser >> gfx_shadow_rank_cutoff;
|
|
gfx_shadow_rank_cutoff = clamp(gfx_shadow_rank_cutoff, 1, 3);
|
|
}
|
|
else
|
|
{
|
|
tokenparsed = false;
|
|
}
|
|
|
|
return tokenparsed;
|
|
}
|
|
|
|
void
|
|
global_settings::export_as_text( std::ostream &Output ) const {
|
|
|
|
export_as_text( Output, "sceneryfile", SceneryFile );
|
|
export_as_text( Output, "humanctrlvehicle", local_start_vehicle );
|
|
export_as_text( Output, "fieldofview", FieldOfView );
|
|
export_as_text( Output, "width", window_size.x );
|
|
export_as_text( Output, "height", window_size.y );
|
|
export_as_text( Output, "targetfps", targetfps );
|
|
export_as_text( Output, "basedrawrange", BaseDrawRange );
|
|
export_as_text( Output, "fullscreen", bFullScreen );
|
|
export_as_text( Output, "fullscreenmonitor", fullscreen_monitor );
|
|
export_as_text( Output, "fullscreenwindowed", fullscreen_windowed );
|
|
export_as_text( Output, "vsync", VSync );
|
|
// NOTE: values are changed dynamically during simulation. cache initial settings and export instead
|
|
if( FreeFlyModeFlag ) {
|
|
Output
|
|
<< "freefly yes "
|
|
<< FreeCameraInit[ 0 ].x << " "
|
|
<< FreeCameraInit[ 0 ].y << " "
|
|
<< FreeCameraInit[ 0 ].z << "\n";
|
|
}
|
|
else {
|
|
export_as_text( Output, "freefly", FreeFlyModeFlag );
|
|
}
|
|
export_as_text( Output, "wireframe", bWireFrame );
|
|
export_as_text( Output, "debugmode", DebugModeFlag );
|
|
export_as_text( Output, "soundenabled", bSoundEnabled );
|
|
export_as_text( Output, "sound.openal.renderer", AudioRenderer );
|
|
export_as_text( Output, "sound.volume", AudioVolume );
|
|
export_as_text( Output, "sound.volume.radio", DefaultRadioVolume );
|
|
export_as_text( Output, "sound.volume.vehicle", VehicleVolume );
|
|
export_as_text( Output, "sound.volume.positional", EnvironmentPositionalVolume );
|
|
export_as_text( Output, "sound.volume.ambient", EnvironmentAmbientVolume );
|
|
export_as_text( Output, "physicslog", WriteLogFlag );
|
|
export_as_text( Output, "fullphysics", FullPhysics );
|
|
export_as_text( Output, "debuglog", iWriteLogEnabled );
|
|
export_as_text( Output, "multiplelogs", MultipleLogs );
|
|
export_as_text( Output, "logs.filter", DisabledLogTypes );
|
|
Output
|
|
<< "mousescale "
|
|
<< fMouseXScale << " "
|
|
<< fMouseYScale << "\n";
|
|
export_as_text( Output, "mousecontrol", InputMouse );
|
|
export_as_text( Output, "enabletraction", bEnableTraction );
|
|
export_as_text( Output, "loadtraction", bLoadTraction );
|
|
export_as_text( Output, "friction", fFriction );
|
|
export_as_text( Output, "livetraction", bLiveTraction );
|
|
export_as_text( Output, "skyenabled", asSky );
|
|
export_as_text( Output, "defaultext", szDefaultExt );
|
|
export_as_text( Output, "newaircouplers", bnewAirCouplers );
|
|
export_as_text( Output, "anisotropicfiltering", AnisotropicFiltering );
|
|
export_as_text( Output, "usevbo", bUseVBO );
|
|
export_as_text( Output, "feedbackmode", iFeedbackMode );
|
|
export_as_text( Output, "feedbackport", iFeedbackPort );
|
|
export_as_text( Output, "multiplayer", iMultiplayer );
|
|
export_as_text( Output, "isolatedtrainnumber", bIsolatedTrainName);
|
|
export_as_text( Output, "maxtexturesize", iMaxTextureSize );
|
|
export_as_text( Output, "maxcabtexturesize", iMaxCabTextureSize );
|
|
export_as_text( Output, "movelight", fMoveLight );
|
|
export_as_text( Output, "dynamiclights", DynamicLightCount );
|
|
if( std::isnormal( ScenarioTimeOverride ) ) {
|
|
export_as_text( Output, "scenario.time.override", ScenarioTimeOverride );
|
|
}
|
|
export_as_text( Output, "scenario.time.offset", ScenarioTimeOffset );
|
|
export_as_text( Output, "scenario.time.current", ScenarioTimeCurrent );
|
|
export_as_text( Output, "scenario.weather.temperature", AirTemperature );
|
|
export_as_text( Output, "ai.trainman", AITrainman );
|
|
export_as_text( Output, "scalespeculars", ScaleSpecularValues );
|
|
export_as_text( Output, "gfxrenderer", GfxRenderer );
|
|
export_as_text( Output, "shadows", RenderShadows );
|
|
Output
|
|
<< "shadowtune "
|
|
<< shadowtune.map_size << " "
|
|
<< 0 << " "
|
|
<< shadowtune.range << " "
|
|
<< 0 << "\n";
|
|
export_as_text( Output, "gfx.shadows.cab.range", RenderCabShadowsRange );
|
|
export_as_text( Output, "gfx.smoke", Smoke );
|
|
export_as_text( Output, "gfx.smoke.fidelity", SmokeFidelity );
|
|
export_as_text( Output, "smoothtraction", bSmoothTraction );
|
|
export_as_text( Output, "splinefidelity", SplineFidelity );
|
|
export_as_text( Output, "rendercab", render_cab );
|
|
export_as_text( Output, "createswitchtrackbeds", CreateSwitchTrackbeds );
|
|
export_as_text( Output, "gfx.resource.sweep", ResourceSweep );
|
|
export_as_text( Output, "gfx.resource.move", ResourceMove );
|
|
export_as_text( Output, "gfx.reflections.framerate", 1.0 / reflectiontune.update_interval );
|
|
export_as_text( Output, "gfx.reflections.fidelity", reflectiontune.fidelity );
|
|
export_as_text( Output, "timespeed", fTimeSpeed );
|
|
export_as_text( Output, "multisampling", iMultisampling );
|
|
export_as_text( Output, "latitude", fLatitudeDeg );
|
|
export_as_text( Output, "convertmodels", iConvertModels );
|
|
export_as_text( Output, "file.binary.terrain", file_binary_terrain );
|
|
export_as_text( Output, "inactivepause", bInactivePause );
|
|
export_as_text( Output, "slowmotion", iSlowMotionMask );
|
|
export_as_text( Output, "hideconsole", bHideConsole );
|
|
export_as_text( Output, "rollfix", bRollFix );
|
|
export_as_text( Output, "fpsaverage", fFpsAverage );
|
|
export_as_text( Output, "fpsdeviation", fFpsDeviation );
|
|
for( auto idx = 0; idx < 6; ++idx ) {
|
|
Output
|
|
<< "calibrate5din "
|
|
<< idx << " "
|
|
<< fCalibrateIn[ idx ][ 0 ] << " "
|
|
<< fCalibrateIn[ idx ][ 1 ] << " "
|
|
<< fCalibrateIn[ idx ][ 2 ] << " "
|
|
<< fCalibrateIn[ idx ][ 3 ] << " "
|
|
<< fCalibrateIn[ idx ][ 4 ] << " "
|
|
<< fCalibrateIn[ idx ][ 5 ] << "\n";
|
|
}
|
|
for( auto idx = 0; idx < 6; ++idx ) {
|
|
Output
|
|
<< "calibrate5dout "
|
|
<< idx << " "
|
|
<< fCalibrateOut[ idx ][ 0 ] << " "
|
|
<< fCalibrateOut[ idx ][ 1 ] << " "
|
|
<< fCalibrateOut[ idx ][ 2 ] << " "
|
|
<< fCalibrateOut[ idx ][ 3 ] << " "
|
|
<< fCalibrateOut[ idx ][ 4 ] << " "
|
|
<< fCalibrateOut[ idx ][ 5 ] << "\n";
|
|
}
|
|
Output
|
|
<< "calibrateoutmaxvalues "
|
|
<< fCalibrateOutMax[ 0 ] << " "
|
|
<< fCalibrateOutMax[ 1 ] << " "
|
|
<< fCalibrateOutMax[ 2 ] << " "
|
|
<< fCalibrateOutMax[ 3 ] << " "
|
|
<< fCalibrateOutMax[ 4 ] << " "
|
|
<< fCalibrateOutMax[ 5 ] << " "
|
|
<< fCalibrateOutMax[ 6 ] << "\n";
|
|
export_as_text( Output, "calibrateoutdebuginfo", iCalibrateOutDebugInfo );
|
|
for( auto idx = 0; idx < 7; ++idx ) {
|
|
Output
|
|
<< "pwm "
|
|
<< idx << " "
|
|
<< iPoKeysPWM[ idx ] << "\n";
|
|
}
|
|
export_as_text( Output, "brakestep", fBrakeStep );
|
|
export_as_text( Output, "joinduplicatedevents", bJoinEvents );
|
|
export_as_text( Output, "hiddenevents", iHiddenEvents );
|
|
export_as_text( Output, "pause", ( iPause & 1 ) != 0 );
|
|
export_as_text(Output, "priorityLoadText3D", priorityLoadText3D);
|
|
export_as_text( Output, "lang", asLang );
|
|
export_as_text( Output, "python.updatetime", PythonScreenUpdateRate );
|
|
Output
|
|
<< "uitextcolor "
|
|
<< UITextColor.r * 255 << " "
|
|
<< UITextColor.g * 255 << " "
|
|
<< UITextColor.b * 255 << "\n";
|
|
export_as_text( Output, "ui.bg.opacity", UIBgOpacity );
|
|
export_as_text( Output, "input.gamepad", InputGamepad );
|
|
#ifdef WITH_UART
|
|
if( uart_conf.enable ) {
|
|
Output
|
|
<< "uart "
|
|
<< uart_conf.port << " "
|
|
<< uart_conf.baud << " "
|
|
<< uart_conf.updatetime << "\n";
|
|
}
|
|
Output
|
|
<< "uarttune "
|
|
<< uart_conf.mainbrakemin << " "
|
|
<< uart_conf.mainbrakemax << " "
|
|
<< uart_conf.localbrakemin << " "
|
|
<< uart_conf.localbrakemax << " "
|
|
<< uart_conf.tankmax << " "
|
|
<< uart_conf.tankuart << " "
|
|
<< uart_conf.pipemax << " "
|
|
<< uart_conf.pipeuart << " "
|
|
<< uart_conf.brakemax << " "
|
|
<< uart_conf.brakeuart << " "
|
|
<< uart_conf.pantographmax << " "
|
|
<< uart_conf.pipemax << " "
|
|
<< uart_conf.hvmax << " "
|
|
<< uart_conf.hvuart << " "
|
|
<< uart_conf.currentmax << " "
|
|
<< uart_conf.currentuart << " "
|
|
<< uart_conf.lvmax << " "
|
|
<< uart_conf.lvuart << "\n";
|
|
export_as_text( Output, "uarttachoscale", uart_conf.tachoscale );
|
|
|
|
std::vector<std::string> enabled_uartfeatures;
|
|
for(auto const &x : uartfeatures_map) {
|
|
if(*(x.second)) {
|
|
enabled_uartfeatures.push_back(x.first);
|
|
}
|
|
}
|
|
Output << "uartfeature ";
|
|
if(enabled_uartfeatures.empty()) {
|
|
Output << "none\n";
|
|
} else {
|
|
for(auto const &feature : enabled_uartfeatures) {
|
|
Output << feature;
|
|
if(&feature != &enabled_uartfeatures.back()) {
|
|
Output << "|";
|
|
}
|
|
}
|
|
Output << "\n";
|
|
}
|
|
export_as_text( Output, "uartdebug", uart_conf.debug );
|
|
#endif
|
|
|
|
export_as_text( Output, "extcam.cmd", extcam_cmd );
|
|
export_as_text( Output, "extcam.rec", extcam_rec );
|
|
Output
|
|
<< "extcam.res "
|
|
<< extcam_res.x << " "
|
|
<< extcam_res.y << "\n";
|
|
|
|
export_as_text( Output, "compresstex", compress_tex );
|
|
export_as_text( Output, "gfx.framebuffer.width", gfx_framebuffer_width );
|
|
export_as_text( Output, "gfx.framebuffer.height", gfx_framebuffer_height );
|
|
export_as_text( Output, "gfx.shadowmap.enabled", gfx_shadowmap_enabled );
|
|
// TODO: export fpslimit
|
|
export_as_text( Output, "randomseed", Global.random_seed );
|
|
export_as_text( Output, "gfx.envmap.enabled", gfx_envmap_enabled );
|
|
export_as_text( Output, "gfx.postfx.motionblur.enabled", gfx_postfx_motionblur_enabled );
|
|
export_as_text( Output, "gfx.postfx.motionblur.shutter", gfx_postfx_motionblur_shutter );
|
|
// TODO: export gfx_postfx_motionblur_format
|
|
export_as_text( Output, "gfx.postfx.chromaticaberration.enabled", gfx_postfx_chromaticaberration_enabled );
|
|
// TODO: export gfx_format_color
|
|
// TODO: export gfx_format_depth
|
|
export_as_text( Output, "gfx.skiprendering", gfx_skiprendering );
|
|
export_as_text( Output, "gfx.skippipeline", gfx_skippipeline );
|
|
export_as_text( Output, "gfx.extraeffects", gfx_extraeffects );
|
|
export_as_text( Output, "gfx.shadergamma", gfx_shadergamma );
|
|
export_as_text( Output, "gfx.shadow.angle.min", gfx_shadow_angle_min );
|
|
export_as_text( Output, "gfx.shadow.rank.cutoff", gfx_shadow_rank_cutoff );
|
|
export_as_text( Output, "python.enabled", python_enabled );
|
|
export_as_text( Output, "python.threadedupload", python_threadedupload );
|
|
export_as_text( Output, "python.uploadmain", python_uploadmain );
|
|
export_as_text( Output, "python.mipmaps", python_mipmaps );
|
|
for( auto const &server : network_servers ) {
|
|
Output
|
|
<< "network.server "
|
|
<< server.first << " " << server.second << "\n";
|
|
}
|
|
if( network_client ) {
|
|
Output
|
|
<< "network.client "
|
|
<< network_client->first << " " << network_client->second << "\n";
|
|
}
|
|
export_as_text( Output, "execonexit", exec_on_exit );
|
|
}
|
|
|
|
template <>
|
|
void
|
|
global_settings::export_as_text( std::ostream &Output, std::string const Key, std::string const &Value ) const {
|
|
|
|
if( Value.empty() ) { return; }
|
|
|
|
if( contains( Value, ' ' ) ) {
|
|
Output << Key << " \"" << Value << "\"\n";
|
|
}
|
|
else {
|
|
Output << Key << " " << Value << "\n";
|
|
}
|
|
}
|
|
|
|
template <> void global_settings::export_as_text(std::ostream &Output, std::string const Key, bool const &Value) const
|
|
{
|
|
|
|
Output << Key << " " << (Value ? "yes" : "no") << "\n";
|
|
}
|
|
|
|
global_settings &GetGlobalSettings()
|
|
{
|
|
static global_settings global{};
|
|
return global;
|
|
}
|