Ejemplo n.º 1
0
        public SpritePS()
        {
            Name             = "SpritePS";
            Type             = ShaderType.Pixel;
            KeyPart          = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.DiffuseMap);
            FeatureLevel     = FeatureLevel.PS_4_0_Level_9_1;
            EnableSeparators = true;
            var inputStruct = SpriteVS.VSOut;

            inputStruct.Name = "input";

            InputStruct  = inputStruct;
            OutputStruct = Struct.PixelShaderOutput;
            Struct   cbMaterial = ConstantBuffer.CBMaterial;
            Struct   material   = (Struct)cbMaterial[Param.Struct.Material];
            Variable tDiffuse   = Texture.Diffuse;
            Variable sDiffuse   = Sampler.MinMagMipLinearWrap;

            Add(cbMaterial);
            Add(sDiffuse);
            Add(tDiffuse);

            TextureSampleNode nTexSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tDiffuse,
                Sampler   = sDiffuse,
                IsVerbose = true,
                Output    = new Vector()
                {
                    Name = "cDiffuse", Type = Shaders.Type.Float4
                }
            };

            MultiplyNode nMultiply = new MultiplyNode
            {
                Input1 = nTexSample,
                Input2 = new ReferenceNode {
                    Value = material[Param.Material.Diffuse]
                },
                Output = new Vector {
                    Name = "cFinal", Type = Shaders.Type.Float4
                }
            };

            Result = new PSOutputNode
            {
                FinalColor = nMultiply,
                Output     = OutputStruct
            };
        }
Ejemplo n.º 2
0
        public SkyboxPS()
        {
            Name             = "SkyboxPS";
            Type             = ShaderType.Pixel;
            KeyPart          = new TechniqueKey(ps: PixelShaderFlags.Diffuse);
            FeatureLevel     = FeatureLevel.PS_4_0_Level_9_1;
            EnableSeparators = true;
            var inputStruct = SkyboxVS.VSOutput;

            inputStruct.Name = "input";

            InputStruct  = inputStruct;
            OutputStruct = Struct.PixelShaderOutput;

            Struct cbMaterial = Structs.ConstantBuffer.CBMaterial;
            Struct material   = (Struct)cbMaterial[Param.Struct.Material];

            Add(cbMaterial);

            Texture tDiffuse        = Texture.CubeMap;
            Sampler sDiffuseSampler = Sampler.MinMagMipLinearWrap;

            Add(tDiffuse);
            Add(sDiffuseSampler);
            TextureSampleNode textureSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture = tDiffuse,
                Sampler = sDiffuseSampler
            };
            MultiplyNode multiply = new MultiplyNode
            {
                Input1 = textureSample,
                Input2 = new ReferenceNode {
                    Value = material[Param.Material.Diffuse]
                }
            };

            Result = new PSOutputNode
            {
                FinalColor = multiply,
                Output     = OutputStruct
            };
        }
Ejemplo n.º 3
0
        public NormalMappingPS()
        {
            Name    = "NormalMappingPS";
            KeyPart = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.DiffuseMap | PixelShaderFlags.Specular | PixelShaderFlags.NormalMap);

            Struct inputStruct = Struct.VertexPositionNormalTextureTangentOut;

            inputStruct.Name = "input";
            InputStruct      = inputStruct;

            PhongLightingNode nPhongLighting  = (PhongLightingNode)((PSOutputNode)Result).FinalColor;
            Texture           tNormal         = Texture.NormalMap;
            Sampler           sDiffuseSampler = Get <Sampler>(Param.Samplers.MinMagMipLinearWrap);

            Add(tNormal);

            TextureSampleNode nNormalMapSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tNormal,
                Sampler   = sDiffuseSampler,
                IsVerbose = true
            };

            TrinaryFunctionNode nNormalMapping = new TrinaryFunctionNode
            {
                Input1 = nPhongLighting.Normal,
                Input2 = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Tangent]
                },
                Input3   = nNormalMapSample,
                Function = new NormalMappingMethod(),
                Output   = new Vector {
                    Type = Shaders.Type.Float3, Name = "vNormalTS"
                },
                IsVerbose = true
            };

            nPhongLighting.Normal = nNormalMapping;
        }
Ejemplo n.º 4
0
        public FullScreenQuadPS()
        {
            Name             = "FullScreenQuadPS";
            Type             = ShaderType.Pixel;
            KeyPart          = new TechniqueKey(ps: PixelShaderFlags.DiffuseMap);
            FeatureLevel     = FeatureLevel.PS_4_0_Level_9_1;
            EnableSeparators = true;
            var inputStruct = SpriteVS.VSOut;

            inputStruct.Name = "input";

            InputStruct  = inputStruct;
            OutputStruct = Struct.PixelShaderOutput;
            Variable tDiffuse = Texture.Diffuse;
            Variable sDiffuse = Sampler.MinMagMipLinearWrap;

            Add(sDiffuse);
            Add(tDiffuse);

            TextureSampleNode nTexSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tDiffuse,
                Sampler   = sDiffuse,
                IsVerbose = true,
                Output    = new Vector()
                {
                    Name = "cDiffuse", Type = Shaders.Type.Float4
                }
            };

            Result = new PSOutputNode
            {
                FinalColor = nTexSample,
                Output     = OutputStruct
            };
        }
