wjpu  Check-in [f41568d116]

 * 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.
 */

#include "glfw3webgpu.hpp"

#include <webgpu/webgpu.h>

#define WGPU_TARGET_MACOS 1
#define WGPU_TARGET_LINUX_X11 2
#define WGPU_TARGET_WINDOWS 3
#define WGPU_TARGET_LINUX_WAYLAND 4

#if WGPU_TARGET == WGPU_TARGET_MACOS
    {
        id metal_layer = NULL;
        NSWindow* ns_window = glfwGetCocoaWindow(window);
        [ns_window.contentView setWantsLayer : YES] ;
        metal_layer = [CAMetalLayer layer];
        [ns_window.contentView setLayer : metal_layer] ;
        
        WGPUSurfaceDescriptorFromMetalLayer nativeChainedStruct;
        WGPUChainedStruct generalChainedStruct;
        generalChainedStruct.next = NULL;
        generalChainedStruct.sType = WGPUSType_SurfaceDescriptorFromMetalLayer;
        nativeChainedStruct.chain = generalChainedStruct;
        nativeChainedStruct.layer = metal_layer;
        ///////////////////////////////////////
        WGPUSurfaceDescriptor desc;
        desc.label = NULL;
        desc.nextInChain = (const WGPUChainedStruct*)&nativeChainedStruct;
        return wgpuInstanceCreateSurface(instance, &desc);
/*
        return wgpuInstanceCreateSurface(
            instance,
            &(WGPUSurfaceDescriptor){
            .label = NULL,
                .nextInChain =
                (const WGPUChainedStruct*)&(
                    WGPUSurfaceDescriptorFromMetalLayer) {
                .chain =
                    (WGPUChainedStruct){
                        .next = NULL,
                        .sType = WGPUSType_SurfaceDescriptorFromMetalLayer,
                },
                .layer = metal_layer,
                /////////////////////
            },
        });
        */
    }
#elif WGPU_TARGET == WGPU_TARGET_LINUX_X11
    {
        Display* x11_display = glfwGetX11Display();
        Window x11_window = glfwGetX11Window(window);
        
        WGPUSurfaceDescriptorFromXlibWindow nativeChainedStruct;
        WGPUChainedStruct generalChainedStruct;
        generalChainedStruct.next = NULL;
        generalChainedStruct.sType = WGPUSType_SurfaceDescriptorFromXlibWindow;
        nativeChainedStruct.chain = generalChainedStruct;
        nativeChainedStruct.display = x11_display;
        nativeChainedStruct.window = x11_window;
        WGPUSurfaceDescriptor desc;
        desc.label = NULL;
        desc.nextInChain = (const WGPUChainedStruct*)&nativeChainedStruct;
        return wgpuInstanceCreateSurface(instance, &desc);
/*
        return wgpuInstanceCreateSurface(
            instance,
            &(WGPUSurfaceDescriptor){
            .label = NULL,
                .nextInChain =
                (const WGPUChainedStruct*)&(
                    WGPUSurfaceDescriptorFromXlibWindow) {
                .chain =
                    (WGPUChainedStruct){
                        .next = NULL,
                        .sType = WGPUSType_SurfaceDescriptorFromXlibWindow,
                },
                .display = x11_display,
                .window = x11_window,
            },
        });
        */
    }
#elif WGPU_TARGET == WGPU_TARGET_LINUX_WAYLAND
    {
        struct wl_display* wayland_display = glfwGetWaylandDisplay();
        struct wl_surface* wayland_surface = glfwGetWaylandWindow(window);
        
        WGPUSurfaceDescriptorFromWaylandSurface nativeChainedStruct;
        WGPUChainedStruct generalChainedStruct;
        generalChainedStruct.next = NULL;
        generalChainedStruct.sType = WGPUSType_SurfaceDescriptorFromWaylandSurface;
        nativeChainedStruct.chain = generalChainedStruct;
        nativeChainedStruct.display = wayland_display;
        nativeChainedStruct.surface = wayland_surface;
        WGPUSurfaceDescriptor desc;
        desc.label = NULL;
        desc.nextInChain = (const WGPUChainedStruct*)&nativeChainedStruct;
        return wgpuInstanceCreateSurface(instance, &desc);
/*
        return wgpuInstanceCreateSurface(
            instance,
            &(WGPUSurfaceDescriptor){
            .label = NULL,
                .nextInChain =
                (const WGPUChainedStruct*)&(
                    WGPUSurfaceDescriptorFromWaylandSurface) {
                .chain =
                    (WGPUChainedStruct){
                        .next = NULL,

                        .sType = WGPUSType_SurfaceDescriptorFromWaylandSurface,
              },
              .display = wayland_display,
              .surface = wayland_surface,
            },
    });
    */
  }
