Esempio n. 1
0
        /// <summary>
        /// Create a new Image.
        /// </summary>
        /// <remarks>Initial layout will be automatically set to Undefined if tiling is optimal and Preinitialized if tiling is linear.</remarks>
        /// <param name="device">The logical device that create the image.</param>
        /// <param name="format">format and type of the texel blocks that will be contained in the image</param>
        /// <param name="usage">bitmask describing the intended usage of the image.</param>
        /// <param name="_memoryPropertyFlags">Memory property flags.</param>
        /// <param name="width">number of data in the X dimension of the image.</param>
        /// <param name="height">number of data in the Y dimension of the image.</param>
        /// <param name="type">value specifying the basic dimensionality of the image. Layers in array textures do not count as a dimension for the purposes of the image type.</param>
        /// <param name="samples">number of sample per texel.</param>
        /// <param name="tiling">tiling arrangement of the texel blocks in memory.</param>
        /// <param name="mipsLevels">describes the number of levels of detail available for minified sampling of the image.</param>
        /// <param name="layers">number of layers in the image.</param>
        /// <param name="depth">number of data in the Z dimension of the image</param>
        /// <param name="createFlags">bitmask describing additional parameters of the image.</param>
        /// <param name="sharingMode">value specifying the sharing mode of the image when it will be accessed by multiple queue families.</param>
        /// <param name="queuesFamillies">list of queue families that will access this image (ignored if sharingMode is not CONCURRENT).</param>
        public Image(Device device, VkFormat format, VkImageUsageFlags usage, VkMemoryPropertyFlags _memoryPropertyFlags,
                     uint width, uint height,
                     VkImageType type               = VkImageType.Image2D, VkSampleCountFlags samples = VkSampleCountFlags.SampleCount1,
                     VkImageTiling tiling           = VkImageTiling.Optimal, uint mipsLevels          = 1, uint layers = 1, uint depth = 1,
                     VkImageCreateFlags createFlags = 0, VkSharingMode sharingMode                    = VkSharingMode.Exclusive, params uint[] queuesFamillies)
            : base(device, _memoryPropertyFlags)
        {
            info.imageType     = type;
            info.format        = format;
            info.extent.width  = width;
            info.extent.height = height;
            info.extent.depth  = depth;
            info.mipLevels     = mipsLevels;
            info.arrayLayers   = layers;
            info.samples       = samples;
            info.tiling        = tiling;
            info.usage         = usage;
            info.initialLayout = (tiling == VkImageTiling.Optimal) ? VkImageLayout.Undefined : VkImageLayout.Preinitialized;
            info.sharingMode   = sharingMode;
            info.flags         = createFlags;

            this.queueFalillies = queuesFamillies;
            lastKnownLayout     = info.initialLayout;

            Activate();
        }
Esempio n. 2
0
        internal void TransitionImageLayout(
            VkCommandBuffer cb,
            uint baseMipLevel,
            uint levelCount,
            uint baseArrayLayer,
            uint layerCount,
            VkImageLayout newLayout)
        {
            if (_stagingBuffer != Vulkan.VkBuffer.Null)
            {
                return;
            }

            VkImageLayout oldLayout = _imageLayouts[CalculateSubresource(baseMipLevel, baseArrayLayer)];

#if DEBUG
            for (uint level = 0; level < levelCount; level++)
            {
                for (uint layer = 0; layer < layerCount; layer++)
                {
                    if (_imageLayouts[CalculateSubresource(baseMipLevel + level, baseArrayLayer + layer)] != oldLayout)
                    {
                        throw new VeldridException("Unexpected image layout.");
                    }
                }
            }
#endif
            if (oldLayout != newLayout)
            {
                VkImageAspectFlags aspectMask;
                if ((Usage & TextureUsage.DepthStencil) != 0)
                {
                    aspectMask       = FormatHelpers.IsStencilFormat(Format)
                        ? aspectMask = VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil
                        : aspectMask = VkImageAspectFlags.Depth;
                }
                else
                {
                    aspectMask = VkImageAspectFlags.Color;
                }
                VulkanUtil.TransitionImageLayout(
                    cb,
                    OptimalDeviceImage,
                    baseMipLevel,
                    levelCount,
                    baseArrayLayer,
                    layerCount,
                    aspectMask,
                    _imageLayouts[CalculateSubresource(baseMipLevel, baseArrayLayer)],
                    newLayout);

                for (uint level = 0; level < levelCount; level++)
                {
                    for (uint layer = 0; layer < layerCount; layer++)
                    {
                        _imageLayouts[CalculateSubresource(baseMipLevel + level, baseArrayLayer + layer)] = newLayout;
                    }
                }
            }
        }
