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

rewrite device creation in C

Browse Source
This commit is contained in:
Greg Wells
2025-05-21 14:56:45 -04:00
parent 7341abb617
commit 586b5bdd0c
18 changed files with 274 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
rendering_api/metal/src/core/devices/metal_output_device.cpp
View File

@@ -1,98 +1,98 @@
#include <core/output_device/gryphn_physical_output_device.h>
#include <Metal/Metal.hpp>
#include <core/metal_instance.h>
#include "metal_output_devices.h"
// #include <core/output_device/gryphn_physical_output_device.h>
// #include <Metal/Metal.hpp>
// #include <core/metal_instance.h>
// #include "metal_output_devices.h"
struct mtlFramebufferVertex {
float x, y;
float u, v;
};
// struct mtlFramebufferVertex {
// float x, y;
// float u, v;
// };
GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice) {
if (outputDevice->outputDevice == nullptr) outputDevice->outputDevice = new gnPlatformOutputDevice();
outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice);
// GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice) {
// if (outputDevice->outputDevice == nullptr) outputDevice->outputDevice = new gnPlatformOutputDevice();
// outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice);
// instance.instance->metalLayer->setDevice(physicalDevice.physicalOutputDevice->device);
// // instance.instance->metalLayer->setDevice(physicalDevice.physicalOutputDevice->device);
// outputDevice->outputDevice->contentView = instance.instance->metalContentView->retain();
outputDevice->outputDevice->device = physicalDevice.physicalOutputDevice->device->retain();
outputDevice->outputDevice->commandQueue = outputDevice->outputDevice->device->newCommandQueue();
outputDevice->outputDevice->instance = const_cast<gnInstance*>(&instance);
// // outputDevice->outputDevice->contentView = instance.instance->metalContentView->retain();
// outputDevice->outputDevice->device = physicalDevice.physicalOutputDevice->device->retain();
// outputDevice->outputDevice->commandQueue = outputDevice->outputDevice->device->newCommandQueue();
// outputDevice->outputDevice->instance = const_cast<gnInstance*>(&instance);
{
const char* shaderSrc = R"metal(
#include <metal_stdlib>
using namespace metal;
// {
// const char* shaderSrc = R"metal(
// #include <metal_stdlib>
// using namespace metal;
struct VertexOut {
float4 position [[position]];
float2 uv;
};
// struct VertexOut {
// float4 position [[position]];
// float2 uv;
// };
vertex VertexOut vs_main(uint vertexID [[vertex_id]]) {
float2 positions[4] = {
{-1.0, -1.0},
{ 1.0, -1.0},
{-1.0, 1.0},
{ 1.0, 1.0}
};
float2 uvs[4] = {
{0.0, 1.0},
{1.0, 1.0},
{0.0, 0.0},
{1.0, 0.0}
};
// vertex VertexOut vs_main(uint vertexID [[vertex_id]]) {
// float2 positions[4] = {
// {-1.0, -1.0},
// { 1.0, -1.0},
// {-1.0, 1.0},
// { 1.0, 1.0}
// };
// float2 uvs[4] = {
// {0.0, 1.0},
// {1.0, 1.0},
// {0.0, 0.0},
// {1.0, 0.0}
// };
VertexOut out;
out.position = float4(positions[vertexID], 0.0, 1.0);
out.uv = uvs[vertexID];
return out;
}
// VertexOut out;
// out.position = float4(positions[vertexID], 0.0, 1.0);
// out.uv = uvs[vertexID];
// return out;
// }
fragment float4 fs_main(VertexOut in [[stage_in]],
texture2d<float> colorTex [[texture(0)]],
sampler samp [[sampler(0)]]) {
return colorTex.sample(samp, in.uv);
}
)metal";
// fragment float4 fs_main(VertexOut in [[stage_in]],
// texture2d<float> colorTex [[texture(0)]],
// sampler samp [[sampler(0)]]) {
// return colorTex.sample(samp, in.uv);
// }
// )metal";
NS::Error* error = nullptr;
MTL::CompileOptions* options = nullptr;
MTL::Library* library = physicalDevice.physicalOutputDevice->device->newLibrary(NS::String::string(shaderSrc, NS::UTF8StringEncoding), options, &error);
if (!library) {
return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String());
}
MTL::Function* vs = library->newFunction(NS::String::string("vs_main", NS::UTF8StringEncoding));
MTL::Function* fs = library->newFunction(NS::String::string("fs_main", NS::UTF8StringEncoding));
// NS::Error* error = nullptr;
// MTL::CompileOptions* options = nullptr;
// MTL::Library* library = physicalDevice.physicalOutputDevice->device->newLibrary(NS::String::string(shaderSrc, NS::UTF8StringEncoding), options, &error);
// if (!library) {
// return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String());
// }
// MTL::Function* vs = library->newFunction(NS::String::string("vs_main", NS::UTF8StringEncoding));
// MTL::Function* fs = library->newFunction(NS::String::string("fs_main", NS::UTF8StringEncoding));
MTL::RenderPipelineDescriptor* pipelineDesc = MTL::RenderPipelineDescriptor::alloc()->init();
pipelineDesc->setVertexFunction(vs);
pipelineDesc->setFragmentFunction(fs);
pipelineDesc->colorAttachments()->object(0)->setPixelFormat(MTL::PixelFormatBGRA8Unorm);
// MTL::RenderPipelineDescriptor* pipelineDesc = MTL::RenderPipelineDescriptor::alloc()->init();
// pipelineDesc->setVertexFunction(vs);
// pipelineDesc->setFragmentFunction(fs);
// pipelineDesc->colorAttachments()->object(0)->setPixelFormat(MTL::PixelFormatBGRA8Unorm);
instance.instance->framebufferRenderer = outputDevice->outputDevice->device->newRenderPipelineState(pipelineDesc, &error);
if (!instance.instance->framebufferRenderer) {
return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String());
}
}
// instance.instance->framebufferRenderer = outputDevice->outputDevice->device->newRenderPipelineState(pipelineDesc, &error);
// if (!instance.instance->framebufferRenderer) {
// return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String());
// }
// }
return GN_SUCCESS;
}
// return GN_SUCCESS;
// }
GN_EXPORT void gnWaitForDeviceFn(const gnOutputDevice& device) {
NS::AutoreleasePool* pool = NS::AutoreleasePool::alloc()->init();
// GN_EXPORT void gnWaitForDeviceFn(const gnOutputDevice& device) {
// NS::AutoreleasePool* pool = NS::AutoreleasePool::alloc()->init();
auto mtlDevice = device.physicalOutputDevice->physicalOutputDevice->device;
// auto mtlDevice = device.physicalOutputDevice->physicalOutputDevice->device;
auto commandBuffer = device.outputDevice->commandQueue->commandBuffer();
// auto commandBuffer = device.outputDevice->commandQueue->commandBuffer();
commandBuffer->commit();
commandBuffer->waitUntilCompleted();
// commandBuffer->commit();
// commandBuffer->waitUntilCompleted();
pool->release();
}
// pool->release();
// }
GN_EXPORT void gnDestroyOutputDeviceFn(gnOutputDevice& device) {
device.outputDevice->commandQueue->release();
device.physicalOutputDevice->physicalOutputDevice->device->release();
}
// GN_EXPORT void gnDestroyOutputDeviceFn(gnOutputDevice& device) {
// device.outputDevice->commandQueue->release();
// device.physicalOutputDevice->physicalOutputDevice->device->release();
// }

