public override Node visitPrimitiveTypes(JuliarParser.PrimitiveTypesContext ctx) { PrimitiveNode node = new PrimitiveNode(); new IterateOverContext(this, ctx, this, node); return(node); }
private int aggregateVariable(IList <VariableNode> variableNodeList, ActivationFrame frame) { int sum = 0; for (int i = 0; i < variableNodeList.Count; i++) { Node v = frame.variableSet[variableNodeList[i].variableName]; FinalNode finalNode = null; if (v is FinalNode && v.Instructions.Count == 0) { finalNode = (FinalNode)v; } if (v is PrimitiveNode) { PrimitiveNode primitiveNode = (PrimitiveNode)v; finalNode = (FinalNode)primitiveNode.Instructions[0]; } if (finalNode != null) { sum += Convert.ToInt32(finalNode.dataString()); } } return(sum); }
private string getFileName(List <PrimitiveNode> pNodes, int nodeOffset) { PrimitiveNode tlNode = (from pnode in pNodes where pnode.Nodestring.Equals("Texture library") select pnode).FirstOrDefault(); if (tlNode == null) { throw new Exception("Couldn't find Texture Library node"); } PrimitiveNode tlSubNode = (from pnode in pNodes where pnode.InitialPos == nodeOffset + tlNode.ChildOffset select pnode).FirstOrDefault(); if (tlNode == null) { throw new Exception("Couldn't find Texture Library sub node"); } if (tlSubNode.PeerNextOffset == 0) { string fileName = ""; if (tlSubNode.Nodestring.EndsWith(".tga")) { fileName = tlSubNode.Nodestring.Remove(tlSubNode.Nodestring.LastIndexOf(".tga"), 4); } return(fileName); } else { throw new Exception("Multiple texture library sub nodes"); } }
public override Node visitPrimitives(JuliarParser.PrimitivesContext ctx) { PrimitiveNode primitiveNode = new PrimitiveNode(); IterateOverContext context = new IterateOverContext(this); context.iterateOverChildren(ctx, this, primitiveNode); return(primitiveNode); }
public static void TestEqualityWithDifferentNodeTypes() { var groupNode = new GroupNode("group", Repetition.Required, new Node[0]); var primitiveNode = new PrimitiveNode("primitive", Repetition.Required, PhysicalType.Int32); Assert.AreNotEqual(groupNode, primitiveNode); Assert.AreNotEqual(primitiveNode, groupNode); }
public static void TestNodeUtf8Name() { const string name = "2H₂ + O₂ ⇌ 2H₂O, R = 4.7 kΩ, ⌀ 200 mm"; using var groupNode = new GroupNode(name, Repetition.Required, new Node[0]); using var primitiveNode = new PrimitiveNode(name, Repetition.Required, LogicalType.Int(32, true), PhysicalType.Int32); Assert.AreEqual(name, groupNode.Name); Assert.AreEqual(name, primitiveNode.Name); }
public override Node Create(Vector2 pos) { // This function has to be registered in Node_Editor.ContextCallback PrimitiveNode node = CreateInstance <PrimitiveNode> (); node.name = "Primitive Node"; node.rect = new Rect(pos.x, pos.y, 200, 100); NodeInput.Create(node, "Parent", "GameObject"); NodeOutput.Create(node, "GameObject", "GameObject"); return(node); }
private string Getstring(BinaryReader br, PrimitiveNode node, int stringOffset) { string currstring = ""; this.reader.BaseStream.Position = stringOffset + node.StringOffset; int currChar = 0; while ((currChar = this.reader.ReadByte()) != 0) { currstring += Convert.ToChar(currChar); } return(currstring); }
protected override PropertyEditor AutoCreateMemberEditor(MemberInfo info) { if (ReflectionHelper.MemberInfoEquals(info, typeof(PrimitiveNode).GetProperty("PrimitiveValue"))) { PrimitiveNode primitiveNode = this.GetValue().NotNull().FirstOrDefault() as PrimitiveNode; Type actualType = primitiveNode.NodeType.ToActualType(); if (actualType == null) { actualType = (info as PropertyInfo).PropertyType; } this.editorPrimitiveValue = this.ParentGrid.CreateEditor(actualType, this); return(this.editorPrimitiveValue); } else { return(base.AutoCreateMemberEditor(info)); } }
public override NodeViewModel CreateModel() { PrimitiveNode result = null; switch (primative) { case NoisePrimitive.Constant: result = new ConstantNode(); break; case NoisePrimitive.Spheres: result = new SpheresNode(); break; case NoisePrimitive.Cylinders: result = new CylindersNode(); break; case NoisePrimitive.BevinsValue: result = new BevinsValueNode(); break; case NoisePrimitive.BevinsGradient: result = new BevinsGradientNode(); break; case NoisePrimitive.ImprovedPerlin: result = new ImprovedPerlinNode(); break; case NoisePrimitive.SimplexPerlin: result = new SimplexPerlinNode(); break; } (result.Quality.Editor as EnumEditorViewModel).Value = quality; (result.Seed.Editor as ValueEditorViewModel <int?>).Value = seed; (result.Offset.Editor as FloatEditorViewModel).Value = offset; result.Name = name; result.Position = pos; return(result); }
public static void primitiveInstance(PrimitiveNode primitiveNode, ActivationFrame activationFrame, VariableDeclarationNode variableToAssignTo) { if (canPrimitiveValueBeAssignedToVar(variableToAssignTo, primitiveNode)) { string variableName; if (variableToAssignTo.IntegralType == juserDefined) { variableName = variableToAssignTo.UserDefinedNode.FullyQualifiedVariableName; } else { FinalNode variableNameTerminalNode = (FinalNode)variableToAssignTo.Instructions[1].Instructions[0]; variableName = variableNameTerminalNode.dataString(); } if (activationFrame.variableSet.ContainsKey(variableName)) { activationFrame.variableSet.Remove(variableName); } activationFrame.variableSet[variableName] = primitiveNode; } }
public PrimitiveTreeNode(PrimitiveNode data) : base(data) { this.primitiveData = data; }
public string GetImage(string destPath, string nickName) { try { char[] buffer = new char[4]; this.reader.Read(buffer, 0, 4); string ash = new string(buffer); int ver = this.reader.ReadInt32(); if (!ash.Equals("UTF ") && ver == 257) { throw new Exception("Wrong file format"); } int nodeOffset = this.reader.ReadInt32(); int nodeSize = this.reader.ReadInt32(); this.reader.BaseStream.Position = this.reader.BaseStream.Position + 8; int stringOffset = this.reader.ReadInt32(); int stringSize = this.reader.ReadInt32(); this.reader.BaseStream.Position = this.reader.BaseStream.Position + 4; this.reader.BaseStream.Position = 36; int dataOffset = this.reader.ReadInt32(); int dateSize = (int)(this.reader.BaseStream.Length - this.reader.BaseStream.Position); #region get nodes this.reader.BaseStream.Position = nodeOffset; List <PrimitiveNode> nodes = new List <PrimitiveNode>(); while (this.reader.BaseStream.Position < nodeOffset + nodeSize) { nodes.Add(this.GetNode(this.reader)); } #endregion #region get strings foreach (PrimitiveNode node in nodes) { node.Nodestring = this.Getstring(this.reader, node, stringOffset); // node.PrintNode(); } #endregion PrimitiveNode mipNode = (from node in nodes where node.Nodestring.Equals("MIP0") select node).FirstOrDefault(); if (mipNode == null) { throw new Exception("Couldn't locate mip node"); } this.reader.BaseStream.Position = dataOffset + mipNode.ChildOffset; byte[] fileBytes = new byte[mipNode.Size]; this.reader.Read(fileBytes, 0, fileBytes.Length); string fileName = this.getFileName(nodes, nodeOffset); if (fileName == "") { fileName = nickName; } fileName += ".jpg"; Bitmap image = TargaImage.LoadTargaImage(fileBytes); image.Save(destPath + fileName); return(fileName); #region test /* * string path = @"C:\Users\Yaoquizque\Desktop\FreelancerTrading\FilesFeed\commoditiesModels\TGA\"; * using (BinaryWriter bw = new BinaryWriter(File.Open(path + this.getFileName(nodes, nodeOffset), FileMode.Create))) * { * bw.Write(fileBytes); * }*/ #endregion } finally { this.Dispose(); } }
public int CompareTo(PrimitiveNode <T> other) { return(Value.CompareTo(other.Value)); }
public bool Equals(PrimitiveNode <T> other) { return(Equals(Value, other.Value)); }
public static bool canPrimitiveValueBeAssignedToVar(VariableDeclarationNode lvalue, PrimitiveNode rvalue) { FinalNode rvalueTerminal = (FinalNode)rvalue.Instructions[0]; VariableNode variableNode; if (juserDefined == lvalue.IntegralType) { variableNode = lvalue.UserDefinedNode.VariableNode; } else { variableNode = (VariableNode)lvalue.Instructions[1]; } string data = rvalueTerminal.dataString(); try { switch (variableNode.IntegralType) { case jinteger: return(true); case jdouble: return(true); case jfloat: return(true); case jlong: return(true); case jstring: return(true); case jobject: return(false); case jboolean: return(Convert.ToBoolean(data)); case juserDefined: return(true); default: return(false); } } catch (NumberFormatException) { return(false); } }
public static IList <Node> evalFunctionCall(Node node, ActivationFrameStack activationFrame, string mainFunctionName, IDictionary <string, Node> functionNodeMap, Interpreter callback) { FunctionCallNode functionCallNode = (FunctionCallNode)node; string functionToCall = functionCallNode.functionName(); //ActivationFrame evalFrame = activationFrameStack.pop(); bool isPrimitive = EvaluatePrimitives.evalIfPrimitive(node, activationFrame.peek(), callback); //activationFrameStack.push( evalFrame ); if (isPrimitive) { return(new List <>()); } // main should only be called from the compliationUnit if (functionCallNode.Equals(mainFunctionName)) { return(new List <>()); } FunctionDeclNode functionDeclNode = (FunctionDeclNode)functionNodeMap[functionToCall]; if (functionDeclNode != null) { ActivationFrame frame = new ActivationFrame(); frame.frameName = functionToCall; IList <VariableNode> sourceVariables = new List <VariableNode>(); IList <VariableDeclarationNode> targetVariables = new List <VariableDeclarationNode>(); foreach (Node v in node.Instructions) { if (v is VariableNode) { sourceVariables.Add((VariableNode)v); } } foreach (Node v in functionDeclNode.Instructions) { if (v is VariableDeclarationNode) { targetVariables.Add((VariableDeclarationNode)v); } } if (sourceVariables.Count != targetVariables.Count) { throw new Exception("Source and target variable count do not match"); } // since the function that is getting called can reference the variable using the // formal parameters of the function this code will match the calling functions data // with the target calling functions variable name. for (int i = 0; i < sourceVariables.Count; i++) { VariableNode variableNode = (VariableNode)targetVariables[0].Instructions[1]; if (variableNode.integralTypeNode == sourceVariables[i].integralTypeNode) { frame.variableSet[variableNode.variableName] = activationFrame.peek().variableSet[sourceVariables[i].variableName]; } else { throw new Exception("data types are not the same"); } } activationFrame.push(frame); IList <Node> statements = getFunctionStatements(functionDeclNode.Instructions); callback.execute(statements); activationFrame.pop(); //activationFrame.push(frame); //execute(functionDeclNode.getInstructions()); return(new List <Node>()); } else { FinalNode primitiveArg = new FinalNode(); primitiveArg.DataString = functionToCall; PrimitiveNode primitiveNode = new PrimitiveNode(); primitiveNode.addInst(primitiveArg); foreach (Node primArgs in node.Instructions) { if (primArgs is VariableNode || primArgs is IntegralTypeNode) { primitiveNode.addInst(primArgs); } } return(EvaluatePrimitives.evalPrimitives(primitiveNode, activationFrame.peek(), callback)); } }