protected override void UpdateNode(Node node)
        {
            if(node.name.Equals("setAngle"))
            {
				node.updated = true;
                if(node.objectTarget == null && _analogInput == null)
                    return;
                
                if(node.objectTarget != null)
                {
                    if(node.objectTarget.Equals(_analogInput))
                        return;
                }
                
                _analogInput = node.objectTarget as IWireInput<float>;
                if(_analogInput == null)
                    node.objectTarget = null;
                
                return;
            }
            else if(node.name.Equals("getAngle"))
            {
				node.updated = true;
                if(node.objectTarget == null && _analogOutput == null)
                    return;
                
                if(node.objectTarget != null)
                {
                    if(node.objectTarget.Equals(_analogOutput))
                        return;
                }
                
                _analogOutput = node.objectTarget as IWireOutput<float>;
                if(_analogOutput == null)
                    node.objectTarget = null;
                
                return;
            }
            else if(node.name.Equals("rotateDrag"))
            {
				node.updated = true;
                if(node.objectTarget == null && _dragInput == null)
                    return;
                
                if(node.objectTarget != null)
                {
                    if(node.objectTarget.Equals(_dragInput))
                        return;
                }
                
                _dragInput = node.objectTarget as IWireInput<DragData>;
                if(_dragInput == null)
                    node.objectTarget = null;
                
                return;
            }
                            
            base.UpdateNode(node);
        }
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("input"))
            {
                node.updated = true;

                if (node.objectTarget == null && _input == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_input))
                    {
                        return;
                    }
                }

                if (_input != null)
                {
                    _input.OnWireInputChanged -= InputChanged;
                }

                _input = node.objectTarget as IWireInput <UINT16>;
                if (_input != null)
                {
                    _input.OnWireInputChanged += InputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("bitMask"))
            {
                node.updated = true;
                node.text    = "Mask: " + ToMaskString(bitMask);
                return;
            }
            else if (node.name.Equals("Value"))
            {
                node.updated = true;
                return;
            }

            base.UpdateNode(node);
        }
Beispiel #3
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("checkEdge"))
            {
                node.updated = true;
                node.text    = checkEdge.ToString();
                return;
            }
            else if (node.name.Equals("sourceValue"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalInput))
                    {
                        return;
                    }
                }

                if (_digitalInput != null)
                {
                    _digitalInput.OnWireInputChanged -= DoTrigger;
                }

                _digitalInput = node.objectTarget as IWireInput <bool>;
                if (_digitalInput != null)
                {
                    _digitalInput.OnWireInputChanged += DoTrigger;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("resultValue"))
            {
                node.updated = true;
                return;
            }

            base.UpdateNode(node);
        }
Beispiel #4
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("input"))
            {
                node.updated = true;

                if (node.objectTarget == null && _input == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_input))
                    {
                        return;
                    }
                }

                if (_input != null)
                {
                    _input.OnWireInputChanged -= InputChanged;
                }

                _input = node.objectTarget as IWireInput <float>;
                if (_input != null)
                {
                    _input.OnWireInputChanged += InputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("impulse"))
            {
                node.updated = true;
                return;
            }
            else if (node.name.Equals("trigger"))
            {
                node.updated = true;
                return;
            }

            base.UpdateNode(node);
        }
