feat: apple support

.gitignore

@@ -1,3 +1,6 @@
+# apple
+.DS_Store
+
 # cmake
 CMakeFiles/
 .cmake/

CMakeLists.txt

@@ -6,6 +6,8 @@ option (NRI_ENABLE_NVTX_SUPPORT "Annotations for NVIDIA Nsight Systems" OFF)
 
 # Options: backends
 option (NRI_ENABLE_NONE_SUPPORT "Enable NONE backend" ON)
+option (NRI_ENABLE_VK_SUPPORT "Enable VULKAN backend" ON)
+option (NRI_ENABLE_METAL_SUPPORT "Enable METAL backend" ON)
 option (NRI_ENABLE_D3D11_SUPPORT "Enable D3D11 backend" ON)
 option (NRI_ENABLE_D3D12_SUPPORT "Enable D3D12 backend" ON)
 option (NRI_ENABLE_VK_SUPPORT "Enable VULKAN backend" ON)
@@ -233,6 +235,25 @@ if (WIN32 AND NRI_ENABLE_D3D12_SUPPORT)
     endif ()
 endif ()
 
+# METAL
+if (NRI_ENABLE_METAL_SUPPORT AND APPLE) 
+    message ("NRI adding backend: METAL")
+    set (COMPILE_DEFINITIONS ${COMPILE_DEFINITIONS} NRI_USE_MTL=1)
+    file (GLOB MTL_SOURCE "Source/Metal/*.cpp" "Source/Metal/*.mm" "Source/Metal/*.h" "Source/Metal/*.hpp" )
+    source_group ("" FILES ${MTL_SOURCE})
+    add_library (NRI_MTL STATIC ${MTL_SOURCE})
+    target_link_libraries(NRI_MTL        
+        "-framework Metal"
+        "-framework MetalKit"
+        "-framework AppKit"
+        "-framework Foundation"
+        "-framework IOKit"
+        "-framework QuartzCore"
+    )
+    target_include_directories (NRI_MTL PRIVATE "Include" "Source/Shared" "External")
+    target_compile_definitions (NRI_MTL PRIVATE ${COMPILE_DEFINITIONS})
+endif()
+
 # VK
 if (NRI_ENABLE_VK_SUPPORT)
     message ("NRI adding backend: VK")
@@ -301,8 +322,14 @@ file (GLOB NRI_EXTENSIONS "Include/Extensions/*.h" "Include/Extensions/*.hpp")
 source_group ("Include/Extensions" FILES ${NRI_EXTENSIONS})
 
 file (GLOB NRI_SOURCE "Source/Creation/*.cpp" "Source/Creation/*.h")
+if (NRI_ENABLE_METAL_SUPPORT)
+    file (GLOB MTL_SOURCE "Source/Creation/*.mm")
+    list (APPEND NRI_SOURCE ${MTL_SOURCE})
+endif()
 source_group ("Sources" FILES ${NRI_SOURCE})
 
+
+
 file (GLOB NRI_RESOURCES "Resources/*")
 source_group ("Resources" FILES ${NRI_RESOURCES})
 
@@ -342,6 +369,9 @@ endif ()
 if (NRI_ENABLE_VK_SUPPORT)
     target_link_libraries (${PROJECT_NAME} PRIVATE NRI_VK)
 endif ()
+if (NRI_ENABLE_METAL_SUPPORT)
+    target_link_libraries (${PROJECT_NAME} PRIVATE NRI_MTL)
+endif ()
 
 set_property (TARGET ${PROJECT_NAME} PROPERTY FOLDER ${PROJECT_FOLDER})
 

Include/Extensions/NRIWrapperMTL.h

@@ -0,0 +1,62 @@
+// © 2021 NVIDIA Corporation
+
+#pragma once
+
+#include "NRIMacro.h"
+#include "NRIDeviceCreation.h"
+
+
+NriNamespaceBegin
+
+
+typedef void* MTLHeap;
+typedef void* MTLDeviceHandle; // id<MTLDevice>
+typedef void* MTLBufferHandle; // id<MTLHeap>
+typedef void* MTLTextureHandle;
+
+typedef uint32_t MTLEnum;
+
+NriStruct(DeviceCreationMTLDesc)
+{
+    bool enableNRIValidation;
+    MTLDeviceHandle MtlDevice;
+};
+
+NriStruct(CommandBufferMTLDesc)
+{
+
+};
+
+NriStruct(BufferMTLDesc)
+{
+  MTLBufferHandle buffer;
+  void* mappedMemory;
+  //MTLResourceOptions options; 
+};
+
+NriStruct(TextureMTLDesc)
+{
+    MTLTextureHandle mtlTexture;
+    MTLEnum textureType;
+    MTLEnum pixelFormat;
+    Nri(Dim_t) width;
+    Nri(Dim_t) height;
+    Nri(Dim_t) depth;
+    Nri(Mip_t) mipNum;
+    Nri(Dim_t) layerNum;
+    Nri(Sample_t) sampleNum;
+  //MTLTextureDescriptor* descriptor;
+};
+
+NriStruct(MemoryMTLDesc)
+{
+    uint64_t size;
+   // MTLStorageMode storage;
+
+  //MTLResourceOptions options; 
+};
+
+NRI_API Nri(Result) NRI_CALL nriCreateDeviceFromMtlDevice(const NriRef(DeviceCreationMTLDesc) deviceDesc, NriRef(Device*) device);
+
+NriNamespaceEnd
+

Include/NRIDescs.h

@@ -1,4 +1,4 @@
-// © 2021 NVIDIA Corporation
+// © 2021 NVIDIA Corporation
 
 #pragma once
 
@@ -76,7 +76,8 @@ NriEnum(GraphicsAPI, uint8_t,
     NONE,   // Supports everything, does nothing, returns dummy non-NULL objects and ~0-filled descs, available if "NRI_ENABLE_NONE_SUPPORT = ON" in CMake
     D3D11,  // Direct3D 11 (feature set 11.1), available if "NRI_ENABLE_D3D11_SUPPORT = ON" in CMake
     D3D12,  // Direct3D 12 (feature set 11.1+), available if "NRI_ENABLE_D3D12_SUPPORT = ON" in CMake
-    VK      // Vulkan 1.3 or 1.2+ (can be used on MacOS via MoltenVK), available if "NRI_ENABLE_VK_SUPPORT = ON" in CMake
+    VK,      // Vulkan 1.3 or 1.2+ (can be used on MacOS via MoltenVK), available if "NRI_ENABLE_VK_SUPPORT = ON" in CMake
+    MTL
 );
 
 NriEnum(Result, uint8_t,
@@ -685,9 +686,14 @@ NriStruct(VertexAttributeVK) {
     uint32_t location;
 };
 
+NriStruct(VertexAttributeMTL) {
+    uint32_t location;
+};
+
 NriStruct(VertexAttributeDesc) {
     Nri(VertexAttributeD3D) d3d;
     Nri(VertexAttributeVK) vk;
+    Nri(VertexAttributeMTL) mtl;
     uint32_t offset;
     Nri(Format) format;
     uint16_t streamIndex;
@@ -1284,12 +1290,17 @@ NriStruct(PipelineStatisticsDesc) {
 #pragma region [ Device desc ]
 //============================================================================================================================================================================================
 
+// defined in apple framework
+#undef INTEL
+#undef AMD
+
 NriEnum(Vendor, uint8_t,
     UNKNOWN,
     NVIDIA,
     AMD,
-    INTEL
-);
+    INTEL,
+    APPLE
+); 
 
 NriStruct(AdapterDesc) {
     char name[256];

Include/NRIMacro.h

@@ -202,6 +202,7 @@
         constexpr name operator | (name val0, name val1) { return (name)((type)val0 | (type)val1); } \
         constexpr name& operator &= (name& val0, name val1) { val0 = (name)(val0 & val1); return val0; } \
         constexpr name& operator |= (name& val0, name val1) { val0 = (name)(val0 | val1); return val0; } \
+        constexpr name operator ~(name val0) { return (name)(~(type)val0); } \
         enum class name : type { \
             _NRI_ENUM_EXPAND(__VA_ARGS__), \
         }

Source/Creation/Creation.cpp

@@ -18,6 +18,11 @@ Result CreateDeviceD3D12(const DeviceCreationDesc& deviceCreationDesc, DeviceBas
 Result CreateDeviceD3D12(const DeviceCreationD3D12Desc& deviceCreationDesc, DeviceBase*& device);
 #endif
 
+#if NRI_USE_MTL
+Result CreateDeviceMTL(const DeviceCreationDesc& deviceCreationDesc, DeviceBase*& device);
+Result CreateDeviceMTL(const DeviceCreationMTLDesc& deviceCreationDesc, DeviceBase*& device);
+#endif
+
 #if NRI_USE_VK
 Result CreateDeviceVK(const DeviceCreationDesc& deviceCreationDesc, DeviceBase*& device);
 Result CreateDeviceVK(const DeviceCreationVKDesc& deviceDesc, DeviceBase*& device);
@@ -216,6 +221,11 @@ NRI_API Result NRI_CALL nriCreateDevice(const DeviceCreationDesc& deviceCreation
     if (modifiedDeviceCreationDesc.graphicsAPI == GraphicsAPI::D3D12)
         result = CreateDeviceD3D12(modifiedDeviceCreationDesc, deviceImpl);
 #endif
+
+#if NRI_USE_MTL
+    if (modifiedDeviceCreationDesc.graphicsAPI == GraphicsAPI::MTL)
+        result = CreateDeviceMTL(modifiedDeviceCreationDesc, deviceImpl);
+#endif
 
 #if NRI_USE_VK
     if (modifiedDeviceCreationDesc.graphicsAPI == GraphicsAPI::VK)
@@ -284,6 +294,24 @@ NRI_API Result NRI_CALL nriCreateDeviceFromD3D12Device(const DeviceCreationD3D12
     return FinalizeDeviceCreation(deviceCreationDesc, *deviceImpl, device);
 }
 
+NRI_API Result NRI_CALL nriCreateDeviceFromMtlDevice(const DeviceCreationMTLDesc& deviceCreationMtlDesc, Device*& device) {
+    DeviceCreationDesc deviceCreationDesc = {};
+    deviceCreationDesc.graphicsAPI = GraphicsAPI::MTL;
+    deviceCreationDesc.enableNRIValidation = deviceCreationMtlDesc.enableNRIValidation;
+
+    Result result = Result::UNSUPPORTED;
+    DeviceBase* deviceImpl = nullptr;
+
+#if NRI_USE_MTL
+    //result = CreateDeviceD3D12(tempDeviceCreationD3D12Desc, deviceImpl);
+#endif
+
+    if (result != Result::SUCCESS)
+        return result;
+
+    return FinalizeDeviceCreation(deviceCreationDesc, *deviceImpl, device);
+}
+
 NRI_API Result NRI_CALL nriCreateDeviceFromVkDevice(const DeviceCreationVKDesc& deviceCreationVKDesc, Device*& device) {
     DeviceCreationDesc deviceCreationDesc = {};
     deviceCreationDesc.callbackInterface = deviceCreationVKDesc.callbackInterface;
@@ -325,6 +353,17 @@ NRI_API Format NRI_CALL nriConvertDXGIFormatToNRI(uint32_t dxgiFormat) {
     return DXGIFormatToNRIFormat(dxgiFormat);
 }
 
+NRI_API uint32_t NRI_CALL nriConvertNRIFormatToMTL(Format format) {
+    MaybeUnused(format);
+
+#if NRI_USE_VK
+    return NRIFormatToMTLFormat(format);
+#else
+    return 0;
+#endif
+}
+
+
 NRI_API uint32_t NRI_CALL nriConvertNRIFormatToVK(Format format) {
     MaybeUnused(format);
 
@@ -443,6 +482,8 @@ NRI_API void NRI_CALL nriReportLiveObjects() {
         pDebug->ReportLiveObjects(DXGI_DEBUG_ALL, (DXGI_DEBUG_RLO_FLAGS)((uint32_t)DXGI_DEBUG_RLO_DETAIL | (uint32_t)DXGI_DEBUG_RLO_IGNORE_INTERNAL));
 }
 
+#elif __APPLE__
+
 #else
 #    include <vulkan/vulkan.h>
 #    define GET_VK_FUNCTION(instance, name) \

Source/Creation/Creation.mm

@@ -0,0 +1,83 @@
+#import <MetalKit/MetalKit.h>
+
+#include "SharedExternal.h"
+
+using namespace nri;
+
+// referenced from Molten VK
+static uint32_t GetEntryProperty(io_registry_entry_t entry, CFStringRef propertyName) {
+
+    uint32_t value = 0;
+
+    CFTypeRef cfProp = IORegistryEntrySearchCFProperty(entry,
+                                                       kIOServicePlane,
+                                                       propertyName,
+                                                       kCFAllocatorDefault,
+                                                       kIORegistryIterateRecursively |
+                                                       kIORegistryIterateParents);
+    if (cfProp) {
+        const uint32_t* pValue = reinterpret_cast<const uint32_t*>(CFDataGetBytePtr((CFDataRef)cfProp));
+        if (pValue) { value = *pValue; }
+        CFRelease(cfProp);
+    }
+
+    return value;
+}
+
+
+static int SortAdaptersByDedicatedVideoMemorySize(const void* pa, const void* pb) {
+    AdapterDesc* a = (AdapterDesc*)pa;
+    AdapterDesc* b = (AdapterDesc*)pb;
+
+    if (a->videoMemorySize > b->videoMemorySize)
+        return -1;
+
+    if (a->videoMemorySize < b->videoMemorySize)
+        return 1;
+
+    return 0;
+}
+
+NRI_API Result NRI_CALL nriEnumerateAdapters(AdapterDesc* adapterDescs, uint32_t& adapterDescNum) {
+
+    NSArray<id<MTLDevice>>* devices = MTLCopyAllDevices();
+    if(!adapterDescs) {
+        adapterDescNum = (uint32_t)devices.count;
+        return Result::SUCCESS;
+    }
+
+    AdapterDesc* adapterDescsSorted = (AdapterDesc*)alloca(sizeof(AdapterDesc) * devices.count);
+    for(size_t i = 0; i < devices.count; i++) {
+        NSString* name = [devices[i] name];
+        [name getCString:adapterDescsSorted[i].name maxLength: sizeof(adapterDescs[i].name) - 1 encoding: NSASCIIStringEncoding];
+        const uint64_t regID = [devices[i] registryID];
+        adapterDescsSorted[i].luid = regID;
+        if (regID)
+        {
+            io_registry_entry_t entry = IOServiceGetMatchingService(MACH_PORT_NULL, IORegistryEntryIDMatching(regID));
+            if (entry)
+            {
+                // That returned the IOGraphicsAccelerator nub. Its parent, then, is the actual PCI device.
+                io_registry_entry_t deviceEntry;
+                if (IORegistryEntryGetParentEntry(entry, kIOServicePlane, &deviceEntry) == kIOReturnSuccess)
+                {
+                    adapterDescsSorted[i].vendor = GetVendorFromID(GetEntryProperty(deviceEntry, CFSTR("vendor-id"))) ;
+                    adapterDescsSorted[i].deviceId = GetEntryProperty(deviceEntry, CFSTR("device-id"));
+                }
+            }
+        } else {
+            adapterDescsSorted[i].vendor = nri::Vendor::APPLE;
+        }
+        adapterDescsSorted[i].videoMemorySize = [devices[i] recommendedMaxWorkingSetSize];
+        NSProcessInfo *pinfo = [NSProcessInfo processInfo];
+        adapterDescsSorted[i].systemMemorySize = [pinfo physicalMemory];
+    }
+
+    // Sort by video memory size
+    qsort(adapterDescsSorted, devices.count, sizeof(adapterDescsSorted[0]), SortAdaptersByDedicatedVideoMemorySize);
+    for(size_t i = 0; i < MIN(devices.count, adapterDescNum); i++) {
+        adapterDescs[i] = adapterDescsSorted[i];
+    }
+    adapterDescNum = (uint32_t)MIN(devices.count, adapterDescNum);
+    return Result::SUCCESS;
+}