lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-05-04 17:10:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
f0aecfbfa386d838e1cf7ff2ed9f17551a5cfc08
renderdoc/qrenderdoc/Code/qrenderdoc.cpp
T

750 lines
20 KiB
C++
Raw Blame History

/******************************************************************************
* The MIT License (MIT)
*
* Copyright (c) 2019-2024 Baldur Karlsson
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
******************************************************************************/
#include <stdio.h>
#include <QApplication>
#include <QCommandLineParser>
#include <QDir>
#include <QFileInfo>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QStandardPaths>
#include <QSysInfo>
#include "Code/CaptureContext.h"
#include "Code/QRDUtils.h"
#include "Code/Resources.h"
#include "Code/pyrenderdoc/PythonContext.h"
#include "Windows/Dialogs/CrashDialog.h"
#include "Windows/MainWindow.h"
#include "version.h"
#if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)
#include <QOperatingSystemVersion>
QString getOSVersion()
{
QOperatingSystemVersion ver = QOperatingSystemVersion::current();
if(ver.type() == QOperatingSystemVersion::Windows && ver.majorVersion() >= 10)
{
int major = ver.majorVersion();
int build = ver.microVersion();
if(build >= 22000)
major = 11;
return QFormatStr("Windows %1 Build num %2").arg(major).arg(build);
}
return QSysInfo::prettyProductName();
}
#else
QString getOSVersion()
{
return QSysInfo::prettyProductName();
}
#endif
#if ENABLE_UNIT_TESTS
#define CATCH_CONFIG_RUNNER
#define CATCH_CONFIG_NOSTDOUT
#include "3rdparty/catch/catch.hpp"
// since we force use of ToStr for everything and don't allow using catch's stringstream (so that
// enums get forwarded to ToStr) we need to implement ToStr for one of Catch's structs.
template <>
rdcstr DoStringise(const Catch::SourceLineInfo &el)
{
return QFormatStr("%1:%2").arg(QString::fromUtf8(el.file)).arg(el.line);
}
class LogOutputter : public std::stringbuf
{
FILE *file;
public:
LogOutputter(FILE *f) : file(f) {}
void finish()
{
std::string msg = this->str();
RENDERDOC_LogMessage(LogType::Comment, "EXTN", __FILE__, __LINE__, msg.c_str());
fputs(msg.c_str(), file);
}
virtual int sync() override
{
rdcstr str = this->str().c_str();
int idx = str.indexOf('\n');
if(idx >= 0)
{
rdcstr msg = str.substr(0, idx + 1);
RENDERDOC_LogMessage(LogType::Comment, "EXTN", __FILE__, __LINE__, msg);
fputs(msg.c_str(), file);
str = str.substr(idx + 1);
this->str("");
this->sputn(str.c_str(), str.size());
}
return 0;
}
// force a sync on every output
virtual std::streamsize xsputn(const char *s, std::streamsize n) override
{
std::streamsize ret = std::stringbuf::xsputn(s, n);
sync();
return ret;
}
};
std::ostream *catch_stream = NULL;
namespace Catch
{
std::ostream &cout()
{
return *catch_stream;
}
std::ostream &cerr()
{
return *catch_stream;
}
std::ostream &clog()
{
return *catch_stream;
}
}
#endif
#if defined(Q_OS_WIN32)
extern "C" {
_declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
_declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
}
#endif
REPLAY_PROGRAM_MARKER()
void sharedLogOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
LogType logtype = LogType::Comment;
switch(type)
{
case QtDebugMsg: logtype = LogType::Debug; break;
case QtInfoMsg: logtype = LogType::Comment; break;
case QtWarningMsg: logtype = LogType::Warning; break;
case QtCriticalMsg: logtype = LogType::Error; break;
case QtFatalMsg: logtype = LogType::Fatal; break;
}
RENDERDOC_LogMessage(logtype, "QTRD", context.file ? context.file : rdcstr(), context.line, msg);
}
static QString tr(const char *string)
{
return QApplication::translate("qrenderdoc", string);
}
void hideOption(QCommandLineOption &opt)
{
#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
opt.setFlags(QCommandLineOption::HiddenFromHelp);
#else
opt.setHidden(true);
#endif
}
int main(int argc, char *argv[])
{
// call this as the very first thing - no-op on other platforms, but on linux it means
// XInitThreads will be called allowing driver access to xlib on multiple threads.
QCoreApplication::setAttribute(Qt::AA_X11InitThreads);
qInstallMessageHandler(sharedLogOutput);
// there seems to be a persistent crash in QWidgetPrivate::subtractOpaqueSiblings where a widget
// has no parent but is not a window. Try to work around it by setting this env var, as it's only
// an optimisation
qputenv("QT_NO_SUBTRACTOPAQUESIBLINGS", lit("1").toUtf8());
qInfo() << "QRenderDoc initialising.";
if(IsRunningAsAdmin())
qInfo() << "Running as administrator";
#if defined(RENDERDOC_PLATFORM_LINUX) && !defined(RENDERDOC_WINDOWING_WAYLAND)
bool envChanged = false;
{
const char *qpa_plat = getenv("QT_QPA_PLATFORM");
// if not set or empty, force non-wayland to help go through backwards compatibility path on wayland.
char env_set[] = "QT_QPA_PLATFORM=xcb\0";
if(!qpa_plat || qpa_plat[0] == 0)
{
putenv(env_set);
envChanged = true;
}
}
#endif
QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QGuiApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
#if(QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
QGuiApplication::setHighDpiScaleFactorRoundingPolicy(
Qt::HighDpiScaleFactorRoundingPolicy::RoundPreferFloor);
#endif
QApplication::setApplicationVersion(lit(FULL_VERSION_STRING));
// shortcut here so we can run this with a non-GUI application
#if ENABLE_UNIT_TESTS
if(QString::fromUtf8(argv[1]) == lit("--unittest"))
{
char **mod_argv = new char *[argc + 1];
char **alloc_argv = mod_argv;
for(int i = 0; i < argc; i++)
mod_argv[i] = argv[i];
mod_argv[argc] = 0;
// pop --unittest
argc--;
mod_argv++;
FILE *test_logOut = NULL;
if(argc >= 2 && QString::fromUtf8(mod_argv[1]).left(4) == lit("log="))
{
test_logOut = fopen(mod_argv[1] + 4, "w");
// pop
argc--;
mod_argv++;
}
mod_argv[0] = argv[0];
if(test_logOut == NULL)
test_logOut = stdout;
LogOutputter logbuf(test_logOut);
std::ostream logstream(&logbuf);
int ret = 0;
// catch tests first
{
catch_stream = &logstream;
Catch::Session session;
session.configData().name = "QRenderDoc";
session.configData().shouldDebugBreak = Catch::isDebuggerActive();
ret = session.applyCommandLine(argc, mod_argv);
if(ret == 0)
{
int numFailed = session.run();
// Note that on unices only the lower 8 bits are usually used, clamping
// the return value to 255 prevents false negative when some multiple
// of 256 tests has failed
if(numFailed != 0)
ret = (numFailed < 0xff ? numFailed : 0xff);
}
}
{
QCoreApplication application(argc, mod_argv);
PythonContext::GlobalInit();
logstream << "Checking python binding consistency.\n";
rdcstr errorLog;
bool errors = false;
{
PythonContextHandle py;
errors = py.ctx().CheckInterfaces(errorLog);
}
if(errors)
{
logstream << errorLog;
qCritical() << "Found errors in python bindings. Please fix!\n";
ret = 1;
}
else
{
logstream << "Python bindings are consistent.\n";
}
}
logbuf.finish();
delete[] alloc_argv;
fclose(test_logOut);
return ret;
}
#endif
QApplication application(argc, argv);
QCommandLineParser parser;
parser.setApplicationDescription(tr("Qt UI for RenderDoc"));
QCommandLineOption helpOption = parser.addHelpOption();
QCommandLineOption versionOption = parser.addVersionOption();
QCommandLineOption tempfile(
lit("tempfile"), tr("The filename to be opened is a temporary file owned by this instance."));
parser.addOption(tempfile);
QCommandLineOption targetcontrol({lit("targetcontrol"), lit("remoteaccess")},
tr("A target control connection to open on startup."),
lit("host:port"));
parser.addOption(targetcontrol);
QCommandLineOption replayhost(lit("replayhost"), tr("The replay host to connect to on startup."),
lit("host"));
parser.addOption(replayhost);
QCommandLineOption python({lit("python"), lit("script"), lit("py")},
tr("Run a python script before opening the main UI."),
lit("filename.py"));
parser.addOption(python);
QCommandLineOption uiscript({lit("ui-python"), lit("ui-script"), lit("ui-py")},
tr("Run a python script after opening the main UI."),
lit("filename.py"));
parser.addOption(uiscript);
// secret non-described options
QCommandLineOption installLayer(lit("install_vulkan_layer"), QString(), lit("root_or_not"));
hideOption(installLayer);
parser.addOption(installLayer);
QCommandLineOption updateFailed(lit("updatefailed"), QString(), lit("errormsg"));
hideOption(updateFailed);
parser.addOption(updateFailed);
QCommandLineOption updateDone(lit("updatedone"));
hideOption(updateDone);
parser.addOption(updateDone);
QCommandLineOption crashReport(lit("crash"), QString(), lit("reportpath"));
hideOption(crashReport);
parser.addOption(crashReport);
parser.addPositionalArgument(lit("filename"), tr("The file to open."));
bool parsedCommands = parser.parse(application.arguments());
if(!parsedCommands)
qCritical() << parser.errorText();
if(parser.isSet(helpOption))
{
parser.showHelp();
return 0;
}
if(parser.isSet(versionOption))
{
printf("QRenderDoc v%s (%s)\n", MAJOR_MINOR_VERSION_STRING, RENDERDOC_GetCommitHash());
#if defined(DISTRIBUTION_VERSION)
printf("Packaged for %s - %s\n", DISTRIBUTION_NAME, DISTRIBUTION_CONTACT);
#endif
return 0;
}
if(parser.isSet(installLayer))
{
qInfo() << "Updating Vulkan layer registration";
if(parser.value(installLayer) == lit("root"))
RENDERDOC_UpdateVulkanLayerRegistration(true);
else
RENDERDOC_UpdateVulkanLayerRegistration(false);
return 0;
}
bool temp = parser.isSet(tempfile);
bool updateApplied = false;
if(parser.isSet(updateFailed))
{
RDDialog::critical(NULL, tr("Error updating"),
tr("Error applying update: %1").arg(parser.value(updateFailed)));
}
if(parser.isSet(updateDone))
{
updateApplied = true;
RENDERDOC_UpdateInstalledVersionNumber();
}
QString remoteHost;
uint remoteIdent = 0;
if(parser.isSet(targetcontrol))
{
QRegularExpression regexp(lit("^([a-zA-Z\\.0-9_-]+)?(:([0-9]+))?$"));
QRegularExpressionMatch match = regexp.match(parser.value(targetcontrol));
if(!match.hasMatch())
{
qCritical() << "--targetcontrol option must be followed by host:port or host";
return 1;
}
QString host = match.captured(1);
bool ok = false;
uint32_t ident = 0;
if(match.capturedLength(2) > 0)
{
ident = match.captured(3).toUInt(&ok);
}
else
{
// no port specified, find the first open port.
ident = RENDERDOC_EnumerateRemoteTargets(host, ident);
ok = (ident != 0);
}
if(!ok)
{
if(match.capturedLength(2) > 0)
{
qCritical() << "--targetcontrol port " << match.captured(3) << "malformed";
}
else
{
qCritical() << "All ports are busy, cannot find an available port";
}
return 1;
}
remoteHost = host;
remoteIdent = ident;
}
QString crashReportPath;
if(parser.isSet(crashReport))
crashReportPath = parser.value(crashReport);
QString uiscriptFile;
if(parser.isSet(uiscript))
uiscriptFile = parser.value(uiscript);
QStringList pyscripts = parser.values(python);
// load the first filename in the positional arguments.
QStringList remaining = parser.positionalArguments();
QString filename;
for(int i = 0; i < remaining.count(); i++)
{
const QString &fn = remaining[i];
QFileInfo checkFile(fn);
if(checkFile.exists() && checkFile.isFile())
{
filename = fn;
remaining.removeAt(i);
break;
}
}
RegisterMetatypeConversions();
{
PersistantConfig config;
{
QString configPath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
QDir dir(configPath);
if(!dir.exists())
dir.mkpath(configPath);
}
QString configFilename = ConfigFilePath(lit("UI.config"));
if(!config.Load(configFilename))
{
RDDialog::critical(
NULL, CaptureContext::tr("Error loading config"),
CaptureContext::tr(
"Error loading config file\n%1\nA default config is loaded and will be saved out.")
.arg(configFilename));
}
int replayHostIndex = -1;
if(parser.isSet(replayhost))
{
rdcstr replayHost = parser.value(replayhost);
rdcarray<RemoteHost> hosts = config.GetRemoteHosts();
for(int i = 0; i < hosts.count(); i++)
{
if(hosts[i].Hostname() == replayHost)
{
replayHostIndex = i;
break;
}
}
if(replayHostIndex < 0)
{
RDDialog::critical(
NULL, tr("Error loading remote host"),
tr("Remote host %1 doesn't exist. Please add it in Remote Host Manager first.")
.arg(parser.value(replayhost)));
}
}
if(config.Analytics_TotalOptOut)
Analytics::Disable();
else
Analytics::Load();
bool isDarkTheme = IsDarkTheme();
bool styleSet = config.SetStyle();
// unrecognised style, or empty (none set), choose a default
if(!styleSet)
{
config.UIStyle = isDarkTheme ? lit("RDDark") : lit("RDLight");
config.SetStyle();
}
config.SetupFormatting();
Resources::Initialise();
GUIInvoke::init();
{
QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
#if defined(Q_OS_WIN32)
QString fn = homePath + lit("/AppData/Local/LunarG/vkconfig/override/");
#else
QString fn = homePath + lit("/.local/share/vulkan/implicit_layer.d/");
#endif
// documentation is unclear, mentions both these files so check both just in case
QFileInfo vkconfigcheck1(fn + lit("VkLayerOverride.json"));
QFileInfo vkconfigcheck2(fn + lit("VkLayer_Override.json"));
if((vkconfigcheck1.exists() && vkconfigcheck1.isFile()) ||
(vkconfigcheck2.exists() && vkconfigcheck2.isFile()))
{
RDDialog::warning(
NULL, tr("vkconfig detected - possible incompatibility"),
tr("Configuration from 'vkconfig' tool detected.\n\n"
"This program has caused problems in the past and it is \n"
"strongly recommended that you disable it while using RenderDoc.\n\n"
"If this program is not active check the path below for any leftover files:\n\n%1")
.arg(fn));
qInfo() << "vkconfig detected and warned";
}
}
{
GlobalEnvironment env;
#if defined(RENDERDOC_PLATFORM_LINUX)
env.xlibDisplay = QX11Info::display();
if(QGuiApplication::platformName() == lit("wayland"))
{
env.waylandDisplay = (wl_display *)AccessWaylandPlatformInterface("display", NULL);
QString warning =
tr("Running directly on Wayland is NOT SUPPORTED and is likely to crash, hang, or "
"fail to render.");
qInfo() << "------ !!!! WARNING !!!! ------";
qInfo() << warning;
qInfo() << "------ !!!! WARNING !!!! ------";
RDDialog::critical(NULL, tr("Wayland Qt platform not supported"), warning);
}
#endif
rdcarray<rdcstr> coreargs;
if(!crashReportPath.isEmpty())
coreargs.push_back("--crash");
for(const QString &arg : remaining)
coreargs.push_back(arg);
// don't enumerate GPUs when reporting a crash, in case enumerating GPUs *causes* the crash.
if(!crashReportPath.isEmpty())
env.enumerateGPUs = false;
RENDERDOC_InitialiseReplay(env, coreargs);
}
#if defined(RENDERDOC_PLATFORM_LINUX) && !defined(RENDERDOC_WINDOWING_WAYLAND)
if(envChanged)
unsetenv("QT_QPA_PLATFORM");
#endif
if(!crashReportPath.isEmpty())
{
QVariantMap json;
{
QFile f(crashReportPath);
if(f.exists() && f.open(QIODevice::ReadOnly | QIODevice::Text))
json = JSONToVariant(QString::fromUtf8(f.readAll()));
}
if(json.contains(lit("report")))
{
CrashDialog dialog(config, json);
RDDialog::show(&dialog);
}
}
else
{
PythonContext::GlobalInit();
if(updateApplied)
{
config.CheckUpdate_UpdateAvailable = false;
config.CheckUpdate_UpdateResponse = "";
config.Save();
}
CaptureContext ctx(config);
if(replayHostIndex >= 0)
{
ctx.SetRemoteHost(replayHostIndex);
}
Analytics::Prompt(ctx, config);
ANALYTIC_SET(Metadata.RenderDocVersion, lit(FULL_VERSION_STRING));
#if defined(DISTRIBUTION_VERSION)
ANALYTIC_SET(Metadata.DistributionVersion, lit(DISTRIBUTION_NAME));
#endif
ANALYTIC_SET(Metadata.Bitness, ((sizeof(void *) == sizeof(uint64_t)) ? 64 : 32));
ANALYTIC_SET(Metadata.OSVersion, getOSVersion());
#if RENDERDOC_STABLE_BUILD
ANALYTIC_SET(Metadata.OfficialBuildRun, true);
#else
ANALYTIC_SET(Metadata.DevelBuildRun, true);
#endif
ANALYTIC_SET(Metadata.DaysUsed[QDateTime::currentDateTime().date().day()], true);
bool pythonExited = false;
if(!pyscripts.isEmpty())
{
PythonContextHandle py;
ANALYTIC_SET(UIFeatures.PythonInterop, true);
py.ctx().setGlobal("pyrenderdoc", (ICaptureContext *)&ctx);
QObject::connect(
&py.ctx(), &PythonContext::exception,
[&pythonExited](const QString &type, const QString &value, int, QList<QString> frames) {
if(type == lit("SystemExit"))
{
pythonExited = true;
return;
}
QString exString;
if(!frames.isEmpty())
{
exString += tr("Traceback (most recent call last):\n");
for(const QString &f : frames)
exString += QFormatStr(" %1\n").arg(f);
}
exString += QFormatStr("%1: %2\n").arg(type).arg(value);
qCritical("%s", exString.toUtf8().data());
});
QObject::connect(&py.ctx(), &PythonContext::textOutput,
[](bool isStdError, const QString &output) {
if(isStdError)
qCritical("%s", output.toUtf8().data());
else
qInfo("%s", output.toUtf8().data());
});
for(const QString &f : pyscripts)
{
QFileInfo checkFile(f);
if(checkFile.exists() && checkFile.isFile())
{
qInfo() << "running" << f;
py.ctx().executeFile(f);
}
else
{
qWarning() << "Invalid python script" << f;
}
if(pythonExited)
break;
}
}
if(!pythonExited)
{
ctx.Begin(filename, remoteHost, remoteIdent, temp, uiscriptFile);
while(ctx.isRunning())
{
application.processEvents(QEventLoop::WaitForMoreEvents);
QCoreApplication::sendPostedEvents();
QCoreApplication::sendPostedEvents(NULL, QEvent::DeferredDelete);
}
}
config.Save();
}
RENDERDOC_ShutdownReplay();
PythonContext::GlobalShutdown();
Formatter::shutdown();
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink