public PotentialField(
NavigationField navigationField,
Target target)
{
Size = navigationField.fieldSize;
NavigationField = navigationField;
Target = target;
Potentials = new FloatField(navigationField.fieldSize);
Flows = new Vector2Field(navigationField.fieldSize);
_heap =
new MaxHeap<CellPotentialHeapEntry>
{
RemoveAction = CellPotentialHeapEntry.ReturnCellCostHeapEntry
};
}
public void RefreshPropertyValue(object val, int specificity)
{
if (val is float floatValue)
{
FloatField field = GetOrCreateField <FloatField, float>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(floatValue);
}
}
else if (val is int intValue)
{
IntegerField field = GetOrCreateField <IntegerField, int>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(intValue);
}
}
else if (val is Length lengthValue)
{
StyleLengthField field = GetOrCreateField <StyleLengthField, StyleLength>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(new StyleLength(lengthValue));
}
}
else if (val is Color colorValue)
{
ColorField field = GetOrCreateField <ColorField, Color>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(colorValue);
}
}
// Note: val may be null in case of reference type like "Font"
else if (m_PropertyInfo.type == typeof(StyleFont))
{
ObjectField field;
field = GetOrCreateObjectField <Font>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(val as Font);
}
}
else if (val is FontDefinition fontDefinition)
{
ObjectField field;
if (fontDefinition.fontAsset != null)
{
if (childCount == 0)
{
field = TextEditorDelegates.GetObjectFieldOfTypeFontAsset();
SetField(field);
}
else
{
field = (ObjectField)ElementAt(0);
}
}
else
{
field = GetOrCreateObjectField <Font>();
}
if (!IsFocused(field))
{
field.SetValueWithoutNotify(fontDefinition.fontAsset != null ? fontDefinition.fontAsset : fontDefinition.font);
}
}
else if (val is Background bgValue)
{
ObjectField field;
if (bgValue.vectorImage != null)
{
field = GetOrCreateObjectField <VectorImage>();
}
else if (bgValue.sprite != null)
{
field = GetOrCreateObjectField <Sprite>();
}
else if (bgValue.renderTexture != null)
{
field = GetOrCreateObjectField <RenderTexture>();
}
else
{
field = GetOrCreateObjectField <Texture2D>();
}
if (!IsFocused(field))
{
field.SetValueWithoutNotify(
bgValue.vectorImage != null ? (UnityEngine.Object)bgValue.vectorImage :
(bgValue.sprite != null ? (UnityEngine.Object)bgValue.sprite :
(bgValue.renderTexture != null ? (UnityEngine.Object)bgValue.renderTexture :
(UnityEngine.Object)bgValue.texture)));
}
}
else if (val is Cursor cursorValue)
{
// Recreate the cursor fields every time since StyleCursor
// can be made of different fields (based on the value)
Clear();
if (cursorValue.texture != null)
{
var uiTextureField = new ObjectField(m_PropertyName)
{
value = cursorValue.texture
};
uiTextureField.RegisterValueChangedCallback(e =>
{
var currentCursor = (Cursor)StyleDebug.GetComputedStyleActualValue(m_SelectedElement.computedStyle, m_PropertyInfo.id);
currentCursor.texture = e.newValue as Texture2D;
SetPropertyValue(new StyleCursor(currentCursor));
});
Add(uiTextureField);
var uiHotspotField = new Vector2Field("hotspot")
{
value = cursorValue.hotspot
};
uiHotspotField.RegisterValueChangedCallback(e =>
{
var currentCursor = (Cursor)StyleDebug.GetComputedStyleActualValue(m_SelectedElement.computedStyle, m_PropertyInfo.id);
currentCursor.hotspot = e.newValue;
SetPropertyValue(new StyleCursor(currentCursor));
});
Add(uiHotspotField);
}
else
{
int mouseId = cursorValue.defaultCursorId;
var uiField = new EnumField(m_PropertyName, (MouseCursor)mouseId);
uiField.RegisterValueChangedCallback(e =>
{
int cursorId = Convert.ToInt32(e.newValue);
var cursor = new Cursor()
{
defaultCursorId = cursorId
};
SetPropertyValue(new StyleCursor(cursor));
});
Add(uiField);
}
Add(m_SpecificityLabel);
SetSpecificity(specificity);
}
else if (val is TextShadow textShadow)
{
ColorField colorFieldfield = GetOrCreateFields <ColorField, Color>(m_PropertyName, 0);
if (!IsFocused(colorFieldfield))
{
colorFieldfield.SetValueWithoutNotify(textShadow.color);
}
Vector2Field vector2Field = GetOrCreateFields <Vector2Field, Vector2>("offset", 1);
if (!IsFocused(vector2Field))
{
vector2Field.SetValueWithoutNotify(textShadow.offset);
}
FloatField floatField = GetOrCreateFields <FloatField, float>("blur", 2);
if (!IsFocused(floatField))
{
floatField.SetValueWithoutNotify(textShadow.blurRadius);
}
if (childCount == 3)
{
Add(m_SpecificityLabel);
}
}
else
{
// Enum
Debug.Assert(val is Enum, "Expected Enum value");
Enum enumValue = (Enum)val;
EnumField field = GetOrCreateEnumField(enumValue);
if (!IsFocused(field))
{
field.SetValueWithoutNotify(enumValue);
}
}
SetSpecificity(specificity);
}
public BlackboardFieldPropertyView(AbstractMaterialGraph graph, IShaderProperty property)
{
AddStyleSheetPath("Styles/ShaderGraphBlackboard");
m_Graph = graph;
m_Property = property;
m_ExposedToogle = new Toggle();
m_ExposedToogle.OnToggleChanged(evt =>
{
property.generatePropertyBlock = evt.newValue;
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;
EventCallback <ChangeEvent <bool> > onBooleanChanged = evt =>
{
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();
}
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 RefreshPropertyValue(object val, int specificity)
{
if (val is StyleFloat)
{
var style = (StyleFloat)val;
FloatField field = GetOrCreateField <FloatField, float>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(style.value);
}
}
else if (val is StyleInt)
{
var style = (StyleInt)val;
IntegerField field = GetOrCreateField <IntegerField, int>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(style.value);
}
}
else if (val is StyleLength)
{
var style = (StyleLength)val;
StyleLengthField field = GetOrCreateField <StyleLengthField, StyleLength>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(style);
}
}
else if (val is StyleColor)
{
var style = (StyleColor)val;
ColorField field = GetOrCreateField <ColorField, Color>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(style.value);
}
}
else if (val is StyleFont)
{
var style = (StyleFont)val;
ObjectField field = GetOrCreateObjectField <Font>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(style.value);
}
}
else if (val is StyleBackground)
{
var background = ((StyleBackground)val).value;
ObjectField field;
if (background.vectorImage != null)
{
field = GetOrCreateObjectField <VectorImage>();
}
else
{
field = GetOrCreateObjectField <Texture2D>();
}
if (!IsFocused(field))
{
field.SetValueWithoutNotify(background.vectorImage != null ? (UnityEngine.Object)background.vectorImage : (UnityEngine.Object)background.texture);
}
}
else if (val is StyleCursor)
{
// Recreate the cursor fields every time since StyleCursor
// can be made of different fields (based on the value)
Clear();
StyleCursor style = (StyleCursor)val;
if (style.value.texture != null)
{
var uiTextureField = new ObjectField(m_PropertyName)
{
value = style.value.texture
};
uiTextureField.RegisterValueChangedCallback(e =>
{
StyleCursor styleCursor = (StyleCursor)StyleDebug.GetComputedStyleValue(m_SelectedElement.computedStyle, m_PropertyInfo.id);
var currentCursor = styleCursor.value;
currentCursor.texture = e.newValue as Texture2D;
SetPropertyValue(new StyleCursor(currentCursor));
});
Add(uiTextureField);
var uiHotspotField = new Vector2Field("hotspot")
{
value = style.value.hotspot
};
uiHotspotField.RegisterValueChangedCallback(e =>
{
StyleCursor styleCursor = (StyleCursor)StyleDebug.GetComputedStyleValue(m_SelectedElement.computedStyle, m_PropertyInfo.id);
var currentCursor = styleCursor.value;
currentCursor.hotspot = e.newValue;
SetPropertyValue(new StyleCursor(currentCursor));
});
Add(uiHotspotField);
}
else
{
int mouseId = style.value.defaultCursorId;
var uiField = new EnumField(m_PropertyName, (MouseCursor)mouseId);
uiField.RegisterValueChangedCallback(e =>
{
int cursorId = Convert.ToInt32(e.newValue);
var cursor = new Cursor()
{
defaultCursorId = cursorId
};
SetPropertyValue(new StyleCursor(cursor));
});
Add(uiField);
}
Add(m_SpecificityLabel);
SetSpecificity(specificity);
}
else
{
// StyleEnum<T>
var type = val.GetType();
var propInfo = type.GetProperty("value");
Enum enumValue = propInfo.GetValue(val, null) as Enum;
EnumField field = GetOrCreateEnumField(enumValue);
if (!IsFocused(field))
{
field.SetValueWithoutNotify(enumValue);
}
}
SetSpecificity(specificity);
}
void BuildMatrix2PropertyField(Matrix2ShaderProperty property)
{
var row0Field = new Vector2Field {
value = property.value.GetRow(0)
};
row0Field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector2 row1 = property.value.GetRow(1);
property.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 = property.value.GetRow(1)
};
row1Field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Property Value");
Vector2 row0 = property.value.GetRow(0);
property.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);
}
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);
}
}
public DelegateEntryEditor(ExposedDelegateEditor exposedDelegateEditor, DelegateEntry delegateEntry)
{
this.exposedDelegateEditor = exposedDelegateEditor;
this.delegateEntry = delegateEntry;
VisualTreeAsset visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/UtilityAI/Scripts/Editor/Delegate Entry Editor/DelegateEntryEditor.uxml");
visualTree.CloneTree(this);
StyleSheet stylesheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/UtilityAI/Scripts/Editor/Delegate Entry Editor/DelegateEntryEditor.uss");
this.styleSheets.Add(stylesheet);
this.AddToClassList("delegateEntryEditor");
if (exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor.GetType() == typeof(UtilityAIAgentEditor))
{
UtilityAIAgentEditor editorWindow = (UtilityAIAgentEditor)exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor;
if (delegateEntry.TargetGO != editorWindow.utilityAIAgent.gameObject)
{
delegateEntry.TargetGO = editorWindow.utilityAIAgent.gameObject;
}
}
delegateEntryFoldout = this.Query <Foldout>("delegateEntry");
delegateEntryFoldout.Query <Toggle>().First().AddToClassList("delegateEntryFoldout");
Button moveUpButton = this.Query <Button>("moveUpButton").First();
moveUpButton.BringToFront();
moveUpButton.clickable.clicked += MoveEntryUp;
Button moveDownButton = this.Query <Button>("moveDownButton").First();
moveDownButton.BringToFront();
moveDownButton.clickable.clicked += MoveEntryDown;
Button deleteButton = this.Query <Button>("deleteButton").First();
deleteButton.BringToFront();
deleteButton.clickable.clicked += DeleteEntry;
List <Component> components = new List <Component>();
if (exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor is UtilityAIAgentEditor)
{
components = delegateEntry.TargetGO.GetComponents <Component>().ToList();
}
else if (exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor is UtilityAIActionSetEditor)
{
if (((UtilityAIActionSetEditor)exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor).utilityAIAgent.inheritingGameObject != null)
{
components = ((UtilityAIActionSetEditor)exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor).utilityAIAgent.inheritingGameObject.GetComponents <Component>().ToList();
}
}
if (components.Count > 0)
{
int index = 0;
if (delegateEntry.Target != null)
{
List <Component> sharedComponents = components.Where(o => o.GetType() == delegateEntry.Target.GetType()).ToList();
if (sharedComponents.Count > 0)
{
index = components.IndexOf(sharedComponents[0]);
}
else
{
if (exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor is UtilityAIAgentEditor && ((UtilityAIAgentEditor)exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor).utilityAIAgent.actionSet != null)
{
((UtilityAIAgentEditor)exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor).utilityAIAgent.MakeActionsSetUnique();
((UtilityAIAgentEditor)exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor).CreateInspectorGUI();
return;
}
}
}
PopupField <Component> targetComponentField = new PopupField <Component>("Component: ", components, index);
delegateEntry.Target = targetComponentField.value;
targetComponentField.RegisterCallback <ChangeEvent <Component> >(
e =>
{
delegateEntry.Target = (Component)e.newValue;
exposedDelegateEditor.UpdateDelegateEntries();
}
);
delegateEntryFoldout.Add(targetComponentField);
if (delegateEntry.Target != null)
{
Type selectedComponentType = delegateEntry.Target.GetType();
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
//Get a list of methods attached to the component, and create a dropdown menu:
List <MethodInfo> methods = selectedComponentType.GetMethods(flags).ToList();
PopupField <MethodInfo> targetMethodField = new PopupField <MethodInfo>("Method: ", methods, methods.Contains(delegateEntry.Method) ? methods.IndexOf(delegateEntry.Method) : 0);
if (delegateEntry.Method == null || delegateEntry.Method.Name != targetMethodField.value.Name)
{
delegateEntry.SetMethod(selectedComponentType, targetMethodField.value.Name);
}
targetMethodField.RegisterCallback <ChangeEvent <MethodInfo> >(
e =>
{
delegateEntry.SetMethod(selectedComponentType, e.newValue.Name);
exposedDelegateEditor.UpdateDelegateEntries();
}
);
delegateEntryFoldout.Add(targetMethodField);
if (delegateEntry.Method != null && delegateEntry.Parameters.Length > 0)
{
Foldout parametersFoldout = new Foldout();
parametersFoldout.text = "Parameters: ";
foreach (SerializableObject parameter in delegateEntry.Parameters)
{
if (parameter.obj is int)
{
IntegerField parameterField = new IntegerField();
parameterField.value = (int)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <int> >(
e =>
{
parameter.obj = (int)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is float)
{
FloatField parameterField = new FloatField();
parameterField.value = (float)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <float> >(
e =>
{
parameter.obj = (float)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is bool)
{
Toggle parameterField = new Toggle();
parameterField.value = (bool)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <bool> >(
e =>
{
parameter.obj = (bool)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is string)
{
TextField parameterField = new TextField();
parameterField.value = (string)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <string> >(
e =>
{
parameter.obj = (string)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is Vector3)
{
Vector3Field parameterField = new Vector3Field();
parameterField.value = (Vector3)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <Vector3> >(
e =>
{
parameter.obj = (Vector3)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is Vector2)
{
Vector2Field parameterField = new Vector2Field();
parameterField.value = (Vector2)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <Vector2> >(
e =>
{
parameter.obj = (Vector2)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is Bounds)
{
BoundsField parameterField = new BoundsField();
parameterField.value = (Bounds)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <Bounds> >(
e =>
{
parameter.obj = (Bounds)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is Rect)
{
RectField parameterField = new RectField();
parameterField.value = (Rect)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <Rect> >(
e =>
{
parameter.obj = (Rect)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is Color)
{
ColorField parameterField = new ColorField();
parameterField.value = (Color)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <Color> >(
e =>
{
parameter.obj = (Color)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
else if (parameter.obj is UnityEngine.Object)
{
ObjectField parameterField = new ObjectField();
parameterField.value = (UnityEngine.Object)parameter.obj;
parameterField.RegisterCallback <ChangeEvent <UnityEngine.Object> >(
e =>
{
parameter.obj = (UnityEngine.Object)e.newValue;
}
);
parametersFoldout.Add(parameterField);
}
}
delegateEntryFoldout.Add(parametersFoldout);
}
}
}
if (delegateEntry.TargetGO != null)
{
delegateEntryFoldout.text += delegateEntry.TargetGO.name;
if (delegateEntry.Target != null)
{
delegateEntryFoldout.text += "(" + delegateEntry.Target.GetType() + ") ";
if (delegateEntry.Method != null)
{
delegateEntryFoldout.text += delegateEntry.Method.Name;
}
}
delegateEntryFoldout.text += ": ";
}
else
{
delegateEntryFoldout.text = "New Delegate Entry:";
}
if (exposedDelegateEditor.utilityAIActionEditor.utilityAIAgentEditor is UtilityAIActionSetEditor && components.Count <= 0)
{
delegateEntryFoldout.text = "No inheriting object selected!";
}
}
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();
}
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.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 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");
}
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.Localize(),
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.Closed += (s, e) => object3D.Invalidated -= RefreshField;
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 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)
{
var showAsList = property.PropertyInfo.GetCustomAttributes(true).OfType <ShowAsListAttribute>().FirstOrDefault() != null;
if (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)
{
rowContainer.AddChild(CreateSourceChildSelector(childSelector, sourceContainer, theme));
}
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.Localize(),
valueField,
theme);
void RefreshField(object s, InvalidateArgs e)
{
if (e.InvalidateType.HasFlag(InvalidateType.DisplayValues))
{
double newValue = (double)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
{
// 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();
if (field is TextField)
{
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) =>
{
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 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);
}
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");
samplerStateProperty.value.filter = (TextureSamplerState.FilterMode)evt.newValue;
DirtyNodes(ModificationScope.Graph);
});
AddRow("Filter", filterField);
var wrapField = new EnumField(samplerStateProperty.value.wrap);
wrapField.RegisterValueChangedCallback(evt =>
{
m_Graph.owner.RegisterCompleteObjectUndo("Change Property Value");
samplerStateProperty.value.wrap = (TextureSamplerState.WrapMode)evt.newValue;
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);
}
// 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();
}
public void GenerateBlackBoard(GraphData currentData)
{
Blackboard blackboard = new Blackboard(this)
{
scrollable = true,
};
blackboard.AddToClassList("grayboard");
//blackboard.Add(new BlackboardSection { title="Exposed Properties" });
blackboard.addItemRequested = _blackboard => { };
blackboard.SetPosition(new Rect(10, 30, 200, 200));
this.Add(blackboard);
/* Start: how to add to blackboard */
/*var container = new VisualElement();
* var blackboardField = new BlackboardField {
* text = "Sample_Property",
* typeText = "String Property"
* };
* var blackboardFieldValue = new TextField("Value") {
* value = "Value"
* };
* blackboardFieldValue.RegisterValueChangedCallback(evt => {
* Debug.Log(evt.newValue);
* });
* var blackBoardRow = new BlackboardRow(blackboardField, blackboardFieldValue);
* container.Add(blackboardField);
* container.Add(blackBoardRow);
* blackboard.Add(container);*/
/* End: how to add to blackboard */
if (currentData != null)
{
blackboard.title = currentData.name;
blackboard.subTitle = "Properties";
FieldInfo[] fields = currentData.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
//Debug.Log(currentData.GetType());
for (int i = 0; i < fields.Length; i++)
{
FieldInfo fieldInfo = fields[i];
if (!hiddenFields.Contains(fieldInfo.Name))
{
//Debug.Log(fields[i].ToString());
string fName = SplitCamelCase(fieldInfo.Name);
var container = new VisualElement();
BlackboardSection bbField;
BlackboardRow bbRow;
switch (fieldInfo.FieldType.ToString())
{
case "System.String":
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
TextField bbfValue = new TextField()
{
value = fieldInfo.GetValue(currentData) as string,
multiline = true
};
bbfValue.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfValue);
container.Add(bbRow);
break;
case "System.Int32":
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
IntegerField bbfIntValue = new IntegerField()
{
value = (int)fieldInfo.GetValue(currentData)
};
bbfIntValue.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfIntValue);
container.Add(bbRow);
break;
case "System.Single":
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
FloatField bbfFloatValue = new FloatField()
{
value = (float)fieldInfo.GetValue(currentData)
};
bbfFloatValue.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfFloatValue);
container.Add(bbRow);
break;
case "UnityEngine.Vector2":
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
Vector2Field bbfVector2Value = new Vector2Field()
{
value = (Vector2)fieldInfo.GetValue(currentData)
};
bbfVector2Value.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfVector2Value);
container.Add(bbRow);
break;
case "UnityEngine.Vector3":
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
Vector3Field bbfVector3Value = new Vector3Field()
{
value = (Vector3)fieldInfo.GetValue(currentData)
};
bbfVector3Value.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfVector3Value);
container.Add(bbRow);
break;
case "UnityEngine.AnimationCurve":
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
CurveField bbfAnimationCurveValue = new CurveField()
{
value = (UnityEngine.AnimationCurve)fieldInfo.GetValue(currentData)
};
bbfAnimationCurveValue.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfAnimationCurveValue);
container.Add(bbRow);
break;
default:
if (fieldInfo.FieldType.ToString().IndexOf("UnityEngine.") == 0)
{
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
ObjectField bbfObjectValue = new ObjectField()
{
value = (UnityEngine.Object)fieldInfo.GetValue(currentData),
allowSceneObjects = false,
objectType = fieldInfo.FieldType
};
bbfObjectValue.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfObjectValue);
container.Add(bbRow);
}
else
{
bbField = new BlackboardSection {
title = fName
};
container.Add(bbField);
EnumField bbfEnumValue = new EnumField((System.Enum)fieldInfo.GetValue(currentData))
{
value = (System.Enum)fieldInfo.GetValue(currentData)
};
bbfEnumValue.RegisterValueChangedCallback(evt => {
fieldInfo.SetValue(currentData, evt.newValue);
//Debug.Log(evt.newValue);
});
bbRow = new BlackboardRow(bbField, bbfEnumValue);
container.Add(bbRow);
}
break;
}
blackboard.Add(container);
}
}
}
// Get the properties of 'Type' class object.
}
public VisualElement GetDefaultInspector()
{
VisualElement inspector = new VisualElement()
{
name = "inspector"
};
VisualElement header = new VisualElement()
{
name = "inspector-header"
};
header.Add(new Image()
{
image = CoreEditorUtils.LoadIcon(@"Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/", "LookDev_EnvironmentHDR", forceLowRes: true)
});
environmentName = new TextField();
environmentName.isDelayed = true;
environmentName.RegisterValueChangedCallback(evt =>
{
string path = AssetDatabase.GetAssetPath(environment);
environment.name = evt.newValue;
AssetDatabase.SetLabels(environment, new string[] { evt.newValue });
EditorUtility.SetDirty(environment);
AssetDatabase.ImportAsset(path);
environmentName.name = environment.name;
});
header.Add(environmentName);
inspector.Add(header);
Foldout foldout = new Foldout()
{
text = "Environment Settings"
};
skyCubemapField = new ObjectField("Sky with Sun")
{
tooltip = "A cubemap that will be used as the sky."
};
skyCubemapField.allowSceneObjects = false;
skyCubemapField.objectType = typeof(Cubemap);
skyCubemapField.RegisterValueChangedCallback(evt =>
{
var tmp = environment.sky.cubemap;
RegisterChange(ref tmp, evt.newValue as Cubemap);
environment.sky.cubemap = tmp;
latlong.image = GetLatLongThumbnailTexture(environment, k_SkyThumbnailWidth);
});
foldout.Add(skyCubemapField);
shadowCubemapField = new ObjectField("Sky without Sun")
{
tooltip = "[Optional] A cubemap that will be used to compute self shadowing.\nIt should be the same sky without the sun.\nIf nothing is provided, the sky with sun will be used with lower intensity."
};
shadowCubemapField.allowSceneObjects = false;
shadowCubemapField.objectType = typeof(Cubemap);
shadowCubemapField.RegisterValueChangedCallback(evt =>
{
var tmp = environment.shadow.cubemap;
RegisterChange(ref tmp, evt.newValue as Cubemap);
environment.shadow.cubemap = tmp;
latlong.image = GetLatLongThumbnailTexture(environment, k_SkyThumbnailWidth);
});
foldout.Add(shadowCubemapField);
skyRotationOffset = new FloatField("Rotation")
{
tooltip = "Rotation offset on the longitude of the sky."
};
skyRotationOffset.RegisterValueChangedCallback(evt
=> RegisterChange(ref environment.sky.rotation, Environment.Shadow.ClampLongitude(evt.newValue), skyRotationOffset, updatePreview: true));
foldout.Add(skyRotationOffset);
skyExposureField = new FloatField("Exposure")
{
tooltip = "The exposure to apply with this sky."
};
skyExposureField.RegisterValueChangedCallback(evt
=> RegisterChange(ref environment.sky.exposure, evt.newValue));
foldout.Add(skyExposureField);
var style = foldout.Q <Toggle>().style;
style.marginLeft = 3;
style.unityFontStyleAndWeight = FontStyle.Bold;
inspector.Add(foldout);
sunPosition = new Vector2Field("Sun Position")
{
tooltip = "The sun position as (Longitude, Latitude)\nThe button compute brightest position in the sky with sun."
};
sunPosition.Q("unity-x-input").Q <FloatField>().formatString = "n1";
sunPosition.Q("unity-y-input").Q <FloatField>().formatString = "n1";
sunPosition.RegisterValueChangedCallback(evt =>
{
var tmpContainer = new Vector2(
environment.shadow.sunLongitude,
environment.shadow.sunLatitude);
var tmpNewValue = new Vector2(
Environment.Shadow.ClampLongitude(evt.newValue.x),
Environment.Shadow.ClampLatitude(evt.newValue.y));
RegisterChange(ref tmpContainer, tmpNewValue, sunPosition);
environment.shadow.sunLongitude = tmpContainer.x;
environment.shadow.sunLatitude = tmpContainer.y;
});
foldout.Add(sunPosition);
Button sunToBrightess = new Button(() =>
{
ResetToBrightestSpot(environment);
sunPosition.SetValueWithoutNotify(new Vector2(
Environment.Shadow.ClampLongitude(environment.shadow.sunLongitude),
Environment.Shadow.ClampLatitude(environment.shadow.sunLatitude)));
})
{
name = "sunToBrightestButton"
};
sunToBrightess.Add(new Image()
{
image = CoreEditorUtils.LoadIcon(@"Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/", "LookDev_SunPosition", forceLowRes: true)
});
sunToBrightess.AddToClassList("sun-to-brightest-button");
var vector2Input = sunPosition.Q(className: "unity-vector2-field__input");
vector2Input.Remove(sunPosition.Q(className: "unity-composite-field__field-spacer"));
vector2Input.Add(sunToBrightess);
shadowColor = new ColorField("Shadow Tint")
{
tooltip = "The wanted shadow tint to be used when computing shadow."
};
shadowColor.RegisterValueChangedCallback(evt
=> RegisterChange(ref environment.shadow.color, evt.newValue));
foldout.Add(shadowColor);
style = foldout.Q <Toggle>().style;
style.marginLeft = 3;
style.unityFontStyleAndWeight = FontStyle.Bold;
inspector.Add(foldout);
return(inspector);
}
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;
// create a double editor
if (propertyValue is double doubleValue)
{
var field = new DoubleField();
field.Initialize(0);
field.DoubleValue = doubleValue;
field.ValueChanged += (s, e) =>
{
property.SetValue(field.DoubleValue);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
void RefreshField(object s, InvalidateArgs e)
{
if (e.InvalidateType == InvalidateType.Properties)
{
double newValue = (double)property.Value;
if (newValue != field.DoubleValue)
{
field.DoubleValue = newValue;
}
}
}
object3D.Invalidated += RefreshField;
field.Content.Closed += (s, e) => object3D.Invalidated -= RefreshField;
rowContainer = CreateSettingsRow(property, field);
}
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, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field);
}
else if (propertyValue is Vector2 vector2)
{
var field = new Vector2Field();
field.Initialize(0);
field.Vector2 = vector2;
field.ValueChanged += (s, e) =>
{
property.SetValue(field.Vector2);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsColumn(property, field);
}
else if (propertyValue is Vector3 vector3)
{
var field = new Vector3Field();
field.Initialize(0);
field.Vector3 = vector3;
field.ValueChanged += (s, e) =>
{
property.SetValue(field.Vector3);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsColumn(property, field);
}
else if (propertyValue is DirectionVector directionVector)
{
var field = new DirectionVectorField(theme);
field.Initialize(0);
field.SetValue(directionVector);
field.ValueChanged += (s, e) =>
{
property.SetValue(field.DirectionVector);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field);
}
else if (propertyValue is DirectionAxis directionAxis)
{
rowContainer = CreateSettingsColumn(property);
var newDirectionVector = new DirectionVector()
{
Normal = directionAxis.Normal
};
var row1 = CreateSettingsRow("Axis".Localize());
var field1 = new DirectionVectorField(theme);
field1.Initialize(0);
field1.SetValue(newDirectionVector);
row1.AddChild(field1.Content);
rowContainer.AddChild(row1);
// the direction axis
// the distance from the center of the part
// create a double editor
var field2 = new Vector3Field();
field2.Initialize(0);
field2.Vector3 = directionAxis.Origin - property.Item.Children.First().GetAxisAlignedBoundingBox().Center;
var row2 = CreateSettingsColumn("Offset", field2);
// update this when changed
EventHandler <InvalidateArgs> updateData = (s, 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, undoBuffer));
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, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer.AddChild(row2);
}
else if (propertyValue is ChildrenSelector childSelector)
{
var showAsList = property.PropertyInfo.GetCustomAttributes(true).OfType <ShowAsListAttribute>().FirstOrDefault() != null;
if (showAsList)
{
UIField field = new ChildrenSelectorListField(property, theme);
field.Initialize(0);
field.ValueChanged += (s, e) =>
{
property.SetValue(new ChildrenSelector()
{
field.Value
});
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field);
}
else // show the subtarct editor for boolean subtract and subtract and replace
{
rowContainer = CreateSettingsColumn(property);
rowContainer.AddChild(CreateSelector(childSelector, property.Item, theme));
}
}
else if (propertyValue is ImageBuffer imageBuffer)
{
rowContainer = CreateSettingsColumn(property);
rowContainer.AddChild(CreateImageDisplay(imageBuffer, property.Item, theme));
}
#if !__ANDROID__
else if (propertyValue is List <string> stringList)
{
var selectedItem = ApplicationController.Instance.DragDropData.SceneContext.Scene.SelectedItem;
var field = new SurfacedEditorsField(theme, selectedItem);
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)
{
var field = new IntField();
field.Initialize(0);
field.IntValue = intValue;
field.ValueChanged += (s, e) =>
{
property.SetValue(field.IntValue);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
void RefreshField(object s, InvalidateArgs e)
{
if (e.InvalidateType == InvalidateType.Properties)
{
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);
}
// create a bool editor
else if (propertyValue is bool boolValue)
{
var field = new ToggleboxField(theme);
field.Initialize(0);
field.Checked = boolValue;
field.ValueChanged += (s, e) =>
{
property.SetValue(field.Checked);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field);
}
// create a string editor
else if (propertyValue is string stringValue)
{
var field = new TextField();
field.Initialize(0);
field.SetValue(stringValue, false);
field.Content.HAnchor = HAnchor.Stretch;
field.ValueChanged += (s, e) =>
{
property.SetValue(field.Value);
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field);
var label = rowContainer.Children.First();
if (field is TextField)
{
var spacer = rowContainer.Children.OfType <HorizontalSpacer>().FirstOrDefault();
spacer.HAnchor = HAnchor.Absolute;
spacer.Width = Math.Max(0, 100 - label.Width);
}
}
// create a char editor
else if (propertyValue is char charValue)
{
var field = new CharField();
field.Initialize(0);
field.SetValue(charValue.ToString(), false);
field.ValueChanged += (s, e) =>
{
property.SetValue(Convert.ToChar(field.Value));
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field);
}
// create an enum editor
else if (property.PropertyType.IsEnum)
{
UIField field;
var iconsAttribute = property.PropertyInfo.GetCustomAttributes(true).OfType <IconsAttribute>().FirstOrDefault();
if (iconsAttribute != null)
{
field = new IconEnumField(property, iconsAttribute, theme)
{
InitialValue = propertyValue.ToString()
};
}
else
{
field = new EnumField(property, theme);
}
field.Initialize(0);
field.ValueChanged += (s, e) =>
{
property.SetValue(Enum.Parse(property.PropertyType, field.Value));
object3D?.Invalidate(new InvalidateArgs(context.item, InvalidateType.Properties, undoBuffer));
propertyGridModifier?.UpdateControls(new PublicPropertyChange(context, property.PropertyInfo.Name));
};
rowContainer = CreateSettingsRow(property, field);
}
// Use known IObject3D editors
else if (propertyValue is IObject3D item &&
ApplicationController.Instance.GetEditorsForType(property.PropertyType)?.FirstOrDefault() is IObject3DEditor iObject3DEditor)
{
rowContainer = iObject3DEditor.Create(item, theme);
}
// remember the row name and widget
context.editRows.Add(property.PropertyInfo.Name, rowContainer);
return(rowContainer);
}
public static VisualElement CreateFieldBasedOnType(ConfiguratorValueType _valueType, object _initialValue, string _label, System.Action _changeEventCallback)
{
switch (_valueType)
{
case ConfiguratorValueType.BOOL:
Toggle newToggle = new Toggle(_label)
{
value = _initialValue.StructConvertTo <bool>()
};
newToggle.RegisterCallback <ChangeEvent <bool> >(_event => _changeEventCallback?.Invoke());
return(newToggle);
case ConfiguratorValueType.INT:
IntegerField newIntegerField = new IntegerField(_label)
{
value = _initialValue.StructConvertTo <int>()
};
newIntegerField.RegisterCallback <ChangeEvent <int> >(_event => _changeEventCallback?.Invoke());
return(newIntegerField);
case ConfiguratorValueType.FLOAT:
FloatField newFloatField = new FloatField(_label)
{
value = _initialValue.StructConvertTo <float>()
};
newFloatField.RegisterCallback <ChangeEvent <float> >(_event => _changeEventCallback?.Invoke());
return(newFloatField);
case ConfiguratorValueType.STRING:
string castValue = _initialValue.TryConvertTo <string>();
TextField newTextField = new TextField(_label)
{
value = castValue ?? string.Empty
};
newTextField.RegisterCallback <ChangeEvent <string> >(_event => _changeEventCallback?.Invoke());
return(newTextField);
case ConfiguratorValueType.VECTOR2:
Vector2Field newVector2Field = new Vector2Field(_label)
{
value = _initialValue.StructConvertTo <Vector2>()
};
newVector2Field.RegisterCallback <ChangeEvent <Vector2> >(_event => _changeEventCallback?.Invoke());
return(newVector2Field);
case ConfiguratorValueType.VECTOR3:
Vector3Field newVector3Field = new Vector3Field(_label)
{
value = _initialValue.StructConvertTo <Vector3>()
};
newVector3Field.RegisterCallback <ChangeEvent <Vector3> >(_event => _changeEventCallback?.Invoke());
return(newVector3Field);
case ConfiguratorValueType.VECTOR2INT:
Vector2IntField newVector2IntField = new Vector2IntField(_label)
{
value = _initialValue.StructConvertTo <Vector2Int>()
};
newVector2IntField.RegisterCallback <ChangeEvent <Vector2Int> >(_event => _changeEventCallback?.Invoke());
return(newVector2IntField);
case ConfiguratorValueType.VECTOR3INT:
Vector3IntField newVector3IntField = new Vector3IntField(_label)
{
value = _initialValue.StructConvertTo <Vector3Int>()
};
newVector3IntField.RegisterCallback <ChangeEvent <Vector3Int> >(_event => _changeEventCallback?.Invoke());
return(newVector3IntField);
default:
return(null);
}
}
protected VisualElement CreateParameterControl(SingularSerializableParameter parameter, string controlName, Action <SingularSerializableParameter> clampAction = null)
{
VisualElement control;
switch (parameter.Type)
{
case ParameterType.behaviorAction:
control = new VisualElement();
var buttons = new VisualElement {
style = { flexDirection = FlexDirection.Row, paddingRight = 2f, paddingLeft = 2f }
};
var actionLabel = new Label {
style = { paddingLeft = 8f, paddingRight = 8f }
};
var configureButton = new Button {
text = "Configure"
};
configureButton.clickable.clickedWithEventInfo +=
clickEvent =>
{
var worldPosition = clickEvent.originalMousePosition + GraphView.editorWindow.position.position;
GraphView.actionSearcher.TargetParameter = parameter;
SearchWindow.Open(new SearchWindowContext(worldPosition), GraphView.actionSearcher);
};
var removeButton = new Button(() => parameter.BehaviorActionValue = null)
{
text = "Remove"
};
buttons.Add(configureButton);
buttons.Add(removeButton);
control.Add(actionLabel);
control.Add(buttons);
parameter.OnValueChangedMethods += OnBehaviorActionChanged;
OnBehaviorActionChanged(); //Trigger a refresh
void OnBehaviorActionChanged()
{
parameter.LoadBehaviorAction(GraphView.editorWindow.ImportData); //Refresh action name
actionLabel.text = parameter.BehaviorActionValue == null ? "Missing Action" : parameter.BehaviorActionValue.ToString();
//Behavior action parameter controls
const string ParameterGroupName = "Behavior Action Parameters Group";
VisualElement group = control.Q <VisualElement>(ParameterGroupName);
if (group != null)
{
control.Remove(group); //If had old group remove/destroy it
}
var parameters = parameter.BehaviorActionValue?.method.Parameters;
if (parameters == null || parameters.Count == 0)
{
return; //If no parameter for this action
}
group = new VisualElement {
name = ParameterGroupName
}; //Create group
var accessor = ((SerializableParameter)parameter).BehaviorActionParameters;
for (int i = 0; i < parameters.Count; i++)
{
BehaviorActionParameterInfo parameterInfo = parameters[i];
group.Add(CreateParameterControl(accessor[i], parameterInfo.name));
}
control.Add(group);
}
break;
case ParameterType.boolean:
var toggle = new Toggle(controlName)
{
value = parameter.BooleanValue
};
toggle.RegisterValueChangedCallback(
changeEvent =>
{
parameter.BooleanValue = changeEvent.newValue;
clampAction?.Invoke(parameter);
toggle.SetValueWithoutNotify(parameter.BooleanValue);
}
);
control = toggle;
break;
case ParameterType.enumeration:
control = new EnumField();
//TODO
break;
case ParameterType.integer1:
var integerField = new IntegerField(controlName)
{
value = parameter.Integer1Value
};
integerField.RegisterValueChangedCallback(
changeEvent =>
{
parameter.Integer1Value = changeEvent.newValue;
clampAction?.Invoke(parameter);
integerField.SetValueWithoutNotify(parameter.Integer1Value);
}
);
control = integerField;
break;
case ParameterType.integer2:
var vector2IntField = new Vector2IntField(controlName)
{
value = parameter.Integer2Value
};
vector2IntField.RegisterValueChangedCallback(
changeEvent =>
{
parameter.Integer2Value = changeEvent.newValue;
clampAction?.Invoke(parameter);
vector2IntField.SetValueWithoutNotify(parameter.Integer2Value);
}
);
control = vector2IntField;
break;
case ParameterType.integer3:
var vector3IntField = new Vector3IntField(controlName)
{
value = parameter.Integer3Value
};
vector3IntField.RegisterValueChangedCallback(
changeEvent =>
{
parameter.Integer3Value = changeEvent.newValue;
clampAction?.Invoke(parameter);
vector3IntField.SetValueWithoutNotify(parameter.Integer3Value);
}
);
control = vector3IntField;
break;
case ParameterType.float1:
var floatField = new FloatField(controlName)
{
value = parameter.Float1Value
};
floatField.RegisterValueChangedCallback(
changeEvent =>
{
parameter.Float1Value = changeEvent.newValue;
clampAction?.Invoke(parameter);
floatField.SetValueWithoutNotify(parameter.Float1Value);
}
);
control = floatField;
break;
case ParameterType.float2:
var vector2Field = new Vector2Field(controlName)
{
value = parameter.Float2Value
};
vector2Field.RegisterValueChangedCallback(
changeEvent =>
{
parameter.Float2Value = changeEvent.newValue;
clampAction?.Invoke(parameter);
vector2Field.SetValueWithoutNotify(parameter.Float2Value);
}
);
control = vector2Field;
break;
case ParameterType.float3:
var vector3Field = new Vector3Field(controlName)
{
value = parameter.Float3Value
};
vector3Field.RegisterValueChangedCallback(
changeEvent =>
{
parameter.Float3Value = changeEvent.newValue;
clampAction?.Invoke(parameter);
vector3Field.SetValueWithoutNotify(parameter.Float3Value);
}
);
control = vector3Field;
break;
default: throw ExceptionHelper.Invalid(nameof(parameter.Type), parameter.Type, InvalidType.unexpected);
}
control.Query <FloatField>().ForEach(field => field.style.minWidth = 60f);
Label label = control.Q <Label>();
if (label != null)
{
label.style.minWidth = 0f;
label.style.paddingRight = 20f;
}
return(control);
}
void CreateUIElements()
{
var titleRow = new VisualElement()
{
style =
{
flexDirection = FlexDirection.Row,
flexShrink = 0f,
justifyContent = Justify.SpaceBetween
}
};
var label = new Label("VisualElements Container");
label.style.marginTop = 2;
label.style.marginBottom = 2;
m_VisualElementContainer.Add(label);
var curveX = AnimationCurve.Linear(0, 0, 1, 0);
var popupFieldValues = new List <SomeClass>
{
new SomeClass("First Class Value"),
new SomeClass("Second Value"),
new SomeClass("Another Value"),
new SomeClass("Another Value with a very lonnnnnnnnnnnnnnnnnnnnnnnnng text to make sure this is really overflowing the popup field.")
};
var maskFieldOptions = new List <string>(m_MaskFieldOptions);
m_VisualElementContainer.Add(m_IntegerField = new IntegerField());
m_VisualElementContainer.Add(m_LongField = new LongField());
m_VisualElementContainer.Add(m_FloatField = new FloatField());
m_VisualElementContainer.Add(m_DoubleField = new DoubleField());
m_VisualElementContainer.Add(m_EnumField = new EnumField(EnumValues.Two));
m_VisualElementContainer.Add(m_EnumFlagsField = new EnumFlagsField(EnumFlagValues.Second));
m_VisualElementContainer.Add(m_TextField = new TextField());
m_VisualElementContainer.Add(m_PasswordField = new TextField()
{
isPasswordField = true, maskChar = '*'
});
m_VisualElementContainer.Add(m_Vector3Field = new Vector3Field());
m_VisualElementContainer.Add(m_Vector3IntField = new Vector3IntField());
m_VisualElementContainer.Add(m_Vector2Field = new Vector2Field());
m_VisualElementContainer.Add(m_ColorField = new ColorField());
m_VisualElementContainer.Add(m_ObjectFieldCamera = new ObjectField()
{
objectType = typeof(Camera)
});
m_VisualElementContainer.Add(m_ObjectFieldGameObject = new ObjectField()
{
objectType = typeof(GameObject)
});
m_VisualElementContainer.Add(m_CurveField = new CurveField()
{
value = curveX
});
m_VisualElementContainer.Add(m_CurveFieldMesh = new CurveField()
{
value = curveX, renderMode = CurveField.RenderMode.Mesh
});
m_VisualElementContainer.Add(m_PopupField = new PopupField <SomeClass>(popupFieldValues, popupFieldValues[1]));
m_VisualElementContainer.Add(m_RectField = new RectField());
m_VisualElementContainer.Add(m_BoundsField = new BoundsField());
m_VisualElementContainer.Add(m_ToggleField = new Toggle());
m_VisualElementContainer.Add(m_MaskField = new MaskField(maskFieldOptions, 6));
m_VisualElementContainer.Add(m_LayerField = new LayerField());
m_VisualElementContainer.Add(m_TagField = new TagField());
m_VisualElementContainer.Add(m_MinMaxSliderField = new MinMaxSlider(5, 10, 0, 125));
m_VisualElementContainer.Add(m_Slider = new Slider(2, 8));
m_VisualElementContainer.Add(m_SliderInt = new SliderInt(11, 23));
var buttonRow = new VisualElement()
{
style =
{
flexDirection = FlexDirection.Row,
flexShrink = 0f,
}
};
buttonRow.Add(new Button()
{
text = k_ButtonLeftTitle, style = { flexGrow = 1 }
});
buttonRow.Add(new Button()
{
text = k_ButtonRightTitle, style = { flexGrow = 1 }
});
m_VisualElementContainer.Add(buttonRow);
m_VisualElementContainer.Add(new Button()
{
text = k_ButtonTopTitle
});
m_VisualElementContainer.Add(new Button()
{
text = k_ButtonBottomTitle
});
m_VisualElementContainer.Add(m_ColorField1 = new ColorField());
m_VisualElementContainer.Add(m_LayerMaskField = new LayerMaskField(0));
m_VisualElementContainer.Add(m_MultiLineTextField = new TextField()
{
multiline = true
});
m_VisualElementContainer.Add(m_SliderProgressBar = new SliderInt());
m_VisualElementContainer.Add(m_ProgressBar = new ProgressBar());
m_ProgressBar.title = nameof(ProgressBar);
m_SliderProgressBar.lowValue = 0;
m_SliderProgressBar.highValue = 100;
m_SliderProgressBar.bindingPath = nameof(SliderProgressTestObject.exampleValue);
m_ProgressBar.bindingPath = nameof(SliderProgressTestObject.exampleValue);
m_SliderProgressBar.Bind(SliderProgressTestSO);
m_ProgressBar.Bind(SliderProgressTestSO);
// The progress bar by itself does not contain any margin in IMGUI...
// In this example, we are artifically adding the textfield margin to it. (see below, in the IMGUI section, ProgressBar())
m_ProgressBar.style.marginBottom = 2f;
m_VisualElementContainer.Add(m_GradientField = new GradientField());
var visualElementHorizontal = new VisualElement()
{
style = { flexDirection = FlexDirection.Row, marginLeft = 3, marginBottom = 2 }
};
m_VisualElementContainer.Add(visualElementHorizontal);
visualElementHorizontal.Add(m_ScrollViewDisplay = new ScrollView(ScrollViewMode.VerticalAndHorizontal)
{
style = { width = 100, height = 100, backgroundColor = new Color(0f, 0f, 0f, 0.1f) }
}); // color to spot wrong padding/margin
m_ScrollViewDisplay.Add(new Label("ScrollBars")
{
style = { width = 200, height = 200 }
});
visualElementHorizontal.Add(m_verticalSlider = new Slider(0, 10, SliderDirection.Vertical)
{
style = { backgroundColor = new Color(0f, 0f, 0f, 0.05f) }
}); // color to spot wrong padding/margin
RefreshUIElements();
}
