package acorn:resource

Source

AccelerationStructure :: struct {
	buffer:                 StorageBufferInfo($T=u8),
	acceleration_structure: vulkan.AccelerationStructureKHR,
}

AccelerationStructureInstance :: struct {
	acceleration_structure: AccelerationStructure,
	transform:              matrix[4, 4]f32,
}

Block :: struct {
	start_index: u32,
	length:      u32,
}

GenericAccelerationStructure :: struct {
	acceleration_structure: vulkan.AccelerationStructureKHR,
}

GenericBufferImage :: struct {
	image:        vulkan.Image,
	image_memory: vulkan.DeviceMemory,
	image_view:   vulkan.ImageView,
	usage:        vulkan.ImageUsageFlags,
	layout:       vulkan.ImageLayout,
}

GenericResource :: union {
	GenericStorageBuffer, 
	GenericUniformBuffer, 
	GenericBufferImage, 
	GenericSampler, 
	GenericAccelerationStructure, 
}

GenericSampler :: struct {
	sampler: vulkan.Sampler,
}

GenericStorageBuffer :: struct {
	buffer:        vulkan.Buffer,
	buffer_memory: vulkan.DeviceMemory,
	buffer_size:   vulkan.DeviceSize,
}

GenericUniformBuffer :: struct {
	buffer:        vulkan.Buffer,
	buffer_memory: vulkan.DeviceMemory,
	buffer_size:   vulkan.DeviceSize,
}

HostCoherhentBufferInfo :: struct($T: typeid) {
	… // See source for fields
}

ImageInfo :: struct {
	image:        vulkan.Image,
	image_memory: vulkan.DeviceMemory,
	image_view:   vulkan.ImageView,
	format:       vulkan.Format,
	aspect:       vulkan.ImageAspectFlags,
	layout:       vulkan.ImageLayout,
	usage:        vulkan.ImageUsageFlags,
	width:        vulkan.DeviceSize,
	height:       vulkan.DeviceSize,
}

MultiBlockBufferInfo :: struct($T: typeid) {
	… // See source for fields
}

SamplerInfo :: struct {
	sampler: vulkan.Sampler,
}

SerialBufferInfo :: struct($T: typeid) {
	… // See source for fields
}

StorageBufferInfo :: struct($T: typeid) {
	… // See source for fields
}

UniformBufferInfo :: struct($T: typeid) {
	… // See source for fields
}

append_to_serial_buffer :: proc(device_context: ^device.DeviceContext, serial_buffer: ^SerialBufferInfo($T), item: $T) {…}

copy_block_out_to_new_buffer_host_cohearnnt :: proc(device_context: ^device.DeviceContext, multi_block_buffer: ^MultiBlockBufferInfo($T), block: Block) -> HostCoherhentBufferInfo($T) {…}

copy_buffer :: proc(
	device_context: ^device.DeviceContext, 
	src_buffer:     vulkan.Buffer, 
	dst_buffer:     vulkan.Buffer, 
	src_offset:     vulkan.DeviceSize, 
	dst_offset:     vulkan.DeviceSize, 
	size:           vulkan.DeviceSize, 
) {…}

copy_buffer_to_image :: proc(device_context: ^device.DeviceContext, buffer: vulkan.Buffer, image: vulkan.Image, width: u32, height: u32) {…}

copy_host_cohearent_buffer_to_image :: proc(device_context: ^device.DeviceContext, host_cohearent_buffer: HostCoherhentBufferInfo($T), image: ImageInfo) {…}

copy_host_cohernet_buffer_to_mult_block_buffer :: proc(device_context: ^device.DeviceContext, host_coherent_buffer: HostCoherhentBufferInfo($T), multi_block_buffer: ^MultiBlockBufferInfo($T)) -> Block {…}

copy_host_cohernet_buffer_to_mult_block_buffer_block :: proc(device_context: ^device.DeviceContext, host_coherent_buffer: HostCoherhentBufferInfo($T), multi_block_buffer: ^MultiBlockBufferInfo($T), block: Block) {…}

copy_host_cohernet_buffer_to_storage_buffer :: proc(device_context: ^device.DeviceContext, host_coherent_buffer: HostCoherhentBufferInfo($T), storeage_buffer: StorageBufferInfo($T), src_elem_offset: vulkan.DeviceSize = 0, dst_elem_offset: vulkan.DeviceSize = 0) {…}

