Compare commits

...

7 Commits

Author SHA1 Message Date
maj00r
170bb58487 feat(settings): the simulator's OpenAL Soft options in the sound category
A new "Sound device and effects" section sets the eu07.ini keys the simulator
reads for OpenAL Soft: sound.openal.renderer (device), sound.outputmode,
sound.hrtf, sound.hrtf.profile, sound.resampler, sound.limiter,
sound.frequency, sound.doppler, sound.efx.lowpass and
sound.efx.airabsorption.

The lists of devices, HRTF data sets and resamplers come from the OpenAL
library in the game folder (OpenAL32.dll / libopenal.so.1), read in the
background through NativeLibrary and function pointers (AllowUnsafeBlocks);
without it, or with an older library, the lists hold the file's value and the
library's choice. Names with spaces are written in quotes, an empty name takes
its line out, and a key the file lacks is written only when it differs from
the simulator's default, so saving with these left alone adds nothing.

sound.maxsources is left out: OpenAL Soft gives at least 256 sources
whatever is asked, so it would be a setting that does nothing; a line the
file has stays as it is. A device name code page 1250 cannot hold, the
encoding of eu07.ini, is not offered, as it would reach the simulator as
question marks. HRTF data sets and resamplers are offered only with ASCII
names, since the simulator looks those up by the library's own spelling. A
value a slider can't show, outside its range or between its ticks, is kept
by the page's shown-unlike bookkeeping until the slider is moved.

