Ref <Methods> ValueToRef(MethodReference methodRef)
{
var def = new ValueSlot <Methods>();
def.Value = methodRef;
return(def.GetRef());
}
public Vector2ConstructorNode()
{
name = "Vector2";
m_X = CreateInputSlot <ValueSlot <float> >("x").SetShowControl();
m_Y = CreateInputSlot <ValueSlot <float> >("y").SetShowControl();
CreateOutputSlot <GetterSlot <Vector2> >("Out").SetGetter(Build);
}
public ExecutionFilterNode()
{
m_Event = CreateInputSlot <EmptySlot <Action <UIEventData> > >("Event");
m_Event.SetAllowMultipleConnections(true);
m_Filter = CreateInputSlot <ValueSlot <bool> >("Filter").SetShowControl();
CreateOutputSlot <DefaultValueSlot <Action <UIEventData> > >("UI Event").SetDefaultValue(Execute);
}
public Subquery(SubqueryKind kind, ValueSlot valueSlot, BoundRelation relation, BoundExpression passthru)
{
Kind = kind;
ValueSlot = valueSlot;
Relation = relation;
Passthru = passthru;
}
public ClampFLoat()
{
m_Input0 = CreateInputSlot <EmptySlot <float> >(0, "val");
m_Input1 = CreateInputSlot <ValueSlot <float> >(1, "min").SetShowControl().SetValue(0);
m_Input2 = CreateInputSlot <ValueSlot <float> >(2, "max").SetShowControl().SetValue(1);
CreateOutputSlot <GetterSlot <float> >(3, "Out").SetGetter(Execute);
}
Ref <Types> ValueToRef(TypeReference typeRef)
{
var def = new ValueSlot <Types>();
def.Value = typeRef;
return(def.GetRef());
}
public RectMatrixBuilderNode()
{
name = "Rect Matrix";
m_Position = CreateInputSlot <ValueSlot <Vector2> >("Position").SetShowControl();
m_Size = CreateInputSlot <ValueSlot <Vector2> >("Size").SetShowControl();
CreateOutputSlot <GetterSlot <Matrix4x4> >("Out").SetGetter(BuildMatrix);
}
public MatrixBuilderNode()
{
name = "Matrix Builder";
CreateOutputSlot <GetterSlot <Matrix4x4> >("Out").SetGetter(() => Matrix4x4.TRS(m_Pos[this], m_Rot[this], m_Scale[this]));
m_Pos = CreateInputSlot <ValueSlot <Vector3> >("Position").SetShowControl();
m_Rot = CreateInputSlot <ValueSlot <Quaternion> >("Rotation").SetShowControl();
m_Scale = CreateInputSlot <ValueSlot <Vector3> >("Scale").SetShowControl();
}
public UIMasterNode()
{
name = "UI Master Node";
m_Input = CreateInputSlot <EmptySlot <Action <UIEventData> > >("UI Event");
m_Input.SetAllowMultipleConnections(true);
m_Rect = CreateInputSlot <ValueSlot <Rect> >("Rect").SetShowControl();
m_Matrix = CreateInputSlot <DefaultValueSlot <Matrix4x4> >("Matrix").SetDefaultValue(Matrix4x4.identity);
}
public Ref <Methods> Import(SR.MethodBase method)
{
var methodRef = container.Import(method);
var def = new ValueSlot <Methods> {
Value = methodRef
};
return(def.GetRef());
}
public Ref <ResolutionScopes> FromAssemblyName(Name1 name1)
{
var scope = GetScopeByName(name1, false);
var def = new ValueSlot <ResolutionScopes> {
Value = scope
};
return(def.GetRef());
}
public RowBufferEntry this[ValueSlot valueSlot]
{
get
{
return(!_mapping.ContainsKey(valueSlot) && Parent != null
? Parent[valueSlot]
: new RowBufferEntry(RowBuffer, _mapping[valueSlot]));
}
}
public Ref <ResolutionScopes> FromModuleName(Name1 name1)
{
var scope = GetScopeByName(name1, true);
var def = new ValueSlot <ResolutionScopes> {
Value = scope
};
return(def.GetRef());
}
protected GraphicNode()
{
m_Pivot = CreateInputSlot <ValueSlot <Vector2> >("Pivot %").SetValue(Vector2.one * 0.5f).SetShowControl();
m_Color = CreateInputSlot <ValueSlot <Color> >("Color").SetValue(Color.white).SetShowControl();
m_Matrix = CreateInputSlot <DefaultValueSlot <Matrix4x4> >("Matrix").SetDefaultValue(Matrix4x4.identity);
m_Material = CreateInputSlot <DefaultValueSlot <Material> >("Material");
m_ZOffset = CreateInputSlot <ValueSlot <float> >("zOffset", "Z Offset").SetShowControl();
CreateOutputSlot <ValueSlot <Action <UIEventData> > >("UI Event").SetValue(Execute);
}
protected override ValueSlot RewriteValueSlot(ValueSlot valueSlot)
{
if (valueSlot == null)
{
return(null);
}
ValueSlot newSlot;
return(_valueSlotMapping.TryGetValue(valueSlot, out newSlot) ? newSlot : valueSlot);
}
public UIElementNode()
{
m_Event = CreateInputSlot <EmptySlot <Action <UIEventData> > >("Event");
m_Event.SetAllowMultipleConnections(true);
m_Position = CreateInputSlot <ValueSlot <Vector2> >("pos", "Position").SetShowControl();
m_Size = CreateInputSlot <ValueSlot <Vector2> >("size", "Size").SetValue(new Vector2(100, 100)).SetShowControl();
m_OffsetMin = CreateInputSlot <ValueSlot <Vector2> >("minOffset", "Offset Min").SetShowControl();
m_OffsetMax = CreateInputSlot <ValueSlot <Vector2> >("maxOffset", "Offset Max").SetShowControl();
m_AnchorMin = CreateInputSlot <ValueSlot <Vector2> >("minAnchor", "Anchor Min %").SetValue(new Vector2(0.5f, 0.5f)).SetShowControl();
m_AnchorMax = CreateInputSlot <ValueSlot <Vector2> >("maxAnchor", "Anchor Max %").SetValue(new Vector2(0.5f, 0.5f)).SetShowControl();
}
public TextNode()
{
m_Text = CreateInputSlot <ValueSlot <string> >("Text").SetShowControl();
m_FontSize = CreateInputSlot <ValueSlot <int> >("Size").SetValue(DefaultFontSize).SetShowControl();
m_Pivot = CreateInputSlot <ValueSlot <Vector2> >("Pivot").SetShowControl();
m_Color = CreateInputSlot <ValueSlot <Color> >("Color").SetValue(Color.white).SetShowControl();
m_Font = CreateInputSlot <DefaultValueSlot <Font> >("Font");
m_Matrix = CreateInputSlot <DefaultValueSlot <Matrix4x4> >("Matrix").SetDefaultValue(Matrix4x4.identity);
m_Material = CreateInputSlot <EmptySlot <Material> >("Material");
CreateOutputSlot <ValueSlot <Action <UIEventData> > >("UI Event").SetValue(Execute);
CreateOutputSlot <GetterSlot <Rect> >("Extents").SetGetter(() => m_TextGenerator.rectExtents);
}
private static BoundQuery CreateBoundQuery(BoundExpression expression)
{
var factory = new ValueSlotFactory();
var valueSlot = new ValueSlot(factory, @"result", 0, expression.Type);
var computedValue = new BoundComputedValue(expression, valueSlot);
var constantRelation = new BoundConstantRelation();
var computeRelation = new BoundComputeRelation(constantRelation, new[] { computedValue });
var projectRelation = new BoundProjectRelation(computeRelation, new [] { valueSlot });
var columnSymbol = new QueryColumnInstanceSymbol(valueSlot.Name, valueSlot);
return(new BoundQuery(projectRelation, new[] { columnSymbol }));
}
public ScreenMatrixNode()
{
m_Camera = CreateOutputSlot <GetterSlot <Camera> >("Camera").SetGetter(() => m_CachedCamera);
m_ScreenRect = CreateOutputSlot <ValueSlot <Rect> >("ScreenRect").SetValue(new Rect(0, 0, 256, 256));
m_Output = CreateOutputSlot <ValueSlot <Matrix4x4> >("Mat").SetValue(Matrix4x4.identity);
}
public ExecutionNode()
{
Input = CreateInputSlot <ValueSlot <Action> >("Input");
}
public ValueNode()
{
m_Output = CreateOutputSlot <ValueSlot <T> >(kOutputSlotName);
name = typeof(T).Name;
UpdateNodeAfterDeserialization();
}
public GradientSamplerNode()
{
m_Gradient = CreateInputSlot <ValueSlot <Gradient> >("In").SetShowControl();
m_Time = CreateInputSlot <SliderSlot>("Value").SetRange(0, 1);
CreateOutputSlot <GetterSlot <Color> >("Color").SetGetter(SampleColor);
}
public RectTransformNode()
{
m_EventOut = CreateOutputSlot <ValueSlot <Action <UIEventData> > >("outEvent", "Event").SetValue(CalculateRect);
m_OutRect = CreateOutputSlot <ValueSlot <Rect> >("outRect", "Rect");
}
public Ref<ResolutionScopes> FromModuleName(Name1 name1)
{
var scope = GetScopeByName(name1, true);
var def = new ValueSlot<ResolutionScopes> { Value = scope };
return def.GetRef();
}
Ref<Types> ValueToRef(TypeReference typeRef)
{
var def = new ValueSlot<Types>();
def.Value = typeRef;
return def.GetRef();
}
internal QueryColumnInstanceSymbol(string name, ValueSlot valueSlot)
: base(name)
{
ValueSlot = valueSlot;
}
public Ref<ResolutionScopes> FromAssemblyName(Name1 name1)
{
var scope = GetScopeByName(name1, false);
var def = new ValueSlot<ResolutionScopes> { Value = scope };
return def.GetRef();
}
public static BoundExpression Value(ValueSlot valueSlot)
{
return(new BoundValueSlotExpression(valueSlot));
}
private void AddNullRejectedTable(ValueSlot valueSlot)
{
_nullRejectedRowBufferEntries.Add(valueSlot);
}
public ValueSlotControlView(ValueSlot <T> slot)
{
m_Slot = slot;
if (slot is ValueSlot <bool> )
{
var toggle = new Toggle();
toggle.value = ((IHasValue <bool>)slot).value;
toggle.RegisterValueChangedCallback((e) =>
{
m_Slot.owner.owner.owner.RegisterCompleteObjectUndo("Boolean Change");
if (m_Slot is IValueSetter <bool> )
{
((IValueSetter <bool>)m_Slot).SetValue(e.newValue);
}
m_Slot.owner.Dirty(ModificationScope.Node);
});
Add(toggle);
}
#if UNITY_EDITOR
else if (slot is ValueSlot <float> )
{
AddControl(new FloatField(), slot);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/FloatControlView"));
}
else if (slot is ValueSlot <double> )
{
AddControl(new DoubleField(), slot);
}
else if (slot is ValueSlot <string> )
{
AddControl(new TextField(), slot);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/StringControlView"));
}
else if (slot is ValueSlot <int> )
{
AddControl(new IntegerField(), slot);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/IntegerControlView"));
}
else if (slot is ValueSlot <Color> )
{
AddControl(new ColorField(), slot);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/ColorControlView"));
}
else if (slot is ValueSlot <Gradient> )
{
AddControl(new GradientField(), slot);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/GradientControlView"));
}
else if (slot is ValueSlot <AnimationCurve> )
{
AddControl(new CurveField(), slot);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/CurveControlView"));
}
else if (slot is ValueSlot <Vector2> )
{
Add(new MultiFloatSlotControlView(m_Slot.owner, new [] { "x", "y" }, () => (m_Slot as ValueSlot <Vector2>).value, v => (m_Slot as ValueSlot <Vector2>).value = v));
}
else if (slot is ValueSlot <Vector3> )
{
Add(new MultiFloatSlotControlView(m_Slot.owner, new[] { "x", "y", "z" }, () => (m_Slot as ValueSlot <Vector3>).value, v => (m_Slot as ValueSlot <Vector3>).value = v));
}
else if (slot is ValueSlot <Vector4> )
{
Add(new MultiFloatSlotControlView(m_Slot.owner, new[] { "x", "y", "z", "w" }, () => (m_Slot as ValueSlot <Vector4>).value, v => (m_Slot as ValueSlot <Vector4>).value = v));
}
else if (slot is ValueSlot <Quaternion> )
{
Add(new MultiFloatSlotControlView(m_Slot.owner, new[] { "x", "y", "z" }, () => (m_Slot as ValueSlot <Quaternion>).value.eulerAngles, v => (m_Slot as ValueSlot <Quaternion>).value = Quaternion.Euler(v)));
}
else if (slot is ValueSlot <Rect> )
{
Add(new MultiFloatSlotControlView(m_Slot.owner, new[] { "x", "y", "w", "h" }, () =>
{
var rect = (m_Slot as ValueSlot <Rect>).value;
return(new Vector4(rect.x, rect.y, rect.width, rect.height));
}, v => (m_Slot as ValueSlot <Rect>).value = new Rect(v.x, v.y, v.z, v.w)));
}
else
{
var genericType = slot.GetType().GetGenericArguments()[0];
if (typeof(Object).IsAssignableFrom(genericType))
{
var objField = new ObjectField()
{
objectType = genericType
};
if (slot is IHasValue <Object> )
{
objField.value = ((IHasValue <Object>)slot).value;
}
objField.RegisterValueChangedCallback(e =>
{
slot.owner.owner.owner.RegisterCompleteObjectUndo(genericType.Name + " Change");
if (m_Slot is IValueSetter <Object> )
{
((IValueSetter <Object>)m_Slot).SetValue(e.newValue);
}
slot.owner.Dirty(ModificationScope.Node);
});
Add(objField);
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/ObjectSlotControlView"));
}
}
#endif
}
public DivideFloat()
{
m_Input0 = CreateInputSlot <ValueSlot <float> >(0, "x").SetShowControl();
m_Input1 = CreateInputSlot <ValueSlot <float> >(1, "y").SetShowControl();
CreateOutputSlot <GetterSlot <float> >(3, "Out").SetGetter(Execute);
}
public EqualPredicate(BoundExpression condition, ValueSlot left, ValueSlot right)
{
Condition = condition;
Left = left;
Right = right;
}
public void Record(ValueSlot valueSlot)
{
UsedValueSlots.Add(valueSlot);
}
