EngineConfiguration.cs

using Gondwana.Logging;
using Gondwana.Rendering;
using Gondwana.Rendering.Backbuffers;
using Gondwana.Timers;
using Newtonsoft.Json;
 
namespace Gondwana.Configuration;

[JsonObject]
public partial class EngineConfiguration
{
    private float _renderScale = 1f;

    public float RenderScale
    {
        get => _renderScale;
        set
        {
            if (!float.IsFinite(value) || value <= 0)
                throw new ArgumentOutOfRangeException(nameof(value), "RenderScale must be finite and positive.");
            if (_renderScale == value) return;
            var surfaces = RenderSurfaceHostRegistry.Snapshot();
            // Validate every dimension before publishing intent or queuing any changes.
            foreach (var surface in surfaces)
            {
                if (surface.RenderSurfaceAdapter is { } adapter)
                {
                    PresentationTransform.ScaleDimension(adapter.Width, value);
                    PresentationTransform.ScaleDimension(adapter.Height, value);
                }
            }
            _renderScale = value;
            foreach (var surface in surfaces)
                surface.RequestRenderScale(value);
        }
    }
 
    private RenderScalingFilter _renderScalingFilter = RenderScalingFilter.Linear;

    public RenderScalingFilter RenderScalingFilter
    {
        get => _renderScalingFilter;
        set
        {
            if (!Enum.IsDefined(value)) throw new ArgumentOutOfRangeException(nameof(value));
            _renderScalingFilter = value;
            foreach (var surface in RenderSurfaceHostRegistry.Snapshot())
                surface.InvalidatePresentation();
        }
    }
 
    private int _targetFPS = 60;

    public int TargetFPS
    {
        get => _targetFPS;
        set
        {
            _targetFPS = value < 0 ? 0 : value;
 
            // Propagate to all active GPU backbuffers so their TargetFps stays in sync.
            foreach (var surface in RenderSurfaceHostRegistry.Snapshot())
            {
                if (surface.Backbuffer is GpuBackbuffer gpuBb)
                    gpuBb.TargetFps = _targetFPS;
            }
        }
    }
 
    private int _timerDrivenSimulationRate = 120;

    public int TimerDrivenSimulationRate
    {
        get => _timerDrivenSimulationRate;
        set => _timerDrivenSimulationRate = Math.Max(1, value);
    }
 
    private int _maxTimerDrivenSimulationSteps = 8;

    public int MaxTimerDrivenSimulationSteps
    {
        get => _maxTimerDrivenSimulationSteps;
        set => _maxTimerDrivenSimulationSteps = Math.Max(1, value);
    }
 
    private float _startInitializationWaitTimeout = 30f;

    public float StartInitializationWaitTimeout
    {
        get => _startInitializationWaitTimeout;
        set => _startInitializationWaitTimeout =
            !float.IsFinite(value) || value <= 0f
                ? 0.001f
                : Math.Min(value, (float)TimeSpan.MaxValue.TotalSeconds);
    }
 
    private bool _vSync = true;

    public bool VSync
    {
        get => _vSync;
        set
        {
            _vSync = value;
 
            // Propagate to all active GPU backbuffers so their VSync stays in sync.
            foreach (var surface in RenderSurfaceHostRegistry.Snapshot())
            {
                if (surface.Backbuffer is GpuBackbuffer gpuBb)
                    gpuBb.VSync = _vSync;
            }
        }
    }
 
    private int _msaaSampleCount = 1;

    public int MsaaSampleCount
    {
        get => _msaaSampleCount;
        set
        {
            _msaaSampleCount = value < 1 ? 1 : value;
 
            // Propagate to all active GPU backbuffers so their MsaaSampleCount stays in sync.
            foreach (var surface in RenderSurfaceHostRegistry.Snapshot())
            {
                if (surface.Backbuffer is GpuBackbuffer gpuBb)
                    gpuBb.MsaaSampleCount = _msaaSampleCount;
            }
        }
    }
 
    private double _samplingTimeForCPS = 1.5;

    [Obsolete(
        "Legacy CPS/FPS sampling is deprecated. Use Engine.Profiler.Configure(...) for runtime telemetry.",
        DiagnosticId = "GOND0001")]
    public double SamplingTimeForCPS
    {
        get => _samplingTimeForCPS;
        set => _samplingTimeForCPS = value < 0 ? 0 : value;
    }

    [JsonIgnore]
    [Obsolete(
        "Legacy CPS/FPS sampling is deprecated. Use Engine.Profiler.Configure(...) for runtime telemetry.",
        DiagnosticId = "GOND0001")]
    public long SamplingTimeForCPSTicks => LegacyCpsSamplingTicks;

    internal double LegacyCpsSamplingTime
    {
        get => _samplingTimeForCPS;
        set => _samplingTimeForCPS = value < 0 ? 0 : value;
    }

    internal long LegacyCpsSamplingTicks =>
        (long)(_samplingTimeForCPS * HighResTimer.TicksPerSecond);

    public double TimeBetweenKeyboardEvents { get; set; } = 0.03;
 
