Remove 'replay-new' C wrapper, complete C++ wrapper, tweak build.rs

Author: ebkalderon

renderdoc_sys/build.rs

@@ -41,7 +41,6 @@ fn main() {
         .whitelist_type("pRENDERDOC_.*")
         .whitelist_type("ReplayStatus")
         .whitelist_type("Shader.*")
-        .whitelist_type("TargetControl.*")
         .whitelist_type("Texture.*")
         .whitelist_type("Window.*")
         .whitelist_type("XCBWindowData")
@@ -50,9 +49,11 @@ fn main() {
         // Custom wrapper types.
         .whitelist_type("Camera")
         .whitelist_type("CaptureFile")
+        .whitelist_type("RemoteServer")
         .whitelist_type("ReplayController")
+        .whitelist_type("ReplayOutput")
         .whitelist_type("TargetControl")
-        .opaque_type("Camera")
+        // .opaque_type("Camera")
         .generate_inline_functions(true)
         .generate()
         .expect("Unable to generate replay bindings!");
@@ -63,8 +64,12 @@ fn main() {
 
     cc::Build::new()
         .include("replay")
+        .include("renderdoc")
         .file("replay/src/Camera.cpp")
         .file("replay/src/CaptureFile.cpp")
+        .file("replay/src/RemoteServer.cpp")
+        .file("replay/src/ReplayController.cpp")
+        .file("replay/src/ReplayOutput.cpp")
         .file("replay/src/TargetControl.cpp")
         .define("RENDERDOC_PLATFORM_LINUX", None)
         .define("RENDERDOC_WINDOWING_XLIB", None)

renderdoc_sys/replay-new/include/camera.h

@@ -5,9 +5,6 @@
 
 #include "../../renderdoc/renderdoc/api/replay/basic_types.h"
 
-typedef uint8_t byte;
-
-enum class FileType : uint32_t;
 class ReplayController;
 enum class ReplayStatus : uint32_t;
 enum class ReplaySupport : uint32_t;
@@ -24,7 +21,7 @@ class CaptureFile {
     const char *DriverName();
     const char *RecordedMachineIdent();
 
-    rdctype::pair<ReplayStatus, ReplayController> OpenCapture(float *progress);
+    rdctype::pair<ReplayStatus, ReplayController*> OpenCapture(float *progress);
     rdctype::array<byte> GetThumbnail(FileType type, uint32_t maxsize);
 
 private:

renderdoc_sys/replay-new/include/float_vector.h

@@ -0,0 +1,63 @@
+#ifndef REMOTE_SERVER_H
+#define REMOTE_SERVER_H
+
+#include <cstdint>
+
+#include "../../renderdoc/renderdoc/api/replay/replay_enums.h"
+
+struct CaptureOptions;
+struct EnvironmentModification;
+struct PathEntry;
+class ReplayController;
+
+class RemoteServer {
+public:
+    static void BecomeRemoteServer(const char *listenhost, uint32_t port,
+                                   uint32_t *kill);
+
+    static uint32_t ExecuteAndInject(
+        const char *app,
+        const char *workingDir,
+        const char *cmdLine,
+        const rdctype::array<EnvironmentModification> &env,
+        const char *logfile,
+        const CaptureOptions &opts,
+        bool32 waitForExit
+    );
+
+    static uint32_t GetDefaultRemoteServerPort();
+
+    RemoteServer(const char *host, uint32_t port);
+    ~RemoteServer();
+
+    void ShutdownConnection();
+    bool Ping();
+
+    rdctype::array<rdctype::str> LocalProxies();
+    rdctype::array<rdctype::str> RemoteSupportedReplays();
+
+    rdctype::str GetHomeFolder();
+    rdctype::array<PathEntry> ListFolder(const char *path);
+
+    void TakeOwnershipCapture(const char *filename);
+    rdctype::str CopyCaptureToRemote(const char *filename, float *progress);
+    void CopyCaptureFromRemote(const char *remotepath, const char *localpath,
+                               float *progress);
+
+    rdctype::pair<ReplayStatus, ReplayController*> OpenCapture(
+        uint32_t proxyid,
+        const char *logfile,
+        float *progress
+    );
+
+    void CloseCapture(ReplayController *ctrl);
+
+    static const uint32_t NoPreference = ~0U;
+
+private:
+    void ShutdownServerAndConnection();
+
+    class IRemoteServer *inner;
+};
+
+#endif // REMOTE_SERVER_H

renderdoc_sys/replay-new/wrapper.h

@@ -3,13 +3,6 @@
 
 #include <cstdint>
 
-#include "../../renderdoc/renderdoc/api/replay/basic_types.h"
-#include "../../renderdoc/renderdoc/api/replay/d3d11_pipestate.h"
-#include "../../renderdoc/renderdoc/api/replay/d3d12_pipestate.h"
-#include "../../renderdoc/renderdoc/api/replay/gl_pipestate.h"
-#include "../../renderdoc/renderdoc/api/replay/shader_types.h"
-#include "../../renderdoc/renderdoc/api/replay/vk_pipestate.h"
-
 class ReplayOutput;
 
 class ReplayController {
@@ -117,6 +110,9 @@ class ReplayController {
     ~ReplayController() = default;
 
 private:
+    friend class CaptureFile;
+    friend class RemoteServer;
+
     class IReplayController *inner;
 };
 

renderdoc_sys/replay/include/CaptureFile.h

@@ -0,0 +1,47 @@
+#ifndef REPLAY_OUTPUT_H
+#define REPLAY_OUTPUT_H
+
+#include "../../renderdoc/renderdoc/api/replay/control_types.h"
+
+class ReplayOutput {
+public:
+    void SetTextureDisplay(const TextureDisplay &o);
+    void SetMeshDisplay(const MeshDisplay &o);
+
+    void ClearThumbnails();
+    bool AddThumbnail(WindowingSystem system, void *data, ResourceId texID,
+                      CompType typeHint);
+
+    void Display();
+
+    bool SetPixelContext(WindowingSystem system, void *data);
+    void SetPixelContextLocation(uint32_t x, uint32_t y);
+    void DisablePixelContext();
+
+    rdctype::pair<PixelValue, PixelValue> GetMinMax();
+    rdctype::array<uint32_t> GetHistogram(float minval, float maxval,
+                                          bool channels[4]);
+
+    ResourceId GetCustomShaderTexID();
+    ResourceId GetDebugOverlayTexID();
+
+    PixelValue PickPixel(ResourceId texID, bool customShader, uint32_t x,
+                         uint32_t y, uint32_t sliceFace, uint32_t mip,
+                         uint32_t sample);
+
+    rdctype::pair<uint32_t, uint32_t> PickVertex(uint32_t eventID, uint32_t x,
+                                                 uint32_t y);
+
+    static const uint32_t NoResult = ~0U;
+
+protected:
+    friend class ReplayController;
+
+    ReplayOutput() = default;
+    ~ReplayOutput() = default;
+
+private:
+    class IReplayOutput *inner;
+};
+
+#endif // REPLAY_OUTPUT_H

renderdoc_sys/replay/include/RemoteServer.h

@@ -7,6 +7,8 @@ class TargetControlMessage;
 
 class TargetControl {
 public:
+    static uint32_t EnumerateRemoteTargets(const char *host, uint32_t nextIdent);
+
     TargetControl(const char *host, uint32_t ident, const char *clientName,
                   bool forceConnection);
     ~TargetControl();

renderdoc_sys/replay/include/ReplayController.h

@@ -31,11 +31,18 @@ const char *CaptureFile::RecordedMachineIdent() {
     return this->inner->RecordedMachineIdent();
 }
 
-rdctype::pair<ReplayStatus, ReplayController> CaptureFile::OpenCapture(float *progress) {
+rdctype::pair<ReplayStatus, ReplayController*> CaptureFile::OpenCapture(
+    float *progress
+) {
     auto result = this->inner->OpenCapture(progress);
+
     if (result.first == ReplayStatus::Succeeded) {
-        
+        ReplayController *ctrl = new ReplayController;
+        ctrl->inner = result.second;
+        return { result.first, ctrl };
     }
+
+    return { result.first, NULL };
 }
 
 rdctype::array<byte> CaptureFile::GetThumbnail(FileType type, uint32_t maxsize) {

renderdoc_sys/replay/include/ReplayOutput.h

@@ -0,0 +1,104 @@
+#include "../../renderdoc/renderdoc/api/replay/renderdoc_replay.h"
+
+#include "../include/RemoteServer.h"
+#include "../include/ReplayController.h"
+
+void RemoteServer::BecomeRemoteServer(
+    const char *listenhost,
+    uint32_t port,
+    uint32_t *killReplay
+) {
+    RENDERDOC_BecomeRemoteServer(listenhost, port, killReplay);
+}
+
+uint32_t RemoteServer::ExecuteAndInject(
+    const char *app,
+    const char *workingDir,
+    const char *cmdLine,
+    const rdctype::array<EnvironmentModification> &env,
+    const char *logfile,
+    const CaptureOptions &opts,
+    bool32 waitForExit
+) {
+    return RENDERDOC_ExecuteAndInject(
+        app, workingDir, cmdLine, env, logfile, opts, waitForExit
+    );
+}
+
+uint32_t RemoteServer::GetDefaultRemoteServerPort() {
+    return RENDERDOC_GetDefaultRemoteServerPort();
+}
+
+RemoteServer::RemoteServer(const char *host, uint32_t port) {
+    RENDERDOC_CreateRemoteServerConnection(host, port, &this->inner);
+}
+
+RemoteServer::~RemoteServer() {
+    this->inner->ShutdownServerAndConnection();
+}
+
+void RemoteServer::ShutdownConnection() {
+    this->inner->ShutdownConnection();
+}
+
+bool RemoteServer::Ping() {
+    return this->inner->Ping();
+}
+
+rdctype::array<rdctype::str> RemoteServer::LocalProxies() {
+    return this->inner->LocalProxies();
+}
+
+rdctype::array<rdctype::str> RemoteServer::RemoteSupportedReplays() {
+    return this->inner->RemoteSupportedReplays();
+}
+
+rdctype::str RemoteServer::GetHomeFolder() {
+    return this->inner->GetHomeFolder();
+}
+
+rdctype::array<PathEntry> RemoteServer::ListFolder(const char *path) {
+    return this->inner->ListFolder(path);
+}
+
+void RemoteServer::TakeOwnershipCapture(const char *filename) {
+    this->inner->TakeOwnershipCapture(filename);
+}
+
+rdctype::str RemoteServer::CopyCaptureToRemote(const char *filename,
+                                               float *progress)
+{
+    return this->inner->CopyCaptureToRemote(filename, progress);
+}
+
+void RemoteServer::CopyCaptureFromRemote(
+    const char *remotepath,
+    const char *localpath,
+    float *progress
+) {
+    this->inner->CopyCaptureFromRemote(remotepath, localpath, progress);
+}
+
+rdctype::pair<ReplayStatus, ReplayController*> RemoteServer::OpenCapture(
+    uint32_t proxyid,
+    const char *logfile,
+    float *progress
+) {
+    auto result = this->inner->OpenCapture(proxyid, logfile, progress);
+
+    if (result.first == ReplayStatus::Succeeded) {
+        ReplayController *ctrl = new ReplayController;
+        ctrl->inner = result.second;
+        return { result.first, ctrl };
+    }
+
+    return { result.first, NULL };
+}
+
+void RemoteServer::CloseCapture(ReplayController *ctrl) {
+    this->inner->CloseCapture(ctrl->inner);
+}
+
+void RemoteServer::ShutdownServerAndConnection() {
+    this->inner->ShutdownServerAndConnection();
+}