18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 08:35:01 +01:00
Commit Graph

3702 Commits

Author SHA1 Message Date
maj00r
8794c80c58 fix(models): a scenery light that is off no longer shows lit for a moment the first time it comes into view (#407)
* fix(models): a scenery light that is off no longer shows lit for a moment the first time it comes into view

Since d13c27a7 (the light blinking rework) the opacity of a light changes step
by step from its last value, and the opacities start at 1. RaAnimate runs only
for the instances that are drawn, so a model with "lights 0" (a W24 LED
indicator, for one) was drawn lit when it first came into range and faded out
over 0.45 s. Before d13c27a7 the opacity of a plain on/off light was worked out
anew from a timer starting at 0, so a light that is off was off from the first
frame.

Now the first time an instance is animated its lights take their current
state at once, whether it came from the definition or from an event since.
Every later change fades as before. The light threshold modes (ls_Dark,
ls_Home) are untouched. The only other difference from before d13c27a7: a
light that is on no longer fades in the first time it is drawn.

* fix(models): the light opacity step written without an implicit double to float conversion (Sonar S5276)

The sum is still worked out in double and rounded to float once, as the
compound assignment did, so the result is the same to the bit.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:52 +01:00
maj00r
79c88c1793 Python screens: the worker's image goes in place only after its fence, not a bare glFlush (#411)
* fix(python): a screen uploaded by the worker goes into a texture of its own, put in place after a fence

With python.threadedupload (the default) the worker wrote the image into the texture the drawing thread
draws from, with glTexImage2D and glGenerateMipmap from its own context, and only a glFlush after. Nothing
ordered the two contexts: the drawing one could sample the texture while its storage was being made anew,
its level 0 half written or its mipmaps not made yet, and on a change of size the worker deleted the texture
and wrote a new name into `id` with no synchronisation.

The worker now uploads each image into a new texture, sets a fence after it and flushes. The drawing thread,
once per frame in python_taskqueue::update(), waits for that fence on the gpu (glWaitSync, the cpu goes on),
deletes the old texture and puts the new one in place. The worker no longer touches the texture drawn from,
nor `id`. An image the drawing thread didn't take yet is dropped by the next one. Without sync objects the
worker waits for the upload with glFinish.

The windows of python.displaywindows with python.sharectx bound the texture once; they now bind the name of
the last image put in place, which python_rt keeps for them.

Uploads on the drawing thread (python.threadedupload no, the Lua and WebAssembly screens, the editor) are
as they were.

* fix(python): the image of the worker goes in place once its fence is signalled, the viewer binds it each frame

From the review of 8811ee5a:

- glWaitSync ordered only the context of the main window. The extra viewports and the windows of
  python.displaywindows draw in contexts of their own and could bind the new texture before the upload
  was done. commit_thread_upload() now asks the fence without waiting (glClientWaitSync, timeout 0) and
  puts the image in place only once it is signalled, so every context binding it afterwards has it whole.
  Until then the task stays in the upload queue and is asked again the next frame.
- The drawing thread chose between upload and commit by python.threadedupload, the worker by whether it
  got a context. With python.threadedupload on and no context made for the worker, the screens were no
  longer updated. The task now records that a worker uploaded it.
- The viewer of python.displaywindows told a new image by its texture name, but a deleted name comes back
  for a later texture. It binds the name of the last image each frame, read under the lock of the render
  target, and the name it starts with is read on the drawing thread when it is made.

* fix(python): the old texture deleted under the lock the viewers bind under, a fence not made waited for with glFinish

From the review of #411:

- finish_upload() deleted the old texture before it took the lock of the render target, and the
  windows of python.displaywindows read the name under that lock but bound it after letting go of it.
  A window could bind a name already deleted, or already given to the next upload. In a compatibility
  context (the legacy renderer) that makes a new empty texture: a black frame and a texture never
  deleted. The commit and the publishing of the new name now go under the lock, and the viewer binds
  under it too. A name bound before the deletion stays alive in that window's context while bound.
- A glFenceSync that returns no fence was taken for a signalled one: the image went in place at once,
  with nothing ordering the contexts. The worker now waits for its upload with glFinish then, as
  without sync objects.

* fix(python): the worker waits for the lock of the screen without the gil, no flush after a finish

From the review of 939514ea:

- The drawing thread now holds the lock of the render target for a whole upload with
  python.threadedupload off. The worker, copying the next image under that lock, waited for it holding
  the gil. It now lets the gil go around the lock and the copy: the bytes it copies stay valid, the
  object is immutable and held by the reference the worker has.
- glFlush after glFinish did nothing; the worker flushes only when it made a fence.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:42 +01:00
maj00r
1b26caca24 fix: inverted clamp bounds give the upper bound again, as the old clamp did (#412)
* fix: inverted clamp bounds give the upper bound again, as the old clamp did

The project's own clamp() of 26.05 applied the lower bound first and the
upper one last, so bounds given the wrong way round always gave the upper
one. Its calls became std::clamp (undefined for such bounds) and, where the
bounds can cross, safe_clamp, which swapped them instead. Neither gives the
old result.

- safe_clamp is the old clamp again, min(max(value, lo), hi). This restores
  26.05 at every place it is used, among them the AI's dynamic brake test
  (its demand was fAccThreshold x1.21, the swap made it x1.01), the
  generator voltage, the heavy cargo acceleration of the AI and the EP
  correction of the brake.
- The cab camera is kept inside the cab with safe_clamp. The bounds come
  from the .mmd as written and some cabs have them reversed (the B cars of
  SA134 and 21xM, ET40, 754); with std::clamp the camera jumped between
  the two bounds every frame on MSVC, as its result is fed back.

* fix: every call of the old clamp gives what it gave up to 26.05.1

d1f16411 (#99) made every call of the project's clamp() std::clamp. Where the bounds come from the data or
are computed at runtime they can cross, and then std::clamp gives another result (undefined behaviour;
MSVC gives the lower bound unless the value is above the upper one) where the old clamp gave the upper
bound. These calls use safe_clamp, the old clamp, too:

- Mover: the pantograph pressure (MaxPress), the compressor switch (CompressorListPosNo), the coupler
  distance (DmaxB, DmaxC), the engine revolutions, the eimic ramp (CtrlDelay), the eimic limit
  (eimic_max), the speed control ramp (PowerUpSpeed, PowerDownSpeed), the load (MaxLoad), the magnet of
  the security system (Dim.L);
- DynObj: the coupler distance of the buffers (DmaxB), the axle distance (Dim.L);
- Train: the brake handle positions (BrakeCtrlPosNo, the range of the handle);
- the legacy renderer: the mouse pick (the window size).

With the bounds in order nothing changes. Calls whose bounds the code keeps in order (constants,
SplineFidelity 1-4, the season table, the guarded output calibration) give the same result with
std::clamp and stay as they are.

The load offset takes its arguments in the 26.05.1 order again; fa2ed089 swapped them, which with the
old clamp differs only for a negative load.

The bump at a rail joint gives the old result again. Up to 26.05.1 its clamps had 0 in place of the
value (since 96f43e11 and 4d72d352), and the old clamp made that the headroom Vmax - (Vel + 0.32 Vmax),
negative above 68% of the top speed, capped from above only; d464628a and 03bfbb13 kept it at 0 or
above. Only damaged track has the bump: a damage flag in the .scn, a derailer set by an event, a track
made on a derailment.

The interior light of the cab in the 3.3 renderer is computed in double again, as before d1f16411.

The call added since (stepped_uc_value, 00955513) keeps what master does: bounds given the other way
round are put in order.

* fix: the alpha of a particle in the legacy renderer as up to 26.05.1, the NaN cases of the clamp tested

Up to 26.05.1 the alpha was clamp<std::uint8_t>( particle.opacity * 255, 0, 255 ): the float was
made a byte first, so the clamp did nothing and an opacity over 1 (a smoke max_opacity over 1)
wrapped round, 1.2 giving 50. The move to std::clamp made it 255. It's made a byte as then again,
through int: the byte the x86-64 compilers gave, without the undefined behaviour of that conversion
(MSVC makes the same two instructions of both). openglparticles.cpp goes with feat/gl46-migration;
its opengl33 counterpart, std::clamp( opacity, 0, 1 ), already gives what 26.05.1 gave.

The tests pin what the old clamp gave with NaN: a NaN value stays NaN, a NaN bound doesn't clamp.
The checks named after the AI braking test and the bump at a rail joint say they test the helper with
the arguments of those calls, not the calls.

* test: the includes of the clamp tests before the project's headers

<cmath> and <limits> go up, after the test headers, so the change no longer touches the lines
#416 adds its includes after. With both merged <cmath> is included twice, which is harmless.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:29 +01:00
maj00r
a1fbdf47c6 fix(camera): the cab shake taken at the frame's moment between its fixed steps, it no longer moves in steps (#403)
The shake of the cab camera (ShakeState) is stepped by update_shake at a fixed 1/50 s, while the camera read the
raw state every frame. At any frame rate other than 50 the shake moved in steps: some frames showed the same
state as the one before, others jumped one or two steps at once. Players with 144/165 Hz screens saw the cab
jump around the camera.

The vehicle now keeps the state from before the last step (ShakeStateBefore), and the camera takes the state
between the two at the share of the step the simulation time has reached (shake_between). The offset and the
velocity are blended, the angles worked out from the blended velocity. The shake itself is computed as before,
with the same fixed step and the same springs; only what the camera shows of it changes. It lags the vehicle
by a constant 1/50 s instead of 0 to 1/50 s.

Measured with the same build and the blending switched off by a temporary environment variable (not in this
commit), the EU07 on td.scn driven by the AI, frames over 30 km/h, two runs of each:
- 60 fps: frames with the shake standing still 25% -> 0%, the change in its speed frame to frame 4-5 times
  smaller for the offset, a third smaller for the angles
- ~144 fps: 65% -> 0%, 10-18 times smaller for the offset, 4 times for the angles
- no fps limit (~520 fps): 90% -> 0%

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:03 +01:00
maj00r
72c69d9249 Fix stutter with fpslimit on Windows and a texture unit cache race with threaded Python screens (#399)
* fix(render): the python upload thread only marks the texture unit cache stale, the drawing thread clears it

update_from_memory() runs on the python upload thread with python.threadedupload (the default), and since
e230d7b9 it cleared opengl_texture::units there outright. That raced Bind_Material filling the same array
for its multi-bind: a unit reset between the fill and glBindTextures() made the bind of that unit fail, and
the object was drawn with the texture of the one drawn before it, for a frame, at the rate of the screens.

The thread now sets an atomic flag, and the drawing thread clears the cache when it next binds textures
(bind() and the multi-bind of Bind_Material), so a screen texture given a new gl name is still rebound.

* fix(app): fpslimit asks Windows for the 1 ms timer, the frames no longer come in turns long and short

The wait of fpslimit sleeps, and Windows wakes a process which didn't ask for a finer timer in steps of
up to ~15.6 ms. A 10 ms slot of fpslimit 100 ended ~15.6 ms later, the pacer made it up with no wait in the
next frame, and with vsync on the frames were shown for one or two refreshes in turn: visible stutter at a
steady FPS. timeBeginPeriod(1) is held from the settings to the exit, only when fpslimit is set.

* fix: the 1 ms timer also for an fpslimit set by the scenery, the stale unit cache checked with a plain load first

A config block of the scenery is parsed after the settings and can set fpslimit, so the timer period is
asked for at the first wait of the pacer too, once. bind() checks the stale flag of the unit cache with a
relaxed load before the exchange, which it does for every texture.

* fix(textures): the stale flag of the unit cache uses the default memory order (Sonar S8417)

On x86 a sequentially consistent load and exchange cost the same as the
relaxed and acq_rel ones; only the store in invalidate_unit_cache() becomes
an xchg, and it runs rarely.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:01 +01:00
maj00r
4b80d3c428 fix(particles): the smoke of a cold diesel keeps the colour of its template (#413)
bcb9e644 (#109) turned a comparison into an assignment: the smoke of a
vehicle in air at 5 degrees or less, or with its engine under 45 degrees,
got the colour 128,128,128. The emitter colour is on a 0-1 scale, so the
smoke turned pure white, glowing at night, and stayed so once the engine
warmed up. Up to 26.05 the line compared and did nothing; the smoke keeps
the colour of its template again, as it did then.

Co-authored-by: maj00r <maj00r@host>
2026-11-19 05:24:42 +01:00
maj00r
8bda0275f3 fix(camera): the roll of the cab shake tilts the view about the line of sight again (#414)
623c4f82 (#97, in 26.05.1) changed the order of the camera rotations from
Z, X, Y to X, Y, Z. The order matters only with a roll, which the cab
shake gives (Angle.z, set in drivermode.cpp), or a camera entry of the
scenery with a roll. Applied last, in the
space of the cab, the roll nodded the view up and down when looking out
of a side window instead of tilting it. The roll is multiplied in first
again, as in 26.05.

Co-authored-by: maj00r <maj00r@host>
2026-11-19 05:24:28 +01:00
maj00r
267d5b3a8f AI: shunting brakes for a stop point again; test mode: no false SPAD for a train set across a signal (#409)
* fix(ai): shunting AI brakes for a stop point again, the braking curve doesn't plan from a brake table left at zero

The braking curve outside the final approach plans from the consist brake table since ce87aa0e (#187, merged
with #264) whenever the brake is pneumatic. That table is worked out only for train running (Obey_train, Bank);
in shunting it stays at zero, the planned full braking falls to its floor of 0.01 m/s2, and the demand comes out
at a few hundredths of a m/s2, above the shunting brake threshold of -0.2. A shunting engine then rolled on
without braking until the final approach, too late, and ran through the signal it was to stop at (seed
480873929 of l053_poranek: ep07p-2003 at sandomierz_g4_sem_info, sm42-1096, et22-654).

With no worked out table the curve is again the constant deceleration over the distance left, as it was before
ce87aa0e and as #187 meant to keep it for shunting. Train running is unchanged.

The curve moves out of TController into vehicle/brakingcurve.{h,cpp} so that it is unit tested:
tests/unit/test_braking_curve.cpp checks a shunting engine braking to a stop point with the zeroed table, and
that a train with a worked out table gets the same demand as before.

* test(ai): pin the train braking-curve demand to the results of the code before the move

A brake table that grips harder as the train slows and a gradient, so that a wrong gravity sign, table index or a dropped term in the shaped demand shows; the expected values were worked out with the code removed from TController::adjust_desired_speed_for_braking_curve.

* fix(test): a train set across a signal doesn't pass it at danger the moment the AI first looks at it

The speed table takes in events up to a train length behind the head, so a signal the train stands across at the start of a scenario is found already behind the head, becomes elapsed on its first update, and the test mode reported it as passed at danger (calkowo_lotos: st43-189 at mac_daleko3_sem_info, manewrowo3: st43-100 at suw_szopa_a02_sem_info, both at 13.6 s with the train at a stand, the signal 20 m behind the head). A point now counts as passed only when the head of the train had it ahead once; the blackbox record of passed signals follows the same rule.

* fix(test): a signal found up to 5 m behind the head still counts as seen ahead

The distance to an event is found in steps of a metre from the position of its memory cell, so a signal just ahead of the head (a train stopped short of it when the autopilot takes over, or set right at it at the start) could come out slightly behind it, and passing it would not be reported. The trains set across a signal that the previous commit is about stood 20 m past it.

Still not reported: a signal crossed while the speed table is being traced anew in motion (a Timetable: command to a running train, the autopilot taking over in motion), as it is found behind the head when the trace is made.

* docs(test): say what the seen-ahead tolerance gives up

A train set less than 5 m past a signal at stop is still reported to pass it at danger: standing that close it can't be told from a train stopped just short of the signal, which the tolerance is there for.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-19 04:55:33 +01:00
80fd5aad2b Merge pull request #385 from MaSzyna-EU07/feat/blackbox-standalone
feat(blackbox): the black box on its own, lighter physics logs, physicslog.trains
2026-11-16 16:01:52 +00:00
388b8407a5 Merge pull request #386 from MaSzyna-EU07/fix/editor-trackbed-texture-crash
fix(editor): the texture pickers let go of the images scrolled past, the memory no longer runs out
2026-11-16 16:01:30 +00:00
maj00r
bcecfe2964 refactor(renderer): a material's textures let go of in one place, for every backend
Unload_Material walked the textures of a material and of its variants the
same way in both opengl renderers, and Sonar counted its declarations, set
into the long run of overrides the two headers share, as duplicated: 5.2%
of the new code, 3% allowed. The walk is gfx_renderer's now, over
IMaterial::GetAllTextures and the backend's Unload_Texture. Materials that
don't tell their textures, the Vulkan renderer's, give none, and are left
alone as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
build-fix-editor-trackbed-texture-crash
2026-11-16 15:59:57 +01:00
maj00r
16cad1fc07 Merge pull request #332 from MaSzyna-EU07/fix/editor-po-wizard-newlines
Editor: the Polish of the download area tooltip and hint shows again
2026-11-16 13:32:18 +01:00
maj00r
a0d7b86d03 Merge pull request #362 from MaSzyna-EU07/fix/linux-file-case
fix(files): data named in another case is found on Linux, folders included
2026-11-16 13:32:01 +01:00
maj00r
c6e7315bc1 Merge pull request #380 from MaSzyna-EU07/fix/editor-ca-bundle
fix(editor): the certificates of https looked for where the distribution keeps them
2026-11-16 13:31:44 +01:00
maj00r
ba4bea92e8 Merge pull request #381 from MaSzyna-EU07/feature/no-avx-build
ci: Windows and Linux builds without AVX2, named _noavx2, in the public download
2026-11-16 13:31:24 +01:00
maj00r
c745909488 Merge pull request #383 from MaSzyna-EU07/fix/legacy-ui-stale-texcoord
fix(renderer): the legacy renderer clears the arrays the scene left before it draws the ui
2026-11-16 13:30:31 +01:00
maj00r
b48694ba3c Merge pull request #384 from MaSzyna-EU07/fix/unknown-renderer-falls-back-to-full
fix(app): a renderer this build doesn't have starts the full one, not the legacy one
2026-11-16 13:30:17 +01:00
maj00r
0a1c4fd425 fix(physicslog): what no file name may have on Windows is replaced in the name of a log, on every system
A spawned vehicle is named <spawn>:<number>, and its log went to physicslog/<spawn>:<number>.dat. On
NTFS that isn't even an error: it is the stream <number>.dat of the file <spawn>, which nothing lists,
so the log was written and no one could find it. On Linux the file was there, under a name Windows
can't open.

The name of the file of a log has < > : " / \ | ? * and the control characters replaced by _, on every
system, so the logs are named alike everywhere (spawn_ezt:12 is spawn_ezt_12.dat), and a _ before a
name Windows keeps for a device (con, nul, com1..., with an extension too). The bytes of 1250 stay.
The black box tells the log it begins by the same name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
build-feat-blackbox-standalone
2026-11-16 13:00:16 +01:00
maj00r
5498995672 fix(blackbox): the tapes go on after the editor, with the physics logs off
The tapes of the user's vehicles were written by update() after the check for the writer of the
recording, which close() drops on entering the editor (F11). With "physicslog no", the speed recorder's
tape ended at F11 while the drivers' own logs of "physicslog yes" went on.

The tapes are files of their own: they are kept from the moment the recording was to be made, the file
made or not, closed or not, until the simulator closes, after the gap of the time in the editor.
Only the recording itself stops at F11, as before.

Reported in the review of #385.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:47:22 +01:00
maj00r
99b93abd64 fix(physicslog): nothing that goes wrong in the writing ends the simulator; a name in 1250 makes a path on a Windows set to UTF-8
The writer's thread called flush() with nothing around it, so an exception leaving write() ended the
process with std::terminate, with no message. One that happens: the file of a log was made a
std::filesystem::path of the vehicle's name, which MSVC converts in the code page of the system and
throws for bytes not of it; on a Windows with "Use Unicode UTF-8 for worldwide language support" a
vehicle named in 1250, as the sceneries have them (0xB3 for ł), isn't UTF-8.

- the file of a log is made of the name with MultiByteToWideChar without MB_ERR_INVALID_CHARS: the same
  file as before for every name of the code page, U+FFFD for the bytes not of it instead of a throw.
  Elsewhere the bytes are the name of the file as they were
- a log whose writing throws for any other reason (memory) is kept for the next try as one whose file
  can't be written, and the other logs are written still
- the thread, flush_for() and stop() write through flush_safely(), which lets nothing out: what was taken
  for a writing failing as a whole is lost and told in the log, the next writing goes on
- the messages name the file by the bytes of the name, not by path::string(), which converts back

Tests: a log which can't be written doesn't keep the others from theirs; a vehicle named in 1250 has its
log, read back by physicslog_writer::file().

Reported in the review of #385.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:47:22 +01:00
maj00r
b832d2fab9 fix(editor): the image of a material with no texture in its first slot is let go of too
Its normal and specular maps were read with it and stayed in the memory: the trim passed over every image with no texture of its own, the material along with it.
2026-11-16 02:13:09 +01:00
maj00r
423d49b42c fix(physicslog): every stop asked wakes the writer, the one from itself too; no psyche for a driver of no vehicle 2026-11-16 02:12:01 +01:00
maj00r
0bbf07bf11 fix(editor): the images of the materials let go of with all their textures, the browser's Refresh a frame later
An image of a material read the material with all its textures, the normal and specular maps and the variants, and only the first one was let go of: those stayed in the memory for every material scrolled past. They are let go of together now (Unload_Material). texture_manager::unload also takes the textures read and not made yet, waiting for a worker still reading one, and deletes the gl texture itself: release() would read it back from the card with gfx.resource.move only for it to be dropped.

The Refresh of the texture browser let go of the images in the middle of the frame, while panels drawn before it could still refer to them; it now marks them, and they go at the start of the next frame.

Checked on td.scn by a scripted run: 8040 images of the picker read a batch every few frames end at 2.0 GB, against 2.3-2.6 GB before this and 1.1 GB at the start; a trackbed material picked from the folder is drawn on the track after its image was let go.
2026-11-16 02:10:59 +01:00
maj00r
94b7c7f01b fix(physicslog): the writer's destructor throws nothing, its wait a plain condition variable woken to stop; a driver of no vehicle controls nothing 2026-11-16 02:08:04 +01:00
maj00r
4525023777 fix(editor): the texture pickers let go of the images scrolled past, the memory no longer runs out
The picker of the textures of a track offers every texture of the textures folder, and each tile that came into sight read its texture full size, into the graphics card and the memory, and kept it there for good. Scrolling through the list for a trackbed texture took about 2.5 MB a tile: some 900 tiles made 3.5 GB, the whole folder 28 GB, and the game went down once the memory ran out.

An image out of sight for 3 seconds is now taken out of both again (texture_manager::unload, Unload_Texture of the renderers) and read anew when it's shown once more, a few a frame as before. Only a texture the scene has never drawn is let go; those of the scene stay to the resource sweep. The texture browser lets go of its images on Refresh too. The picker no longer lists textures/previews: the 4100 previews of the node bank are images of models, not textures of anything.

Checked on td.scn by a scripted run: 8000 images of the picker read one batch a few frames after another held the game at 2-3 GB, where it went to 28 GB and fell before; images shown again after they were let go come back; a trackbed texture picked from the folder is drawn on the track after its image was let go.
2026-11-16 01:54:40 +01:00
maj00r
b421550cbe fix(physicslog): a train's log begun at its first line, so passive crews get no file
Every crew is primary in the constructor and the drivers but one of a train with crews in more
vehicles are made passive only before it starts, so a log begun there left files with only
the header. With physicslog on all logs begin at once as before; one of a train waits for
update_logs.
2026-11-15 23:56:30 +01:00
maj00r
b7950af6b6 feat(physicslog): the logs of the trains only, physicslog.trains
"physicslog.trains yes" in eu07.ini writes the .dat log of each driver who
drives rail vehicles, not of the passengers nor of the road vehicles that make
"physicslog yes" hundreds of files on a big scenery: the tape of every train.
A driver made primary later begins its log then, and isn't counted while it
doesn't log. The black box goes with it when the ini says nothing of its own,
and doesn't write a second log of a driver writing its own. The doc tells the
doors' sides are the vehicle's, the driver's swapped in the rear cab.
2026-11-15 23:48:23 +01:00
maj00r
043b9fb2f0 fix(physicslog): failed logs kept within 64 MB in all, cut outside the lock, never written twice; the writer knows itself when stopped
The lines kept while files can't be written are cut to their share of 64 MB
before the lock the simulation waits on. A log written in part is cut back to
its length, so the next try doesn't write its start twice. A stop from the
writer itself is told by its id even after another thread took it to join, and
the watchdog's flush waits at most its time, the writing on a thread of its own.
2026-11-15 23:38:24 +01:00
maj00r
5d0bf6ed00 fix(blackbox): the wheels of the powered vehicle, as the speedometer has them, and the logs described as the drivers' they are
In a unit driven from an unpowered car, the speed of the wheels was of the car
the user is in, whose wheels never slip; now of the motor car, signed as the
occupied vehicle's speed. The doc tells of a log per driver, and of the two
seconds of real time a crash loses.
2026-11-15 23:32:39 +01:00
maj00r
7547e6bf07 fix(physicslog): a log whose file can't be written keeps its lines and header, and the writer is stopped once on every way out
A failed write put its lines back, ahead of those since, so a file held by
another program for a while gets its header and every line once it can be
written; up to 4 MB kept per log. Stopping is joined once, and not from the
writer's own thread. main stops the logs after an error it caught too, and the
test watchdog flushes with a time limit, so a disk that doesn't answer doesn't
keep the run from ending.
2026-11-15 23:32:38 +01:00
maj00r
aaff0a430b fix(settings): the gfxrenderer word read in any case, as the starter reads it
A hand-written "gfxrenderer Legacy" started the legacy renderer only because every unknown word did; with unknown words going to the full renderer it would have changed. The word is lowercased when read, as StarterNG's RenderEngineOf does, so Legacy, Simple or Full mean what they say.
build-fix-unknown-renderer-falls-back-to-full
2026-11-15 23:22:50 +01:00
maj00r
68c33922a6 fix(app): a renderer this build doesn't have starts the full one, not the legacy one
The starter writes "gfxrenderer vulkan" for the Vulkan renderer of the builds
that have it. This exe doesn't know the word, and every word other than
default/experimental fell to the legacy renderer: a player who picked Vulkan
got the slowest renderer, the one whose ui crashes on NVIDIA (the arrays left
by the scene). "experimental" in a build without the NVRHI renderer ended with
"no renderer found!" and no game at all.

After the settings are read, a gfxrenderer word this build has no renderer for
becomes "default", with a line in the log saying so. The words it knows stay
as they were: full/default, legacy, simple, null, the older starters'
simpleshader and off (legacy as before), and experimental where it is built.
2026-11-15 23:20:18 +01:00
maj00r
88522fe600 fix(renderer): the legacy renderer clears the arrays the scene left before it draws the ui
The legacy renderer drew the ui with the client arrays of the last scene draw
still enabled: the texture coordinates of the normal map unit and the normals,
pointing into the vertex buffer of whatever was drawn last, 48 bytes a vertex.
The ImGui backend sets up the vertex, colour and texture coordinates of the
active unit only, so the driver read the stale arrays with the indices of the
ui. Once the ui had more vertices than that buffer, the NVIDIA driver read past
its end and the game crashed; a crash dump of the editor (an area selected, a
track being laid) shows the read of vertex 15113 at a 48-byte stride in
ImGui_ImplOpenGL2_RenderDrawData.

The arrays are now disabled on every texture unit the geometry uses, with the
normal and colour arrays, inside the glPushClientAttrib already there, so the
scene gets its state back after the ui. The default and the experimental
renderers don't go through this code.
build-fix-legacy-ui-stale-texcoord
2026-11-15 23:09:49 +01:00
maj00r
0916104293 ci: Linux is built without AVX2 too, published as maszyna-linux-x64-noavx2.tar.gz
The Linux job becomes the same two-variant matrix as Windows (ENABLE_AVX2=ON/OFF), each
variant with a concurrency group of its own. The publish job downloads both Linux artifacts,
restores the executable bits in both and releases maszyna-linux-x64.tar.gz (AVX2, the old
name) next to maszyna-linux-x64-noavx2.tar.gz. The no-AVX2 executable is
eu07_<date>_<hash>_noavx2.
build-feature-no-avx-build
2026-11-15 21:25:30 +01:00
maj00r
507fcd8cb3 build: a build without AVX2 has _noavx2 at the end of its executable name
With ENABLE_AVX2=OFF the executable is eu07-x64_<date>_<hash>_noavx2.exe (eu07-x64_noavx2.exe
without ADD_VERSION_SUFFIX), so a starter can tell the two builds apart by the name alone and
pick this one on a CPU without AVX2. The AVX2 build keeps its name.
2026-11-15 21:22:14 +01:00
maj00r
348a814ce2 fix(ci): the no-AVX2 Windows build has its own concurrency group and its own public download
After master was merged the two Windows variants shared one concurrency group with
cancel-in-progress, so one cancelled the other, and the publish job looked for an artifact
name the matrix no longer produces. Each variant now has its own group, the publish job
downloads both, and the release carries maszyna-windows-x64.zip (AVX2, the old name, so the
links already handed out still work) and maszyna-windows-x64-noavx2.zip. The AVX2 variant
passes -DENABLE_AVX2=ON explicitly instead of an empty flag.
2026-11-15 21:18:22 +01:00
maj00r
6ffbc0a6f6 Merge master into feature/no-avx-build 2026-11-15 21:16:45 +01:00
maj00r
465300df8d fix(editor): an https proxy checked with the same certificates
CURLOPT_PROXY_CAINFO gets the file found for CURLOPT_CAINFO, so a download through an https:// proxy on Fedora or RHEL doesn't fail on the proxy's certificate.
build-fix-editor-ca-bundle
2026-11-15 20:43:08 +01:00
maj00r
4558976733 fix(editor): the certificates of https looked for where the distribution keeps them
The Linux game bundles the libcurl of Ubuntu, which knows only Ubuntu's
/etc/ssl/certs/ca-certificates.crt. Fedora, RHEL and openSUSE keep the
certificates elsewhere, so every download of the editor (orthophoto, terrain
model, topo map) failed there with a certificate error.

The file is taken from SSL_CERT_FILE or CURL_CA_BUNDLE when set, else the
first of the files the distributions keep, and passed as CURLOPT_CAINFO.
With none found libcurl keeps its own.
2026-11-15 20:42:13 +01:00
maj00r
e413675c02 Merge pull request #369 from MaSzyna-EU07/fix/ci-openal-audio-backends
fix(ci): build OpenAL Soft with the PipeWire, PulseAudio and ALSA bac…
2026-11-14 22:38:13 +01:00
maj00r
73d535f73e fix(ci): build OpenAL Soft with the PipeWire, PulseAudio and ALSA backends, so the Linux game has sound
The Linux job builds OpenAL Soft 1.24.2 from source, but the runner had none of the headers of its
audio backends, and OpenAL Soft's CMake leaves out every backend it can't find. The bundled
libopenal.so.1 had only OSS, Null, Wave and Loopback. Modern distributions and the Steam Linux
Runtime have no /dev/dsp, so the game logged "Failed to obtain audio device" and played nothing,
with any Steam Linux Runtime and without one.

- install libasound2-dev, libpulse-dev and libpipewire-0.3-dev before building OpenAL Soft
- configure it with ALSOFT_REQUIRE_PIPEWIRE/PULSEAUDIO/ALSA, so a missing header fails the build
  instead of shipping a library without sound

The backends are loaded with dlopen at run time (ALSOFT_DLOPEN is on by default), so the bundled
library gains no new dependency. Tested by putting an OpenAL Soft 1.24.2 with these backends next to
the game from the Steam depot: under Steam Linux Runtime 4.0 the sound works.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
build-fix-ci-openal-audio-backends
2026-11-14 20:58:04 +01:00
maj00r
7b7529e24e feat(blackbox): the cab record holds the speed of the wheels, apart from the vehicle's when they slip
The speed of the cab record is the vehicle's. The speedometer, and a speed recorder's tape with it, shows the
speed of the wheels as they turn, which runs away from it while they slip and drops to 0 while they are
locked in a skid. It is added at the end of the record (194 bytes), where the readers skip what they don't
know; the .dat tapes have it already, in their second column.
2026-11-14 00:48:18 +01:00
maj00r
03a3b4c09a feat(physicslog): the logs written every two seconds by a thread of their own, no file kept open; the black box's tapes as it goes
"physicslog yes" kept the .dat of every vehicle with a driver open for the whole run and flushed it twenty
times a second from the simulation's thread: some 580 open files on Tomaszewo. The lines are kept now and a
thread of their own writes them every two seconds, each file opened only for the moment it is written to.
The files, their lines and their text mode stay as they were.

- The black box, with the physics logs off, writes the tapes of the user's vehicles through the same
  writer as it goes, not at the end. A log begins when the user is first in the vehicle and goes on
  while the user looks around outside, until another vehicle is taken; back in it, the log goes on after
  the gap. The vehicle's own driver keeps the log only if it is the primary one, as a passive one's clock
  stands still; otherwise the driver of its train does.
- What is kept is written when the simulator closes, after the black box, at the end of a test run, and
  when the test watchdog ends a run. A crash loses the last two seconds.
- On Tomaszewo with the black box alone, the one tape grows every two seconds. With "physicslog yes", the
  581 logs grow and the simulator holds as many handles as without them; writing them takes the thread
  about 1.9 s, which the closing waits for once.
2026-11-14 00:48:17 +01:00
maj00r
5ca2f7e38f feat(blackbox): the black box on its own, writing the tapes of the user's vehicles at the end
"blackbox yes" in eu07.ini records the black box with the physics logs on or off, "blackbox no" never;
with no entry it goes with "physicslog yes" as before. With the physics logs off, the recorder keeps the
line of the physics log of the driver the user is with, every 0.05 s, and writes it to
physicslog/<vehicle>.dat when the recording closes: the speed recorder's tape of the vehicles the user
was in, without every vehicle keeping a log open and written twenty times a second.

The line and the header of the log are made by one function of the driver, which its own log writes
too, and the file is opened the same way, so the two are the same to the byte: the readers of these
logs (the old Hasler tape viewer, the starter) read them as before.
2026-11-14 00:04:55 +01:00
maj00r
0488519f39 fix: the simulator opens more than 512 files at once, and a shader it can't open says why
With "physicslog yes" every driver keeps its .dat open, and a large scenery (Tomaszewo: some 500 vehicles,
cars of the roads included) took all 512 streams the MSVC runtime gives: the next fopen failed and the
simulator stopped at "cannot read shader: shaders/map.vert" on opening the map. The limit is raised to
8192 at the start (the soft limit of open files up to the hard one on Linux), and a shader file that
doesn't open is told as such, with the system's reason, rather than as one that can't be read.
2026-11-14 00:04:54 +01:00
maj00r
38540d08f5 refactor(files): named functions instead of the lambdas of the folder cache (Sonar S2259, S3608, S6004)
Sonar took the folder captured by the lambda reading it for a reference
to null, failing the quality gate on reliability. The folder is read and
the path kept by functions in the anonymous namespace, the age of the
listing declared in its if.
build-fix-linux-file-case
2026-11-13 17:49:18 +01:00
maj00r
d76e6368b0 fix(files): models named in another case are found on Linux
The manager of the models looked for the file with FileExists of a single
name, a plain check again since the banks keep the names asked for, so a
model named in another case (models/przejazdy/plyty3_L,
dynamic/pkp/st44_v2/main/2M62-0685-A) was reported missing before
TModel3d::LoadFromFile() could open it as it's named on the disk.

find_on_disk() finds the file in any case and gives back the name asked
for, the key of the bank.
2026-11-13 17:49:18 +01:00
maj00r
f9b7e9174c fix(files): terrain files named in another case are found on Linux
The terrain directive names .txtf/.btf files in lowercase, as the parser
gives every token. The name is now taken as it is on disk, from the text
file first, so the binary file is made next to the text and the editor's
references and layers keep one name.
2026-11-13 16:34:06 +01:00
maj00r
1e5b095150 perf(files): a file missing costs a single check, as before
Measured in a case sensitive folder (3000 textures, every 20th in mixed
case, looked up the way Texture.cpp does), the walk over every part of the
path made a texture lookup 4-5 times slower than master: each name tried
and missing checked every folder of its path.

- the folders found are kept by the name they're given with, the missing
  ones for a second, so a missing file checks its folder alone
- a folder named as it is on the disk is taken without its listing
- the time a folder was changed is looked at once a second at most

The lookup is now as fast as master's (about 180 us per texture on NTFS in
both) while finding the files named in another case too.
2026-11-13 16:18:27 +01:00
maj00r
0371581049 Merge pull request #342 from MaSzyna-EU07/linux-curl
fix(ci): build the Linux game with libcurl, so the editor can downloa…
2026-11-13 16:10:47 +01:00