lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-08-18 12:36:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename ReplayRenderer to ReplayController

Browse Source 
* It's not a renderer, it's an interface to controlling the replay and
  any 'renderer' type work actually happens in ReplayOutput.
This commit is contained in:
baldurk
2017-04-18 14:57:47 +01:00
parent a7ab0d9300
commit 6930841705
35 changed files with 215 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/python_api/enums_data.rst
+1 -1
View File
@@ -5,4 +5,4 @@ Enums and Data Structures
:members:
:undoc-members:
:imported-members:
:exclude-members: free_functions__, enum_constants__, name_match__startswith__D3D11_, name_match__startswith__D3D12_, name_match__startswith__VK_, name_match__startswith__GL_, str, ReplayRenderer, ReplayOutput, TargetControl, RemoteServer, CaptureFile
:exclude-members: free_functions__, enum_constants__, name_match__startswith__D3D11_, name_match__startswith__D3D12_, name_match__startswith__VK_, name_match__startswith__GL_, str, ReplayController, ReplayOutput, TargetControl, RemoteServer, CaptureFile
docs/python_api/main_ifaces.rst
+3 -3
View File
@@ -5,10 +5,10 @@ Primary Interfaces
.. module:: renderdoc
ReplayRenderer
--------------
ReplayController
----------------
.. autoclass:: renderdoc.ReplayRenderer
.. autoclass:: renderdoc.ReplayController
:members:
:undoc-members:
qrenderdoc/Code/CaptureContext.cpp
+2 -2
View File
@@ -200,7 +200,7 @@ void CaptureContext::LoadLogfileThreaded(const QString &logFile, const QString &
m_EventID = 0;
// fetch initial data like drawcalls, textures and buffers
m_Renderer.BlockInvoke([this](IReplayRenderer *r) {
m_Renderer.BlockInvoke([this](IReplayController *r) {
m_FrameInfo = r->GetFrameInfo();
m_APIProps = r->GetAPIProperties();
@@ -553,7 +553,7 @@ void CaptureContext::SetEventID(const QVector<ILogViewerForm *> &exclude, uint32
uint32_t prevEventID = m_EventID;
m_EventID = eventID;
m_Renderer.BlockInvoke([this, eventID, force](IReplayRenderer *r) {
m_Renderer.BlockInvoke([this, eventID, force](IReplayController *r) {
r->SetFrameEvent(eventID, force);
m_CurD3D11PipelineState = r->GetD3D11PipelineState();
m_CurD3D12PipelineState = r->GetD3D12PipelineState();
qrenderdoc/Code/Interface/QRDInterface.h
+1 -1
View File
@@ -258,7 +258,7 @@ DECLARE_REFLECTION_STRUCT(ILogViewerForm);
struct IRenderManager
{
typedef std::function<void(IReplayRenderer *)> InvokeMethod;
typedef std::function<void(IReplayController *)> InvokeMethod;
typedef std::function<void(const rdctype::str &, const rdctype::array<PathEntry> &)> DirectoryBrowseMethod;
virtual void DeleteCapture(const QString &logfile, bool local) = 0;
qrenderdoc/Code/RenderManager.cpp
+6 -6
View File
@@ -63,7 +63,7 @@ void RenderManager::DeleteCapture(const QString &logfile, bool local)
{
if(IsRunning())
{
AsyncInvoke([this, logfile, local](IReplayRenderer *) { DeleteCapture(logfile, local); });
AsyncInvoke([this, logfile, local](IReplayController *) { DeleteCapture(logfile, local); });
return;
}
@@ -106,7 +106,7 @@ void RenderManager::GetHomeFolder(bool synchronous, DirectoryBrowseMethod cb)
if(IsRunning() && m_Thread->isCurrentThread())
{
auto lambda = [cb, this](IReplayRenderer *r) {
auto lambda = [cb, this](IReplayController *r) {
cb(m_Remote->GetHomeFolder().c_str(), rdctype::array<PathEntry>());
};
@@ -136,7 +136,7 @@ bool RenderManager::ListFolder(QString path, bool synchronous, DirectoryBrowseMe
if(IsRunning() && m_Thread->isCurrentThread())
{
auto lambda = [cb, pathUTF8, this](IReplayRenderer *r) {
auto lambda = [cb, pathUTF8, this](IReplayController *r) {
cb(pathUTF8.data(), m_Remote->ListFolder(pathUTF8.data()));
};
@@ -170,7 +170,7 @@ QString RenderManager::CopyCaptureToRemote(const QString &localpath, QWidget *wi
bool copied = false;
float progress = 0.0f;
auto lambda = [this, localpath, &remotepath, &progress, &copied](IReplayRenderer *r) {
auto lambda = [this, localpath, &remotepath, &progress, &copied](IReplayController *r) {
QMutexLocker autolock(&m_RemoteLock);
remotepath = m_Remote->CopyCaptureToRemote(localpath.toUtf8().data(), &progress);
copied = true;
@@ -203,7 +203,7 @@ void RenderManager::CopyCaptureFromRemote(const QString &remotepath, const QStri
bool copied = false;
float progress = 0.0f;
auto lambda = [this, localpath, remotepath, &progress, &copied](IReplayRenderer *r) {
auto lambda = [this, localpath, remotepath, &progress, &copied](IReplayController *r) {
QMutexLocker autolock(&m_RemoteLock);
m_Remote->CopyCaptureFromRemote(remotepath.toUtf8().data(), localpath.toUtf8().data(), &progress);
copied = true;
@@ -393,7 +393,7 @@ void RenderManager::PushInvoke(RenderManager::InvokeHandle *cmd)
void RenderManager::run()
{
IReplayRenderer *renderer = NULL;
IReplayController *renderer = NULL;
if(m_Remote)
{
qrenderdoc/Code/RenderManager.h
+2 -2
View File
@@ -36,13 +36,13 @@
#include "QRDUtils.h"
#include "renderdoc_replay.h"
struct IReplayRenderer;
struct IReplayController;
class LambdaThread;
class RemoteHost;
// simple helper for the common case of 'we just need to run this on the render thread
#define INVOKE_MEMFN(function) \
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) { function(r); });
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) { function(r); });
class RenderManager : public IRenderManager
{
qrenderdoc/Widgets/CustomPaintWidget.cpp
+1 -1
View File
@@ -90,7 +90,7 @@ void CustomPaintWidget::paintEvent(QPaintEvent *e)
if(m_Ctx)
{
if(m_Output != NULL)
m_Ctx->Renderer().AsyncInvoke([this](IReplayRenderer *r) { m_Output->Display(); });
m_Ctx->Renderer().AsyncInvoke([this](IReplayController *r) { m_Output->Display(); });
}
else if(m_Dark == m_Light)
{
qrenderdoc/Windows/APIInspector.cpp
+1 -1
View File
@@ -97,7 +97,7 @@ void APIInspector::on_apiEvents_itemSelectionChanged()
if(ev.callstack.count > 0)
{
m_Ctx.Renderer().AsyncInvoke([this, ev](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, ev](IReplayController *r) {
rdctype::array<rdctype::str> trace = r->GetResolve(ev.callstack);
GUIInvoke::call([this, trace]() { addCallstack(trace); });
qrenderdoc/Windows/BufferViewer.cpp
+6 -6
View File
@@ -1149,7 +1149,7 @@ void BufferViewer::OnLogfileLoaded()
WId renderID = ui->render->winId();
m_Ctx.Renderer().BlockInvoke([renderID, this](IReplayRenderer *r) {
m_Ctx.Renderer().BlockInvoke([renderID, this](IReplayController *r) {
m_Output = r->CreateOutput(m_Ctx.CurWindowingSystem(), m_Ctx.FillWindowingData(renderID),
ReplayOutputType::Mesh);
@@ -1223,7 +1223,7 @@ void BufferViewer::OnEventChanged(uint32_t eventID)
guessSecondaryColumn(m_ModelGSOut);
}
m_Ctx.Renderer().AsyncInvoke([this, vsinHoriz, vsoutHoriz, gsoutHoriz](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, vsinHoriz, vsoutHoriz, gsoutHoriz](IReplayController *r) {
if(m_MeshView)
{
@@ -1291,7 +1291,7 @@ void BufferViewer::OnEventChanged(uint32_t eventID)
});
}
void BufferViewer::RT_FetchMeshData(IReplayRenderer *r)
void BufferViewer::RT_FetchMeshData(IReplayController *r)
{
const DrawcallDescription *draw = m_Ctx.CurDrawcall();
@@ -2189,7 +2189,7 @@ void BufferViewer::render_clicked(QMouseEvent *e)
if((e->buttons() & Qt::RightButton) && m_Output)
{
m_Ctx.Renderer().AsyncInvoke("PickVertex", [this, curpos](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke("PickVertex", [this, curpos](IReplayController *r) {
uint32_t instanceSelected = 0;
uint32_t vertSelected = 0;
@@ -2289,7 +2289,7 @@ void BufferViewer::render_timer()
INVOKE_MEMFN(RT_UpdateAndDisplay);
}
void BufferViewer::RT_UpdateAndDisplay(IReplayRenderer *)
void BufferViewer::RT_UpdateAndDisplay(IReplayController *)
{
if(m_Output)
{
@@ -2734,7 +2734,7 @@ void BufferViewer::debugVertex()
uint32_t index =
m_CurView->model()->data(m_CurView->model()->index(idx.row(), 1), Qt::DisplayRole).toUInt();
m_Ctx.Renderer().AsyncInvoke([this, vertid, index](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, vertid, index](IReplayController *r) {
ShaderDebugTrace *trace =
r->DebugVertex(vertid, m_Config.curInstance, index, m_Ctx.CurDrawcall()->instanceOffset,
m_Ctx.CurDrawcall()->vertexOffset);
qrenderdoc/Windows/BufferViewer.h
+2 -2
View File
@@ -122,8 +122,8 @@ private:
IReplayOutput *m_Output;
void RT_UpdateAndDisplay(IReplayRenderer *);
void RT_FetchMeshData(IReplayRenderer *r);
void RT_UpdateAndDisplay(IReplayController *);
void RT_FetchMeshData(IReplayController *r);
MeshDisplay m_Config;
qrenderdoc/Windows/ConstantBufferPreviewer.cpp
+2 -2
View File
@@ -110,7 +110,7 @@ void ConstantBufferPreviewer::OnEventChanged(uint32_t eventID)
if(!m_formatOverride.empty())
{
m_Ctx.Renderer().AsyncInvoke([this, offs, size](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, offs, size](IReplayController *r) {
rdctype::array<byte> data = r->GetBufferData(m_cbuffer, offs, size);
rdctype::array<ShaderVariable> vars = applyFormatOverride(data);
GUIInvoke::call([this, vars] { setVariables(vars); });
@@ -118,7 +118,7 @@ void ConstantBufferPreviewer::OnEventChanged(uint32_t eventID)
}
else
{
m_Ctx.Renderer().AsyncInvoke([this, entryPoint, offs](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, entryPoint, offs](IReplayController *r) {
rdctype::array<ShaderVariable> vars = r->GetCBufferVariableContents(
m_shader, entryPoint.toUtf8().data(), m_slot, m_cbuffer, offs);
GUIInvoke::call([this, vars] { setVariables(vars); });
qrenderdoc/Windows/EventBrowser.cpp
+1 -1
View File
@@ -261,7 +261,7 @@ void EventBrowser::on_bookmark_clicked()
void EventBrowser::on_timeDraws_clicked()
{
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) {
rdctype::array<CounterResult> results = r->FetchCounters({GPUCounter::EventGPUDuration});
qrenderdoc/Windows/MainWindow.cpp
+4 -4
View File
@@ -966,7 +966,7 @@ void MainWindow::messageCheck()
{
if(m_Ctx.LogLoaded())
{
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) {
rdctype::array<DebugMessage> msgs = r->GetDebugMessages();
bool disconnected = false;
@@ -1229,7 +1229,7 @@ void MainWindow::OnLogfileLoaded()
setLogHasErrors(!m_Ctx.DebugMessages().empty());
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) {
bool hasResolver = r->HasCallstacks();
GUIInvoke::call([this, hasResolver]() {
@@ -1401,12 +1401,12 @@ void MainWindow::on_action_Statistics_Viewer_triggered()
void MainWindow::on_action_Resolve_Symbols_triggered()
{
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) { r->InitResolver(); });
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) { r->InitResolver(); });
ShowProgressDialog(this, tr("Please Wait - Resolving Symbols"), [this]() {
bool running = true;
m_Ctx.Renderer().BlockInvoke(
[&running](IReplayRenderer *r) { running = r->HasCallstacks() && !r->InitResolver(); });
[&running](IReplayController *r) { running = r->HasCallstacks() && !r->InitResolver(); });
return !running;
});
qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp
+3 -3
View File
@@ -322,10 +322,10 @@ void PipelineStateViewer::EditShader(ShaderStage shaderType, ResourceId id,
if(updatedfiles.contains("@cmdline"))
compileSource = updatedfiles["@cmdline"] + "\n\n" + compileSource;
// invoke off to the ReplayRenderer to replace the log's shader
// invoke off to the ReplayController to replace the log's shader
// with our edited one
ctx->Renderer().AsyncInvoke([ctx, entryFunc, compileSource, shaderType, id, shaderDetails,
viewer](IReplayRenderer *r) {
viewer](IReplayController *r) {
rdctype::str errs;
uint flags = shaderDetails->DebugInfo.compileFlags;
@@ -354,7 +354,7 @@ void PipelineStateViewer::EditShader(ShaderStage shaderType, ResourceId id,
[id](ICaptureContext *ctx) {
// remove the replacement on close (we could make this more sophisticated if there
// was a place to control replaced resources/shaders).
ctx->Renderer().AsyncInvoke([ctx, id](IReplayRenderer *r) {
ctx->Renderer().AsyncInvoke([ctx, id](IReplayController *r) {
r->RemoveReplacement(id);
GUIInvoke::call([ctx] { ctx->RefreshStatus(); });
});
qrenderdoc/Windows/PixelHistoryView.cpp
+1 -1
View File
@@ -639,7 +639,7 @@ void PixelHistoryView::startDebug(EventTag tag)
bool success = false;
m_Ctx.Renderer().BlockInvoke([this, &success, &trace](IReplayRenderer *r) {
m_Ctx.Renderer().BlockInvoke([this, &success, &trace](IReplayController *r) {
trace = r->DebugPixel((uint32_t)m_Pixel.x(), (uint32_t)m_Pixel.y(), m_Display.sampleIdx, ~0U);
});
qrenderdoc/Windows/TextureViewer.cpp
+23 -23
View File
@@ -660,7 +660,7 @@ void TextureViewer::RT_FetchCurrentPixel(uint32_t x, uint32_t y, PixelValue &pic
m_TexDisplay.mip, m_TexDisplay.sampleIdx);
}
void TextureViewer::RT_PickPixelsAndUpdate(IReplayRenderer *)
void TextureViewer::RT_PickPixelsAndUpdate(IReplayController *)
{
PixelValue pickValue, realValue;
@@ -679,7 +679,7 @@ void TextureViewer::RT_PickPixelsAndUpdate(IReplayRenderer *)
GUIInvoke::call([this]() { UI_UpdateStatusText(); });
}
void TextureViewer::RT_PickHoverAndUpdate(IReplayRenderer *)
void TextureViewer::RT_PickHoverAndUpdate(IReplayController *)
{
PixelValue pickValue, realValue;
@@ -693,7 +693,7 @@ void TextureViewer::RT_PickHoverAndUpdate(IReplayRenderer *)
GUIInvoke::call([this]() { UI_UpdateStatusText(); });
}
void TextureViewer::RT_UpdateAndDisplay(IReplayRenderer *)
void TextureViewer::RT_UpdateAndDisplay(IReplayController *)
{
if(m_Output != NULL)
m_Output->SetTextureDisplay(m_TexDisplay);
@@ -701,7 +701,7 @@ void TextureViewer::RT_UpdateAndDisplay(IReplayRenderer *)
GUIInvoke::call([this]() { ui->render->update(); });
}
void TextureViewer::RT_UpdateVisualRange(IReplayRenderer *)
void TextureViewer::RT_UpdateVisualRange(IReplayController *)
{
TextureDescription *texptr = GetCurrentTexture();
@@ -895,7 +895,7 @@ void TextureViewer::UI_UpdateStatusText()
if(m_Output != NULL)
{
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *) { m_Output->DisablePixelContext(); });
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *) { m_Output->DisablePixelContext(); });
}
// PixelPicked = false;
@@ -1285,7 +1285,7 @@ void TextureViewer::UI_OnTextureSelectionChanged(bool newdraw)
if(ui->autoFit->isChecked())
AutoFitRange();
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) {
RT_UpdateVisualRange(r);
RT_UpdateAndDisplay(r);
@@ -1901,7 +1901,7 @@ void TextureViewer::InitResourcePreview(ResourcePreview *prev, ResourceId id, Co
prev->setResourceName(fullname);
WId handle = prev->thumbWinId();
m_Ctx.Renderer().AsyncInvoke([this, handle, id, typeHint](IReplayRenderer *) {
m_Ctx.Renderer().AsyncInvoke([this, handle, id, typeHint](IReplayController *) {
m_Output->AddThumbnail(m_Ctx.CurWindowingSystem(), m_Ctx.FillWindowingData(handle), id,
typeHint);
});
@@ -1920,7 +1920,7 @@ void TextureViewer::InitResourcePreview(ResourcePreview *prev, ResourceId id, Co
prev->setResourceName(fullname);
WId handle = prev->thumbWinId();
m_Ctx.Renderer().AsyncInvoke([this, handle](IReplayRenderer *) {
m_Ctx.Renderer().AsyncInvoke([this, handle](IReplayController *) {
m_Output->AddThumbnail(m_Ctx.CurWindowingSystem(), m_Ctx.FillWindowingData(handle),
ResourceId(), CompType::Typeless);
});
@@ -1929,7 +1929,7 @@ void TextureViewer::InitResourcePreview(ResourcePreview *prev, ResourceId id, Co
{
prev->setResourceName("");
WId handle = prev->thumbWinId();
m_Ctx.Renderer().AsyncInvoke([this, handle](IReplayRenderer *) {
m_Ctx.Renderer().AsyncInvoke([this, handle](IReplayController *) {
m_Output->AddThumbnail(m_Ctx.CurWindowingSystem(), m_Ctx.FillWindowingData(handle),
ResourceId(), CompType::Typeless);
});
@@ -1947,7 +1947,7 @@ void TextureViewer::InitResourcePreview(ResourcePreview *prev, ResourceId id, Co
prev->setSelected(true);
WId handle = prev->thumbWinId();
m_Ctx.Renderer().AsyncInvoke([this, handle](IReplayRenderer *) {
m_Ctx.Renderer().AsyncInvoke([this, handle](IReplayController *) {
m_Output->AddThumbnail(m_Ctx.CurWindowingSystem(), m_Ctx.FillWindowingData(handle),
ResourceId(), CompType::Typeless);
});
@@ -2123,7 +2123,7 @@ void TextureViewer::thumb_clicked(QMouseEvent *e)
}
else
{
m_Ctx.Renderer().AsyncInvoke([this, id](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, id](IReplayController *r) {
rdctype::array<EventUsage> usage = r->GetUsage(id);
GUIInvoke::call([this, id, usage]() { OpenResourceContextMenu(id, usage); });
@@ -2170,12 +2170,12 @@ void TextureViewer::render_mouseMove(QMouseEvent *e)
m_PickedPoint.setY(qBound(0, m_PickedPoint.y(), (int)texptr->height - 1));
m_Ctx.Renderer().AsyncInvoke("PickPixelClick",
[this](IReplayRenderer *r) { RT_PickPixelsAndUpdate(r); });
[this](IReplayController *r) { RT_PickPixelsAndUpdate(r); });
}
else if(e->buttons() == Qt::NoButton)
{
m_Ctx.Renderer().AsyncInvoke("PickPixelHover",
[this](IReplayRenderer *r) { RT_PickHoverAndUpdate(r); });
[this](IReplayController *r) { RT_PickHoverAndUpdate(r); });
}
}
}
@@ -2278,7 +2278,7 @@ void TextureViewer::render_keyPress(QKeyEvent *e)
qBound(0, m_PickedPoint.y(), (int)texptr->height - 1));
e->accept();
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) {
RT_PickPixelsAndUpdate(r);
RT_UpdateAndDisplay(r);
});
@@ -2470,7 +2470,7 @@ void TextureViewer::OnLogfileLoaded()
m_TexDisplay.lightBackgroundColor =
FloatVector(lightBack.redF(), lightBack.greenF(), lightBack.blueF(), 1.0f);
m_Ctx.Renderer().BlockInvoke([renderID, contextID, this](IReplayRenderer *r) {
m_Ctx.Renderer().BlockInvoke([renderID, contextID, this](IReplayController *r) {
m_Output = r->CreateOutput(m_Ctx.CurWindowingSystem(), m_Ctx.FillWindowingData(renderID),
ReplayOutputType::Texture);
@@ -2970,7 +2970,7 @@ void TextureViewer::AutoFitRange()
if(!m_Ctx.LogLoaded() || GetCurrentTexture() == NULL || m_Output == NULL)
return;
m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this](IReplayController *r) {
PixelValue min, max;
std::tie(min, max) = m_Output->GetMinMax();
@@ -3242,7 +3242,7 @@ void TextureViewer::on_saveTex_clicked()
{
ResourceId id;
m_Ctx.Renderer().BlockInvoke(
[this, &id](IReplayRenderer *r) { id = m_Output->GetCustomShaderTexID(); });
[this, &id](IReplayController *r) { id = m_Output->GetCustomShaderTexID(); });
if(id != ResourceId())
config.id = id;
@@ -3258,7 +3258,7 @@ void TextureViewer::on_saveTex_clicked()
bool ret = false;
QString fn = saveDialog.filename();
m_Ctx.Renderer().BlockInvoke([this, &ret, config, fn](IReplayRenderer *r) {
m_Ctx.Renderer().BlockInvoke([this, &ret, config, fn](IReplayController *r) {
ret = r->SaveTexture(config, fn.toUtf8().data());
});
@@ -3279,7 +3279,7 @@ void TextureViewer::on_debugPixelContext_clicked()
int x = m_PickedPoint.x() >> (int)m_TexDisplay.mip;
int y = m_PickedPoint.y() >> (int)m_TexDisplay.mip;
m_Ctx.Renderer().AsyncInvoke([this, x, y](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, x, y](IReplayController *r) {
ShaderDebugTrace *trace = r->DebugPixel((uint32_t)x, (uint32_t)y, m_TexDisplay.sampleIdx, ~0U);
if(trace->states.count == 0)
@@ -3326,7 +3326,7 @@ void TextureViewer::on_pixelHistory_clicked()
// render thread before we insert the long blocking pixel history task
LambdaThread *thread = new LambdaThread([this, texptr, x, y, hist]() {
QThread::msleep(150);
m_Ctx.Renderer().AsyncInvoke([this, texptr, x, y, hist](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, texptr, x, y, hist](IReplayController *r) {
rdctype::array<PixelModification> history =
r->PixelHistory(texptr->ID, (uint32_t)x, (int32_t)y, m_TexDisplay.sliceFace,
m_TexDisplay.mip, m_TexDisplay.sampleIdx, m_TexDisplay.typeHint);
@@ -3402,7 +3402,7 @@ void TextureViewer::reloadCustomShaders(const QString &filter)
QList<ResourceId> shaders = m_CustomShaders.values();
m_Ctx.Renderer().AsyncInvoke([shaders](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([shaders](IReplayController *r) {
for(ResourceId s : shaders)
r->FreeCustomShader(s);
});
@@ -3423,7 +3423,7 @@ void TextureViewer::reloadCustomShaders(const QString &filter)
return;
ResourceId freed = m_CustomShaders[key];
m_Ctx.Renderer().AsyncInvoke([freed](IReplayRenderer *r) { r->FreeCustomShader(freed); });
m_Ctx.Renderer().AsyncInvoke([freed](IReplayController *r) { r->FreeCustomShader(freed); });
m_CustomShaders.remove(key);
@@ -3469,7 +3469,7 @@ void TextureViewer::reloadCustomShaders(const QString &filter)
m_CustomShaders[key] = ResourceId();
m_CustomShadersBusy.push_back(key);
m_Ctx.Renderer().AsyncInvoke([this, fn, key, source](IReplayRenderer *r) {
m_Ctx.Renderer().AsyncInvoke([this, fn, key, source](IReplayController *r) {
rdctype::str errors;
ResourceId id;
qrenderdoc/Windows/TextureViewer.h
+4 -4
View File
@@ -204,10 +204,10 @@ private slots:
void channelsWidget_selected(int index) { UI_UpdateChannels(); }
private:
void RT_FetchCurrentPixel(uint32_t x, uint32_t y, PixelValue &pickValue, PixelValue &realValue);
void RT_PickPixelsAndUpdate(IReplayRenderer *);
void RT_PickHoverAndUpdate(IReplayRenderer *);
void RT_UpdateAndDisplay(IReplayRenderer *);
void RT_UpdateVisualRange(IReplayRenderer *);
void RT_PickPixelsAndUpdate(IReplayController *);
void RT_PickHoverAndUpdate(IReplayController *);
void RT_UpdateAndDisplay(IReplayController *);
void RT_UpdateVisualRange(IReplayController *);
void UI_RecreatePanels();
renderdoc/CMakeLists.txt
+2 -2
View File
@@ -117,8 +117,8 @@ set(sources
replay/entry_points.cpp
replay/replay_driver.h
replay/replay_output.cpp
replay/replay_renderer.cpp
replay/replay_renderer.h
replay/replay_controller.cpp
replay/replay_controller.h
replay/type_helpers.cpp
replay/type_helpers.h
serialise/grisu2.cpp
renderdoc/api/replay/control_types.h
+1 -1
View File
@@ -237,7 +237,7 @@ See :ref:`the FAQ entry <gamma-linear-display>`.
DOCUMENT(R"(The :class:`ResourceId` of a custom shader to use when rendering.
See :meth:`ReplayRenderer.BuildCustomShader` for creating an appropriate custom shader.
See :meth:`ReplayController.BuildCustomShader` for creating an appropriate custom shader.
)");
ResourceId CustomShader;
renderdoc/api/replay/renderdoc_replay.h
+19 -19
View File
@@ -379,14 +379,14 @@ protected:
~IReplayOutput() = default;
};
DOCUMENT(R"(The primary interface to access a capture's information and control the replay and
analysis functionality available.
DOCUMENT(R"(The primary interface to access the information in a capture and the current state, as
well as control the replay and analysis functionality available.
.. data:: NoPreference
No preference for a particular value, see :meth:`DebugPixel`.
)");
struct IReplayRenderer
struct IReplayController
{
DOCUMENT(R"(Retrieve a :class:`APIProperties` object describing the current capture.
@@ -762,11 +762,11 @@ sample 0, etc.
static const uint32_t NoPreference = ~0U;
protected:
IReplayRenderer() = default;
~IReplayRenderer() = default;
IReplayController() = default;
~IReplayController() = default;
};
DECLARE_REFLECTION_STRUCT(IReplayRenderer);
DECLARE_REFLECTION_STRUCT(IReplayController);
DOCUMENT(R"(A connection to a running application with RenderDoc injected, which allows limited
control over the capture process as well as querying the current status.
@@ -988,9 +988,9 @@ as possible will happen locally to save on bandwidth, processing and latency.
This function will block until the capture is fully opened on the remote system and ready for use,
or an error has occurred.
.. note:: You *must* close the resulting :class:`ReplayRenderer` with the :meth:`CloseCapture`
.. note:: You *must* close the resulting :class:`ReplayController` with the :meth:`CloseCapture`
function to ensure the local proxy is correctly tidied up, instead of using
:meth:`ReplayRenderer.Shutdown`.
:meth:`ReplayController.Shutdown`.
:param int proxyid: The index in the array returned by :meth:`LocalProxies` to use as a local proxy,
or :data:`NoPreference` to indicate no preference for any proxy.
@@ -999,18 +999,18 @@ or an error has occurred.
:param float progress: A reference to a ``float`` value that will be updated as the copy happens
from ``0.0`` to ``1.0``. The parameter can be ``None`` if no progress update is desired.
:return: A tuple containing the status of opening the capture, whether success or failure, and the
resulting :class:`ReplayRenderer` handle if successful.
:rtype: ``tuple`` of :class:`ReplayStatus` and :class:`ReplayRenderer`
resulting :class:`ReplayController` handle if successful.
:rtype: ``tuple`` of :class:`ReplayStatus` and :class:`ReplayController`
)");
virtual rdctype::pair<ReplayStatus, IReplayRenderer *> OpenCapture(uint32_t proxyid,
const char *logfile,
float *progress) = 0;
virtual rdctype::pair<ReplayStatus, IReplayController *> OpenCapture(uint32_t proxyid,
const char *logfile,
float *progress) = 0;
DOCUMENT(R"(Close a capture analysis handle previously opened by :meth:`OpenCapture`.
:param ReplayRenderer rend: The ReplayRenderer that is to be closed.
:param ReplayController rend: The ReplayController that is to be closed.
)");
virtual void CloseCapture(IReplayRenderer *rend) = 0;
virtual void CloseCapture(IReplayController *rend) = 0;
static const uint32_t NoPreference = ~0U;
@@ -1072,15 +1072,15 @@ This filename is exactly as specified without any modificaton to make it an abso
This function will block until the capture is fully loaded and ready.
Once the replay is created, this :class:`CaptureFile` can be shut down, there is no dependency on it
by the :class:`ReplayRenderer`.
by the :class:`ReplayController`.
:param float progress: A reference to a ``float`` value that will be updated as the copy happens
from ``0.0`` to ``1.0``. The parameter can be ``None`` if no progress update is desired.
:return: A tuple containing the status of opening the capture, whether success or failure, and the
resulting :class:`ReplayRenderer` handle if successful.
:rtype: ``tuple`` of :class:`ReplayStatus` and :class:`ReplayRenderer`.
resulting :class:`ReplayController` handle if successful.
:rtype: ``tuple`` of :class:`ReplayStatus` and :class:`ReplayController`.
)");
virtual rdctype::pair<ReplayStatus, IReplayRenderer *> OpenCapture(float *progress) = 0;
virtual rdctype::pair<ReplayStatus, IReplayController *> OpenCapture(float *progress) = 0;
DOCUMENT(R"(Retrieves the embedded thumbnail from the capture.
renderdoc/api/replay/replay_enums.h
+1 -1
View File
@@ -2781,7 +2781,7 @@ enum class LogicOp : uint32_t
DOCUMENT(R"(Pre-defined GPU counters that can be supported by a given implementation.
GPU counters actually available can be queried by :meth:`ReplayRenderer.EnumerateCounters`. If any
GPU counters actually available can be queried by :meth:`ReplayController.EnumerateCounters`. If any
in this list are supported they will be returned with these counter IDs. More counters may be
enumerated with IDs in the appropriate ranges.
renderdoc/core/remote_server.cpp
+9 -9
View File
@@ -28,7 +28,7 @@
#include "api/replay/renderdoc_replay.h"
#include "core/core.h"
#include "os/os_specific.h"
#include "replay/replay_renderer.h"
#include "replay/replay_controller.h"
#include "serialise/serialiser.h"
#include "serialise/string_utils.h"
#include "replay_proxy.h"
@@ -986,10 +986,10 @@ public:
Send(eRemoteServer_TakeOwnershipCapture, sendData);
}
rdctype::pair<ReplayStatus, IReplayRenderer *> OpenCapture(uint32_t proxyid, const char *filename,
float *progress)
rdctype::pair<ReplayStatus, IReplayController *> OpenCapture(uint32_t proxyid,
const char *filename, float *progress)
{
rdctype::pair<ReplayStatus, IReplayRenderer *> ret;
rdctype::pair<ReplayStatus, IReplayController *> ret;
ret.first = ReplayStatus::InternalError;
ret.second = NULL;
@@ -1062,7 +1062,7 @@ public:
return ret;
}
ReplayRenderer *rend = new ReplayRenderer();
ReplayController *rend = new ReplayController();
ReplayProxy *proxy = new ReplayProxy(m_Socket, proxyDriver);
status = rend->SetDevice(proxy);
@@ -1074,7 +1074,7 @@ public:
return ret;
}
// ReplayRenderer takes ownership of the ProxySerialiser (as IReplayDriver)
// ReplayController takes ownership of the ProxySerialiser (as IReplayDriver)
// and it cleans itself up in Shutdown.
ret.first = ReplayStatus::Succeeded;
@@ -1082,7 +1082,7 @@ public:
return ret;
}
void CloseCapture(IReplayRenderer *rend)
void CloseCapture(IReplayController *rend)
{
Serialiser sendData("", Serialiser::WRITING, false);
Send(eRemoteServer_CloseLog, sendData);
@@ -1193,7 +1193,7 @@ extern "C" RENDERDOC_API ReplayStatus RENDERDOC_CC RemoteServer_OpenCapture(IRem
uint32_t proxyid,
const char *logfile,
float *progress,
IReplayRenderer **rend)
IReplayController **rend)
{
auto ret = remote->OpenCapture(proxyid, logfile, progress);
if(rend)
@@ -1202,7 +1202,7 @@ extern "C" RENDERDOC_API ReplayStatus RENDERDOC_CC RemoteServer_OpenCapture(IRem
}
extern "C" RENDERDOC_API void RENDERDOC_CC RemoteServer_CloseCapture(IRemoteServer *remote,
IReplayRenderer *rend)
IReplayController *rend)
{
return remote->CloseCapture(rend);
}
renderdoc/renderdoc.vcxproj
+2 -2
View File
@@ -287,7 +287,7 @@
<ClInclude Include="os\win32\win32_hook.h" />
<ClInclude Include="os\win32\win32_specific.h" />
<ClInclude Include="replay\replay_driver.h" />
<ClInclude Include="replay\replay_renderer.h" />
<ClInclude Include="replay\replay_controller.h" />
<ClInclude Include="replay\type_helpers.h" />
<ClInclude Include="serialise\serialiser.h" />
<ClInclude Include="serialise\string_utils.h" />
@@ -389,7 +389,7 @@
<ClCompile Include="replay\capture_options.cpp" />
<ClCompile Include="replay\entry_points.cpp" />
<ClCompile Include="replay\replay_output.cpp" />
<ClCompile Include="replay\replay_renderer.cpp" />
<ClCompile Include="replay\replay_controller.cpp" />
<ClCompile Include="replay\type_helpers.cpp" />
<ClCompile Include="serialise\grisu2.cpp" />
<ClCompile Include="serialise\serialiser.cpp" />
renderdoc/renderdoc.vcxproj.filters
+2 -2
View File
@@ -147,7 +147,7 @@
<ClInclude Include="replay\replay_driver.h">
<Filter>Replay</Filter>
</ClInclude>
<ClInclude Include="replay\replay_renderer.h">
<ClInclude Include="replay\replay_controller.h">
<Filter>Replay</Filter>
</ClInclude>
<ClInclude Include="core\core.h">
@@ -326,7 +326,7 @@
<ClCompile Include="replay\replay_output.cpp">
<Filter>Replay</Filter>
</ClCompile>
<ClCompile Include="replay\replay_renderer.cpp">
<ClCompile Include="replay\replay_controller.cpp">
<Filter>Replay</Filter>
</ClCompile>
<ClCompile Include="core\core.cpp">
renderdoc/replay/capture_file.cpp
+6 -6
View File
@@ -26,7 +26,7 @@
#include "core/core.h"
#include "jpeg-compressor/jpgd.h"
#include "jpeg-compressor/jpge.h"
#include "replay/replay_renderer.h"
#include "replay/replay_controller.h"
#include "serialise/serialiser.h"
#include "stb/stb_image_resize.h"
#include "stb/stb_image_write.h"
@@ -50,7 +50,7 @@ public:
ReplaySupport LocalReplaySupport() { return m_Support; }
const char *DriverName() { return m_DriverName.c_str(); }
const char *RecordedMachineIdent() { return m_Ident.c_str(); }
rdctype::pair<ReplayStatus, IReplayRenderer *> OpenCapture(float *progress);
rdctype::pair<ReplayStatus, IReplayController *> OpenCapture(float *progress);
rdctype::array<byte> GetThumbnail(FileType type, uint32_t maxsize);
@@ -92,12 +92,12 @@ CaptureFile::CaptureFile(const char *f)
}
}
rdctype::pair<ReplayStatus, IReplayRenderer *> CaptureFile::OpenCapture(float *progress)
rdctype::pair<ReplayStatus, IReplayController *> CaptureFile::OpenCapture(float *progress)
{
if(m_Status != ReplayStatus::Succeeded)
return rdctype::make_pair<ReplayStatus, IReplayRenderer *>(m_Status, NULL);
return rdctype::make_pair<ReplayStatus, IReplayController *>(m_Status, NULL);
ReplayRenderer *render = new ReplayRenderer();
ReplayController *render = new ReplayController();
ReplayStatus ret;
RenderDoc::Inst().SetProgressPtr(progress);
@@ -109,7 +109,7 @@ rdctype::pair<ReplayStatus, IReplayRenderer *> CaptureFile::OpenCapture(float *p
if(ret != ReplayStatus::Succeeded)
SAFE_DELETE(render);
return rdctype::make_pair<ReplayStatus, IReplayRenderer *>(ret, render);
return rdctype::make_pair<ReplayStatus, IReplayController *>(ret, render);
}
rdctype::array<byte> CaptureFile::GetThumbnail(FileType type, uint32_t maxsize)
renderdoc/replay/entry_points.cpp
+1 -1
View File
@@ -350,7 +350,7 @@ extern "C" RENDERDOC_API ReplaySupport RENDERDOC_CC RENDERDOC_SupportLocalReplay
}
extern "C" RENDERDOC_API ReplayStatus RENDERDOC_CC
RENDERDOC_CreateReplayRenderer(const char *logfile, float *progress, IReplayRenderer **rend)
RENDERDOC_CreateReplayRenderer(const char *logfile, float *progress, IReplayController **rend)
{
ICaptureFile *file = RENDERDOC_OpenCaptureFile(logfile);
renderdoc/replay/replay_renderer.cpp → renderdoc/replay/replay_controller.cpp
+91 -91
View File
@@ -23,7 +23,7 @@
* THE SOFTWARE.
******************************************************************************/
#include "replay_renderer.h"
#include "replay_controller.h"
#include <string.h>
#include <time.h>
#include "common/dds_readwrite.h"
@@ -133,14 +133,14 @@ static void fileWriteFunc(void *context, void *data, int size)
FileIO::fwrite(data, 1, size, (FILE *)context);
}
ReplayRenderer::ReplayRenderer()
ReplayController::ReplayController()
{
m_pDevice = NULL;
m_EventID = 100000;
}
ReplayRenderer::~ReplayRenderer()
ReplayController::~ReplayController()
{
RDCLOG("Shutting down replay renderer");
@@ -164,7 +164,7 @@ ReplayRenderer::~ReplayRenderer()
m_pDevice = NULL;
}
void ReplayRenderer::SetFrameEvent(uint32_t eventID, bool force)
void ReplayController::SetFrameEvent(uint32_t eventID, bool force)
{
if(eventID != m_EventID || force)
{
@@ -181,32 +181,32 @@ void ReplayRenderer::SetFrameEvent(uint32_t eventID, bool force)
}
}
D3D11Pipe::State ReplayRenderer::GetD3D11PipelineState()
D3D11Pipe::State ReplayController::GetD3D11PipelineState()
{
return m_D3D11PipelineState;
}
D3D12Pipe::State ReplayRenderer::GetD3D12PipelineState()
D3D12Pipe::State ReplayController::GetD3D12PipelineState()
{
return m_D3D12PipelineState;
}
GLPipe::State ReplayRenderer::GetGLPipelineState()
GLPipe::State ReplayController::GetGLPipelineState()
{
return m_GLPipelineState;
}
VKPipe::State ReplayRenderer::GetVulkanPipelineState()
VKPipe::State ReplayController::GetVulkanPipelineState()
{
return m_VulkanPipelineState;
}
FrameDescription ReplayRenderer::GetFrameInfo()
FrameDescription ReplayController::GetFrameInfo()
{
return m_FrameRecord.frameInfo;
}
DrawcallDescription *ReplayRenderer::GetDrawcallByEID(uint32_t eventID)
DrawcallDescription *ReplayController::GetDrawcallByEID(uint32_t eventID)
{
if(eventID >= m_Drawcalls.size())
return NULL;
@@ -214,12 +214,12 @@ DrawcallDescription *ReplayRenderer::GetDrawcallByEID(uint32_t eventID)
return m_Drawcalls[eventID];
}
rdctype::array<DrawcallDescription> ReplayRenderer::GetDrawcalls()
rdctype::array<DrawcallDescription> ReplayController::GetDrawcalls()
{
return m_FrameRecord.drawcallList;
}
rdctype::array<CounterResult> ReplayRenderer::FetchCounters(const rdctype::array<GPUCounter> &counters)
rdctype::array<CounterResult> ReplayController::FetchCounters(const rdctype::array<GPUCounter> &counters)
{
vector<GPUCounter> counterArray;
counterArray.reserve(counters.count);
@@ -229,12 +229,12 @@ rdctype::array<CounterResult> ReplayRenderer::FetchCounters(const rdctype::array
return m_pDevice->FetchCounters(counterArray);
}
rdctype::array<GPUCounter> ReplayRenderer::EnumerateCounters()
rdctype::array<GPUCounter> ReplayController::EnumerateCounters()
{
return m_pDevice->EnumerateCounters();
}
CounterDescription ReplayRenderer::DescribeCounter(GPUCounter counterID)
CounterDescription ReplayController::DescribeCounter(GPUCounter counterID)
{
CounterDescription ret;
@@ -243,7 +243,7 @@ CounterDescription ReplayRenderer::DescribeCounter(GPUCounter counterID)
return ret;
}
rdctype::array<BufferDescription> ReplayRenderer::GetBuffers()
rdctype::array<BufferDescription> ReplayController::GetBuffers()
{
if(m_Buffers.empty())
{
@@ -258,7 +258,7 @@ rdctype::array<BufferDescription> ReplayRenderer::GetBuffers()
return m_Buffers;
}
rdctype::array<TextureDescription> ReplayRenderer::GetTextures()
rdctype::array<TextureDescription> ReplayController::GetTextures()
{
if(m_Textures.empty())
{
@@ -273,7 +273,7 @@ rdctype::array<TextureDescription> ReplayRenderer::GetTextures()
return m_Textures;
}
rdctype::array<rdctype::str> ReplayRenderer::GetResolve(const rdctype::array<uint64_t> &callstack)
rdctype::array<rdctype::str> ReplayController::GetResolve(const rdctype::array<uint64_t> &callstack)
{
rdctype::array<rdctype::str> ret;
@@ -295,17 +295,17 @@ rdctype::array<rdctype::str> ReplayRenderer::GetResolve(const rdctype::array<uin
return ret;
}
rdctype::array<DebugMessage> ReplayRenderer::GetDebugMessages()
rdctype::array<DebugMessage> ReplayController::GetDebugMessages()
{
return m_pDevice->GetDebugMessages();
}
rdctype::array<EventUsage> ReplayRenderer::GetUsage(ResourceId id)
rdctype::array<EventUsage> ReplayController::GetUsage(ResourceId id)
{
return m_pDevice->GetUsage(m_pDevice->GetLiveID(id));
}
MeshFormat ReplayRenderer::GetPostVSData(uint32_t instID, MeshDataStage stage)
MeshFormat ReplayController::GetPostVSData(uint32_t instID, MeshDataStage stage)
{
DrawcallDescription *draw = GetDrawcallByEID(m_EventID);
@@ -320,7 +320,7 @@ MeshFormat ReplayRenderer::GetPostVSData(uint32_t instID, MeshDataStage stage)
return m_pDevice->GetPostVSBuffers(draw->eventID, instID, stage);
}
rdctype::array<byte> ReplayRenderer::GetBufferData(ResourceId buff, uint64_t offset, uint64_t len)
rdctype::array<byte> ReplayController::GetBufferData(ResourceId buff, uint64_t offset, uint64_t len)
{
rdctype::array<byte> ret;
@@ -343,7 +343,7 @@ rdctype::array<byte> ReplayRenderer::GetBufferData(ResourceId buff, uint64_t off
return ret;
}
rdctype::array<byte> ReplayRenderer::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint32_t mip)
rdctype::array<byte> ReplayController::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint32_t mip)
{
rdctype::array<byte> ret;
@@ -368,7 +368,7 @@ rdctype::array<byte> ReplayRenderer::GetTextureData(ResourceId tex, uint32_t arr
return ret;
}
bool ReplayRenderer::SaveTexture(const TextureSave &saveData, const char *path)
bool ReplayController::SaveTexture(const TextureSave &saveData, const char *path)
{
TextureSave sd = saveData; // mutable copy
ResourceId liveid = m_pDevice->GetLiveID(sd.id);
@@ -1162,10 +1162,10 @@ bool ReplayRenderer::SaveTexture(const TextureSave &saveData, const char *path)
return success;
}
rdctype::array<PixelModification> ReplayRenderer::PixelHistory(ResourceId target, uint32_t x,
uint32_t y, uint32_t slice,
uint32_t mip, uint32_t sampleIdx,
CompType typeHint)
rdctype::array<PixelModification> ReplayController::PixelHistory(ResourceId target, uint32_t x,
uint32_t y, uint32_t slice,
uint32_t mip, uint32_t sampleIdx,
CompType typeHint)
{
rdctype::array<PixelModification> ret;
@@ -1263,8 +1263,8 @@ rdctype::array<PixelModification> ReplayRenderer::PixelHistory(ResourceId target
return ret;
}
ShaderDebugTrace *ReplayRenderer::DebugVertex(uint32_t vertid, uint32_t instid, uint32_t idx,
uint32_t instOffset, uint32_t vertOffset)
ShaderDebugTrace *ReplayController::DebugVertex(uint32_t vertid, uint32_t instid, uint32_t idx,
uint32_t instOffset, uint32_t vertOffset)
{
ShaderDebugTrace *ret = new ShaderDebugTrace;
@@ -1275,8 +1275,8 @@ ShaderDebugTrace *ReplayRenderer::DebugVertex(uint32_t vertid, uint32_t instid,
return ret;
}
ShaderDebugTrace *ReplayRenderer::DebugPixel(uint32_t x, uint32_t y, uint32_t sample,
uint32_t primitive)
ShaderDebugTrace *ReplayController::DebugPixel(uint32_t x, uint32_t y, uint32_t sample,
uint32_t primitive)
{
ShaderDebugTrace *ret = new ShaderDebugTrace;
@@ -1287,7 +1287,7 @@ ShaderDebugTrace *ReplayRenderer::DebugPixel(uint32_t x, uint32_t y, uint32_t sa
return ret;
}
ShaderDebugTrace *ReplayRenderer::DebugThread(uint32_t groupid[3], uint32_t threadid[3])
ShaderDebugTrace *ReplayController::DebugThread(uint32_t groupid[3], uint32_t threadid[3])
{
ShaderDebugTrace *ret = new ShaderDebugTrace;
@@ -1298,7 +1298,7 @@ ShaderDebugTrace *ReplayRenderer::DebugThread(uint32_t groupid[3], uint32_t thre
return ret;
}
rdctype::array<ShaderVariable> ReplayRenderer::GetCBufferVariableContents(
rdctype::array<ShaderVariable> ReplayController::GetCBufferVariableContents(
ResourceId shader, const char *entryPoint, uint32_t cbufslot, ResourceId buffer, uint64_t offs)
{
vector<byte> data;
@@ -1312,12 +1312,12 @@ rdctype::array<ShaderVariable> ReplayRenderer::GetCBufferVariableContents(
return v;
}
rdctype::array<WindowingSystem> ReplayRenderer::GetSupportedWindowSystems()
rdctype::array<WindowingSystem> ReplayController::GetSupportedWindowSystems()
{
return m_pDevice->GetSupportedWindowSystems();
}
ReplayOutput *ReplayRenderer::CreateOutput(WindowingSystem system, void *data, ReplayOutputType type)
ReplayOutput *ReplayController::CreateOutput(WindowingSystem system, void *data, ReplayOutputType type)
{
ReplayOutput *out = new ReplayOutput(this, system, data, type);
@@ -1332,17 +1332,17 @@ ReplayOutput *ReplayRenderer::CreateOutput(WindowingSystem system, void *data, R
return out;
}
void ReplayRenderer::ShutdownOutput(IReplayOutput *output)
void ReplayController::ShutdownOutput(IReplayOutput *output)
{
RDCUNIMPLEMENTED("Shutting down individual outputs");
}
void ReplayRenderer::Shutdown()
void ReplayController::Shutdown()
{
delete this;
}
rdctype::pair<ResourceId, rdctype::str> ReplayRenderer::BuildTargetShader(
rdctype::pair<ResourceId, rdctype::str> ReplayController::BuildTargetShader(
const char *entry, const char *source, const uint32_t compileFlags, ShaderStage type)
{
ResourceId id;
@@ -1369,7 +1369,7 @@ rdctype::pair<ResourceId, rdctype::str> ReplayRenderer::BuildTargetShader(
return rdctype::make_pair<ResourceId, rdctype::str>(id, errs);
}
rdctype::pair<ResourceId, rdctype::str> ReplayRenderer::BuildCustomShader(
rdctype::pair<ResourceId, rdctype::str> ReplayController::BuildCustomShader(
const char *entry, const char *source, const uint32_t compileFlags, ShaderStage type)
{
ResourceId id;
@@ -1396,19 +1396,19 @@ rdctype::pair<ResourceId, rdctype::str> ReplayRenderer::BuildCustomShader(
return rdctype::make_pair<ResourceId, rdctype::str>(id, errs);
}
void ReplayRenderer::FreeTargetResource(ResourceId id)
void ReplayController::FreeTargetResource(ResourceId id)
{
m_TargetResources.erase(id);
m_pDevice->FreeTargetResource(id);
}
void ReplayRenderer::FreeCustomShader(ResourceId id)
void ReplayController::FreeCustomShader(ResourceId id)
{
m_CustomShaders.erase(id);
m_pDevice->FreeCustomShader(id);
}
void ReplayRenderer::ReplaceResource(ResourceId from, ResourceId to)
void ReplayController::ReplaceResource(ResourceId from, ResourceId to)
{
m_pDevice->ReplaceResource(from, to);
@@ -1419,7 +1419,7 @@ void ReplayRenderer::ReplaceResource(ResourceId from, ResourceId to)
m_Outputs[i]->Display();
}
void ReplayRenderer::RemoveReplacement(ResourceId id)
void ReplayController::RemoveReplacement(ResourceId id)
{
m_pDevice->RemoveReplacement(id);
@@ -1430,7 +1430,7 @@ void ReplayRenderer::RemoveReplacement(ResourceId id)
m_Outputs[i]->Display();
}
ReplayStatus ReplayRenderer::CreateDevice(const char *logfile)
ReplayStatus ReplayController::CreateDevice(const char *logfile)
{
RDCLOG("Creating replay device for %s", logfile);
@@ -1459,7 +1459,7 @@ ReplayStatus ReplayRenderer::CreateDevice(const char *logfile)
return status;
}
ReplayStatus ReplayRenderer::SetDevice(IReplayDriver *device)
ReplayStatus ReplayController::SetDevice(IReplayDriver *device)
{
if(device)
{
@@ -1471,7 +1471,7 @@ ReplayStatus ReplayRenderer::SetDevice(IReplayDriver *device)
return ReplayStatus::InternalError;
}
ReplayStatus ReplayRenderer::PostCreateInit(IReplayDriver *device)
ReplayStatus ReplayController::PostCreateInit(IReplayDriver *device)
{
m_pDevice = device;
@@ -1486,28 +1486,28 @@ ReplayStatus ReplayRenderer::PostCreateInit(IReplayDriver *device)
return ReplayStatus::Succeeded;
}
void ReplayRenderer::FileChanged()
void ReplayController::FileChanged()
{
m_pDevice->FileChanged();
}
bool ReplayRenderer::HasCallstacks()
bool ReplayController::HasCallstacks()
{
return m_pDevice->HasCallstacks();
}
APIProperties ReplayRenderer::GetAPIProperties()
APIProperties ReplayController::GetAPIProperties()
{
return m_pDevice->GetAPIProperties();
}
bool ReplayRenderer::InitResolver()
bool ReplayController::InitResolver()
{
m_pDevice->InitCallstackResolver();
return m_pDevice->GetCallstackResolver() != NULL;
}
void ReplayRenderer::FetchPipelineState()
void ReplayController::FetchPipelineState()
{
m_pDevice->SavePipelineState();
@@ -1562,7 +1562,7 @@ void ReplayRenderer::FetchPipelineState()
}
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetAPIProperties(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetAPIProperties(IReplayController *rend,
APIProperties *props)
{
if(props)
@@ -1570,69 +1570,69 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetAPIProperties(IRepl
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetSupportedWindowSystems(
IReplayRenderer *rend, rdctype::array<WindowingSystem> *systems)
IReplayController *rend, rdctype::array<WindowingSystem> *systems)
{
*systems = rend->GetSupportedWindowSystems();
}
extern "C" RENDERDOC_API IReplayOutput *RENDERDOC_CC ReplayRenderer_CreateOutput(
IReplayRenderer *rend, WindowingSystem system, void *data, ReplayOutputType type)
IReplayController *rend, WindowingSystem system, void *data, ReplayOutputType type)
{
return rend->CreateOutput(system, data, type);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_Shutdown(IReplayRenderer *rend)
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_Shutdown(IReplayController *rend)
{
rend->Shutdown();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_ShutdownOutput(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_ShutdownOutput(IReplayController *rend,
IReplayOutput *output)
{
rend->ShutdownOutput(output);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_FileChanged(IReplayRenderer *rend)
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_FileChanged(IReplayController *rend)
{
rend->FileChanged();
}
extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_HasCallstacks(IReplayRenderer *rend)
extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_HasCallstacks(IReplayController *rend)
{
return rend->HasCallstacks();
}
extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_InitResolver(IReplayRenderer *rend)
extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_InitResolver(IReplayController *rend)
{
return rend->InitResolver();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_SetFrameEvent(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_SetFrameEvent(IReplayController *rend,
uint32_t eventID,
bool32 force)
{
rend->SetFrameEvent(eventID, force != 0);
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetD3D11PipelineState(IReplayRenderer *rend, D3D11Pipe::State *state)
ReplayRenderer_GetD3D11PipelineState(IReplayController *rend, D3D11Pipe::State *state)
{
*state = rend->GetD3D11PipelineState();
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetD3D12PipelineState(IReplayRenderer *rend, D3D12Pipe::State *state)
ReplayRenderer_GetD3D12PipelineState(IReplayController *rend, D3D12Pipe::State *state)
{
*state = rend->GetD3D12PipelineState();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetGLPipelineState(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetGLPipelineState(IReplayController *rend,
GLPipe::State *state)
{
*state = rend->GetGLPipelineState();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetVulkanPipelineState(IReplayRenderer *rend,
VKPipe::State *state)
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetVulkanPipelineState(IReplayController *rend, VKPipe::State *state)
{
*state = rend->GetVulkanPipelineState();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_BuildCustomShader(
IReplayRenderer *rend, const char *entry, const char *source, const uint32_t compileFlags,
IReplayController *rend, const char *entry, const char *source, const uint32_t compileFlags,
ShaderStage type, ResourceId *shaderID, rdctype::str *errors)
{
if(shaderID == NULL)
@@ -1644,14 +1644,14 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_BuildCustomShader(
if(errors)
*errors = ret.second;
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_FreeCustomShader(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_FreeCustomShader(IReplayController *rend,
ResourceId id)
{
rend->FreeCustomShader(id);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_BuildTargetShader(
IReplayRenderer *rend, const char *entry, const char *source, const uint32_t compileFlags,
IReplayController *rend, const char *entry, const char *source, const uint32_t compileFlags,
ShaderStage type, ResourceId *shaderID, rdctype::str *errors)
{
if(shaderID == NULL)
@@ -1663,35 +1663,35 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_BuildTargetShader(
if(errors)
*errors = ret.second;
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_ReplaceResource(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_ReplaceResource(IReplayController *rend,
ResourceId from,
ResourceId to)
{
rend->ReplaceResource(from, to);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_RemoveReplacement(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_RemoveReplacement(IReplayController *rend,
ResourceId id)
{
rend->RemoveReplacement(id);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_FreeTargetResource(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_FreeTargetResource(IReplayController *rend,
ResourceId id)
{
rend->FreeTargetResource(id);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetFrameInfo(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetFrameInfo(IReplayController *rend,
FrameDescription *frame)
{
*frame = rend->GetFrameInfo();
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetDrawcalls(IReplayRenderer *rend, rdctype::array<DrawcallDescription> *draws)
ReplayRenderer_GetDrawcalls(IReplayController *rend, rdctype::array<DrawcallDescription> *draws)
{
*draws = rend->GetDrawcalls();
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_FetchCounters(IReplayRenderer *rend, GPUCounter *counters, uint32_t numCounters,
ReplayRenderer_FetchCounters(IReplayController *rend, GPUCounter *counters, uint32_t numCounters,
rdctype::array<CounterResult> *results)
{
rdctype::array<GPUCounter> counterArray;
@@ -1699,28 +1699,28 @@ ReplayRenderer_FetchCounters(IReplayRenderer *rend, GPUCounter *counters, uint32
*results = rend->FetchCounters(counterArray);
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_EnumerateCounters(IReplayRenderer *rend, rdctype::array<GPUCounter> *counters)
ReplayRenderer_EnumerateCounters(IReplayController *rend, rdctype::array<GPUCounter> *counters)
{
*counters = rend->EnumerateCounters();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DescribeCounter(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DescribeCounter(IReplayController *rend,
GPUCounter counterID,
CounterDescription *desc)
{
*desc = rend->DescribeCounter(counterID);
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetTextures(IReplayRenderer *rend, rdctype::array<TextureDescription> *texs)
ReplayRenderer_GetTextures(IReplayController *rend, rdctype::array<TextureDescription> *texs)
{
*texs = rend->GetTextures();
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetBuffers(IReplayRenderer *rend, rdctype::array<BufferDescription> *bufs)
ReplayRenderer_GetBuffers(IReplayController *rend, rdctype::array<BufferDescription> *bufs)
{
*bufs = rend->GetBuffers();
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetResolve(IReplayRenderer *rend, uint64_t *callstack, uint32_t callstackLen,
ReplayRenderer_GetResolve(IReplayController *rend, uint64_t *callstack, uint32_t callstackLen,
rdctype::array<rdctype::str> *trace)
{
rdctype::array<uint64_t> stack;
@@ -1728,26 +1728,26 @@ ReplayRenderer_GetResolve(IReplayRenderer *rend, uint64_t *callstack, uint32_t c
*trace = rend->GetResolve(stack);
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_GetDebugMessages(IReplayRenderer *rend, rdctype::array<DebugMessage> *msgs)
ReplayRenderer_GetDebugMessages(IReplayController *rend, rdctype::array<DebugMessage> *msgs)
{
*msgs = rend->GetDebugMessages();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_PixelHistory(
IReplayRenderer *rend, ResourceId target, uint32_t x, uint32_t y, uint32_t slice, uint32_t mip,
uint32_t sampleIdx, CompType typeHint, rdctype::array<PixelModification> *history)
IReplayController *rend, ResourceId target, uint32_t x, uint32_t y, uint32_t slice,
uint32_t mip, uint32_t sampleIdx, CompType typeHint, rdctype::array<PixelModification> *history)
{
*history = rend->PixelHistory(target, x, y, slice, mip, sampleIdx, typeHint);
}
extern "C" RENDERDOC_API void RENDERDOC_CC
ReplayRenderer_DebugVertex(IReplayRenderer *rend, uint32_t vertid, uint32_t instid, uint32_t idx,
ReplayRenderer_DebugVertex(IReplayController *rend, uint32_t vertid, uint32_t instid, uint32_t idx,
uint32_t instOffset, uint32_t vertOffset, ShaderDebugTrace *trace)
{
ShaderDebugTrace *ret = rend->DebugVertex(vertid, instid, idx, instOffset, vertOffset);
*trace = *ret;
delete ret;
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DebugPixel(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DebugPixel(IReplayController *rend,
uint32_t x, uint32_t y,
uint32_t sample,
uint32_t primitive,
@@ -1757,7 +1757,7 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DebugPixel(IReplayRend
*trace = *ret;
delete ret;
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DebugThread(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DebugThread(IReplayController *rend,
uint32_t groupid[3],
uint32_t threadid[3],
ShaderDebugTrace *trace)
@@ -1767,7 +1767,7 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_DebugThread(IReplayRen
delete ret;
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetUsage(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetUsage(IReplayController *rend,
ResourceId id,
rdctype::array<EventUsage> *usage)
{
@@ -1775,20 +1775,20 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetUsage(IReplayRender
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetCBufferVariableContents(
IReplayRenderer *rend, ResourceId shader, const char *entryPoint, uint32_t cbufslot,
IReplayController *rend, ResourceId shader, const char *entryPoint, uint32_t cbufslot,
ResourceId buffer, uint64_t offs, rdctype::array<ShaderVariable> *vars)
{
*vars = rend->GetCBufferVariableContents(shader, entryPoint, cbufslot, buffer, offs);
}
extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_SaveTexture(IReplayRenderer *rend,
extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_SaveTexture(IReplayController *rend,
const TextureSave &saveData,
const char *path)
{
return rend->SaveTexture(saveData, path);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetPostVSData(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetPostVSData(IReplayController *rend,
uint32_t instID,
MeshDataStage stage,
MeshFormat *data)
@@ -1796,7 +1796,7 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetPostVSData(IReplayR
*data = rend->GetPostVSData(instID, stage);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetBufferData(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetBufferData(IReplayController *rend,
ResourceId buff,
uint64_t offset, uint64_t len,
rdctype::array<byte> *data)
@@ -1804,7 +1804,7 @@ extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetBufferData(IReplayR
*data = rend->GetBufferData(buff, offset, len);
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetTextureData(IReplayRenderer *rend,
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_GetTextureData(IReplayController *rend,
ResourceId tex,
uint32_t arrayIdx,
uint32_t mip,
renderdoc/replay/replay_renderer.h → renderdoc/replay/replay_controller.h
+7 -7
View File
@@ -33,7 +33,7 @@
#include "replay/replay_driver.h"
#include "type_helpers.h"
struct ReplayRenderer;
struct ReplayController;
struct ReplayOutput : public IReplayOutput
{
@@ -60,7 +60,7 @@ public:
rdctype::pair<uint32_t, uint32_t> PickVertex(uint32_t eventID, uint32_t x, uint32_t y);
private:
ReplayOutput(ReplayRenderer *parent, WindowingSystem system, void *data, ReplayOutputType type);
ReplayOutput(ReplayController *parent, WindowingSystem system, void *data, ReplayOutputType type);
virtual ~ReplayOutput();
void SetFrameEvent(int eventID);
@@ -72,7 +72,7 @@ private:
void DisplayMesh();
ReplayRenderer *m_pRenderer;
ReplayController *m_pRenderer;
bool m_OverlayDirty;
bool m_ForceOverlayRefresh;
@@ -113,14 +113,14 @@ private:
MeshDisplay meshDisplay;
} m_RenderData;
friend struct ReplayRenderer;
friend struct ReplayController;
};
struct ReplayRenderer : public IReplayRenderer
struct ReplayController : public IReplayController
{
public:
ReplayRenderer();
virtual ~ReplayRenderer();
ReplayController();
virtual ~ReplayController();
APIProperties GetAPIProperties();
renderdoc/replay/replay_output.cpp
+2 -2
View File
@@ -26,7 +26,7 @@
#include "common/common.h"
#include "maths/matrix.h"
#include "serialise/string_utils.h"
#include "replay_renderer.h"
#include "replay_controller.h"
static uint64_t GetHandle(WindowingSystem system, void *data)
{
@@ -69,7 +69,7 @@ static uint64_t GetHandle(WindowingSystem system, void *data)
#endif
}
ReplayOutput::ReplayOutput(ReplayRenderer *parent, WindowingSystem system, void *data,
ReplayOutput::ReplayOutput(ReplayController *parent, WindowingSystem system, void *data,
ReplayOutputType type)
{
m_pRenderer = parent;
renderdoccmd/renderdoccmd.cpp
+3 -3
View File
@@ -45,7 +45,7 @@ void readCapOpts(const std::string &str, CaptureOptions *opts)
*(b++) = (byte(str[i * 2 + 0] - 'a') << 4) | byte(str[i * 2 + 1] - 'a');
}
void DisplayRendererPreview(IReplayRenderer *renderer, uint32_t width, uint32_t height)
void DisplayRendererPreview(IReplayController *renderer, uint32_t width, uint32_t height)
{
if(renderer == NULL)
return;
@@ -510,7 +510,7 @@ struct ReplayCommand : public Command
rdctype::str remotePath = remote->CopyCaptureToRemote(filename.c_str(), NULL);
IReplayRenderer *renderer = NULL;
IReplayController *renderer = NULL;
std::tie(status, renderer) = remote->OpenCapture(~0U, remotePath.elems, NULL);
if(status == ReplayStatus::Succeeded)
@@ -539,7 +539,7 @@ struct ReplayCommand : public Command
return 1;
}
IReplayRenderer *renderer = NULL;
IReplayController *renderer = NULL;
ReplayStatus status = ReplayStatus::InternalError;
std::tie(status, renderer) = file->OpenCapture(NULL);
renderdoccmd/renderdoccmd.h
+2 -2
View File
@@ -28,7 +28,7 @@
struct CaptureOptions;
struct TextureDisplay;
struct IReplayRenderer;
struct IReplayController;
struct Command
{
@@ -55,6 +55,6 @@ int renderdoccmd(std::vector<std::string> &argv);
void readCapOpts(const std::string &str, CaptureOptions *opts);
// these must be defined in platform .cpps
void DisplayRendererPreview(IReplayRenderer *renderer, TextureDisplay &displayCfg, uint32_t width,
void DisplayRendererPreview(IReplayController *renderer, TextureDisplay &displayCfg, uint32_t width,
uint32_t height);
void Daemonise();
renderdoccmd/renderdoccmd_android.cpp
+1 -1
View File
@@ -48,7 +48,7 @@ void Daemonise()
{
}
void DisplayRendererPreview(IReplayRenderer *renderer, TextureDisplay &displayCfg, uint32_t width,
void DisplayRendererPreview(IReplayController *renderer, TextureDisplay &displayCfg, uint32_t width,
uint32_t height)
{
ANativeWindow *connectionScreenWindow = android_state->window;
renderdoccmd/renderdoccmd_apple.cpp
+1 -1
View File
@@ -35,7 +35,7 @@ void Daemonise()
{
}
void DisplayRendererPreview(IReplayRenderer *renderer, TextureDisplay &displayCfg, uint32_t width,
void DisplayRendererPreview(IReplayController *renderer, TextureDisplay &displayCfg, uint32_t width,
uint32_t height)
{
}
renderdoccmd/renderdoccmd_linux.cpp
+1 -1
View File
@@ -200,7 +200,7 @@ void VerifyVulkanLayer(int argc, char *argv[])
add_command("vulkanregister", new VulkanRegisterCommand());
}
void DisplayRendererPreview(IReplayRenderer *renderer, TextureDisplay &displayCfg, uint32_t width,
void DisplayRendererPreview(IReplayController *renderer, TextureDisplay &displayCfg, uint32_t width,
uint32_t height)
{
// we only have the preview implemented for platforms that have xlib & xcb. It's unlikely
renderdoccmd/renderdoccmd_win32.cpp
+1 -1
View File
@@ -233,7 +233,7 @@ void Daemonise()
// nothing really to do, windows version of renderdoccmd is already 'detached'
}
void DisplayRendererPreview(IReplayRenderer *renderer, TextureDisplay &displayCfg, uint32_t width,
void DisplayRendererPreview(IReplayController *renderer, TextureDisplay &displayCfg, uint32_t width,
uint32_t height)
{
RECT wr = {0, 0, (LONG)width, (LONG)height};