plusui-native-core 0.1.4 → 0.1.7

package/Core/include/plusui/webgpu.hpp

@@ -0,0 +1,434 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <functional>
+#include <optional>
+
+namespace plusui {
+
+// Forward declarations for WebGPU types
+class WebGPU;
+
+/**
+ * @brief Configuration options for WebGPU initialization
+ */
+struct WebGPUConfig {
+    /// Enable WebGPU feature
+    bool enabled = false;
+
+    /// Enable API validation in debug builds
+    bool validateAPI = true;
+
+    /// Enable verbose logging for debugging
+    bool verbose = false;
+};
+
+/**
+ * @brief WebGPU Resource Manager
+ *
+ * Manages GPU resources and provides access to WebGPU API.
+ * Uses handle-based resource management to support JSON-RPC communication.
+ */
+class WebGPU {
+public:
+    WebGPU();
+    ~WebGPU();
+
+    // Prevent copying but allow moving
+    WebGPU(const WebGPU&) = delete;
+    WebGPU& operator=(const WebGPU&) = delete;
+    WebGPU(WebGPU&&) noexcept;
+    WebGPU& operator=(WebGPU&&) noexcept;
+
+    /**
+     * @brief Create a WebGPU instance with configuration
+     * @param config WebGPU configuration options
+     * @return New WebGPU instance
+     */
+    static WebGPU create(const WebGPUConfig& config);
+
+    /**
+     * @brief Initialize the WebGPU subsystem
+     * @return true if initialization successful, false otherwise
+     */
+    bool initialize();
+
+    /**
+     * @brief Destroy all GPU resources and shut down WebGPU
+     */
+    void destroy();
+
+    /**
+     * @brief Check if WebGPU is initialized and available
+     * @return true if WebGPU is ready to use
+     */
+    bool isAvailable() const;
+
+    // ========================================================================
+    // Adapter API
+    // ========================================================================
+
+    /**
+     * @brief Request a GPU adapter with specified options
+     * @param options JSON string with request options (e.g., power preference)
+     * @return JSON string with adapter info and handle, or empty string if failed
+     */
+    std::string requestAdapter(const std::string& options);
+
+    /**
+     * @brief Get all available GPU adapters
+     * @return JSON string with array of adapters
+     */
+    std::string getAdapters();
+
+    // ========================================================================
+    // Device API
+    // ========================================================================
+
+    /**
+     * @brief Request a logical GPU device from an adapter
+     * @param adapterId Adapter handle (from requestAdapter)
+     * @param descriptor JSON string with device descriptor
+     * @return JSON string with device info and handle, or empty string if failed
+     */
+    std::string requestDevice(const std::string& adapterId, const std::string& descriptor);
+
+    /**
+     * @brief Get device info and features
+     * @param deviceId Device handle
+     * @return JSON string with device information
+     */
+    std::string getDeviceInfo(const std::string& deviceId);
+
+    // ========================================================================
+    // Buffer API
+    // ========================================================================
+
+    /**
+     * @brief Create a GPU buffer
+     * @param deviceId Device handle
+     * @param descriptor JSON string with buffer descriptor
+     * @return Buffer handle (string ID), or empty string if failed
+     */
+    std::string createBuffer(const std::string& deviceId, const std::string& descriptor);
+
+    /**
+     * @brief Write data to a GPU buffer
+     * @param bufferId Buffer handle
+     * @param offset Offset in bytes
+     * @param data Raw binary data as base64 or hex string
+     * @return true if successful
+     */
+    bool writeBuffer(const std::string& bufferId, uint32_t offset, const std::string& data);
+
+    /**
+     * @brief Map a buffer for CPU access
+     * @param bufferId Buffer handle
+     * @param mode Access mode ("read" or "write")
+     * @return true if mapping successful
+     */
+    bool mapBuffer(const std::string& bufferId, const std::string& mode);
+
+    /**
+     * @brief Unmap a previously mapped buffer
+     * @param bufferId Buffer handle
+     * @return true if unmapping successful
+     */
+    bool unmapBuffer(const std::string& bufferId);
+
+    /**
+     * @brief Get mapped buffer data
+     * @param bufferId Buffer handle
+     * @return Data as base64 or hex string
+     */
+    std::string getMappedBufferData(const std::string& bufferId);
+
+    // ========================================================================
+    // Texture API
+    // ========================================================================
+
+    /**
+     * @brief Create a GPU texture
+     * @param deviceId Device handle
+     * @param descriptor JSON string with texture descriptor
+     * @return Texture handle, or empty string if failed
+     */
+    std::string createTexture(const std::string& deviceId, const std::string& descriptor);
+
+    /**
+     * @brief Write data to a GPU texture
+     * @param textureId Texture handle
+     * @param descriptor JSON string with write descriptor
+     * @param data Raw texture data
+     * @return true if successful
+     */
+    bool writeTexture(const std::string& textureId, const std::string& descriptor, const std::string& data);
+
+    /**
+     * @brief Create a texture view
+     * @param textureId Texture handle
+     * @param descriptor JSON string with view descriptor
+     * @return Texture view handle
+     */
+    std::string createTextureView(const std::string& textureId, const std::string& descriptor);
+
+    // ========================================================================
+    // Sampler API
+    // ========================================================================
+
+    /**
+     * @brief Create a GPU sampler for texture sampling
+     * @param deviceId Device handle
+     * @param descriptor JSON string with sampler descriptor
+     * @return Sampler handle
+     */
+    std::string createSampler(const std::string& deviceId, const std::string& descriptor);
+
+    // ========================================================================
+    // Shader API
+    // ========================================================================
+
+    /**
+     * @brief Create a shader module from WGSL source code
+     * @param deviceId Device handle
+     * @param wgslSource WGSL shader source code
+     * @return Shader module handle, or empty string if compilation failed
+     */
+    std::string createShaderModule(const std::string& deviceId, const std::string& wgslSource);
+
+    /**
+     * @brief Get shader compilation errors
+     * @param shaderId Shader module handle
+     * @return Error messages as JSON string
+     */
+    std::string getShaderErrors(const std::string& shaderId);
+
+    // ========================================================================
+    // Pipeline API
+    // ========================================================================
+
+    /**
+     * @brief Create a render pipeline
+     * @param deviceId Device handle
+     * @param descriptor JSON string with pipeline descriptor
+     * @return Pipeline handle, or empty string if failed
+     */
+    std::string createRenderPipeline(const std::string& deviceId, const std::string& descriptor);
+
+    /**
+     * @brief Create a compute pipeline
+     * @param deviceId Device handle
+     * @param descriptor JSON string with pipeline descriptor
+     * @return Pipeline handle, or empty string if failed
+     */
+    std::string createComputePipeline(const std::string& deviceId, const std::string& descriptor);
+
+    /**
+     * @brief Get pipeline info
+     * @param pipelineId Pipeline handle
+     * @return Pipeline information as JSON
+     */
+    std::string getPipelineInfo(const std::string& pipelineId);
+
+    // ========================================================================
+    // Bind Group API
+    // ========================================================================
+
+    /**
+     * @brief Create a bind group layout
+     * @param deviceId Device handle
+     * @param descriptor JSON string with layout descriptor
+     * @return Layout handle
+     */
+    std::string createBindGroupLayout(const std::string& deviceId, const std::string& descriptor);
+
+    /**
+     * @brief Create a bind group
+     * @param deviceId Device handle
+     * @param descriptor JSON string with bind group descriptor
+     * @return Bind group handle
+     */
+    std::string createBindGroup(const std::string& deviceId, const std::string& descriptor);
+
+    // ========================================================================
+    // Surface API
+    // ========================================================================
+
+    /**
+     * @brief Create a GPU surface for rendering
+     * @param windowHandle Native window handle (HWND on Windows, NSView* on macOS, etc.)
+     * @param width Surface width
+     * @param height Surface height
+     * @return Surface handle
+     */
+    std::string createSurface(void* windowHandle, uint32_t width, uint32_t height);
+
+    /**
+     * @brief Configure a surface
+     * @param surfaceId Surface handle
+     * @param descriptor JSON string with configuration
+     * @return true if successful
+     */
+    bool configureSurface(const std::string& surfaceId, const std::string& descriptor);
+
+    /**
+     * @brief Resize a surface
+     * @param surfaceId Surface handle
+     * @param width New width
+     * @param height New height
+     * @return true if successful
+     */
+    bool resizeSurface(const std::string& surfaceId, uint32_t width, uint32_t height);
+
+    /**
+     * @brief Get the next texture from the swap chain
+     * @param surfaceId Surface handle
+     * @return Texture handle for current frame
+     */
+    std::string getNextTexture(const std::string& surfaceId);
+
+    // ========================================================================
+    // Command Encoding API
+    // ========================================================================
+
+    /**
+     * @brief Create a command encoder
+     * @param deviceId Device handle
+     * @return Command encoder handle
+     */
+    std::string createCommandEncoder(const std::string& deviceId);
+
+    /**
+     * @brief Begin a render pass
+     * @param encoderId Command encoder handle
+     * @param descriptor JSON string with render pass descriptor
+     * @return Render pass encoder handle
+     */
+    std::string beginRenderPass(const std::string& encoderId, const std::string& descriptor);
+
+    /**
+     * @brief End a render pass
+     * @param passId Render pass encoder handle
+     * @return true if successful
+     */
+    bool endRenderPass(const std::string& passId);
+
+    /**
+     * @brief Set the current render pipeline
+     * @param passId Render pass encoder handle
+     * @param pipelineId Pipeline handle
+     * @return true if successful
+     */
+    bool setRenderPipeline(const std::string& passId, const std::string& pipelineId);
+
+    /**
+     * @brief Set a bind group for rendering
+     * @param passId Render pass encoder handle
+     * @param groupIndex Bind group index
+     * @param bindGroupId Bind group handle
+     * @return true if successful
+     */
+    bool setBindGroup(const std::string& passId, uint32_t groupIndex, const std::string& bindGroupId);
+
+    /**
+     * @brief Set vertex buffer
+     * @param passId Render pass encoder handle
+     * @param slot Vertex buffer slot
+     * @param bufferId Buffer handle
+     * @param offset Offset in buffer
+     * @return true if successful
+     */
+    bool setVertexBuffer(const std::string& passId, uint32_t slot, const std::string& bufferId, uint64_t offset);
+
+    /**
+     * @brief Set index buffer
+     * @param passId Render pass encoder handle
+     * @param bufferId Buffer handle
+     * @param format Index format ("uint16" or "uint32")
+     * @param offset Offset in buffer
+     * @return true if successful
+     */
+    bool setIndexBuffer(const std::string& passId, const std::string& bufferId, const std::string& format, uint64_t offset);
+
+    /**
+     * @brief Issue a draw command
+     * @param passId Render pass encoder handle
+     * @param vertexCount Number of vertices to draw
+     * @param instanceCount Number of instances
+     * @param firstVertex First vertex index
+     * @param firstInstance First instance index
+     * @return true if successful
+     */
+    bool draw(const std::string& passId, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+
+    /**
+     * @brief Issue an indexed draw command
+     * @param passId Render pass encoder handle
+     * @param indexCount Number of indices
+     * @param instanceCount Number of instances
+     * @param firstIndex First index
+     * @param baseVertex Base vertex offset
+     * @param firstInstance First instance index
+     * @return true if successful
+     */
+    bool drawIndexed(const std::string& passId, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t baseVertex, uint32_t firstInstance);
+
+    /**
+     * @brief Finish command encoding and get the command buffer
+     * @param encoderId Command encoder handle
+     * @return Command buffer handle
+     */
+    std::string finish(const std::string& encoderId);
+
+    // ========================================================================
+    // Queue API
+    // ========================================================================
+
+    /**
+     * @brief Submit command buffers to the GPU queue
+     * @param deviceId Device handle
+     * @param commandBufferIds JSON array of command buffer handles
+     * @return true if submission successful
+     */
+    bool submitCommands(const std::string& deviceId, const std::string& commandBufferIds);
+
+    /**
+     * @brief Present a surface
+     * @param surfaceId Surface handle
+     * @return true if presentation successful
+     */
+    bool presentSurface(const std::string& surfaceId);
+
+    // ========================================================================
+    // Resource Management
+    // ========================================================================
+
+    /**
+     * @brief Destroy a GPU resource
+     * @param handle Resource handle
+     * @return true if destroyed successfully
+     */
+    bool destroyResource(const std::string& handle);
+
+    /**
+     * @brief Destroy a device and all its resources
+     * @param deviceId Device handle
+     * @return true if destroyed successfully
+     */
+    bool destroyDevice(const std::string& deviceId);
+
+    /**
+     * @brief Get memory usage statistics
+     * @return JSON string with memory usage info
+     */
+    std::string getMemoryStats();
+
+private:
+    struct Impl;
+    std::shared_ptr<Impl> pImpl;
+};
+
+} // namespace plusui

package/Core/include/plusui/webview.hpp

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <functional>
+#include <future>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace plusui {
+
+class TrayManager;
+class WindowManager;
+class Window;
+
+struct WebViewConfig {
+  std::string userAgent = "";
+  bool devtools = true;
+  bool contextMenu = true;
+  bool javascript = true;
+  bool webSecurity = true;
+  bool allowFileAccess = false;
+  bool allowRemoteContent = true;
+  std::string dataPath = "";
+  int cacheSize = 100; // MB
+  bool scrollbars = true;  // Show/hide scrollbars
+
+  // App Builder style config
+  std::string title;
+  int width = 800;
+  int height = 600;
+  bool resizable = true;
+};
+
+class WebView {
+public:
+  using WindowId = uint64_t;
+
+  // Callback types
+  using VoidCallback = std::function<void()>;
+  using StringCallback = std::function<void(const std::string &result)>;
+  using BoolCallback = std::function<bool(const std::string &url)>;
+  using ErrorCallback = std::function<void(const std::string &error, int code)>;
+  using ConsoleCallback = std::function<void(
+      const std::string &message, int level, const std::string &source)>;
+  using JSCallback = std::function<std::string(const std::string &args)>;
+  using NavigationCallback = std::function<bool(const std::string &url)>;
+  using LoadCallback = std::function<void()>;
+
+  WebView();
+  // Constructor used by App::Builder
+  struct AppConfig;
+  // WebView(const AppConfig& config); // We'll handle this via create or
+  // similar
+
+  ~WebView();
+
+  // Move only
+  WebView(WebView &&other) noexcept;
+  WebView &operator=(WebView &&other) noexcept;
+  WebView(const WebView &) = delete;
+  WebView &operator=(const WebView &) = delete;
+
+  static WebView create(void *windowHandle, const WebViewConfig &config = {});
+
+  // Content loading
+  void loadURL(const std::string &url);
+  void loadHTML(const std::string &html);
+  void loadHTML(const std::string &html, const std::string &baseURL);
+  void loadFile(const std::string &filePath);
+  void navigate(const std::string &url);
+
+  // Navigation
+  void reload();
+  void stop();
+  void goBack();
+  void goForward();
+  bool canGoBack() const;
+  bool canGoForward() const;
+
+  // Scripting
+  void executeScript(const std::string &script);
+  void executeScript(const std::string &script, StringCallback callback);
+  void eval(const std::string &js) {
+    executeScript(js);
+  } // Alias for compatibility
+
+  template <typename T> std::future<T> evaluate(const std::string &js) {
+    // Implementation in cpp or inline
+    return std::future<T>();
+  }
+
+  // Bindings
+  void bind(const std::string &name, JSCallback callback);
+  void unbind(const std::string &name);
+
+  template <typename F> void expose(const std::string &name, F &&callback) {
+    // Implementation for simplified expose
+  }
+
+  // Dev tools
+  void openDevTools();
+  void closeDevTools();
+
+  // Events
+  void on(const std::string &event,
+          std::function<void(const std::string &)> callback);
+  void emit(const std::string &event, const std::string &data = "");
+
+  // Settings
+  void setUserAgent(const std::string &userAgent);
+  std::string getUserAgent() const;
+  void setZoom(double factor);
+  double getZoom() const;
+  void injectCSS(const std::string &css);
+
+  // Callbacks
+  void onNavigationStart(NavigationCallback callback);
+  void onNavigationComplete(LoadCallback callback);
+  void onLoadStart(LoadCallback callback);
+  void onLoadEnd(LoadCallback callback);
+  void onLoadError(ErrorCallback callback);
+  void onConsoleMessage(ConsoleCallback callback);
+
+  // State
+  bool isLoading() const;
+  std::string getURL() const;
+  std::string getTitle() const;
+  void *nativeHandle() const;
+  void *nativeWindow() { return nativeHandle(); } // Alias
+
+  // Features
+  void setWindow(std::shared_ptr<Window> win);
+  TrayManager &tray();
+  WindowManager &window();
+
+private:
+  struct Impl;
+  std::shared_ptr<Impl> pImpl;
+};
+
+} // namespace plusui

