Пример #1
0
        VkDescriptorSet CreateDescriptorSet(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
        {
            VkDescriptorPool descriptorPool;
            {
                // this pool can allocate one uniform descriptor.
                var info = new VkDescriptorPoolCreateInfo {
                    sType = VkStructureType.DescriptorPoolCreateInfo
                };
                var size = new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer, 1);
                info.poolSizes = size;
                info.maxSets   = 1;
                vkAPI.vkCreateDescriptorPool(device, &info, null, &descriptorPool).Check();
                info.Free();
            }
            VkDescriptorSet descriptorSet;

            {
                var info = new VkDescriptorSetAllocateInfo {
                    sType = VkStructureType.DescriptorSetAllocateInfo
                };
                info.setLayouts     = descriptorSetLayout;
                info.descriptorPool = descriptorPool;
                vkAPI.vkAllocateDescriptorSets(device, &info, &descriptorSet).Check();
                info.Free();
            }

            return(descriptorSet);
        }
Пример #2
0
        private static VkDescriptorPool CreateDescriptorPool(VkDevice device, uint swapchainImageCount, uint textureCount)
        {
            VkDescriptorPoolSize[] sizes = new VkDescriptorPoolSize[2];
            sizes[0] = new VkDescriptorPoolSize();
            sizes[0].descriptorCount = swapchainImageCount * textureCount;
            sizes[0].type            = VkDescriptorType.CombinedImageSampler;

            sizes[1] = new VkDescriptorPoolSize();
            sizes[1].descriptorCount = swapchainImageCount * 1;
            sizes[1].type            = VkDescriptorType.UniformBuffer;

            VkDescriptorPoolCreateInfo createInfo = VkDescriptorPoolCreateInfo.New();

            createInfo.poolSizeCount = 2;

            fixed(VkDescriptorPoolSize *ptr = sizes)
            createInfo.pPoolSizes = ptr;

            createInfo.maxSets = swapchainImageCount;

            VkDescriptorPool pool = VkDescriptorPool.Null;

            Assert(vkCreateDescriptorPool(device, &createInfo, null, &pool));
            return(pool);
        }
Пример #3
0
 public DescriptorPool(Device dev, VkDescriptorPoolCreateFlag flags, uint maxSets,
                       Dictionary <VkDescriptorType, uint> countByType)
 {
     unsafe
     {
         var pools = stackalloc VkDescriptorPoolSize[countByType.Count];
         var i     = 0;
         foreach (var kv in countByType)
         {
             pools[i++] = new VkDescriptorPoolSize()
             {
                 Type            = kv.Key,
                 DescriptorCount = kv.Value
             }
         }
         ;
         Device = dev;
         var info = new VkDescriptorPoolCreateInfo()
         {
             SType         = VkStructureType.DescriptorPoolCreateInfo,
             Flags         = flags,
             MaxSets       = maxSets,
             PNext         = IntPtr.Zero,
             PoolSizeCount = (uint)countByType.Count,
             PPoolSizes    = pools
         };
         Handle = dev.Handle.CreateDescriptorPool(&info, dev.Instance.AllocationCallbacks);
     }
 }