copy_image_to_buffer :: proc(
	device_context: ^device.DeviceContext, 
	image:          vulkan.Image, 
	image_layout:   vulkan.ImageLayout, 
	buffer:         vulkan.Buffer, 
	width:          u32, 
	height:         u32, 
) {…}

copy_image_to_new_host_coherent_buffer :: proc(device_context: ^device.DeviceContext, $T: typeid, image: ImageInfo) -> HostCoherhentBufferInfo($T=typeid) {…}

copy_storage_buffer_to_host_coherent_buffer :: proc(
	device_context:        ^device.DeviceContext, 
	storeage_buffer:       StorageBufferInfo($T), 
	host_cohearent_buffer: HostCoherhentBufferInfo($T), 
	src_elem_offset:       vulkan.DeviceSize = 0, 
	dst_elem_offset:       vulkan.DeviceSize = 0, 
	n_elems:               vulkan.DeviceSize = 1, 
) {…}

copy_storage_buffer_to_new_host_coherent_buffer :: proc(device_context: ^device.DeviceContext, storeage_buffer: StorageBufferInfo($T)) -> HostCoherhentBufferInfo($T) {…}

copy_storeage_buffer_to_storeage_buffer :: proc(device_context: ^device.DeviceContext, storeage_buffer1: StorageBufferInfo($T), storeage_buffer2: StorageBufferInfo($T)) {…}

create_bottom_level_acceleration_structure :: proc(device_context: ^device.DeviceContext, vertex_buffer: StorageBufferInfo($T=[4]f32), index_buffer: StorageBufferInfo($T=u32)) -> AccelerationStructure {…}

create_buffer :: proc(
	device_context: ^device.DeviceContext, 
	size:           vulkan.DeviceSize, 
	useage:         vulkan.BufferUsageFlags, 
	properties:     vulkan.MemoryPropertyFlags, 
	buffer:         ^vulkan.Buffer, 
	buffer_memory:  ^vulkan.DeviceMemory, 
) {…}

create_image :: proc(
	device_context: ^device.DeviceContext, 
	width:          u32, 
	height:         u32, 
	format:         vulkan.Format, 
	tiling:         vulkan.ImageTiling, 
	usage:          vulkan.ImageUsageFlags, 
	properties:     vulkan.MemoryPropertyFlags, 
	initial_layout: vulkan.ImageLayout, 
	image:          ^vulkan.Image, 
	image_memory:   ^vulkan.DeviceMemory, 
) {…}

create_top_level_acceleration_structure :: proc(device_context: ^device.DeviceContext, bottom_level_acceleration_structures: []AccelerationStructureInstance) -> AccelerationStructure {…}

delete_acceleration_structure :: proc(device_context: ^device.DeviceContext, acceleration_structure: AccelerationStructure) {…}

delete_host_cohearnent_buffer :: proc(device_context: ^device.DeviceContext, uniform_buffer: HostCoherhentBufferInfo($T)) {…}

delete_multi_block_buffer :: proc(device_context: ^device.DeviceContext, multi_block_buffer: MultiBlockBufferInfo($T)) {…}

delete_sampler :: proc(device_context: ^device.DeviceContext, sampler: SamplerInfo) {…}

delete_serial_buffer :: proc(device_context: ^device.DeviceContext, serial_buffer: SerialBufferInfo($T)) {…}

delete_storage_buffer :: proc(device_context: ^device.DeviceContext, serial_buffer: StorageBufferInfo($T)) {…}

delete_storeage_image :: proc(device_context: ^device.DeviceContext, storage_image: ImageInfo) {…}

delete_uniform_buffer :: proc(device_context: ^device.DeviceContext, uniform_buffer: UniformBufferInfo($T)) {…}

elem_len :: proc(storage_buffer: StorageBufferInfo($T)) -> u32 {…}

find_memory_type :: proc(device_context: ^device.DeviceContext, type_filter: u32, properites: vulkan.MemoryPropertyFlags) -> u32 {…}

generic_buffer_vk_buffer :: proc(generic_buffer: GenericResource) -> vulkan.Buffer {…}