Esempio n. 3
0
 public void SetLayout(CommandBuffer cmdbuffer,
                       VkImageAspectFlags aspectMask,
                       VkImageLayout oldImageLayout,
                       VkImageLayout newImageLayout)
 {
     SetLayout(cmdbuffer, aspectMask, oldImageLayout, newImageLayout, oldImageLayout.GetDefaultStage(), newImageLayout.GetDefaultStage());
 }
Esempio n. 4
0
 public unsafe void cmdCopyImageToBuffer(VkImage SrcImage, VkImageLayout ImageLayout, VkBuffer DstBuffer, VkBufferImageCopy[] Regions)
 {
     fixed(VkBufferImageCopy *pRegions = &Regions[0])
     {
         _Parent.Device.vkCmdCopyImageToBuffer(_Handle, SrcImage._Handle, ImageLayout, DstBuffer._Handle, (uint)Regions.Length, new IntPtr(pRegions));
     }
 }
        private void setImageMemoryBarrier(VkCommandBuffer command,
                                           VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
                                           VkImageLayout oldLayout, VkImageLayout newLayout,
                                           VkImage image, VkImageAspectFlags aspectFlags)
        {
            var imageMemoryBarrier = new VkImageMemoryBarrier()
            {
                srcAccessMask       = srcAccessMask,
                dstAccessMask       = dstAccessMask,
                oldLayout           = oldLayout,
                newLayout           = newLayout,
                srcQueueFamilyIndex = ~0u,
                dstQueueFamilyIndex = ~0u,
                subresourceRange    = new VkImageSubresourceRange
                {
                    aspectMask     = aspectFlags,
                    baseMipLevel   = 0,
                    levelCount     = 1,
                    baseArrayLayer = 0,
                    layerCount     = 1,
                },
                image = image
            };

            VulkanAPI.vkCmdPipelineBarrier(
                command,
                VkPipelineStageFlags.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                VkPipelineStageFlags.VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                0,
                null, // MemoryBarriers
                null, // BufferMemoryBarriers
                new VkImageMemoryBarrier[] { imageMemoryBarrier }
                );
        }
Esempio n. 6
0
 private (VkAttachmentDescription, VkAttachmentReference) CreateAttachment(
     VkFormat format,
     VkSampleCountFlags samples,
     uint index,
     VkAttachmentLoadOp loadOp,
     VkAttachmentStoreOp storeOp,
     VkAttachmentStoreOp stencilStoreOp,
     VkImageLayout initialLayout,
     VkImageLayout finalLayout)
 {
     return(new VkAttachmentDescription()
     {
         format = format,
         samples = samples,
         loadOp = loadOp,
         storeOp = storeOp,
         stencilLoadOp = VkAttachmentLoadOp.Load,
         stencilStoreOp = stencilStoreOp,
         initialLayout = initialLayout,
         finalLayout = finalLayout
     }, new VkAttachmentReference()
     {
         attachment = index,
         layout = finalLayout
     });
 }
Esempio n. 7
0
        private KeyValuePair <VkAccessFlags, VkPipelineStageFlags> GetImageTransferFlags(
            VkImageLayout layout
            )
        {
            switch (layout)
            {
            case VkImageLayout.TransferDstOptimal:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.TransferWrite,
                           VkPipelineStageFlags.Transfer
                           ));

            case VkImageLayout.TransferSrcOptimal:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.TransferRead,
                           VkPipelineStageFlags.Transfer
                           ));

            case VkImageLayout.Undefined:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.None,
                           VkPipelineStageFlags.TopOfPipe
                           ));

            case VkImageLayout.ColorAttachmentOptimal:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite,
                           VkPipelineStageFlags.ColorAttachmentOutput
                           ));

            case VkImageLayout.PresentSrcKHR:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.ColorAttachmentRead,
                           VkPipelineStageFlags.ColorAttachmentOutput
                           ));

            case VkImageLayout.DepthStencilAttachmentOptimal:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.DepthStencilAttachmentRead | VkAccessFlags.DepthStencilAttachmentWrite,
                           VkPipelineStageFlags.EarlyFragmentTests
                           ));

            case VkImageLayout.General:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite,
                           VkPipelineStageFlags.ColorAttachmentOutput
                           ));

            case VkImageLayout.ShaderReadOnlyOptimal:
                return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                           VkAccessFlags.ShaderRead,
                           VkPipelineStageFlags.AllGraphics
                           ));
            }

            return(new KeyValuePair <VkAccessFlags, VkPipelineStageFlags>(
                       VkAccessFlags.None,
                       VkPipelineStageFlags.None
                       ));
        }
