From 4a124d75a373129e96fb3ecb32171a051ae1b4ba Mon Sep 17 00:00:00 2001
From: saschawillems <webmaster@saschawillems.de>
Date: Wed, 11 May 2016 20:39:22 +0200
Subject: [PATCH] Triangle example code cleanup, use VK_CHECK_RESULT macro
 instead of asserts, added more comments

---
 data/shaders/triangle.frag.spv | Bin 572 -> 572 bytes
 data/shaders/triangle.vert     |   6 ++
 data/shaders/triangle.vert.spv | Bin 1780 -> 1444 bytes
 triangle/triangle.cpp          | 180 ++++++++++++++++-----------------
 4 files changed, 92 insertions(+), 94 deletions(-)

diff --git a/data/shaders/triangle.frag.spv b/data/shaders/triangle.frag.spv
index 6c9ae8d45894788cbada5e4085457cabc10f79e6..06ab7a2fc2398c7fe17c45bb65069587bc9af78c 100644
GIT binary patch
delta 28
gcmdnPvWI0th#)5e0|O5b3otM<umEZHjj7ie0Y`ZRmjD0&

delta 28
gcmdnPvWI0th#(IG0|O@z3otM<umEX}jj7ie0Y{1im;e9(

diff --git a/data/shaders/triangle.vert b/data/shaders/triangle.vert
index 946ae30c..56602c5a 100644
--- a/data/shaders/triangle.vert
+++ b/data/shaders/triangle.vert
@@ -15,6 +15,12 @@ layout (binding = 0) uniform UBO
 
 layout (location = 0) out vec3 outColor;
 
