public unsafe void OMSetRenderTargetsAndUnorderedAccessViews(
            ID3D11RenderTargetView renderTargetView,
            ID3D11DepthStencilView depthStencilView,
            int startSlot,
            ID3D11UnorderedAccessView[] unorderedAccessViews)
        {
            Guard.NotNull(renderTargetView, nameof(renderTargetView));
            Guard.NotNullOrEmpty(unorderedAccessViews, nameof(unorderedAccessViews));

            // Marshal array.
            var renderTargetViewsPtr = renderTargetView.NativePointer;

            var  unorderedAccessViewsPtr = stackalloc IntPtr[unorderedAccessViews.Length];
            int *uavInitialCounts        = stackalloc int[unorderedAccessViews.Length];

            for (int i = 0; i < unorderedAccessViews.Length; i++)
            {
                unorderedAccessViewsPtr[i] = unorderedAccessViews[i].NativePointer;
                uavInitialCounts[i]        = -1;
            }

            OMSetRenderTargetsAndUnorderedAccessViews(1, renderTargetViewsPtr,
                                                      depthStencilView,
                                                      startSlot, unorderedAccessViews.Length, (IntPtr)unorderedAccessViewsPtr,
                                                      (IntPtr)uavInitialCounts);
        }
        public unsafe void OMSetRenderTargetsAndUnorderedAccessViews(
            ID3D11RenderTargetView[] renderTargetViews,
            ID3D11DepthStencilView depthStencilView,
            int startSlot,
            ID3D11UnorderedAccessView[] unorderedAccessViews,
            int[] uavInitialCounts)
        {
            Guard.NotNullOrEmpty(renderTargetViews, nameof(renderTargetViews));
            Guard.NotNullOrEmpty(unorderedAccessViews, nameof(unorderedAccessViews));
            Guard.NotNullOrEmpty(uavInitialCounts, nameof(uavInitialCounts));

            // Marshal array.
            var renderTargetViewsPtr = stackalloc IntPtr[renderTargetViews.Length];

            for (int i = 0; i < renderTargetViews.Length; i++)
            {
                renderTargetViewsPtr[i] = renderTargetViews[i].NativePointer;
            }

            var unorderedAccessViewsPtr = stackalloc IntPtr[unorderedAccessViews.Length];

            for (int i = 0; i < unorderedAccessViews.Length; i++)
            {
                unorderedAccessViewsPtr[i] = unorderedAccessViews[i].NativePointer;
            }

            OMSetRenderTargetsAndUnorderedAccessViews(renderTargetViews.Length, (IntPtr)renderTargetViewsPtr,
                                                      depthStencilView,
                                                      startSlot, unorderedAccessViews.Length, (IntPtr)unorderedAccessViewsPtr,
                                                      (IntPtr)Unsafe.AsPointer(ref uavInitialCounts[0]));
        }
Exemple #3
0
        public unsafe void OMSetRenderTargetsAndUnorderedAccessViews(
            ID3D11RenderTargetView[] renderTargetViews,
            ID3D11DepthStencilView depthStencilView,
            int startSlot,
            ID3D11UnorderedAccessView[] unorderedAccessViews)
        {
            // Marshal array.
            var renderTargetViewsPtr = stackalloc IntPtr[renderTargetViews.Length];

            for (int i = 0; i < renderTargetViews.Length; i++)
            {
                renderTargetViewsPtr[i] = renderTargetViews[i].NativePointer;
            }

            var  unorderedAccessViewsPtr = stackalloc IntPtr[unorderedAccessViews.Length];
            int *uavInitialCounts        = stackalloc int[unorderedAccessViews.Length];

            for (int i = 0; i < unorderedAccessViews.Length; i++)
            {
                unorderedAccessViewsPtr[i] = unorderedAccessViews[i].NativePointer;
                uavInitialCounts[i]        = -1;
            }

            OMSetRenderTargetsAndUnorderedAccessViews(renderTargetViews.Length, (IntPtr)renderTargetViewsPtr,
                                                      depthStencilView,
                                                      startSlot, unorderedAccessViews.Length, (IntPtr)unorderedAccessViewsPtr,
                                                      (IntPtr)uavInitialCounts);
        }