Strings in en and pl with descriptions, labels in cz, hu and ru.
2026-11-17 14:34:28 +01:00
c07ed2fb4d Merge pull request #54 from MaSzyna-EU07/feat/tapes-from-blackbox
feat(tapes): tapes from the black box, live view that keeps up, train tapes setting
2026-11-16 16:00:52 +00:00
cfea240243 Merge pull request #53 from MaSzyna-EU07/fix/scenery-file-events
fix: scenery files are looked at when they change, not every two seconds
2026-11-16 16:00:36 +00:00
maj00r
2a85ca384a refactor(scenery): the looks at the scenery files timed by a class of their own, under test
When the main window looks at the scenery files - once the reports of a
save stop, back at the window, now and then anyway, seldom where the
system reports changes and often where it does not - is FolderLooks now,
on TimeProvider timers, so the tests drive the clock. The window keeps
only the look itself. A report coming as the window closes leaves the
disposed timers be.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 15:55:22 +01:00
maj00r
100bbea83e fix(tests): the black box text tests wait their turn with the other Avalonia ones
EventTextsTests and SecurityBrakingTests from #55 ran beside the Avalonia
controls collection; their AppBuilder setup raced it and 28 UI tests failed
with "Setup was already called" on every runner.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 15:42:56 +01:00
maj00r
c370d1509e Merge main into fix/scenery-file-events
Conflict in MainWindow.axaml.cs, the Activated handler: main (#52) refreshes the list of simulators when
the settings are shown, this branch looks at the scenery files through _sceneryLook. Both kept.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 13:02:45 +01:00
maj00r
31fc4c3fdc fix: scenery files are looked at when they change, not every two seconds
The starter compared every file of every scenery each two seconds: on a full
installation 175 sceneries and 378 files, 15-18 ms a look, thirty looks a
minute with nothing changed. The system now reports changes in the scenery
folder and a look follows once the burst of a save has passed, 400 ms after
the last report.

The reports are only a hint. A look still comes on coming back to the window
and right after the simulator or its editor closes, and every 30 seconds
anyway, for network drives, Wine and Linux past its limit of watches, where
reports may not come. Where the folder cannot be watched at all the look
stays every two seconds as before. A change reported during a look is not
lost: one more look follows it.
2026-11-15 21:18:20 +01:00
20 changed files with 1148 additions and 11 deletions

View File

@@ -0,0 +1,65 @@
using StarterNG.Infrastructure.Adapters;
namespace StarterNG.Tests;
public sealed class FolderChangesTests : IDisposable
{
private static readonly TimeSpan Patience = TimeSpan.FromSeconds(10);
private readonly string _root = Path.Combine(Path.GetTempPath(), "folder-changes-" + Guid.NewGuid().ToString("N"));
public FolderChangesTests() => Directory.CreateDirectory(Path.Combine(_root, "sub"));
public void Dispose() => Directory.Delete(_root, recursive: true);
private static async Task<bool> Reported(FolderChanges changes, Action change)
{
var told = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
changes.Changed += () => told.TrySetResult();
change();
return await Task.WhenAny(told.Task, Task.Delay(Patience)) == told.Task;
}
[Fact]
public async Task A_file_written_below_the_folder_is_reported()
{
string file = Path.Combine(_root, "sub", "a.scm");
File.WriteAllText(file, "old");
using var changes = new FolderChanges(_root);
Assert.True(changes.Watching);
Assert.True(await Reported(changes, () => File.WriteAllText(file, "new text")));
}
[Fact]
public async Task A_save_through_a_renamed_temp_file_is_reported()
{
string file = Path.Combine(_root, "test.scn");
File.WriteAllText(file, "old");
using var changes = new FolderChanges(_root);
Assert.True(await Reported(changes, () =>
{
string temp = file + ".tmp";
File.WriteAllText(temp, "new");
File.Move(temp, file, overwrite: true);
}));
}
[Fact]
public async Task A_file_removed_is_reported()
{
string file = Path.Combine(_root, "gone.scn");
File.WriteAllText(file, "x");
using var changes = new FolderChanges(_root);
Assert.True(await Reported(changes, () => File.Delete(file)));
}
[Fact]
public void A_missing_folder_is_not_watched_and_does_not_throw()
{
using var changes = new FolderChanges(Path.Combine(_root, "nowhere"));
Assert.False(changes.Watching);
}
}

View File

@@ -0,0 +1,192 @@
using Avalonia.Controls;
using StarterNG.Infrastructure;
namespace StarterNG.Tests;
[Collection(AvaloniaControls.Name)]
public sealed class FolderLooksTests : IDisposable
{
private static readonly TimeSpan Patience = TimeSpan.FromSeconds(10);
private readonly string _root = Path.Combine(Path.GetTempPath(), "folder-looks-" + Guid.NewGuid().ToString("N"));
private readonly ManualTime _time = new();
private readonly Window _window;
private int _looks;
public FolderLooksTests()
{
Directory.CreateDirectory(_root);
HeadlessDrawing.Ensure();
_window = new Window();
}
public void Dispose()
{
_window.Close();
Directory.Delete(_root, recursive: true);
}
private FolderLooks Opened(string folder)
{
var looks = new FolderLooks(_window, () => folder, () =>
{
_looks++;
return Task.CompletedTask;
}, _time);
_window.Show();
Controls.Settle();
_looks = 0;
return looks;
}
private ManualTimer Quiet => _time.Timers.Single(t => t.Period == Timeout.InfiniteTimeSpan);
private ManualTimer Often => _time.Timers.Single(t => t.Period != Timeout.InfiniteTimeSpan);
// Waited for without leaving the thread: the window belongs to it.
private static void Until(Func<bool> condition) => Assert.True(SpinWait.SpinUntil(condition, Patience), "waited too long");
[Fact]
public void Nothing_is_watched_before_the_window_opens()
{
_ = new FolderLooks(_window, () => _root, () => Task.CompletedTask, _time);
Assert.Empty(_time.Timers);
}
[Fact]
public void A_watched_folder_is_looked_at_anyway_seldom()
{
var looks = Opened(_root);
Assert.True(looks.Watching);
Assert.Equal(FolderLooks.Watched, Often.Due);
Assert.Equal(FolderLooks.Watched, Often.Period);
Assert.Equal(Timeout.InfiniteTimeSpan, Quiet.Due);
}
[Fact]
public void A_folder_the_system_reports_nothing_of_is_looked_at_often()
{
var looks = Opened(Path.Combine(_root, "nowhere"));
Assert.False(looks.Watching);
Assert.Equal(FolderLooks.Unwatched, Often.Period);
}
[Fact]
public void A_tick_looks_on_the_ui_thread_once_it_gets_there()
{
Opened(_root);
Often.Fire();
Assert.Equal(0, _looks);
Controls.Settle();
Assert.Equal(1, _looks);
}
[Fact]
public void A_change_is_looked_at_once_the_reports_stop()
{
Opened(_root);
File.WriteAllText(Path.Combine(_root, "test.scn"), "new");
Until(() => Quiet.Due == FolderLooks.Quiet);
Controls.Settle();
Assert.Equal(0, _looks);
Quiet.Fire();
Controls.Settle();
Assert.Equal(1, _looks);
}
[Fact]
public void Coming_back_to_the_window_looks()
{
Opened(_root);
_window.Activate();
Controls.Settle();
Assert.Equal(1, _looks);
}
[Fact]
public void Asked_it_looks()
{
var looks = Opened(_root);
Assert.True(looks.LookAsync().IsCompletedSuccessfully);
Assert.Equal(1, _looks);
}
[Fact]
public void Closed_it_stops_the_timers()
{
Opened(_root);
_window.Close();
Assert.Equal(2, _time.Timers.Count);
Assert.All(_time.Timers, t => Assert.True(t.Disposed));
}
private sealed class ManualTime : TimeProvider
{
private readonly List<ManualTimer> _timers = new();
public IReadOnlyList<ManualTimer> Timers
{
get
{
lock (_timers)
return _timers.ToList();
}
}
public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
{
var timer = new ManualTimer(() => callback(state), dueTime, period);
lock (_timers)
_timers.Add(timer);
return timer;
}
}
private sealed class ManualTimer : ITimer
{
private readonly Action _tick;
private long _dueTicks;
public ManualTimer(Action tick, TimeSpan due, TimeSpan period)
{
_tick = tick;
_dueTicks = due.Ticks;
Period = period;
}
public TimeSpan Due => TimeSpan.FromTicks(Interlocked.Read(ref _dueTicks));
public TimeSpan Period { get; private set; }
public bool Disposed { get; private set; }
public void Fire() => _tick();
public bool Change(TimeSpan dueTime, TimeSpan period)
{
if (Disposed)
throw new ObjectDisposedException(nameof(ManualTimer));
Interlocked.Exchange(ref _dueTicks, dueTime.Ticks);
Period = period;
return true;
}
public void Dispose() => Disposed = true;
public ValueTask DisposeAsync()
{
Dispose();
return ValueTask.CompletedTask;
}
}
}

View File

@@ -0,0 +1,80 @@
using StarterNG.Application;
namespace StarterNG.Tests;
public class OneAtATimeTests
{
private static async Task Until(Func<bool> condition)
{
var giveUp = DateTime.UtcNow.AddSeconds(5);
while (!condition())
{
Assert.True(DateTime.UtcNow < giveUp, "waited too long");
await Task.Delay(10);
}
}
[Fact]
public async Task Asked_once_it_runs_once()
{
int runs = 0;
var once = new OneAtATime(() => { runs++; return Task.CompletedTask; });
await once.RunAsync();
Assert.Equal(1, runs);
Assert.False(once.IsRunning);
}
[Fact]
public async Task Asked_while_running_it_runs_once_more_after_not_alongside()
{
int runs = 0, together = 0, most = 0;
var gates = new Queue<TaskCompletionSource>();
var once = new OneAtATime(async () =>
{
runs++;
most = Math.Max(most, ++together);
var gate = new TaskCompletionSource();
gates.Enqueue(gate);
await gate.Task;
together--;
});
var first = once.RunAsync();
// Three requests during the first run make one more run, not three.
await once.RunAsync();
await once.RunAsync();
await once.RunAsync();
Assert.Equal(1, runs);
gates.Dequeue().SetResult();
await Until(() => Volatile.Read(ref runs) == 2);
await Until(() => gates.Count == 1);
gates.Dequeue().SetResult();
await first;
Assert.Equal(2, runs);
Assert.Equal(1, most);
Assert.False(once.IsRunning);
}
[Fact]
public async Task A_failed_run_does_not_keep_it_busy()
{
bool fail = true;
int runs = 0;
var once = new OneAtATime(() =>
{
runs++;
return fail ? Task.FromException(new IOException("locked")) : Task.CompletedTask;
});
await Assert.ThrowsAsync<IOException>(once.RunAsync);
fail = false;
await once.RunAsync();
Assert.Equal(2, runs);
Assert.False(once.IsRunning);
}
}

View File

@@ -1520,4 +1520,75 @@ public class SettingsStoreTests
Assert.Null(LineFor(installation, "blackbox"));
}
[Fact]
public void The_sound_device_options_left_alone_add_nothing_to_the_file()
{
var installation = WithHome(new InMemoryFileSystem().WithFile(UserIni, "width 1920\n"));
installation.SettingsStore.Load();
installation.SettingsStore.Save();
string saved = SavedLines(installation);
foreach (var key in new[] { "sound.openal.renderer", "sound.outputmode", "sound.hrtf", "sound.hrtf.profile",
"sound.resampler", "sound.limiter", "sound.frequency", "sound.maxsources",
"sound.doppler", "sound.efx.lowpass", "sound.efx.airabsorption" })
Assert.Null(LineFor(installation, key));
Assert.Contains("width 1920\n", saved);
}
[Fact]
public void The_sound_device_options_survive_a_round_trip_with_names_in_quotes()
{
var installation = WithHome();
installation.SettingsStore.Load();
var s = installation.SettingsStore.Settings;
s.AudioDevice = "OpenAL Soft on Speakers (Realtek(R) Audio)";
s.AudioOutputMode = "headphones";
s.AudioHrtf = "on";
s.AudioHrtfProfile = "Built-In HRTF";
s.AudioResampler = "Cubic";
s.AudioLimiter = "off";
s.AudioFrequency = 48000;
s.AudioDoppler = 0.5;
s.AudioLowpass = true;
s.AudioAirAbsorption = 1.0;
installation.SettingsStore.Save();
Assert.Equal("sound.openal.renderer \"OpenAL Soft on Speakers (Realtek(R) Audio)\"",
LineFor(installation, "sound.openal.renderer"));
Assert.Equal("sound.resampler Cubic", LineFor(installation, "sound.resampler"));
Assert.Empty(BareSimulatorKeys(installation));
var again = WithHome(new InMemoryFileSystem().WithFile(UserIni, installation.Files.ReadAllText(UserIni)));
again.SettingsStore.Load();
var read = again.SettingsStore.Settings;
Assert.Equal(s.AudioDevice, read.AudioDevice);
Assert.Equal("headphones", read.AudioOutputMode);
Assert.Equal("on", read.AudioHrtf);
Assert.Equal("Built-In HRTF", read.AudioHrtfProfile);
Assert.Equal("Cubic", read.AudioResampler);
Assert.Equal("off", read.AudioLimiter);
Assert.Equal(48000, read.AudioFrequency);
Assert.Equal(0.5, read.AudioDoppler, 6);
Assert.True(read.AudioLowpass);
Assert.Equal(1.0, read.AudioAirAbsorption, 6);
}
[Fact]
public void A_sound_name_set_back_to_the_librarys_choice_takes_its_line_out()
{
var installation = WithHome(new InMemoryFileSystem()
.WithFile(UserIni, "sound.openal.renderer \"Old Device\"\nsound.resampler Cubic\n"));
installation.SettingsStore.Load();
Assert.Equal("Old Device", installation.SettingsStore.Settings.AudioDevice);
installation.SettingsStore.Settings.AudioDevice = "";
installation.SettingsStore.Settings.AudioResampler = "";
installation.SettingsStore.Save();
Assert.Null(LineFor(installation, "sound.openal.renderer"));
Assert.Null(LineFor(installation, "sound.resampler"));
}
}

