public static VisualElement GetElementOfFloatField(float startValue, string fieldName, Action <object> setValue, Action <object> getValue)
{
FloatField field = new FloatField(fieldName);
field.SetValueWithoutNotify(startValue);
field.RegisterValueChangedCallback(s => setValue.Invoke(s.newValue));
getValue += o => field.SetValueWithoutNotify((float)o);
return(field);
}
public ValueSlider(string label, float start, float end, SliderDirection direction, int pageSize,
float defaultValue = 0f) : base(label, start, end, direction, pageSize)
{
var newFloatField = new FloatField();
value = defaultValue;
this.RegisterValueChangedCallback(evt => { newFloatField.SetValueWithoutNotify(evt.newValue); });
newFloatField.RegisterValueChangedCallback(evt => { value = evt.newValue; });
Add(newFloatField);
newFloatField.SetValueWithoutNotify(value);
}
static void ClampFloatFieldValue(float value, FloatField ff)
{
(float item1, float item2) = k_FloatFieldRanges[ff];
if (value < item1)
{
ff.SetValueWithoutNotify(item1);
}
else if (value > item2)
{
ff.SetValueWithoutNotify(item2);
}
}
VisualElement CreateLightExposureContent()
{
var exposure = SceneView.s_DrawModeExposure;
var root = new VisualElement();
root.AddToClassList(k_SliderRowClass);
var icon = new Image()
{
name = "exposure-label"
};
m_ExposureSlider = new Slider(-m_ExposureMax, m_ExposureMax)
{
name = "exposure-slider"
};
m_ExposureSlider.AddToClassList(k_SliderClass);
m_ExposureSlider.RegisterValueChangedCallback(SetBakedExposure);
m_ExposureSlider.SetValueWithoutNotify(exposure);
m_ExposureField = new FloatField()
{
name = "exposure-float-field"
};
m_ExposureField.AddToClassList(k_SliderFloatFieldClass);
m_ExposureField.RegisterValueChangedCallback(SetBakedExposure);
m_ExposureField.SetValueWithoutNotify(exposure);
root.Add(icon);
root.Add(m_ExposureSlider);
root.Add(m_ExposureField);
return(root);
}
public virtual void LoadData(AnimationGraphView graphView, NodeAsset nodeAsset, Dictionary <NodeAsset, BaseNodeUI> nodeMap)
{
ID = string.IsNullOrEmpty(nodeAsset.ID) ? Guid.NewGuid().ToString() : nodeAsset.ID;
NameField.SetValueWithoutNotify(string.IsNullOrEmpty(nodeAsset.Data.Name) ? DefaultName : nodeAsset.Data.Name);
_speedField.SetValueWithoutNotify(nodeAsset.Data.Speed);
}
public BaseNodeUI()
{
VisualElement container = new VisualElement();
title = DefaultName;
Label titleLabel = (Label)titleContainer[0];
titleContainer.RemoveAt(0);
NameField = new TextField();
NameField.style.flexGrow = 1f;
container.Add(titleLabel);
container.Add(NameField);
titleContainer.Insert(0, container);
_speedField = new FloatField("Speed");
_speedField.SetValueWithoutNotify(1f);
_speedField.AddToClassList("speed-field");
mainContainer.Insert(1, _speedField);
RefreshExpandedState();
RefreshPorts();
}
VisualElement CreateSliderWithField(GUIContent label, float value, float min, float max, EventCallback <ChangeEvent <float> > callback)
{
var root = new VisualElement()
{
name = "Slider Float Field"
};
root.AddToClassList(k_SliderRowClass);
var slider = new Slider(min, max);
slider.AddToClassList(k_SliderClass);
slider.RegisterValueChangedCallback(callback);
slider.SetValueWithoutNotify(value);
if (label != null && !string.IsNullOrEmpty(label.text))
{
slider.label = label.text;
slider.tooltip = label.tooltip;
}
var field = new FloatField();
field.AddToClassList(k_SliderFloatFieldClass);
field.RegisterValueChangedCallback(callback);
field.SetValueWithoutNotify(value);
root.Add(slider);
root.Add(field);
return(root);
}
public void Bind(TransitionInfoCondition condition)
{
_condition = condition;
if (_parameterFinder.Item != null)
{
_parameterFinder.Item.OnTypeChanged -= ParameterTypeChanged;
}
_parameterFinder.SelectItemWithoutNotify(_condition.Parameter, true);
if (_parameterFinder.Item != null)
{
_parameterFinder.Item.OnTypeChanged += ParameterTypeChanged;
}
_stateFinder.SelectItemWithoutNotify(_condition.State, true);
_stateValueProvider.SetValueWithoutNotify(_condition.StateValueProvider);
SetProviderSourceType(_condition.ProviderSourceType);
_boolComparisonValueField.SetValueWithoutNotify(_condition.BoolComparisonValue ? Bool.True : Bool.False);
_intComparisonField.SetValueWithoutNotify(_condition.IntComparison);
_intComparisonValueField.SetValueWithoutNotify(_condition.IntComparisonValue);
_floatComparisonField.SetValueWithoutNotify(_condition.FloatComparison);
_floatComparisonValueField.SetValueWithoutNotify(_condition.FloatComparisonValue);
}
public void LoadData(Parameter parameter)
{
Name = parameter.Name;
ParameterTypeField.SetValueWithoutNotify(parameter.Type);
ChangeParameterType(parameter.Type, default);
switch (parameter.ValueProvider)
{
case BoolProvider boolProvider:
BoolField.SetValueWithoutNotify(boolProvider.Value);
break;
case IntProvider intProvider:
IntField.SetValueWithoutNotify(intProvider.Value);
break;
case FloatProvider floatProvider:
FloatField.SetValueWithoutNotify(floatProvider.Value);
break;
default:
break;
}
}
void SetFPSLabelText()
{
if (TaggedClip != null && TaggedClip.Valid)
{
if (ActiveTick.style.display == DisplayStyle.Flex)
{
if (TimelineUnits == TimelineViewMode.frames)
{
m_ActiveTimeField.SetValueWithoutNotify(ActiveTime * TaggedClip.SampleRate);
}
else
{
m_ActiveTimeField.SetValueWithoutNotify(ActiveTime);
}
}
}
}
public override void Update()
{
var value = TypeConversion.Convert <TValue, float>(Target);
if (value != m_ValueField.value)
{
m_ValueField.SetValueWithoutNotify(TypeConversion.Convert <TValue, float>(Target));
}
}
public static void RenderFloatProperty(VisualElement container, string name, object value,
Action <object> setter)
{
var field = new FloatField(name);
field.SetValueWithoutNotify((float)value);
field.MarkDirtyRepaint();
field.RegisterValueChangedCallback(evt => setter(evt.newValue));
container.Add(field);
}
protected override void OnEnable()
{
base.OnEnable();
rootVisualElement.styleSheets.Add((StyleSheet)EditorGUIUtility.Load("StyleSheets/SceneViewToolbarElements/SnapWindowsCommon.uss"));
rootVisualElement.Add(new SnapSettingsHeader(L10n.Tr("Increment Snapping"), ResetValues));
// Move
m_MoveLinkedField = new LinkedVector3Field(L10n.Tr("Move"))
{
name = "Move"
};
m_MoveLinkedField.value = EditorSnapSettings.move;
m_MoveLinkedField.linked = Mathf.Approximately(m_MoveLinkedField.value.x, m_MoveLinkedField.value.y) &&
Mathf.Approximately(m_MoveLinkedField.value.x, m_MoveLinkedField.value.z);
rootVisualElement.Add(m_MoveLinkedField);
EditorSnapSettings.moveChanged += (value) => m_MoveLinkedField.SetValueWithoutNotify(value);
m_MoveLinkedField.RegisterValueChangedCallback(OnMoveValueChanged);
// Rotate
var rotate = new FloatField(L10n.Tr("Rotate"))
{
name = "Rotate"
};
rotate.value = EditorSnapSettings.rotate;
rootVisualElement.Add(rotate);
EditorSnapSettings.rotateChanged += (value) => rotate.SetValueWithoutNotify(value);
rotate.RegisterValueChangedCallback(evt =>
{
EditorSnapSettings.rotate = evt.newValue;
EditorSnapSettings.Save();
});
// Scale
var scale = new FloatField(L10n.Tr("Scale"))
{
name = "Scale"
};
scale.value = EditorSnapSettings.scale;
rootVisualElement.Add(scale);
EditorSnapSettings.scaleChanged += (value) => scale.SetValueWithoutNotify(value);
scale.RegisterValueChangedCallback(evt =>
{
EditorSnapSettings.scale = evt.newValue;
EditorSnapSettings.Save();
});
}
private void BindTransitionFields(TransitionInfo transition)
{
DurationTypeField.SetValueWithoutNotify(transition.DurationType);
DurationField.SetValueWithoutNotify(transition.Duration);
OffsetTypeField.SetValueWithoutNotify(transition.OffsetType);
OffsetField.SetValueWithoutNotify(transition.Offset);
InterruptionSourceField.SetValueWithoutNotify(transition.InterruptionSource);
OrderedInterruptionToggle.SetValueWithoutNotify(transition.OrderedInterruption);
InterruptableByAnyStateToggle.SetValueWithoutNotify(transition.InterruptableByAnyState);
PlayAfterTransitionToggle.SetValueWithoutNotify(transition.PlayAfterTransition);
_conditions.itemsSource = transition.Conditions;
_conditions.selectedIndex = -1;
_conditions.Refresh();
}
public override void Update()
{
_isCreatedField.SetValueWithoutNotify(Target.Collider.IsCreated);
unsafe
{
long address = (long)Target.Collider.GetUnsafePtr();
_addressField.SetValueWithoutNotify(address);
}
if (Target.Collider.IsCreated)
{
_radiusField.SetValueWithoutNotify(Target.Collider.Value.Radius);
_typeField.SetValueWithoutNotify(Target.Collider.Value.ColliderType);
}
}
private void OnRadiusSliderChange(ChangeEvent <float> evt)
{
var value = Math.Pow(evt.newValue, 10) * 10000;
if (value >= 10)
{
value = Math.Round(value, 0);
}
else
{
value = Math.Round(value, 4);
}
_radiusInput.SetValueWithoutNotify((float)value);
_star.Radius = (float)value;
EditorUtility.SetDirty(_star);
}
public void Bind(Environment environment)
{
this.environment = environment;
if (environment == null || environment.Equals(null))
{
return;
}
if (latlong != null && !latlong.Equals(null))
{
latlong.image = GetLatLongThumbnailTexture();
}
skyCubemapField.SetValueWithoutNotify(environment.sky.cubemap);
skyRotationOffset.SetValueWithoutNotify(environment.sky.rotation);
skyExposureField.SetValueWithoutNotify(environment.sky.exposure);
shadowCubemapField.SetValueWithoutNotify(environment.shadow.cubemap);
sunPosition.SetValueWithoutNotify(new Vector2(environment.shadow.sunLongitude, environment.shadow.sunLatitude));
shadowColor.SetValueWithoutNotify(environment.shadow.color);
environmentName.SetValueWithoutNotify(environment.name);
}
void SetBakedExposure(ChangeEvent <float> evt)
{
var value = Mathf.Clamp(evt.newValue, -k_ExposureSliderAbsoluteMax, k_ExposureSliderAbsoluteMax);
// This will allow the user to set a new max value for the current session
if (Mathf.Abs(value) > m_ExposureMax)
{
m_ExposureMax = Mathf.Min(k_ExposureSliderAbsoluteMax, Mathf.Abs(value));
m_ExposureSlider.lowValue = -m_ExposureMax;
m_ExposureSlider.highValue = m_ExposureMax;
}
m_ExposureSlider.SetValueWithoutNotify(value);
if (evt.target != m_ExposureField || evt.newValue != 0)
{
m_ExposureField.SetValueWithoutNotify(value);
}
SceneView.s_DrawModeExposure.value = value;
}
public void RefreshSettingsValues()
{
outputSizeMode?.SetValueWithoutNotify(settings.sizeMode);
outputDimension?.SetValueWithoutNotify(settings.dimension);
outputChannels?.SetValueWithoutNotify(settings.outputChannels);
outputPrecision?.SetValueWithoutNotify(settings.outputPrecision);
wrapMode?.SetValueWithoutNotify(settings.wrapMode);
filterMode?.SetValueWithoutNotify(settings.filterMode);
potSize?.SetValueWithoutNotify(settings.potSize);
outputWidth?.SetValueWithoutNotify(settings.width);
outputWidthScale?.SetValueWithoutNotify(SizeScaleToInt(settings.widthScale));
outputHeight?.SetValueWithoutNotify(settings.height);
outputHeightScale?.SetValueWithoutNotify(SizeScaleToInt(settings.heightScale));
outputDepth?.SetValueWithoutNotify(settings.depth);
outputDepthScale?.SetValueWithoutNotify(SizeScaleToInt(settings.depthScale));
doubleBuffered?.SetValueWithoutNotify(settings.doubleBuffered);
refreshMode?.SetValueWithoutNotify(settings.refreshMode);
period?.SetValueWithoutNotify(settings.period);
}
public override VisualElement CreateInspectorGUI()
{
m_Root = new VisualElement();
UIElementsUtils.ApplyStyleSheet(BuilderWindow.k_Stylesheet, m_Root);
UIElementsUtils.CloneTemplateInto(k_TemplatePath, m_Root);
m_Root.AddToClassList("mainContainer");
m_Asset = target as Asset;
m_Asset.BuildStarted += BuildStarted;
m_Asset.BuildStopped += BuildStopped;
m_AssetSettingsInput = m_Root.Q <VisualElement>("assetSettings");
//set restrictions on asset settings
var sampleRateInput = m_AssetSettingsInput.Q <FloatField>("sampleRate");
sampleRateInput.isDelayed = true;
var sampleRateSlider = m_AssetSettingsInput.Q <Slider>("sampleRateSlider");
float sampleRate = Mathf.Clamp(m_Asset.SampleRate, 1f, m_Asset.SampleRate);
sampleRateInput.value = sampleRate;
sampleRateSlider.value = sampleRate;
sampleRateInput.RegisterValueChangedCallback(evt =>
{
float newSampleRate = Mathf.Clamp(evt.newValue, k_MinSampleRate, k_MaxSampleRate);
m_Asset.SampleRate = newSampleRate;
sampleRateSlider.SetValueWithoutNotify(newSampleRate);
ClampTimeHorizonInput(1f / newSampleRate);
});
sampleRateSlider.RegisterValueChangedCallback(evt =>
{
float newSampleRate = Mathf.Clamp(evt.newValue, k_MinSampleRate, k_MaxSampleRate);
m_Asset.SampleRate = newSampleRate;
sampleRateInput.SetValueWithoutNotify(newSampleRate);
ClampTimeHorizonInput(1f / newSampleRate);
});
sampleRateInput.SetFloatFieldRange(sampleRateSlider.lowValue, sampleRateSlider.highValue);
m_TimeHorizonInput = m_AssetSettingsInput.Q <FloatField>("timeHorizon");
m_TimeHorizonInput.isDelayed = true;
m_TimeHorizonSlider = m_AssetSettingsInput.Q <Slider>("timeHorizonSlider");
m_TimeHorizonSlider.value = m_Asset.TimeHorizon;
m_TimeHorizonInput.value = m_Asset.TimeHorizon;
m_TimeHorizonInput.RegisterValueChangedCallback(evt =>
{
float newTimeHorizon = Mathf.Clamp(evt.newValue, k_MinTimeHorizon, k_MaxTimeHorizon);
m_Asset.TimeHorizon = newTimeHorizon;
m_TimeHorizonSlider.SetValueWithoutNotify(newTimeHorizon);
});
m_TimeHorizonSlider.RegisterValueChangedCallback(evt =>
{
float newTimeHorizon = Mathf.Clamp(evt.newValue, k_MinTimeHorizon, k_MaxTimeHorizon);
m_Asset.TimeHorizon = newTimeHorizon;
m_TimeHorizonInput.SetValueWithoutNotify(newTimeHorizon);
});
m_TimeHorizonSlider.lowValue = 1f / sampleRateSlider.lowValue;
m_TimeHorizonInput.SetFloatFieldRange(m_TimeHorizonSlider.lowValue, m_TimeHorizonSlider.highValue);
var avatarSelector = m_Root.Q <ObjectField>("destinationAvatar");
avatarSelector.objectType = typeof(Avatar);
avatarSelector.value = m_Asset.DestinationAvatar;
avatarSelector.RegisterValueChangedCallback(OnAvatarSelectionChanged);
UIElementsUtils.ApplyStyleSheet(k_Stylesheet, m_Root);
m_MetricsEditor = new MetricsEditor(m_Asset);
m_Root.Q <VisualElement>("metrics").Add(m_MetricsEditor);
var buildButton = m_Root.Q <Button>("buildButton");
buildButton.clickable.clicked += BuildButtonClicked;
if (EditorApplication.isPlaying || m_Asset.BuildInProgress)
{
SetInputEnabled(false);
}
EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
return(m_Root);
}
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);
}
public override void SetValueWithoutNotify(float newValue)
{
base.SetValueWithoutNotify(newValue);
m_Slider.SetValueWithoutNotify(newValue);
m_FloatField.SetValueWithoutNotify(newValue);
}
void OnCostChanged(float _newCost)
{
costField.SetValueWithoutNotify(_newCost);
}
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;
}
protected override void Refresh()
{
_slider.SetValueWithoutNotify(Value);
_minText.SetValueWithoutNotify(Value.x);
_maxText.SetValueWithoutNotify(Value.y);
}
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 = 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 void SetValueWithoutNotify(float value)
{
m_SecondsField.SetValueWithoutNotify(value);
m_FrameField.SetValueWithoutNotify(Mathematics.Missing.roundToInt(value * m_Clip.SampleRate));
}
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);
}
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)
{
var o = new ObjectField();
o.objectType = typeof(FontAsset);
field = o;
SetField(field);
}
else
{
field = (ObjectField)ElementAt(0);
}
}
else
{
field = GetOrCreateObjectField <Font>();
}
if (!IsFocused(field))
{
field.SetValueWithoutNotify(fontDefinition.fontAsset != null ? (UnityEngine.Object)fontDefinition.fontAsset : (UnityEngine.Object)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.GetComputedStyleValue(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.GetComputedStyleValue(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 if (val is Rotate rotate)
{
FloatField floatField = GetOrCreateFields <FloatField, float>(m_PropertyName, 0);
if (!IsFocused(floatField))
{
floatField.SetValueWithoutNotify(rotate.angle.value);
}
Add(m_SpecificityLabel);
SetSpecificity(specificity);
}
else if (val is Scale scale)
{
Vector3Field vector3Field = GetOrCreateFields <Vector3Field, Vector3>(m_PropertyName, 0);
if (!IsFocused(vector3Field))
{
vector3Field.SetValueWithoutNotify(scale.value);
}
Add(m_SpecificityLabel);
SetSpecificity(specificity);
}
else if (val is Translate translate)
{
StyleLengthField fieldx = GetOrCreateFields <StyleLengthField, StyleLength>(m_PropertyName, 0);
if (!IsFocused(fieldx))
{
fieldx.SetValueWithoutNotify(translate.x);
}
StyleLengthField fieldy = GetOrCreateFields <StyleLengthField, StyleLength>("y", 1);
if (!IsFocused(fieldy))
{
fieldy.SetValueWithoutNotify(translate.x);
}
FloatField floatField = GetOrCreateFields <FloatField, float>("z", 2);
if (!IsFocused(floatField))
{
floatField.SetValueWithoutNotify(translate.z);
}
Add(m_SpecificityLabel);
SetSpecificity(specificity);
SetEnabled(false);
}
else if (val is TransformOrigin transformOrigin)
{
StyleLengthField fieldx = GetOrCreateFields <StyleLengthField, StyleLength>(m_PropertyName, 0);
if (!IsFocused(fieldx))
{
fieldx.SetValueWithoutNotify(transformOrigin.x);
}
StyleLengthField fieldy = GetOrCreateFields <StyleLengthField, StyleLength>("y", 1);
if (!IsFocused(fieldy))
{
fieldy.SetValueWithoutNotify(transformOrigin.x);
}
FloatField floatField = GetOrCreateFields <FloatField, float>("z", 2);
if (!IsFocused(floatField))
{
floatField.SetValueWithoutNotify(transformOrigin.z);
}
Add(m_SpecificityLabel);
SetSpecificity(specificity);
SetEnabled(false);
}
else if (val is Enum)
{
Enum enumValue = (Enum)val;
EnumField field = GetOrCreateEnumField(enumValue);
if (!IsFocused(field))
{
field.SetValueWithoutNotify(enumValue);
}
}
else
{
var type = val.GetType();
Debug.Assert(type.IsArrayOrList(), "Expected List type");
var listValue = val as System.Collections.IList;
var valueString = listValue[0].ToString();
for (int i = 1; i < listValue.Count; i++)
{
valueString += $", {listValue[i]}";
}
TextField field = GetOrCreateField <TextField, string>();
if (!IsFocused(field))
{
field.SetValueWithoutNotify(valueString);
}
}
SetSpecificity(specificity);
}
private void AddMainUI(VisualElement mainView)
{
var visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Packages/com.unity.2d.sprite/Editor/UI/SpriteEditor/SpriteFrameModuleInspector.uxml") as VisualTreeAsset;
m_SelectedFrameInspector = visualTree.CloneTree().Q("spriteFrameModuleInspector");
m_NameElement = m_SelectedFrameInspector.Q("name");
m_NameField = m_SelectedFrameInspector.Q <TextField>("spriteName");
m_NameField.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
selectedSpriteName = evt.newValue;
}
});
m_NameField.RegisterCallback <FocusOutEvent>((focus) =>
{
if (hasSelected)
{
m_NameField.SetValueWithoutNotify(selectedSpriteName);
}
});
m_PositionElement = m_SelectedFrameInspector.Q("position");
m_PositionFieldX = m_PositionElement.Q <IntegerField>("positionX");
m_PositionFieldX.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.x = evt.newValue;
selectedSpriteRect = rect;
UpdatePositionField(selectedSpriteRect);
}
});
m_PositionFieldY = m_PositionElement.Q <IntegerField>("positionY");
m_PositionFieldY.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.y = evt.newValue;
selectedSpriteRect = rect;
UpdatePositionField(selectedSpriteRect);
}
});
m_PositionFieldW = m_PositionElement.Q <IntegerField>("positionW");
m_PositionFieldW.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.width = evt.newValue;
selectedSpriteRect = rect;
UpdatePositionField(selectedSpriteRect);
}
});
m_PositionFieldH = m_PositionElement.Q <IntegerField>("positionH");
m_PositionFieldH.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var rect = selectedSpriteRect;
rect.height = evt.newValue;
selectedSpriteRect = rect;
UpdatePositionField(selectedSpriteRect);
}
});
var borderElement = m_SelectedFrameInspector.Q("border");
m_BorderFieldL = borderElement.Q <IntegerField>("borderL");
m_BorderFieldL.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.x = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldL.SetValueWithoutNotify((int)selectedSpriteBorder.x);
}
});
m_BorderFieldT = borderElement.Q <IntegerField>("borderT");
m_BorderFieldT.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.w = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldT.SetValueWithoutNotify((int)selectedSpriteBorder.w);
evt.StopPropagation();
}
});
m_BorderFieldR = borderElement.Q <IntegerField>("borderR");
m_BorderFieldR.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.z = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldR.SetValueWithoutNotify((int)selectedSpriteBorder.z);
}
});
m_BorderFieldB = borderElement.Q <IntegerField>("borderB");
m_BorderFieldB.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
var border = selectedSpriteBorder;
border.y = evt.newValue;
selectedSpriteBorder = border;
m_BorderFieldB.SetValueWithoutNotify((int)selectedSpriteBorder.y);
}
});
m_PivotField = m_SelectedFrameInspector.Q <EnumField>("pivotField");
m_PivotField.Init(SpriteAlignment.Center);
m_PivotField.label = L10n.Tr("Pivot");
m_PivotField.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
SpriteAlignment alignment = (SpriteAlignment)evt.newValue;
SetSpritePivotAndAlignment(selectedSpritePivot, alignment);
m_CustomPivotElement.SetEnabled(selectedSpriteAlignment == SpriteAlignment.Custom);
Vector2 pivot = selectedSpritePivotInCurUnitMode;
m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);
}
});
m_PivotUnitModeField = m_SelectedFrameInspector.Q <EnumField>("pivotUnitModeField");
m_PivotUnitModeField.Init(PivotUnitMode.Normalized);
m_PivotUnitModeField.label = L10n.Tr("Pivot Unit Mode");
m_PivotUnitModeField.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
m_PivotUnitMode = (PivotUnitMode)evt.newValue;
Vector2 pivot = selectedSpritePivotInCurUnitMode;
m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);
}
});
m_CustomPivotElement = m_SelectedFrameInspector.Q("customPivot");
m_CustomPivotFieldX = m_CustomPivotElement.Q <FloatField>("customPivotX");
m_CustomPivotFieldX.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
float newValue = (float)evt.newValue;
float pivotX = m_PivotUnitMode == PivotUnitMode.Pixels
? ConvertFromRectToNormalizedSpace(new Vector2(newValue, 0.0f), selectedSpriteRect).x
: newValue;
var pivot = selectedSpritePivot;
pivot.x = pivotX;
SetSpritePivotAndAlignment(pivot, selectedSpriteAlignment);
}
});
m_CustomPivotFieldY = m_CustomPivotElement.Q <FloatField>("customPivotY");
m_CustomPivotFieldY.RegisterValueChangedCallback((evt) =>
{
if (hasSelected)
{
float newValue = (float)evt.newValue;
float pivotY = m_PivotUnitMode == PivotUnitMode.Pixels
? ConvertFromRectToNormalizedSpace(new Vector2(0.0f, newValue), selectedSpriteRect).y
: newValue;
var pivot = selectedSpritePivot;
pivot.y = pivotY;
SetSpritePivotAndAlignment(pivot, selectedSpriteAlignment);
}
});
//// Force an update of all the fields.
PopulateSpriteFrameInspectorField();
mainView.RegisterCallback <SpriteSelectionChangeEvent>(SelectionChange);
// Stop mouse events from reaching the main view.
m_SelectedFrameInspector.pickingMode = PickingMode.Ignore;
m_SelectedFrameInspector.RegisterCallback <MouseDownEvent>((e) => { e.StopPropagation(); });
m_SelectedFrameInspector.RegisterCallback <MouseUpEvent>((e) => { e.StopPropagation(); });
m_SelectedFrameInspector.AddToClassList("moduleWindow");
m_SelectedFrameInspector.AddToClassList("bottomRightFloating");
mainView.Add(m_SelectedFrameInspector);
}