Esempio n. 8
0
        public void SetLayout(
            CommandBuffer cmdbuffer,
            VkAccessFlags srcAccessMask,
            VkAccessFlags dstAccessMask,
            VkImageLayout oldImageLayout,
            VkImageLayout newImageLayout,
            VkImageSubresourceRange subresourceRange,
            VkPipelineStageFlags srcStageMask = VkPipelineStageFlags.AllCommands,
            VkPipelineStageFlags dstStageMask = VkPipelineStageFlags.AllCommands,
            uint srcQueueFamilyIndex          = Vk.QueueFamilyIgnored,
            uint dstQueueFamilyIndex          = Vk.QueueFamilyIgnored)
        {
            VkImageMemoryBarrier imageMemoryBarrier = VkImageMemoryBarrier.New();

            imageMemoryBarrier.srcQueueFamilyIndex = srcQueueFamilyIndex;
            imageMemoryBarrier.dstQueueFamilyIndex = dstQueueFamilyIndex;
            imageMemoryBarrier.oldLayout           = oldImageLayout;
            imageMemoryBarrier.newLayout           = newImageLayout;
            imageMemoryBarrier.image            = handle;
            imageMemoryBarrier.subresourceRange = subresourceRange;
            imageMemoryBarrier.srcAccessMask    = srcAccessMask;
            imageMemoryBarrier.dstAccessMask    = dstAccessMask;

            Vk.vkCmdPipelineBarrier(
                cmdbuffer.Handle,
                srcStageMask,
                dstStageMask,
                0,
                0, IntPtr.Zero,
                0, IntPtr.Zero,
                1, ref imageMemoryBarrier);
        }
Esempio n. 9
0
 public unsafe VkImageMemoryBarrier(
     VkImage image, VkImageAspectFlags aspectMask,
     VkImageLayout oldLayout, VkImageLayout newLayout,
     void *pNext = default)
     : this(image, oldLayout, newLayout, new VkImageSubresourceRange(aspectMask, 0, 1, 0, 1), pNext)
 {
 }
Esempio n. 10
0
 /// <summary>
 /// Starts building a new attachment for this render pass
 /// </summary>
 /// <param name="id">identifier for the attachment</param>
 /// <param name="format">attachment's format</param>
 /// <param name="finalLayout">attachment's final image layout</param>
 /// <param name="samples">attachment's sample count</param>
 /// <returns>attachment builder</returns>
 public AttachmentBuilder WithAttachment(TAttachment id, VkFormat format, VkImageLayout finalLayout,
                                         VkSampleCountFlag samples = VkSampleCountFlag.Count1)
 {
     Debug.Assert(!_attachmentOrder.Contains(id));
     _attachmentOrder.Add(id);
     return(new AttachmentBuilder(this, id, format, finalLayout, samples));
 }
Esempio n. 11
0
        protected void TransitionImageLayout(VkImage image, uint mipLevels, VkImageLayout oldLayout, VkImageLayout newLayout)
        {
            VkCommandBuffer cb = BeginOneTimeCommands();

            VkImageMemoryBarrier barrier = VkImageMemoryBarrier.New();

            barrier.oldLayout           = oldLayout;
            barrier.newLayout           = newLayout;
            barrier.srcQueueFamilyIndex = QueueFamilyIgnored;
            barrier.dstQueueFamilyIndex = QueueFamilyIgnored;
            barrier.image = image;
            barrier.subresourceRange.aspectMask     = VkImageAspectFlags.Color;
            barrier.subresourceRange.baseMipLevel   = 0;
            barrier.subresourceRange.levelCount     = mipLevels;
            barrier.subresourceRange.baseArrayLayer = 0;
            barrier.subresourceRange.layerCount     = 1;

            vkCmdPipelineBarrier(
                cb,
                VkPipelineStageFlags.TopOfPipe,
                VkPipelineStageFlags.TopOfPipe,
                VkDependencyFlags.None,
                0, null,
                0, null,
                1, &barrier);

            EndOneTimeCommands(cb);
        }
