static VisualElement BuildVectorEditor <T>(this IConstantEditorBuilder builder, IEditableVectorType <T> v)
{
var root = new VisualElement();
root.styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.TemplatePath + "ConstantEditors.uss"));
root.AddToClassList(v.UssClassName);
if (v.Object != null)
{
var serializedObject = new SerializedObject(v.Object);
foreach (var propertyName in v.PropertyNames)
{
SerializedProperty p = serializedObject.FindProperty(propertyName);
var propertyField = new PropertyField(p);
propertyField.RegisterCallback <ChangeEvent <T> >(new EventCallback <IChangeEvent>(builder.OnValueChanged));
root.Add(propertyField);
}
}
else
{
foreach (var propertyLabel in v.PropertyLabels)
{
root.Add(v.MakePreviewField(propertyLabel));
}
}
return(root);
}
static void CreateField <T>(string label, IConstantEditorBuilder builder, VisualElement container, T oldValue, float fieldValue, Func <ChangeEvent <float>, T> generateValue)
{
var field = new FloatField(label);
field.value = fieldValue;
container.Add(field);
field.RegisterValueChangedCallback(evt => Dispatch(builder, oldValue, generateValue(evt)));
}
public static InlineFloatEditor MakeFloatVectorEditor <T>(this IConstantEditorBuilder builder, ConstantNodeModel <T> model, IEnumerable <string> fieldNames, Func <T, int, float> getField, VectorType <T, float> .SetFieldDelegate setField)
{
var vectorType = new VectorType <T, float>(model.value, fieldNames, getField, setField);
return(builder.MakeVectorEditor(vectorType, (label, fieldValue) => new FloatField(label)
{
value = fieldValue
}));
}
static VisualElement BuildSingleFieldEditor <T>(this IConstantEditorBuilder builder, T oldValue, BaseField <T> field)
{
var root = new VisualElement();
//Mimic UIElement property fields style
root.AddToClassList("unity-property-field");
root.styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.templatePath + "ConstantEditors.uss"));
field.value = oldValue;
root.Add(field);
field.RegisterValueChangedCallback(evt => builder.OnValueChanged(evt));
return(root);
}
public static VisualElement BuildFloat2Editor(this IConstantEditorBuilder builder, ConstantNodeModel <float2> f)
{
var root = new VisualElement();
root.styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.TemplatePath + "ConstantEditors.uss"));
root.AddToClassList("vs-inline-float-editor");
CreateField("x", builder, root, f.value, f.value.x, ChangeX);
CreateField("y", builder, root, f.value, f.value.y, ChangeY);
return(root);
float2 ChangeX(ChangeEvent <float> evt) => new float2(evt.newValue, f.value.y);
float2 ChangeY(ChangeEvent <float> evt) => new float2(f.value.x, evt.newValue);
}
public static VisualElement BuildEnumEditor(this IConstantEditorBuilder builder, EnumConstantNodeModel enumConstant)
{
var enumEditor = new Button {
text = enumConstant.EnumValue.ToString()
}; // TODO use a bindable element
enumEditor.clickable.clickedWithEventInfo += e =>
{
SearcherService.ShowEnumValues("Pick a value", enumConstant.EnumType.Resolve(enumConstant.GraphModel.Stencil), e.originalMousePosition, (v, i) =>
{
enumConstant.value.Value = Convert.ToInt32(v);
enumEditor.text = v.ToString();
builder.OnValueChanged?.Invoke(null);
});
};
enumEditor.SetEnabled(!enumConstant.IsLocked);
return(enumEditor);
}
public static VisualElement BuildVector3Editor(this IConstantEditorBuilder builder, ConstantNodeModel <Vector3> v)
{
var root = new VisualElement();
root.styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.TemplatePath + "ConstantEditors.uss"));
root.AddToClassList("vs-inline-float-editor");
CreateField("x", builder, root, v.value, v.value.x, ChangeX);
CreateField("y", builder, root, v.value, v.value.y, ChangeY);
CreateField("z", builder, root, v.value, v.value.z, ChangeZ);
return(root);
//Local Functions
Vector3 ChangeX(ChangeEvent <float> evt) => new Vector3(evt.newValue, v.value.y, v.value.z);
Vector3 ChangeY(ChangeEvent <float> evt) => new Vector3(v.value.x, evt.newValue, v.value.z);
Vector3 ChangeZ(ChangeEvent <float> evt) => new Vector3(v.value.x, v.value.y, evt.newValue);
}
public static VisualElement BuildStringWrapperEditor(this IConstantEditorBuilder builder, IStringWrapperConstantModel icm)
{
var enumEditor = new Button {
text = icm.ObjectValue.ToString()
}; // TODO use a bindable element
enumEditor.clickable.clickedWithEventInfo += e =>
{
List <string> allInputNames = icm.GetAllInputNames();
SearcherService.ShowValues("Pick a value", allInputNames, e.originalMousePosition, (v, pickedIndex) =>
{
icm.SetValueFromString(v);
enumEditor.text = v;
builder.OnValueChanged?.Invoke(null);
});
};
enumEditor.SetEnabled(!icm.IsLocked);
return(enumEditor);
}
public static VisualElement BuildEnumEditor(this IConstantEditorBuilder builder, EnumConstantNodeModel enumConstant)
{
void TriggerOnValueChange(Enum newEnumValue)
{
var oldValue = enumConstant.value;
var newValue = enumConstant.value;
newValue.Value = Convert.ToInt32(newEnumValue);
builder.TriggerOnValueChanged(oldValue, newValue);
}
Type enumType = enumConstant.EnumType.Resolve(enumConstant.GraphModel.Stencil);
VisualElement editor = enumType == typeof(KeyCode)
? BuildSearcherEnumEditor(enumConstant.EnumValue, enumType, TriggerOnValueChange)
: BuildFieldEnumEditor(enumConstant, TriggerOnValueChange);
editor.SetEnabled(!enumConstant.IsLocked);
return(editor);
}
static VisualElement BuildEnumEditor(IConstantEditorBuilder builder, EnumValueReference enumConstant)
{
void TriggerOnValueChange(Enum newEnumValue)
{
var oldValue = enumConstant;
var newValue = new EnumValueReference(newEnumValue);
using (var evt = ChangeEvent <EnumValueReference> .GetPooled(oldValue, newValue))
builder.OnValueChanged(evt);
}
Type enumType = enumConstant.EnumType.Resolve();
VisualElement editor = enumType == typeof(KeyCode)
? BuildSearcherEnumEditor(enumConstant, enumType, TriggerOnValueChange)
: BuildEnumFieldEditor(enumConstant, TriggerOnValueChange);
editor?.SetEnabled(!builder.ConstantIsLocked);
return(editor);
}
public static VisualElement BuildQuaternionEditor(this IConstantEditorBuilder builder, ConstantNodeModel <Quaternion> q)
{
var root = new VisualElement();
root.styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.TemplatePath + "ConstantEditors.uss"));
root.AddToClassList("vs-inline-float-editor");
CreateField("x", builder, root, q.value, q.value.x, ChangeX);
CreateField("y", builder, root, q.value, q.value.y, ChangeY);
CreateField("z", builder, root, q.value, q.value.z, ChangeZ);
CreateField("w", builder, root, q.value, q.value.w, ChangeW);
return(root);
//Local Functions
Quaternion ChangeX(ChangeEvent <float> evt) => new Quaternion(evt.newValue, q.value.y, q.value.z, q.value.w);
Quaternion ChangeY(ChangeEvent <float> evt) => new Quaternion(q.value.x, evt.newValue, q.value.z, q.value.w);
Quaternion ChangeZ(ChangeEvent <float> evt) => new Quaternion(q.value.x, q.value.y, evt.newValue, q.value.w);
Quaternion ChangeW(ChangeEvent <float> evt) => new Quaternion(q.value.x, q.value.y, q.value.z, evt.newValue);
}
static InlineFloatEditor MakeVectorEditor <T, V, F>(this IConstantEditorBuilder builder, IVectorType <T, V> vectorType, Func <string, V, F> makeField) where F : BaseField <V>
{
var editor = new InlineFloatEditor();
for (int i = 0; i < vectorType.FieldNames.Count; i++)
{
var field = makeField(vectorType.FieldNames[i], vectorType.GetField(i));
editor.Add(field);
var fieldIndex = i; // apparently safer...
field.RegisterValueChangedCallback(evt =>
{
var oldValue = vectorType.Value;
vectorType.SetField(fieldIndex, evt.newValue);
using (ChangeEvent <T> other = ChangeEvent <T> .GetPooled(oldValue, vectorType.Value))
builder.OnValueChanged(other);
});
}
return(editor);
}
public static VisualElement BuildDoubleEditor(this IConstantEditorBuilder builder, ConstantNodeModel <double> d)
{
return(builder.BuildSingleFieldEditor(d.value, new DoubleField()));
}
public static VisualElement BuildQuaternionEditor(this IConstantEditorBuilder builder, ConstantNodeModel <Quaternion> q)
{
return(builder.MakeFloatVectorEditor(q, 4,
(vec, i) => vec[i], (ref Quaternion data, int i, float value) => data[i] = value));
}
public static VisualElement BuildFloat4Editor(this IConstantEditorBuilder builder, ConstantNodeModel <Vector4, float4> v)
{
return(builder.BuildVectorEditor(new EditableFloatVectorType(v, "m_NodeModel.value", new [] { "x", "y", "z", "w" })));
}
public static VisualElement BuildQuaternionEditor(this IConstantEditorBuilder builder, ConstantNodeModel <Quaternion> q)
{
return(null);
}
public static VisualElement BuildVector3Editor(this IConstantEditorBuilder builder, ConstantNodeModel <Vector3> v)
{
return(builder.MakeFloatVectorEditor(v, 3,
(vec, i) => vec[i], (ref Vector3 data, int i, float value) => data[i] = value));
}
public static InlineFloatEditor MakeFloatVectorEditor <T>(this IConstantEditorBuilder builder, ConstantNodeModel <T> model, int vectorSize, Func <T, int, float> getField, VectorType <T, float> .SetFieldDelegate setField)
{
var fieldNames = s_VectorParamNames.Take(vectorSize).Select(c => c.ToString());
return(builder.MakeFloatVectorEditor(model, fieldNames, getField, setField));
}
public static VisualElement BuildStringEditor(this IConstantEditorBuilder builder, ConstantNodeModel <string> s)
{
return(builder.BuildSingleFieldEditor(s.value, new TextField()));
}
public static VisualElement BuildColorEditor(this IConstantEditorBuilder builder, ConstantNodeModel <Color> c)
{
return(builder.BuildSingleFieldEditor(c.value, new ColorField()));
}
public static VisualElement BuildBoolEditor(this IConstantEditorBuilder builder, ConstantNodeModel <bool> b)
{
return(builder.BuildSingleFieldEditor(b.value, new Toggle()));
}
public static VisualElement BuildIntEditor(this IConstantEditorBuilder builder, ConstantNodeModel <int> i)
{
return(builder.BuildSingleFieldEditor(i.value, new IntegerField()));
}
static void Dispatch <T>(IConstantEditorBuilder builder, T oldValue, T newValue)
{
using (ChangeEvent <T> other = ChangeEvent <T> .GetPooled(oldValue, newValue))
builder.OnValueChanged(other);
}
public static VisualElement BuildDefaultConstantEditor(this IConstantEditorBuilder builder, IConstant constant)
{
if (constant.Type == typeof(float))
{
return(BuildInlineValueEditor(constant.ObjectValue, new FloatField(), builder.OnValueChanged));
}
if (constant.Type == typeof(double))
{
return(BuildInlineValueEditor(constant.ObjectValue, new DoubleField(), builder.OnValueChanged));
}
if (constant.Type == typeof(int))
{
return(BuildInlineValueEditor(constant.ObjectValue, new IntegerField(), builder.OnValueChanged));
}
if (constant.Type == typeof(long))
{
return(BuildInlineValueEditor(constant.ObjectValue, new LongField(), builder.OnValueChanged));
}
if (constant.Type == typeof(bool))
{
return(BuildInlineValueEditor(constant.ObjectValue, new Toggle(), builder.OnValueChanged));
}
if (constant.Type == typeof(string))
{
return(BuildInlineValueEditor(constant.ObjectValue, new TextField(), builder.OnValueChanged));
}
if (constant.Type == typeof(Color))
{
return(BuildInlineValueEditor(constant.ObjectValue, new ColorField(), builder.OnValueChanged));
}
if (constant.Type == typeof(Vector2))
{
return(BuildInlineValueEditor(constant.ObjectValue, new Vector2Field(), builder.OnValueChanged));
}
if (constant.Type == typeof(Vector3))
{
return(BuildInlineValueEditor(constant.ObjectValue, new Vector3Field(), builder.OnValueChanged));
}
if (constant.Type == typeof(Vector4))
{
return(BuildInlineValueEditor(constant.ObjectValue, new Vector4Field(), builder.OnValueChanged));
}
if (constant.Type == typeof(GameObject))
{
return(BuildInlineValueEditor(constant.ObjectValue,
new ObjectField {
allowSceneObjects = true, objectType = constant.Type
},
builder.OnValueChanged));
}
if (typeof(Object).IsAssignableFrom(constant.Type))
{
return(BuildInlineValueEditor(constant.ObjectValue,
new ObjectField {
allowSceneObjects = false, objectType = constant.Type
},
builder.OnValueChanged));
}
if (constant.Type == typeof(EnumValueReference))
{
return(BuildEnumEditor(builder, (EnumValueReference)constant.ObjectValue));
}
return(null);
}
public static VisualElement BuildFloatEditor(this IConstantEditorBuilder builder, ConstantNodeModel <float> f)
{
return(builder.BuildSingleFieldEditor(f.value, new FloatField()));
}
public static VisualElement BuildFloat4Editor(this IConstantEditorBuilder builder, ConstantNodeModel <float4> f)
{
return(builder.MakeFloatVectorEditor(f, 4,
(vec, i) => vec[i], (ref float4 data, int i, float value) => data[i] = value));
}
public static void TriggerOnValueChanged <T>(this IConstantEditorBuilder builder, T oldValue, T newValue)
{
using (ChangeEvent <T> other = ChangeEvent <T> .GetPooled(oldValue, newValue))
builder.OnValueChanged(other);
}