26
rendering_api/metal/src/core/devices/metal_output_devices.h
View File

@@ -1,16 +1,16 @@
#pragma once
#include <Metal/Metal.hpp>
#include <MetalKit/MetalKit.hpp>
// #pragma once
// #include <Metal/Metal.hpp>
// #include <MetalKit/MetalKit.hpp>
struct gnPlatformPhysicalOutputDevice {
MTL::Device* device;
};
struct gnInstance;
// struct gnPlatformPhysicalOutputDevice {
// MTL::Device* device;
// };
// struct gnInstance;
struct gnPlatformOutputDevice {
MTL::Device* device;
MTL::CommandQueue* commandQueue;
MTK::View* contentView;
// struct gnPlatformOutputDevice {
// MTL::Device* device;
// MTL::CommandQueue* commandQueue;
// MTK::View* contentView;
gnInstance* instance;
};
// gnInstance* instance;
// };

42
rendering_api/metal/src/core/devices/metal_physical_device.cpp
View File

@@ -1,23 +1,23 @@
#include <core/output_device/gryphn_physical_output_device.h>
#include <Metal/Metal.hpp>
#include "metal_output_devices.h"
// #include <core/output_device/gryphn_physical_output_device.h>
// #include <Metal/Metal.hpp>
// #include "metal_output_devices.h"
GN_EXPORT gnPhysicalOutputDevice* gnGetPhysicalOutputDevicesFn(const gnInstance& instance, uint32_t* count) {
// gnList<gnPhysicalOutputDevice> physicalOutputDevices = gnCreateList<gnPhysicalOutputDevice>();
NS::Array *devices = MTL::CopyAllDevices();
gnPhysicalOutputDevice* devicesList = (gnPhysicalOutputDevice*)malloc(sizeof(gnPhysicalOutputDevice) * devices->count());
for (int i = 0; i < devices->count(); i++) {
devicesList[i].outputDeviceName = reinterpret_cast<MTL::Device*>(devices->object(0))->name()->cString(NS::StringEncoding::UTF8StringEncoding);
devicesList[i].physicalOutputDevice = new gnPlatformPhysicalOutputDevice();
devicesList[i].physicalOutputDevice->device = reinterpret_cast<MTL::Device*>(devices->object(0));
}
*count = devices->count();
return devicesList;
}
// GN_EXPORT gnPhysicalOutputDevice* gnGetPhysicalOutputDevicesFn(const gnInstance& instance, uint32_t* count) {
// // gnList<gnPhysicalOutputDevice> physicalOutputDevices = gnCreateList<gnPhysicalOutputDevice>();
// NS::Array *devices = MTL::CopyAllDevices();
// gnPhysicalOutputDevice* devicesList = (gnPhysicalOutputDevice*)malloc(sizeof(gnPhysicalOutputDevice) * devices->count());
// for (int i = 0; i < devices->count(); i++) {
// devicesList[i].outputDeviceName = reinterpret_cast<MTL::Device*>(devices->object(0))->name()->cString(NS::StringEncoding::UTF8StringEncoding);
// devicesList[i].physicalOutputDevice = new gnPlatformPhysicalOutputDevice();
// devicesList[i].physicalOutputDevice->device = reinterpret_cast<MTL::Device*>(devices->object(0));
// }
// *count = devices->count();
// return devicesList;
// }
GN_EXPORT gnBool gnDeviceSupportsAPIFn(const gnPhysicalOutputDevice& device) {
// so as far as my understanding goes which is not very far I dont think that the
// method I am using to ge the devices would return a list of devices that are not supported on
// metal but idk or really care cuz fuck you for using metal
return true;
}
// GN_EXPORT gnBool gnDeviceSupportsAPIFn(const gnPhysicalOutputDevice& device) {
// // so as far as my understanding goes which is not very far I dont think that the
// // method I am using to ge the devices would return a list of devices that are not supported on
// // metal but idk or really care cuz fuck you for using metal
// return true;
// }

