Huge shader infrastructure refactor

lib/nx/ApplicationNX.cpp

@@ -0,0 +1,139 @@
+#include "boo/IApplication.hpp"
+#include "logvisor/logvisor.hpp"
+#include "nxstl/thread"
+#include "nxstl/condition_variable"
+#include "boo/graphicsdev/NX.hpp"
+#include <limits.h>
+
+#include <switch.h>
+
+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;
+
+    NXContext m_nxCtx;
+
+    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)
+    {}
+
+    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);
+
+        // 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;
+    }
+
+    std::string_view getUniqueName() const
+    {
+        return m_uniqueName;
+    }
+
+    std::string_view getFriendlyName() const
+    {
+        return m_friendlyName;
+    }
+
+    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());
+
+    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;
+}
+
+}

lib/nx/WindowNX.cpp

@@ -0,0 +1,120 @@
+#include "boo/IWindow.hpp"
+#include "boo/IGraphicsContext.hpp"
+#include "logvisor/logvisor.hpp"
+#include "boo/graphicsdev/NX.hpp"
+
+#include <switch.h>
+
+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;
+public:
+    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() {}
+
+    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;
+public:
+    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 closeWindow() {}
+    void showWindow() {}
+    void hideWindow() {}
+
+    SystemString getTitle() { return m_title; }
+    void setTitle(SystemStringView title) { m_title = title; }
+
+    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; }
+
+    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 waitForRetrace() {}
+
+    uintptr_t getPlatformHandle() const { return 0; }
+    bool _incomingEvent(void* event) {(void)event; return false;}
+    void _cleanup() {}
+
+    ETouchType getTouchType() const { return ETouchType::Display; }
+
+    void setStyle(EWindowStyle style) {}
+    EWindowStyle getStyle() const { return EWindowStyle::None; }
+
+    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(); }
+};
+
+std::shared_ptr<IWindow> _WindowNXNew(std::string_view title, NXContext* nxCtx)
+{
+    std::shared_ptr<IWindow> ret = std::make_shared<WindowNX>(title, nxCtx);
+    return ret;
+}
+
+}