Beispiel #5
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("source"))
            {
                node.updated = true;
                node.text    = sourceName;

                if (node.objectTarget == null && _sourceInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_sourceInput))
                    {
                        return;
                    }
                }

                if (_sourceInput != null)
                {
                    _sourceInput.OnWireInputChanged -= SourceInputChanged;
                }

                _sourceInput = node.objectTarget as IWireInput <float>;;
                if (_sourceInput != null)
                {
                    _sourceInput.OnWireInputChanged += SourceInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("result"))
            {
                node.updated = true;
                node.text    = resultName;
                return;
            }

            base.UpdateNode(node);
        }
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("rotation"))
            {
                node.updated = true;
                if (node.objectTarget == null && _rotation == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_rotation))
                    {
                        return;
                    }
                }

                if (_rotation != null)
                {
                    _rotation.OnWireInputChanged -= OnRotationChanged;
                }

                _rotation = node.objectTarget as IWireInput <Quaternion>;
                if (_rotation != null)
                {
                    _rotation.OnWireInputChanged += OnRotationChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("signal input"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogInput))
                    {
                        return;
                    }
                }

                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged -= OnAnalogInputChanged;
                }

                _analogInput = node.objectTarget as IWireInput <float>;
                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged += OnAnalogInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("active"))
            {
                node.updated = true;
                if (node.objectTarget == null && _triggerInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_triggerInput))
                    {
                        return;
                    }
                }

                if (_triggerInput != null)
                {
                    _triggerInput.OnWireInputChanged -= DoExplosion;
                }

                _triggerInput = node.objectTarget as IWireInput <Trigger>;
                if (_triggerInput != null)
                {
                    _triggerInput.OnWireInputChanged += DoExplosion;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
Beispiel #9
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("analogHorizontal"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogHorizontal == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogHorizontal))
                    {
                        return;
                    }
                }

                if (_analogHorizontal != null)
                {
                    _analogHorizontal.OnWireInputChanged -= AnalogHorizontalChanged;
                }

                _analogHorizontal = node.objectTarget as IWireInput <float>;
                if (_analogHorizontal != null)
                {
                    _analogHorizontal.OnWireInputChanged += AnalogHorizontalChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("analogVertical"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogVertical == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogVertical))
                    {
                        return;
                    }
                }

                if (_analogVertical != null)
                {
                    _analogVertical.OnWireInputChanged -= AnalogVerticalChanged;
                }

                _analogVertical = node.objectTarget as IWireInput <float>;
                if (_analogVertical != null)
                {
                    _analogVertical.OnWireInputChanged += AnalogVerticalChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("digitalUp"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalUp == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalUp))
                    {
                        return;
                    }
                }

                if (_digitalUp != null)
                {
                    _digitalUp.OnWireInputChanged -= DigitalUpChanged;
                }

                _digitalUp = node.objectTarget as IWireInput <bool>;
                if (_digitalUp != null)
                {
                    _digitalUp.OnWireInputChanged += DigitalUpChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("digitalDown"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalDown == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalDown))
                    {
                        return;
                    }
                }

                if (_digitalDown != null)
                {
                    _digitalDown.OnWireInputChanged -= DigitalDownChanged;
                }

                _digitalDown = node.objectTarget as IWireInput <bool>;
                if (_digitalDown != null)
                {
                    _digitalDown.OnWireInputChanged += DigitalDownChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("digitalRight"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalRight == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalRight))
                    {
                        return;
                    }
                }

                if (_digitalRight != null)
                {
                    _digitalRight.OnWireInputChanged -= DigitalRightChanged;
                }

                _digitalRight = node.objectTarget as IWireInput <bool>;
                if (_digitalRight != null)
                {
                    _digitalRight.OnWireInputChanged += DigitalRightChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("digitalLeft"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalLeft == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalLeft))
                    {
                        return;
                    }
                }

                if (_digitalLeft != null)
                {
                    _digitalLeft.OnWireInputChanged -= DigitalLeftChanged;
                }

                _digitalLeft = node.objectTarget as IWireInput <bool>;
                if (_digitalLeft != null)
                {
                    _digitalLeft.OnWireInputChanged += DigitalLeftChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("axis"))
            {
                node.updated = true;
                return;
            }

            base.UpdateNode(node);
        }
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("FlameValue"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogInput))
                    {
                        return;
                    }
                }

                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged -= OnAnalogInputChanged;
                }

                _analogInput = node.objectTarget as IWireInput <float>;
                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged += OnAnalogInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("Buzzer"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalOutput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalOutput))
                    {
                        return;
                    }
                }

                _digitalOutput = node.objectTarget as IWireOutput <bool>;
                if (_digitalOutput == null)
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
Beispiel #11
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("setPosition"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogInput))
                    {
                        return;
                    }
                }

                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged -= OnAnalogInputChanged;
                }

                _analogInput = node.objectTarget as IWireInput <float>;
                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged += OnAnalogInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("getPosition"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogOutput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogOutput))
                    {
                        return;
                    }
                }

                _analogOutput = node.objectTarget as IWireOutput <float>;
                if (_analogOutput == null)
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("moveDrag"))
            {
                node.updated = true;
                if (node.objectTarget == null && _dragInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_dragInput))
                    {
                        return;
                    }
                }

                if (_dragInput != null)
                {
                    _dragInput.OnWireInputChanged -= OnDragInputChanged;
                }

                _dragInput = node.objectTarget as IWireInput <DragData>;
                if (_dragInput != null)
                {
                    _dragInput.OnWireInputChanged += OnDragInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
Beispiel #12
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("play"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalInput))
                    {
                        return;
                    }
                }

                if (_digitalInput != null)
                {
                    _digitalInput.OnWireInputChanged -= OnDigitalInputChanged;
                }

                _digitalInput = node.objectTarget as IWireInput <bool>;
                if (_digitalInput != null)
                {
                    _digitalInput.OnWireInputChanged += OnDigitalInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("playOnly"))
            {
                node.updated = true;
                if (node.objectTarget == null && _triggerInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_triggerInput))
                    {
                        return;
                    }
                }

                if (_triggerInput != null)
                {
                    _triggerInput.OnWireInputChanged -= OnTriggerInputChanged;
                }

                _triggerInput = node.objectTarget as IWireInput <Trigger>;
                if (_triggerInput != null)
                {
                    _triggerInput.OnWireInputChanged += OnTriggerInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("setVolume"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogInput))
                    {
                        return;
                    }
                }

                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged -= OnAnalogInputChanged;
                }

                _analogInput = node.objectTarget as IWireInput <float>;
                if (_analogInput != null)
                {
                    _analogInput.OnWireInputChanged += OnAnalogInputChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
Beispiel #13
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("analogRed"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogRed == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogRed))
                    {
                        return;
                    }
                }

                if (_analogRed != null)
                {
                    _analogRed.OnWireInputChanged -= AnalogRedChanged;
                }

                _analogRed = node.objectTarget as IWireInput <float>;
                if (_analogRed != null)
                {
                    _analogRed.OnWireInputChanged += AnalogRedChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("analogGreen"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogGreen == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogGreen))
                    {
                        return;
                    }
                }

                if (_analogGreen != null)
                {
                    _analogGreen.OnWireInputChanged -= AnalogGreenChanged;
                }

                _analogGreen = node.objectTarget as IWireInput <float>;
                if (_analogGreen != null)
                {
                    _analogGreen.OnWireInputChanged += AnalogGreenChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("analogBlue"))
            {
                node.updated = true;
                if (node.objectTarget == null && _analogBlue == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_analogBlue))
                    {
                        return;
                    }
                }

                if (_analogBlue != null)
                {
                    _analogBlue.OnWireInputChanged -= AnalogBlueChanged;
                }

                _analogBlue = node.objectTarget as IWireInput <float>;
                if (_analogBlue != null)
                {
                    _analogBlue.OnWireInputChanged += AnalogBlueChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("digitalRed"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalRed == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalRed))
                    {
                        return;
                    }
                }

                if (_digitalRed != null)
                {
                    _digitalRed.OnWireInputChanged -= DigitalRedChanged;
                }

                _digitalRed = node.objectTarget as IWireInput <bool>;
                if (_digitalRed != null)
                {
                    _digitalRed.OnWireInputChanged += DigitalRedChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("digitalGreen"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalGreen == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalGreen))
                    {
                        return;
                    }
                }

                if (_digitalGreen != null)
                {
                    _digitalGreen.OnWireInputChanged -= DigitalGreenChanged;
                }

                _digitalGreen = node.objectTarget as IWireInput <bool>;
                if (_digitalGreen != null)
                {
                    _digitalGreen.OnWireInputChanged += DigitalGreenChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("digitalBlue"))
            {
                node.updated = true;
                if (node.objectTarget == null && _digitalBlue == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_digitalBlue))
                    {
                        return;
                    }
                }

                if (_digitalBlue != null)
                {
                    _digitalBlue.OnWireInputChanged -= DigitalBlueChanged;
                }

                _digitalBlue = node.objectTarget as IWireInput <bool>;
                if (_digitalBlue != null)
                {
                    _digitalBlue.OnWireInputChanged += DigitalBlueChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("inputColor"))
            {
                node.updated = true;
                return;
            }

            base.UpdateNode(node);
        }
