// Compile compute shader from file and add to computeShaders dictionary
        public void CompileComputeShader(string csFunction, string csFile = @"Shaders\ImageProcessingCS.hlsl", string csVersion = "cs_5_0")
        {
            var shaderFlags = ShaderFlags.None;

#if DEBUG
            shaderFlags = ShaderFlags.Debug | ShaderFlags.SkipOptimization;
#endif
            SharpDX.Direct3D.ShaderMacro[] defines = new[] {
                new SharpDX.Direct3D.ShaderMacro("THREADSX", ThreadsX),
                new SharpDX.Direct3D.ShaderMacro("THREADSY", ThreadsY),
            };

            // Use our HLSL file include handler to resolve #include directives in the HLSL source
            var includeHandler = new HLSLFileIncludeHandler(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "Shaders"));

            using (var bytecode = ShaderBytecode.CompileFromFile(csFile, csFunction, csVersion, shaderFlags, EffectFlags.None, defines, includeHandler))
            {
                computeShaders[csFunction] = ToDispose(new ComputeShader(this.DeviceManager.Direct3DDevice, bytecode));
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Compiles files into shader byte-code and creates a shader from the shader files that exist
        /// </summary>
        /// <param name="folderPath"></param>
        /// <param name="fileName"></param>
        public ComputeShader(string folderPath, string fileName)
        {
            Init();

            ShaderFlags shaderFlags = ShaderFlags.Debug;

            SharpDX.Direct3D11.ComputeShader computeShader = null;

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

            string path = Path.Combine(folderPath, fileName);

            if (File.Exists(path))
            {
                CompilationResult byteCode = ShaderBytecode.CompileFromFile(path, "main", "cs_5_0", shaderFlags,
                                                                            EffectFlags.None, null, includeHandler);
                computeShader = new SharpDX.Direct3D11.ComputeShader(d3dDevice, byteCode);
            }

            this.computeShader = computeShader;
        }
Esempio n. 3
0
        /// <summary>
        /// Create any device dependent resources here.
        /// This method will be called when the device is first
        /// initialized or recreated after being removed or reset.
        /// </summary>
        protected override void CreateDeviceDependentResources()
        {
            // Ensure that if already set the device resources
            // are correctly disposed of before recreating
            RemoveAndDispose(ref vertexShader);
            RemoveAndDispose(ref vertexLayout);
            RemoveAndDispose(ref vertexBuffer);

            // Retrieve our SharpDX.Direct3D11.Device1 instance
            var device = DeviceManager.Direct3DDevice;

            ShaderFlags shaderFlags = ShaderFlags.None;

#if DEBUG
            shaderFlags = ShaderFlags.Debug | ShaderFlags.SkipOptimization;
#endif
            // Use our HLSL file include handler to resolve #include directives in the HLSL source
            var includeHandler = new HLSLFileIncludeHandler(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "Shaders"));

            // Compile and create the vertex shader
            using (ShaderBytecode vertexShaderBytecode = ShaderBytecode.CompileFromFile(@"Shaders\SAQuad.hlsl", "VSMain", "vs_5_0", shaderFlags, EffectFlags.None, null, includeHandler))
            {
                vertexShader = ToDispose(new VertexShader(device, vertexShaderBytecode));
                // Layout from VertexShader input signature
                vertexLayout = ToDispose(new InputLayout(device,
                                                         vertexShaderBytecode.GetPart(ShaderBytecodePart.InputSignatureBlob),
                                                         //ShaderSignature.GetInputSignature(vertexShaderBytecode),
                                                         new[]
                {
                    // "SV_Position" = vertex coordinate
                    new InputElement("SV_Position", 0, Format.R32G32B32_Float, 0, 0),
                }));

                // Create vertex buffer
                vertexBuffer = ToDispose(Buffer.Create(device, BindFlags.VertexBuffer, new Vector3[] {
                    /*  Position: float x 3 */
                    new Vector3(-1.0f, -1.0f, -1.0f),
                    new Vector3(-1.0f, 1.0f, -1.0f),
                    new Vector3(1.0f, -1.0f, -1.0f),
                    new Vector3(1.0f, 1.0f, -1.0f),
                }));
                vertexBinding = new VertexBufferBinding(vertexBuffer, Utilities.SizeOf <Vector3>(), 0);
                // Triangle strip:
                // v1   v3
                // |\   |
                // | \ B|
                // | A\ |
                // |   \|
                // v0   v2
            }

            // Compile and create the pixel shader
            using (var bytecode = ToDispose(ShaderBytecode.CompileFromFile(@"Shaders\SAQuad.hlsl", "PSMain", "ps_5_0", shaderFlags, EffectFlags.None, null, includeHandler)))
                pixelShader = ToDispose(new PixelShader(device, bytecode));

            using (var bytecode = ToDispose(ShaderBytecode.CompileFromFile(@"Shaders\SAQuad.hlsl", "PSMainMultisample", "ps_5_0", shaderFlags, EffectFlags.None, null, includeHandler)))
                pixelShaderMS = ToDispose(new PixelShader(device, bytecode));

            samplerState = ToDispose(new SamplerState(device, new SamplerStateDescription
            {
                Filter             = Filter.MinMagMipLinear,
                AddressU           = TextureAddressMode.Wrap,
                AddressV           = TextureAddressMode.Wrap,
                AddressW           = TextureAddressMode.Wrap,
                ComparisonFunction = Comparison.Never,
                MinimumLod         = 0,
                MaximumLod         = float.MaxValue
            }));

            //pointSamplerState = ToDispose(new SamplerState(device, new SamplerStateDescription
            //{
            //    Filter = Filter.MinMagMipPoint,
            //    AddressU = TextureAddressMode.Wrap,
            //    AddressV = TextureAddressMode.Wrap,
            //    AddressW = TextureAddressMode.Wrap,
            //    ComparisonFunction = Comparison.Never,
            //    MinimumLod = 0,
            //    MaximumLod = float.MaxValue
            //}));
        }