View File

@@ -0,0 +1,45 @@
using System;
using System.Threading.Tasks;
namespace StarterNG.Application;
/// <summary>
/// Runs a piece of work one at a time. Asked again while it runs, it does not start a
/// second one alongside, nor forget the request: it runs once more when the first ends,
/// however many times it was asked meanwhile. For the UI thread, which calls it alone.
/// </summary>
public sealed class OneAtATime
{
private readonly Func<Task> _work;
private bool _running;
private bool _again;
public OneAtATime(Func<Task> work) => _work = work;
public bool IsRunning => _running;
public async Task RunAsync()
{
if (_running)
{
_again = true;
return;
}
_running = true;
try
{
do
{
_again = false;
await _work();
}
while (_again);
}
finally
{
_running = false;
_again = false;
}
}
}

View File

@@ -161,6 +161,29 @@ public sealed class SimulatorSettings
public int VehiclesVolume = 100;
public int PositionalVolume = 100;
public int AmbientVolume = 100;
// OpenAL Soft options of the simulator; the defaults leave the choice to the library, as the
// simulator did before it had these keys.
/// <summary>sound.openal.renderer: the output device, empty for the system's default.</summary>
public string AudioDevice = "";
/// <summary>sound.outputmode: auto, mono, stereo, stereo-basic, uhj, headphones, quad, 5.1, 6.1, 7.1.</summary>
public string AudioOutputMode = "auto";
/// <summary>sound.hrtf: auto, on, off.</summary>
public string AudioHrtf = "auto";
/// <summary>sound.hrtf.profile: the HRTF data set, empty for the library's choice.</summary>
public string AudioHrtfProfile = "";
/// <summary>sound.resampler: empty for the library's default.</summary>
public string AudioResampler = "";
/// <summary>sound.limiter: auto, on, off.</summary>
public string AudioLimiter = "auto";
/// <summary>sound.frequency: the mixing rate in Hz, 0 for the device's.</summary>
public int AudioFrequency;
/// <summary>sound.doppler: the strength of the Doppler effect.</summary>
public double AudioDoppler = 0.25;
/// <summary>sound.efx.lowpass: soundproofing also muffles the high frequencies.</summary>
public bool AudioLowpass;
/// <summary>sound.efx.airabsorption: 0-10, the high frequencies fade with distance.</summary>
public double AudioAirAbsorption;
public bool SkipPipeline;
public int PythonScreenUpdateRate = 200;
public bool DebugLogVisible;

View File

@@ -0,0 +1,55 @@
using System;
using System.IO;
namespace StarterNG.Infrastructure.Adapters;
/// <summary>
/// Tells when anything in a folder or below it is written, made, removed or renamed, as
/// the system reports it. Only a hint that it is time to look: a save comes as several
/// reports, and on a network drive, under Wine or past the system's limit of watches it
/// may come as none, so whoever listens still looks now and then on its own.
/// </summary>
public sealed class FolderChanges : IDisposable
{
private readonly FileSystemWatcher? _watcher;
/// <summary>Something changed, or the reports were lost and anything may have: on a thread of the pool.</summary>
public event Action? Changed;
/// <param name="folder">Watched with everything below it; a missing one is not watched.</param>
public FolderChanges(string folder)
{
try
{
if (!Directory.Exists(folder))
return;
var watcher = new FileSystemWatcher(folder)
{
IncludeSubdirectories = true,
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName
| NotifyFilters.LastWrite | NotifyFilters.Size,
// Unpacking an update changes hundreds of files at once.
InternalBufferSize = 64 * 1024
};
watcher.Changed += (_, _) => Changed?.Invoke();
watcher.Created += (_, _) => Changed?.Invoke();
watcher.Deleted += (_, _) => Changed?.Invoke();
watcher.Renamed += (_, _) => Changed?.Invoke();
// Too many at once for the buffer: which ones is lost, so all are looked at.
watcher.Error += (_, _) => Changed?.Invoke();
watcher.EnableRaisingEvents = true;
_watcher = watcher;
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException
or PlatformNotSupportedException)
{
// Out of watches on Linux, or a drive that gives none: the slow look alone stays.
}
}
/// <summary>Whether the system reports changes here at all.</summary>
public bool Watching => _watcher is not null;
public void Dispose() => _watcher?.Dispose();
}

View File

