Re-add metal backend

This also adds dummy placeholders for DX12 and WebGPU ;-)

engine/gfx/CMakeLists.txt

@@ -16,6 +16,12 @@ add_custom_target(GFXInterface SOURCES
     public/gfx_sampler.hpp)
 set_target_properties(GFXInterface PROPERTIES CMAKE_FOLDER "GFX")
 
+add_subdirectory(dummy)
+
+if(ENABLE_DX12)
+    add_subdirectory(dx12)
+endif()
+
 if(ENABLE_METAL)
     add_subdirectory(metal)
 endif()
@@ -23,3 +29,7 @@ endif()
 if(ENABLE_VULKAN)
    add_subdirectory(vulkan)
 endif()
+
+if(ENABLE_WEBGPU)
+   add_subdirectory(webgpu)
+endif()

engine/gfx/dx12/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_library(GFXDX12 STATIC src/gfx_dummy.cpp)
+target_include_directories(GFXDX12 PUBLIC include)
+target_link_libraries(GFXDX12 PUBLIC GFX)

engine/gfx/dx12/include/gfx_dummy.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "gfx.hpp"
+
+class GFXDummy : public GFX {
+public:
+    bool initialize() override;
+	void initializeView(void* native_handle, uint32_t width, uint32_t height) override;
+
+    // buffer operations
+    GFXBuffer* createBuffer(void* data, GFXSize size, GFXBufferUsage usage) override;
+    void copyBuffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) override;
+    
+    // texture operations
+    GFXTexture* createTexture(uint32_t width, uint32_t height, GFXPixelFormat format, GFXStorageMode storageMode, GFXTextureUsage usage) override;
+    void copyTexture(GFXTexture* texture, void* data, GFXSize size) override;
+    
+    // framebuffer operations
+    GFXFramebuffer* createFramebuffer(GFXFramebufferCreateInfo& info) override;
+    
+    // render pass operations
+    GFXRenderPass* createRenderPass(GFXRenderPassCreateInfo& info) override;
+    
+    // pipeline operations
+    GFXPipeline* createPipeline(GFXPipelineCreateInfo& info) override;
+    
+    void render(GFXCommandBuffer* command_buffer) override;
+    
+    const char* getName() override;
+};

engine/gfx/dx12/src/gfx_dummy.cpp

@@ -0,0 +1,46 @@
+#include "gfx_dummy.hpp"
+
+bool GFXDummy::initialize() {
+	return true;
+}
+
+void GFXDummy::initializeView(void* native_handle, uint32_t width, uint32_t height) {
+       
+}
+
+GFXBuffer* GFXDummy::createBuffer(void* data, GFXSize size, GFXBufferUsage usage) {
+    return nullptr;
+}
+
+void GFXDummy::copyBuffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) {
+
+}
+
+GFXTexture* GFXDummy::createTexture(uint32_t width, uint32_t height, GFXPixelFormat format, GFXStorageMode storageMode, GFXTextureUsage usage) {
+    return nullptr;
+}
+
+void GFXDummy::copyTexture(GFXTexture* texture, void* data, GFXSize size) {
+
+}
+
+
+GFXFramebuffer* GFXDummy::createFramebuffer(GFXFramebufferCreateInfo& info) {
+    return nullptr;
+}
+
+GFXRenderPass* GFXDummy::createRenderPass(GFXRenderPassCreateInfo& info) {
+    return nullptr;
+}
+
+GFXPipeline* GFXDummy::createPipeline(GFXPipelineCreateInfo& info) {
+    return nullptr;
+}
+
+void GFXDummy::render(GFXCommandBuffer* command_buffer) {
+
+}
+
+const char* GFXDummy::getName() {
+    return "None";
+}

engine/gfx/metal/CMakeLists.txt

@@ -0,0 +1,29 @@
+set(SRC
+    include/gfx_metal.hpp
+    
+    src/gfx_metal.mm
+    src/gfx_metal_buffer.hpp
+    src/gfx_metal_pipeline.hpp
+    src/gfx_metal_texture.hpp
+    src/gfx_metal_framebuffer.hpp
+    src/gfx_metal_renderpass.hpp
+    src/gfx_metal_sampler.hpp)
+
+add_library(GFXMetal STATIC
+    ${SRC})
+
+set_target_properties(GFXMetal PROPERTIES
+    FRAMEWORK TRUE
+    FRAMEWORK_VERSION OBJC
+    PUBLIC_HEADER "${HEADERS}"
+)
+target_link_libraries(GFXMetal PUBLIC
+    GFX
+    Core
+    Log
+    "-framework Metal")
+target_include_directories(GFXMetal PUBLIC
+    include
+    PRIVATE
+    src)
+set_engine_properties(GFXMetal)