Пример #4
0
        public static VkDescriptorPoolSize descriptorPoolSize(
            VkDescriptorType type,
            uint descriptorCount)
        {
            VkDescriptorPoolSize descriptorPoolSize = new VkDescriptorPoolSize();

            descriptorPoolSize.type            = type;
            descriptorPoolSize.descriptorCount = descriptorCount;
            return(descriptorPoolSize);
        }
        private void PrepareDescriptor(VkDevice device)
        {
            // 定数バッファを1つだけ持つものを作る.
            VkDescriptorPoolSize descriptorPoolSize = new VkDescriptorPoolSize()
            {
                descriptorCount = 1,
                type            = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            };
            var descriptorPoolCreateInfo = new VkDescriptorPoolCreateInfo()
            {
                poolSizes = new[] { descriptorPoolSize },
                maxSets   = 1,
                flags     = VkDescriptorPoolCreateFlags.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
            };

            VulkanAPI.vkCreateDescriptorPool(device, ref descriptorPoolCreateInfo, out m_descriptorPool);

            // ディスクリプタセットレイアウトの作成.
            // 今は定数バッファを1つ持つだけのものを作成.
            var descriptorLayoutBinding = new VkDescriptorSetLayoutBinding();

            descriptorLayoutBinding.binding         = 0;
            descriptorLayoutBinding.descriptorCount = 1;
            descriptorLayoutBinding.descriptorType  = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
            descriptorLayoutBinding.stageFlags      = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT;

            var descriptorSetLayoutCreateInfo = new VkDescriptorSetLayoutCreateInfo();

            descriptorSetLayoutCreateInfo.bindings = new[] { descriptorLayoutBinding };
            VulkanAPI.vkCreateDescriptorSetLayout(device, ref descriptorSetLayoutCreateInfo, out m_descriptorSetLayout);

            // ディスクリプタセットを作成.
            VkDescriptorSet[] descriptorSets;
            var descriptorSetAllocateInfo = new VkDescriptorSetAllocateInfo(m_descriptorPool, new[] { m_descriptorSetLayout });

            VulkanAPI.vkAllocateDescriptorSets(device, ref descriptorSetAllocateInfo, out descriptorSets);
            m_descriptorSet = descriptorSets[0];

            // ディスクリプタを更新.
            // 定数バッファ1つを持つレイアウトでディスクリプタを作る.
            VkDescriptorBufferInfo descUniformBufferInfo = new VkDescriptorBufferInfo();

            descUniformBufferInfo.buffer = m_uniformBuffer;
            descUniformBufferInfo.range  = Marshal.SizeOf <Transform>();
            var descriptor = new VkWriteDescriptorSet();

            descriptor.descriptorCount = 1;
            descriptor.descriptorType  = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
            descriptor.pBufferInfo     = new[] { descUniformBufferInfo };
            descriptor.dstBinding      = 0;
            descriptor.dstSet          = m_descriptorSet;
            VulkanAPI.vkUpdateDescriptorSets(device, new[] { descriptor }, null);
        }
Пример #6
0
        void setupDescriptorPool()
        {
            // Example uses one ubo
            VkDescriptorPoolSize poolSizes = Initializers.descriptorPoolSize(VkDescriptorType.UniformBuffer, 1);

            VkDescriptorPoolCreateInfo descriptorPoolInfo =
                Initializers.descriptorPoolCreateInfo(
                    1,
                    &poolSizes,
                    2);

            Util.CheckResult(vkCreateDescriptorPool(device, &descriptorPoolInfo, null, out descriptorPool));
        }
Пример #7
0
        void setupDescriptorPool()
        {
            VkDescriptorPoolSize poolSizes = new VkDescriptorPoolSize()
            {
                type = VkDescriptorType.UniformBuffer, descriptorCount = 1
            };

            VkDescriptorPoolCreateInfo descriptorPoolInfo =
                VkDescriptorPoolCreateInfo.New();

            descriptorPoolInfo.poolSizeCount = 1;
            descriptorPoolInfo.pPoolSizes    = &poolSizes;
            descriptorPoolInfo.maxSets       = 2;

            Util.CheckResult(vkCreateDescriptorPool(Device, &descriptorPoolInfo, null, out descriptorPool));
        }
Пример #8
0
        void CreateDescriptorPool()
        {
            var poolSize = new VkDescriptorPoolSize();

            poolSize.type            = VkDescriptorType.UniformBuffer;
            poolSize.descriptorCount = 1;

            var info = new VkDescriptorPoolCreateInfo();

            info.poolSizes = new List <VkDescriptorPoolSize> {
                poolSize
            };
            info.maxSets = 1;

            descriptorPool = new VkDescriptorPool(device, info);
        }