Esempio n. 12
0
 public Cmd_CopyBufferToImage(SoftwareBuffer srcBuffer, SoftwareImage dstImage, VkImageLayout dstImageLayout, int regionCount, VkBufferImageCopy[] pRegions)
 {
     this.m_srcBuffer      = srcBuffer;
     this.m_dstImage       = dstImage;
     this.m_dstImageLayout = dstImageLayout;
     this.m_regionCount    = regionCount;
     this.m_pRegions       = pRegions;
 }
Esempio n. 13
0
 public static extern void CmdClearDepthStencilImage(
     VkCommandBuffer commandBuffer,
     VkImage image,
     VkImageLayout imageLayout,
     ref VkClearDepthStencilValue pDepthStencil,
     uint rangeCount,
     IntPtr pRanges
     );
Esempio n. 14
0
 public static extern void CmdClearColorImage(
     VkCommandBuffer commandBuffer,
     VkImage image,
     VkImageLayout imageLayout,
     ref VkClearColorValue pColor,
     uint rangeCount,
     IntPtr pRanges
     );
Esempio n. 15
0
 /// <inheritdoc/>
 public SubpassBuilder InputAttachment(TAttachment attachment, VkImageLayout layout)
 {
     _inputAttachmentReferences.Add(new LazyAttachmentReference()
     {
         Id = attachment, Layout = layout
     });
     return(this);
 }
Esempio n. 16
0
 public static extern void CmdCopyBufferToImage(
     VkCommandBuffer commandBuffer,
     VkBuffer srcBuffer,
     VkImage dstImage,
     VkImageLayout dstImageLayout,
     uint regionCount,
     IntPtr pRegions
     );
Esempio n. 17
0
 public static extern void CmdCopyImageToBuffer(
     VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
     VkBuffer dstBuffer,
     uint regionCount,
     IntPtr pRegions
     );
Esempio n. 18
0
        void TransitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout)
        {
            var commandBuffer = BeginSingleTimeCommands();

            var barrier = new VkImageMemoryBarrier();

            barrier.oldLayout           = oldLayout;
            barrier.newLayout           = newLayout;
            barrier.srcQueueFamilyIndex = -1;    //VK_QUEUE_FAMILY_IGNORED
            barrier.dstQueueFamilyIndex = -1;
            barrier.image = image;
            barrier.subresourceRange.aspectMask     = VkImageAspectFlags.ColorBit;
            barrier.subresourceRange.baseMipLevel   = 0;
            barrier.subresourceRange.levelCount     = 1;
            barrier.subresourceRange.baseArrayLayer = 0;
            barrier.subresourceRange.layerCount     = 1;

            VkPipelineStageFlags source;
            VkPipelineStageFlags dest;

            if (oldLayout == VkImageLayout.Undefined && newLayout == VkImageLayout.TransferSrcOptimal)
            {
                barrier.srcAccessMask = VkAccessFlags.HostWriteBit;
                barrier.dstAccessMask = VkAccessFlags.TransferReadBit;

                source = VkPipelineStageFlags.HostBit;
                dest   = VkPipelineStageFlags.TransferBit;
            }
            else if (oldLayout == VkImageLayout.Undefined && newLayout == VkImageLayout.TransferDstOptimal)
            {
                barrier.srcAccessMask = VkAccessFlags.HostWriteBit;
                barrier.dstAccessMask = VkAccessFlags.TransferWriteBit;

                source = VkPipelineStageFlags.HostBit;
                dest   = VkPipelineStageFlags.TransferBit;
            }
            else if (oldLayout == VkImageLayout.TransferDstOptimal && newLayout == VkImageLayout.ShaderReadOnlyOptimal)
            {
                barrier.srcAccessMask = VkAccessFlags.TransferWriteBit;
                barrier.dstAccessMask = VkAccessFlags.ShaderReadBit;

                source = VkPipelineStageFlags.TransferBit;
                dest   = VkPipelineStageFlags.FragmentShaderBit;
            }
            else
            {
                throw new Exception("Unsupported transition");
            }

            commandBuffer.PipelineBarrier(
                source, dest,
                VkDependencyFlags.None,
                null, null, new List <VkImageMemoryBarrier> {
                barrier
            });

            EndSingleTimeCommand(commandBuffer);
        }
