コード例 #1
0
ファイル: ShaderPass.cs プロジェクト: holance/helix-toolkit
            /// <summary>
            /// Sets the shader.
            /// </summary>
            /// <param name="shader">The shader.</param>
            public void SetShader(ShaderBase shader)
            {
                switch (shader.ShaderType)
                {
                case ShaderStage.Vertex:
                    RemoveAndDispose(ref vertexShader);
                    vertexShader = shader as VertexShader ?? VertexShader.NullVertexShader;
                    break;

                case ShaderStage.Pixel:
                    RemoveAndDispose(ref pixelShader);
                    pixelShader = shader as PixelShader ?? PixelShader.NullPixelShader;
                    break;

                case ShaderStage.Compute:
                    RemoveAndDispose(ref computeShader);
                    computeShader = shader as ComputeShader ?? ComputeShader.NullComputeShader;
                    break;

                case ShaderStage.Hull:
                    RemoveAndDispose(ref hullShader);
                    hullShader = shader as HullShader ?? HullShader.NullHullShader;
                    break;

                case ShaderStage.Domain:
                    RemoveAndDispose(ref domainShader);
                    domainShader = shader as DomainShader ?? DomainShader.NullDomainShader;
                    break;

                case ShaderStage.Geometry:
                    RemoveAndDispose(ref geometryShader);
                    geometryShader = shader as GeometryShader ?? GeometryShader.NullGeometryShader;
                    break;
                }
            }
コード例 #2
0
        /// <summary>
        /// Function to reset the shader states.
        /// </summary>
        internal void Reset()
        {
            VertexShader.Reset();
            PixelShader.Reset();

            if (GeometryShader != null)
            {
                GeometryShader.Reset();
            }

            if (ComputeShader != null)
            {
                ComputeShader.Reset();
            }

            if (HullShader != null)
            {
                HullShader.Reset();
            }

            if (DomainShader != null)
            {
                DomainShader.Reset();
            }
        }
コード例 #3
0
        public D3D11Shader(Device device, ShaderDescription description)
        {
            switch (description.Stage)
            {
            case ShaderStages.Vertex:
                DeviceShader = new VertexShader(device, description.ShaderBytes);
                break;

            case ShaderStages.Geometry:
                DeviceShader = new GeometryShader(device, description.ShaderBytes);
                break;

            case ShaderStages.TessellationControl:
                DeviceShader = new HullShader(device, description.ShaderBytes);
                break;

            case ShaderStages.TessellationEvaluation:
                DeviceShader = new DomainShader(device, description.ShaderBytes);
                break;

            case ShaderStages.Fragment:
                DeviceShader = new PixelShader(device, description.ShaderBytes);
                break;

            default:
                throw Illegal.Value <ShaderStages>();
            }

            Bytecode = description.ShaderBytes;
        }
コード例 #4
0
        /// <summary>
        /// Release Elements
        /// </summary>
        public void Dispose()
        {
            if (VertexShader != null)
            {
                VertexShader.Dispose();
            }

            if (PixelShader != null)
            {
                PixelShader.Dispose();
            }

            if (GeometryShader != null)
            {
                GeometryShader.Dispose();
            }

            if (DomainShader != null)
            {
                DomainShader.Dispose();
            }

            if (HullShader != null)
            {
                HullShader.Dispose();
            }

            if (Layout != null)
            {
                Layout.Dispose();
            }
        }
コード例 #5
0
ファイル: ShaderPass.cs プロジェクト: holance/helix-toolkit
            /// <summary>
            ///
            /// </summary>
            /// <param name="passDescription"></param>
            /// <param name="manager"></param>
            public ShaderPass(ShaderPassDescription passDescription, IEffectsManager manager)
            {
                Name           = passDescription.Name;
                effectsManager = manager;
                if (passDescription.ShaderList != null)
                {
                    foreach (var shader in passDescription.ShaderList)
                    {
                        var s = manager.ShaderManager.RegisterShader(shader);
                        switch (shader.ShaderType)
                        {
                        case ShaderStage.Vertex:
                            vertexShader = s as VertexShader;
                            break;

                        case ShaderStage.Domain:
                            domainShader = s as DomainShader;
                            break;

                        case ShaderStage.Hull:
                            hullShader = s as HullShader;
                            break;

                        case ShaderStage.Geometry:
                            geometryShader = s as GeometryShader;
                            break;

                        case ShaderStage.Pixel:
                            pixelShader = s as PixelShader;
                            break;

                        case ShaderStage.Compute:
                            computeShader = s as ComputeShader;
                            break;
                        }
                    }
                }

                blendState = passDescription.BlendStateDescription != null?
                             manager.StateManager.Register((BlendStateDescription)passDescription.BlendStateDescription) : BlendStateProxy.Empty;

                depthStencilState = passDescription.DepthStencilStateDescription != null?
                                    manager.StateManager.Register((DepthStencilStateDescription)passDescription.DepthStencilStateDescription) : DepthStencilStateProxy.Empty;

                rasterState = passDescription.RasterStateDescription != null?
                              manager.StateManager.Register((RasterizerStateDescription)passDescription.RasterStateDescription) : RasterizerStateProxy.Empty;

                BlendFactor = passDescription.BlendFactor;

                StencilRef = passDescription.StencilRef;

                SampleMask = passDescription.SampleMask;

                Topology = passDescription.Topology;
                if (passDescription.InputLayoutDescription != null)
                {
                    layout = manager.ShaderManager.RegisterInputLayout(passDescription.InputLayoutDescription);
                }
            }
コード例 #6
0
        public IHullShader LoadHullShaderFromFile(string relativePath, string entryPoint = null)
        {
            var bytecode = CompileShaderBytecodeFromFileOrThrow($"{BasePath}\\{relativePath}.hlsl", entryPoint ?? "HS", "hs_5_0");
            var shader   = new HullShader(_device, bytecode);

            return(new HullShaderBox {
                Shader = shader
            });
        }
コード例 #7
0
 public ShaderPipelineState(DX11RenderContext renderContext)
 {
     var context = renderContext.CurrentDeviceContext;
     this.VertexShader = context.VertexShader.Get();
     this.HullShader = context.HullShader.Get();
     this.DomainShader = context.DomainShader.Get();
     this.GeometryShader = context.GeometryShader.Get();
     this.PixelShader = context.PixelShader.Get();
 }
コード例 #8
0
        public ShaderPipelineState(DX11RenderContext renderContext)
        {
            var context = renderContext.CurrentDeviceContext;

            this.VertexShader   = context.VertexShader.Get();
            this.HullShader     = context.HullShader.Get();
            this.DomainShader   = context.DomainShader.Get();
            this.GeometryShader = context.GeometryShader.Get();
            this.PixelShader    = context.PixelShader.Get();
        }
コード例 #9
0
        private void ResetManagedState()
        {
            _numVertexBindings = 0;
            Util.ClearArray(_vertexBindings);
            _vertexStrides = null;
            Util.ClearArray(_vertexOffsets);

            _framebuffer = null;

            Util.ClearArray(_viewports);
            Util.ClearArray(_scissors);
            _viewportsChanged    = false;
            _scissorRectsChanged = false;

            _ib = null;
            _graphicsPipeline  = null;
            _blendState        = null;
            _depthStencilState = null;
            _rasterizerState   = null;
            _primitiveTopology = SharpDX.Direct3D.PrimitiveTopology.Undefined;
            _inputLayout       = null;
            _vertexShader      = null;
            _geometryShader    = null;
            _hullShader        = null;
            _domainShader      = null;
            _pixelShader       = null;
            Util.ClearArray(_graphicsResourceSets);

            Util.ClearArray(_vertexBoundUniformBuffers);
            Util.ClearArray(_vertexBoundTextureViews);
            Util.ClearArray(_vertexBoundSamplers);

            Util.ClearArray(_fragmentBoundUniformBuffers);
            Util.ClearArray(_fragmentBoundTextureViews);
            Util.ClearArray(_fragmentBoundSamplers);

            _computePipeline = null;
            Util.ClearArray(_computeResourceSets);

            foreach (KeyValuePair <Texture, List <BoundTextureInfo> > kvp in _boundSRVs)
            {
                List <BoundTextureInfo> list = kvp.Value;
                list.Clear();
                PoolBoundTextureList(list);
            }
            _boundSRVs.Clear();

            foreach (KeyValuePair <Texture, List <BoundTextureInfo> > kvp in _boundUAVs)
            {
                List <BoundTextureInfo> list = kvp.Value;
                list.Clear();
                PoolBoundTextureList(list);
            }
            _boundUAVs.Clear();
        }
コード例 #10
0
 public void SetShader(HullShader shader, bool bindConstantBuffer = true)
 {
     deviceContext.HullShader.Set(shader.Shader);
     if (bindConstantBuffer)
     {
         foreach (var buff in shader.ConstantBufferMapping.Mappings)
         {
             deviceContext.HullShader.SetConstantBuffer(buff.Key, buff.Value.Buffer);
         }
     }
 }
コード例 #11
0
ファイル: Shader.cs プロジェクト: Saggre/Raymarch-Engine
        public Shader(InputLayout inputLayout, VertexShader vertexShader, HullShader hullShader,
                      DomainShader domainShader,
                      GeometryShader geometryShader, PixelShader pixelShader)
        {
            InputLayout    = inputLayout;
            VertexShader   = vertexShader;
            HullShader     = hullShader;
            DomainShader   = domainShader;
            GeometryShader = geometryShader;
            PixelShader    = pixelShader;

            shaderResourceViews = new Dictionary <int, ShaderResourceView>();
        }
コード例 #12
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="device">Device</param>
        /// <param name="filename">Path of shader file</param>
        /// <param name="description">Description structure</param>
        /// <param name="elements">Input Layout Elements</param>
        public SharpShader(SharpDevice device, string filename, SharpShaderDescription description, InputElement[] elements)
        {
            Device = device;
            // Compile Vertex and Pixel shaders
            var vertexShaderByteCode = ShaderBytecode.CompileFromFile(filename, description.VertexShaderFunction, "vs_5_0");

            VertexShader = new VertexShader(Device.Device, vertexShaderByteCode);

            //create pixel shader
            if (!string.IsNullOrEmpty(description.PixelShaderFunction))
            {
                var pixelShaderByteCode = ShaderBytecode.CompileFromFile(filename, description.PixelShaderFunction, "ps_5_0");
                PixelShader = new PixelShader(Device.Device, pixelShaderByteCode);
            }

            if (!string.IsNullOrEmpty(description.GeometryShaderFunction))
            {
                var geometryShaderByteCode = ShaderBytecode.CompileFromFile(filename, description.GeometryShaderFunction, "gs_5_0");

                if (description.GeometrySO == null)
                {
                    GeometryShader = new GeometryShader(Device.Device, geometryShaderByteCode);
                }
                else
                {
                    int[] size = new int[] { description.GeometrySO.Select(e => e.ComponentCount * 4).Sum() };

                    GeometryShader = new GeometryShader(Device.Device, geometryShaderByteCode, description.GeometrySO, size, -1);
                }
            }

            if (!string.IsNullOrEmpty(description.DomainShaderFunction))
            {
                var domainShaderByteCode = ShaderBytecode.CompileFromFile(filename, description.DomainShaderFunction, "ds_5_0");
                DomainShader = new DomainShader(Device.Device, domainShaderByteCode);
            }

            if (!string.IsNullOrEmpty(description.HullShaderFunction))
            {
                var hullShaderByteCode = ShaderBytecode.CompileFromFile(filename, description.HullShaderFunction, "hs_5_0");
                HullShader = new HullShader(Device.Device, hullShaderByteCode);
            }

            var signature = ShaderSignature.GetInputSignature(vertexShaderByteCode);

            // Layout from VertexShader input signature
            Layout = new InputLayout(Device.Device, signature, elements);
        }
コード例 #13
0
 public void SetShader(HullShader shader, bool bindConstantBuffer = true)
 {
     deviceContext.HullShader.Set(shader.Shader);
     if (bindConstantBuffer)
     {
         foreach (var buff in shader.ConstantBufferMapping.Mappings)
         {
             int idx = CBCheckHullShaderStartIdx + buff.Key;
             if (ConstantBufferCheck[idx] != buff.Value)
             {
                 ConstantBufferCheck[idx] = buff.Value;
                 deviceContext.HullShader.SetConstantBuffer(buff.Key, buff.Value.Buffer);
             }
         }
     }
 }
コード例 #14
0
ファイル: D3D11Shader.cs プロジェクト: user135711/veldrid
        public D3D11Shader(Device device, ShaderDescription description)
            : base(description.Stage)
        {
            if (description.ShaderBytes.Length > 4 &&
                description.ShaderBytes[0] == 0x44 &&
                description.ShaderBytes[1] == 0x58 &&
                description.ShaderBytes[2] == 0x42 &&
                description.ShaderBytes[3] == 0x43)
            {
                Bytecode = Util.ShallowClone(description.ShaderBytes);
            }
            else
            {
                Bytecode = CompileCode(description);
            }

            switch (description.Stage)
            {
            case ShaderStages.Vertex:
                DeviceShader = new VertexShader(device, Bytecode);
                break;

            case ShaderStages.Geometry:
                DeviceShader = new GeometryShader(device, Bytecode);
                break;

            case ShaderStages.TessellationControl:
                DeviceShader = new HullShader(device, Bytecode);
                break;

            case ShaderStages.TessellationEvaluation:
                DeviceShader = new DomainShader(device, Bytecode);
                break;

            case ShaderStages.Fragment:
                DeviceShader = new PixelShader(device, Bytecode);
                break;

            case ShaderStages.Compute:
                DeviceShader = new ComputeShader(device, Bytecode);
                break;

            default:
                throw Illegal.Value <ShaderStages>();
            }
        }
コード例 #15
0
        public Tesselation(Device dv, int tFactor)
        {
            this.tFactor = tFactor;
            this.World   = Matrix.Identity;
            _dv          = dv;
            _tri         = new Tri(dv);
            _quad        = new Quad(dv);

            _cb = new Buffer(dv, Utilities.SizeOf <TesConst>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);

            var inputElements = new InputElement[]
            {
                new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0)
                // new InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float,12, 0)
            };

            _drawer = new Drawer("Shaders\\Tes.hlsl", inputElements, dv.ImmediateContext);
            var m = _dv.ImmediateContext.LoadTextureFromFile("Textures\\grass.jpg");

            _viewModel.Textures        = new[] { m };
            _viewModel.ConstantBuffers = new[] { _cb };

            ShaderFlags shaderFlags = ShaderFlags.None;

#if DEBUG
            shaderFlags = ShaderFlags.Debug;
#endif
            using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile("Shaders\\Tes.hlsl", "HS", "hs_5_0", shaderFlags))
            {
                _HShader = new HullShader(_dv, pixelShaderByteCode);
            }
            using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile("Shaders\\Tes.hlsl", "DS", "ds_5_0", shaderFlags))
            {
                _DShader = new DomainShader(_dv, pixelShaderByteCode);
            }
            using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile("Shaders\\Tes.hlsl", "GS", "gs_5_0", shaderFlags))
            {
                _GShader = new GeometryShader(_dv, pixelShaderByteCode);
            }

            var r = RasterizerStateDescription.Default();
            r.CullMode = CullMode.None;
            r.FillMode = FillMode.Wireframe;
            _drawer.RasterizerDescription = r;
        }
