renderdoc/qrenderdoc/Code/RenderManager.h

/******************************************************************************
 * The MIT License (MIT)
 *
 * Copyright (c) 2016-2017 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.
 ******************************************************************************/

#pragma once

#include <QMutex>
#include <QQueue>
#include <QSemaphore>
#include <QString>
#include <QThread>
#include <QVariantMap>
#include <QWaitCondition>
#include <functional>
#include "QRDUtils.h"
#include "RemoteHost.h"
#include "renderdoc_replay.h"

struct IReplayRenderer;
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); });

struct EnvironmentModification
{
  QString variable;
  QString value;

  EnvMod type;
  EnvSep separator;

  QString GetTypeString() const
  {
    QString ret;

    if(type == EnvMod::Append)
      ret = QString("Append, %1").arg(ToQStr(separator));
    else if(type == EnvMod::Prepend)
      ret = QString("Prepend, %1").arg(ToQStr(separator));
    else
      ret = "Set";

    return ret;
  }

  QString GetDescription() const
  {
    QString ret;

    if(type == EnvMod::Append)
      ret = QString("Append %1 with %2 using %3").arg(variable).arg(value).arg(ToQStr(separator));
    else if(type == EnvMod::Prepend)
      ret = QString("Prepend %1 with %2 using %3").arg(variable).arg(value).arg(ToQStr(separator));
    else
      ret = QString("Set %1 to %2").arg(variable).arg(value);

    return ret;
  }

  QVariantMap toJSON() const
  {
    QVariantMap ret;
    ret["variable"] = variable;
    ret["value"] = value;
    ret["type"] = ToQStr(type);
    ret["separator"] = ToQStr(separator);
    return ret;
  }

  void fromJSON(const QVariantMap &data)
  {
    variable = data["variable"].toString();
    value = data["value"].toString();

    QString t = data["type"].toString();

    if(t == ToQStr(EnvMod::Append))
      type = EnvMod::Append;
    else if(t == ToQStr(EnvMod::Prepend))
      type = EnvMod::Prepend;
    else
      type = EnvMod::Set;

    QString s = data["separator"].toString();

    if(s == ToQStr(EnvSep::SemiColon))
      separator = EnvSep::SemiColon;
    else if(s == ToQStr(EnvSep::Colon))
      separator = EnvSep::Colon;
    else if(s == ToQStr(EnvSep::Platform))
      separator = EnvSep::Platform;
    else
      separator = EnvSep::NoSep;
  }
};

class RenderManager
{
public:
  typedef std::function<void(IReplayRenderer *)> InvokeMethod;
  typedef std::function<void(const char *, const rdctype::array<DirectoryFile> &)> DirectoryBrowseMethod;

  RenderManager();
  ~RenderManager();

  void OpenCapture(const QString &logfile, float *progress);
  void DeleteCapture(const QString &logfile, bool local);

  bool IsRunning();
  ReplayStatus GetCreateStatus() { return m_CreateStatus; }
  // this tagged version is for cases when we might send a request - e.g. to pick a vertex or pixel
  // - and want to pre-empt it with a new request before the first has returned. Either because some
  // other work is taking a while or because we're sending requests faster than they can be
  // processed.
  // the manager processes only the request on the top of the queue, so when a new tagged invoke
  // comes in, we remove any other requests in the queue before it that have the same tag
  void AsyncInvoke(const QString &tag, InvokeMethod m);
  void AsyncInvoke(InvokeMethod m);
  void BlockInvoke(InvokeMethod m);

  void CloseThread();

  ReplayStatus ConnectToRemoteServer(RemoteHost *host);
  void DisconnectFromRemoteServer();
  void ShutdownServer();
  void PingRemote();

  const RemoteHost *remote() { return m_RemoteHost; }
  uint32_t ExecuteAndInject(const QString &exe, const QString &workingDir, const QString &cmdLine,
                            const QList<EnvironmentModification> &env, const QString &logfile,
                            CaptureOptions opts);

  QStringList GetRemoteSupport();
  void GetHomeFolder(bool synchronous, DirectoryBrowseMethod cb);
  bool ListFolder(QString path, bool synchronous, DirectoryBrowseMethod cb);
  QString CopyCaptureToRemote(const QString &localpath, QWidget *window);
  void CopyCaptureFromRemote(const QString &remotepath, const QString &localpath, QWidget *window);

private:
  struct InvokeHandle
  {
    InvokeHandle(InvokeMethod m, const QString &t = QString())
    {
      tag = t;
      method = m;
      selfdelete = false;
    }

    QString tag;
    InvokeMethod method;
    QSemaphore processed;
    bool selfdelete;
  };

  void run();

  QMutex m_RenderLock;
  QQueue<InvokeHandle *> m_RenderQueue;
  QWaitCondition m_RenderCondition;

  void PushInvoke(InvokeHandle *cmd);

  int m_ProxyRenderer;
  QString m_ReplayHost;
  QString m_Logfile;
  float *m_Progress;

  QMutex m_RemoteLock;
  RemoteHost *m_RemoteHost = NULL;
  IRemoteServer *m_Remote = NULL;

  volatile bool m_Running;
  LambdaThread *m_Thread;
  ReplayStatus m_CreateStatus;
};