public EditorFloatSliderField(string label, float value, float min, float max, EventCallback <ChangeEvent <float> > callback)
{
slider = new Slider(label, min, max, SliderDirection.Horizontal);
slider.name = nameof(slider);
slider.value = value;
labelElement.StylePadding(0, 8, 0, 0);
Add(slider);
floatField = new FloatField();
floatField.name = nameof(floatField);
floatField.StyleWidth(64);
floatField.style.paddingLeft = 4;
floatField.style.marginRight = 0;
floatField.value = value;
floatField.RegisterValueChangedCallback(callback);
floatField.RegisterValueChangedCallback((callbackChangedSlider) =>
{
slider.value = callbackChangedSlider.newValue;
});
slider.Add(floatField);
slider.RegisterValueChangedCallback((callbackSlide) =>
{
floatField.value = callbackSlide.newValue;
});
}
// -----------------------------------------------------------------------------------------
public void Generate_Broadcaster_Vertical_Spacing_Field()
{
var floatProp = new FloatProperty();
floatProp.PropertyName = _TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyName;
floatProp.PropertyValue = _TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyValue;
var visualElement = new VisualElement();
var blackboardField = new BlackboardField {
text = floatProp.PropertyName, typeText = ""
};
visualElement.Add(blackboardField);
var field = new FloatField("Value:");
field.value = floatProp.PropertyValue;
field.RegisterValueChangedCallback(ChangeEvent =>
{
_TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyValue = field.value;
if (_TranzmitGraphView.CurrentArrangementType == Tranzmit_Graph_View.ArrangementTypes.Vertical)
{
_TranzmitGraphView.Arrange_Broadcaster_Results(Tranzmit_Graph_View.ArrangementTypes.Vertical);
}
});
var blackBoardValueRow = new BlackboardRow(blackboardField, field);
visualElement.Add(blackBoardValueRow);
_TranzmitGraphView.Blackboard.Add(visualElement);
}
public override void Enable()
{
base.Enable();
var node = nodeTarget as RandomRangeNode;
var min = new FloatField("Min")
{
value = node.min
};
min.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Min " + e.newValue);
node.min = e.newValue;
NotifyNodeChanged();
});
var max = new FloatField("Max")
{
value = node.max
};
max.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Max " + e.newValue);
node.max = e.newValue;
NotifyNodeChanged();
});
controlsContainer.Add(min);
controlsContainer.Add(max);
}
void AddRealtimeFields(MixtureNode node, MixtureGraphView owner)
{
doubleBuffered = new Toggle("Double Buffered")
{
value = node.rtSettings.doubleBuffered,
};
doubleBuffered.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Double Buffered " + e.newValue);
node.rtSettings.doubleBuffered = e.newValue;
onChanged?.Invoke();
});
Add(doubleBuffered);
refreshMode = new EnumField("Refresh Mode", node.rtSettings.refreshMode);
refreshMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Refresh Mode " + e.newValue);
node.rtSettings.refreshMode = (RefreshMode)e.newValue;
onChanged?.Invoke();
});
Add(refreshMode);
period = new FloatField("Period")
{
value = node.rtSettings.period
};
period.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Period " + e.newValue);
node.rtSettings.period = e.newValue;
onChanged?.Invoke();
});
Add(period);
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
float fieldToDraw,
string labelName,
out VisualElement propertyFloatField,
int indentLevel = 0)
{
var floatField = new FloatField {
label = "X", value = fieldToDraw
};
floatField.labelElement.style.minWidth = 15;
if (valueChangedCallback != null)
{
floatField.RegisterValueChangedCallback(evt => { valueChangedCallback((float)evt.newValue); });
}
propertyFloatField = floatField;
var defaultRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
defaultRow.Add(propertyFloatField);
defaultRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(defaultRow);
}
public FloatSlider() : base()
{
slider.RegisterValueChangedCallback(evt => { field.value = value = evt.newValue; });
slider.style.minWidth = 50;
field.RegisterValueChangedCallback(evt => { slider.value = value = evt.newValue; });
field.style.minWidth = 80;
}
VisualElement CreateLightExposureContent()
{
var exposure = SceneView.s_DrawModeExposure;
var root = new VisualElement();
root.AddToClassList(k_SliderRowClass);
var icon = new Image()
{
name = "exposure-label"
};
m_ExposureSlider = new Slider(-m_ExposureMax, m_ExposureMax)
{
name = "exposure-slider"
};
m_ExposureSlider.AddToClassList(k_SliderClass);
m_ExposureSlider.RegisterValueChangedCallback(SetBakedExposure);
m_ExposureSlider.SetValueWithoutNotify(exposure);
m_ExposureField = new FloatField()
{
name = "exposure-float-field"
};
m_ExposureField.AddToClassList(k_SliderFloatFieldClass);
m_ExposureField.RegisterValueChangedCallback(SetBakedExposure);
m_ExposureField.SetValueWithoutNotify(exposure);
root.Add(icon);
root.Add(m_ExposureSlider);
root.Add(m_ExposureField);
return(root);
}
public void CreateGUI()
{
VisualElement root = rootVisualElement;
var visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/EasePreview.uxml");
VisualElement labelFromUXML = visualTree.Instantiate();
labelFromUXML.style.flexGrow = 1;
root.Add(labelFromUXML);
var styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Editor/EasePreview.uss");
root.styleSheets.Add(styleSheet);
var selector = root.Q <EnumField>("selector");
selector.Init(_easeType);
selector.RegisterValueChangedCallback(SelectorValueChanged);
_drawPanel = root.Q <VisualElement>("drawPanel");
_drawPanel.generateVisualContent = DrawEaseFunction;
_overField = root.Q <FloatField>("overshootOrAmplitude");
_overField.RegisterValueChangedCallback(ParaChangedOvershootOrAmplitude);
_overField.visible = false;
_periodField = root.Q <FloatField>("period");
_periodField.RegisterValueChangedCallback(ParaChangedPeriod);
_periodField.visible = false;
root.Bind(new SerializedObject(this));
}
public CreateVector2Node()
{
Initialize("Create Vector2", DefaultNodePosition);
var inputField = new FloatField {
label = "x:", value = 0
};
inputField.labelElement.style.minWidth = 0;
inputField.name = "xInput";
inputField.RegisterValueChangedCallback(evt => {
CodeGraph.Instance.InvalidateSaveButton();
x = evt.newValue;
});
inputContainer.Add(inputField);
var inputField2 = new FloatField {
label = "y:", value = 0
};
inputField2.labelElement.style.minWidth = 0;
inputField2.name = "yInput";
inputField2.RegisterValueChangedCallback(evt => {
CodeGraph.Instance.InvalidateSaveButton();
y = evt.newValue;
});
inputContainer.Add(inputField2);
var valuePort = base.InstantiatePort(Orientation.Horizontal, Direction.Output, Port.Capacity.Multi, typeof(float));
valuePort.portName = "value (2)";
AddOutputPort(valuePort, () => $"new Vector2({x}f,{y}f)");
Refresh();
}
VisualElement CreateSliderWithField(GUIContent label, float value, float min, float max, EventCallback <ChangeEvent <float> > callback)
{
var root = new VisualElement()
{
name = "Slider Float Field"
};
root.AddToClassList(k_SliderRowClass);
var slider = new Slider(min, max);
slider.AddToClassList(k_SliderClass);
slider.RegisterValueChangedCallback(callback);
slider.SetValueWithoutNotify(value);
if (label != null && !string.IsNullOrEmpty(label.text))
{
slider.label = label.text;
slider.tooltip = label.tooltip;
}
var field = new FloatField();
field.AddToClassList(k_SliderFloatFieldClass);
field.RegisterValueChangedCallback(callback);
field.SetValueWithoutNotify(value);
root.Add(slider);
root.Add(field);
return(root);
}
void LoadTemplate()
{
AddToClassList("timeField");
m_FieldName = new Label();
m_FieldName.AddToClassList("timeFieldNameLabel");
Add(m_FieldName);
var inputContainer = new VisualElement();
inputContainer.AddToClassList("timeFieldInputContainer");
Add(inputContainer);
m_SecondsField = new FloatField("Seconds");
m_SecondsField.AddToClassList("timeInput");
m_SecondsField.RegisterValueChangedCallback(OnTimeInSecondsChanged);
inputContainer.Add(m_SecondsField);
m_FrameField = new IntegerField("Frame");
m_FrameField.AddToClassList("timeInput");
m_FrameField.RegisterValueChangedCallback(OnFrameChanged);
inputContainer.Add(m_FrameField);
SyncToViewModeSetting();
RegisterCallback <AttachToPanelEvent>(OnAttachToPanel);
RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel);
}
public override VisualElement Build()
{
base.Build();
var range = DrawerAttribute;
var lowValue = Mathf.Max(range.min, LowValue);
var highValue = Mathf.Min(range.max, HighValue);
m_Field.lowValue = TypeConversion.Convert <float, TFieldType>(ref lowValue);
m_Field.highValue = TypeConversion.Convert <float, TFieldType>(ref highValue);
var root = new VisualElement();
root.Add(m_Field);
m_Field.style.flexGrow = 1;
m_ValueField = new FloatField
{
name = Name,
label = null,
tooltip = Tooltip,
};
m_ValueField.formatString = "0.##";
m_ValueField.RegisterValueChangedCallback(OnChanged);
m_ValueField.style.flexGrow = 0;
m_ValueField.style.width = 50;
root.Add(m_ValueField);
root.style.flexDirection = FlexDirection.Row;
return(root);
}
void AddField(Vector4 initialValue, int index, string subLabel)
{
var dummy = new VisualElement {
name = "dummy"
};
var label = new Label(subLabel);
dummy.Add(label);
Add(dummy);
var field = new FloatField {
userData = index, value = initialValue[index]
};
var dragger = new FieldMouseDragger <double>(field);
dragger.SetDragZone(label);
field.Q("unity-text-input").RegisterCallback <KeyDownEvent>(evt =>
{
// Record Undo for input field edit
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
}
// Handle scaping input field edit
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
evt.StopPropagation();
}
// Dont record Undo again until input field is unfocused
m_UndoGroup++;
this.MarkDirtyRepaint();
});
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (m_UndoGroup == -1)
{
m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
}
var value = m_Get();
if (value[index] != (float)evt.newValue)
{
value[index] = (float)evt.newValue;
m_Set(value);
m_Node.Dirty(ModificationScope.Node);
}
});
// Reset UndoGroup when done editing input field & update title
field.Q("unity-text-input").RegisterCallback <FocusOutEvent>(evt =>
{
m_Node.owner.owner.isDirty = true;
m_UndoGroup = -1;
});
Add(field);
}
static void CreateField <T>(string label, IConstantEditorBuilder builder, VisualElement container, T oldValue, float fieldValue, Func <ChangeEvent <float>, T> generateValue)
{
var field = new FloatField(label);
field.value = fieldValue;
container.Add(field);
field.RegisterValueChangedCallback(evt => Dispatch(builder, oldValue, generateValue(evt)));
}
public static void SetFloatFieldRange(this FloatField field, float min = float.MinValue, float max = float.MaxValue)
{
k_FloatFieldRanges[field] = new Tuple <float, float>(min, max);
field.RegisterValueChangedCallback(OnFloatFieldValueChanged);
field.RegisterCallback <DetachFromPanelEvent>(OnFloatFieldDetachedFromPanel);
ClampFloatFieldValue(field.value, field);
}
public void SetData(WidgetDataLaunchCommandElement data)
{
_widgetData = data;
_nameLabel.text = data.GameConsoleInvokable.DisplayName;
_activeToggle.value = data.Active;
_paramsContainer.Clear();
int paramIndex = 0;
foreach (IGameConsoleParameter param in data.GameConsoleInvokable.Parameters)
{
if (param.Type == typeof(bool))
{
var field = new Toggle();
bool.TryParse(TryPopParam(), out bool val);
field.value = val;
field.RegisterValueChangedCallback((evt) => OnParameterModified());
_paramsContainer.Add(field);
}
else if (param.Type == typeof(int))
{
var field = new IntegerField();
int.TryParse(TryPopParam(), out int val);
field.value = val;
field.RegisterValueChangedCallback((evt) => OnParameterModified());
_paramsContainer.Add(field);
}
else if (param.Type == typeof(float))
{
var field = new FloatField();
float.TryParse(TryPopParam(), out float val);
field.value = val;
field.RegisterValueChangedCallback((evt) => OnParameterModified());
_paramsContainer.Add(field);
}
else
{
var field = new TextField();
field.value = TryPopParam();
field.RegisterValueChangedCallback((evt) => OnParameterModified());
_paramsContainer.Add(field);
}
}
_nameLabel.SetEnabled(data.Active);
foreach (var item in _paramsContainer.Children())
{
item.SetEnabled(data.Active);
}
OnParameterModified();
string TryPopParam()
{
if (data.Parameters == null)
{
return(default);
public static VisualElement GetElementOfFloatField(float startValue, string fieldName, Action <object> setValue, Action <object> getValue)
{
FloatField field = new FloatField(fieldName);
field.SetValueWithoutNotify(startValue);
field.RegisterValueChangedCallback(s => setValue.Invoke(s.newValue));
getValue += o => field.SetValueWithoutNotify((float)o);
return(field);
}
public static void RenderFloatProperty(VisualElement container, string name, object value,
Action <object> setter)
{
var field = new FloatField(name);
field.SetValueWithoutNotify((float)value);
field.MarkDirtyRepaint();
field.RegisterValueChangedCallback(evt => setter(evt.newValue));
container.Add(field);
}
void AddField(int index, string subLabel)
{
var dummy = new VisualElement {
name = "dummy"
};
var label = new Label(subLabel);
dummy.Add(label);
Add(dummy);
var field = new FloatField {
userData = index, value = m_Value[index]
};
// var dragger = new FieldMouseDragger<float>(field);
// dragger.SetDragZone(label);
field.RegisterCallback <MouseDownEvent>(Repaint);
field.RegisterCallback <MouseMoveEvent>(Repaint);
field.RegisterValueChangedCallback(evt =>
{
var value = GetValue();
value[index] = (float)evt.newValue;
SetValue(value);
m_UndoGroup = -1;
MarkDirtyRepaint();
});
field.RegisterCallback <InputEvent>(evt =>
{
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
_mLogicNodeEditor.Owner.LogicGraphEditorObject.RegisterCompleteObjectUndo("Change " + _mLogicNodeEditor.ToString());
}
float newValue;
if (!float.TryParse(evt.newData, out newValue))
{
newValue = 0f;
}
var value = GetValue();
value[index] = newValue;
SetValue(value);
MarkDirtyRepaint();
});
field.RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
m_Value = GetValue();
evt.StopPropagation();
}
MarkDirtyRepaint();
});
Add(field);
}
void AddField(Vector4 initialValue, int index, string subLabel)
{
var dummy = new VisualElement {
name = "dummy"
};
var label = new Label(subLabel);
dummy.Add(label);
Add(dummy);
var field = new FloatField {
userData = index, value = initialValue[index]
};
var dragger = new FieldMouseDragger <double>(field);
dragger.SetDragZone(label);
field.RegisterValueChangedCallback(evt =>
{
var value = m_Get();
value[index] = (float)evt.newValue;
m_Set(value);
m_Node.Dirty(ModificationScope.Node);
m_UndoGroup = -1;
});
field.Q("unity-text-input").RegisterCallback <InputEvent>(evt =>
{
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
}
float newValue;
if (!float.TryParse(evt.newData, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out newValue))
{
newValue = 0f;
}
var value = m_Get();
if (Math.Abs(value[index] - newValue) > 1e-9)
{
value[index] = newValue;
m_Set(value);
m_Node.Dirty(ModificationScope.Node);
}
});
field.Q("unity-text-input").RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
evt.StopPropagation();
}
this.MarkDirtyRepaint();
});
Add(field);
}
public Slider(
float val,
float min,
float max,
EventCallback <float> valueCB,
EventCallback <float> minCB,
EventCallback <float> maxCB
)
{
ValueCallback = valueCB;
MinCallback = minCB;
MaxCallback = maxCB;
Value = val;
contentContainer.AddToClassList("bounded-float");
contentContainer.AddToClassList("range");
Range = new SliderFloat {
highValue = max,
lowValue = min,
value = val
};
Min = new FloatField {
value = min
};
Current = new FloatField {
value = val
};
Max = new FloatField {
value = max
};
Min.AddToClassList("min-value");
Current.AddToClassList("current-value");
Max.AddToClassList("max-value");
var Fields = new VisualElement();
Fields.AddToClassList("input-fields");
Fields.Add(Min);
Fields.Add(Current);
Fields.Add(Max);
contentContainer.Add(Range);
contentContainer.Add(Fields);
Range.RegisterValueChangedCallback(CurrentChanged);
Min.RegisterValueChangedCallback(MinChanged);
Current.RegisterValueChangedCallback(CurrentChanged);
Max.RegisterValueChangedCallback(MaxChanged);
}
public ValueSlider(string label, float start, float end, SliderDirection direction, int pageSize,
float defaultValue = 0f) : base(label, start, end, direction, pageSize)
{
var newFloatField = new FloatField();
value = defaultValue;
this.RegisterValueChangedCallback(evt => { newFloatField.SetValueWithoutNotify(evt.newValue); });
newFloatField.RegisterValueChangedCallback(evt => { value = evt.newValue; });
Add(newFloatField);
newFloatField.SetValueWithoutNotify(value);
}
void AddField(Vector4 initialValue, int index, string subLabel)
{
var dummy = new VisualElement {
name = "dummy"
};
var label = new Label(subLabel);
dummy.Add(label);
Add(dummy);
var field = new FloatField {
userData = index, value = initialValue[index]
};
var dragger = new FieldMouseDragger <float>(field);
dragger.SetDragZone(label);
field.RegisterValueChangedCallback(evt =>
{
var value = _get();
value[index] = (float)evt.newValue;
_set(value);
_nodeEditor.SetDirty();
_undoGroup = -1;
});
field.RegisterCallback <InputEvent>(evt =>
{
if (_undoGroup == -1)
{
_undoGroup = Undo.GetCurrentGroup();
_nodeEditor.Owner.LogicGraphEditorObject.RegisterCompleteObjectUndo("Change " + _nodeEditor.NodeType());
}
if (!float.TryParse(evt.newData, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out var newValue))
{
newValue = 0f;
}
var value = _get();
if (Math.Abs(value[index] - newValue) > 1e-9)
{
value[index] = newValue;
_set(value);
_nodeEditor.SetDirty();
}
});
field.RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && _undoGroup > -1)
{
Undo.RevertAllDownToGroup(_undoGroup);
_undoGroup = -1;
evt.StopPropagation();
}
MarkDirtyRepaint();
});
Add(field);
}
/// <summary> Updates the way values are drawn in the inspector. </summary>
/// <returns> The visual element containing the heirarchy and styles of the class. </returns>
private VisualElement UpdateClassElements()
{
classElements.Clear();
IMGUIContainer eventsContainer = new IMGUIContainer(DrawUnityEvents);
classElements.Add(eventsContainer);
visualTree.CloneTree(classElements);
Toggle isMoonlightActiveToggle = classElements.Q <Toggle>("isMoonlightActive");
isMoonlightActiveToggle.value = moonlightActive.boolValue;
isMoonlightActiveToggle.RegisterValueChangedCallback(IsMoonlightActiveValueChanged);
Toggle useTimerToggle = classElements.Q <Toggle>("useTimer");
useTimerToggle.value = useTimerValue.boolValue;
useTimerToggle.RegisterValueChangedCallback(UseTimersValueChanged);
#region Active Field
moonlightActiveTimeField = classElements.Q <Slider>("moonlightActiveTime");
moonlightActiveTimeField.lowValue = moonlightTimeMin;
moonlightActiveTimeField.highValue = moonlightTimeMax;
moonlightActiveTimeField.value = moonlightActiveTime.floatValue;
moonlightActiveTimeField.RegisterValueChangedCallback(MoonlightActiveTimeValueChanged);
moonlightActiveTimeFloatField = classElements.Q <FloatField>("moonlightActiveValue");
moonlightActiveTimeFloatField.value = moonlightActiveTime.floatValue;
moonlightActiveTimeFloatField.RegisterValueChangedCallback(MoonlightActiveTimeValueChanged);
#endregion
#region Inactive Field
moonlightInactiveTimeField = classElements.Q <Slider>("moonlightInactiveTime");
moonlightInactiveTimeField.lowValue = moonlightTimeMin;
moonlightInactiveTimeField.highValue = moonlightTimeMax;
moonlightInactiveTimeField.value = moonlightInactiveTime.floatValue;
moonlightInactiveTimeField.RegisterValueChangedCallback(MoonlightInactiveTimeValueChanged);
moonlightInactiveTimeFloatField = classElements.Q <FloatField>("moonlightInactiveValue");
moonlightInactiveTimeFloatField.value = moonlightInactiveTime.floatValue;
moonlightInactiveTimeFloatField.RegisterValueChangedCallback(MoonlightInactiveTimeValueChanged);
#endregion
UpdateMoonlightTimerFields();
return(classElements);
}
protected override void OnEnable()
{
base.OnEnable();
rootVisualElement.styleSheets.Add((StyleSheet)EditorGUIUtility.Load("StyleSheets/SceneViewToolbarElements/SnapWindowsCommon.uss"));
rootVisualElement.Add(new SnapSettingsHeader(L10n.Tr("Increment Snapping"), ResetValues));
// Move
m_MoveLinkedField = new LinkedVector3Field(L10n.Tr("Move"))
{
name = "Move"
};
m_MoveLinkedField.value = EditorSnapSettings.move;
m_MoveLinkedField.linked = Mathf.Approximately(m_MoveLinkedField.value.x, m_MoveLinkedField.value.y) &&
Mathf.Approximately(m_MoveLinkedField.value.x, m_MoveLinkedField.value.z);
rootVisualElement.Add(m_MoveLinkedField);
EditorSnapSettings.moveChanged += (value) => m_MoveLinkedField.SetValueWithoutNotify(value);
m_MoveLinkedField.RegisterValueChangedCallback(OnMoveValueChanged);
// Rotate
var rotate = new FloatField(L10n.Tr("Rotate"))
{
name = "Rotate"
};
rotate.value = EditorSnapSettings.rotate;
rootVisualElement.Add(rotate);
EditorSnapSettings.rotateChanged += (value) => rotate.SetValueWithoutNotify(value);
rotate.RegisterValueChangedCallback(evt =>
{
EditorSnapSettings.rotate = evt.newValue;
EditorSnapSettings.Save();
});
// Scale
var scale = new FloatField(L10n.Tr("Scale"))
{
name = "Scale"
};
scale.value = EditorSnapSettings.scale;
rootVisualElement.Add(scale);
EditorSnapSettings.scaleChanged += (value) => scale.SetValueWithoutNotify(value);
scale.RegisterValueChangedCallback(evt =>
{
EditorSnapSettings.scale = evt.newValue;
EditorSnapSettings.Save();
});
}
void Init()
{
FloatField field = new FloatField()
{
value = config.value != null ? (float)config.value : new float(),
};
field.RegisterValueChangedCallback((e) => {
config.OnValueChanged(e.newValue);
MarkDirtyRepaint();
});
Add(field);
}
FloatField AddField(VisualElement panel, Slider slider, int index, DielectricSpecularNode.DielectricMaterial initMaterial)
{
float initValue;
if (index == 1)
{
initValue = initMaterial.indexOfRefraction;
}
else
{
initValue = initMaterial.range;
}
var field = new FloatField {
userData = index, value = initValue
};
field.RegisterCallback <MouseDownEvent>(Repaint);
field.RegisterCallback <MouseMoveEvent>(Repaint);
field.RegisterValueChangedCallback(evt =>
{
var fieldValue = (float)evt.newValue;
if (index == 1)
{
m_DielectricMaterial.indexOfRefraction = fieldValue;
}
else
{
m_DielectricMaterial.range = fieldValue;
}
m_PropertyInfo.SetValue(m_Node, m_DielectricMaterial, null);
this.MarkDirtyRepaint();
});
field.Q("unity-text-input").RegisterCallback <FocusOutEvent>(evt =>
{
if (index == 1)
{
RedrawIORControls(m_DielectricMaterial.indexOfRefraction);
}
else
{
RedrawRangeControls(m_DielectricMaterial.range);
}
this.MarkDirtyRepaint();
});
panel.Add(field);
return(field);
}
public FloatField AddFloatField(float value = 0f, bool alternate = false, bool secondAlternate = false, bool thirdAlternate = false)
{
FloatField el = new FloatField();
el.value = value;
el.AddToClassList("list-item-input");
el.AddToClassList("list-item-float-input");
AddAlternates(el, alternate, secondAlternate, thirdAlternate);
el.RegisterValueChangedCallback(e => {
eventManager.Raise <ListItemInputChange>(new ListItemInputChange(el));
});
this.Add(el);
return(el);
}
protected void Init()
{
AddToClassList(USS_CLASS_NAME);
AddToClassList("worldStateItem");
AddToClassList("rounded");
m_WorldStateField = new TextField("World State")
{
value = m_UtilityDescription.WorldStateName
};
m_WorldStateField.tooltip = "The identifier of the world state. The corresponding world state value should be castable to float.";
m_WorldStateField.maxLength = 30;
hierarchy.Add(m_WorldStateField);
m_OperatorSelectorField = new UtilityOperatorSelectorField("Operator")
{
value = m_UtilityDescription.UtilityOperator
};
m_OperatorSelectorField.tooltip = "Defines how the resulting value will be applied to the base utility value. All curves will be applied in order of appearance.";
hierarchy.Add(m_OperatorSelectorField);
m_CurveField = new CurveField("Curve")
{
value = m_UtilityDescription.UtilityCurve
};
m_CurveField.tooltip = "The curve that will be evaluated based on the world state. world state will be interpreted as a float.";
hierarchy.Add(m_CurveField);
m_CurveMultiplierField = new FloatField("Curve Multiplier")
{
value = m_UtilityDescription.CurveMultiplier
};
m_CurveMultiplierField.tooltip = "The evaluated curve value will be multiplied with this number before it is applied to the base utility value.";
hierarchy.Add(m_CurveMultiplierField);
m_WorldStateField.RegisterValueChangedCallback(WorldStateNameChanged);
m_OperatorSelectorField.RegisterValueChangedCallback(UtilityOperatorChanged);
m_CurveField.RegisterValueChangedCallback(CurveChanged);
m_CurveMultiplierField.RegisterValueChangedCallback(CurveMultiplierChanged);
this.AddManipulator(new Clickable(() => OnMouseDown?.Invoke(this)));
this.AddManipulator(new ContextualMenuManipulator(_menubuilder =>
{
_menubuilder.menu.AppendAction("Delete", _dropDownMenuAction => OnDelete?.Invoke(this), DropdownMenuAction.Status.Normal);
_menubuilder.menu.AppendAction("Duplicate", _dropDownMenuAction => OnDuplicate?.Invoke(this), DropdownMenuAction.Status.Normal);
}));
}
public MinMaxSliderControl(Vector2 value, float min, float max)
{
_slider = new MinMaxSlider(value.x, value.y, min, max);
_minText = new FloatField();
_minText.RegisterValueChangedCallback(evt => this.SendChangeEvent(evt.previousValue, evt.newValue));
_minText.AddToClassList(TextUssClassName);
_maxText = new FloatField();
_maxText.RegisterValueChangedCallback(evt => this.SendChangeEvent(evt.previousValue, evt.newValue));
_maxText.AddToClassList(TextUssClassName);
Add(_minText);
Setup(value);
Add(_maxText);
}