package/Core/include/plusui/window.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace plusui {
+
+struct WindowConfig {
+  std::string title = "PlusUI Window";
+  int x = -1;
+  int y = -1;
+  int width = 800;
+  int height = 600;
+  int minWidth = 100;
+  int minHeight = 100;
+  int maxWidth = -1;
+  int maxHeight = -1;
+  bool resizable = true;
+  bool minimizable = true;
+  bool maximizable = true;
+  bool closable = true;
+  bool alwaysOnTop = false;
+  bool center = true;
+  bool frame = true;
+  bool transparent = false;
+  bool decorations = true;
+  bool skipTaskbar = false;
+  double opacity = 1.0;
+  bool fullscreen = false;
+};
+
+struct WindowState {
+  int x = 0;
+  int y = 0;
+  int width = 0;
+  int height = 0;
+  bool isMinimized = false;
+  bool isMaximized = false;
+  bool isVisible = true;
+  bool isFocused = false;
+  bool isFullscreen = false;
+  bool isHidden = false;
+};
+
+class Window {
+public:
+  using MoveCallback = std::function<void(int x, int y)>;
+  using ResizeCallback = std::function<void(int w, int h)>;
+  using CloseCallback = std::function<void()>;
+  using FocusCallback = std::function<void(bool focused)>;
+  using StateCallback = std::function<void(const WindowState &state)>;
+
+  Window();
+  ~Window();
+
+  static Window create(const WindowConfig &config);
+
+  void setTitle(const std::string &title);
+  std::string getTitle() const;
+
+  void setSize(int width, int height);
+  void getSize(int &width, int &height) const;
+  void setMinSize(int width, int height);
+  void setMaxSize(int width, int height);
+
+  void setPosition(int x, int y);
+  void getPosition(int &x, int &y) const;
+  void center();
+
+  void setFullscreen(bool enabled);
+  bool isFullscreen() const;
+
+  void minimize();
+  void maximize();
+  void restore();
+  bool isMaximized() const;
+  bool isMinimized() const;
+
+  void show();
+  void hide();
+  bool isVisible() const;
+  bool isHidden() const;
+
+  void focus();
+  bool isFocused() const;
+
+  void setAlwaysOnTop(bool enabled);
+  void setResizable(bool enabled);
+  void setDecorations(bool enabled);
+  void setSkipTaskbar(bool enabled);
+  void setOpacity(double opacity);
+  void setIconFromMemory(const unsigned char *data, size_t size);
+
+  WindowState getState() const;
+
+  void onMove(MoveCallback callback);
+  void onResize(ResizeCallback callback);
+  void onClose(CloseCallback callback);
+  void onFocus(FocusCallback callback);
+  void onStateChange(StateCallback callback);
+
+  void *nativeHandle() const;
+
+private:
+  struct Impl;
+  std::shared_ptr<Impl> pImpl;
+};
+
+} // namespace plusui