Exemple #4
0
 public void OMSetRenderTargets(ID3D11RenderTargetView renderTarget, ID3D11DepthStencilView depthStencil)
 {
     unsafe
     {
         var renderTargetViews = stackalloc IntPtr[1];
         renderTargetViews[0] = renderTarget.Handle;
         OMSetRenderTargets(renderTargetViews, 1, depthStencil?.Handle ?? IntPtr.Zero);
     }
 }
Exemple #5
0
 public Device(ID3D11Device device, ID3D11RenderTargetView renderTarget, ID3D11DepthStencilView depthStencilView, ID3DCompiler compiler)
 {
     _device           = device ?? throw new ArgumentNullException(nameof(device));
     _renderTarget     = renderTarget ?? throw new ArgumentNullException(nameof(renderTarget));
     _depthStencilView = depthStencilView ?? throw new ArgumentNullException(nameof(depthStencilView));
     ImmediateContext  = new DeviceContext(device.Context, false);
     BackBuffer        = new RenderTarget(renderTarget);
     DepthStencil      = new DepthStencil(depthStencilView);
     TEMPORARYCompiler = compiler;
 }
        public static void ClearDepthStencilView(this ID3D11DeviceContext context, ID3D11DepthStencilView depthStencilView, D3D11_CLEAR_FLAG flags, float depth, byte stencil)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            if (depthStencilView == null)
            {
                throw new ArgumentNullException(nameof(depthStencilView));
            }

            context.ClearDepthStencilView(depthStencilView, (uint)flags, depth, stencil);
        }
        public TextureViewD3D11(DeviceD3D11 device, TextureD3D11 texture, TextureViewDescriptor descriptor)
            : base(texture, descriptor)
        {
            Device = device;

            if ((texture.Usage & TextureUsage.RenderTarget) != TextureUsage.None)
            {
                // TODO: Use TextureViewDescriptor
                if (!PixelFormatUtil.IsDepthStencilFormat(descriptor.Format))
                {
                    RenderTargetView = device.D3D11Device.CreateRenderTargetView(texture);
                }
                else
                {
                    DepthStencilView = device.D3D11Device.CreateDepthStencilView(texture);
                }
            }
        }
