jayden/nova-engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename local parameter variables to use p_ prefix

Browse Source
This commit is contained in:
Jayden Grubb
2025-04-13 10:04:53 +10:00
parent 8efa200e9e
commit 859547570b
8 changed files with 81 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
engine/include/nova/platform/window_driver.h
View File

@@ -38,6 +38,6 @@ namespace Nova {
virtual void set_window_position(WindowID window, i32 x, i32 y) = 0;
[[nodiscard]] virtual const char* get_surface_extension() const = 0;
[[nodiscard]] virtual SurfaceID create_surface(WindowID window, RenderDriver* render_driver) = 0;
[[nodiscard]] virtual SurfaceID create_surface(WindowID window, RenderDriver* driver) = 0;
};
} // namespace Nova

10
engine/src/core/debug.cpp
View File

@@ -26,13 +26,13 @@ bool Debug::is_debug() {
#endif
}
void Internals::_assert_fail(std::string_view assertion, std::string_view file, std::string_view func, int line) {
void Internals::_assert_fail(std::string_view p_assertion, std::string_view p_file, std::string_view p_func, int p_line) {
Debug::get_logger()->critical(
"ASSERTION FAILED\n Assertion: \"{}\"\n File: \"{}\" (line {})\n Function: {}()",
assertion,
file,
line,
func
p_assertion,
p_file,
p_line,
p_func
);
std::abort();
}

73
engine/src/drivers/vulkan/render_driver.cpp
View File

@@ -21,7 +21,7 @@
using namespace Nova;
VulkanRenderDriver::VulkanRenderDriver(WindowDriver* window_driver) : m_window_driver(window_driver) {
VulkanRenderDriver::VulkanRenderDriver(WindowDriver* p_driver) : m_window_driver(p_driver) {
NOVA_AUTO_TRACE();
_check_version();
_check_extensions();
@@ -69,34 +69,39 @@ u32 VulkanRenderDriver::get_device_count() const {
return static_cast<u32>(m_devices.size());
}
const RenderDevice& VulkanRenderDriver::get_device(const u32 index) const {
NOVA_ASSERT(index < m_devices.size());
return m_devices[index];
const RenderDevice& VulkanRenderDriver::get_device(const u32 p_index) const {
NOVA_ASSERT(p_index < m_devices.size());
return m_devices[p_index];
}
bool VulkanRenderDriver::get_device_supports_surface(const u32 index, const SurfaceID surface) const {
bool VulkanRenderDriver::get_device_supports_surface(const u32 p_index, const SurfaceID p_surface) const {
NOVA_AUTO_TRACE();
NOVA_ASSERT(index < m_devices.size());
NOVA_ASSERT(surface);
NOVA_ASSERT(p_index < m_devices.size());
NOVA_ASSERT(p_surface);
// TODO: Check other queue families?
SurfaceData* data = reinterpret_cast<SurfaceData*>(surface);
SurfaceData* data = reinterpret_cast<SurfaceData*>(p_surface);
VkBool32 supported = false;
if (vkGetPhysicalDeviceSurfaceSupportKHR(static_cast<VkPhysicalDevice>(m_devices[index].handle), 0, data->handle, &supported)
if (vkGetPhysicalDeviceSurfaceSupportKHR(
static_cast<VkPhysicalDevice>(m_devices[p_index].handle),
0,
data->handle,
&supported
)
!= VK_SUCCESS) {
return false;
}
return supported;
}
void VulkanRenderDriver::select_device(u32 index) {
void VulkanRenderDriver::select_device(u32 p_index) {
NOVA_AUTO_TRACE();
NOVA_ASSERT(!m_device);
NOVA_ASSERT(index < m_devices.size());
NOVA_ASSERT(p_index < m_devices.size());
NOVA_LOG("Using device: {}", m_devices[index].name);
m_physical_device = static_cast<VkPhysicalDevice>(m_devices[index].handle);
NOVA_LOG("Using device: {}", m_devices[p_index].name);
m_physical_device = static_cast<VkPhysicalDevice>(m_devices[p_index].handle);
_check_device_extensions();
_check_device_features();
@@ -107,15 +112,15 @@ void VulkanRenderDriver::select_device(u32 index) {
_init_device(queues);
}
SurfaceID VulkanRenderDriver::create_surface(const WindowID window) {
SurfaceID VulkanRenderDriver::create_surface(const WindowID p_window) {
NOVA_AUTO_TRACE();
NOVA_ASSERT(m_window_driver);
return m_window_driver->create_surface(window, this);
return m_window_driver->create_surface(p_window, this);
}
void VulkanRenderDriver::destroy_surface(const SurfaceID surface) {
void VulkanRenderDriver::destroy_surface(const SurfaceID p_surface) {
NOVA_AUTO_TRACE();
SurfaceData* data = reinterpret_cast<SurfaceData*>(surface);
SurfaceData* data = reinterpret_cast<SurfaceData*>(p_surface);
vkDestroySurfaceKHR(m_instance, data->handle, get_allocator(VK_OBJECT_TYPE_SURFACE_KHR));
delete data;
}
@@ -124,9 +129,9 @@ VkInstance VulkanRenderDriver::get_instance() const {
return m_instance;
}
VkAllocationCallbacks* VulkanRenderDriver::get_allocator(const VkObjectType type) const {
VkAllocationCallbacks* VulkanRenderDriver::get_allocator(const VkObjectType p_type) const {
// TODO: Add custom allocator
(void)type;
(void)p_type;
return nullptr;
}
@@ -331,7 +336,7 @@ void VulkanRenderDriver::_check_device_capabilities() {
// TODO: Check device capabilities
}
void VulkanRenderDriver::_init_queues(std::vector<VkDeviceQueueCreateInfo>& queues) const {
void VulkanRenderDriver::_init_queues(std::vector<VkDeviceQueueCreateInfo>& p_queues) const {
NOVA_AUTO_TRACE();
u32 count;
@@ -339,12 +344,12 @@ void VulkanRenderDriver::_init_queues(std::vector<VkDeviceQueueCreateInfo>& queu
std::vector<VkQueueFamilyProperties> available(count);
vkGetPhysicalDeviceQueueFamilyProperties(m_physical_device, &count, available.data());
constexpr VkQueueFlags mask = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT;
static float priority = 1.0f;
constexpr VkQueueFlags QUEUE_MASK = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT;
static float s_priority = 1.0f;
VkQueueFlags found = 0;
for (u32 i = 0; i < count; i++) {
if ((available[i].queueFlags & mask) == 0) {
if ((available[i].queueFlags & QUEUE_MASK) == 0) {
continue;
}
if (!available[i].queueCount) {
@@ -354,19 +359,21 @@ void VulkanRenderDriver::_init_queues(std::vector<VkDeviceQueueCreateInfo>& queu
NOVA_LOG("Using queue family: {}", i);
found |= available[i].queueFlags;
queues.emplace_back();
queues.back().sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queues.back().queueFamilyIndex = i;
queues.back().queueCount = 1; // TODO: Does it make sense to have more than one queue?
queues.back().pQueuePriorities = &priority;
VkDeviceQueueCreateInfo queue {};
queue.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queue.queueFamilyIndex = i;
queue.queueCount = 1;
queue.pQueuePriorities = &s_priority;
p_queues.push_back(queue);
}
if ((found & mask) != mask) {
throw std::runtime_error("Failed to find required queue family");
if ((found & QUEUE_MASK) != QUEUE_MASK) {
throw std::runtime_error("Failed to find all required queue families");
}
}
void VulkanRenderDriver::_init_device(const std::vector<VkDeviceQueueCreateInfo>& queues) {
void VulkanRenderDriver::_init_device(const std::vector<VkDeviceQueueCreateInfo>& p_queues) {
NOVA_AUTO_TRACE();
VkDeviceCreateInfo create {};
@@ -375,8 +382,8 @@ void VulkanRenderDriver::_init_device(const std::vector<VkDeviceQueueCreateInfo>
create.ppEnabledLayerNames = m_layers.data();
create.enabledExtensionCount = static_cast<u32>(m_device_extensions.size());
create.ppEnabledExtensionNames = m_device_extensions.data();
create.queueCreateInfoCount = static_cast<u32>(queues.size());
create.pQueueCreateInfos = queues.data();
create.queueCreateInfoCount = static_cast<u32>(p_queues.size());
create.pQueueCreateInfos = p_queues.data();
create.pEnabledFeatures = &m_features;
// TODO: pNext for additional features

48
engine/src/drivers/x11/window_driver.cpp
View File

@@ -98,48 +98,48 @@ u32 X11WindowDriver::get_window_count() const {
return static_cast<u32>(m_windows.size());
}
WindowID X11WindowDriver::create_window(const std::string_view title, const u32 width, const u32 height) {
WindowID X11WindowDriver::create_window(const std::string_view p_title, const u32 p_width, const u32 p_height) {
NOVA_AUTO_TRACE();
const WindowID window = XCreateSimpleWindow(m_display, DefaultRootWindow(m_display), 0, 0, width, height, 0, 0, 0);
const WindowID window = XCreateSimpleWindow(m_display, DefaultRootWindow(m_display), 0, 0, p_width, p_height, 0, 0, 0);
WindowData& data = m_windows[window];
data.width = width;
data.height = height;
data.width = p_width;
data.height = p_height;
XSetWMProtocols(m_display, window, &m_window_close_atom, 1);
XSelectInput(m_display, window, StructureNotifyMask);
XStoreName(m_display, window, title.data());
XStoreName(m_display, window, p_title.data());
XMapWindow(m_display, window);
XFlush(m_display);
return window;
}
void X11WindowDriver::destroy_window(const WindowID window) {
void X11WindowDriver::destroy_window(const WindowID p_window) {
NOVA_AUTO_TRACE();
if (!m_windows.contains(window)) {
if (!m_windows.contains(p_window)) {
return;
}
XDestroyWindow(m_display, window);
m_windows.erase(window);
XDestroyWindow(m_display, p_window);
m_windows.erase(p_window);
}
void X11WindowDriver::set_window_title(const WindowID window, const std::string_view title) {
void X11WindowDriver::set_window_title(const WindowID p_window, const std::string_view p_title) {
NOVA_AUTO_TRACE();
NOVA_ASSERT(m_windows.contains(window));
XStoreName(m_display, window, title.data());
NOVA_ASSERT(m_windows.contains(p_window));
XStoreName(m_display, p_window, p_title.data());
}
void X11WindowDriver::set_window_size(const WindowID window, const u32 width, const u32 height) {
void X11WindowDriver::set_window_size(const WindowID p_window, const u32 p_width, const u32 p_height) {
NOVA_AUTO_TRACE();
NOVA_ASSERT(m_windows.contains(window));
XResizeWindow(m_display, window, width, height);
NOVA_ASSERT(m_windows.contains(p_window));
XResizeWindow(m_display, p_window, p_width, p_height);
}
void X11WindowDriver::set_window_position(const WindowID window, const i32 x, const i32 y) {
void X11WindowDriver::set_window_position(const WindowID p_window, const i32 p_x, const i32 p_y) {
NOVA_AUTO_TRACE();
NOVA_ASSERT(m_windows.contains(window));
XMoveWindow(m_display, window, x, y);
NOVA_ASSERT(m_windows.contains(p_window));
XMoveWindow(m_display, p_window, p_x, p_y);
}
const char* X11WindowDriver::get_surface_extension() const {
@@ -150,19 +150,19 @@ const char* X11WindowDriver::get_surface_extension() const {
#endif
}
SurfaceID X11WindowDriver::create_surface(const WindowID window, RenderDriver* render_driver) {
SurfaceID X11WindowDriver::create_surface(const WindowID p_window, RenderDriver* p_driver) {
NOVA_AUTO_TRACE();
NOVA_ASSERT(m_windows.contains(window));
NOVA_ASSERT(render_driver);
NOVA_ASSERT(render_driver->get_api() == RenderAPI::VULKAN);
NOVA_ASSERT(m_windows.contains(p_window));
NOVA_ASSERT(p_driver);
NOVA_ASSERT(p_driver->get_api() == RenderAPI::VULKAN);
#ifdef NOVA_VULKAN
VkXlibSurfaceCreateInfoKHR create {};
create.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
create.dpy = m_display;
create.window = static_cast<Window>(window);
create.window = static_cast<Window>(p_window);
const auto vkrd = static_cast<VulkanRenderDriver*>(render_driver);
const auto vkrd = static_cast<VulkanRenderDriver*>(p_driver);
SurfaceData* surface = new SurfaceData();
if (vkCreateXlibSurfaceKHR(vkrd->get_instance(), &create, vkrd->get_allocator(VK_OBJECT_TYPE_SURFACE_KHR), &surface->handle)

2
engine/src/drivers/x11/window_driver.h
View File

@@ -39,7 +39,7 @@ namespace Nova {
void set_window_position(WindowID window, i32 x, i32 y) override;
[[nodiscard]] const char* get_surface_extension() const override;
[[nodiscard]] SurfaceID create_surface(WindowID window, RenderDriver* render_driver) override;
[[nodiscard]] SurfaceID create_surface(WindowID window, RenderDriver* driver) override;
private:
Display* m_display = nullptr;

10
engine/src/render/render_device.cpp
View File

@@ -10,18 +10,18 @@
using namespace Nova;
u32 RenderDevice::choose_device(RenderDriver* driver, std::span<const SurfaceID> surfaces) {
u32 RenderDevice::choose_device(RenderDriver* p_driver, std::span<const SurfaceID> p_surfaces) {
NOVA_AUTO_TRACE();
u32 best_index = -1;
u32 best_score = 0;
for (u32 i = 0; i < driver->get_device_count(); i++) {
auto& device = driver->get_device(i);
for (u32 i = 0; i < p_driver->get_device_count(); i++) {
auto& device = p_driver->get_device(i);
u32 score = 1;
for (SurfaceID surface : surfaces) {
if (!driver->get_device_supports_surface(i, surface)) {
for (SurfaceID surface : p_surfaces) {
if (!p_driver->get_device_supports_surface(i, surface)) {
score = 0;
break;
}

6
engine/src/render/render_driver.cpp
View File

@@ -12,16 +12,16 @@
using namespace Nova;
RenderDriver* RenderDriver::create(const RenderAPI api, WindowDriver* window_driver) {
RenderDriver* RenderDriver::create(const RenderAPI p_api, WindowDriver* p_driver) {
NOVA_AUTO_TRACE();
switch (api) {
switch (p_api) {
#ifdef NOVA_DX12
case RenderAPI::DX12:
return new DX12RenderDriver();
#endif
#ifdef NOVA_VULKAN
case RenderAPI::VULKAN:
return new VulkanRenderDriver(window_driver);
return new VulkanRenderDriver(p_driver);
#endif
default:
throw std::runtime_error("Unsupported render API");

4
engine/src/render/renderer.cpp
View File

@@ -13,11 +13,11 @@ using namespace Nova;
static std::unique_ptr<RenderDriver> s_driver;
void Renderer::init(const RenderAPI api) {
void Renderer::init(const RenderAPI p_api) {
NOVA_AUTO_TRACE();
NOVA_ASSERT(!s_driver);
s_driver = std::unique_ptr<RenderDriver>(RenderDriver::create(api, nullptr));
s_driver = std::unique_ptr<RenderDriver>(RenderDriver::create(p_api, nullptr));
}
void Renderer::shutdown() {