+out gl_PerVertex 
+{
+    vec4 gl_Position;   
+};
+
+
 void main() 
 {
 	outColor = inColor;
diff --git a/data/shaders/triangle.vert.spv b/data/shaders/triangle.vert.spv
index cd135f5657b8fac4310a6c4db74c80931033fe07..ccd02c2b9d2b300083894ef7b6bd74640055185f 100644
GIT binary patch
literal 1444
zcmZ9L+fEZv6o$7gtyL66<lqT=@QfkEpfNEXz>9KGBWmDwGSEpKEi=t@s$TL6`ba*N
zHzxkyo>`{2o5f!Lzs_qm)k^2Ab7%BxxJRxy3$7yU+^nnnyW9KN+ZgBljjbn}c+9z~
zcf@Djo%8yP{vL;M0)Uy7T#~dURsAZue<@%_)^0D@{;(5_qfwZJc@&I4h5aZC(!<Zu
zQ9eHHBU79Vf?=2pCgC6owjOVe!lN&)rcBc{YhtLIPVzVDFwLZTANq)sf~skrIpM)D
z*o(4*D9fYo_|;1u9a}n%^EgcuU-dJ<qhHazzw=Js4X?wGvXrjn{x;0B_+LJJ+0Sv>
zkA|g*I`Hh`YaD&E2y!orn;fRTXLc4RYD0I|Z_K$h=^QXKfyuwC2xj8IbGph0N1a{y
zQ<GDZ;BUC&+0&dJgP+;rs4*P}ChoPwa>4x{NA2l2FmWdmi-WT`dbZs#Bl~DeIEGsV
z^cb7%WKolntEC*gO!Q@Gb=^(Lit<qhjJ+w`D0TSfCFcE@{k(LW3p<$o!jbQyZu0R4
z*A&IR;mAF&n>=vDg85&7TM}N--IS1Py~LNLb5?~Hb(5>eU3@P%6KX68GbcNv2AG|}
zVP7eAVywosk~3^?$mVOyZap#EZHaRyugLdM8vWDPQ+-+L&>si>w-~<n3$g6<f`om&
zl$E`Lx8*@!s}g!;X8h^#ss!GAu1m*<p3UcmboigjL(EMHaqt#*OFD7PW^qmF@D|sS
zPHa<R{dS}?|9j<T_B#?dj&XOT!?7dd?v)(-*wf_f=e~q^{IRpgAIgjEfrR?_&@+2o
Sm+(H=2m1o!_eYhUN&W&0wPOPS

literal 1780
zcmZ9LYflqV5QdM17QBIoTvWssyrYN&jfwHXB`G8rQKDZrOWD-bWw+UG)%c0Opg+l9
z<rfp*XLqL-4;jw9@64RJZHFq0BhH=D->6%4#hGvwVdu`eT7EZo_ji}O+2Qiq;}tx{
z+)(a_&$zre!;&LEjL~mOU{6aXB?LW^4C$|;`<DWTWo_<y>+d$aZqV^lKMTC>NB=NL
zz2x9i(8{_eePjybwio$vyXUt9Z*6s@<F`J$s$Lq*T@^##q?c_bQIbl{eW)jl3#zKV
zCWPCOw-=-zf;0=h;a4kpbZkjC%)%rVJCgg;Z_bBtwjX{E@G~2I$+j7VovpB&`Ee`g
z+n5%%UKI6hRn3CgaL{LTzu$PHn9*E^@1zNnPzkU7EDifL;!7<@$zc$cCTfSLjxS;G
z)gpNNvbf$slFxzNgt1!F&8*msYAc4Yvn8gM?@HWGT=XH<xn{mG=jNqzz|0g(E!&D@
zrkvu7_{U*~8}y@2IA&w9=y2?_DGTr6w=IU=I8_P$h8J`8B&QGBUC8~4IPwn0fr)!1
zvA5v<k0bYB9GJLciN(QL95vexm=AMbkZ=q)3YcSdF*r|lLI32$pWh6)CYjVE$kk8|
z=7c^i4O?9@BY)}uW3LO3mOA{i67$<I`x)uhH+C@j;CS!6Zr)=bQ~E!qyDs4@m3Uk_
z{&T|29DlfZY3$G5z=lxQMcveZoxEUv3vlGQq`NNRUGjjZB%E2{Y2Ca_UGwF)0B1su
zSz%_xKF9%PA8^>OlsYk%<66lXZU|F@&4zthP4szN;@t5|-g_X8`l$>2P&dBRPCS_X
z+IwL33x1*=sEd9$yz^TO-@$XS?C+d}-Mo;M9fH^8K_6Eo^u~<vr>8jyy!r5*;X{w+
zb6q<8PrXA-T|ykZ#VtrDt|76wMd|PscSCwz0&n%+lFq!|>TPCqM*_z&?yht=W?<aC
sl4Blw>YRBlNr=ZEJ9Gb`cd^}<kRKmvW)I5}z9;6vyukSVQKqMozde40TL1t6

diff --git a/triangle/triangle.cpp b/triangle/triangle.cpp
index f137667b..1fce48e9 100644
--- a/triangle/triangle.cpp
+++ b/triangle/triangle.cpp
@@ -133,16 +133,16 @@ public:
 		renderPassBeginInfo.clearValueCount = 2;
 		renderPassBeginInfo.pClearValues = clearValues;
 
-		VkResult err;
-		
+	
 		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
 		{
 			// Set target frame buffer
 			renderPassBeginInfo.framebuffer = frameBuffers[i];
 
-			err = vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo);
-			assert(!err);
+			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
 
+			// Start the first sub pass specified in our default render pass setup by the base class
+			// This will clear the color and depth attachment
 			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
 
 			// Update dynamic viewport state
@@ -204,17 +204,14 @@ public:
 				0, nullptr,
 				1, &prePresentBarrier);
 
-			err = vkEndCommandBuffer(drawCmdBuffers[i]);
-			assert(!err);
+			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
 		}
 	}
 
 	void draw()
 	{
-		VkResult err;
 		// Get next image in the swap chain (back/front buffer)
-		err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
-		assert(!err);
+		VK_CHECK_RESULT(swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer));
 
 		// Add a post present image memory barrier
 		// This will transform the frame buffer color attachment back
@@ -236,8 +233,7 @@ public:
 		VkCommandBufferBeginInfo cmdBufInfo = {};
 		cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 
-		err = vkBeginCommandBuffer(postPresentCmdBuffer, &cmdBufInfo);
-		assert(!err);
+		VK_CHECK_RESULT(vkBeginCommandBuffer(postPresentCmdBuffer, &cmdBufInfo));
 
 		// Put post present barrier into command buffer
 		vkCmdPipelineBarrier(
@@ -249,19 +245,19 @@ public:
 			0, nullptr,
 			1, &postPresentBarrier);
 
-		err = vkEndCommandBuffer(postPresentCmdBuffer);
-		assert(!err);
+		VK_CHECK_RESULT(vkEndCommandBuffer(postPresentCmdBuffer));
 
-		// Submit to the queue
+		// Submit the image barrier to the current queue
 		submitInfo = {};
 		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 		submitInfo.commandBufferCount = 1;
 		submitInfo.pCommandBuffers = &postPresentCmdBuffer;
 
-		err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
-		assert(!err);
-		err = vkQueueWaitIdle(queue);
-		assert(!err);
+		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
+		
+		// Make sure that the image barrier command submitted to the queue 
+		// has finished executing
+		VK_CHECK_RESULT(vkQueueWaitIdle(queue));
 
 		// The submit infor strcuture contains a list of
 		// command buffers and semaphores to be submitted to a queue
@@ -284,15 +280,13 @@ public:
 		submitInfo.pSignalSemaphores = &semaphores.renderComplete;
 
 		// Submit to the graphics queue
-		err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
-		assert(!err);
+		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
 
 		// Present the current buffer to the swap chain
 		// We pass the signal semaphore from the submit info
 		// to ensure that the image is not rendered until
 		// all commands have been submitted
-		err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
-		assert(!err);
+		VK_CHECK_RESULT(swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete));
 	}
 
 	// Create synchronzation semaphores
@@ -304,13 +298,11 @@ public:
 
 		// This semaphore ensures that the image is complete
 		// before starting to submit again
-		VkResult err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.presentComplete);
-		assert(!err);
+		VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.presentComplete));
 
 		// This semaphore ensures that all commands submitted
 		// have been finished before submitting the image to the queue
-		err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.renderComplete);
-		assert(!err);
+		VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.renderComplete));
 	}
 
 	// Setups vertex and index buffers for an indexed triangle,
@@ -352,6 +344,8 @@ public:
 			// - Copy the data to this buffer
 			// - Create another buffer that's local on the device (VRAM) with the same size
 			// - Copy the data from the host to the device using a command buffer
+			// - Delete the host visible (staging) buffer
+			// - Use the device local buffers for rendering
 
 			struct StagingBuffer {
 				VkDeviceMemory memory;
@@ -371,7 +365,7 @@ public:
 			cmdBufInfo.commandBufferCount = 1;
 
 			VkCommandBuffer copyCommandBuffer;
-			vkTools::checkResult(vkAllocateCommandBuffers(device, &cmdBufInfo, &copyCommandBuffer));
+			VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufInfo, &copyCommandBuffer));
 
 			// Vertex buffer
 			VkBufferCreateInfo vertexBufferInfo = {};
@@ -380,52 +374,51 @@ public:
 			// Buffer is used as the copy source
 			vertexBufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 			// Create a host-visible buffer to copy the vertex data to (staging buffer)
-			vkTools::checkResult(vkCreateBuffer(device, &vertexBufferInfo, nullptr, &stagingBuffers.vertices.buffer));
+			VK_CHECK_RESULT(vkCreateBuffer(device, &vertexBufferInfo, nullptr, &stagingBuffers.vertices.buffer));
 			vkGetBufferMemoryRequirements(device, stagingBuffers.vertices.buffer, &memReqs);
 			memAlloc.allocationSize = memReqs.size;
-			getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAlloc.memoryTypeIndex);
-			vkTools::checkResult(vkAllocateMemory(device, &memAlloc, nullptr, &stagingBuffers.vertices.memory));
+			memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+			VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &stagingBuffers.vertices.memory));
 			// Map and copy
-			vkTools::checkResult(vkMapMemory(device, stagingBuffers.vertices.memory, 0, memAlloc.allocationSize, 0, &data));
+			VK_CHECK_RESULT(vkMapMemory(device, stagingBuffers.vertices.memory, 0, memAlloc.allocationSize, 0, &data));
 			memcpy(data, vertexBuffer.data(), vertexBufferSize);
 			vkUnmapMemory(device, stagingBuffers.vertices.memory);
-			vkTools::checkResult(vkBindBufferMemory(device, stagingBuffers.vertices.buffer, stagingBuffers.vertices.memory, 0));
+			VK_CHECK_RESULT(vkBindBufferMemory(device, stagingBuffers.vertices.buffer, stagingBuffers.vertices.memory, 0));
 
 			// Create the destination buffer with device only visibility
 			// Buffer will be used as a vertex buffer and is the copy destination
 			vertexBufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-			vkTools::checkResult(vkCreateBuffer(device, &vertexBufferInfo, nullptr, &vertices.buf));
+			VK_CHECK_RESULT(vkCreateBuffer(device, &vertexBufferInfo, nullptr, &vertices.buf));
 			vkGetBufferMemoryRequirements(device, vertices.buf, &memReqs);
 			memAlloc.allocationSize = memReqs.size;
-			getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAlloc.memoryTypeIndex);
-			vkTools::checkResult(vkAllocateMemory(device, &memAlloc, nullptr, &vertices.mem));
-			vkTools::checkResult(vkBindBufferMemory(device, vertices.buf, vertices.mem, 0));
+			memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+			VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &vertices.mem));
+			VK_CHECK_RESULT(vkBindBufferMemory(device, vertices.buf, vertices.mem, 0));
 
 			// Index buffer
-			// todo : comment
 			VkBufferCreateInfo indexbufferInfo = {};
 			indexbufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 			indexbufferInfo.size = indexBufferSize;
 			indexbufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 			// Copy index data to a buffer visible to the host (staging buffer)
-			vkTools::checkResult(vkCreateBuffer(device, &indexbufferInfo, nullptr, &stagingBuffers.indices.buffer));
+			VK_CHECK_RESULT(vkCreateBuffer(device, &indexbufferInfo, nullptr, &stagingBuffers.indices.buffer));
 			vkGetBufferMemoryRequirements(device, stagingBuffers.indices.buffer, &memReqs);
 			memAlloc.allocationSize = memReqs.size;
-			getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAlloc.memoryTypeIndex);
-			vkTools::checkResult(vkAllocateMemory(device, &memAlloc, nullptr, &stagingBuffers.indices.memory));
-			vkTools::checkResult(vkMapMemory(device, stagingBuffers.indices.memory, 0, indexBufferSize, 0, &data));
+			memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+			VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &stagingBuffers.indices.memory));
+			VK_CHECK_RESULT(vkMapMemory(device, stagingBuffers.indices.memory, 0, indexBufferSize, 0, &data));
 			memcpy(data, indexBuffer.data(), indexBufferSize);
 			vkUnmapMemory(device, stagingBuffers.indices.memory);
-			vkTools::checkResult(vkBindBufferMemory(device, stagingBuffers.indices.buffer, stagingBuffers.indices.memory, 0));
+			VK_CHECK_RESULT(vkBindBufferMemory(device, stagingBuffers.indices.buffer, stagingBuffers.indices.memory, 0));
 
 			// Create destination buffer with device only visibility
 			indexbufferInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-			vkTools::checkResult(vkCreateBuffer(device, &indexbufferInfo, nullptr, &indices.buf));
+			VK_CHECK_RESULT(vkCreateBuffer(device, &indexbufferInfo, nullptr, &indices.buf));
 			vkGetBufferMemoryRequirements(device, indices.buf, &memReqs);
 			memAlloc.allocationSize = memReqs.size;
-			getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAlloc.memoryTypeIndex);
-			vkTools::checkResult(vkAllocateMemory(device, &memAlloc, nullptr, &indices.mem));
-			vkTools::checkResult(vkBindBufferMemory(device, indices.buf, indices.mem, 0));
+			memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+			VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &indices.mem));
+			VK_CHECK_RESULT(vkBindBufferMemory(device, indices.buf, indices.mem, 0));
 			indices.count = indexBuffer.size();
 
 			VkCommandBufferBeginInfo cmdBufferBeginInfo = {};
@@ -437,7 +430,7 @@ public:
 			// Put buffer region copies into command buffer
 			// Note that the staging buffer must not be deleted before the copies 
 			// have been submitted and executed
-			vkTools::checkResult(vkBeginCommandBuffer(copyCommandBuffer, &cmdBufferBeginInfo));
+			VK_CHECK_RESULT(vkBeginCommandBuffer(copyCommandBuffer, &cmdBufferBeginInfo));
 
 			// Vertex buffer
 			copyRegion.size = vertexBufferSize;
@@ -456,7 +449,7 @@ public:
 				1,
 				&copyRegion);
 
-			vkTools::checkResult(vkEndCommandBuffer(copyCommandBuffer));
+			VK_CHECK_RESULT(vkEndCommandBuffer(copyCommandBuffer));
 
 			// Submit copies to the queue
 			VkSubmitInfo copySubmitInfo = {};
@@ -464,8 +457,8 @@ public:
 			copySubmitInfo.commandBufferCount = 1;
 			copySubmitInfo.pCommandBuffers = &copyCommandBuffer;
 
-			vkTools::checkResult(vkQueueSubmit(queue, 1, &copySubmitInfo, VK_NULL_HANDLE));
-			vkTools::checkResult(vkQueueWaitIdle(queue));
+			VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &copySubmitInfo, VK_NULL_HANDLE));
+			VK_CHECK_RESULT(vkQueueWaitIdle(queue));
 
 			vkFreeCommandBuffers(device, cmdPool, 1, &copyCommandBuffer);
 
@@ -480,7 +473,8 @@ public:
 			// Don't use staging
 			// Create host-visible buffers only and use these for rendering
 			// This is not advised for real world applications and will
-			// result in lower performances
+			// result in lower performances at least on devices that
+			// separate between host visible and device local memory
 
 			// Vertex buffer
 			VkBufferCreateInfo vertexBufferInfo = {};
@@ -489,15 +483,15 @@ public:
 			vertexBufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
 
 			// Copy vertex data to a buffer visible to the host
-			vkTools::checkResult(vkCreateBuffer(device, &vertexBufferInfo, nullptr, &vertices.buf));
+			VK_CHECK_RESULT(vkCreateBuffer(device, &vertexBufferInfo, nullptr, &vertices.buf));
 			vkGetBufferMemoryRequirements(device, vertices.buf, &memReqs);
 			memAlloc.allocationSize = memReqs.size;
-			getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAlloc.memoryTypeIndex);
-			vkTools::checkResult(vkAllocateMemory(device, &memAlloc, nullptr, &vertices.mem));
-			vkTools::checkResult(vkMapMemory(device, vertices.mem, 0, memAlloc.allocationSize, 0, &data));
+			memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+			VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &vertices.mem));
+			VK_CHECK_RESULT(vkMapMemory(device, vertices.mem, 0, memAlloc.allocationSize, 0, &data));
 			memcpy(data, vertexBuffer.data(), vertexBufferSize);
 			vkUnmapMemory(device, vertices.mem);
-			vkTools::checkResult(vkBindBufferMemory(device, vertices.buf, vertices.mem, 0));
+			VK_CHECK_RESULT(vkBindBufferMemory(device, vertices.buf, vertices.mem, 0));
 
 			// Index buffer
 			VkBufferCreateInfo indexbufferInfo = {};
@@ -507,15 +501,15 @@ public:
 
 			// Copy index data to a buffer visible to the host
 			memset(&indices, 0, sizeof(indices));
-			vkTools::checkResult(vkCreateBuffer(device, &indexbufferInfo, nullptr, &indices.buf));
+			VK_CHECK_RESULT(vkCreateBuffer(device, &indexbufferInfo, nullptr, &indices.buf));
 			vkGetBufferMemoryRequirements(device, indices.buf, &memReqs);
 			memAlloc.allocationSize = memReqs.size;
-			getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAlloc.memoryTypeIndex);
-			vkTools::checkResult(vkAllocateMemory(device, &memAlloc, nullptr, &indices.mem));
-			vkTools::checkResult(vkMapMemory(device, indices.mem, 0, indexBufferSize, 0, &data));
+			memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+			VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &indices.mem));
+			VK_CHECK_RESULT(vkMapMemory(device, indices.mem, 0, indexBufferSize, 0, &data));
 			memcpy(data, indexBuffer.data(), indexBufferSize);
 			vkUnmapMemory(device, indices.mem);
-			vkTools::checkResult(vkBindBufferMemory(device, indices.buf, indices.mem, 0));
+			VK_CHECK_RESULT(vkBindBufferMemory(device, indices.buf, indices.mem, 0));
 			indices.count = indexBuffer.size();
 		}
 
@@ -539,7 +533,7 @@ public:
 		vertices.attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
 		vertices.attributeDescriptions[1].offset = sizeof(float) * 3;
 
-		// Assign to vertex buffer
+		// Assign to vertex input state
 		vertices.inputState.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 		vertices.inputState.pNext = NULL;
 		vertices.inputState.flags = VK_FLAGS_NONE;
@@ -573,8 +567,7 @@ public:
 		// Requesting descriptors beyond maxSets will result in an error
 		descriptorPoolInfo.maxSets = 1;
 
-		VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);
-		assert(!vkRes);
+		VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
 	}
 
 	void setupDescriptorSetLayout()
@@ -598,8 +591,7 @@ public:
 		descriptorLayout.bindingCount = 1;
 		descriptorLayout.pBindings = &layoutBinding;
 
-		VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, NULL, &descriptorSetLayout);
-		assert(!err);
+		VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, NULL, &descriptorSetLayout));
 
 		// Create the pipeline layout that is used to generate the rendering pipelines that
 		// are based on this descriptor set layout
@@ -611,25 +603,25 @@ public:
 		pPipelineLayoutCreateInfo.setLayoutCount = 1;
 		pPipelineLayoutCreateInfo.pSetLayouts = &descriptorSetLayout;
 
-		err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout);
-		assert(!err);
+		VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
 	}
 
 	void setupDescriptorSet()
 	{
-		// Update descriptor sets determining the shader binding points
-		// For every binding point used in a shader there needs to be one
-		// descriptor set matching that binding point
-		VkWriteDescriptorSet writeDescriptorSet = {};
-
+		// Allocate a new descriptor set from the global descriptor pool
 		VkDescriptorSetAllocateInfo allocInfo = {};
 		allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
 		allocInfo.descriptorPool = descriptorPool;
 		allocInfo.descriptorSetCount = 1;
 		allocInfo.pSetLayouts = &descriptorSetLayout;
 
-		VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet);
-		assert(!vkRes);
+		VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
+
+		// Update the descriptor set determining the shader binding points
+		// For every binding point used in a shader there needs to be one
+		// descriptor set matching that binding point
+
+		VkWriteDescriptorSet writeDescriptorSet = {};
 
 		// Binding 0 : Uniform buffer
 		writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
@@ -661,8 +653,6 @@ public:
 
 		VkGraphicsPipelineCreateInfo pipelineCreateInfo = {};
 
-		VkResult err;
-
 		pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
 		// The layout used for this pipeline
 		pipelineCreateInfo.layout = pipelineLayout;
@@ -767,13 +757,14 @@ public:
 		pipelineCreateInfo.pDynamicState = &dynamicState;
 
 		// Create rendering pipeline
-		err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solid);
-		assert(!err);
+		VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solid));
 	}
 
 	void prepareUniformBuffers()
 	{
-		// Prepare and initialize uniform buffer containing shader uniforms
+		// Prepare and initialize a uniform buffer block containing shader uniforms
+		// In Vulkan there are no more single uniforms like in GL
+		// All shader uniforms are passed as uniform buffer blocks 
 		VkMemoryRequirements memReqs;
 
 		// Vertex shader uniform buffer block
@@ -783,27 +774,24 @@ public:
 		allocInfo.pNext = NULL;
 		allocInfo.allocationSize = 0;
 		allocInfo.memoryTypeIndex = 0;
-		VkResult err;
 
 		bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 		bufferInfo.size = sizeof(uboVS);
 		bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 
 		// Create a new buffer
-		err = vkCreateBuffer(device, &bufferInfo, nullptr, &uniformDataVS.buffer);
-		assert(!err);
+		VK_CHECK_RESULT(vkCreateBuffer(device, &bufferInfo, nullptr, &uniformDataVS.buffer));
 		// Get memory requirements including size, alignment and memory type 
 		vkGetBufferMemoryRequirements(device, uniformDataVS.buffer, &memReqs);
 		allocInfo.allocationSize = memReqs.size;
-		// Gets the appropriate memory type for this type of buffer allocation
-		// Only memory types that are visible to the host
-		getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &allocInfo.memoryTypeIndex);
+		// Get the memory type index that supports host visibile memory access
+		// Most implementations offer multiple memory tpyes and selecting the 
+		// correct one to allocate memory from is important
+		allocInfo.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
 		// Allocate memory for the uniform buffer
-		err = vkAllocateMemory(device, &allocInfo, nullptr, &(uniformDataVS.memory));
-		assert(!err);
+		VK_CHECK_RESULT(vkAllocateMemory(device, &allocInfo, nullptr, &(uniformDataVS.memory)));
 		// Bind memory to buffer
-		err = vkBindBufferMemory(device, uniformDataVS.buffer, uniformDataVS.memory, 0);
-		assert(!err);
+		VK_CHECK_RESULT(vkBindBufferMemory(device, uniformDataVS.buffer, uniformDataVS.memory, 0));
 		
 		// Store information in the uniform's descriptor
 		uniformDataVS.descriptor.buffer = uniformDataVS.buffer;
@@ -826,12 +814,12 @@ public:
 		uboVS.modelMatrix = glm::rotate(uboVS.modelMatrix, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
 
 		// Map uniform buffer and update it
+		// If you want to keep a handle to the memory and not unmap it afer updating, 
+		// create the memory with the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT 
 		uint8_t *pData;
-		VkResult err = vkMapMemory(device, uniformDataVS.memory, 0, sizeof(uboVS), 0, (void **)&pData);
-		assert(!err);
+		VK_CHECK_RESULT(vkMapMemory(device, uniformDataVS.memory, 0, sizeof(uboVS), 0, (void **)&pData));
 		memcpy(pData, &uboVS, sizeof(uboVS));
 		vkUnmapMemory(device, uniformDataVS.memory);
-		assert(!err);
 	}
 
 	void prepare()
@@ -852,13 +840,17 @@ public:
 	{
 		if (!prepared)
 			return;
-		vkDeviceWaitIdle(device);
 		draw();
 		vkDeviceWaitIdle(device);
 	}
 
 	virtual void viewChanged()
 	{
+		// Before updating the uniform buffer we want to make
+		// sure that the device has finished all operations
+		// In a real-world application you would use synchronization
+		// objects for this
+		vkDeviceWaitIdle(device);
 		// This function is called by the base example class 
 		// each time the view is changed by user input
 		updateUniformBuffers();