Exemple #8
0
 public void ClearDepthStencilView(ID3D11DepthStencilView depthStencilView, D3D11ClearFlag clearFlags, float depth, sbyte stencil) => ClearDepthStencilView(depthStencilView.Handle, clearFlags, depth, stencil);
        public unsafe void OMSetRenderTargets(ID3D11RenderTargetView[] renderTargetViews, ID3D11DepthStencilView depthStencilView = null)
        {
            var renderTargetViewsPtr = stackalloc IntPtr[renderTargetViews.Length];

            for (int i = 0; i < renderTargetViews.Length; i++)
            {
                renderTargetViewsPtr[i] = renderTargetViews[i].NativePointer;
            }

            OMSetRenderTargets(renderTargetViews.Length, (IntPtr)renderTargetViewsPtr, depthStencilView);
        }
        public unsafe void OMSetRenderTargets(int renderTargetViewsCount, ID3D11RenderTargetView[] renderTargetViews, ID3D11DepthStencilView depthStencilView = null)
        {
            IntPtr *renderTargetViewsPtr = (IntPtr *)0;

            if (renderTargetViewsCount > 0)
            {
                var tempPtr = stackalloc IntPtr[renderTargetViewsCount];
                renderTargetViewsPtr = tempPtr;
                for (int i = 0; i < renderTargetViewsCount; i++)
                {
                    renderTargetViewsPtr[i] = (renderTargetViews[i] == null) ? IntPtr.Zero : renderTargetViews[i].NativePointer;
                }
            }

            OMSetRenderTargets(renderTargetViewsCount, (IntPtr)renderTargetViewsPtr, depthStencilView);
        }
        public unsafe void OMSetRenderTargets(ID3D11RenderTargetView renderTargetView, ID3D11DepthStencilView depthStencilView = null)
        {
            Guard.NotNull(renderTargetView, nameof(renderTargetView));
            var renderTargetViewPtr = renderTargetView.NativePointer;

            OMSetRenderTargets(1, new IntPtr(&renderTargetViewPtr), depthStencilView);
        }
        public FramebufferD3D11(DeviceD3D11 device, FramebufferAttachment[] colorAttachments, FramebufferAttachment?depthStencilAttachment)
            : base(device, colorAttachments, depthStencilAttachment)
        {
            if (colorAttachments.Length > 0)
            {
                RenderTargetViews = new ID3D11RenderTargetView[colorAttachments.Length];
                for (var i = 0; i < colorAttachments.Length; i++)
                {
                    var  attachment  = colorAttachments[i];
                    var  texture     = attachment.Texture;
                    var  arraySize   = texture.ArrayLayers - attachment.Slice;
                    bool isTextureMs = (int)texture.Samples > 1;

                    var d3dTexture = (TextureD3D11)texture;
                    var viewDesc   = new RenderTargetViewDescription
                    {
                        Format = d3dTexture.DXGIFormat
                    };

                    switch (texture.TextureType)
                    {
                    case TextureType.Texture1D:
                        if (arraySize > 1)
                        {
                            viewDesc.ViewDimension                  = RenderTargetViewDimension.Texture1DArray;
                            viewDesc.Texture1DArray.MipSlice        = attachment.MipLevel;
                            viewDesc.Texture1DArray.FirstArraySlice = attachment.Slice;
                            viewDesc.Texture1DArray.ArraySize       = arraySize;
                        }
                        else
                        {
                            viewDesc.ViewDimension      = RenderTargetViewDimension.Texture1D;
                            viewDesc.Texture1D.MipSlice = attachment.MipLevel;
                        }
                        break;

                    case TextureType.Texture2D:
                        if (arraySize > 1)
                        {
                            if (isTextureMs)
                            {
                                viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DMultisampledArray;
                                viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice;
                                viewDesc.Texture2DMSArray.ArraySize       = arraySize;
                            }
                            else
                            {
                                viewDesc.ViewDimension                  = RenderTargetViewDimension.Texture2DArray;
                                viewDesc.Texture2DArray.MipSlice        = attachment.MipLevel;
                                viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice;
                                viewDesc.Texture2DArray.ArraySize       = arraySize;
                            }
                        }
                        else
                        {
                            if (isTextureMs)
                            {
                                viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DMultisampled;
                            }
                            else
                            {
                                viewDesc.ViewDimension      = RenderTargetViewDimension.Texture2D;
                                viewDesc.Texture2D.MipSlice = attachment.MipLevel;
                            }
                        }
                        break;

                    case TextureType.Texture3D:
                        // TODO: Add RenderPassAttachment.DepthPlane
                        viewDesc.ViewDimension         = RenderTargetViewDimension.Texture3D;
                        viewDesc.Texture3D.MipSlice    = attachment.MipLevel;
                        viewDesc.Texture3D.FirstWSlice = attachment.Slice;
                        viewDesc.Texture3D.WSize       = texture.Depth;
                        break;

                    case TextureType.TextureCube:
                        if (isTextureMs)
                        {
                            viewDesc.ViewDimension = RenderTargetViewDimension.Texture2DMultisampledArray;
                            viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice * 6;
                            viewDesc.Texture2DMSArray.ArraySize       = arraySize * 6;
                        }
                        else
                        {
                            viewDesc.ViewDimension                  = RenderTargetViewDimension.Texture2DArray;
                            viewDesc.Texture2DArray.MipSlice        = attachment.MipLevel;
                            viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice * 6;
                            viewDesc.Texture2DArray.ArraySize       = arraySize * 6;
                        }
                        break;
                    }

                    RenderTargetViews[i] = device.Device.CreateRenderTargetView(d3dTexture.Resource, viewDesc);
                }
            }
            else
            {
                RenderTargetViews = new ID3D11RenderTargetView[0];
            }

            if (depthStencilAttachment != null)
            {
                var  attachment  = depthStencilAttachment.Value;
                var  texture     = attachment.Texture;
                var  d3dTexture  = (TextureD3D11)texture;
                var  arraySize   = texture.ArrayLayers - attachment.Slice;
                bool isTextureMs = (int)texture.Samples > 1;

                var viewDesc = new DepthStencilViewDescription
                {
                    Format = d3dTexture.DXGIFormat,
                    Flags  = DepthStencilViewFlags.None
                };

                switch (texture.TextureType)
                {
                case TextureType.Texture1D:
                    if (arraySize > 1)
                    {
                        viewDesc.ViewDimension                  = DepthStencilViewDimension.Texture1DArray;
                        viewDesc.Texture1DArray.MipSlice        = attachment.MipLevel;
                        viewDesc.Texture1DArray.FirstArraySlice = attachment.Slice;
                        viewDesc.Texture1DArray.ArraySize       = arraySize;
                    }
                    else
                    {
                        viewDesc.ViewDimension      = DepthStencilViewDimension.Texture1D;
                        viewDesc.Texture1D.MipSlice = attachment.MipLevel;
                    }
                    break;

                case TextureType.Texture2D:
                    if (arraySize > 1)
                    {
                        if (isTextureMs)
                        {
                            viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DMultisampledArray;
                            viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice;
                            viewDesc.Texture2DMSArray.ArraySize       = arraySize;
                        }
                        else
                        {
                            viewDesc.ViewDimension                  = DepthStencilViewDimension.Texture2DArray;
                            viewDesc.Texture2DArray.MipSlice        = attachment.MipLevel;
                            viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice;
                            viewDesc.Texture2DArray.ArraySize       = arraySize;
                        }
                    }
                    else
                    {
                        if (isTextureMs)
                        {
                            viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DMultisampled;
                        }
                        else
                        {
                            viewDesc.ViewDimension      = DepthStencilViewDimension.Texture2D;
                            viewDesc.Texture2D.MipSlice = attachment.MipLevel;
                        }
                    }

                    break;

                case TextureType.TextureCube:
                    if (isTextureMs)
                    {
                        viewDesc.ViewDimension = DepthStencilViewDimension.Texture2DMultisampledArray;
                        viewDesc.Texture2DMSArray.FirstArraySlice = attachment.Slice * 6;
                        viewDesc.Texture2DMSArray.ArraySize       = arraySize * 6;
                    }
                    else
                    {
                        viewDesc.ViewDimension                  = DepthStencilViewDimension.Texture2DArray;
                        viewDesc.Texture2DArray.MipSlice        = attachment.MipLevel * 6;
                        viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice * 6;
                        viewDesc.Texture2DArray.ArraySize       = arraySize * 6;
                    }
                    break;

                case TextureType.Texture3D:
                    viewDesc.ViewDimension                  = DepthStencilViewDimension.Texture2DArray;
                    viewDesc.Texture2DArray.MipSlice        = attachment.MipLevel;
                    viewDesc.Texture2DArray.FirstArraySlice = attachment.Slice;
                    viewDesc.Texture2DArray.ArraySize       = texture.Depth;
                    break;

                default:
                    viewDesc.ViewDimension = DepthStencilViewDimension.Unknown;
                    Log.Error("Invalid texture type");
                    break;
                }

                DepthStencilView = device.Device.CreateDepthStencilView(d3dTexture.Resource, viewDesc);
            }
        }
Exemple #13
0
 internal D3D11DepthStencilView(ID3D11DepthStencilView depthStencilView)
 {
     this.depthStencilView = depthStencilView;
 }
        public static void OMSetRenderTargets(this ID3D11DeviceContext context, ID3D11RenderTargetView[] renderTargetViews, ID3D11DepthStencilView depthStencilView = null)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            if (renderTargetViews == null)
            {
                throw new ArgumentNullException(nameof(renderTargetViews));
            }

            context.OMSetRenderTargets((renderTargetViews?.Length).GetValueOrDefault(), renderTargetViews, depthStencilView);
        }
 internal D3D11DepthStencilView(ID3D11DepthStencilView depthStencilView)
 {
     this.depthStencilView = depthStencilView;
 }
Exemple #16
0
 public DepthStencil(ID3D11DepthStencilView depStencilView)
 {
     _depStencilView = depStencilView;
 }