5 files changed, 370 insertions, 10 deletions

diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index 06d8898..112e38b 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -403,6 +403,7 @@ VkFormat format_from_vertex_attr(vertex_attrib_type attr) {
 }
 
 gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) {
+  TRACE("GPU Graphics Pipeline creation");
   // Allocate
   gpu_pipeline_layout* layout =
       pipeline_layout_pool_alloc(&context.gpu_pools.pipeline_layouts, NULL);
diff --git a/src/renderer/backends/metal/backend_metal.h b/src/renderer/backends/metal/backend_metal.h
new file mode 100644
index 0000000..59b21d6
--- /dev/null
+++ b/src/renderer/backends/metal/backend_metal.h
@@ -0,0 +1,74 @@
+#pragma once
+#define CEL_REND_BACKEND_METAL
+#if defined(CEL_REND_BACKEND_METAL)
+
+#include "defines.h"
+#include "maths_types.h"
+#ifdef __OBJC__
+#import <Metal/Metal.h>
+#import <MetalKit/MetalKit.h>
+#import <QuartzCore/CAMetalLayer.h>
+#import <Foundation/Foundation.h>
+#else
+typedef void* id;
+#endif
+
+typedef struct gpu_swapchain {
+  u32x2 dimensions;
+  #ifdef __OBJC__
+  CAMetalLayer* swapchain;
+  #else
+  void* swapchain;
+  #endif
+} gpu_swapchain;
+typedef struct gpu_device {
+  /** @brief `device` gives us access to our GPU */
+  #ifdef __OBJC__
+  id<MTLDevice> id;
+  #else
+  void* id;
+  #endif
+} gpu_device;
+typedef struct gpu_pipeline_layout {
+  void* pad;
+} gpu_pipeline_layout;
+typedef struct gpu_pipeline {
+  #ifdef __OBJC__
+  id<MTLRenderPipelineState> pipeline_state;
+  #else
+  void* pipeline_state;
+  #endif
+} gpu_pipeline;
+typedef struct gpu_renderpass {
+  #ifdef __OBJC__
+  MTLRenderPassDescriptor* rpass_descriptor;
+  #else
+  void* rpass_descriptor;
+  #endif
+} gpu_renderpass;
+typedef struct gpu_cmd_encoder {
+  #ifdef __OBJC__
+  id<MTLCommandBuffer> cmd_buffer;
+  id<MTLRenderCommandEncoder> render_encoder;
+  #else
+  void* cmd_buffer;
+  void* render_encoder;
+  #endif
+} gpu_cmd_encoder;
+typedef struct gpu_cmd_buffer {
+  void* pad;
+} gpu_cmd_buffer;
+
+typedef struct gpu_buffer {
+  #ifdef __OBJC__
+  id<MTLBuffer> id;
+  #else
+  void* id;
+  #endif
+  u64 size;
+} gpu_buffer;
+typedef struct gpu_texture {
+  void* pad;
+} gpu_texture;
+
+#endif
\ No newline at end of file
diff --git a/src/renderer/backends/metal/backend_metal.m b/src/renderer/backends/metal/backend_metal.m
new file mode 100644
index 0000000..0e9399e
--- /dev/null
+++ b/src/renderer/backends/metal/backend_metal.m
@@ -0,0 +1,285 @@
+#include <assert.h>
+#define CEL_REND_BACKEND_METAL
+#if defined(CEL_REND_BACKEND_METAL)
+#include <stddef.h>
+#include "ral_types.h"
+#include "colours.h"
+#include <stdlib.h>
+#include "camera.h"
+#include "defines.h"
+#include "file.h"
+#include "log.h"
+#include "maths_types.h"
+#include "ral.h"
+
+#define GLFW_INCLUDE_NONE
+#define GLFW_EXPOSE_NATIVE_COCOA
+
+#include <GLFW/glfw3.h>
+#include <GLFW/glfw3native.h>
+
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+#import <MetalKit/MetalKit.h>
+#import <QuartzCore/CAMetalLayer.h>
+#include "backend_metal.h"
+
+// --- Handy macros
+#define BUFFER_GET(h) (buffer_pool_get(&context.resource_pools->buffers, h))
+#define TEXTURE_GET(h) (texture_pool_get(&context.resource_pools->textures, h))
+
+typedef struct metal_context {
+  GLFWwindow* window;
+  NSWindow* metal_window;
+  arena pool_arena;
+
+  gpu_device* device;
+  gpu_swapchain* swapchain;
+  id<CAMetalDrawable> surface;
+
+  id<MTLCommandQueue> command_queue;
+  gpu_cmd_encoder main_command_buf;
+  gpu_backend_pools gpu_pools;
+  struct resource_pools* resource_pools;
+} metal_context;
+
+static metal_context context;
+
+struct GLFWwindow;
+
+bool gpu_backend_init(const char *window_name, struct GLFWwindow *window) {
+  INFO("loading Metal backend");
+
+  memset(&context, 0, sizeof(metal_context));
+  context.window = window;
+
+ size_t pool_buffer_size = 1024 * 1024;
+  context.pool_arena = arena_create(malloc(pool_buffer_size), pool_buffer_size);
+
+  backend_pools_init(&context.pool_arena, &context.gpu_pools);
+  context.resource_pools = malloc(sizeof(struct resource_pools));
+  resource_pools_init(&context.pool_arena, context.resource_pools);
+
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+
+  glfwMakeContextCurrent(window);
+  // FIXME: glfwSetFramebufferSizeCallback(ren->window, framebuffer_size_callback);
+
+  // get a NSWindow pointer from GLFWwindow
+  NSWindow *nswindow = glfwGetCocoaWindow(window);
+  context.metal_window = nswindow;
+
+  // const id<MTLCommandQueue> queue = [gpu newCommandQueue];
+  // CAMetalLayer *swapchain = [CAMetalLayer layer];
+  // swapchain.device = gpu;
+  // swapchain.opaque = YES;
+
+  // // set swapchain for the window
+  // nswindow.contentView.layer = swapchain;
+  // nswindow.contentView.wantsLayer = YES;
+
+  // MTLClearColor color = MTLClearColorMake(0.7, 0.1, 0.2, 1.0);
+
+  // // set all our state properties
+  // state->device = gpu;
+  // state->cmd_queue = queue;
+  // state->swapchain = swapchain;
+  // state->clear_color = color;
+
+  // NSError *err = 0x0; // TEMPORARY
+
+  // WARN("About to try loading metallib");
+  // id<MTLLibrary> defaultLibrary = [state->device newLibraryWithFile: @"build/gfx.metallib" error:&err];
+  // CASSERT(defaultLibrary);
+  // state->default_lib = defaultLibrary;
+  // if (!state->default_lib) {
+  //     NSLog(@"Failed to load library");
+  //     exit(0);
+  // }
+
+  // create_render_pipeline(state);
+
+  return true;
+}
+
+void gpu_backend_shutdown() {}
+
+bool gpu_device_create(gpu_device* out_device) {
+  TRACE("GPU Device creation");
+  const id<MTLDevice> gpu = MTLCreateSystemDefaultDevice();
+  out_device->id = gpu;
+  context.device = out_device;
+
+  const id<MTLCommandQueue> queue = [gpu newCommandQueue];
+  context.command_queue = queue;
+
+  return true;
+}
+void gpu_device_destroy() {}
+
+// --- Render Pipeline
+gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) {
+  TRACE("GPU Graphics Pipeline creation");
+  // Allocate
+  // gpu_pipeline_layout* layout =
+  //     pipeline_layout_pool_alloc(&context.gpu_pools.pipeline_layouts, NULL);
+  gpu_pipeline* pipeline = pipeline_pool_alloc(&context.gpu_pools.pipelines, NULL);
+
+  WARN("About to try loading metallib");
+  assert(description.vs.is_combined_vert_frag);
+  // Ignore fragment shader data, as vert shader data contains both
+  NSError *err = 0x0; // TEMPORARY
+  NSString *myNSString = [NSString stringWithUTF8String:(char*)description.vs.filepath.buf];
+  id<MTLLibrary> default_library = [context.device->id newLibraryWithFile:myNSString error:&err];
+  assert(default_library);
+
+  // setup vertex and fragment shaders
+  id<MTLFunction> ren_vert = [default_library newFunctionWithName:@"basic_vertex"];
+  assert(ren_vert);
+  id<MTLFunction> ren_frag = [default_library newFunctionWithName:@"basic_fragment"];
+  assert(ren_frag);
+
+  // create pipeline descriptor
+  @autoreleasepool {
+    NSError *err = 0x0;
+    MTLRenderPipelineDescriptor *pld = [[MTLRenderPipelineDescriptor alloc] init];
+    NSString *pipeline_name = [NSString stringWithUTF8String: description.debug_name];
+    pld.label = pipeline_name;
+    pld.vertexFunction = ren_vert;
+    pld.fragmentFunction = ren_frag;
+    pld.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm;
+    pld.colorAttachments[0].blendingEnabled = YES;
+
+    MTLDepthStencilDescriptor *depthStencilDescriptor = [MTLDepthStencilDescriptor new];
+    depthStencilDescriptor.depthCompareFunction = MTLCompareFunctionLess;
+    depthStencilDescriptor.depthWriteEnabled = YES;
+    pld.depthAttachmentPixelFormat = MTLPixelFormatDepth32Float_Stencil8;
+
+    id<MTLDepthStencilState> depth_descriptor = [context.device->id newDepthStencilStateWithDescriptor:depthStencilDescriptor];
+    // FIXME: state->depth_state = depth_descriptor;
+
+    id<MTLRenderPipelineState> pipeline_state = [context.device->id newRenderPipelineStateWithDescriptor:pld error:&err];
+    TRACE("created renderpipelinestate");
+    pipeline->pipeline_state = pipeline_state;
+
+  }
+
+  return pipeline;
+}
+void gpu_pipeline_destroy(gpu_pipeline* pipeline) {}
+
+// --- Renderpass
+gpu_renderpass* gpu_renderpass_create(const gpu_renderpass_desc* description) {
+  gpu_renderpass* renderpass = renderpass_pool_alloc(&context.gpu_pools.renderpasses, NULL);
+
+  // TODO: Configure based on description
+   // set up render pass
+  context.surface = [context.swapchain->swapchain nextDrawable];
+  MTLRenderPassDescriptor *renderPassDescriptor = [[MTLRenderPassDescriptor alloc] init];
+  MTLRenderPassColorAttachmentDescriptor *cd = renderPassDescriptor.colorAttachments[0];
+  [cd setTexture:context.surface.texture];
+  [cd setLoadAction:MTLLoadActionClear];
+  MTLClearColor clearColor = MTLClearColorMake(0.1, 0.1, 0.0, 1.0);
+  [cd setClearColor:clearColor];
+  [cd setStoreAction:MTLStoreActionStore];
+
+  renderpass->rpass_descriptor = renderPassDescriptor;
+
+  return renderpass;
+}
+
+void gpu_renderpass_destroy(gpu_renderpass* pass) {}
+
+// --- Swapchain
+bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {
+  TRACE("GPU Swapchain creation");
+  CAMetalLayer *swapchain = [CAMetalLayer layer];
+  swapchain.device = context.device->id;
+  swapchain.opaque = YES;
+  out_swapchain->swapchain = swapchain;
+
+  // set swapchain for the window
+  context.metal_window.contentView.layer = swapchain;
+  context.metal_window.contentView.wantsLayer = YES;
+
+  context.swapchain = out_swapchain;
+  return true;
+}
+void gpu_swapchain_destroy(gpu_swapchain* swapchain) {}
+
+// --- Command buffer
+gpu_cmd_encoder gpu_cmd_encoder_create() {
+  id <MTLCommandBuffer> cmd_buffer = [context.command_queue commandBuffer];
+  
+  return (gpu_cmd_encoder) {
+    .cmd_buffer = cmd_buffer
+  };
+}
+void gpu_cmd_encoder_destroy(gpu_cmd_encoder* encoder) {}
+void gpu_cmd_encoder_begin(gpu_cmd_encoder encoder) { /* no-op */ }
+void gpu_cmd_encoder_begin_render(gpu_cmd_encoder* encoder, gpu_renderpass* renderpass) {
+  DEBUG("Create Render Command Encoder");
+  id<MTLRenderCommandEncoder> render_encoder = [encoder->cmd_buffer renderCommandEncoderWithDescriptor:renderpass->rpass_descriptor];
+  encoder->render_encoder = render_encoder;
+  // [encoder setDepthStencilState:state->depth_state];
+}
+void gpu_cmd_encoder_end_render(gpu_cmd_encoder* encoder) {}
+void gpu_cmd_encoder_begin_compute() {}
+gpu_cmd_encoder* gpu_get_default_cmd_encoder() {
+  return &context.main_command_buf;
+}
+
+/** @brief Finish recording and return a command buffer that can be submitted to a queue */
+gpu_cmd_buffer gpu_cmd_encoder_finish(gpu_cmd_encoder* encoder) {}
+
+void gpu_queue_submit(gpu_cmd_buffer* buffer) {}
+
+void encode_buffer_copy(gpu_cmd_encoder* encoder, buffer_handle src, u64 src_offset,
+                        buffer_handle dst, u64 dst_offset, u64 copy_size);
+void buffer_upload_bytes(buffer_handle gpu_buf, bytebuffer cpu_buf, u64 offset, u64 size);
+
+void copy_buffer_to_buffer_oneshot(buffer_handle src, u64 src_offset, buffer_handle dst,
+                                   u64 dst_offset, u64 copy_size);
+void copy_buffer_to_image_oneshot(buffer_handle src, texture_handle dst);
+
+void encode_bind_pipeline(gpu_cmd_encoder* encoder, pipeline_kind kind, gpu_pipeline* pipeline) {}
+void encode_bind_shader_data(gpu_cmd_encoder* encoder, u32 group, shader_data* data) {}
+void encode_set_default_settings(gpu_cmd_encoder* encoder) {
+  [encoder->render_encoder setCullMode:MTLCullModeBack];
+}
+void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {
+  gpu_buffer* vertex_buf = BUFFER_GET(buf);
+  [encoder->render_encoder setVertexBuffer:vertex_buf->id offset:0 atIndex:0];
+}
+void encode_set_index_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {}
+void encode_set_bind_group() {}
+void encode_draw(gpu_cmd_encoder* encoder) {}
+void encode_draw_indexed(gpu_cmd_encoder* encoder, u64 index_count) {}
+void encode_clear_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {}
+
+buffer_handle gpu_buffer_create(u64 size, gpu_buffer_type buf_type, gpu_buffer_flags flags,
+                                const void* data) {
+  buffer_handle handle;
+  gpu_buffer* buffer = buffer_pool_alloc(&context.resource_pools->buffers, &handle);
+  buffer->size = size;
+
+  id<MTLBuffer> mtl_vert_buf = [context.device->id newBufferWithBytes:data
+      length: size
+      options:MTLResourceStorageModeShared];
+  return handle;
+}
+void gpu_buffer_destroy(buffer_handle buffer) {}
+void gpu_buffer_upload(const void* data) {}
+
+texture_handle gpu_texture_create(texture_desc desc, bool create_view, const void* data) {}
+void gpu_texture_destroy(texture_handle) {}
+void gpu_texture_upload(texture_handle texture, const void* data) {}
+
+bool gpu_backend_begin_frame() {
+  context.main_command_buf.cmd_buffer = [context.command_queue commandBuffer];
+  return true;
+  }
+void gpu_backend_end_frame() {}
+void gpu_temp_draw(size_t n_verts) {}
+
+#endif
\ No newline at end of file
diff --git a/src/renderer/backends/opengl/backend_opengl.c b/src/renderer/backends/opengl/backend_opengl.c
index 8be1c2a..96415f1 100644
--- a/src/renderer/backends/opengl/backend_opengl.c
+++ b/src/renderer/backends/opengl/backend_opengl.c
@@ -2,7 +2,7 @@
 #include "colours.h"
 #include "opengl_helpers.h"
 #include "ral_types.h"