コード例 #16
0
ファイル: ShaderLoaders.cs プロジェクト: eymike/Janus
        public override object ProcessStream(Stream assetStream)
        {
            var graphics = (GraphicsDevice)m_services.GetService(typeof(GraphicsDevice));
            var device   = graphics.Device;

            assetStream.Position = 0;
            var buffer = new byte[assetStream.Length];

            for (int totalBytesCopied = 0; totalBytesCopied < assetStream.Length;)
            {
                totalBytesCopied += assetStream.Read(buffer, totalBytesCopied, Convert.ToInt32(assetStream.Length) - totalBytesCopied);
            }

            var vShader = new HullShader(device, buffer);

            vShader.Tag = buffer;

            return(vShader);
        }
コード例 #17
0
        /// <summary>
        /// Конструктор класса
        /// </summary>
        /// <param name="dC">Контекст Директ икс 11</param>
        /// <param name="shadersFile">Путь к файлу в которм описанный шейдеры. Назвалине функций шейредов должно быть VS, PS, GS, HS и DS соответственно.</param>
        ///<param name="inputElements">Входные элементы для Вертексного шейдера</param>
        /// <param name="hasGeom">Используеться ли Геометри шейдер GS</param>
        /// <param name="hasTes">Использовать ли Хулл HS и Домейн DS шейдеры необходимые для тесселяции</param>
        public Shader(DeviceContext dC, string shadersFile, SharpDX.Direct3D11.InputElement[] inputElements, bool hasGeom = false, bool hasTes = false)
        {
            _dx11DeviceContext = dC;
            ShaderFlags shaderFlags = ShaderFlags.None;

#if DEBUG
            shaderFlags = ShaderFlags.Debug;
#endif

            using (var vertexShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "VS", "vs_5_0", shaderFlags))
            {
                //Синатура храянящая сведения о том какие входные переменные есть у шейдера
                _inputSignature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
                _vertexShader   = new VertexShader(_dx11DeviceContext.Device, vertexShaderByteCode);
            }
            using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "PS", "ps_5_0", shaderFlags))
            {
                _pixelShader = new PixelShader(_dx11DeviceContext.Device, pixelShaderByteCode);
            }

            if (hasTes)
            {
                using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "HS", "hs_5_0", shaderFlags))
                {
                    _HShader = new HullShader(_dx11DeviceContext.Device, pixelShaderByteCode);
                }
                using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "DS", "ds_5_0", shaderFlags))
                {
                    _DShader = new DomainShader(_dx11DeviceContext.Device, pixelShaderByteCode);
                }
            }

            if (hasGeom)
            {
                using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(shadersFile, "GS", "gs_5_0", shaderFlags))
                {
                    _GShader = new GeometryShader(_dx11DeviceContext.Device, pixelShaderByteCode);
                }
            }

            _inputLayout = new InputLayout(_dx11DeviceContext.Device, _inputSignature, inputElements);
        }
コード例 #18
0
        /// <summary>
        /// Function clean up any resources within this interface.
        /// </summary>
        internal void CleanUp()
        {
            if (PixelShader != null)
            {
                PixelShader.CleanUp();
            }

            if (VertexShader != null)
            {
                VertexShader.CleanUp();
            }

            if (GeometryShader != null)
            {
                GeometryShader.CleanUp();
            }

            if (ComputeShader != null)
            {
                ComputeShader.CleanUp();
            }

            if (HullShader != null)
            {
                HullShader.CleanUp();
            }

            if (DomainShader != null)
            {
                DomainShader.CleanUp();
            }

            ComputeShader  = null;
            GeometryShader = null;
            PixelShader    = null;
            VertexShader   = null;
        }
コード例 #19
0
ファイル: Shader.Direct3D.cs プロジェクト: sonicviz/xenko
        private Shader(GraphicsDevice device, ShaderStage shaderStage, byte[] shaderBytecode)
            : base(device)
        {
            this.stage = shaderStage;

            switch (shaderStage)
            {
            case ShaderStage.Vertex:
                NativeDeviceChild    = new VertexShader(device.NativeDevice, shaderBytecode);
                NativeInputSignature = shaderBytecode;
                break;

            case ShaderStage.Hull:
                NativeDeviceChild = new HullShader(device.NativeDevice, shaderBytecode);
                break;

            case ShaderStage.Domain:
                NativeDeviceChild = new DomainShader(device.NativeDevice, shaderBytecode);
                break;

            case ShaderStage.Geometry:
                NativeDeviceChild = new GeometryShader(device.NativeDevice, shaderBytecode);
                break;

            case ShaderStage.Pixel:
                NativeDeviceChild = new PixelShader(device.NativeDevice, shaderBytecode);
                break;

            case ShaderStage.Compute:
                NativeDeviceChild = new ComputeShader(device.NativeDevice, shaderBytecode);
                break;

            default:
                throw new ArgumentOutOfRangeException("shaderStage");
            }
        }
コード例 #20
0
        private void ResetManagedState()
        {
            _numVertexBindings = 0;
            Util.ClearArray(_vertexBindings);
            _vertexStrides = null;
            Util.ClearArray(_vertexOffsets);

            _fb = null;

            Util.ClearArray(_viewports);
            Util.ClearArray(_scissors);
            _viewportsChanged    = false;
            _scissorRectsChanged = false;

            _ib                = null;
            _pipeline          = null;
            _blendState        = null;
            _depthStencilState = null;
            _rasterizerState   = null;
            _primitiveTopology = SharpDX.Direct3D.PrimitiveTopology.Undefined;
            _inputLayout       = null;
            _vertexShader      = null;
            _geometryShader    = null;
            _hullShader        = null;
            _domainShader      = null;
            _pixelShader       = null;
            Util.ClearArray(_resourceSets);

            Util.ClearArray(_vertexBoundUniformBuffers);
            Util.ClearArray(_vertexBoundTextureViews);
            Util.ClearArray(_vertexBoundSamplers);

            Util.ClearArray(_fragmentBoundUniformBuffers);
            Util.ClearArray(_fragmentBoundTextureViews);
            Util.ClearArray(_fragmentBoundSamplers);
        }
コード例 #21
0
 private void ShuddownShader()
 {
     // Release the tessellation constant buffer.
     ConstantTessellationBuffer?.Dispose();
     ConstantTessellationBuffer = null;
     // Release the matrix constant buffer.
     ConstantMatrixBuffer?.Dispose();
     ConstantMatrixBuffer = null;
     // Release the layout.
     Layout?.Dispose();
     Layout = null;
     // Release the Vertex shader.
     VertexShader?.Dispose();
     VertexShader = null;
     // Release the Hull shader.
     PixelShader?.Dispose();
     PixelShader = null;
     // Release the Domain shader.
     HullShader?.Dispose();
     HullShader = null;
     // Release the Pixel shader.
     DomainShader?.Dispose();
     DomainShader = null;
 }
