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 <core/output_device/gryphn_physical_output_device.h>
#include <Metal/Metal.hpp> // #include <Metal/Metal.hpp>
#include <core/metal_instance.h> // #include <core/metal_instance.h>
#include "metal_output_devices.h" // #include "metal_output_devices.h"
struct mtlFramebufferVertex { // struct mtlFramebufferVertex {
float x, y; // float x, y;
float u, v; // float u, v;
}; // };
GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice) { // GN_EXPORT gnReturnCode gnRegisterOutputDeviceFn(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice) {
if (outputDevice->outputDevice == nullptr) outputDevice->outputDevice = new gnPlatformOutputDevice(); // if (outputDevice->outputDevice == nullptr) outputDevice->outputDevice = new gnPlatformOutputDevice();
outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice); // 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->contentView = instance.instance->metalContentView->retain();
outputDevice->outputDevice->device = physicalDevice.physicalOutputDevice->device->retain(); // outputDevice->outputDevice->device = physicalDevice.physicalOutputDevice->device->retain();
outputDevice->outputDevice->commandQueue = outputDevice->outputDevice->device->newCommandQueue(); // outputDevice->outputDevice->commandQueue = outputDevice->outputDevice->device->newCommandQueue();
outputDevice->outputDevice->instance = const_cast<gnInstance*>(&instance); // outputDevice->outputDevice->instance = const_cast<gnInstance*>(&instance);
{ // {
const char* shaderSrc = R"metal( // const char* shaderSrc = R"metal(
#include <metal_stdlib> // #include <metal_stdlib>
using namespace metal; // using namespace metal;
struct VertexOut { // struct VertexOut {
float4 position [[position]]; // float4 position [[position]];
float2 uv; // float2 uv;
}; // };
vertex VertexOut vs_main(uint vertexID [[vertex_id]]) { // vertex VertexOut vs_main(uint vertexID [[vertex_id]]) {
float2 positions[4] = { // float2 positions[4] = {
{-1.0, -1.0}, // {-1.0, -1.0},
{ 1.0, -1.0}, // { 1.0, -1.0},
{-1.0, 1.0}, // {-1.0, 1.0},
{ 1.0, 1.0} // { 1.0, 1.0}
}; // };
float2 uvs[4] = { // float2 uvs[4] = {
{0.0, 1.0}, // {0.0, 1.0},
{1.0, 1.0}, // {1.0, 1.0},
{0.0, 0.0}, // {0.0, 0.0},
{1.0, 0.0} // {1.0, 0.0}
}; // };
VertexOut out; // VertexOut out;
out.position = float4(positions[vertexID], 0.0, 1.0); // out.position = float4(positions[vertexID], 0.0, 1.0);
out.uv = uvs[vertexID]; // out.uv = uvs[vertexID];
return out; // return out;
} // }
fragment float4 fs_main(VertexOut in [[stage_in]], // fragment float4 fs_main(VertexOut in [[stage_in]],
texture2d<float> colorTex [[texture(0)]], // texture2d<float> colorTex [[texture(0)]],
sampler samp [[sampler(0)]]) { // sampler samp [[sampler(0)]]) {
return colorTex.sample(samp, in.uv); // return colorTex.sample(samp, in.uv);
} // }
)metal"; // )metal";
NS::Error* error = nullptr; // NS::Error* error = nullptr;
MTL::CompileOptions* options = nullptr; // MTL::CompileOptions* options = nullptr;
MTL::Library* library = physicalDevice.physicalOutputDevice->device->newLibrary(NS::String::string(shaderSrc, NS::UTF8StringEncoding), options, &error); // MTL::Library* library = physicalDevice.physicalOutputDevice->device->newLibrary(NS::String::string(shaderSrc, NS::UTF8StringEncoding), options, &error);
if (!library) { // if (!library) {
return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String()); // return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String());
} // }
MTL::Function* vs = library->newFunction(NS::String::string("vs_main", NS::UTF8StringEncoding)); // 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::Function* fs = library->newFunction(NS::String::string("fs_main", NS::UTF8StringEncoding));
MTL::RenderPipelineDescriptor* pipelineDesc = MTL::RenderPipelineDescriptor::alloc()->init(); // MTL::RenderPipelineDescriptor* pipelineDesc = MTL::RenderPipelineDescriptor::alloc()->init();
pipelineDesc->setVertexFunction(vs); // pipelineDesc->setVertexFunction(vs);
pipelineDesc->setFragmentFunction(fs); // pipelineDesc->setFragmentFunction(fs);
pipelineDesc->colorAttachments()->object(0)->setPixelFormat(MTL::PixelFormatBGRA8Unorm); // pipelineDesc->colorAttachments()->object(0)->setPixelFormat(MTL::PixelFormatBGRA8Unorm);
instance.instance->framebufferRenderer = outputDevice->outputDevice->device->newRenderPipelineState(pipelineDesc, &error); // instance.instance->framebufferRenderer = outputDevice->outputDevice->device->newRenderPipelineState(pipelineDesc, &error);
if (!instance.instance->framebufferRenderer) { // if (!instance.instance->framebufferRenderer) {
return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String()); // return gnReturnError(GN_FAILED_CREATE_DEVICE, error->localizedDescription()->utf8String());
} // }
} // }
return GN_SUCCESS; // return GN_SUCCESS;
} // }
GN_EXPORT void gnWaitForDeviceFn(const gnOutputDevice& device) { // GN_EXPORT void gnWaitForDeviceFn(const gnOutputDevice& device) {
NS::AutoreleasePool* pool = NS::AutoreleasePool::alloc()->init(); // 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->commit();
commandBuffer->waitUntilCompleted(); // commandBuffer->waitUntilCompleted();
pool->release(); // pool->release();
} // }
GN_EXPORT void gnDestroyOutputDeviceFn(gnOutputDevice& device) { // GN_EXPORT void gnDestroyOutputDeviceFn(gnOutputDevice& device) {
device.outputDevice->commandQueue->release(); // device.outputDevice->commandQueue->release();
device.physicalOutputDevice->physicalOutputDevice->device->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 // #pragma once
#include <Metal/Metal.hpp> // #include <Metal/Metal.hpp>
#include <MetalKit/MetalKit.hpp> // #include <MetalKit/MetalKit.hpp>
struct gnPlatformPhysicalOutputDevice { // struct gnPlatformPhysicalOutputDevice {
MTL::Device* device; // MTL::Device* device;
}; // };
struct gnInstance; // struct gnInstance;
struct gnPlatformOutputDevice { // struct gnPlatformOutputDevice {
MTL::Device* device; // MTL::Device* device;
MTL::CommandQueue* commandQueue; // MTL::CommandQueue* commandQueue;
MTK::View* contentView; // 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 <core/output_device/gryphn_physical_output_device.h>
#include <Metal/Metal.hpp> // #include <Metal/Metal.hpp>
#include "metal_output_devices.h" // #include "metal_output_devices.h"
GN_EXPORT gnPhysicalOutputDevice* gnGetPhysicalOutputDevicesFn(const gnInstance& instance, uint32_t* count) { // GN_EXPORT gnPhysicalOutputDevice* gnGetPhysicalOutputDevicesFn(const gnInstance& instance, uint32_t* count) {
// gnList<gnPhysicalOutputDevice> physicalOutputDevices = gnCreateList<gnPhysicalOutputDevice>(); // // gnList<gnPhysicalOutputDevice> physicalOutputDevices = gnCreateList<gnPhysicalOutputDevice>();
NS::Array *devices = MTL::CopyAllDevices(); // NS::Array *devices = MTL::CopyAllDevices();
gnPhysicalOutputDevice* devicesList = (gnPhysicalOutputDevice*)malloc(sizeof(gnPhysicalOutputDevice) * devices->count()); // gnPhysicalOutputDevice* devicesList = (gnPhysicalOutputDevice*)malloc(sizeof(gnPhysicalOutputDevice) * devices->count());
for (int i = 0; i < devices->count(); i++) { // 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].outputDeviceName = reinterpret_cast<MTL::Device*>(devices->object(0))->name()->cString(NS::StringEncoding::UTF8StringEncoding);
devicesList[i].physicalOutputDevice = new gnPlatformPhysicalOutputDevice(); // devicesList[i].physicalOutputDevice = new gnPlatformPhysicalOutputDevice();
devicesList[i].physicalOutputDevice->device = reinterpret_cast<MTL::Device*>(devices->object(0)); // devicesList[i].physicalOutputDevice->device = reinterpret_cast<MTL::Device*>(devices->object(0));
} // }
*count = devices->count(); // *count = devices->count();
return devicesList; // return devicesList;
} // }
GN_EXPORT gnBool gnDeviceSupportsAPIFn(const gnPhysicalOutputDevice& device) { // GN_EXPORT gnBool gnDeviceSupportsAPIFn(const gnPhysicalOutputDevice& device) {
// so as far as my understanding goes which is not very far I dont think that the // // 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 // // 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 // // metal but idk or really care cuz fuck you for using metal
return true; // 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 <vulkan/vulkan.h>
#include "presentation_queue/vulkan_queue_families.h" // #include "presentation_queue/vulkan_queue_families.h"
#include "presentation_queue/vulkan_swapchain.h" // #include "presentation_queue/vulkan_swapchain.h"
#include "vulkan_device_extensions.h"
#include "vulkan_output_devices.h" #include "vulkan_output_devices.h"
#include <instance/vulkan_instance.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(); 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::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; float queuePriority = 1.0f;
for (uint32_t queueFamily : uniqueQueueFamilies) { 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.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data(); createInfo.ppEnabledExtensionNames = deviceExtensions.data();
if (instance.debugger) { const char* validation_layers[1] = { "VK_LAYER_KHRONOS_validation" };
auto validation_layers = instance.debugger->debug_layers;
gnList<const char*> validation_layers_c = gnCreateList<const char*>(); createInfo.enabledLayerCount = 1;
for (int i = 0; i < gnListLength(validation_layers); i++) createInfo.ppEnabledLayerNames = validation_layers;
gnListAdd(validation_layers_c, gnToCString(validation_layers[i]));
createInfo.enabledLayerCount = static_cast<uint32_t>(gnListLength(validation_layers_c)); if (vkCreateDevice(physicalDevice.physicalDevice->device, &createInfo, nullptr, &outputDevice->outputDevice->device) != VK_SUCCESS) {
createInfo.ppEnabledLayerNames = gnListData(validation_layers_c); return GN_FAILED_TO_CREATE_DEVICE;
} else {
createInfo.enabledLayerCount = 0;
}
if (vkCreateDevice(physicalDevice.physicalOutputDevice->device, &createInfo, nullptr, &outputDevice->outputDevice->device) != VK_SUCCESS) {
return GN_FAILED;
} }
vkGetDeviceQueue(outputDevice->outputDevice->device, indices.graphicsFamily.value(), 0, &outputDevice->outputDevice->graphicsQueue); vkGetDeviceQueue(outputDevice->outputDevice->device, indices.graphicsFamily.value(), 0, &outputDevice->outputDevice->graphicsQueue);
vkGetDeviceQueue(outputDevice->outputDevice->device, indices.presentFamily.value(), 0, &outputDevice->outputDevice->presentQueue); // vkGetDeviceQueue(outputDevice->outputDevice->device, indices.presentFamily.value(), 0, &outputDevice->outputDevice->presentQueue);
outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice); // outputDevice->physicalOutputDevice = const_cast<gnPhysicalOutputDevice*>(&physicalDevice);
{ // {
QueueFamilyIndices queueFamilyIndices = findQueueFamilies( // QueueFamilyIndices queueFamilyIndices = findQueueFamilies(
outputDevice->physicalOutputDevice->physicalOutputDevice->instance->instance->window_surface, // outputDevice->physicalOutputDevice->physicalOutputDevice->instance->instance->window_surface,
outputDevice->physicalOutputDevice->physicalOutputDevice->device // outputDevice->physicalOutputDevice->physicalOutputDevice->device
); // );
VkCommandPoolCreateInfo poolInfo{}; // VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; // poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; // poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value(); // poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
if (vkCreateCommandPool(outputDevice->outputDevice->device, &poolInfo, nullptr, &outputDevice->outputDevice->commandPool) != VK_SUCCESS) { // if (vkCreateCommandPool(outputDevice->outputDevice->device, &poolInfo, nullptr, &outputDevice->outputDevice->commandPool) != VK_SUCCESS) {
return GN_FAILED; // return GN_FAILED;
} // }
} // }
return GN_SUCCESS; return GN_SUCCESS;
} }
@@ -82,6 +79,6 @@ GN_EXPORT void gnWaitForDeviceFn(const gnOutputDevice& device) {
} }
GN_EXPORT void gnDestroyOutputDeviceFn(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); vkDestroyDevice(device.outputDevice->device, nullptr);
} }

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

