Move serialiser to locally cached variable per-function invocation

2026-08-26 16:36:31 +00:00 · 2016-02-07 18:42:18 +01:00
parent b1cf7d98db
commit 8b595f5f43
16 changed files with 719 additions and 459 deletions
@@ -74,7 +74,7 @@ struct VkGenericStruct
 	const VkGenericStruct *pNext;
 };

-#define IMPLEMENT_FUNCTION_SERIALISED(ret, func) ret func; bool CONCAT(Serialise_, func);
+#define IMPLEMENT_FUNCTION_SERIALISED(ret, func, ...) ret func(__VA_ARGS__); bool CONCAT(Serialise_, func(Serialiser *localSerialiser, __VA_ARGS__));

 template<> void Serialiser::Serialise(const char *name, VkRect2D &el);
 template<> void Serialiser::Serialise(const char *name, VkRect3D &el);
@@ -154,6 +154,8 @@ VkInitParams::VkInitParams()

 ReplayCreateStatus VkInitParams::Serialise()
 {
+	Serialiser *localSerialiser = GetSerialiser();
+
 	SERIALISE_ELEMENT(uint32_t, ver, VK_SERIALISE_VERSION); SerialiseVersion = ver;

 	if(ver != VK_SERIALISE_VERSION)
@@ -162,16 +164,16 @@ ReplayCreateStatus VkInitParams::Serialise()
 		return eReplayCreate_APIIncompatibleVersion;
 	}

-	GetSerialiser()->Serialise("AppName", AppName);
-	GetSerialiser()->Serialise("EngineName", EngineName);
-	GetSerialiser()->Serialise("AppVersion", AppVersion);
-	GetSerialiser()->Serialise("EngineVersion", EngineVersion);
-	GetSerialiser()->Serialise("APIVersion", APIVersion);
+	localSerialiser->Serialise("AppName", AppName);
+	localSerialiser->Serialise("EngineName", EngineName);
+	localSerialiser->Serialise("AppVersion", AppVersion);
+	localSerialiser->Serialise("EngineVersion", EngineVersion);
+	localSerialiser->Serialise("APIVersion", APIVersion);

-	GetSerialiser()->Serialise("Layers", Layers);
-	GetSerialiser()->Serialise("Extensions", Extensions);
+	localSerialiser->Serialise("Layers", Layers);
+	localSerialiser->Serialise("Extensions", Extensions);

-	GetSerialiser()->Serialise("InstanceID", InstanceID);
+	localSerialiser->Serialise("InstanceID", InstanceID);

 	return eReplayCreate_Success;
 }
@@ -408,6 +410,11 @@ const char * WrappedVulkan::GetChunkName(uint32_t idx)
 	return VkChunkNames[idx-FIRST_CHUNK_ID];
 }

+Serialiser *WrappedVulkan::GetThreadSerialiser()
+{
+	return m_pSerialiser;
+}
+
 void WrappedVulkan::Serialise_CaptureScope(uint64_t offset)
 {
 	uint32_t FrameNumber = m_FrameCounter;
@@ -432,6 +439,8 @@ void WrappedVulkan::Serialise_CaptureScope(uint64_t offset)

 void WrappedVulkan::EndCaptureFrame(VkImage presentImage)
 {
+	Serialiser *localSerialiser = GetMainSerialiser();
+
 	SCOPED_SERIALISE_CONTEXT(CONTEXT_CAPTURE_FOOTER);
 	
 	SERIALISE_ELEMENT(ResourceId, bbid, GetResID(presentImage));
@@ -529,6 +538,8 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState)
 	
 void WrappedVulkan::BeginCaptureFrame()
 {
+	CACHE_THREAD_SERIALISER();
+
 	SCOPED_SERIALISE_CONTEXT(CONTEXT_CAPTURE_HEADER);

 	Serialise_BeginCaptureFrame(false);
@@ -839,265 +850,265 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context)
 			break;
 		}
 	case ENUM_PHYSICALS:
-		Serialise_vkEnumeratePhysicalDevices(NULL, NULL, NULL);
+		Serialise_vkEnumeratePhysicalDevices(GetMainSerialiser(), NULL, NULL, NULL);
 		break;
 	case CREATE_DEVICE:
