CMakeLists.txt

@@ -4,10 +4,10 @@ cmake_minimum_required(VERSION 3.13)
 
 project( Aster VERSION 0.1.0 )
 
-set(CMAKE_CXX_STANDARD 23)
+set( CMAKE_CXX_STANDARD 20 )
 set( CMAKE_CXX_STANDARD_REQUIRED ON )
 set( CMAKE_CXX_EXTENSIONS OFF )
 
-set(CMAKE_CXX_FLAGS -Wall)
+
 
 add_subdirectory( "aster_core" )

aster_core/CMakeLists.txt

@@ -1,42 +1,18 @@
-# CMakeList.txt ; CMake project for Aster Core
+# CMakeList.txt ; CMake project for Blaze
 
 cmake_minimum_required( VERSION 3.13 )
 
 find_package( glm CONFIG REQUIRED )
-find_package(glfw3 CONFIG REQUIRED)
 find_path( SCOTTT_DEBUGBREAK_INCLUDE_DIRS "debugbreak.h" )
-find_package(Vulkan REQUIRED)
+find_package( VulkanHeaders CONFIG REQUIRED )
-# find_package( VulkanHeaders CONFIG REQUIRED )
 find_package( VulkanMemoryAllocator CONFIG REQUIRED )
-find_package(fmt CONFIG REQUIRED)
 
-set(HEADER_FILES
+set( HEADER_FILES "constants.h" "config.h" "logger.h" "global.h" )
-        constants.h
+set( SOURCE_FILES "logger.cpp" "global.cpp" )
-        config.h
-        logger.h
-        global.h
-        context.h
-        window.h
-        device.h
-        physical_device.h)
 
-set(SOURCE_FILES
+add_library( aster_core "aster.cpp" ${SOURCE_FILES} ${HEADER_FILES} )
-        logger.cpp
+set_property( TARGET aster_core PROPERTY CXX_STANDARD 20 )
-        global.cpp
-        context.cpp
-        window.cpp
-        device.cpp
-        physical_device.cpp)
-
-add_library(aster_core ${SOURCE_FILES} ${HEADER_FILES})
-set_property(TARGET aster_core PROPERTY CXX_STANDARD 23)
 
 target_link_libraries( aster_core PRIVATE glm::glm-header-only )
-target_link_libraries(aster_core PRIVATE glfw)
 target_include_directories( aster_core PRIVATE ${SCOTTT_DEBUGBREAK_INCLUDE_DIRS})
-target_link_libraries(aster_core PRIVATE Vulkan::Vulkan Vulkan::Headers GPUOpen::VulkanMemoryAllocator)
+target_link_libraries( aster_core PRIVATE Vulkan::Headers GPUOpen::VulkanMemoryAllocator )
-target_link_libraries(aster_core PRIVATE fmt::fmt)
-
-add_executable(aster_exe "aster.cpp")
-target_link_libraries(aster_exe PRIVATE aster_core)
-target_link_libraries(aster_exe PRIVATE glm::glm-header-only)

aster_core/aster.cpp

@@ -1,38 +1,10 @@
-#include "constants.h"
+#include <iostream>
-#include "glfw_context.h"
+#include <glm/glm.hpp>
-#include "physical_device.h"
-#include "window.h"
-
-bool suitable_device(const PhysicalDevice *physical_device) {
-	constexpr auto required_support = QueueSupportFlags{} | QueueSupportFlagBits::eGraphics | QueueSupportFlagBits::ePresent | QueueSupportFlagBits::eTransfer;
-
-	return physical_device->properties.deviceType != vk::PhysicalDeviceType::eCpu &&
-			!physical_device->surface_formats.empty() &&
-			!physical_device->present_modes.empty() &&
-			cast<bool>(physical_device->queue_support & required_support);
-}
-
-PhysicalDevice find_suitable_device(PhysicalDevices &&_physical_devices) {
-	for (auto physdev : _physical_devices) {
-		VERBOSE(fmt::format("Checking device: {}", physdev.properties.deviceName.data()));
-		if (suitable_device(&physdev)) {
-			VERBOSE(fmt::format("Found suitable device {}.", physdev.properties.deviceName.data()));
-			return physdev;
-		}
-	}
-	throw std::runtime_error("No suitable physical device found.");
-}
 
 int main(int, char**) {
-	GlfwContext glfw = {};
-	Context context = { "Aster", VERSION };
-	Window window = { "Aster1", &context, { 640, 480 } };
   
-	PhysicalDevice physical_device = find_suitable_device({ &window, &context });
+  printf("Hello World\n");
-	INFO(fmt::format("Using Device {}", physical_device.properties.deviceName.data()));
-
-	while (window.poll()) {
-	}
 
   return 0;
 }