@@ -0,0 +1,96 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using Avalonia.Controls;
using Avalonia.Threading;
using StarterNG.Application;
using StarterNG.Infrastructure.Adapters;
namespace StarterNG.Infrastructure;
/// <summary>
/// Looks at a folder's files for a window, one look at a time on the UI thread: when the system
/// reports a change, once the burst a save makes has passed; when the window comes back to the
/// front; when asked; and now and then anyway, for the drives and systems where the reports do
/// not come - often where none come at all. From the window's opening to its closing.
/// </summary>
public sealed class FolderLooks
{
/// <summary>How long the reports have to stop for: a save comes as several of them.</summary>
public static readonly TimeSpan Quiet = TimeSpan.FromMilliseconds(400);
/// <summary>How often it looks anyway where the system reports the changes.</summary>
public static readonly TimeSpan Watched = TimeSpan.FromSeconds(30);
/// <summary>How often it looks where the system reports nothing.</summary>
public static readonly TimeSpan Unwatched = TimeSpan.FromSeconds(2);
private readonly Func<string> _folder;
private readonly OneAtATime _look;
private readonly TimeProvider _time;
private readonly object _gate = new();
private bool _closed;
private ITimer? _quiet;
private ITimer? _often;
private FolderChanges? _changes;
/// <param name="window">Looked for from its opening to its closing.</param>
/// <param name="folder">The folder, as it is when the window opens.</param>
/// <param name="look">The look itself; it knows when it is no time to look.</param>
/// <param name="time">The clock of the timers, the system's when not given.</param>
public FolderLooks(Window window, Func<string> folder, Func<Task> look, TimeProvider? time = null)
{
_folder = folder;
_look = new OneAtATime(look);
_time = time ?? TimeProvider.System;
window.Opened += (_, _) => Watch();
window.Activated += async (_, _) => await LookAsync();
window.Closed += (_, _) => Close();
}
/// <summary>Whether the system reports the folder's changes; not before the window opens.</summary>
public bool Watching => _changes?.Watching == true;
/// <summary>Looks now, or once more after the look that runs.</summary>
public Task LookAsync() => _look.RunAsync();
private void Watch()
{
var changes = new FolderChanges(_folder());
var often = changes.Watching ? Watched : Unwatched;
lock (_gate)
{
_changes = changes;
_quiet = _time.CreateTimer(_ => LookLater(), null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
_often = _time.CreateTimer(_ => LookLater(), null, often, often);
}
changes.Changed += PutOff;
}
// Each report puts the look off again, so a save of many files is one look after it. The
// reports come on threads of the pool, and may come still as the window closes.
private void PutOff()
{
lock (_gate)
{
if (!_closed)
_quiet?.Change(Quiet, Timeout.InfiniteTimeSpan);
}
}
// The timers tick on threads of the pool; the look belongs on the UI thread.
private void LookLater() => Dispatcher.UIThread.Post(() => _ = LookAsync());
private void Close()
{
FolderChanges? changes;
lock (_gate)
{
_closed = true;
_quiet?.Dispose();
_often?.Dispose();
changes = _changes;
}
changes?.Dispose();
}
}

View File

@@ -0,0 +1,159 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
namespace StarterNG.Infrastructure;
/// <summary>What the simulator's OpenAL library offers for its sound settings.</summary>
public sealed record AudioChoices(IReadOnlyList<string> Devices, IReadOnlyList<string> HrtfProfiles, IReadOnlyList<string> Resamplers)
{
public static AudioChoices None { get; } = new(Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>());
}
/// <summary>
/// Asks the OpenAL library beside the simulator, the one it plays through, for the output devices,
/// the HRTF data sets and the resamplers. The data sets and the resamplers are known only with a
/// device open, so the default one is opened for a moment. An older library (OpenAL Soft before
/// 1.19 lists no resamplers), or none at all, gives what it can and empty lists for the rest.
/// </summary>
public static unsafe class OpenAlProbe
{
private const int AlcDeviceSpecifier = 0x1005;
private const int AlcAllDevicesSpecifier = 0x1013;
private const int AlcNumHrtfSpecifiers = 0x1994;
private const int AlcHrtfSpecifier = 0x1995;
private const int AlNumResamplers = 0x1210;
private const int AlResamplerName = 0x1213;
/// <summary>The file of the library in the simulator's folder.</summary>
public static string LibraryFile => OperatingSystem.IsWindows() ? "OpenAL32.dll" : "libopenal.so.1";
public static AudioChoices Read(string gameFolder)
{
// The library stays loaded: OpenAL Soft keeps threads of its own, unloading it under them is not safe.
if (!NativeLibrary.TryLoad(Path.Combine(gameFolder, LibraryFile), out IntPtr library))
return AudioChoices.None;
try
{
return new Api(library).Read();
}
catch (EntryPointNotFoundException)
{
return AudioChoices.None;
}
}
/// <summary>The entry points of one library; the extension ones are null where it lacks them.</summary>
private sealed class Api
{
private readonly delegate* unmanaged[Cdecl]<IntPtr, byte*, byte> _alcIsExtensionPresent;
private readonly delegate* unmanaged[Cdecl]<IntPtr, int, byte*> _alcGetString;
private readonly delegate* unmanaged[Cdecl]<byte*, IntPtr> _alcOpenDevice;
private readonly delegate* unmanaged[Cdecl]<IntPtr, byte> _alcCloseDevice;
private readonly delegate* unmanaged[Cdecl]<IntPtr, int*, IntPtr> _alcCreateContext;
private readonly delegate* unmanaged[Cdecl]<IntPtr, byte> _alcMakeContextCurrent;
private readonly delegate* unmanaged[Cdecl]<IntPtr, void> _alcDestroyContext;
private readonly delegate* unmanaged[Cdecl]<IntPtr, int, int, int*, void> _alcGetIntegerv;
private readonly delegate* unmanaged[Cdecl]<int, int> _alGetInteger;
private readonly delegate* unmanaged[Cdecl]<IntPtr, int, int, byte*> _alcGetStringiSOFT;
private readonly delegate* unmanaged[Cdecl]<int, int, byte*> _alGetStringiSOFT;
public Api(IntPtr library)
{
_alcIsExtensionPresent = (delegate* unmanaged[Cdecl]<IntPtr, byte*, byte>)NativeLibrary.GetExport(library, "alcIsExtensionPresent");
_alcGetString = (delegate* unmanaged[Cdecl]<IntPtr, int, byte*>)NativeLibrary.GetExport(library, "alcGetString");
_alcOpenDevice = (delegate* unmanaged[Cdecl]<byte*, IntPtr>)NativeLibrary.GetExport(library, "alcOpenDevice");
_alcCloseDevice = (delegate* unmanaged[Cdecl]<IntPtr, byte>)NativeLibrary.GetExport(library, "alcCloseDevice");
_alcCreateContext = (delegate* unmanaged[Cdecl]<IntPtr, int*, IntPtr>)NativeLibrary.GetExport(library, "alcCreateContext");
_alcMakeContextCurrent = (delegate* unmanaged[Cdecl]<IntPtr, byte>)NativeLibrary.GetExport(library, "alcMakeContextCurrent");
_alcDestroyContext = (delegate* unmanaged[Cdecl]<IntPtr, void>)NativeLibrary.GetExport(library, "alcDestroyContext");
_alcGetIntegerv = (delegate* unmanaged[Cdecl]<IntPtr, int, int, int*, void>)NativeLibrary.GetExport(library, "alcGetIntegerv");
_alGetInteger = (delegate* unmanaged[Cdecl]<int, int>)NativeLibrary.GetExport(library, "alGetInteger");
// OpenAL Soft exports its extension functions too; a library without them leaves these null.
NativeLibrary.TryGetExport(library, "alcGetStringiSOFT", out IntPtr getStringi);
_alcGetStringiSOFT = (delegate* unmanaged[Cdecl]<IntPtr, int, int, byte*>)getStringi;
NativeLibrary.TryGetExport(library, "alGetStringiSOFT", out IntPtr alGetStringi);
_alGetStringiSOFT = (delegate* unmanaged[Cdecl]<int, int, byte*>)alGetStringi;
}
public AudioChoices Read()
{
int deviceList = HasExtension("ALC_ENUMERATE_ALL_EXT\0"u8) ? AlcAllDevicesSpecifier : AlcDeviceSpecifier;
List<string> devices = NameList(_alcGetString(IntPtr.Zero, deviceList));
IntPtr device = _alcOpenDevice(null);
if (device == IntPtr.Zero)
return new AudioChoices(devices, Array.Empty<string>(), Array.Empty<string>());
try
{
return new AudioChoices(devices, HrtfProfiles(device), Resamplers(device));
}
finally
{
_alcCloseDevice(device);
}
}
private bool HasExtension(ReadOnlySpan<byte> name)
{
fixed (byte* text = name)
return _alcIsExtensionPresent(IntPtr.Zero, text) != 0;
}
private List<string> HrtfProfiles(IntPtr device)
{
var names = new List<string>();
if (_alcGetStringiSOFT == null)
return names;
int count = 0;
_alcGetIntegerv(device, AlcNumHrtfSpecifiers, 1, &count);
for (int index = 0; index < count; index++)
names.Add(Utf8(_alcGetStringiSOFT(device, AlcHrtfSpecifier, index)));
return names;
}
private List<string> Resamplers(IntPtr device)
{
var names = new List<string>();
if (_alGetStringiSOFT == null)
return names;
IntPtr context = _alcCreateContext(device, null);
if (context == IntPtr.Zero)
return names;
try
{
_alcMakeContextCurrent(context);
int count = _alGetInteger(AlNumResamplers);
for (int index = 0; index < count; index++)
names.Add(Utf8(_alGetStringiSOFT(AlResamplerName, index)));
}
finally
{
_alcMakeContextCurrent(IntPtr.Zero);
_alcDestroyContext(context);
}
return names;
}
}
private static string Utf8(byte* text) => text == null ? "" : Marshal.PtrToStringUTF8((IntPtr)text) ?? "";
/// <summary>A list of null-terminated names ending with an empty one, as OpenAL gives the devices.</summary>
private static List<string> NameList(byte* list)
{
var names = new List<string>();
if (list == null)
return names;
while (*list != 0)
{
int length = 0;
while (list[length] != 0)
length++;
names.Add(Encoding.UTF8.GetString(list, length));
list += length + 1;
}
return names;
}
}

View File

@@ -194,6 +194,7 @@ public sealed class SettingsSerializer
s.VehiclesVolume = Clamp((int)Math.Round(c.GetDouble("sound.volume.vehicle", 1.0) * 100), 0, 100);
s.PositionalVolume = Clamp((int)Math.Round(c.GetDouble("sound.volume.positional", 1.0) * 100), 0, 100);
s.AmbientVolume = Clamp((int)Math.Round(c.GetDouble("sound.volume.ambient", 1.0) * 100), 0, 100);
ReadAudioDevice(c, s);
s.SkipPipeline = c.GetBool("gfx.skippipeline", false);
s.PythonScreenUpdateRate = c.Has("python.updatetime")
? Clamp(c.GetInt("python.updatetime", 200), 0, 10000)
@@ -412,6 +413,7 @@ public sealed class SettingsSerializer
c.SetDouble("sound.volume.vehicle", s.VehiclesVolume / 100.0);
c.SetDouble("sound.volume.positional", s.PositionalVolume / 100.0);
c.SetDouble("sound.volume.ambient", s.AmbientVolume / 100.0);
WriteAudioDevice(c, s);
c.SetBool("gfx.skippipeline", s.SkipPipeline);
c.SetInt("python.updatetime", s.PythonScreenUpdateRate);
@@ -457,6 +459,65 @@ public sealed class SettingsSerializer
return Clamp((int)Math.Round(value > 4 ? value : value * 100), 25, 200);
}
// The OpenAL Soft options. The names (devices, HRTF data sets, resamplers) can hold spaces, so
// the simulator takes them in quotes.
private static void ReadAudioDevice(ConfigFile c, SimulatorSettings s)
{
s.AudioDevice = Unquoted(c.GetString("sound.openal.renderer", ""));
s.AudioOutputMode = FirstTokenOr(c, "sound.outputmode", "auto");
s.AudioHrtf = FirstTokenOr(c, "sound.hrtf", "auto");
s.AudioHrtfProfile = Unquoted(c.GetString("sound.hrtf.profile", ""));
s.AudioResampler = Unquoted(c.GetString("sound.resampler", ""));
s.AudioLimiter = FirstTokenOr(c, "sound.limiter", "auto");
s.AudioFrequency = Clamp(c.GetInt("sound.frequency", 0), 0, 192000);
s.AudioDoppler = Math.Clamp(c.GetDouble("sound.doppler", 0.25), 0.0, 10.0);
s.AudioLowpass = c.GetBool("sound.efx.lowpass", false);
s.AudioAirAbsorption = Math.Clamp(c.GetDouble("sound.efx.airabsorption", 0.0), 0.0, 10.0);
}
// A key the file lacks is written only when the value differs from the simulator's default, so
// saving with these left alone adds nothing an older simulator would not know.
private static void WriteAudioDevice(ConfigFile c, SimulatorSettings s)
{
SetName(c, "sound.openal.renderer", s.AudioDevice);
SetUnlessDefault(c, "sound.outputmode", s.AudioOutputMode, "auto");
SetUnlessDefault(c, "sound.hrtf", s.AudioHrtf, "auto");
SetName(c, "sound.hrtf.profile", s.AudioHrtfProfile);
SetName(c, "sound.resampler", s.AudioResampler);
SetUnlessDefault(c, "sound.limiter", s.AudioLimiter, "auto");
if (c.Has("sound.frequency") || s.AudioFrequency != 0) c.SetInt("sound.frequency", s.AudioFrequency);
if (c.Has("sound.doppler") || Math.Abs(s.AudioDoppler - 0.25) > 1e-9) c.SetDouble("sound.doppler", s.AudioDoppler);
if (c.Has("sound.efx.lowpass") || s.AudioLowpass) c.SetBool("sound.efx.lowpass", s.AudioLowpass);
if (c.Has("sound.efx.airabsorption") || s.AudioAirAbsorption != 0.0) c.SetDouble("sound.efx.airabsorption", s.AudioAirAbsorption);
}
private static void SetUnlessDefault(ConfigFile c, string key, string value, string fallback)
{
if (c.Has(key) || value != fallback)
c.Set(key, value);
}
// An empty name is the library's choice: the line goes, rather than staying with a name in it.
private static void SetName(ConfigFile c, string key, string name)
{
if (name.Length > 0)
c.Set(key, name.Contains(' ') ? $"\"{name}\"" : name);
else if (c.Has(key))
c.Remove(key);
}
private static string Unquoted(string value)
{
value = value.Trim();
return value.Length >= 2 && value[0] == '"' && value[^1] == '"' ? value[1..^1] : value;
}
private static string FirstTokenOr(ConfigFile c, string key, string fallback)
{
string token = FirstToken(c, key);
return token.Length > 0 ? token : fallback;
}
private static string FirstToken(ConfigFile c, string key)
{
var tokens = c.GetTokens(key);

View File

@@ -40,8 +40,9 @@ public partial class MainWindow : Window
private DateTime _openedUtc = DateTime.UtcNow;
private DateTime _startedUtc = DateTime.MinValue;
private bool _starting;
private bool _lookingAtSceneryFiles;
private readonly DispatcherTimer _sceneryFilesTimer = new() { Interval = TimeSpan.FromSeconds(2) };
// Scenery files: looked at when they change, on coming back to the window or from the
// simulator, and now and then anyway.
private readonly FolderLooks _sceneryLooks;
public MainWindow()
{
@@ -107,7 +108,6 @@ public partial class MainWindow : Window
_openedUtc = DateTime.UtcNow;
UpdateStartButton();
_sceneryFilesTimer.Start();
FollowLastRun();
};
Activated += (_, _) =>
@@ -117,20 +117,20 @@ public partial class MainWindow : Window
if (SettingsView.IsVisible)
SettingsView.RefreshExecutables();
};
_sceneryFilesTimer.Tick += async (_, _) => await LookAtSceneryFilesAsync();
Closed += (_, _) => _sceneryFilesTimer.Stop();
// After the handlers above: back at the window, the settings are checked first.
_sceneryLooks = new FolderLooks(this, () => AppServices.Current.Paths.Scenery, LookAtSceneryFilesAsync);
}
/// <summary>
/// Scenery files changed outside the starter are picked up without a reload. Not
/// with the simulator running: it is left in peace, and what it changes comes in after it.
/// Run through <see cref="_sceneryLooks"/>, one look at a time.
/// </summary>
private async Task LookAtSceneryFilesAsync()
{
if (_lookingAtSceneryFiles || AppServices.Current.State.SimulatorRunning || !IsVisible || WindowState == WindowState.Minimized)
if (AppServices.Current.State.SimulatorRunning || !IsVisible || WindowState == WindowState.Minimized)
return;
_lookingAtSceneryFiles = true;
try
{
var services = AppServices.Current;
@@ -146,10 +146,6 @@ public partial class MainWindow : Window
{
Diagnostics.Log("Following the scenery files", ex);
}
finally
{
_lookingAtSceneryFiles = false;
}
}
/// <summary>
@@ -765,6 +761,8 @@ public partial class MainWindow : Window
FollowLastRun();
RestoreFromSimulator();
ReportIfCrashed(simulator, executable, started);
// What the simulator or its editor wrote while it ran comes in now.
_ = _sceneryLooks.LookAsync();
}), TaskScheduler.Default);
}

