Program() : base(false) { vbo = new HostBuffer <Vertex> (dev, VkBufferUsageFlags.VertexBuffer, vertices); ibo = new HostBuffer <ushort> (dev, VkBufferUsageFlags.IndexBuffer, indices); uboMats = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, matrices); descriptorPool = new DescriptorPool(dev, 1, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer)); dsLayout = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer)); GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, VkSampleCountFlags.SampleCount1); cfg.Layout = new PipelineLayout(dev, dsLayout); cfg.RenderPass = new RenderPass(dev, swapChain.ColorFormat, dev.GetSuitableDepthFormat(), cfg.Samples); cfg.AddVertexBinding <Vertex> (0); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32b32Sfloat); cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/triangle.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/triangle.frag.spv"); pipeline = new GraphicPipeline(cfg); descriptorSet = descriptorPool.Allocate(dsLayout); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descriptorSet, dsLayout); uboUpdate.Write(dev, uboMats.Descriptor); uboMats.Map(); }
public Program() { instance = new Instance(); phy = instance.GetAvailablePhysicalDevice().FirstOrDefault(); dev = new Device(phy); computeQ = new Queue(dev, VkQueueFlags.Compute); dev.Activate(default(VkPhysicalDeviceFeatures)); createRandomDatas(); inBuff = new HostBuffer <int> (dev, VkBufferUsageFlags.StorageBuffer, datas); outBuff = new HostBuffer <int> (dev, VkBufferUsageFlags.StorageBuffer, data_size); dsPool = new DescriptorPool(dev, 1, new VkDescriptorPoolSize(VkDescriptorType.StorageBuffer, 2)); dsLayout = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer) ); plCompute = new ComputePipeline(new PipelineLayout(dev, dsLayout), "#shaders.compute.comp.spv"); dset = dsPool.Allocate(dsLayout); DescriptorSetWrites dsUpdate = new DescriptorSetWrites(dset, dsLayout); dsUpdate.Write(dev, inBuff.Descriptor, outBuff.Descriptor); }
public void LoadModel(Queue transferQ, string path) { dev.WaitIdle(); model?.Dispose(); if (TEXTURE_ARRAY) { PbrModelTexArray mod = new PbrModelTexArray(transferQ, path); if (mod.texArray != null) { DescriptorSetWrites uboUpdate = new DescriptorSetWrites(dsMain, descLayoutMain.Bindings[5], descLayoutMain.Bindings[7]); uboUpdate.Write(dev, mod.materialUBO.Descriptor, mod.texArray.Descriptor); } model = mod; } else { model = new PbrModelSeparatedTextures(transferQ, path, descLayoutTextures, AttachmentType.Color, AttachmentType.PhysicalProps, AttachmentType.Normal, AttachmentType.AmbientOcclusion, AttachmentType.Emissive); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(dsMain, descLayoutMain.Bindings[5]); uboUpdate.Write(dev, model.materialUBO.Descriptor); } modelAABB = model.DefaultScene.AABB; }
void createGBuff() { gbColorRough?.Dispose(); gbEmitMetal?.Dispose(); gbN?.Dispose(); gbPos?.Dispose(); gbColorRough = new Image(dev, VkFormat.R8g8b8a8Unorm, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height); gbEmitMetal = new Image(dev, VkFormat.R8g8b8a8Unorm, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height); gbN = new Image(dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height); gbPos = new Image(dev, VkFormat.R16g16b16a16Sfloat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height); gbColorRough.CreateView(); gbColorRough.CreateSampler(); gbEmitMetal.CreateView(); gbEmitMetal.CreateSampler(); gbN.CreateView(); gbN.CreateSampler(); gbPos.CreateView(); gbPos.CreateSampler(); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descLayoutGBuff); uboUpdate.Write(dev, dsGBuff, gbColorRough.Descriptor, gbEmitMetal.Descriptor, gbN.Descriptor, gbPos.Descriptor); gbColorRough.SetName("GBuffColorRough"); gbEmitMetal.SetName("GBuffEmitMetal"); gbN.SetName("GBuffN"); gbPos.SetName("GBuffPos"); }
public PBRPipeline(Queue staggingQ, RenderPass renderPass, string cubeMapPath, PipelineCache pipelineCache = null) : base(renderPass, pipelineCache, "pbr pipeline") { descriptorPool = new DescriptorPool(Dev, 2, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer, 2), new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler, 8) ); descLayoutMain = new DescriptorSetLayout(Dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer)); descLayoutTextures = new DescriptorSetLayout(Dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler) ); using (GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, renderPass.Samples)) { cfg.Layout = new PipelineLayout(Dev, descLayoutMain, descLayoutTextures); cfg.Layout.AddPushConstants( new VkPushConstantRange(VkShaderStageFlags.Vertex, (uint)Marshal.SizeOf <Matrix4x4> ()), new VkPushConstantRange(VkShaderStageFlags.Fragment, sizeof(int), 64) ); cfg.RenderPass = renderPass; cfg.AddVertexBinding <PbrModel.Vertex> (0); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32b32Sfloat, VkFormat.R32g32Sfloat, VkFormat.R32g32Sfloat); cfg.AddShader(Dev, VkShaderStageFlags.Vertex, "#shaders.pbr.vert.spv"); cfg.AddShader(Dev, VkShaderStageFlags.Fragment, "#shaders.pbr_khr.frag.spv"); layout = cfg.Layout; init(cfg); } dsMain = descriptorPool.Allocate(descLayoutMain); envCube = new EnvironmentCube(cubeMapPath, layout, staggingQ, RenderPass); matrices.prefilteredCubeMipLevels = envCube.prefilterCube.CreateInfo.mipLevels; uboMats = new HostBuffer(Dev, VkBufferUsageFlags.UniformBuffer, matrices, true); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descLayoutMain.Bindings.GetRange(0, 4).ToArray()); uboUpdate.Write(Dev, dsMain, uboMats.Descriptor, envCube.irradianceCube.Descriptor, envCube.prefilterCube.Descriptor, envCube.lutBrdf.Descriptor); }
public void LoadModel(Queue transferQ, string path) { dev.WaitIdle(); model?.Dispose(); model = new PbrModelTexArray(transferQ, path); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(dsMain, descLayoutMain.Bindings[5], descLayoutMain.Bindings[7]); uboUpdate.Write(dev, model.materialUBO.Descriptor, (model as PbrModelTexArray).texArray.Descriptor); modelAABB = model.DefaultScene.AABB; }
protected override void initVulkan() { base.initVulkan(); //first create the needed buffers vbo = new HostBuffer <Vertex> (dev, VkBufferUsageFlags.VertexBuffer, vertices); ibo = new HostBuffer <ushort> (dev, VkBufferUsageFlags.IndexBuffer, indices); //because mvp matrice may be updated by mouse move, we keep it mapped after creation. uboMats = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, mvp, true); //a descriptor pool to allocate the mvp matrice descriptor from. descriptorPool = new DescriptorPool(dev, 1, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer)); //Graphic pipeline configuration are predefined by the GraphicPipelineConfig class, which ease sharing config for several pipelines having lots in common. using (GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, VkSampleCountFlags.SampleCount1, false)) { //Create the pipeline layout, it will be automatically activated on pipeline creation, so that sharing layout among different pipelines will benefit //from the reference counting to automatically dispose unused layout on pipeline clean up. It's the same for DescriptorSetLayout. cfg.Layout = new PipelineLayout(dev, new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex, VkDescriptorType.UniformBuffer))); //create a default renderpass with just a color attachment for the swapchain image, a default subpass is automatically created and the renderpass activation //will follow the pipeline life cicle and will be automatically disposed when no longuer used. cfg.RenderPass = new RenderPass(dev, swapChain.ColorFormat, cfg.Samples); //configuration of vertex bindings and attributes cfg.AddVertexBinding <Vertex> (0); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32b32Sfloat); //position + color //shader are automatically compiled by SpirVTasks if added to the project. The resulting shaders are automatically embedded in the assembly. //To specifiy that the shader path is a resource name, put the '#' prefix. Else the path will be search on disk. cfg.AddShaders( new ShaderInfo(dev, VkShaderStageFlags.Vertex, "#shaders.main.vert.spv"), new ShaderInfo(dev, VkShaderStageFlags.Fragment, "#shaders.main.frag.spv") ); //create and activate the pipeline with the configuration we've just done. pipeline = new GraphicPipeline(cfg); } //because descriptor layout used for a pipeline are only activated on pipeline activation, descriptor set must not be allocated before, except if the layout has been manually activated, //but in this case, layout will need also to be explicitly disposed. descriptorSet = descriptorPool.Allocate(pipeline.Layout.DescriptorSetLayouts[0]); //Write the content of the descriptor, the mvp matrice. DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descriptorSet, pipeline.Layout.DescriptorSetLayouts[0]); //Descriptor property of the mvp buffer will return a default descriptor with no offset of the full size of the buffer. uboUpdate.Write(dev, uboMats.Descriptor); //allocate the default VkWindow buffers, one per swapchain image. Their will be only reset when rebuilding and not reallocated. cmds = cmdPool.AllocateCommandBuffer(swapChain.ImageCount); }
//in the main vulkan thread void updateTextureSet() { nextTexture.CreateView(VkImageViewType.Cube, VkImageAspectFlags.Color, 6); nextTexture.CreateSampler(); nextTexture.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descriptorSet, dsLayout.Bindings[1]); uboUpdate.Write(dev, nextTexture.Descriptor); texture?.Dispose(); texture = nextTexture; nextTexture = null; }
public void LoadModel(Queue staggingQ, string path) { model?.Dispose(); model = new PbrModel(staggingQ, path, descLayoutTextures, AttachmentType.Color, AttachmentType.PhysicalProps, AttachmentType.Normal, AttachmentType.AmbientOcclusion, AttachmentType.Emissive); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descLayoutMain.Bindings[4]); uboUpdate.Write(Dev, dsMain, model.materialUBO.Descriptor); }
//in the main vulkan thread void updateTextureSet() { nextTexture.CreateView(); nextTexture.CreateSampler(); nextTexture.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; dev.WaitIdle(); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descriptorSet, dsLayout.Bindings[1]); uboUpdate.Write(dev, nextTexture.Descriptor); texture?.Dispose(); texture = nextTexture; nextTexture = null; }
public Program() { instance = new Instance(); #if DEBUG dbgReport = new DebugReport(instance, VkDebugReportFlagsEXT.ErrorEXT | VkDebugReportFlagsEXT.DebugEXT | VkDebugReportFlagsEXT.WarningEXT | VkDebugReportFlagsEXT.PerformanceWarningEXT ); #endif phy = instance.GetAvailablePhysicalDevice().FirstOrDefault(); dev = new Device(phy); computeQ = new Queue(dev, VkQueueFlags.Compute); dev.Activate(enabledFeatures, enabledExtensions); datas = new float[data_size]; Random rnd = new Random(); for (uint i = 0; i < data_size; i++) { datas[i] = (float)rnd.NextDouble(); } inBuff = new HostBuffer <float> (dev, VkBufferUsageFlags.StorageBuffer, datas); outBuff = new HostBuffer <float> (dev, VkBufferUsageFlags.StorageBuffer, data_size); dsPool = new DescriptorPool(dev, 2, new VkDescriptorPoolSize(VkDescriptorType.StorageBuffer, 4)); dsLayoutCompute = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer) ); plCompute = new ComputePipeline( new PipelineLayout(dev, new VkPushConstantRange(VkShaderStageFlags.Compute, sizeof(int)), dsLayoutCompute), "shaders/computeTest.comp.spv"); dsetPing = dsPool.Allocate(dsLayoutCompute); dsetPong = dsPool.Allocate(dsLayoutCompute); DescriptorSetWrites dsUpdate = new DescriptorSetWrites(dsetPing, dsLayoutCompute); dsUpdate.Write(dev, inBuff.Descriptor, outBuff.Descriptor); dsUpdate.Write(dev, dsetPong, outBuff.Descriptor, inBuff.Descriptor); }
protected override void initVulkan() { base.initVulkan(); cmds = cmdPool.AllocateCommandBuffer(swapChain.ImageCount); loadTexture(imgPathes[currentImgIndex]); vbo = new GPUBuffer <float> (presentQueue, cmdPool, VkBufferUsageFlags.VertexBuffer, vertices); ibo = new GPUBuffer <ushort> (presentQueue, cmdPool, VkBufferUsageFlags.IndexBuffer, indices); descriptorPool = new DescriptorPool(dev, 1, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer), new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler) ); dsLayout = new DescriptorSetLayout(dev, 0, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex, VkDescriptorType.UniformBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)); using (GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, VkSampleCountFlags.SampleCount4)) { cfg.Layout = new PipelineLayout(dev, dsLayout); cfg.RenderPass = new RenderPass(dev, swapChain.ColorFormat, dev.GetSuitableDepthFormat(), cfg.Samples); cfg.AddVertexBinding(0, 5 * sizeof(float)); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32Sfloat); cfg.AddShader(dev, VkShaderStageFlags.Vertex, "#shaders.main.vert.spv"); cfg.AddShader(dev, VkShaderStageFlags.Fragment, "#shaders.main.frag.spv"); pipeline = new GraphicPipeline(cfg); } uboMats = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, matrices); uboMats.Map(); //permanent map descriptorSet = descriptorPool.Allocate(dsLayout); updateTextureSet(); DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descriptorSet, dsLayout.Bindings[0]); uboUpdate.Write(dev, uboMats.Descriptor); }
void createGBuff() { gbColorRough?.Dispose(); gbEmitMetal?.Dispose(); gbN_AO?.Dispose(); gbPos?.Dispose(); hdrImg?.Dispose(); gbColorRough = new Image(dev, swapChain.ColorFormat, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, NUM_SAMPLES); gbEmitMetal = new Image(dev, VkFormat.R8g8b8a8Unorm, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, NUM_SAMPLES); gbN_AO = new Image(dev, MRT_FORMAT, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, NUM_SAMPLES); gbPos = new Image(dev, MRT_FORMAT, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, NUM_SAMPLES); hdrImg = new Image(dev, HDR_FORMAT, VkImageUsageFlags.InputAttachment | VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransientAttachment, VkMemoryPropertyFlags.DeviceLocal | VkMemoryPropertyFlags.DeviceLocal, swapChain.Width, swapChain.Height, VkImageType.Image2D, NUM_SAMPLES); gbColorRough.CreateView(); gbColorRough.CreateSampler(); gbColorRough.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; gbEmitMetal.CreateView(); gbEmitMetal.CreateSampler(); gbEmitMetal.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; gbN_AO.CreateView(); gbN_AO.CreateSampler(); gbN_AO.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; gbPos.CreateView(); gbPos.CreateSampler(); gbPos.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; hdrImg.CreateView(); hdrImg.CreateSampler(); hdrImg.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descLayoutGBuff); uboUpdate.Write(dev, dsGBuff, gbColorRough.Descriptor, gbEmitMetal.Descriptor, gbN_AO.Descriptor, gbPos.Descriptor, hdrImg.Descriptor); gbColorRough.SetName("GBuffColorRough"); gbEmitMetal.SetName("GBuffEmitMetal"); gbN_AO.SetName("GBuffN"); gbPos.SetName("GBuffPos"); hdrImg.SetName("HDRimg"); }
protected override void OnResize() { vkvgImage?.Dispose(); vkvgSurf?.Dispose(); vkvgSurf = new vkvg.Surface(vkvgDev, (int)swapChain.Width, (int)swapChain.Height); vkvgImage = new Image(dev, new VkImage((ulong)vkvgSurf.VkImage.ToInt64()), VkFormat.B8g8r8a8Unorm, VkImageUsageFlags.ColorAttachment, (uint)vkvgSurf.Width, (uint)vkvgSurf.Height); vkvgImage.CreateView(VkImageViewType.ImageView2D, VkImageAspectFlags.Color); vkvgImage.CreateSampler(VkFilter.Nearest, VkFilter.Nearest, VkSamplerMipmapMode.Nearest, VkSamplerAddressMode.ClampToBorder); vkvgImage.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; DescriptorSetWrites uboUpdate = new DescriptorSetWrites(dsMats, descLayoutMatrix.Bindings[1]); uboUpdate.Write(dev, vkvgImage.Descriptor); updateMatrices(); if (frameBuffers != null) { for (int i = 0; i < swapChain.ImageCount; ++i) { frameBuffers[i]?.Dispose(); } } frameBuffers = new Framebuffer[swapChain.ImageCount]; for (int i = 0; i < swapChain.ImageCount; ++i) { frameBuffers[i] = new Framebuffer(pipeline.RenderPass, swapChain.Width, swapChain.Height, (pipeline.Samples == VkSampleCountFlags.SampleCount1) ? new Image[] { swapChain.images[i], null } : new Image[] { null, null, swapChain.images[i] }); frameBuffers[i].SetName("main FB " + i); } buildCommandBuffers(); }
protected override void OnResize() { base.OnResize(); dev.WaitIdle(); renderer.Resize(Width, Height); UpdateView(); frameBuffers?.Dispose(); frameBuffers = plToneMap.RenderPass.CreateFrameBuffers(swapChain); DescriptorSetWrites dsUpdate = new DescriptorSetWrites(plToneMap.Layout.DescriptorSetLayouts[0].Bindings[0]); dsUpdate.Write(dev, descriptorSet, renderer.hdrImgResolved.Descriptor); buildCommandBuffers(); dev.WaitIdle(); }
protected override void OnResize() { dev.WaitIdle(); recreateSurfaceStatus = true; while (recreateSurfaceStatus) { Thread.Sleep(1); } vkvgImage.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; DescriptorSetWrites uboUpdate = new DescriptorSetWrites(dsVkvg, descLayout); uboUpdate.Write(dev, vkvgImage.Descriptor); if (frameBuffers != null) { for (int i = 0; i < swapChain.ImageCount; ++i) { frameBuffers[i]?.Dispose(); } } frameBuffers = new Framebuffer[swapChain.ImageCount]; for (int i = 0; i < swapChain.ImageCount; ++i) { frameBuffers[i] = new Framebuffer(uiPipeline.RenderPass, swapChain.Width, swapChain.Height, (uiPipeline.Samples == VkSampleCountFlags.SampleCount1) ? new Image[] { swapChain.images[i], null } : new Image[] { null, null, swapChain.images[i] }); frameBuffers[i].SetName("main FB " + i); } buildCommandBuffers(); }
protected override void OnResize() { initUISurface(); uiImage.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; DescriptorSetWrites uboUpdate = new DescriptorSetWrites(pbrPipeline.dsMain, pbrPipeline.Layout.DescriptorSetLayouts[0].Bindings[5]); uboUpdate.Write(dev, uiImage.Descriptor); UpdateView(); if (frameBuffers != null) { for (int i = 0; i < swapChain.ImageCount; ++i) { frameBuffers[i]?.Dispose(); } } frameBuffers = new Framebuffer[swapChain.ImageCount]; for (int i = 0; i < swapChain.ImageCount; ++i) { frameBuffers[i] = new Framebuffer(pbrPipeline.RenderPass, swapChain.Width, swapChain.Height, (pbrPipeline.RenderPass.Samples == VkSampleCountFlags.SampleCount1) ? new Image[] { swapChain.images[i], null } : new Image[] { null, null, swapChain.images[i] }); } buildCommandBuffers(); }
Vector4 outlineColor = new Vector4(1.0f, 0.0f, 0.0f, 0.6f); //alpha => 0:disabled 1:enabled protected override void initVulkan() { base.initVulkan(); cmds = cmdPool.AllocateCommandBuffer(swapChain.ImageCount); font = new BMFont(vke.samples.Utils.GetDataFile("font.fnt")); vbo = new GPUBuffer <float> (dev, VkBufferUsageFlags.VertexBuffer | VkBufferUsageFlags.TransferDst, 1024); ibo = new GPUBuffer <ushort> (dev, VkBufferUsageFlags.IndexBuffer | VkBufferUsageFlags.TransferDst, 2048); descriptorPool = new DescriptorPool(dev, 1, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer), new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler) ); dsLayout = new DescriptorSetLayout(dev, 0, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex, VkDescriptorType.UniformBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)); using (GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, VkSampleCountFlags.SampleCount4, false)) { cfg.Layout = new PipelineLayout(dev, dsLayout); cfg.Layout.AddPushConstants(new VkPushConstantRange(VkShaderStageFlags.Fragment, (uint)Marshal.SizeOf <Vector4> () * 2)); cfg.RenderPass = new RenderPass(dev, swapChain.ColorFormat, cfg.Samples); cfg.blendAttachments[0] = new VkPipelineColorBlendAttachmentState( true, VkBlendFactor.One, VkBlendFactor.OneMinusSrcAlpha, VkBlendOp.Add, VkBlendFactor.One, VkBlendFactor.Zero); cfg.AddVertexBinding(0, 5 * sizeof(float)); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32Sfloat); cfg.AddShader(dev, VkShaderStageFlags.Vertex, "#shaders.main.vert.spv"); cfg.AddShader(dev, VkShaderStageFlags.Fragment, "#shaders.main.frag.spv"); pipeline = new GraphicPipeline(cfg); } uboMats = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, matrices); uboMats.Map(); //permanent map descriptorSet = descriptorPool.Allocate(dsLayout); fontTexture = font.GetPageTexture(0, presentQueue, cmdPool); fontTexture.CreateView(); fontTexture.CreateSampler(); fontTexture.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; DescriptorSetWrites dsUpdate = new DescriptorSetWrites(descriptorSet, dsLayout); dsUpdate.Write(dev, uboMats.Descriptor, fontTexture.Descriptor); generateText("Vulkan", out HostBuffer <Vertex> staggingVbo, out HostBuffer <ushort> staggingIbo); PrimaryCommandBuffer cmd = cmdPool.AllocateAndStart(VkCommandBufferUsageFlags.OneTimeSubmit); staggingVbo.CopyTo(cmd, vbo); staggingIbo.CopyTo(cmd, ibo); presentQueue.EndSubmitAndWait(cmd); staggingVbo.Dispose(); staggingIbo.Dispose(); UpdateFrequency = 10; }
public Program() : base() { if (Instance.DEBUG_UTILS) { dbgReport = new DebugReport(instance, VkDebugReportFlagsEXT.ErrorEXT | VkDebugReportFlagsEXT.DebugEXT | VkDebugReportFlagsEXT.WarningEXT | VkDebugReportFlagsEXT.PerformanceWarningEXT ); } imgResult = new Image(dev, VkFormat.R32g32b32a32Sfloat, VkImageUsageFlags.TransferDst | VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, imgDim, imgDim); imgResult.CreateView(); imgResult.CreateSampler(VkFilter.Nearest, VkFilter.Nearest, VkSamplerMipmapMode.Nearest, VkSamplerAddressMode.ClampToBorder); imgResult.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; datas = new float[data_size]; addSeed(imgDim / 2 - 1, imgDim / 2 - 1); stagingDataBuff = new HostBuffer <float> (dev, VkBufferUsageFlags.TransferSrc, datas); stagingDataBuff.Map(); inBuff = new GPUBuffer <float> (dev, VkBufferUsageFlags.StorageBuffer | VkBufferUsageFlags.TransferSrc | VkBufferUsageFlags.TransferDst, (int)data_size); outBuff = new GPUBuffer <float> (dev, VkBufferUsageFlags.StorageBuffer | VkBufferUsageFlags.TransferSrc, (int)data_size); dsPool = new DescriptorPool(dev, 3, new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler), new VkDescriptorPoolSize(VkDescriptorType.StorageBuffer, 4)); dslImage = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler) ); dslCompute = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer) ); GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, VkSampleCountFlags.SampleCount1); cfg.Layout = new PipelineLayout(dev, dslImage); cfg.RenderPass = new RenderPass(dev, swapChain.ColorFormat, dev.GetSuitableDepthFormat(), VkSampleCountFlags.SampleCount1); cfg.RenderPass.ClearValues[0] = new VkClearValue { color = new VkClearColorValue(0.0f, 0.1f, 0.0f) }; cfg.ResetShadersAndVerticesInfos(); cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/FullScreenQuad.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/simpletexture.frag.spv"); cfg.blendAttachments[0] = new VkPipelineColorBlendAttachmentState(true); grPipeline = new GraphicPipeline(cfg); plCompute = new ComputePipeline( new PipelineLayout(dev, new VkPushConstantRange(VkShaderStageFlags.Compute, 2 * sizeof(int)), dslCompute), "shaders/computeTest.comp.spv"); plNormalize = new ComputePipeline( plCompute.Layout, "shaders/normalize.comp.spv"); dsImage = dsPool.Allocate(dslImage); dsetPing = dsPool.Allocate(dslCompute); dsetPong = dsPool.Allocate(dslCompute); DescriptorSetWrites dsUpdate = new DescriptorSetWrites(dsetPing, dslCompute); dsUpdate.Write(dev, inBuff.Descriptor, outBuff.Descriptor); dsUpdate.Write(dev, dsetPong, outBuff.Descriptor, inBuff.Descriptor); dsUpdate = new DescriptorSetWrites(dsImage, dslImage); dsUpdate.Write(dev, imgResult.Descriptor); UpdateFrequency = 5; }
void init(float nearPlane, float farPlane) { init_renderpass(); descLayoutMain = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer),//matrices and params new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), 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 #if WITH_SHADOWS descLayoutMain.Bindings.Add(new VkDescriptorSetLayoutBinding(6, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)); #endif if (TEXTURE_ARRAY) { descLayoutMain.Bindings.Add(new VkDescriptorSetLayoutBinding(7, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)); //texture array //descLayoutMain.Bindings.Add (new VkDescriptorSetLayoutBinding (8, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler));//down sampled hdr } else { descLayoutTextures = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler) ); } descLayoutGBuff = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), //color + roughness new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), //emit + metal new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), //normals + AO new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment)); //Pos + depth GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, NUM_SAMPLES); cfg.rasterizationState.cullMode = VkCullModeFlags.Back; if (NUM_SAMPLES != VkSampleCountFlags.SampleCount1) { cfg.multisampleState.sampleShadingEnable = true; cfg.multisampleState.minSampleShading = 0.5f; } cfg.Cache = pipelineCache; if (TEXTURE_ARRAY) { cfg.Layout = new PipelineLayout(dev, descLayoutMain, descLayoutGBuff); } else { cfg.Layout = new PipelineLayout(dev, descLayoutMain, descLayoutGBuff, descLayoutTextures); } cfg.Layout.AddPushConstants( new VkPushConstantRange(VkShaderStageFlags.Vertex, (uint)Marshal.SizeOf <Matrix4x4> ()), new VkPushConstantRange(VkShaderStageFlags.Fragment, sizeof(int), 64) ); cfg.RenderPass = renderPass; cfg.SubpassIndex = SP_MODELS; cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); //cfg.blendAttachments.Add (new VkPipelineColorBlendAttachmentState (false)); cfg.AddVertex <PbrModelTexArray.Vertex> (); using (SpecializationInfo constants = new SpecializationInfo( new SpecializationConstant <float> (0, nearPlane), new SpecializationConstant <float> (1, farPlane), new SpecializationConstant <float> (2, MAX_MATERIAL_COUNT))) { cfg.AddShaders(new ShaderInfo(dev, VkShaderStageFlags.Vertex, "#shaders.GBuffPbr.vert.spv")); if (TEXTURE_ARRAY) { cfg.AddShaders(new ShaderInfo(dev, VkShaderStageFlags.Fragment, "#shaders.GBuffPbrTexArray.frag.spv", constants)); } else { cfg.AddShaders(new ShaderInfo(dev, VkShaderStageFlags.Fragment, "#shaders.GBuffPbr.frag.spv", constants)); } gBuffPipeline = new GraphicPipeline(cfg); } cfg.rasterizationState.cullMode = VkCullModeFlags.Front; //COMPOSE PIPELINE cfg.blendAttachments.Clear(); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.ResetShadersAndVerticesInfos(); cfg.SubpassIndex = SP_COMPOSE; cfg.Layout = gBuffPipeline.Layout; cfg.depthStencilState.depthTestEnable = false; cfg.depthStencilState.depthWriteEnable = false; using (SpecializationInfo constants = new SpecializationInfo( new SpecializationConstant <uint> (0, (uint)lights.Length))) { cfg.AddShaders(new ShaderInfo(dev, VkShaderStageFlags.Vertex, "#vke.FullScreenQuad.vert.spv")); #if WITH_SHADOWS cfg.AddShaders(new ShaderInfo(dev, VkShaderStageFlags.Fragment, "#shaders.compose_with_shadows.frag.spv", constants)); #else cfg.AddShader(VkShaderStageFlags.Fragment, "#shaders.compose.frag.spv", constants); #endif composePipeline = new GraphicPipeline(cfg); } cfg.Shaders[1].Dispose(); //DEBUG DRAW use subpass of compose cfg.Shaders[1] = new ShaderInfo(dev, VkShaderStageFlags.Fragment, "#shaders.show_gbuff.frag.spv"); cfg.SubpassIndex = SP_COMPOSE; debugPipeline = new GraphicPipeline(cfg); cfg.DisposeShaders(); ////TONE MAPPING //cfg.shaders[1] = new ShaderInfo (VkShaderStageFlags.Fragment, "#shaders.tone_mapping.frag.spv"); //cfg.SubpassIndex = SP_TONE_MAPPING; //toneMappingPipeline = new GraphicPipeline (cfg); dsMain = descriptorPool.Allocate(descLayoutMain); dsGBuff = descriptorPool.Allocate(descLayoutGBuff); envCube = new EnvironmentCube(cubemapPath, gBuffPipeline.Layout, gQueue, renderPass); matrices.prefilteredCubeMipLevels = envCube.prefilterCube.CreateInfo.mipLevels; DescriptorSetWrites dsMainWrite = new DescriptorSetWrites(dsMain, descLayoutMain.Bindings.GetRange(0, 5).ToArray()); dsMainWrite.Write(dev, uboMatrices.Descriptor, envCube.irradianceCube.Descriptor, envCube.prefilterCube.Descriptor, envCube.lutBrdf.Descriptor, uboLights.Descriptor); #if WITH_SHADOWS dsMainWrite = new DescriptorSetWrites(dsMain, descLayoutMain.Bindings[6]); dsMainWrite.Write(dev, shadowMapRenderer.shadowMap.Descriptor); #endif }
void init(VkSampleCountFlags samples = VkSampleCountFlags.SampleCount4) { descriptorPool = new DescriptorPool(dev, 2, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer), new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler) ); descLayoutMatrix = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler) ); descLayoutTextures = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler) ); dsMats = descriptorPool.Allocate(descLayoutMatrix); GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, samples); cfg.Layout = new PipelineLayout(dev, descLayoutMatrix, descLayoutTextures); cfg.Layout.AddPushConstants( new VkPushConstantRange(VkShaderStageFlags.Vertex, (uint)Marshal.SizeOf <Matrix4x4> ()), new VkPushConstantRange(VkShaderStageFlags.Fragment, (uint)Marshal.SizeOf <Model.PbrMaterial> (), 64) ); cfg.RenderPass = new RenderPass(dev, swapChain.ColorFormat, dev.GetSuitableDepthFormat(), samples); cfg.AddVertexBinding <Model.Vertex> (0); cfg.SetVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32b32Sfloat, VkFormat.R32g32Sfloat); cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/pbrtest.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/pbrtest.frag.spv"); pipeline = new GraphicPipeline(cfg); cfg.ResetShadersAndVerticesInfos(); cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/FullScreenQuad.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/simpletexture.frag.spv"); cfg.blendAttachments[0] = new VkPipelineColorBlendAttachmentState(true); uiPipeline = new GraphicPipeline(cfg); uboMats = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, (ulong)Marshal.SizeOf <Matrices>()); uboMats.Map(); //permanent map DescriptorSetWrites uboUpdate = new DescriptorSetWrites(dsMats, descLayoutMatrix.Bindings[0]); uboUpdate.Write(dev, uboMats.Descriptor); cfg.Layout.SetName("Main Pipeline layout"); uboMats.SetName("uboMats"); descriptorPool.SetName("main pool"); descLayoutTextures.SetName("descLayoutTextures"); statPool = new PipelineStatisticsQueryPool(dev, VkQueryPipelineStatisticFlags.InputAssemblyVertices | VkQueryPipelineStatisticFlags.InputAssemblyPrimitives | VkQueryPipelineStatisticFlags.ClippingInvocations | VkQueryPipelineStatisticFlags.ClippingPrimitives | VkQueryPipelineStatisticFlags.FragmentShaderInvocations); timestampQPool = new TimestampQueryPool(dev); }
void init(float nearPlane, float farPlane, string cubemapPath) { init_renderpass(); descLayoutMain = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer), //matrices and params new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), //irradiance new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), //prefil new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), //lut brdf new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer), //lights new VkDescriptorSetLayoutBinding(5, VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer), //materials new VkDescriptorSetLayoutBinding(6, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), //shadow map new VkDescriptorSetLayoutBinding(7, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), //texture array new VkDescriptorSetLayoutBinding(8, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)); //uiImage descLayoutGBuff = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), //color + roughness new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), //emit + metal new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), //normals + AO new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), //Pos + depth new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment)); //hdr descLayoutMain.SetName("main"); descLayoutGBuff.SetName("GBuff"); using (GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, NUM_SAMPLES)) { cfg.rasterizationState.cullMode = VkCullModeFlags.Back; if (NUM_SAMPLES != VkSampleCountFlags.SampleCount1) { cfg.multisampleState.sampleShadingEnable = true; cfg.multisampleState.minSampleShading = 0.5f; } cfg.Cache = pipelineCache; cfg.Layout = new PipelineLayout(dev, new VkPushConstantRange[] { new VkPushConstantRange(VkShaderStageFlags.Vertex, (uint)Marshal.SizeOf <Matrix4x4> ()), new VkPushConstantRange(VkShaderStageFlags.Fragment, sizeof(int), 64) }, descLayoutMain, descLayoutGBuff); cfg.RenderPass = renderPass; //cfg.blendAttachments.Add (new VkPipelineColorBlendAttachmentState (false)); cfg.AddVertexBinding <PbrModelTexArray.Vertex> (0); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32b32Sfloat, VkFormat.R32g32Sfloat, VkFormat.R32g32Sfloat); cfg.AddVertexBinding <VkChess.InstanceData> (1, VkVertexInputRate.Instance); cfg.AddVertexAttributes(1, VkFormat.R32g32b32a32Sfloat, VkFormat.R32g32b32a32Sfloat, VkFormat.R32g32b32a32Sfloat, VkFormat.R32g32b32a32Sfloat, VkFormat.R32g32b32a32Sfloat); using (SpecializationInfo constants = new SpecializationInfo( new SpecializationConstant <float> (0, nearPlane), new SpecializationConstant <float> (1, farPlane), new SpecializationConstant <int> (2, MAX_MATERIAL_COUNT))) { cfg.AddShader(dev, VkShaderStageFlags.Vertex, "#vkChess.net.GBuffPbrInstanced.vert.spv"); cfg.SubpassIndex = SP_DEPTH_PREPASS; depthPrepassPipeline = new GraphicPipeline(cfg, "Depth prepass"); cfg.depthStencilState.depthCompareOp = VkCompareOp.Equal; cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.SubpassIndex = SP_MODELS; cfg.AddShader(dev, VkShaderStageFlags.Fragment, "#vkChess.net.GBuffPbrTexArray.frag.spv", constants); gBuffPipeline = new GraphicPipeline(cfg, "GBuff"); } cfg.rasterizationState.cullMode = VkCullModeFlags.Front; //COMPOSE PIPELINE cfg.blendAttachments.Clear(); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.ResetShadersAndVerticesInfos(); cfg.SubpassIndex = SP_COMPOSE; cfg.Layout = gBuffPipeline.Layout; cfg.depthStencilState.depthTestEnable = false; cfg.depthStencilState.depthWriteEnable = false; using (SpecializationInfo constants = new SpecializationInfo( new SpecializationConstant <uint> (0, (uint)lights.Length), new SpecializationConstant <float> (1, 0.25f))) { cfg.AddShader(dev, VkShaderStageFlags.Vertex, "#vke.FullScreenQuad.vert.spv"); cfg.AddShader(dev, VkShaderStageFlags.Fragment, "#vkChess.net.compose_with_shadows.frag.spv", constants); composePipeline = new GraphicPipeline(cfg, "compose"); } //DEBUG DRAW use subpass of compose cfg.ReplaceShader(1, new ShaderInfo(dev, VkShaderStageFlags.Fragment, "#vkChess.net.show_gbuff.frag.spv")); cfg.SubpassIndex = SP_COMPOSE; debugPipeline = new GraphicPipeline(cfg, "debug"); //TONE MAPPING cfg.ReplaceShader(1, new ShaderInfo(dev, VkShaderStageFlags.Fragment, "#vkChess.net.tone_mapping.frag.spv")); cfg.SubpassIndex = SP_TONE_MAPPING; toneMappingPipeline = new GraphicPipeline(cfg, "tonne mapping"); } dsMain = descriptorPool.Allocate(descLayoutMain); dsGBuff = descriptorPool.Allocate(descLayoutGBuff); envCube = new vke.Environment.EnvironmentCube(cubemapPath, gBuffPipeline.Layout, presentQueue, renderPass); matrices.prefilteredCubeMipLevels = envCube.prefilterCube.CreateInfo.mipLevels; DescriptorSetWrites dsMainWrite = new DescriptorSetWrites(dsMain, descLayoutMain.Bindings.GetRange(0, 5).ToArray()); dsMainWrite.Write(dev, uboMatrices.Descriptor, envCube.irradianceCube.Descriptor, envCube.prefilterCube.Descriptor, envCube.lutBrdf.Descriptor, uboLights.Descriptor); dsMainWrite = new DescriptorSetWrites(dsMain, descLayoutMain.Bindings[6]); dsMainWrite.Write(dev, shadowMapRenderer.shadowMap.Descriptor); }
void init() { //Shadow map renderpass shadowPass = new RenderPass(dev, VkSampleCountFlags.SampleCount1); shadowPass.AddAttachment(SHADOWMAP_FORMAT, VkImageLayout.DepthStencilReadOnlyOptimal, SHADOWMAP_NUM_SAMPLES); shadowPass.ClearValues.Add(new VkClearValue { depthStencil = new VkClearDepthStencilValue(1.0f, 0) }); SubPass subpass0 = new SubPass(); subpass0.SetDepthReference(0); shadowPass.AddSubpass(subpass0); shadowPass.AddDependency(Vk.SubpassExternal, 0, VkPipelineStageFlags.FragmentShader, VkPipelineStageFlags.EarlyFragmentTests, VkAccessFlags.ShaderRead, VkAccessFlags.DepthStencilAttachmentWrite); shadowPass.AddDependency(0, Vk.SubpassExternal, VkPipelineStageFlags.LateFragmentTests, VkPipelineStageFlags.FragmentShader, VkAccessFlags.DepthStencilAttachmentWrite, VkAccessFlags.ShaderRead); descLayoutShadow = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Geometry, VkDescriptorType.UniformBuffer), //matrices new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Geometry, VkDescriptorType.UniformBuffer)); //lights GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList); cfg.rasterizationState.cullMode = VkCullModeFlags.Back; cfg.rasterizationState.depthBiasEnable = true; cfg.dynamicStates.Add(VkDynamicState.DepthBias); cfg.RenderPass = shadowPass; cfg.Layout = new PipelineLayout(dev, descLayoutShadow); cfg.Layout.AddPushConstants( new VkPushConstantRange(VkShaderStageFlags.Vertex, (uint)Marshal.SizeOf <Matrix4x4> ()) ); cfg.AddVertexBinding <PbrModel.Vertex> (0); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat); cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/shadow.vert.spv"); cfg.AddShader(VkShaderStageFlags.Geometry, "shaders/shadow.geom.spv"); shadowPipeline = new GraphicPipeline(cfg); //shadow map image shadowMap = new Image(dev, SHADOWMAP_FORMAT, VkImageUsageFlags.DepthStencilAttachment | VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, SHADOWMAP_SIZE, SHADOWMAP_SIZE, VkImageType.Image2D, SHADOWMAP_NUM_SAMPLES, VkImageTiling.Optimal, 1, (uint)renderer.lights.Length); shadowMap.CreateView(VkImageViewType.ImageView2DArray, VkImageAspectFlags.Depth, shadowMap.CreateInfo.arrayLayers); shadowMap.CreateSampler(VkSamplerAddressMode.ClampToBorder); shadowMap.Descriptor.imageLayout = VkImageLayout.DepthStencilReadOnlyOptimal; fbShadowMap = new Framebuffer(shadowPass, SHADOWMAP_SIZE, SHADOWMAP_SIZE, (uint)renderer.lights.Length); fbShadowMap.attachments.Add(shadowMap); fbShadowMap.Activate(); dsShadow = descriptorPool.Allocate(descLayoutShadow); DescriptorSetWrites dsWrite = new DescriptorSetWrites(dsShadow, descLayoutShadow); dsWrite.Write(dev, renderer.uboMatrices.Descriptor, renderer.uboLights.Descriptor); }
public Program() : base() { #if DEBUG dbgReport = new DebugReport(instance, VkDebugReportFlagsEXT.ErrorEXT | VkDebugReportFlagsEXT.DebugEXT | VkDebugReportFlagsEXT.WarningEXT | VkDebugReportFlagsEXT.PerformanceWarningEXT ); #endif imgResult = new Image(dev, VkFormat.R32g32b32a32Sfloat, VkImageUsageFlags.TransferDst | VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, IMG_DIM, IMG_DIM); imgResult.CreateView(); imgResult.CreateSampler(VkFilter.Nearest, VkFilter.Nearest, VkSamplerMipmapMode.Nearest, VkSamplerAddressMode.ClampToBorder); imgResult.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; staggingVBO = new HostBuffer <Vector2> (dev, VkBufferUsageFlags.TransferSrc, MAX_VERTICES); staggingVBO.Map(); vbo = new GPUBuffer <Vector2> (dev, VkBufferUsageFlags.VertexBuffer | VkBufferUsageFlags.StorageBuffer | VkBufferUsageFlags.TransferDst, MAX_VERTICES); ibo = new GPUBuffer <uint> (dev, VkBufferUsageFlags.IndexBuffer | VkBufferUsageFlags.StorageBuffer, MAX_VERTICES * 3); inBuff = new GPUBuffer <float> (dev, VkBufferUsageFlags.StorageBuffer | VkBufferUsageFlags.TransferSrc | VkBufferUsageFlags.TransferDst, (int)data_size); outBuff = new GPUBuffer <float> (dev, VkBufferUsageFlags.StorageBuffer | VkBufferUsageFlags.TransferSrc | VkBufferUsageFlags.TransferDst, (int)data_size); dsPool = new DescriptorPool(dev, 4, new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler), new VkDescriptorPoolSize(VkDescriptorType.StorageBuffer, 6)); dslImage = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler) ); dslCompute = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer) ); dslVAO = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Compute, VkDescriptorType.StorageBuffer) ); plInit = new ComputePipeline( new PipelineLayout(dev, new VkPushConstantRange(VkShaderStageFlags.Compute, 3 * sizeof(int)), dslCompute, dslVAO), "shaders/init.comp.spv"); plCompute = new ComputePipeline(plInit.Layout, "shaders/computeTest.comp.spv"); plNormalize = new ComputePipeline(plInit.Layout, "shaders/normalize.comp.spv"); GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, VkSampleCountFlags.SampleCount1); cfg.Layout = new PipelineLayout(dev, dslImage); cfg.RenderPass = new RenderPass(dev, swapChain.ColorFormat, dev.GetSuitableDepthFormat(), VkSampleCountFlags.SampleCount1); cfg.RenderPass.ClearValues[0] = new VkClearValue { color = new VkClearColorValue(0.1f, 0.1f, 0.1f) }; cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/FullScreenQuad.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/simpletexture.frag.spv"); cfg.blendAttachments[0] = new VkPipelineColorBlendAttachmentState(true); grPipeline = new GraphicPipeline(cfg); cfg.ResetShadersAndVerticesInfos(); cfg.Layout = new PipelineLayout(dev, new VkPushConstantRange(VkShaderStageFlags.Vertex, 4 * sizeof(int))); cfg.inputAssemblyState.topology = VkPrimitiveTopology.LineStrip; cfg.AddVertexBinding <Vector2> (0); cfg.SetVertexAttributes(0, VkFormat.R32g32Sfloat); cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/triangle.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/triangle.frag.spv"); trianglesPipeline = new GraphicPipeline(cfg); dsImage = dsPool.Allocate(dslImage); dsPing = dsPool.Allocate(dslCompute); dsPong = dsPool.Allocate(dslCompute); dsVAO = dsPool.Allocate(dslCompute); DescriptorSetWrites dsUpdate = new DescriptorSetWrites(dsPing, dslCompute); dsUpdate.Write(dev, inBuff.Descriptor, outBuff.Descriptor); dsUpdate.Write(dev, dsPong, outBuff.Descriptor, inBuff.Descriptor); dsUpdate = new DescriptorSetWrites(dsImage, dslImage); dsUpdate.Write(dev, imgResult.Descriptor); dsUpdate = new DescriptorSetWrites(dsVAO, dslVAO); dsUpdate.Write(dev, vbo.Descriptor, ibo.Descriptor); UpdateFrequency = 5; addPoint(IMG_DIM / 2 - 1, IMG_DIM / 2 - 1); }
public Image generateCubeMap(Queue staggingQ, CommandPool cmdPool, CBTarget target) { const float deltaPhi = (2.0f * (float)Math.PI) / 180.0f; const float deltaTheta = (0.5f * (float)Math.PI) / 64.0f; VkFormat format = VkFormat.R32g32b32a32Sfloat; uint dim = 64; if (target == CBTarget.PREFILTEREDENV) { format = VkFormat.R16g16b16a16Sfloat; dim = 512; } uint numMips = (uint)Math.Floor(Math.Log(dim, 2)) + 1; Image imgFbOffscreen = new Image(Dev, format, VkImageUsageFlags.TransferSrc | VkImageUsageFlags.ColorAttachment, VkMemoryPropertyFlags.DeviceLocal, dim, dim); imgFbOffscreen.SetName("offscreenfb"); imgFbOffscreen.CreateView(); Image cmap = new Image(Dev, format, VkImageUsageFlags.TransferDst | VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, dim, dim, VkImageType.Image2D, VkSampleCountFlags.SampleCount1, VkImageTiling.Optimal, numMips, 6, 1, VkImageCreateFlags.CubeCompatible); if (target == CBTarget.PREFILTEREDENV) { cmap.SetName("prefilterenvmap"); } else { cmap.SetName("irradianceCube"); } cmap.CreateView(VkImageViewType.Cube, VkImageAspectFlags.Color, 6, 0); cmap.CreateSampler(VkSamplerAddressMode.ClampToEdge); DescriptorPool dsPool = new DescriptorPool(Dev, 2, new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler)); DescriptorSetLayout dsLayout = new DescriptorSetLayout(Dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)); GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, VkSampleCountFlags.SampleCount1, false); cfg.Layout = new PipelineLayout(Dev, dsLayout); cfg.Layout.AddPushConstants( new VkPushConstantRange(VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, (uint)Marshal.SizeOf <Matrix4x4> () + 8)); cfg.RenderPass = new RenderPass(Dev); cfg.RenderPass.AddAttachment(format, VkImageLayout.ColorAttachmentOptimal); cfg.RenderPass.ClearValues.Add(new VkClearValue { color = new VkClearColorValue(0, 0, 0) }); cfg.RenderPass.AddSubpass(new SubPass(VkImageLayout.ColorAttachmentOptimal)); cfg.AddVertexBinding(0, 3 * sizeof(float)); cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat); cfg.AddShaders(new ShaderInfo(Dev, VkShaderStageFlags.Vertex, "#EnvironmentPipeline.filtercube.vert.spv")); if (target == CBTarget.PREFILTEREDENV) { cfg.AddShaders(new ShaderInfo(Dev, VkShaderStageFlags.Fragment, "#EnvironmentPipeline.prefilterenvmap.frag.spv")); } else { cfg.AddShaders(new ShaderInfo(Dev, VkShaderStageFlags.Fragment, "#EnvironmentPipeline.irradiancecube.frag.spv")); } Matrix4x4[] matrices = { // POSITIVE_X Matrix4x4.CreateRotationX(Utils.DegreesToRadians(180)) * Matrix4x4.CreateRotationY(Utils.DegreesToRadians(90)), // NEGATIVE_X Matrix4x4.CreateRotationX(Utils.DegreesToRadians(180)) * Matrix4x4.CreateRotationY(Utils.DegreesToRadians(-90)), // POSITIVE_Y Matrix4x4.CreateRotationX(Utils.DegreesToRadians(-90)), // NEGATIVE_Y Matrix4x4.CreateRotationX(Utils.DegreesToRadians(90)), // POSITIVE_Z Matrix4x4.CreateRotationX(Utils.DegreesToRadians(180)), // NEGATIVE_Z Matrix4x4.CreateRotationZ(Utils.DegreesToRadians(180)) }; VkImageSubresourceRange subRes = new VkImageSubresourceRange(VkImageAspectFlags.Color, 0, numMips, 0, 6); using (GraphicPipeline pl = new GraphicPipeline(cfg)) { cfg.Dispose(); DescriptorSet dset = dsPool.Allocate(dsLayout); DescriptorSetWrites dsUpdate = new DescriptorSetWrites(dsLayout); dsUpdate.Write(Dev, dset, cubemap.Descriptor); Dev.WaitIdle(); using (FrameBuffer fb = new FrameBuffer(pl.RenderPass, dim, dim, imgFbOffscreen)) { PrimaryCommandBuffer cmd = cmdPool.AllocateCommandBuffer(); cmd.Start(VkCommandBufferUsageFlags.OneTimeSubmit); cmap.SetLayout(cmd, VkImageLayout.Undefined, VkImageLayout.TransferDstOptimal, subRes); float roughness = 0; cmd.SetScissor(dim, dim); cmd.SetViewport((float)(dim), (float)dim); for (int m = 0; m < numMips; m++) { roughness = (float)m / ((float)numMips - 1f); for (int f = 0; f < 6; f++) { pl.RenderPass.Begin(cmd, fb); pl.Bind(cmd); float viewPortSize = (float)Math.Pow(0.5, m) * dim; cmd.SetViewport(viewPortSize, viewPortSize); cmd.PushConstant(pl.Layout, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, matrices[f] * Matrix4x4.CreatePerspectiveFieldOfView(Utils.DegreesToRadians(90), 1f, 0.1f, 512f)); if (target == CBTarget.IRRADIANCE) { cmd.PushConstant(pl.Layout, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, deltaPhi, (uint)Marshal.SizeOf <Matrix4x4> ()); 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, 64u, (uint)Marshal.SizeOf <Matrix4x4> () + 4); } cmd.BindDescriptorSet(pl.Layout, dset); cmd.BindVertexBuffer(vboSkybox); cmd.Draw(36); pl.RenderPass.End(cmd); imgFbOffscreen.SetLayout(cmd, VkImageAspectFlags.Color, VkImageLayout.ColorAttachmentOptimal, VkImageLayout.TransferSrcOptimal); VkImageCopy region = new VkImageCopy(); region.srcSubresource = new VkImageSubresourceLayers(VkImageAspectFlags.Color, 1); region.dstSubresource = new VkImageSubresourceLayers(VkImageAspectFlags.Color, 1, (uint)m, (uint)f); region.extent = new VkExtent3D { width = (uint)viewPortSize, height = (uint)viewPortSize, depth = 1 }; Vk.vkCmdCopyImage(cmd.Handle, imgFbOffscreen.Handle, VkImageLayout.TransferSrcOptimal, cmap.Handle, VkImageLayout.TransferDstOptimal, 1, region.Pin()); region.Unpin(); imgFbOffscreen.SetLayout(cmd, VkImageAspectFlags.Color, VkImageLayout.TransferSrcOptimal, VkImageLayout.ColorAttachmentOptimal); } } cmap.SetLayout(cmd, VkImageLayout.TransferDstOptimal, VkImageLayout.ShaderReadOnlyOptimal, subRes); cmd.End(); staggingQ.Submit(cmd); staggingQ.WaitIdle(); cmd.Free(); } } cmap.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; dsLayout.Dispose(); imgFbOffscreen.Dispose(); dsPool.Dispose(); return(cmap); }
void init() { renderPass = new RenderPass(dev); renderPass.AddAttachment(swapChain.ColorFormat, VkImageLayout.ColorAttachmentOptimal, VkSampleCountFlags.SampleCount1); renderPass.AddAttachment(dev.GetSuitableDepthFormat(), VkImageLayout.DepthStencilAttachmentOptimal, samples); renderPass.AddAttachment(VkFormat.R8g8b8a8Unorm, VkImageLayout.ColorAttachmentOptimal); renderPass.AddAttachment(VkFormat.R8g8b8a8Unorm, VkImageLayout.ColorAttachmentOptimal); renderPass.AddAttachment(VkFormat.R16g16b16a16Sfloat, VkImageLayout.ColorAttachmentOptimal); renderPass.AddAttachment(VkFormat.R16g16b16a16Sfloat, VkImageLayout.ColorAttachmentOptimal); 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 { 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) }); renderPass.ClearValues.Add(new VkClearValue { color = new VkClearColorValue(0.0f, 0.0f, 0.0f) }); SubPass[] subpass = { new SubPass(), new SubPass() }; subpass[0].AddColorReference(new VkAttachmentReference(2, VkImageLayout.ColorAttachmentOptimal), new VkAttachmentReference(3, VkImageLayout.ColorAttachmentOptimal), new VkAttachmentReference(4, VkImageLayout.ColorAttachmentOptimal), new VkAttachmentReference(5, VkImageLayout.ColorAttachmentOptimal)); subpass[0].SetDepthReference(1, VkImageLayout.DepthStencilAttachmentOptimal); subpass[1].AddColorReference(0, VkImageLayout.ColorAttachmentOptimal); subpass[1].AddInputReference(new VkAttachmentReference(2, VkImageLayout.ShaderReadOnlyOptimal), new VkAttachmentReference(3, VkImageLayout.ShaderReadOnlyOptimal), new VkAttachmentReference(4, VkImageLayout.ShaderReadOnlyOptimal), new VkAttachmentReference(5, VkImageLayout.ShaderReadOnlyOptimal)); renderPass.AddSubpass(subpass); renderPass.AddDependency(Vk.SubpassExternal, 0, VkPipelineStageFlags.BottomOfPipe, VkPipelineStageFlags.ColorAttachmentOutput, VkAccessFlags.MemoryRead, VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite); renderPass.AddDependency(0, 1, VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader, VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.ShaderRead); renderPass.AddDependency(1, Vk.SubpassExternal, VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.BottomOfPipe, VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite, VkAccessFlags.MemoryRead); descriptorPool = new DescriptorPool(dev, 3, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer, 2), new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler, 3), new VkDescriptorPoolSize(VkDescriptorType.InputAttachment, 4) ); descLayoutMain = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Vertex | VkShaderStageFlags.Fragment, VkDescriptorType.UniformBuffer), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler)); descLayoutModelTextures = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler), new VkDescriptorSetLayoutBinding(4, VkShaderStageFlags.Fragment, VkDescriptorType.CombinedImageSampler) ); descLayoutGBuff = new DescriptorSetLayout(dev, new VkDescriptorSetLayoutBinding(0, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), new VkDescriptorSetLayoutBinding(1, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), new VkDescriptorSetLayoutBinding(2, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment), new VkDescriptorSetLayoutBinding(3, VkShaderStageFlags.Fragment, VkDescriptorType.InputAttachment)); dsMain = descriptorPool.Allocate(descLayoutMain); dsGBuff = descriptorPool.Allocate(descLayoutGBuff); GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, samples); cfg.Layout = new PipelineLayout(dev, descLayoutMain, descLayoutModelTextures, descLayoutGBuff); cfg.Layout.AddPushConstants( new VkPushConstantRange(VkShaderStageFlags.Vertex, (uint)Marshal.SizeOf <Matrix4x4> ()), new VkPushConstantRange(VkShaderStageFlags.Fragment, sizeof(int), 64) ); cfg.RenderPass = renderPass; cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.AddVertexBinding <Model.Vertex> (0); cfg.SetVertexAttributes(0, VkFormat.R32g32b32Sfloat, VkFormat.R32g32b32Sfloat, VkFormat.R32g32Sfloat); cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/pbrtest.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/GBuffPbr.frag.spv"); gBuffPipeline = new GraphicPipeline(cfg); cfg.blendAttachments.Clear(); cfg.blendAttachments.Add(new VkPipelineColorBlendAttachmentState(false)); cfg.ResetShadersAndVerticesInfos(); cfg.SubpassIndex = 1; cfg.Layout = gBuffPipeline.Layout; cfg.depthStencilState.depthTestEnable = false; cfg.depthStencilState.depthWriteEnable = false; cfg.AddShader(VkShaderStageFlags.Vertex, "shaders/FullScreenQuad.vert.spv"); cfg.AddShader(VkShaderStageFlags.Fragment, "shaders/pbrtest.frag.spv"); composePipeline = new GraphicPipeline(cfg); envCube = new EnvironmentCube(presentQueue, renderPass); uboMats = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, (ulong)Marshal.SizeOf <Matrices> () * 2); uboMats.Map(); //permanent map DescriptorSetWrites uboUpdate = new DescriptorSetWrites(descLayoutMain); uboUpdate.Write(dev, dsMain, uboMats.Descriptor, envCube.lutBrdf.Descriptor, envCube.irradianceCube.Descriptor, envCube.prefilterCube.Descriptor); uboMats.Descriptor.offset = (ulong)Marshal.SizeOf <Matrices> (); envCube.WriteDesc(uboMats.Descriptor); #if DEBUG debugDraw = new DebugDrawPipeline(dev, descLayoutMain, swapChain.ColorFormat); debugDraw.AddLine(Vector3.Zero, new Vector3(matrices.lightPos.X, matrices.lightPos.Y, matrices.lightPos.Z) * 3, 1, 1, 1); debugDraw.AddLine(Vector3.Zero, Vector3.UnitX, 1, 0, 0); debugDraw.AddLine(Vector3.Zero, Vector3.UnitY, 0, 1, 0); debugDraw.AddLine(Vector3.Zero, Vector3.UnitZ, 0, 0, 1); #endif model = new Model(presentQueue, "../data/models/DamagedHelmet/glTF/DamagedHelmet.gltf"); //model = new Model (presentQueue, "../data/models/chess.gltf"); //model = new Model (presentQueue, "../data/models/Sponza/glTF/Sponza.gltf"); //model = new Model (dev, presentQueue, "../data/models/icosphere.gltf"); //model = new Model (dev, presentQueue, cmdPool, "../data/models/cube.gltf"); model.WriteMaterialsDescriptorSets(descLayoutModelTextures, VK.AttachmentType.Color, VK.AttachmentType.Normal, VK.AttachmentType.AmbientOcclusion, VK.AttachmentType.PhysicalProps, VK.AttachmentType.Emissive); }