public bool VisitCastNode(CastNode node, CompilationState state) { var casting = true; switch (node.DataType) { case DataValueType.String: state.Write("tostring"); break; case DataValueType.Integer: case DataValueType.Float: state.Write("tonumber"); break; case DataValueType.Boolean: return(BooleanCasting(state, node.Argument)); default: casting = false; break; } if (casting) { state.Write("("); } node.Argument.AcceptVisitor(this, state); if (casting) { state.Write(")"); } return(true); }
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; }
public AstNode VisitCast(CastNode n) { Append("("); Visit(n.Type); Append(")"); Visit(n.Right); return(n); }
private void InsertCastNode(CommonTree parent, int index, TypeInfo type) { CastNode newNode = new CastNode(new CommonToken(-1, "Cast")); newNode.Type = type; ReplaceNode(parent, index, newNode); }
private TypeInfo Visit(CastNode node, MethodBuilder builder, CodegenContext context) { var res = Visit(node.Expression as dynamic, builder, context); var convType = node.Type as SimpleType; builder.Convert(convType.SType); return(convType); }
protected Node WHILE() { Accept(TT.TT_IdentWHILE); //Entscheidungs Node Node decNode = Addition(); if (decNode == null) { #warning Script Implement Error Handling Console.WriteLine("Error - 27"); return(null); } if (!decNode.IsContentNode) { #warning Script Implement Error Handling Console.WriteLine("Error - 28"); return(null); } ContentNode <bool> dec; if (decNode.ContentType == typeof(bool)) { dec = (ContentNode <bool>)decNode; } else { if (decNode.ContentType == typeof(int)) { dec = new CastNode <bool, int>((ContentNode <int>)decNode); } else if (decNode.ContentType == typeof(double)) { dec = new CastNode <bool, double>((ContentNode <double>)decNode); } else { dec = new CastNode <bool, string>((ContentNode <string>)decNode); } } Accept(TT.TT_ParenRight); Accept(TT.TT_BlockBegin); List <Node> nodes = new List <Node>(); while (Current.TokenType != TT.TT_BlockEnd) { Node n = Input(); if (n != null) { nodes.Add(n); } } Accept(TT.TT_BlockEnd); return(new WHILENode(dec, nodes)); }
public void Visit(CastNode node) { visitor.OnVisit((n, v) => { var r = n as CastNode; if (r != null && r.GetCastType() == node.GetCastType()) { Result = IsSameChildren(r, node); } }); reference.Visit(visitor); }
/// <summary> /// create a new Casting node /// </summary> /// <param name="graph"></param> /// <param name="input"></param> /// <param name="output"></param> /// <param name="pos"></param> /// <returns></returns> public static NodeBase CreateNode(NodeGraph graph, VarType input, VarType output, Vector2 pos) { CastNode res = null; if (graph != null) { res = ScriptableObject.CreateInstance <CastNode>(); res.Initialize(); res.Construct(input, output); InitNode(res, graph, pos); } return(res); }
public SkyboxVS() { Name = "SkyboxVS"; Type = ShaderType.Vertex; KeyPart = new TechniqueKey(vs: VertexShaderFlags.Position | VertexShaderFlags.Normal | VertexShaderFlags.TextureUVW); FeatureLevel = FeatureLevel.VS_4_0_Level_9_1; EnableSeparators = true; InputStruct = Struct.VertexPositionNormalTextureUVW; OutputStruct = VSOutput; Add(CBStatic); Add(Structs.ConstantBuffer.CBPerFrame); IVariable position = InputStruct[Param.SemanticVariables.ObjectPosition]; IVariable texture = InputStruct[Param.SemanticVariables.Texture]; 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 = "vSkyBoxPosition", }, }; Result = new PhongVSOutputNode { Position = new SwizzleNode { Input = mulPosWVP, Swizzle = new[] { Swizzle.X, Swizzle.Y, Swizzle.W, Swizzle.W } }, Texture = new ReferenceNode { Value = texture }, Output = OutputStruct }; }
protected Node IdentCast() { string name = ((TokenWithContent <string>)Current).Content; Accept(TT.TT_IdentCast); Node a = Addition(); if (a == null) { #warning Script Implement Error Handling Console.WriteLine("Error - 15"); return(null); } if (!a.IsContentNode) { #warning Script Implement Error Handling Console.WriteLine("Error - 16"); return(null); } Node con = null; switch (name) { case "INT": if (a.ContentType == typeof(double)) { con = new CastNode <int, double>((ContentNode <double>)a); } else { //Int muss nicht auf int gecastet werden con = a; } break; case "DOUBLE": if (a.ContentType == typeof(int)) { con = new CastNode <double, int>((ContentNode <int>)a); } else { con = a; } break; } Accept(TT.TT_ParenRight); return(con); }
private ValInfo Visit(CastNode node) { ValInfo val = Visit(node.Expression); var type = node.Type as SimpleType; if (val == null) { return(null); } if (val.isConst && type != null) { object obj = null; switch (type.SType) { case SimpleTypeEnum.Bool: obj = (bool)val.val; break; case SimpleTypeEnum.Byte: obj = (byte)val.val; break; case SimpleTypeEnum.Char: obj = (char)val.val; break; case SimpleTypeEnum.Int: obj = (int)val.val; break; case SimpleTypeEnum.Float: obj = (float)val.val; break; case SimpleTypeEnum.Double: obj = (double)val.val; break; default: throw new ArgumentOutOfRangeException(); } return(new ValInfo(obj, type.SType, true)); } return(new ValInfo()); }
public void Visit(CastNode node) { var paren = node.GetPrecedence() < node.GetValue().GetPrecedence() || node.GetValue() is CastNode; if (paren) { source.Append("("); } node.GetValue().Visit(this); if (paren) { source.Append(")"); } source.Append(" as " + node.GetCastType().Identifier); }
private TypeDescriptor Visit(CastNode node, Context context) { var expType = Visit(node.Expression as dynamic, context); var convertType = context.GetType(node.TypeNode.TypeName); if (!TypeInfo.IsNumeric(expType.Type) || !TypeInfo.IsNumeric(convertType)) { Log( "Явное преобразование может применяться только для числовых типов", node); return(TypeDescriptor.Undefined); } node.Type = convertType; return(new TypeDescriptor(false, convertType)); }
public SymConst Visit(CastNode node) { var castingConst = node.Expr.Accept(this); // Explicit casts are currently not allowed in const expr. The only available implicit cast is int -> double. switch (node.Type) { case SymDouble s: switch (castingConst) { case SymIntConst intConst: return(new SymDoubleConst(intConst.Name, _symStack.SymDouble, intConst.Value, SymVarOrConst.SymLocTypeEnum.Global)); case SymDoubleConst doubleConst: return(castingConst); } break; } throw EvalException(); }
public bool VisitCastNode(CastNode node, CompilationState state) { switch (node.DataType) { case DataValueType.String: state.Write("tostring"); break; case DataValueType.Integer: case DataValueType.Float: state.Write("tonumber"); break; default: throw new LuaCompilationException($"Unsupported cast to '{node.DataType}'"); } state.Write("("); node.Argument.AcceptVisitor(this, state); state.Write(")"); return(true); }
protected virtual void StripCast(CastNode node, HashSet <QueryMethod> additionalQueryMethods) { additionalQueryMethods.Add(new CastMethod(node.TargetType)); }
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; }
protected virtual QueryNode VisitCast(CastNode node, AzureQueryOptimizerState state) { return((QueryNode) new CastNode(this.Visit(node.SourceNode, state), node.TargetType)); }
protected Node FOR() { Accept(TT.TT_IdentFOR); //Init Node Node init = VariableAssignment(); if (init == null) { #warning Script Implement Error Handling Console.WriteLine("Error - 21"); return(null); } Accept(TT.TT_Semicolon); //Entscheidungs Node Node decNode = Addition(); if (decNode == null) { #warning Script Implement Error Handling Console.WriteLine("Error - 22"); return(null); } if (!decNode.IsContentNode) { #warning Script Implement Error Handling Console.WriteLine("Error - 23"); return(null); } ContentNode <bool> dec; if (decNode.ContentType == typeof(bool)) { dec = (ContentNode <bool>)decNode; } else { if (decNode.ContentType == typeof(int)) { dec = new CastNode <bool, int>((ContentNode <int>)decNode); } else if (decNode.ContentType == typeof(double)) { dec = new CastNode <bool, double>((ContentNode <double>)decNode); } else { dec = new CastNode <bool, string>((ContentNode <string>)decNode); } } Accept(TT.TT_Semicolon); //Iter Node Node iter = VariableAssignment(); if (iter == null) { #warning Script Implement Error Handling Console.WriteLine("Error - 24"); return(null); } Accept(TT.TT_ParenRight); Accept(TT.TT_BlockBegin); List <Node> nodes = new List <Node>(); while (Current.TokenType != TT.TT_BlockEnd) { Node n = Input(); if (n != null) { nodes.Add(n); } } Accept(TT.TT_BlockEnd); return(new FORNode(init, dec, iter, nodes)); }
public virtual AstNode VisitCast(CastNode n) { Visit(n.Type); Visit(n.Right); return(n); }
protected Node IF() { Accept(TT.TT_IdentIF); Node a = Addition(); if (a == null) { #warning Script Implement Error Handling Console.WriteLine("Error - 25"); return(null); } if (!a.IsContentNode) { #warning Script Implement Error Handling Console.WriteLine("Error - 26"); return(null); } ContentNode <bool> dec; if (a.ContentType == typeof(bool)) { dec = (ContentNode <bool>)a; } else { if (a.ContentType == typeof(int)) { dec = new CastNode <bool, int>((ContentNode <int>)a); } else if (a.ContentType == typeof(double)) { dec = new CastNode <bool, double>((ContentNode <double>)a); } else { dec = null; } } Accept(TT.TT_ParenRight); Accept(TT.TT_BlockBegin); List <Node> ifnodes = new List <Node>(); while (Current.TokenType != TT.TT_BlockEnd) { Node n = Input(); if (n != null) { ifnodes.Add(n); } } Accept(TT.TT_BlockEnd); if (Current.TokenType == TT.TT_IdentElse) { Accept(TT.TT_IdentElse); Accept(TT.TT_BlockBegin); List <Node> elsenodes = new List <Node>(); while (Current.TokenType != TT.TT_BlockEnd) { Node n = Input(); if (n != null) { elsenodes.Add(n); } } Accept(TT.TT_BlockEnd); return(new IFNode(dec, ifnodes, elsenodes)); } return(new IFNode(dec, ifnodes)); }
public PhongInstanceVS() { Name = "PhongInstanceVS"; Type = ShaderType.Vertex; KeyPart = new TechniqueKey(vs: VertexShaderFlags.Position | VertexShaderFlags.Normal | VertexShaderFlags.TextureUV | VertexShaderFlags.InstanceWorld); FeatureLevel = FeatureLevel.VS_4_0_Level_9_3; EnableSeparators = true; var instanceStruct = Struct.VertexPositionNormalTexture; instanceStruct.Add(Matrix.EntityInstanceWorld); InputStruct = instanceStruct; OutputStruct = Struct.VertexPositionNormalTextureOut; Structs.ConstantBuffer cbFrame = ConstantBuffer.CBPerFrame; Add(cbFrame); IVariable position = InputStruct[Param.SemanticVariables.ObjectPosition]; IVariable normal = InputStruct[Param.SemanticVariables.Normal]; IVariable texture = InputStruct[Param.SemanticVariables.Texture]; 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 }; ReferenceNode mWorld = new ReferenceNode { Value = InputStruct[Param.SemanticVariables.InstanceWorld], Output = new Matrix { Type = Shaders.Type.Matrix, Name = "mWorld", }, IsVerbose = true }; MatrixMultiplyNode m1m2 = new MatrixMultiplyNode { Input1 = mWorld, Input2 = new ReferenceNode { Value = Matrix.CameraView }, }; MatrixMultiplyNode mulWVP = new MatrixMultiplyNode { Input1 = m1m2, Input2 = new ReferenceNode { Value = Matrix.CameraProjection }, IsVerbose = true }; MatrixMultiplyNode mulPosWVP = new MatrixMultiplyNode { Input1 = nV3toV4, Input2 = mulWVP, }; MatrixMultiplyNode mulWP = new MatrixMultiplyNode { Input1 = nV3toV4, Input2 = mWorld, }; MatrixMultiplyNode mulNormal = new MatrixMultiplyNode { Input1 = new ReferenceNode { Value = normal }, Input2 = CastNode.CastWorldFloat3x3((Matrix)mWorld.Output, "mWorld3x3") }; Result = new PhongVSOutputNode { Position = mulPosWVP, WorldPosition = mulWP, Normal = mulNormal, Texture = new ReferenceNode { Value = texture }, Output = OutputStruct }; }
public PhongVS() { Name = "PhongVS"; Type = ShaderType.Vertex; KeyPart = new TechniqueKey(vs: VertexShaderFlags.Position | VertexShaderFlags.Normal | VertexShaderFlags.TextureUV); FeatureLevel = FeatureLevel.VS_4_0_Level_9_1; EnableSeparators = true; InputStruct = Struct.VertexPositionNormalTexture; OutputStruct = Struct.VertexPositionNormalTextureOut; Structs.ConstantBuffer cbFrame = ConstantBuffer.CBPerFrame; Structs.ConstantBuffer cbInstance = CBPerInstance; Add(cbFrame); Add(cbInstance); IVariable position = InputStruct[Param.SemanticVariables.ObjectPosition]; IVariable normal = InputStruct[Param.SemanticVariables.Normal]; IVariable texture = InputStruct[Param.SemanticVariables.Texture]; 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, }; MatrixMultiplyNode mulWP = new MatrixMultiplyNode { Input1 = nV3toV4, Input2 = new ReferenceNode { Value = Matrix.EntityWorld }, }; MatrixMultiplyNode mulNormal = new MatrixMultiplyNode { Input1 = new ReferenceNode { Value = normal }, Input2 = CastNode.WorldInverseTransposeFloat3x3 }; Result = new PhongVSOutputNode { Position = mulPosWVP, WorldPosition = mulWP, Normal = mulNormal, Texture = new ReferenceNode { Value = texture }, Output = OutputStruct }; }
protected virtual QueryNode VisitCast(CastNode node, ElasticSearchQueryOptimizerState state) { return(new CastNode(Visit(node.SourceNode, state), node.TargetType)); }
public PhongPS() { Name = "PhongPS"; Type = ShaderType.Pixel; KeyPart = new TechniqueKey(ps: PixelShaderFlags.Diffuse | PixelShaderFlags.Specular); FeatureLevel = FeatureLevel.PS_4_0_Level_9_1; EnableSeparators = true; var input = Struct.VertexPositionNormalTextureOut; input.Name = "input"; InputStruct = input; OutputStruct = Struct.PixelShaderOutput; Structs.ConstantBuffer cbStatic = CBLight; Structs.ConstantBuffer cbFrame = CBFrame; Structs.ConstantBuffer cbInstance = ConstantBuffer.CBMaterial; Struct pointLight = (Struct)cbStatic[Param.Struct.PointLight]; Struct material = (Struct)cbInstance[Param.Struct.Material]; Add(cbStatic); Add(cbFrame); Add(cbInstance); CastNode vWorldPos = new CastNode { Input = new SwizzleNode { Input = new ReferenceNode { Value = InputStruct[Param.SemanticVariables.WorldPosition] } , Swizzle = new[] { Swizzle.X, Swizzle.Y, Swizzle.Z } }, Output = new Vector { Type = Shaders.Type.Float3, Name = "vWorldPos", }, IsVerbose = true }; SubtractionNode vLightDirection = new SubtractionNode { Input1 = new ReferenceNode { Value = pointLight[Param.Light.Position] }, Input2 = vWorldPos, }; SubtractionNode vViewDirection = new SubtractionNode { Input1 = new ReferenceNode { Value = cbFrame[Param.Vectors.CameraPosition] }, Input2 = vWorldPos, }; ReferenceNode nNormal = new ReferenceNode { Value = InputStruct[Param.SemanticVariables.Normal] }; UnaryFunctionNode normalizeNormal = new UnaryFunctionNode { Input1 = nNormal, Function = HlslIntrinsics.Normalize, Output = new Vector { Type = nNormal.Output.Type, Name = "vNormal" }, IsVerbose = true, }; UnaryFunctionNode normalizeViewDirection = new UnaryFunctionNode { Input1 = vViewDirection, Function = HlslIntrinsics.Normalize, Output = new Vector { Type = vViewDirection.Output.Type, Name = "vViewDirection" }, IsVerbose = true, }; UnaryFunctionNode normalizeLightDirection = new UnaryFunctionNode { Input1 = vLightDirection, Function = HlslIntrinsics.Normalize, Output = new Vector { Type = vLightDirection.Output.Type, Name = "vLightDirection" }, IsVerbose = true, }; InvertNode vLightDirectionInv = new InvertNode { Input = normalizeLightDirection, //Output = new Vector { Type = Shaders.Type.Float3, Name = "vLightDirection" }, }; PhongLightingNode nPhongLighting = new PhongLightingNode { Light = new ReferenceNode { Value = pointLight }, Material = new ReferenceNode { Value = material }, ViewDirection = normalizeViewDirection, Normal = normalizeNormal, LightDirection = vLightDirectionInv, Specular = true, }; Result = new PSOutputNode { FinalColor = nPhongLighting, Output = OutputStruct }; }