8
rendering_api/vulkan/src/output_device/vulkan_device_extensions.h Normal file
View File

@@ -0,0 +1,8 @@
#pragma once
#include <vulkan/vulkan.h>
#include "vector"
const std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
"VK_KHR_portability_subset"
};

67
rendering_api/vulkan/src/output_device/vulkan_output_device.cpp
View File

@@ -1,17 +1,22 @@
#include <vulkan/vulkan.h>
#include "presentation_queue/vulkan_queue_families.h"
#include "presentation_queue/vulkan_swapchain.h"
// #include "presentation_queue/vulkan_queue_families.h"
// #include "presentation_queue/vulkan_swapchain.h"
#include "vulkan_device_extensions.h"
#include "vulkan_output_devices.h"
#include <instance/vulkan_instance.h>
#include "set"
#include "vulkan_physical_device.h"
#include "presentation_queue/vulkan_queue_families.h"
// #include <set>
GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice) {
GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, gnInstance* instance, const gnPhysicalDevice physicalDevice) {
if (outputDevice->outputDevice == nullptr) outputDevice->outputDevice = new gnPlatformOutputDevice();
QueueFamilyIndices indices = findQueueFamilies(instance.instance->window_surface, physicalDevice.physicalOutputDevice->device);
//instance.instance->window_surface,
QueueFamilyIndices indices = findQueueFamilies(physicalDevice.physicalDevice->device);
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
//indices.presentFamily.value()
std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value()};
float queuePriority = 1.0f;
for (uint32_t queueFamily : uniqueQueueFamilies) {
@@ -37,42 +42,34 @@ GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, co
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
if (instance.debugger) {
auto validation_layers = instance.debugger->debug_layers;
const char* validation_layers[1] = { "VK_LAYER_KHRONOS_validation" };
gnList<const char*> validation_layers_c = gnCreateList<const char*>();
for (int i = 0; i < gnListLength(validation_layers); i++)
gnListAdd(validation_layers_c, gnToCString(validation_layers[i]));
createInfo.enabledLayerCount = 1;
createInfo.ppEnabledLayerNames = validation_layers;
createInfo.enabledLayerCount = static_cast<uint32_t>(gnListLength(validation_layers_c));
createInfo.ppEnabledLayerNames = gnListData(validation_layers_c);
} else {
createInfo.enabledLayerCount = 0;
}
if (vkCreateDevice(physicalDevice.physicalOutputDevice->device, &createInfo, nullptr, &outputDevice->outputDevice->device) != VK_SUCCESS) {
return GN_FAILED;
if (vkCreateDevice(physicalDevice.physicalDevice->device, &createInfo, nullptr, &outputDevice->outputDevice->device) != VK_SUCCESS) {
return GN_FAILED_TO_CREATE_DEVICE;
}
vkGetDeviceQueue(outputDevice->outputDevice->device, indices.graphicsFamily.value(), 0, &outputDevice->outputDevice->graphicsQueue);
vkGetDeviceQueue(outputDevice->outputDevice->device, indices.presentFamily.value(), 0, &outputDevice->outputDevice->presentQueue);
outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice);
// vkGetDeviceQueue(outputDevice->outputDevice->device, indices.presentFamily.value(), 0, &outputDevice->outputDevice->presentQueue);
// outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice);
{
QueueFamilyIndices queueFamilyIndices = findQueueFamilies(
outputDevice->physicalOutputDevice->physicalOutputDevice->instance->instance->window_surface,
outputDevice->physicalOutputDevice->physicalOutputDevice->device
);
// {
// QueueFamilyIndices queueFamilyIndices = findQueueFamilies(
// outputDevice->physicalOutputDevice->physicalOutputDevice->instance->instance->window_surface,
// outputDevice->physicalOutputDevice->physicalOutputDevice->device
// );
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
// VkCommandPoolCreateInfo poolInfo{};
// poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
// poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
// poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
if (vkCreateCommandPool(outputDevice->outputDevice->device, &poolInfo, nullptr, &outputDevice->outputDevice->commandPool) != VK_SUCCESS) {
return GN_FAILED;
}
}
// if (vkCreateCommandPool(outputDevice->outputDevice->device, &poolInfo, nullptr, &outputDevice->outputDevice->commandPool) != VK_SUCCESS) {
// return GN_FAILED;
// }
// }
return GN_SUCCESS;
}
@@ -82,6 +79,6 @@ GN_EXPORT void gnWaitForDeviceFn(const gnOutputDevice& device) {
}
GN_EXPORT void gnDestroyOutputDeviceFn(gnOutputDevice& device) {
vkDestroyCommandPool(device.outputDevice->device, device.outputDevice->commandPool, nullptr);
// vkDestroyCommandPool(device.outputDevice->device, device.outputDevice->commandPool, nullptr);
vkDestroyDevice(device.outputDevice->device, nullptr);
}