#elif WGPU_TARGET == WGPU_TARGET_WINDOWS
    {
        HWND hwnd = glfwGetWin32Window(window);
        HINSTANCE hinstance = GetModuleHandle(NULL);
        
        WGPUSurfaceDescriptorFromWindowsHWND nativeChainedStruct;
        WGPUChainedStruct generalChainedStruct;
        generalChainedStruct.next = NULL;
        generalChainedStruct.sType = WGPUSType_SurfaceDescriptorFromWindowsHWND;
        nativeChainedStruct.chain = generalChainedStruct;
        nativeChainedStruct.hinstance = hinstance;
        nativeChainedStruct.hwnd = hwnd;
        WGPUSurfaceDescriptor desc;
        desc.label = NULL;
        desc.nextInChain = (const WGPUChainedStruct*)&nativeChainedStruct;
        return wgpuInstanceCreateSurface(instance, &desc);
/*
return
  wgpuInstanceCreateSurface(
    instance,
    &(WGPUSurfaceDescriptor) {
      .label = NULL,
      .nextInChain =
        (const WGPUChainedStruct*)&(WGPUSurfaceDescriptorFromWindowsHWND) {

          .chain =
            (WGPUChainedStruct) {
              .next = NULL,
              .sType = WGPUSType_SurfaceDescriptorFromWindowsHWND,
            },
          .hinstance = hinstance,
          .hwnd = hwnd,
        },
      }
      );*/
    
  }
#else
#error "Unsupported WGPU_TARGET"
#endif
}

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef _glfw3_webgpu_h_
#define _glfw3_webgpu_h_

#include <webgpu/webgpu.hpp>
#include <GLFW/glfw3.h>

