You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
497 lines
22 KiB
C#
497 lines
22 KiB
C#
using UnityEngine;
|
|
using UnityEditor;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System;
|
|
|
|
namespace UnityEditor.Polybrush
|
|
{
|
|
/// <summary>
|
|
/// CustomEditor for PrefabPalette.
|
|
/// </summary>
|
|
[CustomEditor(typeof(PrefabPalette))]
|
|
public class PrefabPaletteEditor : Editor
|
|
{
|
|
internal SerializedProperty prefabs;
|
|
internal HashSet<int> selected = new HashSet<int>();
|
|
internal PrefabLoadoutEditor loadoutEditor;
|
|
internal Action<IEnumerable<int>> onSelectionChanged = null;
|
|
|
|
static internal GUIStyle paletteStyle = new GUIStyle();
|
|
|
|
GUIContent m_GCCurrentPaletteLabel = new GUIContent("Current Palette", "Currently selected Prefabs Palette");
|
|
GUIContent m_GCPlacementSettingsLabel = new GUIContent("Placement Settings", "Currently selected Prefab(s) settings");
|
|
|
|
private void OnEnable()
|
|
{
|
|
paletteStyle.padding = new RectOffset(8, 8, 8, 8);
|
|
prefabs = serializedObject.FindProperty("prefabs");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a New PrefabPalette
|
|
/// </summary>
|
|
/// <returns>The Newly created PrefabPalette</returns>
|
|
internal static PrefabPalette AddNew()
|
|
{
|
|
string path = PolyEditorUtility.UserAssetDirectory + "Prefab Palette";
|
|
|
|
if (string.IsNullOrEmpty(path))
|
|
path = "Assets";
|
|
|
|
path = AssetDatabase.GenerateUniqueAssetPath(path + "/New Prefab Palette.asset");
|
|
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
PrefabPalette palette = ScriptableObject.CreateInstance<PrefabPalette>();
|
|
palette.SetDefaultValues();
|
|
|
|
AssetDatabase.CreateAsset(palette, path);
|
|
AssetDatabase.Refresh();
|
|
|
|
EditorGUIUtility.PingObject(palette);
|
|
|
|
return palette;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overriding function to make a custom IMGUI inspector.
|
|
/// </summary>
|
|
public override void OnInspectorGUI()
|
|
{
|
|
if (loadoutEditor != null)
|
|
{
|
|
OnInspectorGUI_Internal(64);
|
|
}
|
|
}
|
|
|
|
private bool IsDeleteKey(Event e)
|
|
{
|
|
return e.keyCode == KeyCode.Backspace;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draw everything concerning a single Prefab Palette in the Polybrush Window
|
|
/// </summary>
|
|
/// <param name="thumbSize">size of the preview textures</param>
|
|
internal void OnInspectorGUI_Internal(int thumbSize)
|
|
{
|
|
PolyGUILayout.Label(m_GCCurrentPaletteLabel);
|
|
|
|
serializedObject.Update();
|
|
int count = prefabs != null ? prefabs.arraySize : 0;
|
|
Rect dropDownZone = EditorGUILayout.BeginVertical(paletteStyle);
|
|
dropDownZone.width = EditorGUIUtility.currentViewWidth;
|
|
Rect backGroundRect = new Rect(dropDownZone);
|
|
|
|
if (count != 0)
|
|
{
|
|
const int pad = 4;
|
|
int size = thumbSize + pad;
|
|
backGroundRect.x += 8;
|
|
backGroundRect.y += 4;
|
|
// The backgroundRect is currently as wide as the current view.
|
|
// Adjust it to take the size of the vertical scrollbar and padding into account.
|
|
backGroundRect.width -= (20 + (int)GUI.skin.verticalScrollbar.fixedWidth);
|
|
// size variable will not take into account the padding to the right of all the thumbnails,
|
|
// therefore it needs to be substracted from the width.
|
|
int container_width = ((int)Mathf.Floor(backGroundRect.width) - (pad + 1));
|
|
int columns = (int)Mathf.Floor(container_width / size);
|
|
int rows = count / columns + (count % columns == 0 ? 0 : 1);
|
|
if (rows < 1) rows = 1;
|
|
|
|
backGroundRect.height = 8 + rows * thumbSize + (rows - 1) * pad;
|
|
EditorGUI.DrawRect(backGroundRect, EditorGUIUtility.isProSkin ? PolyGUI.k_BoxBackgroundDark : PolyGUI.k_BoxBackgroundLight);
|
|
|
|
int currentIndex = 0;
|
|
for (int i = 0; i < rows; i++)
|
|
{
|
|
var horizontalRect = EditorGUILayout.BeginHorizontal();
|
|
for (int j = 0; j < columns; j++)
|
|
{
|
|
GUILayout.Space(pad);
|
|
var prefab = prefabs.GetArrayElementAtIndex(currentIndex);
|
|
var previewRectXPos = pad + j * size + horizontalRect.x;
|
|
DrawPrefabPreview(prefab, currentIndex, thumbSize, previewRectXPos, horizontalRect.y);
|
|
currentIndex++;
|
|
if (currentIndex >= count)
|
|
break;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
GUILayout.Space(pad);
|
|
}
|
|
|
|
EditorGUILayout.EndVertical();
|
|
|
|
if (selected.Count > 0)
|
|
{
|
|
EditorGUILayout.LabelField(m_GCPlacementSettingsLabel);
|
|
GUILayout.Space(pad);
|
|
}
|
|
|
|
EditorGUILayout.BeginVertical();
|
|
|
|
foreach (var i in selected)
|
|
DrawSinglePrefabPlacementSettings(prefabs.GetArrayElementAtIndex(i), i);
|
|
|
|
/// Little Hack to get the Rect for dropping new prefabs
|
|
Rect endDropDownZone = EditorGUILayout.BeginVertical();
|
|
dropDownZone.height = endDropDownZone.y - dropDownZone.y;
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
else
|
|
{
|
|
dropDownZone.height = thumbSize;
|
|
var r = EditorGUILayout.BeginVertical(GUILayout.Height(thumbSize+4));
|
|
EditorGUI.DrawRect(r, EditorGUIUtility.isProSkin ? PolyGUI.k_BoxBackgroundDark : PolyGUI.k_BoxBackgroundLight);
|
|
GUILayout.FlexibleSpace();
|
|
GUILayout.Label("Drag Prefabs Here!", EditorStyles.centeredGreyMiniLabel);
|
|
GUILayout.FlexibleSpace();
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
|
|
Event e = Event.current;
|
|
|
|
if (dropDownZone.Contains(e.mousePosition) &&
|
|
(e.type == EventType.DragUpdated || e.type == EventType.DragPerform) && DragAndDrop.objectReferences.Length > 0)
|
|
{
|
|
if (PolyEditorUtility.ContainsPrefabAssets(DragAndDrop.objectReferences))
|
|
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
|
|
else
|
|
DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
|
|
|
|
if (e.type == EventType.DragPerform)
|
|
{
|
|
DragAndDrop.AcceptDrag();
|
|
|
|
IEnumerable<GameObject> dragAndDropReferences = DragAndDrop.objectReferences
|
|
.Where(x => x is GameObject && PolyEditorUtility.IsPrefabAsset(x)).Cast<GameObject>();
|
|
|
|
foreach (GameObject go in dragAndDropReferences)
|
|
{
|
|
prefabs.InsertArrayElementAtIndex(prefabs.arraySize);
|
|
SerializedProperty last = prefabs.GetArrayElementAtIndex(prefabs.arraySize - 1);
|
|
SerializedProperty gameObject = last.FindPropertyRelative("gameObject");
|
|
gameObject.objectReferenceValue = go;
|
|
PlacementSettings.PopulateSerializedProperty(last.FindPropertyRelative("settings"));
|
|
last.FindPropertyRelative("name").stringValue = go.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (e.type == EventType.KeyUp)
|
|
{
|
|
if (IsDeleteKey(e) && !GUI.GetNameOfFocusedControl().Contains("cancelbackspace"))
|
|
{
|
|
PrefabPalette t = target as PrefabPalette;
|
|
t.RemoveRange(selected.ToArray());
|
|
|
|
selected.Clear();
|
|
|
|
if (onSelectionChanged != null)
|
|
onSelectionChanged(null);
|
|
|
|
PolybrushEditor.DoRepaint();
|
|
}
|
|
}
|
|
|
|
serializedObject.ApplyModifiedProperties();
|
|
redrawCounter += 1;
|
|
}
|
|
|
|
private bool shouldopencontextmenu = false;
|
|
private int rightClickTime = 0;
|
|
private int redrawCounter = 0;
|
|
private int idx = -1;
|
|
|
|
/// <summary>
|
|
/// Draws previews for a prefab in the palette.
|
|
/// </summary>
|
|
/// <param name="prefab">Prefab being previewed</param>
|
|
/// <param name="index">index of the prefab in `prefabs`</param>
|
|
/// <param name="thumbSize">Size of the preview texture</param>
|
|
private void DrawPrefabPreview(SerializedProperty prefab, int index, int thumbSize, float x, float y)
|
|
{
|
|
Rect r = new Rect(x, y, thumbSize, thumbSize);
|
|
Rect rightClickZone = new Rect(r);
|
|
|
|
// Texture Preview
|
|
UnityEngine.Object o = prefab.FindPropertyRelative("gameObject").objectReferenceValue;
|
|
|
|
Texture2D preview = PreviewsDatabase.GetAssetPreview(o);
|
|
if (selected.Contains(index))
|
|
{
|
|
Rect r2 = new Rect(r);
|
|
r2.x -= 1;
|
|
r2.y -= 1;
|
|
r2.width += 2;
|
|
r2.height += 2;
|
|
EditorGUI.DrawRect(r2, Color.blue);
|
|
}
|
|
|
|
EditorGUI.DrawPreviewTexture(r, preview);
|
|
|
|
// Those numbers were obtained by empirical experimentation
|
|
r.x += thumbSize - 17;
|
|
r.y += thumbSize - 17;
|
|
r.width = 17;
|
|
r.height = 17;
|
|
LoadoutInfo li = new LoadoutInfo(target as PrefabPalette, index);
|
|
bool isLoaded = loadoutEditor.ContainsPrefab(li);
|
|
Event e = Event.current;
|
|
bool rightClick = (e.type == EventType.MouseDown || e.type == EventType.ContextClick) && rightClickZone.Contains(e.mousePosition) && e.button == 1;
|
|
bool b1 = GUI.Toggle(r, isLoaded, "");
|
|
// Reducing the width by 1 to ensure the button is not larger than the thumbnail.
|
|
// Otherwise button is slightly too large and horizontal scrollbar may appear.
|
|
bool b2 = GUILayout.Button("", GUIStyle.none, GUILayout.Width(thumbSize-1), GUILayout.Height(thumbSize));
|
|
// Set the focus to nothing in case the user want to press delete or backspace key
|
|
// I dont know why but If we don't do that the Textfield with the name of prefab settings never looses focus
|
|
if (b2 || rightClick)
|
|
{
|
|
GUI.FocusControl(null);
|
|
e.Use();
|
|
}
|
|
if (rightClick)
|
|
{
|
|
rightClickTime = redrawCounter;
|
|
shouldopencontextmenu = true;
|
|
idx = index;
|
|
if (!selected.Contains(index))
|
|
{
|
|
selected.Clear();
|
|
selected.Add(index);
|
|
}
|
|
return;
|
|
}
|
|
else if (shouldopencontextmenu && redrawCounter > rightClickTime)
|
|
{
|
|
loadoutEditor.OpenCopyPasteMenu(new LoadoutInfo(target as PrefabPalette, idx), selected);
|
|
shouldopencontextmenu = false;
|
|
idx = -1;
|
|
// reset the redraw counter to avoid overflow
|
|
redrawCounter = 0;
|
|
}
|
|
|
|
if (b1 && !isLoaded)
|
|
{
|
|
loadoutEditor.AddPrefabInLoadout(li);
|
|
//loadoutEditor.loadouts.Add(li);
|
|
}
|
|
else if (!b1 && isLoaded)
|
|
{
|
|
loadoutEditor.RemovePrefabFromLoadout(li);
|
|
//loadoutEditor.loadouts.Remove(li);
|
|
}
|
|
else if (b2)
|
|
{
|
|
if (Event.current.shift || Event.current.control)
|
|
{
|
|
if (!selected.Add(index))
|
|
selected.Remove(index);
|
|
}
|
|
else
|
|
{
|
|
if (selected.Count == 1 && selected.Contains(index))
|
|
selected.Remove(index);
|
|
else
|
|
{
|
|
selected.Clear();
|
|
selected.Add(index);
|
|
}
|
|
}
|
|
|
|
if (onSelectionChanged != null)
|
|
onSelectionChanged(selected);
|
|
|
|
GUI.changed = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Show the specific placement settings for a prefab in the palette
|
|
/// </summary>
|
|
/// <param name="prefab">The prefab whose settings we're showing</param>
|
|
/// <param name="index">The index of the prefab in `prefabs`</param>
|
|
private void DrawSinglePrefabPlacementSettings(SerializedProperty prefab, int index)
|
|
{
|
|
SerializedProperty go = prefab.FindPropertyRelative("gameObject");
|
|
SerializedProperty settings = prefab.FindPropertyRelative("settings");
|
|
SerializedProperty name = prefab.FindPropertyRelative("name");
|
|
|
|
SerializedProperty uniformBool = settings.FindPropertyRelative("m_UniformBool");
|
|
SerializedProperty strength = settings.FindPropertyRelative("m_Strength");
|
|
SerializedProperty minRot = settings.FindPropertyRelative("m_RotationRangeMin");
|
|
SerializedProperty maxRot = settings.FindPropertyRelative("m_RotationRangeMax");
|
|
SerializedProperty minScale = settings.FindPropertyRelative("m_ScaleRangeMin");
|
|
SerializedProperty maxScale = settings.FindPropertyRelative("m_ScaleRangeMax");
|
|
SerializedProperty xScaleBool = settings.FindPropertyRelative("m_XScaleBool");
|
|
SerializedProperty yScaleBool = settings.FindPropertyRelative("m_YScaleBool");
|
|
SerializedProperty zScaleBool = settings.FindPropertyRelative("m_ZScaleBool");
|
|
SerializedProperty xRotationBool = settings.FindPropertyRelative("m_XRotationBool");
|
|
SerializedProperty yRotationBool = settings.FindPropertyRelative("m_YRotationBool");
|
|
SerializedProperty zRotationBool = settings.FindPropertyRelative("m_ZRotationBool");
|
|
|
|
const int pad = 4;
|
|
|
|
var settingsBackgroundStyle = new GUIStyle();
|
|
settingsBackgroundStyle.normal.background = EditorGUIUtility.whiteTexture;
|
|
settingsBackgroundStyle.padding = new RectOffset(0, 0, 0, 0);
|
|
PolyGUI.PushBackgroundColor(EditorGUIUtility.isProSkin ? PolyGUI.k_BoxBackgroundDark : PolyGUI.k_BoxBackgroundLight);
|
|
|
|
EditorGUILayout.BeginVertical(settingsBackgroundStyle);
|
|
|
|
GUILayout.Space(pad);
|
|
|
|
PolyGUI.PopBackgroundColor();
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Space(pad);
|
|
|
|
/// Name field And Strenght Slider
|
|
using (new GUILayout.VerticalScope())
|
|
{
|
|
GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
|
|
GUI.SetNextControlName("cancelbackspace1" + index);
|
|
name.stringValue = GUILayout.TextField(name.stringValue, GUILayout.ExpandWidth(true));
|
|
GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUI.SetNextControlName("cancelbackspace2" + index);
|
|
strength.floatValue = EditorGUILayout.Slider("Frequency (%)", strength.floatValue,
|
|
BrushModePrefab.k_PrefabOccurrenceMin, BrushModePrefab.k_PrefabOccurrenceMax, GUILayout.ExpandWidth(true));
|
|
}
|
|
}
|
|
GUILayout.Space(pad);
|
|
}
|
|
|
|
GUILayout.BeginVertical();
|
|
|
|
float floatfieldWidth = EditorGUIUtility.currentViewWidth / 10;
|
|
GUILayoutOption[] floatFieldsOptions = new GUILayoutOption[] { GUILayout.Width(floatfieldWidth), GUILayout.MinWidth(40) };
|
|
GUILayoutOption widthConstraint = GUILayout.Width(15);
|
|
|
|
int slidersMargin = 15;
|
|
|
|
EditorGUILayout.LabelField("Randomize Scale");
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
GUILayout.Space(slidersMargin);
|
|
EditorGUILayout.LabelField("Uniform Scale", GUILayout.Width(90));
|
|
uniformBool.boolValue = EditorGUILayout.Toggle(uniformBool.boolValue, widthConstraint);
|
|
GUILayout.FlexibleSpace();
|
|
if (uniformBool.boolValue)
|
|
{
|
|
SerializedProperty uScale = settings.FindPropertyRelative("m_UniformScale");
|
|
Vector2 uniformScale = uScale.vector2Value;
|
|
GUILayout.Space(slidersMargin);
|
|
GUI.SetNextControlName("cancelbackspace3" + index);
|
|
uniformScale.x = EditorGUILayout.FloatField(uniformScale.x, floatFieldsOptions);
|
|
EditorGUILayout.MinMaxSlider(ref uniformScale.x, ref uniformScale.y, 0.0f, 10f);
|
|
GUI.SetNextControlName("cancelbackspace4" + index);
|
|
uniformScale.y = EditorGUILayout.FloatField(uniformScale.y, floatFieldsOptions);
|
|
GUILayout.FlexibleSpace();
|
|
uScale.vector2Value = uniformScale;
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
else
|
|
{
|
|
EditorGUILayout.EndHorizontal();
|
|
//Random Scale
|
|
Vector3 scaleRangeMin = minScale.vector3Value;
|
|
Vector3 scaleRangeMax = maxScale.vector3Value;
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Space(slidersMargin);
|
|
xScaleBool.boolValue = EditorGUILayout.Toggle(xScaleBool.boolValue, widthConstraint);
|
|
EditorGUILayout.LabelField("X", widthConstraint);
|
|
GUI.SetNextControlName("cancelbackspace5" + index);
|
|
scaleRangeMin.x = EditorGUILayout.FloatField(scaleRangeMin.x, floatFieldsOptions);
|
|
EditorGUILayout.MinMaxSlider(ref scaleRangeMin.x, ref scaleRangeMax.x, 0.0f, 10f);
|
|
GUI.SetNextControlName("cancelbackspace6" + index);
|
|
scaleRangeMax.x = EditorGUILayout.FloatField(scaleRangeMax.x, floatFieldsOptions);
|
|
}
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Space(slidersMargin);
|
|
yScaleBool.boolValue = EditorGUILayout.Toggle(yScaleBool.boolValue, widthConstraint);
|
|
EditorGUILayout.LabelField("Y", widthConstraint);
|
|
GUI.SetNextControlName("cancelbackspace7" + index);
|
|
scaleRangeMin.y = EditorGUILayout.FloatField(scaleRangeMin.y, floatFieldsOptions);
|
|
EditorGUILayout.MinMaxSlider(ref scaleRangeMin.y, ref scaleRangeMax.y, 0.0f, 10f);
|
|
GUI.SetNextControlName("cancelbackspace8" + index);
|
|
scaleRangeMax.y = EditorGUILayout.FloatField(scaleRangeMax.y, floatFieldsOptions);
|
|
}
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Space(slidersMargin);
|
|
zScaleBool.boolValue = EditorGUILayout.Toggle(zScaleBool.boolValue, widthConstraint);
|
|
EditorGUILayout.LabelField("Z", widthConstraint);
|
|
GUI.SetNextControlName("cancelbackspace9" + index);
|
|
scaleRangeMin.z = EditorGUILayout.FloatField(scaleRangeMin.z, floatFieldsOptions);
|
|
EditorGUILayout.MinMaxSlider(ref scaleRangeMin.z, ref scaleRangeMax.z, 0.0f, 10f);
|
|
GUI.SetNextControlName("cancelbackspace10" + index);
|
|
scaleRangeMax.z = EditorGUILayout.FloatField(scaleRangeMax.z, floatFieldsOptions);
|
|
}
|
|
minScale.vector3Value = scaleRangeMin;
|
|
maxScale.vector3Value = scaleRangeMax;
|
|
}
|
|
|
|
// Random Rotation
|
|
Vector3 rotationRangeMin = minRot.vector3Value;
|
|
Vector3 rotationRangeMax = maxRot.vector3Value;
|
|
EditorGUILayout.LabelField("Randomize Rotation");
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Space(slidersMargin);
|
|
xRotationBool.boolValue = EditorGUILayout.Toggle(xRotationBool.boolValue, widthConstraint);
|
|
EditorGUILayout.LabelField("X", widthConstraint);
|
|
GUI.SetNextControlName("cancelbackspace11" + index);
|
|
rotationRangeMin.x = EditorGUILayout.FloatField(rotationRangeMin.x, floatFieldsOptions);
|
|
EditorGUILayout.MinMaxSlider(ref rotationRangeMin.x, ref rotationRangeMax.x, 0.0f, 360f);
|
|
GUI.SetNextControlName("cancelbackspace12" + index);
|
|
rotationRangeMax.x = EditorGUILayout.FloatField(rotationRangeMax.x, floatFieldsOptions);
|
|
}
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Space(slidersMargin);
|
|
yRotationBool.boolValue = EditorGUILayout.Toggle(yRotationBool.boolValue, widthConstraint);
|
|
EditorGUILayout.LabelField("Y", widthConstraint);
|
|
GUI.SetNextControlName("cancelbackspace13" + index);
|
|
rotationRangeMin.y = EditorGUILayout.FloatField(rotationRangeMin.y, floatFieldsOptions);
|
|
EditorGUILayout.MinMaxSlider(ref rotationRangeMin.y, ref rotationRangeMax.y, 0.0f, 360f);
|
|
GUI.SetNextControlName("cancelbackspace14" + index);
|
|
rotationRangeMax.y = EditorGUILayout.FloatField(rotationRangeMax.y, floatFieldsOptions);
|
|
}
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Space(slidersMargin);
|
|
zRotationBool.boolValue = EditorGUILayout.Toggle(zRotationBool.boolValue, widthConstraint);
|
|
EditorGUILayout.LabelField("Z", widthConstraint);
|
|
GUI.SetNextControlName("cancelbackspace15" + index);
|
|
rotationRangeMin.z = EditorGUILayout.FloatField(rotationRangeMin.z, floatFieldsOptions);
|
|
EditorGUILayout.MinMaxSlider(ref rotationRangeMin.z, ref rotationRangeMax.z, 0.0f, 360f);
|
|
GUI.SetNextControlName("cancelbackspace16" + index);
|
|
rotationRangeMax.z = EditorGUILayout.FloatField(rotationRangeMax.z, floatFieldsOptions);
|
|
}
|
|
minRot.vector3Value = rotationRangeMin;
|
|
maxRot.vector3Value = rotationRangeMax;
|
|
GUILayout.EndVertical();
|
|
|
|
GUILayout.Space(pad);
|
|
GUILayout.EndVertical();
|
|
GUILayout.Space(pad);
|
|
}
|
|
}
|
|
}
|