public override CExecutionPin Execute(CNodeExecutionContext context, List <object> inParameters, List <object> outReturn)
        {
            for (int i = 0; i < inParameters.Count; i++)
            {
                if (InputPins[i].SourceNode == null)
                {
                    inParameters[i] = InputPins[i].Literal;
                }
            }

            if (m_functionProxy.bIsCompiled)
            {
                m_functionProxy.compiledMethod(inParameters, outReturn);
            }
            else
            {
                object   targetObject;
                object[] parameterArray;
                int      parameterStartIndex;
                if (TargetMethod.IsStatic)
                {
                    targetObject        = null;
                    parameterArray      = new object[InputPins.Count];
                    parameterStartIndex = 0;
                }
                else
                {
                    targetObject        = inParameters[0];
                    parameterArray      = new object[InputPins.Count - 1];
                    parameterStartIndex = 1;
                }

                for (int i = parameterStartIndex; i < InputPins.Count; i++)
                {
                    parameterArray[i - parameterStartIndex] = inParameters[i];
                }

                object returnValue = TargetMethod.Invoke(targetObject, parameterArray);
                outReturn.Add(returnValue);
                foreach (int returnIndex in m_additionalReturns)
                {
                    outReturn.Add(parameterArray[returnIndex]);
                }
            }

            return(IsImplicit ? null : OutExecutionPins[0]);
        }
Esempio n. 2
0
        public override CExecutionPin Execute(CNodeExecutionContext context, List <object> inParameters, List <object> outReturn)
        {
            for (int i = 0; i < inParameters.Count; i++)
            {
                if (inParameters[i] == null)
                {
                    inParameters[i] = InputPins[i].Literal;
                }
            }

            if (m_bIsField)
            {
                TargetField.SetValue(inParameters[0], inParameters[1]);
                outReturn.Add(inParameters[1]);
            }
            else
            {
                TargetProperty.SetValue(inParameters[0], inParameters[1]);
                outReturn.Add(TargetProperty.GetValue(inParameters[0]));
            }
            return(OutExecutionPins[0]);
        }
Esempio n. 3
0
        public override CExecutionPin Execute(CNodeExecutionContext context, List <object> inParameters, List <object> outReturn)
        {
            for (int i = 0; i < inParameters.Count; i++)
            {
                if (inParameters[i] == null)
                {
                    inParameters[i] = InputPins[i].Literal;
                }
            }

            object targetObject = inParameters[0];

            if (m_bIsField)
            {
                outReturn.Add(TargetField.GetValue(targetObject));
            }
            else
            {
                outReturn.Add(TargetProperty.GetValue(targetObject));
            }

            // Implicit nodes do not return a following node
            return(null);
        }
Esempio n. 4
0
 /// <summary>
 /// Execute this nodes behavior
 /// </summary>
 /// <param name="context">Graph this node is executed on</param>
 /// <param name="inParameters">Parameters with which to execute</param>
 /// <param name="outReturn">Parameters this node returns</param>
 /// <returns>Node to execute next</returns>
 public abstract CExecutionPin Execute(CNodeExecutionContext context, List <object> inParameters, List <object> outReturn);