AstralTech/Gryphn
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

start to redo physical device model

Browse Source
This commit is contained in:
Gregory Wells
2025-09-04 14:52:37 -04:00
parent a709ff8808
commit c5297cb17b
9 changed files with 43 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
projects/apis/vulkan/src/output_device/vulkan_physical_device.c
View File

@@ -31,13 +31,15 @@ VkSampleCountFlags gnSampleCountToVulkan(gnMultisampleCountFlags counts) {
return sampleCount; return sampleCount;
} }
void vulkanLoadNeededQueues(VkPhysicalDevice vulkanDevice, gnPhysicalDevice gryphnDevice) { void vulkanLoadNeededQueues(gnPhysicalDevice physicalDevice) {
uint32_t queueFamilyCount = 0; vulkanPhysicalDevice* device = (vulkanPhysicalDevice*)physicalDevice;
vkGetPhysicalDeviceQueueFamilyProperties(vulkanDevice, &queueFamilyCount, NULL);
VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(vulkanDevice, &queueFamilyCount, queueFamilies);
gryphnDevice->physicalDevice->neededQueues = malloc(sizeof(vulkanNeededQueue) * queueFamilyCount); uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(device->device, &queueFamilyCount, NULL);
VkQueueFamilyProperties* queueFamilies = malloc(sizeof(VkQueueFamilyProperties) * queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(device->device, &queueFamilyCount, queueFamilies);
device->neededQueues = malloc(sizeof(vulkanNeededQueue) * queueFamilyCount);
for (uint32_t c = 0; c < queueFamilyCount; c++) { for (uint32_t c = 0; c < queueFamilyCount; c++) {
gnBool hasNeededQueue = GN_FALSE; gnBool hasNeededQueue = GN_FALSE;
@@ -55,98 +57,24 @@ void vulkanLoadNeededQueues(VkPhysicalDevice vulkanDevice, gnPhysicalDevice gryp
if ((queueFamilies[c].queueFlags & VK_QUEUE_GRAPHICS_BIT)) neededQueue.createFlags |= VK_QUEUE_GRAPHICS_BIT; if ((queueFamilies[c].queueFlags & VK_QUEUE_GRAPHICS_BIT)) neededQueue.createFlags |= VK_QUEUE_GRAPHICS_BIT;
if ((queueFamilies[c].queueFlags & VK_QUEUE_TRANSFER_BIT)) neededQueue.createFlags |= VK_QUEUE_TRANSFER_BIT; if ((queueFamilies[c].queueFlags & VK_QUEUE_TRANSFER_BIT)) neededQueue.createFlags |= VK_QUEUE_TRANSFER_BIT;
gryphnDevice->physicalDevice->neededQueues[gryphnDevice->physicalDevice->neededQueueCount] = neededQueue; device->neededQueues[device->neededQueueCount] = neededQueue;
gryphnDevice->physicalDevice->neededQueueCount++; device->neededQueueCount++;
} }
} }
free(queueFamilies); free(queueFamilies);
} }
gnPhysicalDevice* getPhysicalDevices(gnInstanceHandle instance, uint32_t* deviceCount) {
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, NULL);
if (deviceCount == 0)
return NULL;
VkPhysicalDevice* physicalDevices = malloc(sizeof(VkPhysicalDevice) * *deviceCount); gnBool deviceCanPresentToSurface(gnPhysicalDevice physicalDevice, gnWindowSurface surface) {
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, physicalDevices); vulkanPhysicalDevice* device = (vulkanPhysicalDevice*)physicalDevice;
gnPhysicalDevice* outputDevices = (gnPhysicalDevice*)malloc(sizeof(gnPhysicalDevice) * *deviceCount);
for (uint32_t i = 0; i < *deviceCount; i++) {
outputDevices[i] = malloc(sizeof(gnPhysicalOutputDevice_t));
outputDevices[i]->physicalDevice = malloc(sizeof(struct gnPlatformPhysicalDevice_t));
outputDevices[i]->physicalDevice->device = physicalDevices[i];
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(physicalDevices[i], &deviceProperties);
outputDevices[i]->properties.name = gnCreateString(deviceProperties.deviceName);
switch(deviceProperties.deviceType) {
case VK_PHYSICAL_DEVICE_TYPE_OTHER: outputDevices[i]->properties.deviceType = GN_EXTERNAL_DEVICE;
case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: outputDevices[i]->properties.deviceType = GN_INTEGRATED_DEVICE;
case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: outputDevices[i]->properties.deviceType = GN_DEDICATED_DEVICE;
case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: outputDevices[i]->properties.deviceType = GN_INTEGRATED_DEVICE;
case VK_PHYSICAL_DEVICE_TYPE_CPU: outputDevices[i]->properties.deviceType = GN_INTEGRATED_DEVICE;
case VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM: outputDevices[i]->properties.deviceType = GN_INTEGRATED_DEVICE;
}
if (instance->enabledExtensions[GN_EXT_QUEUES] == GN_FALSE)
vulkanLoadNeededQueues(physicalDevices[i], outputDevices[i]);
VkPhysicalDeviceProperties physicalDeviceProperties;
vkGetPhysicalDeviceProperties(physicalDevices[i], &physicalDeviceProperties);
outputDevices[i]->features.maxColorSamples = vkSampleCountToGryphn(physicalDeviceProperties.limits.framebufferColorSampleCounts);
outputDevices[i]->features.maxDepthSamples = vkSampleCountToGryphn(physicalDeviceProperties.limits.framebufferDepthSampleCounts);
outputDevices[i]->features.maxMemoryAllocations = physicalDeviceProperties.limits.maxMemoryAllocationCount;
outputDevices[i]->features.maxPushConstantSize = physicalDeviceProperties.limits.maxPushConstantsSize;
}
free(physicalDevices);
return outputDevices;
}
gnBool deviceCanPresentToSurface(gnPhysicalDevice device, gnWindowSurface surface) {
uint32_t queueFamilyCount = 0; uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(device->physicalDevice->device, &queueFamilyCount, NULL); vkGetPhysicalDeviceQueueFamilyProperties(device->device, &queueFamilyCount, NULL);
for (uint32_t i = 0; i < queueFamilyCount; i++) { for (uint32_t i = 0; i < queueFamilyCount; i++) {
VkBool32 supportsPresent; VkBool32 supportsPresent;
vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, i, surface->windowSurface->surface, &supportsPresent); vkGetPhysicalDeviceSurfaceSupportKHR(device->device, i, surface->windowSurface->surface, &supportsPresent);
if (supportsPresent) return GN_TRUE; if (supportsPresent) return GN_TRUE;
} }
return GN_FALSE; return GN_FALSE;
} }
// gnBool foundQueue = GN_FALSE;
// for (uint32_t i = 0; i < device->physicalDevice->neededQueueCount; i++) {
// VkBool32 supportsPresent = VK_FALSE;
// vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, device->physicalDevice->neededQueues[i].queueIndex, surface->windowSurface->surface, &supportsPresent);
// if (supportsPresent) {
// device->physicalDevice->neededQueues[i].usedForPresent = GN_TRUE;
// foundQueue = GN_TRUE;
// break;
// }
// surface->windowSurface->presentQueueIndex = i;
// }
// if (!foundQueue) {
// uint32_t queueFamilyCount = 0;
// vkGetPhysicalDeviceQueueFamilyProperties(device->physicalDevice->device, &queueFamilyCount, NULL);
// for (uint32_t i = 0; i < queueFamilyCount; i++) {
// VkBool32 supportsPresent = VK_FALSE;
// vkGetPhysicalDeviceSurfaceSupportKHR(device->physicalDevice->device, i, surface->windowSurface->surface, &supportsPresent);
// if (supportsPresent) {
// device->physicalDevice->neededQueues[device->physicalDevice->neededQueueCount] = (vulkanNeededQueue){
// .queueIndex = i,
// .createFlags = 0,
// .usedForPresent = GN_TRUE
// };
// foundQueue = GN_TRUE;
// surface->windowSurface->presentQueueIndex = device->physicalDevice->neededQueueCount;
// device->physicalDevice->neededQueueCount++;
// break;
// }
// }
// }
// return foundQueue;

