BlackMATov/unity-iso-tools
1
0
Fork 0
mirror of https://github.com/BlackMATov/unity-iso-tools.git synced 2025-12-15 01:12:05 +07:00
Code Issues Packages Projects Releases Wiki Activity

multiple worlds support done

Browse Source
This commit is contained in:
Matvey Cherevko
2016-12-19 02:30:30 +07:00
parent c5084b1596
commit 236e72d879
12 changed files with 2767 additions and 636 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
Assets/IsoTools/Scripts/Internal/Editor/IsoEditorUtils.cs
View File

@@ -1,8 +1,17 @@
using UnityEngine;
using UnityEditor;
using System.Linq;
using System.Collections.Generic;
namespace IsoTools.Internal {
static class IsoEditorUtils {
// ---------------------------------------------------------------------
//
// Inspector
//
// ---------------------------------------------------------------------
public static void DoWithMixedValue(bool mixed, System.Action act) {
var last_show_mixed_value = EditorGUI.showMixedValue;
EditorGUI.showMixedValue = mixed;
@@ -21,5 +30,298 @@ namespace IsoTools.Internal {
EditorGUI.EndDisabledGroup();
}
}
public static void DrawWorldProperties(IsoWorld[] iso_worlds) {
if ( iso_worlds.Length > 0 ) {
var so = new SerializedObject(iso_worlds);
var so_prop = so.GetIterator();
if ( so_prop.NextVisible(true) ) {
while ( so_prop.NextVisible(true) ) {
EditorGUILayout.PropertyField(so_prop);
}
}
if ( GUI.changed ) {
so.ApplyModifiedProperties();
}
}
}
public static void DrawSelfWorldProperty(IsoWorld[] iso_worlds, string type_name) {
if ( iso_worlds.Length > 0 ) {
var mixed_world = iso_worlds.GroupBy(p => p).Count() > 1;
EditorGUILayout.Space();
IsoEditorUtils.DoWithEnabledGUI(false, () => {
IsoEditorUtils.DoWithMixedValue(mixed_world, () => {
EditorGUILayout.ObjectField(
"Current IsoWorld",
iso_worlds.First(),
typeof(IsoWorld),
true);
});
});
} else {
EditorGUILayout.HelpBox(
string.Format(
"Detached {0}\nNeed to be a child of IsoWorld",
type_name),
MessageType.Warning,
true);
}
}
// ---------------------------------------------------------------------
//
// Editor
//
// ---------------------------------------------------------------------
public static float ZMoveIsoObjects(
bool move,
IsoWorld iso_world,
Dictionary<IsoWorld, List<IsoObject>> all_iso_objects,
Dictionary<IsoWorld, List<IsoObject>> all_other_objects,
float delta)
{
List<IsoObject> iso_objects;
if ( all_iso_objects.TryGetValue(iso_world, out iso_objects) ) {
if ( move ) {
Undo.RecordObjects(
iso_objects.ToArray(),
iso_objects.Count > 1 ? "Move IsoObjects" : "Move IsoObject");
}
List<IsoObject> other_objects;
if ( all_other_objects.TryGetValue(iso_world, out other_objects) && other_objects.Count > 0 ) {
var snapping_z = false;
if ( IsSnapByObjectsEnabled(iso_world) ) {
foreach ( var iso_object in iso_objects ) {
var iso_orig_z = iso_object.positionZ;
var result_p_z = iso_orig_z + delta;
foreach ( var other in other_objects ) {
if ( IsoEditorUtils.IsSnapOverlaps(iso_object.positionX, iso_object.sizeX, other.positionX, other.sizeX) &&
IsoEditorUtils.IsSnapOverlaps(iso_object.positionY, iso_object.sizeY, other.positionY, other.sizeY) )
{
var new_snapping_z = !snapping_z && IsoEditorUtils.IsSnapOverlaps(result_p_z, iso_object.sizeZ, other.positionZ, other.sizeZ)
? IsoEditorUtils.SnapProcess(ref result_p_z, iso_object.sizeZ, other.positionZ, other.sizeZ)
: false;
if ( new_snapping_z ) {
delta = result_p_z - iso_orig_z;
snapping_z = true;
break;
}
}
}
if ( snapping_z ) {
break;
}
}
}
if ( IsSnapByCellsEnabled(iso_world) && !snapping_z ) {
foreach ( var iso_object in iso_objects ) {
var iso_orig_z = iso_object.positionZ;
var result_p_z = iso_orig_z + delta;
var new_snapping_z = IsoEditorUtils.SnapProcess(ref result_p_z, iso_object.sizeZ, iso_object.tilePositionZ, 1.0f);
if ( new_snapping_z ) {
delta = result_p_z - iso_orig_z;
snapping_z = true;
break;
}
}
}
}
return iso_objects.Aggregate(0.0f, (AccIn, iso_object) => {
var iso_orig_z = iso_object.positionZ;
var result_p_z = iso_orig_z + delta;
if ( move ) {
iso_object.positionZ = IsoUtils.FloatBeautifier(result_p_z);
}
var z_delta = result_p_z - iso_orig_z;
return Mathf.Abs(z_delta) > Mathf.Abs(AccIn) ? z_delta : AccIn;
});
}
return delta;
}
public static Vector3 XYMoveIsoObjects(
bool move,
IsoWorld iso_world,
Dictionary<IsoWorld, List<IsoObject>> all_iso_objects,
Dictionary<IsoWorld, List<IsoObject>> all_other_objects,
Vector3 iso_delta)
{
List<IsoObject> iso_objects;
if ( all_iso_objects.TryGetValue(iso_world, out iso_objects) ) {
if ( move ) {
Undo.RecordObjects(
iso_objects.ToArray(),
iso_objects.Count > 1 ? "Move IsoObjects" : "Move IsoObject");
}
List<IsoObject> other_objects;
if ( all_other_objects.TryGetValue(iso_world, out other_objects) && other_objects.Count > 0 ) {
var snapping_x = false;
var snapping_y = false;
if ( IsSnapByObjectsEnabled(iso_world) ) {
foreach ( var iso_object in iso_objects ) {
var iso_orig_p = iso_object.position;
var result_pos_iso = iso_orig_p + iso_delta;
foreach ( var other in other_objects ) {
if ( IsoEditorUtils.IsSnapOverlaps(iso_object.positionZ, iso_object.sizeZ, other.positionZ, other.sizeZ) ) {
var new_snapping_x = !snapping_x && IsoEditorUtils.IsSnapOverlaps(result_pos_iso.y, iso_object.sizeY, other.positionY, other.sizeY)
? IsoEditorUtils.SnapProcess(ref result_pos_iso.x, iso_object.sizeX, other.positionX, other.sizeX)
: false;
var new_snapping_y = !snapping_y && IsoEditorUtils.IsSnapOverlaps(result_pos_iso.x, iso_object.sizeX, other.positionX, other.sizeX)
? IsoEditorUtils.SnapProcess(ref result_pos_iso.y, iso_object.sizeY, other.positionY, other.sizeY)
: false;
if ( new_snapping_x || new_snapping_y ) {
if ( new_snapping_x ) {
snapping_x = true;
iso_delta.x = result_pos_iso.x - iso_orig_p.x;
iso_delta.y = result_pos_iso.y - iso_orig_p.y;
}
if ( new_snapping_y ) {
snapping_y = true;
iso_delta.x = result_pos_iso.x - iso_orig_p.x;
iso_delta.y = result_pos_iso.y - iso_orig_p.y;
}
if ( snapping_x && snapping_y ) {
break;
}
}
}
}
if ( snapping_x && snapping_y ) {
break;
}
}
}
if ( IsSnapByCellsEnabled(iso_world) && !snapping_x && !snapping_y ) {
foreach ( var iso_object in iso_objects ) {
var iso_orig_p = iso_object.position;
var result_pos_iso = iso_orig_p + iso_delta;
var new_snapping_x = IsoEditorUtils.SnapProcess(ref result_pos_iso.x, iso_object.sizeX, iso_object.tilePositionX, 1.0f);
var new_snapping_y = IsoEditorUtils.SnapProcess(ref result_pos_iso.y, iso_object.sizeY, iso_object.tilePositionY, 1.0f);
if ( new_snapping_x || new_snapping_y ) {
if ( new_snapping_x ) {
iso_delta.x = result_pos_iso.x - iso_orig_p.x;
iso_delta.y = result_pos_iso.y - iso_orig_p.y;
snapping_x = true;
}
if ( new_snapping_y ) {
iso_delta.x = result_pos_iso.x - iso_orig_p.x;
iso_delta.y = result_pos_iso.y - iso_orig_p.y;
snapping_y = true;
}
if ( snapping_x && snapping_y ) {
break;
}
}
}
}
}
return iso_objects.Aggregate(Vector3.zero, (AccIn, iso_object) => {
var iso_orig_p = iso_object.position;
var result_pos_iso = iso_orig_p + iso_delta;
if ( move ) {
iso_object.position = IsoUtils.VectorBeautifier(result_pos_iso);
}
var pos_delta = result_pos_iso - iso_orig_p;
return pos_delta.magnitude > AccIn.magnitude ? pos_delta : AccIn;
});
}
return iso_delta;
}
// ---------------------------------------------------------------------
//
// Gizmos
//
// ---------------------------------------------------------------------
public static Vector3 GizmoRectangle(Vector3 center) {
Handles.color = new Color(
Handles.zAxisColor.r,
Handles.zAxisColor.g,
Handles.zAxisColor.b,
0.3f);
Handles.DotCap(
0,
center,
Quaternion.identity,
HandleUtility.GetHandleSize(center) * 0.15f);
Handles.color = Handles.zAxisColor;
Handles.ArrowCap(
0,
center,
Quaternion.identity,
HandleUtility.GetHandleSize(center));
Handles.color = Handles.zAxisColor;
return Handles.FreeMoveHandle(
center,
Quaternion.identity,
HandleUtility.GetHandleSize(center) * 0.15f,
Vector3.zero,
Handles.RectangleCap);
}
public static Vector3 GizmoSlider(Color color, Vector3 pos, Vector3 dir) {
Handles.color = color;
return Handles.Slider(pos, dir);
}
// ---------------------------------------------------------------------
//
// Snapping
//
// ---------------------------------------------------------------------
const float SnapDistance = 0.2f;
public static bool SnapProcess(ref float min_a, float size_a, float min_b, float size_b) {
var max_a = min_a + size_a;
var max_b = min_b + size_b;
var result = false;
if ( IsSnapOverlaps(min_a, size_a, min_b, size_b) ) {
// |min_a max_a|min_b max_b|
if ( Mathf.Abs(max_a - min_b) < SnapDistance ) {
min_a = min_b - size_a;
result = true;
}
// |min_b max_b|min_a max_a|
if ( Mathf.Abs(max_b - min_a) < SnapDistance ) {
min_a = max_b;
result = true;
}
// |min_a_____max_a|
// |min_b__max_b|
if ( Mathf.Abs(min_a - min_b) < SnapDistance ) {
min_a = min_b;
result = true;
}
// |min_a_____max_a|
// |min_b__max_b|
if ( Mathf.Abs(max_a - max_b) < SnapDistance ) {
min_a = max_b - size_a;
result = true;
}
}
return result;
}
public static bool IsSnapOverlaps(float min_a, float size_a, float min_b, float size_b) {
return
min_a + size_a + SnapDistance >= min_b &&
min_a - SnapDistance <= min_b + size_b;
}
public static bool IsSnapByCellsEnabled(IsoWorld iso_world) {
return
iso_world &&
(iso_world.isSnapByCells != Event.current.control);
}
public static bool IsSnapByObjectsEnabled(IsoWorld iso_world) {
return
iso_world &&
(iso_world.isSnapByObjects != Event.current.control);
}
}
}