OpenTTD Source  12.0-beta2
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 
28 #include "safeguards.h"
29 
30 
34 namespace {
35 
37  const int NUM_FRAMERATE_POINTS = 512;
40 
41  struct PerformanceData {
43  static const TimingMeasurement INVALID_DURATION = UINT64_MAX;
44 
50  double expected_rate;
56  int num_valid;
57 
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 
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 
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 
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 
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 
224 {
225  using namespace std::chrono;
226  return (TimingMeasurement)time_point_cast<microseconds>(high_resolution_clock::now()).time_since_epoch().count();
227 }
228 
229 
235 {
236  assert(elem < PFE_MAX);
237 
238  this->elem = elem;
239  this->start_time = GetPerformanceTimer();
240 }
241 
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) {
251  return;
252  }
253  }
254  _pf_data[this->elem].Add(this->start_time, GetPerformanceTimer());
255 }
256 
259 {
260  _pf_data[this->elem].expected_rate = rate;
261 }
262 
265 {
266  _pf_data[elem].num_valid = 0;
267  _pf_data[elem].next_index = 0;
268  _pf_data[elem].prev_index = 0;
269 }
270 
276 {
279 }
280 
281 
287 {
288  assert(elem < PFE_MAX);
289 
290  this->elem = elem;
291  this->start_time = GetPerformanceTimer();
292 }
293 
296 {
297  _pf_data[this->elem].AddAccumulate(GetPerformanceTimer() - this->start_time);
298 }
299 
306 {
308 }
309 
310 
312 
313 
314 static const PerformanceElement DISPLAY_ORDER_PFE[PFE_MAX] = {
315  PFE_GAMELOOP,
319  PFE_GL_SHIPS,
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,
340  PFE_DRAWING,
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[] = {
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(),
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(),
382  NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_FRW_SCROLLBAR),
383  NWidget(WWT_RESIZEBOX, COLOUR_GREY),
384  EndContainer(),
385  EndContainer(),
386 };
387 
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 
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:
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;
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);
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);
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) {
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,
714  0,
715  _framerate_window_widgets, lengthof(_framerate_window_widgets)
716 );
717 
718 
720 static const NWidgetPart _frametime_graph_window_widgets[] = {
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),
728  NWidget(WWT_EMPTY, COLOUR_GREY, WID_FGW_GRAPH),
729  EndContainer(),
730  EndContainer(),
731 };
732 
737 
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,
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,
1000  0,
1001  _frametime_graph_window_widgets, lengthof(_frametime_graph_window_widgets)
1002 );
1003 
1004 
1005 
1008 {
1009  AllocateWindowDescFront<FramerateWindow>(&_framerate_display_desc, 0);
1010 }
1011 
1014 {
1015  if (elem < PFE_FIRST || elem >= PFE_MAX) return; // maybe warn?
1016  AllocateWindowDescFront<FrametimeGraphWindow>(&_frametime_graph_window_desc, elem, true);
1017 }
1018 
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