7
projects/apis/vulkan/src/output_device/vulkan_physical_device.h
View File

@@ -8,13 +8,6 @@ typedef struct vulkanNeededQueue {
uint32_t queueIndex; uint32_t queueIndex;
} vulkanNeededQueue; } vulkanNeededQueue;
typedef struct gnPlatformPhysicalDevice_t {
VkPhysicalDevice device;
uint32_t neededQueueCount;
vulkanNeededQueue* neededQueues;
} gnPlatformPhysicalDevice;
gnPhysicalDevice* getPhysicalDevices(gnInstanceHandle instance, uint32_t* deviceCount); gnPhysicalDevice* getPhysicalDevices(gnInstanceHandle instance, uint32_t* deviceCount);
gnBool deviceCanPresentToSurface(gnPhysicalDevice device, gnWindowSurface surface); gnBool deviceCanPresentToSurface(gnPhysicalDevice device, gnWindowSurface surface);

8
projects/core/src/gryphn_handles.h
View File

@@ -10,9 +10,15 @@ typedef struct type##_t* type##Handle; \
typedef struct type##_t* type typedef struct type##_t* type
// The value of this handle is defined by the implementation // The value of this handle is defined by the implementation
#ifndef GN_IMPLEMENTATION
#define GN_IMPLEMENTATION_HANDLE(type) \ #define GN_IMPLEMENTATION_HANDLE(type) \
typedef uint64_t type##Handle; \ typedef uint64_t type##Handle; \
typedef uint64_t type typedef uint64_t type
#else
#define GN_IMPLEMENTATION_HANDLE(type) \
typedef uint64_t type##Handle; \
typedef uint64_t type
#endif
// can be used to alias a normal handle or an implementation handle // can be used to alias a normal handle or an implementation handle
#define GN_HANDLE_ALIAS(handle, alias) \ #define GN_HANDLE_ALIAS(handle, alias) \
@@ -20,7 +26,7 @@ typedef struct handle##_t* alias##Handle; \
typedef struct handle##_t* alias typedef struct handle##_t* alias
GN_HANDLE(gnInstance); GN_HANDLE(gnInstance);
GN_HANDLE(gnPhysicalDevice); // NOTE: needs to become a impl handle GN_IMPLEMENTATION_HANDLE(gnPhysicalDevice); // NOTE: needs to become a impl handle
GN_HANDLE(gnWindowSurface); GN_HANDLE(gnWindowSurface);
GN_HANDLE(gnPresentationQueue); GN_HANDLE(gnPresentationQueue);

