forked from firleju/maszyna
-
Notifications
You must be signed in to change notification settings - Fork 2
/
Globals.h
273 lines (255 loc) · 11.7 KB
/
Globals.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
/*
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/.
*/
#pragma once
#define WITH_UART
#include "Classes.h"
#include "Camera.h"
#include "dumb3d.h"
#include "Float3d.h"
#include "light.h"
#ifdef WITH_UART
#include "uart.h"
#endif
#include "utilities.h"
struct global_settings {
// members
// data items
// TODO: take these out of the settings
bool shiftState{ false }; //m7todo: brzydko
bool ctrlState{ false };
bool altState{ false };
std::mt19937 random_engine;
std::mt19937 local_random_engine;
bool ready_to_load{ false };
std::time_t starting_timestamp = 0; // starting time, in local timezone
uint32_t random_seed = 0;
TCamera pCamera; // parametry kamery
TCamera pDebugCamera;
std::array<Math3D::vector3, 10> FreeCameraInit; // pozycje kamery
std::array<Math3D::vector3, 10> FreeCameraInitAngle;
int iCameraLast{ -1 };
int iSlowMotion{ 0 }; // info o malym FPS: 0-OK, 1-wyłączyć multisampling, 3-promień 1.5km, 7-1km
basic_light DayLight;
float SunAngle{ 0.f }; // angle of the sun relative to horizon
double fLuminance{ 1.0 }; // jasność światła do automatycznego zapalania
double fTimeAngleDeg{ 0.0 }; // godzina w postaci kąta
float fClockAngleDeg[ 6 ]; // kąty obrotu cylindrów dla zegara cyfrowego
std::string LastGLError;
float ZoomFactor{ 1.f }; // determines current camera zoom level. TODO: move it to the renderer
bool CabWindowOpen{ false }; // controls sound attenuation between cab and outside
bool ControlPicking{ true }; // indicates controls pick mode is active
bool DLFont{ false }; // switch indicating presence of basic font
bool bActive{ true }; // czy jest aktywnym oknem
int iPause{ 0 }; // globalna pauza ruchu: b0=start,b1=klawisz,b2=tło,b3=lagi,b4=wczytywanie
float AirTemperature{ 15.f };
std::string asCurrentSceneryPath{ "scenery/" };
std::string asCurrentTexturePath{ szTexturePath };
std::string asCurrentDynamicPath;
int CurrentMaxTextureSize{ 4096 };
bool GfxFramebufferSRGB{ true };
bool UpdateMaterials{ true };
// settings
// filesystem
bool bLoadTraction{ true };
bool CreateSwitchTrackbeds{ true };
std::string szTexturesTGA{ ".tga" }; // lista tekstur od TGA
std::string szTexturesDDS{ ".dds" }; // lista tekstur od DDS
std::string szDefaultExt{ szTexturesDDS };
std::string SceneryFile{ "td.scn" };
std::string local_start_vehicle{ "EU07-424" };
int iConvertModels{ 0 }; // tworzenie plików binarnych
bool file_binary_terrain{ true }; // enable binary terrain (de)serialization
// logs
int iWriteLogEnabled{ 3 }; // maska bitowa: 1-zapis do pliku, 2-okienko, 4-nazwy torów
bool MultipleLogs{ false };
unsigned int DisabledLogTypes{ 0 };
// simulation
bool RealisticControlMode{ false }; // controls ability to steer the vehicle from outside views
bool bEnableTraction{ true };
float fFriction{ 1.f }; // mnożnik tarcia - KURS90
float FrictionWeatherFactor{ 1.f };
bool bLiveTraction{ true };
float Overcast{ 0.1f }; // NOTE: all this weather stuff should be moved elsewhere
glm::vec3 FogColor = { 0.6f, 0.7f, 0.8f };
float fFogEnd{ 7500 };
std::string Season{}; // season of the year, based on simulation date
std::string Weather{ "cloudy:" }; // current weather
std::string Period{}; // time of the day, based on sun position
bool FullPhysics{ true }; // full calculations performed for each simulation step
bool bnewAirCouplers{ true };
float fMoveLight{ 0.f }; // numer dnia w roku albo -1
bool FakeLight{ false }; // toggle between fixed and dynamic daylight
double fTimeSpeed{ 1.0 }; // przyspieszenie czasu, zmienna do testów
double fLatitudeDeg{ 52.0 }; // szerokość geograficzna
float ScenarioTimeOverride{ std::numeric_limits<float>::quiet_NaN() }; // requested scenario start time
float ScenarioTimeOffset{ 0.f }; // time shift (in hours) applied to train timetables
bool ScenarioTimeCurrent{ false }; // automatic time shift to match scenario time with local clock
bool bInactivePause{ true }; // automatyczna pauza, gdy okno nieaktywne
int iSlowMotionMask{ -1 }; // maska wyłączanych właściwości
bool bHideConsole{ false }; // hunter-271211: ukrywanie konsoli
bool bRollFix{ true }; // czy wykonać przeliczanie przechyłki
bool bJoinEvents{ false }; // czy grupować eventy o tych samych nazwach
int iHiddenEvents{ 1 }; // czy łączyć eventy z torami poprzez nazwę toru
bool AITrainman{ true }; // virtual assistant performing consist coupling/decoupling and other maintenance tasks
// ui
int PythonScreenUpdateRate{ 200 }; // delay between python-based screen updates, in milliseconds
int iTextMode{ 0 }; // tryb pracy wyświetlacza tekstowego
glm::vec4 UITextColor{ glm::vec4( 225.f / 255.f, 225.f / 255.f, 225.f / 255.f, 1.f ) }; // base color of UI text
float UIBgOpacity{ 0.65f }; // opacity of ui windows
std::string asLang{ "pl" }; // domyślny język - http://tools.ietf.org/html/bcp47
// gfx
int iWindowWidth{ 800 };
int iWindowHeight{ 600 };
float fDistanceFactor{ 1.f }; // baza do przeliczania odległości dla LoD
float targetfps{ 0.0f };
bool bFullScreen{ false };
bool VSync{ false };
bool bWireFrame{ false };
bool bAdjustScreenFreq{ true };
float BaseDrawRange{ 2500.f };
int DynamicLightCount{ 7 };
bool ScaleSpecularValues{ true };
std::string GfxRenderer{ "default" };
bool LegacyRenderer{ false };
bool BasicRenderer{ false };
bool RenderShadows{ true };
int RenderCabShadowsRange{ 0 };
struct shadowtune_t {
unsigned int map_size{ 2048 };
float range{ 250.f };
} shadowtune;
struct reflectiontune_t {
double update_interval{ 300.0 };
int fidelity{ 0 }; // 0: sections, 1: +static models, 2: +vehicles
float range_instances{ 750.f };
float range_vehicles{ 250.f };
} reflectiontune;
bool bUseVBO{ true }; // czy jest VBO w karcie graficznej (czy użyć)
float AnisotropicFiltering{ 8.f }; // requested level of anisotropic filtering. TODO: move it to renderer object
float FieldOfView{ 45.f }; // vertical field of view for the camera. TODO: move it to the renderer
GLint iMaxTextureSize{ 4096 }; // maksymalny rozmiar tekstury
GLint iMaxCabTextureSize{ 4096 }; // largest allowed texture in vehicle cab
int iMultisampling{ 2 }; // tryb antyaliasingu: 0=brak,1=2px,2=4px,3=8px,4=16px
bool bSmoothTraction{ true }; // wygładzanie drutów starym sposobem
float SplineFidelity{ 1.f }; // determines segment size during conversion of splines to geometry
bool Smoke{ true }; // toggles smoke simulation and visualization
float SmokeFidelity{ 1.f }; // determines amount of generated smoke particles
bool ResourceSweep{ true }; // gfx resource garbage collection
bool ResourceMove{ false }; // gfx resources are moved between cpu and gpu side instead of sending a copy
bool compress_tex{ true }; // all textures are compressed on gpu side
std::string asSky{ "1" };
float fFpsAverage{ 0.f }; // oczekiwana wartosć FPS
float fFpsDeviation{ 5.f }; // odchylenie standardowe FPS
double fFpsMin{ 30.0 }; // dolna granica FPS, przy której promień scenerii będzie zmniejszany
double fFpsMax{ 65.0 }; // górna granica FPS, przy której promień scenerii będzie zwiększany
// audio
bool bSoundEnabled{ true };
float AudioVolume{ 1.f };
float RadioVolume{ 0.75f };
float VehicleVolume{ 1.0f };
float EnvironmentPositionalVolume{ 1.0f };
float EnvironmentAmbientVolume{ 1.0f };
float PausedVolume { 0.15f };
std::string AudioRenderer;
// input
float fMouseXScale{ 1.5f };
float fMouseYScale{ 0.2f };
int iFeedbackMode{ 1 }; // tryb pracy informacji zwrotnej
int iFeedbackPort{ 0 }; // dodatkowy adres dla informacji zwrotnych
bool InputGamepad{ true }; // whether gamepad support is enabled
bool InputMouse{ true }; // whether control pick mode can be activated
double fBrakeStep{ 1.0 }; // krok zmiany hamulca dla klawiszy [Num3] i [Num9]
// parametry kalibracyjne wejść z pulpitu
double fCalibrateIn[ 6 ][ 6 ] = {
{ 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0 } };
// parametry kalibracyjne wyjść dla pulpitu
double fCalibrateOut[ 7 ][ 6 ] = {
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0 } };
// wartości maksymalne wyjść dla pulpitu
double fCalibrateOutMax[ 7 ] = {
0, 0, 0, 0, 0, 0, 0 };
int iCalibrateOutDebugInfo{ -1 }; // numer wyjścia kalibrowanego dla którego wyświetlać informacje podczas kalibracji
int iPoKeysPWM[ 7 ] = { 0, 1, 2, 3, 4, 5, 6 }; // numery wejść dla PWM
#ifdef WITH_UART
uart_input::conf_t uart_conf;
#endif
// multiplayer
int iMultiplayer{ 0 }; // blokada działania niektórych eventów na rzecz kominikacji
// other
std::string AppName{ "EU07" };
std::string asVersion{ "UNKNOWN" }; // z opisem
// TODO: move these to relevant areas
bool render_cab = true;
std::chrono::duration<float> minframetime{ 0.0f };
std::string fullscreen_monitor;
bool fullscreen_windowed{ false };
bool python_enabled = true;
bool python_mipmaps = true;
bool python_threadedupload = true;
bool python_uploadmain = true;
bool gfx_skiprendering = false;
int gfx_framebuffer_width = -1;
int gfx_framebuffer_height = -1;
int gfx_framebuffer_fidelity = -1;
bool gfx_shadowmap_enabled = true;
bool gfx_envmap_enabled = true;
bool gfx_postfx_motionblur_enabled = true;
float gfx_postfx_motionblur_shutter = 0.01f;
GLenum gfx_postfx_motionblur_format = GL_RG16F;
GLenum gfx_format_color = GL_RGB16F;
GLenum gfx_format_depth = GL_DEPTH_COMPONENT32F;
bool gfx_postfx_chromaticaberration_enabled = true;
bool gfx_skippipeline = false;
bool gfx_extraeffects = true;
bool gfx_shadergamma = false;
bool gfx_usegles = false;
float gfx_distance_factor_max { 3.f };
float gfx_shadow_angle_min { -0.2f };
int gfx_shadow_rank_cutoff { 3 };
std::string exec_on_exit;
std::vector<std::pair<std::string, std::string>> network_servers;
std::optional<std::pair<std::string, std::string>> network_client;
double desync = 0.0;
float m_skysaturationcorrection{ 1.65f };
float m_skyhuecorrection{ 0.5f };
// methods
void LoadIniFile( std::string asFileName );
void ConfigParse( cParser &parser );
bool ConfigParse_gfx( cParser &parser, std::string_view const Token );
// sends basic content of the class in legacy (text) format to provided stream
void
export_as_text( std::ostream &Output ) const;
template <typename Type_>
void
export_as_text( std::ostream &Output, std::string const Key, Type_ const &Value ) const;
};
template <typename Type_>
void
global_settings::export_as_text( std::ostream &Output, std::string const Key, Type_ const &Value ) const {
Output << Key << " " << Value << "\n";
}
template <>
void
global_settings::export_as_text( std::ostream &Output, std::string const Key, std::string const &Value ) const;
template <>
void
global_settings::export_as_text( std::ostream &Output, std::string const Key, bool const &Value ) const;
extern global_settings Global;
//---------------------------------------------------------------------------