FloatField AddField(VisualElement panel, string label, int index, Vector3 initValiue)
{
var field = new FloatField {
userData = index, value = initValiue[index]
};
if (label != "")
{
var l = new Label(label);
panel.Add(l);
var dragger = new FieldMouseDragger <double>(field);
dragger.SetDragZone(l);
}
field.RegisterCallback <MouseDownEvent>(Repaint);
field.RegisterCallback <MouseMoveEvent>(Repaint);
field.OnValueChanged(evt =>
{
var value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
value[index] = (float)evt.newValue;
m_PropertyInfo.SetValue(m_Node, value, null);
m_UndoGroup = -1;
UpdateSlider(m_SliderPanel, index, value);
this.MarkDirtyRepaint();
});
field.RegisterCallback <InputEvent>(evt =>
{
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
}
float newValue;
if (!float.TryParse(evt.newData, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out newValue))
{
newValue = 0f;
}
var value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
value[index] = newValue;
m_PropertyInfo.SetValue(m_Node, value, null);
this.MarkDirtyRepaint();
});
field.RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
m_Value = (Vector3)m_PropertyInfo.GetValue(m_Node, null);
UpdateSlider(m_SliderPanel, index, m_Value);
evt.StopPropagation();
}
this.MarkDirtyRepaint();
});
panel.Add(field);
return(field);
}
void AddField(int index, string subLabel)
{
var dummy = new VisualElement {
name = "dummy"
};
var label = new Label(subLabel);
dummy.Add(label);
Add(dummy);
var field = new FloatField {
userData = index, value = m_Value[index]
};
var dragger = new FieldMouseDragger <double>(field);
dragger.SetDragZone(label);
field.RegisterCallback <MouseDownEvent>(Repaint);
field.RegisterCallback <MouseMoveEvent>(Repaint);
field.OnValueChanged(evt =>
{
var value = GetValue();
value[index] = (float)evt.newValue;
SetValue(value);
m_UndoGroup = -1;
this.MarkDirtyRepaint();
});
field.RegisterCallback <InputEvent>(evt =>
{
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
}
float newValue;
if (!float.TryParse(evt.newData, out newValue))
{
newValue = 0f;
}
var value = GetValue();
value[index] = newValue;
SetValue(value);
this.MarkDirtyRepaint();
});
field.RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
m_Value = GetValue();
evt.StopPropagation();
}
this.MarkDirtyRepaint();
});
Add(field);
}
void AddField(Vector4 initialValue, int index, string subLabel)
{
var dummy = new VisualElement {
name = "dummy"
};
var label = new Label(subLabel);
dummy.Add(label);
Add(dummy);
var field = new FloatField {
userData = index, value = initialValue[index]
};
var dragger = new FieldMouseDragger <double>(field);
dragger.SetDragZone(label);
field.OnValueChanged(evt =>
{
var value = m_Get();
value[index] = (float)evt.newValue;
m_Set(value);
m_Node.Dirty(ModificationScope.Node);
m_UndoGroup = -1;
});
field.RegisterCallback <InputEvent>(evt =>
{
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
}
float newValue;
if (!float.TryParse(evt.newData, out newValue))
{
newValue = 0f;
}
var value = m_Get();
if (Math.Abs(value[index] - newValue) > 1e-9)
{
value[index] = newValue;
m_Set(value);
m_Node.Dirty(ModificationScope.Node);
}
});
field.RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
evt.StopPropagation();
}
Dirty(ChangeType.Repaint);
});
Add(field);
}
FloatField AddField(VisualElement panel, Slider slider, int index, DielectricSpecularNode.DielectricMaterial initMaterial)
{
float initValue;
if (index == 1)
{
initValue = initMaterial.indexOfRefraction;
}
else
{
initValue = initMaterial.range;
}
var field = new FloatField {
userData = index, value = initValue
};
field.RegisterCallback <MouseDownEvent>(Repaint);
field.RegisterCallback <MouseMoveEvent>(Repaint);
field.RegisterValueChangedCallback(evt =>
{
var fieldValue = (float)evt.newValue;
if (index == 1)
{
m_DielectricMaterial.indexOfRefraction = fieldValue;
}
else
{
m_DielectricMaterial.range = fieldValue;
}
m_PropertyInfo.SetValue(m_Node, m_DielectricMaterial, null);
this.MarkDirtyRepaint();
});
field.Q("unity-text-input").RegisterCallback <FocusOutEvent>(evt =>
{
if (index == 1)
{
RedrawIORControls(m_DielectricMaterial.indexOfRefraction);
}
else
{
RedrawRangeControls(m_DielectricMaterial.range);
}
this.MarkDirtyRepaint();
});
panel.Add(field);
return(field);
}
public void OpenClipsTransitionsModal(MVideoClip clip, MTransition transition)
{
var modalContent = this.ShowModalWindow("Transition");
// Create a new field and assign it its value.
var TypeField = new EnumField("Type:", transition.Type);
modalContent.Add(TypeField);
var durationField = new FloatField("Duration:");
durationField.value = transition.duration;
modalContent.Add(durationField);
TypeField.RegisterCallback <ChangeEvent <System.Enum> >((evt) =>
{
transition.Type = (MTransition.TransitionType)evt.newValue;
});
durationField.RegisterCallback <ChangeEvent <float> >((evt) =>
{
transition.duration = evt.newValue;
});
}
protected override void SetBaseVisualElement(VisualElement visualElement)
{
Vector3Field originField = new Vector3Field("Origin: ")
{
value = Blueprint.Origin
};
originField.RegisterCallback <ChangeEvent <Vector3> >(evt => Blueprint.SetOrigin(evt.newValue));
visualElement.Add(originField);
FloatField lengthField = new FloatField("Length: ")
{
value = Blueprint.Length
};
lengthField.RegisterCallback <ChangeEvent <float> >(evt => Blueprint.SetLength(evt.newValue));
visualElement.Add(lengthField);
// visualElement.Add(new ValidatorField(Blueprint.NonZeroVolumeValidator));
for (int i = 0; i < Blueprint.Points.Count; i++)
{
int pointNum = i;
TextField nameField = new TextField((pointNum + 1).GetOrdinalForm() + " Point name: ")
{
value = Blueprint.Points[i].PointName
};
nameField.RegisterCallback <ChangeEvent <string> >(evt => Blueprint.SetPointName(pointNum, evt.newValue));
visualElement.Add(nameField);
visualElement.Add(new ValidatorField(Blueprint.Points[i].NameNotEmptyValidator));
visualElement.Add(new ValidatorField(Blueprint.Points[i].NameUniquenessValidator));
visualElement.Add(new ValidatorField(Blueprint.Points[i].PositionUniquenessValidator));
}
}
public override VisualElement CreateInspectorGUI()
{
var root = _root;
UI.CloneTree(_root);
// Name
_name = root.Query <TextField>("Name").First();
_name.value = _star.Name;
_name.RegisterCallback <ChangeEvent <string> >(OnNameChange);
// Color
var _color = root.Query <ColorField>("Color").First();
_color.value = _star.Color;
_color.RegisterCallback <ChangeEvent <Color> >(OnColorChange);
// Radius's power slider
_radiusSlider = root.Query <Slider>("RadiusSlider").First();
_radiusSlider.value = CalcSliderPosFromRadius(_star.Radius);
_radiusSlider.RegisterCallback <ChangeEvent <float> >(OnRadiusSliderChange);
_radiusInput = root.Query <FloatField>("RadiusInput").First();
_radiusInput.value = _star.Radius;
_radiusInput.RegisterCallback <ChangeEvent <float> >(OnRadiusInputChange);
_radiusInput.maxLength = 5;
// Gravity well radius
_gravityWellSlider = root.Query <Slider>("GravityWellSlider").First();
_gravityWellSlider.value = _star.GravityWellRadius;
_gravityWellSlider.RegisterCallback <ChangeEvent <float> >(OnGravityWellSliderChange);
return(root);
}
public static void SetFloatFieldRange(this FloatField field, float min = float.MinValue, float max = float.MaxValue)
{
k_FloatFieldRanges[field] = new Tuple <float, float>(min, max);
field.RegisterValueChangedCallback(OnFloatFieldValueChanged);
field.RegisterCallback <DetachFromPanelEvent>(OnFloatFieldDetachedFromPanel);
ClampFloatFieldValue(field.value, field);
}
private void BindFields()
{
m_ScaleModeField.RegisterCallback <ChangeEvent <Enum> >(evt =>
UpdateScaleModeValues((PanelScaleModes)evt.newValue));
m_ScreenMatchModeField.RegisterCallback <ChangeEvent <Enum> >(evt =>
UpdateScreenMatchModeValues((PanelScreenMatchModes)evt.newValue));
m_ClearColorField.RegisterCallback <ChangeEvent <bool> >(evt =>
UpdateColorClearValue(evt.newValue));
m_SortOrderField.RegisterCallback <ChangeEvent <float> >(evt => SetSortOrder(evt));
}
void AddField(Vector4 initialValue, int index, string subLabel)
{
var dummy = new VisualElement {
name = "dummy"
};
var label = new Label(subLabel);
dummy.Add(label);
Add(dummy);
var field = new FloatField {
userData = index, value = initialValue[index]
};
var dragger = new FieldMouseDragger <float>(field);
dragger.SetDragZone(label);
field.RegisterValueChangedCallback(evt =>
{
var value = _get();
value[index] = (float)evt.newValue;
_set(value);
_nodeEditor.SetDirty();
_undoGroup = -1;
});
field.RegisterCallback <InputEvent>(evt =>
{
if (_undoGroup == -1)
{
_undoGroup = Undo.GetCurrentGroup();
_nodeEditor.Owner.LogicGraphEditorObject.RegisterCompleteObjectUndo("Change " + _nodeEditor.NodeType());
}
if (!float.TryParse(evt.newData, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out var newValue))
{
newValue = 0f;
}
var value = _get();
if (Math.Abs(value[index] - newValue) > 1e-9)
{
value[index] = newValue;
_set(value);
_nodeEditor.SetDirty();
}
});
field.RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && _undoGroup > -1)
{
Undo.RevertAllDownToGroup(_undoGroup);
_undoGroup = -1;
evt.StopPropagation();
}
MarkDirtyRepaint();
});
Add(field);
}
public PlanetSubEditor(OrbitLineSubEditor orbitLineSubEditor, Planet planet)
{
this.orbitLineSubEditor = orbitLineSubEditor;
this.planet = planet;
VisualTreeAsset visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Examples/StarSystemScene/Scripts/Editor/StarSystemEditor/PlanetSubEditor.uxml");
visualTree.CloneTree(this);
StyleSheet stylesheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Examples/StarSystemScene/Scripts/Editor/StarSystemEditor/PlanetSubEditor.uss");
this.styleSheets.Add(stylesheet);
this.AddToClassList("planetSubeditor");
#region Fields
TextField nameField = this.Query <TextField>("planetName").First();
nameField.value = planet.name;
nameField.RegisterCallback <ChangeEvent <string> >(
e =>
{
planet.name = (string)e.newValue;
EditorUtility.SetDirty(planet);
}
);
FloatField scaleField = this.Query <FloatField>("planetScale").First();
scaleField.value = planet.scale;
scaleField.RegisterCallback <ChangeEvent <float> >(
e =>
{
planet.scale = e.newValue;
EditorUtility.SetDirty(planet);
}
);
FloatField speedField = this.Query <FloatField>("planetSpeed").First();
speedField.value = planet.speed;
speedField.RegisterCallback <ChangeEvent <float> >(
e =>
{
planet.speed = e.newValue;
EditorUtility.SetDirty(planet);
}
);
#endregion
#region Buttons
Button btnRemovePlanet = this.Query <Button>("btnRemove").First();
btnRemovePlanet.clickable.clicked += RemovePlanet;
#endregion
}
void SetWindSetArtistTool()
{
VisualElement root = rootVisualElement;
root.Clear();
//Loads and clones our VisualTree inside the root.
VisualTreeAsset quickToolVisualTree = Resources.Load <VisualTreeAsset>("WindArtistTool");
quickToolVisualTree.CloneTree(root);
root.styleSheets.Add(Resources.Load <StyleSheet>("WindArtistTool"));
#region Wind Shader
// Set Initial Values
VisualElement windComponent = root.Q <VisualElement>(name: "Wind");
if (windComponent != null)
{
Vector4Field windDirectionQuaternion = windComponent.Q <Vector4Field>(name: "WindDirection");
windDirectionQuaternion.value = GetWindDirection();
FloatField windScaleFloat = windComponent.Q <FloatField>(name: "WindScale");
windScaleFloat.value = GetWindScale();
MinMaxValue minMaxStrength = GetWindStrength();
VisualElement windStrengthHolder = windComponent.Q <VisualElement>(name: "WinStrengthHolder");
MinMaxSlider windStrengthSlider = windStrengthHolder.Q <MinMaxSlider>(name: "WindStrength");
windStrengthSlider.highLimit = minMaxStrength.HighLimit;
windStrengthSlider.lowLimit = minMaxStrength.LowLimit;
windStrengthSlider.value = new Vector2(minMaxStrength.minValue, minMaxStrength.maxValue);
windStrengthHolder.Q <Label>(name: "MinValue").text = "Min Value :" + minMaxStrength.minValue;
windStrengthHolder.Q <Label>(name: "MaxValue").text = "Max Value :" + minMaxStrength.maxValue;
FloatField windSpeedFloat = windComponent.Q <FloatField>(name: "WindSpeed");
windSpeedFloat.value = GetWindSpeed();
//Set Callbacks values
windDirectionQuaternion.RegisterCallback <ChangeEvent <Vector4> >(ChangeWindDirection);
windScaleFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindScale);
windStrengthSlider.RegisterCallback <ChangeEvent <Vector2> >(ChangeWindStrength);
windSpeedFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindSpeed);
}
#endregion
root.Q <Button>(name: "SaveButton").clicked += SaveButton;
root.Q <Button>(name: "ResetButton").clicked += ResetToInitialSceneValues;
}
protected override void SetBaseVisualElement(VisualElement visualElement)
{
VisualElement nameField = new TextField("Name")
{
value = Blueprint.PointData.PointName
};
nameField.RegisterCallback <ChangeEvent <string> >(evt => Blueprint.PointData.SetName(evt.newValue));
visualElement.Add(nameField);
visualElement.Add(new ValidatorField(Blueprint.PointData.NameNotEmptyValidator));
visualElement.Add(new ValidatorField(Blueprint.PointData.NameUniquenessValidator));
visualElement.Add(new ValidatorField(Blueprint.PointData.PositionUniquenessValidator));
visualElement.Add(new ChoseShapeDataField <PointData>(
Blueprint.ShapeDataFactory,
Blueprint,
"Source Point: ",
() => Blueprint.SourcePoint,
pointData => Blueprint.SetSourcePoint(pointData)));
visualElement.Add(new ChoseShapeDataField <PointData>(
Blueprint.ShapeDataFactory,
Blueprint,
"Second point: ",
() => Blueprint.SecondPoint,
pointData => Blueprint.SetSecondPoint(pointData)));
visualElement.Add(new ValidatorField(Blueprint.PointsNotSameValidator));
visualElement.Add(new ChoseShapeDataField <PointData>(
Blueprint.ShapeDataFactory,
Blueprint,
"Third point: ",
() => Blueprint.ThirdPoint,
pointData => Blueprint.SetThirdPoint(pointData)));
FloatField coefficient1Field = new FloatField("Coefficient1: ")
{
value = Blueprint.Coefficient1
};
coefficient1Field.RegisterCallback <ChangeEvent <float> >(evt => Blueprint.SetCoefficient1(evt.newValue));
visualElement.Add(coefficient1Field);
FloatField coefficient2Field = new FloatField("Coefficient2: ")
{
value = Blueprint.Coefficient2
};
coefficient2Field.RegisterCallback <ChangeEvent <float> >(evt => Blueprint.SetCoefficient2(evt.newValue));
visualElement.Add(coefficient2Field);
}
public override VisualElement CreateInspectorGUI()
{
#region Fields
// Find the visual element with the name "systemSprite" and make it display the star system sprite if it has one.
VisualElement systemSprite = rootElement.Query <VisualElement>("systemSprite").First();
systemSprite.style.backgroundImage = starSystem.sprite ? starSystem.sprite.texture : null;
// Find an object field with the name "systemSpriteField", set that it only accepts objects of type Sprite,
// set its initial value and register a callback that will occur if the value of the filed changes.
ObjectField spriteField = rootElement.Query <ObjectField>("systemSpriteField").First();
spriteField.objectType = typeof(Sprite);
spriteField.value = starSystem.sprite;
spriteField.RegisterCallback <ChangeEvent <Object> >(
e =>
{
starSystem.sprite = (Sprite)e.newValue;
systemSprite.style.backgroundImage = starSystem.sprite.texture;
// Set StarSystem as being dirty. This tells the editor that there have been changes made to the asset and that it requires a save.
EditorUtility.SetDirty(starSystem);
}
);
FloatField scaleField = rootElement.Query <FloatField>("starScale").First();
scaleField.value = starSystem.scale;
scaleField.RegisterCallback <ChangeEvent <float> >(
e => {
starSystem.scale = e.newValue;
EditorUtility.SetDirty(starSystem);
}
);
#endregion
#region Display Planet Data
// Store visual element that will contain the planet sub-inspectors.
planetList = rootElement.Query <VisualElement>("planetList").First();
UpdatePlanets();
#endregion
#region Buttons
// Assign methods to the click events of the two buttons.
Button btnAddPlanet = rootElement.Query <Button>("btnAddNew").First();
btnAddPlanet.clickable.clicked += AddPlanet;
Button btnRemoveAllPlanets = rootElement.Query <Button>("btnRemoveAll").First();
btnRemoveAllPlanets.clickable.clicked += RemoveAll;
#endregion
return(rootElement);
}
protected override void SetBaseVisualElement(VisualElement visualElement)
{
m_VerticesCountField = new IntegerField("Vertices Count: ")
{
value = Blueprint.VerticesAtTheBaseCount
};
m_VerticesCountField.RegisterCallback <ChangeEvent <int> >(evt => SetVerticesCount(evt.newValue));
visualElement.Add(m_VerticesCountField);
visualElement.Add(m_CantChangeVerticesCount);
Vector3Field originField = new Vector3Field("Origin: ")
{
value = Blueprint.Origin
};
originField.RegisterCallback <ChangeEvent <Vector3> >(evt => Blueprint.SetOrigin(evt.newValue));
visualElement.Add(originField);
Vector3Field offsetField = new Vector3Field("Offset: ")
{
value = Blueprint.Offset
};
offsetField.RegisterCallback <ChangeEvent <Vector3> >(evt => Blueprint.SetOffset(evt.newValue));
visualElement.Add(offsetField);
FloatField radiusField = new FloatField("Radius: ")
{
value = Blueprint.Radius
};
radiusField.RegisterCallback <ChangeEvent <float> >(evt => Blueprint.SetRadius(evt.newValue));
visualElement.Add(radiusField);
// visualElement.Add(new ValidatorField(Blueprint.NonZeroVolumeValidator));
Label namesLabel = new Label("Points Names");
namesLabel.AddToClassList("sub-header");
visualElement.Add(namesLabel);
m_PointNameFields = new VisualElement();
visualElement.Add(m_PointNameFields);
Blueprint.DependenciesUpdated.Subscribe(UpdateVerticesCountFieldAvailability);
UpdateVerticesCountFieldAvailability();
UpdatePointNameFields();
}
public VFXFloatSliderField()
{
m_Slider = new Slider(0, 1, ValueChanged, SliderDirection.Horizontal, (range.y - range.x) * 0.1f);
m_Slider.AddToClassList("textfield");
m_Slider.valueChanged += ValueChanged;
m_FloatField = new FloatField();
m_FloatField.RegisterCallback <ChangeEvent <float> >(ValueChanged);
m_FloatField.name = "Field";
m_Field = m_FloatField;
m_IndeterminateLabel = new Label()
{
name = "indeterminate",
text = VFXControlConstants.indeterminateText
};
m_IndeterminateLabel.SetEnabled(false);
Add(m_Slider);
Add(m_FloatField);
RegisterCallBack();
}
void SetArtistTool()
{
VisualElement root = rootVisualElement;
root.Clear();
VisualTreeAsset ArtistToolVisualTree = Resources.Load <VisualTreeAsset>("ArtistTool");
ArtistToolVisualTree.CloneTree(root);
root.styleSheets.Add(Resources.Load <StyleSheet>("ArtistTool"));
SerializedObject Tso = new SerializedObject(TimeController);
Slider timeSlider = root.Q <Slider>(name: "Time");
timeSlider.Bind(Tso);
#region SkyColor
VisualElement gradientVisualElement = root.Q <VisualElement>(name: "SkyGradient");
if (gradientVisualElement != null)
{
GradientField gradientField = gradientVisualElement.Q <GradientField>();
if (gradientField != null)
{
skyColorSetter = GameObject.Find("Light - Sky").GetComponent <MaterialColorSetter>();
SerializedObject serialized_MaterialSetter = new SerializedObject(skyColorSetter);
gradientField.bindingPath = "gradient";
gradientField.Bind(serialized_MaterialSetter);
gradientVisualElement.Q <Label>().text = "Sky Gradient";
}
}
#endregion
#region Ruins
GradientEditorSetter("RuinsGradient", "Ruins Gradient", RuinsColorSetter);
#endregion
#region Trees
GradientEditorSetter("TreesGradient", "Trees Gradient", TreesColorSetter);
#endregion
#region Rim
GradientEditorSetter("RimColor", "Rim Gradient", RimColorSetter);
#endregion
#region Lights
#region SunLights
SerializedObject serialized_SunSpot = new SerializedObject(SunSpot_Group);
VisualElement sunLightVisualElement = root.Q <VisualElement>(name: "Sunlight");
if (sunLightVisualElement.Q <VisualElement>(name: "LightGradient") != null)
{
GradientField sunLightGradient = sunLightVisualElement.Q <VisualElement>(name: "LightGradient").Q <GradientField>();
FloatField sunLightIntensity = root.Q <FloatField>(name: "Intensity");
if (sunLightGradient != null)
{
sunLightGradient.bindingPath = "gradient";
sunLightGradient.Bind(serialized_SunSpot);
sunLightGradient.label = "Gradient";
}
sunLightIntensity.value = GetSpotLightIntensity();
sunLightIntensity.RegisterCallback <ChangeEvent <float> >(ChangeIntensitySpotLightsEvent);
}
#endregion
#region GrassLight
SerializedObject serialized_GrassLight_Group = new SerializedObject(GrassLight_Group);
VisualElement grassLightVisualElement = root.Q <VisualElement>(name: "GrassLight");
if (grassLightVisualElement.Q <VisualElement>(name: "LightGradient") != null)
{
GradientField grassLightGradient = grassLightVisualElement.Q <VisualElement>(name: "LightGradient").Q <GradientField>();
FloatField grassLightIntensity = grassLightVisualElement.Q <FloatField>(name: "Intensity");
if (grassLightGradient != null)
{
grassLightGradient.bindingPath = "gradient";
grassLightGradient.Bind(serialized_GrassLight_Group);
grassLightGradient.label = "Gradient";
}
grassLightIntensity.value = GrassLight.intensity;
SerializedObject serialized_GrassLight = new SerializedObject(GrassLight);
grassLightIntensity.Bind(serialized_GrassLight);
}
#endregion
#region cave Light
SerializedObject serialized_CaveHoleLight = new SerializedObject(CaveHoleLight);
VisualElement caveLightVisualElement = root.Q <VisualElement>(name: "CaveHoleLight");
caveLightVisualElement.Q <FloatField>(name: "Falloff").Bind(serialized_CaveHoleLight);
Slider fallOffSlider = caveLightVisualElement.Q <Slider>(name: "FalloffIntencity");
FloatField fallOffField = fallOffSlider.Q <FloatField>(name: "CurrentValue");
fallOffSlider.Bind(serialized_CaveHoleLight);
fallOffField.SetValueWithoutNotify(CaveHoleLight.falloffIntensity);
fallOffField.RegisterCallback <ChangeEvent <float> >((evt) => fallOffSlider.value = evt.newValue);
fallOffSlider.RegisterCallback <ChangeEvent <float> >((evt) => fallOffField.SetValueWithoutNotify(evt.newValue));
#endregion
#region Visualisers
var AllGradientElements = root.Query <GradientField>();
AllGradientElements.ForEach((element) =>
{
//registerCallback for Gradient to apply changes on scene
element.RegisterCallback <ChangeEvent <Gradient> >(ChangeGradientEvent);
VisualElement visualiser = element.Q <VisualElement>(name: "VisualisationColor");
//Init color of visualisation cube
float currentTime = TimeController.timeValue;
visualiser.style.backgroundColor = element.value.Evaluate(currentTime);
//register Callback for each visualisation cube when gradient Changes
element.RegisterCallback <ChangeEvent <Gradient> >((evt) =>
{
float timeOfChange = TimeController.timeValue;
visualiser.style.backgroundColor = evt.newValue.Evaluate(currentTime);
});
//register Callback for each visualisation cube when Time Changes
timeSlider.RegisterCallback <ChangeEvent <float> >((evt) =>
{
visualiser.style.backgroundColor = element.value.Evaluate(evt.newValue);
});
});
#endregion
#endregion
#region Wind Shader
// Set Initial Values
VisualElement windComponent = root.Q <VisualElement>(name: "Wind");
if (windComponent != null)
{
Vector4Field windDirectionQuaternion = windComponent.Q <Vector4Field>(name: "WindDirection");
windDirectionQuaternion.value = GetWindDirection();
FloatField windScaleFloat = windComponent.Q <FloatField>(name: "WindScale");
windScaleFloat.value = GetWindScale();
MinMaxValue minMaxStrength = GetWindStrength();
VisualElement windStrengthHolder = windComponent.Q <VisualElement>(name: "WinStrengthHolder");
MinMaxSlider windStrengthSlider = windStrengthHolder.Q <MinMaxSlider>(name: "WindStrength");
windStrengthSlider.highLimit = minMaxStrength.HighLimit;
windStrengthSlider.lowLimit = minMaxStrength.LowLimit;
windStrengthSlider.value = new Vector2(minMaxStrength.minValue, minMaxStrength.maxValue);
windStrengthHolder.Q <Label>(name: "MinValue").text = "Min Value :" + minMaxStrength.minValue;
windStrengthHolder.Q <Label>(name: "MaxValue").text = "Max Value :" + minMaxStrength.maxValue;
FloatField windSpeedFloat = windComponent.Q <FloatField>(name: "WindSpeed");
windSpeedFloat.value = GetWindSpeed();
//Set Callbacks values
windDirectionQuaternion.RegisterCallback <ChangeEvent <Vector4> >(ChangeWindDirection);
windScaleFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindScale);
windStrengthSlider.RegisterCallback <ChangeEvent <Vector2> >(ChangeWindStrength);
windSpeedFloat.RegisterCallback <ChangeEvent <float> >(ChangeWindSpeed);
}
#endregion
#region Postprocessing
#region WhiteBalance
//serialize White balance property
SerializedObject serialized_whiteBalanceProperty = new SerializedObject(whiteBalanceProperty);
//Get White balance Visual Element
VisualElement whiteBalanceVisualElement = root.Q <VisualElement>(name: "WhiteBalance");
#region Temperature
//Get White Balance temperature Visual Element
VisualElement whiteBalanceTemperatureVE = whiteBalanceVisualElement.Q <VisualElement>(name: "Temperature");
//Get White Balance temperature Slider
Slider whiteBalanceTemperatureSlider = whiteBalanceTemperatureVE.Q <Slider>(name: "SliderValue");
//Bind Slider to value
whiteBalanceTemperatureSlider.bindingPath = "temperature.m_Value";
whiteBalanceTemperatureSlider.Bind(serialized_whiteBalanceProperty);
//Get White Balance temperature Float Field
FloatField whiteBalanceTemperatureFloat = whiteBalanceTemperatureVE.Q <FloatField>(name: "CurrentValue");
//Set default Temperature
whiteBalanceTemperatureFloat.SetValueWithoutNotify(whiteBalanceProperty.temperature.value);
//Register change callback for the float field to change the slider value. Changing slider value will change the values bound with it.
whiteBalanceTemperatureFloat.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTemperatureSlider.value = evt.newValue);
//Register change Callback for the slider, to change the float fiel Without notification (to avoid triggering Float field callback)
whiteBalanceTemperatureSlider.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTemperatureFloat.SetValueWithoutNotify(evt.newValue));
#endregion
#region Tint
//Get White Balance Tint Visual Element
VisualElement whiteBalanceTintVE = whiteBalanceVisualElement.Q <VisualElement>(name: "Tint");
//Get White Balance Tint Slider
Slider whiteBalanceTintSlider = whiteBalanceTintVE.Q <Slider>(name: "SliderValue");
//Bind Slider to value
whiteBalanceTintSlider.bindingPath = "tint.m_Value";
whiteBalanceTintSlider.Bind(serialized_whiteBalanceProperty);
//Get White Balance Tint Float Field
FloatField whiteBalanceTintFloat = whiteBalanceTintVE.Q <FloatField>(name: "CurrentValue");
//Set default Tint
whiteBalanceTintFloat.SetValueWithoutNotify(whiteBalanceProperty.tint.value);
//Register change callback for the float field to change the slider value. Changing slider value will change the values bound with it.
whiteBalanceTintFloat.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTintSlider.value = evt.newValue);
//Register change Callback for the slider, to change the float fiel Without notification (to avoid triggering Float field callback)
whiteBalanceTintSlider.RegisterCallback <ChangeEvent <float> >((evt) => whiteBalanceTintFloat.SetValueWithoutNotify(evt.newValue));
#endregion
#endregion
#region Bloom
//serialize bloom property
SerializedObject serialized_BloomProperty = new SerializedObject(BloomProperty);
//Get Bloom Visual Element
VisualElement bloomVisualElement = root.Q <VisualElement>(name: "Bloom");
//Get Bloom Tint Color
ColorField bloomTint = bloomVisualElement.Q <ColorField>(name: "Tint");
//Bind color to value
bloomTint.bindingPath = "tint.m_Value";
bloomTint.Bind(serialized_BloomProperty);
//Get Bloom Intensity
FloatField bloomIntensity = bloomVisualElement.Q <FloatField>(name: "Intensity");
//Bind Intensity to value
bloomIntensity.Bind(serialized_BloomProperty);
#endregion
#endregion
#region VFX
SerializedObject serialized_GlowParticleSystem = new SerializedObject(GlowParticleSystem);
VisualElement VFXVisualElement = root.Q <VisualElement>(name: "VFX");
VFXVisualElement.Q <FloatField>(name: "Emission").bindingPath = "EmissionModule.rateOverTime.scalar";
VFXVisualElement.Q <FloatField>(name: "Emission").Bind(serialized_GlowParticleSystem);
VFXVisualElement.Q <EnumField>(name: "RenderMode").Init(GlowParticleSystem.GetComponent <ParticleSystemRenderer>().renderMode);
VFXVisualElement.Q <EnumField>(name: "RenderMode").RegisterCallback <ChangeEvent <string> >(ChangeRenderMode);
VFXVisualElement.Q <ObjectField>(name: "Material").objectType = typeof(Material);
VFXVisualElement.Q <ObjectField>(name: "Material").RegisterCallback <ChangeEvent <string> >(ChangeRenderMaterial);
#endregion
root.Q <Button>(name: "SaveButton").clicked += SaveButton;
root.Q <Button>(name: "ResetButton").clicked += ResetToInitialSceneValues;
}
public 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);
}
}
public void OnEnable()
{
VisualElement root = rootVisualElement;
VisualElement vt = Resources.Load <VisualTreeAsset>("Editor/SDFWizardMarkup").Instantiate();
vt.styleSheets.Add(Resources.Load <StyleSheet>("Editor/SDFWizardStyle"));
root.Add(vt);
Label dLabel = vt.Q <Label> (null, "dLabel");
Image dropBox = vt.Q <Image> ("DropBox");
SliderInt sizeSlider = vt.Q <SliderInt> ("SizeSlider");
IntegerField sizeField = vt.Q <IntegerField> ("SizeField");
Slider tresholdSlider = vt.Q <Slider> ("TresholdSlider");
FloatField tresholdField = vt.Q <FloatField> ("TresholdField");
SliderInt sampleSlider = vt.Q <SliderInt> ("SampleSlider");
IntegerField sampleField = vt.Q <IntegerField> ("SampleField");
EnumField channelSelect = vt.Q <EnumField> ("ChannelSelect");
Box channelDisplay = vt.Q <Box> ("ChannelDisplay");
EnumField modeSelect = vt.Q <EnumField> ("RenderingSelect");
EnumField tilingSelect = vt.Q <EnumField> ("TilingSelect");
channelSelect.Init(WizardUtils.ColorChannel.Alpha);
modeSelect.Init(SDFConverter.RenderingMode.DistanceOnly);
tilingSelect.Init(TextureWrapMode.Repeat);
bool validated = false;
dropBox.RegisterCallback <DragEnterEvent>((e) =>
{
foreach (var item in DragAndDrop.objectReferences)
{
if (item.GetType() == typeof(Texture2D))
{
validated = true;
}
}
dropBox.tintColor = validated ? new Color(.6f, .94f, .2f) : new Color(.94f, .3f, .2f);
dLabel.style.color = validated ? new Color(.6f, .94f, .2f) : new Color(.94f, .3f, .2f);
});
dropBox.RegisterCallback <DragUpdatedEvent>((e) =>
{
if (validated)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
}
});
dropBox.RegisterCallback <DragPerformEvent>((e) =>
{
if (validated)
{
for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
{
var item = (UnityEngine.Object)DragAndDrop.objectReferences[i];
string path = DragAndDrop.paths[i];
if (item.GetType() == typeof(Texture2D))
{
string newPath = path.Substring(0, path.LastIndexOf(".")) + "_SDF.png";
string systemPath = Application.dataPath.Substring(0, Application.dataPath.Length - 6) + newPath;
var texture = item as Texture2D;
texture.wrapMode = (TextureWrapMode)tilingSelect.value;
var outData = SDFConverter.RenderSDF(texture, sizeField.value, tresholdField.value, sampleField.value, channelSelect.value, modeSelect.value);
System.IO.File.WriteAllBytes(systemPath, outData.EncodeToPNG());
AssetDatabase.Refresh();
var importer = (TextureImporter)AssetImporter.GetAtPath(newPath);
var importerSettings = new TextureImporterSettings();
((TextureImporter)AssetImporter.GetAtPath(path)).ReadTextureSettings(importerSettings);
importer.SetTextureSettings(importerSettings);
importer.sRGBTexture &= modeSelect.value.Equals(SDFConverter.RenderingMode.RGBDistance);
importer.textureCompression = TextureImporterCompression.Uncompressed;
importer.SaveAndReimport();
AssetDatabase.ImportAsset(newPath);
}
}
}
});
dropBox.RegisterCallback <DragExitedEvent>((e) =>
{
validated = false;
dropBox.tintColor = Color.white;
dLabel.style.color = Color.white;
});
dropBox.RegisterCallback <DragLeaveEvent>((e) =>
{
validated = false;
dropBox.tintColor = Color.white;
dLabel.style.color = Color.white;
});
sizeSlider.RegisterCallback <ChangeEvent <int> >((e) =>
{
sizeField.value = 2 << e.newValue;
});
sizeField.RegisterCallback <ChangeEvent <int> >((e) =>
{
int c = 0;
int v = e.newValue;
while (v > 2)
{
c++; v >>= 1;
}
sizeSlider.value = c;
sizeField.value = 2 << c;
});
tresholdSlider.RegisterCallback <ChangeEvent <float> >((e) =>
{
tresholdField.value = 1f - e.newValue;
});
tresholdField.RegisterCallback <ChangeEvent <float> >((e) =>
{
tresholdSlider.value = 1f - e.newValue;
});
sampleSlider.RegisterCallback <ChangeEvent <int> >((e) =>
{
sampleField.value = e.newValue;
});
sampleField.RegisterCallback <ChangeEvent <int> >((e) =>
{
sampleSlider.value = e.newValue;
});
channelSelect.RegisterCallback <ChangeEvent <Enum> >((e) =>
{
switch (e.newValue)
{
case WizardUtils.ColorChannel.Red:
channelDisplay.style.backgroundColor = new Color(.94f, .3f, .2f);
break;
case WizardUtils.ColorChannel.Green:
channelDisplay.style.backgroundColor = new Color(.6f, .94f, .2f);
break;
case WizardUtils.ColorChannel.Blue:
channelDisplay.style.backgroundColor = new Color(.2f, .6f, .94f);
break;
case WizardUtils.ColorChannel.Alpha:
channelDisplay.style.backgroundColor = Color.grey;
break;
default:
channelDisplay.style.backgroundColor = Color.white;
break;
}
});
}
private void BindFields()
{
m_ParentField.RegisterCallback <ChangeEvent <Object> >(evt => UpdateValues());
m_PanelSettingsField.RegisterCallback <ChangeEvent <Object> >(evt => UpdateValues());
m_SortOrderField.RegisterCallback <ChangeEvent <float> >(evt => SetSortOrder(evt));
}
FloatField AddField(VisualElement panel, Slider slider, int index, DielectricSpecularNode.DielectricMaterial initMaterial)
{
float initValue;
if (index == 1)
{
initValue = initMaterial.indexOfRefraction;
}
else
{
initValue = initMaterial.range;
}
var field = new FloatField {
userData = index, value = initValue
};
field.RegisterCallback <MouseDownEvent>(Repaint);
field.RegisterCallback <MouseMoveEvent>(Repaint);
field.OnValueChanged(evt =>
{
var value = (DielectricSpecularNode.DielectricMaterial)m_PropertyInfo.GetValue(m_Node, null);
var fieldValue = (float)evt.newValue;
if (index == 1)
{
value.indexOfRefraction = fieldValue;
RedrawIORControls(fieldValue);
}
else
{
value.range = fieldValue;
RedrawRangeControls(fieldValue);
}
m_PropertyInfo.SetValue(m_Node, value, null);
m_UndoGroup = -1;
this.MarkDirtyRepaint();
});
field.RegisterCallback <InputEvent>(evt =>
{
if (m_UndoGroup == -1)
{
m_UndoGroup = Undo.GetCurrentGroup();
m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
}
float newValue;
if (!float.TryParse(evt.newData, out newValue))
{
newValue = 0f;
}
var value = (DielectricSpecularNode.DielectricMaterial)m_PropertyInfo.GetValue(m_Node, null);
if (index == 1)
{
value.indexOfRefraction = newValue;
}
else
{
value.range = newValue;
}
m_PropertyInfo.SetValue(m_Node, value, null);
this.MarkDirtyRepaint();
});
field.RegisterCallback <KeyDownEvent>(evt =>
{
if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1)
{
Undo.RevertAllDownToGroup(m_UndoGroup);
m_UndoGroup = -1;
var value = (DielectricSpecularNode.DielectricMaterial)m_PropertyInfo.GetValue(m_Node, null);
if (index == 1)
{
RedrawIORControls(value.indexOfRefraction);
}
else
{
RedrawRangeControls(value.range);
}
evt.StopPropagation();
}
this.MarkDirtyRepaint();
});
panel.Add(field);
return(field);
}
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 ResponseCurveEditor(UtilityAIConsiderationEditor utilityAIConsiderationEditor, ResponseCurve responseCurve)
{
this.utilityAIConsiderationEditor = utilityAIConsiderationEditor;
this.responseCurve = responseCurve;
VisualTreeAsset visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/UtilityAI/Scripts/Editor/Response Curve Editor/ResponseCurveEditor.uxml");
visualTree.CloneTree(this);
StyleSheet stylesheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/UtilityAI/Scripts/Editor/Response Curve Editor/ResponseCurveEditor.uss");
this.styleSheets.Add(stylesheet);
this.AddToClassList("responseCurveEditor");
EnumField curveTypeField = this.Query <EnumField>("curveType").First();
curveTypeField.Init(CurveType.Linear);
curveTypeField.value = responseCurve.curveType;
curveTypeField.RegisterCallback <ChangeEvent <Enum> >(
e =>
{
responseCurve.curveType = (CurveType)e.newValue;
utilityAIConsiderationEditor.UpdateResponseCurve();
}
);
FloatField xShiftField = this.Query <FloatField>("xShift").First();
xShiftField.value = responseCurve.xShift;
xShiftField.RegisterCallback <ChangeEvent <float> >(
e =>
{
responseCurve.xShift = (float)e.newValue;
utilityAIConsiderationEditor.UpdateResponseCurve();
}
);
FloatField yShiftField = this.Query <FloatField>("yShift").First();
yShiftField.value = responseCurve.yShift;
yShiftField.RegisterCallback <ChangeEvent <float> >(
e =>
{
responseCurve.yShift = (float)e.newValue;
utilityAIConsiderationEditor.UpdateResponseCurve();
}
);
FloatField slopeField = this.Query <FloatField>("slope").First();
slopeField.value = responseCurve.slope;
slopeField.RegisterCallback <ChangeEvent <float> >(
e =>
{
responseCurve.slope = (float)e.newValue;
utilityAIConsiderationEditor.UpdateResponseCurve();
}
);
FloatField exponentialField = this.Query <FloatField>("exponential").First();
exponentialField.value = responseCurve.exponential;
exponentialField.RegisterCallback <ChangeEvent <float> >(
e =>
{
responseCurve.exponential = (float)e.newValue;
utilityAIConsiderationEditor.UpdateResponseCurve();
}
);
Box box = new Box()
{
style =
{
flexGrow = 1,
marginTop = 5,
marginBottom = 5,
marginLeft = 5,
marginRight = 5,
height = 300,
}
};
this.Add(box);
VisualElement meshContainer = new VisualElement()
{
style = { flexGrow = 1, }
};
box.Add(meshContainer);
meshContainer.generateVisualContent += DrawGraph;
}
private void Init()
{
var uiAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Scripts/USS attempt/Editor/MyWindow.uxml");
Layout = uiAsset.CloneTree();
var myStyle = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Scripts/USS attempt/Editor/MyStylesheet.uss");
var myBox = new Box {
name = "myBox"
};
myBox.AddToClassList("My_Fancy_box");
input = new TextField("New Name");
myBox.Add(input);
var row = new VisualElement {
name = "row"
};
row.Add(new Label("Position"));
var x = new FloatField("x");
var y = new FloatField("y");
var z = new FloatField("z");
x.RegisterCallback <ChangeEvent <float> >(l => pos.x = x.value);
y.RegisterCallback <ChangeEvent <float> >(l => pos.y = y.value);
z.RegisterCallback <ChangeEvent <float> >(l => pos.z = z.value);
row.Add(x);
row.Add(y);
row.Add(z);
myBox.Add(row);
myBox.Q <TextField>().RegisterCallback <ChangeEvent <string> >(l => newName = (l.target as TextField).value);
doTheThing = new Button();
doTheThing.AddToClassList("Fancy__button");
doTheThing.text = "Do the thing...";
///Button Click methods????\\\
//doTheThing.clickable = new Clickable(delegate () { DoTheThing(); });
//doTheThing.clickable = new Clickable(l => DoTheThing());
//doTheThing.clickable = new Clickable(delegate () { DoTheThing(); }, 1, 1);
//doTheThing.clickable.clicked += DoTheThing;
//////Finally something worked
doTheThing.clickable.clickedWithEventInfo += GoDoThatThing();
///Button Click methods????\\\
myBox.Add(doTheThing);
Layout.Add(myBox);
rootVisualElement.styleSheets.Add(myStyle);
rootVisualElement.Add(Layout);
}
public void OpenProjectSettings(MProject project)
{
var ModalContent = this.ShowModalWindow("PROJECT SETTINGS");
var NameField = new TextField("Project Name: ");
NameField.value = project.ProjectName;
ModalContent.Add(NameField);
NameField.RegisterCallback <ChangeEvent <string> >((evt) =>
{
project.ProjectName = evt.newValue;
});
// Resolution Field.
var resolutionField = new PopupField <string>("Resolution: ", ResNames, project.ResolutionIndex);
//normalField.value = ResNames[0];
ModalContent.Add(resolutionField);
// Create a new field and assign it its value.
var framerateField = new PopupField <string>("FrameRate: ", FPSNames, project.FrameRateIndex);
ModalContent.Add(framerateField);
var customResField = new Vector2IntField("Custom:");
customResField.value = new Vector2Int(project.OutputWidth, project.OutputHeight);
customResField.style.display = (project.ResolutionIndex == CustomResIndex) ? DisplayStyle.Flex : DisplayStyle.None;
ModalContent.Add(customResField);
// Mirror value of uxml field into the C# field.
resolutionField.RegisterCallback <ChangeEvent <string> >((evt) =>
{
project.ResolutionIndex = ResNames.IndexOf(evt.newValue);
var size = this.ResSizes[project.ResolutionIndex];
project.OutputWidth = (int)size.x;
project.OutputHeight = (int)size.y;
customResField.style.display = (project.ResolutionIndex == CustomResIndex)
? DisplayStyle.Flex : DisplayStyle.None;
project.is360 = _360Indices.Contains(project.ResolutionIndex);
project.is360Stereo = (project.ResolutionIndex == _360StereoIndex);
});
framerateField.RegisterCallback <ChangeEvent <string> >((evt) =>
{
project.FrameRateIndex = FPSNames.IndexOf(evt.newValue);
project.FrameRate = this.FPSValues[project.FrameRateIndex];
});
customResField.RegisterCallback <ChangeEvent <Vector2Int> >((evt) =>
{
project.OutputWidth = evt.newValue.x;
project.OutputHeight = evt.newValue.y;
});
var toggleScreenShots = new Toggle("Capture ScreenShots:");
toggleScreenShots.value = project.TakeScreenShots;
ModalContent.Add(toggleScreenShots);
var ScreenShotsInterval = new FloatField("ScreenShots Interval (sec): ");
ScreenShotsInterval.value = project.ScreenShotsInterval;
ScreenShotsInterval.style.display = (project.TakeScreenShots) ? DisplayStyle.Flex : DisplayStyle.None;
ModalContent.Add(ScreenShotsInterval);
toggleScreenShots.RegisterCallback <ChangeEvent <bool> >((evt) =>
{
project.TakeScreenShots = evt.newValue;
ScreenShotsInterval.style.display = (project.TakeScreenShots) ? DisplayStyle.Flex : DisplayStyle.None;
});
ScreenShotsInterval.RegisterCallback <ChangeEvent <float> >((evt) =>
{
project.ScreenShotsInterval = evt.newValue;
});
var DeleteButton = new Button();
DeleteButton.text = "DELETE PROJECT";
DeleteButton.clicked += () => {
this.ShowConfirmDialog("Delete Project", "Are you sure?",
(bool confirm) => {
if (confirm)
{
this.m_MainWindow.DeleteProject(project);
}
else
{
this.OpenProjectSettings(project);
}
});
};
ModalContent.Add(DeleteButton);
}
public ChannelMixerControlView(string label, float minimum, float maximum, AbstractMaterialNode node, PropertyInfo propertyInfo)
{
m_Node = node;
m_PropertyInfo = propertyInfo;
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/ChannelMixerControlView"));
m_ChannelMixer = (ChannelMixerNode.ChannelMixer)m_PropertyInfo.GetValue(m_Node, null);
m_OutChannel = 0;
m_Minimum = minimum;
m_Maximum = maximum;
if (propertyInfo.PropertyType != typeof(ChannelMixerNode.ChannelMixer))
{
throw new ArgumentException("Property must be of type ChannelMixer.", "propertyInfo");
}
label = label ?? ObjectNames.NicifyVariableName(propertyInfo.Name);
if (!string.IsNullOrEmpty(label))
{
Add(new Label(label));
}
var buttonPanel = new VisualElement {
name = "buttonPanel"
};
Action changedOutputRed = () => OnClickButton(0);
var outputButtonRed = new Button(changedOutputRed);
outputButtonRed.Add(new Label("R"));
buttonPanel.Add(outputButtonRed);
Action changedOutputGreen = () => OnClickButton(1);
var outputButtonGreen = new Button(changedOutputGreen);
outputButtonGreen.Add(new Label("G"));
buttonPanel.Add(outputButtonGreen);
Action changedOutputBlue = () => OnClickButton(2);
var outputButtonBlue = new Button(changedOutputBlue);
outputButtonBlue.Add(new Label("B"));
buttonPanel.Add(outputButtonBlue);
Add(buttonPanel);
var redSliderPanel = new VisualElement {
name = "sliderPanel"
};
redSliderPanel.Add(new Label("R"));
Action <float> changedRedIn = (s) => { OnChangeSlider(s, 0); };
m_RedSlider = new Slider(m_Minimum, m_Maximum);
m_RedSlider.RegisterValueChangedCallback((evt) => OnChangeSlider(evt.newValue, 0));
redSliderPanel.Add(m_RedSlider);
m_RedInputField = new FloatField {
value = m_ChannelMixer.outRed.x
};
m_RedInputField.RegisterCallback <ChangeEvent <double>, int>(OnChangeInputField, 0);
redSliderPanel.Add(m_RedInputField);
Add(redSliderPanel);
var greenSliderPanel = new VisualElement {
name = "sliderPanel"
};
greenSliderPanel.Add(new Label("G"));
m_GreenSlider = new Slider(m_Minimum, m_Maximum);
m_GreenSlider.RegisterValueChangedCallback((evt) => OnChangeSlider(evt.newValue, 1));
greenSliderPanel.Add(m_GreenSlider);
m_GreenInputField = new FloatField {
value = m_ChannelMixer.outRed.y
};
m_GreenInputField.RegisterCallback <ChangeEvent <double>, int>(OnChangeInputField, 1);
greenSliderPanel.Add(m_GreenInputField);
Add(greenSliderPanel);
var blueSliderPanel = new VisualElement {
name = "sliderPanel"
};
blueSliderPanel.Add(new Label("B"));
m_BlueSlider = new Slider(m_Minimum, m_Maximum);
m_BlueSlider.RegisterValueChangedCallback((evt) => OnChangeSlider(evt.newValue, 2));
blueSliderPanel.Add(m_BlueSlider);
m_BlueInputField = new FloatField {
value = m_ChannelMixer.outRed.z
};
m_BlueInputField.RegisterCallback <ChangeEvent <double>, int>(OnChangeInputField, 2);
blueSliderPanel.Add(m_BlueInputField);
Add(blueSliderPanel);
m_Initialized = true;
ResetSliders();
}
public PlanetSubEditor(StarSystemEditor starSystemEditor, Planet planet)
{
this.starSystemEditor = starSystemEditor;
this.planet = planet;
VisualTreeAsset visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Scripts/Editor/Star System Editor/PlanetSubEditor.uxml");
visualTree.CloneTree(this);
StyleSheet stylesheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Scripts/Editor/Star System Editor/PlanetSubEditor.uss");
this.styleSheets.Add(stylesheet);
this.AddToClassList("planetSubeditor");
#region Fields
TextField nameField = this.Query <TextField>("planetName").First();
nameField.value = planet.name;
nameField.RegisterCallback <ChangeEvent <string> >(
e =>
{
planet.name = (string)e.newValue;
EditorUtility.SetDirty(planet);
}
);
// Sprite is displayed the same way as in the Star System Inspector
VisualElement planetSpriteDisplay = this.Query <VisualElement>("planetSpriteDisplay").First();
planetSpriteDisplay.style.backgroundImage = planet.sprite ? planet.sprite.texture : null;
ObjectField spriteField = this.Query <ObjectField>("planetSprite").First();
spriteField.objectType = typeof(Sprite);
spriteField.value = planet.sprite;
spriteField.RegisterCallback <ChangeEvent <Object> >(
e =>
{
planet.sprite = (Sprite)e.newValue;
planetSpriteDisplay.style.backgroundImage = planet.sprite.texture;
EditorUtility.SetDirty(planet);
}
);
FloatField scaleField = this.Query <FloatField>("planetScale").First();
scaleField.value = planet.scale;
scaleField.RegisterCallback <ChangeEvent <float> >(
e =>
{
planet.scale = e.newValue;
EditorUtility.SetDirty(planet);
}
);
FloatField distanceField = this.Query <FloatField>("planetDistance").First();
distanceField.value = planet.distance;
distanceField.RegisterCallback <ChangeEvent <float> >(
e =>
{
planet.distance = e.newValue;
EditorUtility.SetDirty(planet);
}
);
FloatField speedField = this.Query <FloatField>("planetSpeed").First();
speedField.value = planet.speed;
speedField.RegisterCallback <ChangeEvent <float> >(
e =>
{
planet.speed = e.newValue;
EditorUtility.SetDirty(planet);
}
);
#endregion
#region Buttons
Button btnAddPlanet = this.Query <Button>("btnRemove").First();
btnAddPlanet.clickable.clicked += RemovePlanet;
#endregion
}