Ejemplo n.º 5
0
        public PhongShadowsPS()
        {
            Name         = "PhongShadowsPS";
            FeatureLevel = FeatureLevel.PS_5_0;
            KeyPart      = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.Specular | PixelShaderFlags.Shadows | PixelShaderFlags.ShadowMap, sm: FromFeatureLevel(FeatureLevel));
            Clear();
            PhongLightingNode nPhongLighting = (PhongLightingNode)((PSOutputNode)Result).FinalColor;
            var inputStruct = PhongShadowsVS.VSOut;

            inputStruct.Name = "input";
            InputStruct      = inputStruct;

            Structs.ConstantBuffer cbStatic = CBStatic;
            Structs.ConstantBuffer cbFrame  = CBFrame;
            Texture tShadow        = Texture.ShadowMap;
            Sampler sShadowSampler = Sampler.MinMagMiLinearMirrorLessEqual;

            sShadowSampler.Name = "sShadowMap";

            Add(tShadow);
            Add(sShadowSampler);
            Add(cbStatic);
            Add(cbFrame);

            TextureSampleNode nShadowMapSampler = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = inputStruct[Param.SemanticVariables.ShadowProjection]
                },
                Texture   = tShadow,
                Sampler   = sShadowSampler,
                IsVerbose = false,
            };

            nPhongLighting.ShadowMapSample = nShadowMapSampler;
            nPhongLighting.Shadows         = true;
        }
Ejemplo n.º 6
0
        public GlowPS()
        {
            Name             = "GlowPS";
            Type             = ShaderType.Pixel;
            KeyPart          = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.DiffuseMap);
            FeatureLevel     = FeatureLevel.PS_4_0_Level_9_1;
            EnableSeparators = true;
            var inputStruct = SpriteVS.VSOut;

            inputStruct.Name = "input";

            InputStruct  = inputStruct;
            OutputStruct = Struct.PixelShaderOutput;
            Texture tDiffuse = Texture.Diffuse;
            Texture tGlow    = new Texture {
                Name = "tGlow", Type = Shaders.Type.Texture2D
            };
            Variable sLinearWrap = Sampler.MinMagMipLinearWrap;
            var      cbFrame     = CBFrame;

            Add(sLinearWrap);
            Add(tDiffuse);
            Add(tGlow);
            Add(cbFrame);

            TextureSampleNode nTexSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tDiffuse,
                Sampler   = sLinearWrap,
                IsVerbose = true,
                Output    = new Vector {
                    Name = "cDiffuse", Type = Shaders.Type.Float4
                }
            };

            TextureSampleNode nGlowSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tGlow,
                Sampler   = sLinearWrap,
                IsVerbose = true,
                Output    = new Vector {
                    Name = "cGlow", Type = Shaders.Type.Float4
                }
            };

            UnaryFunctionNode nSaturate = new UnaryFunctionNode
            {
                Input1 = new AdditionNode
                {
                    Input1 = nTexSample,
                    Input2 = new MultiplyNode
                    {
                        Input1 = nGlowSample,
                        Input2 = new ReferenceNode {
                            Value = cbFrame[Param.Floats.GlowStrength]
                        },
                        Parenthesize = true
                    }
                },
                Function = HlslIntrinsics.Saturate
            };

            Result = new PSOutputNode
            {
                FinalColor = nSaturate,
                Output     = OutputStruct
            };
        }
