13446237865

Committed 20 Feb 2025 10:55PM UTC coverage: 9.865% (-0.3%) from 10.129%

Build # 13446237865

Build Type

push

coveralls.net

Committed by

DemoBytom

Commit Message

Fixing FPS timer and adding crude UPS timer

FPS is now calculated per surface.
UPS is general.

Run Details

227 of 2301 relevant lines covered (9.87%)

16997.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Demo.Engine.Core/Services/FpsTimer.cs

// Copyright © Michał Dembski and contributors.
// Distributed under MIT license. See LICENSE file in the root for more information.

using System.Diagnostics;
using Demo.Engine.Core.Interfaces;
using Demo.Engine.Core.ValueObjects;
using Microsoft.Extensions.Logging;

namespace Demo.Engine.Core.Services;

internal sealed class FpsTimer(
    ILogger<FpsTimer> logger)
    : IFpsTimer
{
    internal class SurfaceFpsCounter(
        ILogger logger,
        RenderingSurfaceId surfaceId)
        : IFpsTimer.IFpsInternalTimer
    {
        private readonly ILogger _logger = logger;
        private readonly RenderingSurfaceId _surfaceId = surfaceId;

        private float _averageMs { get; set; } = 0.0f;
        private ulong _fpsCounter { get; set; } = 1;
        private long _start;
        private long _seconds = Stopwatch.GetTimestamp();

        public void Start()
            => _start = Stopwatch.GetTimestamp();

        public void Stop()
        {
            var dt = Stopwatch.GetElapsedTime(_start);

            _averageMs += (dt.Milliseconds - _averageMs) / _fpsCounter;
            ++_fpsCounter;

            if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
            {
                _logger.LogTrace(
                    "{surfaceId}: Avg. frame (ms): {millisecond}, fps: {fps}",
                    _surfaceId,
                    _averageMs,
                    _fpsCounter);

                _averageMs = 0.0f;
                _fpsCounter = 1;
                _seconds = Stopwatch.GetTimestamp();
            }
        }
    }

    private readonly ILogger<FpsTimer> _logger = logger;
    private readonly Dictionary<RenderingSurfaceId, SurfaceFpsCounter> _surfaceFpsCounters = [];

    public void StartRenderingTimer(
        RenderingSurfaceId surfaceId)
    {
        if (!_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter = new SurfaceFpsCounter(
                _logger,
                surfaceId);

            _surfaceFpsCounters.Add(
                surfaceId,
                fpsCounter);
        }

        fpsCounter.Start();
    }

    public FpsTimerScope StartRenderingTimerScope(
        RenderingSurfaceId surfaceId)
    {
        if (!_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter = new SurfaceFpsCounter(
                _logger,
                surfaceId);

            _surfaceFpsCounters.Add(
                surfaceId,
                fpsCounter);
        }

        return new FpsTimerScope(
            fpsCounter);
    }

    public void StopRenderingTimer(
        RenderingSurfaceId surfaceId)
    {
        if (_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter.Stop();
        }
    }

    private float _averageMs { get; set; } = 0.0f;
    private ulong _upsCounter { get; set; } = 1;
    private long _start;
    private long _seconds = Stopwatch.GetTimestamp();

    public void StartUpdateTimer()
        => _start = Stopwatch.GetTimestamp();

    public void StopUpdateTimer()
    {
        var dt = Stopwatch.GetElapsedTime(_start);

        _averageMs += (dt.Milliseconds - _averageMs) / _upsCounter;
        ++_upsCounter;

        if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
        {
            _logger.LogTrace(
                "Avg. update (ms): {millisecond}, ups: {ups}",
                _averageMs,
                _upsCounter);

            _averageMs = 0.0f;
            _upsCounter = 1;
            _seconds = Stopwatch.GetTimestamp();
        }
    }
}