コード例 #22
0
        protected override void CreateDeviceDependentResources(DeviceManager deviceManager)
        {
            base.CreateDeviceDependentResources(deviceManager);

            // Release all resources
            RemoveAndDispose(ref vertexShader);

            RemoveAndDispose(ref pixelShader);
            RemoveAndDispose(ref depthPixelShader);
            RemoveAndDispose(ref lambertShader);
            RemoveAndDispose(ref blinnPhongShader);
            RemoveAndDispose(ref phongShader);

            RemoveAndDispose(ref tessellateVertexShader);
            RemoveAndDispose(ref tessellateTriIntegerShader);
            RemoveAndDispose(ref tessellateTriPow2Shader);
            RemoveAndDispose(ref tessellateTriFractionalEvenShader);
            RemoveAndDispose(ref tessellateTriFractionalOddShader);
            RemoveAndDispose(ref tessellateTriDomainShader);

            RemoveAndDispose(ref tessellateQuadIntegerShader);
            RemoveAndDispose(ref tessellateQuadPow2Shader);
            RemoveAndDispose(ref tessellateQuadFractionalEvenShader);
            RemoveAndDispose(ref tessellateQuadFractionalOddShader);
            RemoveAndDispose(ref tessellateQuadDomainShader);

            RemoveAndDispose(ref tessellateBezierIntegerShader);
            RemoveAndDispose(ref tessellateBezierPow2Shader);
            RemoveAndDispose(ref tessellateBezierFractionalEvenShader);
            RemoveAndDispose(ref tessellateBezierFractionalOddShader);
            RemoveAndDispose(ref tessellateBezierDomainShader);

            RemoveAndDispose(ref tessellateParametricIntegerShader);
            RemoveAndDispose(ref tessellateParametricPow2Shader);
            RemoveAndDispose(ref tessellateParametricFractionalEvenShader);
            RemoveAndDispose(ref tessellateParametricFractionalOddShader);
            RemoveAndDispose(ref tessellateParametricDomainShader);

            RemoveAndDispose(ref debugNormals);

            RemoveAndDispose(ref vertexLayout);
            RemoveAndDispose(ref perObjectBuffer);
            RemoveAndDispose(ref perFrameBuffer);
            RemoveAndDispose(ref perMaterialBuffer);
            RemoveAndDispose(ref perArmatureBuffer);

            RemoveAndDispose(ref depthStencilState);

            // Get a reference to the Device1 instance and immediate context
            var device  = deviceManager.Direct3DDevice;
            var context = deviceManager.Direct3DContext;


            // Compile and create the vertex shader and input layout
            using (var vertexShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\VS.hlsl", "VSMain", "vs_5_0"))
                using (var vertexTessBytecode = HLSLCompiler.CompileFromFile(@"Shaders\VS.hlsl", "VSPassThruTessellate", "vs_5_0"))
                {
                    vertexShader           = ToDispose(new VertexShader(device, vertexShaderBytecode));
                    tessellateVertexShader = ToDispose(new VertexShader(device, vertexTessBytecode));

                    // Layout from VertexShader input signature
                    vertexLayout = ToDispose(new InputLayout(device,
                                                             vertexShaderBytecode.GetPart(ShaderBytecodePart.InputSignatureBlob),
                                                             new[]
                    {
                        // "SV_Position" = vertex coordinate in object space
                        new InputElement("SV_Position", 0, Format.R32G32B32_Float, 0, 0),
                        // "NORMAL" = the vertex normal
                        new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
                        // "COLOR"
                        new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 24, 0),
                        // "UV"
                        new InputElement("TEXCOORD", 0, Format.R32G32_Float, 28, 0),
                        // "BLENDINDICES"
                        new InputElement("BLENDINDICES", 0, Format.R32G32B32A32_UInt, 36, 0),
                        // "BLENDWEIGHT"
                        new InputElement("BLENDWEIGHT", 0, Format.R32G32B32A32_Float, 52, 0),
                    }));
                }

            // Compile and create the pixel shader
            using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\SimplePS.hlsl", "PSMain", "ps_5_0"))
                pixelShader = ToDispose(new PixelShader(device, bytecode));

            // Compile and create the depth vertex and pixel shaders
            // This shader is for checking what the depth buffer would look like
            using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\DepthPS.hlsl", "PSMain", "ps_5_0"))
                depthPixelShader = ToDispose(new PixelShader(device, bytecode));

            // Compile and create the Lambert pixel shader
            using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\DiffusePS.hlsl", "PSMain", "ps_5_0"))
                lambertShader = ToDispose(new PixelShader(device, bytecode));

            // Compile and create the Lambert pixel shader
            using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\BlinnPhongPS.hlsl", "PSMain", "ps_5_0"))
                blinnPhongShader = ToDispose(new PixelShader(device, bytecode));

            // Compile and create the Lambert pixel shader
            using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\PhongPS.hlsl", "PSMain", "ps_5_0"))
                phongShader = ToDispose(new PixelShader(device, bytecode));

            #region Tessellation Shaders

            using (var integer = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesInteger", "hs_5_0", null))
                using (var pow2 = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesPow2", "hs_5_0", null))
                    using (var fracEven = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesFractionalEven", "hs_5_0", null))
                        using (var fracOdd = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "HS_TrianglesFractionalOdd", "hs_5_0", null))
                            using (var domain = HLSLCompiler.CompileFromFile(@"Shaders\TessellateTri.hlsl", "DS_Triangles", "ds_5_0", null))
                            {
                                tessellateTriIntegerShader        = ToDispose(new HullShader(device, integer));
                                tessellateTriPow2Shader           = ToDispose(new HullShader(device, pow2));
                                tessellateTriFractionalEvenShader = ToDispose(new HullShader(device, fracEven));
                                tessellateTriFractionalOddShader  = ToDispose(new HullShader(device, fracOdd));
                                tessellateTriDomainShader         = ToDispose(new DomainShader(device, domain));
                            }
            using (var quadIntegerBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateQuad.hlsl", "HS_QuadsInteger", "hs_5_0", null))
                using (var quadPow2Bytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateQuad.hlsl", "HS_QuadsPow2", "hs_5_0", null))
                    using (var quadFractionalEvenBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateQuad.hlsl", "HS_QuadsFractionalEven", "hs_5_0", null))
                        using (var quadFractionalOddBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateQuad.hlsl", "HS_QuadsFractionalOdd", "hs_5_0", null))
                            using (var quadDomainShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateQuad.hlsl", "DS_Quads", "ds_5_0", null))
                            {
                                tessellateQuadIntegerShader        = ToDispose(new HullShader(device, quadIntegerBytecode));
                                tessellateQuadPow2Shader           = ToDispose(new HullShader(device, quadPow2Bytecode));
                                tessellateQuadFractionalEvenShader = ToDispose(new HullShader(device, quadFractionalEvenBytecode));
                                tessellateQuadFractionalOddShader  = ToDispose(new HullShader(device, quadFractionalOddBytecode));
                                tessellateQuadDomainShader         = ToDispose(new DomainShader(device, quadDomainShaderBytecode));
                            }
            using (var bezierIntegerBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateBezier.hlsl", "HS_BezierInteger", "hs_5_0", null))
                using (var bezierPow2Bytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateBezier.hlsl", "HS_BezierPow2", "hs_5_0", null))
                    using (var bezierFractionalEvenBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateBezier.hlsl", "HS_BezierFractionalEven", "hs_5_0", null))
                        using (var bezierFractionalOddBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateBezier.hlsl", "HS_BezierFractionalOdd", "hs_5_0", null))
                            using (var bezierDomainShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateBezier.hlsl", "DS_Bezier", "ds_5_0", null))
                            {
                                tessellateBezierIntegerShader        = ToDispose(new HullShader(device, bezierIntegerBytecode));
                                tessellateBezierPow2Shader           = ToDispose(new HullShader(device, bezierPow2Bytecode));
                                tessellateBezierFractionalEvenShader = ToDispose(new HullShader(device, bezierFractionalEvenBytecode));
                                tessellateBezierFractionalOddShader  = ToDispose(new HullShader(device, bezierFractionalOddBytecode));
                                tessellateBezierDomainShader         = ToDispose(new DomainShader(device, bezierDomainShaderBytecode));
                            }

            using (var parametricIntegerBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateParametric.hlsl", "HS_ParametricInteger", "hs_5_0", null))
                using (var parametricPow2Bytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateParametric.hlsl", "HS_ParametricPow2", "hs_5_0", null))
                    using (var parametricFractionalEvenBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateParametric.hlsl", "HS_ParametricFractionalEven", "hs_5_0", null))
                        using (var parametricFractionalOddBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateParametric.hlsl", "HS_ParametricFractionalOdd", "hs_5_0", null))
                            using (var parametricDomainShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\TessellateParametric.hlsl", "DS_Parametric", "ds_5_0", null))
                            {
                                tessellateParametricIntegerShader        = ToDispose(new HullShader(device, parametricIntegerBytecode));
                                tessellateParametricPow2Shader           = ToDispose(new HullShader(device, parametricPow2Bytecode));
                                tessellateParametricFractionalEvenShader = ToDispose(new HullShader(device, parametricFractionalEvenBytecode));
                                tessellateParametricFractionalOddShader  = ToDispose(new HullShader(device, parametricFractionalOddBytecode));
                                tessellateParametricDomainShader         = ToDispose(new DomainShader(device, parametricDomainShaderBytecode));
                            }

            using (var geomShaderByteCode = HLSLCompiler.CompileFromFile(@"Shaders\GS_DebugNormals.hlsl", "GSMain", "gs_5_0", null))
            {
                debugNormals = ToDispose(new GeometryShader(device, geomShaderByteCode));
            }

            #endregion


            // IMPORTANT: A constant buffer's size must be a multiple of 16-bytes
            // use LayoutKind.Explicit and an explicit Size= to force this for structures
            // or alternatively add padding fields and use a LayoutKind.Sequential and Pack=1

            // Create the constant buffer that will
            // store our worldViewProjection matrix
            perObjectBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <ConstantBuffers.PerObject>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));

            // Create the per frame constant buffer
            // lighting / camera position
            perFrameBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerFrame>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));

            // Create the per material constant buffer
            perMaterialBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerMaterial>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));

            // Create the per armature/skeletong constant buffer
            perArmatureBuffer = ToDispose(new Buffer(device, ConstantBuffers.PerArmature.Size(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));

            // Configure the depth buffer to discard pixels that are
            // further than the current pixel.
            depthStencilState = ToDispose(new DepthStencilState(device,
                                                                new DepthStencilStateDescription()
            {
                IsDepthEnabled   = true,   // enable depth?
                DepthComparison  = Comparison.Less,
                DepthWriteMask   = SharpDX.Direct3D11.DepthWriteMask.All,
                IsStencilEnabled = false,   // enable stencil?
                StencilReadMask  = 0xff,    // 0xff (no mask)
                StencilWriteMask = 0xff,    // 0xff (no mask)
                // Configure FrontFace depth/stencil operations
                FrontFace = new DepthStencilOperationDescription()
                {
                    Comparison         = Comparison.Always,
                    PassOperation      = StencilOperation.Keep,
                    FailOperation      = StencilOperation.Keep,
                    DepthFailOperation = StencilOperation.Increment
                },
                // Configure BackFace depth/stencil operations
                BackFace = new DepthStencilOperationDescription()
                {
                    Comparison         = Comparison.Always,
                    PassOperation      = StencilOperation.Keep,
                    FailOperation      = StencilOperation.Keep,
                    DepthFailOperation = StencilOperation.Decrement
                },
            }));

            // Tell the IA what the vertices will look like
            context.InputAssembler.InputLayout = vertexLayout;

            // Set our constant buffer (to store worldViewProjection)
            context.VertexShader.SetConstantBuffer(0, perObjectBuffer);
            context.VertexShader.SetConstantBuffer(1, perFrameBuffer);
            context.VertexShader.SetConstantBuffer(2, perMaterialBuffer);
            context.VertexShader.SetConstantBuffer(3, perArmatureBuffer);

            // Set the vertex shader to run
            context.VertexShader.Set(vertexShader);

            // Set our hull/domain shader constant buffers
            context.HullShader.SetConstantBuffer(0, perObjectBuffer);
            context.HullShader.SetConstantBuffer(1, perFrameBuffer);
            context.DomainShader.SetConstantBuffer(0, perObjectBuffer);
            context.DomainShader.SetConstantBuffer(1, perFrameBuffer);

            // Set gemoetry shader buffers
            context.GeometryShader.SetConstantBuffer(0, perObjectBuffer);
            context.GeometryShader.SetConstantBuffer(1, perFrameBuffer);

            // Set our pixel constant buffers
            context.PixelShader.SetConstantBuffer(1, perFrameBuffer);
            context.PixelShader.SetConstantBuffer(2, perMaterialBuffer);

            // Set the pixel shader to run
            context.PixelShader.Set(blinnPhongShader);

            // Set our depth stencil state
            context.OutputMerger.DepthStencilState = depthStencilState;

            // Back-face culling
            context.Rasterizer.State = ToDispose(new RasterizerState(device, new RasterizerStateDescription()
            {
                FillMode = FillMode.Wireframe,
                CullMode = CullMode.Back,
            }));
        }
コード例 #23
0
ファイル: EffectPool.cs プロジェクト: loreggia/SharpDX
        internal DeviceChild GetOrCompileShader(EffectShaderType shaderType, int index, int soRasterizedStream, StreamOutputElement[] soElements, out string profileError)
        {
            DeviceChild shader = null;

            profileError = null;
            lock (sync)
            {
                shader = compiledShadersGroup[(int)shaderType][index];
                if (shader == null)
                {
                    if (RegisteredShaders[index].Level > graphicsDevice.Features.Level)
                    {
                        profileError = string.Format("{0}", RegisteredShaders[index].Level);
                        return(null);
                    }

                    var bytecodeRaw = RegisteredShaders[index].Bytecode;
                    switch (shaderType)
                    {
                    case EffectShaderType.Vertex:
                        shader = new VertexShader(graphicsDevice, bytecodeRaw);
                        break;

                    case EffectShaderType.Domain:
                        shader = new DomainShader(graphicsDevice, bytecodeRaw);
                        break;

                    case EffectShaderType.Hull:
                        shader = new HullShader(graphicsDevice, bytecodeRaw);
                        break;

                    case EffectShaderType.Geometry:
                        if (soElements != null)
                        {
                            // Calculate the strides
                            var soStrides = new List <int>();
                            foreach (var streamOutputElement in soElements)
                            {
                                for (int i = soStrides.Count; i < (streamOutputElement.Stream + 1); i++)
                                {
                                    soStrides.Add(0);
                                }

                                soStrides[streamOutputElement.Stream] += streamOutputElement.ComponentCount * sizeof(float);
                            }
                            shader = new GeometryShader(graphicsDevice, bytecodeRaw, soElements, soStrides.ToArray(), soRasterizedStream);
                        }
                        else
                        {
                            shader = new GeometryShader(graphicsDevice, bytecodeRaw);
                        }
                        break;

                    case EffectShaderType.Pixel:
                        shader = new PixelShader(graphicsDevice, bytecodeRaw);
                        break;

                    case EffectShaderType.Compute:
                        shader = new ComputeShader(graphicsDevice, bytecodeRaw);
                        break;
                    }
                    compiledShadersGroup[(int)shaderType][index] = ToDispose(shader);
                }
            }
            return(shader);
        }
コード例 #24
0
            private bool disposedValue = false; // To detect redundant calls

            public StateBackup(DeviceContext deviceContext)
            {
                this.deviceContext = deviceContext;

                this.ScissorRects        = new Rectangle[16]; // I couldn't find D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE as a SharpDX enum
                this.Viewports           = new RawViewportF[16];
                this.VertexBuffers       = new Buffer[InputAssemblerStage.VertexInputResourceSlotCount];
                this.VertexBufferStrides = new int[InputAssemblerStage.VertexInputResourceSlotCount];
                this.VertexBufferOffsets = new int[InputAssemblerStage.VertexInputResourceSlotCount];

                // IA
                this.InputLayout = deviceContext.InputAssembler.InputLayout;
                this.deviceContext.InputAssembler.GetIndexBuffer(out this.IndexBuffer, out this.IndexBufferFormat, out this.IndexBufferOffset);
                this.PrimitiveTopology = this.deviceContext.InputAssembler.PrimitiveTopology;
                this.deviceContext.InputAssembler.GetVertexBuffers(0, InputAssemblerStage.VertexInputResourceSlotCount, this.VertexBuffers, this.VertexBufferStrides, this.VertexBufferOffsets);

                // RS
                this.RS = this.deviceContext.Rasterizer.State;
                this.deviceContext.Rasterizer.GetScissorRectangles <Rectangle>(this.ScissorRects);
                this.deviceContext.Rasterizer.GetViewports <RawViewportF>(this.Viewports);

                // OM
                this.BlendState        = this.deviceContext.OutputMerger.GetBlendState(out this.BlendFactor, out this.SampleMask);
                this.DepthStencilState = this.deviceContext.OutputMerger.GetDepthStencilState(out this.DepthStencilRef);
                this.RenderTargetViews = this.deviceContext.OutputMerger.GetRenderTargets(OutputMergerStage.SimultaneousRenderTargetCount, out this.DepthStencilView);

                // VS
                this.VS                = this.deviceContext.VertexShader.Get();
                this.VSSamplers        = this.deviceContext.VertexShader.GetSamplers(0, CommonShaderStage.SamplerSlotCount);
                this.VSConstantBuffers = this.deviceContext.VertexShader.GetConstantBuffers(0, CommonShaderStage.ConstantBufferApiSlotCount);
                this.VSResourceViews   = this.deviceContext.VertexShader.GetShaderResources(0, CommonShaderStage.InputResourceSlotCount);

                // HS
                this.HS                = this.deviceContext.HullShader.Get();
                this.HSSamplers        = this.deviceContext.HullShader.GetSamplers(0, CommonShaderStage.SamplerSlotCount);
                this.HSConstantBuffers = this.deviceContext.HullShader.GetConstantBuffers(0, CommonShaderStage.ConstantBufferApiSlotCount);
                this.HSResourceViews   = this.deviceContext.HullShader.GetShaderResources(0, CommonShaderStage.InputResourceSlotCount);

                // DS
                this.DS                = this.deviceContext.DomainShader.Get();
                this.DSSamplers        = this.deviceContext.DomainShader.GetSamplers(0, CommonShaderStage.SamplerSlotCount);
                this.DSConstantBuffers = this.deviceContext.DomainShader.GetConstantBuffers(0, CommonShaderStage.ConstantBufferApiSlotCount);
                this.DSResourceViews   = this.deviceContext.DomainShader.GetShaderResources(0, CommonShaderStage.InputResourceSlotCount);

                // GS
                this.GS                = this.deviceContext.GeometryShader.Get();
                this.GSSamplers        = this.deviceContext.GeometryShader.GetSamplers(0, CommonShaderStage.SamplerSlotCount);
                this.GSConstantBuffers = this.deviceContext.GeometryShader.GetConstantBuffers(0, CommonShaderStage.ConstantBufferApiSlotCount);
                this.GSResourceViews   = this.deviceContext.GeometryShader.GetShaderResources(0, CommonShaderStage.InputResourceSlotCount);

                // PS
                this.PS                = this.deviceContext.PixelShader.Get();
                this.PSSamplers        = this.deviceContext.PixelShader.GetSamplers(0, CommonShaderStage.SamplerSlotCount);
                this.PSConstantBuffers = this.deviceContext.PixelShader.GetConstantBuffers(0, CommonShaderStage.ConstantBufferApiSlotCount);
                this.PSResourceViews   = this.deviceContext.PixelShader.GetShaderResources(0, CommonShaderStage.InputResourceSlotCount);

                // CS
                this.CS                = this.deviceContext.ComputeShader.Get();
                this.CSSamplers        = this.deviceContext.ComputeShader.GetSamplers(0, CommonShaderStage.SamplerSlotCount);
                this.CSConstantBuffers = this.deviceContext.ComputeShader.GetConstantBuffers(0, CommonShaderStage.ConstantBufferApiSlotCount);
                this.CSResourceViews   = this.deviceContext.ComputeShader.GetShaderResources(0, CommonShaderStage.InputResourceSlotCount);
                this.CSUAVs            = this.deviceContext.ComputeShader.GetUnorderedAccessViews(0, ComputeShaderStage.UnorderedAccessViewSlotCount); // should be register count and not slot, but the value is correct
            }
コード例 #25
0
ファイル: ShaderPass.cs プロジェクト: xzcxlyh/helix-toolkit
 /// <summary>
 /// Sets the shader.
 /// </summary>
 /// <param name="shader">The shader.</param>
 public void SetShader(HullShader shader)
 {
     HullShader = shader;
 }
コード例 #26
0
ファイル: Shader.cs プロジェクト: Saggre/Raymarch-Engine
        /// <summary>
        /// Compiles files into shader byte-code and creates a shader from the shader files that exist
        /// </summary>
        /// <param name="folderPath"></param>
        public static Shader CompileFromFiles(string folderPath)
        {
            // TODO simplify method with a loop
            // TODO build shaders on program build with dxc

            ShaderFlags shaderFlags = ShaderFlags.Debug;

            InputLayout    inputLayout    = null;
            VertexShader   vertexShader   = null;
            HullShader     hullShader     = null;
            DomainShader   domainShader   = null;
            GeometryShader geometryShader = null;
            PixelShader    pixelShader    = null;

            // Handler for #include directive
            HLSLFileIncludeHandler includeHandler = new HLSLFileIncludeHandler(folderPath);

            // Vertex shader + Shader signature
            {
                string path = Path.Combine(folderPath, "Vertex.hlsl");

                if (File.Exists(path))
                {
                    CompilationResult byteCode = ShaderBytecode.CompileFromFile(path, "main", "vs_5_0", shaderFlags,
                                                                                EffectFlags.None, null, includeHandler);
                    vertexShader = new VertexShader(Engine.RenderDevice.device, byteCode);

                    ShaderSignature inputSignature = ShaderSignature.GetInputSignature(byteCode);
                    inputLayout = new InputLayout(Engine.RenderDevice.device, inputSignature,
                                                  RenderVertex.InputElements);
                }
                else
                {
                    // TODO fail
                }
            }

            // Hull shader
            {
                string path = Path.Combine(folderPath, "Hull.hlsl");

                if (File.Exists(path))
                {
                    CompilationResult byteCode = ShaderBytecode.CompileFromFile(path, "main", "hs_5_0", shaderFlags,
                                                                                EffectFlags.None, null, includeHandler);
                    hullShader = new HullShader(Engine.RenderDevice.device, byteCode);
                }
            }

            // Domain shader
            {
                string path = Path.Combine(folderPath, "Domain.hlsl");

                if (File.Exists(path))
                {
                    CompilationResult byteCode = ShaderBytecode.CompileFromFile(path, "main", "ds_5_0", shaderFlags,
                                                                                EffectFlags.None, null, includeHandler);
                    domainShader = new DomainShader(Engine.RenderDevice.device, byteCode);
                }
            }

            // Geometry shader
            {
                string path = Path.Combine(folderPath, "Geometry.hlsl");

                if (File.Exists(path))
                {
                    CompilationResult byteCode = ShaderBytecode.CompileFromFile(path, "main", "gs_5_0", shaderFlags,
                                                                                EffectFlags.None, null, includeHandler);
                    geometryShader = new GeometryShader(Engine.RenderDevice.device, byteCode);
                }
            }

            // Pixel shader
            {
                string path = Path.Combine(folderPath, "Pixel.hlsl");

                if (File.Exists(path))
                {
                    CompilationResult byteCode = ShaderBytecode.CompileFromFile(path, "main", "ps_5_0", shaderFlags,
                                                                                EffectFlags.None, null, includeHandler);
                    pixelShader = new PixelShader(Engine.RenderDevice.device, byteCode);
                }
            }

            return(new Shader(inputLayout, vertexShader, hullShader, domainShader, geometryShader, pixelShader));
        }
コード例 #27
0
        public override void SetPipeline(Pipeline pipeline)
        {
            if (_pipeline != pipeline)
            {
                D3D11Pipeline d3dPipeline = Util.AssertSubtype <Pipeline, D3D11Pipeline>(pipeline);
                _pipeline = d3dPipeline;
                Util.ClearArray(_resourceSets); // Invalidate resource set bindings -- they may be invalid.

                BlendState blendState = d3dPipeline.BlendState;
                if (_blendState != blendState)
                {
                    _blendState = blendState;
                    _context.OutputMerger.SetBlendState(blendState);
                }

                DepthStencilState depthStencilState = d3dPipeline.DepthStencilState;
                if (_depthStencilState != depthStencilState)
                {
                    _depthStencilState = depthStencilState;
                    _context.OutputMerger.SetDepthStencilState(depthStencilState);
                }

                RasterizerState rasterizerState = d3dPipeline.RasterizerState;
                if (_rasterizerState != rasterizerState)
                {
                    _rasterizerState          = rasterizerState;
                    _context.Rasterizer.State = rasterizerState;
                }

                SharpDX.Direct3D.PrimitiveTopology primitiveTopology = d3dPipeline.PrimitiveTopology;
                if (_primitiveTopology != primitiveTopology)
                {
                    _primitiveTopology = primitiveTopology;
                    _context.InputAssembler.PrimitiveTopology = primitiveTopology;
                }

                InputLayout inputLayout = d3dPipeline.InputLayout;
                if (_inputLayout != inputLayout)
                {
                    _inputLayout = inputLayout;
                    _context.InputAssembler.InputLayout = inputLayout;
                }

                VertexShader vertexShader = d3dPipeline.VertexShader;
                if (_vertexShader != vertexShader)
                {
                    _vertexShader = vertexShader;
                    _context.VertexShader.Set(vertexShader);
                }

                GeometryShader geometryShader = d3dPipeline.GeometryShader;
                if (_geometryShader != geometryShader)
                {
                    _geometryShader = geometryShader;
                    _context.GeometryShader.Set(geometryShader);
                }

                HullShader hullShader = d3dPipeline.HullShader;
                if (_hullShader != hullShader)
                {
                    _hullShader = hullShader;
                    _context.HullShader.Set(hullShader);
                }

                DomainShader domainShader = d3dPipeline.DomainShader;
                if (_domainShader != domainShader)
                {
                    _domainShader = domainShader;
                    _context.DomainShader.Set(domainShader);
                }

                PixelShader pixelShader = d3dPipeline.PixelShader;
                if (_pixelShader != pixelShader)
                {
                    _pixelShader = pixelShader;
                    _context.PixelShader.Set(pixelShader);
                }

                _vertexStrides = d3dPipeline.VertexStrides;
                int vertexStridesCount = _vertexStrides.Length;
                Util.EnsureArraySize(ref _vertexBindings, (uint)vertexStridesCount);
                Util.EnsureArraySize(ref _vertexOffsets, (uint)vertexStridesCount);

                Util.EnsureArraySize(ref _resourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
            }
        }
コード例 #28
0
        /// <summary>
        /// Create Shader.
        /// <para>All constant buffers for all shaders are created here./></para>
        /// </summary>
        /// <param name="device"></param>
        /// <param name="pool"></param>
        /// <returns></returns>
        public ShaderBase CreateShader(Device device, IConstantBufferPool pool)
        {
            if (ByteCode == null)
            {
                return(null);
            }
            if (shaderReflector != null)
            {
                shaderReflector.Parse(ByteCode, ShaderType);
                Level = shaderReflector.FeatureLevel;
                if (Level > device.FeatureLevel)
                {
                    throw new Exception($"Shader {this.Name} requires FeatureLevel {Level}. Current device only supports FeatureLevel {device.FeatureLevel} and below.");
                }
                this.ConstantBufferMappings = shaderReflector.ConstantBufferMappings.Values.ToArray();
                this.TextureMappings        = shaderReflector.TextureMappings.Values.ToArray();
                this.UAVMappings            = shaderReflector.UAVMappings.Values.ToArray();
                this.SamplerMappings        = shaderReflector.SamplerMappings.Values.ToArray();
            }
            ShaderBase shader = null;

            switch (ShaderType)
            {
            case ShaderStage.Vertex:
                shader = new VertexShader(device, Name, ByteCode);
                break;

            case ShaderStage.Pixel:
                shader = new PixelShader(device, Name, ByteCode);
                break;

            case ShaderStage.Compute:
                shader = new ComputeShader(device, Name, ByteCode);
                break;

            case ShaderStage.Domain:
                shader = new DomainShader(device, Name, ByteCode);
                break;

            case ShaderStage.Hull:
                shader = new HullShader(device, Name, ByteCode);
                break;

            case ShaderStage.Geometry:
                shader = new GeometryShader(device, Name, ByteCode);
                break;

            default:
                shader = NullShader.GetNullShader(ShaderType);
                break;
            }
            if (ConstantBufferMappings != null)
            {
                foreach (var mapping in ConstantBufferMappings)
                {
                    shader.ConstantBufferMapping.AddMapping(mapping.Description.Name, mapping.Slot, pool.Register(mapping.Description));
                }
            }
            if (TextureMappings != null)
            {
                foreach (var mapping in TextureMappings)
                {
                    shader.ShaderResourceViewMapping.AddMapping(mapping.Description.Name, mapping.Slot, mapping);
                }
            }
            if (UAVMappings != null)
            {
                foreach (var mapping in UAVMappings)
                {
                    shader.UnorderedAccessViewMapping.AddMapping(mapping.Description.Name, mapping.Slot, mapping);
                }
            }
            if (SamplerMappings != null)
            {
                foreach (var mapping in SamplerMappings)
                {
                    shader.SamplerMapping.AddMapping(mapping.Name, mapping.Slot, mapping);
                }
            }
            return(shader);
        }
コード例 #29
0
ファイル: ShaderFactory.cs プロジェクト: temik911/audio
        public HullShader GetHullShader( string bytecode )
        {
            HullShader	shader;

            if (!hsDictionary.TryGetValue( bytecode, out shader ) ) {
                shader = new HullShader( device, bytecode );
                hsDictionary.Add( bytecode, shader );
            }

            return shader;
        }
コード例 #30
0
        private void CreateShaders()
        {
            foreach (var shaderBytecode in effectBytecode.Stages)
            {
                var bytecodeRaw = shaderBytecode.Data;
                var reflection  = effectBytecode.Reflection;

                // TODO CACHE Shaders with a bytecode hash
                switch (shaderBytecode.Stage)
                {
                case ShaderStage.Vertex:
                    vertexShader = new VertexShader(GraphicsDevice.NativeDevice, bytecodeRaw);
                    // Note: input signature can be reused when reseting device since it only stores non-GPU data,
                    // so just keep it if it has already been created before.
                    if (inputSignature == null)
                    {
                        inputSignature = EffectInputSignature.GetOrCreateLayout(new EffectInputSignature(shaderBytecode.Id, bytecodeRaw));
                    }
                    break;

                case ShaderStage.Domain:
                    domainShader = new DomainShader(GraphicsDevice.NativeDevice, bytecodeRaw);
                    break;

                case ShaderStage.Hull:
                    hullShader = new HullShader(GraphicsDevice.NativeDevice, bytecodeRaw);
                    break;

                case ShaderStage.Geometry:
                    if (reflection.ShaderStreamOutputDeclarations != null && reflection.ShaderStreamOutputDeclarations.Count > 0)
                    {
                        // Calculate the strides
                        var soStrides = new List <int>();
                        foreach (var streamOutputElement in reflection.ShaderStreamOutputDeclarations)
                        {
                            for (int i = soStrides.Count; i < (streamOutputElement.Stream + 1); i++)
                            {
                                soStrides.Add(0);
                            }

                            soStrides[streamOutputElement.Stream] += streamOutputElement.ComponentCount * sizeof(float);
                        }
                        var soElements = new StreamOutputElement[0];     // TODO CREATE StreamOutputElement from bytecode.Reflection.ShaderStreamOutputDeclarations
                        geometryShader = new GeometryShader(GraphicsDevice.NativeDevice, bytecodeRaw, soElements, soStrides.ToArray(), reflection.StreamOutputRasterizedStream);
                    }
                    else
                    {
                        geometryShader = new GeometryShader(GraphicsDevice.NativeDevice, bytecodeRaw);
                    }
                    break;

                case ShaderStage.Pixel:
                    pixelShader = new PixelShader(GraphicsDevice.NativeDevice, bytecodeRaw);
                    break;

                case ShaderStage.Compute:
                    computeShader = new ComputeShader(GraphicsDevice.NativeDevice, bytecodeRaw);
                    break;
                }
            }
        }
コード例 #31
0
            /// <summary>
            /// Create Shader.
            /// <para>All constant buffers for all shaders are created here./></para>
            /// </summary>
            /// <param name="device"></param>
            /// <param name="pool"></param>
            /// <param name="logger"></param>
            /// <returns></returns>
            public ShaderBase CreateShader(Device device, IConstantBufferPool pool, LogWrapper logger)
            {
                if (ByteCode == null)
                {
                    return(null);
                }
                ShaderReflector = ShaderReflector ?? new ShaderReflector();
                ShaderReflector.Parse(ByteCode, ShaderType);
                Level = ShaderReflector.FeatureLevel;
                if (Level > device.FeatureLevel)
                {
                    logger?.Log(LogLevel.Warning, $"Shader {this.Name} requires FeatureLevel {Level}. Current device only supports FeatureLevel {device.FeatureLevel} and below.");
                    return(null);
                    //throw new Exception($"Shader {this.Name} requires FeatureLevel {Level}. Current device only supports FeatureLevel {device.FeatureLevel} and below.");
                }
                this.ConstantBufferMappings = ShaderReflector.ConstantBufferMappings.Values.ToArray();
                this.TextureMappings        = ShaderReflector.TextureMappings.Values.ToArray();
                this.UAVMappings            = ShaderReflector.UAVMappings.Values.ToArray();
                this.SamplerMappings        = ShaderReflector.SamplerMappings.Values.ToArray();

                ShaderBase shader = null;

                switch (ShaderType)
                {
                case ShaderStage.Vertex:
                    shader = new VertexShader(device, Name, ByteCode);
                    break;

                case ShaderStage.Pixel:
                    shader = new PixelShader(device, Name, ByteCode);
                    break;

                case ShaderStage.Compute:
                    shader = new ComputeShader(device, Name, ByteCode);
                    break;

                case ShaderStage.Domain:
                    shader = new DomainShader(device, Name, ByteCode);
                    break;

                case ShaderStage.Hull:
                    shader = new HullShader(device, Name, ByteCode);
                    break;

                case ShaderStage.Geometry:
                    if (IsGSStreamOut)
                    {
                        shader = new GeometryShader(device, Name, ByteCode, GSSOElement, GSSOStrides, GSSORasterized);
                    }
                    else
                    {
                        shader = new GeometryShader(device, Name, ByteCode);
                    }
                    break;

                default:
                    break;
                }
                if (ConstantBufferMappings != null)
                {
                    foreach (var mapping in ConstantBufferMappings)
                    {
                        shader.ConstantBufferMapping.AddMapping(mapping.Description.Name, mapping.Slot, pool.Register(mapping.Description));
                    }
                }
                if (TextureMappings != null)
                {
                    foreach (var mapping in TextureMappings)
                    {
                        shader.ShaderResourceViewMapping.AddMapping(mapping.Description.Name, mapping.Slot, mapping);
                    }
                }
                if (UAVMappings != null)
                {
                    foreach (var mapping in UAVMappings)
                    {
                        shader.UnorderedAccessViewMapping.AddMapping(mapping.Description.Name, mapping.Slot, mapping);
                    }
                }
                if (SamplerMappings != null)
                {
                    foreach (var mapping in SamplerMappings)
                    {
                        shader.SamplerMapping.AddMapping(mapping.Name, mapping.Slot, mapping);
                    }
                }
                return(shader);
            }
コード例 #32
0
        protected override void SetPipelineCore(Pipeline pipeline)
        {
            if (!pipeline.IsComputePipeline && _graphicsPipeline != pipeline)
            {
                D3D11Pipeline d3dPipeline = Util.AssertSubtype <Pipeline, D3D11Pipeline>(pipeline);
                _graphicsPipeline = d3dPipeline;
                Util.ClearArray(_graphicsResourceSets); // Invalidate resource set bindings -- they may be invalid.
                Util.ClearArray(_invalidatedGraphicsResourceSets);

                BlendState blendState = d3dPipeline.BlendState;
                if (_blendState != blendState)
                {
                    _blendState = blendState;
                    _context.OutputMerger.SetBlendState(blendState);
                }

                DepthStencilState depthStencilState = d3dPipeline.DepthStencilState;
                uint stencilReference = d3dPipeline.StencilReference;
                if (_depthStencilState != depthStencilState || _stencilReference != stencilReference)
                {
                    _depthStencilState = depthStencilState;
                    _stencilReference  = stencilReference;
                    _context.OutputMerger.SetDepthStencilState(depthStencilState, (int)stencilReference);
                }

                RasterizerState rasterizerState = d3dPipeline.RasterizerState;
                if (_rasterizerState != rasterizerState)
                {
                    _rasterizerState          = rasterizerState;
                    _context.Rasterizer.State = rasterizerState;
                }

                SharpDX.Direct3D.PrimitiveTopology primitiveTopology = d3dPipeline.PrimitiveTopology;
                if (_primitiveTopology != primitiveTopology)
                {
                    _primitiveTopology = primitiveTopology;
                    _context.InputAssembler.PrimitiveTopology = primitiveTopology;
                }

                InputLayout inputLayout = d3dPipeline.InputLayout;
                if (_inputLayout != inputLayout)
                {
                    _inputLayout = inputLayout;
                    _context.InputAssembler.InputLayout = inputLayout;
                }

                VertexShader vertexShader = d3dPipeline.VertexShader;
                if (_vertexShader != vertexShader)
                {
                    _vertexShader = vertexShader;
                    _context.VertexShader.Set(vertexShader);
                }

                GeometryShader geometryShader = d3dPipeline.GeometryShader;
                if (_geometryShader != geometryShader)
                {
                    _geometryShader = geometryShader;
                    _context.GeometryShader.Set(geometryShader);
                }

                HullShader hullShader = d3dPipeline.HullShader;
                if (_hullShader != hullShader)
                {
                    _hullShader = hullShader;
                    _context.HullShader.Set(hullShader);
                }

                DomainShader domainShader = d3dPipeline.DomainShader;
                if (_domainShader != domainShader)
                {
                    _domainShader = domainShader;
                    _context.DomainShader.Set(domainShader);
                }

                PixelShader pixelShader = d3dPipeline.PixelShader;
                if (_pixelShader != pixelShader)
                {
                    _pixelShader = pixelShader;
                    _context.PixelShader.Set(pixelShader);
                }

                _vertexStrides = d3dPipeline.VertexStrides;
                if (_vertexStrides != null)
                {
                    int vertexStridesCount = _vertexStrides.Length;
                    Util.EnsureArrayMinimumSize(ref _vertexBindings, (uint)vertexStridesCount);
                    Util.EnsureArrayMinimumSize(ref _vertexOffsets, (uint)vertexStridesCount);
                }

                Util.EnsureArrayMinimumSize(ref _graphicsResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
                Util.EnsureArrayMinimumSize(ref _invalidatedGraphicsResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
            }
            else if (pipeline.IsComputePipeline && _computePipeline != pipeline)
            {
                D3D11Pipeline d3dPipeline = Util.AssertSubtype <Pipeline, D3D11Pipeline>(pipeline);
                _computePipeline = d3dPipeline;
                Util.ClearArray(_computeResourceSets); // Invalidate resource set bindings -- they may be invalid.
                Util.ClearArray(_invalidatedComputeResourceSets);

                ComputeShader computeShader = d3dPipeline.ComputeShader;
                _context.ComputeShader.Set(computeShader);
                Util.EnsureArrayMinimumSize(ref _computeResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
                Util.EnsureArrayMinimumSize(ref _invalidatedComputeResourceSets, (uint)d3dPipeline.ResourceLayouts.Length);
            }
        }