New code style refactor

2025-12-09 21:47:57 +00:00 · 2018-12-07 19:17:51 -10:00
parent 2c2c72bfd1
commit 058ea23a00
113 changed files with 23305 additions and 27650 deletions
--- a/lib/nx/ApplicationNX.cpp
+++ b/lib/nx/ApplicationNX.cpp
@@ -7,133 +7,95 @@

 #include <switch.h>

-namespace boo
-{
+namespace boo {
 static logvisor::Module Log("boo::NXApplication");

 std::shared_ptr<IWindow> _WindowNXNew(std::string_view title, NXContext* nxCtx);

-class ApplicationNX : public IApplication
-{
-    IApplicationCallback& m_callback;
-    const std::string m_uniqueName;
-    const std::string m_friendlyName;
-    const std::string m_pname;
-    const std::vector<std::string> m_args;
+class ApplicationNX : public IApplication {
+  IApplicationCallback& m_callback;
+  const std::string m_uniqueName;
+  const std::string m_friendlyName;
+  const std::string m_pname;
+  const std::vector<std::string> m_args;

-    NXContext m_nxCtx;
+  NXContext m_nxCtx;

-    void _deletedWindow(IWindow* window) {}
+  void _deletedWindow(IWindow* window) {}

 public:
-    ApplicationNX(IApplicationCallback& callback,
-                  std::string_view uniqueName,
-                  std::string_view friendlyName,
-                  std::string_view pname,
-                  const std::vector<std::string>& args,
-                  std::string_view gfxApi,
-                  uint32_t samples,
-                  uint32_t anisotropy,
-                  bool deepColor,
-                  bool singleInstance)
-    : m_callback(callback),
-      m_uniqueName(uniqueName),
-      m_friendlyName(friendlyName),
-      m_pname(pname),
-      m_args(args)
-    {}
+  ApplicationNX(IApplicationCallback& callback, std::string_view uniqueName, std::string_view friendlyName,
+                std::string_view pname, const std::vector<std::string>& args, std::string_view gfxApi, uint32_t samples,
+                uint32_t anisotropy, bool deepColor, bool singleInstance)
+  : m_callback(callback), m_uniqueName(uniqueName), m_friendlyName(friendlyName), m_pname(pname), m_args(args) {}

-    EPlatformType getPlatformType() const { return EPlatformType::NX; }
+  EPlatformType getPlatformType() const { return EPlatformType::NX; }

-    int run()
-    {
-        /* Spawn client thread */
-        int clientReturn = INT_MIN;
-        std::mutex initmt;
-        std::condition_variable initcv;
-        std::unique_lock<std::mutex> outerLk(initmt);
-        std::thread clientThread([&]()
-        {
-            std::unique_lock<std::mutex> innerLk(initmt);
-            innerLk.unlock();
-            initcv.notify_one();
-            std::string thrName = std::string(getFriendlyName()) + " Client";
-            logvisor::RegisterThreadName(thrName.c_str());
-            clientReturn = m_callback.appMain(this);
-        });
-        initcv.wait(outerLk);
+  int run() {
+    /* Spawn client thread */
+    int clientReturn = INT_MIN;
+    std::mutex initmt;
+    std::condition_variable initcv;
+    std::unique_lock<std::mutex> outerLk(initmt);
+    std::thread clientThread([&]() {
+      std::unique_lock<std::mutex> innerLk(initmt);
+      innerLk.unlock();
+      initcv.notify_one();
+      std::string thrName = std::string(getFriendlyName()) + " Client";
+      logvisor::RegisterThreadName(thrName.c_str());
+      clientReturn = m_callback.appMain(this);
+    });
+    initcv.wait(outerLk);

-        // Main graphics loop
-        while (clientReturn == INT_MIN && appletMainLoop())
-        {
-            // Get and process input
-            hidScanInput();
-            u32 kDown = hidKeysDown(CONTROLLER_P1_AUTO);
-            if (kDown & KEY_PLUS)
-                break;
-        }
-
-        m_callback.appQuitting(this);
-        if (clientThread.joinable())
-            clientThread.join();
-
-        return 0;
+    // Main graphics loop
+    while (clientReturn == INT_MIN && appletMainLoop()) {
+      // Get and process input
+      hidScanInput();
+      u32 kDown = hidKeysDown(CONTROLLER_P1_AUTO);
+      if (kDown & KEY_PLUS)
+        break;
    }

-    std::string_view getUniqueName() const
-    {
-        return m_uniqueName;
-    }
+    m_callback.appQuitting(this);
+    if (clientThread.joinable())
+      clientThread.join();

-    std::string_view getFriendlyName() const
-    {
-        return m_friendlyName;
-    }
+    return 0;
+  }

-    std::string_view getProcessName() const
-    {
-        return m_pname;
-    }
+  std::string_view getUniqueName() const { return m_uniqueName; }

-    const std::vector<std::string>& getArgs() const
-    {
-        return m_args;
-    }
+  std::string_view getFriendlyName() const { return m_friendlyName; }

-    std::shared_ptr<IWindow> m_window;
-    std::shared_ptr<IWindow> newWindow(std::string_view title)
-    {
-        if (m_window)
-            Log.report(logvisor::Fatal, "Only 1 window allowed on NX");
-        m_window = _WindowNXNew(title, &m_nxCtx);
-        return m_window;
-    }
+  std::string_view getProcessName() const { return m_pname; }
+
+  const std::vector<std::string>& getArgs() const { return m_args; }
+
+  std::shared_ptr<IWindow> m_window;
+  std::shared_ptr<IWindow> newWindow(std::string_view title) {
+    if (m_window)
+      Log.report(logvisor::Fatal, "Only 1 window allowed on NX");
+    m_window = _WindowNXNew(title, &m_nxCtx);
+    return m_window;
+  }
 };

 IApplication* APP = nullptr;
-int ApplicationRun(IApplication::EPlatformType platform,
-                   IApplicationCallback& cb,
-                   SystemStringView uniqueName,
-                   SystemStringView friendlyName,
-                   SystemStringView pname,
-                   const std::vector<SystemString>& args,
-                   std::string_view gfxApi,
-                   uint32_t samples,
-                   uint32_t anisotropy,
-                   bool deepColor,
-                   bool singleInstance)
-{
-    std::string thrName = std::string(friendlyName) + " Main Thread";
-    logvisor::RegisterThreadName(thrName.c_str());
+int ApplicationRun(IApplication::EPlatformType platform, IApplicationCallback& cb, SystemStringView uniqueName,
+                   SystemStringView friendlyName, SystemStringView pname, const std::vector<SystemString>& args,
+                   std::string_view gfxApi, uint32_t samples, uint32_t anisotropy, bool deepColor,
+                   bool singleInstance) {
+  std::string thrName = std::string(friendlyName) + " Main Thread";
+  logvisor::RegisterThreadName(thrName.c_str());

-    if (APP)
-        return 1;
-    APP = new ApplicationNX(cb, uniqueName, friendlyName, pname, args, gfxApi,
-                            samples, anisotropy, deepColor, singleInstance);
-    int ret = APP->run();
-    delete APP;
-    APP = nullptr;
-    return ret;
+  if (APP)
+    return 1;
+  APP = new ApplicationNX(cb, uniqueName, friendlyName, pname, args, gfxApi, samples, anisotropy, deepColor,
+                          singleInstance);
+  int ret = APP->run();
+  delete APP;
+  APP = nullptr;
+  return ret;
 }

-}
+} // namespace boo
--- a/lib/nx/WindowNX.cpp
+++ b/lib/nx/WindowNX.cpp
@@ -5,116 +5,111 @@

 #include <switch.h>

-namespace boo
-{
+namespace boo {

 std::unique_ptr<IGraphicsCommandQueue> _NewNXCommandQueue(NXContext* ctx, IGraphicsContext* parent);
 std::unique_ptr<IGraphicsDataFactory> _NewNXDataFactory(IGraphicsContext* parent, NXContext* ctx);

-struct GraphicsContextNX : IGraphicsContext
-{
-    NXContext* m_nxCtx;
-    std::unique_ptr<IGraphicsDataFactory> m_dataFactory;
-    std::unique_ptr<IGraphicsCommandQueue> m_commandQueue;
+struct GraphicsContextNX : IGraphicsContext {
+  NXContext* m_nxCtx;
+  std::unique_ptr<IGraphicsDataFactory> m_dataFactory;
+  std::unique_ptr<IGraphicsCommandQueue> m_commandQueue;
+
 public:
-    explicit GraphicsContextNX(NXContext* nxCtx)
-    : m_nxCtx(nxCtx)
-    {
-        m_dataFactory = _NewNXDataFactory(this, nxCtx);
-        m_commandQueue = _NewNXCommandQueue(nxCtx, this);
-    }
+  explicit GraphicsContextNX(NXContext* nxCtx) : m_nxCtx(nxCtx) {
+    m_dataFactory = _NewNXDataFactory(this, nxCtx);
+    m_commandQueue = _NewNXCommandQueue(nxCtx, this);
+  }

-    EGraphicsAPI getAPI() const { return EGraphicsAPI::NX; }
-    EPixelFormat getPixelFormat() const { return EPixelFormat::RGBA8; }
-    void setPixelFormat(EPixelFormat pf) {}
-    bool initializeContext(void* handle) { return m_nxCtx->initialize(); }
-    void makeCurrent() {}
-    void postInit() {}
-    void present() {}
+  EGraphicsAPI getAPI() const { return EGraphicsAPI::NX; }
+  EPixelFormat getPixelFormat() const { return EPixelFormat::RGBA8; }
+  void setPixelFormat(EPixelFormat pf) {}
+  bool initializeContext(void* handle) { return m_nxCtx->initialize(); }
+  void makeCurrent() {}
+  void postInit() {}
+  void present() {}

-    IGraphicsCommandQueue* getCommandQueue() { return m_commandQueue.get(); }
-    IGraphicsDataFactory* getDataFactory() { return m_dataFactory.get(); }
-    IGraphicsDataFactory* getMainContextDataFactory() { return m_dataFactory.get(); }
-    IGraphicsDataFactory* getLoadContextDataFactory() { return m_dataFactory.get(); }
+  IGraphicsCommandQueue* getCommandQueue() { return m_commandQueue.get(); }
+  IGraphicsDataFactory* getDataFactory() { return m_dataFactory.get(); }
+  IGraphicsDataFactory* getMainContextDataFactory() { return m_dataFactory.get(); }
+  IGraphicsDataFactory* getLoadContextDataFactory() { return m_dataFactory.get(); }
 };

-class WindowNX : public IWindow
-{
-    std::string m_title;
-    std::unique_ptr<GraphicsContextNX> m_gfxCtx;
-    IWindowCallback* m_callback = nullptr;
+class WindowNX : public IWindow {
+  std::string m_title;
+  std::unique_ptr<GraphicsContextNX> m_gfxCtx;
+  IWindowCallback* m_callback = nullptr;
+
 public:
-    WindowNX(std::string_view title, NXContext* nxCtx)
-    : m_title(title), m_gfxCtx(new GraphicsContextNX(nxCtx))
-    {
-        m_gfxCtx->initializeContext(nullptr);
-    }
+  WindowNX(std::string_view title, NXContext* nxCtx) : m_title(title), m_gfxCtx(new GraphicsContextNX(nxCtx)) {
+    m_gfxCtx->initializeContext(nullptr);
+  }

-    void setCallback(IWindowCallback* cb) { m_callback = cb; }
+  void setCallback(IWindowCallback* cb) { m_callback = cb; }

-    void closeWindow() {}
-    void showWindow() {}
-    void hideWindow() {}
+  void closeWindow() {}
+  void showWindow() {}
+  void hideWindow() {}

-    SystemString getTitle() { return m_title; }
-    void setTitle(SystemStringView title) { m_title = title; }
+  SystemString getTitle() { return m_title; }
+  void setTitle(SystemStringView title) { m_title = title; }

-    void setCursor(EMouseCursor cursor) {}
-    void setWaitCursor(bool wait) {}
+  void setCursor(EMouseCursor cursor) {}
+  void setWaitCursor(bool wait) {}

-    void setWindowFrameDefault() {}
-    void getWindowFrame(float& xOut, float& yOut, float& wOut, float& hOut) const
-    {
-        u32 width, height;
-        gfxGetFramebufferResolution(&width, &height);
-        xOut = 0;
-        yOut = 0;
-        wOut = width;
-        hOut = height;
-    }
-    void getWindowFrame(int& xOut, int& yOut, int& wOut, int& hOut) const
-    {
-        u32 width, height;
-        gfxGetFramebufferResolution(&width, &height);
-        xOut = 0;
-        yOut = 0;
-        wOut = width;
-        hOut = height;
-    }
-    void setWindowFrame(float x, float y, float w, float h) {}
-    void setWindowFrame(int x, int y, int w, int h) {}
-    float getVirtualPixelFactor() const { return 1.f; }
+  void setWindowFrameDefault() {}
+  void getWindowFrame(float& xOut, float& yOut, float& wOut, float& hOut) const {
+    u32 width, height;
+    gfxGetFramebufferResolution(&width, &height);
+    xOut = 0;
+    yOut = 0;
+    wOut = width;
+    hOut = height;
+  }
+  void getWindowFrame(int& xOut, int& yOut, int& wOut, int& hOut) const {
+    u32 width, height;
+    gfxGetFramebufferResolution(&width, &height);
+    xOut = 0;
+    yOut = 0;
+    wOut = width;
+    hOut = height;
+  }
+  void setWindowFrame(float x, float y, float w, float h) {}
+  void setWindowFrame(int x, int y, int w, int h) {}
+  float getVirtualPixelFactor() const { return 1.f; }

-    bool isFullscreen() const { return true; }
-    void setFullscreen(bool fs) {}
+  bool isFullscreen() const { return true; }
+  void setFullscreen(bool fs) {}

-    void claimKeyboardFocus(const int coord[2]) {}
-    bool clipboardCopy(EClipboardType type, const uint8_t* data, size_t sz) { return false; }
-    std::unique_ptr<uint8_t[]> clipboardPaste(EClipboardType type, size_t& sz) { return {}; }
+  void claimKeyboardFocus(const int coord[2]) {}
+  bool clipboardCopy(EClipboardType type, const uint8_t* data, size_t sz) { return false; }
+  std::unique_ptr<uint8_t[]> clipboardPaste(EClipboardType type, size_t& sz) { return {}; }

-    void waitForRetrace() {}
+  void waitForRetrace() {}

-    uintptr_t getPlatformHandle() const { return 0; }
-    bool _incomingEvent(void* event) {(void)event; return false;}
-    void _cleanup() {}
+  uintptr_t getPlatformHandle() const { return 0; }
+  bool _incomingEvent(void* event) {
+    (void)event;
+    return false;
+  }
+  void _cleanup() {}

-    ETouchType getTouchType() const { return ETouchType::Display; }
+  ETouchType getTouchType() const { return ETouchType::Display; }

-    void setStyle(EWindowStyle style) {}
-    EWindowStyle getStyle() const { return EWindowStyle::None; }
+  void setStyle(EWindowStyle style) {}
+  EWindowStyle getStyle() const { return EWindowStyle::None; }

-    void setTouchBarProvider(void*) {}
+  void setTouchBarProvider(void*) {}

-    IGraphicsCommandQueue* getCommandQueue() { return m_gfxCtx->getCommandQueue(); }
-    IGraphicsDataFactory* getDataFactory() { return m_gfxCtx->getDataFactory(); }
-    IGraphicsDataFactory* getMainContextDataFactory() { return m_gfxCtx->getMainContextDataFactory(); }
-    IGraphicsDataFactory* getLoadContextDataFactory() { return m_gfxCtx->getLoadContextDataFactory(); }
+  IGraphicsCommandQueue* getCommandQueue() { return m_gfxCtx->getCommandQueue(); }
+  IGraphicsDataFactory* getDataFactory() { return m_gfxCtx->getDataFactory(); }
+  IGraphicsDataFactory* getMainContextDataFactory() { return m_gfxCtx->getMainContextDataFactory(); }
+  IGraphicsDataFactory* getLoadContextDataFactory() { return m_gfxCtx->getLoadContextDataFactory(); }
 };

-std::shared_ptr<IWindow> _WindowNXNew(std::string_view title, NXContext* nxCtx)
-{
-    std::shared_ptr<IWindow> ret = std::make_shared<WindowNX>(title, nxCtx);
-    return ret;
+std::shared_ptr<IWindow> _WindowNXNew(std::string_view title, NXContext* nxCtx) {
+  std::shared_ptr<IWindow> ret = std::make_shared<WindowNX>(title, nxCtx);
+  return ret;
 }

-}
+} // namespace boo