View File

@@ -6,6 +6,8 @@
<IsAotCompatible>true</IsAotCompatible>
<TargetFramework>net9.0</TargetFramework>
<Nullable>enable</Nullable>
<!-- function pointers into the OpenAL library of the simulator (Infrastructure/OpenAlProbe.cs) -->
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<BuiltInComInteropSupport>true</BuiltInComInteropSupport>
<ApplicationManifest>app.manifest</ApplicationManifest>
<ApplicationIcon>Assets\starter.ico</ApplicationIcon>

View File

@@ -0,0 +1,87 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Avalonia.Controls;
using StarterNG.Application;
using StarterNG.Domain.Settings;
using StarterNG.Infrastructure;
using StarterNG.Infrastructure.Adapters;
namespace StarterNG.Views;
// The OpenAL Soft options of the sound category. The lists of devices, HRTF data sets and
// resamplers come from the simulator's own OpenAL library, read in the background; until then,
// and where the library cannot say, a list holds the library's choice and the value of the file.
public partial class Settings
{
// eu07.ini is written in code page 1250: a name it cannot hold (a device named in Cyrillic, say)
// would reach the simulator as question marks, so such a name is not offered.
private static readonly Encoding StrictCodePage1250 =
Encoding.GetEncoding(LegacyText.CodePage1250.CodePage, EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);
private async void ReadAudioChoices()
{
string root = AppServices.Current.Paths.Root;
AudioChoices choices = await Task.Run(() => OpenAlProbe.Read(root));
// Adding items leaves the selection alone, so this marks nothing as changed.
AddNames(AudioDeviceCb, choices.Devices, FitsTheFile);
// The simulator finds a device named in code page 1250 too, but an HRTF data set or a
// resampler only by the library's own spelling, so of those only plain ASCII is offered.
AddNames(AudioHrtfProfileCb, choices.HrtfProfiles, PlainAscii);
AddNames(AudioResamplerCb, choices.Resamplers, PlainAscii);
}
private static void AddNames(ComboBox cb, IReadOnlyList<string> names, Func<string, bool> offered)
{
foreach (string name in names)
if (name.Length > 0 && offered(name) && IndexOfTag(cb, name) < 0)
cb.Items.Add(new ComboBoxItem { Tag = name, Content = name });
}
private static bool PlainAscii(string name) => Ascii.IsValid(name);
private static bool FitsTheFile(string name)
{
try
{
StrictCodePage1250.GetByteCount(name);
return true;
}
catch (EncoderFallbackException)
{
return false;
}
}
private void ShowSound(SimulatorSettings s)
{
SelectOrAddTag(AudioDeviceCb, s.AudioDevice, s.AudioDevice);
SelectOrAddTag(AudioOutputModeCb, s.AudioOutputMode, s.AudioOutputMode);
SelectOrAddTag(AudioHrtfCb, s.AudioHrtf, s.AudioHrtf);
SelectOrAddTag(AudioHrtfProfileCb, s.AudioHrtfProfile, s.AudioHrtfProfile);
SelectOrAddTag(AudioResamplerCb, s.AudioResampler, s.AudioResampler);
SelectOrAddTag(AudioLimiterCb, s.AudioLimiter, s.AudioLimiter);
string frequency = s.AudioFrequency.ToString(Invariant);
SelectOrAddTag(AudioFrequencyCb, frequency, frequency + " Hz");
AudioDopplerSlider.Value = s.AudioDoppler;
AudioLowpassCb.IsChecked = s.AudioLowpass;
AudioAirAbsorptionSlider.Value = s.AudioAirAbsorption;
}
private void CaptureSound(SimulatorSettings s)
{
s.AudioDevice = SelectedTag(AudioDeviceCb) ?? "";
s.AudioOutputMode = SelectedTag(AudioOutputModeCb) ?? "auto";
s.AudioHrtf = SelectedTag(AudioHrtfCb) ?? "auto";
s.AudioHrtfProfile = SelectedTag(AudioHrtfProfileCb) ?? "";
s.AudioResampler = SelectedTag(AudioResamplerCb) ?? "";
s.AudioLimiter = SelectedTag(AudioLimiterCb) ?? "auto";
s.AudioFrequency = TagInt(AudioFrequencyCb, 0);
// A value the slider can't show (past its end, between its ticks) is kept by the
// shown-unlike bookkeeping of the page until the slider is moved.
s.AudioDoppler = AudioDopplerSlider.Value;
s.AudioLowpass = IsChecked(AudioLowpassCb);
s.AudioAirAbsorption = AudioAirAbsorptionSlider.Value;
}
}

