diff options
Diffstat (limited to 'include/lrhi.h')
| -rw-r--r-- | include/lrhi.h | 850 |
1 files changed, 850 insertions, 0 deletions
diff --git a/include/lrhi.h b/include/lrhi.h new file mode 100644 index 0000000..0a6b6f7 --- /dev/null +++ b/include/lrhi.h @@ -0,0 +1,850 @@ +#ifndef LRHI_H +#define LRHI_H + +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> + +#define LRHI_LOG(...) \ + do { \ + fprintf(stderr, "[LRHI %s:%d] ", __FILE__, __LINE__); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, "\n"); \ + } while (0) + +#define LRHI_LOG_ERR(...) LRHI_LOG("ERR: " __VA_ARGS__) + +#define ARRAY_LENGTH(arr) (sizeof(arr) / sizeof((arr)[0])) + +#define LRHI_PANIC(...) \ + do { \ + LRHI_LOG("Panic: " __VA_ARGS__); \ + exit(1); \ + } while (0) + +#define LRHI_KB 1024 +#define LRHI_MB (1024 * LRHI_KB) +#define LRHI_GB (1024 * LRHI_MB) + +struct lrhi_allocator { + void *(*allocate)(ptrdiff_t size, void *ctx); + void (*free)(void *ptr, ptrdiff_t size, void *ctx); + void *ctx; +}; +void *lrhi_allocator_allocate(struct lrhi_allocator *allocator, ptrdiff_t size); +void lrhi_allocator_free(struct lrhi_allocator *allocator, ptrdiff_t size, + void *ptr); + +typedef struct lrhi_arena lrhi_arena; +lrhi_arena *lrhi_arena_create(struct lrhi_allocator *allocator, + ptrdiff_t arena_size); +void lrhi_arena_destroy(struct lrhi_allocator *allocator, lrhi_arena *arena); +void *lrhi_arena_allocate(lrhi_arena *arena, ptrdiff_t size); +void lrhi_arena_reset(lrhi_arena *arena); +struct lrhi_allocator lrhi_arena_allocator(lrhi_arena *arena); + +struct lrhi_instance_desc { + bool enable_validation_layers; +}; +struct lrhi_instance; +typedef struct lrhi_instance lrhi_instance; +struct lrhi_surface_configuration { + uint32_t width; + uint32_t height; +}; +struct lrhi_surface; +typedef struct lrhi_surface lrhi_surface; +struct lrhi_device; +typedef struct lrhi_device lrhi_device; +struct lrhi_shader_module_desc { + const char *label; + const unsigned char *spirv_source; + size_t spirv_source_size; +}; +struct lrhi_shader_module; +typedef struct lrhi_shader_module lrhi_shader_module; + +struct lrhi_pipeline_layout; +typedef struct lrhi_pipeline_layout lrhi_pipeline_layout; + +struct lrhi_render_pass; +typedef struct lrhi_render_pass lrhi_render_pass; +struct lrhi_descriptor_set_layout; +typedef struct lrhi_descriptor_set_layout lrhi_descriptor_set_layout; + +enum lrhi_descriptor_type { + lrhi_DESCRIPTOR_TYPE_UNIFORM_BUFFER, + lrhi_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, +}; + +typedef uint32_t lrhi_shader_stages; +#define lrhi_SHADER_STAGE_VERTEX (1 << 0) +#define lrhi_SHADER_STAGE_FRAGMENT (1 << 0) + +struct lrhi_descriptor_set_layout_binding { + uint32_t binding; + enum lrhi_descriptor_type descriptor_type; + uint32_t descriptor_count; + lrhi_shader_stages visibility; +}; + +struct lrhi_descriptor_set_layout_desc { + uint32_t binding_count; + const struct lrhi_descriptor_set_layout_binding *bindings; +}; + +struct lrhi_pipeline_layout_desc { + uint32_t set_layout_count; + lrhi_descriptor_set_layout *set_layouts; +}; + +enum lrhi_vertex_input_rate { + lrhi_VERTEX_INPUT_RATE_VERTEX, + lrhi_VERTEX_INPUT_RATE_INSTANCE, +}; + +struct lrhi_vertex_input_binding_desc { + uint32_t binding; + uint32_t stride; + enum lrhi_vertex_input_rate input_rate; +}; + +enum lrhi_format { + lrhi_FORMAT_B8G8R8A8_SRGB, + lrhi_FORMAT_R8G8B8A8_SRGB, + lrhi_FORMAT_R32G32_SFLOAT, + lrhi_FORMAT_R32G32B32_SFLOAT, + lrhi_FORMAT_D32_SFLOAT +}; +struct lrhi_vertex_input_attribute_desc { + uint32_t binding; + uint32_t location; + enum lrhi_format format; + uint32_t offset; +}; + +struct lrhi_vertex_input { + const struct lrhi_vertex_input_binding_desc *bindings; + const struct lrhi_vertex_input_attribute_desc *attributes; + int binding_count; + int attribute_count; +}; + +enum lrhi_compare_function { + lrhi_COMPARE_FUNCTION_NEVER, + lrhi_COMPARE_FUNCTION_LESS, + lrhi_COMPARE_FUNCTION_EQUAL, + lrhi_COMPARE_FUNCTION_LESS_EQUAL, + lrhi_COMPARE_FUNCTION_GREATER, + lrhi_COMPARE_FUNCTION_NOT_EQUAL, + lrhi_COMPARE_FUNCTION_GREATER_EQUAL, + lrhi_COMPARE_FUNCTION_ALWAYS +}; + +struct lrhi_pipeline_depth_stencil_state_desc { + bool depth_write_enabled; + enum lrhi_compare_function compare_function; +}; + +struct lrhi_pipeline_desc { + const struct lrhi_vertex_input *vertex_input; + const struct lrhi_pipeline_depth_stencil_state_desc *depth_stencil; + const lrhi_shader_module *vertex_module; + const lrhi_shader_module *fragment_module; + const lrhi_pipeline_layout *layout; + const lrhi_render_pass *pass; +}; +struct lrhi_pipeline; +typedef struct lrhi_pipeline lrhi_pipeline; + +struct lrhi_command_buffer; +typedef struct lrhi_command_buffer lrhi_command_buffer; + +struct lrhi_clear_color { + float r; + float g; + float b; + float a; +}; + +struct lrhi_texture_view; +typedef struct lrhi_texture_view lrhi_texture_view; + +struct lrhi_render_pass_color_attachment { + lrhi_texture_view *view; +}; + +struct lrhi_render_pass_depth_stencil_attachment { + lrhi_texture_view *view; +}; + +struct lrhi_render_pass_begin_desc { + struct lrhi_clear_color clear_color; + lrhi_render_pass *pass; + + const struct lrhi_render_pass_color_attachment *color_attachments; + uint32_t color_attachment_count; + + const struct lrhi_render_pass_depth_stencil_attachment + *depth_stencil_attachment; + + lrhi_surface *surface; +}; + +struct lrhi_viewport { + float x; + float y; + float width; + float height; + float min_depth; + float max_depth; +}; + +struct lrhi_scissor { + float x_offset; + float y_offset; + float width; + float height; +}; + +struct lrhi_buffer; +typedef struct lrhi_buffer lrhi_buffer; +typedef uint32_t lrhi_buffer_usage; +#define lrhi_BUFFER_USAGE_VERTEX (1 << 0) +#define lrhi_BUFFER_USAGE_INDEX (1 << 1) +#define lrhi_BUFFER_USAGE_TRANSFER (1 << 2) +#define lrhi_BUFFER_USAGE_UNIFORM (1 << 3) + +struct lrhi_buffer_desc { + uint32_t size; + lrhi_buffer_usage usage; +}; + +struct lrhi_texture; +typedef struct lrhi_texture lrhi_texture; + +typedef uint32_t lrhi_texture_usage; +#define lrhi_TEXTURE_USAGE_COPY_SRC (1 << 0) +#define lrhi_TEXTURE_USAGE_COPY_DST (1 << 1) +#define lrhi_TEXTURE_USAGE_TEXTURE_BINDING (1 << 2) +#define lrhi_TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT (1 << 3) + +struct lrhi_texture_desc { + uint32_t width; + uint32_t height; + uint32_t mip_level_count; + uint32_t sample_count; + enum lrhi_format format; + lrhi_texture_usage usage; +}; + +struct lrhi_texel_copy_buffer_layout { + uint64_t offset; + uint32_t bytes_per_row; + uint32_t rows_per_image; +}; + +struct lrhi_texel_copy_buffer_desc { + lrhi_buffer *buffer; + const struct lrhi_texel_copy_buffer_layout *layout; +}; + +struct lrhi_texel_copy_texture_desc { + lrhi_texture *texture; + uint32_t mip_level; +}; + +typedef uint32_t lrhi_image_aspect; +#define lrhi_IMAGE_ASPECT_COLOR (1 << 0) +#define lrhi_IMAGE_ASPECT_DEPTH (1 << 1) + +struct lrhi_texture_view_desc { + lrhi_texture *texture; + enum lrhi_format format; + lrhi_image_aspect aspect; +}; + +struct lrhi_sampler; +typedef struct lrhi_sampler lrhi_sampler; + +enum lrhi_filter { + lrhi_FILTER_NEAREST, + lrhi_FILTER_LINEAR, +}; + +enum lrhi_sampler_address_mode { + lrhi_SAMPLER_ADDRESS_MODE_REPEAT, + lrhi_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, + lrhi_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + lrhi_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, +}; + +struct lrhi_sampler_desc { + enum lrhi_filter mag_filter; + enum lrhi_filter min_filter; + enum lrhi_sampler_address_mode address_mode_u; + enum lrhi_sampler_address_mode address_mode_v; +}; + +struct lrhi_descriptor_buffer_info { + lrhi_buffer *buffer; + uint32_t offset; + uint64_t range; +}; + +struct lrhi_descriptor_texture_info { + lrhi_texture_view *view; + lrhi_sampler *sampler; +}; + +struct lrhi_descriptor_set_entry { + uint32_t binding; + uint32_t array_element; + enum lrhi_descriptor_type descriptor_type; + const struct lrhi_descriptor_buffer_info *buffer_info; + const struct lrhi_descriptor_texture_info *texture_info; +}; + +struct lrhi_descriptor_set_desc { + lrhi_descriptor_set_layout *layout; + const struct lrhi_descriptor_set_entry *entries; + uint32_t entry_count; +}; + +struct lrhi_descriptor_set; +typedef struct lrhi_descriptor_set lrhi_descriptor_set; + +struct lrhi_buffer_init_desc { + unsigned char *content; + uint32_t size; + lrhi_buffer_usage usage; +}; + +struct lrhi_buffer_copy_region { + uint64_t src_offset; + uint64_t dst_offset; + uint64_t size; +}; + +struct lrhi_buffer_copy { + lrhi_buffer *src; + lrhi_buffer *dst; + uint32_t region_count; + const struct lrhi_buffer_copy_region *regions; +}; + +enum lrhi_attachment_load_op { + lrhi_ATTACHMENT_LOAD_OP_LOAD, + lrhi_ATTACHMENT_LOAD_OP_CLEAR, + lrhi_ATTACHMENT_LOAD_OP_DONT_CARE +}; + +enum lrhi_attachment_store_op { + lrhi_ATTACHMENT_STORE_OP_STORE, + lrhi_ATTACHMENT_STORE_OP_DONT_CARE +}; + +struct lrhi_attachment_desc { + enum lrhi_format format; + uint32_t sample_count; + enum lrhi_attachment_load_op load_op; + enum lrhi_attachment_store_op store_op; +}; + +struct lrhi_render_pass_desc { + uint32_t color_attachment_count; + const struct lrhi_attachment_desc *color_attachments; + const struct lrhi_attachment_desc *depth_stencil_attachment; +}; + +typedef void (*lrhi_surface_reconfigured_callback)(int32_t width, + int32_t height, + void *user_data); +enum lrhi_window_backend { + LRHI_WINDOW_BACKEND_X11, +}; +struct lrhi_native_surface { + enum lrhi_window_backend backend; + void *window_hnd; + void *display_hnd; +}; +/** + * Creates a new instance. + * + * \param allocator The allocator to use for creating the instance. + * \param window_backend The window backend that will be used. + * \param desc The instance configuration. + * \returns The created instance on success, NULL on failure. + */ +lrhi_instance *lrhi_instance_create(struct lrhi_allocator *allocator, + enum lrhi_window_backend window_backend, + const struct lrhi_instance_desc *desc); +/** + * Destroys the instance. + * + * \param allocator The allocator used to allocate the instance. + * \param instance The instance to destroy. + */ +void lrhi_instance_destroy(struct lrhi_allocator *allocator, + lrhi_instance *instance); + +/** + * Creates a logical device connected to a physical device. + * + * \param instance The instance to use to fetch the physical device. + * \param surface The surface to use. + * \returns The created device on success, NULL on failure. + */ +lrhi_device *lrhi_instance_create_device(lrhi_instance *instance, + lrhi_surface *surface); + +/** + * Destroys a logical device. + * + * \param instance The instance used to create the device. + * \param device The device to destroy. + */ +void lrhi_instance_destroy_device(lrhi_instance *instance, lrhi_device *device); + +/** + * Creates a buffer. + * + * \param device The logical device used to create the buffer. + * \param desc The buffer description. + * \returns The created buffer on success, NULL on failure. + */ +lrhi_buffer *lrhi_device_create_buffer(lrhi_device *device, + const struct lrhi_buffer_desc *desc); +/** + * Creates a buffer with initial data. + * + * \param device The logical device used to create the buffer. + * \param desc The buffer description. + * \returns The created buffer on success, NULL on failure. + */ +lrhi_buffer * +lrhi_device_create_buffer_init(lrhi_device *device, + const struct lrhi_buffer_init_desc *desc); +/** + * Destroys a buffer. + * + * \param device The logical device used to create the buffer. + * \param buffer The buffer to destroy. + */ +void lrhi_device_destroy_buffer(lrhi_device *device, lrhi_buffer *buffer); +/** + * Maps a buffer. + * + * \param device The logical device to use. + * \param buffer The buffer to map. + * \returns The mapped buffer on success, NULL on failure. + */ +void *lrhi_device_map_buffer(lrhi_device *device, lrhi_buffer *buffer); +/** + * Unmaps a buffer. + * + * \param device The logical device to use. + * \param buffer The buffer to unmap. + */ +void lrhi_device_unmap_buffer(lrhi_device *device, lrhi_buffer *buffer); +/** + * Returns the allocated size of a buffer. + * + * \returns The allocated size of the buffer in bytes. + */ +uint32_t lrhi_buffer_size(lrhi_buffer *buffer); + +/** + * Creates a texture. + * + * \param device The logical device used to create the texture. + * \param desc The texture description. + * \returns The created texture on success, NULL on failure. + */ +lrhi_texture *lrhi_device_create_texture(lrhi_device *device, + const struct lrhi_texture_desc *desc); +/** + * Destroys a texture. + * + * \param device The logical device used to create the texture. + * \param texture The texture to destroy. + */ +void lrhi_device_destroy_texture(lrhi_device *device, lrhi_texture *texture); +/** + * Writes data into a texture. + * + * \param device The logical device to use. + * \param texture The target texture. + * \param data The data to write. + * \param data_size The size of the data to write in bytes. + * \param layout Layout of the texutre in a buffer's memory. + * \param width The width of the texture. + * \param heightThe height of the texture. + */ +void lrhi_device_write_texture( + lrhi_device *device, const struct lrhi_texel_copy_texture_desc *texture, + unsigned char *data, size_t data_size, + const struct lrhi_texel_copy_buffer_layout *layout, uint32_t width, + uint32_t height); + +/** + * Creates a texture view. + * + * \param device The logical device used to create the texture view. + * \param desc The texture view description. + * \returns The created texture view on success, NULL on failure. + */ +lrhi_texture_view * +lrhi_device_create_texture_view(lrhi_device *device, + const struct lrhi_texture_view_desc *desc); +/** + * Destroys a texture view. + * + * \param device The logical device used to create the texture view. + * \param texture_view The texture view to destroy. + */ +void lrhi_device_destroy_texture_view(lrhi_device *device, + lrhi_texture_view *texture_view); + +/** + * Creates a sampler. + * + * \param device The logical device used to create the sampler. + * \param desc The sampler description. + * \returns The created sampler on success, NULL on failure. + */ +lrhi_sampler *lrhi_device_create_sampler(lrhi_device *device, + const struct lrhi_sampler_desc *desc); +/** + * Destroys a sampler. + * + * \param device The logical device used to create the sampler. + * \param sampler The sampler to destroy. + */ +void lrhi_device_destroy_sampler(lrhi_device *device, lrhi_sampler *sampler); + +/** + * Creates a shader module. + * + * \param device The logical device used to create the shader module. + * \param desc The shader module description. + * \returns The created shader module on success, NULL on failure. + */ +lrhi_shader_module * +lrhi_device_create_shader_module(lrhi_device *device, + const struct lrhi_shader_module_desc *desc); +/** + * Destroys a shader module. + * + * \param device The logical device used to create the shader module. + * \param module The shader module to destroy. + */ +void lrhi_device_destroy_shader_module(lrhi_device *device, + lrhi_shader_module *module); +/** + * Wait for the device to become idle + * + * \param device The logical device to idle. + */ +void lrhi_device_wait_idle(lrhi_device *device); + +/** + * Creates a descriptor set layout. + * + * \param device The logical device used to create the descriptor set layout. + * \param desc The descriptor set layout description. + * \returns The created descriptor set layout on success, NULL on failure. + */ +lrhi_descriptor_set_layout *lrhi_device_create_descriptor_set_layout( + lrhi_device *device, const struct lrhi_descriptor_set_layout_desc *desc); +/** + * Destroys a descriptor set layout. + * + * \param device The logical device used to create the descriptor set layout. + * \param layout The descriptor set layout to destroy. + */ +void lrhi_device_destroy_descriptor_set_layout( + lrhi_device *device, lrhi_descriptor_set_layout *layout); + +/** + * Creates a descriptor set. + * + * \param device The logical device used to create the descriptor set. + * \param desc The descriptor set description. + * \returns The created descriptor set on success, NULL on failure. + */ +lrhi_descriptor_set * +lrhi_device_create_descriptor_set(lrhi_device *device, + const struct lrhi_descriptor_set_desc *desc); +/** + * Creates a pipeline layout. + * + * \param device The logical device used to create the pipeline layout. + * \param desc The pipeline layout description. + * \returns The created pipeline layout on success, NULL on failure. + */ +lrhi_pipeline_layout *lrhi_device_create_pipeline_layout( + lrhi_device *device, const struct lrhi_pipeline_layout_desc *desc); +/** + * Destroys a pipeline layout. + * + * \param device The logical device used to create the pipeline layout. + * \param layout The pipeline layout to destroy. + */ +void lrhi_device_destroy_pipeline_layout(lrhi_device *device, + lrhi_pipeline_layout *layout); +/** + * Creates a render pass. + * + * \param device The logical device used to create the render pass. + * \param desc The render pass description. + * \returns The created render pass on success, NULL on failure. + */ +lrhi_render_pass * +lrhi_device_create_render_pass(lrhi_device *device, + const struct lrhi_render_pass_desc *desc); +/** + * Destroys a render pass. + * + * \param device The logical device used to create the render pass. + * \param pass The render pass to destroy. + */ +void lrhi_device_destroy_render_pass(lrhi_device *device, + lrhi_render_pass *pass); + +/** + * Creates a pipeline. + * + * \param device The logical device used to create the pipeline. + * \param desc The pipeline description. + * \returns The created pipeline on success, NULL on failure. + */ +lrhi_pipeline * +lrhi_device_create_pipeline(lrhi_device *device, + const struct lrhi_pipeline_desc *desc); +/** + * Destroys a pipeline. + * + * \param device The logical device used to create the pipeline. + * \param pipeline The pipeline to destroy. + */ +void lrhi_device_destroy_pipeline(lrhi_device *device, lrhi_pipeline *pipeline); + +/** + * Begins recording a command buffer. + * + * \param device The logical device to use. + * \returns The recording command buffer. + */ +lrhi_command_buffer *lrhi_command_buffer_begin(lrhi_device *device); +/** + * Begins recording a render pass. + * + * \param buffer The command buffer to use. + * \param desc The render pass begin description. + */ +void lrhi_command_begin_render_pass( + lrhi_command_buffer *buffer, + const struct lrhi_render_pass_begin_desc *desc); +/** + * Ends recording a render pass. + * + * \param buffer The command buffer to use. + */ +void lrhi_command_end_render_pass(lrhi_command_buffer *buffer); +/** + * Copies a buffer's data to another buffer. + * + * \param buffer The command buffer to use. + * \param copy The buffer copy description. + */ +void lrhi_command_copy_buffer_to_buffer(lrhi_command_buffer *buffer, + const struct lrhi_buffer_copy *copy); +/** + * Copies a buffer's data to a texture. + * + * \param cmdbuf The command buffer to use. + * \param buffer The source buffer texel copy description. + * \param texture The target texture description. + * \param The width of the texture. + * \param The height of the texture + */ +void lrhi_command_copy_buffer_to_texture( + lrhi_command_buffer *cmdbuf, + const struct lrhi_texel_copy_buffer_desc *buffer, + const struct lrhi_texel_copy_texture_desc *texture, uint32_t width, + uint32_t height); +/** + * Binds a pipeline. + * + * \param buffer The command buffer to use. + * \param pipeline The pipeline to bind. + */ +void lrhi_command_bind_pipeline(lrhi_command_buffer *buffer, + lrhi_pipeline *pipeline); +/** + * Binds vertex buffers. + * + * \param buffer The command buffer to use. + * \param first_binding The index of the first vertex input binding. + * \param binding_count The number of vertex input bindings. + * \param buffers The buffers to bind. + * \params offsets The buffer offsets. + */ +void lrhi_command_bind_vertex_buffers(lrhi_command_buffer *buffer, + uint32_t first_binding, + uint32_t binding_count, + lrhi_buffer **buffers, uint64_t *offsets); +/** + * Binds an index buffer. + * + * \param cmdbuf The command buffer to use. + * \param index_buffer The index buffer to bind. + * \param offset The index buffer offset. + */ +void lrhi_command_bind_index_buffer(lrhi_command_buffer *cmdbuf, + lrhi_buffer *index_buffer, uint64_t offset); +/** + * Binds descriptor sets. + * + * \param cmdbuf The command buffer to use. + * \param pipeline_layout The pipeline layout to use. + * \param first_set The index of the first set to be bound. + * \param descriptor_set_count The number of descriptor sets to bind. + * \param sets The descriptor sets to bind. + * \param dynamic_offset_count The number of dynamic offsets. + * \param dynamic_offsets The dynamic offsets. + */ +void lrhi_command_bind_descriptor_set(lrhi_command_buffer *cmdbuf, + lrhi_pipeline_layout *pipeline_layout, + uint32_t first_set, + uint32_t descriptor_set_count, + const lrhi_descriptor_set *sets, + uint32_t dynamic_offset_count, + const uint32_t *dynamic_offsets); +/** + * Sets the viewport. + * + * \param buffer The command buffer to use. + * \param viewport The viewport to use. + */ +void lrhi_command_set_viewport(lrhi_command_buffer *buffer, + const struct lrhi_viewport *viewport); +/** + * Sets the scissor. + * + * \param buffer The command buffer to use. + * \param scissor The scissor to use. + */ +void lrhi_command_set_scissor(lrhi_command_buffer *buffer, + const struct lrhi_scissor *scissor); +/** + * Draws primitives. + * + * \param buffer The command buffer to use. + * \param vertex_count The number of vertices to draw. + * \param instance_count The number of instances to draw. + * \param first_vertex Index of the first vertex to draw. + * \param first_instance Index of the first instance to draw. + */ +void lrhi_command_draw(lrhi_command_buffer *buffer, uint32_t vertex_count, + uint32_t instance_count, uint32_t first_vertex, + uint32_t first_instance); +/** + * Draws indexed primitives. + * + * \param buffer The command buffer to use. + * \param index_count The number of indices to draw. + * \param instance_count The number of instances to draw. + * \param first_index Index of the first index to draw. + * \param first_vertex Index of the first vertex to draw. + * \param first_instance Index of the first instance to draw. + */ +void lrhi_command_draw_indexed(lrhi_command_buffer *cmdbuf, + uint32_t index_count, uint32_t instance_count, + uint32_t first_index, uint32_t first_vertex, + uint32_t first_instance); + +/** + * Ends recording a command buffer. + * + * \param buffer The command buffer. + * \returns true on success, false on failure. + */ +bool lrhi_command_buffer_end(lrhi_command_buffer *buffer); +/** + * Submits a command buffer. + * + * \param device The logical device to use. + * \param buffer The command buffer to submit. + * \param surface The surface to use. + * \returns true on success, false on failure. + */ +bool lrhi_device_submit_command_buffer(lrhi_device *device, + lrhi_command_buffer *buffer, + lrhi_surface *surface); + +/** + * Creates a surface. + * + * \param instance The instance used to create the surface. + * \param platform The platform used to create the surface. + * \param surface_reconfigured_callback The callback to use when the surface is + * reconfigured. + * \param surface_reconfigured_user_data The user data passed to the + * surface_reconfigured_callback. + * \returns the surface created on success, NULL on failure. + */ +lrhi_surface *lrhi_instance_create_surface( + lrhi_instance *instance, struct lrhi_native_surface *surface, + lrhi_surface_reconfigured_callback surface_reconfigured_callback, + void *surface_reconfigured_user_data); +/** + * Destroys a surface. + * + * \param instance The instance used to create the surface. + * \param device The device used with this surface. + * \param surface The surface to destroy. + */ +void lrhi_instance_destroy_surface(lrhi_instance *instance, lrhi_device *device, + lrhi_surface *surface); +/** + * Resizes a surface. + * + * \param surface The surface to resize. + * \param width The requested width for the surface. + * \param height The requested height for the surface. + */ +void lrhi_surface_resize(lrhi_surface *surface, int32_t width, int32_t height); +/** + * Configures a surface. + * + * \param surface The surface to configure. + * \param device The device to use. + * \param configuration The surface configuration. + * \return true on success, false on failure. + */ +bool lrhi_surface_configure( + lrhi_surface *surface, lrhi_device *device, + const struct lrhi_surface_configuration *configuration); +/** + * Returns the next swapchain image of a surface. + * + * \param surface The surface to fetch the next swapchain image from. + * \param device The device used with the surface. + * \return The next swapchain image's texture view. + */ +lrhi_texture_view *lrhi_surface_acquire_next_image(lrhi_surface *surface, + lrhi_device *device); +/** + * Presents the surface. + * + * \param device The device used with the surface. + * \param surface The surface to present. + * \return true on success, false on failure. + */ +bool lrhi_surface_present(lrhi_device *device, lrhi_surface *surface); + +#endif // LRHI_H |