#ifdef __cplusplus
extern "C" {
#endif

/**

echo gen
call jpm run gen

echo build
call jpm build

set RUST_BACKTRACE=full
echo test
call jpm test

 
 :cppflags [;default-cflags
          ;cflags]
 
 :defines os-defines

 :source ["src/glfw.gen.cpp"
          "glfw3webgpu/glfw3webgpu.cpp"]
 :headers ["src/glfw.aux.hpp"
           "glfw3webgpu/glfw3webgpu.hpp"
           "glfw/include/GLFW/glfw3.h"
           "webgpu-release/include/webgpu/webgpu-release.h"
           "WebGPU-distribution-wgpu/include/webgpu/webgpu.h"
           "WebGPU-distribution-wgpu/include/webgpu/wgpu.h"]
 
 :lflags [;default-lflags
          ;lflags])

#include <janet.h>
#include <GLFW/glfw3.h>
#include <webgpu/webgpu.h>
#include <webgpu/webgpu-release.h>
#include <glfw3webgpu.hpp>

template <typename T>
T unwrap_wgpu(Janet wgpuHandle) {
  return (T)(janet_unwrap_u64(wgpuHandle));
}

template <typename T>

#  (c/include <webgpu/webgpu.h>)
#  see define in project.janet
#  (c/include <webgpu/webgpu-release.h>)
  
  (c/include "\"glfw.aux.hpp\"")
  #######################################
  
  (macex1 '(c/cfunction initialize-context
    :static
    ```Initializes the GLFW context,
    run once to setup the library.

    returns false on failure
    see: https://www.glfw.org/docs/latest/intro_guide.html#error_handling```
    [] -> :int
      (return (glfwInit))))
  ##################

  (macex1 '(c/cfunction terminate-context
    :static
    ```Terminates the GLFW context,
    run once to shutdown the context.
    If you need GLFW afterwards, call init again to start it back up.

    If init failed, this does not have to be called.

  
  (macex1 '(c/cfunction poll-events
    :static
    "polls for events"
    [] -> :Janet
      (glfwPollEvents)
      (return (janet_wrap_nil))))

  #######################################
  (macex1 '(c/cfunction get-wgpu-surface
    :static
    "uses a WGPUInstance and GLFWwindow to create a WGPUSurface which needs to be released via wgpu-release-surface"
    [instance:Janet window:pointer] -> :Janet
      (return
        (wrap_wgpu<WGPUSurface>
          (glfwGetWGPUSurface
            (unwrap_wgpu<WGPUInstance> instance)
            (cast GLFWwindow* window))))))
  ###################
  # WGPU ahead
  #######################################

  (macex1 '(c/cfunction wgpu-create-instance
    :static
    "returns a new wgpu instance which needs to be released via wgpu-release-instance"
    [] -> :Janet
      (def (desc WGPUInstanceDescriptor))
      (set desc.nextInChain NULL)
      (return (wrap_wgpu<WGPUInstance> (wgpuCreateInstance &desc)))))
   ###################

  (macex1 '(c/cfunction wgpu-release-instance
    :static
    "releases or drops the instance"
    [instance:Janet] -> :Janet
      (wgpuInstanceRelease (unwrap_wgpu<WGPUInstance> instance))
      (return (janet_wrap_nil))))
  ########################################












  (macex1 '(c/cfunction wgpu-release-surface
    :static
    "releases or drops the surface"
    [surface:Janet] -> :Janet
      (wgpuSurfaceRelease (unwrap_wgpu<WGPUSurface> surface))
      (return (janet_wrap_nil))))

    ""
    [swapChain:Janet] -> :Janet
      (wgpuSwapChainPresent
        (unwrap_wgpu<WGPUSwapChain> swapChain))
      (return (janet_wrap_nil))))

#textureview
  (macex1 '(c/cfunction wgpu-swapchain-get-current-textureview
    :static
    ""
    [swapChain:Janet] -> :Janet
      (return
        (wrap_wgpu<WGPUTextureView>
          (wgpuSwapChainGetCurrentTextureView
            (unwrap_wgpu<WGPUSwapChain>
              swapChain))))))

  (macex1 '(c/cfunction wgpu-release-textureview
    :static
    ""
    [textureview:Janet] -> :Janet
      (wgpuTextureViewRelease
        (unwrap_wgpu<WGPUTextureView> textureview))
      (return (janet_wrap_nil))))

(macex1 '(c/cfunction wgpu-get-example-renderpass
    :static
    ""
    [encoder:Janet nextTexture:Janet clear_color:table] -> :Janet
      #renderPassColorAttachment
      (def (renderPassColorAttachment WGPURenderPassColorAttachment))
      # The attachment is tied to the view returned by the swapchain, so that
      # the render pass draws directly on screen.

28-05-2023
https://eliemichel.github.io/LearnWebGPU/getting-started/the-command-queue.html
@993:
As of now, the wgpuQueueOnSubmittedWorkDone is not implemented by our wgpu-native backend. Using it will result in a null pointer exception so do not copy the above code block.
```
  )

  (macex1 '(c/cfunction wgpu-surface-get-preferred-format
    :static
    ""
    [surface:Janet adapter:Janet] -> :Janet
      (return
        (wrap_wgpu<WGPUTextureFormat>
          (wgpuSurfaceGetPreferredFormat
            (unwrap_wgpu<WGPUSurface> surface)

(use ../build/wjpu)
(import spork/test :as test)

(initialize-context)

(def GLFW_CLIENT_API 0x00022001)
(def GLFW_NO_API 0)

(hint-next-window GLFW_CLIENT_API GLFW_NO_API)

(def window (create-window 200 200 "welcome window"))
(unless window
  (terminate-context)
  (error "could not create window"))




(def wgpu-instance (wgpu-create-instance))
(unless wgpu-instance
  (destroy-window window)
  (terminate-context)
  (error "could not create instance"))

(def wgpu-surface (get-wgpu-surface wgpu-instance window))
(unless wgpu-surface
  (wgpu-release-instance wgpu-instance)
  (destroy-window window)
  (terminate-context)
  (error "could not create surface"))

(def wgpu-adapter (wgpu-get-adapter wgpu-instance wgpu-surface))
(unless wgpu-adapter
  (wgpu-release-surface wgpu-surface)
  (wgpu-release-instance wgpu-instance)
  (destroy-window window)
  (terminate-context)
  (error "could not create adapter"))

(printf "Found %q features" (wgpu-inspect-adapter wgpu-adapter))
#(wgpu-inspect-adapter wgpu-adapter)

(def wgpu-device (wgpu-get-device wgpu-adapter))
(unless wgpu-device
  (if wgpu-adapter
    (wgpu-release-adapter wgpu-adapter)
    (pp "adapter already gone"))
  (if wgpu-surface
    (wgpu-release-surface wgpu-surface)
    (pp "surface already gone"))
  (if wgpu-instance
    (wgpu-release-instance wgpu-instance)
    (pp "instance already gone"))
  (if window
    (destroy-window window)
    (pp "window already gone"))
  (terminate-context)
  (error "could not create device"))

(wgpu-device-set-uncaptured-error-callback wgpu-device)

(def wgpu-queue (wgpu-device-get-queue wgpu-device))

(print "wgpu-device-set-uncaptured-error-callback wgpu-device")

(def wgpu-swapchain (wgpu-device-create-swapchain wgpu-device wgpu-adapter wgpu-surface))



(def clear-color
  @{:r (math/random)
    :g (math/random)
    :b (math/random)
    :a 1.0})

(var nextTexture 0)
(var wgpu-commandencoder 0)
(var renderPass 0)

(test/timeit
  (while (not (close-window? window))
  ##(print "poll")
    (poll-events)
  ##(print "poll done")
  ##(print "T")
    (def nextTexture (wgpu-swapchain-get-current-textureview wgpu-swapchain))
    # Getting the texture may fail, in particular if the window has been resized
    # and thus the target surface changed.
    (when (nil? nextTexture)
      (printf "Cannot acquire next swap chain texture")
      (break))
  ##(print "E")
    (def wgpu-commandencoder (wgpu-device-create-command-encoder wgpu-device))

    (put clear-color :r (math/random))
    (put clear-color :g (math/random))
    (put clear-color :b (math/random))

  #(print "P")
    (def renderPass (wgpu-get-example-renderpass wgpu-commandencoder nextTexture clear-color))
  #(print "hellobug")
    (wgpu-render-pass-encoder-end renderPass)
  ##(print "D")
    (wgpu-release-textureview nextTexture)
  ###(print "debug")
    (wgpu-command-encoder-insert-debug-marker wgpu-commandencoder "hello world")
  ##(print "finish")
    (def cmdbuff (wgpu-command-encoder-finish-ref wgpu-commandencoder))

  ##(print "submit")
    (wgpu-queue-submit wgpu-queue 1 cmdbuff)
  ##(print "present")
    (wgpu-swapchain-present wgpu-swapchain)
  ##(print "presented")
    ))

(print "out of while")



(if wgpu-swapchain
  (wgpu-release-swapchain wgpu-swapchain)
  (pp "swapchain already gone"))
(if wgpu-device
  (wgpu-release-device wgpu-device)
  (pp "device already gone"))
(if wgpu-adapter
  (wgpu-release-adapter wgpu-adapter)
  (pp "adapter already gone"))
(if wgpu-surface
  (wgpu-release-surface wgpu-surface)
  (pp "surface already gone"))
(if wgpu-instance
  (wgpu-release-instance wgpu-instance)
  (pp "instance already gone"))
(if window
  (destroy-window window)
  (pp "window already gone"))

(terminate-context)