コード例 #1
0
 /// <summary>
 /// Recursive function which continues calculation on this node and all the child nodes
 /// Usually does not need to be called manually
 /// Returns success/failure of this node only
 /// </summary>
 public static bool ContinueCalculation(Node node)
 {
     if (!node.shouldCalculate)
     {
         return(false);
     }
     if (node.descendantsCalculated() && node.Calculate())
     {             // finished Calculating, continue with the children
         for (int outCnt = 0; outCnt < node.Outputs.Count; outCnt++)
         {
             NodeOutput output = node.Outputs [outCnt];
             for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)
             {
                 ContinueCalculation(output.connections [conCnt].body);
             }
         }
         workList.Remove(node);
         node.calculated = true;
         return(true);
     }
     else if (!workList.Contains(node))
     {             // failed to calculate, add it to check later
         workList.Add(node);
     }
     return(false);
 }
コード例 #2
0
 /// <summary>
 /// Recursive function which continues calculation on this node and all the child nodes
 /// Usually does not need to be called manually
 /// Returns success/failure of this node only
 /// </summary>
 public static bool ContinueCalculation(Node node)
 {
     if (node.calculated)
     {
         return(false);
     }
     if ((node.descendantsCalculated() || node.isInLoop()) && node.Calculate())
     {             // finished Calculating, continue with the children
         node.calculated = true;
         calculationCount++;
         workList.Remove(node);
         if (node.ContinueCalculation && calculationCount < 1000)
         {
             for (int outCnt = 0; outCnt < node.Outputs.Count; outCnt++)
             {
                 NodeOutput output = node.Outputs [outCnt];
                 for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)
                 {
                     ContinueCalculation(output.connections [conCnt].body);
                 }
             }
         }
         else if (calculationCount >= 1000)
         {
             Debug.LogError("Stopped calculation because of suspected Recursion. Maximum calculation iteration is currently at 1000!");
         }
         return(true);
     }
     else if (!workList.Contains(node))
     {             // failed to calculate, add it to check later
         workList.Add(node);
     }
     return(false);
 }
コード例 #3
0
 private static bool ContinueCalculation(Node node)
 {
     if (node.calculated)
     {
         return(false);
     }
     if ((node.descendantsCalculated() || node.isInLoop()) && node.Calculate())
     {
         node.calculated = true;
         calculationCount++;
         workList.Remove(node);
         if (node.ContinueCalculation && calculationCount < 1000)
         {
             for (int i = 0; i < node.Outputs.Count; i++)
             {
                 NodeOutput nodeOutput = node.Outputs[i];
                 if (!nodeOutput.calculationBlockade)
                 {
                     for (int j = 0; j < nodeOutput.connections.Count; j++)
                     {
                         ContinueCalculation(nodeOutput.connections[j].body);
                     }
                 }
             }
         }
         else if (calculationCount >= 1000)
         {
             Debug.LogError("Stopped calculation because of suspected Recursion. Maximum calculation iteration is currently at 1000!");
         }
         return(true);
     }
     if (!workList.Contains(node))
     {
         workList.Add(node);
     }
     return(false);
 }
コード例 #4
0
		/// <summary>
		/// Recursive function which continues calculation on this node and all the child nodes
		/// Usually does not need to be called manually
		/// Returns success/failure of this node only
		/// </summary>
		public static bool ContinueCalculation (Node node) 
		{
			if (node.calculated)
				return false;
			if ((node.descendantsCalculated () || node.isInLoop ()) && node.Calculate ())
			{ // finished Calculating, continue with the children
				node.calculated = true;
				calculationCount++;
				workList.Remove (node);
				if (node.ContinueCalculation && calculationCount < 1000) 
				{
					foreach (NodeOutput output in node.Outputs)
					{
						foreach (NodeInput connection in output.connections)
							ContinueCalculation (connection.body);
					}
				}
				else if (calculationCount >= 1000)
					Debug.LogError ("Stopped calculation because of suspected Recursion. Maximum calculation iteration is currently at 1000!");
				return true;
			}
			else if (!workList.Contains (node)) 
			{ // failed to calculate, add it to check later
				workList.Add (node);
			}
			return false;
		}
