split work to insert compute stage

8 files changed, 234 insertions, 121 deletions

diff --git a/samples/Triangle/main.cs b/samples/Triangle/main.cs
index 6640ec5..877c1c4 100644
--- a/samples/Triangle/main.cs
+++ b/samples/Triangle/main.cs
@@ -138,6 +138,7 @@ namespace Triangle {
 		}
 
 		protected override void OnResize () {
+			dev.WaitIdle ();
 
 			if (frameBuffers != null)
 				for (int i = 0; i < swapChain.ImageCount; ++i)
@@ -156,12 +157,14 @@ namespace Triangle {
 					});
 
 			buildCommandBuffers ();
+
+			dev.WaitIdle ();
 		}
 
-		protected override void Dispose (bool disposing) {
+		protected override void Dispose (bool disposing) {		
+			dev.WaitIdle ();
 			if (disposing) {
 				if (!isDisposed) {
-					dev.WaitIdle ();
 					pipeline.Dispose ();
 					dsLayout.Dispose ();
 					for (int i = 0; i < swapChain.ImageCount; i++)
diff --git a/samples/deferred/deferredPbrRenderer.cs b/samples/deferred/deferredPbrRenderer.cs
index 39ce23a..0a898da 100644
--- a/samples/deferred/deferredPbrRenderer.cs
+++ b/samples/deferred/deferredPbrRenderer.cs
@@ -50,16 +50,6 @@ namespace deferred {
 			public Matrix4x4 mvp;
 		}
 
-		struct BloomPushCsts {
-			readonly Vector2 texSize;
-			public int dir;
-			public BloomPushCsts(uint width, uint height, int dir) {
-				this.texSize = new Vector2 (width, height);
-				this.dir = dir;
-			}
-		};
-
-
 		public Matrices matrices = new Matrices {
 			scaleIBLAmbient = 0.5f,
 		};
@@ -75,7 +65,7 @@ namespace deferred {
 		};
 
 		Framebuffer frameBuffer;
-		public Image gbColorRough, gbEmitMetal, gbN_AO, gbPos, hdrImgResolved, hdrImgMS;//, downSamp, downSamp2;
+		public Image gbColorRough, gbEmitMetal, gbN_AO, gbPos, hdrImgResolved, hdrImgMS;
 
 		DescriptorPool descriptorPool;
 		DescriptorSetLayout descLayoutMain, descLayoutTextures, descLayoutGBuff;
@@ -103,7 +93,10 @@ namespace deferred {
 		//const int SP_TONE_MAPPING 	= 3;
 
 		string cubemapPath;
+
 		uint width, height;
+		public uint Width => width;
+		public uint Height => height;
 
 		public DeferredPbrRenderer (Queue gQueue, string cubemapPath, uint width, uint height, float nearPlane, float farPlane) {
 			this.gQueue = gQueue;
@@ -333,25 +326,8 @@ namespace deferred {
 			dsMainWrite = new DescriptorSetWrites (dsMain, descLayoutMain.Bindings[6]);
 			dsMainWrite.Write (dev, shadowMapRenderer.shadowMap.Descriptor);
 #endif
-			init_blur ();
 		}
 
-		ComputePipeline plBlur;
-		DescriptorSetLayout dsLayoutBlur;
-		DescriptorSet dsetPing, dsetPong;
-
-		void init_blur () {
-			dsLayoutBlur = new DescriptorSetLayout (dev,
-				new VkDescriptorSetLayoutBinding (0, VkShaderStageFlags.Compute, VkDescriptorType.StorageImage),
-				new VkDescriptorSetLayoutBinding (1, VkShaderStageFlags.Compute, VkDescriptorType.StorageImage)
-			);
-			plBlur = new ComputePipeline (
-				new PipelineLayout (dev, new VkPushConstantRange (VkShaderStageFlags.Compute, (uint)Marshal.SizeOf<BloomPushCsts>()), dsLayoutBlur),
-				"shaders/computeTest.comp.spv");
-
-			dsetPing = descriptorPool.Allocate (dsLayoutBlur);
-			dsetPong = descriptorPool.Allocate (dsLayoutBlur);
-		}
 
 		public void LoadModel (Queue transferQ, string path) {
 			dev.WaitIdle ();
@@ -381,10 +357,7 @@ namespace deferred {
 			modelAABB = model.DefaultScene.AABB;
 		}
 		public void buildCommandBuffers (CommandBuffer cmd) {
-			//downSamp.SetLayout (cmd, VkImageAspectFlags.Color,
-				//VkAccessFlags.ShaderWrite, VkAccessFlags.TransferWrite,
-				//VkImageLayout.General, VkImageLayout.TransferDstOptimal,
-				//VkPipelineStageFlags.ComputeShader, VkPipelineStageFlags.Transfer);
+
 
 			renderPass.Begin (cmd, frameBuffer);
 
@@ -431,34 +404,9 @@ namespace deferred {
 				VkPipelineStageFlags.FragmentShader, VkPipelineStageFlags.Transfer);*/
 
 			/*=====
-			hdrImg.SetLayout (cmd, VkImageAspectFlags.Color,
-				VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.TransferRead,
-				VkImageLayout.ColorAttachmentOptimal, VkImageLayout.TransferSrcOptimal,
-				VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.Transfer);
-
-			hdrImg.BlitTo (cmd, downSamp);
-
-			hdrImg.SetLayout (cmd, VkImageAspectFlags.Color, VkImageLayout.TransferSrcOptimal, VkImageLayout.ColorAttachmentOptimal,
-				VkPipelineStageFlags.Transfer, VkPipelineStageFlags.ColorAttachmentOutput);
 			=========*/
 
 			/*
-			downSamp.SetLayout (cmd, VkImageAspectFlags.Color,
-				VkAccessFlags.TransferWrite, VkAccessFlags.MemoryRead,
-				VkImageLayout.TransferDstOptimal, VkImageLayout.General,
-				VkPipelineStageFlags.Transfer, VkPipelineStageFlags.FragmentShader);
-
-			plBlur.Bind (cmd);
-			BloomPushCsts pcBloom = new BloomPushCsts (downSamp.Width, downSamp.Height, 0);
-
-
-			plBlur.BindDescriptorSet (cmd, dsetPing);
-			cmd.PushConstant (plBlur.Layout, VkShaderStageFlags.Compute, pcBloom);
-			cmd.Dispatch (downSamp.Width / 16, downSamp.Height / 16);
-
-			plBlur.BindDescriptorSet (cmd, dsetPong);
-			cmd.PushConstant (plBlur.Layout, VkShaderStageFlags.Compute, 1, (uint)Marshal.SizeOf<Vector2> ());
-			cmd.Dispatch (downSamp.Width / 16, downSamp.Height / 16);
 			*/
 
 			/*======
@@ -508,8 +456,6 @@ namespace deferred {
 			hdrImgResolved?.Dispose ();
 			hdrImgMS?.Dispose ();
 
-			//downSamp?.Dispose ();
-			//downSamp2?.Dispose ();
 
 			hdrImgResolved = new Image (dev, HDR_FORMAT, VkImageUsageFlags.Sampled | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransferSrc, VkMemoryPropertyFlags.DeviceLocal, width, height, VkImageType.Image2D, VkSampleCountFlags.SampleCount1);
 			gbColorRough = new Image (dev, VkFormat.R8g8b8a8Unorm, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, width, height, VkImageType.Image2D, NUM_SAMPLES);
@@ -519,8 +465,6 @@ namespace deferred {
 			if (NUM_SAMPLES != VkSampleCountFlags.SampleCount1)
 				hdrImgMS = new Image (dev, HDR_FORMAT, VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, width, height, VkImageType.Image2D, NUM_SAMPLES);
 
-			//downSamp = new Image (dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.TransferDst | VkImageUsageFlags.Storage | VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, width / blurScale, height / blurScale, VkImageType.Image2D);
-			//downSamp2 = new Image (dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.TransferDst | VkImageUsageFlags.Storage | VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, width / blurScale, height / blurScale, VkImageType.Image2D);
 
 			gbColorRough.CreateView (); gbColorRough.CreateSampler ();
 			gbColorRough.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
@@ -535,23 +479,12 @@ namespace deferred {
 
 			hdrImgMS?.CreateView ();
 
-			//downSamp.CreateView (); downSamp.CreateSampler ();
-			//downSamp.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
-			//downSamp2.CreateView (); downSamp2.CreateSampler ();
-			//downSamp2.Descriptor.imageLayout = VkImageLayout.General;
 
 			DescriptorSetWrites uboUpdate = new DescriptorSetWrites (descLayoutGBuff);
 			uboUpdate.Write (dev, dsGBuff,	gbColorRough.Descriptor,
 										gbEmitMetal.Descriptor,
 										gbN_AO.Descriptor,
 										gbPos.Descriptor);
-			//uboUpdate = new DescriptorSetWrites (dsMain, descLayoutMain.Bindings[8]);
-			//uboUpdate.Write (dev, downSamp.Descriptor);
-
-			//uboUpdate = new DescriptorSetWrites (dsetPing, dsLayoutBlur);
-			//downSamp.Descriptor.imageLayout = VkImageLayout.General;
-			//uboUpdate.Write (dev, downSamp.Descriptor, downSamp2.Descriptor);
-			//uboUpdate.Write (dev, dsetPong, downSamp2.Descriptor, downSamp.Descriptor);
 
 			gbColorRough.SetName ("GBuffColorRough");
 			gbEmitMetal.SetName ("GBuffEmitMetal");
@@ -559,8 +492,6 @@ namespace deferred {
 			gbPos.SetName ("GBuffPos");
 			hdrImgResolved.SetName ("HDRimg resolved");
 			hdrImgMS?.SetName ("HDRimg resolved");
-			//downSamp.SetName ("HDRimgDownScaled");
-			//downSamp2.SetName ("HDRimgDownScaled2");
 		}
 
 		public void Resize (uint width, uint height) {
diff --git a/samples/deferred/main.cs b/samples/deferred/main.cs
index f9653cc..17d8db1 100644
--- a/samples/deferred/main.cs
+++ b/samples/deferred/main.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Numerics;
+using System.Runtime.InteropServices;
 using CVKL;
 using Glfw;
 using VK;
@@ -79,6 +80,7 @@ namespace deferred {
 			camera = new Camera (Utils.DegreesToRadians (45f), 1f, 0.1f, 16f);
 			camera.SetPosition (0, 0, 2);
 
+			//renderer = new DeferredPbrRenderer (presentQueue, cubemapPathes[2], swapChain.Width, swapChain.Height, camera.NearPlane, camera.FarPlane);
 			renderer = new DeferredPbrRenderer (presentQueue, cubemapPathes[2], swapChain.Width, swapChain.Height, camera.NearPlane, camera.FarPlane);
 			renderer.LoadModel (transferQ, modelPathes[curModelIndex]);
 			camera.Model = Matrix4x4.CreateScale (1f / Math.Max (Math.Max (renderer.modelAABB.Width, renderer.modelAABB.Height), renderer.modelAABB.Depth));
@@ -87,8 +89,9 @@ namespace deferred {
 		}
 
 		void init_final_pl() {
-			descriptorPool = new DescriptorPool (dev, 1,
-				new VkDescriptorPoolSize (VkDescriptorType.CombinedImageSampler, 1)
+			descriptorPool = new DescriptorPool (dev, 3,
+				new VkDescriptorPoolSize (VkDescriptorType.CombinedImageSampler, 2),
+				new VkDescriptorPoolSize (VkDescriptorType.StorageImage, 4)
 			);
 
 			GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault (VkPrimitiveTopology.TriangleList, DeferredPbrRenderer.NUM_SAMPLES);
@@ -96,8 +99,8 @@ namespace deferred {
 			cfg.Layout = new PipelineLayout (dev,
 				new VkPushConstantRange (VkShaderStageFlags.Fragment, 2 * sizeof (float)),
 				new DescriptorSetLayout (dev, 0,
-					new VkDescriptorSetLayoutBinding (0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)
-					//new VkDescriptorSetLayoutBinding (1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)
+					new VkDescriptorSetLayoutBinding (0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
+					new VkDescriptorSetLayoutBinding (1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)
 					));
 
 			cfg.RenderPass = new RenderPass (dev, swapChain.ColorFormat, DeferredPbrRenderer.NUM_SAMPLES);
@@ -108,9 +111,102 @@ namespace deferred {
 			plToneMap = new GraphicPipeline (cfg);
 
 			descriptorSet = descriptorPool.Allocate (cfg.Layout.DescriptorSetLayouts[0]);
+
+			init_blur ();
+		}
+
+		ComputePipeline plBlur;
+		DescriptorSetLayout dsLayoutBlur;
+		DescriptorSet dsetBlurPing, dsetBlurPong;
+		Image downSamp, downSamp2;
+		CommandPool computeCmdPool;
+
+		struct BlurPushCsts {
+			public Vector2 texSize;
+			public int dir;
+			public float scale;
+			public float strength;
+		};
+		BlurPushCsts pcBloom = new BlurPushCsts () { strength = 1.3f, scale = 0.4f };
+
+		void init_blur () {
+			computeCmdPool = new CommandPool (computeQ);
+
+			blurComplete = dev.CreateSemaphore ();
+
+			dsLayoutBlur = new DescriptorSetLayout (dev,
+				new VkDescriptorSetLayoutBinding (0, VkShaderStageFlags.Compute, VkDescriptorType.StorageImage),
+				new VkDescriptorSetLayoutBinding (1, VkShaderStageFlags.Compute, VkDescriptorType.StorageImage)
+			);
+			plBlur = new ComputePipeline (
+				new PipelineLayout (dev, new VkPushConstantRange (VkShaderStageFlags.Compute, (uint)Marshal.SizeOf<BlurPushCsts> ()), dsLayoutBlur),
+				"shaders/bloom.comp.spv");
+
+			dsetBlurPing = descriptorPool.Allocate (dsLayoutBlur);
+			dsetBlurPong = descriptorPool.Allocate (dsLayoutBlur);
+		}
+
+		void buildBlurCmd (CommandBuffer cmd) {
+			renderer.hdrImgResolved.SetLayout (cmd, VkImageAspectFlags.Color,
+				VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.TransferRead,
+				VkImageLayout.ColorAttachmentOptimal, VkImageLayout.TransferSrcOptimal,
+				VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.Transfer);
+			downSamp.SetLayout (cmd, VkImageAspectFlags.Color,
+				VkAccessFlags.ShaderRead, VkAccessFlags.TransferWrite,
+				VkImageLayout.ShaderReadOnlyOptimal, VkImageLayout.TransferDstOptimal,
+				VkPipelineStageFlags.FragmentShader, VkPipelineStageFlags.Transfer);
+
+
+			renderer.hdrImgResolved.BlitTo (cmd, downSamp);
+
+			renderer.hdrImgResolved.SetLayout (cmd, VkImageAspectFlags.Color,
+				VkImageLayout.TransferSrcOptimal, VkImageLayout.ShaderReadOnlyOptimal,
+				VkPipelineStageFlags.Transfer, VkPipelineStageFlags.FragmentShader);
+
+			downSamp2.SetLayout (cmd, VkImageAspectFlags.Color,
+				0, VkAccessFlags.MemoryWrite,
+				VkImageLayout.Undefined, VkImageLayout.General,
+				VkPipelineStageFlags.AllCommands, VkPipelineStageFlags.ComputeShader);
+
+			downSamp.SetLayout (cmd, VkImageAspectFlags.Color,
+				VkAccessFlags.TransferWrite, VkAccessFlags.MemoryRead,
+				VkImageLayout.TransferDstOptimal, VkImageLayout.General,
+				VkPipelineStageFlags.Transfer, VkPipelineStageFlags.ComputeShader);
+
+			plBlur.Bind (cmd);
+
+			pcBloom.dir = 0;
+
+			plBlur.BindDescriptorSet (cmd, dsetBlurPing);
+			cmd.PushConstant (plBlur.Layout, VkShaderStageFlags.Compute, pcBloom);
+			cmd.Dispatch (downSamp.Width / 16, downSamp.Height / 16);
+
+			cmd.SetMemoryBarrier (VkPipelineStageFlags.ComputeShader, VkPipelineStageFlags.ComputeShader,
+									VkAccessFlags.ShaderWrite, VkAccessFlags.ShaderRead);
+				
+			plBlur.BindDescriptorSet (cmd, dsetBlurPong);
+			cmd.PushConstant (plBlur.Layout, VkShaderStageFlags.Compute, 1, (uint)Marshal.SizeOf<Vector2> ());
+			cmd.Dispatch (downSamp.Width / 16, downSamp.Height / 16);
+
+			downSamp.SetLayout (cmd, VkImageAspectFlags.Color,
+				VkAccessFlags.MemoryWrite, VkAccessFlags.ShaderRead,
+				VkImageLayout.General, VkImageLayout.ShaderReadOnlyOptimal,
+				VkPipelineStageFlags.ComputeShader, VkPipelineStageFlags.FragmentShader);
+				/*
+			downSamp.SetLayout (cmd, VkImageAspectFlags.Color,
+				VkAccessFlags.TransferWrite, VkAccessFlags.ShaderRead,
+				VkImageLayout.TransferDstOptimal, VkImageLayout.ShaderReadOnlyOptimal,
+				VkPipelineStageFlags.Transfer, VkPipelineStageFlags.FragmentShader);
+				*/
+			cmd.End ();
 		}
 
+
 		CommandBuffer cmdPbr;
+		CommandBuffer cmdBlur;
+		VkSemaphore blurComplete;
+		const uint downSizing = 2;
+		float finalDebug = -1.0f;
 
 		void buildCommandBuffers () {
 			cmdPbr?.Free ();
@@ -118,12 +214,19 @@ namespace deferred {
 			renderer.buildCommandBuffers (cmdPbr);
 			cmdPbr.End ();
 
+			cmdBlur?.Free ();
+			cmdBlur = computeCmdPool.AllocateAndStart ();
+			buildBlurCmd (cmdBlur);
+
+
 			for (int i = 0; i < swapChain.ImageCount; ++i) {
 				cmds[i]?.Free ();
 				cmds[i] = cmdPool.AllocateAndStart ();
 
-				renderer.hdrImgResolved.SetLayout (cmds[i], VkImageAspectFlags.Color, VkImageLayout.ColorAttachmentOptimal, VkImageLayout.ShaderReadOnlyOptimal,
-					VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader);
+				//renderer.hdrImgResolved.SetLayout (cmds[i], VkImageAspectFlags.Color,
+					//VkAccessFlags.TransferRead, VkAccessFlags.ShaderRead,
+					//VkImageLayout.TransferSrcOptimal, VkImageLayout.ShaderReadOnlyOptimal,
+					//VkPipelineStageFlags.Transfer, VkPipelineStageFlags.FragmentShader);
 
 				plToneMap.RenderPass.Begin (cmds[i], frameBuffers[i]);
 
@@ -133,7 +236,7 @@ namespace deferred {
 				plToneMap.Bind (cmds[i]);
 				plToneMap.BindDescriptorSet (cmds[i], descriptorSet);
 
-				cmds[i].PushConstant (plToneMap.Layout, VkShaderStageFlags.Fragment, 2 * sizeof(float), new float[] { renderer.exposure, renderer.gamma }, 0);
+				cmds[i].PushConstant (plToneMap.Layout, VkShaderStageFlags.Fragment, 12, new float[] { renderer.exposure, renderer.gamma, finalDebug }, 0);
 
 				cmds[i].Draw (3, 1, 0, 0);
 
@@ -175,6 +278,8 @@ namespace deferred {
 			}
 
 		}
+
+
 		protected override void render () {
 			int idx = swapChain.GetNextImage ();
 			if (idx < 0) {
@@ -187,7 +292,9 @@ namespace deferred {
 
 			presentQueue.Submit (cmdPbr, swapChain.presentComplete, renderer.DrawComplete);
 
-			presentQueue.Submit (cmds[idx], renderer.DrawComplete, drawComplete[idx]);
+			computeQ.Submit (cmdBlur, renderer.DrawComplete, blurComplete);
+
+			presentQueue.Submit (cmds[idx], blurComplete, drawComplete[idx]);
 			presentQueue.Present (swapChain, drawComplete[idx]);
 
 			presentQueue.WaitIdle ();
@@ -195,9 +302,27 @@ namespace deferred {
 		protected override void OnResize () {
 			dev.WaitIdle ();
 
-			UpdateView ();
 			renderer.Resize (swapChain.Width, swapChain.Height);
 
+			UpdateView ();
+
+			downSamp?.Dispose ();
+			downSamp2?.Dispose ();
+			downSamp = new Image (dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.TransferDst | VkImageUsageFlags.Storage | VkImageUsageFlags.Sampled,
+				VkMemoryPropertyFlags.DeviceLocal, renderer.Width / downSizing, renderer.Height / downSizing, VkImageType.Image2D);
+			downSamp2 = new Image (dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.Storage,
+				VkMemoryPropertyFlags.DeviceLocal, renderer.Width / downSizing, renderer.Height/ downSizing, VkImageType.Image2D);
+			downSamp.CreateView (); downSamp.CreateSampler ();
+			downSamp.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
+			downSamp2.CreateView (); downSamp2.CreateSampler ();
+			downSamp2.Descriptor.imageLayout = VkImageLayout.General;
+
+			downSamp.SetName ("HDRimgDownScaled");
+			downSamp2.SetName ("HDRimgDownScaled2");
+
+			pcBloom.texSize.X = downSamp.Width;
+			pcBloom.texSize.Y = downSamp.Height;
+
 			if (frameBuffers != null)
 				for (int i = 0; i < swapChain.ImageCount; ++i)
 					frameBuffers[i]?.Dispose ();
@@ -214,8 +339,13 @@ namespace deferred {
 					});
 			}
 
-			DescriptorSetWrites uboUpdate = new DescriptorSetWrites (plToneMap.Layout.DescriptorSetLayouts[0]);
-			uboUpdate.Write (dev, descriptorSet, renderer.hdrImgResolved.Descriptor);
+			DescriptorSetWrites dsUpdate = new DescriptorSetWrites (plToneMap.Layout.DescriptorSetLayouts[0]);
+			dsUpdate.Write (dev, descriptorSet, renderer.hdrImgResolved.Descriptor, downSamp.Descriptor);
+
+			dsUpdate = new DescriptorSetWrites (dsLayoutBlur);
+			downSamp.Descriptor.imageLayout = VkImageLayout.General;
+			dsUpdate.Write (dev, dsetBlurPong, downSamp2.Descriptor, downSamp.Descriptor);
+			dsUpdate.Write (dev, dsetBlurPing, downSamp.Descriptor, downSamp2.Descriptor);
 
 			buildCommandBuffers ();
 
@@ -342,19 +472,38 @@ namespace deferred {
 						renderer.exposure -= 0.3f;
 					else
 						renderer.exposure += 0.3f;
+					rebuildBuffers = true;
 					break;
 				case Key.F3:
 					if (modifiers.HasFlag (Modifier.Shift))
 						renderer.gamma -= 0.1f;
 					else
 						renderer.gamma += 0.1f;
+					rebuildBuffers = true;
 					break;
-				case Key.F4:
-					if (camera.Type == Camera.CamType.FirstPerson)
-						camera.Type = Camera.CamType.LookAt;
-					else
-						camera.Type = Camera.CamType.FirstPerson;
-					Console.WriteLine ($"camera type = {camera.Type}");
+				case Key.D:
+					finalDebug = -finalDebug;
+					rebuildBuffers = true;
+					break;
+				case Key.B:
+					if (modifiers.HasFlag (Modifier.Control)) {
+						if (modifiers.HasFlag (Modifier.Shift))
+							pcBloom.strength -= 0.1f;
+						else
+							pcBloom.strength += 0.1f;
+					} else {
+						if (modifiers.HasFlag (Modifier.Shift))
+							pcBloom.scale *= 1.1f;
+						else
+							pcBloom.scale *= 0.9f;
+					}
+					Console.WriteLine ($"Bloom: scale = {pcBloom.scale}, strength = {pcBloom.strength}");
+					rebuildBuffers = true;
+					//if (camera.Type == Camera.CamType.FirstPerson)
+					//	camera.Type = Camera.CamType.LookAt;
+					//else
+					//	camera.Type = Camera.CamType.FirstPerson;
+					//Console.WriteLine ($"camera type = {camera.Type}");
 					break;
 				case Key.KeypadAdd:
 					curModelIndex++;
@@ -379,8 +528,18 @@ namespace deferred {
 		protected override void Dispose (bool disposing) {
 			if (disposing) {
 				if (!isDisposed) {
+					computeCmdPool.Dispose ();
+					downSamp?.Dispose ();
+					downSamp2?.Dispose ();
+					if (frameBuffers != null)
+						foreach (Framebuffer fb in frameBuffers)
+							fb.Dispose ();
 					renderer.Dispose ();
+					plBlur.Dispose ();
+					plToneMap.Dispose ();
+					descriptorPool.Dispose ();
 				}
+				dev.DestroySemaphore (blurComplete);
 			}
 			base.Dispose (disposing);
 		}
diff --git a/samples/deferred/shaders/bloom.comp b/samples/deferred/shaders/bloom.comp
index b0e00f0..e97c794 100644
--- a/samples/deferred/shaders/bloom.comp
+++ b/samples/deferred/shaders/bloom.comp
@@ -1,12 +1,14 @@
 #version 450
 
 layout (local_size_x = 16, local_size_y = 16) in;
-layout (binding = 0, rgba16) uniform readonly image2D inputImage;
-layout (binding = 1, rgba16) uniform image2D resultImage;
+layout (binding = 0, rgba16f) uniform readonly image2D inputImage;
+layout (binding = 1, rgba16f) uniform image2D resultImage;
 
 layout(push_constant) uniform PushConsts {
     vec2 texSize;
     int dir;
+    float scale;
+    float strength;
 } pc;
 
 void main(void)
@@ -37,25 +39,30 @@ void main(void)
 									0.0073599963704157,
 									0.0043538453346397,
 									0.0024499299678342);
-
-
-	const float blurScale = 0.003;
-	const float blurStrength = 1.0;
+									
 
 	float ar = 1.0;
+    vec4 color = vec4(0.0);
+    
 	// Aspect ratio for vertical blur pass
 	if (pc.dir == 1)
 		ar = pc.texSize.y / pc.texSize.x;
-
-	vec2 P = gl_GlobalInvocationID.yx - vec2(0, (weights.length() >> 1) * ar * blurScale);
-
-	vec4 color = vec4(0.0);
-	for (int i = 0; i < weights.length(); i++)
-	{
-		vec2 dv = vec2(0.0, i * blurScale) * ar;
-		color += imageLoad (inputImage, ivec2(P + dv)) * weights[i] * blurStrength;
-	}
+        
+    vec3 c = imageLoad (inputImage, ivec2(gl_GlobalInvocationID.yx)).rgb;
     
-    //imageStore(resultImage, ivec2(gl_GlobalInvocationID.xy), color);	
-    imageStore(resultImage, ivec2(gl_GlobalInvocationID.xy), vec4(1,0,0,1));	
+    float lum = (0.299*c.r + 0.587*c.g + 0.114*c.b);
+    if (lum<0.3 && pc.dir == 0)
+        imageStore(resultImage, ivec2(gl_GlobalInvocationID.xy), color);    
+    else {
+    	vec2 P = gl_GlobalInvocationID.yx - vec2(0, (weights.length() >> 1) * ar * pc.scale);
+
+    	
+    	for (int i = 0; i < weights.length(); i++)
+    	{
+    		vec2 dv = vec2(0.0, i * pc.scale) * ar;
+    		color += imageLoad (inputImage, ivec2(P + dv)) * weights[i] * pc.strength;
+    	}
+        
+        imageStore(resultImage, ivec2(gl_GlobalInvocationID.xy), color);
+    }
 }
\ No newline at end of file
diff --git a/samples/deferred/shaders/tone_mapping.frag b/samples/deferred/shaders/tone_mapping.frag
index fddf0c4..6a1a8d4 100644
--- a/samples/deferred/shaders/tone_mapping.frag
+++ b/samples/deferred/shaders/tone_mapping.frag
@@ -5,10 +5,11 @@
 layout(push_constant) uniform PushConsts {
 	float exposure;
 	float gamma;
+	float debug;
 } pc;
 
 layout (set = 0, binding = 0) uniform sampler2D samplerHDR;
-//layout (set = 0, binding = 1) uniform sampler2D bloom;
+layout (set = 0, binding = 1) uniform sampler2D bloom;
 
 layout (location = 0) in vec2 inUV;
 layout (location = 0) out vec4 outColor;
@@ -47,17 +48,20 @@ vec3 SRGBtoLINEAR(vec3 srgbIn)
 }
 									                                  
 void main() 
-{    
-    //vec4 hdrColor = texelFetch (samplerHDR, ivec2(inUV), gl_SampleID);    
-    vec4 hdrColor = texture (samplerHDR, inUV);    
-    outColor = vec4(SRGBtoLINEAR(tonemap(hdrColor.rgb)), hdrColor.a);
-    
+{
+	if (pc.debug < 0.0f) {    
+	    //vec4 hdrColor = texelFetch (samplerHDR, ivec2(inUV), gl_SampleID);    
+	    vec4 hdrColor = texture (samplerHDR, inUV);    
+	    //vec4 c = texture (bloom, inUV);
+	    //float lum = (0.299*c.r + 0.587*c.g + 0.114*c.b);
+	    //if (lum>1.0)
+	    //    hdrColor.rgb += c.rgb * 0.05;
+	    outColor = vec4(SRGBtoLINEAR(tonemap(hdrColor.rgb)), hdrColor.a);	    
+    }else
+    	outColor = texture (bloom, inUV);
     
-    //outColor = texture (bloom, inUV);
     
-    /*float lum = (0.299*hdrColor.r + 0.587*hdrColor.g + 0.114*hdrColor.b);
-    if (lum<1.0)
-        discard;
+    /*
     outColor = vec4(SRGBtoLINEAR(tonemap(hdrColor.rgb)), hdrColor.a);;*/
     
 /*  vec3 mapped = vec3(1.0) - exp(-hdrColor.rgb * pc.exposure);        
diff --git a/vke/src/base/CommandBuffer.cs b/vke/src/base/CommandBuffer.cs
index ffd61c6..be14fc3 100644
--- a/vke/src/base/CommandBuffer.cs
+++ b/vke/src/base/CommandBuffer.cs
@@ -120,6 +120,14 @@ namespace CVKL {
 			vkCmdPushConstants (handle, pipelineLayout.handle, stageFlags, offset, size, data.Pin ());
 			data.Unpin ();
 		}
+		public void SetMemoryBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
+			VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkDependencyFlags dependencyFlags = VkDependencyFlags.ByRegion) {
+			VkMemoryBarrier memoryBarrier = VkMemoryBarrier.New ();
+			memoryBarrier.srcAccessMask = srcAccessMask;
+			memoryBarrier.dstAccessMask = dstAccessMask;
+			Vk.vkCmdPipelineBarrier (Handle, srcStageMask, dstStageMask,
+				dependencyFlags, 1, ref memoryBarrier, 0, IntPtr.Zero, 0, IntPtr.Zero);
+		}
 		public void BeginRegion (string name, float r = 1f, float g = 0.1f, float b=0.1f, float a = 1f) {
 			if (!Device.debugMarkersEnabled)
 				return;
diff --git a/vke/src/base/CommandPool.cs b/vke/src/base/CommandPool.cs
index 259b576..255ecfc 100644
--- a/vke/src/base/CommandPool.cs
+++ b/vke/src/base/CommandPool.cs
@@ -19,6 +19,7 @@ namespace CVKL {
 
 			Activate ();
         }
+		public CommandPool (Queue queue) : this(queue.dev, queue.qFamIndex) {}
 		#endregion
 
 		protected override VkDebugMarkerObjectNameInfoEXT DebugMarkerInfo
diff --git a/vke/src/base/Queue.cs b/vke/src/base/Queue.cs
index 34ed9bd..b463ba6 100644
--- a/vke/src/base/Queue.cs
+++ b/vke/src/base/Queue.cs
@@ -72,7 +72,7 @@ namespace CVKL {
             present.pWaitSemaphores = wait.Pin();
             present.pImageIndices = idx.Pin();
 
-            Utils.CheckResult (vkQueuePresentKHR (handle, ref present));
+            vkQueuePresentKHR (handle, ref present);
 
 			sc.Unpin ();
 			wait.Unpin ();