View File

@@ -537,6 +537,86 @@
</ctl:SettingRow>
</StackPanel>
</ctl:SettingsSection>
<ctl:SettingsSection Header="{Binding [SoundDevice], Source={x:Static starterNg:App.Loc}}">
<StackPanel IsEnabled="{Binding #EnableSoundsCb.IsChecked}">
<ctl:SettingRow ConfigKey="sound.openal.renderer" Label="{Binding [SoundOutputDevice], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundOutputDeviceDesc], Source={x:Static starterNg:App.Loc}}">
<ComboBox x:Name="AudioDeviceCb" HorizontalAlignment="Stretch">
<ComboBoxItem Tag="" Content="{Binding [SoundSystemDefault], Source={x:Static starterNg:App.Loc}}" />
</ComboBox>
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.outputmode" Label="{Binding [SoundOutputMode], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundOutputModeDesc], Source={x:Static starterNg:App.Loc}}">
<ComboBox x:Name="AudioOutputModeCb" Classes="Localized" SelectedIndex="0">
<ComboBoxItem Tag="auto" Content="{Binding [SoundAutomatic], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="mono" Content="Mono" />
<ComboBoxItem Tag="stereo" Content="Stereo" />
<ComboBoxItem Tag="stereo-basic" Content="{Binding [SoundStereoBasic], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="uhj" Content="{Binding [SoundStereoUhj], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="headphones" Content="{Binding [SoundHeadphones], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="quad" Content="Quad" />
<ComboBoxItem Tag="5.1" Content="5.1" />
<ComboBoxItem Tag="6.1" Content="6.1" />
<ComboBoxItem Tag="7.1" Content="7.1" />
</ComboBox>
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.hrtf" Label="HRTF"
Description="{Binding [SoundHrtfDesc], Source={x:Static starterNg:App.Loc}}">
<ComboBox x:Name="AudioHrtfCb" Classes="Localized" SelectedIndex="0">
<ComboBoxItem Tag="auto" Content="{Binding [SoundAutomatic], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="on" Content="{Binding [SoundOn], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="off" Content="{Binding [SoundOff], Source={x:Static starterNg:App.Loc}}" />
</ComboBox>
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.hrtf.profile" Label="{Binding [SoundHrtfProfile], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundHrtfProfileDesc], Source={x:Static starterNg:App.Loc}}">
<ComboBox x:Name="AudioHrtfProfileCb" HorizontalAlignment="Stretch">
<ComboBoxItem Tag="" Content="{Binding [SoundLibraryChoice], Source={x:Static starterNg:App.Loc}}" />
</ComboBox>
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.resampler" Label="{Binding [SoundResampler], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundResamplerDesc], Source={x:Static starterNg:App.Loc}}">
<ComboBox x:Name="AudioResamplerCb" HorizontalAlignment="Stretch">
<ComboBoxItem Tag="" Content="{Binding [SoundLibraryDefault], Source={x:Static starterNg:App.Loc}}" />
</ComboBox>
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.limiter" Label="{Binding [SoundLimiter], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundLimiterDesc], Source={x:Static starterNg:App.Loc}}">
<ComboBox x:Name="AudioLimiterCb" Classes="Localized" SelectedIndex="0">
<ComboBoxItem Tag="auto" Content="{Binding [SoundAutomatic], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="on" Content="{Binding [SoundOn], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="off" Content="{Binding [SoundOff], Source={x:Static starterNg:App.Loc}}" />
</ComboBox>
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.frequency" Label="{Binding [SoundFrequency], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundFrequencyDesc], Source={x:Static starterNg:App.Loc}}">
<ComboBox x:Name="AudioFrequencyCb" Classes="Localized" SelectedIndex="0">
<ComboBoxItem Tag="0" Content="{Binding [SoundDeviceRate], Source={x:Static starterNg:App.Loc}}" />
<ComboBoxItem Tag="22050" Content="22050 Hz" />
<ComboBoxItem Tag="32000" Content="32000 Hz" />
<ComboBoxItem Tag="44100" Content="44100 Hz" />
<ComboBoxItem Tag="48000" Content="48000 Hz" />
<ComboBoxItem Tag="96000" Content="96000 Hz" />
</ComboBox>
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.doppler" Label="{Binding [SoundDoppler], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundDopplerDesc], Source={x:Static starterNg:App.Loc}}"
ValueText="{Binding #AudioDopplerSlider.Value, StringFormat='{}{0:0.00}'}">
<ctl:ReadableSlider x:Name="AudioDopplerSlider" Minimum="0" Maximum="1" TickFrequency="0.05"
IsSnapToTickEnabled="True" Value="0.25" />
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.efx.lowpass" Label="{Binding [SoundLowpass], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundLowpassDesc], Source={x:Static starterNg:App.Loc}}">
<CheckBox x:Name="AudioLowpassCb" />
</ctl:SettingRow>
<ctl:SettingRow ConfigKey="sound.efx.airabsorption" Label="{Binding [SoundAirAbsorption], Source={x:Static starterNg:App.Loc}}"
Description="{Binding [SoundAirAbsorptionDesc], Source={x:Static starterNg:App.Loc}}"
ValueText="{Binding #AudioAirAbsorptionSlider.Value, StringFormat='{}{0:0.0}'}">
<ctl:ReadableSlider x:Name="AudioAirAbsorptionSlider" Minimum="0" Maximum="10" TickFrequency="0.5"
IsSnapToTickEnabled="True" Value="0" />
</ctl:SettingRow>
</StackPanel>
</ctl:SettingsSection>
</StackPanel>
<!-- ============================ PHYSICS ============================ -->