@@ -1,16 +1,10 @@
#pragma once #pragma once
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include "core/output_device/gryphn_output_device.h" #include <core/output_device/gryphn_output_device.h>
struct gnPlatformPhysicalOutputDevice {
VkPhysicalDevice device;
gnInstance* instance;
};
struct gnPlatformOutputDevice { struct gnPlatformOutputDevice {
VkDevice device; VkDevice device;
VkQueue presentQueue; VkQueue presentQueue;
VkQueue graphicsQueue; 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 "gryphn/gryphn_utils.h"
#include <vulkan/vulkan.h> #include "vulkan_physical_device.h"
#include <instance/vulkan_instance.h> #include <instance/vulkan_instance.h>
#include "presentation_queue/vulkan_queue_families.h" #include <presentation_queue/vulkan_queue_families.h>
#include "vulkan_output_devices.h" #include "vulkan_device_extensions.h"
#include "presentation_queue/vulkan_swapchain.h"
GN_EXPORT gnPhysicalOutputDevice* gnGetPhysicalOutputDevicesFn(const gnInstance& instance, uint32_t* deviceCount) { // #include "core/output_device/gryphn_physical_output_device.h"
vkEnumeratePhysicalDevices(instance.instance->vk_instance, deviceCount, nullptr); // #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) if (deviceCount == 0)
return nullptr; return nullptr;
std::vector<VkPhysicalDevice> devices(*deviceCount); std::vector<VkPhysicalDevice> devices(*deviceCount);
vkEnumeratePhysicalDevices(instance.instance->vk_instance, deviceCount, devices.data()); vkEnumeratePhysicalDevices(instance->instance->vk_instance, deviceCount, devices.data());
gnPhysicalDevice* outputDevices = (gnPhysicalDevice*)malloc(sizeof(gnPhysicalDevice) * *deviceCount);
gnPhysicalOutputDevice* outputDevices = (gnPhysicalOutputDevice*)malloc(sizeof(gnPhysicalOutputDevice) * *deviceCount);
for (int i = 0; i < *deviceCount; i++) { for (int i = 0; i < *deviceCount; i++) {
outputDevices[i].physicalOutputDevice = new gnPlatformPhysicalOutputDevice(); outputDevices[i].physicalDevice = new gnPlatformPhysicalDevice();
outputDevices[i].physicalOutputDevice->device = devices[i]; outputDevices[i].physicalDevice->device = devices[i];
outputDevices[i].physicalOutputDevice->instance = const_cast<gnInstance*>(&instance);
VkPhysicalDeviceProperties deviceProperties; VkPhysicalDeviceProperties deviceProperties;
vkGetPhysicalDeviceProperties(devices[i], &deviceProperties); vkGetPhysicalDeviceProperties(devices[i], &deviceProperties);
outputDevices[i].outputDeviceName = gnCreateString(deviceProperties.deviceName); outputDevices[i].name = gnCreateString(deviceProperties.deviceName);
} }
return outputDevices; return outputDevices;
} }
GN_EXPORT bool gnDeviceSupportsAPIFn(const gnPhysicalOutputDevice& device) { GN_EXPORT gnBool gnDeviceSupportsAPIFn(const gnPhysicalDevice device) {
QueueFamilyIndices indices = findQueueFamilies(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device); //QueueFamilyIndices indices = findQueueFamilies(device.instance->instance->window_surface, device.physicalDevice->device);
bool extensionsSupported = checkDeviceExtensionSupport(deviceExtensions, device.physicalOutputDevice->device); //bool swapChainAdequate = true, extensionsSupported = true;
// bool extensionsSupported = checkDeviceExtensionSupport(deviceExtensions, device.physicalDevice->device);
bool swapChainAdequate = false; // bool swapChainAdequate = false;
if (extensionsSupported) { // if (extensionsSupported) {
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device); // SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device.physicalOutputDevice->instance->instance->window_surface, device.physicalOutputDevice->device);
swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty(); // swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
} // }
VkPhysicalDeviceFeatures supportedFeatures; //VkPhysicalDeviceFeatures supportedFeatures;
vkGetPhysicalDeviceFeatures(device.physicalOutputDevice->device, &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 // it does work tho
struct QueueFamilyIndices { struct QueueFamilyIndices {
std::optional<uint32_t> graphicsFamily; std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily; // std::optional<uint32_t> presentFamily;
bool isComplete() { 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; QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0; uint32_t queueFamilyCount = 0;
@@ -26,11 +26,11 @@ static QueueFamilyIndices findQueueFamilies(const VkSurfaceKHR& surface, const V
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data()); vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
int i = 0; int i = 0;
for (const auto& queueFamily : queueFamilies) { for (const auto& queueFamily : queueFamilies) {
VkBool32 presentSupport = false; // VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport); // vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
if (presentSupport) // if (presentSupport)
indices.presentFamily = i; // indices.presentFamily = i;
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
indices.graphicsFamily = i; indices.graphicsFamily = i;

12
src/core/gryphn_platform_functions.h
View File

@@ -3,6 +3,8 @@
// why I dont know // why I dont know
#include "instance/gryphn_instance.h" #include "instance/gryphn_instance.h"
#include "debugger/gryphn_debugger.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 { typedef struct gnFunctions_t {
gnReturnCode (*_gnCreateInstance)(gnInstance* instance, struct gnInstanceInfo_t info); 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); gnReturnCode (*_gnCreateDebugger)(gnDebugger* debugger, gnInstance* instance, const struct gnDebuggerInfo_t info);
void (*_gnDestroyDebugger)(gnDebugger* debugger); 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; } 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; if (instance->dynamicLib == NULL) return GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY;
instance->functions = malloc(sizeof(struct gnFunctions_t)); instance->functions = malloc(sizeof(struct gnFunctions_t));
gnLoadFunctions(instance->dynamicLib, instance->functions); gnLoadFunctions(instance->dynamicLib, instance->functions);
return instance->functions->_gnCreateInstance(instance, info); return instance->functions->_gnCreateInstance(instance, info);
} }
void gnDestroyInstance(gnInstance* instance) { 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->_gnDestroyInstance, "gnDestroyInstanceFn");
gnLoadDLLFunction(lib, functions->_gnCreateDebugger, "gnCreateDebuggerFn"); gnLoadDLLFunction(lib, functions->_gnCreateDebugger, "gnCreateDebuggerFn");
gnLoadDLLFunction(lib, functions->_gnDestroyDebugger, "gnDestroyDebuggerFn"); 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); gnBool gnIsAPISupported(gnRenderingAPI RenderingAPI);
struct gnDynamicLibrary_t* gnLoadRenderingDLL(gnRenderingAPI RenderingAPI); struct gnDynamicLibrary_t* gnLoadRenderingDLL(gnRenderingAPI RenderingAPI);
void gnLoadFunctions(struct gnDynamicLibrary_t* lib, struct gnFunctions_t* functions); void gnLoadFunctions(struct gnDynamicLibrary_t* lib, struct gnFunctions_t* functions);
void gnLoadDeviceFunctions(struct gnDynamicLibrary_t* lib, struct gnDeviceFunctions_t* functions);
// #ifdef GN_REVEAL_IMPL // #ifdef GN_REVEAL_IMPL
// gnErrorCode gnInit(gnRenderingAPI RenderingAPI); // 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 #pragma once
#include <gryphn/gryphn_utils.h> #include <core/output_device/gryphn_physical_output_device.h>
#include "gryphn_physical_output_device.h"
struct gnPlatformOutputDevice; struct gnPlatformOutputDevice;
struct gnPhysicalOutputDevice; struct gnDeviceFunctions_t;
struct gnInstance;
struct gnOutputDevice { typedef struct gnOutputDevice_t {
ACCESS_LEVEL: struct gnPlatformOutputDevice* outputDevice;
gnPlatformOutputDevice* outputDevice = nullptr; struct gnDeviceFunctions_t* deviceFunctions;
gnPhysicalOutputDevice* physicalOutputDevice; gnPhysicalDevice* physicalDevice;
public: } gnOutputDevice;
gnOutputDevice() {}
};
inline gnReturnCode (*gnRegisterOutputDevice)(gnOutputDevice* outputDevice, const gnInstance& instance, const gnPhysicalOutputDevice& physicalDevice); gnReturnCode gnRegisterOutputDevice(gnOutputDevice* outputDevice, gnInstance* instance, const gnPhysicalDevice physicalDevice);
inline void (*gnWaitForDevice)(const gnOutputDevice& device); void gnDestroyOutputDevice(gnOutputDevice* device);
inline 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 #pragma once
#include <gryphn/gryphn_utils.h>
#include "core/instance/gryphn_instance.h" #include "core/instance/gryphn_instance.h"
struct gnPlatformPhysicalOutputDevice; struct gnPlatformPhysicalDevice;
struct gnInstance;
struct gnPhysicalOutputDevice { typedef struct gnPhysicalDeviceProperties_t {
ACCESS_LEVEL: // there are currently no properties
bool valid = false; } gnPhysicalDeviceProperties;
gnPlatformPhysicalOutputDevice* physicalOutputDevice = nullptr;
gnString outputDeviceName;
public:
gnPhysicalOutputDevice() {}
};
gnString gnGetPhysicalOutputDeviceName(const gnPhysicalOutputDevice& device); typedef struct gnPhysicalDevice_t {
inline bool (*gnDeviceSupportsAPI)(const gnPhysicalOutputDevice& device); struct gnPlatformPhysicalDevice* physicalDevice;
inline gnPhysicalOutputDevice* (*gnGetPhysicalOutputDevices)(const gnInstance& instance, uint32_t* count); 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_UNSUPPORTED_RENDERING_API,
GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY, GN_UNABLE_TO_LOAD_DYNAMIC_LIBARRY,
GN_FAILED_CREATE_INSTANCE, GN_FAILED_CREATE_INSTANCE,
GN_FAILED_TO_CREATE_DEBUGGER GN_FAILED_TO_CREATE_DEBUGGER,
GN_FAILED_TO_CREATE_DEVICE
// GN_UNKNOWN_ERROR, // GN_UNKNOWN_ERROR,
// GN_UNKNOWN_FRAMEBUFFER_ATTACHMENT, // GN_UNKNOWN_FRAMEBUFFER_ATTACHMENT,
@@ -16,7 +17,6 @@ typedef enum gnReturnCode_t {
// GN_UNSUPPORTED_COLOR_FORMAT, // GN_UNSUPPORTED_COLOR_FORMAT,
// GN_UNKNOWN_COLOR_FORMAT, // GN_UNKNOWN_COLOR_FORMAT,
// GN_FUNCTION_NOT_FOUND, // GN_FUNCTION_NOT_FOUND,
// GN_FAILED_CREATE_DEVICE,
// GN_FAILED_CREATE_GRAPHICS_PIPELINE, // GN_FAILED_CREATE_GRAPHICS_PIPELINE,
// GN_FAILED_CREATE_PRESENTATION_QUEUE, // GN_FAILED_CREATE_PRESENTATION_QUEUE,
// GN_FAILED_TO_CREATE_FRAMEBUFFER, // 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_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_CREATE_INSTANCE: return "GN_FAILED_CREATE_INSTANCE";
case GN_FAILED_TO_CREATE_DEBUGGER: return "GN_FAILED_TO_CREATE_DEBUGGER"; case GN_FAILED_TO_CREATE_DEBUGGER: return "GN_FAILED_TO_CREATE_DEBUGGER";
case GN_FAILED_TO_CREATE_DEVICE: return "GN_FAILED_TO_CREATE_DEVICE";
} }
} }