OpenTTD Source: src/framerate_gui.cpp Source File

OpenTTD Source 12.0-beta1

framerate_gui.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10 #include "framerate_type.h"
11 #include <chrono>
12 #include "gfx_func.h"
13 #include "window_gui.h"
14 #include "window_func.h"
15 #include "table/sprites.h"
16 #include "string_func.h"
17 #include "strings_func.h"
18 #include "console_func.h"
19 #include "console_type.h"
20 #include "guitimer_func.h"
21 #include "company_base.h"
22 #include "ai/ai_info.hpp"
23 #include "ai/ai_instance.hpp"
24 #include "game/game.hpp"
25 #include "game/game_instance.hpp"
26
27 #include "widgets/framerate_widget.h"
28 #include "safeguards.h"
29
30
34 namespace {
35
37 const int NUM_FRAMERATE_POINTS = 512;
39 const TimingMeasurement TIMESTAMP_PRECISION = 1000000;
40
41 struct PerformanceData {
43 static const TimingMeasurement INVALID_DURATION = UINT64_MAX;
44
46 TimingMeasurement durations[NUM_FRAMERATE_POINTS];
48 TimingMeasurement timestamps[NUM_FRAMERATE_POINTS];
50 double expected_rate;
52 int next_index;
54 int prev_index;
56 int num_valid;
57
59 TimingMeasurement acc_duration;
61 TimingMeasurement acc_timestamp;
62
69 explicit PerformanceData(double expected_rate) : expected_rate(expected_rate), next_index(0), prev_index(0), num_valid(0) { }
70
72 void Add(TimingMeasurement start_time, TimingMeasurement end_time)
73 {
74 this->durations[this->next_index] = end_time - start_time;
75 this->timestamps[this->next_index] = start_time;
76 this->prev_index = this->next_index;
77 this->next_index += 1;
78 if (this->next_index >= NUM_FRAMERATE_POINTS) this->next_index = 0;
79 this->num_valid = std::min(NUM_FRAMERATE_POINTS, this->num_valid + 1);
80 }
81
83 void BeginAccumulate(TimingMeasurement start_time)
84 {
85 this->timestamps[this->next_index] = this->acc_timestamp;
86 this->durations[this->next_index] = this->acc_duration;
87 this->prev_index = this->next_index;
88 this->next_index += 1;
89 if (this->next_index >= NUM_FRAMERATE_POINTS) this->next_index = 0;
90 this->num_valid = std::min(NUM_FRAMERATE_POINTS, this->num_valid + 1);
91
92 this->acc_duration = 0;
93 this->acc_timestamp = start_time;
94 }
95
97 void AddAccumulate(TimingMeasurement duration)
98 {
99 this->acc_duration += duration;
100 }
101
103 void AddPause(TimingMeasurement start_time)
104 {
105 if (this->durations[this->prev_index] != INVALID_DURATION) {
106 this->timestamps[this->next_index] = start_time;
107 this->durations[this->next_index] = INVALID_DURATION;
108 this->prev_index = this->next_index;
109 this->next_index += 1;
110 if (this->next_index >= NUM_FRAMERATE_POINTS) this->next_index = 0;
111 this->num_valid += 1;
112 }
113 }
114
116 double GetAverageDurationMilliseconds(int count)
117 {
118 count = std::min(count, this->num_valid);
119
120 int first_point = this->prev_index - count;
121 if (first_point < 0) first_point += NUM_FRAMERATE_POINTS;
122
123 /* Sum durations, skipping invalid points */
124 double sumtime = 0;
125 for (int i = first_point; i < first_point + count; i++) {
126 auto d = this->durations[i % NUM_FRAMERATE_POINTS];
127 if (d != INVALID_DURATION) {
128 sumtime += d;
129 } else {
130 /* Don't count the invalid durations */
131 count--;
132 }
133 }
134
135 if (count == 0) return 0; // avoid div by zero
136 return sumtime * 1000 / count / TIMESTAMP_PRECISION;
137 }
138
140 double GetRate()
141 {
142 /* Start at last recorded point, end at latest when reaching the earliest recorded point */
143 int point = this->prev_index;
144 int last_point = this->next_index - this->num_valid;
145 if (last_point < 0) last_point += NUM_FRAMERATE_POINTS;
146
147 /* Number of data points collected */
148 int count = 0;
149 /* Time of previous data point */
150 TimingMeasurement last = this->timestamps[point];
151 /* Total duration covered by collected points */
152 TimingMeasurement total = 0;
153
154 /* We have nothing to compare the first point against */
155 point--;
156 if (point < 0) point = NUM_FRAMERATE_POINTS - 1;
157
158 while (point != last_point) {
159 /* Only record valid data points, but pretend the gaps in measurements aren't there */
160 if (this->durations[point] != INVALID_DURATION) {
161 total += last - this->timestamps[point];
162 count++;
163 }
164 last = this->timestamps[point];
165 if (total >= TIMESTAMP_PRECISION) break; // end after 1 second has been collected
166 point--;
167 if (point < 0) point = NUM_FRAMERATE_POINTS - 1;
168 }
169
170 if (total == 0 || count == 0) return 0;
171 return (double)count * TIMESTAMP_PRECISION / total;
172 }
173 };
174
176 static const double GL_RATE = 1000.0 / MILLISECONDS_PER_TICK;
177
183 PerformanceData _pf_data[PFE_MAX] = {
184 PerformanceData(GL_RATE), // PFE_GAMELOOP
185 PerformanceData(1), // PFE_ACC_GL_ECONOMY
186 PerformanceData(1), // PFE_ACC_GL_TRAINS
187 PerformanceData(1), // PFE_ACC_GL_ROADVEHS
188 PerformanceData(1), // PFE_ACC_GL_SHIPS
189 PerformanceData(1), // PFE_ACC_GL_AIRCRAFT
190 PerformanceData(1), // PFE_GL_LANDSCAPE
191 PerformanceData(1), // PFE_GL_LINKGRAPH
192 PerformanceData(1000.0 / 30), // PFE_DRAWING
193 PerformanceData(1), // PFE_ACC_DRAWWORLD
194 PerformanceData(60.0), // PFE_VIDEO
195 PerformanceData(1000.0 * 8192 / 44100), // PFE_SOUND
196 PerformanceData(1), // PFE_ALLSCRIPTS
197 PerformanceData(1), // PFE_GAMESCRIPT
198 PerformanceData(1), // PFE_AI0 ...
199 PerformanceData(1),
200 PerformanceData(1),
201 PerformanceData(1),
202 PerformanceData(1),
203 PerformanceData(1),
204 PerformanceData(1),
205 PerformanceData(1),
206 PerformanceData(1),
207 PerformanceData(1),
208 PerformanceData(1),
209 PerformanceData(1),
210 PerformanceData(1),
211 PerformanceData(1),
212 PerformanceData(1), // PFE_AI14
213 };
214
215 }
216
217
223 static TimingMeasurement GetPerformanceTimer()
224 {
225 using namespace std::chrono;
226 return (TimingMeasurement)time_point_cast<microseconds>(high_resolution_clock::now()).time_since_epoch().count();
227 }
228
229
234 PerformanceMeasurer::PerformanceMeasurer(PerformanceElement elem)
235 {
236 assert(elem < PFE_MAX);
237
238 this->elem = elem;
239 this->start_time = GetPerformanceTimer();
240 }
241
243 PerformanceMeasurer::~PerformanceMeasurer()
244 {
245 if (this->elem == PFE_ALLSCRIPTS) {
246 /* Hack to not record scripts total when no scripts are active */
247 bool any_active = _pf_data[PFE_GAMESCRIPT].num_valid > 0;
248 for (uint e = PFE_AI0; e < PFE_MAX; e++) any_active |= _pf_data[e].num_valid > 0;
249 if (!any_active) {
250 PerformanceMeasurer::SetInactive(PFE_ALLSCRIPTS);
251 return;
252 }
253 }
254 _pf_data[this->elem].Add(this->start_time, GetPerformanceTimer());
255 }
256
258 void PerformanceMeasurer::SetExpectedRate(double rate)
259 {
260 _pf_data[this->elem].expected_rate = rate;
261 }
262
264 /* static */ void PerformanceMeasurer::SetInactive(PerformanceElement elem)
265 {
266 _pf_data[elem].num_valid = 0;
267 _pf_data[elem].next_index = 0;
268 _pf_data[elem].prev_index = 0;
269 }
270
275 /* static */ void PerformanceMeasurer::Paused(PerformanceElement elem)
276 {
277 PerformanceMeasurer::SetInactive(elem);
278 _pf_data[elem].AddPause(GetPerformanceTimer());
279 }
280
281
286 PerformanceAccumulator::PerformanceAccumulator(PerformanceElement elem)
287 {
288 assert(elem < PFE_MAX);
289
290 this->elem = elem;
291 this->start_time = GetPerformanceTimer();
292 }
293
295 PerformanceAccumulator::~PerformanceAccumulator()
296 {
297 _pf_data[this->elem].AddAccumulate(GetPerformanceTimer() - this->start_time);
298 }
299
305 void PerformanceAccumulator::Reset(PerformanceElement elem)
306 {
307 _pf_data[elem].BeginAccumulate(GetPerformanceTimer());
308 }
309
310
311 void ShowFrametimeGraphWindow(PerformanceElement elem);
312
313
314 static const PerformanceElement DISPLAY_ORDER_PFE[PFE_MAX] = {
315 PFE_GAMELOOP,
316 PFE_GL_ECONOMY,
317 PFE_GL_TRAINS,
318 PFE_GL_ROADVEHS,
319 PFE_GL_SHIPS,
320 PFE_GL_AIRCRAFT,
321 PFE_GL_LANDSCAPE,
322 PFE_ALLSCRIPTS,
323 PFE_GAMESCRIPT,
324 PFE_AI0,
325 PFE_AI1,
326 PFE_AI2,
327 PFE_AI3,
328 PFE_AI4,
329 PFE_AI5,
330 PFE_AI6,
331 PFE_AI7,
332 PFE_AI8,
333 PFE_AI9,
334 PFE_AI10,
335 PFE_AI11,
336 PFE_AI12,
337 PFE_AI13,
338 PFE_AI14,
339 PFE_GL_LINKGRAPH,
340 PFE_DRAWING,
341 PFE_DRAWWORLD,
342 PFE_VIDEO,
343 PFE_SOUND,
344 };
345
346 static const char * GetAIName(int ai_index)
347 {
348 if (!Company::IsValidAiID(ai_index)) return "";
349 return Company::Get(ai_index)->ai_info->GetName();
350 }
351
353 static const NWidgetPart _framerate_window_widgets[] = {
354 NWidget(NWID_HORIZONTAL),
355 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
356 NWidget(WWT_CAPTION, COLOUR_GREY, WID_FRW_CAPTION), SetDataTip(STR_FRAMERATE_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
357 NWidget(WWT_SHADEBOX, COLOUR_GREY),
358 NWidget(WWT_STICKYBOX, COLOUR_GREY),
359 EndContainer(),
360 NWidget(WWT_PANEL, COLOUR_GREY),
361 NWidget(NWID_VERTICAL), SetPadding(6), SetPIP(0, 3, 0),
362 NWidget(WWT_TEXT, COLOUR_GREY, WID_FRW_RATE_GAMELOOP), SetDataTip(STR_FRAMERATE_RATE_GAMELOOP, STR_FRAMERATE_RATE_GAMELOOP_TOOLTIP),
363 NWidget(WWT_TEXT, COLOUR_GREY, WID_FRW_RATE_DRAWING), SetDataTip(STR_FRAMERATE_RATE_BLITTER, STR_FRAMERATE_RATE_BLITTER_TOOLTIP),
364 NWidget(WWT_TEXT, COLOUR_GREY, WID_FRW_RATE_FACTOR), SetDataTip(STR_FRAMERATE_SPEED_FACTOR, STR_FRAMERATE_SPEED_FACTOR_TOOLTIP),
365 EndContainer(),
366 EndContainer(),
367 NWidget(NWID_HORIZONTAL),
368 NWidget(WWT_PANEL, COLOUR_GREY),
369 NWidget(NWID_VERTICAL), SetPadding(6), SetPIP(0, 3, 0),
370 NWidget(NWID_HORIZONTAL), SetPIP(0, 6, 0),
371 NWidget(WWT_EMPTY, COLOUR_GREY, WID_FRW_TIMES_NAMES), SetScrollbar(WID_FRW_SCROLLBAR),
372 NWidget(WWT_EMPTY, COLOUR_GREY, WID_FRW_TIMES_CURRENT), SetScrollbar(WID_FRW_SCROLLBAR),
373 NWidget(WWT_EMPTY, COLOUR_GREY, WID_FRW_TIMES_AVERAGE), SetScrollbar(WID_FRW_SCROLLBAR),
374 NWidget(NWID_SELECTION, INVALID_COLOUR, WID_FRW_SEL_MEMORY),
375 NWidget(WWT_EMPTY, COLOUR_GREY, WID_FRW_ALLOCSIZE), SetScrollbar(WID_FRW_SCROLLBAR),
376 EndContainer(),
377 EndContainer(),
378 NWidget(WWT_TEXT, COLOUR_GREY, WID_FRW_INFO_DATA_POINTS), SetDataTip(STR_FRAMERATE_DATA_POINTS, 0x0),
379 EndContainer(),
380 EndContainer(),
381 NWidget(NWID_VERTICAL),
382 NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_FRW_SCROLLBAR),
383 NWidget(WWT_RESIZEBOX, COLOUR_GREY),
384 EndContainer(),
385 EndContainer(),
386 };
387
388 struct FramerateWindow : Window {
389 bool small;
390 bool showing_memory;
391 GUITimer next_update;
392 int num_active;
393 int num_displayed;
394
395 struct CachedDecimal {
396 StringID strid;
397 uint32 value;
398
399 inline void SetRate(double value, double target)
400 {
401 const double threshold_good = target * 0.95;
402 const double threshold_bad = target * 2 / 3;
403 this->value = (uint32)(value * 100);
404 this->strid = (value > threshold_good) ? STR_FRAMERATE_FPS_GOOD : (value < threshold_bad) ? STR_FRAMERATE_FPS_BAD : STR_FRAMERATE_FPS_WARN;
405 }
406
407 inline void SetTime(double value, double target)
408 {
409 const double threshold_good = target / 3;
410 const double threshold_bad = target;
411 this->value = (uint32)(value * 100);
412 this->strid = (value < threshold_good) ? STR_FRAMERATE_MS_GOOD : (value > threshold_bad) ? STR_FRAMERATE_MS_BAD : STR_FRAMERATE_MS_WARN;
413 }
414
415 inline void InsertDParams(uint n) const
416 {
417 SetDParam(n, this->value);
418 SetDParam(n + 1, 2);
419 }
420 };
421
422 CachedDecimal rate_gameloop;
423 CachedDecimal rate_drawing;
424 CachedDecimal speed_gameloop;
425 CachedDecimal times_shortterm[PFE_MAX];
426 CachedDecimal times_longterm[PFE_MAX];
427
428 static constexpr int VSPACING = 3;
429 static constexpr int MIN_ELEMENTS = 5;
430
431 FramerateWindow(WindowDesc *desc, WindowNumber number) : Window(desc)
432 {
433 this->InitNested(number);
434 this->small = this->IsShaded();
435 this->showing_memory = true;
436 this->UpdateData();
437 this->num_displayed = this->num_active;
438 this->next_update.SetInterval(100);
439
440 /* Window is always initialised to MIN_ELEMENTS height, resize to contain num_displayed */
441 ResizeWindow(this, 0, (std::max(MIN_ELEMENTS, this->num_displayed) - MIN_ELEMENTS) * FONT_HEIGHT_NORMAL);
442 }
443
444 void OnRealtimeTick(uint delta_ms) override
445 {
446 bool elapsed = this->next_update.Elapsed(delta_ms);
447
448 /* Check if the shaded state has changed, switch caption text if it has */
449 if (this->small != this->IsShaded()) {
450 this->small = this->IsShaded();
451 this->GetWidget<NWidgetLeaf>(WID_FRW_CAPTION)->SetDataTip(this->small ? STR_FRAMERATE_CAPTION_SMALL : STR_FRAMERATE_CAPTION, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS);
452 elapsed = true;
453 }
454
455 if (elapsed) {
456 this->UpdateData();
457 this->SetDirty();
458 this->next_update.SetInterval(100);
459 }
460 }
461
462 void UpdateData()
463 {
464 double gl_rate = _pf_data[PFE_GAMELOOP].GetRate();
465 bool have_script = false;
466 this->rate_gameloop.SetRate(gl_rate, _pf_data[PFE_GAMELOOP].expected_rate);
467 this->speed_gameloop.SetRate(gl_rate / _pf_data[PFE_GAMELOOP].expected_rate, 1.0);
468 if (this->small) return; // in small mode, this is everything needed
469
470 this->rate_drawing.SetRate(_pf_data[PFE_DRAWING].GetRate(), _settings_client.gui.refresh_rate);
471
472 int new_active = 0;
473 for (PerformanceElement e = PFE_FIRST; e < PFE_MAX; e++) {
474 this->times_shortterm[e].SetTime(_pf_data[e].GetAverageDurationMilliseconds(8), MILLISECONDS_PER_TICK);
475 this->times_longterm[e].SetTime(_pf_data[e].GetAverageDurationMilliseconds(NUM_FRAMERATE_POINTS), MILLISECONDS_PER_TICK);
476 if (_pf_data[e].num_valid > 0) {
477 new_active++;
478 if (e == PFE_GAMESCRIPT || e >= PFE_AI0) have_script = true;
479 }
480 }
481
482 if (this->showing_memory != have_script) {
483 NWidgetStacked *plane = this->GetWidget<NWidgetStacked>(WID_FRW_SEL_MEMORY);
484 plane->SetDisplayedPlane(have_script ? 0 : SZSP_VERTICAL);
485 this->showing_memory = have_script;
486 }
487
488 if (new_active != this->num_active) {
489 this->num_active = new_active;
490 Scrollbar *sb = this->GetScrollbar(WID_FRW_SCROLLBAR);
491 sb->SetCount(this->num_active);
492 sb->SetCapacity(std::min(this->num_displayed, this->num_active));
493 this->ReInit();
494 }
495 }
496
497 void SetStringParameters(int widget) const override
498 {
499 switch (widget) {
500 case WID_FRW_CAPTION:
501 /* When the window is shaded, the caption shows game loop rate and speed factor */
502 if (!this->small) break;
503 SetDParam(0, this->rate_gameloop.strid);
504 this->rate_gameloop.InsertDParams(1);
505 this->speed_gameloop.InsertDParams(3);
506 break;
507
508 case WID_FRW_RATE_GAMELOOP:
509 SetDParam(0, this->rate_gameloop.strid);
510 this->rate_gameloop.InsertDParams(1);
511 break;
512 case WID_FRW_RATE_DRAWING:
513 SetDParam(0, this->rate_drawing.strid);
514 this->rate_drawing.InsertDParams(1);
515 break;
516 case WID_FRW_RATE_FACTOR:
517 this->speed_gameloop.InsertDParams(0);
518 break;
519 case WID_FRW_INFO_DATA_POINTS:
520 SetDParam(0, NUM_FRAMERATE_POINTS);
521 break;
522 }
523 }
524
525 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
526 {
527 switch (widget) {
528 case WID_FRW_RATE_GAMELOOP:
529 SetDParam(0, STR_FRAMERATE_FPS_GOOD);
530 SetDParam(1, 999999);
531 SetDParam(2, 2);
532 *size = GetStringBoundingBox(STR_FRAMERATE_RATE_GAMELOOP);
533 break;
534 case WID_FRW_RATE_DRAWING:
535 SetDParam(0, STR_FRAMERATE_FPS_GOOD);
536 SetDParam(1, 999999);
537 SetDParam(2, 2);
538 *size = GetStringBoundingBox(STR_FRAMERATE_RATE_BLITTER);
539 break;
540 case WID_FRW_RATE_FACTOR:
541 SetDParam(0, 999999);
542 SetDParam(1, 2);
543 *size = GetStringBoundingBox(STR_FRAMERATE_SPEED_FACTOR);
544 break;
545
546 case WID_FRW_TIMES_NAMES: {
547 size->width = 0;
548 size->height = FONT_HEIGHT_NORMAL + VSPACING + MIN_ELEMENTS * FONT_HEIGHT_NORMAL;
549 resize->width = 0;
550 resize->height = FONT_HEIGHT_NORMAL;
551 for (PerformanceElement e : DISPLAY_ORDER_PFE) {
552 if (_pf_data[e].num_valid == 0) continue;
553 Dimension line_size;
554 if (e < PFE_AI0) {
555 line_size = GetStringBoundingBox(STR_FRAMERATE_GAMELOOP + e);
556 } else {
557 SetDParam(0, e - PFE_AI0 + 1);
558 SetDParamStr(1, GetAIName(e - PFE_AI0));
559 line_size = GetStringBoundingBox(STR_FRAMERATE_AI);
560 }
561 size->width = std::max(size->width, line_size.width);
562 }
563 break;
564 }
565
566 case WID_FRW_TIMES_CURRENT:
567 case WID_FRW_TIMES_AVERAGE:
568 case WID_FRW_ALLOCSIZE: {
569 *size = GetStringBoundingBox(STR_FRAMERATE_CURRENT + (widget - WID_FRW_TIMES_CURRENT));
570 SetDParam(0, 999999);
571 SetDParam(1, 2);
572 Dimension item_size = GetStringBoundingBox(STR_FRAMERATE_MS_GOOD);
573 size->width = std::max(size->width, item_size.width);
574 size->height += FONT_HEIGHT_NORMAL * MIN_ELEMENTS + VSPACING;
575 resize->width = 0;
576 resize->height = FONT_HEIGHT_NORMAL;
577 break;
578 }
579 }
580 }
581
583 void DrawElementTimesColumn(const Rect &r, StringID heading_str, const CachedDecimal *values) const
584 {
585 const Scrollbar *sb = this->GetScrollbar(WID_FRW_SCROLLBAR);
586 uint16 skip = sb->GetPosition();
587 int drawable = this->num_displayed;
588 int y = r.top;
589 DrawString(r.left, r.right, y, heading_str, TC_FROMSTRING, SA_CENTER, true);
590 y += FONT_HEIGHT_NORMAL + VSPACING;
591 for (PerformanceElement e : DISPLAY_ORDER_PFE) {
592 if (_pf_data[e].num_valid == 0) continue;
593 if (skip > 0) {
594 skip--;
595 } else {
596 values[e].InsertDParams(0);
597 DrawString(r.left, r.right, y, values[e].strid, TC_FROMSTRING, SA_RIGHT);
598 y += FONT_HEIGHT_NORMAL;
599 drawable--;
600 if (drawable == 0) break;
601 }
602 }
603 }
604
605 void DrawElementAllocationsColumn(const Rect &r) const
606 {
607 const Scrollbar *sb = this->GetScrollbar(WID_FRW_SCROLLBAR);
608 uint16 skip = sb->GetPosition();
609 int drawable = this->num_displayed;
610 int y = r.top;
611 DrawString(r.left, r.right, y, STR_FRAMERATE_MEMORYUSE, TC_FROMSTRING, SA_CENTER, true);
612 y += FONT_HEIGHT_NORMAL + VSPACING;
613 for (PerformanceElement e : DISPLAY_ORDER_PFE) {
614 if (_pf_data[e].num_valid == 0) continue;
615 if (skip > 0) {
616 skip--;
617 } else if (e == PFE_GAMESCRIPT || e >= PFE_AI0) {
618 if (e == PFE_GAMESCRIPT) {
619 SetDParam(0, Game::GetInstance()->GetAllocatedMemory());
620 } else {
621 SetDParam(0, Company::Get(e - PFE_AI0)->ai_instance->GetAllocatedMemory());
622 }
623 DrawString(r.left, r.right, y, STR_FRAMERATE_BYTES_GOOD, TC_FROMSTRING, SA_RIGHT);
624 y += FONT_HEIGHT_NORMAL;
625 drawable--;
626 if (drawable == 0) break;
627 } else {
628 /* skip non-script */
629 y += FONT_HEIGHT_NORMAL;
630 drawable--;
631 if (drawable == 0) break;
632 }
633 }
634 }
635
636 void DrawWidget(const Rect &r, int widget) const override
637 {
638 switch (widget) {
639 case WID_FRW_TIMES_NAMES: {
640 /* Render a column of titles for performance element names */
641 const Scrollbar *sb = this->GetScrollbar(WID_FRW_SCROLLBAR);
642 uint16 skip = sb->GetPosition();
643 int drawable = this->num_displayed;
644 int y = r.top + FONT_HEIGHT_NORMAL + VSPACING; // first line contains headings in the value columns
645 for (PerformanceElement e : DISPLAY_ORDER_PFE) {
646 if (_pf_data[e].num_valid == 0) continue;
647 if (skip > 0) {
648 skip--;
649 } else {
650 if (e < PFE_AI0) {
651 DrawString(r.left, r.right, y, STR_FRAMERATE_GAMELOOP + e, TC_FROMSTRING, SA_LEFT);
652 } else {
653 SetDParam(0, e - PFE_AI0 + 1);
654 SetDParamStr(1, GetAIName(e - PFE_AI0));
655 DrawString(r.left, r.right, y, STR_FRAMERATE_AI, TC_FROMSTRING, SA_LEFT);
656 }
657 y += FONT_HEIGHT_NORMAL;
658 drawable--;
659 if (drawable == 0) break;
660 }
661 }
662 break;
663 }
664 case WID_FRW_TIMES_CURRENT:
665 /* Render short-term average values */
666 DrawElementTimesColumn(r, STR_FRAMERATE_CURRENT, this->times_shortterm);
667 break;
668 case WID_FRW_TIMES_AVERAGE:
669 /* Render averages of all recorded values */
670 DrawElementTimesColumn(r, STR_FRAMERATE_AVERAGE, this->times_longterm);
671 break;
672 case WID_FRW_ALLOCSIZE:
673 DrawElementAllocationsColumn(r);
674 break;
675 }
676 }
677
678 void OnClick(Point pt, int widget, int click_count) override
679 {
680 switch (widget) {
681 case WID_FRW_TIMES_NAMES:
682 case WID_FRW_TIMES_CURRENT:
683 case WID_FRW_TIMES_AVERAGE: {
684 /* Open time graph windows when clicking detail measurement lines */
685 const Scrollbar *sb = this->GetScrollbar(WID_FRW_SCROLLBAR);
686 int line = sb->GetScrolledRowFromWidget(pt.y, this, widget, VSPACING + FONT_HEIGHT_NORMAL);
687 if (line != INT_MAX) {
688 line++;
689 /* Find the visible line that was clicked */
690 for (PerformanceElement e : DISPLAY_ORDER_PFE) {
691 if (_pf_data[e].num_valid > 0) line--;
692 if (line == 0) {
693 ShowFrametimeGraphWindow(e);
694 break;
695 }
696 }
697 }
698 break;
699 }
700 }
701 }
702
703 void OnResize() override
704 {
705 auto *wid = this->GetWidget<NWidgetResizeBase>(WID_FRW_TIMES_NAMES);
706 this->num_displayed = (wid->current_y - wid->min_y - VSPACING) / FONT_HEIGHT_NORMAL - 1; // subtract 1 for headings
707 this->GetScrollbar(WID_FRW_SCROLLBAR)->SetCapacity(this->num_displayed);
708 }
709 };
710
711 static WindowDesc _framerate_display_desc(
712 WDP_AUTO, "framerate_display", 0, 0,
713 WC_FRAMERATE_DISPLAY, WC_NONE,
714 0,
715 _framerate_window_widgets, lengthof(_framerate_window_widgets)
716 );
717
718
720 static const NWidgetPart _frametime_graph_window_widgets[] = {
721 NWidget(NWID_HORIZONTAL),
722 NWidget(WWT_CLOSEBOX, COLOUR_GREY),
723 NWidget(WWT_CAPTION, COLOUR_GREY, WID_FGW_CAPTION), SetDataTip(STR_WHITE_STRING, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
724 NWidget(WWT_STICKYBOX, COLOUR_GREY),
725 EndContainer(),
726 NWidget(WWT_PANEL, COLOUR_GREY),
727 NWidget(NWID_VERTICAL), SetPadding(6),
728 NWidget(WWT_EMPTY, COLOUR_GREY, WID_FGW_GRAPH),
729 EndContainer(),
730 EndContainer(),
731 };
732
733 struct FrametimeGraphWindow : Window {
734 int vertical_scale;
735 int horizontal_scale;
736 GUITimer next_scale_update;
737
738 PerformanceElement element;
739 Dimension graph_size;
740
741 FrametimeGraphWindow(WindowDesc *desc, WindowNumber number) : Window(desc)
742 {
743 this->element = (PerformanceElement)number;
744 this->horizontal_scale = 4;
745 this->vertical_scale = TIMESTAMP_PRECISION / 10;
746 this->next_scale_update.SetInterval(1);
747
748 this->InitNested(number);
749 }
750
751 void SetStringParameters(int widget) const override
752 {
753 switch (widget) {
754 case WID_FGW_CAPTION:
755 if (this->element < PFE_AI0) {
756 SetDParam(0, STR_FRAMETIME_CAPTION_GAMELOOP + this->element);
757 } else {
758 SetDParam(0, STR_FRAMETIME_CAPTION_AI);
759 SetDParam(1, this->element - PFE_AI0 + 1);
760 SetDParamStr(2, GetAIName(this->element - PFE_AI0));
761 }
762 break;
763 }
764 }
765
766 void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
767 {
768 if (widget == WID_FGW_GRAPH) {
769 SetDParam(0, 100);
770 Dimension size_ms_label = GetStringBoundingBox(STR_FRAMERATE_GRAPH_MILLISECONDS);
771 SetDParam(0, 100);
772 Dimension size_s_label = GetStringBoundingBox(STR_FRAMERATE_GRAPH_SECONDS);
773
774 /* Size graph in height to fit at least 10 vertical labels with space between, or at least 100 pixels */
775 graph_size.height = std::max(100u, 10 * (size_ms_label.height + 1));
776 /* Always 2:1 graph area */
777 graph_size.width = 2 * graph_size.height;
778 *size = graph_size;
779
780 size->width += size_ms_label.width + 2;
781 size->height += size_s_label.height + 2;
782 }
783 }
784
785 void SelectHorizontalScale(TimingMeasurement range)
786 {
787 /* Determine horizontal scale based on period covered by 60 points
788 * (slightly less than 2 seconds at full game speed) */
789 struct ScaleDef { TimingMeasurement range; int scale; };
790 static const ScaleDef hscales[] = {
791 { 120, 60 },
792 { 10, 20 },
793 { 5, 10 },
794 { 3, 4 },
795 { 1, 2 },
796 };
797 for (const ScaleDef *sc = hscales; sc < hscales + lengthof(hscales); sc++) {
798 if (range < sc->range) this->horizontal_scale = sc->scale;
799 }
800 }
801
802 void SelectVerticalScale(TimingMeasurement range)
803 {
804 /* Determine vertical scale based on peak value (within the horizontal scale + a bit) */
805 static const TimingMeasurement vscales[] = {
806 TIMESTAMP_PRECISION * 100,
807 TIMESTAMP_PRECISION * 10,
808 TIMESTAMP_PRECISION * 5,
809 TIMESTAMP_PRECISION,
810 TIMESTAMP_PRECISION / 2,
811 TIMESTAMP_PRECISION / 5,
812 TIMESTAMP_PRECISION / 10,
813 TIMESTAMP_PRECISION / 50,
814 TIMESTAMP_PRECISION / 200,
815 };
816 for (const TimingMeasurement *sc = vscales; sc < vscales + lengthof(vscales); sc++) {
817 if (range < *sc) this->vertical_scale = (int)*sc;
818 }
819 }
820
822 void UpdateScale()
823 {
824 const TimingMeasurement *durations = _pf_data[this->element].durations;
825 const TimingMeasurement *timestamps = _pf_data[this->element].timestamps;
826 int num_valid = _pf_data[this->element].num_valid;
827 int point = _pf_data[this->element].prev_index;
828
829 TimingMeasurement lastts = timestamps[point];
830 TimingMeasurement time_sum = 0;
831 TimingMeasurement peak_value = 0;
832 int count = 0;
833
834 /* Sensible default for when too few measurements are available */
835 this->horizontal_scale = 4;
836
837 for (int i = 1; i < num_valid; i++) {
838 point--;
839 if (point < 0) point = NUM_FRAMERATE_POINTS - 1;
840
841 TimingMeasurement value = durations[point];
842 if (value == PerformanceData::INVALID_DURATION) {
843 /* Skip gaps in data by pretending time is continuous across them */
844 lastts = timestamps[point];
845 continue;
846 }
847 if (value > peak_value) peak_value = value;
848 count++;
849
850 /* Accumulate period of time covered by data */
851 time_sum += lastts - timestamps[point];
852 lastts = timestamps[point];
853
854 /* Enough data to select a range and get decent data density */
855 if (count == 60) this->SelectHorizontalScale(time_sum / TIMESTAMP_PRECISION);
856
857 /* End when enough points have been collected and the horizontal scale has been exceeded */
858 if (count >= 60 && time_sum >= (this->horizontal_scale + 2) * TIMESTAMP_PRECISION / 2) break;
859 }
860
861 this->SelectVerticalScale(peak_value);
862 }
863
864 void OnRealtimeTick(uint delta_ms) override
865 {
866 this->SetDirty();
867
868 if (this->next_scale_update.Elapsed(delta_ms)) {
869 this->next_scale_update.SetInterval(500);
870 this->UpdateScale();
871 }
872 }
873
875 template<typename T>
876 static inline T Scinterlate(T dst_min, T dst_max, T src_min, T src_max, T value)
877 {
878 T dst_diff = dst_max - dst_min;
879 T src_diff = src_max - src_min;
880 return (value - src_min) * dst_diff / src_diff + dst_min;
881 }
882
883 void DrawWidget(const Rect &r, int widget) const override
884 {
885 if (widget == WID_FGW_GRAPH) {
886 const TimingMeasurement *durations = _pf_data[this->element].durations;
887 const TimingMeasurement *timestamps = _pf_data[this->element].timestamps;
888 int point = _pf_data[this->element].prev_index;
889
890 const int x_zero = r.right - (int)this->graph_size.width;
891 const int x_max = r.right;
892 const int y_zero = r.top + (int)this->graph_size.height;
893 const int y_max = r.top;
894 const int c_grid = PC_DARK_GREY;
895 const int c_lines = PC_BLACK;
896 const int c_peak = PC_DARK_RED;
897
898 const TimingMeasurement draw_horz_scale = (TimingMeasurement)this->horizontal_scale * TIMESTAMP_PRECISION / 2;
899 const TimingMeasurement draw_vert_scale = (TimingMeasurement)this->vertical_scale;
900
901 /* Number of \c horizontal_scale units in each horizontal division */
902 const uint horz_div_scl = (this->horizontal_scale <= 20) ? 1 : 10;
903 /* Number of divisions of the horizontal axis */
904 const uint horz_divisions = this->horizontal_scale / horz_div_scl;
905 /* Number of divisions of the vertical axis */
906 const uint vert_divisions = 10;
907
908 /* Draw division lines and labels for the vertical axis */
909 for (uint division = 0; division < vert_divisions; division++) {
910 int y = Scinterlate(y_zero, y_max, 0, (int)vert_divisions, (int)division);
911 GfxDrawLine(x_zero, y, x_max, y, c_grid);
912 if (division % 2 == 0) {
913 if ((TimingMeasurement)this->vertical_scale > TIMESTAMP_PRECISION) {
914 SetDParam(0, this->vertical_scale * division / 10 / TIMESTAMP_PRECISION);
915 DrawString(r.left, x_zero - 2, y - FONT_HEIGHT_SMALL, STR_FRAMERATE_GRAPH_SECONDS, TC_GREY, SA_RIGHT | SA_FORCE, false, FS_SMALL);
916 } else {
917 SetDParam(0, this->vertical_scale * division / 10 * 1000 / TIMESTAMP_PRECISION);
918 DrawString(r.left, x_zero - 2, y - FONT_HEIGHT_SMALL, STR_FRAMERATE_GRAPH_MILLISECONDS, TC_GREY, SA_RIGHT | SA_FORCE, false, FS_SMALL);
919 }
920 }
921 }
922 /* Draw division lines and labels for the horizontal axis */
923 for (uint division = horz_divisions; division > 0; division--) {
924 int x = Scinterlate(x_zero, x_max, 0, (int)horz_divisions, (int)horz_divisions - (int)division);
925 GfxDrawLine(x, y_max, x, y_zero, c_grid);
926 if (division % 2 == 0) {
927 SetDParam(0, division * horz_div_scl / 2);
928 DrawString(x, x_max, y_zero + 2, STR_FRAMERATE_GRAPH_SECONDS, TC_GREY, SA_LEFT | SA_FORCE, false, FS_SMALL);
929 }
930 }
931
932 /* Position of last rendered data point */
933 Point lastpoint = {
934 x_max,
935 (int)Scinterlate<int64>(y_zero, y_max, 0, this->vertical_scale, durations[point])
936 };
937 /* Timestamp of last rendered data point */
938 TimingMeasurement lastts = timestamps[point];
939
940 TimingMeasurement peak_value = 0;
941 Point peak_point = { 0, 0 };
942 TimingMeasurement value_sum = 0;
943 TimingMeasurement time_sum = 0;
944 int points_drawn = 0;
945
946 for (int i = 1; i < NUM_FRAMERATE_POINTS; i++) {
947 point--;
948 if (point < 0) point = NUM_FRAMERATE_POINTS - 1;
949
950 TimingMeasurement value = durations[point];
951 if (value == PerformanceData::INVALID_DURATION) {
952 /* Skip gaps in measurements, pretend the data points on each side are continuous */
953 lastts = timestamps[point];
954 continue;
955 }
956
957 /* Use total time period covered for value along horizontal axis */
958 time_sum += lastts - timestamps[point];
959 lastts = timestamps[point];
960 /* Stop if past the width of the graph */
961 if (time_sum > draw_horz_scale) break;
962
963 /* Draw line from previous point to new point */
964 Point newpoint = {
965 (int)Scinterlate<int64>(x_zero, x_max, 0, (int64)draw_horz_scale, (int64)draw_horz_scale - (int64)time_sum),
966 (int)Scinterlate<int64>(y_zero, y_max, 0, (int64)draw_vert_scale, (int64)value)
967 };
968 assert(newpoint.x <= lastpoint.x);
969 GfxDrawLine(lastpoint.x, lastpoint.y, newpoint.x, newpoint.y, c_lines);
970 lastpoint = newpoint;
971
972 /* Record peak and average value across graphed data */
973 value_sum += value;
974 points_drawn++;
975 if (value > peak_value) {
976 peak_value = value;
977 peak_point = newpoint;
978 }
979 }
980
981 /* If the peak value is significantly larger than the average, mark and label it */
982 if (points_drawn > 0 && peak_value > TIMESTAMP_PRECISION / 100 && 2 * peak_value > 3 * value_sum / points_drawn) {
983 TextColour tc_peak = (TextColour)(TC_IS_PALETTE_COLOUR | c_peak);
984 GfxFillRect(peak_point.x - 1, peak_point.y - 1, peak_point.x + 1, peak_point.y + 1, c_peak);
985 SetDParam(0, peak_value * 1000 / TIMESTAMP_PRECISION);
986 int label_y = std::max(y_max, peak_point.y - FONT_HEIGHT_SMALL);
987 if (peak_point.x - x_zero > (int)this->graph_size.width / 2) {
988 DrawString(x_zero, peak_point.x - 2, label_y, STR_FRAMERATE_GRAPH_MILLISECONDS, tc_peak, SA_RIGHT | SA_FORCE, false, FS_SMALL);
989 } else {
990 DrawString(peak_point.x + 2, x_max, label_y, STR_FRAMERATE_GRAPH_MILLISECONDS, tc_peak, SA_LEFT | SA_FORCE, false, FS_SMALL);
991 }
992 }
993 }
994 }
995 };
996
997 static WindowDesc _frametime_graph_window_desc(
998 WDP_AUTO, "frametime_graph", 140, 90,
999 WC_FRAMETIME_GRAPH, WC_NONE,
1000 0,
1001 _frametime_graph_window_widgets, lengthof(_frametime_graph_window_widgets)
1002 );
1003
1004
1005
1007 void ShowFramerateWindow()
1008 {
1009 AllocateWindowDescFront<FramerateWindow>(&_framerate_display_desc, 0);
1010 }
1011
1013 void ShowFrametimeGraphWindow(PerformanceElement elem)
1014 {
1015 if (elem < PFE_FIRST || elem >= PFE_MAX) return; // maybe warn?
1016 AllocateWindowDescFront<FrametimeGraphWindow>(&_frametime_graph_window_desc, elem, true);
1017 }
1018
1020 void ConPrintFramerate()
1021 {
1022 const int count1 = NUM_FRAMERATE_POINTS / 8;
1023 const int count2 = NUM_FRAMERATE_POINTS / 4;
1024 const int count3 = NUM_FRAMERATE_POINTS / 1;
1025
1026 IConsolePrint(TC_SILVER, "Based on num. data points: {} {} {}", count1, count2, count3);
1027
1028 static const char *MEASUREMENT_NAMES[PFE_MAX] = {
1029 "Game loop",
1030 " GL station ticks",
1031 " GL train ticks",
1032 " GL road vehicle ticks",
1033 " GL ship ticks",
1034 " GL aircraft ticks",
1035 " GL landscape ticks",
1036 " GL link graph delays",
1037 "Drawing",
1038 " Viewport drawing",
1039 "Video output",
1040 "Sound mixing",
1041 "AI/GS scripts total",
1042 "Game script",
1043 };
1044 char ai_name_buf[128];
1045
1046 static const PerformanceElement rate_elements[] = { PFE_GAMELOOP, PFE_DRAWING, PFE_VIDEO };
1047
1048 bool printed_anything = false;
1049
1050 for (const PerformanceElement *e = rate_elements; e < rate_elements + lengthof(rate_elements); e++) {
1051 auto &pf = _pf_data[*e];
1052 if (pf.num_valid == 0) continue;
1053 IConsolePrint(TC_GREEN, "{} rate: {:.2f}fps (expected: {:.2f}fps)",
1054 MEASUREMENT_NAMES[*e],
1055 pf.GetRate(),
1056 pf.expected_rate);
1057 printed_anything = true;
1058 }
1059
1060 for (PerformanceElement e = PFE_FIRST; e < PFE_MAX; e++) {
1061 auto &pf = _pf_data[e];
1062 if (pf.num_valid == 0) continue;
1063 const char *name;
1064 if (e < PFE_AI0) {
1065 name = MEASUREMENT_NAMES[e];
1066 } else {
1067 seprintf(ai_name_buf, lastof(ai_name_buf), "AI %d %s", e - PFE_AI0 + 1, GetAIName(e - PFE_AI0)),
1068 name = ai_name_buf;
1069 }
1070 IConsolePrint(TC_LIGHT_BLUE, "{} times: {:.2f}ms {:.2f}ms {:.2f}ms",
1071 name,
1072 pf.GetAverageDurationMilliseconds(count1),
1073 pf.GetAverageDurationMilliseconds(count2),
1074 pf.GetAverageDurationMilliseconds(count3));
1075 printed_anything = true;
1076 }
1077
1078 if (!printed_anything) {
1079 IConsolePrint(CC_ERROR, "No performance measurements have been taken yet.");
1080 }
1081 }
FrametimeGraphWindow::vertical_scale
int vertical_scale
number of TIMESTAMP_PRECISION units vertically
Definition: framerate_gui.cpp:734
game.hpp
anonymous_namespace{framerate_gui.cpp}::NUM_FRAMERATE_POINTS
const int NUM_FRAMERATE_POINTS
Number of data points to keep in buffer for each performance measurement.
Definition: framerate_gui.cpp:37
FrametimeGraphWindow::horizontal_scale
int horizontal_scale
number of half-second units horizontally
Definition: framerate_gui.cpp:735
anonymous_namespace{framerate_gui.cpp}::PerformanceData::GetRate
double GetRate()
Get current rate of a performance element, based on approximately the past one second of data.
Definition: framerate_gui.cpp:140
PFE_AI11
@ PFE_AI11
AI execution for player slot 12.
Definition: framerate_type.h:74
anonymous_namespace{framerate_gui.cpp}::PerformanceData::acc_duration
TimingMeasurement acc_duration
Current accumulated duration.
Definition: framerate_gui.cpp:59
anonymous_namespace{framerate_gui.cpp}::TIMESTAMP_PRECISION
const TimingMeasurement TIMESTAMP_PRECISION
Units a second is divided into in performance measurements
Definition: framerate_gui.cpp:39
GUISettings::refresh_rate
uint16 refresh_rate
How often we refresh the screen (time between draw-ticks).
Definition: settings_type.h:171
FramerateWindow
Definition: framerate_gui.cpp:388
game_instance.hpp
PFE_AI9
@ PFE_AI9
AI execution for player slot 10.
Definition: framerate_type.h:72
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
SetScrollbar
static NWidgetPart SetScrollbar(int index)
Attach a scrollbar to a widget.
Definition: widget_type.h:1188
PFE_VIDEO
@ PFE_VIDEO
Speed of painting drawn video buffer.
Definition: framerate_type.h:59
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:27
FramerateWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: framerate_gui.cpp:497
WWT_STICKYBOX
@ WWT_STICKYBOX
Sticky box (at top-right of a window, after WWT_DEFSIZEBOX)
Definition: widget_type.h:64
SetPadding
static NWidgetPart SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
Widget part function for setting additional space around a widget.
Definition: widget_type.h:1139
Window::GetScrollbar
const Scrollbar * GetScrollbar(uint widnum) const
Return the Scrollbar to a widget index.
Definition: window.cpp:320
PFE_AI14
@ PFE_AI14
AI execution for player slot 15.
Definition: framerate_type.h:77
PC_DARK_RED
static const uint8 PC_DARK_RED
Dark red palette colour.
Definition: gfx_func.h:196
guitimer_func.h
FrametimeGraphWindow::OnRealtimeTick
void OnRealtimeTick(uint delta_ms) override
Called periodically.
Definition: framerate_gui.cpp:864
Window::ReInit
void ReInit(int rx=0, int ry=0)
Re-initialize a window, and optionally change its size.
Definition: window.cpp:1004
company_base.h
anonymous_namespace{framerate_gui.cpp}::PerformanceData::BeginAccumulate
void BeginAccumulate(TimingMeasurement start_time)
Begin an accumulation of multiple measurements into a single value, from a given start time.
Definition: framerate_gui.cpp:83
FrametimeGraphWindow::Scinterlate
static T Scinterlate(T dst_min, T dst_max, T src_min, T src_max, T value)
Scale and interpolate a value from a source range into a destination range.
Definition: framerate_gui.cpp:876
WWT_CAPTION
@ WWT_CAPTION
Window caption (window title between closebox and stickybox)
Definition: widget_type.h:59
FrametimeGraphWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: framerate_gui.cpp:883
PFE_AI1
@ PFE_AI1
AI execution for player slot 2.
Definition: framerate_type.h:64
NWID_HORIZONTAL
@ NWID_HORIZONTAL
Horizontal container.
Definition: widget_type.h:73
PFE_GL_ROADVEHS
@ PFE_GL_ROADVEHS
Time spend processing road vehicles.
Definition: framerate_type.h:52
anonymous_namespace{framerate_gui.cpp}::PerformanceData::timestamps
TimingMeasurement timestamps[NUM_FRAMERATE_POINTS]
Start time of each cycle of the performance element, circular buffer.
Definition: framerate_gui.cpp:48
FramerateWindow::times_shortterm
CachedDecimal times_shortterm[PFE_MAX]
cached short term average times
Definition: framerate_gui.cpp:425
anonymous_namespace{framerate_gui.cpp}::GL_RATE
static const double GL_RATE
Game loop rate, cycles per second
Definition: framerate_gui.cpp:176
Scrollbar::SetCount
void SetCount(int num)
Sets the number of elements in the list.
Definition: widget_type.h:710
anonymous_namespace{framerate_gui.cpp}::PerformanceData::AddPause
void AddPause(TimingMeasurement start_time)
Indicate a pause/expected discontinuity in processing the element.
Definition: framerate_gui.cpp:103
ConPrintFramerate
void ConPrintFramerate()
Print performance statistics to game console.
Definition: framerate_gui.cpp:1020
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:250
FrametimeGraphWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: framerate_gui.cpp:766
FrametimeGraphWindow::next_scale_update
GUITimer next_scale_update
interval for next scale update
Definition: framerate_gui.cpp:736
PFE_GL_LINKGRAPH
@ PFE_GL_LINKGRAPH
Time spent waiting for link graph background jobs.
Definition: framerate_type.h:56
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
DrawString
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:642
WWT_EMPTY
@ WWT_EMPTY
Empty widget, place holder to reserve space in widget array.
Definition: widget_type.h:46
WindowNumber
int32 WindowNumber
Number to differentiate different windows of the same class.
Definition: window_type.h:711
PerformanceAccumulator::~PerformanceAccumulator
~PerformanceAccumulator()
Finish and add one block of the accumulating value.
Definition: framerate_gui.cpp:295
SA_RIGHT
@ SA_RIGHT
Right align the text (must be a single bit).
Definition: gfx_type.h:330
Scrollbar::GetScrolledRowFromWidget
int GetScrolledRowFromWidget(int clickpos, const Window *const w, int widget, int padding=0) const
Compute the row of a scrolled widget that a user clicked in.
Definition: widget.cpp:2098
Scrollbar
Scrollbar data structure.
Definition: widget_type.h:629
ShowFrametimeGraphWindow
void ShowFrametimeGraphWindow(PerformanceElement elem)
Open a graph window for a performance element.
Definition: framerate_gui.cpp:1013
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
NWidgetPart
Partial widget specification to allow NWidgets to be written nested.
Definition: widget_type.h:971
SetDataTip
static NWidgetPart SetDataTip(uint32 data, StringID tip)
Widget part function for setting the data and tooltip.
Definition: widget_type.h:1107
PerformanceMeasurer::SetInactive
static void SetInactive(PerformanceElement elem)
Mark a performance element as not currently in use.
Definition: framerate_gui.cpp:264
PFE_GL_LANDSCAPE
@ PFE_GL_LANDSCAPE
Time spent processing other world features.
Definition: framerate_type.h:55
GetStringBoundingBox
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
Definition: gfx.cpp:888
PerformanceElement
PerformanceElement
Elements of game performance that can be measured.
Definition: framerate_type.h:47
anonymous_namespace{framerate_gui.cpp}::PerformanceData::num_valid
int num_valid
Number of data points recorded, clamped to NUM_FRAMERATE_POINTS.
Definition: framerate_gui.cpp:56
PFE_GL_TRAINS
@ PFE_GL_TRAINS
Time spent processing trains.
Definition: framerate_type.h:51
ai_info.hpp
console_type.h
gfx_func.h
WindowDesc
High level window description.
Definition: window_gui.h:168
PerformanceMeasurer::SetExpectedRate
void SetExpectedRate(double rate)
Set the rate of expected cycles per second of a performance element.
Definition: framerate_gui.cpp:258
window_gui.h
GUITimer
Definition: guitimer_func.h:13
WDP_AUTO
@ WDP_AUTO
Find a place automatically.
Definition: window_gui.h:156
PFE_AI7
@ PFE_AI7
AI execution for player slot 8.
Definition: framerate_type.h:70
WC_FRAMETIME_GRAPH
@ WC_FRAMETIME_GRAPH
Frame time graph; Window numbers:
Definition: window_type.h:690
Window::resize
ResizeInfo resize
Resize information.
Definition: window_gui.h:317
Window::InitNested
void InitNested(WindowNumber number=0)
Perform complete initialization of the Window with nested widgets, to allow use.
Definition: window.cpp:1789
Window::SetDirty
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
Definition: window.cpp:993
FramerateWindow::DrawElementTimesColumn
void DrawElementTimesColumn(const Rect &r, StringID heading_str, const CachedDecimal *values) const
Render a column of formatted average durations.
Definition: framerate_gui.cpp:583
FS_SMALL
@ FS_SMALL
Index of the small font in the font tables.
Definition: gfx_type.h:208
FrametimeGraphWindow
Definition: framerate_gui.cpp:733
PFE_GL_SHIPS
@ PFE_GL_SHIPS
Time spent processing ships.
Definition: framerate_type.h:53
PerformanceMeasurer::~PerformanceMeasurer
~PerformanceMeasurer()
Finish a cycle of a measured element and store the measurement taken.
Definition: framerate_gui.cpp:243
ShowFramerateWindow
void ShowFramerateWindow()
Open the general framerate window.
Definition: framerate_gui.cpp:1007
PFE_AI2
@ PFE_AI2
AI execution for player slot 3.
Definition: framerate_type.h:65
ai_instance.hpp
anonymous_namespace{framerate_gui.cpp}::PerformanceData::PerformanceData
PerformanceData(double expected_rate)
Initialize a data element with an expected collection rate.
Definition: framerate_gui.cpp:69
TC_IS_PALETTE_COLOUR
@ TC_IS_PALETTE_COLOUR
Colour value is already a real palette colour index, not an index of a StringColour.
Definition: gfx_type.h:273
SA_FORCE
@ SA_FORCE
Force the alignment, i.e. don't swap for RTL languages.
Definition: gfx_type.h:340
safeguards.h
Company::IsValidAiID
static bool IsValidAiID(size_t index)
Is this company a valid company, controlled by the computer (a NoAI program)?
Definition: company_base.h:135
FrametimeGraphWindow::UpdateScale
void UpdateScale()
Recalculate the graph scaling factors based on current recorded data.
Definition: framerate_gui.cpp:822
PerformanceMeasurer::PerformanceMeasurer
PerformanceMeasurer(PerformanceElement elem)
Begin a cycle of a measured element.
Definition: framerate_gui.cpp:234
FramerateWindow::OnRealtimeTick
void OnRealtimeTick(uint delta_ms) override
Called periodically.
Definition: framerate_gui.cpp:444
PFE_DRAWING
@ PFE_DRAWING
Speed of drawing world and GUI.
Definition: framerate_type.h:57
sprites.h
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
PFE_AI12
@ PFE_AI12
AI execution for player slot 13.
Definition: framerate_type.h:75
PFE_GL_AIRCRAFT
@ PFE_GL_AIRCRAFT
Time spent processing aircraft.
Definition: framerate_type.h:54
PFE_AI10
@ PFE_AI10
AI execution for player slot 11.
Definition: framerate_type.h:73
PFE_MAX
@ PFE_MAX
End of enum, must be last.
Definition: framerate_type.h:78
PC_BLACK
static const uint8 PC_BLACK
Black palette colour.
Definition: gfx_func.h:190
GfxFillRect
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
Definition: gfx.cpp:116
anonymous_namespace{framerate_gui.cpp}::PerformanceData::expected_rate
double expected_rate
Expected number of cycles per second when the system is running without slowdowns.
Definition: framerate_gui.cpp:50
FramerateWindow::MIN_ELEMENTS
static constexpr int MIN_ELEMENTS
smallest number of elements to display
Definition: framerate_gui.cpp:429
anonymous_namespace{framerate_gui.cpp}::PerformanceData::prev_index
int prev_index
Last index written to in durations and timestamps.
Definition: framerate_gui.cpp:54
NWidgetStacked::SetDisplayedPlane
void SetDisplayedPlane(int plane)
Select which plane to show (for NWID_SELECTION only).
Definition: widget.cpp:1195
NWidgetStacked
Stacked widgets, widgets all occupying the same space in the window.
Definition: widget_type.h:438
WC_NONE
@ WC_NONE
No window, redirects to WC_MAIN_WINDOW.
Definition: window_type.h:37
PerformanceMeasurer::Paused
static void Paused(PerformanceElement elem)
Indicate that a cycle of "pause" where no processing occurs.
Definition: framerate_gui.cpp:275
NWID_VERTICAL
@ NWID_VERTICAL
Vertical container.
Definition: widget_type.h:75
FONT_HEIGHT_SMALL
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
Definition: gfx_func.h:162
WWT_CLOSEBOX
@ WWT_CLOSEBOX
Close box (at top-left of a window)
Definition: widget_type.h:67
WWT_RESIZEBOX
@ WWT_RESIZEBOX
Resize box (normally at bottom-right of a window)
Definition: widget_type.h:66
string_func.h
Scrollbar::SetCapacity
void SetCapacity(int capacity)
Set the capacity of visible elements.
Definition: widget_type.h:726
PFE_GAMESCRIPT
@ PFE_GAMESCRIPT
Game script execution.
Definition: framerate_type.h:62
FramerateWindow::CachedDecimal
Definition: framerate_gui.cpp:395
FramerateWindow::DrawWidget
void DrawWidget(const Rect &r, int widget) const override
Draw the contents of a nested widget.
Definition: framerate_gui.cpp:636
PerformanceAccumulator::PerformanceAccumulator
PerformanceAccumulator(PerformanceElement elem)
Begin measuring one block of the accumulating value.
Definition: framerate_gui.cpp:286
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
PFE_SOUND
@ PFE_SOUND
Speed of mixing audio samples.
Definition: framerate_type.h:60
FramerateWindow::times_longterm
CachedDecimal times_longterm[PFE_MAX]
cached long term average times
Definition: framerate_gui.cpp:426
EndContainer
static NWidgetPart EndContainer()
Widget part function for denoting the end of a container (horizontal, vertical, WWT_FRAME,...
Definition: widget_type.h:1092
anonymous_namespace{framerate_gui.cpp}::_pf_data
PerformanceData _pf_data[PFE_MAX]
Storage for all performance element measurements.
Definition: framerate_gui.cpp:183
strings_func.h
NWID_VSCROLLBAR
@ NWID_VSCROLLBAR
Vertical scrollbar.
Definition: widget_type.h:82
PFE_GAMELOOP
@ PFE_GAMELOOP
Speed of gameloop processing.
Definition: framerate_type.h:49
Window::IsShaded
bool IsShaded() const
Is window shaded currently?
Definition: window_gui.h:520
PFE_AI8
@ PFE_AI8
AI execution for player slot 9.
Definition: framerate_type.h:71
PFE_GL_ECONOMY
@ PFE_GL_ECONOMY
Time spent processing cargo movement.
Definition: framerate_type.h:50
WWT_TEXT
@ WWT_TEXT
Pure simple text.
Definition: widget_type.h:56
FrametimeGraphWindow::graph_size
Dimension graph_size
size of the main graph area (excluding axis labels)
Definition: framerate_gui.cpp:739
TimingMeasurement
uint64 TimingMeasurement
Type used to hold a performance timing measurement.
Definition: framerate_type.h:83
WC_FRAMERATE_DISPLAY
@ WC_FRAMERATE_DISPLAY
Framerate display; Window numbers:
Definition: window_type.h:684
anonymous_namespace{framerate_gui.cpp}::PerformanceData::AddAccumulate
void AddAccumulate(TimingMeasurement duration)
Accumulate a period onto the current measurement.
Definition: framerate_gui.cpp:97
FONT_HEIGHT_NORMAL
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
Definition: gfx_func.h:165
NWidget
static NWidgetPart NWidget(WidgetType tp, Colours col, int16 idx=-1)
Widget part function for starting a new 'real' widget.
Definition: widget_type.h:1207
framerate_type.h
WWT_PANEL
@ WWT_PANEL
Simple depressed panel.
Definition: widget_type.h:48
PFE_AI3
@ PFE_AI3
AI execution for player slot 4.
Definition: framerate_type.h:66
PFE_AI6
@ PFE_AI6
AI execution for player slot 7.
Definition: framerate_type.h:69
Scrollbar::GetPosition
uint16 GetPosition() const
Gets the position of the first visible element in the list.
Definition: widget_type.h:671
PFE_ALLSCRIPTS
@ PFE_ALLSCRIPTS
Sum of all GS/AI scripts.
Definition: framerate_type.h:61
anonymous_namespace{framerate_gui.cpp}::PerformanceData
Definition: framerate_gui.cpp:41
seprintf
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Definition: string.cpp:535
CC_ERROR
static const TextColour CC_ERROR
Colour for error lines.
Definition: console_type.h:24
FramerateWindow::rate_drawing
CachedDecimal rate_drawing
cached drawing frame rate
Definition: framerate_gui.cpp:423
GUITimer::Elapsed
bool Elapsed(uint delta)
Test if a timer has elapsed.
Definition: guitimer_func.h:55
framerate_widget.h
SA_LEFT
@ SA_LEFT
Left align the text.
Definition: gfx_type.h:328
anonymous_namespace{framerate_gui.cpp}::PerformanceData::Add
void Add(TimingMeasurement start_time, TimingMeasurement end_time)
Collect a complete measurement, given start and ending times for a processing block.
Definition: framerate_gui.cpp:72
MILLISECONDS_PER_TICK
static const uint MILLISECONDS_PER_TICK
The number of milliseconds per game tick.
Definition: gfx_type.h:310
window_func.h
SA_CENTER
@ SA_CENTER
Center both horizontally and vertically.
Definition: gfx_type.h:338
FramerateWindow::OnResize
void OnResize() override
Called after the window got resized.
Definition: framerate_gui.cpp:703
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:378
SetPIP
static NWidgetPart SetPIP(uint8 pre, uint8 inter, uint8 post)
Widget part function for setting a pre/inter/post spaces.
Definition: widget_type.h:1169
FrametimeGraphWindow::SetStringParameters
void SetStringParameters(int widget) const override
Initialize string parameters for a widget.
Definition: framerate_gui.cpp:751
FramerateWindow::VSPACING
static constexpr int VSPACING
space between column heading and values
Definition: framerate_gui.cpp:428
PFE_AI5
@ PFE_AI5
AI execution for player slot 6.
Definition: framerate_type.h:68
PerformanceAccumulator::Reset
static void Reset(PerformanceElement elem)
Store the previous accumulator value and reset for a new cycle of accumulating measurements.
Definition: framerate_gui.cpp:305
PFE_AI13
@ PFE_AI13
AI execution for player slot 14.
Definition: framerate_type.h:76
anonymous_namespace{framerate_gui.cpp}::PerformanceData::next_index
int next_index
Next index to write to in durations and timestamps.
Definition: framerate_gui.cpp:52
anonymous_namespace{framerate_gui.cpp}::PerformanceData::durations
TimingMeasurement durations[NUM_FRAMERATE_POINTS]
Time spent processing each cycle of the performance element, circular buffer.
Definition: framerate_gui.cpp:46
FrametimeGraphWindow::element
PerformanceElement element
what element this window renders graph for
Definition: framerate_gui.cpp:738
Window
Data structure for an opened window.
Definition: window_gui.h:279
SZSP_VERTICAL
@ SZSP_VERTICAL
Display plane with zero size horizontally, and filling and resizing vertically.
Definition: widget_type.h:421
FramerateWindow::rate_gameloop
CachedDecimal rate_gameloop
cached game loop tick rate
Definition: framerate_gui.cpp:422
PFE_AI4
@ PFE_AI4
AI execution for player slot 5.
Definition: framerate_type.h:67
FramerateWindow::OnClick
void OnClick(Point pt, int widget, int click_count) override
A click with the left mouse button has been made on the window.
Definition: framerate_gui.cpp:678
PFE_AI0
@ PFE_AI0
AI execution for player slot 1.
Definition: framerate_type.h:63
PC_DARK_GREY
static const uint8 PC_DARK_GREY
Dark grey palette colour.
Definition: gfx_func.h:191
console_func.h
anonymous_namespace{framerate_gui.cpp}::PerformanceData::GetAverageDurationMilliseconds
double GetAverageDurationMilliseconds(int count)
Get average cycle processing time over a number of data points.
Definition: framerate_gui.cpp:116
NWID_SELECTION
@ NWID_SELECTION
Stacked widgets, only one visible at a time (eg in a panel with tabs).
Definition: widget_type.h:78
GetPerformanceTimer
static TimingMeasurement GetPerformanceTimer()
Return a timestamp with TIMESTAMP_PRECISION ticks per second precision.
Definition: framerate_gui.cpp:223
Game::GetInstance
static class GameInstance * GetInstance()
Get the current active instance.
Definition: game.hpp:111
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
anonymous_namespace{framerate_gui.cpp}::PerformanceData::acc_timestamp
TimingMeasurement acc_timestamp
Start time for current accumulation cycle.
Definition: framerate_gui.cpp:61
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:394
FramerateWindow::UpdateWidgetSize
void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize) override
Update size and resize step of a widget in the window.
Definition: framerate_gui.cpp:525
SetDParamStr
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:296
PFE_DRAWWORLD
@ PFE_DRAWWORLD
Time spent drawing world viewports in GUI.
Definition: framerate_type.h:58
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:593
FramerateWindow::speed_gameloop
CachedDecimal speed_gameloop
cached game loop speed factor
Definition: framerate_gui.cpp:424
ResizeWindow
void ResizeWindow(Window *w, int delta_x, int delta_y, bool clamp_to_screen)
Resize the window.
Definition: window.cpp:2069
WWT_SHADEBOX
@ WWT_SHADEBOX
Shade box (at top-right of a window, between WWT_DEBUGBOX and WWT_DEFSIZEBOX)
Definition: widget_type.h:62
IConsolePrint
void IConsolePrint(TextColour colour_code, const std::string &string)
Handle the printing of text entered into the console or redirected there by any other means.
Definition: console.cpp:94