Пример #9
0
        void setupDescriptorPool()
        {
            // Example uses one ubo and one image sampler
            var poolSizes = new VkDescriptorPoolSize[2];

            poolSizes[0].type            = VkDescriptorType.UniformBuffer;
            poolSizes[0].descriptorCount = 1;
            poolSizes[1].type            = VkDescriptorType.CombinedImageSampler;
            poolSizes[1].descriptorCount = 1;

            var poolInfo = VkDescriptorPoolCreateInfo.Alloc();

            poolInfo[0].poolSizes = poolSizes;
            poolInfo[0].maxSets   = 2;
            {
                VkDescriptorPool pool;
                vkCreateDescriptorPool(device, poolInfo, null, &pool);
                descriptorPool = pool;
            }
        }
        void setupDescriptorPool()
        {
            // Example uses one ubo and one image sampler
            var poolSizes = new VkDescriptorPoolSize[] {
                new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer, 1),
                new VkDescriptorPoolSize(VkDescriptorType.UniformBufferDynamic, 1),
                new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler, 1),
            };

            var info = new VkDescriptorPoolCreateInfo();

            info.sType     = DescriptorPoolCreateInfo;
            info.poolSizes = poolSizes;
            info.maxSets   = 2;

            VkDescriptorPool pool;

            vkCreateDescriptorPool(device, &info, null, &pool);
            this.descriptorPool = pool;
        }
Пример #11
0
        void setupDescriptorPool()
        {
            // Example uses three ubos and one image sampler
            var poolSizes = new VkDescriptorPoolSize[2];

            poolSizes[0].type            = VkDescriptorType.UniformBuffer;
            poolSizes[0].descriptorCount = 4;
            poolSizes[1].type            = VkDescriptorType.CombinedImageSampler;
            poolSizes[1].descriptorCount = 6;

            var descriptorPoolInfo = VkDescriptorPoolCreateInfo.Alloc();

            descriptorPoolInfo->poolSizes = poolSizes;
            descriptorPoolInfo->maxSets   = 2;

            VkDescriptorPool pool;

            vkCreateDescriptorPool(device, descriptorPoolInfo, null, &pool);
            this.descriptorPool = pool;
            Marshal.FreeHGlobal((IntPtr)descriptorPoolInfo);
        }
Пример #12
0
        private void PrepareDescriptor(VkDevice device)
        {
            // 今は定数バッファを1つを格納できるだけのディスクリプタプールを準備.
            var descriptorPoolSize = new VkDescriptorPoolSize()
            {
                descriptorCount = 1,
                type            = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            };

            m_descriptorPool = m_resourceManager.CreateDescriptorPool(device, new[] { descriptorPoolSize }, 1);

            // ディスクリプタセットレイアウトの作成.
            //  - 定数バッファを1つ
            var descLayoutBinding = new VkDescriptorSetLayoutBinding()
            {
                binding         = 0,
                descriptorCount = 1,
                descriptorType  = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                stageFlags      = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT
            };

            m_descriptorSetLayout = m_resourceManager.CreateDescriptorSetLayout(device, new[] { descLayoutBinding });

            // ディスクリプタを作成&更新.
            VkDescriptorSet[] descriptorSets;
            var descriptorSetAllocateInfo = new VkDescriptorSetAllocateInfo(m_descriptorPool, new[] { m_descriptorSetLayout });

            VulkanAPI.vkAllocateDescriptorSets(device, ref descriptorSetAllocateInfo, out descriptorSets);
            m_descriptorSet = descriptorSets[0];

            var descUniform = new VkDescriptorBufferInfo()
            {
                buffer = m_uniformBuffer,
                range  = Marshal.SizeOf <Transform>(),
            };
            var descForUniform   = SampleHelpers.CreateDescriptorFromUniformBuffer(0, descUniform, m_descriptorSet);
            var descriptorWrites = new[] { descForUniform };

            VulkanAPI.vkUpdateDescriptorSets(device, descriptorWrites, null);
        }