-#define CEL_REND_BACKEND_OPENGL
+// #define CEL_REND_BACKEND_OPENGL
 #if defined(CEL_REND_BACKEND_OPENGL)
 #include <stdlib.h>
 #include "camera.h"
diff --git a/src/renderer/backends/opengl/opengl_helpers.h b/src/renderer/backends/opengl/opengl_helpers.h
index 2f6bef3..44d40cb 100644
--- a/src/renderer/backends/opengl/opengl_helpers.h
+++ b/src/renderer/backends/opengl/opengl_helpers.h
@@ -1,36 +1,36 @@
 #pragma once
-#include "ral_types.h"
 #include <glad/glad.h>
 #include <glfw3.h>
+#include "ral_types.h"
 typedef struct opengl_vertex_attr {
   u32 count;
   GLenum data_type;
-} opengl_vertex_attr ;
+} opengl_vertex_attr;
 opengl_vertex_attr format_from_vertex_attr(vertex_attrib_type attr) {
   switch (attr) {
     case ATTR_F32:
-      return (opengl_vertex_attr){.count = 1, .data_type = GL_FLOAT };
+      return (opengl_vertex_attr){ .count = 1, .data_type = GL_FLOAT };
     case ATTR_U32:
-      return (opengl_vertex_attr){.count = 1, .data_type = GL_UNSIGNED_INT };
+      return (opengl_vertex_attr){ .count = 1, .data_type = GL_UNSIGNED_INT };
     case ATTR_I32:
-      return (opengl_vertex_attr){.count = 1, .data_type = GL_INT };
+      return (opengl_vertex_attr){ .count = 1, .data_type = GL_INT };
     case ATTR_F32x2:
-      return (opengl_vertex_attr){.count = 2, .data_type = GL_FLOAT };
+      return (opengl_vertex_attr){ .count = 2, .data_type = GL_FLOAT };
     case ATTR_U32x2:
       // return VK_FORMAT_R32G32_UINT;
     case ATTR_I32x2:
       // return VK_FORMAT_R32G32_UINT;
     case ATTR_F32x3:
-      return (opengl_vertex_attr){.count = 3, .data_type = GL_FLOAT };
+      return (opengl_vertex_attr){ .count = 3, .data_type = GL_FLOAT };
     case ATTR_U32x3:
       // return VK_FORMAT_R32G32B32_UINT;
     case ATTR_I32x3:
       // return VK_FORMAT_R32G32B32_SINT;
     case ATTR_F32x4:
-      return (opengl_vertex_attr){.count = 4, .data_type = GL_FLOAT };
+      return (opengl_vertex_attr){ .count = 4, .data_type = GL_FLOAT };
     case ATTR_U32x4:
       // return VK_FORMAT_R32G32B32A32_UINT;
     case ATTR_I32x4:
-      // return VK_FORMAT_R32G32B32A32_SINT;
+      return (opengl_vertex_attr){ .count = 4, .data_type = GL_INT }; 
   }
 }
\ No newline at end of file