Merge remote-tracking branch 'upstream/main'

include/renderer/internal/vulkan/vulkan_buffer.h

@@ -28,6 +28,7 @@
 
 #include <vulkan/vulkan.h>
 #include <renderer/defines.h>		// u32
+#include <renderer/internal/vulkan/vulkan_object.h>
 
 typedef struct vulkan_buffer_create_info_t
 {
@@ -48,6 +49,7 @@ typedef struct vulkan_buffer_create_info_t
 
 typedef struct vulkan_buffer_t
 {
+	__VULKAN_OBJECT__;
 	vulkan_renderer_t* renderer;				// pointer to the vulkan_renderer_t object
 	VkBuffer vo_handle;
 	VkDeviceMemory vo_memory;

include/renderer/internal/vulkan/vulkan_host_buffered_buffer.h

@@ -3,6 +3,7 @@
 #include <renderer/defines.h>
 #include <bufferlib/buffer.h>
 #include <renderer/internal/vulkan/vulkan_buffer.h>
+#include <renderer/internal/vulkan/vulkan_object.h>
 
 typedef struct vulkan_host_buffered_buffer_create_info_t
 {
@@ -19,6 +20,7 @@ typedef BUFFER buffer_t;
 /* a GPU buffer having a coherent copy on the host side */
 typedef struct vulkan_host_buffered_buffer_t
 {
+	__VULKAN_OBJECT__;
 	vulkan_renderer_t* renderer;
 	vulkan_buffer_t device_buffer;
 	buffer_t host_buffer;
@@ -27,6 +29,9 @@ typedef struct vulkan_host_buffered_buffer_t
 	bool is_dirty;
 } vulkan_host_buffered_buffer_t;
 
+#define VULKAN_HOST_BUFFERED_BUFFER(typed_ptr) VULKAN_OBJECT_TYPE_CAST(vulkan_host_buffered_buffer_t*, VULKAN_OBJECT_TYPE_HOST_BUFFERED_BUFFER, typed_ptr)
+#define VULKAN_HOST_BUFFERED_BUFFER_CONST(typed_ptr) VULKAN_OBJECT_TYPE_CONST_CAST(const vulkan_host_buffered_buffer_t*, VULKAN_OBJECT_TYPE_HOST_BUFFERED_BUFFER, typed_ptr)
+
 
 BEGIN_CPP_COMPATIBLE
 

include/renderer/internal/vulkan/vulkan_instance_buffer.h

@@ -27,6 +27,7 @@
 #pragma once
 
 #include <renderer/internal/vulkan/vulkan_buffer.h>
+#include <renderer/internal/vulkan/vulkan_object.h>
 #include <renderer/multi_buffer.h>
 
 typedef struct vulkan_renderer_t vulkan_renderer_t;
@@ -39,14 +40,16 @@ typedef struct vulkan_instance_buffer_create_info_t
 
 typedef struct vulkan_instance_buffer_t
 {
+	__VULKAN_OBJECT__;
 	vulkan_renderer_t* renderer;
 	vulkan_buffer_t device_buffer;			// buffer in the device memory
 	multi_buffer_t host_buffer;				// buffer in the host memory
 	bool has_device_buffer; 				// initially only host-side buffer is created and used; so it would be false if *_commit never called
 	bool is_dirty;
 } vulkan_instance_buffer_t;
 
-#define VULKAN_INSTANCE_BUFFER(ptr) CAST_TO(vulkan_instance_buffer_t*, ptr)
+#define VULKAN_INSTANCE_BUFFER(ptr) VULKAN_OBJECT_TYPE_CAST(vulkan_instance_t*, VULKAN_OBJECT_TYPE_INSTANCE_BUFFER, ptr)
+#define VULKAN_INSTANCE_BUFFER_CONST(ptr) VULKAN_OBJECT_TYPE_CONST_CAST(const vulkan_instance_t*, VULKAN_OBJECT_TYPE_INSTANCE_BUFFER, ptr)
 
 BEGIN_CPP_COMPATIBLE
 

include/renderer/internal/vulkan/vulkan_object.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include <renderer/defines.h>			// stdbool.h
+#include <renderer/alloc.h>				// memset
+#include <renderer/assert.h> 			// _debug_assert__
+
+typedef enum vulkan_object_nationality_t
+{
+	VULKAN_OBJECT_NATIONALITY_UNDEFINED = 0,
+	VULKAN_OBJECT_NATIONALITY_EXTERNAL,
+	VULKAN_OBJECT_NATIONALITY_INTERNAL,
+	VULKAN_OBJECT_NATIONALITY_MAX
+} vulkan_object_nationality_t;
+
+typedef enum vulkan_object_type_t
+{
+	VULKAN_OBJECT_TYPE_UNDEFINED = 0,
+	VULKAN_OBJECT_TYPE_BUFFER,
+	VULKAN_OBJECT_TYPE_SHADER_MODULE,
+	VULKAN_OBJECT_TYPE_INSTANCE_BUFFER,
+	VULKAN_OBJECT_TYPE_HOST_BUFFERED_BUFFER,
+	VULKAN_OBJECT_TYPE_MAX
+} vulkan_object_type_t;
+
+typedef struct vulkan_object_t
+{
+	vulkan_object_nationality_t nationality;
+
+	/* type information need not to be retained in release mode */
+	IF_DEBUG( vulkan_object_type_t type; )
+} vulkan_object_t;
+
+#define VULKAN_OBJECT(typed_ptr) REINTERPRET_CAST(vulkan_object_t*, typed_ptr)
+#define VULKAN_OBJECT_CONST(typed_ptr) REINTERPRET_CONST_CAST(vulkan_object_t*, typed_ptr)
+#define VULKAN_OBJECT_VOID(void_ptr) CAST_TO(vulkan_object_t*, void_ptr)
+#define VULKAN_OBJECT_CONST_VOID(void_ptr) CAST_TO(const vulkan_object_t*, void_ptr)
+
+#define __VULKAN_OBJECT__ vulkan_object_t __vo##__LINE__
+#define VULKAN_OBJECT_INIT(typed_ptr, type, nationality) vulkan_object_init(VULKAN_OBJECT(typed_ptr), type, nationality)
+static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE void vulkan_object_init(vulkan_object_t* obj, vulkan_object_type_t type, bool nationality)
+{
+	obj->type = type;
+	obj->nationality = nationality;
+}
+#define VULKAN_OBJECT_MEMZERO(typed_ptr, type) vulkan_object_memzero(CAST_TO(void*, VULKAN_OBJECT_VERIFY_FORWARD(typed_ptr)), sizeof(typed_ptr[0]))
+static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE void vulkan_object_memzero(void* ptr, u32 size)
+{
+	_debug_assert__((ptr != NULL) && (size != 0));
+	_debug_assert__(size >= sizeof(vulkan_object_t));
+	memset(ptr + sizeof(vulkan_object_t), 0, size - sizeof(vulkan_object_t));
+}
+
+
+
+
+/* nationality (memory ownership) */
+#define VULKAN_OBJECT_IS_INTERNAL(typed_ptr) (VULKAN_OBJECT_GET_NATIONALITY(typed_ptr) == VULKAN_OBJECT_NATIONALITY_INTERNAL)
+#define VULKAN_OBJECT_IS_EXTERNAL(typed_ptr) (VULKAN_OBJECT_GET_NATIONALITY(typed_ptr) == VULKAN_OBJECT_NATIONALITY_EXTERNAL)
+#define VULKAN_OBJECT_IS_UNDEFINED(typed_ptr) (VULKAN_OBJECT_GET_NATIONALITY(typed_ptr) == VULKAN_OBJECT_NATIONALITY_UNDEFINED)
+#define VULKAN_OBJECT_IS_NATIONALITY_GARBAGE(typed_ptr) (VULKAN_OBJECT_IS_UNDEFINED(typed_ptr) || (VULKAN_OBJECT_GET_NATIONALITY(typed_ptr) >= VULKAN_OBJECT_NATIONALITY_MAX))
+
+/* type of the object */
+#define VULKAN_OBJECT_IS_TYPE_UNDEFINED(typed_ptr) (VULKAN_OBJECT_GET_TYPE(typed_ptr) == VULKAN_OBJECT_TYPE_UNDEFINED)
+#define VULKAN_OBJECT_IS_TYPE_GARBAGE(typed_ptr) (VULKAN_OBJECT_IS_TYPE_UNDEFINED(typed_ptr) || (VULKAN_OBJECT_GET_TYPE(typed_ptr) >= VULKAN_OBJECT_TYPE_MAX))
+
+#define VULKAN_OBJECT_SET_NATIONALITY(typed_ptr, nationality) vulkan_object_set_nationality(VULKAN_OBJECT(typed_ptr), nationality)
+#define VULKAN_OBJECT_GET_NATIONALITY(typed_ptr) vulkan_object_get_nationality(VULKAN_OBJECT_CONST(typed_ptr))
+static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE vulkan_object_nationality_t vulkan_object_get_nationality(const vulkan_object_t* obj) { return obj->nationality; }
+static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE void vulkan_object_set_nationality(vulkan_object_t* obj, bool nationality) { obj->nationality = nationality; }
+
+/* usage of VULKAN_OBJECT_SET_TYPE Or VULKAN_OBJECT_GET_TYPE is not permitted in release mode */
+#ifdef GLOBAL_DEBUG
+#	define VULKAN_OBJECT_SET_TYPE(typed_ptr, type) vulkan_object_set_type(VULKAN_OBJECT(typed_ptr), type)
+#	define VULKAN_OBJECT_GET_TYPE(typed_ptr) vulkan_object_get_type(VULKAN_OBJECT_CONST(typed_ptr))
+	static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE vulkan_object_type_t vulkan_object_get_type(const vulkan_object_t* obj) { return obj->type; }
+	static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE void vulkan_object_set_type(vulkan_object_t* obj, vulkan_object_type_t type) { obj->type = type; }
+#endif /* GLOBAL_DEBUG */
+
+#ifdef GLOBAL_DEBUG
+#	define VULKAN_OBJECT_TYPE_CAST(dst_ptr_type, vulkan_object_type, src_typed_ptr) REINTERPRET_CAST(dst_ptr_type, VULKAN_OBJECT_TYPE_CHECK_FORWARD(src_typed_ptr, vulkan_object_type))
+#	define VULKAN_OBJECT_TYPE_CONST_CAST(dst_ptr_type, vulkan_object_type, src_typed_ptr) REINTERPRET_CONST_CAST(dst_ptr_type, VULKAN_OBJECT_TYPE_CHECK_CONST_FORWARD(src_typed_ptr, vulkan_object_type))
+#	define VULKAN_OBJECT_TYPE_CHECK(type_ptr, vulkan_object_type) vulkan_object_type_check(type_ptr, vulkan_object_type)
+	static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE void vulkan_object_type_check(const vulkan_object_t* obj, vulkan_object_type_t type)
+	{
+		debug_assert__(obj->type == type, "Vulkan Object type mismatched");
+	}
+#	define VULKAN_OBJECT_TYPE_CHECK_FORWARD(typed_ptr, vulkan_object_type) vulkan_object_type_check_forward(VULKAN_OBJECT_CONST(typed_ptr), vulkan_object_type)
+	static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE void* vulkan_object_type_check_forward(const vulkan_object_t* obj, vulkan_object_type_t type)
+	{
+		vulkan_object_type_check(obj, type);
+		return CAST_TO(void*, obj);
+	}
+#	define VULKAN_OBJECT_TYPE_CHECK_CONST_FORWARD(typed_ptr, vulkan_object_type) vulkan_object_type_check_const_forward(VULKAN_OBJECT_CONST(typed_ptr), vulkan_object_type)
+	static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE const void* vulkan_object_type_check_const_forward(const vulkan_object_t* obj, vulkan_object_type_t type)
+	{
+		vulkan_object_type_check(obj, type);
+		return CAST_TO(const void*, obj);
+	}
+#else /* GLOBAL_DEBUG */
+#	define VULKAN_OBJECT_TYPE_CAST(dst_ptr_type, vulkan_object_type, src_typed_ptr) REINTERPRET_CAST(dst_ptr_type, src_typed_ptr)
+#	define VULKAN_OBJECT_TYPE_CONST_CAST(dst_ptr_type, vulkan_object_type, src_typed_ptr) REINTERPRET_CONST_CAST(dst_ptr_type, src_typed_ptr)
+#endif /* GLOBAL_RELEASE */
+
+/* no verification of vulkan objects can be done in release mode */
+#ifdef GLOBAL_DEBUG
+#	define VULKAN_OBJECT_VERIFY(typed_ptr) vulkan_object_verify(VULKAN_OBJECT_CONST(typed_ptr))
+	static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE void vulkan_object_verify(const vulkan_object_t* obj)
+	{
+		debug_assert__(!VULKAN_OBJECT_IS_TYPE_GARBAGE(obj), "Vulkan Object Type is Garbage");
+		debug_assert__(!VULKAN_OBJECT_IS_NATIONALITY_GARBAGE(obj), "Vulkan Object Nationality is Garbage");
+	}
+#	define VULKAN_OBJECT_VERIFY_FORWARD(typed_ptr) vulkan_object_verify_forward(VULKAN_OBJECT_CONST(typed_ptr))
+	static CAN_BE_UNUSED_FUNCTION INLINE_IF_RELEASE_MODE const void* vulkan_object_verify_forward(const vulkan_object_t* obj)
+	{
+		vulkan_object_verify(obj);
+		return CAST_TO(const void*, obj);
+	}
+#else
+#	define VULKAN_OBJECT_VERIFY(typed_ptr)
+#	define VULKAN_OBJECT_VERIFY_FORWARD(typed_ptr) typed_ptr
+#endif

include/renderer/internal/vulkan/vulkan_renderer.h

@@ -36,11 +36,14 @@
 #include <renderer/internal/vulkan/vulkan_descriptor_set.h>
 #include <renderer/internal/vulkan/vulkan_descriptor_set_layout.h>
 
+#include <renderer/struct_descriptor.h>
+
 typedef struct render_window_t render_window_t;
 typedef struct vulkan_shader_library_t vulkan_shader_library_t;
 typedef struct vulkan_material_library_t vulkan_material_library_t;
 typedef struct vulkan_render_pass_pool_t vulkan_render_pass_pool_t;
 typedef struct vulkan_camera_system_t vulkan_camera_system_t;
+typedef struct vulkan_buffer_t vulkan_buffer_t;
 
 typedef enum vulkan_renderer_gpu_type_t
 {
@@ -76,6 +79,24 @@ typedef struct vulkan_renderer_t
 	VkSemaphore vo_render_finished_semaphore;
 	VkFence vo_fence;
 
+	/* global_set::screen_info
+	 * {
+	 * 		uvec2 resolution;  	// resolution of the display (in pixels)
+	 * 		uvec2 dpi; 			// dpi of the display (in pixels per inch)
+	 * 		uvec2 size; 		// window size (in pixels)
+	 * 		mat4 matrix; 		// matrix to project onto the window/screen
+	 * } */
+	struct
+	{
+		struct_descriptor_t 	struct_def;
+		struct_field_handle_t 	resolution_field;
+		struct_field_handle_t 	dpi_field;
+		struct_field_handle_t	size_field;
+		struct_field_handle_t 	matrix_field;
+		vulkan_buffer_t* buffer;
+		event_subscription_handle_t update_handle;
+	} screen_info;
+
 	render_window_t* window;
 	vulkan_swapchain_create_info_t swapchain_create_info;		// for recreating the swapchain
 	vulkan_swapchain_t* swapchain;

include/renderer/internal/vulkan/vulkan_shader_module.h

@@ -29,6 +29,7 @@
 #include <vulkan/vulkan.h>
 #include <renderer/defines.h>
 #include <renderer/internal/vulkan/vulkan_types.h>
+#include <renderer/internal/vulkan/vulkan_object.h>
 
 typedef struct vulkan_shader_module_create_info_t
 {
@@ -53,11 +54,15 @@ typedef struct vulkan_shader_module_load_info_t
 /* vulkan_stage_shader_t renamed to vulkan_shader_module_t */
 typedef struct vulkan_shader_module_t
 {
+	__VULKAN_OBJECT__;
 	vulkan_renderer_t* renderer;
 	VkShaderModule vo_module;
 	VkPipelineShaderStageCreateInfo vo_stage;
 } vulkan_shader_module_t;
 
+#define VULKAN_SHADER_MODULE(typed_ptr) VULKAN_OBJECT_TYPE_CAST(vulkan_shader_module_t*, VULKAN_OBJECT_TYPE_SHADER_MODULE, typed_ptr)
+#define VULKAN_SHADER_MODULE_CONST(typed_ptr) VULKAN_OBJECT_TYPE_CONST_CAST(const vulkan_shader_module_t*, VULKAN_OBJECT_TYPE_SHADER_MODULE, typed_ptr)
+
 BEGIN_CPP_COMPATIBLE
 
 /* constructors & destructors */

include/renderer/render_window.h

@@ -27,10 +27,8 @@
 #pragma once
 
 #include <renderer/defines.h>
-#include <bufferlib/buffer.h>
 #include <renderer/event.h>
 #include <renderer/type_system.h>
-#include <renderer/struct_descriptor.h>
 
 static const type_t TYPE_ID(render_window_t) = TYPE_ID_CREATE(1);
 
@@ -41,24 +39,6 @@ typedef struct render_window_t
 	/* handle to the internal GLFWwindow object */
 	void* handle;
 
-	/* pointer to API specific GPU buffer object */
-	void* api_buffer;
-	/* pointer to the memory mapped GPU buffer data of the above object */
-	void* api_buffer_data_ptr;
-
-	/* global_set::screen_info
-	 * {
-	 * 		uvec2 resolution;  	// resolution of the display (in pixels)
-	 * 		uvec2 dpi; 			// dpi of the display (in pixels per inch)
-	 * 		uvec2 size; 		// window size (in pixels)
-	 * 		mat4 matrix; 		// matrix to project onto the window/screen
-	 * } */
-	struct_descriptor_t 	screen_info_struct;
-	struct_field_handle_t 		resolution_field;
-	struct_field_handle_t 		dpi_field;
-	struct_field_handle_t		size_field;
-	struct_field_handle_t 		matrix_field;
-
 	/* width of the window (in pixels) */
 	u32 width;
 	/* height of the window (in pixels) */
@@ -75,8 +55,6 @@ RENDERER_API bool render_window_should_close(render_window_t* window);
 RENDERER_API void render_window_poll_events(render_window_t* window);
 RENDERER_API void render_window_destroy(render_window_t* window);
 
-RENDERER_API void render_window_initialize_api_buffer(render_window_t* window, void* driver);
-
 // getters
 RENDERER_API void render_window_get_framebuffer_extent(render_window_t* window, u32* out_width, u32* out_height);
 

include/renderer/struct_descriptor.h

@@ -338,6 +338,7 @@ RENDERER_API void struct_descriptor_add_field(struct_descriptor_t* descriptor, c
 RENDERER_API void struct_descriptor_add_field2(struct_descriptor_t* descriptor, const char* name, struct_descriptor_t* record);
 RENDERER_API void struct_descriptor_add_field_array(struct_descriptor_t* descriptor, const char* name, u8 type, u32 array_size);
 RENDERER_API void struct_descriptor_add_field_array2(struct_descriptor_t* descriptor, const char* name, struct_descriptor_t* record, u32 array_size);
+RENDERER_API void struct_descriptor_free(memory_allocator_t* allocator, struct_descriptor_t* descriptor);
 
 RENDERER_API void struct_descriptor_map(struct_descriptor_t* descriptor, void* ptr);
 RENDERER_API void* struct_descriptor_get_mapped(struct_descriptor_t* descriptor);