Expose directory listing functions to C#

renderdoc/api/replay/data_types.h

@@ -34,6 +34,12 @@ struct FloatVector
   float x, y, z, w;
 };
 
+struct DirectoryFile
+{
+  rdctype::str filename;
+  uint32_t flags;
+};
+
 struct ResourceFormat
 {
   ResourceFormat()

renderdoc/api/replay/renderdoc_replay.h

@@ -483,6 +483,9 @@ struct IRemoteServer
   virtual bool LocalProxies(rdctype::array<rdctype::str> *out) = 0;
   virtual bool RemoteSupportedReplays(rdctype::array<rdctype::str> *out) = 0;
 
+  virtual rdctype::str GetHomeFolder() = 0;
+  virtual rdctype::array<DirectoryFile> ListFolder(const char *path) = 0;
+
   virtual uint32_t ExecuteAndInject(const char *app, const char *workingDir, const char *cmdLine,
                                     const CaptureOptions *opts) = 0;
 
@@ -519,6 +522,11 @@ RemoteServer_LocalProxies(RemoteServer *remote, rdctype::array<rdctype::str> *ou
 extern "C" RENDERDOC_API bool32 RENDERDOC_CC
 RemoteServer_RemoteSupportedReplays(RemoteServer *remote, rdctype::array<rdctype::str> *out);
 
+extern "C" RENDERDOC_API void RENDERDOC_CC RemoteServer_GetHomeFolder(RemoteServer *remote,
+                                                                      rdctype::str *home);
+extern "C" RENDERDOC_API void RENDERDOC_CC RemoteServer_ListFolder(
+    RemoteServer *remote, const char *path, rdctype::array<DirectoryFile> *dirlist);
+
 extern "C" RENDERDOC_API uint32_t RENDERDOC_CC
 RemoteServer_ExecuteAndInject(RemoteServer *remote, const char *app, const char *workingDir,
                               const char *cmdLine, const CaptureOptions *opts);

renderdoc/api/replay/replay_enums.h

@@ -25,6 +25,17 @@
 
 #pragma once
 
+enum DirectoryFileProperty
+{
+  eFileProp_Directory = 0x1,
+  eFileProp_Hidden = 0x2,
+  eFileProp_Executable = 0x4,
+
+  eFileProp_ErrorUnknown = 0x2000,
+  eFileProp_ErrorAccessDenied = 0x4000,
+  eFileProp_ErrorInvalidPath = 0x8000,
+};
+
 // replay_shader.h
 
 enum VarType

renderdoc/core/remote_server.cpp

@@ -41,6 +41,15 @@ string ToStrHelper<false, CaptureOptions>::Get(const CaptureOptions &el)
   return "<...>";
 }
 
+template <>
+void Serialiser::Serialise(const char *name, DirectoryFile &el)
+{
+  ScopedContext scope(this, name, "DirectoryFile", 0, true);
+
+  Serialise("filename", el.filename);
+  Serialise("flags", el.flags);
+}
+
 enum RemoteServerPacket
 {
   eRemoteServer_Noop,
@@ -54,6 +63,8 @@ enum RemoteServerPacket
   eRemoteServer_LogOpenProgress,
   eRemoteServer_LogOpened,
   eRemoteServer_CloseLog,
+  eRemoteServer_HomeDir,
+  eRemoteServer_ListDir,
   eRemoteServer_ExecuteAndInject,
   eRemoteServer_ShutdownServer,
   eRemoteServer_RemoteServerCount,
@@ -197,6 +208,33 @@ static void ActiveRemoteClientThread(void *data)
           sendSer.Serialise("", (*it).second);
         }
       }
+      else if(type == eRemoteServer_HomeDir)
+      {
+        sendType = eRemoteServer_HomeDir;
+
+        string home = FileIO::GetHomeFolderFilename();
+        sendSer.Serialise("", home);
+      }
+      else if(type == eRemoteServer_ListDir)
+      {
+        string path;
+        recvser->Serialise("path", path);
+
+        sendType = eRemoteServer_ListDir;
+
+        vector<FileIO::FoundFile> files = FileIO::GetFilesInDirectory(path.c_str());
+
+        uint32_t count = (uint32_t)files.size();
+        sendSer.Serialise("", count);
+
+        for(uint32_t i = 0; i < count; i++)
+        {
+          DirectoryFile df;
+          df.filename = files[i].filename;
+          df.flags = files[i].flags;
+          sendSer.Serialise("", df);
+        }
+      }
       else if(type == eRemoteServer_CopyCaptureFromRemote)
       {
         string path;
@@ -670,6 +708,67 @@ public:
     return true;
   }
 
+  rdctype::str GetHomeFolder()
+  {
+    rdctype::str ret;
+
+    Serialiser sendData("", Serialiser::WRITING, false);
+    Send(eRemoteServer_HomeDir, sendData);
+
+    RemoteServerPacket type = eRemoteServer_HomeDir;
+
+    Serialiser *ser = NULL;
+    Get(type, &ser);
+
+    if(ser)
+    {
+      string home;
+      ser->Serialise("", home);
+
+      ret = home;
+
+      delete ser;
+    }
+
+    return ret;
+  }
+
+  rdctype::array<DirectoryFile> ListFolder(const char *path)
+  {
+    rdctype::array<DirectoryFile> ret;
+
+    string folderPath = path;
+
+    Serialiser sendData("", Serialiser::WRITING, false);
+    sendData.Serialise("", folderPath);
+    Send(eRemoteServer_ListDir, sendData);
+
+    RemoteServerPacket type = eRemoteServer_ListDir;
+
+    Serialiser *ser = NULL;
+    Get(type, &ser);
+
+    if(ser)
+    {
+      uint32_t count = 0;
+      ser->Serialise("", count);
+
+      create_array_uninit(ret, count);
+      for(uint32_t i = 0; i < count; i++)
+        ser->Serialise("", ret[i]);
+
+      delete ser;
+    }
+    else
+    {
+      create_array_uninit(ret, 1);
+      ret.elems[0].filename = path;
+      ret.elems[0].flags = eFileProp_ErrorUnknown;
+    }
+
+    return ret;
+  }
+
   uint32_t ExecuteAndInject(const char *app, const char *workingDir, const char *cmdLine,
                             const CaptureOptions *opts)
   {
@@ -896,6 +995,22 @@ RemoteServer_LocalProxies(RemoteServer *remote, rdctype::array<rdctype::str> *ou
   return remote->LocalProxies(out);
 }
 
+extern "C" RENDERDOC_API void RENDERDOC_CC RemoteServer_GetHomeFolder(RemoteServer *remote,
+                                                                      rdctype::str *home)
+{
+  rdctype::str path = remote->GetHomeFolder();
+  if(home)
+    *home = path;
+}
+
+extern "C" RENDERDOC_API void RENDERDOC_CC RemoteServer_ListFolder(
+    RemoteServer *remote, const char *path, rdctype::array<DirectoryFile> *dirlist)
+{
+  rdctype::array<DirectoryFile> files = remote->ListFolder(path);
+  if(dirlist)
+    *dirlist = files;
+}
+
 extern "C" RENDERDOC_API bool32 RENDERDOC_CC
 RemoteServer_RemoteSupportedReplays(RemoteServer *remote, rdctype::array<rdctype::str> *out)
 {