Beispiel #14
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("active"))
            {
                node.updated = true;
                if (node.objectTarget == null && _triggerInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_triggerInput))
                    {
                        return;
                    }
                }

                if (_triggerInput != null)
                {
                    _triggerInput.OnWireInputChanged -= AddTorque;
                }

                _triggerInput = node.objectTarget as IWireInput <Trigger>;
                if (_triggerInput != null)
                {
                    _triggerInput.OnWireInputChanged += AddTorque;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("activeDrag"))
            {
                node.updated = true;
                if (node.objectTarget == null && _dragInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_dragInput))
                    {
                        return;
                    }
                }

                if (_dragInput != null)
                {
                    _dragInput.OnWireInputChanged -= AddDragForce;
                }

                _dragInput = node.objectTarget as IWireInput <DragData>;
                if (_dragInput != null)
                {
                    _dragInput.OnWireInputChanged += AddDragForce;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
Beispiel #15
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("axis"))
            {
                node.updated = true;
                if (node.objectTarget == null && _axisWire == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_axisWire))
                    {
                        return;
                    }
                }

                if (_axisWire != null)
                {
                    _axisWire.OnWireInputChanged -= OnAxisChanged;
                }

                _axisWire = node.objectTarget as IWireInput <Vector2>;
                if (_axisWire != null)
                {
                    _axisWire.OnWireInputChanged += OnAxisChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("rotation"))
            {
                node.updated = true;
                if (node.objectTarget == null && _rotationWire == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_rotationWire))
                    {
                        return;
                    }
                }

                if (_rotationWire != null)
                {
                    _rotationWire.OnWireInputChanged -= OnRotationChanged;
                }

                _rotationWire = node.objectTarget as IWireInput <Quaternion>;
                if (_rotationWire != null)
                {
                    _rotationWire.OnWireInputChanged += OnRotationChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("jump"))
            {
                node.updated = true;
                if (node.objectTarget == null && _jumpWire == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_jumpWire))
                    {
                        return;
                    }
                }

                if (_jumpWire != null)
                {
                    _jumpWire.OnWireInputChanged -= OnJump;
                }

                _jumpWire = node.objectTarget as IWireInput <Trigger>;
                if (_jumpWire != null)
                {
                    _jumpWire.OnWireInputChanged += OnJump;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }
Beispiel #16
0
        protected override void UpdateNode(Node node)
        {
            if (node.name.Equals("setColor"))
            {
                node.updated = true;
                if (node.objectTarget == null && _colorInput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_colorInput))
                    {
                        return;
                    }
                }

                if (_colorInput != null)
                {
                    _colorInput.OnWireInputChanged -= OnInputColorChanged;
                }

                _colorInput = node.objectTarget as IWireInput <Color>;
                if (_colorInput != null)
                {
                    _colorInput.OnWireInputChanged += OnInputColorChanged;
                }
                else
                {
                    node.objectTarget = null;
                }

                return;
            }
            else if (node.name.Equals("getColor"))
            {
                node.updated = true;
                if (node.objectTarget == null && _colorOutput == null)
                {
                    return;
                }

                if (node.objectTarget != null)
                {
                    if (node.objectTarget.Equals(_colorOutput))
                    {
                        return;
                    }
                }

                _colorOutput = node.objectTarget as IWireOutput <Color>;
                if (_colorOutput == null)
                {
                    node.objectTarget = null;
                }

                return;
            }

            base.UpdateNode(node);
        }