913 lines
35 KiB
C#
913 lines
35 KiB
C#
// Copyright (c) Wojciech Figat. All rights reserved.
|
|
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
using FlaxEditor.Content;
|
|
using FlaxEditor.Content.Import;
|
|
using FlaxEditor.CustomEditors;
|
|
using FlaxEditor.CustomEditors.Editors;
|
|
using FlaxEditor.GUI;
|
|
using FlaxEditor.GUI.Tabs;
|
|
using FlaxEditor.Scripting;
|
|
using FlaxEngine;
|
|
using FlaxEngine.GUI;
|
|
using FlaxEngine.Utilities;
|
|
|
|
#pragma warning disable 1591
|
|
|
|
namespace FlaxEditor.Windows.Assets
|
|
{
|
|
/// <summary>
|
|
/// Editor window to view/modify <see cref="ModelBase"/> asset.
|
|
/// </summary>
|
|
/// <seealso cref="Model" />
|
|
/// <seealso cref="FlaxEditor.Windows.Assets.AssetEditorWindow" />
|
|
public abstract class ModelBaseWindow<TAsset, TWindow> : AssetEditorWindowBase<TAsset>
|
|
where TAsset : ModelBase
|
|
where TWindow : ModelBaseWindow<TAsset, TWindow>
|
|
{
|
|
protected abstract class PropertiesProxyBase
|
|
{
|
|
[HideInEditor]
|
|
public TWindow Window;
|
|
|
|
[HideInEditor]
|
|
public TAsset Asset;
|
|
|
|
public virtual void OnLoad(TWindow window)
|
|
{
|
|
Window = window;
|
|
Asset = window.Asset;
|
|
}
|
|
|
|
public virtual void OnSave()
|
|
{
|
|
}
|
|
|
|
public virtual void OnClean()
|
|
{
|
|
Window = null;
|
|
Asset = null;
|
|
}
|
|
}
|
|
|
|
protected abstract class ProxyEditorBase : GenericEditor
|
|
{
|
|
internal override void RefreshInternal()
|
|
{
|
|
// Skip updates when model is not loaded
|
|
var proxy = (PropertiesProxyBase)Values[0];
|
|
if (proxy.Asset == null || !proxy.Asset.IsLoaded)
|
|
return;
|
|
|
|
base.RefreshInternal();
|
|
}
|
|
}
|
|
|
|
protected class Tab : GUI.Tabs.Tab
|
|
{
|
|
public CustomEditorPresenter Presenter;
|
|
public PropertiesProxyBase Proxy;
|
|
|
|
public Tab(string text, TWindow window, bool modifiesAsset = true)
|
|
: base(text)
|
|
{
|
|
var scrollPanel = new Panel(ScrollBars.Vertical)
|
|
{
|
|
AnchorPreset = AnchorPresets.StretchAll,
|
|
Offsets = Margin.Zero,
|
|
Parent = this
|
|
};
|
|
|
|
Presenter = new CustomEditorPresenter(null);
|
|
Presenter.Panel.Parent = scrollPanel;
|
|
if (modifiesAsset)
|
|
Presenter.Modified += window.MarkAsEdited;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override void OnDestroy()
|
|
{
|
|
if (IsDisposing)
|
|
return;
|
|
base.OnDestroy();
|
|
|
|
Presenter.Deselect();
|
|
Presenter = null;
|
|
Proxy = null;
|
|
}
|
|
}
|
|
|
|
protected class MeshesPropertiesProxyBase : PropertiesProxyBase
|
|
{
|
|
private readonly List<ComboBox> _materialSlotComboBoxes = new List<ComboBox>();
|
|
private readonly List<CheckBox> _isolateCheckBoxes = new List<CheckBox>();
|
|
private readonly List<CheckBox> _highlightCheckBoxes = new List<CheckBox>();
|
|
|
|
public override void OnLoad(TWindow window)
|
|
{
|
|
base.OnLoad(window);
|
|
|
|
Window._isolateIndex = -1;
|
|
Window._highlightIndex = -1;
|
|
}
|
|
|
|
public override void OnClean()
|
|
{
|
|
Window._isolateIndex = -1;
|
|
Window._highlightIndex = -1;
|
|
|
|
base.OnClean();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the highlight/isolate effects on UI.
|
|
/// </summary>
|
|
public void UpdateEffectsOnUI()
|
|
{
|
|
Window._skipEffectsGuiEvents = true;
|
|
|
|
for (int i = 0; i < _isolateCheckBoxes.Count; i++)
|
|
{
|
|
var checkBox = _isolateCheckBoxes[i];
|
|
checkBox.Checked = Window._isolateIndex == ((MeshBase)checkBox.Tag).MaterialSlotIndex;
|
|
}
|
|
|
|
for (int i = 0; i < _highlightCheckBoxes.Count; i++)
|
|
{
|
|
var checkBox = _highlightCheckBoxes[i];
|
|
checkBox.Checked = Window._highlightIndex == ((MeshBase)checkBox.Tag).MaterialSlotIndex;
|
|
}
|
|
|
|
Window._skipEffectsGuiEvents = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the material slots UI parts. Should be called after material slot rename.
|
|
/// </summary>
|
|
public void UpdateMaterialSlotsUI()
|
|
{
|
|
Window._skipEffectsGuiEvents = true;
|
|
|
|
// Generate material slots labels (with index prefix)
|
|
var slots = Asset.MaterialSlots;
|
|
var slotsLabels = new string[slots.Length];
|
|
for (int i = 0; i < slots.Length; i++)
|
|
{
|
|
slotsLabels[i] = string.Format("[{0}] {1}", i, slots[i].Name);
|
|
}
|
|
|
|
// Update comboboxes
|
|
for (int i = 0; i < _materialSlotComboBoxes.Count; i++)
|
|
{
|
|
var comboBox = _materialSlotComboBoxes[i];
|
|
comboBox.SetItems(slotsLabels);
|
|
comboBox.SelectedIndex = ((MeshBase)comboBox.Tag).MaterialSlotIndex;
|
|
}
|
|
|
|
Window._skipEffectsGuiEvents = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the material slot index to the mesh.
|
|
/// </summary>
|
|
/// <param name="mesh">The mesh.</param>
|
|
/// <param name="newSlotIndex">New index of the material slot to use.</param>
|
|
public void SetMaterialSlot(MeshBase mesh, int newSlotIndex)
|
|
{
|
|
if (Window._skipEffectsGuiEvents)
|
|
return;
|
|
|
|
mesh.MaterialSlotIndex = newSlotIndex == -1 ? 0 : newSlotIndex;
|
|
Window.UpdateEffectsOnAsset();
|
|
UpdateEffectsOnUI();
|
|
Window.MarkAsEdited();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the material slot to isolate.
|
|
/// </summary>
|
|
/// <param name="mesh">The mesh.</param>
|
|
public void SetIsolate(MeshBase mesh)
|
|
{
|
|
if (Window._skipEffectsGuiEvents)
|
|
return;
|
|
|
|
Window._isolateIndex = mesh != null ? mesh.MaterialSlotIndex : -1;
|
|
Window.UpdateEffectsOnAsset();
|
|
UpdateEffectsOnUI();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the material slot index to highlight.
|
|
/// </summary>
|
|
/// <param name="mesh">The mesh.</param>
|
|
public void SetHighlight(MeshBase mesh)
|
|
{
|
|
if (Window._skipEffectsGuiEvents)
|
|
return;
|
|
|
|
Window._highlightIndex = mesh != null ? mesh.MaterialSlotIndex : -1;
|
|
Window.UpdateEffectsOnAsset();
|
|
UpdateEffectsOnUI();
|
|
}
|
|
|
|
protected virtual void OnGeneral(LayoutElementsContainer layout)
|
|
{
|
|
}
|
|
|
|
protected class ProxyEditor : ProxyEditorBase
|
|
{
|
|
public override void Initialize(LayoutElementsContainer layout)
|
|
{
|
|
var proxy = (MeshesPropertiesProxyBase)Values[0];
|
|
if (Utilities.Utils.OnAssetProperties(layout, proxy.Asset))
|
|
return;
|
|
proxy._materialSlotComboBoxes.Clear();
|
|
proxy._isolateCheckBoxes.Clear();
|
|
proxy._highlightCheckBoxes.Clear();
|
|
var countLODs = proxy.Asset.LODsCount;
|
|
var loadedLODs = proxy.Asset.LoadedLODs;
|
|
|
|
// General properties
|
|
{
|
|
var group = layout.Group("General");
|
|
|
|
var minScreenSize = group.FloatValue("Min Screen Size", "The minimum screen size to draw model (the bottom limit). Used to cull small models. Set to 0 to disable this feature.");
|
|
minScreenSize.ValueBox.MinValue = 0.0f;
|
|
minScreenSize.ValueBox.MaxValue = 1.0f;
|
|
minScreenSize.ValueBox.Value = proxy.Asset.MinScreenSize;
|
|
minScreenSize.ValueBox.ValueChanged += () =>
|
|
{
|
|
proxy.Asset.MinScreenSize = minScreenSize.ValueBox.Value;
|
|
proxy.Window.MarkAsEdited();
|
|
};
|
|
}
|
|
{
|
|
var group = layout.Group("Vertex Layout");
|
|
GPUVertexLayout vertexLayout = null;
|
|
for (int lodIndex = 0; lodIndex < countLODs; lodIndex++)
|
|
{
|
|
var lod = proxy.Asset.GetLOD(lodIndex);
|
|
if (lodIndex >= countLODs - loadedLODs)
|
|
{
|
|
var mesh = lod.GetMesh(0);
|
|
vertexLayout = mesh.VertexLayout;
|
|
if (vertexLayout != null && vertexLayout.Elements.Length != 0)
|
|
break;
|
|
vertexLayout = null;
|
|
}
|
|
}
|
|
if (vertexLayout != null)
|
|
{
|
|
var elements = vertexLayout.Elements;
|
|
for (uint slot = 0; slot < 4u; slot++)
|
|
{
|
|
var slotElements = elements.Where(x => x.Slot == slot && x.PerInstance == 0).ToArray();
|
|
if (slotElements.Length == 0)
|
|
continue;
|
|
var height = 14;
|
|
group.Label($" Vertex Buffer {slot}:").Label.Height = height;
|
|
foreach (var e in slotElements)
|
|
group.Label($" {e.Type}, {e.Format} ({PixelFormatExtensions.SizeInBytes(e.Format)} bytes), offset {e.Offset}").Label.Height = height;
|
|
}
|
|
group.Label($"{vertexLayout.Stride} bytes per-vertex");
|
|
}
|
|
}
|
|
proxy.OnGeneral(layout);
|
|
|
|
// Group per LOD
|
|
for (int lodIndex = 0; lodIndex < countLODs; lodIndex++)
|
|
{
|
|
var group = layout.Group("LOD " + lodIndex);
|
|
if (lodIndex < countLODs - loadedLODs)
|
|
{
|
|
group.Label("Loading LOD...");
|
|
continue;
|
|
}
|
|
var lod = proxy.Asset.GetLOD(lodIndex);
|
|
proxy.Asset.GetMeshes(out var meshes, lodIndex);
|
|
|
|
int triangleCount = 0, vertexCount = 0;
|
|
ulong[] meshMemory = new ulong[meshes.Length];
|
|
ulong lodMemory = 0;
|
|
for (int meshIndex = 0; meshIndex < meshes.Length; meshIndex++)
|
|
{
|
|
var mesh = meshes[meshIndex];
|
|
triangleCount += mesh.TriangleCount;
|
|
vertexCount += mesh.VertexCount;
|
|
ulong memory = 0;
|
|
for (int vbIndex = 0; vbIndex < 4; vbIndex++)
|
|
{
|
|
var vb = mesh.GetVertexBuffer(vbIndex);
|
|
if (vb != null)
|
|
memory += vb.Size;
|
|
}
|
|
{
|
|
var ib = mesh.GetIndexBuffer();
|
|
if (ib != null)
|
|
memory += ib.Size;
|
|
}
|
|
meshMemory[meshIndex] = memory;
|
|
lodMemory += memory;
|
|
}
|
|
|
|
group.Label(string.Format($"Triangles: {{0:N0}} Vertices: {{1:N0}} Memory: {Utilities.Utils.FormatBytesCount(lodMemory)}", triangleCount, vertexCount)).AddCopyContextMenu();
|
|
group.Label("Size: " + lod.Box.Size).AddCopyContextMenu();
|
|
var screenSize = group.FloatValue("Screen Size", "The screen size to switch LODs. Bottom limit of the model screen size to render this LOD.");
|
|
screenSize.ValueBox.MinValue = 0.0f;
|
|
screenSize.ValueBox.MaxValue = 10.0f;
|
|
screenSize.ValueBox.Value = lod.ScreenSize;
|
|
screenSize.ValueBox.ValueChanged += () =>
|
|
{
|
|
lod.ScreenSize = screenSize.ValueBox.Value;
|
|
proxy.Window.MarkAsEdited();
|
|
};
|
|
|
|
// Every mesh properties
|
|
for (int meshIndex = 0; meshIndex < meshes.Length; meshIndex++)
|
|
{
|
|
var mesh = meshes[meshIndex];
|
|
group.Label($"Mesh {meshIndex} (tris: {mesh.TriangleCount:N0}, vert: {mesh.VertexCount:N0}, mem: {Utilities.Utils.FormatBytesCount(meshMemory[meshIndex])})").AddCopyContextMenu();
|
|
|
|
// Material Slot
|
|
var materialSlot = group.ComboBox("Material Slot", "Material slot used by this mesh during rendering");
|
|
materialSlot.ComboBox.Tag = mesh;
|
|
materialSlot.ComboBox.SelectedIndexChanged += comboBox => proxy.SetMaterialSlot((MeshBase)comboBox.Tag, comboBox.SelectedIndex);
|
|
proxy._materialSlotComboBoxes.Add(materialSlot.ComboBox);
|
|
|
|
// Isolate
|
|
var isolate = group.Checkbox("Isolate", "Shows only this mesh (and meshes using the same material slot)");
|
|
isolate.CheckBox.Tag = mesh;
|
|
isolate.CheckBox.StateChanged += (box) => proxy.SetIsolate(box.Checked ? (MeshBase)box.Tag : null);
|
|
proxy._isolateCheckBoxes.Add(isolate.CheckBox);
|
|
|
|
// Highlight
|
|
var highlight = group.Checkbox("Highlight", "Highlights this mesh with a tint color (and meshes using the same material slot)");
|
|
highlight.CheckBox.Tag = mesh;
|
|
highlight.CheckBox.StateChanged += (box) => proxy.SetHighlight(box.Checked ? (MeshBase)box.Tag : null);
|
|
proxy._highlightCheckBoxes.Add(highlight.CheckBox);
|
|
}
|
|
}
|
|
|
|
// Refresh UI
|
|
proxy.UpdateMaterialSlotsUI();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected class MaterialsPropertiesProxyBase : PropertiesProxyBase
|
|
{
|
|
[Collection(CanReorderItems = true, NotNullItems = true, OverrideEditorTypeName = "FlaxEditor.CustomEditors.Editors.GenericEditor", Spacing = 10)]
|
|
[EditorOrder(10), EditorDisplay("Materials", EditorDisplayAttribute.InlineStyle)]
|
|
public MaterialSlot[] MaterialSlots
|
|
{
|
|
get => Asset != null ? Asset.MaterialSlots : null;
|
|
set
|
|
{
|
|
if (Asset != null)
|
|
{
|
|
if (Asset.MaterialSlots.Length != value.Length)
|
|
{
|
|
MaterialBase[] materials = new MaterialBase[value.Length];
|
|
string[] names = new string[value.Length];
|
|
ShadowsCastingMode[] shadowsModes = new ShadowsCastingMode[value.Length];
|
|
for (int i = 0; i < value.Length; i++)
|
|
{
|
|
if (value[i] != null)
|
|
{
|
|
materials[i] = value[i].Material;
|
|
names[i] = value[i].Name;
|
|
shadowsModes[i] = value[i].ShadowsMode;
|
|
}
|
|
else
|
|
{
|
|
materials[i] = null;
|
|
names[i] = "Material " + i;
|
|
shadowsModes[i] = ShadowsCastingMode.All;
|
|
}
|
|
}
|
|
|
|
Asset.SetupMaterialSlots(value.Length);
|
|
|
|
var slots = Asset.MaterialSlots;
|
|
for (int i = 0; i < slots.Length; i++)
|
|
{
|
|
slots[i].Material = materials[i];
|
|
slots[i].Name = names[i];
|
|
slots[i].ShadowsMode = shadowsModes[i];
|
|
}
|
|
|
|
UpdateMaterialSlotsUI();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private readonly List<ComboBox> _materialSlotComboBoxes = new List<ComboBox>();
|
|
|
|
/// <summary>
|
|
/// Updates the material slots UI parts. Should be called after material slot rename.
|
|
/// </summary>
|
|
public void UpdateMaterialSlotsUI()
|
|
{
|
|
Window._skipEffectsGuiEvents = true;
|
|
|
|
// Generate material slots labels (with index prefix)
|
|
var slots = Asset.MaterialSlots;
|
|
var slotsLabels = new string[slots.Length];
|
|
for (int i = 0; i < slots.Length; i++)
|
|
{
|
|
slotsLabels[i] = string.Format("[{0}] {1}", i, slots[i].Name);
|
|
}
|
|
|
|
// Update comboboxes
|
|
for (int i = 0; i < _materialSlotComboBoxes.Count; i++)
|
|
{
|
|
var comboBox = _materialSlotComboBoxes[i];
|
|
comboBox.SetItems(slotsLabels);
|
|
comboBox.SelectedIndex = ((Mesh)comboBox.Tag).MaterialSlotIndex;
|
|
}
|
|
|
|
Window._skipEffectsGuiEvents = false;
|
|
}
|
|
|
|
protected class ProxyEditor : ProxyEditorBase
|
|
{
|
|
public override void Initialize(LayoutElementsContainer layout)
|
|
{
|
|
var proxy = (MaterialsPropertiesProxyBase)Values[0];
|
|
if (Utilities.Utils.OnAssetProperties(layout, proxy.Asset))
|
|
return;
|
|
|
|
base.Initialize(layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected class UVsPropertiesProxyBase : PropertiesProxyBase
|
|
{
|
|
public enum UVChannel
|
|
{
|
|
None,
|
|
TexCoord0,
|
|
TexCoord1,
|
|
TexCoord2,
|
|
TexCoord3,
|
|
LightmapUVs,
|
|
};
|
|
|
|
private UVChannel _uvChannel = UVChannel.None;
|
|
|
|
[EditorOrder(0), EditorDisplay(null, "Preview UV Channel"), EnumDisplay(EnumDisplayAttribute.FormatMode.None)]
|
|
[Tooltip("Set UV channel to preview.")]
|
|
public UVChannel Channel
|
|
{
|
|
get => _uvChannel;
|
|
set
|
|
{
|
|
if (_uvChannel == value)
|
|
return;
|
|
_uvChannel = value;
|
|
Window._meshData?.RequestMeshData(Window._asset);
|
|
}
|
|
}
|
|
|
|
[EditorOrder(1), EditorDisplay(null, "LOD"), Limit(0, Model.MaxLODs), VisibleIf("ShowUVs")]
|
|
[Tooltip("Level Of Detail index to preview UVs layout.")]
|
|
public int LOD = 0;
|
|
|
|
[EditorOrder(2), EditorDisplay(null, "Mesh"), Limit(-1, 1000000), VisibleIf("ShowUVs")]
|
|
[Tooltip("Mesh index to preview UVs layout. Use -1 for all meshes")]
|
|
public int Mesh = -1;
|
|
|
|
private bool ShowUVs => _uvChannel != UVChannel.None;
|
|
|
|
/// <inheritdoc />
|
|
public override void OnClean()
|
|
{
|
|
Channel = UVChannel.None;
|
|
|
|
base.OnClean();
|
|
}
|
|
|
|
protected class ProxyEditor : ProxyEditorBase
|
|
{
|
|
private UVsLayoutPreviewControl _uvsPreview;
|
|
|
|
public override void Initialize(LayoutElementsContainer layout)
|
|
{
|
|
var proxy = (UVsPropertiesProxyBase)Values[0];
|
|
if (Utilities.Utils.OnAssetProperties(layout, proxy.Asset))
|
|
return;
|
|
|
|
base.Initialize(layout);
|
|
|
|
_uvsPreview = layout.Custom<UVsLayoutPreviewControl>().CustomControl;
|
|
_uvsPreview.Window = proxy.Window;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override void Refresh()
|
|
{
|
|
base.Refresh();
|
|
|
|
if (_uvsPreview != null)
|
|
{
|
|
var proxy = (UVsPropertiesProxyBase)Values[0];
|
|
switch (proxy._uvChannel)
|
|
{
|
|
case UVChannel.TexCoord0: _uvsPreview.Channel = 0; break;
|
|
case UVChannel.TexCoord1: _uvsPreview.Channel = 1; break;
|
|
case UVChannel.TexCoord2: _uvsPreview.Channel = 2; break;
|
|
case UVChannel.TexCoord3: _uvsPreview.Channel = 3; break;
|
|
case UVChannel.LightmapUVs:
|
|
{
|
|
_uvsPreview.Channel = -1;
|
|
if (proxy.Window.Asset && proxy.Window.Asset.IsLoaded)
|
|
{
|
|
// Pick UVs channel index from the first mesh
|
|
proxy.Window.Asset.GetMeshes(out var meshes);
|
|
foreach (var mesh in meshes)
|
|
{
|
|
if (mesh is Mesh m && m.HasLightmapUVs)
|
|
{
|
|
_uvsPreview.Channel = m.LightmapUVsIndex;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default: _uvsPreview.Channel = -1; break;
|
|
}
|
|
_uvsPreview.LOD = proxy.LOD;
|
|
_uvsPreview.Mesh = proxy.Mesh;
|
|
_uvsPreview.HighlightIndex = proxy.Window._highlightIndex;
|
|
_uvsPreview.IsolateIndex = proxy.Window._isolateIndex;
|
|
}
|
|
}
|
|
|
|
protected override void Deinitialize()
|
|
{
|
|
_uvsPreview = null;
|
|
|
|
base.Deinitialize();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected sealed class UVsLayoutPreviewControl : RenderToTextureControl
|
|
{
|
|
private int _channel = -1;
|
|
private int _lod, _mesh = -1;
|
|
private int _highlightIndex = -1;
|
|
private int _isolateIndex = -1;
|
|
public ModelBaseWindow<TAsset, TWindow> Window;
|
|
|
|
public UVsLayoutPreviewControl()
|
|
{
|
|
Offsets = new Margin(4);
|
|
AutomaticInvalidate = false;
|
|
}
|
|
|
|
public int Channel
|
|
{
|
|
set
|
|
{
|
|
if (_channel == value)
|
|
return;
|
|
_channel = value;
|
|
Visible = _channel != -1;
|
|
if (Visible)
|
|
Invalidate();
|
|
}
|
|
}
|
|
|
|
public int LOD
|
|
{
|
|
set
|
|
{
|
|
if (_lod != value)
|
|
{
|
|
_lod = value;
|
|
Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int Mesh
|
|
{
|
|
set
|
|
{
|
|
if (_mesh != value)
|
|
{
|
|
_mesh = value;
|
|
Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int HighlightIndex
|
|
{
|
|
set
|
|
{
|
|
if (_highlightIndex != value)
|
|
{
|
|
_highlightIndex = value;
|
|
Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int IsolateIndex
|
|
{
|
|
set
|
|
{
|
|
if (_isolateIndex != value)
|
|
{
|
|
_isolateIndex = value;
|
|
Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawMeshUVs(int meshIndex, ref MeshDataCache.MeshData meshData, ref Rectangle bounds)
|
|
{
|
|
if (meshData.IndexBuffer == null || meshData.VertexAccessor == null)
|
|
{
|
|
Render2D.DrawText(Style.Current.FontMedium, "Missing mesh data", bounds, Color.Red, TextAlignment.Center, TextAlignment.Center);
|
|
return;
|
|
}
|
|
var linesColor = _highlightIndex != -1 && _highlightIndex == meshIndex ? Style.Current.BackgroundSelected : Color.White;
|
|
var texCoordStream = meshData.VertexAccessor.TexCoord(_channel);
|
|
if (!texCoordStream.IsValid)
|
|
{
|
|
Render2D.DrawText(Style.Current.FontMedium, "Missing texcoords channel", bounds, Color.Yellow, TextAlignment.Center, TextAlignment.Center);
|
|
return;
|
|
}
|
|
var uvScale = bounds.Size;
|
|
for (int i = 0; i < meshData.IndexBuffer.Length; i += 3)
|
|
{
|
|
// Cache triangle indices
|
|
uint i0 = meshData.IndexBuffer[i + 0];
|
|
uint i1 = meshData.IndexBuffer[i + 1];
|
|
uint i2 = meshData.IndexBuffer[i + 2];
|
|
|
|
// Cache triangle uvs positions and transform positions to output target
|
|
Float2 uv0 = texCoordStream.GetFloat2((int)i0) * uvScale;
|
|
Float2 uv1 = texCoordStream.GetFloat2((int)i1) * uvScale;
|
|
Float2 uv2 = texCoordStream.GetFloat2((int)i2) * uvScale;
|
|
|
|
// Don't draw too small triangles
|
|
float area = Float2.TriangleArea(ref uv0, ref uv1, ref uv2);
|
|
if (area > 10.0f)
|
|
{
|
|
// Draw triangle
|
|
Render2D.DrawLine(uv0, uv1, linesColor);
|
|
Render2D.DrawLine(uv1, uv2, linesColor);
|
|
Render2D.DrawLine(uv2, uv0, linesColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override void DrawSelf()
|
|
{
|
|
base.DrawSelf();
|
|
|
|
var bounds = new Rectangle(Float2.Zero, Size);
|
|
if (_channel < 0 || bounds.Size.MaxValue < 5.0f)
|
|
return;
|
|
if (Window._meshData == null)
|
|
Window._meshData = new MeshDataCache();
|
|
if (!Window._meshData.RequestMeshData(Window._asset))
|
|
{
|
|
Invalidate();
|
|
Render2D.DrawText(Style.Current.FontMedium, "Loading...", bounds, Color.White, TextAlignment.Center, TextAlignment.Center);
|
|
return;
|
|
}
|
|
|
|
Render2D.PushClip(bounds);
|
|
|
|
var meshDatas = Window._meshData.MeshDatas;
|
|
var lodIndex = Mathf.Clamp(_lod, 0, meshDatas.Length - 1);
|
|
var lod = meshDatas[lodIndex];
|
|
var mesh = Mathf.Clamp(_mesh, -1, lod.Length - 1);
|
|
if (mesh == -1)
|
|
{
|
|
for (int meshIndex = 0; meshIndex < lod.Length; meshIndex++)
|
|
{
|
|
if (_isolateIndex != -1 && _isolateIndex != meshIndex)
|
|
continue;
|
|
DrawMeshUVs(meshIndex, ref lod[meshIndex], ref bounds);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DrawMeshUVs(mesh, ref lod[mesh], ref bounds);
|
|
}
|
|
|
|
Render2D.PopClip();
|
|
}
|
|
|
|
protected override void OnSizeChanged()
|
|
{
|
|
Height = Width;
|
|
|
|
base.OnSizeChanged();
|
|
}
|
|
|
|
protected override void OnVisibleChanged()
|
|
{
|
|
base.OnVisibleChanged();
|
|
|
|
Parent.PerformLayout();
|
|
Height = Width;
|
|
}
|
|
}
|
|
|
|
protected class ImportPropertiesProxyBase : PropertiesProxyBase
|
|
{
|
|
private ModelImportSettings ImportSettings;
|
|
|
|
/// <inheritdoc />
|
|
public override void OnLoad(TWindow window)
|
|
{
|
|
base.OnLoad(window);
|
|
|
|
ImportSettings = window._importSettings;
|
|
}
|
|
|
|
public void Reimport()
|
|
{
|
|
Editor.Instance.ContentImporting.Reimport((BinaryAssetItem)Window.Item, ImportSettings, true);
|
|
}
|
|
|
|
protected class ProxyEditor : ProxyEditorBase
|
|
{
|
|
public override void Initialize(LayoutElementsContainer layout)
|
|
{
|
|
var proxy = (ImportPropertiesProxyBase)Values[0];
|
|
if (Utilities.Utils.OnAssetProperties(layout, proxy.Asset))
|
|
return;
|
|
|
|
var importSettingsGroup = layout.Group("Import Settings");
|
|
|
|
var importSettingsField = typeof(ImportPropertiesProxyBase).GetField(nameof(ImportSettings), BindingFlags.NonPublic | BindingFlags.Instance);
|
|
var importSettingsValues = new ValueContainer(new ScriptMemberInfo(importSettingsField)) { proxy.ImportSettings };
|
|
importSettingsGroup.Object(importSettingsValues);
|
|
|
|
// Creates the import path UI
|
|
var group = layout.Group("Import Path");
|
|
Utilities.Utils.CreateImportPathUI(group, proxy.Window.Item as BinaryAssetItem);
|
|
|
|
var reimportButton = importSettingsGroup.Button("Reimport");
|
|
reimportButton.Button.Clicked += () => ((ImportPropertiesProxyBase)Values[0]).Reimport();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected readonly SplitPanel _split;
|
|
protected readonly Tabs _tabs;
|
|
protected readonly ToolStripButton _saveButton;
|
|
|
|
protected ModelImportSettings _importSettings = new ModelImportSettings();
|
|
protected bool _refreshOnLODsLoaded;
|
|
protected bool _skipEffectsGuiEvents;
|
|
protected int _isolateIndex = -1;
|
|
protected int _highlightIndex = -1;
|
|
|
|
protected MeshDataCache _meshData;
|
|
|
|
/// <inheritdoc />
|
|
protected ModelBaseWindow(Editor editor, AssetItem item)
|
|
: base(editor, item)
|
|
{
|
|
var inputOptions = Editor.Options.Options.Input;
|
|
|
|
// Toolstrip
|
|
_saveButton = _toolstrip.AddButton(editor.Icons.Save64, Save).LinkTooltip("Save", ref inputOptions.Save);
|
|
|
|
// Split Panel
|
|
_split = new SplitPanel(Orientation.Horizontal, ScrollBars.None, ScrollBars.None)
|
|
{
|
|
AnchorPreset = AnchorPresets.StretchAll,
|
|
Offsets = new Margin(0, 0, _toolstrip.Bottom, 0),
|
|
SplitterValue = 0.59f,
|
|
Parent = this
|
|
};
|
|
|
|
// Properties tabs
|
|
_tabs = new Tabs
|
|
{
|
|
AnchorPreset = AnchorPresets.StretchAll,
|
|
Offsets = Margin.Zero,
|
|
TabsSize = new Float2(60, 20),
|
|
TabsTextHorizontalAlignment = TextAlignment.Center,
|
|
UseScroll = true,
|
|
Parent = _split.Panel2
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the highlight/isolate effects on a model asset.
|
|
/// </summary>
|
|
protected abstract void UpdateEffectsOnAsset();
|
|
|
|
/// <inheritdoc />
|
|
protected override void UpdateToolstrip()
|
|
{
|
|
_saveButton.Enabled = IsEdited;
|
|
|
|
base.UpdateToolstrip();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
protected override void UnlinkItem()
|
|
{
|
|
_meshData?.WaitForMeshDataRequestEnd();
|
|
foreach (var child in _tabs.Children)
|
|
{
|
|
if (child is Tab tab && tab.Proxy?.Window != null)
|
|
tab.Proxy?.OnClean();
|
|
}
|
|
|
|
base.UnlinkItem();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
protected override void OnAssetLoaded()
|
|
{
|
|
_refreshOnLODsLoaded = true;
|
|
Editor.TryRestoreImportOptions(ref _importSettings.Settings, Item.Path);
|
|
UpdateEffectsOnAsset();
|
|
foreach (var child in _tabs.Children)
|
|
{
|
|
if (child is Tab tab)
|
|
{
|
|
tab.Proxy?.OnLoad((TWindow)this);
|
|
tab.Presenter.BuildLayout();
|
|
}
|
|
}
|
|
ClearEditedFlag();
|
|
|
|
base.OnAssetLoaded();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override void OnItemReimported(ContentItem item)
|
|
{
|
|
// Discard any old mesh data cache
|
|
_meshData?.Dispose();
|
|
|
|
// Refresh the properties (will get new data in OnAssetLoaded)
|
|
foreach (var child in _tabs.Children)
|
|
{
|
|
if (child is Tab tab)
|
|
{
|
|
tab.Proxy.OnClean();
|
|
tab.Presenter.BuildLayout();
|
|
}
|
|
}
|
|
ClearEditedFlag();
|
|
_refreshOnLODsLoaded = true;
|
|
|
|
base.OnItemReimported(item);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override void OnDestroy()
|
|
{
|
|
// Free mesh memory
|
|
_meshData?.Dispose();
|
|
_meshData = null;
|
|
|
|
base.OnDestroy();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override bool UseLayoutData => true;
|
|
|
|
/// <inheritdoc />
|
|
public override void OnLayoutSerialize(XmlWriter writer)
|
|
{
|
|
LayoutSerializeSplitter(writer, "Split", _split);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override void OnLayoutDeserialize(XmlElement node)
|
|
{
|
|
LayoutDeserializeSplitter(node, "Split", _split);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override void OnLayoutDeserialize()
|
|
{
|
|
_split.SplitterValue = 0.59f;
|
|
}
|
|
}
|
|
}
|