* feat(editor): Fields in the Terrain work mode, the ground under them made wavy, natural slopes
A Fields tool beside Fill: LMB outlines a field, which gets the material chosen in the palette
and is kept in a list (terrain/<name>/patches.txt, or in the manifest while there are few),
where its material, repeat, angle, transition and grass are changed later.
- painted into the terrain (the paint of the chunks, its edge blended over a transition and
shifted by a noise, the 3D grass under it left, taken away or of another kind), or
- a surface of its own: the ground cut away within the outline and the field drawn over the
hole as a mesh following the heights of the terrain, made around the camera as the water
is. It doesn't take one of the 8 materials of a chunk; its edge is sharp.
The ground under a field can be made wavy before: rolling hills, furrows, bumps, long waves,
a hollow or a mound, hummocks in a grid, strips of fields; with a profile (rounded, sharp
ridges, sharp valleys, terraces, flat tops), roughness, variation and a fade from the edge.
The chunks under it are made finer where the waves need it.
The formation modifiers get an optional natural shape (natural: wander, scale, gentler,
soften, roughness in the manifest): the formation and the edges of the track bed stay, the
slopes and their foot wander, get gentler and meet the ground softly. Without it the
modifiers shape the ground as before.
Formats: new optional entries patches, patches_file and natural of the manifest, and the
patches file; a terrain without them reads and saves as before, and the release doesn't read
them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* Fields: one noise for the edges of the fields and the natural slopes, one filling of the geometry of the water
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* Fields: the vertices handed to the geometry of the water by value
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* fix(editor): whole-number loop counters instead of float ones (Sonar cpp:S2193)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* fix(editor): Fields: the edits of a field stick, the natural slopes stay when the formations are laid again, no holes far off or by a missing chunk
The copy of the field the widgets edit is kept while one of them is held, so a drag ends with what it was dragged to. Laying
the formations again keeps the natural shape of the slopes of each. The surfaces of the fields are made as far as the chunks
are drawn, so their holes never show without them; a field over ground with no chunk is made of what has ground, and waits
only for chunks which are in the files but not loaded yet. Outline it again puts the points on the ground and the cut changes
that field. The holes of the fields are marked (254) and giving one back closes only its own, the holes cut by hand stay.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* fix(editor): Fields: a separate field is built after loading with the camera still; a cleared outline or another field chosen forgets the one to outline again; giving back a field keeps the holes of the others over it
- waits_for_ground counts a chunk as still coming while its pack isn't read
yet (right after opening the scenery none is), and as not coming only when
the pack is missing or read without that chunk. Before, the first build
after opening left a saved separate field a hole until the camera moved.
- Clear the outline (Fields and the area fill) and choosing another field in
the list forget the field put back by Outline it again, so the next cut is
a new field and not the old one moved.
- All holes of separate fields share one mark, so closing one closed it under
an overlapping field too; the separate fields left over the closed outline
are cut again after it (when a field is given back or outlined again).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* chore(editor): Fields: one identifier a statement, contains() for the sets (Sonar cpp:S1659, cpp:S6171)
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* ci(windows): build lua51.dll for the unit tests
(cherry picked from commit b3e6e02779)
* fix(terrain): the fields made again only when one comes or goes; patches_file a plain name; the hand holes leave the fields'
After the review of jerrrrycho at edb5160a:
- update() no longer rebuilds all the water and the separate fields every 200 m the camera moves. Past
patch_move it compares the separate (not painted) fields within the reach with the ones made, and rebuilds
only when one came within the reach or left it; otherwise only the centre moves. A terrain with only
painted fields never rebuilds for a move, also in driving mode. The fields waiting for their ground are
made again as before.
- patches_file of a manifest is taken only as a plain file name in the folder of the terrain. A path with
folders, "..", or a root is logged ("Bad terrain: ...") and patches.txt is used instead, so a downloaded
manifest can't have the patches read from, or saved over, a file elsewhere.
- The holes cut or closed by hand (the Holes tool, "Close the hole" of the Fill section) leave the hole
samples of the fields (kFieldHole) as they are, so a field's mesh no longer stands over closed ground and
z-fights with it, and "Give back" still finds the field's hole. The unmarked fallback of cut_field (the
fields cut before the mark) thereby closes only unmarked holes.
- The field picked with "Outline it again" is forgotten when the Fill tool uses the outline up, and when
another terrain tool than the fields is chosen, so the next field drawn is a new one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QRgQ1K1Qu7TCsa74zsNURd
---------
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Hirek193 <polomarket73@gmail.com>
* feat(editor): fill_store, the filled areas kept in the scenery as //$f lines
* feat(editor): fill_store: reading and writing the filled areas
* build: editorFillStore.cpp
* feat(scene): //$f lines of the filled areas kept with the layer files
* feat(editor): area fill: the members of the list of filled areas
* lang(pl): area fill list
* feat(editor): area fill: Enter finishes an area, Esc drops the outline, filled areas listed to be changed later
* fix(editor): the filled areas kept as //$w lines, //$f being the fitted tracks of the profile tool
* fix(editor): a changed area keeps its own rotation and its layer; its models go to the layer of the area, on an undo as on a refill
Change + Enter took the rotation of the Functions panel instead of the area's own:
the area keeps it now, unless the rotation of the panel is changed while the area
is picked up.
The models of an area were made in the active layer, the area record stayed in its
own: on an undo of a change or a removal, with another layer active, they were
saved apart. create_model() takes the layer to put the model in (none: the active
one, as before), and the models of an area go to the layer of the area (the active
one if that's gone). The active layer isn't switched for it: Layers.active() also
shows and unlocks the layer it's given.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* chore(editor): the seeded generator of the area fill marked as not security (Sonar cpp:S2245)
The fill must repeat from its seed (the same area filled again gets the
same objects), so a cryptographic generator is not wanted there.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DDcMn1Q7wdYkbxDUWscNHZ
* ci(windows): build lua51.dll for the unit tests
(cherry picked from commit b3e6e02779)
* fix(editor): the filled areas kept under //$u, as //$w is the mark of the shared grade lines on master
After the review of jerrrrycho: on master //$w is the mark of the shared grade lines (scenelayers.cpp,
editormodegradeline.cpp), and both stores save through Layers.mark(Layer, Mark, Lines), which replaces the
lines of the mark. Once master reached this branch, a layer with a grade line and a filled area would have
kept only the lines of whichever store saved last; before that, a master build reads the lines of the areas
as grade lines it doesn't know.
The area fill takes //$u, free on master, on feat/gl46-migration and in the letters of the starters
(n d f i l a), and the same letter the ficzery2 builds the testers have already save the areas under, so
their sceneries keep their areas. A scenery saved by a build of this PR before this commit has its areas
under //$w: they are no longer read as areas; saved again, the editor keeps those lines as lines it doesn't
know.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QRgQ1K1Qu7TCsa74zsNURd
---------
Co-authored-by: miloszunio <miloszunio@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Hirek193 <polomarket73@gmail.com>
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>
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>
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>
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>
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.
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.
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.
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.
"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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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>
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.
"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.
"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.
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.
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.
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.
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.
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.