4
projects/core/src/instance/gryphn_instance.c
View File

@@ -84,6 +84,10 @@ gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceCreateInfo*
return (*instance)->functions->createInstance(*instance, info, (*instance)->functions->next, &(*instance)->allocators); return (*instance)->functions->createInstance(*instance, info, (*instance)->functions->next, &(*instance)->allocators);
} }
gnReturnCode gnInstanceQueryDevices(gnInstanceHandle instance, uint32_t* count, gnPhysicalDeviceHandle* devices) {
return instance->functions->queryDevices(instance, count, devices);
}
void gnDestroyInstance(gnInstanceHandle* instance) { void gnDestroyInstance(gnInstanceHandle* instance) {
if (instance == GN_NULL_HANDLE) return; if (instance == GN_NULL_HANDLE) return;
(*instance)->functions->destroyInstance(*instance, (*instance)->functions->next, &(*instance)->allocators); (*instance)->functions->destroyInstance(*instance, (*instance)->functions->next, &(*instance)->allocators);

1
projects/core/src/instance/gryphn_instance.h
View File

@@ -45,4 +45,5 @@ struct gnInstance_t {
#endif #endif
gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceCreateInfo* info); gnReturnCode gnCreateInstance(gnInstanceHandle* instance, gnInstanceCreateInfo* info);
gnReturnCode gnInstanceQueryDevices(gnInstanceHandle instance, uint32_t* count, gnPhysicalDeviceHandle* devices);
void gnDestroyInstance(gnInstanceHandle* instance); void gnDestroyInstance(gnInstanceHandle* instance);

10
projects/core/src/output_device/gryphn_physical_device.c
View File

@@ -4,14 +4,12 @@
gnPhysicalDeviceHandle* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count) {; gnPhysicalDeviceHandle* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count) {;
gnPhysicalDeviceHandle* devices = instance->callingLayer->instanceFunctions._gnGetPhysicalDevices(instance, count); gnPhysicalDeviceHandle* devices = instance->callingLayer->instanceFunctions._gnGetPhysicalDevices(instance, count);
for (uint32_t i = 0; i < *count; i++)
devices[i]->instance = instance;
return devices; return devices;
} }
gnBool gnPhysicalDeviceCanPresentToSurface(gnPhysicalDeviceHandle device, gnWindowSurfaceHandle windowSurface) { gnBool gnPhysicalDeviceCanPresentToSurface(gnInstanceHandle instance, gnPhysicalDeviceHandle device, gnWindowSurfaceHandle windowSurface) {
return device->instance->callingLayer->instanceFunctions._gnPhysicalDeviceCanPresentToSurface(device, windowSurface); return instance->callingLayer->instanceFunctions._gnPhysicalDeviceCanPresentToSurface(device, windowSurface);
} }
gnPhysicalDeviceProperties gnGetPhysicalDeviceProperties(gnPhysicalDeviceHandle device) { return device->properties; } // gnPhysicalDeviceProperties gnGetPhysicalDeviceProperties(gnPhysicalDeviceHandle device) { return device->properties; }
gnPhysicalDeviceFeatures gnGetPhysicalDeviceFeatures(gnPhysicalDeviceHandle device) { return device->features; } // gnPhysicalDeviceFeatures gnGetPhysicalDeviceFeatures(gnPhysicalDeviceHandle device) { return device->features; }

