void BuildVector4PropertyField(Vector4ShaderProperty property)
{
var field = new Vector4Field {
value = property.value
};
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-w-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-w-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (undoGroup == -1)
{
graph.owner.RegisterCompleteObjectUndo("Change property value");
}
property.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
public static VisualElement GetElementOfVector4Field(Vector4 startValue, string fieldName, Action <object> setValue, Action <object> getValue)
{
Vector4Field field = new Vector4Field(fieldName);
field.SetValueWithoutNotify(startValue);
field.RegisterValueChangedCallback(s => setValue.Invoke(s.newValue));
getValue += o => field.SetValueWithoutNotify((Vector4)o);
return(field);
}
public override VisualElement Build()
{
var valueField = new Vector4Field {
bindingPath = "Value"
};
valueField.Query <FloatField>().ForEach(field => field.formatString = "0.###");
return(valueField);
}
public static void RenderVector4Property(VisualElement container, string name, object value,
Action <object> setter)
{
var field = new Vector4Field(name);
field.SetValueWithoutNotify((Vector4)value);
field.MarkDirtyRepaint();
field.RegisterValueChangedCallback(evt => setter(evt.newValue));
container.Add(field);
}
ConstantColor() : base()
{
title = "Constant Color";
AddOutputPort <Vector4>("Value");
RefreshPorts();
m_VectorField = new Vector4Field()
{
style = { flexWrap = Wrap.NoWrap }
};
extensionContainer.Add(m_VectorField);
RefreshExpandedState();
}
void Init()
{
Vector4Field field = new Vector4Field()
{
value = config.value != null ? (Vector4)config.value : new Vector4(),
};
field.RegisterValueChangedCallback((e) => {
config.OnValueChanged(e.newValue);
MarkDirtyRepaint();
});
Add(field);
}
public VisualElement Build(InspectorDataProxy <float4> proxy)
{
m_VectorField = new Vector4Field(proxy.Name);
m_VectorField.AddToClassList(proxy.Name);
SetInputClass(m_VectorField.Q <FloatField>("unity-x-input"), "x");
SetInputClass(m_VectorField.Q <FloatField>("unity-y-input"), "y");
SetInputClass(m_VectorField.Q <FloatField>("unity-z-input"), "z");
SetInputClass(m_VectorField.Q <FloatField>("unity-w-input"), "w");
m_VectorField.RegisterValueChangedCallback(evt => ValueChanged(proxy, evt));
return(m_VectorField);
}
public static void DrawControl(this FieldControl <Vector4> control)
{
Vector4Field input = control.AddVector4Field(control.value);
control.eventManager.AddListener <ListItemInputChange>(e => {
if (e.input != input)
{
return;
}
control.value = input.value;
control.eventManager.Raise <FieldControlUpdated <Vector4> >(new FieldControlUpdated <Vector4>(control));
});
}
void SetWindSetArtistTool()
{
VisualElement root = rootVisualElement;
root.Clear();
//Loads and clones our VisualTree inside the root.
VisualTreeAsset quickToolVisualTree = Resources.Load <VisualTreeAsset>("WindArtistTool");
quickToolVisualTree.CloneTree(root);
root.styleSheets.Add(Resources.Load <StyleSheet>("WindArtistTool"));
#region Wind Shader
// Set Initial Values
VisualElement windComponent = root.Q <VisualElement>(name: "Wind");
if (windComponent != null)
{
Vector4Field windDirectionQuaternion = windComponent.Q <Vector4Field>(name: "WindDirection");
windDirectionQuaternion.value = GetWindDirection();
FloatField windScaleFloat = windComponent.Q <FloatField>(name: "WindScale");
windScaleFloat.value = GetWindScale();
MinMaxValue minMaxStrength = GetWindStrength();
VisualElement windStrengthHolder = windComponent.Q <VisualElement>(name: "WinStrengthHolder");
MinMaxSlider windStrengthSlider = windStrengthHolder.Q <MinMaxSlider>(name: "WindStrength");
windStrengthSlider.highLimit = minMaxStrength.HighLimit;
windStrengthSlider.lowLimit = minMaxStrength.LowLimit;
windStrengthSlider.value = new Vector2(minMaxStrength.minValue, minMaxStrength.maxValue);
windStrengthHolder.Q <Label>(name: "MinValue").text = "Min Value :" + minMaxStrength.minValue;
windStrengthHolder.Q <Label>(name: "MaxValue").text = "Max Value :" + minMaxStrength.maxValue;
FloatField windSpeedFloat = windComponent.Q <FloatField>(name: "WindSpeed");
windSpeedFloat.value = GetWindSpeed();
//Set Callbacks values
windDirectionQuaternion.RegisterCallback <ChangeEvent <Vector4> >(ChangeWindDirection);
windScaleFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindScale);
windStrengthSlider.RegisterCallback <ChangeEvent <Vector2> >(ChangeWindStrength);
windSpeedFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindSpeed);
}
#endregion
root.Q <Button>(name: "SaveButton").clicked += SaveButton;
root.Q <Button>(name: "ResetButton").clicked += ResetToInitialSceneValues;
}
public Vector4Field AddVector4Field(Vector4 value = new Vector4(), bool alternate = false, bool secondAlternate = false, bool thirdAlternate = false)
{
Vector4Field el = new Vector4Field();
el.value = value;
el.AddToClassList("list-item-input");
el.AddToClassList("list-item-vector-input");
AddAlternates(el, alternate, secondAlternate, thirdAlternate);
el.RegisterValueChangedCallback(e => {
eventManager.Raise <ListItemInputChange>(new ListItemInputChange(el));
});
this.Add(el);
return(el);
}
public override VisualElement CreatePropertyGUI(SerializedProperty property)
{
var vectorField = new Vector4Field()
{
value = property.vector4Value
};
vectorField.RegisterValueChangedCallback(e => {
property.vector4Value = e.newValue;
property.serializedObject.ApplyModifiedProperties();
});
return(vectorField);
}
public QuaternionField() : base(null, null)
{
// Set up styling
AddToClassList("UdonValueField");
// Create Vector4 Editor and listen for changes
Vector4Field field = new Vector4Field();
field.RegisterValueChangedCallback(
e =>
value = new Quaternion(e.newValue.x, e.newValue.y, e.newValue.z, e.newValue.w)
);
Add(field);
}
public override VisualElement Build()
{
var root = new BindableElement
{
bindingPath = "Value"
};
for (var i = 0; i < 4; ++i)
{
var column = new Vector4Field {
bindingPath = "c" + i
};
column.Query <FloatField>().ForEach(field => field.formatString = "0.###");
root.Add(column);
}
return(root);
}
public QuaternionField()
#endif
{
// Set up styling
AddToClassList("UdonValueField");
// Create Vector4 Editor and listen for changes
Vector4Field field = new Vector4Field();
#if UNITY_2019_3_OR_NEWER
field.RegisterValueChangedCallback(
#else
field.OnValueChanged(
#endif
e =>
value = new Quaternion(e.newValue.x, e.newValue.y, e.newValue.z, e.newValue.w)
);
Add(field);
}
internal override void Apply(VisualElement container)
{
/// <sample>
// Get a reference to the field from UXML and assign it its value.
var uxmlField = container.Q<Vector4Field>("the-uxml-field");
uxmlField.value = new Vector4(23.8f, 12.6f, 88.3f, 92.1f);
// Create a new field, disable it, and give it a style class.
var csharpField = new Vector4Field("C# Field");
csharpField.SetEnabled(false);
csharpField.AddToClassList("some-styled-field");
csharpField.value = uxmlField.value;
container.Add(csharpField);
// Mirror value of uxml field into the C# field.
uxmlField.RegisterCallback<ChangeEvent<Vector4>>((evt) =>
{
csharpField.value = evt.newValue;
});
/// </sample>
}
internal VisualElement CreateGUI(
ValueChangedCallback valueChangedCallback,
Vector4 fieldToDraw,
string labelName,
out VisualElement propertyVec4Field,
int indentLevel = 0)
{
var vector4Field = new Vector4Field {
value = fieldToDraw
};
var inputFields = vector4Field.Query("unity-text-input").ToList();
foreach (var inputField in inputFields)
{
inputField.RegisterCallback <KeyDownEvent>(m_KeyDownCallback);
inputField.RegisterCallback <FocusOutEvent>(m_FocusOutCallback);
}
vector4Field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (mUndoGroup == -1)
{
preValueChangeCallback?.Invoke();
}
valueChangedCallback(evt.newValue);
postValueChangeCallback?.Invoke();
});
propertyVec4Field = vector4Field;
var defaultRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel));
defaultRow.Add(propertyVec4Field);
defaultRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow"));
return(defaultRow);
}
public async Task Vector4FieldTest()
{
var theme = MatterHackers.MatterControl.AppContext.Theme;
Vector4Field.VectorXYZWEditWidth = 50;
var testField = new Vector4Field(theme);
await ValidateAgainstValueMap(
testField,
theme,
(field) =>
{
return(string.Join(",", field.Content.Children.OfType <MHNumberEdit>().Select(w => w.ActuallNumberEdit.Text).ToArray()));
},
new List <ValueMap>()
{
{ "0.1,0.2,0.3,0.4", "0.1,0.2,0.3,0.4" },
{ "1,2,3,4", "1,2,3,4" },
{ ",2,,4", "0,2,0,4" }, // Empty components should revert to 0s
{ "x,2,y,4", "0,2,0,4" }, // Non-numeric components should revert to 0s
{ ",2,", "0,0,0,0" }, // Non-vector4 csv should revert to Vector4.Zero
});
}
public static GuiWidget CreatePropertyEditor(EditableProperty property, UndoBuffer undoBuffer, PPEContext context, ThemeConfig theme)
{
var object3D = property.Item;
var propertyGridModifier = property.Item as IPropertyGridModifier;
GuiWidget rowContainer = null;
// Get reflected property value once, then test for each case below
var propertyValue = property.Value;
void RegisterValueChanged(UIField field, Func <string, object> valueFromString, Func <object, string> valueToString = null)
{
field.ValueChanged += (s, e) =>
{
var newValue = field.Value;
var oldValue = property.Value.ToString();
if (valueToString != null)
{
oldValue = valueToString(property.Value);
}
// field.Content
if (undoBuffer != null)
{
undoBuffer.AddAndDo(new UndoRedoActions(() =>
{
property.SetValue(valueFromString(oldValue));
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
},
() =>
{
property.SetValue(valueFromString(newValue));
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
}));
}
else
{
property.SetValue(valueFromString(newValue));
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
}
};
}
var readOnly = property.PropertyInfo.GetCustomAttributes(true).OfType <ReadOnlyAttribute>().FirstOrDefault() != null;
// create a double editor
if (propertyValue is double doubleValue)
{
if (readOnly)
{
var valueField = new TextWidget(string.Format("{0:n}", doubleValue), textColor: theme.TextColor, pointSize: 10)
{
AutoExpandBoundsToText = true
};
rowContainer = new SettingsRow(property.DisplayName.Localize(),
property.Description,
valueField,
theme);
void RefreshField(object s, InvalidateArgs e)
{
if (e.InvalidateType.HasFlag(InvalidateType.DisplayValues))
{
double newValue = (double)property.Value;
valueField.Text = string.Format("{0:n}", newValue);
}
}
object3D.Invalidated += RefreshField;
valueField.Closed += (s, e) => object3D.Invalidated -= RefreshField;
}
else // normal edit row
{
var field = new DoubleField(theme);
field.Initialize(0);
field.DoubleValue = doubleValue;
field.ClearUndoHistory();
RegisterValueChanged(field, (valueString) => { return(double.Parse(valueString)); });
void RefreshField(object s, InvalidateArgs e)
{
if (e.InvalidateType.HasFlag(InvalidateType.DisplayValues))
{
double newValue = (double)property.Value;
if (newValue != field.DoubleValue)
{
field.DoubleValue = newValue;
}
}
}
object3D.Invalidated += RefreshField;
field.Content.Descendants <InternalTextEditWidget>().First().Name = property.DisplayName + " Edit";
field.Content.Closed += (s, e) => object3D.Invalidated -= RefreshField;
if (property.PropertyInfo.GetCustomAttributes(true).OfType <MaxDecimalPlacesAttribute>().FirstOrDefault() is MaxDecimalPlacesAttribute decimalPlaces)
{
field.Content.Descendants <InternalNumberEdit>().First().MaxDecimalsPlaces = decimalPlaces.Number;
}
rowContainer = CreateSettingsRow(property, field, theme);
}
}
else if (propertyValue is Color color)
{
var field = new ColorField(theme, object3D.Color);
field.Initialize(0);
field.ValueChanged += (s, e) =>
{
property.SetValue(field.Color);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field, theme);
}
else if (propertyValue is Vector2 vector2)
{
var field = new Vector2Field(theme);
field.Initialize(0);
field.Vector2 = vector2;
field.ClearUndoHistory();
RegisterValueChanged(field,
(valueString) => Vector2.Parse(valueString),
(value) =>
{
var s = ((Vector2)value).ToString();
return(s.Substring(1, s.Length - 2));
});
rowContainer = CreateSettingsColumn(property, field);
}
else if (propertyValue is Vector3 vector3)
{
var field = new Vector3Field(theme);
field.Initialize(0);
field.Vector3 = vector3;
field.ClearUndoHistory();
RegisterValueChanged(
field,
(valueString) => Vector3.Parse(valueString),
(value) =>
{
var s = ((Vector3)value).ToString();
return(s.Substring(1, s.Length - 2));
});
rowContainer = CreateSettingsColumn(property, field);
}
else if (propertyValue is Vector4 vector4)
{
var field = new Vector4Field(theme);
if (property.PropertyInfo.GetCustomAttributes(true).OfType <VectorFieldLabelsAttribute>().FirstOrDefault() is VectorFieldLabelsAttribute vectorFieldLabels)
{
field.Labels = vectorFieldLabels.Labels;
}
field.Initialize(0);
field.Vector4 = vector4;
field.ClearUndoHistory();
RegisterValueChanged(
field,
(valueString) => Vector4.Parse(valueString),
(value) =>
{
var s = ((Vector4)value).ToString();
return(s.Substring(1, s.Length - 2));
});
rowContainer = CreateSettingsColumn(property, field);
}
else if (propertyValue is DirectionVector directionVector)
{
var field = new DirectionVectorField(theme);
field.Initialize(0);
field.SetValue(directionVector);
field.ClearUndoHistory();
field.ValueChanged += (s, e) =>
{
property.SetValue(field.DirectionVector);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field, theme);
}
else if (propertyValue is DirectionAxis directionAxis)
{
rowContainer = CreateSettingsColumn(property);
var field1 = new DirectionVectorField(theme);
field1.Initialize(0);
field1.ClearUndoHistory();
field1.SetValue(new DirectionVector()
{
Normal = directionAxis.Normal
});
rowContainer.AddChild(new SettingsRow("Axis".Localize(), null, field1.Content, theme));
// the direction axis
// the distance from the center of the part
// create a double editor
var field2 = new Vector3Field(theme);
field2.Initialize(0);
field2.Vector3 = directionAxis.Origin - property.Item.Children.First().GetAxisAlignedBoundingBox().Center;
field2.ClearUndoHistory();
var row2 = CreateSettingsColumn("Offset".Localize(), field2);
// update this when changed
void UpdateData(object s, InvalidateArgs e)
{
field2.Vector3 = ((DirectionAxis)property.Value).Origin - property.Item.Children.First().GetAxisAlignedBoundingBox().Center;
}
property.Item.Invalidated += UpdateData;
field2.Content.Closed += (s, e) =>
{
property.Item.Invalidated -= UpdateData;
};
// update functions
field1.ValueChanged += (s, e) =>
{
property.SetValue(new DirectionAxis()
{
Normal = field1.DirectionVector.Normal,
Origin = property.Item.Children.First().GetAxisAlignedBoundingBox().Center + field2.Vector3
});
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
field2.ValueChanged += (s, e) =>
{
property.SetValue(new DirectionAxis()
{
Normal = field1.DirectionVector.Normal,
Origin = property.Item.Children.First().GetAxisAlignedBoundingBox().Center + field2.Vector3
});
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer.AddChild(row2);
}
else if (propertyValue is SelectedChildren childSelector)
{
if (property.PropertyInfo.GetCustomAttributes(true).OfType <ShowAsListAttribute>().FirstOrDefault() is ShowAsListAttribute showAsList)
{
UIField field = new ChildrenSelectorListField(property, theme);
field.Initialize(0);
RegisterValueChanged(field,
(valueString) =>
{
var childrenSelector = new SelectedChildren();
foreach (var child in valueString.Split(','))
{
childrenSelector.Add(child);
}
return(childrenSelector);
});
rowContainer = CreateSettingsRow(property, field, theme);
}
else // show the subtract editor for boolean subtract and subtract and replace
{
rowContainer = CreateSettingsColumn(property);
if (property.Item is OperationSourceContainerObject3D sourceContainer)
{
Action selected = null;
if (!(context.item.GetType().GetCustomAttributes(typeof(ShowUpdateButtonAttribute), true).FirstOrDefault() is ShowUpdateButtonAttribute showUpdate))
{
selected = () =>
{
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
};
}
rowContainer.AddChild(CreateSourceChildSelector(childSelector, sourceContainer, theme, selected));
}
else
{
rowContainer.AddChild(CreateSelector(childSelector, property.Item, theme));
}
}
}
else if (propertyValue is ImageBuffer imageBuffer)
{
rowContainer = CreateSettingsColumn(property);
rowContainer.AddChild(new ImageWidget(imageBuffer)
{
HAnchor = HAnchor.Left,
Margin = new BorderDouble(0, 3)
});
}
#if !__ANDROID__
else if (propertyValue is List <string> stringList)
{
var field = new SurfacedEditorsField(theme, property.Item);
field.Initialize(0);
field.ListValue = stringList;
field.ValueChanged += (s, e) =>
{
property.SetValue(field.ListValue);
};
rowContainer = CreateSettingsColumn(property, field);
rowContainer.Descendants <HorizontalSpacer>().FirstOrDefault()?.Close();
}
#endif
// create a int editor
else if (propertyValue is int intValue)
{
if (readOnly)
{
var valueField = new TextWidget(string.Format("{0:n0}", intValue),
textColor: theme.TextColor,
pointSize: 10)
{
AutoExpandBoundsToText = true
};
rowContainer = new SettingsRow(property.DisplayName.Localize(),
property.Description,
valueField,
theme);
void RefreshField(object s, InvalidateArgs e)
{
if (e.InvalidateType.HasFlag(InvalidateType.DisplayValues))
{
int newValue = (int)property.Value;
valueField.Text = string.Format("{0:n0}", newValue);
}
}
object3D.Invalidated += RefreshField;
valueField.Closed += (s, e) => object3D.Invalidated -= RefreshField;
}
else // normal edit row
{
var field = new IntField(theme);
field.Initialize(0);
field.IntValue = intValue;
field.ClearUndoHistory();
RegisterValueChanged(field, (valueString) => { return(int.Parse(valueString)); });
void RefreshField(object s, InvalidateArgs e)
{
if (e.InvalidateType.HasFlag(InvalidateType.DisplayValues))
{
int newValue = (int)property.Value;
if (newValue != field.IntValue)
{
field.IntValue = newValue;
}
}
}
object3D.Invalidated += RefreshField;
field.Content.Closed += (s, e) => object3D.Invalidated -= RefreshField;
rowContainer = CreateSettingsRow(property, field, theme);
}
}
else if (propertyValue is bool boolValue)
{
// create a bool editor
var field = new ToggleboxField(theme);
field.Initialize(0);
field.Checked = boolValue;
RegisterValueChanged(field,
(valueString) => { return(valueString == "1"); },
(value) => { return(((bool)value) ? "1" : "0"); });
rowContainer = CreateSettingsRow(property, field, theme);
}
else if (propertyValue is string stringValue)
{
if (readOnly)
{
rowContainer = new WrappedTextWidget(stringValue,
textColor: theme.TextColor,
pointSize: 10)
{
Margin = 5
};
}
else // normal edit row
{
var multiLineEditAttribute = property.PropertyInfo.GetCustomAttributes(true).OfType <MultiLineEditAttribute>().FirstOrDefault();
if (multiLineEditAttribute != null)
{
// create a a multi-line string editor
var field = new MultilineStringField(theme);
field.Initialize(0);
field.SetValue(stringValue, false);
field.ClearUndoHistory();
field.Content.HAnchor = HAnchor.Stretch;
// field.Content.MinimumSize = new Vector2(0, 200 * GuiWidget.DeviceScale);
RegisterValueChanged(field, (valueString) => valueString);
rowContainer = CreateSettingsColumn(property, field, fullWidth: true);
}
else
{
// create a string editor
var field = new TextField(theme);
field.Initialize(0);
field.SetValue(stringValue, false);
field.ClearUndoHistory();
field.Content.HAnchor = HAnchor.Stretch;
RegisterValueChanged(field, (valueString) => valueString);
rowContainer = CreateSettingsRow(property, field, theme);
var label = rowContainer.Children.First();
var spacer = rowContainer.Children.OfType <HorizontalSpacer>().FirstOrDefault();
spacer.HAnchor = HAnchor.Absolute;
spacer.Width = Math.Max(0, 100 - label.Width);
}
}
}
else if (propertyValue is char charValue)
{
// create a char editor
var field = new CharField(theme);
field.Initialize(0);
field.SetValue(charValue.ToString(), false);
field.ClearUndoHistory();
field.ValueChanged += (s, e) =>
{
property.SetValue(Convert.ToChar(field.Value));
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field, theme);
}
else if (property.PropertyType.IsEnum)
{
// create an enum editor
UIField field;
var enumDisplayAttribute = property.PropertyInfo.GetCustomAttributes(true).OfType <EnumDisplayAttribute>().FirstOrDefault();
var addToSettingsRow = true;
if (enumDisplayAttribute != null)
{
field = new EnumDisplayField(property, enumDisplayAttribute, theme)
{
InitialValue = propertyValue.ToString(),
};
if (enumDisplayAttribute.Mode == EnumDisplayAttribute.PresentationMode.Tabs)
{
addToSettingsRow = false;
}
}
else
{
if (property.PropertyType == typeof(NamedTypeFace))
{
field = new FontSelectorField(property, theme);
}
else
{
field = new EnumField(property, theme);
}
}
field.Initialize(0);
RegisterValueChanged(field,
(valueString) =>
{
return(Enum.Parse(property.PropertyType, valueString));
});
field.ValueChanged += (s, e) =>
{
if (property.Value.ToString() != field.Value)
{
property.SetValue(Enum.Parse(property.PropertyType, field.Value));
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
}
};
if (addToSettingsRow)
{
rowContainer = CreateSettingsRow(property, field, theme);
}
else
{
// field.Content.Margin = new BorderDouble(3, 0);
field.Content.HAnchor = HAnchor.Stretch;
rowContainer = field.Content;
}
}
else if (propertyValue is IObject3D item &&
ApplicationController.Instance.Extensions.GetEditorsForType(property.PropertyType)?.FirstOrDefault() is IObject3DEditor iObject3DEditor)
{
// Use known IObject3D editors
rowContainer = iObject3DEditor.Create(item, undoBuffer, theme);
}
// remember the row name and widget
context.editRows.Add(property.PropertyInfo.Name, rowContainer);
return(rowContainer);
}
public override VisualElement CreatePropertyGUI(SerializedProperty property)
{
BindableElement newField = null;
if (property.propertyType == SerializedPropertyType.Float)
{
if (property.type == "float")
{
newField = new FloatField(property.displayName);
((BaseField <float>)newField).onValidateValue += OnValidateValue;
}
else if (property.type == "double")
{
newField = new DoubleField(property.displayName);
((BaseField <double>)newField).onValidateValue += OnValidateValue;
}
}
else if (property.propertyType == SerializedPropertyType.Integer)
{
if (property.type == "int")
{
newField = new IntegerField(property.displayName);
((BaseField <int>)newField).onValidateValue += OnValidateValue;
}
else if (property.type == "long")
{
newField = new LongField(property.displayName);
((BaseField <long>)newField).onValidateValue += OnValidateValue;
}
}
else if (property.propertyType == SerializedPropertyType.Vector2)
{
newField = new Vector2Field(property.displayName);
((BaseField <Vector2>)newField).onValidateValue += OnValidateValue;
}
else if (property.propertyType == SerializedPropertyType.Vector2Int)
{
newField = new Vector2IntField(property.displayName);
((BaseField <Vector2Int>)newField).onValidateValue += OnValidateValue;
}
else if (property.propertyType == SerializedPropertyType.Vector3)
{
newField = new Vector3Field(property.displayName);
((BaseField <Vector3>)newField).onValidateValue += OnValidateValue;
}
else if (property.propertyType == SerializedPropertyType.Vector3Int)
{
newField = new Vector3IntField(property.displayName);
((BaseField <Vector3Int>)newField).onValidateValue += OnValidateValue;
}
else if (property.propertyType == SerializedPropertyType.Vector4)
{
newField = new Vector4Field(property.displayName);
((BaseField <Vector4>)newField).onValidateValue += OnValidateValue;
}
if (newField != null)
{
newField.bindingPath = property.propertyPath;
return(newField);
}
return(new Label(s_InvalidTypeMessage));
}
public BlackboardFieldPropertyView(AbstractMaterialGraph graph, IShaderProperty property)
{
AddStyleSheetPath("Styles/ShaderGraphBlackboard");
m_Graph = graph;
m_Property = property;
m_ExposedToogle = new Toggle(() =>
{
property.generatePropertyBlock = m_ExposedToogle.value;
DirtyNodes(ModificationScope.Graph);
});
m_ExposedToogle.value = property.generatePropertyBlock;
AddRow("Exposed", m_ExposedToogle);
m_ReferenceNameField = new TextField(512, false, false, ' ');
m_ReferenceNameField.AddStyleSheetPath("Styles/PropertyNameReferenceField");
AddRow("Reference", m_ReferenceNameField);
m_ReferenceNameField.value = property.referenceName;
m_ReferenceNameField.isDelayed = true;
m_ReferenceNameField.OnValueChanged(newName =>
{
string newReferenceName = m_Graph.SanitizePropertyReferenceName(newName.newValue, property.guid);
property.overrideReferenceName = newReferenceName;
m_ReferenceNameField.value = property.referenceName;
if (string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.RemoveFromClassList("modified");
}
else
{
m_ReferenceNameField.AddToClassList("modified");
}
DirtyNodes(ModificationScope.Graph);
UpdateReferenceNameResetMenu();
});
if (!string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.AddToClassList("modified");
}
if (property is Vector1ShaderProperty)
{
VisualElement floatRow = new VisualElement();
VisualElement intRow = new VisualElement();
VisualElement modeRow = new VisualElement();
VisualElement minRow = new VisualElement();
VisualElement maxRow = new VisualElement();
FloatField floatField = null;
var floatProperty = (Vector1ShaderProperty)property;
if (floatProperty.floatType == FloatType.Integer)
{
var field = new IntegerField {
value = (int)floatProperty.value
};
field.OnValueChanged(intEvt =>
{
floatProperty.value = (float)intEvt.newValue;
DirtyNodes();
});
intRow = AddRow("Default", field);
}
else
{
floatField = new FloatField {
value = floatProperty.value
};
floatField.OnValueChanged(evt =>
{
floatProperty.value = (float)evt.newValue;
DirtyNodes();
});
floatRow = AddRow("Default", floatField);
}
var floatModeField = new EnumField((Enum)floatProperty.floatType);
floatModeField.value = floatProperty.floatType;
floatModeField.OnValueChanged(evt =>
{
if (floatProperty.floatType == (FloatType)evt.newValue)
{
return;
}
floatProperty = (Vector1ShaderProperty)property;
floatProperty.floatType = (FloatType)evt.newValue;
switch (floatProperty.floatType)
{
case FloatType.Slider:
RemoveElements(new VisualElement[] { floatRow, intRow, modeRow, minRow, maxRow });
var field = new FloatField {
value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x)
};
floatProperty.value = (float)field.value;
field.OnValueChanged(defaultEvt =>
{
floatProperty.value = Mathf.Max(Mathf.Min((float)defaultEvt.newValue, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
field.value = floatProperty.value;
DirtyNodes();
});
floatRow = AddRow("Default", field);
field.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
modeRow = AddRow("Mode", floatModeField);
var minField = new FloatField {
value = floatProperty.rangeValues.x
};
minField.OnValueChanged(minEvt =>
{
floatProperty.rangeValues = new Vector2((float)minEvt.newValue, floatProperty.rangeValues.y);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
field.value = floatProperty.value;
DirtyNodes();
});
minRow = AddRow("Min", minField);
var maxField = new FloatField {
value = floatProperty.rangeValues.y
};
maxField.OnValueChanged(maxEvt =>
{
floatProperty.rangeValues = new Vector2(floatProperty.rangeValues.x, (float)maxEvt.newValue);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
field.value = floatProperty.value;
DirtyNodes();
});
maxRow = AddRow("Max", maxField);
break;
case FloatType.Integer:
RemoveElements(new VisualElement[] { floatRow, intRow, modeRow, minRow, maxRow });
var intField = new IntegerField {
value = (int)floatProperty.value
};
intField.OnValueChanged(intEvt =>
{
floatProperty.value = (float)intEvt.newValue;
DirtyNodes();
});
intRow = AddRow("Default", intField);
modeRow = AddRow("Mode", floatModeField);
break;
default:
RemoveElements(new VisualElement[] { floatRow, intRow, modeRow, minRow, maxRow });
field = new FloatField {
value = floatProperty.value
};
field.OnValueChanged(defaultEvt =>
{
floatProperty.value = (float)defaultEvt.newValue;
DirtyNodes();
});
floatRow = AddRow("Default", field);
modeRow = AddRow("Mode", floatModeField);
break;
}
DirtyNodes();
});
modeRow = AddRow("Mode", floatModeField);
if (floatProperty.floatType == FloatType.Slider)
{
var minField = new FloatField {
value = floatProperty.rangeValues.x
};
minField.OnValueChanged(minEvt =>
{
floatProperty.rangeValues = new Vector2((float)minEvt.newValue, floatProperty.rangeValues.y);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
floatField.value = floatProperty.value;
DirtyNodes();
});
minRow = AddRow("Min", minField);
var maxField = new FloatField {
value = floatProperty.rangeValues.y
};
maxField.OnValueChanged(maxEvt =>
{
floatProperty.rangeValues = new Vector2(floatProperty.rangeValues.x, (float)maxEvt.newValue);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
floatField.value = floatProperty.value;
DirtyNodes();
});
maxRow = AddRow("Max", maxField);
}
}
else if (property is Vector2ShaderProperty)
{
var vectorProperty = (Vector2ShaderProperty)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector3ShaderProperty)
{
var vectorProperty = (Vector3ShaderProperty)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector4ShaderProperty)
{
var vectorProperty = (Vector4ShaderProperty)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ColorShaderProperty)
{
var colorProperty = (ColorShaderProperty)property;
var colorField = new ColorField {
value = property.defaultValue, showEyeDropper = false, hdr = colorProperty.colorMode == ColorMode.HDR
};
colorField.OnValueChanged(evt =>
{
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", colorField);
var colorModeField = new EnumField((Enum)colorProperty.colorMode);
colorModeField.OnValueChanged(evt =>
{
if (colorProperty.colorMode == (ColorMode)evt.newValue)
{
return;
}
colorProperty.colorMode = (ColorMode)evt.newValue;
colorField.hdr = colorProperty.colorMode == ColorMode.HDR;
colorField.MarkDirtyRepaint();
DirtyNodes();
});
AddRow("Mode", colorModeField);
}
else if (property is TextureShaderProperty)
{
var textureProperty = (TextureShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture)
};
field.OnValueChanged(evt =>
{
textureProperty.value.texture = (Texture)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Texture2DArrayShaderProperty)
{
var textureProperty = (Texture2DArrayShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.textureArray, objectType = typeof(Texture2DArray)
};
field.OnValueChanged(evt =>
{
textureProperty.value.textureArray = (Texture2DArray)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Texture3DShaderProperty)
{
var textureProperty = (Texture3DShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture3D)
};
field.OnValueChanged(evt =>
{
textureProperty.value.texture = (Texture3D)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is CubemapShaderProperty)
{
var cubemapProperty = (CubemapShaderProperty)property;
var field = new ObjectField {
value = cubemapProperty.value.cubemap, objectType = typeof(Cubemap)
};
field.OnValueChanged(evt =>
{
cubemapProperty.value.cubemap = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is BooleanShaderProperty)
{
var booleanProperty = (BooleanShaderProperty)property;
Action onBooleanChanged = () =>
{
booleanProperty.value = !booleanProperty.value;
DirtyNodes();
};
var field = new Toggle(onBooleanChanged);
field.SetValue(booleanProperty.value);
AddRow("Default", field);
}
// AddRow("Type", new TextField());
// AddRow("Exposed", new Toggle(null));
// AddRow("Range", new Toggle(null));
// AddRow("Default", new TextField());
// AddRow("Tooltip", new TextField());
AddToClassList("sgblackboardFieldPropertyView");
UpdateReferenceNameResetMenu();
}
void BuildMatrix4PropertyField(Matrix4ShaderProperty property)
{
var row0Field = new Vector4Field {
value = property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row1 = property.value.GetRow(1);
Vector4 row2 = property.value.GetRow(2);
Vector4 row3 = property.value.GetRow(3);
property.value = new Matrix4x4()
{
m00 = evt.newValue.x,
m01 = evt.newValue.y,
m02 = evt.newValue.z,
m03 = evt.newValue.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("Default", row0Field);
var row1Field = new Vector4Field {
value = property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = property.value.GetRow(0);
Vector4 row2 = property.value.GetRow(2);
Vector4 row3 = property.value.GetRow(3);
property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = evt.newValue.x,
m11 = evt.newValue.y,
m12 = evt.newValue.z,
m13 = evt.newValue.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("", row1Field);
var row2Field = new Vector4Field {
value = property.value.GetRow(2)
};
row2Field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = property.value.GetRow(0);
Vector4 row1 = property.value.GetRow(1);
Vector4 row3 = property.value.GetRow(3);
property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = evt.newValue.x,
m21 = evt.newValue.y,
m22 = evt.newValue.z,
m23 = evt.newValue.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("", row2Field);
var row3Field = new Vector4Field {
value = property.value.GetRow(3)
};
row3Field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = property.value.GetRow(0);
Vector4 row1 = property.value.GetRow(1);
Vector4 row2 = property.value.GetRow(2);
property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = evt.newValue.x,
m31 = evt.newValue.y,
m32 = evt.newValue.z,
m33 = evt.newValue.w,
};
DirtyNodes();
});
AddRow("", row3Field);
}
public BlackboardFieldPropertyView(AbstractNodeGraph graph, INodeProperty property)
{
styleSheets.Add(Resources.Load <StyleSheet>("Styles/NodeGraphBlackboard"));
m_Graph = graph;
m_Reference = new TextField();
m_Reference.RegisterValueChangedCallback(evt =>
{
property.reference = evt.newValue;
DirtyNodes(ModificationScope.Graph);
});
m_Reference.value = property.reference;
AddRow("Reference", m_Reference);
if (property is ValueProperty <float> )
{
var floatProperty = (ValueProperty <float>)property;
FloatField floatField = new FloatField {
value = floatProperty.value
};
floatField.RegisterValueChangedCallback(evt =>
{
floatProperty.value = (float)evt.newValue;
DirtyNodes();
});
AddRow("Default", floatField);
/*if (floatProperty.floatType == FloatType.Slider)
* {
* var minField = new FloatField { value = floatProperty.rangeValues.x };
* minField.OnValueChanged(minEvt =>
* {
* floatProperty.rangeValues = new Vector2((float)minEvt.newValue, floatProperty.rangeValues.y);
* floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
* floatField.value = floatProperty.value;
* DirtyNodes();
* });
* minRow = AddRow("Min", minField);
* var maxField = new FloatField { value = floatProperty.rangeValues.y };
* maxField.OnValueChanged(maxEvt =>
* {
* floatProperty.rangeValues = new Vector2(floatProperty.rangeValues.x, (float)maxEvt.newValue);
* floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
* floatField.value = floatProperty.value;
* DirtyNodes();
* });
* maxRow = AddRow("Max", maxField);
* }*/
}
else if (property is ValueProperty <int> )
{
var intProperty = (ValueProperty <int>)property;
var field = new IntegerField {
value = intProperty.value
};
field.RegisterValueChangedCallback(intEvt =>
{
intProperty.value = intEvt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Vector2> )
{
var vectorProperty = (ValueProperty <Vector2>)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Vector3> )
{
var vectorProperty = (ValueProperty <Vector3>)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Vector4> )
{
var vectorProperty = (ValueProperty <Vector4>)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Color> )
{
var colorProperty = (ValueProperty <Color>)property;
//todo add HDR
var colorField = new ColorField {
value = (Color)property.defaultValue, showEyeDropper = false
};
colorField.RegisterValueChangedCallback(evt =>
{
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", colorField);
}
else if (property is ValueProperty <Texture2D> )
{
var textureProperty = (ValueProperty <Texture2D>)property;
var field = new ObjectField {
value = textureProperty.value, objectType = typeof(Texture2D)
};
field.RegisterValueChangedCallback(evt =>
{
textureProperty.value = (Texture2D)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Cubemap> )
{
var cubemapProperty = (ValueProperty <Cubemap>)property;
var field = new ObjectField {
value = cubemapProperty.value, objectType = typeof(Cubemap)
};
field.RegisterValueChangedCallback(evt =>
{
cubemapProperty.value = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <bool> )
{
var booleanProperty = (ValueProperty <bool>)property;
EventCallback <ChangeEvent <bool> > onBooleanChanged = evt =>
{
booleanProperty.value = evt.newValue;
DirtyNodes();
};
var field = new Toggle();
field.RegisterValueChangedCallback(onBooleanChanged);
field.value = booleanProperty.value;
AddRow("Default", field);
}
// AddRow("Type", new TextField());
// AddRow("Exposed", new Toggle(null));
// AddRow("Range", new Toggle(null));
// AddRow("Default", new TextField());
// AddRow("Tooltip", new TextField());
AddToClassList("sgblackboardFieldPropertyView");
}
public void Initialize()
{
if (FieldInfo != null)
{
var methodInfo = this.GetType().GetMethod("RegisterCallbackInternal", BindingFlags.NonPublic | BindingFlags.Instance);
var method = methodInfo.MakeGenericMethod(m_fieldInfo.FieldType);
VisualElement visualElement = null;
bool failed = false;
Type type = m_fieldInfo.FieldType;
TitleAttribute titleAttrib = m_fieldInfo.GetCustomAttribute <TitleAttribute>();
string fieldName = "";
if (titleAttrib != null)
{
fieldName = titleAttrib.Title;
}
else
{
fieldName = m_fieldInfo.Name;
}
if (type == typeof(float))
{
visualElement = new FloatField(fieldName);
}
else if (type == typeof(int))
{
visualElement = new IntegerField(fieldName);
}
else if (type == typeof(string))
{
visualElement = new TextField(fieldName);
}
else if (type == typeof(bool))
{
visualElement = new Toggle(fieldName);
}
else if (type == typeof(AnimationCurve))
{
visualElement = new CurveField(fieldName);
}
else if (type == typeof(Vector2))
{
visualElement = new Vector2Field(fieldName);
}
else if (type == typeof(Vector3))
{
visualElement = new Vector3Field(fieldName);
}
else if (type == typeof(Vector4))
{
visualElement = new Vector4Field(fieldName);
}
else if (type == typeof(Color))
{
visualElement = new ColorField(fieldName);
}
else if (type == typeof(Enum))
{
visualElement = new EnumField(fieldName);
}
else
{
failed = true;
visualElement = new ErrorText("Unsupported Field: " + FieldInfo.Name + ":" + type.Name);
visualElement.name = "error-text";
}
if (!failed)
{
var baseFieldType = typeof(BaseField <>).MakeGenericType(type);
PropertyInfo info = baseFieldType.GetProperty("value");
info.SetValue(visualElement, m_fieldInfo.GetValue(m_fieldOwner));
method?.Invoke(this, new object[] { visualElement });
}
this.Add(visualElement);
}
}
void ResetToInitialSceneValues()
{
VisualElement root = rootVisualElement;
VisualElement SkyGradientVE = root.Q <VisualElement>(name: "SkyGradient");
if (SkyGradientVE != null)
{
SkyGradientVE.Q <GradientField>().value = initialSceneValues.SkyGradient;
}
VisualElement RuinsGradientVE = root.Q <VisualElement>(name: "RuinsGradient");
if (RuinsGradientVE != null)
{
RuinsGradientVE.Q <GradientField>().value = initialSceneValues.RuinsGradient;
}
VisualElement TreesGradientVE = root.Q <VisualElement>(name: "TreesGradient");
if (TreesGradientVE != null)
{
TreesGradientVE.Q <GradientField>().value = initialSceneValues.TreesGradient;
}
VisualElement RimColorVE = root.Q <VisualElement>(name: "RimColor");
if (RimColorVE != null)
{
RimColorVE.Q <GradientField>().value = initialSceneValues.RimGradient;
}
VisualElement SunlightVE = root.Q <VisualElement>(name: "Sunlight");
if (SunlightVE != null)
{
if (SunlightVE.Q <VisualElement>(name: "LightGradient") != null)
{
SunlightVE.Q <VisualElement>(name: "LightGradient").Q <GradientField>().value = initialSceneValues.SunlightGradient;
}
SunlightVE.Q <FloatField>(name: "Intensity").value = initialSceneValues.SunlightIntencity;
}
VisualElement GrassLightVE = root.Q <VisualElement>(name: "GrassLight");
if (GrassLightVE != null)
{
if (GrassLightVE.Q <VisualElement>(name: "LightGradient") != null)
{
GrassLightVE.Q <VisualElement>(name: "LightGradient").Q <GradientField>().value = initialSceneValues.GrassLightGradient;
}
GrassLightVE.Q <FloatField>(name: "Intensity").value = initialSceneValues.GrassLightIntensity;
}
VisualElement CaveHoleLightVE = root.Q <VisualElement>(name: "CaveHoleLight");
if (CaveHoleLightVE != null)
{
CaveHoleLightVE.Q <FloatField>(name: "Falloff").value = initialSceneValues.FalloffCaveHole;
CaveHoleLightVE.Q <Slider>(name: "FalloffIntencity").value = initialSceneValues.FalloffIntensityCaveHole;
CaveHoleLightVE.Q <VisualElement>(name: "FalloffIntencity").Q <FloatField>(name: "CurrentValue").value = initialSceneValues.FalloffIntensityCaveHole;
}
VisualElement WindVE = root.Q <VisualElement>(name: "Wind");
if (WindVE != null)
{
Vector4Field WindDirection = WindVE.Q <Vector4Field>(name: "WindDirection");
if (WindDirection != null)
{
WindDirection.value = initialSceneValues.WindDirection;
}
FloatField WindScale = WindVE.Q <FloatField>(name: "WindScale");
if (WindScale != null)
{
WindScale.value = initialSceneValues.WindScale;
}
MinMaxSlider WindStrength = WindVE.Q <MinMaxSlider>(name: "WindStrength");
if (WindStrength != null)
{
WindStrength.minValue = initialSceneValues.WindStrength.minValue;
WindStrength.maxValue = initialSceneValues.WindStrength.maxValue;
}
VisualElement WinStrengthHolder = WindVE.Q <VisualElement>(name: "WinStrengthHolder");
if (WinStrengthHolder != null)
{
WinStrengthHolder.Q <Label>(name: "MinValue").text = "Min Value :" + initialSceneValues.WindStrength.minValue;
WinStrengthHolder.Q <Label>(name: "MaxValue").text = "Max Value :" + initialSceneValues.WindStrength.maxValue;
}
FloatField WindSpeed = WindVE.Q <FloatField>(name: "WindSpeed");
if (WindSpeed != null)
{
WindSpeed.value = initialSceneValues.WindSpeed;
}
}
VisualElement WhiteBalanceVE = root.Q <VisualElement>(name: "WhiteBalance");
if (WhiteBalanceVE != null)
{
VisualElement whiteBalanceTemperature = WhiteBalanceVE.Q <VisualElement>(name: "Temperature");
whiteBalanceTemperature.Q <Slider>(name: "SliderValue").value = initialSceneValues.WhiteBalanceTemperature;
whiteBalanceTemperature.Q <FloatField>(name: "CurrentValue").value = initialSceneValues.WhiteBalanceTemperature;
VisualElement whiteBalanceTint = WhiteBalanceVE.Q <VisualElement>(name: "Tint");
whiteBalanceTint.Q <Slider>(name: "SliderValue").value = initialSceneValues.WhiteBalanceTint;
whiteBalanceTint.Q <FloatField>(name: "CurrentValue").value = initialSceneValues.WhiteBalanceTint;
}
VisualElement BloomVE = root.Q <VisualElement>(name: "Bloom");
if (BloomVE != null)
{
BloomVE.Q <ColorField>(name: "Tint").value = initialSceneValues.BloomTint;
BloomVE.Q <FloatField>(name: "Intensity").value = initialSceneValues.BloomIntensity;
}
VisualElement VFXVisualElement = root.Q <VisualElement>(name: "VFX");
if (VFXVisualElement != null)
{
VFXVisualElement.Q <FloatField>(name: "Emission").value = initialSceneValues.GlowParticleEmission;
VFXVisualElement.Q <EnumField>(name: "RenderMode").Init(initialSceneValues.GlowParticlesRenderMode);
SetRenderMaterial(initialSceneValues.GlowParticleRenderMaterial);
}
}
public BlackboardFieldPropertyView(BlackboardField blackboardField, GraphData graph, AbstractShaderProperty property)
{
styleSheets.Add(Resources.Load <StyleSheet>("Styles/ShaderGraphBlackboard"));
m_BlackboardField = blackboardField;
m_Graph = graph;
m_Property = property;
m_ExposedToogle = new Toggle();
m_ExposedToogle.OnToggleChanged(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Exposed Toggle");
if (m_OnExposedToggle != null)
{
m_OnExposedToggle();
}
property.generatePropertyBlock = evt.newValue;
if (property.generatePropertyBlock)
{
m_BlackboardField.icon = BlackboardProvider.exposedIcon;
}
else
{
m_BlackboardField.icon = null;
}
DirtyNodes(ModificationScope.Graph);
});
m_ExposedToogle.value = property.generatePropertyBlock;
AddRow("Exposed", m_ExposedToogle);
m_ReferenceNameField = new TextField(512, false, false, ' ');
m_ReferenceNameField.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyNameReferenceField"));
AddRow("Reference", m_ReferenceNameField);
m_ReferenceNameField.value = property.referenceName;
m_ReferenceNameField.isDelayed = true;
m_ReferenceNameField.RegisterValueChangedCallback(newName =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change reference name");
if (m_ReferenceNameField.value != m_Property.referenceName)
{
string newReferenceName = m_Graph.SanitizePropertyReferenceName(newName.newValue, property.guid);
property.overrideReferenceName = newReferenceName;
}
m_ReferenceNameField.value = property.referenceName;
if (string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.RemoveFromClassList("modified");
}
else
{
m_ReferenceNameField.AddToClassList("modified");
}
DirtyNodes(ModificationScope.Graph);
UpdateReferenceNameResetMenu();
});
if (!string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.AddToClassList("modified");
}
if (property is Vector1ShaderProperty)
{
var floatProperty = (Vector1ShaderProperty)property;
BuildVector1PropertyView(floatProperty);
}
else if (property is Vector2ShaderProperty)
{
var vectorProperty = (Vector2ShaderProperty)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector3ShaderProperty)
{
var vectorProperty = (Vector3ShaderProperty)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector4ShaderProperty)
{
var vectorProperty = (Vector4ShaderProperty)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ColorShaderProperty)
{
var colorProperty = (ColorShaderProperty)property;
var colorField = new ColorField {
value = property.defaultValue, showEyeDropper = false, hdr = colorProperty.colorMode == ColorMode.HDR
};
colorField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", colorField);
var colorModeField = new EnumField((Enum)colorProperty.colorMode);
colorModeField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Color Mode");
if (colorProperty.colorMode == (ColorMode)evt.newValue)
{
return;
}
colorProperty.colorMode = (ColorMode)evt.newValue;
colorField.hdr = colorProperty.colorMode == ColorMode.HDR;
colorField.MarkDirtyRepaint();
DirtyNodes();
});
AddRow("Mode", colorModeField);
}
else if (property is TextureShaderProperty)
{
var textureProperty = (TextureShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.texture = (Texture)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
var defaultModeField = new EnumField((Enum)textureProperty.defaultType);
defaultModeField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Texture Mode");
if (textureProperty.defaultType == (TextureShaderProperty.DefaultType)evt.newValue)
{
return;
}
textureProperty.defaultType = (TextureShaderProperty.DefaultType)evt.newValue;
DirtyNodes(ModificationScope.Graph);
});
void ToggleDefaultModeFieldEnabled()
{
defaultModeField.SetEnabled(!defaultModeField.enabledSelf);
}
m_OnExposedToggle += ToggleDefaultModeFieldEnabled;
AddRow("Mode", defaultModeField);
}
else if (property is Texture2DArrayShaderProperty)
{
var textureProperty = (Texture2DArrayShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.textureArray, objectType = typeof(Texture2DArray)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.textureArray = (Texture2DArray)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Texture3DShaderProperty)
{
var textureProperty = (Texture3DShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture3D)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.texture = (Texture3D)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is CubemapShaderProperty)
{
var cubemapProperty = (CubemapShaderProperty)property;
var field = new ObjectField {
value = cubemapProperty.value.cubemap, objectType = typeof(Cubemap)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
cubemapProperty.value.cubemap = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is BooleanShaderProperty)
{
var booleanProperty = (BooleanShaderProperty)property;
EventCallback <ChangeEvent <bool> > onBooleanChanged = evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
booleanProperty.value = evt.newValue;
DirtyNodes();
};
var field = new Toggle();
field.OnToggleChanged(onBooleanChanged);
field.value = booleanProperty.value;
AddRow("Default", field);
}
// AddRow("Type", new TextField());
// AddRow("Exposed", new Toggle(null));
// AddRow("Range", new Toggle(null));
// AddRow("Default", new TextField());
// AddRow("Tooltip", new TextField());
AddToClassList("sgblackboardFieldPropertyView");
UpdateReferenceNameResetMenu();
}
void SetArtistTool()
{
VisualElement root = rootVisualElement;
root.Clear();
VisualTreeAsset ArtistToolVisualTree = Resources.Load <VisualTreeAsset>("ArtistTool");
ArtistToolVisualTree.CloneTree(root);
root.styleSheets.Add(Resources.Load <StyleSheet>("ArtistTool"));
SerializedObject Tso = new SerializedObject(TimeController);
Slider timeSlider = root.Q <Slider>(name: "Time");
timeSlider.Bind(Tso);
#region SkyColor
VisualElement gradientVisualElement = root.Q <VisualElement>(name: "SkyGradient");
if (gradientVisualElement != null)
{
GradientField gradientField = gradientVisualElement.Q <GradientField>();
if (gradientField != null)
{
skyColorSetter = GameObject.Find("Light - Sky").GetComponent <MaterialColorSetter>();
SerializedObject serialized_MaterialSetter = new SerializedObject(skyColorSetter);
gradientField.bindingPath = "gradient";
gradientField.Bind(serialized_MaterialSetter);
gradientVisualElement.Q <Label>().text = "Sky Gradient";
}
}
#endregion
#region Ruins
GradientEditorSetter("RuinsGradient", "Ruins Gradient", RuinsColorSetter);
#endregion
#region Trees
GradientEditorSetter("TreesGradient", "Trees Gradient", TreesColorSetter);
#endregion
#region Rim
GradientEditorSetter("RimColor", "Rim Gradient", RimColorSetter);
#endregion
#region Lights
#region SunLights
SerializedObject serialized_SunSpot = new SerializedObject(SunSpot_Group);
VisualElement sunLightVisualElement = root.Q <VisualElement>(name: "Sunlight");
if (sunLightVisualElement.Q <VisualElement>(name: "LightGradient") != null)
{
GradientField sunLightGradient = sunLightVisualElement.Q <VisualElement>(name: "LightGradient").Q <GradientField>();
FloatField sunLightIntensity = root.Q <FloatField>(name: "Intensity");
if (sunLightGradient != null)
{
sunLightGradient.bindingPath = "gradient";
sunLightGradient.Bind(serialized_SunSpot);
sunLightGradient.label = "Gradient";
}
sunLightIntensity.value = GetSpotLightIntensity();
sunLightIntensity.RegisterCallback <ChangeEvent <float> >(ChangeIntensitySpotLightsEvent);
}
#endregion
#region GrassLight
SerializedObject serialized_GrassLight_Group = new SerializedObject(GrassLight_Group);
VisualElement grassLightVisualElement = root.Q <VisualElement>(name: "GrassLight");
if (grassLightVisualElement.Q <VisualElement>(name: "LightGradient") != null)
{
GradientField grassLightGradient = grassLightVisualElement.Q <VisualElement>(name: "LightGradient").Q <GradientField>();
FloatField grassLightIntensity = grassLightVisualElement.Q <FloatField>(name: "Intensity");
if (grassLightGradient != null)
{
grassLightGradient.bindingPath = "gradient";
grassLightGradient.Bind(serialized_GrassLight_Group);
grassLightGradient.label = "Gradient";
}
grassLightIntensity.value = GrassLight.intensity;
SerializedObject serialized_GrassLight = new SerializedObject(GrassLight);
grassLightIntensity.Bind(serialized_GrassLight);
}
#endregion
#region cave Light
SerializedObject serialized_CaveHoleLight = new SerializedObject(CaveHoleLight);
VisualElement caveLightVisualElement = root.Q <VisualElement>(name: "CaveHoleLight");
caveLightVisualElement.Q <FloatField>(name: "Falloff").Bind(serialized_CaveHoleLight);
Slider fallOffSlider = caveLightVisualElement.Q <Slider>(name: "FalloffIntencity");
FloatField fallOffField = fallOffSlider.Q <FloatField>(name: "CurrentValue");
fallOffSlider.Bind(serialized_CaveHoleLight);
fallOffField.SetValueWithoutNotify(CaveHoleLight.falloffIntensity);
fallOffField.RegisterCallback <ChangeEvent <float> >((evt) => fallOffSlider.value = evt.newValue);
fallOffSlider.RegisterCallback <ChangeEvent <float> >((evt) => fallOffField.SetValueWithoutNotify(evt.newValue));
#endregion
#region Visualisers
var AllGradientElements = root.Query <GradientField>();
AllGradientElements.ForEach((element) =>
{
//registerCallback for Gradient to apply changes on scene
element.RegisterCallback <ChangeEvent <Gradient> >(ChangeGradientEvent);
VisualElement visualiser = element.Q <VisualElement>(name: "VisualisationColor");
//Init color of visualisation cube
float currentTime = TimeController.timeValue;
visualiser.style.backgroundColor = element.value.Evaluate(currentTime);
//register Callback for each visualisation cube when gradient Changes
element.RegisterCallback <ChangeEvent <Gradient> >((evt) =>
{
float timeOfChange = TimeController.timeValue;
visualiser.style.backgroundColor = evt.newValue.Evaluate(currentTime);
});
//register Callback for each visualisation cube when Time Changes
timeSlider.RegisterCallback <ChangeEvent <float> >((evt) =>
{
visualiser.style.backgroundColor = element.value.Evaluate(evt.newValue);
});
});
#endregion
#endregion
#region Wind Shader
// Set Initial Values
VisualElement windComponent = root.Q <VisualElement>(name: "Wind");
if (windComponent != null)
{
Vector4Field windDirectionQuaternion = windComponent.Q <Vector4Field>(name: "WindDirection");
windDirectionQuaternion.value = GetWindDirection();
FloatField windScaleFloat = windComponent.Q <FloatField>(name: "WindScale");
windScaleFloat.value = GetWindScale();
MinMaxValue minMaxStrength = GetWindStrength();
VisualElement windStrengthHolder = windComponent.Q <VisualElement>(name: "WinStrengthHolder");
MinMaxSlider windStrengthSlider = windStrengthHolder.Q <MinMaxSlider>(name: "WindStrength");
windStrengthSlider.highLimit = minMaxStrength.HighLimit;
windStrengthSlider.lowLimit = minMaxStrength.LowLimit;
windStrengthSlider.value = new Vector2(minMaxStrength.minValue, minMaxStrength.maxValue);
windStrengthHolder.Q <Label>(name: "MinValue").text = "Min Value :" + minMaxStrength.minValue;
windStrengthHolder.Q <Label>(name: "MaxValue").text = "Max Value :" + minMaxStrength.maxValue;
FloatField windSpeedFloat = windComponent.Q <FloatField>(name: "WindSpeed");
windSpeedFloat.value = GetWindSpeed();
//Set Callbacks values
windDirectionQuaternion.RegisterCallback <ChangeEvent <Vector4> >(ChangeWindDirection);
windScaleFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindScale);
windStrengthSlider.RegisterCallback <ChangeEvent <Vector2> >(ChangeWindStrength);
windSpeedFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindSpeed);
}
#endregion
#region Postprocessing
#region WhiteBalance
//serialize White balance property
SerializedObject serialized_whiteBalanceProperty = new SerializedObject(whiteBalanceProperty);
//Get White balance Visual Element
VisualElement whiteBalanceVisualElement = root.Q <VisualElement>(name: "WhiteBalance");
#region Temperature
//Get White Balance temperature Visual Element
VisualElement whiteBalanceTemperatureVE = whiteBalanceVisualElement.Q <VisualElement>(name: "Temperature");
//Get White Balance temperature Slider
Slider whiteBalanceTemperatureSlider = whiteBalanceTemperatureVE.Q <Slider>(name: "SliderValue");
//Bind Slider to value
whiteBalanceTemperatureSlider.bindingPath = "temperature.m_Value";
whiteBalanceTemperatureSlider.Bind(serialized_whiteBalanceProperty);
//Get White Balance temperature Float Field
FloatField whiteBalanceTemperatureFloat = whiteBalanceTemperatureVE.Q <FloatField>(name: "CurrentValue");
//Set default Temperature
whiteBalanceTemperatureFloat.SetValueWithoutNotify(whiteBalanceProperty.temperature.value);
//Register change callback for the float field to change the slider value. Changing slider value will change the values bound with it.
whiteBalanceTemperatureFloat.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTemperatureSlider.value = evt.newValue);
//Register change Callback for the slider, to change the float fiel Without notification (to avoid triggering Float field callback)
whiteBalanceTemperatureSlider.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTemperatureFloat.SetValueWithoutNotify(evt.newValue));
#endregion
#region Tint
//Get White Balance Tint Visual Element
VisualElement whiteBalanceTintVE = whiteBalanceVisualElement.Q <VisualElement>(name: "Tint");
//Get White Balance Tint Slider
Slider whiteBalanceTintSlider = whiteBalanceTintVE.Q <Slider>(name: "SliderValue");
//Bind Slider to value
whiteBalanceTintSlider.bindingPath = "tint.m_Value";
whiteBalanceTintSlider.Bind(serialized_whiteBalanceProperty);
//Get White Balance Tint Float Field
FloatField whiteBalanceTintFloat = whiteBalanceTintVE.Q <FloatField>(name: "CurrentValue");
//Set default Tint
whiteBalanceTintFloat.SetValueWithoutNotify(whiteBalanceProperty.tint.value);
//Register change callback for the float field to change the slider value. Changing slider value will change the values bound with it.
whiteBalanceTintFloat.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTintSlider.value = evt.newValue);
//Register change Callback for the slider, to change the float fiel Without notification (to avoid triggering Float field callback)
whiteBalanceTintSlider.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTintFloat.SetValueWithoutNotify(evt.newValue));
#endregion
#endregion
#region Bloom
//serialize bloom property
SerializedObject serialized_BloomProperty = new SerializedObject(BloomProperty);
//Get Bloom Visual Element
VisualElement bloomVisualElement = root.Q <VisualElement>(name: "Bloom");
//Get Bloom Tint Color
ColorField bloomTint = bloomVisualElement.Q <ColorField>(name: "Tint");
//Bind color to value
bloomTint.bindingPath = "tint.m_Value";
bloomTint.Bind(serialized_BloomProperty);
//Get Bloom Intensity
FloatField bloomIntensity = bloomVisualElement.Q <FloatField>(name: "Intensity");
//Bind Intensity to value
bloomIntensity.Bind(serialized_BloomProperty);
#endregion
#endregion
#region VFX
SerializedObject serialized_GlowParticleSystem = new SerializedObject(GlowParticleSystem);
VisualElement VFXVisualElement = root.Q <VisualElement>(name: "VFX");
VFXVisualElement.Q <FloatField>(name: "Emission").bindingPath = "EmissionModule.rateOverTime.scalar";
VFXVisualElement.Q <FloatField>(name: "Emission").Bind(serialized_GlowParticleSystem);
VFXVisualElement.Q <EnumField>(name: "RenderMode").Init(GlowParticleSystem.GetComponent <ParticleSystemRenderer>().renderMode);
VFXVisualElement.Q <EnumField>(name: "RenderMode").RegisterCallback <ChangeEvent <string> >(ChangeRenderMode);
VFXVisualElement.Q <ObjectField>(name: "Material").objectType = typeof(Material);
VFXVisualElement.Q <ObjectField>(name: "Material").RegisterCallback <ChangeEvent <string> >(ChangeRenderMaterial);
#endregion
root.Q <Button>(name: "SaveButton").clicked += SaveButton;
root.Q <Button>(name: "ResetButton").clicked += ResetToInitialSceneValues;
}
public BlackboardFieldPropertyView(BlackboardField blackboardField, GraphData graph, AbstractShaderProperty property)
{
styleSheets.Add(Resources.Load <StyleSheet>("Styles/ShaderGraphBlackboard"));
m_BlackboardField = blackboardField;
m_Graph = graph;
m_Property = property;
if (!m_Graph.isSubGraph)
{
if (property.isExposable)
{
m_ExposedToogle = new Toggle();
m_ExposedToogle.OnToggleChanged(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Exposed Toggle");
if (m_OnExposedToggle != null)
{
m_OnExposedToggle();
}
property.generatePropertyBlock = evt.newValue;
if (property.generatePropertyBlock)
{
m_BlackboardField.icon = BlackboardProvider.exposedIcon;
}
else
{
m_BlackboardField.icon = null;
}
DirtyNodes(ModificationScope.Graph);
});
m_ExposedToogle.value = property.generatePropertyBlock;
AddRow("Exposed", m_ExposedToogle);
}
if (property.isExposable)
{
m_ReferenceNameField = new TextField(512, false, false, ' ');
m_ReferenceNameField.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyNameReferenceField"));
AddRow("Reference", m_ReferenceNameField);
m_ReferenceNameField.value = property.referenceName;
m_ReferenceNameField.isDelayed = true;
m_ReferenceNameField.RegisterValueChangedCallback(newName =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Reference Name");
if (m_ReferenceNameField.value != m_Property.referenceName)
{
string newReferenceName = m_Graph.SanitizePropertyReferenceName(newName.newValue, property.guid);
property.overrideReferenceName = newReferenceName;
}
m_ReferenceNameField.value = property.referenceName;
if (string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.RemoveFromClassList("modified");
}
else
{
m_ReferenceNameField.AddToClassList("modified");
}
DirtyNodes(ModificationScope.Graph);
UpdateReferenceNameResetMenu();
});
if (!string.IsNullOrEmpty(property.overrideReferenceName))
{
m_ReferenceNameField.AddToClassList("modified");
}
}
}
// Key Undo callbacks for input fields
EventCallback <KeyDownEvent> keyDownCallback = new EventCallback <KeyDownEvent>(evt =>
{
// Record Undo for input field edit
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
// 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();
});
EventCallback <FocusOutEvent> focusOutCallback = new EventCallback <FocusOutEvent>(evt =>
{
// Reset UndoGroup when done editing input field
m_UndoGroup = -1;
});
if (property is Vector1ShaderProperty)
{
var floatProperty = (Vector1ShaderProperty)property;
BuildVector1PropertyView(floatProperty);
}
else if (property is Vector2ShaderProperty)
{
var vectorProperty = (Vector2ShaderProperty)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (m_UndoGroup == -1)
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector3ShaderProperty)
{
var vectorProperty = (Vector3ShaderProperty)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (m_UndoGroup == -1)
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector4ShaderProperty)
{
var vectorProperty = (Vector4ShaderProperty)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-x-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-y-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-z-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
field.Q("unity-w-input").Q("unity-text-input").RegisterCallback <KeyDownEvent>(keyDownCallback);
field.Q("unity-w-input").Q("unity-text-input").RegisterCallback <FocusOutEvent>(focusOutCallback);
// Called after KeyDownEvent
field.RegisterValueChangedCallback(evt =>
{
// Only true when setting value via FieldMouseDragger
// Undo recorded once per dragger release
if (m_UndoGroup == -1)
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
}
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ColorShaderProperty)
{
var colorProperty = (ColorShaderProperty)property;
var colorField = new ColorField {
value = property.defaultValue, showEyeDropper = false, hdr = colorProperty.colorMode == ColorMode.HDR
};
colorField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", colorField);
if (!m_Graph.isSubGraph)
{
var colorModeField = new EnumField((Enum)colorProperty.colorMode);
colorModeField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Color Mode");
if (colorProperty.colorMode == (ColorMode)evt.newValue)
{
return;
}
colorProperty.colorMode = (ColorMode)evt.newValue;
colorField.hdr = colorProperty.colorMode == ColorMode.HDR;
colorField.MarkDirtyRepaint();
DirtyNodes();
});
AddRow("Mode", colorModeField);
}
}
else if (property is TextureShaderProperty)
{
var textureProperty = (TextureShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.texture = (Texture)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
if (!m_Graph.isSubGraph)
{
var defaultModeField = new EnumField((Enum)textureProperty.defaultType);
defaultModeField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Texture Mode");
if (textureProperty.defaultType == (TextureShaderProperty.DefaultType)evt.newValue)
{
return;
}
textureProperty.defaultType = (TextureShaderProperty.DefaultType)evt.newValue;
DirtyNodes(ModificationScope.Graph);
});
void ToggleDefaultModeFieldEnabled()
{
defaultModeField.SetEnabled(!defaultModeField.enabledSelf);
}
m_OnExposedToggle += ToggleDefaultModeFieldEnabled;
AddRow("Mode", defaultModeField);
}
}
else if (property is Texture2DArrayShaderProperty)
{
var textureProperty = (Texture2DArrayShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.textureArray, objectType = typeof(Texture2DArray)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.textureArray = (Texture2DArray)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Texture3DShaderProperty)
{
var textureProperty = (Texture3DShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture3D)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
textureProperty.value.texture = (Texture3D)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is CubemapShaderProperty)
{
var cubemapProperty = (CubemapShaderProperty)property;
var field = new ObjectField {
value = cubemapProperty.value.cubemap, objectType = typeof(Cubemap)
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
cubemapProperty.value.cubemap = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is BooleanShaderProperty)
{
var booleanProperty = (BooleanShaderProperty)property;
EventCallback <ChangeEvent <bool> > onBooleanChanged = evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change property value");
booleanProperty.value = evt.newValue;
DirtyNodes();
};
var field = new Toggle();
field.OnToggleChanged(onBooleanChanged);
field.value = booleanProperty.value;
AddRow("Default", field);
}
else if (property is Matrix2ShaderProperty)
{
var matrix2Property = (Matrix2ShaderProperty)property;
var row0Field = new Vector2Field {
value = matrix2Property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector2 row1 = matrix2Property.value.GetRow(1);
matrix2Property.value = new Matrix4x4()
{
m00 = evt.newValue.x,
m01 = evt.newValue.y,
m02 = 0,
m03 = 0,
m10 = row1.x,
m11 = row1.y,
m12 = 0,
m13 = 0,
m20 = 0,
m21 = 0,
m22 = 0,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("Default", row0Field);
var row1Field = new Vector2Field {
value = matrix2Property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector2 row0 = matrix2Property.value.GetRow(0);
matrix2Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = 0,
m03 = 0,
m10 = evt.newValue.x,
m11 = evt.newValue.y,
m12 = 0,
m13 = 0,
m20 = 0,
m21 = 0,
m22 = 0,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("", row1Field);
}
else if (property is Matrix3ShaderProperty)
{
var matrix3Property = (Matrix3ShaderProperty)property;
var row0Field = new Vector3Field {
value = matrix3Property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector3 row1 = matrix3Property.value.GetRow(1);
Vector3 row2 = matrix3Property.value.GetRow(2);
matrix3Property.value = new Matrix4x4()
{
m00 = evt.newValue.x,
m01 = evt.newValue.y,
m02 = evt.newValue.z,
m03 = 0,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = 0,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("Default", row0Field);
var row1Field = new Vector3Field {
value = matrix3Property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector3 row0 = matrix3Property.value.GetRow(0);
Vector3 row2 = matrix3Property.value.GetRow(2);
matrix3Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = 0,
m10 = evt.newValue.x,
m11 = evt.newValue.y,
m12 = evt.newValue.z,
m13 = 0,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("", row1Field);
var row2Field = new Vector3Field {
value = matrix3Property.value.GetRow(2)
};
row2Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector3 row0 = matrix3Property.value.GetRow(0);
Vector3 row1 = matrix3Property.value.GetRow(1);
matrix3Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = 0,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = 0,
m20 = evt.newValue.x,
m21 = evt.newValue.y,
m22 = evt.newValue.z,
m23 = 0,
m30 = 0,
m31 = 0,
m32 = 0,
m33 = 0,
};
DirtyNodes();
});
AddRow("", row2Field);
}
else if (property is Matrix4ShaderProperty)
{
var matrix4Property = (Matrix4ShaderProperty)property;
var row0Field = new Vector4Field {
value = matrix4Property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row1 = matrix4Property.value.GetRow(1);
Vector4 row2 = matrix4Property.value.GetRow(2);
Vector4 row3 = matrix4Property.value.GetRow(3);
matrix4Property.value = new Matrix4x4()
{
m00 = evt.newValue.x,
m01 = evt.newValue.y,
m02 = evt.newValue.z,
m03 = evt.newValue.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("Default", row0Field);
var row1Field = new Vector4Field {
value = matrix4Property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = matrix4Property.value.GetRow(0);
Vector4 row2 = matrix4Property.value.GetRow(2);
Vector4 row3 = matrix4Property.value.GetRow(3);
matrix4Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = evt.newValue.x,
m11 = evt.newValue.y,
m12 = evt.newValue.z,
m13 = evt.newValue.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("", row1Field);
var row2Field = new Vector4Field {
value = matrix4Property.value.GetRow(2)
};
row2Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = matrix4Property.value.GetRow(0);
Vector4 row1 = matrix4Property.value.GetRow(1);
Vector4 row3 = matrix4Property.value.GetRow(3);
matrix4Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = evt.newValue.x,
m21 = evt.newValue.y,
m22 = evt.newValue.z,
m23 = evt.newValue.w,
m30 = row3.x,
m31 = row3.y,
m32 = row3.z,
m33 = row3.w,
};
DirtyNodes();
});
AddRow("", row2Field);
var row3Field = new Vector4Field {
value = matrix4Property.value.GetRow(3)
};
row3Field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector4 row0 = matrix4Property.value.GetRow(0);
Vector4 row1 = matrix4Property.value.GetRow(1);
Vector4 row2 = matrix4Property.value.GetRow(2);
matrix4Property.value = new Matrix4x4()
{
m00 = row0.x,
m01 = row0.y,
m02 = row0.z,
m03 = row0.w,
m10 = row1.x,
m11 = row1.y,
m12 = row1.z,
m13 = row1.w,
m20 = row2.x,
m21 = row2.y,
m22 = row2.z,
m23 = row2.w,
m30 = evt.newValue.x,
m31 = evt.newValue.y,
m32 = evt.newValue.z,
m33 = evt.newValue.w,
};
DirtyNodes();
});
AddRow("", row3Field);
}
else if (property is SamplerStateShaderProperty)
{
var samplerStateProperty = (SamplerStateShaderProperty)property;
var filterField = new EnumField(samplerStateProperty.value.filter);
filterField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
TextureSamplerState state = samplerStateProperty.value;
state.filter = (TextureSamplerState.FilterMode)evt.newValue;
samplerStateProperty.value = state;
DirtyNodes(ModificationScope.Graph);
});
AddRow("Filter", filterField);
var wrapField = new EnumField(samplerStateProperty.value.wrap);
wrapField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
TextureSamplerState state = samplerStateProperty.value;
state.wrap = (TextureSamplerState.WrapMode)evt.newValue;
samplerStateProperty.value = state;
DirtyNodes(ModificationScope.Graph);
});
AddRow("Wrap", wrapField);
}
else if (property is GradientShaderProperty)
{
var gradientProperty = (GradientShaderProperty)property;
var field = new GradientField {
value = gradientProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
gradientProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
var precisionField = new EnumField((Enum)property.precision);
precisionField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Precision");
if (property.precision == (Precision)evt.newValue)
{
return;
}
property.precision = (Precision)evt.newValue;
m_Graph.ValidateGraph();
precisionField.MarkDirtyRepaint();
DirtyNodes();
});
AddRow("Precision", precisionField);
AddToClassList("sgblackboardFieldPropertyView");
UpdateReferenceNameResetMenu();
}
public BlackboardFieldPropertyView(AbstractMaterialGraph graph, IShaderProperty property)
{
m_Graph = graph;
if (property is Vector1ShaderProperty)
{
VisualElement floatRow = new VisualElement();
VisualElement intRow = new VisualElement();
VisualElement modeRow = new VisualElement();
VisualElement minRow = new VisualElement();
VisualElement maxRow = new VisualElement();
FloatField floatField = null;
var floatProperty = (Vector1ShaderProperty)property;
if (floatProperty.floatType == FloatType.Integer)
{
var field = new IntegerField {
value = (int)floatProperty.value
};
field.OnValueChanged(intEvt =>
{
floatProperty.value = (float)intEvt.newValue;
DirtyNodes();
});
intRow = AddRow("Default", field);
}
else
{
floatField = new FloatField {
value = floatProperty.value
};
floatField.OnValueChanged(evt =>
{
floatProperty.value = (float)evt.newValue;
DirtyNodes();
});
floatRow = AddRow("Default", floatField);
}
var floatModeField = new EnumField((Enum)floatProperty.floatType);
floatModeField.value = floatProperty.floatType;
floatModeField.OnValueChanged(evt =>
{
if (floatProperty.floatType == (FloatType)evt.newValue)
{
return;
}
floatProperty = (Vector1ShaderProperty)property;
floatProperty.floatType = (FloatType)evt.newValue;
switch (floatProperty.floatType)
{
case FloatType.Slider:
RemoveElements(new VisualElement[] { floatRow, intRow, modeRow, minRow, maxRow });
var field = new FloatField {
value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x)
};
floatProperty.value = (float)field.value;
field.OnValueChanged(defaultEvt =>
{
floatProperty.value = Mathf.Max(Mathf.Min((float)defaultEvt.newValue, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
field.value = floatProperty.value;
DirtyNodes();
});
floatRow = AddRow("Default", field);
field.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
modeRow = AddRow("Mode", floatModeField);
var minField = new FloatField {
value = floatProperty.rangeValues.x
};
minField.OnValueChanged(minEvt =>
{
floatProperty.rangeValues = new Vector2((float)minEvt.newValue, floatProperty.rangeValues.y);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
field.value = floatProperty.value;
DirtyNodes();
});
minRow = AddRow("Min", minField);
var maxField = new FloatField {
value = floatProperty.rangeValues.y
};
maxField.OnValueChanged(maxEvt =>
{
floatProperty.rangeValues = new Vector2(floatProperty.rangeValues.x, (float)maxEvt.newValue);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
field.value = floatProperty.value;
DirtyNodes();
});
maxRow = AddRow("Max", maxField);
break;
case FloatType.Integer:
RemoveElements(new VisualElement[] { floatRow, intRow, modeRow, minRow, maxRow });
var intField = new IntegerField {
value = (int)floatProperty.value
};
intField.OnValueChanged(intEvt =>
{
floatProperty.value = (float)intEvt.newValue;
DirtyNodes();
});
intRow = AddRow("Default", intField);
modeRow = AddRow("Mode", floatModeField);
break;
default:
RemoveElements(new VisualElement[] { floatRow, intRow, modeRow, minRow, maxRow });
field = new FloatField {
value = floatProperty.value
};
field.OnValueChanged(defaultEvt =>
{
floatProperty.value = (float)defaultEvt.newValue;
DirtyNodes();
});
floatRow = AddRow("Default", field);
modeRow = AddRow("Mode", floatModeField);
break;
}
DirtyNodes();
});
modeRow = AddRow("Mode", floatModeField);
if (floatProperty.floatType == FloatType.Slider)
{
var minField = new FloatField {
value = floatProperty.rangeValues.x
};
minField.OnValueChanged(minEvt =>
{
floatProperty.rangeValues = new Vector2((float)minEvt.newValue, floatProperty.rangeValues.y);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
floatField.value = floatProperty.value;
DirtyNodes();
});
minRow = AddRow("Min", minField);
var maxField = new FloatField {
value = floatProperty.rangeValues.y
};
maxField.OnValueChanged(maxEvt =>
{
floatProperty.rangeValues = new Vector2(floatProperty.rangeValues.x, (float)maxEvt.newValue);
floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
floatField.value = floatProperty.value;
DirtyNodes();
});
maxRow = AddRow("Max", maxField);
}
}
else if (property is Vector2ShaderProperty)
{
var vectorProperty = (Vector2ShaderProperty)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector3ShaderProperty)
{
var vectorProperty = (Vector3ShaderProperty)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector4ShaderProperty)
{
var vectorProperty = (Vector4ShaderProperty)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ColorShaderProperty)
{
var colorProperty = (ColorShaderProperty)property;
var colorField = new ColorField {
value = property.defaultValue, showEyeDropper = false, hdr = colorProperty.colorMode == ColorMode.HDR
};
colorField.OnValueChanged(evt =>
{
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", colorField);
var colorModeField = new EnumField((Enum)colorProperty.colorMode);
colorModeField.OnValueChanged(evt =>
{
if (colorProperty.colorMode == (ColorMode)evt.newValue)
{
return;
}
colorProperty.colorMode = (ColorMode)evt.newValue;
colorField.hdr = colorProperty.colorMode == ColorMode.HDR;
colorField.DoRepaint();
DirtyNodes();
});
AddRow("Mode", colorModeField);
}
else if (property is TextureShaderProperty)
{
var textureProperty = (TextureShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture)
};
field.OnValueChanged(evt =>
{
textureProperty.value.texture = (Texture)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is CubemapShaderProperty)
{
var cubemapProperty = (CubemapShaderProperty)property;
var field = new ObjectField {
value = cubemapProperty.value.cubemap, objectType = typeof(Cubemap)
};
field.OnValueChanged(evt =>
{
cubemapProperty.value.cubemap = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is BooleanShaderProperty)
{
var booleanProperty = (BooleanShaderProperty)property;
Action onBooleanChanged = () =>
{
booleanProperty.value = !booleanProperty.value;
DirtyNodes();
};
var field = new Toggle(onBooleanChanged)
{
on = booleanProperty.value
};
AddRow("Default", field);
}
// AddRow("Type", new TextField());
// AddRow("Exposed", new Toggle(null));
// AddRow("Range", new Toggle(null));
// AddRow("Default", new TextField());
// AddRow("Tooltip", new TextField());
AddToClassList("sgblackboardFieldPropertyView");
}
public BlackboardFieldPropertyView(AbstractMaterialGraph graph, IShaderProperty property)
{
m_Graph = graph;
if (property is FloatShaderProperty)
{
var floatProperty = (FloatShaderProperty)property;
var field = new FloatField {
value = floatProperty.value
};
field.OnValueChanged(evt =>
{
floatProperty.value = (float)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector2ShaderProperty)
{
var vectorProperty = (Vector2ShaderProperty)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector3ShaderProperty)
{
var vectorProperty = (Vector3ShaderProperty)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is Vector4ShaderProperty)
{
var vectorProperty = (Vector4ShaderProperty)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.OnValueChanged(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ColorShaderProperty)
{
var colorProperty = (ColorShaderProperty)property;
var field = new ColorField {
value = property.defaultValue, hdr = colorProperty.HDR
};
field.OnValueChanged(evt =>
{
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is TextureShaderProperty)
{
var textureProperty = (TextureShaderProperty)property;
var field = new ObjectField {
value = textureProperty.value.texture, objectType = typeof(Texture)
};
field.OnValueChanged(evt =>
{
textureProperty.value.texture = (Texture)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is CubemapShaderProperty)
{
var cubemapProperty = (CubemapShaderProperty)property;
var field = new ObjectField {
value = cubemapProperty.value.cubemap, objectType = typeof(Cubemap)
};
field.OnValueChanged(evt =>
{
cubemapProperty.value.cubemap = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
// AddRow("Type", new TextField());
// AddRow("Exposed", new Toggle(null));
// AddRow("Range", new Toggle(null));
// AddRow("Default", new TextField());
// AddRow("Tooltip", new TextField());
AddToClassList("sgblackboardFieldPropertyView");
}
