vkvg ui, MemoryPool graph

12 files changed, 206 insertions, 46 deletions

diff --git a/samples/deferred/EnvironmentPipeline.cs b/samples/deferred/EnvironmentPipeline.cs
index 909ee4a..e372561 100644
--- a/samples/deferred/EnvironmentPipeline.cs
+++ b/samples/deferred/EnvironmentPipeline.cs
@@ -24,7 +24,7 @@ namespace CVKL {
 
 				vboSkybox = new GPUBuffer<float> (staggingQ, cmdPool, VkBufferUsageFlags.VertexBuffer, box_vertices);
 
-				cubemap = KTX.KTX.Load (staggingQ, cmdPool, cubemapPathes[2],
+				cubemap = KTX.KTX.Load (staggingQ, cmdPool, cubemapPathes[0],
 					VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, true);
 				cubemap.CreateView (VkImageViewType.Cube, VkImageAspectFlags.Color, 6, 0, cubemap.CreateInfo.mipLevels);
 				cubemap.CreateSampler (VkSamplerAddressMode.ClampToEdge);
@@ -259,7 +259,7 @@ namespace CVKL {
 								cmd.PushConstant (pl.Layout, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, deltaTheta, (uint)Marshal.SizeOf<Matrix4x4> () + 4);
 							} else {
 								cmd.PushConstant (pl.Layout, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, roughness, (uint)Marshal.SizeOf<Matrix4x4> ());
-								cmd.PushConstant (pl.Layout, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, 512u, (uint)Marshal.SizeOf<Matrix4x4> () + 4);
+								cmd.PushConstant (pl.Layout, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, 64u, (uint)Marshal.SizeOf<Matrix4x4> () + 4);
 							}
 
 							cmd.BindDescriptorSet (pl.Layout, dset);
diff --git a/samples/deferred/deferredPbrRenderer.cs b/samples/deferred/deferredPbrRenderer.cs
index 2dba1df..575d0eb 100644
--- a/samples/deferred/deferredPbrRenderer.cs
+++ b/samples/deferred/deferredPbrRenderer.cs
@@ -11,8 +11,9 @@ namespace deferred {
 		SwapChain swapChain;
 		PresentQueue presentQueue;
 
-		VkSampleCountFlags samples = VkSampleCountFlags.SampleCount4;
+		VkSampleCountFlags samples = VkSampleCountFlags.SampleCount1;
 		VkFormat hdrFormat = VkFormat.R32g32b32a32Sfloat;
+		VkFormat mrtFormat = VkFormat.R32g32b32a32Sfloat;
 
 		public enum DebugView {
 			none,
@@ -102,12 +103,12 @@ namespace deferred {
 			renderPass.AddAttachment (dev.GetSuitableDepthFormat(), VkImageLayout.DepthStencilAttachmentOptimal, samples);
 			renderPass.AddAttachment (swapChain.ColorFormat, VkImageLayout.ColorAttachmentOptimal, samples, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare);//GBuff0 (color + roughness) and final color before resolve
 			renderPass.AddAttachment (VkFormat.R8g8b8a8Unorm, VkImageLayout.ColorAttachmentOptimal, samples, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare);//GBuff1 (emit + metal)
-			renderPass.AddAttachment (VkFormat.R16g16b16a16Sfloat, VkImageLayout.ColorAttachmentOptimal, samples, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare);//GBuff2 (normals + AO)
-			renderPass.AddAttachment (VkFormat.R16g16b16a16Sfloat, VkImageLayout.ColorAttachmentOptimal, samples, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare);//GBuff3 (Pos + depth)
+			renderPass.AddAttachment (mrtFormat, VkImageLayout.ColorAttachmentOptimal, samples, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare);//GBuff2 (normals + AO)
+			renderPass.AddAttachment (mrtFormat, VkImageLayout.ColorAttachmentOptimal, samples, VkAttachmentLoadOp.Clear, VkAttachmentStoreOp.DontCare);//GBuff3 (Pos + depth)
 			renderPass.AddAttachment (hdrFormat, VkImageLayout.ColorAttachmentOptimal, samples);//hdr color
 
 			renderPass.ClearValues.Add (new VkClearValue { color = new VkClearColorValue (0.0f, 0.0f, 0.0f) });
-            	renderPass.ClearValues.Add (new VkClearValue { depthStencil = new VkClearDepthStencilValue (1.0f, 0) });
+			renderPass.ClearValues.Add (new VkClearValue { depthStencil = new VkClearDepthStencilValue (1.0f, 0) });
 			renderPass.ClearValues.Add (new VkClearValue { color = new VkClearColorValue (0.0f, 0.0f, 0.0f) });
 			renderPass.ClearValues.Add (new VkClearValue { color = new VkClearColorValue (0.0f, 0.0f, 0.0f) });
 			renderPass.ClearValues.Add (new VkClearValue { color = new VkClearColorValue (0.0f, 0.0f, 0.0f) });
@@ -158,7 +159,7 @@ namespace deferred {
 			 
 			descriptorPool = new DescriptorPool (dev, 3,
 				new VkDescriptorPoolSize (VkDescriptorType.UniformBuffer, 3),
-				new VkDescriptorPoolSize (VkDescriptorType.CombinedImageSampler, 3),
+				new VkDescriptorPoolSize (VkDescriptorType.CombinedImageSampler, 4),
 				new VkDescriptorPoolSize (VkDescriptorType.InputAttachment, 6)
 			);
 
@@ -168,7 +169,8 @@ namespace deferred {
 				new VkDescriptorSetLayoutBinding (2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
 				new VkDescriptorSetLayoutBinding (3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
 				new VkDescriptorSetLayoutBinding (4, VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer),//lights
-				new VkDescriptorSetLayoutBinding (5, VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer));//materials
+				new VkDescriptorSetLayoutBinding (5, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),//ui overlay
+				new VkDescriptorSetLayoutBinding (6, VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer));//materials
 
 			descLayoutTextures = new DescriptorSetLayout (dev,
 				new VkDescriptorSetLayoutBinding (0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler),
@@ -268,12 +270,18 @@ namespace deferred {
 				AttachmentType.Normal,
 				AttachmentType.AmbientOcclusion,
 				AttachmentType.Emissive);
-			DescriptorSetWrites uboUpdate = new DescriptorSetWrites (dsMain, descLayoutMain.Bindings[5]);
+
+			DescriptorSetWrites uboUpdate = new DescriptorSetWrites (dsMain, descLayoutMain.Bindings[6]);
 			uboUpdate.Write (dev, model.materialUBO.Descriptor);
 
 			modelAABB = model.DefaultScene.AABB;
 		}
 
+		public void WriteUiImgDesciptor (Image uiImage) {
+			DescriptorSetWrites uboUpdate = new DescriptorSetWrites (dsMain, descLayoutMain.Bindings[5]);
+			uboUpdate.Write (dev, uiImage.Descriptor);
+		}
+
 		public void buildCommandBuffers (CommandBuffer[] cmds) {
 			for (int i = 0; i < swapChain.ImageCount; ++i) {
 				cmds[i].Start ();
@@ -352,8 +360,8 @@ namespace deferred {
 
 			gbColorRough = new Image (dev, swapChain.ColorFormat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, samples);
 			gbEmitMetal = new Image (dev, VkFormat.R8g8b8a8Unorm, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, samples);
-			gbN_AO = new Image (dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, samples);
-			gbPos = new Image (dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, samples);
+			gbN_AO = new Image (dev, mrtFormat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, samples);
+			gbPos = new Image (dev, mrtFormat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, samples);
 			hdrImg = new Image (dev, hdrFormat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal | VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, samples);
 
 			gbColorRough.CreateView ();
diff --git a/samples/deferred/main.cs b/samples/deferred/main.cs
index abea5fe..152cdb7 100644
--- a/samples/deferred/main.cs
+++ b/samples/deferred/main.cs
@@ -49,16 +49,151 @@ namespace deferred {
 			};
 
 		int curModelIndex = 0;
-		bool reloadModel = true;
+		bool reloadModel;
 
 		Queue transferQ;
 		DeferredPbrRenderer renderer;
 
+		#if WITH_VKVG
+		vkvg.Device vkvgDev;
+		vkvg.Surface vkvgSurf;
+		Image uiImage;
+
+		void initUISurface () {
+			uiImage?.Dispose ();
+			vkvgSurf?.Dispose ();
+			vkvgSurf = new vkvg.Surface (vkvgDev, (int)swapChain.Width, (int)swapChain.Height);
+			uiImage = new Image (dev, new VkImage ((ulong)vkvgSurf.VkImage.ToInt64 ()), VkFormat.B8g8r8a8Unorm,
+				VkImageUsageFlags.ColorAttachment, (uint)vkvgSurf.Width, (uint)vkvgSurf.Height);
+			uiImage.CreateView (VkImageViewType.ImageView2D, VkImageAspectFlags.Color);
+			uiImage.CreateSampler (VkFilter.Nearest, VkFilter.Nearest, VkSamplerMipmapMode.Nearest, VkSamplerAddressMode.ClampToBorder);
+			uiImage.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
+		}
+
+		void vkvgDraw () {
+			using (vkvg.Context ctx = new vkvg.Context (vkvgSurf)) {
+				ctx.Operator = vkvg.Operator.Clear;
+				ctx.Paint ();
+				ctx.Operator = vkvg.Operator.Over;
+
+				ctx.LineWidth = 1;
+				ctx.SetSource (0.1, 0.1, 0.1, 0.8);
+				ctx.Rectangle (5.5, 5.5, 320, 300);
+				ctx.FillPreserve ();
+				ctx.Flush ();
+				ctx.SetSource (0.8, 0.8, 0.8);
+				ctx.Stroke ();
+
+				ctx.FontFace = "mono";
+				ctx.FontSize = 8;
+				int x = 16;
+				int y = 40, dy = 16;
+				ctx.MoveTo (x, y);
+				ctx.ShowText (string.Format ($"fps:     {fps,5} "));
+				ctx.MoveTo (x + 200, y - 0.5);
+				ctx.Rectangle (x + 200, y - 8.5, 0.1 * fps, 10);
+				ctx.SetSource (0.1, 0.9, 0.1);
+				ctx.Fill ();
+				ctx.SetSource (0.8, 0.8, 0.8);
+				y += dy;
+				ctx.MoveTo (x, y);
+				ctx.ShowText (string.Format ($"Exposure:{renderer.matrices.exposure,5} "));
+				y += dy;
+				ctx.MoveTo (x, y);
+				ctx.ShowText (string.Format ($"Gamma:   {renderer.matrices.gamma,5} "));
+				y += dy;
+				ctx.MoveTo (x, y);
+				ctx.ShowText (string.Format ($"Light pos:   {renderer.lightPos.ToString ()} "));
+				y += dy;
+				ctx.MoveTo (x, y);
+				ctx.ShowText (string.Format ($"{"Debug draw (numpad 0->9)",-30} : {renderer.currentDebugView.ToString ()} "));
+				y += dy;
+				ctx.MoveTo (x, y);
+				ctx.ShowText (string.Format ($"{"Debug Prefil Face: (f)",-30} : {renderer.envCube.debugFace.ToString ()} "));
+				y += dy;
+				ctx.MoveTo (x, y);
+				ctx.ShowText (string.Format ($"{"Debug Prefil Mip: (m)",-30} : {renderer.envCube.debugMip.ToString ()} "));
+
+				//drawResources (ctx);
+			}
+		}
+
+		void drawResources (vkvg.Context ctx) {
+			ResourceManager rm = dev.resourceManager;
+
+			int margin = 5, memPoolHeight=15;
+			int drawingWidth = (int)swapChain.Width - 4 * margin;
+			int drawingHeight = (memPoolHeight + margin) * (rm.memoryPools.Length) + margin;
+			int y = (int)swapChain.Height - drawingHeight - margin;
+			int x = 2 * margin;
+			ctx.LineWidth = 1;
+			ctx.SetSource (0.1, 0.1, 0.1, 0.8);
+			ctx.Rectangle (0.5+margin, 0.5+y, swapChain.Width - 2*margin, drawingHeight);
+			ctx.FillPreserve ();
+			ctx.Flush ();
+			ctx.SetSource (0.8, 0.8, 0.8);
+			ctx.Stroke ();
+
+
+
+			foreach (MemoryPool mp in rm.memoryPools) {
+				float byteWidth = (float)drawingWidth / mp.Size;
+
+				y += margin;
+				ctx.Rectangle (x, y, drawingWidth, memPoolHeight);
+				ctx.SetSource (0.3, 0.3, 0.3, 0.4);
+				ctx.Fill ();
+
+				Resource r = mp.First;
+				while (r != null) {
+					float width = Math.Max (1f, byteWidth * r.AllocatedDeviceMemorySize);
+
+					Vector3 c = new Vector3 (0);
+					Image img = r as Image;
+					if (img != null) {
+						c.Z = 1f;
+						if (img.CreateInfo.usage.HasFlag (VkImageUsageFlags.InputAttachment))
+							c.Y += 0.3f;
+						if (img.CreateInfo.usage.HasFlag (VkImageUsageFlags.ColorAttachment))
+							c.Y += 0.1f;
+						if (img.CreateInfo.usage.HasFlag (VkImageUsageFlags.Sampled))
+							c.X += 0.3f;
+					} else {
+						CVKL.Buffer buff = r as CVKL.Buffer;
+						c.X = 1f;
+						if (buff.Infos.usage.HasFlag (VkBufferUsageFlags.IndexBuffer))
+							c.Y += 0.2f;
+						if (buff.Infos.usage.HasFlag (VkBufferUsageFlags.VertexBuffer))
+							c.Y += 0.4f;
+						if (buff.Infos.usage.HasFlag (VkBufferUsageFlags.UniformBuffer))
+							c.Z += 0.3f;
+					}
+					ctx.SetSource (c.X, c.Y, c.Z, 0.5);
+					ctx.Rectangle (0.5f+ x + byteWidth * r.poolOffset, 0.5f+ y, width, memPoolHeight);
+					ctx.FillPreserve ();
+					ctx.SetSource (0.01f, 0.01f, 0.01f);
+					ctx.Stroke ();
+					r = r.next;
+				}
+				y += memPoolHeight;
+			}
+		}
+		#endif
+
 		Program () {
-			camera = new Camera (Utils.DegreesToRadians (60f), 1f, 0.1f, 16f);
-			camera.SetPosition (0, 0, 3);
+			camera = new Camera (Utils.DegreesToRadians (45f), 1f, 0.1f, 256f);
+			camera.SetPosition (0, 0, 2);
+
+			#if WITH_VKVG
+			vkvgDev = new vkvg.Device (instance.Handle, phy.Handle, dev.VkDev.Handle, presentQueue.qFamIndex,
+				vkvg.SampleCount.Sample_4, presentQueue.index);
+
+			initUISurface ();
+			#endif
 
 			renderer = new DeferredPbrRenderer (dev, swapChain, presentQueue, 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));
 		}
 
 		void buildCommandBuffers () {
@@ -79,12 +214,20 @@ namespace deferred {
 				updateViewRequested = true;
 				rebuildBuffers = true;
 			}
-			if (!rebuildBuffers)
-				return;
-			buildCommandBuffers ();
-			rebuildBuffers = false;
+			if (rebuildBuffers) {
+				buildCommandBuffers ();
+				rebuildBuffers = false;
+			}
+			#if WITH_VKVG
+			vkvgDraw ();
+			#endif
 		}
 		protected override void OnResize () {
+			#if WITH_VKVG
+			initUISurface ();
+			renderer.WriteUiImgDesciptor (uiImage);
+			#endif
+
 			UpdateView ();
 			renderer.Resize ();
 			buildCommandBuffers ();
@@ -201,7 +344,7 @@ namespace deferred {
 					break;
 				case Key.KeypadSubtract:
 					curModelIndex--;
-					if (curModelIndex < modelPathes.Length)
+					if (curModelIndex < 0)
 						curModelIndex = modelPathes.Length -1;
 					reloadModel = true;
 					break;
@@ -217,6 +360,11 @@ namespace deferred {
 			if (disposing) {
 				if (!isDisposed) {
 					renderer.Dispose ();
+					#if WITH_VKVG
+					uiImage?.Dispose ();
+					vkvgSurf?.Dispose ();
+					vkvgDev.Dispose ();
+					#endif
 				}
 			}
 
diff --git a/samples/deferred/shaders/GBuffPbr.frag b/samples/deferred/shaders/GBuffPbr.frag
index c5708a0..1375af4 100644
--- a/samples/deferred/shaders/GBuffPbr.frag
+++ b/samples/deferred/shaders/GBuffPbr.frag
@@ -45,14 +45,10 @@ layout (set = 0, binding = 0) uniform UBO {
     mat4 projection;
     mat4 model;
     mat4 view;
-    vec4 camPos;    
-    float exposure;
-    float gamma;
-    float prefilteredCubeMipLevels;
-    float scaleIBLAmbient;
+    vec4 camPos;
 } ubo;
 
-layout (set = 0, binding = 5) uniform UBOMaterials {
+layout (set = 0, binding = 6) uniform UBOMaterials {
     Material materials[16];
 };
 
@@ -217,7 +213,7 @@ void main()
         ao = texture(aoMap, inUV1).r;
         
     vec3 n = getNormal();    
-    vec3 v = normalize(ubo.camPos.xyz - inWorldPos);
+    vec3 v = ubo.camPos.xyz - inWorldPos;
     
     outColorRough = vec4 (baseColor.rgb, perceptualRoughness);
     outEmitMetal = vec4 (emissive, metallic);
diff --git a/samples/deferred/shaders/GBuffPbr.vert b/samples/deferred/shaders/GBuffPbr.vert
index aa526a0..29069af 100644
--- a/samples/deferred/shaders/GBuffPbr.vert
+++ b/samples/deferred/shaders/GBuffPbr.vert
@@ -8,12 +8,7 @@ layout (location = 3) in vec2 inUV1;
 layout (set = 0, binding = 0) uniform UBO {
     mat4 projection;
     mat4 model;
-    mat4 view;
-    vec4 camPos;    
-    float exposure;
-    float gamma;
-    float prefilteredCubeMipLevels;
-    float scaleIBLAmbient;
+    mat4 view;    
 } ubo;
 
 layout(push_constant) uniform PushConsts {
diff --git a/samples/deferred/shaders/compose.frag b/samples/deferred/shaders/compose.frag
index fc185a3..95da239 100644
--- a/samples/deferred/shaders/compose.frag
+++ b/samples/deferred/shaders/compose.frag
@@ -205,13 +205,12 @@ void main()
 
         // Calculation of analytical lighting contribution
         vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);
-        vec3 specContrib = F * G * D / (4.0 * NdotL * NdotV);
+        vec3 specContrib = F * G * D / (4.0 * NdotL * NdotV);        
         // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
         vec3 color = NdotL * lights[i].color.rgb * (diffuseContrib + specContrib);
 
         // Calculate lighting contribution from image based lighting source (IBL)
-        colors += color + getIBLContribution(pbrInputs, n, reflection);
-    
+        colors += color + getIBLContribution(pbrInputs, n, reflection);          
     }
     colors /= NUM_LIGHTS;
     
@@ -223,6 +222,5 @@ void main()
     colors = mix(colors, colors * subpassLoad(samplerN_AO, gl_SampleID).a, u_OcclusionStrength);
     colors += emissive;             
     
-    outColor = vec4(colors, baseColor.a);
-
+    outColor = vec4(colors, baseColor.a);       
 }
\ No newline at end of file
diff --git a/samples/deferred/shaders/tone_mapping.frag b/samples/deferred/shaders/tone_mapping.frag
index 66f435d..14cc6ab 100644
--- a/samples/deferred/shaders/tone_mapping.frag
+++ b/samples/deferred/shaders/tone_mapping.frag
@@ -12,6 +12,7 @@ layout (set = 0, binding = 0) uniform UBO {
 } ubo;
 
 layout (input_attachment_index = 0, set = 2, binding = 4) uniform subpassInputMS samplerHDR;
+layout (binding = 5) uniform sampler2D samplerUI;
 
 layout (location = 0) in vec2 inUV;
 layout (location = 0) out vec4 outColor;
@@ -51,9 +52,16 @@ vec3 SRGBtoLINEAR(vec3 srgbIn)
 
 void main() 
 {    
-    vec4 hdrColor = subpassLoad(samplerHDR, gl_SampleID);    
+    vec4 hdrColor = subpassLoad(samplerHDR, gl_SampleID);        
+    hdrColor = vec4(SRGBtoLINEAR(tonemap(hdrColor.rgb)), hdrColor.a);
+    #if WITH_VKVG
+    vec4 ui = texture(samplerUI, inUV);
+    outColor = vec4 (mix (hdrColor.rgb, ui.rgb, ui.a), hdrColor.a);
+    #else
+    outColor = hdrColor;
+    #endif
+    
     
-    outColor = vec4(SRGBtoLINEAR(tonemap(hdrColor.rgb)), hdrColor.a);
     /*
     vec3 mapped = vec3(1.0) - exp(-hdrColor.rgb * ubo.exposure);        
     mapped = pow(mapped, vec3(1.0 / ubo.gamma));
diff --git a/vke/CVKL.csproj b/vke/CVKL.csproj
index 1cf95cc..66fcad4 100644
--- a/vke/CVKL.csproj
+++ b/vke/CVKL.csproj
@@ -14,7 +14,7 @@
     <WarningLevel>4</WarningLevel>
     <Optimize>false</Optimize>    
     <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>
-    <DefineConstants>DEBUG;RENDERDOC;</DefineConstants>
+    <DefineConstants>DEBUG;_RENDERDOC;</DefineConstants>
     <LangVersion>7.2</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
diff --git a/vke/src/Buffer.cs b/vke/src/Buffer.cs
index 565deeb..f361f5b 100644
--- a/vke/src/Buffer.cs
+++ b/vke/src/Buffer.cs
@@ -120,9 +120,11 @@ namespace CVKL {
 	/// </summary>
 	public class Buffer : Resource {
         internal VkBuffer handle;
-        public VkDescriptorBufferInfo Descriptor;
+		protected VkBufferCreateInfo createInfo = VkBufferCreateInfo.New ();
+
+		public VkDescriptorBufferInfo Descriptor;
 		public VkBuffer Handle => handle;
-        protected VkBufferCreateInfo createInfo = VkBufferCreateInfo.New();
+		public VkBufferCreateInfo Infos => createInfo;
         
 		protected override VkDebugMarkerObjectNameInfoEXT DebugMarkerInfo
 			=> new VkDebugMarkerObjectNameInfoEXT(VkDebugReportObjectTypeEXT.BufferEXT, handle.Handle);
diff --git a/vke/src/MemoryPool.cs b/vke/src/MemoryPool.cs
index f544aaf..71b2d38 100644
--- a/vke/src/MemoryPool.cs
+++ b/vke/src/MemoryPool.cs
@@ -27,6 +27,7 @@ namespace CVKL {
 		public ulong Size => memInfo.allocationSize;
 		public bool IsMapped => mappedPointer != IntPtr.Zero;
 		public IntPtr MappedData => mappedPointer;
+		public Resource First => firstResource;
 
 		public MemoryPool (Device dev, uint memoryTypeIndex, UInt64 size) {
 			this.dev = dev;
@@ -53,6 +54,10 @@ namespace CVKL {
 			resource.bindMemory ();
 		}
 
+		public void Defrag () { 
+
+		}
+
 		public void Remove (Resource resource) {
 			if (resource == firstResource)
 				firstResource = resource.next;
diff --git a/vke/src/Resource.cs b/vke/src/Resource.cs
index 1f25826..c44f893 100644
--- a/vke/src/Resource.cs
+++ b/vke/src/Resource.cs
@@ -9,10 +9,10 @@ namespace CVKL {
     public abstract class Resource : Activable {
 		protected VkMemoryRequirements memReqs;
 		internal MemoryPool memoryPool;
-		internal ulong poolOffset;
+		public ulong poolOffset;
 		/// <summary> double linked list in memory pool </summary>
 		internal Resource previous;
-		internal Resource next;
+		public Resource next;
 
 		public ulong AllocatedDeviceMemorySize => memReqs.size;
 		public uint TypeBits => memReqs.memoryTypeBits;
diff --git a/vke/src/ResourceManager.cs b/vke/src/ResourceManager.cs
index 02388b8..10fef13 100644
--- a/vke/src/ResourceManager.cs
+++ b/vke/src/ResourceManager.cs
@@ -9,13 +9,13 @@ using static VK.Vk;
 namespace CVKL {
     public class ResourceManager : IDisposable {
 		VkPhysicalDeviceMemoryProperties memoryProperties;
-		MemoryPool[] memoryPools;
+		public MemoryPool[] memoryPools;
 		ulong[] reservedHeapMemory;
 
 		VkMemoryHeap getHeapFromMemoryIndex (uint i) => memoryProperties.memoryHeaps[memoryProperties.memoryTypes[i].heapIndex];
 
 
-		public ResourceManager (Device dev, ulong defaultPoolsBlockDivisor = 8) {
+		public ResourceManager (Device dev, ulong defaultPoolsBlockDivisor = 4) {
 			memoryProperties = dev.phy.memoryProperties;
 			memoryPools = new MemoryPool[memoryProperties.memoryTypeCount];
 			reservedHeapMemory = new ulong[memoryProperties.memoryHeapCount];