コード例 #1
0
        public ShapeVS()
        {
            Name             = "ShapeVS";
            Type             = ShaderType.Vertex;
            FeatureLevel     = FeatureLevel.VS_4_0_Level_9_1;
            KeyPart          = new TechniqueKey(vs: VertexShaderFlags.Position | VertexShaderFlags.Color);
            EnableSeparators = true;
            InputStruct      = Struct.VertexPositionColor;
            OutputStruct     = VSOut;

            ConstantBuffer cbScene    = CBPerFrame;
            ConstantBuffer cbInstance = CBPerInstance;

            Add(cbScene);
            Add(cbInstance);

            var nPosV3toV4 = CastNode.PositionV3toV4(InputStruct[Param.SemanticVariables.Position]);
            var mulPosWVP  = new MatrixMultiplyNode
            {
                Input1 = nPosV3toV4,
                Input2 = MatrixMultiplyNode.WorldViewProjection,
            };

            CustomOutputNode outputNode = new CustomOutputNode()
            {
                Output = OutputStruct
            };

            outputNode.RegisterField(Vector.ClipPosition, mulPosWVP, Shaders.Type.Float4);
            outputNode.RegisterField(Vector.Color, new ReferenceNode {
                Value = InputStruct[Param.SemanticVariables.Color]
            }, Shaders.Type.Float4);

            Result = outputNode;
        }
コード例 #2
0
ファイル: WireframeVS.cs プロジェクト: OkashiKami/Odyssey
        public WireframeVS()
        {
            Name             = "WireframeVS";
            Type             = ShaderType.Vertex;
            KeyPart          = new TechniqueKey(vs: VertexShaderFlags.Position | VertexShaderFlags.Normal | VertexShaderFlags.TextureUV | VertexShaderFlags.Barycentric);
            FeatureLevel     = FeatureLevel.VS_4_0_Level_9_1;
            EnableSeparators = true;
            InputStruct      = VertexPositionNormalBarycentric;
            OutputStruct     = VertexPositionTextureIntensityBarycentricOut;

            ConstantBuffer cbFrame    = CBPerFrame;
            ConstantBuffer cbInstance = CBPerInstance;

            Add(cbFrame);
            Add(cbInstance);

            IVariable position       = InputStruct[Param.SemanticVariables.ObjectPosition];
            IVariable lightDirection = cbFrame[Param.Vectors.LightDirection];
            IVariable normal         = InputStruct[Param.SemanticVariables.Normal];
            IVariable texture        = InputStruct[Param.SemanticVariables.Texture];
            IVariable barycentric    = InputStruct[Param.SemanticVariables.Barycentric];

            CastNode nV3toV4 = new CastNode
            {
                Input = new SwizzleNode {
                    Input = new ReferenceNode {
                        Value = position
                    }, Swizzle = new[] { Swizzle.X, Swizzle.Y, Swizzle.Z, Swizzle.Null }
                },
                Output = new Vector {
                    Type = Shaders.Type.Float4, Name = "vPosition"
                },
                Mask      = new[] { "0", "0", "0", "1" },
                IsVerbose = true
            };

            MatrixMultiplyNode mulPosWVP = new MatrixMultiplyNode
            {
                Input1 = nV3toV4,
                Input2 = MatrixMultiplyNode.WorldViewProjection,
                Output = new Vector()
                {
                    Type = Shaders.Type.Float4, Name = "vClipPosition"
                },
                IsVerbose = true
            };

            MultiplyNode perspectiveCorrection = new MultiplyNode()
            {
                Input1 = new ReferenceNode()
                {
                    Value = barycentric
                },
                Input2 = new SwizzleNode()
                {
                    Input   = mulPosWVP,
                    Swizzle = new Swizzle[] { Swizzle.W, }
                }
            };

            BinaryFunctionNode dotLightNormal = new BinaryFunctionNode
            {
                Input1 = new ReferenceNode {
                    Value = lightDirection
                },
                Input2 = new ReferenceNode {
                    Value = normal
                },
                Function = HlslIntrinsics.Dot
            };

            BinaryFunctionNode maxIntensity = new BinaryFunctionNode
            {
                Input1 = dotLightNormal,
                Input2 = new ScalarNode()
                {
                    Value = 0.3f
                },
                Function = HlslIntrinsics.Max
            };

            CustomOutputNode outputNode = new CustomOutputNode()
            {
                Output = OutputStruct
            };

            outputNode.RegisterField(Vector.ClipPosition, mulPosWVP, Shaders.Type.Float4);
            outputNode.RegisterField(Param.SemanticVariables.Intensity, Semantics.Intensity, maxIntensity, Shaders.Type.Float3);
            outputNode.RegisterField(Vector.TextureUV, new ReferenceNode {
                Value = texture
            }, Shaders.Type.Float2);
            outputNode.RegisterField(Param.SemanticVariables.Barycentric, Semantics.Barycentric, perspectiveCorrection, Shaders.Type.Float3);

            Result = outputNode;
        }