/// <summary>
///
/// </summary>
/// <param name="selection"></param>
/// <param name="maxWidth"></param>
/// <returns>Returns true on GUI change detected.</returns>
public static bool OnGUI(ProBuilderMesh[] selection, float width)
{
UpdateDiffDictionary(selection);
s_ScrollPosition = EditorGUILayout.BeginScrollView(s_ScrollPosition);
float tempFloat = 0f;
EditorGUI.BeginChangeCheck();
/**
* Set Tile mode
*/
GUILayout.Label("Tiling & Alignment", EditorStyles.boldLabel);
GUILayout.BeginHorizontal();
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["fill"];
GUILayout.Label("Fill Mode", GUILayout.MaxWidth(80), GUILayout.MinWidth(80));
EditorGUI.BeginChangeCheck();
s_AutoUVSettings.fill = (AutoUnwrapSettings.Fill)EditorGUILayout.EnumPopup(s_AutoUVSettings.fill);
if (EditorGUI.EndChangeCheck())
{
SetFill(s_AutoUVSettings.fill, selection);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
bool enabled = GUI.enabled;
GUI.enabled = !s_AutoUVSettings.useWorldSpace;
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["anchor"];
EditorGUI.BeginChangeCheck();
GUILayout.Label("Anchor", GUILayout.MaxWidth(80), GUILayout.MinWidth(80));
s_AutoUVSettings.anchor = (AutoUnwrapSettings.Anchor)EditorGUILayout.EnumPopup(s_AutoUVSettings.anchor);
if (EditorGUI.EndChangeCheck())
{
SetAnchor(s_AutoUVSettings.anchor, selection);
}
GUI.enabled = enabled;
GUILayout.EndHorizontal();
GUI.backgroundColor = PreferenceKeys.proBuilderLightGray;
UI.EditorGUIUtility.DrawSeparator(1);
GUI.backgroundColor = Color.white;
GUILayout.Label("Transform", EditorStyles.boldLabel);
/**
* Offset
*/
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["offsetx"] || s_AutoUVSettingsDiff["offsety"];
var tempVec2 = s_AutoUVSettings.offset;
UnityEngine.GUI.SetNextControlName("offset");
s_AutoUVSettings.offset = EditorGUILayout.Vector2Field("Offset", s_AutoUVSettings.offset, GUILayout.MaxWidth(width));
if (tempVec2.x != s_AutoUVSettings.offset.x)
{
SetOffset(s_AutoUVSettings.offset, Axis2D.X, selection);
}
if (tempVec2.y != s_AutoUVSettings.offset.y)
{
SetOffset(s_AutoUVSettings.offset, Axis2D.Y, selection);
}
/**
* Rotation
*/
tempFloat = s_AutoUVSettings.rotation;
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["rotation"];
GUILayout.Label(new GUIContent("Rotation", "Rotation around the center of face UV bounds."), GUILayout.MaxWidth(width - 64));
UnityEngine.GUI.SetNextControlName("rotation");
EditorGUI.BeginChangeCheck();
tempFloat = EditorGUILayout.Slider(tempFloat, 0f, 360f, GUILayout.MaxWidth(width));
if (EditorGUI.EndChangeCheck())
{
SetRotation(tempFloat, selection);
}
/**
* Scale
*/
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["scalex"] || s_AutoUVSettingsDiff["scaley"];
tempVec2 = s_AutoUVSettings.scale;
GUI.SetNextControlName("scale");
EditorGUI.BeginChangeCheck();
s_AutoUVSettings.scale = EditorGUILayout.Vector2Field("Tiling", s_AutoUVSettings.scale, GUILayout.MaxWidth(width));
if (EditorGUI.EndChangeCheck())
{
if (tempVec2.x != s_AutoUVSettings.scale.x)
{
SetScale(s_AutoUVSettings.scale, Axis2D.X, selection);
}
if (tempVec2.y != s_AutoUVSettings.scale.y)
{
SetScale(s_AutoUVSettings.scale, Axis2D.Y, selection);
}
}
// Draw tiling shortcuts
GUILayout.BeginHorizontal();
if (GUILayout.Button(".5", EditorStyles.miniButtonLeft))
{
SetScale(Vector2.one * 2f, Axis2D.XY, selection);
}
if (GUILayout.Button("1", EditorStyles.miniButtonMid))
{
SetScale(Vector2.one, Axis2D.XY, selection);
}
if (GUILayout.Button("2", EditorStyles.miniButtonMid))
{
SetScale(Vector2.one * .5f, Axis2D.XY, selection);
}
if (GUILayout.Button("4", EditorStyles.miniButtonMid))
{
SetScale(Vector2.one * .25f, Axis2D.XY, selection);
}
if (GUILayout.Button("8", EditorStyles.miniButtonMid))
{
SetScale(Vector2.one * .125f, Axis2D.XY, selection);
}
if (GUILayout.Button("16", EditorStyles.miniButtonRight))
{
SetScale(Vector2.one * .0625f, Axis2D.XY, selection);
}
GUILayout.EndHorizontal();
GUILayout.Space(4);
UnityEngine.GUI.backgroundColor = PreferenceKeys.proBuilderLightGray;
UI.EditorGUIUtility.DrawSeparator(1);
UnityEngine.GUI.backgroundColor = Color.white;
/**
* Special
*/
GUILayout.Label("Special", EditorStyles.boldLabel);
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["useWorldSpace"];
EditorGUI.BeginChangeCheck();
s_AutoUVSettings.useWorldSpace = EditorGUILayout.Toggle("World Space", s_AutoUVSettings.useWorldSpace);
if (EditorGUI.EndChangeCheck())
{
SetUseWorldSpace(s_AutoUVSettings.useWorldSpace, selection);
}
GUI.backgroundColor = PreferenceKeys.proBuilderLightGray;
UI.EditorGUIUtility.DrawSeparator(1);
GUI.backgroundColor = Color.white;
// Flip U
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["flipU"];
EditorGUI.BeginChangeCheck();
s_AutoUVSettings.flipU = EditorGUILayout.Toggle("Flip U", s_AutoUVSettings.flipU);
if (EditorGUI.EndChangeCheck())
{
SetFlipU(s_AutoUVSettings.flipU, selection);
}
// Flip V
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["flipV"];
EditorGUI.BeginChangeCheck();
s_AutoUVSettings.flipV = EditorGUILayout.Toggle("Flip V", s_AutoUVSettings.flipV);
if (EditorGUI.EndChangeCheck())
{
SetFlipV(s_AutoUVSettings.flipV, selection);
}
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["swapUV"];
EditorGUI.BeginChangeCheck();
s_AutoUVSettings.swapUV = EditorGUILayout.Toggle("Swap U/V", s_AutoUVSettings.swapUV);
if (EditorGUI.EndChangeCheck())
{
SetSwapUV(s_AutoUVSettings.swapUV, selection);
}
/**
* Texture Groups
*/
GUILayout.Label("Texture Groups", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = s_AutoUVSettingsDiff["textureGroup"];
GUI.SetNextControlName("textureGroup");
textureGroup = UI.EditorGUIUtility.IntFieldConstrained(new GUIContent("Texture Group", "Faces in a texture group will be UV mapped as a group, just as though you had selected these faces and used the \"Planar Project\" action"), textureGroup, (int)width);
if (EditorGUI.EndChangeCheck())
{
SetTextureGroup(selection, textureGroup);
foreach (var kvp in MeshSelection.selectedFacesInEditZone)
{
kvp.Key.RefreshUV(kvp.Value);
}
SceneView.RepaintAll();
s_AutoUVSettingsDiff["textureGroup"] = false;
}
if (GUILayout.Button(new GUIContent("Group Selected Faces", "This sets all selected faces to share a texture group. What that means is that the UVs on these faces will all be projected as though they are a single plane. Ideal candidates for texture groups are floors with multiple faces, walls with edge loops, flat surfaces, etc.")))
{
for (int i = 0; i < selection.Length; i++)
{
TextureGroupSelectedFaces(selection[i]);
}
ProBuilderEditor.Refresh();
}
if (GUILayout.Button(new GUIContent("Break Selected Groups", "This resets all the selected face Texture Groups.")))
{
SetTextureGroup(selection, -1);
foreach (var kvp in MeshSelection.selectedFacesInEditZone)
{
kvp.Key.ToMesh();
kvp.Key.Refresh();
kvp.Key.Optimize();
}
SceneView.RepaintAll();
s_AutoUVSettingsDiff["textureGroup"] = false;
ProBuilderEditor.Refresh();
}
/* Select all in current texture group */
if (GUILayout.Button(new GUIContent("Select Texture Group", "Selects all faces contained in this texture group.")))
{
for (int i = 0; i < selection.Length; i++)
{
selection[i].SetSelectedFaces(System.Array.FindAll(selection[i].facesInternal, x => x.textureGroup == textureGroup));
}
ProBuilderEditor.Refresh();
}
if (GUILayout.Button(new GUIContent("Reset UVs", "Reset UV projection parameters.")))
{
UndoUtility.RecordSelection(selection, "Reset UVs");
for (int i = 0; i < selection.Length; i++)
{
foreach (Face face in selection[i].GetSelectedFaces())
{
face.uv = AutoUnwrapSettings.tile;
}
}
ProBuilderEditor.Refresh();
}
GUI.backgroundColor = PreferenceKeys.proBuilderLightGray;
UI.EditorGUIUtility.DrawSeparator(1);
GUI.backgroundColor = Color.white;
/**
* Clean up
*/
GUILayout.EndScrollView();
EditorGUI.showMixedValue = false;
return(EditorGUI.EndChangeCheck());
}
public override void OnWillBeDeactivated()
{
base.OnWillBeDeactivated();
EditorApplication.delayCall += () => ProBuilderEditor.ResetToLastSelectMode();
}
public static void DoMouseDrag(Rect mouseDragRect, SelectMode selectionMode, ScenePickerPreferences scenePickerPreferences)
{
var pickingOptions = new PickerOptions()
{
depthTest = scenePickerPreferences.cullMode == CullingMode.Back,
rectSelectMode = scenePickerPreferences.rectSelectMode
};
UndoUtility.RecordSelection("Drag Select");
bool isAppendModifier = EditorHandleUtility.IsAppendModifier(Event.current.modifiers);
if (!isAppendModifier)
{
MeshSelection.ClearElementSelection();
}
bool elementsInDragRect = false;
switch (selectionMode)
{
case SelectMode.Vertex:
case SelectMode.TextureVertex:
{
Dictionary <ProBuilderMesh, HashSet <int> > selected = SelectionPicker.PickVerticesInRect(
SceneView.lastActiveSceneView.camera,
mouseDragRect,
MeshSelection.topInternal,
pickingOptions,
EditorGUIUtility.pixelsPerPoint);
foreach (var kvp in selected)
{
var mesh = kvp.Key;
SharedVertex[] sharedIndexes = mesh.sharedVerticesInternal;
HashSet <int> common;
if (isAppendModifier)
{
common = mesh.GetSharedVertexHandles(mesh.selectedIndexesInternal);
if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Add)
{
common.UnionWith(kvp.Value);
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Subtract)
{
common.RemoveWhere(x => kvp.Value.Contains(x));
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Difference)
{
common.SymmetricExceptWith(kvp.Value);
}
}
else
{
common = kvp.Value;
}
elementsInDragRect |= kvp.Value.Any();
mesh.SetSelectedVertices(common.SelectMany(x => sharedIndexes[x]));
}
break;
}
case SelectMode.Face:
case SelectMode.TextureFace:
{
Dictionary <ProBuilderMesh, HashSet <Face> > selected = SelectionPicker.PickFacesInRect(
SceneView.lastActiveSceneView.camera,
mouseDragRect,
MeshSelection.topInternal,
pickingOptions,
EditorGUIUtility.pixelsPerPoint);
foreach (var kvp in selected)
{
HashSet <Face> current;
if (isAppendModifier)
{
current = new HashSet <Face>(kvp.Key.selectedFacesInternal);
if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Add)
{
current.UnionWith(kvp.Value);
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Subtract)
{
current.RemoveWhere(x => kvp.Value.Contains(x));
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Difference)
{
current.SymmetricExceptWith(kvp.Value);
}
}
else
{
current = kvp.Value;
}
elementsInDragRect |= kvp.Value.Any();
kvp.Key.SetSelectedFaces(current);
}
break;
}
case SelectMode.Edge:
case SelectMode.TextureEdge:
{
var selected = SelectionPicker.PickEdgesInRect(
SceneView.lastActiveSceneView.camera,
mouseDragRect,
MeshSelection.topInternal,
pickingOptions,
EditorGUIUtility.pixelsPerPoint);
foreach (var kvp in selected)
{
ProBuilderMesh mesh = kvp.Key;
Dictionary <int, int> common = mesh.sharedVertexLookup;
HashSet <EdgeLookup> selectedEdges = EdgeLookup.GetEdgeLookupHashSet(kvp.Value, common);
HashSet <EdgeLookup> current;
if (isAppendModifier)
{
current = EdgeLookup.GetEdgeLookupHashSet(mesh.selectedEdges, common);
if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Add)
{
current.UnionWith(selectedEdges);
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Subtract)
{
current.RemoveWhere(x => selectedEdges.Contains(x));
}
else if (scenePickerPreferences.selectionModifierBehavior == SelectionModifierBehavior.Difference)
{
current.SymmetricExceptWith(selectedEdges);
}
}
else
{
current = selectedEdges;
}
elementsInDragRect |= kvp.Value.Any();
mesh.SetSelectedEdges(current.Select(x => x.local));
}
break;
}
}
// if nothing was selected in the drag rect, clear the object selection too
if (!elementsInDragRect && !isAppendModifier)
{
MeshSelection.ClearElementAndObjectSelection();
}
ProBuilderEditor.Refresh();
SceneView.RepaintAll();
}
void ApplyTranslation(Vector3 translation)
{
var translationMagnitude = translation.magnitude;
foreach (var key in elementSelection)
{
if (!(key is MeshAndPositions))
{
continue;
}
var kvp = (MeshAndPositions)key;
var mesh = kvp.mesh;
var worldToLocal = mesh.transform.worldToLocalMatrix;
var origins = kvp.positions;
var positions = mesh.positionsInternal;
foreach (var group in kvp.elementGroups)
{
var postApplyMatrix = GetPostApplyMatrix(group);
var preApplyMatrix = postApplyMatrix.inverse;
foreach (var index in group.indices)
{
// res = Group pre-apply matrix * world vertex position
// res += translation
// res = Group post-apply matrix * res
// positions[i] = mesh.worldToLocal * res
if (EditorSnapping.snapMode == SnapMode.World && !m_SnapAsGroup)
{
if (snapAxisConstraint && m_ActiveAxesWorld.active == 1)
{
var wp = postApplyMatrix.MultiplyPoint3x4(preApplyMatrix.MultiplyPoint3x4(origins[index]));
var snap = ProBuilderSnapping.SnapValueOnRay(
new Ray(wp, m_RawHandleDelta),
translationMagnitude,
GetSnapValueForAxis(m_ActiveAxesWorld),
m_ActiveAxesWorld);
positions[index] = worldToLocal.MultiplyPoint3x4(snap);
}
else
{
var wp = postApplyMatrix.MultiplyPoint3x4(translation + preApplyMatrix.MultiplyPoint3x4(origins[index]));
var snap = ProBuilderSnapping.Snap(wp, snapValue);
positions[index] = worldToLocal.MultiplyPoint3x4(snap);
}
}
else
{
positions[index] = worldToLocal.MultiplyPoint3x4(
postApplyMatrix.MultiplyPoint3x4(
translation + preApplyMatrix.MultiplyPoint3x4(origins[index])));
}
}
}
mesh.mesh.vertices = positions;
mesh.RefreshUV(MeshSelection.selectedFacesInEditZone[mesh]);
mesh.Refresh(RefreshMask.Normals);
}
ProBuilderEditor.Refresh(false);
}
void OnGUI()
{
DoContextMenu();
GUILayout.BeginHorizontal(EditorStyles.toolbar);
GUILayout.FlexibleSpace();
GUIStyle style = m_WorldSpace ? EditorStyles.toolbarButton : UI.EditorGUIUtility.GetOnStyle(EditorStyles.toolbarButton);
if (GUILayout.Button(m_WorldSpace ? "World Space" : "Model Space", style))
{
m_WorldSpace = !m_WorldSpace;
}
GUILayout.EndHorizontal();
if (m_Selection == null || m_Selection.Count < 1 || !m_Selection.Any(x => x.Key.selectedVertexCount > 0))
{
GUILayout.FlexibleSpace();
GUILayout.Label("Select a ProBuilder Mesh", UI.EditorGUIUtility.CenteredGreyMiniLabel);
GUILayout.FlexibleSpace();
return;
}
Event e = Event.current;
if (m_IsActive)
{
if (e.type == EventType.Ignore ||
e.type == EventType.MouseUp)
{
OnVertexMovementFinish();
}
}
m_Scroll = EditorGUILayout.BeginScrollView(m_Scroll);
foreach (var kvp in m_Selection)
{
ProBuilderMesh mesh = kvp.Key;
VertexEditorSelection sel = kvp.Value;
bool open = sel.isVisible;
EditorGUI.BeginChangeCheck();
open = EditorGUILayout.Foldout(open, mesh.name);
if (EditorGUI.EndChangeCheck())
{
sel.isVisible = open;
}
if (open)
{
int index = 0;
bool wasWideMode = EditorGUIUtility.wideMode;
EditorGUIUtility.wideMode = true;
Color background = GUI.backgroundColor;
Transform transform = mesh.transform;
foreach (int u in sel.common)
{
GUI.backgroundColor = index % 2 == 0 ? s_EvenColor : s_OddColor;
GUILayout.BeginHorizontal(UI.EditorGUIUtility.solidBackgroundStyle);
GUI.backgroundColor = background;
GUILayout.Label(u.ToString(), GUILayout.MinWidth(32), GUILayout.MaxWidth(32));
Vector3 v = mesh.positionsInternal[mesh.sharedVerticesInternal[u][0]];
if (m_WorldSpace)
{
v = transform.TransformPoint(v);
}
EditorGUI.BeginChangeCheck();
v = EditorGUILayout.Vector3Field("", v);
if (EditorGUI.EndChangeCheck())
{
if (!m_IsActive)
{
OnVertexMovementBegin(mesh);
}
UndoUtility.RecordObject(mesh, "Set Vertex Postion");
mesh.SetSharedVertexPosition(u, m_WorldSpace ? transform.InverseTransformPoint(v) : v);
if (ProBuilderEditor.instance != null)
{
mesh.RefreshUV(MeshSelection.selectedFacesInEditZone[mesh]);
mesh.Refresh(RefreshMask.Normals);
mesh.mesh.RecalculateBounds();
ProBuilderEditor.Refresh();
}
}
index++;
GUILayout.EndHorizontal();
}
GUI.backgroundColor = background;
EditorGUIUtility.wideMode = wasWideMode;
}
}
EditorGUILayout.EndScrollView();
}
void OnBecameVisible()
{
// fixes maximizing/unmaximizing
s_Instance = this;
}