    private double _gamepadConnectionUpdateFrequencyHz = 0.2;

    public double GamepadConnectionUpdateFrequencyHz
    {
        get => _gamepadConnectionUpdateFrequencyHz;
        set => _gamepadConnectionUpdateFrequencyHz =
            double.IsFinite(value) && value > 0d ? value : 0d;
    }
 
    private double _gamepadPollFrequencyHz = 60d;

    public double GamepadPollFrequencyHz
    {
        get => _gamepadPollFrequencyHz;
        set => _gamepadPollFrequencyHz =
            double.IsFinite(value) && value > 0d ? value : 0d;
    }

    public double TimeBetweenGamepadEvents { get; set; } = 0.03;

    public double TimeBetweenMouseEvents { get; set; } = 0.03;

    public double TimeBetweenTouchEvents { get; set; } = 0.03;

    public EngineLoggingMode LoggingMode { get; set; } = EngineLoggingMode.Asynchronous;
 
    private int _loggingQueueCapacity = 8192;

    public int LoggingQueueCapacity
    {
        get => _loggingQueueCapacity;
        set
        {
            if (value <= 0)
                throw new ArgumentOutOfRangeException(nameof(value), "Capacity must be > 0.");
            _loggingQueueCapacity = value;
        }
    }

    public bool FlushAsyncLogsOnShutdown { get; set; } = true;

    public List<StateFileMount>? StateFiles { get; set; }
 
    #region ConfigurationSections

    [JsonProperty]
    public Dictionary<string, Dictionary<string, string>> ConfigurationSections { get; set; } = new();

    public bool HasConfigurationSection(string section)
    {
        return ConfigurationSections.ContainsKey(section);
    }

    public Dictionary<string, string> CreateConfigurationSection(string section)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
 
        if (!ConfigurationSections.TryGetValue(section, out var values))
        {
            values = new Dictionary<string, string>();
            ConfigurationSections[section] = values;
        }
 
        return values;
    }

    public bool RemoveConfigurationSection(string section)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
 
        return ConfigurationSections.Remove(section);
    }

    public IReadOnlyDictionary<string, string>? GetConfigurationSection(string section)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
 
        return ConfigurationSections.TryGetValue(section, out var values)
            ? values
            : null;
    }

    public bool HasConfigurationValue(string section, string key)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
        ArgumentException.ThrowIfNullOrWhiteSpace(key);
 
        return ConfigurationSections.TryGetValue(section, out var values)
            && values.ContainsKey(key);
    }

    public string? GetConfigurationValue(string section, string key, string? defaultValue = null)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
        ArgumentException.ThrowIfNullOrWhiteSpace(key);
 
        return ConfigurationSections.TryGetValue(section, out var values)
            && values.TryGetValue(key, out var value)
                ? value
                : defaultValue;
    }

    public void SetConfigurationValue(string section, string key, string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
        ArgumentException.ThrowIfNullOrWhiteSpace(key);
        ArgumentNullException.ThrowIfNull(value);
 
        var values = CreateConfigurationSection(section);
        values[key] = value;
    }

    public bool RemoveConfigurationValue(string section, string key)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
        ArgumentException.ThrowIfNullOrWhiteSpace(key);
 
        return ConfigurationSections.TryGetValue(section, out var values)
            && values.Remove(key);
    }

    public bool ClearConfigurationSection(string section)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(section);
 
        if (!ConfigurationSections.TryGetValue(section, out var values))
            return false;
 
        values.Clear();
        return true;
    }

    public void ClearConfigurationSections()
    {
        ConfigurationSections.Clear();
    }

    public Dictionary<string, string>? this[string section]
    {
        get
        {
            ArgumentException.ThrowIfNullOrWhiteSpace(section);
 
            return ConfigurationSections.TryGetValue(section, out var values)
                ? values
                : null;
        }
        set
        {
            ArgumentException.ThrowIfNullOrWhiteSpace(section);
 
            if (value == null)
            {
                ConfigurationSections.Remove(section);
            }
            else
            {
                ConfigurationSections[section] = value;
            }
        }
    }

    public string? this[string section, string key]
    {
        get
        {
            ArgumentException.ThrowIfNullOrWhiteSpace(section);
            ArgumentException.ThrowIfNullOrWhiteSpace(key);
 
            return ConfigurationSections.TryGetValue(section, out var values)
                && values.TryGetValue(key, out var value)
                    ? value
                    : null;
        }
        set
        {
            ArgumentException.ThrowIfNullOrWhiteSpace(section);
            ArgumentException.ThrowIfNullOrWhiteSpace(key);
 
            if (value == null)
            {
                if (ConfigurationSections.TryGetValue(section, out var values))
                {
                    values.Remove(key);
                }
                return;
            }
 
            if (!ConfigurationSections.TryGetValue(section, out var sectionValues))
            {
                sectionValues = new Dictionary<string, string>();
                ConfigurationSections[section] = sectionValues;
            }
 
            sectionValues[key] = value;
        }
    }
 
    #endregion ConfigurationSections
}