Esempio n. 19
0
 public void CmdClearDepthStencilImage(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenImage image,
     VkImageLayout imageLayout,
     VkClearDepthStencilValue *pDepthStencil,
     [CountFor("ranges")] int rangeCount,
     [IsArray] VkImageSubresourceRange *pRanges)
 {
 }
Esempio n. 20
0
 /// <inheritdoc/>
 public SubpassBuilder ResolveAttachment(uint attachment, VkImageLayout layout)
 {
     _resolveAttachmentReferences.Add(new VkAttachmentReference()
     {
         Attachment = attachment,
         Layout     = layout
     });
     return(this);
 }
Esempio n. 21
0
        public void TransferImageLayout(Image image, VkImageLayout newLayout)
        {
            for (uint i = 0; i < image.MipLevel; i++)
            {
                TransferImageLayout(image.Handle, image.Format, image.Layout[i], newLayout, i);
            }

            Array.Fill(image.Layout, newLayout);
        }
Esempio n. 22
0
 public void CmdCopyBufferToImage(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenBuffer srcBuffer,
     GenImage dstImage,
     VkImageLayout dstImageLayout,
     [CountFor("regions")] int regionCount,
     [IsArray] VkBufferImageCopy *pRegions)
 {
 }
Esempio n. 23
0
 public void ClearColorImage(Image image, VkImageLayout imageLayout, ref VkClearColorValue clearColor, List <VkImageSubresourceRange> ranges)
 {
     unsafe
     {
         var rangesNative = stackalloc VkImageSubresourceRange[ranges.Count];
         Interop.Copy(ranges, (IntPtr)rangesNative);
         Device.Commands.cmdClearColorImage(commandBuffer, image.Native, imageLayout, ref clearColor, (uint)ranges.Count, (IntPtr)rangesNative);
     }
 }
Esempio n. 24
0
 public void CmdCopyImageToBuffer(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenImage srcImage,
     VkImageLayout srcImageLayout,
     GenBuffer dstBuffer,
     [CountFor("regions")] int regionCount,
     [IsArray] VkBufferImageCopy *pRegions)
 {
 }
Esempio n. 25
0
 /// <inheritdoc/>
 public SubpassBuilder ColorAttachment(TAttachment attachment,
                                       VkImageLayout layout = VkImageLayout.ColorAttachmentOptimal)
 {
     _colorAttachmentReferences.Add(new LazyAttachmentReference()
     {
         Id = attachment, Layout = layout
     });
     return(this);
 }
Esempio n. 26
0
        public void CmdCopyBufferToImage(VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, int regionCount, VkBufferImageCopy[] pRegions)
        {
            if (m_State != CommandBufferState.Recording)
            {
                return;
            }

            m_Commands.Add(new Cmd_CopyBufferToImage((SoftwareBuffer)srcBuffer, (SoftwareImage)dstImage, dstImageLayout, regionCount, pRegions));
        }
Esempio n. 27
0
        internal SoftwareSampler2D(VkImageLayout imageLayout, SoftwareImageView imageView, SoftwareSampler sampler)
        {
            this.imageLayout = imageLayout;
            this.imageView   = imageView;
            this.sampler     = sampler;

            this.m_Width  = imageView.GetWidth();
            this.m_Height = imageView.GetHeight();
        }
Esempio n. 28
0
 public static extern void CmdResolveImage(
     VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
     VkImage dstImage,
     VkImageLayout dstImageLayout,
     uint regionCount,
     IntPtr pRegions
     );
Esempio n. 29
0
 public void CmdClearColorImage(VkImage Image, VkImageLayout ImageLayout, uint R, uint G, uint B, uint A, VkImageSubresourceRange[] Ranges)
 {
     VkClearValue.VkClearColorValue.UInt32_t color = new VkClearValue.VkClearColorValue.UInt32_t();
     color.uint32    = new uint[4];
     color.uint32[0] = R;
     color.uint32[1] = G;
     color.uint32[2] = B;
     color.uint32[3] = A;
     CmdClearColorImage(Image, ImageLayout, ref color, Ranges);
 }
