# HG changeset patch
# User John Tsiombikas <nuclear@member.fsf.org>
# Date 1530183448 -10800
# Node ID 8de4fe9268823c6f3ac894531a91bee555352217

initial commit

diff -r 000000000000 -r 8de4fe926882 .hgignore
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Thu Jun 28 13:57:28 2018 +0300
@@ -0,0 +1,5 @@
+\.o$
+\.swp$
+\.d$
+\.spv$
+^test$
diff -r 000000000000 -r 8de4fe926882 Makefile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile	Thu Jun 28 13:57:28 2018 +0300
@@ -0,0 +1,21 @@
+src = $(wildcard src/*.c)
+obj = $(src:.c=.o)
+bin = test
+
+def = -DGLFW_INCLUDE_VULKAN
+
+CFLAGS = -pedantic -Wall -g $(def)
+LDFLAGS = -lvulkan -lglfw
+
+$(bin): $(obj) vertex.spv pixel.spv
+	$(CC) -o $@ $(obj) $(LDFLAGS)
+
+vertex.spv: vertex.glsl
+	glslangValidator -o $@ -S vert -V $<
+
+pixel.spv: pixel.glsl
+	glslangValidator -o $@ -S frag -V $<
+
+.PHONY: clean
+clean:
+	rm -f $(obj) $(bin) *.spv
diff -r 000000000000 -r 8de4fe926882 pixel.glsl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pixel.glsl	Thu Jun 28 13:57:28 2018 +0300
@@ -0,0 +1,10 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 incol;
+layout(location = 0) out vec4 outcol;
+
+void main()
+{
+	outcol = vec4(incol, 1.0);
+}
diff -r 000000000000 -r 8de4fe926882 src/main.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main.c	Thu Jun 28 13:57:28 2018 +0300
@@ -0,0 +1,748 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <errno.h>
+#include <alloca.h>
+#include <GLFW/glfw3.h>
+
+void keyb(GLFWwindow *win, int key, int sc, int act, int mods);
+int init(void);
+void destroy(void);
+void draw(void);
+
+GLFWwindow *win;
+int win_width = 800;
+int win_height = 600;
+int redraw_pending;
+
+int main(void)
+{
+	if(!glfwInit()) {
+		fprintf(stderr, "glfw init failed\n");
+		return 1;
+	}
+
+	glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+	win = glfwCreateWindow(win_width, win_height, "test", 0, 0);
+	glfwSetKeyCallback(win, keyb);
+
+	if(init() == -1) {
+		glfwDestroyWindow(win);
+		glfwTerminate();
+		return 1;
+	}
+
+	redraw_pending = 1;
+
+	while(!glfwWindowShouldClose(win)) {
+		glfwWaitEvents();
+
+		if(redraw_pending) {
+			redraw_pending = 0;
+			draw();
+		}
+	}
+
+	destroy();
+	glfwDestroyWindow(win);
+	glfwTerminate();
+	return 0;
+}
+
+void keyb(GLFWwindow *win, int key, int sc, int act, int mods)
+{
+	if(act == GLFW_PRESS) {
+		switch(key) {
+		case GLFW_KEY_ESCAPE:
+			glfwSetWindowShouldClose(win, 1);
+			break;
+		}
+	}
+}
+
+/* -------------------------------------------------------------- */
+int create_instance(void);
+int create_surface(void);
+int choose_phys_dev(void);
+int create_device(void);
+int create_swapchain(void);
+int create_imgviews(void);
+int create_rendpass(void);
+int create_pipeline(void);
+int create_framebuf(void);
+int create_cmdpool(void);
+int create_cmdbuf(void);
+int create_semaphores(void);
+VkShaderModule load_shader(const char *fname);
+
+VkInstance vk;
+VkPhysicalDevice vkpdev;
+int vkqfam_idx = -1;
+VkDevice vkdev;
+VkQueue vkq;
+VkSurfaceKHR vksurf;
+VkSurfaceCapabilitiesKHR vksurf_caps;
+int vksurf_numfmt, vksurf_selfmt;
+VkSurfaceFormatKHR *vksurf_fmt;
+VkSwapchainKHR vksc;
+int vksc_numimg;
+VkImage *vksc_img;
+VkExtent2D vksc_extent;
+VkImageView *vksc_view;
+VkRenderPass vkrpass;
+VkPipelineLayout vkpipe_layout;
+VkPipeline vkpipe;
+VkFramebuffer *vksc_fb;
+VkCommandPool vkcmdpool;
+VkCommandBuffer *vksc_cmdbuf;
+VkSemaphore sem_gotimg, sem_drawdone;
+
+int init(void)
+{
+	if(create_instance() == -1) return -1;
+	if(create_surface() == -1) return -1;
+	if(choose_phys_dev() == -1) return -1;
+	if(create_device() == -1) return -1;
+	if(create_swapchain() == -1) return -1;
+	if(create_imgviews() == -1) return -1;
+	if(create_rendpass() == -1) return -1;
+	if(create_pipeline() == -1) return -1;
+	if(create_framebuf() == -1) return -1;
+	if(create_cmdpool() == -1) return -1;
+	if(create_cmdbuf() == -1) return -1;
+	if(create_semaphores() == -1) return -1;
+	return 0;
+}
+
+void destroy(void)
+{
+	int i;
+
+	if(sem_gotimg) vkDestroySemaphore(vkdev, sem_gotimg, 0);
+	if(sem_drawdone) vkDestroySemaphore(vkdev, sem_drawdone, 0);
+	if(vkcmdpool) vkDestroyCommandPool(vkdev, vkcmdpool, 0);
+	if(vksc_fb) {
+		for(i=0; i<vksc_numimg; i++) {
+			vkDestroyFramebuffer(vkdev, vksc_fb[i], 0);
+		}
+	}
+	if(vkpipe) vkDestroyPipeline(vkdev, vkpipe, 0);
+	if(vkpipe_layout) vkDestroyPipelineLayout(vkdev, vkpipe_layout, 0);
+	if(vkrpass) vkDestroyRenderPass(vkdev, vkrpass, 0);
+	if(vksc_view) {
+		for(i=0; i<vksc_numimg; i++) {
+			vkDestroyImageView(vkdev, vksc_view[i], 0);
+		}
+	}
+	if(vksc) vkDestroySwapchainKHR(vkdev, vksc, 0);
+	if(vkdev) vkDestroyDevice(vkdev, 0);
+	if(vksurf) vkDestroySurfaceKHR(vk, vksurf, 0);
+	if(vk) vkDestroyInstance(vk, 0);
+}
+
+void draw(void)
+{
+	uint32_t img_idx;
+	VkSubmitInfo submit;
+	VkPipelineStageFlags wait_stages = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	VkPresentInfoKHR pres;
+
+	vkAcquireNextImageKHR(vkdev, vksc, UINT64_MAX, sem_gotimg, 0, &img_idx);
+
+	memset(&submit, 0, sizeof submit);
+	submit.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+	submit.waitSemaphoreCount = 1;
+	submit.pWaitSemaphores = &sem_gotimg;
+	submit.pWaitDstStageMask = &wait_stages;
+	submit.commandBufferCount = 1;
+	submit.pCommandBuffers = vksc_cmdbuf + img_idx;
+	submit.signalSemaphoreCount = 1;
+	submit.pSignalSemaphores = &sem_drawdone;
+
+	if(vkQueueSubmit(vkq, 1, &submit, 0) != 0) {
+		fprintf(stderr, "failed to submit draw commands\n");
+		abort();
+	}
+
+	memset(&pres, 0, sizeof pres);
+	pres.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+	pres.waitSemaphoreCount = 1;
+	pres.pWaitSemaphores = &sem_drawdone;
+	pres.swapchainCount = 1;
+	pres.pSwapchains = &vksc;
+	pres.pImageIndices = &img_idx;
+
+	vkQueuePresentKHR(vkq, &pres);
+}
+
+int create_instance(void)
+{
+	VkApplicationInfo appinf;
+	VkInstanceCreateInfo iinf;
+	uint32_t num_ext;
+	const char **ext;
+
+	ext = glfwGetRequiredInstanceExtensions(&num_ext);
+
+	memset(&appinf, 0, sizeof appinf);
+	appinf.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+	appinf.pApplicationName = "test";
+	appinf.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
+	appinf.pEngineName = "fuckoff";
+	appinf.engineVersion = VK_MAKE_VERSION(1, 0, 0);
+	appinf.apiVersion = VK_API_VERSION_1_0;
+
+	memset(&iinf, 0, sizeof iinf);
+	iinf.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+	iinf.pApplicationInfo = &appinf;
+	iinf.enabledExtensionCount = num_ext;
+	iinf.ppEnabledExtensionNames = ext;
+
+	if(vkCreateInstance(&iinf, 0, &vk) != 0) {
+		fprintf(stderr, "failed to create instance\n");
+		return -1;
+	}
+	return 0;
+}
+
+int create_surface(void)
+{
+	if(glfwCreateWindowSurface(vk, win, 0, &vksurf) != 0) {
+		fprintf(stderr, "failed to create window surface\n");
+		return -1;
+	}
+	return 0;
+}
+
+static int is_pdev_skookum(VkPhysicalDevice dev)
+{
+	uint32_t i, num_fmt, num_qfam, num_ext;
+	VkQueueFamilyProperties *qfam;
+	VkExtensionProperties *ext;
+	VkPhysicalDeviceProperties prop;
+	VkPhysicalDeviceFeatures feat;
+	VkBool32 can_pres;
+	int have_swap_ext;
+
+	vkGetPhysicalDeviceProperties(dev, &prop);
+	vkGetPhysicalDeviceFeatures(dev, &feat);
+
+	/* check if we have the swapchain extension */
+	vkEnumerateDeviceExtensionProperties(dev, 0, &num_ext, 0);
+	ext = alloca(num_ext * sizeof *ext);
+	vkEnumerateDeviceExtensionProperties(dev, 0, &num_ext, ext);
+
+	have_swap_ext = 0;
+	for(i=0; i<num_ext; i++) {
+		if(strcmp(ext[i].extensionName, "VK_KHR_swapchain") == 0) {
+			have_swap_ext = 1;
+			break;
+		}
+	}
+	if(!have_swap_ext) {
+		return 0;
+	}
+
+	/* populate format and present modes arrays, and make sure we have some of each */
+	vkGetPhysicalDeviceSurfaceFormatsKHR(dev, vksurf, &num_fmt, 0);
+	if(!num_fmt || !(vksurf_fmt = malloc(num_fmt * sizeof *vksurf_fmt))) {
+		return 0;
+	}
+	vksurf_numfmt = num_fmt;
+	vkGetPhysicalDeviceSurfaceFormatsKHR(dev, vksurf, &num_fmt, vksurf_fmt);
+
+	vkGetPhysicalDeviceSurfaceCapabilitiesKHR(dev, vksurf, &vksurf_caps);
+
+	/* find a queue family which can do graphics and can present */
+	vkGetPhysicalDeviceQueueFamilyProperties(dev, &num_qfam, 0);
+	qfam = alloca(num_qfam * sizeof *qfam);
+	vkGetPhysicalDeviceQueueFamilyProperties(dev, &num_qfam, qfam);
+
+	vkqfam_idx = -1;
+	for(i=0; i<num_qfam; i++) {
+		vkGetPhysicalDeviceSurfaceSupportKHR(dev, i, vksurf, &can_pres);
+		if(qfam[i].queueCount && (qfam[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && can_pres) {
+			vkqfam_idx = i;
+			return 1;
+		}
+	}
+
+	free(vksurf_fmt);
+	vksurf_fmt = 0;
+	vksurf_numfmt = 0;
+	return 0;
+}
+
+static int choose_pixfmt(void)
+{
+	int i, j;
+	static const VkFormat pref[] = {
+		VK_FORMAT_B8G8R8_UNORM,
+		VK_FORMAT_R8G8B8_UNORM,
+		VK_FORMAT_B8G8R8A8_UNORM,
+		VK_FORMAT_R8G8B8A8_UNORM
+	};
+
+	vksurf_selfmt = 0;
+	for(i=0; i<vksurf_numfmt; i++) {
+		if(vksurf_fmt[i].colorSpace != VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
+			continue;
+		}
+		for(j=0; j<sizeof pref / sizeof *pref; j++) {
+			if(vksurf_fmt[i].format == pref[j]) {
+				vksurf_selfmt = i;
+				return i;
+			}
+		}
+	}
+	return -1;
+}
+
+int choose_phys_dev(void)
+{
+	uint32_t i, num_pdev;
+	VkPhysicalDevice *pdev;
+
+	vkEnumeratePhysicalDevices(vk, &num_pdev, 0);
+	if(!num_pdev) {
+		fprintf(stderr, "no vulkan devices found\n");
+		return -1;
+	}
+	pdev = alloca(num_pdev * sizeof *pdev);
+	vkEnumeratePhysicalDevices(vk, &num_pdev, pdev);
+
+	for(i=0; i<num_pdev; i++) {
+		if(is_pdev_skookum(pdev[i])) {
+			vkpdev = pdev[i];
+			break;
+		}
+	}
+	if(!vkpdev) {
+		fprintf(stderr, "no skookum device found, vulkan can't chooch\n");
+		return -1;
+	}
+
+	choose_pixfmt();
+	return 0;
+}
+
+int create_device(void)
+{
+	static const float prio = 1.0f;
+	VkDeviceQueueCreateInfo qinf;
+	VkPhysicalDeviceFeatures feat;
+	VkDeviceCreateInfo devinf;
+
+	static const char *extensions[] = {
+		"VK_KHR_swapchain"
+	};
+
+	memset(&feat, 0, sizeof feat);
+
+	memset(&qinf, 0, sizeof qinf);
+	qinf.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+	qinf.queueFamilyIndex = vkqfam_idx;
+	qinf.queueCount = 1;
+	qinf.pQueuePriorities = &prio;
+
+	memset(&devinf, 0, sizeof devinf);
+	devinf.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+	devinf.pQueueCreateInfos = &qinf;
+	devinf.queueCreateInfoCount = 1;
+	devinf.pEnabledFeatures = &feat;
+	devinf.enabledExtensionCount = sizeof extensions / sizeof *extensions;
+	devinf.ppEnabledExtensionNames = extensions;
+
+	if(vkCreateDevice(vkpdev, &devinf, 0, &vkdev) != 0) {
+		fprintf(stderr, "failed to create vulkan device\n");
+		return -1;
+	}
+
+	vkGetDeviceQueue(vkdev, vkqfam_idx, 0, &vkq);
+	return 0;
+}
+
+int create_swapchain(void)
+{
+	uint32_t num;
+	VkSwapchainCreateInfoKHR scinf;
+
+	vksc_extent.width = win_width;
+	vksc_extent.height = win_height;
+
+	memset(&scinf, 0, sizeof scinf);
+	scinf.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+	scinf.surface = vksurf;
+	scinf.minImageCount = 2;
+	scinf.imageFormat = vksurf_fmt[vksurf_selfmt].format;
+	scinf.imageColorSpace = vksurf_fmt[vksurf_selfmt].colorSpace;
+	scinf.imageExtent = vksc_extent;
+	scinf.imageArrayLayers = 1;
+	scinf.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+	scinf.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+	scinf.preTransform = vksurf_caps.currentTransform;
+	scinf.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+	scinf.presentMode = VK_PRESENT_MODE_FIFO_KHR;
+	scinf.clipped = VK_TRUE;
+
+	if(vkCreateSwapchainKHR(vkdev, &scinf, 0, &vksc) != 0) {
+		fprintf(stderr, "failed to create swapchain\n");
+		return -1;
+	}
+
+	vkGetSwapchainImagesKHR(vkdev, vksc, &num, 0);
+	if(!num || !(vksc_img = malloc(num * sizeof *vksc_img))) {
+		fprintf(stderr, "failed to allocate swapchain image array (%d images)\n", vksc_numimg);
+		return -1;
+	}
+	vkGetSwapchainImagesKHR(vkdev, vksc, &num, vksc_img);
+	vksc_numimg = num;
+
+	return 0;
+}
+
+int create_imgviews(void)
+{
+	int i;
+	VkImageViewCreateInfo ivinf;
+
+	if(!(vksc_view = malloc(vksc_numimg * sizeof *vksc_view))) {
+		fprintf(stderr, "failed to allocate image view array (%d images)\n", vksc_numimg);
+		return -1;
+	}
+
+	for(i=0; i<vksc_numimg; i++) {
+		memset(&ivinf, 0, sizeof ivinf);
+		ivinf.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+		ivinf.image = vksc_img[i];
+		ivinf.format = vksurf_fmt[vksurf_selfmt].format;
+		ivinf.components.r = ivinf.components.g = ivinf.components.b =
+			ivinf.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+		ivinf.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		ivinf.subresourceRange.levelCount = 1;
+		ivinf.subresourceRange.layerCount = 1;
+
+		if(vkCreateImageView(vkdev, &ivinf, 0, vksc_view + i) != 0) {
+			fprintf(stderr, "failed to create image view for image %d\n", i);
+			return -1;
+		}
+	}
+	return 0;
+}
+
+int create_rendpass(void)
+{
+	VkAttachmentDescription cat;
+	VkAttachmentReference catref;
+	VkSubpassDescription subpass;
+	VkRenderPassCreateInfo pinf;
+	VkSubpassDependency dep;
+
+	memset(&cat, 0, sizeof cat);
+	cat.format = vksurf_fmt[vksurf_selfmt].format;
+	cat.samples = VK_SAMPLE_COUNT_1_BIT;
+	cat.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+	cat.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+	cat.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	cat.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+	cat.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	cat.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+
+	memset(&catref, 0, sizeof catref);
+	catref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+	memset(&subpass, 0, sizeof subpass);
+	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+	subpass.colorAttachmentCount = 1;
+	subpass.pColorAttachments = &catref;
+
+	memset(&dep, 0, sizeof dep);
+	dep.srcSubpass = VK_SUBPASS_EXTERNAL;
+	dep.dstSubpass = 0;
+	dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	dep.srcAccessMask = 0;
+	dep.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+	dep.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+
+	memset(&pinf, 0, sizeof pinf);
+	pinf.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+	pinf.attachmentCount = 1;
+	pinf.pAttachments = &cat;
+	pinf.subpassCount = 1;
+	pinf.pSubpasses = &subpass;
+	pinf.dependencyCount = 1;
+	pinf.pDependencies = &dep;
+
+	if(vkCreateRenderPass(vkdev, &pinf, 0, &vkrpass) != 0) {
+		fprintf(stderr, "failed to create render pass\n");
+		return -1;
+	}
+	return 0;
+}
+
+int create_pipeline(void)
+{
+	int i;
+	VkShaderModule sdr[2];
+	VkPipelineShaderStageCreateInfo ssinf[2];
+	VkPipelineVertexInputStateCreateInfo vinp;
+	VkPipelineInputAssemblyStateCreateInfo vasm;
+	VkViewport vport;
+	VkRect2D scissor;
+	VkPipelineViewportStateCreateInfo vp;
+	VkPipelineRasterizationStateCreateInfo rast;
+	VkPipelineMultisampleStateCreateInfo msaa;
+	VkPipelineColorBlendAttachmentState bat;
+	VkPipelineColorBlendStateCreateInfo blend;
+	VkPipelineLayoutCreateInfo lay;
+	VkGraphicsPipelineCreateInfo pinf;
+
+	if(!(sdr[0] = load_shader("vertex.glsl")) || !(sdr[1] = load_shader("pixel.glsl"))) {
+		return -1;
+	}
+	memset(ssinf, 0, sizeof ssinf);
+	for(i=0; i<2; i++) {
+		ssinf[i].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		ssinf[i].stage = i == 0 ? VK_SHADER_STAGE_VERTEX_BIT : VK_SHADER_STAGE_FRAGMENT_BIT;
+		ssinf[i].module = sdr[i];
+		ssinf[i].pName = "main";
+	}
+
+	memset(&vinp, 0, sizeof vinp);
+	vinp.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+
+	memset(&vasm, 0, sizeof vasm);
+	vasm.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+	vasm.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+
+	vport.x = vport.y = 0;
+	vport.width = vksc_extent.width;
+	vport.height = vksc_extent.height;
+	vport.minDepth = 0.0f;
+	vport.maxDepth = 1.0f;
+
+	scissor.offset.x = scissor.offset.y = 0;
+	scissor.extent = vksc_extent;
+
+	memset(&vp, 0, sizeof vp);
+	vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+	vp.viewportCount = 1;
+	vp.pViewports = &vport;
+	vp.scissorCount = 1;
+	vp.pScissors = &scissor;
+
+	memset(&rast, 0, sizeof rast);
+	rast.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+	rast.polygonMode = VK_POLYGON_MODE_FILL;
+	rast.lineWidth = 1.0f;
+	rast.cullMode = VK_CULL_MODE_BACK_BIT;
+	rast.frontFace = VK_FRONT_FACE_CLOCKWISE;
+
+	memset(&msaa, 0, sizeof msaa);
+	msaa.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+	msaa.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+	msaa.minSampleShading = 1.0f;
+
+	memset(&bat, 0, sizeof bat);
+	bat.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+		VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+
+	memset(&blend, 0, sizeof blend);
+	blend.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+	blend.attachmentCount = 1;
+	blend.pAttachments = &bat;
+
+
+	memset(&lay, 0, sizeof lay);
+	lay.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+
+	if(vkCreatePipelineLayout(vkdev, &lay, 0, &vkpipe_layout) != 0) {
+		fprintf(stderr, "failed to create a pipeline layout\n");
+		return -1;
+	}
+
+	memset(&pinf, 0, sizeof pinf);
+	pinf.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+	pinf.stageCount = 2;
+	pinf.pStages = ssinf;
+	pinf.pVertexInputState = &vinp;
+	pinf.pInputAssemblyState = &vasm;
+	pinf.pViewportState = &vp;
+	pinf.pRasterizationState = &rast;
+	pinf.pMultisampleState = &msaa;
+	pinf.pColorBlendState = &blend;
+	pinf.layout = vkpipe_layout;
+	pinf.renderPass = vkrpass;
+	pinf.basePipelineIndex = -1;
+
+	if(vkCreateGraphicsPipelines(vkdev, 0, 1, &pinf, 0, &vkpipe) != 0) {
+		fprintf(stderr, "failed to create graphics pipeline\n");
+		return -1;
+	}
+
+	for(i=0; i<2; i++) {
+		vkDestroyShaderModule(vkdev, sdr[i], 0);
+	}
+	return 0;
+}
+
+int create_framebuf(void)
+{
+	int i;
+	VkFramebufferCreateInfo fbinf;
+
+	if(!(vksc_fb = malloc(vksc_numimg * sizeof *vksc_fb))) {
+		fprintf(stderr, "failed to allocate array for swap chain framebuffers\n");
+		return -1;
+	}
+
+	for(i=0; i<vksc_numimg; i++) {
+		memset(&fbinf, 0, sizeof fbinf);
+		fbinf.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+		fbinf.renderPass = vkrpass;
+		fbinf.attachmentCount = 1;
+		fbinf.pAttachments = vksc_view + i;
+		fbinf.width = vksc_extent.width;
+		fbinf.height = vksc_extent.height;
+		fbinf.layers = 1;
+
+		if(vkCreateFramebuffer(vkdev, &fbinf, 0, vksc_fb + i) != 0) {
+			fprintf(stderr, "failed to create framebuffer\n");
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int create_cmdpool(void)
+{
+	VkCommandPoolCreateInfo cpinf;
+
+	memset(&cpinf, 0, sizeof cpinf);
+	cpinf.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+	cpinf.queueFamilyIndex = vkqfam_idx;
+
+	if(vkCreateCommandPool(vkdev, &cpinf, 0, &vkcmdpool) != 0) {
+		fprintf(stderr, "failed to create command pool\n");
+		return -1;
+	}
+	return 0;
+}
+
+int create_cmdbuf(void)
+{
+	int i;
+	VkCommandBufferAllocateInfo cbinf;
+
+	if(!(vksc_cmdbuf = malloc(vksc_numimg * sizeof *vksc_cmdbuf))) {
+		fprintf(stderr, "failed to allocate array of command buffers\n");
+		return -1;
+	}
+
+	memset(&cbinf, 0, sizeof cbinf);
+	cbinf.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+	cbinf.commandPool = vkcmdpool;
+	cbinf.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+	cbinf.commandBufferCount = vksc_numimg;
+
+	if(vkAllocateCommandBuffers(vkdev, &cbinf, vksc_cmdbuf) != 0) {
+		fprintf(stderr, "failed to allocate command buffers\n");
+		return -1;
+	}
+
+	/* pre-record command buffers, because why the fuck not */
+	for(i=0; i<vksc_numimg; i++) {
+		VkCommandBufferBeginInfo cbegin;
+		VkRenderPassBeginInfo rbegin;
+		VkClearValue clear;
+
+		memset(&cbegin, 0, sizeof cbegin);
+		cbegin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+		cbegin.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+
+		if(vkBeginCommandBuffer(vksc_cmdbuf[i], &cbegin) != 0) {
+			fprintf(stderr, "failed to begin command buffer recording\n");
+			return -1;
+		}
+
+		clear.color.float32[0] = 0.2f;
+		clear.color.float32[1] = 0.2f;
+		clear.color.float32[2] = 0.2f;
+		clear.color.float32[3] = 1.0f;
+
+		memset(&rbegin, 0, sizeof rbegin);
+		rbegin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+		rbegin.renderPass = vkrpass;
+		rbegin.framebuffer = vksc_fb[i];
+		rbegin.renderArea.extent = vksc_extent;
+		rbegin.clearValueCount = 1;
+		rbegin.pClearValues = &clear;
+
+		vkCmdBeginRenderPass(vksc_cmdbuf[i], &rbegin, VK_SUBPASS_CONTENTS_INLINE);
+		vkCmdBindPipeline(vksc_cmdbuf[i], VK_PIPELINE_BIND_POINT_GRAPHICS, vkpipe);
+		vkCmdDraw(vksc_cmdbuf[i], 3, 1, 0, 0);
+		vkCmdEndRenderPass(vksc_cmdbuf[i]);
+
+		if(vkEndCommandBuffer(vksc_cmdbuf[i]) != 0) {
+			fprintf(stderr, "failed to record command buffer\n");
+			return -1;
+		}
+	}
+	return 0;
+}
+
+int create_semaphores(void)
+{
+	VkSemaphoreCreateInfo sinf;
+
+	memset(&sinf, 0, sizeof sinf);
+	sinf.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+
+	if(vkCreateSemaphore(vkdev, &sinf, 0, &sem_gotimg) != 0) {
+		fprintf(stderr, "failed to create semaphore\n");
+		return -1;
+	}
+	if(vkCreateSemaphore(vkdev, &sinf, 0, &sem_drawdone) != 0) {
+		fprintf(stderr, "failed to create semaphore\n");
+		return -1;
+	}
+	return 0;
+}
+
+VkShaderModule load_shader(const char *fname)
+{
+	FILE *fp;
+	long sz;
+	void *buf;
+	VkShaderModuleCreateInfo sinf;
+	VkShaderModule sdr;
+
+	if(!(fp = fopen(fname, "rb"))) {
+		fprintf(stderr, "failed to open shader: %s: %s\n", fname, strerror(errno));
+		return 0;
+	}
+	fseek(fp, 0, SEEK_END);
+	sz = ftell(fp);
+	fseek(fp, 0, SEEK_SET);
+
+	buf = alloca(sz);
+	if(fread(buf, 1, sz, fp) < sz) {
+		fprintf(stderr, "unexpected EOF while reading shader: %s\n", fname);
+		fclose(fp);
+		return 0;
+	}
+	fclose(fp);
+
+	memset(&sinf, 0, sizeof sinf);
+	sinf.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+	sinf.codeSize = sz;
+	sinf.pCode = buf;
+
+	if(vkCreateShaderModule(vkdev, &sinf, 0, &sdr) != 0) {
+		fprintf(stderr, "failed to create shader from %s\n", fname);
+		return 0;
+	}
+	return sdr;
+}
diff -r 000000000000 -r 8de4fe926882 vertex.glsl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vertex.glsl	Thu Jun 28 13:57:28 2018 +0300
@@ -0,0 +1,26 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+out gl_PerVertex {
+	vec4 gl_Position;
+};
+
+layout(location = 0) out vec3 color;
+
+vec2 vpos[3] = vec2[](
+	vec2(0.0, -0.5),
+	vec2(0.5, 0.5),
+	vec2(-0.5, 0.5)
+);
+
+vec3 vcol[3] = vec3[](
+	vec3(1.0, 0.0, 0.0),
+	vec3(0.0, 1.0, 0.0),
+	vec3(0.0, 0.0, 1.0)
+);
+
+void main()
+{
+	gl_Position = vec4(vpos[gl_VertexIndex], 0.0, 1.0);
+	color = vcol[gl_VertexIndex];
+}