10
rendering_api/vulkan/src/output_device/vulkan_output_devices.h
View File

@@ -1,16 +1,10 @@
#pragma once
#include <vulkan/vulkan.h>
#include "core/output_device/gryphn_output_device.h"
struct gnPlatformPhysicalOutputDevice {
VkPhysicalDevice device;
gnInstance* instance;
};
#include <core/output_device/gryphn_output_device.h>
struct gnPlatformOutputDevice {
VkDevice device;
VkQueue presentQueue;
VkQueue graphicsQueue;
VkCommandPool commandPool;
// VkCommandPool commandPool;
};

54
rendering_api/vulkan/src/output_device/vulkan_physical_device.cpp
View File

@@ -1,45 +1,49 @@
#include "core/output_device/gryphn_physical_output_device.h"
#include <vulkan/vulkan.h>
#include "gryphn/gryphn_utils.h"
#include "vulkan_physical_device.h"
#include <instance/vulkan_instance.h>
#include "presentation_queue/vulkan_queue_families.h"
#include "vulkan_output_devices.h"
#include "presentation_queue/vulkan_swapchain.h"
#include <presentation_queue/vulkan_queue_families.h>
#include "vulkan_device_extensions.h"
GN_EXPORT gnPhysicalOutputDevice* gnGetPhysicalOutputDevicesFn(const gnInstance& instance, uint32_t* deviceCount) {
vkEnumeratePhysicalDevices(instance.instance->vk_instance, deviceCount, nullptr);
// #include "core/output_device/gryphn_physical_output_device.h"
// #include <vulkan/vulkan.h>
// #include "vulkan_output_devices.h"
// #include "presentation_queue/vulkan_swapchain.h"
GN_EXPORT gnPhysicalDevice* gnGetPhysicalDevicesFn(gnInstance* instance, uint32_t* deviceCount) {
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, nullptr);
if (deviceCount == 0)
return nullptr;
std::vector<VkPhysicalDevice> devices(*deviceCount);
vkEnumeratePhysicalDevices(instance.instance->vk_instance, deviceCount, devices.data());
gnPhysicalOutputDevice* outputDevices = (gnPhysicalOutputDevice*)malloc(sizeof(gnPhysicalOutputDevice) * *deviceCount);
vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, devices.data());
gnPhysicalDevice* outputDevices = (gnPhysicalDevice*)malloc(sizeof(gnPhysicalDevice) * *deviceCount);
for (int i = 0; i < *deviceCount; i++) {
outputDevices[i].physicalOutputDevice = new gnPlatformPhysicalOutputDevice();
outputDevices[i].physicalOutputDevice->device = devices[i];
outputDevices[i].physicalOutputDevice->instance = const_cast<gnInstance*>(&instance);
outputDevices[i].physicalDevice = new gnPlatformPhysicalDevice();
outputDevices[i].physicalDevice->device = devices[i];
VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(devices[i], &deviceProperties);
outputDevices[i].outputDeviceName = gnCreateString(deviceProperties.deviceName);
outputDevices[i].name = gnCreateString(deviceProperties.deviceName);
}
return outputDevices;
}
GN_EXPORT bool gnDeviceSupportsAPIFn(const gnPhysicalOutputDevice& device) {
QueueFamilyIndices indices = findQueueFamilies(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device);
bool extensionsSupported = checkDeviceExtensionSupport(deviceExtensions, device.physicalOutputDevice->device);
GN_EXPORT gnBool gnDeviceSupportsAPIFn(const gnPhysicalDevice device) {
//QueueFamilyIndices indices = findQueueFamilies(device.instance->instance->window_surface, device.physicalDevice->device);
//bool swapChainAdequate = true, extensionsSupported = true;
// bool extensionsSupported = checkDeviceExtensionSupport(deviceExtensions, device.physicalDevice->device);
bool swapChainAdequate = false;
if (extensionsSupported) {
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device);
swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
}
// bool swapChainAdequate = false;
// if (extensionsSupported) {
// SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device);
// swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
// }
VkPhysicalDeviceFeatures supportedFeatures;
vkGetPhysicalDeviceFeatures(device.physicalOutputDevice->device, &supportedFeatures);
//VkPhysicalDeviceFeatures supportedFeatures;
//vkGetPhysicalDeviceFeatures(device.physicalDevice->device, &supportedFeatures);
return indices.isComplete() && extensionsSupported && swapChainAdequate && supportedFeatures.samplerAnisotropy;
//return indices.isComplete() && extensionsSupported && swapChainAdequate && supportedFeatures.samplerAnisotropy;
return gnTrue;
}

