/// <inheritdoc />
public override void Initialize(LayoutElementsContainer layout)
{
base.Initialize(layout);
// Show instanced parameters to view/edit at runtime
if (Values.IsSingleObject && Editor.Instance.StateMachine.IsPlayMode)
{
var group = layout.Group("Parameters");
group.Panel.Open(false);
group.Panel.IndexInParent -= 2;
var animatedModel = (AnimatedModel)Values[0];
var parameters = animatedModel.Parameters;
for (int i = 0; i < parameters.Length; i++)
{
var param = parameters[i];
if (!param.IsPublic)
{
continue;
}
var id = param.Identifier;
var value = param.Value;
var valueType = Utilities.Utils.GetGraphParameterValueType(param.Type);
var valueContainer = new CustomValueContainer(
valueType,
value,
(instance, index) => animatedModel.GetParameterValue(id),
(instance, index, o) => animatedModel.SetParameterValue(id, o)
);
group.Property(param.Name, valueContainer);
}
}
}
/// <inheritdoc />
public override void Initialize(LayoutElementsContainer layout)
{
// Get the target options
_options = Options;
if (_options == null)
{
throw new ArgumentNullException();
}
int selectedIndex = -1;
bool hasDifferentTypes = Values.HasDifferentTypes;
var type = Type;
_type = type;
// Type
var typeEditor = layout.ComboBox("Type", "Type of the object value. Use it to change the object.");
for (int i = 0; i < _options.Length; i++)
{
typeEditor.ComboBox.AddItem(_options[i].Name);
selectedIndex = _options[i].Type == type ? i : selectedIndex;
}
typeEditor.ComboBox.SupportMultiSelect = false;
typeEditor.ComboBox.SelectedIndex = hasDifferentTypes ? -1 : selectedIndex;
typeEditor.ComboBox.SelectedIndexChanged += OnSelectedIndexChanged;
// Editing different types is not supported
if (Values.HasDifferentTypes)
{
var property = layout.AddPropertyItem("Value");
property.Label("Different Values");
return;
}
// Nothing to edit
if (Values.HasNull)
{
var property = layout.AddPropertyItem("Value");
property.Label("<null>");
return;
}
// Value
var values = new CustomValueContainer(type, (instance, index) => instance, (instance, index, value) => { });
values.AddRange(Values);
var editor = CustomEditorsUtil.CreateEditor(type);
layout.Property("Value", values, editor);
}
public override void Initialize(LayoutElementsContainer layout)
{
var window = ((PropertiesProxy)Values[0])._window;
var texture = window?.Asset;
if (texture == null || !texture.IsLoaded)
{
layout.Label("Loading...", TextAlignment.Center);
return;
}
// Texture info
var general = layout.Group("General");
general.Label("Format: " + texture.Format);
general.Label(string.Format("Size: {0}x{1}", texture.Width, texture.Height));
general.Label("Mip levels: " + texture.MipLevels);
general.Label("Memory usage: " + Utilities.Utils.FormatBytesCount(texture.TotalMemoryUsage));
// Texture properties
var properties = layout.Group("Properties");
var textureGroup = new CustomValueContainer(new ScriptType(typeof(int)), texture.TextureGroup,
(instance, index) => texture.TextureGroup,
(instance, index, value) =>
{
texture.TextureGroup = (int)value;
window.MarkAsEdited();
});
properties.Property("Texture Group", textureGroup, new TextureGroupEditor(), "The texture group used by this texture.");
// Import settings
base.Initialize(layout);
// Reimport
layout.Space(10);
var reimportButton = layout.Button("Reimport");
reimportButton.Button.Clicked += () => ((PropertiesProxy)Values[0]).Reimport();
}
/// <inheritdoc />
public override void Initialize(LayoutElementsContainer layout)
{
var window = Values[0] as IVisjectSurfaceWindow;
var asset = window?.VisjectAsset;
if (asset == null)
{
layout.Label("No parameters");
return;
}
if (asset.LastLoadFailed)
{
layout.Label("Failed to load asset");
return;
}
if (!asset.IsLoaded)
{
layout.Label("Loading...");
return;
}
var parameters = window.VisjectSurface.Parameters;
GroupElement lastGroup = null;
for (int i = 0; i < parameters.Count; i++)
{
var p = parameters[i];
if (!p.IsPublic)
{
continue;
}
var pIndex = i;
var pValue = p.Value;
var attributes = p.Meta.GetAttributes();
if (attributes == null || attributes.Length == 0)
{
attributes = DefaultAttributes;
}
var itemLayout = layout;
var name = p.Name;
// Editor Display
var editorDisplay = (EditorDisplayAttribute)attributes.FirstOrDefault(x => x is EditorDisplayAttribute);
if (editorDisplay?.Group != null)
{
if (lastGroup == null || lastGroup.Panel.HeaderText != editorDisplay.Group)
{
lastGroup = layout.Group(editorDisplay.Group);
lastGroup.Panel.Open(false);
}
itemLayout = lastGroup;
}
else
{
lastGroup = null;
itemLayout = layout;
}
if (editorDisplay?.Name != null)
{
name = editorDisplay.Name;
}
// Space
var space = (SpaceAttribute)attributes.FirstOrDefault(x => x is SpaceAttribute);
if (space != null)
{
itemLayout.Space(space.Height);
}
// Header
var header = (HeaderAttribute)attributes.FirstOrDefault(x => x is HeaderAttribute);
if (header != null)
{
itemLayout.Header(header.Text);
}
var propertyValue = new CustomValueContainer
(
p.Type,
pValue,
(instance, index) => ((IVisjectSurfaceWindow)instance).GetParameter(pIndex),
(instance, index, value) => ((IVisjectSurfaceWindow)instance).SetParameter(pIndex, value),
attributes
);
var propertyLabel = new DraggablePropertyNameLabel(name)
{
Tag = pIndex,
Drag = OnDragParameter
};
var tooltip = (TooltipAttribute)attributes.FirstOrDefault(x => x is TooltipAttribute);
propertyLabel.MouseLeftDoubleClick += (label, location) => StartParameterRenaming(pIndex, label);
propertyLabel.SetupContextMenu += OnPropertyLabelSetupContextMenu;
var property = itemLayout.AddPropertyItem(propertyLabel, tooltip?.Text);
property.Object(propertyValue);
}
// Parameters creating
var newParameterTypes = window.NewParameterTypes;
if (newParameterTypes != null)
{
layout.Space(parameters.Count > 0 ? 10 : 4);
var newParam = layout.Button("Add parameter...");
newParam.Button.ButtonClicked += OnAddParameterButtonClicked;
layout.Space(10);
}
}
/// <inheritdoc />
public override void Initialize(LayoutElementsContainer layout)
{
var window = Values[0] as VisjectSurfaceWindow <TAsset, TSurface, TPreview>;
var asset = window?.Asset;
if (asset == null)
{
layout.Label("No parameters");
return;
}
if (!asset.IsLoaded)
{
layout.Label("Loading...");
return;
}
var parameters = window.Surface.Parameters;
for (int i = 0; i < parameters.Count; i++)
{
var p = parameters[i];
if (!p.IsPublic)
{
continue;
}
var pIndex = i;
var pValue = p.Value;
Type pType;
object[] attributes = null;
switch (p.Type)
{
case ParameterType.CubeTexture:
pType = typeof(CubeTexture);
break;
case ParameterType.Texture:
case ParameterType.NormalMap:
pType = typeof(Texture);
break;
case ParameterType.RenderTarget:
case ParameterType.RenderTargetArray:
case ParameterType.RenderTargetCube:
case ParameterType.RenderTargetVolume:
pType = typeof(RenderTarget);
break;
default:
pType = p.Value.GetType();
// TODO: support custom attributes with defined value range for parameter (min, max)
attributes = DefaultAttributes;
break;
}
var propertyValue = new CustomValueContainer
(
pType,
pValue,
(instance, index) => ((VisjectSurfaceWindow <TAsset, TSurface, TPreview>)instance).GetParameter(pIndex),
(instance, index, value) => ((VisjectSurfaceWindow <TAsset, TSurface, TPreview>)instance).SetParameter(pIndex, value),
attributes
);
var propertyLabel = new DragablePropertyNameLabel(p.Name)
{
Tag = pIndex,
Drag = DragParameter
};
propertyLabel.MouseLeftDoubleClick += (label, location) => StartParameterRenaming(pIndex, label);
propertyLabel.MouseRightClick += (label, location) => ShowParameterMenu(pIndex, label, ref location);
var property = layout.AddPropertyItem(propertyLabel);
property.Object(propertyValue);
}
// Parameters creating
var newParameterTypes = window.NewParameterTypes;
if (newParameterTypes != null)
{
if (parameters.Count > 0)
{
layout.Space(10);
}
var paramType = layout.Enum(newParameterTypes);
paramType.Value = (int)ParameterType.Float;
var newParam = layout.Button("Add parameter");
newParam.Button.Clicked += () => AddParameter((ParameterType)paramType.Value);
}
}
/// <inheritdoc />
public override void Initialize(LayoutElementsContainer layout)
{
var materialWin = Values[0] as MaterialWindow;
var material = materialWin?.Asset;
if (material == null)
{
_parametersHash = -1;
layout.Label("No parameters");
return;
}
if (!material.IsLoaded)
{
_parametersHash = -2;
layout.Label("Loading...");
return;
}
_parametersHash = material._parametersHash;
var parameters = material.Parameters;
for (int i = 0; i < parameters.Length; i++)
{
var p = parameters[i];
if (!p.IsPublic)
{
continue;
}
var pIndex = i;
var pValue = p.Value;
var pGuidType = false;
Type pType;
switch (p.Type)
{
case MaterialParameterType.CubeTexture:
pType = typeof(CubeTexture);
pGuidType = true;
break;
case MaterialParameterType.Texture:
case MaterialParameterType.NormalMap:
pType = typeof(Texture);
pGuidType = true;
break;
case MaterialParameterType.RenderTarget:
pType = typeof(RenderTarget);
pGuidType = true;
break;
default:
pType = p.Value.GetType();
break;
}
var propertyValue = new CustomValueContainer(
pType,
pValue,
(instance, index) =>
{
// Get material parameter
var win = (MaterialWindow)instance;
return(win.Asset.Parameters[pIndex].Value);
},
(instance, index, value) =>
{
// Set material parameter and surface parameter
var win = (MaterialWindow)instance;
// Visject surface paramaters are only value type objects so convert value if need to (eg. instead of texture ref write texture id)
var surfaceParam = value;
if (pGuidType)
{
surfaceParam = (value as FlaxEngine.Object)?.ID ?? Guid.Empty;
}
win.Asset.Parameters[pIndex].Value = value;
win.Surface.Parameters[pIndex].Value = surfaceParam;
win._paramValueChange = true;
}
);
var propertyLabel = new DragablePropertyNameLabel(p.Name);
propertyLabel.Tag = pIndex;
propertyLabel.MouseLeftDoubleClick += (label, location) => StartParameterRenaming(pIndex, label);
propertyLabel.MouseRightClick += (label, location) => ShowParameterMenu(pIndex, label, ref location);
propertyLabel.Drag = DragParameter;
var property = layout.AddPropertyItem(propertyLabel);
property.Object(propertyValue);
}
if (parameters.Length > 0)
{
layout.Space(10);
}
// Parameters creating
var paramType = layout.Enum(typeof(NewParameterType));
paramType.Value = (int)NewParameterType.Float;
var newParam = layout.Button("Add parameter");
newParam.Button.Clicked += () => AddParameter((ParameterType)paramType.Value);
}
/// <inheritdoc />
public override void Initialize(LayoutElementsContainer layout)
{
// Get the target options
_options = Options;
if (_options == null)
{
throw new ArgumentNullException();
}
int selectedIndex = -1;
bool hasDifferentTypes = Values.HasDifferentTypes;
var type = Type;
_type = type;
// Type
var typeEditor = layout.ComboBox(TypeComboBoxName, "Type of the object value. Use it to change the object.");
for (int i = 0; i < _options.Length; i++)
{
typeEditor.ComboBox.AddItem(_options[i].Name);
selectedIndex = _options[i].Type == type.Type ? i : selectedIndex;
}
typeEditor.ComboBox.SupportMultiSelect = false;
typeEditor.ComboBox.SelectedIndex = hasDifferentTypes ? -1 : selectedIndex;
typeEditor.ComboBox.SelectedIndexChanged += OnSelectedIndexChanged;
// Editing different types is not supported
if (Values.HasDifferentTypes)
{
var property = layout.AddPropertyItem("Value");
property.Label("Different Values");
return;
}
// Nothing to edit
if (Values.HasNull)
{
var property = layout.AddPropertyItem("Value");
property.Label("<null>");
return;
}
// Value
var values = new CustomValueContainer(type, (instance, index) => instance, (instance, index, value) => { });
values.AddRange(Values);
var editor = CustomEditorsUtil.CreateEditor(type);
var style = editor.Style;
if (style == DisplayStyle.InlineIntoParent)
{
layout.Object(values, editor);
}
else if (style == DisplayStyle.Group)
{
var group = layout.Group("Value", true);
group.Panel.Open(false);
group.Object(values, editor);
// Remove empty group
if (group.ContainerControl.ChildrenCount == 0)
{
layout.Children.Remove(group);
group.Panel.Dispose();
}
}
else
{
layout.AddPropertyItem("Value").Object(values, editor);
}
}
internal static void DisplayGraphParameters(LayoutElementsContainer layout, GraphParameterData[] data, GetGraphParameterDelegate getter, SetGraphParameterDelegate setter, ValueContainer values, GetGraphParameterDelegate defaultValueGetter = null, CustomPropertySpawnDelegate propertySpawn = null)
{
GroupElement lastGroup = null;
for (int i = 0; i < data.Length; i++)
{
ref var e = ref data[i];
if (!e.IsPublic)
{
continue;
}
var tag = e.Tag;
var parameter = e.Parameter;
LayoutElementsContainer itemLayout;
// Editor Display
if (e.Display?.Group != null)
{
if (lastGroup == null || lastGroup.Panel.HeaderText != e.Display.Group)
{
lastGroup = layout.Group(e.Display.Group);
lastGroup.Panel.Open(false);
}
itemLayout = lastGroup;
}
else
{
lastGroup = null;
itemLayout = layout;
}
// Space
if (e.Space != null)
{
itemLayout.Space(e.Space.Height);
}
// Header
if (e.Header != null)
{
itemLayout.Header(e.Header);
}
// Values container
var valueType = new ScriptType(e.Type);
var valueContainer = new CustomValueContainer(valueType, (instance, index) => getter(values[index], parameter, tag), (instance, index, value) => setter(values[index], value, parameter, tag), e.Attributes);
for (int j = 0; j < values.Count; j++)
{
valueContainer.Add(getter(values[j], parameter, tag));
}
// Default value
if (defaultValueGetter != null)
{
valueContainer.SetDefaultValue(defaultValueGetter(values[0], parameter, tag));
}
// Prefab value
if (values.HasReferenceValue)
{
var referenceValue = getter(values.ReferenceValue, parameter, tag);
if (referenceValue != null)
{
valueContainer.SetReferenceValue(referenceValue);
}
}
if (propertySpawn == null)
{
itemLayout.Property(e.DisplayName, valueContainer, null, e.Tooltip?.Text);
}
else
{
propertySpawn(itemLayout, valueContainer, ref e);
}
}
/// <inheritdoc />
public override void Initialize(LayoutElementsContainer layout)
{
base.Initialize(layout);
_isValid = IsValid;
if (!_isValid)
{
return;
}
// Show all effect parameters grouped by the emitter track name
var effect = (ParticleEffect)Values[0];
var groups = layout.Group("Parameters");
groups.Panel.Open(false);
var parameters = effect.Parameters;
var parametersGroups = parameters.GroupBy(x => x.EmitterIndex);
foreach (var parametersGroup in parametersGroups)
{
var trackName = parametersGroup.First().TrackName;
var group = groups.Group(trackName);
group.Panel.Open(false);
foreach (var parameter in parametersGroup)
{
if (!parameter.IsPublic)
{
continue;
}
var parameterName = parameter.Name;
var value = parameter.Value;
var valueType = Utilities.Utils.GetGraphParameterValueType(parameter.ParamType);
// Parameter value accessor
var valueContainer = new CustomValueContainer(
valueType,
value,
(instance, index) => ((ParticleEffect)Values[index]).GetParameterValue(trackName, parameterName),
(instance, index, o) => ((ParticleEffect)Values[index]).SetParameterValue(trackName, parameterName, o)
);
for (int index = 1; index < Values.Count; index++)
{
valueContainer.Add(((ParticleEffect)Values[index]).GetParameterValue(trackName, parameterName));
}
// Default value
valueContainer.SetDefaultValue(parameter.DefaultValue);
// Prefab value
if (Values.HasReferenceValue)
{
var referenceEffect = (ParticleEffect)Values.ReferenceValue;
var referenceParameter = referenceEffect.GetParameter(trackName, parameterName);
if (referenceParameter != null)
{
valueContainer.SetReferenceValue(referenceParameter.Value);
}
}
group.Property(parameter.Name, valueContainer);
}
}
}
