public override void InitializeNodeProcessor(NodeProcessor processor)
{
if (RType == RandomType.InsideUnitCircle)
{
processor.Vector2Out = () => UnityEngine.Random.insideUnitCircle;
}
else if (RType == RandomType.OnUnitCircle)
{
processor.Vector2Out = () => UnityEngine.Random.insideUnitCircle.normalized;
}
if (RType == RandomType.InsideUnitSphere)
{
processor.Vector3Out = () => UnityEngine.Random.insideUnitSphere;
}
if (RType == RandomType.OnUnitSphere)
{
processor.Vector3Out = () => UnityEngine.Random.onUnitSphere;
}
if (RType == RandomType.Value01)
{
processor.FloatOut = () => UnityEngine.Random.value;
}
if (RType == RandomType.Valuem11)
{
processor.FloatOut = () => UnityEngine.Random.Range(-1f, 1f);
}
if (RType == RandomType.Rotation)
{
processor.Vector4Out = () => ToV(UnityEngine.Random.rotation);
}
if (RType == RandomType.RotationUniform)
{
processor.Vector4Out = () => ToV(UnityEngine.Random.rotationUniform);
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () =>
{
float val = processor.Inputs[0].FloatOut();
float delta = val - _lastVal;
_lastVal = val;
return(delta);
};
processor.Vector2Out = () =>
{
Vector2 val2 = processor.Inputs[0].Vector2Out();
Vector2 delta2 = val2 - _lastVal2;
_lastVal2 = val2;
return(delta2);
};
processor.Vector3Out = () =>
{
Vector3 val3 = processor.Inputs[0].Vector3Out();
Vector3 delta3 = val3 - _lastVal3;
_lastVal3 = val3;
return(delta3);
};
processor.Vector4Out = () =>
{
Vector4 val4 = processor.Inputs[0].Vector4Out();
Vector4 delta4 = val4 - _lastVal4;
_lastVal4 = val4;
return(delta4);
};
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
OperationInitializer(_Type);
processor.FloatOut = () => _operation(processor.Inputs[0].FloatOut());
processor.Vector2Out = () =>
{
Vector2 a = processor.Inputs[0].Vector2Out();
return(new Vector2(_operation(a.x), _operation(a.y)));
};
processor.Vector3Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
return(new Vector3(_operation(a.x), _operation(a.y), _operation(a.z)));
};
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
return(new Vector4(_operation(a.x), _operation(a.y), _operation(a.z), _operation(a.w)));
};
processor.ColorOut = () =>
{
Color a = processor.Inputs[0].ColorOut();
return(new Color(_operation(a.r), _operation(a.g), _operation(a.b), _operation(a.a)));
};
}
void GeneratedProcessorInitializerOneInput(NodeProcessor processor)
{
processor.Vector2Out = () =>
{
Vector2 in0 = processor.Inputs[0].Vector2Out();
return(new Vector2(OperationOneInput(in0.x), OperationOneInput(in0.y)));
};
processor.Vector3Out = () =>
{
Vector3 in0 = processor.Inputs[0].Vector3Out();
return(new Vector3(OperationOneInput(in0.x), OperationOneInput(in0.y), OperationOneInput(in0.z)));
};
processor.Vector4Out = () =>
{
Vector4 in0 = processor.Inputs[0].Vector4Out();
return(new Vector4(OperationOneInput(in0.x), OperationOneInput(in0.y), OperationOneInput(in0.z), OperationOneInput(in0.w)));
};
processor.ColorOut = () =>
{
Color in0 = processor.Inputs[0].ColorOut();
return(new Color(OperationOneInput(in0.r), OperationOneInput(in0.g), OperationOneInput(in0.b), OperationOneInput(in0.a)));
};
processor.FloatOut = () =>
{
float in0 = processor.Inputs[0].FloatOut();
return(OperationOneInput(in0));
};
processor.IntOut = () =>
{
int in0 = processor.Inputs[0].IntOut();
return(OperationOneInputInt(in0));
};
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () => processor.Inputs[0].BoolOut() ? processor.Inputs[1].FloatOut() : processor.Inputs[2].FloatOut();
processor.Vector2Out = () => processor.Inputs[0].BoolOut() ? processor.Inputs[1].Vector2Out() : processor.Inputs[2].Vector2Out();
processor.Vector3Out = () => processor.Inputs[0].BoolOut() ? processor.Inputs[1].Vector3Out() : processor.Inputs[2].Vector3Out();
processor.Vector4Out = () => processor.Inputs[0].BoolOut() ? processor.Inputs[1].Vector4Out() : processor.Inputs[2].Vector4Out();
processor.ColorOut = () => processor.Inputs[0].BoolOut() ? processor.Inputs[1].ColorOut() : processor.Inputs[2].ColorOut();
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () => Mathf.LerpUnclamped(processor.Inputs[0].FloatOut(), processor.Inputs[1].FloatOut(), processor.Inputs[2].FloatOut());
processor.Vector2Out = () => Vector2.LerpUnclamped(processor.Inputs[0].Vector2Out(), processor.Inputs[1].Vector2Out(), processor.Inputs[2].FloatOut());
processor.Vector3Out = () => Vector3.LerpUnclamped(processor.Inputs[0].Vector3Out(), processor.Inputs[1].Vector3Out(), processor.Inputs[2].FloatOut());
processor.Vector4Out = () => Vector4.LerpUnclamped(processor.Inputs[0].Vector4Out(), processor.Inputs[1].Vector4Out(), processor.Inputs[2].FloatOut());
processor.ColorOut = () => Color.LerpUnclamped(processor.Inputs[0].ColorOut(), processor.Inputs[1].ColorOut(), processor.Inputs[2].FloatOut());
processor.IntOut = () => (int)Mathf.LerpUnclamped(processor.Inputs[0].IntOut(), processor.Inputs[1].IntOut(), processor.Inputs[2].FloatOut());
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () =>
{
int repeatSize = processor.Inputs[0].IntOut();
int octaves = processor.Inputs[1].IntOut();
int seed = processor.Inputs[2].IntOut();
float roughness = processor.Inputs[3].FloatOut();
Vector2 in0 = processor.Inputs[4].Vector2Out();
return(Perlin.FBM(in0.x, in0.y, octaves, 2, roughness, repeatSize, seed));
};
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
IOUpdate();
if (IOMode == IOMode.Output)
{
processor.VoidOut = () => Value = processor.Inputs[0].FloatOut();
}
else
{
processor.FloatOut = () => Value;
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () =>
{
_time += Parent.Dt * TimeSpeed;
if (processor.Inputs[0].BoolOut())
{
_time = 0f;
}
float val = _time;
if (_time > Limit)
{
switch (LType)
{
case LimitType.Repeat:
val = Mathf.Repeat(_time, Limit);
break;
case LimitType.StayToStart:
val = 0f;
break;
case LimitType.StayToEnd:
val = Limit;
break;
case LimitType.PingPong:
val = Mathf.PingPong(_time, Limit);
break;
case LimitType.PingPongOnce:
val = Mathf.Max(0, Limit - Mathf.Abs(_time - Limit));
break;
default:
val = _time;
break;
}
}
if (Inverse)
{
val = Limit - val;
}
if (To01)
{
val /= Limit;
}
return(val);
};
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
GeneratedOperationInitializer(_Type);
int inputsCount = OperationConfigs[(int)_Type].InputCount;
if (inputsCount == 2)
{
ValueTypeConfig a = ValueTypeConfig.Types[(int)Parent.GetNode(Inputs[0]).CashedOutputType];
ValueTypeConfig b = ValueTypeConfig.Types[(int)Parent.GetNode(Inputs[1]).CashedOutputType];
GeneratedProcessorInitializerTwoInput(processor, a, b);
}
else
{
GeneratedProcessorInitializerOneInput(processor);
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
//ValueType valueType = GetMember();
//Inputs[0].Type = valueType;
ValueType valueType = Inputs[0].Type;
if (valueType != ValueType.Error)
{
if (valueType == ValueType.Float)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <float>()(processor.Inputs[0].FloatOut());
}
if (valueType == ValueType.Vector2)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <Vector2>()(processor.Inputs[0].Vector2Out());
}
if (valueType == ValueType.Vector3)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <Vector3>()(processor.Inputs[0].Vector3Out());
}
if (valueType == ValueType.Vector4)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <Vector4>()(processor.Inputs[0].Vector4Out());
}
if (valueType == ValueType.Color)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <Color>()(processor.Inputs[0].ColorOut());
}
if (valueType == ValueType.Int)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <int>()(processor.Inputs[0].IntOut());
}
if (valueType == ValueType.Bool)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <bool>()(processor.Inputs[0].BoolOut());
}
if (valueType == ValueType.Texture2D)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <Texture2D>()(processor.Inputs[0].Texture2DOut());
}
if (valueType == ValueType.RenderTexture)
{
processor.VoidOut = () => _reflectedValue.CompileSetMethod <RenderTexture>()(processor.Inputs[0].RenderTextureOut());
}
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
switch (_Type)
{
case OperationType.AMoreThanB:
processor.BoolOut = () => (processor.Inputs[0].FloatOut() > processor.Inputs[1].FloatOut()) ^ Invert;
break;
case OperationType.AMoreOrEqualB:
processor.BoolOut = () => (processor.Inputs[0].FloatOut() >= processor.Inputs[1].FloatOut()) ^ Invert;
break;
case OperationType.AEqualB:
processor.BoolOut = () => (processor.Inputs[0].FloatOut() == processor.Inputs[1].FloatOut()) ^ Invert;
break;
}
}
void RebuildGraph()
{
_nodeList = _nodeData.GetAllNodes();
_deadEnds = _nodeData.GetDeadEnds(_nodeList);
foreach (Node node in _nodeList)
{
node.Processor = null;
}
List <int> outputs = new List <int>();
foreach (Node node in _deadEnds)
{
node.UpdateTypes(_nodeData, new HashSet <Node>());
NodeProcessor pr = _nodeData.GetNodeProcessor(node);
if (!_nodeData.ValidateNodes(node))
{
continue;
}
if (pr != null && pr.VoidOut != null && node.OutputType != ValueType.Error)
{
outputs.Add(node.NodeId);
}
}
_nodeData.Outputs = outputs.ToArray();
_nodeData.Prepare();
if (_nodeData.Externals == null)
{
_nodeData.Externals = new NodeDataExternals();
}
_nodeData.Externals.InitializeFrom(_nodeData);
if (_selectionProcessor.Host != null)
{
EditorUtility.SetDirty(_selectionProcessor.Host);
EditorHelper.CallOnValidate(_selectionProcessor.Host);
EditorHelper.RepaintInspectors();
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
if (CashedOutputType != ValueType.Error)
{
if (CashedOutputType == ValueType.Float)
{
processor.FloatOut = _reflectedValue.CompileGetMethod <float>();
}
if (CashedOutputType == ValueType.Vector2)
{
processor.Vector2Out = _reflectedValue.CompileGetMethod <Vector2>();
}
if (CashedOutputType == ValueType.Vector3)
{
processor.Vector3Out = _reflectedValue.CompileGetMethod <Vector3>();
}
if (CashedOutputType == ValueType.Vector4)
{
processor.Vector4Out = _reflectedValue.CompileGetMethod <Vector4>();
}
if (CashedOutputType == ValueType.Color)
{
processor.ColorOut = _reflectedValue.CompileGetMethod <Color>();
}
if (CashedOutputType == ValueType.Int)
{
processor.IntOut = _reflectedValue.CompileGetMethod <int>();
}
if (CashedOutputType == ValueType.Bool)
{
processor.BoolOut = _reflectedValue.CompileGetMethod <bool>();
}
if (CashedOutputType == ValueType.Texture2D)
{
processor.Texture2DOut = _reflectedValue.CompileGetMethod <Texture2D>();
}
if (CashedOutputType == ValueType.RenderTexture)
{
processor.RenderTextureOut = _reflectedValue.CompileGetMethod <RenderTexture>();
}
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
switch (_Type)
{
case OperationType.InvertA:
processor.BoolOut = () => !processor.Inputs[0].BoolOut();
break;
case OperationType.TriggerA:
processor.BoolOut = () =>
{
bool val = processor.Inputs[0].BoolOut();
if (_lastVal == val)
{
return(false);
}
_lastVal = val;
return(true);
};
break;
case OperationType.Equal:
processor.BoolOut = () => processor.Inputs[0].BoolOut() == processor.Inputs[1].BoolOut();
break;
case OperationType.Or:
processor.BoolOut = () => processor.Inputs[0].BoolOut() || processor.Inputs[1].BoolOut();
break;
case OperationType.And:
processor.BoolOut = () => processor.Inputs[0].BoolOut() && processor.Inputs[1].BoolOut();
break;
case OperationType.Xor:
processor.BoolOut = () => processor.Inputs[0].BoolOut() ^ processor.Inputs[1].BoolOut();
break;
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
Damping = Math.Max(Damping, float.Epsilon);
_damping = 1f / (1f + Mathf.Pow(Damping, 5));
processor.FloatOut = () =>
{
_velocity += processor.Inputs[0].FloatOut();
_velocity -= _current * Hardness;
_velocity *= Mathf.Pow(_damping, Parent.Dt);
_current += _velocity;
return(_current);
};
processor.Vector2Out = () =>
{
_velocity2 += processor.Inputs[0].Vector2Out();
_velocity2 -= _current2 * Hardness;
_velocity2 *= Mathf.Pow(_damping, Parent.Dt);
_current2 += _velocity2;
return(_current2);
};
processor.Vector3Out = () =>
{
_velocity3 += processor.Inputs[0].Vector3Out();
_velocity3 -= _current3 * Hardness;
_velocity3 *= Mathf.Pow(_damping, Parent.Dt);
_current3 += _velocity3;
return(_current3);
};
processor.Vector4Out = () =>
{
_velocity4 += processor.Inputs[0].Vector4Out();
_velocity4 -= _current4 * Hardness;
_velocity4 *= Mathf.Pow(_damping, Parent.Dt);
_current4 += _velocity4;
return(_current4);
};
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
if (_Type == OperationType.HSV_RGB)
{
processor.ColorOut = () =>
{
Vector3 v = processor.Inputs[0].Vector3Out();
return(Color.HSVToRGB(v.x, v.y, v.z, true));
};
}
else if (_Type == OperationType.RGB_HSV)
{
processor.Vector3Out = () =>
{
Vector3 v = new Vector3();
Color.RGBToHSV(processor.Inputs[0].ColorOut(), out v.x, out v.y, out v.z);
return(v);
};
}
else if (_Type == OperationType.HSVv_RGB)
{
processor.ColorOut = () => { return(Color.HSVToRGB(processor.Inputs[0].FloatOut(), processor.Inputs[1].FloatOut(), processor.Inputs[2].FloatOut(), true)); };
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
switch (_Type)
{
case OperationType.Multyply:
{
ValueType t0 = Parent.GetNode(Inputs[0]).CashedOutputType;
ValueType t1 = Parent.GetNode(Inputs[1]).CashedOutputType;
if (t0 == ValueType.Vector3 && t1 == ValueType.Vector4)
{
processor.Vector3Out = () =>
{
Vector4 q = processor.Inputs[1].Vector4Out();
Vector3 v = processor.Inputs[0].Vector3Out();
return(ToQ(q) * v);
};
}
if (t0 == ValueType.Vector2 && t1 == ValueType.Vector4)
{
processor.Vector2Out = () =>
{
Vector4 q = processor.Inputs[1].Vector4Out();
Vector2 v = processor.Inputs[0].Vector2Out();
return(ToQ(q) * v);
};
}
if (t0 == ValueType.Vector4 && t1 == ValueType.Vector3)
{
processor.Vector3Out = () =>
{
Vector4 q = processor.Inputs[0].Vector4Out();
Vector3 v = processor.Inputs[1].Vector3Out();
return(ToQ(q) * v);
};
}
if (t0 == ValueType.Vector4 && t1 == ValueType.Vector2)
{
processor.Vector2Out = () =>
{
Vector4 q = processor.Inputs[0].Vector4Out();
Vector2 v = processor.Inputs[1].Vector2Out();
return(ToQ(q) * v);
};
}
if (t0 == ValueType.Vector4 && t1 == ValueType.Vector4)
{
processor.Vector4Out = () =>
{
Vector4 q0 = processor.Inputs[0].Vector4Out();
Vector4 q1 = processor.Inputs[1].Vector4Out();
return(ToV(ToQ(q0) * ToQ(q1)));
};
}
}
break;
case OperationType.AxisAngle:
{
processor.Vector4Out = () =>
{
float a = processor.Inputs[0].FloatOut();
Vector3 b = processor.Inputs[1].Vector3Out();
return(ToV(Quaternion.AngleAxis(a, b)));
};
}
break;
case OperationType.FormEuler:
{
processor.Vector4Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
return(ToV(Quaternion.Euler(a)));
};
}
break;
case OperationType.ToEuler:
{
processor.Vector3Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
return(ToQ(a).eulerAngles);
};
}
break;
case OperationType.FromToRotation:
{
processor.Vector4Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
Vector3 b = processor.Inputs[1].Vector3Out();
return(ToV(Quaternion.FromToRotation(a, b)));
};
}
break;
case OperationType.Inverse:
{
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
return(ToV(Quaternion.Inverse(ToQ(a))));
};
}
break;
case OperationType.LerpUnclamped:
{
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
Vector4 b = processor.Inputs[1].Vector4Out();
float t = processor.Inputs[2].FloatOut();
return(ToV(Quaternion.LerpUnclamped(ToQ(a), ToQ(b), t)));
};
break;
}
case OperationType.SlerpUnclamped:
{
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
Vector4 b = processor.Inputs[1].Vector4Out();
float t = processor.Inputs[2].FloatOut();
return(ToV(Quaternion.SlerpUnclamped(ToQ(a), ToQ(b), t)));
};
}
break;
case OperationType.LookRotation:
{
if (Inputs[1].Type == ValueType.None)
{
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
return(ToV(Quaternion.LookRotation(a)));
}
}
;
else
{
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
Vector4 b = processor.Inputs[1].Vector4Out();
return(ToV(Quaternion.LookRotation(a, b)));
}
};
}
break;
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () =>
{
if (processor.Inputs[1].BoolOut())
{
_lastVal = processor.Inputs[0].FloatOut();
}
else if (!Freeze)
{
_lastVal = 0;
}
return(_lastVal);
};
processor.Vector2Out = () =>
{
if (processor.Inputs[1].BoolOut())
{
_lastVal2 = processor.Inputs[0].Vector2Out();
}
else if (!Freeze)
{
_lastVal2 = new Vector2();
}
return(_lastVal2);
};
processor.Vector3Out = () =>
{
if (processor.Inputs[1].BoolOut())
{
_lastVal3 = processor.Inputs[0].Vector3Out();
}
else if (!Freeze)
{
_lastVal3 = new Vector3();
}
return(_lastVal3);
};
processor.Vector4Out = () =>
{
if (processor.Inputs[1].BoolOut())
{
_lastVal4 = processor.Inputs[0].Vector4Out();
}
else if (!Freeze)
{
_lastVal4 = new Vector4();
}
return(_lastVal4);
}; processor.ColorOut = () =>
{
if (processor.Inputs[1].BoolOut())
{
_lastValC = processor.Inputs[0].ColorOut();
}
else if (!Freeze)
{
_lastValC = new Color();
}
return(_lastValC);
};
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.Vector2Out = () =>
{
Vector2 v = _zero2;
NodeProcessor inx = processor.Inputs[0];
NodeProcessor iny = processor.Inputs[1];
if (inx != null)
{
v.x = inx.FloatOut();
}
if (iny != null)
{
v.y = iny.FloatOut();
}
return(v);
};
processor.Vector3Out = () =>
{
Vector3 v = _zero3;
NodeProcessor inx = processor.Inputs[0];
NodeProcessor iny = processor.Inputs[1];
NodeProcessor inz = processor.Inputs[2];
if (inx != null)
{
v.x = inx.FloatOut();
}
if (iny != null)
{
v.y = iny.FloatOut();
}
if (inz != null)
{
v.z = inz.FloatOut();
}
return(v);
};
processor.Vector4Out = () =>
{
Vector4 v = _zero4;
NodeProcessor inx = processor.Inputs[0];
NodeProcessor iny = processor.Inputs[1];
NodeProcessor inz = processor.Inputs[2];
NodeProcessor inw = processor.Inputs[3];
if (inx != null)
{
v.x = inx.FloatOut();
}
if (iny != null)
{
v.y = iny.FloatOut();
}
if (inz != null)
{
v.z = inz.FloatOut();
}
if (inw != null)
{
v.w = inw.FloatOut();
}
return(v);
};
processor.ColorOut = () =>
{
Color v = _zeroC;
NodeProcessor inx = processor.Inputs[0];
NodeProcessor iny = processor.Inputs[1];
NodeProcessor inz = processor.Inputs[2];
NodeProcessor inw = processor.Inputs[3];
if (inx != null)
{
v.r = inx.FloatOut();
}
if (iny != null)
{
v.g = iny.FloatOut();
}
if (inz != null)
{
v.b = inz.FloatOut();
}
if (inw != null)
{
v.a = inw.FloatOut();
}
return(v);
};
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.ColorOut = () => Gradient.Evaluate(processor.Inputs[0].FloatOut());
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.Vector4Out = () => Value;
}
void GeneratedProcessorInitializerTwoInput(NodeProcessor processor, ValueTypeConfig aConfig, ValueTypeConfig bConfig)
{
if (aConfig.IsVector && bConfig.IsVector)
{
processor.Vector2Out = () =>
{
Vector2 in0 = processor.Inputs[0].Vector2Out();
Vector2 in1 = processor.Inputs[1].Vector2Out();
return(new Vector2(OperationTwoInput(in0.x, in1.x), OperationTwoInput(in0.y, in1.y)));
};
processor.Vector3Out = () =>
{
Vector3 in0 = processor.Inputs[0].Vector3Out();
Vector3 in1 = processor.Inputs[1].Vector3Out();
return(new Vector3(OperationTwoInput(in0.x, in1.x), OperationTwoInput(in0.y, in1.y), OperationTwoInput(in0.z, in1.z)));
};
processor.Vector4Out = () =>
{
Vector4 in0 = processor.Inputs[0].Vector4Out();
Vector4 in1 = processor.Inputs[1].Vector4Out();
return(new Vector4(OperationTwoInput(in0.x, in1.x), OperationTwoInput(in0.y, in1.y), OperationTwoInput(in0.z, in1.z), OperationTwoInput(in0.w, in1.w)));
};
processor.ColorOut = () =>
{
Color in0 = processor.Inputs[0].ColorOut();
Color in1 = processor.Inputs[1].ColorOut();
return(new Color(OperationTwoInput(in0.r, in1.r), OperationTwoInput(in0.g, in1.g), OperationTwoInput(in0.b, in1.b), OperationTwoInput(in0.a, in1.a)));
};
}
else if (aConfig.IsVector && !bConfig.IsVector)
{
if (bConfig.ValueType == ValueType.Float)
{
processor.Vector2Out = () =>
{
Vector2 in0 = processor.Inputs[0].Vector2Out();
float in1 = processor.Inputs[1].FloatOut();
return(new Vector2(OperationTwoInput(in0.x, in1), OperationTwoInput(in0.y, in1)));
};
processor.Vector3Out = () =>
{
Vector3 in0 = processor.Inputs[0].Vector3Out();
float in1 = processor.Inputs[1].FloatOut();
return(new Vector3(OperationTwoInput(in0.x, in1), OperationTwoInput(in0.y, in1), OperationTwoInput(in0.z, in1)));
};
processor.Vector4Out = () =>
{
Vector4 in0 = processor.Inputs[0].Vector4Out();
float in1 = processor.Inputs[1].FloatOut();
return(new Vector4(OperationTwoInput(in0.x, in1), OperationTwoInput(in0.y, in1), OperationTwoInput(in0.z, in1), OperationTwoInput(in0.w, in1)));
};
processor.ColorOut = () =>
{
Color in0 = processor.Inputs[0].ColorOut();
float in1 = processor.Inputs[1].FloatOut();
return(new Color(OperationTwoInput(in0.r, in1), OperationTwoInput(in0.g, in1), OperationTwoInput(in0.b, in1), OperationTwoInput(in0.a, in1)));
};
}
else
{
processor.Vector2Out = () =>
{
Vector2 in0 = processor.Inputs[0].Vector2Out();
int in1 = processor.Inputs[1].IntOut();
return(new Vector2(OperationTwoInput(in0.x, in1), OperationTwoInput(in0.y, in1)));
};
processor.Vector3Out = () =>
{
Vector3 in0 = processor.Inputs[0].Vector3Out();
int in1 = processor.Inputs[1].IntOut();
return(new Vector3(OperationTwoInput(in0.x, in1), OperationTwoInput(in0.y, in1), OperationTwoInput(in0.z, in1)));
};
processor.Vector4Out = () =>
{
Vector4 in0 = processor.Inputs[0].Vector4Out();
int in1 = processor.Inputs[1].IntOut();
return(new Vector4(OperationTwoInput(in0.x, in1), OperationTwoInput(in0.y, in1), OperationTwoInput(in0.z, in1), OperationTwoInput(in0.w, in1)));
};
processor.ColorOut = () =>
{
Color in0 = processor.Inputs[0].ColorOut();
int in1 = processor.Inputs[1].IntOut();
return(new Color(OperationTwoInput(in0.r, in1), OperationTwoInput(in0.g, in1), OperationTwoInput(in0.b, in1), OperationTwoInput(in0.a, in1)));
};
}
}
else if (!aConfig.IsVector && bConfig.IsVector)
{
if (aConfig.ValueType == ValueType.Float)
{
processor.Vector2Out = () =>
{
float in0 = processor.Inputs[0].FloatOut();
Vector2 in1 = processor.Inputs[1].Vector2Out();
return(new Vector2(OperationTwoInput(in0, in1.x), OperationTwoInput(in0, in1.y)));
};
processor.Vector3Out = () =>
{
float in0 = processor.Inputs[0].FloatOut();
Vector3 in1 = processor.Inputs[1].Vector3Out();
return(new Vector3(OperationTwoInput(in0, in1.x), OperationTwoInput(in0, in1.y), OperationTwoInput(in0, in1.z)));
};
processor.Vector4Out = () =>
{
float in0 = processor.Inputs[0].FloatOut();
Vector4 in1 = processor.Inputs[1].Vector4Out();
return(new Vector4(OperationTwoInput(in0, in1.x), OperationTwoInput(in0, in1.y), OperationTwoInput(in0, in1.z), OperationTwoInput(in0, in1.w)));
};
processor.ColorOut = () =>
{
float in0 = processor.Inputs[0].FloatOut();
Color in1 = processor.Inputs[1].ColorOut();
return(new Color(OperationTwoInput(in0, in1.r), OperationTwoInput(in0, in1.g), OperationTwoInput(in0, in1.b), OperationTwoInput(in0, in1.a)));
};
}
else
{
processor.Vector2Out = () =>
{
int in0 = processor.Inputs[0].IntOut();
Vector2 in1 = processor.Inputs[1].Vector2Out();
return(new Vector2(OperationTwoInput(in0, in1.x), OperationTwoInput(in0, in1.y)));
};
processor.Vector3Out = () =>
{
int in0 = processor.Inputs[0].IntOut();
Vector3 in1 = processor.Inputs[1].Vector3Out();
return(new Vector3(OperationTwoInput(in0, in1.x), OperationTwoInput(in0, in1.y), OperationTwoInput(in0, in1.z)));
};
processor.Vector4Out = () =>
{
int in0 = processor.Inputs[0].IntOut();
Vector4 in1 = processor.Inputs[1].Vector4Out();
return(new Vector4(OperationTwoInput(in0, in1.x), OperationTwoInput(in0, in1.y), OperationTwoInput(in0, in1.z), OperationTwoInput(in0, in1.w)));
};
processor.ColorOut = () =>
{
int in0 = processor.Inputs[0].IntOut();
Color in1 = processor.Inputs[1].ColorOut();
return(new Color(OperationTwoInput(in0, in1.r), OperationTwoInput(in0, in1.g), OperationTwoInput(in0, in1.b), OperationTwoInput(in0, in1.a)));
};
}
}
else if (!aConfig.IsVector && !bConfig.IsVector)
{
if (aConfig.ValueType == ValueType.Float)
{
if (bConfig.ValueType == ValueType.Float)
{
processor.FloatOut = () =>
{
float in0 = processor.Inputs[0].FloatOut();
float in1 = processor.Inputs[1].FloatOut();
return(OperationTwoInput(in0, in1));
};
}
else
{
processor.FloatOut = () =>
{
float in0 = processor.Inputs[0].FloatOut();
int in1 = processor.Inputs[1].IntOut();
return(OperationTwoInput(in0, in1));
};
}
}
else
{
if (bConfig.ValueType == ValueType.Float)
{
processor.FloatOut = () =>
{
int in0 = processor.Inputs[0].IntOut();
float in1 = processor.Inputs[1].FloatOut();
return(OperationTwoInput(in0, in1));
};
}
else
{
processor.IntOut = () =>
{
int in0 = processor.Inputs[0].IntOut();
int in1 = processor.Inputs[1].IntOut();
return(OperationTwoInputInt(in0, in1));
};
}
}
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
GeneratedSwizzles(processor, Parent.GetNode(Inputs[0]).CashedOutputType);
}
void GeneratedSwizzles(NodeProcessor processor, ValueType input)
{
if (input == ValueType.Float)
{
processor.FloatOut = () =>
{
float v = processor.Inputs[0].FloatOut();
return(v);
};
processor.Vector2Out = () =>
{
float v = processor.Inputs[0].FloatOut();
return(new Vector2(v, v));
};
processor.Vector3Out = () =>
{
float v = processor.Inputs[0].FloatOut();
return(new Vector3(v, v, v));
};
processor.Vector4Out = () =>
{
float v = processor.Inputs[0].FloatOut();
return(new Vector4(v, v, v, v));
};
processor.ColorOut = () =>
{
float v = processor.Inputs[0].FloatOut();
return(new Color(v, v, v, v));
};
processor.IntOut = () =>
{
float v = processor.Inputs[0].FloatOut();
return((int)v);
};
}
else if (input == ValueType.Vector2)
{
processor.FloatOut = () =>
{
Vector2 v = processor.Inputs[0].Vector2Out();
return(v[_comp0]);
};
processor.Vector2Out = () =>
{
Vector2 v = processor.Inputs[0].Vector2Out();
return(new Vector2(v[_comp0], v[_comp1]));
};
processor.Vector3Out = () =>
{
Vector2 v = processor.Inputs[0].Vector2Out();
return(new Vector3(v[_comp0], v[_comp1], v[_comp2]));
};
processor.Vector4Out = () =>
{
Vector2 v = processor.Inputs[0].Vector2Out();
return(new Vector4(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.ColorOut = () =>
{
Vector2 v = processor.Inputs[0].Vector2Out();
return(new Color(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.IntOut = () =>
{
Vector2 v = processor.Inputs[0].Vector2Out();
return((int)v[_comp0]);
};
}
else if (input == ValueType.Vector3)
{
processor.FloatOut = () =>
{
Vector3 v = processor.Inputs[0].Vector3Out();
return(v[_comp0]);
};
processor.Vector2Out = () =>
{
Vector3 v = processor.Inputs[0].Vector3Out();
return(new Vector2(v[_comp0], v[_comp1]));
};
processor.Vector3Out = () =>
{
Vector3 v = processor.Inputs[0].Vector3Out();
return(new Vector3(v[_comp0], v[_comp1], v[_comp2]));
};
processor.Vector4Out = () =>
{
Vector3 v = processor.Inputs[0].Vector3Out();
return(new Vector4(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.ColorOut = () =>
{
Vector3 v = processor.Inputs[0].Vector3Out();
return(new Color(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.IntOut = () =>
{
Vector3 v = processor.Inputs[0].Vector3Out();
return((int)v[_comp0]);
};
}
else if (input == ValueType.Vector4)
{
processor.FloatOut = () =>
{
Vector4 v = processor.Inputs[0].Vector4Out();
return(v[_comp0]);
};
processor.Vector2Out = () =>
{
Vector4 v = processor.Inputs[0].Vector4Out();
return(new Vector2(v[_comp0], v[_comp1]));
};
processor.Vector3Out = () =>
{
Vector4 v = processor.Inputs[0].Vector4Out();
return(new Vector3(v[_comp0], v[_comp1], v[_comp2]));
};
processor.Vector4Out = () =>
{
Vector4 v = processor.Inputs[0].Vector4Out();
return(new Vector4(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.ColorOut = () =>
{
Vector4 v = processor.Inputs[0].Vector4Out();
return(new Color(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.IntOut = () =>
{
Vector4 v = processor.Inputs[0].Vector4Out();
return((int)v[_comp0]);
};
}
else if (input == ValueType.Color)
{
processor.FloatOut = () =>
{
Color v = processor.Inputs[0].ColorOut();
return(v[_comp0]);
};
processor.Vector2Out = () =>
{
Color v = processor.Inputs[0].ColorOut();
return(new Vector2(v[_comp0], v[_comp1]));
};
processor.Vector3Out = () =>
{
Color v = processor.Inputs[0].ColorOut();
return(new Vector3(v[_comp0], v[_comp1], v[_comp2]));
};
processor.Vector4Out = () =>
{
Color v = processor.Inputs[0].ColorOut();
return(new Vector4(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.ColorOut = () =>
{
Color v = processor.Inputs[0].ColorOut();
return(new Color(v[_comp0], v[_comp1], v[_comp2], v[_comp3]));
};
processor.IntOut = () =>
{
Color v = processor.Inputs[0].ColorOut();
return((int)v[_comp0]);
};
}
else if (input == ValueType.Int)
{
processor.FloatOut = () =>
{
int v = processor.Inputs[0].IntOut();
return(v);
};
processor.Vector2Out = () =>
{
int v = processor.Inputs[0].IntOut();
return(new Vector2(v, v));
};
processor.Vector3Out = () =>
{
int v = processor.Inputs[0].IntOut();
return(new Vector3(v, v, v));
};
processor.Vector4Out = () =>
{
int v = processor.Inputs[0].IntOut();
return(new Vector4(v, v, v, v));
};
processor.ColorOut = () =>
{
int v = processor.Inputs[0].IntOut();
return(new Color(v, v, v, v));
};
processor.IntOut = () =>
{
int v = processor.Inputs[0].IntOut();
return((int)v);
};
}
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
switch (_Type)
{
case OperationType.Dot:
{
ValueType t0 = Parent.GetNode(Inputs[0]).CashedOutputType;
if (t0 == ValueType.Vector2)
{
processor.FloatOut = () =>
{
Vector2 a = processor.Inputs[0].Vector2Out();
Vector2 b = processor.Inputs[1].Vector2Out();
return(Vector2.Dot(a, b));
};
}
if (t0 == ValueType.Vector3)
{
processor.FloatOut = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
Vector3 b = processor.Inputs[1].Vector3Out();
return(Vector3.Dot(a, b));
};
}
if (t0 == ValueType.Vector4)
{
processor.FloatOut = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
Vector4 b = processor.Inputs[1].Vector4Out();
return(Vector4.Dot(a, b));
};
}
if (t0 == ValueType.Color)
{
processor.FloatOut = () =>
{
Color a = processor.Inputs[0].ColorOut();
Color b = processor.Inputs[1].ColorOut();
return(ColorDot(a, b));
};
}
}
break;
case OperationType.Normalize:
{
processor.Vector2Out = () =>
{
Vector2 a = processor.Inputs[0].Vector2Out();
return(a.normalized);
};
processor.Vector3Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
return(a.normalized);
};
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
return(a.normalized);
};
processor.ColorOut = () =>
{
Color a = processor.Inputs[0].ColorOut();
return(ColorNormalized(a));
};
}
break;
case OperationType.Length:
{
ValueType t0 = Parent.GetNode(Inputs[0]).CashedOutputType;
if (t0 == ValueType.Vector2)
{
processor.FloatOut = () =>
{
Vector2 a = processor.Inputs[0].Vector2Out();
return(a.magnitude);
};
}
if (t0 == ValueType.Vector3)
{
processor.FloatOut = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
return(a.magnitude);
};
}
if (t0 == ValueType.Vector4)
{
processor.FloatOut = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
return(a.magnitude);
};
}
if (t0 == ValueType.Color)
{
processor.FloatOut = () =>
{
Color a = processor.Inputs[0].ColorOut();
return(ColorLength(a));
};
}
}
break;
case OperationType.Distance:
{
ValueType t0 = Parent.GetNode(Inputs[0]).CashedOutputType;
if (t0 == ValueType.Vector2)
{
processor.FloatOut = () =>
{
Vector2 a = processor.Inputs[0].Vector2Out();
Vector2 b = processor.Inputs[1].Vector2Out();
return(Vector2.Distance(a, b));
};
}
if (t0 == ValueType.Vector3)
{
processor.FloatOut = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
Vector3 b = processor.Inputs[1].Vector3Out();
return(Vector3.Distance(a, b));
};
}
if (t0 == ValueType.Vector4)
{
processor.FloatOut = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
Vector4 b = processor.Inputs[1].Vector4Out();
return(Vector4.Distance(a, b));
};
}
if (t0 == ValueType.Color)
{
processor.FloatOut = () =>
{
Color a = processor.Inputs[0].ColorOut();
Color b = processor.Inputs[1].ColorOut();
return(ColorLength(a - b));
};
}
}
break;
case OperationType.Cross:
{
processor.Vector3Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
Vector3 b = processor.Inputs[1].Vector3Out();
return(Vector3.Cross(a, b));
};
}
break;
case OperationType.Project:
{
processor.Vector3Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
Vector3 b = processor.Inputs[1].Vector3Out();
return(Vector3.Project(a, b));
};
processor.Vector4Out = () =>
{
Vector4 a = processor.Inputs[0].Vector4Out();
Vector4 b = processor.Inputs[1].Vector4Out();
return(Vector4.Project(a, b));
};
}
break;
case OperationType.ProjectOnPlane:
{
processor.Vector3Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
Vector3 b = processor.Inputs[1].Vector3Out();
return(Vector3.ProjectOnPlane(a, b));
};
}
break;
case OperationType.Reflect:
{
processor.Vector2Out = () =>
{
Vector2 a = processor.Inputs[0].Vector2Out();
Vector2 b = processor.Inputs[1].Vector2Out();
return(Vector2.Reflect(a, b));
};
processor.Vector3Out = () =>
{
Vector3 a = processor.Inputs[0].Vector3Out();
Vector3 b = processor.Inputs[1].Vector3Out();
return(Vector3.Reflect(a, b));
};
}
break;
}
}
public virtual void InitializeNodeProcessor(NodeProcessor processor)
{
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () => Value;
}
public override void InitializeNodeProcessor(NodeProcessor processor)
{
processor.FloatOut = () => Curve.Evaluate(processor.Inputs[0].FloatOut());
}