Пример #13
0
        void CreateDescriptorPool()
        {
            var size1 = new VkDescriptorPoolSize();

            size1.type            = VkDescriptorType.UniformBuffer;
            size1.descriptorCount = 1;

            var size2 = new VkDescriptorPoolSize();

            size2.type            = VkDescriptorType.CombinedImageSampler;
            size2.descriptorCount = 1;

            var poolSizes = new List <VkDescriptorPoolSize> {
                size1, size2
            };

            var info = new VkDescriptorPoolCreateInfo();

            info.poolSizes = poolSizes;
            info.maxSets   = 1;

            descriptorPool = new VkDescriptorPool(device, info);
        }
        private VkDescriptorPool CreateVulkanDescriptorPool()
        {
            VkDescriptorPool vulkanDescriptorPool = VK_NULL_HANDLE;
            var vulkanDescriptorPoolSizes         = Array.Empty <VkDescriptorPoolSize>();

            var descriptorPoolCreateInfo = new VkDescriptorPoolCreateInfo {
                sType   = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
                flags   = (uint)VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
                maxSets = 1,
            };

            var resources       = Resources;
            var resourcesLength = resources.Length;

            if (resourcesLength != 0)
            {
                var vulkanDescriptorPoolSizesCount = 0;
                var constantBufferCount            = 0;
                var textureCount = 0;

                for (var resourceIndex = 0; resourceIndex < resourcesLength; resourceIndex++)
                {
                    var resource = resources[resourceIndex];

                    switch (resource.Kind)
                    {
                    case GraphicsPipelineResourceKind.ConstantBuffer:
                    {
                        if (constantBufferCount == 0)
                        {
                            vulkanDescriptorPoolSizesCount++;
                        }
                        constantBufferCount++;
                        break;
                    }

                    case GraphicsPipelineResourceKind.Texture:
                    {
                        if (textureCount == 0)
                        {
                            vulkanDescriptorPoolSizesCount++;
                        }
                        textureCount++;
                        break;
                    }

                    default:
                    {
                        break;
                    }
                    }
                }

                vulkanDescriptorPoolSizes = new VkDescriptorPoolSize[vulkanDescriptorPoolSizesCount];
                var vulkanDescriptorPoolSizesIndex = 0;

                if (constantBufferCount != 0)
                {
                    vulkanDescriptorPoolSizes[vulkanDescriptorPoolSizesIndex] = new VkDescriptorPoolSize {
                        type            = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                        descriptorCount = unchecked ((uint)constantBufferCount),
                    };
                    vulkanDescriptorPoolSizesIndex++;
                }

                if (textureCount != 0)
                {
                    vulkanDescriptorPoolSizes[vulkanDescriptorPoolSizesIndex] = new VkDescriptorPoolSize {
                        type            = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                        descriptorCount = unchecked ((uint)textureCount),
                    };
                    vulkanDescriptorPoolSizesIndex++;
                }

                fixed(VkDescriptorPoolSize *pVulkanDescriptorPoolSizes = vulkanDescriptorPoolSizes)
                {
                    descriptorPoolCreateInfo.poolSizeCount = unchecked ((uint)vulkanDescriptorPoolSizes.Length);
                    descriptorPoolCreateInfo.pPoolSizes    = pVulkanDescriptorPoolSizes;

                    ThrowExternalExceptionIfNotSuccess(vkCreateDescriptorPool(Device.VulkanDevice, &descriptorPoolCreateInfo, pAllocator: null, (ulong *)&vulkanDescriptorPool), nameof(vkCreateDescriptorPool));
                }
            }

            return(vulkanDescriptorPool);
        }
Пример #15
0
        public unsafe DescriptorPool(DescriptorLayout layout, uint maxSets)
        {
            _device  = layout.Device;
            _layout  = layout;
            _maxSets = maxSets;

            var poolSizes = new List <VkDescriptorPoolSize>();

            foreach (var binding in layout.Bindings)
            {
                var poolSizeIndex = poolSizes.FindIndex(
                    p => p.type == binding.DescriptorType
                    );
                if (poolSizeIndex == -1)
                {
                    poolSizes.Add(new VkDescriptorPoolSize
                    {
                        type            = binding.DescriptorType,
                        descriptorCount = binding.DescriptorCounts
                    });
                }
                else
                {
                    poolSizes[poolSizeIndex] = new VkDescriptorPoolSize
                    {
                        type            = binding.DescriptorType,
                        descriptorCount = (
                            poolSizes[poolSizeIndex].descriptorCount +
                            binding.DescriptorCounts
                            )
                    };
                }
            }

            var vulkanPoolSizes = new NativeList <VkDescriptorPoolSize>();

            foreach (var p in poolSizes)
            {
                vulkanPoolSizes.Add(p);
            }

            var createInfo = new VkDescriptorPoolCreateInfo
            {
                sType         = VkStructureType.DescriptorPoolCreateInfo,
                maxSets       = maxSets,
                poolSizeCount = vulkanPoolSizes.Count,
                pPoolSizes    = (VkDescriptorPoolSize *)vulkanPoolSizes.Data.ToPointer()
            };

            VkDescriptorPool descriptorPool;

            if (VulkanNative.vkCreateDescriptorPool(
                    _device.Handle,
                    &createInfo,
                    null,
                    &descriptorPool
                    ) != VkResult.Success)
            {
                throw new Exception("failed to create descriptor pool");
            }
            _handle = descriptorPool;
        }
