ld58/code/game/core.c

void G_ImagesLoad(G_State *game) {
	M_TempScope(0, 0) {
		FS_List assets = FS_PathList(temp.arena, S("assets"));

		Vk_Buffer staging = { 0 };
		staging.size         = MB(256);
		staging.usage        = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
		staging.host_visible = true;

		Vk_BufferCreate(&staging);

		U8 *base   = staging.data;
		U64 offset = 0;

		Vk_CommandBuffer *cmds = Vk_CommandBufferPush();

		U32 n_images = 0;

		for (FS_Entry *it = assets.first; it != 0; it = it->next) {
			if (Str8_EndsWith(it->basename, S("png"))) {
				if (Str8_Equal(it->basename, S("saloon_ext.png"), 0)) {
						printf("IMAGE SALOON == %d\n", n_images);
				}

				n_images += 1;
			}
		}

		VkBufferImageCopy copy = { 0 };
		game->images = M_ArenaPush(game->arena, G_Image, .count = n_images);
		n_images = 0;

		// Image upload is sbi_load -> copy to staging -> upload to gpu texture

		for (FS_Entry *it = assets.first; it != 0; it = it->next) {
			if (Str8_EndsWith(it->basename, S("png"))) {
				S32 w, h, c;
				stbi_uc *data = stbi_load((const char *) it->path.data, &w, &h, &c, 4);

				if (data) {
					G_Image *image = &game->images[n_images];

					U64 image_sz = 4 * w * h;

					M_CopySize(base, data, image_sz);

					copy.bufferOffset      = offset;
					copy.bufferRowLength   = 0;
					copy.bufferImageHeight = 0;

					copy.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
					copy.imageSubresource.mipLevel       = 0;
					copy.imageSubresource.baseArrayLayer = 0;
					copy.imageSubresource.layerCount     = 1;

					copy.imageExtent.width  = w;
					copy.imageExtent.height = h;
					copy.imageExtent.depth  = 1;

					base   += image_sz;
					offset += image_sz;

					Assert(offset <= staging.size);

					n_images += 1;

					image->name = Str8_Copy(game->arena, Str8_RemoveAfterLast(it->basename, '.'));

					image->image.width  = w;
					image->image.height = h;

					image->image.format = VK_FORMAT_R8G8B8A8_SRGB;
					image->image.usage  = VK_IMAGE_USAGE_SAMPLED_BIT;

					Vk_ImageCreate(&image->image);

					VkImageMemoryBarrier2 transfer = { 0 };
					VkImageMemoryBarrier2 shader_read = { 0 };

					transfer.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
					transfer.srcStageMask  = VK_PIPELINE_STAGE_2_NONE;
					transfer.srcAccessMask = VK_ACCESS_2_NONE;
					transfer.dstStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
					transfer.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
					transfer.oldLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
					transfer.newLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
					transfer.image         = image->image.handle;

					transfer.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
					transfer.subresourceRange.layerCount = 1;
					transfer.subresourceRange.levelCount = 1;

					shader_read.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
					shader_read.srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
					shader_read.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
					shader_read.dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
					shader_read.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
					shader_read.oldLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
					shader_read.newLayout     = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
					shader_read.image         = image->image.handle;

					shader_read.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
					shader_read.subresourceRange.layerCount = 1;
					shader_read.subresourceRange.levelCount = 1;

					VkDependencyInfo dep = { 0 };
					dep.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;

					dep.imageMemoryBarrierCount = 1;
					dep.pImageMemoryBarriers    = &transfer;

					vk.CmdPipelineBarrier2(cmds->handle, &dep);

					vk.CmdCopyBufferToImage(cmds->handle, staging.handle, image->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);

					dep.pImageMemoryBarriers = &shader_read;

					vk.CmdPipelineBarrier2(cmds->handle, &dep);

					stbi_image_free(data);
				}
			}
		}

		Vk_CommandBufferSubmit(cmds, true /* wait */);
	}
}

void G_PipelinesLoad(G_State *game) {
	game->pipelines = M_ArenaPush(game->arena, Vk_Pipeline, .count = 1);

	Vk_Pipeline *basic = &game->pipelines[0];

	VkShaderModule vshader = 0, fshader = 0;
	M_TempScope(0, 0) {
		Str8 vshader_code = FS_ReadEntireFile(temp.arena, S("assets/shaders/basic.vert.spv"));
		Str8 fshader_code = FS_ReadEntireFile(temp.arena, S("assets/shaders/basic.frag.spv"));

		VkShaderModuleCreateInfo create_info = { 0 };
		create_info.sType    = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
		create_info.pCode    = (U32 *) vshader_code.data;
		create_info.codeSize = vshader_code.count;

		vk.CreateShaderModule(vk.device, &create_info, 0, &vshader);

		create_info.pCode    = (U32 *) fshader_code.data;
		create_info.codeSize = fshader_code.count;

		vk.CreateShaderModule(vk.device, &create_info, 0, &fshader);
	}

	// Create pipeline layout, its insane what you have to do for this because the ALREADY KNOW
	// all of this information
	{
		VkDescriptorSetLayoutBinding bindings[2] = { 0 };

		bindings[0].binding         = 0;
		bindings[0].descriptorType  = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
		bindings[0].descriptorCount = 1;
		bindings[0].stageFlags      = VK_SHADER_STAGE_VERTEX_BIT;

		bindings[1].binding         = 1;
		bindings[1].descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
		bindings[1].descriptorCount = 1;
		bindings[1].stageFlags      = VK_SHADER_STAGE_FRAGMENT_BIT;

		VkDescriptorSetLayoutCreateInfo set_info = { 0 };
		set_info.sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
		set_info.bindingCount = 2;
		set_info.pBindings    = bindings;

		vk.CreateDescriptorSetLayout(vk.device, &set_info, 0, &basic->layout.set);

		VkPipelineLayoutCreateInfo layout_create = { 0 };
		layout_create.sType          = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
		layout_create.setLayoutCount = 1;
		layout_create.pSetLayouts    = &basic->layout.set;

		vk.CreatePipelineLayout(vk.device, &layout_create, 0, &basic->layout.pipeline);
	}

	basic->targets.items[0] = vk.swapchain.format.format;
	basic->targets.count    = 1;

	basic->shaders.count = 2;

	basic->shaders.items[0].stage  = VK_SHADER_STAGE_VERTEX_BIT;
	basic->shaders.items[0].handle = vshader;

	basic->shaders.items[1].stage  = VK_SHADER_STAGE_FRAGMENT_BIT;
	basic->shaders.items[1].handle = fshader;

	Vk_PipelineCreate(basic);
}

#include "impl/aabb.c"
#include "impl/nav.c"
#include "impl/player.c"