-		Serialise_vkCreateDevice(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateDevice(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case GET_DEVICE_QUEUE:
-		Serialise_vkGetDeviceQueue(VK_NULL_HANDLE, 0, 0, NULL);
+		Serialise_vkGetDeviceQueue(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, NULL);
 		break;

 	case ALLOC_MEM:
-		Serialise_vkAllocMemory(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkAllocMemory(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case UNMAP_MEM:
-		Serialise_vkUnmapMemory(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkUnmapMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case FLUSH_MEM:
-		Serialise_vkFlushMappedMemoryRanges(VK_NULL_HANDLE, 0, NULL);
+		Serialise_vkFlushMappedMemoryRanges(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL);
 		break;
 	case FREE_MEM:
 		// VKTODOMED see vkFreeMemory
-		//Serialise_vkFreeMemory(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		//Serialise_vkFreeMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		//break;
 	case CREATE_CMD_POOL:
-		Serialise_vkCreateCommandPool(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateCommandPool(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_CMD_BUFFER:
 		RDCERR("vkCreateCommandBuffer should not be serialised directly");
 		break;
 	case CREATE_FRAMEBUFFER:
-		Serialise_vkCreateFramebuffer(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateFramebuffer(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_RENDERPASS:
-		Serialise_vkCreateRenderPass(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateRenderPass(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_DESCRIPTOR_POOL:
-		Serialise_vkCreateDescriptorPool(VK_NULL_HANDLE, VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM, 0, NULL, NULL);
+		Serialise_vkCreateDescriptorPool(GetMainSerialiser(), VK_NULL_HANDLE, VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM, 0, NULL, NULL);
 		break;
 	case CREATE_DESCRIPTOR_SET_LAYOUT:
-		Serialise_vkCreateDescriptorSetLayout(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateDescriptorSetLayout(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_BUFFER:
-		Serialise_vkCreateBuffer(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateBuffer(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_BUFFER_VIEW:
-		Serialise_vkCreateBufferView(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateBufferView(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_IMAGE:
-		Serialise_vkCreateImage(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateImage(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_IMAGE_VIEW:
-		Serialise_vkCreateImageView(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateImageView(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_ATTACHMENT_VIEW:
-		Serialise_vkCreateAttachmentView(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateAttachmentView(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_VIEWPORT_STATE:
-		Serialise_vkCreateDynamicViewportState(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateDynamicViewportState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_RASTER_STATE:
-		Serialise_vkCreateDynamicRasterState(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateDynamicRasterState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_BLEND_STATE:
-		Serialise_vkCreateDynamicColorBlendState(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateDynamicColorBlendState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_DEPTH_STATE:
-		Serialise_vkCreateDynamicDepthStencilState(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateDynamicDepthStencilState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_SAMPLER:
-		Serialise_vkCreateSampler(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateSampler(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_SHADER:
-		Serialise_vkCreateShader(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateShader(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_SHADER_MODULE:
-		Serialise_vkCreateShaderModule(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateShaderModule(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_PIPE_LAYOUT:
-		Serialise_vkCreatePipelineLayout(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreatePipelineLayout(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_PIPE_CACHE:
-		Serialise_vkCreatePipelineCache(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreatePipelineCache(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_GRAPHICS_PIPE:
-		Serialise_vkCreateGraphicsPipelines(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL);
+		Serialise_vkCreateGraphicsPipelines(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL);
 		break;
 	case CREATE_COMPUTE_PIPE:
 		//VKTODOMED:
-		//Serialise_vkCreateComputePipelines(VK_NULL_HANDLE, NULL, NULL);
+		//Serialise_vkCreateComputePipelines(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case PRESENT_IMAGE:
-		Serialise_vkGetSwapChainInfoWSI(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_SWAP_CHAIN_INFO_TYPE_MAX_ENUM_WSI, NULL, NULL);
+		Serialise_vkGetSwapChainInfoWSI(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_SWAP_CHAIN_INFO_TYPE_MAX_ENUM_WSI, NULL, NULL);
 		break;

 	case CREATE_SEMAPHORE:
-		Serialise_vkCreateSemaphore(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateSemaphore(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case CREATE_FENCE:
-		Serialise_vkCreateFence(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateFence(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;
 	case GET_FENCE_STATUS:
-		Serialise_vkGetFenceStatus(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkGetFenceStatus(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case WAIT_FENCES:
 		//VKTODOMED:
-		//Serialise_vkWaitForFences(VK_NULL_HANDLE, 0, NULL, VK_FALSE, 0.0f);
+		//Serialise_vkWaitForFences(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL, VK_FALSE, 0.0f);
 		break;

 	case CREATE_QUERY_POOL:
-		Serialise_vkCreateQueryPool(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateQueryPool(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;

 	case ALLOC_DESC_SET:
-		Serialise_vkAllocDescriptorSets(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_DESCRIPTOR_SET_USAGE_MAX_ENUM, 0, NULL, NULL, NULL);
+		Serialise_vkAllocDescriptorSets(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_DESCRIPTOR_SET_USAGE_MAX_ENUM, 0, NULL, NULL, NULL);
 		break;
 	case UPDATE_DESC_SET:
-		Serialise_vkUpdateDescriptorSets(VK_NULL_HANDLE, 0, NULL, 0, NULL);
+		Serialise_vkUpdateDescriptorSets(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL, 0, NULL);
 		break;

 	case RESET_CMD_BUFFER:
-		Serialise_vkResetCommandBuffer(VK_NULL_HANDLE, 0);
+		Serialise_vkResetCommandBuffer(GetMainSerialiser(), VK_NULL_HANDLE, 0);
 		break;
 	case BEGIN_CMD_BUFFER:
-		Serialise_vkBeginCommandBuffer(VK_NULL_HANDLE, NULL);
+		Serialise_vkBeginCommandBuffer(GetMainSerialiser(), VK_NULL_HANDLE, NULL);
 		break;
 	case END_CMD_BUFFER:
-		Serialise_vkEndCommandBuffer(VK_NULL_HANDLE);
+		Serialise_vkEndCommandBuffer(GetMainSerialiser(), VK_NULL_HANDLE);
 		break;

 	case QUEUE_SIGNAL_SEMAPHORE:
-		Serialise_vkQueueSignalSemaphore(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkQueueSignalSemaphore(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case QUEUE_WAIT_SEMAPHORE:
-		Serialise_vkQueueWaitSemaphore(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkQueueWaitSemaphore(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case QUEUE_WAIT_IDLE:
-		Serialise_vkQueueWaitIdle(VK_NULL_HANDLE);
+		Serialise_vkQueueWaitIdle(GetMainSerialiser(), VK_NULL_HANDLE);
 		break;
 	case DEVICE_WAIT_IDLE:
-		Serialise_vkDeviceWaitIdle(VK_NULL_HANDLE);
+		Serialise_vkDeviceWaitIdle(GetMainSerialiser(), VK_NULL_HANDLE);
 		break;

 	case QUEUE_SUBMIT:
-		Serialise_vkQueueSubmit(VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE);
+		Serialise_vkQueueSubmit(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE);
 		break;
 	case BIND_BUFFER_MEM:
-		Serialise_vkBindBufferMemory(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
+		Serialise_vkBindBufferMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
 		break;
 	case BIND_IMAGE_MEM:
-		Serialise_vkBindImageMemory(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
+		Serialise_vkBindImageMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
 		break;

 	case BEGIN_RENDERPASS:
-		Serialise_vkCmdBeginRenderPass(VK_NULL_HANDLE, NULL, VK_RENDER_PASS_CONTENTS_MAX_ENUM);
+		Serialise_vkCmdBeginRenderPass(GetMainSerialiser(), VK_NULL_HANDLE, NULL, VK_RENDER_PASS_CONTENTS_MAX_ENUM);
 		break;
 	case END_RENDERPASS:
-		Serialise_vkCmdEndRenderPass(VK_NULL_HANDLE);
+		Serialise_vkCmdEndRenderPass(GetMainSerialiser(), VK_NULL_HANDLE);
 		break;

 	case BIND_PIPELINE:
-		Serialise_vkCmdBindPipeline(VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE);
+		Serialise_vkCmdBindPipeline(GetMainSerialiser(), VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE);
 		break;
 	case BIND_VP_STATE:
-		Serialise_vkCmdBindDynamicViewportState(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkCmdBindDynamicViewportState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case BIND_RS_STATE:
-		Serialise_vkCmdBindDynamicRasterState(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkCmdBindDynamicRasterState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case BIND_CB_STATE:
-		Serialise_vkCmdBindDynamicColorBlendState(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkCmdBindDynamicColorBlendState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case BIND_DS_STATE:
-		Serialise_vkCmdBindDynamicDepthStencilState(VK_NULL_HANDLE, VK_NULL_HANDLE);
+		Serialise_vkCmdBindDynamicDepthStencilState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE);
 		break;
 	case BIND_DESCRIPTOR_SET:
-		Serialise_vkCmdBindDescriptorSets(VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE, 0, 0, NULL, 0, NULL);
+		Serialise_vkCmdBindDescriptorSets(GetMainSerialiser(), VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE, 0, 0, NULL, 0, NULL);
 		break;
 	case BIND_INDEX_BUFFER:
-		Serialise_vkCmdBindIndexBuffer(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, VK_INDEX_TYPE_MAX_ENUM);
+		Serialise_vkCmdBindIndexBuffer(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, VK_INDEX_TYPE_MAX_ENUM);
 		break;
 	case BIND_VERTEX_BUFFERS:
-		Serialise_vkCmdBindVertexBuffers(VK_NULL_HANDLE, 0, 0, NULL, NULL);
+		Serialise_vkCmdBindVertexBuffers(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, NULL, NULL);
 		break;
 	case COPY_BUF2IMG:
-		Serialise_vkCmdCopyBufferToImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL);
+		Serialise_vkCmdCopyBufferToImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL);
 		break;
 	case COPY_IMG2BUF:
-		Serialise_vkCmdCopyImageToBuffer(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, 0, NULL);
+		Serialise_vkCmdCopyImageToBuffer(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, 0, NULL);
 		break;
 	case COPY_IMG:
-		Serialise_vkCmdCopyImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL);
+		Serialise_vkCmdCopyImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL);
 		break;
 	case BLIT_IMG:
-		Serialise_vkCmdBlitImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL, VK_TEX_FILTER_MAX_ENUM);
+		Serialise_vkCmdBlitImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL, VK_TEX_FILTER_MAX_ENUM);
 		break;
 	case RESOLVE_IMG:
-		Serialise_vkCmdResolveImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL);
+		Serialise_vkCmdResolveImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL);
 		break;
 	case COPY_BUF:
-		Serialise_vkCmdCopyBuffer(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL);
+		Serialise_vkCmdCopyBuffer(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL);
 		break;
 	case CLEAR_COLOR:
-		Serialise_vkCmdClearColorImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL);
+		Serialise_vkCmdClearColorImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL);
 		break;
 	case CLEAR_DEPTHSTENCIL:
-		Serialise_vkCmdClearDepthStencilImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL);
+		Serialise_vkCmdClearDepthStencilImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL);
 		break;
 	case CLEAR_COLOR_ATTACH:
-		Serialise_vkCmdClearColorAttachment(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL);
+		Serialise_vkCmdClearColorAttachment(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL);
 		break;
 	case CLEAR_DEPTHSTENCIL_ATTACH:
-		Serialise_vkCmdClearDepthStencilAttachment(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL);
+		Serialise_vkCmdClearDepthStencilAttachment(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL);
 		break;
 	case PIPELINE_BARRIER:
-		Serialise_vkCmdPipelineBarrier(VK_NULL_HANDLE, 0, 0, VK_FALSE, 0, NULL);
+		Serialise_vkCmdPipelineBarrier(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, VK_FALSE, 0, NULL);
 		break;
 	case WRITE_TIMESTAMP:
 		//VKTODOMED:
-		//Serialise_vkCmdWriteTimestamp(VK_NULL_HANDLE, VK_TIMESTAMP_TYPE_MAX_ENUM, VK_NULL_HANDLE, 0);
+		//Serialise_vkCmdWriteTimestamp(GetMainSerialiser(), VK_NULL_HANDLE, VK_TIMESTAMP_TYPE_MAX_ENUM, VK_NULL_HANDLE, 0);
 		break;
 	case BEGIN_QUERY:
-		Serialise_vkCmdBeginQuery(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
+		Serialise_vkCmdBeginQuery(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
 		break;
 	case END_QUERY:
-		Serialise_vkCmdEndQuery(VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
+		Serialise_vkCmdEndQuery(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
 		break;
 	case RESET_QUERY_POOL:
-		Serialise_vkCmdResetQueryPool(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
+		Serialise_vkCmdResetQueryPool(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
 		break;
 	case DRAW:
-		Serialise_vkCmdDraw(VK_NULL_HANDLE, 0, 0, 0, 0);
+		Serialise_vkCmdDraw(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, 0, 0);
 		break;
 	case DRAW_INDIRECT:
-		Serialise_vkCmdDrawIndirect(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
+		Serialise_vkCmdDrawIndirect(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
 		break;
 	case DRAW_INDEXED:
-		Serialise_vkCmdDrawIndexed(VK_NULL_HANDLE, 0, 0, 0, 0, 0);
+		Serialise_vkCmdDrawIndexed(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, 0, 0, 0);
 		break;
 	case DRAW_INDEXED_INDIRECT:
-		Serialise_vkCmdDrawIndexedIndirect(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
+		Serialise_vkCmdDrawIndexedIndirect(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
 		break;
 	case DISPATCH:
-		Serialise_vkCmdDispatch(VK_NULL_HANDLE, 0, 0, 0);
+		Serialise_vkCmdDispatch(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, 0);
 		break;
 	case DISPATCH_INDIRECT:
-		Serialise_vkCmdDispatchIndirect(VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
+		Serialise_vkCmdDispatchIndirect(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0);
 		break;

 	case BEGIN_EVENT:
-		Serialise_vkCmdDbgMarkerBegin(VK_NULL_HANDLE, NULL);
+		Serialise_vkCmdDbgMarkerBegin(GetMainSerialiser(), VK_NULL_HANDLE, NULL);
 		break;
 	case SET_MARKER:
 		RDCFATAL("No such function vkCmdDbgMarker");
 		break;
 	case END_EVENT:
-		Serialise_vkCmdDbgMarkerEnd(VK_NULL_HANDLE);
+		Serialise_vkCmdDbgMarkerEnd(GetMainSerialiser(), VK_NULL_HANDLE);
 		break;

 	case CREATE_SWAP_BUFFER:
-		Serialise_vkCreateSwapChainWSI(VK_NULL_HANDLE, NULL, NULL);
+		Serialise_vkCreateSwapChainWSI(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL);
 		break;

 	case CAPTURE_SCOPE:
@@ -1105,6 +1116,8 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context)
 		break;
 	case CONTEXT_CAPTURE_FOOTER:
 		{
+			Serialiser *localSerialiser = GetMainSerialiser();
+
 			SERIALISE_ELEMENT(ResourceId, bbid, ResourceId());

 			ResourceId liveBBid = GetResourceManager()->GetLiveID(bbid);
@@ -156,6 +156,9 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res)

 bool WrappedVulkan::Serialise_InitialState(WrappedVkRes *res)
 {
+	// use same serialiser as resource manager
+	Serialiser *localSerialiser = GetMainSerialiser();
+
 	SERIALISE_ELEMENT(VkResourceType, type, IdentifyTypeByPtr(res));
 	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(res));

@@ -207,6 +207,8 @@ void VulkanResourceManager::RecordTransitions(vector< pair<ResourceId, ImageRegi

 void VulkanResourceManager::SerialiseImageStates(map<ResourceId, ImgState> &states, vector<VkImageMemoryBarrier> &transitions)
 {
+	Serialiser *localSerialiser = m_pSerialiser;
+
 	SERIALISE_ELEMENT(uint32_t, NumMems, (uint32_t)states.size());

 	auto srcit = states.begin();
@@ -451,17 +451,17 @@ ResourceId VulkanReplay::GetLiveID(ResourceId id)

 void VulkanReplay::InitCallstackResolver()
 {
-	m_pDriver->GetSerialiser()->InitCallstackResolver();
+	m_pDriver->GetMainSerialiser()->InitCallstackResolver();
 }

 bool VulkanReplay::HasCallstacks()
 {
-	return m_pDriver->GetSerialiser()->HasCallstacks();
+	return m_pDriver->GetMainSerialiser()->HasCallstacks();
 }

 Callstack::StackResolver *VulkanReplay::GetCallstackResolver()
 {
-	return m_pDriver->GetSerialiser()->GetCallstackResolver();
+	return m_pDriver->GetMainSerialiser()->GetCallstackResolver();
 }

 vector<FetchFrameRecord> VulkanReplay::GetFrameRecord()
@@ -27,6 +27,7 @@
 // Command pool functions

 bool WrappedVulkan::Serialise_vkCreateCommandPool(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkCmdPoolCreateInfo*                  pCreateInfo,
 			VkCmdPool*                                  pCmdPool)
@@ -70,10 +71,12 @@ VkResult WrappedVulkan::vkCreateCommandPool(
 		if(m_State >= WRITING)
 		{
 			Chunk *chunk = NULL;
-
+			
 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_CMD_POOL);
-				Serialise_vkCreateCommandPool(device, pCreateInfo, pCmdPool);
+				Serialise_vkCreateCommandPool(localSerialiser, device, pCreateInfo, pCmdPool);

 				chunk = scope.Get();
 			}
@@ -139,6 +142,7 @@ VkResult WrappedVulkan::vkCreateCommandBuffer(
 }

 bool WrappedVulkan::Serialise_vkBeginCommandBuffer(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			const VkCmdBufferBeginInfo*                 pBeginInfo)
 {
@@ -173,7 +177,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer(
 	}
 	
 	SERIALISE_ELEMENT(ResourceId, devId, GetResID(device));
-	GetSerialiser()->Serialise("createInfo", createInfo);
+	localSerialiser->Serialise("createInfo", createInfo);

 	if(m_State < WRITING)
 		device = GetResourceManager()->GetLiveHandle<VkDevice>(devId);
@@ -281,8 +285,10 @@ VkResult WrappedVulkan::vkBeginCommandBuffer(
 		record->bakedCommands = GetResourceManager()->AddResourceRecord(ResourceIDGen::GetNewUniqueID());

 		{
+			CACHE_THREAD_SERIALISER();
+
 			SCOPED_SERIALISE_CONTEXT(BEGIN_CMD_BUFFER);
-			Serialise_vkBeginCommandBuffer(cmdBuffer, pBeginInfo);
+			Serialise_vkBeginCommandBuffer(localSerialiser, cmdBuffer, pBeginInfo);
 			
 			record->AddChunk(scope.Get());
 		}
@@ -295,7 +301,7 @@ VkResult WrappedVulkan::vkBeginCommandBuffer(
 	return ObjDisp(cmdBuffer)->BeginCommandBuffer(Unwrap(cmdBuffer), &unwrappedInfo);
 }

-bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
+bool WrappedVulkan::Serialise_vkEndCommandBuffer(Serialiser* localSerialiser, VkCmdBuffer cmdBuffer)
 {
 	SERIALISE_ELEMENT(ResourceId, cmdId, GetResID(cmdBuffer));

@@ -389,8 +395,10 @@ VkResult WrappedVulkan::vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
 		RDCASSERT(record->bakedCommands);

 		{
+			CACHE_THREAD_SERIALISER();
+
 			SCOPED_SERIALISE_CONTEXT(END_CMD_BUFFER);
-			Serialise_vkEndCommandBuffer(cmdBuffer);
+			Serialise_vkEndCommandBuffer(localSerialiser, cmdBuffer);
 			
 			record->AddChunk(scope.Get());
 		}
@@ -401,7 +409,7 @@ VkResult WrappedVulkan::vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
 	return ObjDisp(cmdBuffer)->EndCommandBuffer(Unwrap(cmdBuffer));
 }

-bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
+bool WrappedVulkan::Serialise_vkResetCommandBuffer(Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
 {
 	SERIALISE_ELEMENT(ResourceId, cmdId, GetResID(cmdBuffer));
 	SERIALISE_ELEMENT(VkCmdBufferResetFlags, fl, flags);
@@ -428,7 +436,7 @@ bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdB
 	}
 	
 	SERIALISE_ELEMENT(ResourceId, devId, GetResID(device));
-	GetSerialiser()->Serialise("createInfo", info);
+	localSerialiser->Serialise("createInfo", info);

 	if(m_State == EXECUTING)
 	{
@@ -488,8 +496,10 @@ VkResult WrappedVulkan::vkResetCommandBuffer(
 		// serialising this (as we never re-begin a cmd buffer, we make a new copy
 		// for each bake).
 		{
+			CACHE_THREAD_SERIALISER();
+
 			SCOPED_SERIALISE_CONTEXT(RESET_CMD_BUFFER);
-			Serialise_vkResetCommandBuffer(cmdBuffer, flags);
+			Serialise_vkResetCommandBuffer(localSerialiser, cmdBuffer, flags);
 			
 			record->AddChunk(scope.Get());
 		}
@@ -501,6 +511,7 @@ VkResult WrappedVulkan::vkResetCommandBuffer(
 // Command buffer building functions

 bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			const VkRenderPassBeginInfo*                pRenderPassBegin,
 			VkRenderPassContents                        contents)
@@ -532,7 +543,7 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass(

 		ObjDisp(cmdBuffer)->CmdBeginRenderPass(Unwrap(cmdBuffer), &beginInfo, cont);

-		const string desc = GetSerialiser()->GetDebugStr();
+		const string desc = localSerialiser->GetDebugStr();

 		// VKTODOMED change the name to show render pass load-op
 		AddEvent(BEGIN_RENDERPASS, desc);
@@ -560,8 +571,10 @@ void WrappedVulkan::vkCmdBeginRenderPass(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BEGIN_RENDERPASS);
-		Serialise_vkCmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+		Serialise_vkCmdBeginRenderPass(localSerialiser, cmdBuffer, pRenderPassBegin, contents);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(pRenderPassBegin->renderPass), eFrameRef_Read);
@@ -571,6 +584,7 @@ void WrappedVulkan::vkCmdBeginRenderPass(
 }

 bool WrappedVulkan::Serialise_vkCmdEndRenderPass(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer)
 {
 	SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer));
@@ -611,14 +625,17 @@ void WrappedVulkan::vkCmdEndRenderPass(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(END_RENDERPASS);
-		Serialise_vkCmdEndRenderPass(cmdBuffer);
+		Serialise_vkCmdEndRenderPass(localSerialiser, cmdBuffer);

 		record->AddChunk(scope.Get());
 	}
 }

 bool WrappedVulkan::Serialise_vkCmdBindPipeline(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkPipelineBindPoint                         pipelineBindPoint,
 			VkPipeline                                  pipeline)
@@ -672,8 +689,10 @@ void WrappedVulkan::vkCmdBindPipeline(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_PIPELINE);
-		Serialise_vkCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+		Serialise_vkCmdBindPipeline(localSerialiser, cmdBuffer, pipelineBindPoint, pipeline);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(pipeline), eFrameRef_Read);
@@ -681,6 +700,7 @@ void WrappedVulkan::vkCmdBindPipeline(
 }

 bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkPipelineBindPoint                         pipelineBindPoint,
 			VkPipelineLayout                            layout,
@@ -709,7 +729,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets(
 	for(uint32_t i=0; i < numSets; i++)
 	{
 		if(m_State >= WRITING) descriptorIDs[i] = GetResID(sets[i]);
-		GetSerialiser()->Serialise("DescriptorSet", descriptorIDs[i]);
+		localSerialiser->Serialise("DescriptorSet", descriptorIDs[i]);
 		if(m_State < WRITING)  sets[i] = Unwrap(GetResourceManager()->GetLiveHandle<VkDescriptorSet>(descriptorIDs[i]));
 	}

@@ -813,8 +833,10 @@ void WrappedVulkan::vkCmdBindDescriptorSets(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_DESCRIPTOR_SET);
-		Serialise_vkCmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+		Serialise_vkCmdBindDescriptorSets(localSerialiser, cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(layout), eFrameRef_Read);
@@ -823,6 +845,7 @@ void WrappedVulkan::vkCmdBindDescriptorSets(
 }

 bool WrappedVulkan::Serialise_vkCmdBindDynamicViewportState(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkDynamicViewportState                      dynamicViewportState)
 {
@@ -865,8 +888,10 @@ void WrappedVulkan::vkCmdBindDynamicViewportState(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_VP_STATE);
-		Serialise_vkCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState);
+		Serialise_vkCmdBindDynamicViewportState(localSerialiser, cmdBuffer, dynamicViewportState);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(dynamicViewportState), eFrameRef_Read);
@@ -874,6 +899,7 @@ void WrappedVulkan::vkCmdBindDynamicViewportState(
 }

 bool WrappedVulkan::Serialise_vkCmdBindDynamicRasterState(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkDynamicRasterState                        dynamicRasterState)
 {
@@ -916,8 +942,10 @@ void WrappedVulkan::vkCmdBindDynamicRasterState(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_RS_STATE);
-		Serialise_vkCmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
+		Serialise_vkCmdBindDynamicRasterState(localSerialiser, cmdBuffer, dynamicRasterState);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(dynamicRasterState), eFrameRef_Read);
@@ -925,6 +953,7 @@ void WrappedVulkan::vkCmdBindDynamicRasterState(
 }

 bool WrappedVulkan::Serialise_vkCmdBindDynamicColorBlendState(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkDynamicColorBlendState                    dynamicColorBlendState)
 {
@@ -966,8 +995,10 @@ void WrappedVulkan::vkCmdBindDynamicColorBlendState(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_CB_STATE);
-		Serialise_vkCmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState);
+		Serialise_vkCmdBindDynamicColorBlendState(localSerialiser, cmdBuffer, dynamicColorBlendState);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(dynamicColorBlendState), eFrameRef_Read);
@@ -975,6 +1006,7 @@ void WrappedVulkan::vkCmdBindDynamicColorBlendState(
 }

 bool WrappedVulkan::Serialise_vkCmdBindDynamicDepthStencilState(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkDynamicDepthStencilState                  dynamicDepthStencilState)
 {
@@ -1016,8 +1048,10 @@ void WrappedVulkan::vkCmdBindDynamicDepthStencilState(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_DS_STATE);
-		Serialise_vkCmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState);
+		Serialise_vkCmdBindDynamicDepthStencilState(localSerialiser, cmdBuffer, dynamicDepthStencilState);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(dynamicDepthStencilState), eFrameRef_Read);
@@ -1025,6 +1059,7 @@ void WrappedVulkan::vkCmdBindDynamicDepthStencilState(
 }

 bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(
+		Serialiser*                                 localSerialiser,
    VkCmdBuffer                                 cmdBuffer,
    uint32_t                                    startBinding,
    uint32_t                                    bindingCount,
@@ -1052,8 +1087,8 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers(
 			o = pOffsets[i];
 		}

-		GetSerialiser()->Serialise("pBuffers[]", id);
-		GetSerialiser()->Serialise("pOffsets[]", o);
+		localSerialiser->Serialise("pBuffers[]", id);
+		localSerialiser->Serialise("pOffsets[]", o);

 		if(m_State < WRITING)
 		{
@@ -1111,8 +1146,10 @@ void WrappedVulkan::vkCmdBindVertexBuffers(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_VERTEX_BUFFERS);
-		Serialise_vkCmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+		Serialise_vkCmdBindVertexBuffers(localSerialiser, cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);

 		record->AddChunk(scope.Get());
 		for(uint32_t i=0; i < bindingCount; i++)
@@ -1122,6 +1159,7 @@ void WrappedVulkan::vkCmdBindVertexBuffers(


 bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer(
+		Serialiser*                                 localSerialiser,
    VkCmdBuffer                                 cmdBuffer,
    VkBuffer                                    buffer,
    VkDeviceSize                                offset,
@@ -1175,8 +1213,10 @@ void WrappedVulkan::vkCmdBindIndexBuffer(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BIND_INDEX_BUFFER);
-		Serialise_vkCmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+		Serialise_vkCmdBindIndexBuffer(localSerialiser, cmdBuffer, buffer, offset, indexType);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(buffer), eFrameRef_Read);
@@ -1184,6 +1224,7 @@ void WrappedVulkan::vkCmdBindIndexBuffer(
 }

 bool WrappedVulkan::Serialise_vkCmdPipelineBarrier(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkPipelineStageFlags                        srcStageMask,
 			VkPipelineStageFlags                        destStageMask,
@@ -1316,8 +1357,10 @@ void WrappedVulkan::vkCmdPipelineBarrier(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(PIPELINE_BARRIER);
-		Serialise_vkCmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
+		Serialise_vkCmdPipelineBarrier(localSerialiser, cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);

 		record->AddChunk(scope.Get());

@@ -1340,6 +1383,7 @@ void WrappedVulkan::vkCmdPipelineBarrier(
 }

 bool WrappedVulkan::Serialise_vkCmdBeginQuery(
+		Serialiser*                                 localSerialiser,
    VkCmdBuffer                                 cmdBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    slot,
@@ -1386,8 +1430,10 @@ void WrappedVulkan::vkCmdBeginQuery(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BEGIN_QUERY);
-		Serialise_vkCmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+		Serialise_vkCmdBeginQuery(localSerialiser, cmdBuffer, queryPool, slot, flags);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read);
@@ -1395,6 +1441,7 @@ void WrappedVulkan::vkCmdBeginQuery(
 }

 bool WrappedVulkan::Serialise_vkCmdEndQuery(
+		Serialiser*                                 localSerialiser,
    VkCmdBuffer                                 cmdBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    slot)
@@ -1438,8 +1485,10 @@ void WrappedVulkan::vkCmdEndQuery(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(END_QUERY);
-		Serialise_vkCmdEndQuery(cmdBuffer, queryPool, slot);
+		Serialise_vkCmdEndQuery(localSerialiser, cmdBuffer, queryPool, slot);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read);
@@ -1447,6 +1496,7 @@ void WrappedVulkan::vkCmdEndQuery(
 }

 bool WrappedVulkan::Serialise_vkCmdResetQueryPool(
+		Serialiser*                                 localSerialiser,
    VkCmdBuffer                                 cmdBuffer,
    VkQueryPool                                 queryPool,
    uint32_t                                    startQuery,
@@ -1493,8 +1543,10 @@ void WrappedVulkan::vkCmdResetQueryPool(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(RESET_QUERY_POOL);
-		Serialise_vkCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+		Serialise_vkCmdResetQueryPool(localSerialiser, cmdBuffer, queryPool, startQuery, queryCount);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read);
@@ -1502,6 +1554,7 @@ void WrappedVulkan::vkCmdResetQueryPool(
 }

 bool WrappedVulkan::Serialise_vkCmdDbgMarkerBegin(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer  cmdBuffer,
 			const char*     pMarker)
 {
@@ -1531,14 +1584,16 @@ void WrappedVulkan::vkCmdDbgMarkerBegin(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(BEGIN_EVENT);
-		Serialise_vkCmdDbgMarkerBegin(cmdBuffer, pMarker);
+		Serialise_vkCmdDbgMarkerBegin(localSerialiser, cmdBuffer, pMarker);

 		record->AddChunk(scope.Get());
 	}
 }

-bool WrappedVulkan::Serialise_vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
+bool WrappedVulkan::Serialise_vkCmdDbgMarkerEnd(Serialiser* localSerialiser, VkCmdBuffer cmdBuffer)
 {
 	SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer));
 	
@@ -1564,8 +1619,10 @@ void WrappedVulkan::vkCmdDbgMarkerEnd(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(END_EVENT);
-		Serialise_vkCmdDbgMarkerEnd(cmdBuffer);
+		Serialise_vkCmdDbgMarkerEnd(localSerialiser, cmdBuffer);

 		record->AddChunk(scope.Get());
 	}
@@ -25,6 +25,7 @@
 #include "../vk_core.h"

 bool WrappedVulkan::Serialise_vkCreateDescriptorPool(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			VkDescriptorPoolUsage                       poolUsage,
 			uint32_t                                    maxSets,
@@ -77,8 +78,10 @@ VkResult WrappedVulkan::vkCreateDescriptorPool(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_DESCRIPTOR_POOL);
-				Serialise_vkCreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+				Serialise_vkCreateDescriptorPool(localSerialiser, device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);

 				chunk = scope.Get();
 			}
@@ -96,6 +99,7 @@ VkResult WrappedVulkan::vkCreateDescriptorPool(
 }

 bool WrappedVulkan::Serialise_vkCreateDescriptorSetLayout(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
 		VkDescriptorSetLayout*                      pSetLayout)
@@ -168,8 +172,10 @@ VkResult WrappedVulkan::vkCreateDescriptorSetLayout(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_DESCRIPTOR_SET_LAYOUT);
-				Serialise_vkCreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+				Serialise_vkCreateDescriptorSetLayout(localSerialiser, device, pCreateInfo, pSetLayout);

 				chunk = scope.Get();
 			}
@@ -186,6 +192,7 @@ VkResult WrappedVulkan::vkCreateDescriptorSetLayout(
 	return ret;
 }
 bool WrappedVulkan::Serialise_vkAllocDescriptorSets(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		VkDescriptorPool                            descriptorPool,
 		VkDescriptorSetUsage                        setUsage,
@@ -261,8 +268,10 @@ VkResult WrappedVulkan::vkAllocDescriptorSets(
 				Chunk *chunk = NULL;

 				{
+					CACHE_THREAD_SERIALISER();
+
 					SCOPED_SERIALISE_CONTEXT(ALLOC_DESC_SET);
-					Serialise_vkAllocDescriptorSets(device, descriptorPool, setUsage, 1, &pSetLayouts[i], &pDescriptorSets[i], NULL);
+					Serialise_vkAllocDescriptorSets(localSerialiser, device, descriptorPool, setUsage, 1, &pSetLayouts[i], &pDescriptorSets[i], NULL);

 					chunk = scope.Get();
 				}
@@ -317,6 +326,7 @@ VkResult WrappedVulkan::vkFreeDescriptorSets(
 }

 bool WrappedVulkan::Serialise_vkUpdateDescriptorSets(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		uint32_t                                    writeCount,
 		const VkWriteDescriptorSet*                 pDescriptorWrites,
@@ -491,8 +501,10 @@ VkResult WrappedVulkan::vkUpdateDescriptorSets(
 			for(uint32_t i=0; i < writeCount; i++)
 			{
 				{
+					CACHE_THREAD_SERIALISER();
+
 					SCOPED_SERIALISE_CONTEXT(UPDATE_DESC_SET);
-					Serialise_vkUpdateDescriptorSets(device, 1, &pDescriptorWrites[i], 0, NULL);
+					Serialise_vkUpdateDescriptorSets(localSerialiser, device, 1, &pDescriptorWrites[i], 0, NULL);

 					m_FrameCaptureRecord->AddChunk(scope.Get());
 				}
@@ -505,8 +517,10 @@ VkResult WrappedVulkan::vkUpdateDescriptorSets(
 			for(uint32_t i=0; i < copyCount; i++)
 			{
 				{
+					CACHE_THREAD_SERIALISER();
+
 					SCOPED_SERIALISE_CONTEXT(UPDATE_DESC_SET);
-					Serialise_vkUpdateDescriptorSets(device, 0, NULL, 1, &pDescriptorCopies[i]);
+					Serialise_vkUpdateDescriptorSets(localSerialiser, device, 0, NULL, 1, &pDescriptorCopies[i]);

 					m_FrameCaptureRecord->AddChunk(scope.Get());
 				}
@@ -89,6 +89,7 @@ VkResult WrappedVulkan::vkDestroyInstance(
 }

 bool WrappedVulkan::Serialise_vkEnumeratePhysicalDevices(
+		Serialiser*                                 localSerialiser,
 		VkInstance                                  instance,
 		uint32_t*                                   pPhysicalDeviceCount,
 		VkPhysicalDevice*                           pPhysicalDevices)
@@ -175,8 +176,10 @@ VkResult WrappedVulkan::vkEnumeratePhysicalDevices(

 			if(m_State >= WRITING)
 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(ENUM_PHYSICALS);
-				Serialise_vkEnumeratePhysicalDevices(instance, &i, &devices[i]);
+				Serialise_vkEnumeratePhysicalDevices(localSerialiser, instance, &i, &devices[i]);

 				m_InstanceRecord->AddChunk(scope.Get());
 			}
@@ -192,6 +195,7 @@ VkResult WrappedVulkan::vkEnumeratePhysicalDevices(
 }

 bool WrappedVulkan::Serialise_vkCreateDevice(
+		Serialiser*                                 localSerialiser,
 		VkPhysicalDevice                            physicalDevice,
 		const VkDeviceCreateInfo*                   pCreateInfo,
 		VkDevice*                                   pDevice)
@@ -410,8 +414,10 @@ VkResult WrappedVulkan::vkCreateDevice(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_DEVICE);
-				Serialise_vkCreateDevice(physicalDevice, &createInfo, pDevice);
+				Serialise_vkCreateDevice(localSerialiser, physicalDevice, &createInfo, pDevice);

 				chunk = scope.Get();
 			}
@@ -505,7 +511,7 @@ VkResult WrappedVulkan::vkDestroyDevice(VkDevice device)
 	return ret;
 }

-bool WrappedVulkan::Serialise_vkDeviceWaitIdle(VkDevice device)
+bool WrappedVulkan::Serialise_vkDeviceWaitIdle(Serialiser* localSerialiser, VkDevice device)
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetResID(device));
 	
@@ -524,8 +530,10 @@ VkResult WrappedVulkan::vkDeviceWaitIdle(VkDevice device)
 	
 	if(m_State >= WRITING_CAPFRAME)
 	{
+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(DEVICE_WAIT_IDLE);
-		Serialise_vkDeviceWaitIdle(device);
+		Serialise_vkDeviceWaitIdle(localSerialiser, device);

 		m_FrameCaptureRecord->AddChunk(scope.Get());
 	}
@@ -25,6 +25,7 @@
 #include "../vk_core.h"

 bool WrappedVulkan::Serialise_vkCmdDraw(
+	Serialiser*    localSerialiser,
 	VkCmdBuffer cmdBuffer,
 	uint32_t       firstVertex,
 	uint32_t       vertexCount,
@@ -54,7 +55,7 @@ bool WrappedVulkan::Serialise_vkCmdDraw(

 		ObjDisp(cmdBuffer)->CmdDraw(Unwrap(cmdBuffer), firstVtx, vtxCount, firstInst, instCount);

-		const string desc = GetSerialiser()->GetDebugStr();
+		const string desc = localSerialiser->GetDebugStr();

 		{
 			AddEvent(DRAW, desc);
@@ -92,14 +93,17 @@ void WrappedVulkan::vkCmdDraw(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(DRAW);
-		Serialise_vkCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+		Serialise_vkCmdDraw(localSerialiser, cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);

 		record->AddChunk(scope.Get());
 	}
 }

 bool WrappedVulkan::Serialise_vkCmdBlitImage(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkImage                                     srcImage,
 			VkImageLayout                               srcImageLayout,
@@ -164,8 +168,10 @@ void WrappedVulkan::vkCmdBlitImage(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+		
 		SCOPED_SERIALISE_CONTEXT(BLIT_IMG);
-		Serialise_vkCmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+		Serialise_vkCmdBlitImage(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);

 		record->AddChunk(scope.Get());

@@ -181,6 +187,7 @@ void WrappedVulkan::vkCmdBlitImage(
 }

 bool WrappedVulkan::Serialise_vkCmdResolveImage(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkImage                                     srcImage,
 			VkImageLayout                               srcImageLayout,
@@ -241,8 +248,10 @@ void WrappedVulkan::vkCmdResolveImage(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(RESOLVE_IMG);
-		Serialise_vkCmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+		Serialise_vkCmdResolveImage(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);

 		record->AddChunk(scope.Get());

@@ -258,6 +267,7 @@ void WrappedVulkan::vkCmdResolveImage(
 }

 bool WrappedVulkan::Serialise_vkCmdCopyImage(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkImage                                     srcImage,
 			VkImageLayout                               srcImageLayout,
@@ -317,9 +327,11 @@ void WrappedVulkan::vkCmdCopyImage(
 	if(m_State >= WRITING)
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);
+		
+		CACHE_THREAD_SERIALISER();

 		SCOPED_SERIALISE_CONTEXT(COPY_IMG);
-		Serialise_vkCmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+		Serialise_vkCmdCopyImage(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(srcImage), eFrameRef_Read);
@@ -335,6 +347,7 @@ void WrappedVulkan::vkCmdCopyImage(
 }

 bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkBuffer                                    srcBuffer,
 			VkImage                                     destImage,
@@ -371,7 +384,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage(

 		ObjDisp(cmdBuffer)->CmdCopyBufferToImage(Unwrap(cmdBuffer), Unwrap(srcBuffer), Unwrap(destImage), destImageLayout, count, regions);

-		const string desc = GetSerialiser()->GetDebugStr();
+		const string desc = localSerialiser->GetDebugStr();

 		{
 			AddEvent(COPY_BUF2IMG, desc);
@@ -406,8 +419,10 @@ void WrappedVulkan::vkCmdCopyBufferToImage(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(COPY_BUF2IMG);
-		Serialise_vkCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+		Serialise_vkCmdCopyBufferToImage(localSerialiser, cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);

 		record->AddChunk(scope.Get());

@@ -423,6 +438,7 @@ void WrappedVulkan::vkCmdCopyBufferToImage(
 }

 bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer(
+		Serialiser*                                 localSerialiser,
    VkCmdBuffer                                 cmdBuffer,
 		VkImage                                     srcImage,
 		VkImageLayout                               srcImageLayout,
@@ -481,8 +497,10 @@ void WrappedVulkan::vkCmdCopyImageToBuffer(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(COPY_IMG2BUF);
-		Serialise_vkCmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+		Serialise_vkCmdCopyImageToBuffer(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(srcImage), eFrameRef_Read);
@@ -498,6 +516,7 @@ void WrappedVulkan::vkCmdCopyImageToBuffer(
 }

 bool WrappedVulkan::Serialise_vkCmdCopyBuffer(
+		Serialiser*                                 localSerialiser,
    VkCmdBuffer                                 cmdBuffer,
 		VkBuffer                                    srcBuffer,
 		VkBuffer                                    destBuffer,
@@ -533,7 +552,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer(

 		ObjDisp(cmdBuffer)->CmdCopyBuffer(Unwrap(cmdBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), count, regions);

-		const string desc = GetSerialiser()->GetDebugStr();
+		const string desc = localSerialiser->GetDebugStr();

 		{
 			AddEvent(COPY_BUF, desc);
@@ -567,8 +586,10 @@ void WrappedVulkan::vkCmdCopyBuffer(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(COPY_BUF);
-		Serialise_vkCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+		Serialise_vkCmdCopyBuffer(localSerialiser, cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(srcBuffer), eFrameRef_Read);
@@ -584,6 +605,7 @@ void WrappedVulkan::vkCmdCopyBuffer(
 }

 bool WrappedVulkan::Serialise_vkCmdClearColorImage(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkImage                                     image,
 			VkImageLayout                               imageLayout,
@@ -639,8 +661,10 @@ void WrappedVulkan::vkCmdClearColorImage(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR);
-		Serialise_vkCmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+		Serialise_vkCmdClearColorImage(localSerialiser, cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(image), eFrameRef_Write);
@@ -648,6 +672,7 @@ void WrappedVulkan::vkCmdClearColorImage(
 }

 bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkImage                                     image,
 			VkImageLayout                               imageLayout,
@@ -705,8 +730,10 @@ void WrappedVulkan::vkCmdClearDepthStencilImage(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTHSTENCIL);
-		Serialise_vkCmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+		Serialise_vkCmdClearDepthStencilImage(localSerialiser, cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);

 		record->AddChunk(scope.Get());
 		record->MarkResourceFrameReferenced(GetResID(image), eFrameRef_Write);
@@ -714,6 +741,7 @@ void WrappedVulkan::vkCmdClearDepthStencilImage(
 }

 bool WrappedVulkan::Serialise_vkCmdClearColorAttachment(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			uint32_t                                    colorAttachment,
 			VkImageLayout                               imageLayout,
@@ -746,7 +774,7 @@ bool WrappedVulkan::Serialise_vkCmdClearColorAttachment(

 		ObjDisp(cmdBuffer)->CmdClearColorAttachment(Unwrap(cmdBuffer), att, layout, &col, count, rects);

-		const string desc = GetSerialiser()->GetDebugStr();
+		const string desc = localSerialiser->GetDebugStr();

 		{
 			AddEvent(CLEAR_COLOR_ATTACH, desc);
@@ -781,8 +809,10 @@ void WrappedVulkan::vkCmdClearColorAttachment(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR_ATTACH);
-		Serialise_vkCmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);
+		Serialise_vkCmdClearColorAttachment(localSerialiser, cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);

 		record->AddChunk(scope.Get());
 		// VKTODOHIGH mark referenced the image under the attachment
@@ -791,6 +821,7 @@ void WrappedVulkan::vkCmdClearColorAttachment(
 }

 bool WrappedVulkan::Serialise_vkCmdClearDepthStencilAttachment(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkImageAspectFlags                          imageAspectMask,
 			VkImageLayout                               imageLayout,
@@ -824,7 +855,7 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilAttachment(

 		ObjDisp(cmdBuffer)->CmdClearDepthStencilAttachment(Unwrap(cmdBuffer), asp, lay, d, s, count, rects);

-		const string desc = GetSerialiser()->GetDebugStr();
+		const string desc = localSerialiser->GetDebugStr();

 		{
 			AddEvent(CLEAR_DEPTHSTENCIL_ATTACH, desc);
@@ -860,8 +891,10 @@ void WrappedVulkan::vkCmdClearDepthStencilAttachment(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTHSTENCIL_ATTACH);
-		Serialise_vkCmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects);
+		Serialise_vkCmdClearDepthStencilAttachment(localSerialiser, cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects);

 		record->AddChunk(scope.Get());
 		// VKTODOHIGH mark referenced the image under the attachment
@@ -870,6 +903,7 @@ void WrappedVulkan::vkCmdClearDepthStencilAttachment(
 }

 bool WrappedVulkan::Serialise_vkCmdDrawIndexed(
+	Serialiser*    localSerialiser,
 	VkCmdBuffer cmdBuffer,
 	uint32_t       firstIndex,
 	uint32_t       indexCount,
@@ -901,7 +935,7 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexed(

 		ObjDisp(cmdBuffer)->CmdDrawIndexed(Unwrap(cmdBuffer), firstIdx, idxCount, vtxOffs, firstInst, instCount);

-		const string desc = GetSerialiser()->GetDebugStr();
+		const string desc = localSerialiser->GetDebugStr();

 		{
 			AddEvent(DRAW_INDEXED, desc);
@@ -940,14 +974,17 @@ void WrappedVulkan::vkCmdDrawIndexed(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(DRAW_INDEXED);
-		Serialise_vkCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+		Serialise_vkCmdDrawIndexed(localSerialiser, cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);

 		record->AddChunk(scope.Get());
 	}
 }

 bool WrappedVulkan::Serialise_vkCmdDrawIndirect(
+		Serialiser*                                 localSerialiser,
 		VkCmdBuffer                                 cmdBuffer,
 		VkBuffer                                    buffer,
 		VkDeviceSize                                offset,
@@ -998,14 +1035,17 @@ void WrappedVulkan::vkCmdDrawIndirect(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(DRAW_INDIRECT);
-		Serialise_vkCmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+		Serialise_vkCmdDrawIndirect(localSerialiser, cmdBuffer, buffer, offset, count, stride);

 		record->AddChunk(scope.Get());
 	}
 }

 bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect(
+		Serialiser*                                 localSerialiser,
 		VkCmdBuffer                                 cmdBuffer,
 		VkBuffer                                    buffer,
 		VkDeviceSize                                offset,
@@ -1056,14 +1096,17 @@ void WrappedVulkan::vkCmdDrawIndexedIndirect(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(DRAW_INDEXED_INDIRECT);
-		Serialise_vkCmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+		Serialise_vkCmdDrawIndexedIndirect(localSerialiser, cmdBuffer, buffer, offset, count, stride);

 		record->AddChunk(scope.Get());
 	}
 }

 bool WrappedVulkan::Serialise_vkCmdDispatch(
+	Serialiser*    localSerialiser,
 	VkCmdBuffer cmdBuffer,
 	uint32_t       x,
 	uint32_t       y,
@@ -1107,14 +1150,17 @@ void WrappedVulkan::vkCmdDispatch(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(DISPATCH);
-		Serialise_vkCmdDispatch(cmdBuffer, x, y, z);
+		Serialise_vkCmdDispatch(localSerialiser, cmdBuffer, x, y, z);

 		record->AddChunk(scope.Get());
 	}
 }

 bool WrappedVulkan::Serialise_vkCmdDispatchIndirect(
+			Serialiser*                                 localSerialiser,
 			VkCmdBuffer                                 cmdBuffer,
 			VkBuffer                                    buffer,
 			VkDeviceSize                                offset)
@@ -1158,8 +1204,10 @@ void WrappedVulkan::vkCmdDispatchIndirect(
 	{
 		VkResourceRecord *record = GetRecord(cmdBuffer);

+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(DISPATCH_INDIRECT);
-		Serialise_vkCmdDispatchIndirect(cmdBuffer, buffer, offset);
+		Serialise_vkCmdDispatchIndirect(localSerialiser, cmdBuffer, buffer, offset);

 		record->AddChunk(scope.Get());
 	}
@@ -217,6 +217,7 @@ bool WrappedVulkan::ReleaseResource(WrappedVkRes *res)
 // Sampler functions

 bool WrappedVulkan::Serialise_vkCreateSampler(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkSamplerCreateInfo*                  pCreateInfo,
 			VkSampler*                                  pSampler)
@@ -262,8 +263,10 @@ VkResult WrappedVulkan::vkCreateSampler(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_SAMPLER);
-				Serialise_vkCreateSampler(device, pCreateInfo, pSampler);
+				Serialise_vkCreateSampler(localSerialiser, device, pCreateInfo, pSampler);

 				chunk = scope.Get();
 			}
@@ -281,6 +284,7 @@ VkResult WrappedVulkan::vkCreateSampler(
 }

 bool WrappedVulkan::Serialise_vkCreateSemaphore(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkSemaphoreCreateInfo*                pCreateInfo,
 			VkSemaphore*                                pSemaphore)
@@ -326,8 +330,10 @@ VkResult WrappedVulkan::vkCreateSemaphore(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_SEMAPHORE);
-				Serialise_vkCreateSemaphore(device, pCreateInfo, pSemaphore);
+				Serialise_vkCreateSemaphore(localSerialiser, device, pCreateInfo, pSemaphore);

 				chunk = scope.Get();
 			}
@@ -345,6 +351,7 @@ VkResult WrappedVulkan::vkCreateSemaphore(
 }

 bool WrappedVulkan::Serialise_vkCreateFramebuffer(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkFramebufferCreateInfo*              pCreateInfo,
 			VkFramebuffer*                              pFramebuffer)
@@ -378,6 +385,7 @@ bool WrappedVulkan::Serialise_vkCreateFramebuffer(
 }

 bool WrappedVulkan::Serialise_vkCreateFence(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkFenceCreateInfo*                pCreateInfo,
 			VkFence*                                pFence)
@@ -423,8 +431,10 @@ VkResult WrappedVulkan::vkCreateFence(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_FENCE);
-				Serialise_vkCreateFence(device, pCreateInfo, pFence);
+				Serialise_vkCreateFence(localSerialiser, device, pCreateInfo, pFence);

 				chunk = scope.Get();
 			}
@@ -442,6 +452,7 @@ VkResult WrappedVulkan::vkCreateFence(
 }

 bool WrappedVulkan::Serialise_vkGetFenceStatus(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                device,
 			VkFence                                 fence)
 {
@@ -468,8 +479,10 @@ VkResult WrappedVulkan::vkGetFenceStatus(
 	
 	if(m_State >= WRITING_CAPFRAME)
 	{
+		CACHE_THREAD_SERIALISER();
+
 		SCOPED_SERIALISE_CONTEXT(GET_FENCE_STATUS);
-		Serialise_vkGetFenceStatus(device, fence);
+		Serialise_vkGetFenceStatus(localSerialiser, device, fence);

 		m_FrameCaptureRecord->AddChunk(scope.Get());
 	}
@@ -508,8 +521,10 @@ VkResult WrappedVulkan::vkCreateFramebuffer(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_FRAMEBUFFER);
-				Serialise_vkCreateFramebuffer(device, pCreateInfo, pFramebuffer);
+				Serialise_vkCreateFramebuffer(localSerialiser, device, pCreateInfo, pFramebuffer);

 				chunk = scope.Get();
 			}
@@ -534,6 +549,7 @@ VkResult WrappedVulkan::vkCreateFramebuffer(
 }

 bool WrappedVulkan::Serialise_vkCreateRenderPass(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkRenderPassCreateInfo*               pCreateInfo,
 			VkRenderPass*                               pRenderPass)
@@ -582,8 +598,10 @@ VkResult WrappedVulkan::vkCreateRenderPass(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+
 				SCOPED_SERIALISE_CONTEXT(CREATE_RENDERPASS);
-				Serialise_vkCreateRenderPass(device, pCreateInfo, pRenderPass);
+				Serialise_vkCreateRenderPass(localSerialiser, device, pCreateInfo, pRenderPass);

 				chunk = scope.Get();
 			}
@@ -603,6 +621,7 @@ VkResult WrappedVulkan::vkCreateRenderPass(
 // State object functions

 bool WrappedVulkan::Serialise_vkCreateDynamicViewportState(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                         device,
 			const VkDynamicViewportStateCreateInfo*          pCreateInfo,
 			VkDynamicViewportState*                          pState)
@@ -651,8 +670,10 @@ VkResult WrappedVulkan::vkCreateDynamicViewportState(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_VIEWPORT_STATE);
-				Serialise_vkCreateDynamicViewportState(device, pCreateInfo, pState);
+				Serialise_vkCreateDynamicViewportState(localSerialiser, device, pCreateInfo, pState);

 				chunk = scope.Get();
 			}
@@ -670,6 +691,7 @@ VkResult WrappedVulkan::vkCreateDynamicViewportState(
 }

 bool WrappedVulkan::Serialise_vkCreateDynamicRasterState(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                        device,
 			const VkDynamicRasterStateCreateInfo*           pCreateInfo,
 			VkDynamicRasterState*                           pState)
@@ -718,8 +740,10 @@ VkResult WrappedVulkan::vkCreateDynamicRasterState(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_RASTER_STATE);
-				Serialise_vkCreateDynamicRasterState(device, pCreateInfo, pState);
+				Serialise_vkCreateDynamicRasterState(localSerialiser, device, pCreateInfo, pState);

 				chunk = scope.Get();
 			}
@@ -737,6 +761,7 @@ VkResult WrappedVulkan::vkCreateDynamicRasterState(
 }

 bool WrappedVulkan::Serialise_vkCreateDynamicColorBlendState(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                            device,
 			const VkDynamicColorBlendStateCreateInfo*           pCreateInfo,
 			VkDynamicColorBlendState*                           pState)
@@ -785,8 +810,10 @@ VkResult WrappedVulkan::vkCreateDynamicColorBlendState(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_BLEND_STATE);
-				Serialise_vkCreateDynamicColorBlendState(device, pCreateInfo, pState);
+				Serialise_vkCreateDynamicColorBlendState(localSerialiser, device, pCreateInfo, pState);

 				chunk = scope.Get();
 			}
@@ -804,6 +831,7 @@ VkResult WrappedVulkan::vkCreateDynamicColorBlendState(
 }

 bool WrappedVulkan::Serialise_vkCreateDynamicDepthStencilState(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkDynamicDepthStencilStateCreateInfo*           pCreateInfo,
 			VkDynamicDepthStencilState*                           pState)
@@ -852,8 +880,10 @@ VkResult WrappedVulkan::vkCreateDynamicDepthStencilState(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_DEPTH_STATE);
-				Serialise_vkCreateDynamicDepthStencilState(device, pCreateInfo, pState);
+				Serialise_vkCreateDynamicDepthStencilState(localSerialiser, device, pCreateInfo, pState);

 				chunk = scope.Get();
 			}
@@ -871,6 +901,7 @@ VkResult WrappedVulkan::vkCreateDynamicDepthStencilState(
 }

 bool WrappedVulkan::Serialise_vkCreateQueryPool(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		const VkQueryPoolCreateInfo*                pCreateInfo,
 		VkQueryPool*                                pQueryPool)
@@ -916,8 +947,10 @@ VkResult WrappedVulkan::vkCreateQueryPool(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_QUERY_POOL);
-				Serialise_vkCreateQueryPool(device, pCreateInfo, pQueryPool);
+				Serialise_vkCreateQueryPool(localSerialiser, device, pCreateInfo, pQueryPool);

 				chunk = scope.Get();
 			}
@@ -25,6 +25,7 @@
 #include "../vk_core.h"

 bool WrappedVulkan::Serialise_vkGetDeviceQueue(
+		Serialiser*                                 localSerialiser,
    VkDevice                                    device,
    uint32_t                                    queueNodeIndex,
    uint32_t                                    queueIndex,
@@ -82,8 +83,10 @@ VkResult WrappedVulkan::vkGetDeviceQueue(
 				Chunk *chunk = NULL;

 				{
+					CACHE_THREAD_SERIALISER();
+
 					SCOPED_SERIALISE_CONTEXT(GET_DEVICE_QUEUE);
-					Serialise_vkGetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+					Serialise_vkGetDeviceQueue(localSerialiser, device, queueNodeIndex, queueIndex, pQueue);

 					chunk = scope.Get();
 				}
@@ -106,6 +109,7 @@ VkResult WrappedVulkan::vkGetDeviceQueue(
 }

 bool WrappedVulkan::Serialise_vkQueueSubmit(
+		Serialiser*                                 localSerialiser,
    VkQueue                                     queue,
    uint32_t                                    cmdBufferCount,
    const VkCmdBuffer*                          pCmdBuffers,
@@ -151,7 +155,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(
 			fence = VK_NULL_HANDLE;
 	}

-	const string desc = GetSerialiser()->GetDebugStr();
+	const string desc = localSerialiser->GetDebugStr();

 	if(m_State == READING)
 	{
@@ -369,8 +373,10 @@ VkResult WrappedVulkan::vkQueueSubmit(

 	if(m_State == WRITING_CAPFRAME)
 	{
+		CACHE_THREAD_SERIALISER();
+		
 		SCOPED_SERIALISE_CONTEXT(QUEUE_SUBMIT);
-		Serialise_vkQueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+		Serialise_vkQueueSubmit(localSerialiser, queue, cmdBufferCount, pCmdBuffers, fence);

 		m_FrameCaptureRecord->AddChunk(scope.Get());
 	}
@@ -416,7 +422,7 @@ VkResult WrappedVulkan::vkQueueSubmit(
 	return ret;
 }

-bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore)
+bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(Serialiser* localSerialiser, VkQueue queue, VkSemaphore semaphore)
 {
 	SERIALISE_ELEMENT(ResourceId, qid, GetResID(queue));
 	SERIALISE_ELEMENT(ResourceId, sid, GetResID(semaphore));
@@ -436,8 +442,10 @@ VkResult WrappedVulkan::vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaph
 	
 	if(m_State >= WRITING)
 	{
+		CACHE_THREAD_SERIALISER();
+		
 		SCOPED_SERIALISE_CONTEXT(QUEUE_SIGNAL_SEMAPHORE);
-		Serialise_vkQueueSignalSemaphore(queue, semaphore);
+		Serialise_vkQueueSignalSemaphore(localSerialiser, queue, semaphore);

 		m_FrameCaptureRecord->AddChunk(scope.Get());
 		GetResourceManager()->MarkResourceFrameReferenced(GetResID(queue), eFrameRef_Read);
@@ -447,7 +455,7 @@ VkResult WrappedVulkan::vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaph
 	return ret;
 }

-bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore)
+bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(Serialiser* localSerialiser, VkQueue queue, VkSemaphore semaphore)
 {
 	SERIALISE_ELEMENT(ResourceId, qid, GetResID(queue));
 	SERIALISE_ELEMENT(ResourceId, sid, GetResID(semaphore));
@@ -467,8 +475,10 @@ VkResult WrappedVulkan::vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphor
 	
 	if(m_State >= WRITING_CAPFRAME)
 	{
+		CACHE_THREAD_SERIALISER();
+		
 		SCOPED_SERIALISE_CONTEXT(QUEUE_WAIT_SEMAPHORE);
-		Serialise_vkQueueWaitSemaphore(queue, semaphore);
+		Serialise_vkQueueWaitSemaphore(localSerialiser, queue, semaphore);

 		m_FrameCaptureRecord->AddChunk(scope.Get());
 		GetResourceManager()->MarkResourceFrameReferenced(GetResID(queue), eFrameRef_Read);
@@ -478,7 +488,7 @@ VkResult WrappedVulkan::vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphor
 	return ret;
 }

-bool WrappedVulkan::Serialise_vkQueueWaitIdle(VkQueue queue)
+bool WrappedVulkan::Serialise_vkQueueWaitIdle(Serialiser* localSerialiser, VkQueue queue)
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetResID(queue));
 	
@@ -497,8 +507,10 @@ VkResult WrappedVulkan::vkQueueWaitIdle(VkQueue queue)
 	
 	if(m_State >= WRITING_CAPFRAME)
 	{
+		CACHE_THREAD_SERIALISER();
+		
 		SCOPED_SERIALISE_CONTEXT(QUEUE_WAIT_IDLE);
-		Serialise_vkQueueWaitIdle(queue);
+		Serialise_vkQueueWaitIdle(localSerialiser, queue);

 		m_FrameCaptureRecord->AddChunk(scope.Get());
 		GetResourceManager()->MarkResourceFrameReferenced(GetResID(queue), eFrameRef_Read);
@@ -27,6 +27,7 @@
 // Memory functions

 bool WrappedVulkan::Serialise_vkAllocMemory(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkMemoryAllocInfo*                    pAllocInfo,
 			VkDeviceMemory*                             pMem)
@@ -77,8 +78,10 @@ VkResult WrappedVulkan::vkAllocMemory(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+					
 				SCOPED_SERIALISE_CONTEXT(ALLOC_MEM);
-				Serialise_vkAllocMemory(device, pAllocInfo, pMem);
+				Serialise_vkAllocMemory(localSerialiser, device, pAllocInfo, pMem);

 				chunk = scope.Get();
 			}
@@ -164,6 +167,7 @@ VkResult WrappedVulkan::vkMapMemory(
 }

 bool WrappedVulkan::Serialise_vkUnmapMemory(
+		Serialiser*                                 localSerialiser,
    VkDevice                                    device,
    VkDeviceMemory                              mem)
 {
@@ -238,8 +242,10 @@ VkResult WrappedVulkan::vkUnmapMemory(
 				{
 					if(!it->second.mapFlushed)
 					{
+						CACHE_THREAD_SERIALISER();
+							
 						SCOPED_SERIALISE_CONTEXT(UNMAP_MEM);
-						Serialise_vkUnmapMemory(device, mem);
+						Serialise_vkUnmapMemory(localSerialiser, device, mem);

 						VkResourceRecord *record = GetRecord(mem);

@@ -274,6 +280,7 @@ VkResult WrappedVulkan::vkUnmapMemory(
 }

 bool WrappedVulkan::Serialise_vkFlushMappedMemoryRanges(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			uint32_t                                    memRangeCount,
 			const VkMappedMemoryRange*                  pMemRanges)
@@ -349,8 +356,10 @@ VkResult WrappedVulkan::vkFlushMappedMemoryRanges(

 		if(ret == VK_SUCCESS && m_State >= WRITING_CAPFRAME)
 		{
+			CACHE_THREAD_SERIALISER();
+		
 			SCOPED_SERIALISE_CONTEXT(FLUSH_MEM);
-			Serialise_vkFlushMappedMemoryRanges(device, 1, pMemRanges+i);
+			Serialise_vkFlushMappedMemoryRanges(localSerialiser, device, 1, pMemRanges+i);

 			m_FrameCaptureRecord->AddChunk(scope.Get());
 			GetResourceManager()->MarkResourceFrameReferenced(GetResID(pMemRanges[i].mem), eFrameRef_Write);
@@ -363,6 +372,7 @@ VkResult WrappedVulkan::vkFlushMappedMemoryRanges(
 // Generic API object functions

 bool WrappedVulkan::Serialise_vkBindBufferMemory(
+		Serialiser*                                 localSerialiser,
    VkDevice                                    device,
    VkBuffer                                    buffer,
    VkDeviceMemory                              mem,
@@ -400,8 +410,10 @@ VkResult WrappedVulkan::vkBindBufferMemory(
 		Chunk *chunk = NULL;

 		{
+			CACHE_THREAD_SERIALISER();
+		
 			SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_MEM);
-			Serialise_vkBindBufferMemory(device, buffer, mem, memOffset);
+			Serialise_vkBindBufferMemory(localSerialiser, device, buffer, mem, memOffset);

 			chunk = scope.Get();
 		}
@@ -425,6 +437,7 @@ VkResult WrappedVulkan::vkBindBufferMemory(
 }

 bool WrappedVulkan::Serialise_vkBindImageMemory(
+		Serialiser*                                 localSerialiser,
    VkDevice                                    device,
    VkImage                                     image,
    VkDeviceMemory                              mem,
@@ -460,8 +473,10 @@ VkResult WrappedVulkan::vkBindImageMemory(
 		Chunk *chunk = NULL;

 		{
+			CACHE_THREAD_SERIALISER();
+		
 			SCOPED_SERIALISE_CONTEXT(BIND_IMAGE_MEM);
-			Serialise_vkBindImageMemory(device, image, mem, memOffset);
+			Serialise_vkBindImageMemory(localSerialiser, device, image, mem, memOffset);

 			chunk = scope.Get();
 		}
@@ -485,6 +500,7 @@ VkResult WrappedVulkan::vkBindImageMemory(
 }

 bool WrappedVulkan::Serialise_vkCreateBuffer(
+		Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkBufferCreateInfo*                   pCreateInfo,
 			VkBuffer*                                   pBuffer)
@@ -534,8 +550,10 @@ VkResult WrappedVulkan::vkCreateBuffer(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_BUFFER);
-				Serialise_vkCreateBuffer(device, pCreateInfo, pBuffer);
+				Serialise_vkCreateBuffer(localSerialiser, device, pCreateInfo, pBuffer);

 				chunk = scope.Get();
 			}
@@ -553,6 +571,7 @@ VkResult WrappedVulkan::vkCreateBuffer(
 }

 bool WrappedVulkan::Serialise_vkCreateBufferView(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkBufferViewCreateInfo*               pCreateInfo,
 			VkBufferView*                               pView)
@@ -603,8 +622,10 @@ VkResult WrappedVulkan::vkCreateBufferView(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_BUFFER_VIEW);
-				Serialise_vkCreateBufferView(device, pCreateInfo, pView);
+				Serialise_vkCreateBufferView(localSerialiser, device, pCreateInfo, pView);

 				chunk = scope.Get();
 			}
@@ -623,6 +644,7 @@ VkResult WrappedVulkan::vkCreateBufferView(
 }

 bool WrappedVulkan::Serialise_vkCreateImage(
+			Serialiser*                                 localSerialiser,
 			VkDevice                                    device,
 			const VkImageCreateInfo*                    pCreateInfo,
 			VkImage*                                    pImage)
@@ -693,8 +715,10 @@ VkResult WrappedVulkan::vkCreateImage(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_IMAGE);
-				Serialise_vkCreateImage(device, pCreateInfo, pImage);
+				Serialise_vkCreateImage(localSerialiser, device, pCreateInfo, pImage);

 				chunk = scope.Get();
 			}
@@ -739,6 +763,7 @@ VkResult WrappedVulkan::vkCreateImage(
 // Image view functions

 bool WrappedVulkan::Serialise_vkCreateImageView(
+		Serialiser*                                 localSerialiser,
    VkDevice                                    device,
    const VkImageViewCreateInfo*                pCreateInfo,
    VkImageView*                                pView)
@@ -789,8 +814,10 @@ VkResult WrappedVulkan::vkCreateImageView(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_IMAGE_VIEW);
-				Serialise_vkCreateImageView(device, pCreateInfo, pView);
+				Serialise_vkCreateImageView(localSerialiser, device, pCreateInfo, pView);

 				chunk = scope.Get();
 			}
@@ -809,6 +836,7 @@ VkResult WrappedVulkan::vkCreateImageView(
 }

 bool WrappedVulkan::Serialise_vkCreateAttachmentView(
+		Serialiser*                                 localSerialiser,
    VkDevice                                    device,
    const VkAttachmentViewCreateInfo*           pCreateInfo,
    VkAttachmentView*                           pView)
@@ -859,8 +887,10 @@ VkResult WrappedVulkan::vkCreateAttachmentView(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_ATTACHMENT_VIEW);
-				Serialise_vkCreateAttachmentView(device, pCreateInfo, pView);
+				Serialise_vkCreateAttachmentView(localSerialiser, device, pCreateInfo, pView);

 				chunk = scope.Get();
 			}
@@ -28,6 +28,7 @@

 // Shader functions
 bool WrappedVulkan::Serialise_vkCreatePipelineLayout(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		const VkPipelineLayoutCreateInfo*           pCreateInfo,
 		VkPipelineLayout*                           pPipelineLayout)
@@ -85,8 +86,10 @@ VkResult WrappedVulkan::vkCreatePipelineLayout(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_PIPE_LAYOUT);
-				Serialise_vkCreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+				Serialise_vkCreatePipelineLayout(localSerialiser, device, pCreateInfo, pPipelineLayout);

 				chunk = scope.Get();
 			}
@@ -110,6 +113,7 @@ VkResult WrappedVulkan::vkCreatePipelineLayout(
 }

 bool WrappedVulkan::Serialise_vkCreateShaderModule(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		const VkShaderModuleCreateInfo*             pCreateInfo,
 		VkShaderModule*                             pShaderModule)
@@ -160,8 +164,10 @@ VkResult WrappedVulkan::vkCreateShaderModule(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_SHADER_MODULE);
-				Serialise_vkCreateShaderModule(device, pCreateInfo, pShaderModule);
+				Serialise_vkCreateShaderModule(localSerialiser, device, pCreateInfo, pShaderModule);

 				chunk = scope.Get();
 			}
@@ -179,6 +185,7 @@ VkResult WrappedVulkan::vkCreateShaderModule(
 }

 bool WrappedVulkan::Serialise_vkCreateShader(
+		Serialiser*                                 localSerialiser,
    VkDevice                                    device,
    const VkShaderCreateInfo*                   pCreateInfo,
    VkShader*                                   pShader)
@@ -233,8 +240,10 @@ VkResult WrappedVulkan::vkCreateShader(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_SHADER);
-				Serialise_vkCreateShader(device, pCreateInfo, pShader);
+				Serialise_vkCreateShader(localSerialiser, device, pCreateInfo, pShader);

 				chunk = scope.Get();
 			}
@@ -257,6 +266,7 @@ VkResult WrappedVulkan::vkCreateShader(
 // Pipeline functions

 bool WrappedVulkan::Serialise_vkCreatePipelineCache(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		const VkPipelineCacheCreateInfo*            pCreateInfo,
 		VkPipelineCache*                            pPipelineCache)
@@ -302,8 +312,10 @@ VkResult WrappedVulkan::vkCreatePipelineCache(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_PIPE_CACHE);
-				Serialise_vkCreatePipelineCache(device, pCreateInfo, pPipelineCache);
+				Serialise_vkCreatePipelineCache(localSerialiser, device, pCreateInfo, pPipelineCache);

 				chunk = scope.Get();
 			}
@@ -321,6 +333,7 @@ VkResult WrappedVulkan::vkCreatePipelineCache(
 }

 bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines(
+		Serialiser*                                 localSerialiser,
 		VkDevice                                    device,
 		VkPipelineCache                             pipelineCache,
 		uint32_t                                    count,
@@ -401,8 +414,10 @@ VkResult WrappedVulkan::vkCreateGraphicsPipelines(
 				Chunk *chunk = NULL;

 				{
+					CACHE_THREAD_SERIALISER();
+		
 					SCOPED_SERIALISE_CONTEXT(CREATE_GRAPHICS_PIPE);
-					Serialise_vkCreateGraphicsPipelines(device, pipelineCache, 1, &pCreateInfos[i], &pPipelines[i]);
+					Serialise_vkCreateGraphicsPipelines(localSerialiser, device, pipelineCache, 1, &pCreateInfos[i], &pPipelines[i]);

 					chunk = scope.Get();
 				}
@@ -60,6 +60,7 @@ VkResult WrappedVulkan::vkGetSurfaceInfoWSI(
 }

 bool WrappedVulkan::Serialise_vkGetSwapChainInfoWSI(
+		Serialiser*                              localSerialiser,
 		VkDevice                                 device,
    VkSwapChainWSI                           swapChain,
    VkSwapChainInfoTypeWSI                   infoType,
@@ -123,8 +124,10 @@ VkResult WrappedVulkan::vkGetSwapChainInfoWSI(
 					Chunk *chunk = NULL;

 					{
+						CACHE_THREAD_SERIALISER();
+						
 						SCOPED_SERIALISE_CONTEXT(PRESENT_IMAGE);
-						Serialise_vkGetSwapChainInfoWSI(device, swapChain, infoType, &i, (void *)&images[i]);
+						Serialise_vkGetSwapChainInfoWSI(localSerialiser, device, swapChain, infoType, &i, (void *)&images[i]);

 						chunk = scope.Get();
 					}
@@ -165,6 +168,7 @@ VkResult WrappedVulkan::vkAcquireNextImageWSI(
 }

 bool WrappedVulkan::Serialise_vkCreateSwapChainWSI(
+		Serialiser*                             localSerialiser,
 		VkDevice                                device,
 		const VkSwapChainCreateInfoWSI*         pCreateInfo,
 		VkSwapChainWSI*                         pSwapChain)
@@ -310,8 +314,10 @@ VkResult WrappedVulkan::vkCreateSwapChainWSI(
 			Chunk *chunk = NULL;

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CREATE_SWAP_BUFFER);
-				Serialise_vkCreateSwapChainWSI(device, pCreateInfo, pSwapChain);
+				Serialise_vkCreateSwapChainWSI(localSerialiser, device, pCreateInfo, pSwapChain);

 				chunk = scope.Get();
 			}
@@ -883,6 +889,8 @@ VkResult WrappedVulkan::vkQueuePresentWSI(
 			Serialiser *m_pFileSerialiser = RenderDoc::Inst().OpenWriteSerialiser(m_FrameCounter, &m_InitParams, jpgbuf, len, thwidth, thheight);

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(DEVICE_INIT);

 				m_pFileSerialiser->Insert(scope.Get(true));
@@ -899,6 +907,8 @@ VkResult WrappedVulkan::vkQueuePresentWSI(
 			RDCDEBUG("Creating Capture Scope");	

 			{
+				CACHE_THREAD_SERIALISER();
+		
 				SCOPED_SERIALISE_CONTEXT(CAPTURE_SCOPE);

 				Serialise_CaptureScope(0);
@@ -756,17 +756,20 @@ class ScopedContext
 		}
 };

-#define SCOPED_SERIALISE_CONTEXT(n) ScopedContext scope(GetSerialiser(), GetChunkName(n), n, false);
-#define SCOPED_SERIALISE_SMALL_CONTEXT(n) ScopedContext scope(GetSerialiser(), GetChunkName(n), n, true);
+// can be overridden to locally cache the serialiser pointer (e.g. for TLS lookup)
+#define GET_SERIALISER GetSerialiser()

-#define SERIALISE_ELEMENT(type, name, inValue) type name; if(m_State >= WRITING) name = (inValue); GetSerialiser()->Serialise(#name, name);
-#define SERIALISE_ELEMENT_OPT(type, name, inValue, Condition) type name = type(); if(Condition) { if(m_State >= WRITING) name = (inValue); GetSerialiser()->Serialise(#name, name); }
-#define SERIALISE_ELEMENT_ARR(type, name, inValues, count) type *name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GetSerialiser()->Serialise(#name, name[serialiseIdx]); }
-#define SERIALISE_ELEMENT_ARR_OPT(type, name, inValues, count, Condition) type *name = NULL; if(Condition) { name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GetSerialiser()->Serialise(#name, name[serialiseIdx]); } }
-#define SERIALISE_ELEMENT_PTR(type, name, inValue) type name; if(inValue && m_State >= WRITING) name = *(inValue); GetSerialiser()->Serialise(#name, name);
-#define SERIALISE_ELEMENT_PTR_OPT(type, name, inValue, Condition) type name; if(Condition) { if(inValue && m_State >= WRITING) name = *(inValue); GetSerialiser()->Serialise(#name, name); }
-#define SERIALISE_ELEMENT_BUF(type, name, inBuf, Len) type name = (type)NULL; if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GetSerialiser()->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__));
-#define SERIALISE_ELEMENT_BUF_OPT(type, name, inBuf, Len, Condition) type name = (type)NULL; if(Condition) { if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GetSerialiser()->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__)); }
+#define SCOPED_SERIALISE_CONTEXT(n) ScopedContext scope(GET_SERIALISER, GetChunkName(n), n, false);
+#define SCOPED_SERIALISE_SMALL_CONTEXT(n) ScopedContext scope(GET_SERIALISER, GetChunkName(n), n, true);
+
+#define SERIALISE_ELEMENT(type, name, inValue) type name; if(m_State >= WRITING) name = (inValue); GET_SERIALISER->Serialise(#name, name);
+#define SERIALISE_ELEMENT_OPT(type, name, inValue, Condition) type name = type(); if(Condition) { if(m_State >= WRITING) name = (inValue); GET_SERIALISER->Serialise(#name, name); }
+#define SERIALISE_ELEMENT_ARR(type, name, inValues, count) type *name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GET_SERIALISER->Serialise(#name, name[serialiseIdx]); }
+#define SERIALISE_ELEMENT_ARR_OPT(type, name, inValues, count, Condition) type *name = NULL; if(Condition) { name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GET_SERIALISER->Serialise(#name, name[serialiseIdx]); } }
+#define SERIALISE_ELEMENT_PTR(type, name, inValue) type name; if(inValue && m_State >= WRITING) name = *(inValue); GET_SERIALISER->Serialise(#name, name);
+#define SERIALISE_ELEMENT_PTR_OPT(type, name, inValue, Condition) type name; if(Condition) { if(inValue && m_State >= WRITING) name = *(inValue); GET_SERIALISER->Serialise(#name, name); }
+#define SERIALISE_ELEMENT_BUF(type, name, inBuf, Len) type name = (type)NULL; if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GET_SERIALISER->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__));
+#define SERIALISE_ELEMENT_BUF_OPT(type, name, inBuf, Len, Condition) type name = (type)NULL; if(Condition) { if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GET_SERIALISER->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__)); }

 // forward declare generic pointer version to void*
 template<class T>