Implemented ShaderCompiler for Metal

Core/Application/Application.cpp

@@ -1,5 +1,4 @@
 #include "Application.h"
-#include <SDL_scancode.h>
 #include <chrono>
 #include <SDL2/SDL.h>
 
@@ -10,8 +9,8 @@ namespace CGL::Core
 	bool g_isTestMode{ false };
 
 	Application::Application(std::string_view name, i32 argc, char** argv)
-		: m_name(name)
-		, m_isRunning(true)
+		: m_isRunning(true)
+		, m_name(name)
 		, m_window(nullptr)
 	{
 		// Parse command line arguments

Core/Common.cpp

@@ -0,0 +1,10 @@
+
+#if defined (CGL_RHI_METAL)
+#define NS_PRIVATE_IMPLEMENTATION
+#define CA_PRIVATE_IMPLEMENTATION
+#define MTL_PRIVATE_IMPLEMENTATION
+
+#define EXCLUDE_STDHEADERS
+#include <Core/Common.h>
+
+#endif

Core/Common.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#ifndef EXCLUDE_STDHEADERS
 #include <cassert>
 #include <string>
 #include <string_view>
@@ -12,4 +13,10 @@
 #include <utility>
 
 #include <Core/Types.h>
-#include <Core/Math/Math.h>
+#endif
+
+#if defined (CGL_RHI_METAL)
+#include "Foundation/Foundation.hpp"
+#include "QuartzCore/QuartzCore.hpp"
+#include "Metal/Metal.hpp"
+#endif

Core/Graphics/Buffer.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Core/Graphics/Buffer.h>
+#include <Core/Graphics/Types.h>
 #include <Core/Types.h>
 
 #if defined(CGL_RHI_DX11)
@@ -23,6 +23,7 @@
 #if defined(CGL_RHI_METAL)
 #include <Core/Graphics/RHI/Metal/METALVertexBuffer.h>
 #include <Core/Graphics/RHI/Metal/METALIndexBuffer.h>
+#include <Core/Graphics/RHI/Metal/METALConstantBuffer.h>
 #endif
 
 #if defined(CGL_RHI_VULKAN)
@@ -55,10 +56,11 @@ namespace CGL::Graphics
 #elif defined(CGL_RHI_METAL)
 	using VertexBuffer = METALVertexBuffer;
 	using IndexBuffer  = METALIndexBuffer;
+	template <typename T> using ConstantBuffer = METALConstantBuffer<T>;
 #elif defined(CGL_RHI_VULKAN)
 	using VertexBuffer = VULKANVertexBuffer;
 	using IndexBuffer  = VULKANIndexBuffer;
 #else
 	#error Unsupported buffer types for RHI
 #endif
-}
+}

Core/Graphics/RHI/METALCommon.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Metal/MTLLibrary.hpp"
+#include <Metal/Metal.hpp>
+#include <memory>
+
+struct METALCompileObjects
+{
+    std::unique_ptr<MTL::Library*>& library;
+    MTL::Device* device;
+};

Core/Graphics/RHI/Metal/METALConstantBuffer.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Metal/MTLBuffer.hpp"
+
+namespace CGL::Graphics
+{
+    template <class T>
+    struct METALConstantBuffer
+    {
+        using value_type = T;
+
+        METALConstantBuffer()
+        {
+            static_assert((sizeof(T) % 16) == 0, "Constant buffer size must be 16-byte aligned.");
+        }
+
+        MTL::Buffer* Buffer;
+    };
+}

Core/Graphics/RHI/Metal/METALIndexBuffer.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Foundation/NSTypes.hpp"
+#include "Metal/MTLBuffer.hpp"
+
+namespace CGL::Graphics
+{
+    struct METALIndexBuffer
+    {
+        MTL::Buffer* Buffer;
+
+        NS::UInteger Offset;
+        NS::UInteger Index;
+    };
+}

Core/Graphics/RHI/Metal/METALPipelineHandler.cpp

@@ -0,0 +1,35 @@
+#include "METALPipelineHandler.h"
+#include "Foundation/NSError.hpp"
+#include "Foundation/NSString.hpp"
+
+namespace CGL::Graphics {
+
+    CGL_DEFINE_LOG_CATEGORY(METALPipelineHandler);
+
+    METALPipelineHandler::METALPipelineHandler() : m_rpDescriptor { nullptr }, m_rpState { nullptr }
+    {
+        m_rpDescriptor = MTL::RenderPipelineDescriptor::alloc()->init();
+
+        m_rpDescriptor->colorAttachments()->object(0)->setPixelFormat(MTL::PixelFormatRGBA8Unorm_sRGB);
+
+        CGL_LOG(METALPipelineHandler, Info, "RenderPipelineDescriptor Initialized");
+    }
+
+    void METALPipelineHandler::CreateRenderPipelineState(MTL::Device* gpu_device)
+    {
+        if(!m_rpDescriptor) return;
+
+        NS::Error* ns_error{};
+
+        m_rpState = gpu_device->newRenderPipelineState(m_rpDescriptor, &ns_error);
+
+        if(!m_rpState) {
+            CGL_LOG(METALPipelineHandler, Error, ns_error->localizedDescription()->utf8String());
+            return;
+        }
+
+        CGL_LOG(METALPipelineHandler, Info, "RenderPipelineState Created");
+        m_rpDescriptor->release();
+        m_rpDescriptor = nullptr;
+    }
+}

Core/Graphics/RHI/Metal/METALPipelineHandler.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Metal/MTLDevice.hpp"
+#include "Metal/MTLRenderPipeline.hpp"
+
+#include "Core/Logging/Log.h"
+
+namespace CGL::Graphics
+{
+    CGL_DECLARE_LOG_CATEGORY(METALPipelineHandler);
+
+    class METALPipelineHandler
+    {
+    public:
+        METALPipelineHandler();
+
+        inline auto GetRenderPipelineDescriptor() const { return m_rpDescriptor; }
+        inline auto GetRenderPipelineState() const { return m_rpState; }
+
+        void CreateRenderPipelineState(MTL::Device* gpu_device);
+
+    private:
+        MTL::RenderPipelineDescriptor* m_rpDescriptor;
+        MTL::RenderPipelineState* m_rpState;
+    };
+}

Core/Graphics/RHI/Metal/METALPixelShader.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Metal/MTLLibrary.hpp"
+
+namespace CGL::Graphics
+{
+    struct METALPixelShader
+    {
+        std::unique_ptr<MTL::Library*> SourceContent;
+        MTL::Function* Shader;
+    };
+}