7
rendering_api/vulkan/src/output_device/vulkan_physical_device.h Normal file
View File

@@ -0,0 +1,7 @@
#pragma once
#include <vulkan/vulkan.h>
#include <core/output_device/gryphn_physical_output_device.h>
struct gnPlatformPhysicalDevice {
VkPhysicalDevice device;
};

14
rendering_api/vulkan/src/presentation_queue/vulkan_queue_families.h
View File

@@ -9,14 +9,14 @@
// it does work tho
struct QueueFamilyIndices {
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
// std::optional<uint32_t> presentFamily;
bool isComplete() {
return graphicsFamily.has_value() && presentFamily.has_value();
return graphicsFamily.has_value(); //&& presentFamily.has_value();
}
};
static QueueFamilyIndices findQueueFamilies(const VkSurfaceKHR& surface, const VkPhysicalDevice& device) {
static QueueFamilyIndices findQueueFamilies(const VkPhysicalDevice& device) {
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
@@ -26,11 +26,11 @@ static QueueFamilyIndices findQueueFamilies(const VkSurfaceKHR& surface, const V
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies) {
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
// VkBool32 presentSupport = false;
// vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
if (presentSupport)
indices.presentFamily = i;
// if (presentSupport)
// indices.presentFamily = i;
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
indices.graphicsFamily = i;

12
src/core/gryphn_platform_functions.h
View File

@@ -3,6 +3,8 @@
// why I dont know
#include "instance/gryphn_instance.h"
#include "debugger/gryphn_debugger.h"
#include "output_device/gryphn_physical_output_device.h"
#include "output_device/gryphn_output_device.h"
typedef struct gnFunctions_t {
gnReturnCode (*_gnCreateInstance)(gnInstance* instance, struct gnInstanceInfo_t info);
@@ -10,4 +12,14 @@ typedef struct gnFunctions_t {
gnReturnCode (*_gnCreateDebugger)(gnDebugger* debugger, gnInstance* instance, const struct gnDebuggerInfo_t info);
void (*_gnDestroyDebugger)(gnDebugger* debugger);
gnBool (*_gnDeviceSupportsAPI)(const gnPhysicalDevice device);
gnPhysicalDevice* (*_gnGetPhysicalDevices)(gnInstance* instance, uint32_t* count);
gnReturnCode (*_gnRegisterOutputDevice)(gnOutputDevice* outputDevice, gnInstance* instance, const gnPhysicalDevice physicalDevice);
void (*_gnDestroyOutputDevice)(gnOutputDevice* device);
} gnFunctions;
typedef struct gnDeviceFunctions_t {
} gnDeviceFunctions;

1
src/core/instance/gryphn_instance.c
View File

@@ -8,7 +8,6 @@ gnReturnCode gnCreateInstance(gnInstance* instance, struct gnInstanceInfo_t info
if (instance->dynamicLib == NULL) return GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY;
instance->functions = malloc(sizeof(struct gnFunctions_t));
gnLoadFunctions(instance->dynamicLib, instance->functions);
return instance->functions->_gnCreateInstance(instance, info);
}
void gnDestroyInstance(gnInstance* instance) {

8
src/core/instance/init/gryphn_init.c
View File

@@ -40,4 +40,12 @@ void gnLoadFunctions(struct gnDynamicLibrary_t* lib, struct gnFunctions_t* funct
gnLoadDLLFunction(lib, functions->_gnDestroyInstance, "gnDestroyInstanceFn");
gnLoadDLLFunction(lib, functions->_gnCreateDebugger, "gnCreateDebuggerFn");
gnLoadDLLFunction(lib, functions->_gnDestroyDebugger, "gnDestroyDebuggerFn");
gnLoadDLLFunction(lib, functions->_gnGetPhysicalDevices, "gnGetPhysicalDevicesFn");
gnLoadDLLFunction(lib, functions->_gnDeviceSupportsAPI, "gnDeviceSupportsAPIFn");
gnLoadDLLFunction(lib, functions->_gnRegisterOutputDevice, "gnRegisterOutputDeviceFn");
gnLoadDLLFunction(lib, functions->_gnDestroyOutputDevice, "gnDestroyOutputDeviceFn");
}
void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFunctions_t* functions) {
}

1
src/core/instance/init/gryphn_init.h
View File

@@ -7,6 +7,7 @@
gnBool gnIsAPISupported(gnRenderingAPI RenderingAPI);
struct gnDynamicLibrary_t* gnLoadRenderingDLL(gnRenderingAPI RenderingAPI);
void gnLoadFunctions(struct gnDynamicLibrary_t* lib, struct gnFunctions_t* functions);
void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFunctions_t* functions);
// #ifdef GN_REVEAL_IMPL
// gnErrorCode gnInit(gnRenderingAPI RenderingAPI);

14
src/core/output_device/gryphn_output_device.c Normal file
View File

@@ -0,0 +1,14 @@
#include "gryphn_output_device.h"
#include "core/instance/gryphn_instance.h"
#include "core/gryphn_platform_functions.h"
#include "core/instance/init/gryphn_init.h"
gnReturnCode gnRegisterOutputDevice(gnOutputDevice* outputDevice, gnInstance* instance, const gnPhysicalDevice physicalDevice) {
outputDevice->deviceFunctions = malloc(sizeof(gnDeviceFunctions));
gnLoadDeviceFunctions(instance->dynamicLib, outputDevice->deviceFunctions);
outputDevice->physicalDevice = (gnPhysicalDevice*)(&physicalDevice);
return instance->functions->_gnRegisterOutputDevice(outputDevice, instance, physicalDevice);
}
void gnDestroyOutputDevice(gnOutputDevice* device) {
device->physicalDevice->instance->functions->_gnDestroyOutputDevice(device);
}

25
src/core/output_device/gryphn_output_device.h
View File

@@ -1,19 +1,16 @@
#pragma once
#include <gryphn/gryphn_utils.h>
#include "gryphn_physical_output_device.h"
#include <core/output_device/gryphn_physical_output_device.h>
struct gnPlatformOutputDevice;
struct gnPhysicalOutputDevice;
struct gnInstance;
struct gnDeviceFunctions_t;
struct gnOutputDevice {
ACCESS_LEVEL:
gnPlatformOutputDevice* outputDevice = nullptr;
gnPhysicalOutputDevice* physicalOutputDevice;
public:
gnOutputDevice() {}
};
typedef struct gnOutputDevice_t {
struct gnPlatformOutputDevice* outputDevice;
struct gnDeviceFunctions_t* deviceFunctions;
gnPhysicalDevice* physicalDevice;
} gnOutputDevice;
inline gnReturnCode (*gnRegisterOutputDevice)(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice);
inline void (*gnWaitForDevice)(const gnOutputDevice& device);
inline void (*gnDestroyOutputDevice)(gnOutputDevice& device);
gnReturnCode gnRegisterOutputDevice(gnOutputDevice* outputDevice, gnInstance* instance, const gnPhysicalDevice physicalDevice);
void gnDestroyOutputDevice(gnOutputDevice* device);
// inline void (*gnWaitForDevice)(const gnOutputDevice& device);

13
src/core/output_device/gryphn_physical_output_device.c Normal file
View File

@@ -0,0 +1,13 @@
#include "gryphn_physical_output_device.h"
#include "core/gryphn_platform_functions.h"
gnPhysicalDevice* gnGetPhyscialDevices(gnInstance* instance, uint32_t* count) {
gnPhysicalDevice* devices = instance->functions->_gnGetPhysicalDevices(instance, count);
for (int i = 0; i < *count; i++) {
devices[i].instance = instance;
}
return devices;
}
gnBool gnDeviceSupportsAPI(const gnPhysicalDevice device) {
return device.instance->functions->_gnDeviceSupportsAPI(device);
}

28
src/core/output_device/gryphn_physical_output_device.h
View File

@@ -1,19 +1,19 @@
#pragma once
#include <gryphn/gryphn_utils.h>
#include "core/instance/gryphn_instance.h"
struct gnPlatformPhysicalOutputDevice;
struct gnInstance;
struct gnPlatformPhysicalDevice;
struct gnPhysicalOutputDevice {
ACCESS_LEVEL:
bool valid = false;
gnPlatformPhysicalOutputDevice* physicalOutputDevice = nullptr;
gnString outputDeviceName;
public:
gnPhysicalOutputDevice() {}
};
typedef struct gnPhysicalDeviceProperties_t {
// there are currently no properties
} gnPhysicalDeviceProperties;
gnString gnGetPhysicalOutputDeviceName(const gnPhysicalOutputDevice& device);
inline bool (*gnDeviceSupportsAPI)(const gnPhysicalOutputDevice& device);
inline gnPhysicalOutputDevice* (*gnGetPhysicalOutputDevices)(const gnInstance& instance, uint32_t* count);
typedef struct gnPhysicalDevice_t {
struct gnPlatformPhysicalDevice* physicalDevice;
gnString name;
struct gnPhysicalDeviceProperties_t properties;
gnInstance* instance;
} gnPhysicalDevice;
gnPhysicalDevice* gnGetPhyscialDevices(gnInstance* instance, uint32_t* count);
gnBool gnDeviceSupportsAPI(const gnPhysicalDevice device);

5
src/utils/gryphn_error_code.h
View File

@@ -6,7 +6,8 @@ typedef enum gnReturnCode_t {
GN_UNSUPPORTED_RENDERING_API,
GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY,
GN_FAILED_CREATE_INSTANCE,
GN_FAILED_TO_CREATE_DEBUGGER
GN_FAILED_TO_CREATE_DEBUGGER,
GN_FAILED_TO_CREATE_DEVICE
// GN_UNKNOWN_ERROR,
// GN_UNKNOWN_FRAMEBUFFER_ATTACHMENT,
@@ -16,7 +17,6 @@ typedef enum gnReturnCode_t {
// GN_UNSUPPORTED_COLOR_FORMAT,
// GN_UNKNOWN_COLOR_FORMAT,
// GN_FUNCTION_NOT_FOUND,
// GN_FAILED_CREATE_DEVICE,
// GN_FAILED_CREATE_GRAPHICS_PIPELINE,
// GN_FAILED_CREATE_PRESENTATION_QUEUE,
// GN_FAILED_TO_CREATE_FRAMEBUFFER,
@@ -35,5 +35,6 @@ static const char* gnErrorCodeToCString(enum gnReturnCode_t returnCode) {
case GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY: return "GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY";
case GN_FAILED_CREATE_INSTANCE: return "GN_FAILED_CREATE_INSTANCE";
case GN_FAILED_TO_CREATE_DEBUGGER: return "GN_FAILED_TO_CREATE_DEBUGGER";
case GN_FAILED_TO_CREATE_DEVICE: return "GN_FAILED_TO_CREATE_DEVICE";
}
}