rooty/dxvk
1
0
Fork 0
mirror of https://github.com/doitsujin/dxvk.git synced 2025-01-31 14:52:11 +01:00
Code Issues Projects Releases Wiki Activity

[hud] Remove legacy code

Browse Source
This commit is contained in:
Philip Rebohle 2019-12-13 11:58:09 +01:00
parent 3415376984
commit ed69da0fff
No known key found for this signature in database
GPG Key ID: C8CC613427A31C99
11 changed files with 5 additions and 712 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/dxvk/hud/dxvk_hud.cpp
View File

@ -5,15 +5,10 @@
namespace dxvk::hud {
Hud::Hud(
const Rc<DxvkDevice>& device,
const HudConfig& config)
: m_config (config),
m_device (device),
const Rc<DxvkDevice>& device)
: m_device (device),
m_uniformBuffer (createUniformBuffer()),
m_renderer (device),
m_hudDeviceInfo (device),
m_hudFramerate (config.elements),
m_hudStats (config.elements) {
m_renderer (device) {
// Set up constant state
m_rsState.polygonMode = VK_POLYGON_MODE_FILL;
m_rsState.cullMode = VK_CULL_MODE_BACK_BIT;
@ -55,8 +50,6 @@ namespace dxvk::hud {
void Hud::update() {
m_hudItems.update();
m_hudFramerate.update();
m_hudStats.update(m_device);
}
@ -71,16 +64,7 @@ namespace dxvk::hud {
Rc<Hud> Hud::createHud(const Rc<DxvkDevice>& device) {
std::string hudElements = env::getEnvVar("DXVK_HUD");
if (hudElements.empty())
hudElements = device->config().hud;
HudConfig config(hudElements);
return !config.elements.isClear()
? new Hud(device, config)
: nullptr;
return new Hud(device);
}
@ -97,11 +81,6 @@ namespace dxvk::hud {
void Hud::renderHudElements(const Rc<DxvkContext>& ctx) {
m_hudItems.render(m_renderer);
HudPos position = { 8.0f, 24.0f };
position = m_hudFramerate.render(m_renderer, position);
position = m_hudStats .render(m_renderer, position);
}

14
src/dxvk/hud/dxvk_hud.h
View File

@ -2,14 +2,8 @@
#include "../dxvk_device.h"
#include "../util/util_env.h"
#include "dxvk_hud_config.h"
#include "dxvk_hud_devinfo.h"
#include "dxvk_hud_item.h"
#include "dxvk_hud_fps.h"
#include "dxvk_hud_renderer.h"
#include "dxvk_hud_stats.h"
namespace dxvk::hud {
@ -31,9 +25,7 @@ namespace dxvk::hud {
public:
Hud(
const Rc<DxvkDevice>& device,
const HudConfig& config);
Hud(const Rc<DxvkDevice>& device);
~Hud();
@ -81,7 +73,6 @@ namespace dxvk::hud {
private:
const HudConfig m_config;
const Rc<DxvkDevice> m_device;
Rc<DxvkBuffer> m_uniformBuffer;
@ -91,9 +82,6 @@ namespace dxvk::hud {
HudUniformData m_uniformData;
HudRenderer m_renderer;
HudDeviceInfo m_hudDeviceInfo;
HudFps m_hudFramerate;
HudStats m_hudStats;
HudItemSet m_hudItems;
void setupRendererState(

59
src/dxvk/hud/dxvk_hud_config.cpp
View File

@ -1,59 +0,0 @@
#include "dxvk_hud_config.h"
#include <unordered_map>
namespace dxvk::hud {
const std::unordered_map<std::string, HudElement> g_hudElements = {{
{ "devinfo", HudElement::DeviceInfo },
{ "fps", HudElement::Framerate },
{ "frametimes", HudElement::Frametimes },
{ "drawcalls", HudElement::StatDrawCalls },
{ "submissions", HudElement::StatSubmissions },
{ "pipelines", HudElement::StatPipelines },
{ "memory", HudElement::StatMemory },
{ "gpuload", HudElement::StatGpuLoad },
{ "version", HudElement::DxvkVersion },
{ "api", HudElement::DxvkClientApi },
{ "compiler", HudElement::CompilerActivity },
}};
HudConfig::HudConfig() {
}
HudConfig::HudConfig(const std::string& configStr) {
if (configStr == "1") {
this->elements.set(
HudElement::DeviceInfo,
HudElement::Framerate);
} else if (configStr == "full") {
for (auto pair : g_hudElements)
this->elements.set(pair.second);
} else {
std::string::size_type pos = 0;
std::string::size_type end = 0;
while (pos < configStr.size()) {
end = configStr.find(',', pos);
if (end == std::string::npos)
end = configStr.size();
std::string configPart = configStr.substr(pos, end - pos);
auto element = g_hudElements.find(configPart);
if (element != g_hudElements.cend()) {
this->elements.set(element->second);
Logger::debug(str::format("Hud: Enabled ", configPart));
}
pos = end + 1;
}
}
}
}

49
src/dxvk/hud/dxvk_hud_config.h
View File

@ -1,49 +0,0 @@
#pragma once
#include "../dxvk_include.h"
namespace dxvk::hud {
/**
* \brief HUD element
*
* These flags can be used to enable
* or disable HUD elements on demand.
*/
enum class HudElement {
DeviceInfo = 0,
Framerate = 1,
Frametimes = 2,
StatDrawCalls = 3,
StatSubmissions = 4,
StatPipelines = 5,
StatMemory = 6,
StatGpuLoad = 7,
DxvkVersion = 8,
DxvkClientApi = 9,
CompilerActivity = 10,
};
using HudElements = Flags<HudElement>;
/**
* \brief HUD configuration
*/
struct HudConfig {
HudConfig();
HudConfig(const std::string& configStr);
HudElements elements;
};
/**
* \brief Gets HUD configuration from config strnig
*
* \param [in] configStr Configuration string
* \returns HUD configuration struct
*/
HudConfig parseHudConfigStr(const std::string& configStr);
}

45
src/dxvk/hud/dxvk_hud_devinfo.cpp
View File

@ -1,45 +0,0 @@
#include "dxvk_hud_devinfo.h"
namespace dxvk::hud {
HudDeviceInfo::HudDeviceInfo(const Rc<DxvkDevice>& device) {
VkPhysicalDeviceProperties props = device->adapter()->deviceProperties();
m_deviceName = props.deviceName;
m_driverVer = str::format("Driver: ",
VK_VERSION_MAJOR(props.driverVersion), ".",
VK_VERSION_MINOR(props.driverVersion), ".",
VK_VERSION_PATCH(props.driverVersion));
m_vulkanVer = str::format("Vulkan: ",
VK_VERSION_MAJOR(props.apiVersion), ".",
VK_VERSION_MINOR(props.apiVersion), ".",
VK_VERSION_PATCH(props.apiVersion));
}
HudDeviceInfo::~HudDeviceInfo() {
}
HudPos HudDeviceInfo::render(
HudRenderer& renderer,
HudPos position) {
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
m_deviceName);
renderer.drawText(16.0f,
{ position.x, position.y + 24 },
{ 1.0f, 1.0f, 1.0f, 1.0f },
m_driverVer);
renderer.drawText(16.0f,
{ position.x, position.y + 44 },
{ 1.0f, 1.0f, 1.0f, 1.0f },
m_vulkanVer);
return HudPos { position.x, position.y + 68 };
}
}

32
src/dxvk/hud/dxvk_hud_devinfo.h
View File

@ -1,32 +0,0 @@
#pragma once
#include "dxvk_hud_renderer.h"
namespace dxvk::hud {
/**
* \brief Device info display for the HUD
*
* Displays the name of the device, as well as
* the driver version and Vulkan API version.
*/
class HudDeviceInfo {
public:
HudDeviceInfo(const Rc<DxvkDevice>& device);
~HudDeviceInfo();
HudPos render(
HudRenderer& renderer,
HudPos position);
private:
std::string m_deviceName;
std::string m_driverVer;
std::string m_vulkanVer;
};
}

128
src/dxvk/hud/dxvk_hud_fps.cpp
View File

@ -1,128 +0,0 @@
#include "dxvk_hud_fps.h"
#include <cmath>
#include <iomanip>
namespace dxvk::hud {
HudFps::HudFps(HudElements elements)
: m_elements (elements),
m_fpsString ("FPS: "),
m_prevFpsUpdate(Clock::now()),
m_prevFtgUpdate(Clock::now()) {
}
HudFps::~HudFps() {
}
void HudFps::update() {
m_frameCount += 1;
TimePoint now = Clock::now();
TimeDiff elapsedFps = std::chrono::duration_cast<TimeDiff>(now - m_prevFpsUpdate);
TimeDiff elapsedFtg = std::chrono::duration_cast<TimeDiff>(now - m_prevFtgUpdate);
m_prevFtgUpdate = now;
// Update FPS string
if (elapsedFps.count() >= UpdateInterval) {
const int64_t fps = (10'000'000ll * m_frameCount) / elapsedFps.count();
m_fpsString = str::format("FPS: ", fps / 10, ".", fps % 10);
m_prevFpsUpdate = now;
m_frameCount = 0;
}
// Update frametime stuff
m_dataPoints[m_dataPointId] = float(elapsedFtg.count());
m_dataPointId = (m_dataPointId + 1) % NumDataPoints;
}
HudPos HudFps::render(
HudRenderer& renderer,
HudPos position) {
if (m_elements.test(HudElement::Framerate))
position = this->renderFpsText(renderer, position);
if (m_elements.test(HudElement::Frametimes))
position = this->renderFrametimeGraph(renderer, position);
return position;
}
HudPos HudFps::renderFpsText(
HudRenderer& renderer,
HudPos position) {
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
m_fpsString);
return HudPos { position.x, position.y + 24 };
}
HudPos HudFps::renderFrametimeGraph(
HudRenderer& renderer,
HudPos position) {
std::array<HudLineVertex, NumDataPoints * 2> vData;
// 60 FPS = optimal, 10 FPS = worst
const float targetUs = 16'666.6f;
const float minUs = 5'000.0f;
const float maxUs = 100'000.0f;
// Ten times the maximum/minimum number
// of milliseconds for a single frame
uint32_t minMs = 0xFFFFFFFFu;
uint32_t maxMs = 0x00000000u;
// Paint the time points
for (uint32_t i = 0; i < NumDataPoints; i++) {
float us = m_dataPoints[(m_dataPointId + i) % NumDataPoints];
minMs = std::min(minMs, uint32_t(us / 100.0f));
maxMs = std::max(maxMs, uint32_t(us / 100.0f));
float r = std::min(std::max(-1.0f + us / targetUs, 0.0f), 1.0f);
float g = std::min(std::max( 3.0f - us / targetUs, 0.0f), 1.0f);
float l = std::sqrt(r * r + g * g);
HudNormColor color = {
uint8_t(255.0f * (r / l)),
uint8_t(255.0f * (g / l)),
uint8_t(0), uint8_t(255) };
float x = position.x + float(i);
float y = position.y + 24.0f;
float hVal = std::log2(std::max((us - minUs) / targetUs + 1.0f, 1.0f))
/ std::log2((maxUs - minUs) / targetUs);
float h = std::min(std::max(40.0f * hVal, 2.0f), 40.0f);
vData[2 * i + 0] = HudLineVertex { { x, y }, color };
vData[2 * i + 1] = HudLineVertex { { x, y - h }, color };
}
renderer.drawLines(vData.size(), vData.data());
// Paint min/max frame times in the entire window
renderer.drawText(14.0f,
{ position.x, position.y + 44.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f },
str::format("min: ", minMs / 10, ".", minMs % 10));
renderer.drawText(14.0f,
{ position.x + 150.0f, position.y + 44.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f },
str::format("max: ", maxMs / 10, ".", maxMs % 10));
return HudPos { position.x, position.y + 66.0f };
}
}

56
src/dxvk/hud/dxvk_hud_fps.h
View File

@ -1,56 +0,0 @@
#pragma once
#include "../util/util_time.h"
#include "dxvk_hud_config.h"
#include "dxvk_hud_renderer.h"
namespace dxvk::hud {
/**
* \brief FPS display for the HUD
*
* Displays the current frames per second.
*/
class HudFps {
using Clock = dxvk::high_resolution_clock;
using TimeDiff = std::chrono::microseconds;
using TimePoint = typename Clock::time_point;
constexpr static uint32_t NumDataPoints = 300;
constexpr static int64_t UpdateInterval = 500'000;
public:
HudFps(HudElements elements);
~HudFps();
void update();
HudPos render(
HudRenderer& renderer,
HudPos position);
private:
const HudElements m_elements;
std::string m_fpsString;
TimePoint m_prevFpsUpdate;
TimePoint m_prevFtgUpdate;
int64_t m_frameCount = 0;
std::array<float, NumDataPoints> m_dataPoints = {};
uint32_t m_dataPointId = 0;
HudPos renderFpsText(
HudRenderer& renderer,
HudPos position);
HudPos renderFrametimeGraph(
HudRenderer& renderer,
HudPos position);
};
}

223
src/dxvk/hud/dxvk_hud_stats.cpp
View File

@ -1,223 +0,0 @@
#include "dxvk_hud_stats.h"
namespace dxvk::hud {
HudStats::HudStats(HudElements elements)
: m_elements(filterElements(elements)),
m_compilerShowTime(dxvk::high_resolution_clock::now()) { }
HudStats::~HudStats() {
}
void HudStats::update(const Rc<DxvkDevice>& device) {
if (m_elements.isClear())
return;
// For some counters, we'll display the absolute value,
// for others, the average counter increment per frame.
DxvkStatCounters nextCounters = device->getStatCounters();
m_diffCounters = nextCounters.diff(m_prevCounters);
m_prevCounters = nextCounters;
// GPU load is a bit more complex than that since
// we don't want to update this every frame
if (m_elements.test(HudElement::StatGpuLoad))
this->updateGpuLoad();
}
HudPos HudStats::render(
HudRenderer& renderer,
HudPos position) {
if (m_elements.test(HudElement::StatSubmissions))
position = this->printSubmissionStats(renderer, position);
if (m_elements.test(HudElement::StatDrawCalls))
position = this->printDrawCallStats(renderer, position);
if (m_elements.test(HudElement::StatPipelines))
position = this->printPipelineStats(renderer, position);
if (m_elements.test(HudElement::StatMemory))
position = this->printMemoryStats(renderer, position);
if (m_elements.test(HudElement::StatGpuLoad))
position = this->printGpuLoad(renderer, position);
if (m_elements.test(HudElement::CompilerActivity)) {
this->printCompilerActivity(renderer,
{ position.x, float(renderer.surfaceSize().height) - 20.0f });
}
return position;
}
void HudStats::updateGpuLoad() {
auto now = dxvk::high_resolution_clock::now();
uint64_t ticks = std::chrono::duration_cast<std::chrono::microseconds>(now - m_gpuLoadUpdateTime).count();
if (ticks >= 500'000) {
m_gpuLoadUpdateTime = now;
m_diffGpuIdleTicks = m_prevCounters.getCtr(DxvkStatCounter::GpuIdleTicks) - m_prevGpuIdleTicks;
m_prevGpuIdleTicks = m_prevCounters.getCtr(DxvkStatCounter::GpuIdleTicks);
uint64_t busyTicks = ticks > m_diffGpuIdleTicks
? uint64_t(ticks - m_diffGpuIdleTicks)
: uint64_t(0);
m_gpuLoadString = str::format("GPU: ", (100 * busyTicks) / ticks, "%");
}
}
HudPos HudStats::printDrawCallStats(
HudRenderer& renderer,
HudPos position) {
const uint64_t frameCount = std::max<uint64_t>(m_diffCounters.getCtr(DxvkStatCounter::QueuePresentCount), 1);
const uint64_t gpCalls = m_diffCounters.getCtr(DxvkStatCounter::CmdDrawCalls) / frameCount;
const uint64_t cpCalls = m_diffCounters.getCtr(DxvkStatCounter::CmdDispatchCalls) / frameCount;
const uint64_t rpCalls = m_diffCounters.getCtr(DxvkStatCounter::CmdRenderPassCount) / frameCount;
const std::string strDrawCalls = str::format("Draw calls: ", gpCalls);
const std::string strDispatchCalls = str::format("Dispatch calls: ", cpCalls);
const std::string strRenderPasses = str::format("Render passes: ", rpCalls);
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strDrawCalls);
renderer.drawText(16.0f,
{ position.x, position.y + 20.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strDispatchCalls);
renderer.drawText(16.0f,
{ position.x, position.y + 40.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strRenderPasses);
return { position.x, position.y + 64 };
}
HudPos HudStats::printSubmissionStats(
HudRenderer& renderer,
HudPos position) {
const uint64_t frameCount = std::max<uint64_t>(m_diffCounters.getCtr(DxvkStatCounter::QueuePresentCount), 1);
const uint64_t numSubmits = m_diffCounters.getCtr(DxvkStatCounter::QueueSubmitCount) / frameCount;
const std::string strSubmissions = str::format("Queue submissions: ", numSubmits);
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strSubmissions);
return { position.x, position.y + 24.0f };
}
HudPos HudStats::printPipelineStats(
HudRenderer& renderer,
HudPos position) {
const uint64_t gpCount = m_prevCounters.getCtr(DxvkStatCounter::PipeCountGraphics);
const uint64_t cpCount = m_prevCounters.getCtr(DxvkStatCounter::PipeCountCompute);
const std::string strGpCount = str::format("Graphics pipelines: ", gpCount);
const std::string strCpCount = str::format("Compute pipelines: ", cpCount);
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strGpCount);
renderer.drawText(16.0f,
{ position.x, position.y + 20.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strCpCount);
return { position.x, position.y + 44.0f };
}
HudPos HudStats::printMemoryStats(
HudRenderer& renderer,
HudPos position) {
constexpr uint64_t mib = 1024 * 1024;
const uint64_t memAllocated = m_prevCounters.getCtr(DxvkStatCounter::MemoryAllocated);
const uint64_t memUsed = m_prevCounters.getCtr(DxvkStatCounter::MemoryUsed);
const std::string strMemAllocated = str::format("Memory allocated: ", memAllocated / mib, " MB");
const std::string strMemUsed = str::format("Memory used: ", memUsed / mib, " MB");
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strMemAllocated);
renderer.drawText(16.0f,
{ position.x, position.y + 20.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f },
strMemUsed);
return { position.x, position.y + 44.0f };
}
HudPos HudStats::printGpuLoad(
HudRenderer& renderer,
HudPos position) {
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
m_gpuLoadString);
return { position.x, position.y + 24.0f };
}
HudPos HudStats::printCompilerActivity(
HudRenderer& renderer,
HudPos position) {
auto now = dxvk::high_resolution_clock::now();
bool doShow = m_prevCounters.getCtr(DxvkStatCounter::PipeCompilerBusy);
if (m_prevCounters.getCtr(DxvkStatCounter::PipeCompilerBusy)
&& m_diffCounters.getCtr(DxvkStatCounter::PipeCompilerBusy))
m_compilerShowTime = now;
if (!doShow) {
doShow |= std::chrono::duration_cast<std::chrono::milliseconds>(now - m_compilerShowTime)
< std::chrono::milliseconds(1000);
}
if (doShow) {
renderer.drawText(16.0f,
{ position.x, position.y },
{ 1.0f, 1.0f, 1.0f, 1.0f },
"Compiling shaders...");
}
return { position.x, position.y + 24.0f };
}
HudElements HudStats::filterElements(HudElements elements) {
return elements & HudElements(
HudElement::StatDrawCalls,
HudElement::StatSubmissions,
HudElement::StatPipelines,
HudElement::StatMemory,
HudElement::StatGpuLoad,
HudElement::CompilerActivity);
}
}

78
src/dxvk/hud/dxvk_hud_stats.h
View File

@ -1,78 +0,0 @@
#pragma once
#include "../util/util_time.h"
#include "../dxvk_stats.h"
#include "dxvk_hud_config.h"
#include "dxvk_hud_renderer.h"
namespace dxvk::hud {
/**
* \brief Statistics display for the HUD
*
* Displays some stat counters for the device
* if enabled. Certain groups of counters can
* be enabled inidividually.
*/
class HudStats {
public:
HudStats(HudElements elements);
~HudStats();
void update(
const Rc<DxvkDevice>& device);
HudPos render(
HudRenderer& renderer,
HudPos position);
private:
const HudElements m_elements;
DxvkStatCounters m_prevCounters;
DxvkStatCounters m_diffCounters;
dxvk::high_resolution_clock::time_point m_gpuLoadUpdateTime;
dxvk::high_resolution_clock::time_point m_compilerShowTime;
uint64_t m_prevGpuIdleTicks = 0;
uint64_t m_diffGpuIdleTicks = 0;
std::string m_gpuLoadString = "GPU: ";
void updateGpuLoad();
HudPos printDrawCallStats(
HudRenderer& renderer,
HudPos position);
HudPos printSubmissionStats(
HudRenderer& renderer,
HudPos position);
HudPos printPipelineStats(
HudRenderer& renderer,
HudPos position);
HudPos printMemoryStats(
HudRenderer& renderer,
HudPos position);
HudPos printGpuLoad(
HudRenderer& renderer,
HudPos position);
HudPos printCompilerActivity(
HudRenderer& renderer,
HudPos position);
static HudElements filterElements(HudElements elements);
};
}

4
src/dxvk/meson.build
View File

@ -102,13 +102,9 @@ dxvk_src = files([
'platform/dxvk_win32_exts.cpp',
'hud/dxvk_hud.cpp',
'hud/dxvk_hud_config.cpp',
'hud/dxvk_hud_devinfo.cpp',
'hud/dxvk_hud_font.cpp',
'hud/dxvk_hud_fps.cpp',
'hud/dxvk_hud_item.cpp',
'hud/dxvk_hud_renderer.cpp',
'hud/dxvk_hud_stats.cpp',
])
thread_dep = dependency('threads')