engine/gfx/metal/include/gfx_metal.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <Metal/Metal.h>
+#include <MetalKit/MetalKit.h>
+
+#include "gfx.hpp"
+
+class GFXMetal : public GFX {
+public:
+    bool is_supported() override;
+    GFXContext required_context() override { return GFXContext::Metal; }
+    ShaderLanguage accepted_shader_language() override { return ShaderLanguage::MSL; }
+    const char* get_name() override;
+    
+    bool supports_feature(const GFXFeature feature) override;
+    
+    bool initialize(const GFXCreateInfo& createInfo) override;
+
+    void initialize_view(void* native_handle, const int identifier, const uint32_t width, const uint32_t height) override;
+    void remove_view(const int identifier) override;
+
+    // buffer operations
+    GFXBuffer* create_buffer(void* data, const GFXSize size, const bool dynamicData, const GFXBufferUsage usage) override;
+    void copy_buffer(GFXBuffer* buffer, void* data, const GFXSize offset, const GFXSize size) override;
+    
+    void* get_buffer_contents(GFXBuffer* buffer) override;
+    
+    // texture operations
+    GFXTexture* create_texture(const GFXTextureCreateInfo& info) override;
+    void copy_texture(GFXTexture* texture, void* data, GFXSize size) override;
+    void copy_texture(GFXTexture* from, GFXTexture* to) override;
+    void copy_texture(GFXTexture* from, GFXBuffer* to) override;
+    
+    // sampler opeations
+    GFXSampler* create_sampler(const GFXSamplerCreateInfo& info) override;
+
+    // framebuffer operations
+    GFXFramebuffer* create_framebuffer(const GFXFramebufferCreateInfo& info) override;
+    
+    // render pass operations
+    GFXRenderPass* create_render_pass(const GFXRenderPassCreateInfo& info) override;
+    
+    // pipeline operations
+    GFXPipeline* create_graphics_pipeline(const GFXGraphicsPipelineCreateInfo& info) override;
+    GFXPipeline* create_compute_pipeline(const GFXComputePipelineCreateInfo& info) override;
+
+    GFXCommandBuffer* acquire_command_buffer(bool for_presentation_use = false) override;
+    
+    void submit(GFXCommandBuffer* command_buffer, const int window = -1) override;
+        
+private:
+    struct NativeMTLView {
+        int identifier = -1;
+        CAMetalLayer* layer = nullptr;
+    };
+    
+    std::vector<NativeMTLView*> nativeViews;
+    
+    NativeMTLView* getNativeView(int identifier) {
+        for(auto& view : nativeViews) {
+            if(view->identifier == identifier)
+                return view;
+        }
+        
+        return nullptr;
+    }
+    
+    id<MTLDevice> device = nil;
+    id<MTLCommandQueue> command_queue = nil;
+};

engine/gfx/metal/src/gfx_metal_buffer.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "gfx_buffer.hpp"
+
+class GFXMetalBuffer : public GFXBuffer {
+public:
+    id<MTLBuffer> handles[3] = {nil, nil, nil};
+    bool dynamicData = false;
+    
+    id<MTLBuffer> get(int frameIndex) {
+        if(dynamicData) {
+            return handles[frameIndex];
+        } else {
+            return handles[0];
+        }
+    }
+};

engine/gfx/metal/src/gfx_metal_framebuffer.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <Metal/Metal.h>
+#include <vector>
+
+#include "gfx_framebuffer.hpp"
+
+class GFXMetalTexture;
+
+class GFXMetalFramebuffer : public GFXFramebuffer {
+public:
+    std::vector<GFXMetalTexture*> attachments;
+};