View File

@@ -100,6 +100,7 @@ public partial class Settings : UserControl, ISettingsCapture
BuildPresetButtons();
BuildMonitorRates();
ReadGraphicsCards();
ReadAudioChoices();
App.Loc.LanguageChanged += UpdateCardText;
App.Loc.LanguageChanged += _keyRows.UpdateTexts;
@@ -436,6 +437,7 @@ public partial class Settings : UserControl, ISettingsCapture
LogMissingVehicleFilesCb.IsChecked = s.LogMissingVehicleFiles;
ShowGraphics(s);
ShowSound(s);
GpuCb.SelectedIndex = s.Gpu == GpuPreference.System ? 1 : 0;
SelectResolution(s.Width, s.Height);
bufferScale.Value = s.BufferScalePercent;
@@ -869,6 +871,7 @@ public partial class Settings : UserControl, ISettingsCapture
s.LogMissingVehicleFiles = IsChecked(LogMissingVehicleFilesCb);
CaptureGraphics(s);
CaptureSound(s);
s.Gpu = SelectedGpu();
ReadResolution(s);
s.BufferScalePercent = (int)bufferScale.Value;

View File

@@ -518,6 +518,26 @@
<String key="VehiclesVolume">Hlasitost vozidel</String>
<String key="PositionedSoundsVolume">Hlasitost prostorových zvuků</String>
<String key="AmbientVolume">Hlasitost okolí</String>
<String key="SoundDevice">Zvukové zařízení a efekty</String>
<String key="SoundOutputDevice">Výstupní zařízení</String>
<String key="SoundSystemDefault">Výchozí systémové</String>
<String key="SoundOutputMode">Rozložení reproduktorů</String>
<String key="SoundAutomatic">Automaticky</String>
<String key="SoundStereoBasic">Stereo (jednoduché panorama)</String>
<String key="SoundStereoUhj">Stereo (UHJ, širší)</String>
<String key="SoundHeadphones">Sluchátka (HRTF)</String>
<String key="SoundOn">Zapnuto</String>
<String key="SoundOff">Vypnuto</String>
<String key="SoundHrtfProfile">Sada dat HRTF</String>
<String key="SoundLibraryChoice">Volba knihovny</String>
<String key="SoundResampler">Převzorkování</String>
<String key="SoundLibraryDefault">Výchozí knihovny</String>
<String key="SoundLimiter">Omezovač výstupu</String>
<String key="SoundFrequency">Vzorkovací frekvence mixu</String>
<String key="SoundDeviceRate">Frekvence zařízení</String>
<String key="SoundDoppler">Dopplerův jev</String>
<String key="SoundLowpass">Tlumené zvuky mimo kabinu</String>
<String key="SoundAirAbsorption">Pohlcování vzduchem</String>
<String key="Advanced">Pokročilé</String>
<String key="CompressTextures">Komprimovat textury TGA</String>

View File

@@ -544,6 +544,36 @@
<String key="VehiclesVolume">Vehicles volume</String>
<String key="PositionedSoundsVolume">Positional sounds volume</String>
<String key="AmbientVolume">Ambient volume</String>
<String key="SoundDevice">Sound device and effects</String>
<String key="SoundOutputDevice">Output device</String>
<String key="SoundOutputDeviceDesc">The device the simulator plays through. The system default follows the device chosen in the system, also when it changes during the game.</String>
<String key="SoundSystemDefault">System default</String>
<String key="SoundOutputMode">Speaker layout</String>
<String key="SoundOutputModeDesc">How the sound is mixed: for headphones, stereo speakers or a surround set. Automatic takes what the device reports.</String>
<String key="SoundAutomatic">Automatic</String>
<String key="SoundStereoBasic">Stereo (simple panning)</String>
<String key="SoundStereoUhj">Stereo (UHJ, wider)</String>
<String key="SoundHeadphones">Headphones (HRTF)</String>
<String key="SoundHrtfDesc">Head-related sound for headphones: sources behind, above and below can be told apart. Automatic turns it on where the device is headphones.</String>
<String key="SoundOn">On</String>
<String key="SoundOff">Off</String>
<String key="SoundHrtfProfile">HRTF data set</String>
<String key="SoundHrtfProfileDesc">Which head model HRTF uses, of those the library has. A different one may suit your ears better.</String>
<String key="SoundLibraryChoice">Library's choice</String>
<String key="SoundResampler">Resampler</String>
<String key="SoundResamplerDesc">How sounds are converted to the device's rate and pitched. The better ones sound cleaner and cost a little more processor time.</String>
<String key="SoundLibraryDefault">Library default</String>
<String key="SoundLimiter">Output limiter</String>
<String key="SoundLimiterDesc">Keeps loud moments from clipping by turning the whole mix down for a moment.</String>
<String key="SoundFrequency">Mixing rate</String>
<String key="SoundFrequencyDesc">The sample rate the sound is mixed at. The device's own rate avoids converting it once more.</String>
<String key="SoundDeviceRate">Device rate</String>
<String key="SoundDoppler">Doppler effect</String>
<String key="SoundDopplerDesc">How much the pitch of a passing vehicle changes. 0 turns the effect off, 1 is the physical one.</String>
<String key="SoundLowpass">Muffled sounds outside the cab</String>
<String key="SoundLowpassDesc">Sounds heard through the cab walls lose their high tones as well as their loudness.</String>
<String key="SoundAirAbsorption">Air absorption</String>
<String key="SoundAirAbsorptionDesc">Distant sounds lose their high tones, as in the open air. 0 turns it off, 1 is the natural amount.</String>
<String key="Advanced">Advanced</String>
<String key="CompressTextures">Compress TGA textures</String>

