public static void OMSetDepthStencilState(this ID3D11DeviceContext context, ID3D11DepthStencilState depthStencilState, int stencilfRef = 0)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

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

            context.OMSetDepthStencilState(depthStencilState, (uint)stencilfRef);
        }
Beispiel #2
0
 public void GetPipelineResources(
     ref BlendStateDescription blendDesc,
     ref DepthStencilStateDescription dssDesc,
     ref RasterizerStateDescription rasterDesc,
     bool multisample,
     VertexLayoutDescription[] vertexLayouts,
     byte[] vsBytecode,
     out ID3D11BlendState blendState,
     out ID3D11DepthStencilState depthState,
     out ID3D11RasterizerState rasterState,
     out ID3D11InputLayout inputLayout)
 {
     lock (_lock)
     {
         blendState  = GetBlendState(ref blendDesc);
         depthState  = GetDepthStencilState(ref dssDesc);
         rasterState = GetRasterizerState(ref rasterDesc, multisample);
         inputLayout = GetInputLayout(vertexLayouts, vsBytecode);
     }
 }
Beispiel #3
0
        protected override void SetPipelineStateImpl(PipelineState pipelineState)
        {
            var pipelineStateD3D11 = (PipelineStateD3D11)pipelineState;

            if (pipelineState.IsCompute)
            {
                var computeShader = pipelineStateD3D11.ComputeShader;
                D3D11Context.CSSetShader(computeShader);
            }
            else
            {
                var blendState = pipelineStateD3D11.BlendState;
                if (_boundBlendState != blendState)
                {
                    _boundBlendState = blendState;
                    D3D11Context.OMSetBlendState(blendState, _boundBlendColor);
                }

                var depthStencilState = pipelineStateD3D11.DepthStencilState;
                if (_boundDepthStencilState != depthStencilState)
                {
                    _boundDepthStencilState = depthStencilState;
                    D3D11Context.OMSetDepthStencilState(depthStencilState, _boundStencilReference);
                }

                var rasterizerState = pipelineStateD3D11.RasterizerState;
                if (_boundRasterizerState != rasterizerState)
                {
                    _boundRasterizerState = rasterizerState;
                    D3D11Context.RSSetState(rasterizerState);
                }

                var primitiveTopology = pipelineStateD3D11.PrimitiveTopology;
                if (_boundPrimitiveTopology != primitiveTopology)
                {
                    _boundPrimitiveTopology = primitiveTopology;
                    D3D11Context.IASetPrimitiveTopology(primitiveTopology);
                }

                var inputLayout = pipelineStateD3D11.InputLayout;
                if (_boundInputLayout != inputLayout)
                {
                    _boundInputLayout = inputLayout;
                    D3D11Context.IASetInputLayout(_boundInputLayout);
                }

                var vertexShader = pipelineStateD3D11.VertexShader;
                if (_boundVertexShader != vertexShader)
                {
                    _boundVertexShader = vertexShader;
                    D3D11Context.VSSetShader(vertexShader);
                }

                var geometryShader = pipelineStateD3D11.GeometryShader;
                if (_boundGeometryShader != geometryShader)
                {
                    _boundGeometryShader = geometryShader;
                    D3D11Context.GSSetShader(geometryShader);
                }

                var hullShader = pipelineStateD3D11.HullShader;
                if (_boundHullShader != hullShader)
                {
                    _boundHullShader = hullShader;
                    D3D11Context.HSSetShader(hullShader);
                }

                var domainShader = pipelineStateD3D11.DomainShader;
                if (_boundDomainShader != domainShader)
                {
                    _boundDomainShader = domainShader;
                    D3D11Context.DSSetShader(domainShader);
                }

                var pixelShader = pipelineStateD3D11.PixelShader;
                if (_boundPixelShader != pixelShader)
                {
                    _boundPixelShader = pixelShader;
                    D3D11Context.PSSetShader(pixelShader);
                }
            }
        }
Beispiel #4
0
 internal D3D11DepthStencilState(ID3D11DepthStencilState depthStencilState)
 {
     this.depthStencilState = depthStencilState;
 }
 internal D3D11DepthStencilState(ID3D11DepthStencilState depthStencilState)
 {
     this.depthStencilState = depthStencilState;
 }