Пример #16
0
        private void PrepareDescriptor(VkDevice device)
        {
            // 今は定数バッファを1つ、サンプラーを1つを格納できるだけのディスクリプタプールを準備.
            VkDescriptorPoolSize descriptorPoolSize = new VkDescriptorPoolSize()
            {
                descriptorCount = 1,
                type            = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            };
            VkDescriptorPoolSize descriptorPoolSizeForSampler = new VkDescriptorPoolSize()
            {
                descriptorCount = 1,
                type            = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            };
            var descriptorPoolCreateInfo = new VkDescriptorPoolCreateInfo()
            {
                poolSizes = new[] { descriptorPoolSize, descriptorPoolSizeForSampler },
                maxSets   = 1,
                flags     = VkDescriptorPoolCreateFlags.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
            };

            VulkanAPI.vkCreateDescriptorPool(device, ref descriptorPoolCreateInfo, out m_descriptorPool);

            // ディスクリプタセットレイアウトの作成.
            //  - 定数バッファを1つ
            //  - テクスチャサンプラ1つ
            var descLayoutBindingForUniform = new VkDescriptorSetLayoutBinding();

            descLayoutBindingForUniform.binding         = 0;
            descLayoutBindingForUniform.descriptorCount = 1;
            descLayoutBindingForUniform.descriptorType  = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
            descLayoutBindingForUniform.stageFlags      = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT;
            var descLayoutBindingForSampler = new VkDescriptorSetLayoutBinding();

            descLayoutBindingForSampler.binding         = 1;
            descLayoutBindingForSampler.descriptorCount = 1;
            descLayoutBindingForSampler.descriptorType  = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
            descLayoutBindingForSampler.stageFlags      = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT;
            var descriptorSetLayoutCreateInfo = new VkDescriptorSetLayoutCreateInfo();

            descriptorSetLayoutCreateInfo.bindings = new[] {
                descLayoutBindingForUniform,
                descLayoutBindingForSampler
            };
            VulkanAPI.vkCreateDescriptorSetLayout(device, ref descriptorSetLayoutCreateInfo, out m_descriptorSetLayout);


            // ディスクリプタを作成&更新.
            VkDescriptorSet[] descriptorSets;
            var descriptorSetAllocateInfo = new VkDescriptorSetAllocateInfo(m_descriptorPool, new[] { m_descriptorSetLayout });

            VulkanAPI.vkAllocateDescriptorSets(device, ref descriptorSetAllocateInfo, out descriptorSets);
            m_descriptorSet = descriptorSets[0];

            var descUniform = new VkDescriptorBufferInfo()
            {
                buffer = m_uniformBuffer,
                range  = Marshal.SizeOf <Transform>(),
            };
            var descSampler = new VkDescriptorImageInfo()
            {
                imageView = m_imageView,
                sampler   = m_imageSampler,
            };
            var descForUniform   = SampleHelpers.CreateDescriptorFromUniformBuffer(0, descUniform, m_descriptorSet);
            var descForSampler   = SampleHelpers.CreateDescriptorFromImageSampler(1, descSampler, m_descriptorSet);
            var descriptorWrites = new[] { descForUniform, descForSampler };

            VulkanAPI.vkUpdateDescriptorSets(device, descriptorWrites, null);
        }