Example #1
0
        public override void RegisterPorts(FlowNode node, FieldInfo field, ReflectedFieldNodeWrapper.AccessMode accessMode)
        {
            if (field.IsConstant())
            {
                var constantValue = field.GetValue(null);
                node.AddValueOutput("Value", field.FieldType, () => { return(constantValue); });
                return;
            }

            var targetType = field.DeclaringType;

            if (accessMode == ReflectedFieldNodeWrapper.AccessMode.GetField)
            {
                var instanceInput = node.AddValueInput(targetType.FriendlyName(), targetType);
                node.AddValueOutput("Value", field.FieldType, () => { return(field.GetValue(instanceInput.value)); });
            }
            else
            {
                object instance      = null;
                var    instanceInput = node.AddValueInput(targetType.FriendlyName(), targetType);
                var    valueInput    = node.AddValueInput("Value", field.FieldType);
                var    flowOut       = node.AddFlowOutput(" ");
                node.AddValueOutput(targetType.FriendlyName(), targetType, () => { return(instance); });
                node.AddFlowInput(" ", (f) => { instance = instanceInput.value; field.SetValue(instance, valueInput.value); flowOut.Call(f); });
            }
        }
        public override void RegisterPorts(FlowNode node, ReflectedFieldNodeWrapper.AccessMode accessMode)
        {
            if (fieldInfo == null)
            {
                return;
            }

            if (accessMode == ReflectedFieldNodeWrapper.AccessMode.SetField && !fieldInfo.IsReadOnly())
            {
                var output = node.AddFlowOutput(" ");
                node.AddFlowInput(" ", flow =>
                {
                    SetValue();
                    output.Call(flow);
                });
            }

            //non static
            if (instanceDef.paramMode != ParamMode.Undefined)
            {
                instanceInput = node.AddValueInput(instanceDef.portName, instanceDef.paramType, instanceDef.portId);
                if (accessMode == ReflectedFieldNodeWrapper.AccessMode.SetField && !fieldInfo.IsReadOnly())
                {
                    node.AddValueOutput(instanceDef.portName, instanceDef.paramType, () => instanceObject, instanceDef.portId);
                }
            }
            else
            {
                instanceInput  = null;
                instanceObject = null;
            }

            if (accessMode == ReflectedFieldNodeWrapper.AccessMode.SetField && !fieldInfo.IsReadOnly())
            {
                valueInput = node.AddValueInput(resultDef.portName, resultDef.paramType, resultDef.portId);
            }
            else
            {
                node.AddValueOutput(resultDef.portName, resultDef.portId, resultDef.paramType, () =>
                {
                    GetValue();
                    return(valueObject);
                });
            }
        }
 public override void RegisterPorts(FlowNode node, ReflectedFieldNodeWrapper.AccessMode accessMode)
 {
     if (isConstant)
     {
         delegateParams[0].RegisterAsOutput(node);
     }
     if (getValue == null)
     {
         getValue = GetValue;
     }
     if (accessMode == ReflectedFieldNodeWrapper.AccessMode.SetField && !fieldInfo.IsReadOnly())
     {
         var output = node.AddFlowOutput(" ");
         node.AddFlowInput(" ", flow =>
         {
             SetValue();
             output.Call(flow);
         });
     }
     for (int i = 0; i <= delegateParams.Length - 1; i++)
     {
         var param = delegateParams[i];
         var def   = param.paramDef;
         if (def.paramMode == ParamMode.Instance)
         {
             param.RegisterAsInput(node);
             if (accessMode == ReflectedFieldNodeWrapper.AccessMode.SetField && !fieldInfo.IsReadOnly())
             {
                 param.RegisterAsOutput(node);
             }
         }
         if (def.paramMode == ParamMode.Result)
         {
             if (accessMode == ReflectedFieldNodeWrapper.AccessMode.SetField && !fieldInfo.IsReadOnly())
             {
                 param.RegisterAsInput(node);
             }
             else
             {
                 param.RegisterAsOutput(node, getValue);
             }
         }
     }
 }
 public abstract void RegisterPorts(FlowNode node, ReflectedFieldNodeWrapper.AccessMode accessMode);
Example #5
0
 abstract public void RegisterPorts(FlowNode node, FieldInfo field, ReflectedFieldNodeWrapper.AccessMode accessMode);