View File

@@ -518,6 +518,26 @@
<String key="VehiclesVolume">Járművek hangereje</String>
<String key="PositionedSoundsVolume">Térbeli hangok hangereje</String>
<String key="AmbientVolume">Környezeti hangok hangereje</String>
<String key="SoundDevice">Hangeszköz és effektek</String>
<String key="SoundOutputDevice">Kimeneti eszköz</String>
<String key="SoundSystemDefault">Rendszer alapértelmezése</String>
<String key="SoundOutputMode">Hangszóró-elrendezés</String>
<String key="SoundAutomatic">Automatikus</String>
<String key="SoundStereoBasic">Sztereó (egyszerű panoráma)</String>
<String key="SoundStereoUhj">Sztereó (UHJ, szélesebb)</String>
<String key="SoundHeadphones">Fejhallgató (HRTF)</String>
<String key="SoundOn">Be</String>
<String key="SoundOff">Ki</String>
<String key="SoundHrtfProfile">HRTF-adatkészlet</String>
<String key="SoundLibraryChoice">A könyvtár választása</String>
<String key="SoundResampler">Újramintavételezés</String>
<String key="SoundLibraryDefault">A könyvtár alapértelmezése</String>
<String key="SoundLimiter">Kimeneti limiter</String>
<String key="SoundFrequency">Keverési mintavételi frekvencia</String>
<String key="SoundDeviceRate">Az eszköz frekvenciája</String>
<String key="SoundDoppler">Doppler-hatás</String>
<String key="SoundLowpass">Tompított hangok a fülkén kívülről</String>
<String key="SoundAirAbsorption">Levegő általi elnyelés</String>
<String key="Advanced">Speciális</String>
<String key="CompressTextures">TGA textúrák tömörítése</String>

View File

@@ -544,6 +544,36 @@
<String key="VehiclesVolume">Głośność pojazdów</String>
<String key="PositionedSoundsVolume">Głośność dźwięków pozycjonowanych</String>
<String key="AmbientVolume">Głośność otoczenia</String>
<String key="SoundDevice">Urządzenie i efekty dźwięku</String>
<String key="SoundOutputDevice">Urządzenie wyjściowe</String>
<String key="SoundOutputDeviceDesc">Urządzenie, przez które gra symulator. Domyślne systemowe idzie za urządzeniem wybranym w systemie, także gdy zmieni się ono w trakcie gry.</String>
<String key="SoundSystemDefault">Domyślne systemowe</String>
<String key="SoundOutputMode">Układ głośników</String>
<String key="SoundOutputModeDesc">Jak dźwięk jest miksowany: na słuchawki, głośniki stereo albo zestaw dookólny. Automatycznie bierze to, co zgłasza urządzenie.</String>
<String key="SoundAutomatic">Automatycznie</String>
<String key="SoundStereoBasic">Stereo (proste panoramowanie)</String>
<String key="SoundStereoUhj">Stereo (UHJ, szersze)</String>
<String key="SoundHeadphones">Słuchawki (HRTF)</String>
<String key="SoundHrtfDesc">Dźwięk przestrzenny na słuchawki: źródła z tyłu, z góry i z dołu dają się odróżnić. Automatycznie włącza go, gdy urządzeniem są słuchawki.</String>
<String key="SoundOn">Włączone</String>
<String key="SoundOff">Wyłączone</String>
<String key="SoundHrtfProfile">Zestaw danych HRTF</String>
<String key="SoundHrtfProfileDesc">Którego modelu głowy używa HRTF, spośród tych, które ma biblioteka. Inny może lepiej pasować do twoich uszu.</String>
<String key="SoundLibraryChoice">Wybór biblioteki</String>
<String key="SoundResampler">Przepróbkowanie</String>
<String key="SoundResamplerDesc">Jak dźwięki są przeliczane na częstotliwość urządzenia i zmieniają wysokość. Lepsze brzmią czyściej i kosztują trochę więcej czasu procesora.</String>
<String key="SoundLibraryDefault">Domyślne biblioteki</String>
<String key="SoundLimiter">Ogranicznik wyjścia</String>
<String key="SoundLimiterDesc">Chroni głośne chwile przed przesterowaniem, na moment ściszając cały miks.</String>
<String key="SoundFrequency">Częstotliwość miksowania</String>
<String key="SoundFrequencyDesc">Częstotliwość próbkowania, z jaką dźwięk jest miksowany. Własna częstotliwość urządzenia oszczędza jeszcze jednego przeliczenia.</String>
<String key="SoundDeviceRate">Częstotliwość urządzenia</String>
<String key="SoundDoppler">Efekt Dopplera</String>
<String key="SoundDopplerDesc">Jak bardzo zmienia się wysokość dźwięku przejeżdżającego pojazdu. 0 wyłącza efekt, 1 to wartość fizyczna.</String>
<String key="SoundLowpass">Stłumione dźwięki spoza kabiny</String>
<String key="SoundLowpassDesc">Dźwięki słyszane przez ściany kabiny tracą wysokie tony, a nie tylko głośność.</String>
<String key="SoundAirAbsorption">Pochłanianie przez powietrze</String>
<String key="SoundAirAbsorptionDesc">Odległe dźwięki tracą wysokie tony, jak na otwartej przestrzeni. 0 wyłącza, 1 to naturalna wartość.</String>
<String key="Advanced">Zaawansowane</String>
<String key="CompressTextures">Kompresuj tekstury TGA</String>

View File

@@ -518,6 +518,26 @@
<String key="VehiclesVolume">Громкость подвижного состава</String>
<String key="PositionedSoundsVolume">Громкость позиционных звуков</String>
<String key="AmbientVolume">Громкость окружения</String>
<String key="SoundDevice">Звуковое устройство и эффекты</String>
<String key="SoundOutputDevice">Устройство вывода</String>
<String key="SoundSystemDefault">Системное по умолчанию</String>
<String key="SoundOutputMode">Конфигурация динамиков</String>
<String key="SoundAutomatic">Автоматически</String>
<String key="SoundStereoBasic">Стерео (простое панорамирование)</String>
<String key="SoundStereoUhj">Стерео (UHJ, шире)</String>
<String key="SoundHeadphones">Наушники (HRTF)</String>
<String key="SoundOn">Вкл.</String>
<String key="SoundOff">Выкл.</String>
<String key="SoundHrtfProfile">Набор данных HRTF</String>
<String key="SoundLibraryChoice">Выбор библиотеки</String>
<String key="SoundResampler">Передискретизация</String>
<String key="SoundLibraryDefault">По умолчанию библиотеки</String>
<String key="SoundLimiter">Ограничитель выхода</String>
<String key="SoundFrequency">Частота микширования</String>
<String key="SoundDeviceRate">Частота устройства</String>
<String key="SoundDoppler">Эффект Доплера</String>
<String key="SoundLowpass">Приглушённые звуки вне кабины</String>
<String key="SoundAirAbsorption">Поглощение воздухом</String>
<String key="Advanced">Дополнительно</String>
<String key="CompressTextures">Сжимать текстуры TGA</String>