get_acceleration_structure_device_address :: proc(device_context: ^device.DeviceContext, acceleration_structure: vulkan.AccelerationStructureKHR) -> vulkan.DeviceAddress {…}

get_buffer_device_address :: proc(device_context: ^device.DeviceContext, buffer: vulkan.Buffer) -> vulkan.DeviceAddress {…}

make_host_coherent_buffer :: proc(device_context: ^device.DeviceContext, $T: typeid, n_elemements: u32) -> HostCoherhentBufferInfo($T=typeid) {…}

make_image :: proc(
	device_context: ^device.DeviceContext, 
	width:          vulkan.DeviceSize, 
	height:         vulkan.DeviceSize, 
	n_samples:      vulkan.SampleCountFlags, 
	usage:          vulkan.ImageUsageFlags, 
	format:         vulkan.Format, 
	tiling:         vulkan.ImageTiling, 
	aspect:         vulkan.ImageAspectFlags, 
) -> ImageInfo {…}

make_multi_block_buffer :: proc(device_context: ^device.DeviceContext, $T: typeid, n_elemements: u32, additional_useage_flags: vulkan.BufferUsageFlags) -> MultiBlockBufferInfo($T=typeid) {…}

make_sampler :: proc(device_context: ^device.DeviceContext) -> SamplerInfo {…}

make_serial_buffer :: proc(device_context: ^device.DeviceContext, $T: typeid, n_elemements_capacity: u32) -> SerialBufferInfo($T=typeid) {…}

make_storage_buffer :: proc(device_context: ^device.DeviceContext, $T: typeid, n_elemements: u32, additional_useage_flags: vulkan.BufferUsageFlags) -> StorageBufferInfo($T=typeid) {…}

make_uniform_buffer :: proc(device_context: ^device.DeviceContext, $T: typeid, n_elemements: u32) -> UniformBufferInfo($T=typeid) {…}

remove_from_multiblock_buffer :: proc(multi_block_buffer: ^MultiBlockBufferInfo($T), block: Block) {…}

remove_index_from_serial_buffer :: proc(device_context: ^device.DeviceContext, serial_buffer: ^SerialBufferInfo($T), index_to_remove: u32) {…}

to_generic_buffer_acceleration_structure :: proc(acceleration_structure: AccelerationStructure) -> GenericResource {…}

to_generic_buffer_multi_block_buffer :: proc(storage_buffer: MultiBlockBufferInfo($T)) -> GenericResource {…}

to_generic_buffer_sampler :: proc(sampler: SamplerInfo) -> GenericSampler {…}

to_generic_buffer_serial_buffer :: proc(serial_buffer: SerialBufferInfo($T)) -> GenericResource {…}

to_generic_buffer_storage_buffer :: proc(storage_buffer: StorageBufferInfo($T)) -> GenericResource {…}

to_generic_buffer_storage_image :: proc(storage_image: ImageInfo) -> GenericResource {…}

to_generic_buffer_uniform_buffer :: proc(uniform_buffer: UniformBufferInfo($T)) -> GenericResource {…}

transition_image_layout :: proc(device_context: ^device.DeviceContext, image: ^ImageInfo, new_layout: vulkan.ImageLayout) {…}

transition_image_layout_raw :: proc(
	device_context: ^device.DeviceContext, 
	image:          vulkan.Image, 
	format:         vulkan.Format, 
	aspect:         vulkan.ImageAspectFlags, 
	old_layout:     vulkan.ImageLayout, 
	new_layout:     vulkan.ImageLayout, 
) {…}

try_assign_block_in_multi_block_buffer :: proc(multi_block_buffer: ^MultiBlockBufferInfo($T), required_block_size: u32) -> (Block, bool) {…}

delete_resource :: proc{
	delete_host_cohearnent_buffer,
	delete_storage_buffer,
	delete_serial_buffer,
	delete_uniform_buffer,
	delete_multi_block_buffer,
	delete_acceleration_structure,
	delete_sampler,
	delete_storeage_image,
}

to_generic_buffer :: proc{
	to_generic_buffer_storage_buffer,
	to_generic_buffer_uniform_buffer,
	to_generic_buffer_storage_image,
	to_generic_buffer_multi_block_buffer,
	to_generic_buffer_serial_buffer,
	to_generic_buffer_sampler,
	to_generic_buffer_acceleration_structure,
}