more bindings

libs/sdl/sdl/Vulkan.hx

@@ -15,6 +15,18 @@ abstract VkRenderPass(hl.Abstract<"vk_render_pass">) {
 abstract VkDescriptorSetLayout(hl.Abstract<"vk_descriptor_set">) {
 }
 
+abstract VkFramebuffer(hl.Abstract<"vk_framebuffer">) {
+}
+
+abstract VkImageView(hl.Abstract<"vk_image_view">) {
+}
+
+abstract VkBuffer(hl.Abstract<"vk_buffer">) {
+}
+
+abstract VkDeviceMemory(hl.Abstract<"vk_device_memory">) {
+}
+
 enum abstract VkStructureType(Int) {
 	var APPLICATION_INFO = 0;
 	var INSTANCE_CREATE_INFO = 1;
@@ -762,21 +774,21 @@ enum abstract VkDynamicState(Int) {
 }
 
 enum abstract VkDescriptorType(Int) {
-    var SAMPLER = 0;
-    var COMBINED_IMAGE_SAMPLER = 1;
-    var SAMPLED_IMAGE = 2;
-    var STORAGE_IMAGE = 3;
-    var UNIFORM_TEXEL_BUFFER = 4;
-    var STORAGE_TEXEL_BUFFER = 5;
-    var UNIFORM_BUFFER = 6;
-    var STORAGE_BUFFER = 7;
-    var UNIFORM_BUFFER_DYNAMIC = 8;
-    var STORAGE_BUFFER_DYNAMIC = 9;
-    var INPUT_ATTACHMENT = 10;
-    var INLINE_UNIFORM_BLOCK_EXT = 1000138000;
-    var ACCELERATION_STRUCTURE_KHR = 1000150000;
-    var ACCELERATION_STRUCTURE_NV = 1000165000;
-    var MUTABLE_VALVE = 1000351000;
+	var SAMPLER = 0;
+	var COMBINED_IMAGE_SAMPLER = 1;
+	var SAMPLED_IMAGE = 2;
+	var STORAGE_IMAGE = 3;
+	var UNIFORM_TEXEL_BUFFER = 4;
+	var STORAGE_TEXEL_BUFFER = 5;
+	var UNIFORM_BUFFER = 6;
+	var STORAGE_BUFFER = 7;
+	var UNIFORM_BUFFER_DYNAMIC = 8;
+	var STORAGE_BUFFER_DYNAMIC = 9;
+	var INPUT_ATTACHMENT = 10;
+	var INLINE_UNIFORM_BLOCK_EXT = 1000138000;
+	var ACCELERATION_STRUCTURE_KHR = 1000150000;
+	var ACCELERATION_STRUCTURE_NV = 1000165000;
+	var MUTABLE_VALVE = 1000351000;
 }
 
 @:struct class VkPipelineDynamic {
@@ -798,11 +810,11 @@ enum abstract VkDescriptorType(Int) {
 }
 
 @:struct class VkDescriptorSetLayoutBinding {
-    public var binding : Int;
+	public var binding : Int;
 	public var descriptorType : VkDescriptorType;
 	public var descriptorCount : Int;
-    public var stageFlags : haxe.EnumFlags<VkShaderStageFlag>;
-    public var immutableSamplers : Any; //VkSampler
+	public var stageFlags : haxe.EnumFlags<VkShaderStageFlag>;
+	public var immutableSamplers : Any; //VkSampler
 	public function new() {}
 }
 
@@ -1033,17 +1045,182 @@ enum VkDependencyFlag {
 	}
 }
 
-@:hlNative("?sdl","vk_img_")
-abstract VkImage(hl.Abstract<"vk_image">) {
+@:struct class VkClearValue {
+	public var colorR : Single;
+	public var colorG : Single;
+	public var colorB : Single;
+	public var colorA : Single;
+	public var depth : Single;
+	public var stencil : Int;
+	public function new() {
+	}
+}
+
+@:struct class VkRenderPassBeginInfo {
+	public var type : VkStructureType;
+	public var next : NextPtr;
+	public var renderPass : VkRenderPass;
+	public var framebuffer : VkFramebuffer;
+	public var renderAreaOffsetX : Int;
+	public var renderAreaOffsetY : Int;
+	public var renderAreaExtentX : Int;
+	public var renderAreaExtentY : Int;
+	public var clearValueCount : Int;
+	public var clearValues : ArrayStruct<VkClearValue>;
+	public function new() {
+		type = RENDER_PASS_BEGIN_INFO;
+	}
+}
+
+enum abstract VkSubpassContents(Int) {
+	var INLINE = 0;
+	var SECONDARY_COMMAND_BUFFERS = 1;
+}
+
+enum VkFramebufferCreateFlag {
+	IMAGELESS_BIT;
+}
+
+@:struct class VkFramebufferInfo {
+	public var type : VkStructureType;
+	public var next : NextPtr;
+	public var flags : haxe.EnumFlags<VkFramebufferCreateFlag>;
+	public var renderPass : VkRenderPass;
+	public var attachmentCount : Int;
+	public var attachments : ArrayStruct<VkImageView>;
+	public var width : Int;
+	public var height : Int;
+	public var layers : Int;
+	public function new() {
+		type = FRAMEBUFFER_CREATE_INFO;
+	}
+}
 
-	public function clearColor( r : Float, g : Float, b : Float, a : Float ) {
+enum VkImageViewCreateFlag {
+	FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT;
+	FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT;
+}
+
+enum abstract VkImageViewType(Int) {
+	var TYPE_1D = 0;
+	var TYPE_2D = 1;
+	var TYPE_3D = 2;
+	var TYPE_CUBE = 3;
+	var TYPE_1D_ARRAY = 4;
+	var TYPE_2D_ARRAY = 5;
+	var TYPE_CUBE_ARRAY = 6;
+}
+
+enum abstract VkComponentSwizzle(Int) {
+	var IDENTITY = 0;
+	var ZERO = 1;
+	var ONE = 2;
+	var R = 3;
+	var G = 4;
+	var B = 5;
+	var A = 6;
+}
+
+enum VkImageAspectFlag {
+	COLOR;
+	DEPTH;
+	STENCIL;
+	METADATA;
+	PLANE_0;
+	PLANE_1;
+	PLANE_2;
+	MEMORY_PLANE_0;
+	MEMORY_PLANE_1;
+	MEMORY_PLANE_2;
+	MEMORY_PLANE_3;
+}
+
+@:struct class VkImageViewInfo {
+	public var type : VkStructureType;
+	public var next : NextPtr;
+	public var flags : haxe.EnumFlags<VkImageViewCreateFlag>;
+	public var image : VkImage;
+	public var viewType : VkImageViewType;
+	public var format : VkFormat;
+	public var componentR : VkComponentSwizzle;
+	public var componentG : VkComponentSwizzle;
+	public var componentB : VkComponentSwizzle;
+	public var componentA : VkComponentSwizzle;
+	// 	subresourceRange : VkImageSubresourceRange;
+	public var aspectMask : haxe.EnumFlags<VkImageAspectFlag>;
+	public var baseMipLevel : Int;
+	public var levelCount : Int;
+	public var baseArrayLayer : Int;
+	public var layerCount : Int;
+	public function new() {
+		type = IMAGE_VIEW_CREATE_INFO;
 	}
+}
+
+enum VkBufferCreateFlag {
+	SPARSE_BINDING;
+	SPARSE_RESIDENCY;
+	SPARSE_ALIASED;
+	PROTECTED;
+	DEVICE_ADDRESS_CAPTURE_REPLAY;
+}
+
+enum VkBufferUsageFlag {
+	TRANSFER_SRC;
+	TRANSFER_DST;
+	UNIFORM_TEXEL_BUFFER;
+	STORAGE_TEXEL_BUFFER;
+	UNIFORM_BUFFER;
+	STORAGE_BUFFER;
+	INDEX_BUFFER;
+	VERTEX_BUFFER;
+	INDIRECT_BUFFER;
+}
 
-	public function clearDepthStencil( depth : Float, stencil : Int ) {
+enum abstract VkSharingMode(Int) {
+	var EXCLUSIVE = 0;
+	var CONCURRENT = 1;
+}
+
+@:struct class VkBufferCreateInfo {
+	public var type : VkStructureType;
+	public var next : NextPtr;
+	public var flags : haxe.EnumFlags<VkBufferCreateFlag>;
+	var __align : Int;
+	public var size : Int;
+	public var size64 : Int;
+	public var usage : haxe.EnumFlags<VkBufferUsageFlag>;
+	public var sharingMode : VkSharingMode;
+	public var queueFamilyIndexCount : Int;
+	public var queueFamilyIndices : IntArray<Int>;
+	public function new() {
+		type = BUFFER_CREATE_INFO;
 	}
+}
 
+@:struct class VkMemoryRequirements {
+	public var size : Int;
+	public var size64 : Int;
+	public var alignment : Int;
+	public var alignment64 : Int;
+	public var memoryTypeBits : Int;
+	public function new() {}
 }
 
+@:struct class VkMemoryAllocateInfo {
+	public var type : VkStructureType;
+	public var next : NextPtr;
+	public var size : Int;
+	public var size64 : Int;
+	public var memoryTypeIndex : Int;
+	public function new() {
+		type = MEMORY_ALLOCATE_INFO;
+	}
+}
+
+@:hlNative("?sdl","vk_img_")
+abstract VkImage(hl.Abstract<"vk_image">) {}
+
 @:hlNative("?sdl","vk_")
 abstract VkContext(hl.Abstract<"vk_context">) {
 
@@ -1055,7 +1232,11 @@ abstract VkContext(hl.Abstract<"vk_context">) {
 		return false;
 	}
 
-	public function setCurrent() : VkImage {
+	public function getCurrentImage() : VkImage {
+		return null;
+	}
+
+	public function getCurrentCommandBuffer() : VkCommandBuffer {
 		return null;
 	}
 
@@ -1082,6 +1263,29 @@ abstract VkContext(hl.Abstract<"vk_context">) {
 		return null;
 	}
 
+	public function createFramebuffer( inf : VkFramebufferInfo ) : VkFramebuffer {
+		return null;
+	}
+
+	public function createImageView( inf : VkImageViewInfo ) : VkImageView {
+		return null;
+	}
+
+	public function createBuffer( inf : VkBufferCreateInfo ) : VkBuffer {
+		return null;
+	}
+
+	public function getBufferMemoryRequirements( b : VkBuffer, inf : VkMemoryRequirements ) {
+	}
+
+	public function allocateMemory( inf : VkMemoryAllocateInfo ) : VkDeviceMemory {
+		return null;
+	}
+
+	public function bindBufferMemory( b : VkBuffer, mem : VkDeviceMemory, memOffset : Int ) {
+		return false;
+	}
+
 }
 
 enum abstract ShaderKind(Int) {
@@ -1089,6 +1293,29 @@ enum abstract ShaderKind(Int) {
 	var Fragment = 1;
 }
 
+@:hlNative("?sdl","vk_")
+abstract VkCommandBuffer(hl.Abstract<"vk_command_buffer">) {
+
+	public function clearColorImage( img : VkImage, r : Float, g : Float, b : Float, a : Float ) {
+	}
+
+	public function clearDepthStencilImage( img : VkImage, depth : Float, stencil : Int ) {
+	}
+
+	public function drawIndexed( indexCount : Int, instanceCount : Int, firstIndex : Int, vertexOffset : Int, firstInstance : Int ) {
+	}
+
+	public function bindPipeline( bindPoint : VkPipelineBindPoint, pipeline : VkGraphicsPipeline ) {
+	}
+
+	public function bindIndexBuffer( buffer : VkBuffer, offset : Int, indexType : Int ) {
+	}
+
+	public function beginRenderPass( begin : VkRenderPassBeginInfo, contents : VkSubpassContents ) {
+	}
+
+}
+
 @:hlNative("?sdl","vk_")
 class Vulkan {
 
@@ -1105,12 +1332,6 @@ class Vulkan {
 		return @:privateAccess new haxe.io.Bytes(bytes, outSize);
 	}
 
-	public static function drawIndexed( indexCount : Int, instanceCount : Int, firstIndex : Int, vertexOffset : Int, firstInstance : Int ) {
-	}
-
-	public static function bindPipeline( bindPoint : VkPipelineBindPoint, pipeline : VkGraphicsPipeline ) {
-	}
-
 	static function compile_shader( source : hl.Bytes, shaderFile : hl.Bytes, mainFunction : hl.Bytes, kind : ShaderKind, outSize : hl.Ref<Int> ) : hl.Bytes {
 		return null;
 	}

libs/sdl/vulkan.c

@@ -38,6 +38,22 @@ HL_PRIM bool HL_NAME(vk_init)( bool enable_validation ) {
 	return true;
 }
 
+vbyte *HL_NAME(vk_make_array)( varray *a ) {
+	if( a->size == 0 )
+		return NULL;
+	if( a->at->kind == HABSTRACT )
+		return hl_copy_bytes(hl_aptr(a,vbyte), a->size * sizeof(void*));
+#ifdef HL_DEBUG
+	if( a->at->kind != HSTRUCT ) hl_error("assert");
+#endif
+	int size = a->at->kind == HABSTRACT ? sizeof(void*) : a->at->obj->rt->size;
+	vbyte *ptr = hl_alloc_bytes(size * a->size);
+	int i;
+	for(i=0;i<a->size;i++)
+		memcpy(ptr + i * size, hl_aptr(a,vbyte*)[i], size);
+	return ptr;
+}
+
 // ------------------------------------------ CONTEXT INIT --------------------------------------------
 
 #define MAX_SWAPCHAIN_IMAGES 3
@@ -364,20 +380,32 @@ VkDescriptorSetLayout HL_NAME(vk_create_descriptor_set_layout)( VkContext ctx, V
 	return p;
 }
 
-vbyte *HL_NAME(vk_make_array)( varray *a ) {
-	if( a->size == 0 )
-		return NULL;
-	if( a->at->kind == HABSTRACT )
-		return hl_copy_bytes(hl_aptr(a,vbyte), a->size * sizeof(void*));
-#ifdef HL_DEBUG
-	if( a->at->kind != HSTRUCT ) hl_error("assert");
-#endif
-	int size = a->at->kind == HABSTRACT ? sizeof(void*) : a->at->obj->rt->size;
-	vbyte *ptr = hl_alloc_bytes(size * a->size);
-	int i;
-	for(i=0;i<a->size;i++)
-		memcpy(ptr + i * size, hl_aptr(a,vbyte*)[i], size);
-	return ptr;
+VkBuffer HL_NAME(vk_create_buffer)( VkContext ctx, VkBufferCreateInfo *info ) {
+	VkBuffer b = NULL;
+	vkCreateBuffer(ctx->device, info, NULL, &b);
+	return b;
+}
+
+void HL_NAME(vk_get_buffer_memory_requirements)( VkContext ctx, VkBuffer buf, VkMemoryRequirements *info ) {
+	vkGetBufferMemoryRequirements(ctx->device,buf,info);
+}
+
+VkDeviceMemory HL_NAME(vk_allocate_memory)( VkContext ctx, VkMemoryAllocateInfo *inf ) {
+	VkDeviceMemory m = NULL;
+	vkAllocateMemory(ctx->device, inf, NULL, &m);
+	return m;
+}
+
+bool HL_NAME(vk_bind_buffer_memory)( VkContext ctx, VkBuffer buf, VkDeviceMemory mem, int offset ) {
+	return vkBindBufferMemory(ctx->device, buf, mem, offset) == VK_SUCCESS;
+}
+
+VkImage HL_NAME(vk_get_current_image)( VkContext ctx ) {
+	return ctx->swapchainImages[ctx->currentImage];
+}
+
+VkCommandBuffer HL_NAME(vk_get_current_command_buffer)( VkContext ctx ) {
+	return ctx->frames[ctx->currentFrame].buffer;
 }
 
 #define _VCTX _ABSTRACT(vk_context)
@@ -387,6 +415,9 @@ vbyte *HL_NAME(vk_make_array)( varray *a ) {
 #define _RENDERPASS _ABSTRACT(vk_render_pass)
 #define _IMG _ABSTRACT(vk_image)
 #define _DESCRIPTOR_SET _ABSTRACT(vk_descriptor_set)
+#define _BUFFER _ABSTRACT(vk_buffer)
+#define _MEMORY _ABSTRACT(vk_device_memory)
+#define _CMD _ABSTRACT(vk_command_buffer)
 
 DEFINE_PRIM(_BOOL, vk_init, _BOOL);
 DEFINE_PRIM(_BOOL, vk_init_swapchain, _VCTX _I32 _I32);
@@ -398,41 +429,47 @@ DEFINE_PRIM(_GPIPELINE, vk_create_graphics_pipeline, _VCTX _STRUCT);
 DEFINE_PRIM(_PIPELAYOUT, vk_create_pipeline_layout, _VCTX _STRUCT);
 DEFINE_PRIM(_RENDERPASS, vk_create_render_pass, _VCTX _STRUCT);
 DEFINE_PRIM(_DESCRIPTOR_SET, vk_create_descriptor_set_layout, _VCTX _STRUCT);
+DEFINE_PRIM(_BUFFER, vk_create_buffer, _VCTX _STRUCT);
+DEFINE_PRIM(_VOID, vk_get_buffer_memory_requirements, _VCTX _BUFFER _STRUCT);
+DEFINE_PRIM(_MEMORY, vk_allocate_memory, _VCTX _STRUCT);
+DEFINE_PRIM(_BOOL, vk_bind_buffer_memory, _VCTX _BUFFER _MEMORY _I32);
+DEFINE_PRIM(_IMG, vk_get_current_image, _VCTX);
+DEFINE_PRIM(_CMD, vk_get_current_command_buffer, _VCTX);
 
 // ------ COMMAND BUFFER OPERATIONS -----------------------
 
-static VkContext current_context = NULL;
-static VkCommandBuffer current_buffer = NULL;
+HL_PRIM void HL_NAME(vk_clear_color_image)( VkCommandBuffer out, VkImage img, double r, double g, double b, double a ) {
+	VkClearColorValue color = { (float)r, (float)g, (float)b, (float)a };
+	vkCmdClearColorImage(out, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &RANGE_ALL);
+}
 
-HL_PRIM VkImage HL_NAME(vk_set_current)( VkContext ctx ) {
-	current_context = ctx;
-	current_buffer = ctx->frames[ctx->currentFrame].buffer;
-	return ctx->swapchainImages[ctx->currentImage];
+HL_PRIM void HL_NAME(vk_clear_depth_stencil_image)( VkCommandBuffer out, VkImage img, double d, int stencil ) {
+	VkClearDepthStencilValue ds = { (float)d, (uint32_t)stencil };
+	vkCmdClearDepthStencilImage(out, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &ds, 1, &RANGE_ALL);
 }
 
-HL_PRIM void HL_NAME(vk_img_clear_color)( VkImage img, double r, double g, double b, double a ) {
-	VkClearColorValue color = { (float)r, (float)g, (float)b, (float)a };
-	vkCmdClearColorImage(current_buffer, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &RANGE_ALL);
+HL_PRIM void HL_NAME(vk_draw_indexed)( VkCommandBuffer out, int indexCount, int instanceCount, int firstIndex, int vertexOffset, int firstInstance ) {
+	vkCmdDrawIndexed(out,indexCount,instanceCount,firstIndex,vertexOffset,firstInstance);
 }
 
-HL_PRIM void HL_NAME(vk_img_clear_depth_stencil)( VkImage img, double d, int stencil ) {
-	VkClearDepthStencilValue ds = { (float)d, (uint32_t)stencil };
-	vkCmdClearDepthStencilImage(current_buffer, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &ds, 1, &RANGE_ALL);
+HL_PRIM void HL_NAME(vk_bind_pipeline)( VkCommandBuffer out, int bindPoint, VkPipeline pipeline ) {
+	vkCmdBindPipeline(out, (VkPipelineBindPoint)bindPoint, pipeline);
 }
 
-HL_PRIM void HL_NAME(vk_draw_indexed)( int indexCount, int instanceCount, int firstIndex, int vertexOffset, int firstInstance ) {
-	vkCmdDrawIndexed(current_buffer,indexCount,instanceCount,firstIndex,vertexOffset,firstInstance);
+HL_PRIM void HL_NAME(vk_begin_render_pass)( VkCommandBuffer out, VkRenderPassBeginInfo *info, int contents ) {
+	vkCmdBeginRenderPass(out, info, (VkSubpassContents)contents);
 }
 
-HL_PRIM void HL_NAME(vk_bind_pipeline)( int bindPoint, VkPipeline pipeline ) {
-	vkCmdBindPipeline(current_buffer, (VkPipelineBindPoint)bindPoint, pipeline);
+HL_PRIM void HL_NAME(vk_bind_index_buffer)( VkCommandBuffer out, VkBuffer buf, int offset, int type ) {
+	vkCmdBindIndexBuffer(out, buf, offset, type);
 }
 
-DEFINE_PRIM(_IMG, vk_set_current, _VCTX);
-DEFINE_PRIM(_VOID, vk_img_clear_color, _IMG _F64 _F64 _F64 _F64);
-DEFINE_PRIM(_VOID, vk_img_clear_depth_stencil, _IMG _F64 _I32);
-DEFINE_PRIM(_VOID, vk_draw_indexed, _I32 _I32 _I32 _I32 _I32);
-DEFINE_PRIM(_VOID, vk_bind_pipeline, _I32 _GPIPELINE);
+DEFINE_PRIM(_VOID, vk_clear_color_image, _CMD _IMG _F64 _F64 _F64 _F64);
+DEFINE_PRIM(_VOID, vk_clear_depth_stencil_image, _CMD _IMG _F64 _I32);
+DEFINE_PRIM(_VOID, vk_draw_indexed, _CMD _I32 _I32 _I32 _I32 _I32);
+DEFINE_PRIM(_VOID, vk_bind_pipeline, _CMD _I32 _GPIPELINE);
+DEFINE_PRIM(_VOID, vk_begin_render_pass, _CMD _STRUCT _I32);
+DEFINE_PRIM(_VOID, vk_bind_index_buffer, _CMD _BUFFER _I32 _I32);
 
 // ------ SHADER COMPILATION ------------------------------