コード例 #5
0
ファイル: NodeEditor.cs プロジェクト: MSylvia/Node_Editor
 /// <summary>
 /// Recursive function which continues calculation on this node and all the child nodes
 /// Usually does not need to be called manually
 /// Returns success/failure of this node only
 /// </summary>
 public static bool ContinueCalculation(Node node)
 {
     if (node.descendantsCalculated () && node.Calculate ())
     { // finished Calculating, continue with the children
         for (int outCnt = 0; outCnt < node.Outputs.Count; outCnt++)
         {
             NodeOutput output = node.Outputs [outCnt];
             for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)
                 ContinueCalculation (output.connections [conCnt].body);
         }
         workList.Remove (node);
         node.calculated = true;
         return true;
     }
     else if (!workList.Contains (node))
     { // failed to calculate, add it to check later
         workList.Add (node);
     }
     return false;
 }
コード例 #6
0
        /// <summary>
        /// Recursive function which continues calculation on this node and all the child nodes
        /// Returns success/failure of this node only
        /// </summary>
        public static bool ContinueCalculation(Node node, List <Node> workList)
        {
            if (calculationCount >= 100)
            {
                return(false);
            }
            if (node.calculated)
            {
                return(false);
            }
            bool inputsCalculated = node.descendantsCalculated(); //MikeD


#if DEBUG_LOOPBASIC
            if (InputsCalculated || node.isInLoop())
            {
                Debug.Log(GetPad() + "about to calculate " + node + " inputs calced " + InputsCalculated);
            }
#endif

            if (timer == null)
            {
                timer = new System.Diagnostics.Stopwatch();
            }
            timer.Reset();
            timer.Start();

            if ((inputsCalculated || node.AllowRecursion) && (node.Calculate()))
            {
#if DEBUG_LOOPBASIC
                Debug.Log(GetPad() + " " + calculationCount + " node " + node + " calc success");
#endif
                // finished Calculating, continue with the children
                node.calculated = true;

/*
 *                      int indexTimer = node.name.IndexOf("::");
 *              if (indexTimer!=-1 && indexTimer<4)
 *                  node.name = timer.ElapsedMilliseconds+"::"+node.name.Substring(indexTimer+2, node.name.Length- indexTimer-2) ;
 *              else
 *                  node.name =  timer.ElapsedMilliseconds+ "::"+ node.name;
 */
                calculationCount++;
                workList.Remove(node);
                if (node.ContinueCalculation && calculationCount < 10000)
                {
                    for (int outCnt = 0; outCnt < node.Outputs.Count; outCnt++)
                    {
                        NodeOutput output = node.Outputs[outCnt];
                        if (!output.calculationBlockade)
                        {
                            for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)
                            {
                                ContinueCalculation(output.connections[conCnt].body, workList);
                            }
                        }
                    }
                }
                else if (calculationCount >= 10000)
                {
                    Debug.LogError(GetPad() +
                                   "Stopped calculation because of suspected Recursion. Maximum calculation iteration is currently at 1000!");
                    return(false);
                }
                return(true);        //we actually executed one so go through the list again to see if new ones Canvas execute
            }
            else
            {
#if DEBUG_LOOPBASIC
                Debug.Log(GetPad() + " " + calculationCount + " node " + node + " fail or skipped inputsCalced: " + InputsCalculated + " in loop " + node.isInLoop() + " calc res " + res);
#endif

                if (!inputsCalculated)
                {
                    //add inputs
                    foreach (NodeInput input in node.Inputs)
                    {
                        if (input == null)
                        {
                            continue;
                        }
                        if (input.connection != null && !input.connection.body.calculated)
                        {
                            if (!workList.Contains(input.connection.body))
                            {
                                workList.Add(input.connection.body);
                            }
                        }
                    }
                }

                if (!workList.Contains(node))
                {
                    // failed to calculate, add it to check later
                    workList.Add(node);
                }
//                if (node.AllowRecursion)
//                    return true;
            }
            return(false);
        }