Ejemplo n.º 7
0
        public BloomExtractPS()
        {
            Name             = "BloomExtractPS";
            Type             = ShaderType.Pixel;
            KeyPart          = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.DiffuseMap);
            FeatureLevel     = FeatureLevel.PS_4_0_Level_9_1;
            EnableSeparators = true;
            var inputStruct = SpriteVS.VSOut;

            inputStruct.Name = "input";

            InputStruct  = inputStruct;
            OutputStruct = Struct.PixelShaderOutput;
            Texture tDiffuse    = Texture.Diffuse;
            Sampler sLinearWrap = Sampler.MinMagMipLinearWrap;
            var     cbFrame     = CBFrame;

            Add(sLinearWrap);
            Add(tDiffuse);
            Add(cbFrame);

            TextureSampleNode nTexSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tDiffuse,
                Sampler   = sLinearWrap,
                IsVerbose = true,
                Output    = new Vector {
                    Name = "cDiffuse", Type = Shaders.Type.Float4
                }
            };

            UnaryFunctionNode nSaturate = new UnaryFunctionNode
            {
                Input1 = new DivisionNode()
                {
                    Input1 = new SubtractionNode()
                    {
                        Input1 = nTexSample,
                        Input2 = new ReferenceNode()
                        {
                            Value = cbFrame[Param.Floats.BloomThreshold]
                        },
                        Parenthesize = true
                    },
                    Input2 = new SubtractionNode()
                    {
                        Input1 = new ScalarNode()
                        {
                            Value = 1.0f
                        },
                        Input2 = new ReferenceNode()
                        {
                            Value = cbFrame[Param.Floats.BloomThreshold]
                        },
                        Parenthesize = true
                    }
                },
                Function = HlslIntrinsics.Saturate
            };

            Result = new PSOutputNode
            {
                FinalColor = nSaturate,
                Output     = OutputStruct
            };
        }
Ejemplo n.º 8
0
        public BloomCombinePS()
        {
            Name             = "BloomCombinePS";
            Type             = ShaderType.Pixel;
            KeyPart          = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.DiffuseMap);
            FeatureLevel     = FeatureLevel.PS_4_0_Level_9_1;
            EnableSeparators = true;
            var inputStruct = SpriteVS.VSOut;

            inputStruct.Name = "input";

            InputStruct  = inputStruct;
            OutputStruct = Struct.PixelShaderOutput;
            Texture tDiffuse = Texture.Diffuse;
            Texture tBloom   = new Texture()
            {
                Name = "tBloom", Type = Shaders.Type.Texture2D
            };
            Sampler sLinearWrap = Sampler.MinMagMipLinearWrap;
            var     cbFrame     = CBFrame;

            var blurParams = (Struct)cbFrame[0];

            Add(sLinearWrap);
            Add(tDiffuse);
            Add(tBloom);
            Add(cbFrame);

            TextureSampleNode nTexSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tDiffuse,
                Sampler   = sLinearWrap,
                IsVerbose = true,
                Output    = new Vector {
                    Name = "cDiffuse", Type = Shaders.Type.Float4
                },
            };

            TextureSampleNode nBloomSample = new TextureSampleNode
            {
                Coordinates = new ReferenceNode {
                    Value = InputStruct[Param.SemanticVariables.Texture]
                },
                Texture   = tBloom,
                Sampler   = sLinearWrap,
                IsVerbose = true,
                Output    = new Vector {
                    Name = "cBloom", Type = Shaders.Type.Float4
                }
            };

            var mAdjustSaturation = new AdjustSaturation();

            FunctionNode nAdjustBloomSaturation = new FunctionNode()
            {
                Inputs = new List <INode>()
                {
                    nBloomSample,
                    new ReferenceNode()
                    {
                        Value = blurParams[Param.Floats.BloomSaturation]
                    }
                },
                Method     = mAdjustSaturation,
                ReturnType = Shaders.Type.Float4
            };

            FunctionNode nAdjustBaseSaturation = new FunctionNode()
            {
                Inputs = new List <INode>()
                {
                    nTexSample,
                    new ReferenceNode()
                    {
                        Value = blurParams[Param.Floats.BloomBaseSaturation]
                    }
                },
                Method     = mAdjustSaturation,
                ReturnType = Shaders.Type.Float4
            };

            MultiplyNode nMulBloom = new MultiplyNode()
            {
                Input1 = nAdjustBloomSaturation,
                Input2 = new ReferenceNode()
                {
                    Value = blurParams[Param.Floats.BloomIntensity]
                },
                Output    = nBloomSample.Output,
                IsVerbose = true,
                Declare   = false
            };
            MultiplyNode nMulBase = new MultiplyNode()
            {
                Input1 = nAdjustBaseSaturation,
                Input2 = new ReferenceNode()
                {
                    Value = blurParams[Param.Floats.BloomBaseIntensity]
                },
                Output    = nTexSample.Output,
                IsVerbose = true,
                Declare   = false
            };

            MultiplyNode nDarken = new MultiplyNode()
            {
                Input1 = nMulBase,
                Input2 = new SubtractionNode()
                {
                    Input1 = new ScalarNode()
                    {
                        Value = 1
                    },
                    Input2 = new UnaryFunctionNode()
                    {
                        Input1 = nMulBloom, Function = HlslIntrinsics.Saturate
                    },
                    Parenthesize = true
                },
                Output         = nTexSample.Output,
                IsVerbose      = true,
                Declare        = false,
                AssignToInput1 = true
            };

            Result = new PSOutputNode
            {
                FinalColor = new AdditionNode()
                {
                    Input1 = nDarken, Input2 = nMulBloom
                },
                Output = OutputStruct
            };
        }