Esempio n. 30
0
 public void CmdClearColorImage(VkImage Image, VkImageLayout ImageLayout, float R, float G, float B, float A, VkImageSubresourceRange[] Ranges)
 {
     VkClearValue.VkClearColorValue.Float color = new VkClearValue.VkClearColorValue.Float();
     color.float32    = new float[4];
     color.float32[0] = R;
     color.float32[1] = G;
     color.float32[2] = B;
     color.float32[3] = A;
     CmdClearColorImage(Image, ImageLayout, ref color, Ranges);
 }
Esempio n. 31
0
 public void CmdClearDepthStencilImage(IVkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue depthStencil, IReadOnlyList<VkImageSubresourceRange> ranges)
 {
     var unmanagedSize =
         ranges.SizeOfMarshalDirect();
     var unmanagedArray = new byte[unmanagedSize];
     fixed (byte* unmanagedStart = unmanagedArray)
     {
         var unmanaged = unmanagedStart;
         var _commandBuffer = Handle;
         var _image = image?.Handle ?? VkImage.HandleType.Null;
         var _imageLayout = imageLayout;
         var _pDepthStencil = &depthStencil;
         var _rangeCount = ranges?.Count ?? 0;
         var _pRanges = ranges.MarshalDirect(ref unmanaged);
         Direct.CmdClearDepthStencilImage(_commandBuffer, _image, _imageLayout, _pDepthStencil, _rangeCount, _pRanges);
     }
 }
Esempio n. 32
0
 public void CmdClearDepthStencilImage(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenImage image,
     VkImageLayout imageLayout,
     VkClearDepthStencilValue* pDepthStencil,
     [CountFor("ranges")] int rangeCount,
     [IsArray] VkImageSubresourceRange* pRanges)
 { }
Esempio n. 33
0
 public void CmdCopyBufferToImage(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenBuffer srcBuffer,
     GenImage dstImage,
     VkImageLayout dstImageLayout,
     [CountFor("regions")] int regionCount,
     [IsArray] VkBufferImageCopy* pRegions)
 { }
Esempio n. 34
0
 public void CmdCopyImageToBuffer(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenImage srcImage,
     VkImageLayout srcImageLayout,
     GenBuffer dstBuffer,
     [CountFor("regions")] int regionCount,
     [IsArray] VkBufferImageCopy* pRegions)
 { }
Esempio n. 35
0
 public void CmdBlitImage(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenImage srcImage,
     VkImageLayout srcImageLayout,
     GenImage dstImage,
     VkImageLayout dstImageLayout,
     [CountFor("regions")] int regionCount,
     [IsArray] VkImageBlit* pRegions,
     VkFilter filter)
 { }
Esempio n. 36
0
 public void CmdResolveImage(
     [FromProperty("this")] GenCommandBuffer commandBuffer,
     GenImage srcImage,
     VkImageLayout srcImageLayout,
     GenImage dstImage,
     VkImageLayout dstImageLayout,
     [CountFor("regions")] int regionCount,
     [IsArray] VkImageResolve* pRegions)
 { }
Esempio n. 37
0
 public void CmdResolveImage(IVkImage srcImage, VkImageLayout srcImageLayout, IVkImage dstImage, VkImageLayout dstImageLayout, IReadOnlyList<VkImageResolve> regions)
 {
     var unmanagedSize =
         regions.SizeOfMarshalDirect();
     var unmanagedArray = new byte[unmanagedSize];
     fixed (byte* unmanagedStart = unmanagedArray)
     {
         var unmanaged = unmanagedStart;
         var _commandBuffer = Handle;
         var _srcImage = srcImage?.Handle ?? VkImage.HandleType.Null;
         var _srcImageLayout = srcImageLayout;
         var _dstImage = dstImage?.Handle ?? VkImage.HandleType.Null;
         var _dstImageLayout = dstImageLayout;
         var _regionCount = regions?.Count ?? 0;
         var _pRegions = regions.MarshalDirect(ref unmanaged);
         Direct.CmdResolveImage(_commandBuffer, _srcImage, _srcImageLayout, _dstImage, _dstImageLayout, _regionCount, _pRegions);
     }
 }