Beispiel #6
0
        void CreateDeviceObjects()
        {
            var vertexShaderCode =
                @"
                    cbuffer vertexBuffer : register(b0) 
                    {
                        float4x4 ProjectionMatrix; 
                    };

                    struct VS_INPUT
                    {
                        float2 pos : POSITION;
                        float4 col : COLOR0;
                        float2 uv  : TEXCOORD0;
                    };
            
                    struct PS_INPUT
                    {
                        float4 pos : SV_POSITION;
                        float4 col : COLOR0;
                        float2 uv  : TEXCOORD0;
                    };
            
                    PS_INPUT main(VS_INPUT input)
                    {
                        PS_INPUT output;
                        output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f));
                        output.col = input.col;
                        output.uv  = input.uv;
                        return output;
                    }";

            Compiler.Compile(vertexShaderCode, "main", "vs", "vs_4_0", out vertexShaderBlob, out var errorBlob);
            if (vertexShaderBlob == null)
            {
                throw new Exception("error compiling vertex shader");
            }

            vertexShader = device.CreateVertexShader(vertexShaderBlob.GetBytes());

            var inputElements = new[]
            {
                new InputElementDescription("POSITION", 0, Format.R32G32_Float, 0, 0, InputClassification.PerVertexData, 0),
                new InputElementDescription("TEXCOORD", 0, Format.R32G32_Float, 8, 0, InputClassification.PerVertexData, 0),
                new InputElementDescription("COLOR", 0, Format.R8G8B8A8_UNorm, 16, 0, InputClassification.PerVertexData, 0),
            };

            inputLayout = device.CreateInputLayout(inputElements, vertexShaderBlob);

            var constBufferDesc = new BufferDescription
            {
                SizeInBytes    = VertexConstantBufferSize,
                Usage          = Vortice.Direct3D11.Usage.Dynamic,
                BindFlags      = BindFlags.ConstantBuffer,
                CpuAccessFlags = CpuAccessFlags.Write
            };

            constantBuffer = device.CreateBuffer(constBufferDesc);

            var pixelShaderCode =
                @"struct PS_INPUT
                    {
                        float4 pos : SV_POSITION;
                        float4 col : COLOR0;
                        float2 uv  : TEXCOORD0;
                    };

                    sampler sampler0;
                    Texture2D texture0;
            
                    float4 main(PS_INPUT input) : SV_Target
                    {
                        float4 out_col = input.col * texture0.Sample(sampler0, input.uv); 
                        return out_col; 
                    }";

            Compiler.Compile(pixelShaderCode, "main", "ps", "ps_4_0", out pixelShaderBlob, out errorBlob);
            if (pixelShaderBlob == null)
            {
                throw new Exception("error compiling pixel shader");
            }

            pixelShader = device.CreatePixelShader(pixelShaderBlob.GetBytes());

            var blendDesc = new BlendDescription
            {
                AlphaToCoverageEnable = false
            };

            blendDesc.RenderTarget[0] = new RenderTargetBlendDescription
            {
                IsBlendEnabled        = true,
                SourceBlend           = Blend.SourceAlpha,
                DestinationBlend      = Blend.InverseSourceAlpha,
                BlendOperation        = BlendOperation.Add,
                SourceBlendAlpha      = Blend.InverseSourceAlpha,
                DestinationBlendAlpha = Blend.Zero,
                BlendOperationAlpha   = BlendOperation.Add,
                RenderTargetWriteMask = ColorWriteEnable.All
            };

            blendState = device.CreateBlendState(blendDesc);

            var rasterDesc = new RasterizerDescription
            {
                FillMode        = FillMode.Solid,
                CullMode        = CullMode.None,
                ScissorEnable   = true,
                DepthClipEnable = true
            };

            rasterizerState = device.CreateRasterizerState(rasterDesc);

            var stencilOpDesc = new DepthStencilOperationDescription(StencilOperation.Keep, StencilOperation.Keep, StencilOperation.Keep, ComparisonFunction.Always);
            var depthDesc     = new DepthStencilDescription
            {
                DepthEnable    = false,
                DepthWriteMask = DepthWriteMask.All,
                DepthFunc      = ComparisonFunction.Always,
                StencilEnable  = false,
                FrontFace      = stencilOpDesc,
                BackFace       = stencilOpDesc
            };

            depthStencilState = device.CreateDepthStencilState(depthDesc);

            CreateFontsTexture();
        }