engine/gfx/metal/src/gfx_metal_pipeline.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "gfx_pipeline.hpp"
+
+class GFXMetalPipeline : public GFXPipeline {
+public:
+    std::string label;
+    
+    id<MTLRenderPipelineState> handle = nil;
+    id<MTLComputePipelineState> compute_handle = nil;
+    
+    MTLSize threadGroupSize;
+
+    id<MTLDepthStencilState> depthStencil = nil;
+    MTLPrimitiveType primitiveType;
+
+    MTLCullMode cullMode;
+    GFXWindingMode winding_mode;
+
+    struct VertexStride {
+        int location, stride;
+    };
+    
+    std::vector<VertexStride> vertexStrides;
+    
+    int pushConstantSize = 0;
+    int pushConstantIndex = 0;
+    
+    bool renderWire = false;
+};

engine/gfx/metal/src/gfx_metal_renderpass.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "gfx_renderpass.hpp"
+
+class GFXMetalRenderPass : public GFXRenderPass {
+public:
+    std::vector<MTLPixelFormat> attachments;
+};

engine/gfx/metal/src/gfx_metal_sampler.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "gfx_sampler.hpp"
+
+class GFXMetalSampler : public GFXSampler {
+public:
+    id<MTLSamplerState> handle = nil;
+};

engine/gfx/metal/src/gfx_metal_texture.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "gfx_texture.hpp"
+
+class GFXMetalTexture : public GFXTexture {
+public:
+    id<MTLTexture> handle = nil;
+    id<MTLSamplerState> sampler = nil;
+
+    int array_length = 1;
+    bool is_cubemap = false;
+    
+    MTLPixelFormat format;
+};

engine/gfx/webgpu/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_library(GFXWebGPU STATIC src/gfx_dummy.cpp)
+target_include_directories(GFXWebGPU PUBLIC include)
+target_link_libraries(GFXWebGPU PUBLIC GFX)

engine/gfx/webgpu/include/gfx_dummy.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "gfx.hpp"
+
+class GFXDummy : public GFX {
+public:
+    bool initialize() override;
+	void initializeView(void* native_handle, uint32_t width, uint32_t height) override;
+
+    // buffer operations
+    GFXBuffer* createBuffer(void* data, GFXSize size, GFXBufferUsage usage) override;
+    void copyBuffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) override;
+    
+    // texture operations
+    GFXTexture* createTexture(uint32_t width, uint32_t height, GFXPixelFormat format, GFXStorageMode storageMode, GFXTextureUsage usage) override;
+    void copyTexture(GFXTexture* texture, void* data, GFXSize size) override;
+    
+    // framebuffer operations
+    GFXFramebuffer* createFramebuffer(GFXFramebufferCreateInfo& info) override;
+    
+    // render pass operations
+    GFXRenderPass* createRenderPass(GFXRenderPassCreateInfo& info) override;
+    
+    // pipeline operations
+    GFXPipeline* createPipeline(GFXPipelineCreateInfo& info) override;
+    
+    void render(GFXCommandBuffer* command_buffer) override;
+    
+    const char* getName() override;
+};

engine/gfx/webgpu/src/gfx_dummy.cpp

@@ -0,0 +1,46 @@
+#include "gfx_dummy.hpp"
+
+bool GFXDummy::initialize() {
+	return true;
+}
+
+void GFXDummy::initializeView(void* native_handle, uint32_t width, uint32_t height) {
+       
+}
+
+GFXBuffer* GFXDummy::createBuffer(void* data, GFXSize size, GFXBufferUsage usage) {
+    return nullptr;
+}
+
+void GFXDummy::copyBuffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) {
+
+}
+
+GFXTexture* GFXDummy::createTexture(uint32_t width, uint32_t height, GFXPixelFormat format, GFXStorageMode storageMode, GFXTextureUsage usage) {
+    return nullptr;
+}
+
+void GFXDummy::copyTexture(GFXTexture* texture, void* data, GFXSize size) {
+
+}
+
+
+GFXFramebuffer* GFXDummy::createFramebuffer(GFXFramebufferCreateInfo& info) {
+    return nullptr;
+}
+
+GFXRenderPass* GFXDummy::createRenderPass(GFXRenderPassCreateInfo& info) {
+    return nullptr;
+}
+
+GFXPipeline* GFXDummy::createPipeline(GFXPipelineCreateInfo& info) {
+    return nullptr;
+}
+
+void GFXDummy::render(GFXCommandBuffer* command_buffer) {
+
+}
+
+const char* GFXDummy::getName() {
+    return "None";
+}