+

aster_core/config.h

@@ -11,6 +11,7 @@
 #define GLFW_INCLUDE_VULKAN
 #define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
 #define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
+#define VULKAN_HPP_NO_EXCEPTIONS
 
 #if defined(NDEBUG)
 #define USE_OPTICK (0)

aster_core/constants.h

@@ -30,13 +30,7 @@ using usize = size_t;
 using p64 = intptr_t;
 
 constexpr usize strlen_c(const char *s) {
-	usize len = 0;
+	return *s == '\0' ? 0 : 1 + strlen_c(s + 1);
-	char c = '\0';
-	do {
-		c = s[len];
-		len++;
-	} while (c != '\0');
-	return len;
 }
 
 constexpr auto ANSI_Black = "\u001b[30m";

aster_core/context.cpp

@@ -5,7 +5,7 @@
 
 #include "context.h"
 
-VKAPI_ATTR b32 VKAPI_CALL Context::debug_callback(const VkDebugUtilsMessageSeverityFlagBitsEXT _message_severity, const VkDebugUtilsMessageTypeFlagsEXT _message_type, const VkDebugUtilsMessengerCallbackDataEXT *_callback_data, [[maybe_unused]] void *_user_data) {
+VKAPI_ATTR b32 VKAPI_CALL Context::debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT _message_severity, VkDebugUtilsMessageTypeFlagsEXT _message_type, const VkDebugUtilsMessengerCallbackDataEXT *_callback_data, [[maybe_unused]] void *_user_data) {
 	using Severity = vk::DebugUtilsMessageSeverityFlagsEXT;
 	using SeverityBits = vk::DebugUtilsMessageSeverityFlagBitsEXT;
 	using MessageType = vk::DebugUtilsMessageTypeFlagsEXT;
@@ -29,6 +29,8 @@ VKAPI_ATTR b32 VKAPI_CALL Context::debug_callback(const VkDebugUtilsMessageSever
 }
 
 void Context::init(const std::string_view &_app_name, const Version &_app_version) {
+	vk::Result result;
+
 	INFO_IF(enable_validation_layers, "Validation Layers enabled");
 
 	// Creating Instance
@@ -52,7 +54,9 @@ void Context::init(const std::string_view &_app_name, const Version &_app_versio
 	};
 
 	u32 glfw_extension_count = 0;
-	const char **glfw_extensions = glfwGetRequiredInstanceExtensions(&glfw_extension_count);
+	const char **glfw_extensions = nullptr;
+
+	glfw_extensions = glfwGetRequiredInstanceExtensions(&glfw_extension_count);
 	std::vector<const char *> vulkan_extensions(glfw_extensions, glfw_extensions + glfw_extension_count);
 	if (enable_validation_layers) {
 		vulkan_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
@@ -63,31 +67,33 @@ void Context::init(const std::string_view &_app_name, const Version &_app_versio
 	const auto vkGetInstanceProcAddr = dl.getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
 	VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr);
 
-	try {
+	tie(result, instance) = vk::createInstance({
-		instance = vk::raii::Instance{ raii_context, {
 			.pNext = enable_validation_layers ? &debug_messenger_create_info : nullptr,
 			.pApplicationInfo = &app_info,
 			.enabledLayerCount = enable_validation_layers ? cast<u32>(validation_layers.size()) : 0,
 			.ppEnabledLayerNames = enable_validation_layers ? validation_layers.data() : nullptr,
 			.enabledExtensionCount = cast<u32>(vulkan_extensions.size()),
 			.ppEnabledExtensionNames = vulkan_extensions.data(),
-													 } };
+	});
-	} catch (const std::exception &err) {
+	ERROR_IF(failed(result), "Failed to create Vulkan instance with "s + to_string(result))
-		ERROR("Failed to create Vulkan instance with "s + err.what());
+	THEN_CRASH(result)
-		throw;
+	ELSE_INFO("Instance Created.");
-	}
+	VULKAN_HPP_DEFAULT_DISPATCHER.init(instance);
-	INFO("Instance Created.");
 
 	// Debug Messenger
 	if (enable_validation_layers) {
-		try {
+		tie(result, debug_messenger) = instance.createDebugUtilsMessengerEXT(debug_messenger_create_info);
-			debug_messenger = vk::raii::DebugUtilsMessengerEXT{ instance, debug_messenger_create_info };
+		ERROR_IF(failed(result), "Debug Messenger creation failed with "s + to_string(result))
-		} catch (const std::exception &err) {
+		ELSE_INFO("Debug Messenger Created.");
-			ERROR("Debug Messenger creation failed with "s + err.what());
-			throw;
-		}
-		INFO("Debug Messenger Created.");
 	}
 }
 
-Context::~Context() = default;
+Context::~Context() {
+	if (instance) {
+		if (enable_validation_layers && debug_messenger) {
+			instance.destroyDebugUtilsMessengerEXT(debug_messenger);
+		}
+		instance.destroy();
+		INFO("Context destroyed");
+	}
+}

aster_core/context.h

@@ -73,9 +73,8 @@ public:
 		VK_KHR_MULTIVIEW_EXTENSION_NAME,
 	};
 
-	vk::raii::Context raii_context;
+	vk::Instance instance;
-	vk::raii::Instance instance{ nullptr };
+	vk::DebugUtilsMessengerEXT debug_messenger;
-	vk::raii::DebugUtilsMessengerEXT debug_messenger{ nullptr };
 
 private:
 	void init(const std::string_view &_app_name, const Version &_app_version);

aster_core/device.cpp

@@ -1,94 +0,0 @@
-// =============================================
-//  Aster: device.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#include "device.h"
-
-#include "context.h"
-#include "window.h"
-
-#include <map>
-#include <set>
-#include <vector>
-
-Device::Device(Device &&_other) noexcept :
-		physical_device{ std::move(_other.physical_device) },
-		device{ std::exchange(_other.device, nullptr) },
-		allocator{ std::exchange(_other.allocator, nullptr) },
-		name{ std::move(_other.name) } {}
-
-Device &Device::operator=(Device &&_other) noexcept {
-	if (this == &_other)
-		return *this;
-	physical_device = std::move(_other.physical_device);
-	device = std::exchange(_other.device, nullptr);
-	allocator = std::exchange(_other.allocator, nullptr);
-	name = std::move(_other.name);
-	return *this;
-}
-
-Device::Device(const std::string_view &_name, Context *_context, const PhysicalDevice &_physical_device_info, const vk::PhysicalDeviceFeatures &_enabled_features, std::set<QueueAllocation> &&_enabled_queues) :
-		physical_device{ _physical_device_info },
-		name{ _name } {
-	const auto &physical_device = _physical_device_info.device;
-
-	// Logical Device
-	std::vector queue_priority(_enabled_queues.size(), 1.0f);
-	std::vector<vk::DeviceQueueCreateInfo> queue_create_infos;
-	queue_create_infos.reserve(_enabled_queues.size());
-	for (auto &[family_, count_] : _enabled_queues) {
-		queue_create_infos.push_back({
-				.queueFamilyIndex = family_,
-				.queueCount = count_,
-				.pQueuePriorities = queue_priority.data(),
-		});
-	}
-	try {
-		device = physical_device.createDevice({
-				.queueCreateInfoCount = cast<u32>(queue_create_infos.size()),
-				.pQueueCreateInfos = queue_create_infos.data(),
-				.enabledLayerCount = _context->enable_validation_layers ? cast<u32>(_context->validation_layers.size()) : 0,
-				.ppEnabledLayerNames = _context->enable_validation_layers ? _context->validation_layers.data() : nullptr,
-				.enabledExtensionCount = cast<u32>(_context->device_extensions.size()),
-				.ppEnabledExtensionNames = _context->device_extensions.data(),
-				.pEnabledFeatures = &_enabled_features,
-		});
-	} catch (const std::exception &err) {
-		ERROR("Failed to create a logical device with "s + err.what());
-		throw;
-	}
-	INFO("Logical Device Created!");
-
-	const VmaAllocatorCreateInfo allocator_create_info = {
-		.physicalDevice = *physical_device,
-		.device = *device,
-		.instance = *_context->instance,
-	};
-
-	allocator = nullptr;
-	const auto result = cast<vk::Result>(vmaCreateAllocator(&allocator_create_info, &allocator));
-	if (failed(result)) {
-		ERROR("Memory allocator creation failed with "s + vk::to_string(result));
-		throw std::runtime_error("Memory allocator creation failed with "s + vk::to_string(result));
-	}
-	VERBOSE("Memory Allocator Created");
-
-	INFO(fmt::format("Created Device '{}' Successfully", _name));
-
-	set_name(_name);
-}
-
-Device::~Device() {
-	if (allocator) {
-		vmaDestroyAllocator(allocator);
-	}
-	INFO("Device '" + name + "' Destroyed");
-}
-
-void Device::set_name(const std::string_view &_name) {
-	VERBOSE(fmt::format("Device {} -> {}", name.data(), _name.data()));
-	name = _name;
-	set_object_name(*physical_device.device, fmt::format("{} GPU", _name.data()));
-	set_object_name(*device, fmt::format("{} Device", _name.data()));
-}

aster_core/device.h

@@ -1,57 +0,0 @@
-// =============================================
-//  Aster: device.h
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#pragma once
-
-#include "context.h"
-#include "global.h"
-#include "physical_device.h"
-#include "window.h"
-
-#include <iterator>
-#include <set>
-#include <span>
-#include <string_view>
-#include <utility>
-
-struct QueueAllocation {
-	u32 family;
-	u32 count;
-};
-
-class Device {
-public:
-	Device(const Device &_other) = delete;
-	Device(Device &&_other) noexcept;
-	Device &operator=(const Device &_other) = delete;
-	Device &operator=(Device &&_other) noexcept;
-
-	Device(const std::string_view &_name, Context *_context, const PhysicalDevice &_physical_device_info, const vk::PhysicalDeviceFeatures &_enabled_features, std::set<QueueAllocation> &&_enabled_queues);
-
-	~Device();
-
-	template <typename T>
-	requires vk::isVulkanHandleType<T>::value void set_object_name(const T &_obj, const std::string_view &_name) const {
-		try {
-			device.setDebugUtilsObjectNameEXT({
-					.objectType = _obj.objectType,
-					.objectHandle = get_vk_handle(_obj),
-					.pObjectName = _name.data(),
-			});
-		} catch (const std::exception &err) {
-			WARN("Debug Utils name setting failed with "s + err.what());
-		}
-	}
-
-	// fields
-	PhysicalDevice physical_device;
-	vk::raii::Device device{ nullptr };
-	VmaAllocator allocator;
-
-	std::string name;
-
-private:
-	void set_name(const std::string_view &_name);
-};

aster_core/glfw_context.h

@@ -1,34 +0,0 @@
-// =============================================
-//  Aster: glfw_context.h
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#pragma once
-
-#include "global.h"
-
-struct GlfwContext {
-	static i32 post_error() noexcept {
-		static const char *error_ = nullptr;
-		const auto code = glfwGetError(&error_);
-		ERROR("GLFW "s + error_);
-		return code;
-	}
-
-	inline static u32 count = 0;
-
-	GlfwContext() {
-		if (count++ > 0)
-			return;
-		if (glfwInit() == GLFW_FALSE) {
-			CRASH(post_error());
-		}
-	}
-
-	~GlfwContext() {
-		if (--count == 0) {
-			glfwTerminate();
-		}
-		count = 0;
-	}
-};

aster_core/global.cpp

@@ -8,8 +8,67 @@
 #include <cstdarg>
 #include <cstdio>
 
+#pragma warning(push, 0)
 #define VMA_IMPLEMENTATION
 #include <vma/vk_mem_alloc.h>
+#pragma warning(pop)
 
 // NOTE: Vulkan Dispatch Loader Storage - Should only appear once.
 VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+
+//int Vsnprintf8(char* pDestination, size_t n, const char* pFormat, va_list arguments) {
+//	//ERROR_IF(pDestination == nullptr, "Null buffer") THEN_CRASH(1) ELSE_IF_ERROR(n == 0, "Empty buffer") THEN_CRASH(1);
+//#ifdef _MSC_VER
+//	auto v = vsnprintf(pDestination, n, pFormat, arguments);
+//	ERROR_IF(v == 0, "Final requirement cannot be 0") THEN_CRASH(1);
+//	return v;
+//#else
+//	return vsnprintf(pDestination, n, pFormat, arguments);
+//#endif
+//}
+//
+//int VsnprintfW(wchar_t* pDestination, size_t n, const wchar_t* pFormat, va_list arguments) {
+//	//ERROR_IF(pDestination == nullptr, "Null buffer") THEN_CRASH(1) ELSE_IF_ERROR(n == 0, "Empty buffer") THEN_CRASH(1);
+//#ifdef _MSC_VER
+//	if (pDestination == nullptr && n == 0) {
+//		return _vscwprintf(pFormat, arguments);
+//	} else {
+//		return _vsnwprintf_s(pDestination, n, _TRUNCATE, pFormat, arguments);
+//	}
+//#else
+//	char* d = new char[n + 1];
+//	int r = vsnprintf(d, n, convertstring<char16_t, char>(pFormat).c_str(), arguments);
+//	memcpy(pDestination, convertstring<char, char16_t>(d).c_str(), (n + 1) * sizeof(char16_t));
+//	delete[] d;
+//	return r;
+//#endif
+//}
+//
+//int Vsnprintf16(char16_t* pDestination, size_t n, const char16_t* pFormat, va_list arguments) {
+//	//ERROR_IF(pDestination == nullptr, "Null buffer") THEN_CRASH(1) ELSE_IF_ERROR(n == 0, "Empty buffer") THEN_CRASH(1);
+//#ifdef _MSC_VER
+//	if (pDestination == nullptr && n == 0) {
+//		return _vscwprintf((wchar_t*)pFormat, arguments);
+//	} else {
+//		return _vsnwprintf_s((wchar_t*)pDestination, n, _TRUNCATE, (wchar_t*)pFormat, arguments);
+//	}
+//#else
+//	char* d = new char[n + 1];
+//	int r = vsnprintf(d, n, convertstring<char16_t, char>(pFormat).c_str(), arguments);
+//	memcpy(pDestination, convertstring<char, char16_t>(d).c_str(), (n + 1) * sizeof(char16_t));
+//	delete[] d;
+//	return r;
+//#endif
+//}
+
+std::string std::impl::format(const char *_fmt, ...) {
+	va_list args;
+	va_start(args, _fmt);
+
+	const auto req = vsnprintf(nullptr, 0, _fmt, args) + 1;
+	string buf(req, '\0');
+	vsnprintf(buf.data(), buf.size(), _fmt, args);
+
+	va_end(args);
+	return buf;
+}

aster_core/global.h

@@ -10,20 +10,33 @@
 #include "logger.h"
 
 #include <GLFW/glfw3.h>
-#include <fmt/core.h>
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <string>
 
 #define VULKAN_HPP_ASSERT(expr) DEBUG_IF(!(expr), "Vulkan assert failed")
+#include <vulkan/vulkan.hpp>
+
+#pragma warning(push, 0)
 #include <vk_mem_alloc.h>
-#include <vulkan/vulkan_raii.hpp>
+#pragma warning(pop)
 
 #define CODE_LOC " @ " __FILE__ ":" VULKAN_HPP_STRINGIFY(__LINE__)
 [[nodiscard]] inline bool failed(const vk::Result _result) {
 	return _result != vk::Result::eSuccess;
 }
 
+namespace std {
+namespace impl {
+string format(const char *_fmt, ...);
+}
+
+template <typename... Ts>
+[[nodiscard]] string fmt(const char *_fmt, Ts &&..._args) {
+	return impl::format(_fmt, forward<Ts>(_args)...);
+}
+} // namespace std
+
 template <typename T>
 concept IsVkEnum = requires(T _t) {
 	{ std::is_enum_v<T> };
@@ -44,7 +57,7 @@ using namespace std::literals::string_view_literals;
 template <typename T>
 requires vk::isVulkanHandleType<T>::value [[nodiscard]] constexpr u64
 get_vk_handle(const T &_vk_handle) noexcept {
-	return reinterpret_cast<u64>(cast<typename T::CType>(_vk_handle));
+	return reinterpret_cast<u64>(cast<T::CType>(_vk_handle));
 }
 
 template <typename F>

aster_core/logger.cpp

@@ -5,4 +5,13 @@
 
 #include "logger.h"
 
-auto g_logger = Logger();
+Logger g_logger = Logger();
+
+/* Credits to Const-me */
+//namespace eastl {
+//	void __cdecl AssertionFailure(const char* af)
+//	{
+//		ERROR(af);
+//		__debugbreak();
+//	}
+//}

aster_core/logger.h

@@ -36,7 +36,6 @@ struct Logger {
 			return "[DEBUG]:";
 		if constexpr (LogLevel == LogType::eVerbose)
 			return "[VERB]: ";
-		return "";
 	}
 
 	template <LogType LogLevel>
@@ -51,7 +50,6 @@ struct Logger {
 			return ANSI_White;
 		if constexpr (LogLevel == LogType::eVerbose)
 			return ANSI_Blue;
-		return "";
 	}
 
 	template <LogType LogLevel>
@@ -67,7 +65,7 @@ struct Logger {
 	}
 
 	template <LogType LogLevel>
-	void log_cond(const char *_expr_str, const std::string_view &_message, const char *_loc, const u32 _line) const {
+	void log_cond(const char *_expr_str, const std::string_view &_message, const char *_loc, u32 _line) const {
 		if (cast<u32>(LogLevel) <= minimum_logging_level) {
 			printf("%s%s (%s) %s%s| at %s:%u%s\n", to_color_cstr<LogLevel>(), to_cstr<LogLevel>(), _expr_str, _message.data(), ANSI_Black, _loc, _line, ANSI_Reset);
 		}

aster_core/physical_device.cpp

@@ -1,49 +0,0 @@
-// =============================================
-//  Aster: physical_device.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#include "physical_device.h"
-
-std::vector<QueueFamilyInfo> PhysicalDevice::get_queue_families(const Window *_window) const {
-	auto queue_families_ = device.getQueueFamilyProperties();
-
-	std::vector<QueueFamilyInfo> queue_family_infos;
-	queue_family_infos.reserve(queue_families_.size());
-
-	u32 family_index = 0;
-	for (const auto &queue_family : queue_families_) {
-		QueueSupportFlags support;
-
-		if (queue_family.queueFlags & vk::QueueFlagBits::eGraphics) {
-			support |= QueueSupportFlagBits::eGraphics;
-		}
-		if (queue_family.queueFlags & vk::QueueFlagBits::eCompute) {
-			support |= QueueSupportFlagBits::eCompute;
-		}
-		if (queue_family.queueFlags & vk::QueueFlagBits::eTransfer) {
-			support |= QueueSupportFlagBits::eTransfer;
-		}
-
-		try {
-			if (device.getSurfaceSupportKHR(family_index, *_window->surface)) {
-				support |= QueueSupportFlagBits::ePresent;
-			}
-		} catch (const std::exception &err) {
-			ERROR("Failure in finding surface support, all possibilities fatal. Failed with "s + err.what());
-			throw;
-		}
-
-		VERBOSE(fmt::format("Queue({}): {}", family_index, to_string(support)));
-
-		queue_family_infos.push_back({
-				.index = family_index,
-				.count = queue_family.queueCount,
-				.queue_support = support,
-		});
-
-		++family_index;
-	}
-
-	return queue_family_infos;
-}

aster_core/physical_device.h

@@ -1,84 +0,0 @@
-// =============================================
-//  Aster: physical_device.h
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#pragma once
-
-#include "global.h"
-#include "window.h"
-
-enum class QueueSupportFlagBits {
-	eGraphics = 0b0000'0001,
-	eTransfer = 0b0000'0010,
-	eCompute = 0b0000'0100,
-	ePresent = 0b0000'1000,
-};
-
-using QueueSupportFlags = vk::Flags<QueueSupportFlagBits>;
-
-inline std::string to_string(QueueSupportFlags queue_support) {
-	if (! queue_support)
-		return {};
-
-	std::string result = "";
-	if (queue_support & QueueSupportFlagBits::eGraphics) {
-		result += "Graphics | ";
-	}
-	if (queue_support & QueueSupportFlagBits::eTransfer) {
-		result += "Transfer | ";
-	}
-	if (queue_support & QueueSupportFlagBits::eCompute) {
-		result += "Compute | ";
-	}
-	if (queue_support & QueueSupportFlagBits::ePresent) {
-		result += "Present | ";
-	}
-
-	return "{ " + result.substr( 0, result.size() - 3 ) + " }";
-}
-
-struct QueueFamilyInfo {
-	u32 index;
-	u32 count;
-	QueueSupportFlags queue_support;
-
-	[[nodiscard]] bool has_support(const QueueSupportFlags &support) const {
-		return cast<bool>(queue_support & support);
-	}
-};
-
-struct PhysicalDevice {
-	vk::raii::PhysicalDevice device;
-	vk::PhysicalDeviceProperties properties;
-	vk::PhysicalDeviceFeatures features;
-	std::vector<vk::SurfaceFormatKHR> surface_formats;
-	std::vector<vk::PresentModeKHR> present_modes;
-	std::vector<QueueFamilyInfo> queue_family_infos;
-	QueueSupportFlags queue_support;
-
-	PhysicalDevice(const Window *const _window, vk::raii::PhysicalDevice &&_device) :
-			device{ std::move(_device) } {
-		properties = device.getProperties();
-		features = device.getFeatures();
-		surface_formats = device.getSurfaceFormatsKHR(*_window->surface);
-		present_modes = device.getSurfacePresentModesKHR(*_window->surface);
-		queue_family_infos = get_queue_families(_window);
-		for (auto [family, count, support] : queue_family_infos) {
-			queue_support |= support;
-		}
-	}
-
-	std::vector<QueueFamilyInfo> get_queue_families(const Window *_window) const;
-};
-
-struct PhysicalDevices : std::vector<PhysicalDevice> {
-	PhysicalDevices(const Window *const _window, const Context *_context) {
-		auto phys_devs = vk::raii::PhysicalDevices(_context->instance);
-		reserve(phys_devs.size());
-
-		for (auto physdev : phys_devs) {
-			emplace_back(_window, std::move(physdev));
-		}
-	}
-};

aster_core/window.cpp

@@ -1,75 +0,0 @@
-// =============================================
-//  Aster: window.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#include "window.h"
-#include "context.h"
-#include "glfw_context.h"
-#include "logger.h"
-
-Window::Window(const std::string_view &_title, Context *_context, const vk::Extent2D _extent, const bool _full_screen) :
-		extent{ _extent }, name{ _title } {
-	full_screen = _full_screen;
-	monitor = glfwGetPrimaryMonitor();
-	ERROR_IF(monitor == nullptr, "No monitor found");
-
-	i32 x_, y_, w_, h_;
-	glfwGetMonitorWorkarea(monitor, &x_, &y_, &w_, &h_);
-
-	glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
-	glfwWindowHint(GLFW_CENTER_CURSOR, GLFW_TRUE);
-
-	window = glfwCreateWindow(cast<i32>(extent.width), cast<i32>(extent.height), name.c_str(), (_full_screen ? monitor : nullptr), nullptr);
-	ERROR_IF(window == nullptr, "Window creation failed")
-	ELSE_INFO(fmt::format("Window '{}' created with resolution '{}x{}'", name.data(), extent.width, extent.height));
-	if (window == nullptr) {
-		auto code = GlfwContext::post_error();
-		glfwTerminate();
-		CRASH(code);
-	}
-
-	if (full_screen == false) {
-		glfwSetWindowPos(window, cast<i32>(w_ - extent.width) / 2, cast<i32>(h_ - extent.height) / 2);
-	}
-	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
-
-	VkSurfaceKHR surface_;
-	auto result = cast<vk::Result>(glfwCreateWindowSurface(cast<VkInstance>(*_context->instance), window, nullptr, &surface_));
-	if (failed(result)) {
-		ERROR("Failed to create Surface with "s + to_string(result));
-		throw std::runtime_error("Failed to create Surface with "s + to_string(result));
-	}
-	INFO("Surface Created");
-	surface = vk::raii::SurfaceKHR{ _context->instance, surface_ };
-}
-
-Window::Window(Window &&_other) noexcept :
-		window{ std::exchange(_other.window, nullptr) },
-		monitor{ _other.monitor },
-		surface{ std::exchange(_other.surface, nullptr) },
-		extent{ _other.extent },
-		name{ std::move(_other.name) },
-		full_screen{ _other.full_screen } {}
-
-Window &Window::operator=(Window &&_other) noexcept {
-	if (this == &_other)
-		return *this;
-	window = _other.window;
-	monitor = _other.monitor;
-	surface = std::exchange(_other.surface, nullptr);
-	extent = _other.extent;
-	name = std::move(_other.name);
-	full_screen = _other.full_screen;
-	return *this;
-}
-
-Window::~Window() {
-	if (window != nullptr) {
-		glfwDestroyWindow(window);
-		window = nullptr;
-	}
-	monitor = nullptr;
-
-	INFO(fmt::format("Window '{}' Destroyed", name));
-}

aster_core/window.h

@@ -1,47 +0,0 @@
-// =============================================
-//  Aster: window.h
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#pragma once
-
-#include "global.h"
-
-#include "context.h"
-
-struct Window final {
-	Window(const std::string_view &_title, Context *_context, vk::Extent2D _extent, b8 _full_screen = false);
-
-	Window(const Window &_other) = delete;
-	Window(Window &&_other) noexcept;
-	Window &operator=(const Window &_other) = delete;
-	Window &operator=(Window &&_other) noexcept;
-
-	~Window();
-
-	[[nodiscard]] bool should_close() const noexcept {
-		return glfwWindowShouldClose(window);
-	}
-
-	[[nodiscard]] bool poll() const noexcept {
-		glfwPollEvents();
-		return !glfwWindowShouldClose(window);
-	}
-
-	void set_window_size(const vk::Extent2D &_extent) noexcept {
-		extent = _extent;
-		glfwSetWindowSize(window, cast<i32>(extent.width), cast<i32>(extent.height));
-	}
-
-	void set_window_size(const u32 _width, const u32 _height) noexcept {
-		set_window_size({ _width, _height });
-	}
-
-	// fields
-	GLFWwindow *window{ nullptr };
-	GLFWmonitor *monitor{ nullptr };
-	vk::raii::SurfaceKHR surface{ nullptr };
-	vk::Extent2D extent;
-	std::string name;
-	b8 full_screen{ false };
-};

run.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 if [ -d "out" ]; then
-    pushd ./build/ > /dev/null || exit
+    pushd ./out/ > /dev/null || exit
     if echo "$@" | grep -e "debug" -q
     then
         lldb aster-exe

vcpkg.json

@@ -3,7 +3,6 @@
     "glfw3",
     "glm",
     "scottt-debugbreak",
-    "vulkan-memory-allocator",
+    "vulkan-memory-allocator"
-    "fmt"
   ]
 }