18
projects/core/src/output_device/gryphn_physical_device.h
View File

@@ -28,18 +28,18 @@ typedef struct gnPhysicalDeviceFeatures {
uint32_t maxPushConstantSize; uint32_t maxPushConstantSize;
} gnPhysicalDeviceFeatures; } gnPhysicalDeviceFeatures;
#ifdef GN_REVEAL_IMPL // #ifdef GN_REVEAL_IMPL
typedef struct gnPhysicalDevice_t { // typedef struct gnPhysicalDevice_t {
struct gnPlatformPhysicalDevice_t* physicalDevice; // struct gnPlatformPhysicalDevice_t* physicalDevice;
gnPhysicalDeviceProperties properties; // gnPhysicalDeviceProperties properties;
gnPhysicalDeviceFeatures features; // gnPhysicalDeviceFeatures features;
gnInstanceHandle instance; // gnInstanceHandle instance;
} gnPhysicalOutputDevice_t; // } gnPhysicalOutputDevice_t;
#endif // #endif
gnPhysicalDeviceHandle* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count); gnPhysicalDeviceHandle* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count);
gnBool gnPhysicalDeviceCanPresentToSurface(gnPhysicalDeviceHandle device, gnWindowSurfaceHandle windowSurface); gnBool gnPhysicalDeviceCanPresentToSurface(gnInstance instance, gnPhysicalDeviceHandle device, gnWindowSurfaceHandle windowSurface);
gnPhysicalDeviceProperties gnGetPhysicalDeviceProperties(gnPhysicalDeviceHandle device); gnPhysicalDeviceProperties gnGetPhysicalDeviceProperties(gnPhysicalDeviceHandle device);
gnPhysicalDeviceFeatures gnGetPhysicalDeviceFeatures(gnPhysicalDeviceHandle device); gnPhysicalDeviceFeatures gnGetPhysicalDeviceFeatures(gnPhysicalDeviceHandle device);

5
projects/loader/src/gryphn_instance_functions.h
View File

@@ -20,8 +20,9 @@ typedef struct gnOutputDeviceInfo gnOutputDeviceInfo;
#endif #endif
typedef struct gryphnInstanceFunctionLayers gryphnInstanceFunctionLayers; typedef struct gryphnInstanceFunctionLayers gryphnInstanceFunctionLayers;
typedef gnReturnCode (*PFN_gnCreateInstance)(gnInstanceHandle instance, gnInstanceCreateInfo* info, gryphnInstanceFunctionLayers* next, gnAllocators* alloctors); typedef gnReturnCode (*PFN_gnCreateInstance)(gnInstanceHandle, gnInstanceCreateInfo*, gryphnInstanceFunctionLayers*, gnAllocators*);
typedef void (*PFN_gnDestroyInstance)(gnInstanceHandle instance, gryphnInstanceFunctionLayers* next, gnAllocators* alloctors); typedef gnReturnCode (*PFN_gnInstanceQueryDevices)(gnInstanceHandle, uint32_t*, gnPhysicalDeviceHandle*);
typedef void (*PFN_gnDestroyInstance)(gnInstanceHandle, gryphnInstanceFunctionLayers*, gnAllocators*);
typedef struct gnInstanceFunctions { typedef struct gnInstanceFunctions {
gnPhysicalDevice* (*_gnGetPhysicalDevices)(gnInstanceHandle instance, uint32_t* count); gnPhysicalDevice* (*_gnGetPhysicalDevices)(gnInstanceHandle instance, uint32_t* count);

1
projects/loader/src/gryphn_loader.h
View File

@@ -15,6 +15,7 @@ typedef struct gryphnFunctionLayer {
typedef struct gryphnInstanceFunctionLayers { typedef struct gryphnInstanceFunctionLayers {
PFN_gnCreateInstance createInstance; PFN_gnCreateInstance createInstance;
PFN_gnInstanceQueryDevices queryDevices;
PFN_gnDestroyInstance destroyInstance; PFN_gnDestroyInstance destroyInstance;
struct gryphnInstanceFunctionLayers* next; struct gryphnInstanceFunctionLayers* next;
} gryphnInstanceFunctionLayers; } gryphnInstanceFunctionLayers;