1	// Copyright © Michał Dembski and contributors.
2	// Distributed under MIT license. See LICENSE file in the root for more information.
3
4	using System.Diagnostics;
5	using Demo.Engine.Core.Interfaces;
6	using Demo.Engine.Core.ValueObjects;
7	using Microsoft.Extensions.Logging;
8
9	namespace Demo.Engine.Core.Services;
10
11	internal sealed class FpsTimer(	×
12	ILogger<FpsTimer> logger)	×
13	: IFpsTimer
14	{
15	internal class SurfaceFpsCounter(	×
16	ILogger logger,	×
17	RenderingSurfaceId surfaceId)	×
18	: IFpsTimer.IFpsInternalTimer
19	{
20	private readonly ILogger _logger = logger;	×
21	private readonly RenderingSurfaceId _surfaceId = surfaceId;	×
22
23	private float _averageMs { get; set; } = 0.0f;	×
24	private ulong _fpsCounter { get; set; } = 1;	×
25	private long _start;
26	private long _seconds = Stopwatch.GetTimestamp();	×
27
28	public void Start()
29	=> _start = Stopwatch.GetTimestamp();	×
30
31	public void Stop()
32	{
33	var dt = Stopwatch.GetElapsedTime(_start);	×
34
35	_averageMs += (dt.Milliseconds - _averageMs) / _fpsCounter;	×
36	++_fpsCounter;	×
37
38	if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)	×
39	{
40	_logger.LogTrace(	×
41	"{surfaceId}: Avg. frame (ms): {millisecond}, fps: {fps}",	×
42	_surfaceId,	×
43	_averageMs,	×
44	_fpsCounter);	×
45
46	_averageMs = 0.0f;	×
47	_fpsCounter = 1;	×
48	_seconds = Stopwatch.GetTimestamp();	×
49	}
50	}	×
51	}
52
53	private readonly ILogger<FpsTimer> _logger = logger;	×
54	private readonly Dictionary<RenderingSurfaceId, SurfaceFpsCounter> _surfaceFpsCounters = [];	×
55
56	public void StartRenderingTimer(
57	RenderingSurfaceId surfaceId)
58	{
59	if (!_surfaceFpsCounters.TryGetValue(	×
60	surfaceId,	×
61	out var fpsCounter))	×
62	{
63	fpsCounter = new SurfaceFpsCounter(	×
64	_logger,	×
65	surfaceId);	×
66
67	_surfaceFpsCounters.Add(	×
68	surfaceId,	×
69	fpsCounter);	×
70	}
71
72	fpsCounter.Start();	×
73	}	×
74
75	public FpsTimerScope StartRenderingTimerScope(
76	RenderingSurfaceId surfaceId)
77	{
78	if (!_surfaceFpsCounters.TryGetValue(	×
79	surfaceId,	×
80	out var fpsCounter))	×
81	{
82	fpsCounter = new SurfaceFpsCounter(	×
83	_logger,	×
84	surfaceId);	×
85
86	_surfaceFpsCounters.Add(	×
87	surfaceId,	×
88	fpsCounter);	×
89	}
90
91	return new FpsTimerScope(	×
92	fpsCounter);	×
93	}
94
95	public void StopRenderingTimer(
96	RenderingSurfaceId surfaceId)
97	{
98	if (_surfaceFpsCounters.TryGetValue(	×
99	surfaceId,	×
100	out var fpsCounter))	×
101	{
102	fpsCounter.Stop();	×
103	}
104	}	×
105
106	private float _averageMs { get; set; } = 0.0f;	×
107	private ulong _upsCounter { get; set; } = 1;	×
108	private long _start;
109	private long _seconds = Stopwatch.GetTimestamp();	×
110
111	public void StartUpdateTimer()
112	=> _start = Stopwatch.GetTimestamp();	×
113
114	public void StopUpdateTimer()
115	{
116	var dt = Stopwatch.GetElapsedTime(_start);	×
117
118	_averageMs += (dt.Milliseconds - _averageMs) / _upsCounter;	×
119	++_upsCounter;	×
120
121	if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)	×
122	{
123	_logger.LogTrace(	×
124	"Avg. update (ms): {millisecond}, ups: {ups}",	×
125	_averageMs,	×
126	_upsCounter);	×
127
128	_averageMs = 0.0f;	×
129	_upsCounter = 1;	×
130	_seconds = Stopwatch.GetTimestamp();	×
131	}
132	}	×
133	}

DemoBytom / DemoEngine / 13446237865

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous