enumerate physical device properties

Gryphn/GryphnLoader/src/device/gryphn_physical_device.c

@@ -5,3 +5,7 @@
 gnReturnCode gnEnumeratePhysicalDevices(gnInstance instance, uint32_t* deviceCount, gnPhysicalDevice* devices) {
     return instance->dispatchTable.enumeratePhysicalDevices(instance, deviceCount, devices);
 }
+
+gnReturnCode gnGetPhysicalDeviceProperties(gnPhysicalDevice device, gnPhysicalDeviceProperties* properties) {
+    return device->instance->dispatchTable.getPhysicalDeviceProperties(device, properties);
+}

Gryphn/GryphnLoader/src/device/gryphn_physical_device.h

@@ -2,5 +2,34 @@
 #include "gryphn_handle.h"
 #include "gryphn_return_code.h"
 #include "stdint.h"
+#include "instance/gryphn_application_info.h"
+
+typedef enum gnPhysicalDeviceType {
+    GN_PHYSICAL_DEVICE_TYPE_CPU = 1,
+    GN_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 2,
+    GN_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 3,
+    GN_PHYSICAL_DEVICE_TYPE_EXTERNAL_GPU = 4,
+    GN_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 5,
+    GN_PHYSICAL_DEVICE_TYPE_OTHER = 6,
+} gnPhysicalDeviceType;
+
+// typedef struct gnPhysicalDeviceLimits {
+
+// } gnPhysicalDeviceLimits;
+
+typedef struct gnPhysicalDeviceProperties {
+    gnVersion apiVersion;
+    uint32_t vendorID;
+    uint32_t deviceID;
+    gnPhysicalDeviceType deviceType;
+    char deviceName[256];
+    // gnPhysicalDeviceLimits limits;
+} gnPhysicalDeviceProperties;
+
+typedef struct gnPhysicalDevice_t {
+    gnInstance instance;
+    void* internalData;
+} gnPhysicalDevice_t;
 
 gnReturnCode gnEnumeratePhysicalDevices(gnInstance instance, uint32_t* deviceCount, gnPhysicalDevice* devices);
+gnReturnCode gnGetPhysicalDeviceProperties(gnPhysicalDevice device, gnPhysicalDeviceProperties* properties);

Gryphn/GryphnLoader/src/gryphn_handle.h

@@ -4,4 +4,4 @@
 #define GN_IMPLEMENTATION_HANDLE(type) typedef void* type
 
 GN_HANDLE(gnInstance);
-GN_IMPLEMENTATION_HANDLE(gnPhysicalDevice);
+GN_HANDLE(gnPhysicalDevice);

Gryphn/GryphnLoader/src/instance/dispatch/gryphn_instance_dispatch_table.h

@@ -1,11 +1,13 @@
 #pragma once
 #include "gryphn_handle.h"
+typedef struct gnPhysicalDeviceProperties gnPhysicalDeviceProperties;
 
 typedef gnReturnCode (*PFN_gnDestroyInstance)(gnInstance);
 typedef gnReturnCode (*PFN_enumeratePhysicalDevices)(gnInstance, uint32_t*, gnPhysicalDevice*);
-
+typedef gnReturnCode (*PFN_gnGetPhysicalDeviceProperties)(gnPhysicalDevice, gnPhysicalDeviceProperties*);
 
 typedef struct gnInstanceDispatchTable {
     PFN_gnDestroyInstance destroyInstance;
     PFN_enumeratePhysicalDevices enumeratePhysicalDevices;
+    PFN_gnGetPhysicalDeviceProperties getPhysicalDeviceProperties;
 } gnInstanceDispatchTable;

Gryphn/apis/GryphnMetal/src/metal.m

@@ -20,5 +20,6 @@ gnReturnCode destroyBackend(gnInstance instance) {
 extern "C" gnReturnCode initBackend(gnInstance instance, gnInstanceCreateInfo* info) {
     instance->dispatchTable.destroyInstance = destroyBackend;
     instance->dispatchTable.enumeratePhysicalDevices = metalEnumeratePhysicalDevices;
+    instance->dispatchTable.getPhysicalDeviceProperties = metalGetPhysicalDeviceProperties;
     return GN_SUCCESS;
 }

Gryphn/apis/GryphnMetal/src/metal_device.m

@@ -2,6 +2,7 @@
 #include "metal_functions.h"
 #include "stdio.h"
 #include "stdint.h"
+#include "device/gryphn_physical_device.h"
 
 gnReturnCode metalEnumeratePhysicalDevices(gnInstance instance, uint32_t* deviceCount, gnPhysicalDevice* devices) {
     NSArray<id<MTLDevice>>* mtlDevices = MTLCopyAllDevices();
@@ -10,7 +11,46 @@ gnReturnCode metalEnumeratePhysicalDevices(gnInstance instance, uint32_t* device
 
     if (devices == NULL)
         return GN_SUCCESS;
-    for (uint32_t i = 0; i < *deviceCount; i++)
+    for (uint32_t i = 0; i < *deviceCount; i++) {
-        devices[i] = (gnPhysicalDevice)mtlDevices[i];
+        devices[i] = (gnPhysicalDevice)malloc(sizeof(gnPhysicalDevice_t));
+        devices[i]->instance = instance;
+        devices[i]->internalData = mtlDevices[i];
+    }
+    return GN_SUCCESS;
+}
+
+gnReturnCode metalGetPhysicalDeviceProperties(gnPhysicalDevice device, gnPhysicalDeviceProperties* properties) {
+    id<MTLDevice> mtlDevice = (id<MTLDevice>)device->internalData;
+
+    properties->apiVersion = gnCreateVersion(1, 0, 0);
+
+    if ([[mtlDevice name] containsString:@"Apple"]) {
+        properties->vendorID = 0x106B;
+    } else if ([[mtlDevice name] containsString:@"Intel"]) {
+        properties->vendorID = 0x8086;
+    } else if ([[mtlDevice name] containsString:@"AMD"] || [[mtlDevice name] containsString:@"Radeon"]) {
+        properties->vendorID = 0x1002;
+    } else {
+        properties->vendorID = 0;
+    }
+
+    if (@available(macOS 10.13, *)) {
+        properties->deviceID = (uint32_t)[mtlDevice registryID];
+    } else {
+        properties->deviceID = 0;
+    }
+
+    if ([mtlDevice isRemovable])
+        properties->deviceType = GN_PHYSICAL_DEVICE_TYPE_EXTERNAL_GPU;
+    else if ([mtlDevice isLowPower])
+        properties->deviceType = GN_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+    else if (![mtlDevice isLowPower] && ![mtlDevice hasUnifiedMemory])
+        properties->deviceType = GN_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
+    else
+        properties->deviceType = GN_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+
+    const char* rawName = [[mtlDevice name] UTF8String];
+    strncpy(properties->deviceName, rawName, 255);
+    properties->deviceName[255] = '\0';
     return GN_SUCCESS;
 }

Gryphn/apis/GryphnMetal/src/metal_functions.h

@@ -2,6 +2,7 @@
 #include "gryphn_handle.h"
 #include "gryphn_return_code.h"
 #include "stdint.h"
-
+#include "device/gryphn_physical_device.h"
 
 gnReturnCode metalEnumeratePhysicalDevices(gnInstance instance, uint32_t* deviceCount, gnPhysicalDevice* devices);
+gnReturnCode metalGetPhysicalDeviceProperties(gnPhysicalDevice device, gnPhysicalDeviceProperties* properties);

main.cpp

@@ -47,6 +47,11 @@ void createDevice() {
     CHECK(gnEnumeratePhysicalDevices(instance, &physicalDeviceCount, devices));
 
     std::cout << "Found " << physicalDeviceCount << " physical devices:\n";
+    for (int i = 0; i < physicalDeviceCount; i++) {
+        gnPhysicalDeviceProperties properties;
+        gnGetPhysicalDeviceProperties(devices[i], &properties);
+        std::cout << "Name: " << properties.deviceName << "\n";
+    }
 }
 
 int main() {