gg.easy.airship 0.1.1661 → 0.1.1663

package/Runtime/Code/VoxelWorld/{SelectionZone.cs → Editor/SelectionZone.cs}

@@ -1,5 +1,6 @@
 using System;
 using UnityEngine;
+using System.Collections.Generic;
 
 #if UNITY_EDITOR
 using UnityEditor;
@@ -32,6 +33,9 @@ public class SelectionZone : MonoBehaviour
     [NonSerialized]
     private float previousThickness;
 
+    [NonSerialized]
+    public VoxelWorld voxelWorld;
+
     void OnEnable()
     {
         mesh = new Mesh();
@@ -253,105 +257,338 @@ public class SelectionZone : MonoBehaviour
 
 
 #if UNITY_EDITOR
+ 
 [CustomEditor(typeof(SelectionZone))]
-public class SelectionZoneEditor : Editor {
-    private const float handleSize = 0.1f;
-    private const float snapValue = 1.0f;
+public class SelectionZoneEditor : UnityEditor.Editor {
+    private const float handleSize = 0.3f;
+ 
+    private bool mouseDown = false;
+
+    static bool haveCopiedData = false;
+    static UInt16[] copiedData;
+    static Vector3Int copiedSize;
+    
+    // Define local handle positions based on the cube's size
+    Vector3[] localHandleVectors = new Vector3[6] {
+           new Vector3(1, 0, 0), // Right
+            new Vector3(-1, 0, 0), // Left
+            new Vector3(0, 1, 0), // Top
+            new Vector3(0, -1, 0), // Bottom
+            new Vector3(0, 0, 1), // Front
+            new Vector3(0, 0, -1) // Back
+    };
+
+    Color[] axisColors = new Color[6] {
+        Color.red,
+        Color.red,
+        Color.green,
+        Color.green,
+        Color.blue,
+        Color.blue
+    };
+
+    float[] handleOffset = new float[6] {
+        1,1,1,1,1,1
+    };
+
+    float[] trueHandleOffset = new float[6] {
+        1,1,1,1,1,1
+    };
+ 
+    //Gui
+    public override void OnInspectorGUI() {
+        //draw default
+        //DrawDefaultInspector();
+
+        //Add typeins for size x y and z
+        SelectionZone cube = (SelectionZone)target;
+        Vector3Int oldSize = new Vector3Int((int)cube.size.x, (int)cube.size.y, (int)cube.size.z);
+        Vector3Int newSize = EditorGUILayout.Vector3IntField("Size", oldSize);
+        
+        if (newSize != oldSize) {
+            cube.size = newSize;
+            SnapToGrid();
+            cube.BuildCube();
+            ResetHandles();
+        }
 
-    void Awake() {
+        //Draw a reset button
+        if (GUILayout.Button("Reset")) {
+            handleOffset = new float[6] {
+              1,1,1,1,1,1
+            };
+            trueHandleOffset = new float[6] {
+              1,1,1,1,1,1
+            };
+            
+            cube.size = new Vector3(1, 1, 1);
+            cube.BuildCube();
+        }
+        if (cube.voxelWorld == null) {
+            return;
+        }
+        if (cube.voxelWorld.voxelBlocks == null) {
+            return;
+        }
+        VoxelEditManager voxelEditManager = VoxelEditManager.Instance;
+
+        //Add Copy Button
+        if (GUILayout.Button("Fill")) {
+            //walk the bounds 
+            float dx = cube.size.x / 2;
+            float dy = cube.size.y / 2;
+            float dz = cube.size.z / 2;
+            float px = cube.transform.localPosition.x;
+            float py = cube.transform.localPosition.y;
+            float pz = cube.transform.localPosition.z;
+                        
+            if (cube.voxelWorld) {
+
+                List<VoxelEditAction.EditInfo> edits = new();
+
+                int selectedIndex = cube.voxelWorld.selectedBlockIndex;
+                //Walk the current selection zone
+                for (int x = Mathf.FloorToInt(px - dx); x < Mathf.CeilToInt(px + dx); x++) {
+                    for (int y = Mathf.FloorToInt(py - dy); y < Mathf.CeilToInt(py + dy); y++) {
+                        for (int z = Mathf.FloorToInt(pz - dz); z < Mathf.CeilToInt(pz + dz); z++) {
+                            UInt16 prevData = cube.voxelWorld.ReadVoxelAt(new Vector3Int(x, y, z));
+                            edits.Add(new VoxelEditAction.EditInfo(new Vector3Int(x, y, z), prevData, (UInt16)selectedIndex));
+                        }
+                    }
+                }
+                voxelEditManager.AddEdits(cube.voxelWorld, edits, "Fill Voxels");
+            }
+        }
 
-        //Add a handler for the gizmo refresh event
-        SceneView.duringSceneGui += GizmoRefreshEvent;
+        if (GUILayout.Button("Copy")) {
+            //walk the bounds 
+            float dx = cube.size.x / 2;
+            float dy = cube.size.y / 2;
+            float dz = cube.size.z / 2;
+            float px = cube.transform.localPosition.x;
+            float py = cube.transform.localPosition.y;
+            float pz = cube.transform.localPosition.z;
+
+            haveCopiedData = true;
+            copiedSize = new Vector3Int((int)cube.size.x, (int)cube.size.y, (int)cube.size.z);
+
+            copiedData = new UInt16[(int)cube.size.x * (int)cube.size.y * (int)cube.size.z];
+
+            if (cube.voxelWorld) {
+                
+                int index = 0;
+                //Walk the current selection zone
+                for (int x = Mathf.FloorToInt(px - dx); x < Mathf.CeilToInt(px + dx); x++) {
+                    for (int y = Mathf.FloorToInt(py - dy); y < Mathf.CeilToInt(py + dy); y++) {
+                        for (int z = Mathf.FloorToInt(pz - dz); z < Mathf.CeilToInt(pz + dz); z++) {
+                            copiedData[index++] = cube.voxelWorld.ReadVoxelAt(new Vector3Int(x, y, z)); 
+                        }
+                    }
+                }
+            }
+        }
+
+        if (haveCopiedData == false) {
+            //Disable ui
+            GUI.enabled = false;
+            //Make fake paste button
+            if (GUILayout.Button("Paste")) {
+                //Do nothing
+            }
+
+            GUI.enabled = true;
+        }else {
+            //Actual paste
+            if (GUILayout.Button("Paste")) {
+                //walk the bouns
+                float dx = copiedSize.x / 2;
+                float dy = copiedSize.y / 2;
+                float dz = copiedSize.z / 2;
+                float px = cube.transform.localPosition.x;
+                float py = cube.transform.localPosition.y;
+                float pz = cube.transform.localPosition.z;
+
+                if (cube.voxelWorld) {
+                    int index = 0;
+
+                    List<VoxelEditAction.EditInfo> edits = new();
+
+                    //Walk the current selection zone
+                    for (int x = Mathf.FloorToInt(px - dx); x < Mathf.CeilToInt(px + dx); x++) {
+                        for (int y = Mathf.FloorToInt(py - dy); y < Mathf.CeilToInt(py + dy); y++) {
+                            for (int z = Mathf.FloorToInt(pz - dz); z < Mathf.CeilToInt(pz + dz); z++) {
+                                //cube.voxelWorld.WriteVoxelAt(new Vector3Int(x, y, z), copiedData[index++], false);
+                                UInt16 prevData = cube.voxelWorld.ReadVoxelAt(new Vector3Int(x, y, z));
+                                edits.Add(new VoxelEditAction.EditInfo(new Vector3Int(x, y, z), prevData, copiedData[index++]));
+                            }
+                        }
+                    }
+                    voxelEditManager.AddEdits(cube.voxelWorld, edits, "Paste Voxels");
+
+
+                }
+
+                //resize the box to whatever we pasted
+                cube.size = new Vector3(copiedSize.x, copiedSize.y, copiedSize.z);
+                SnapToGrid();
+                cube.BuildCube();
+                ResetHandles();
+            }
+        }
     }
     
+
+    void Awake() {
+        // Add a handler for the gizmo refresh event
+        SceneView.duringSceneGui += GizmoRefreshEvent;
+
+        SnapToGrid();
+    }
+
+    private void ResetHandles() {
+        SelectionZone cube = (SelectionZone)target;
+        trueHandleOffset[0] = (cube.size.x / 2) + 0.5f;
+        trueHandleOffset[1] = (cube.size.x / 2) + 0.5f;
+        trueHandleOffset[2] = (cube.size.y / 2) + 0.5f;
+        trueHandleOffset[3] = (cube.size.y / 2) + 0.5f;
+        trueHandleOffset[4] = (cube.size.z / 2) + 0.5f;
+        trueHandleOffset[5] = (cube.size.z / 2) + 0.5f;
+        for (int j = 0; j < 6; j++) {
+            handleOffset[j] = trueHandleOffset[j];
+        }
+    }
+    private void OnDestroy() {
+
+        SceneView.duringSceneGui -= GizmoRefreshEvent;
+    }
+
+    public void SnapToGrid() {
+        SelectionZone cube = (SelectionZone)target;
+        Transform cubeTransform = cube.transform;
+
+        // Snap the position to the nearest 0.5 unit grid
+        float x = Mathf.Floor(cubeTransform.localPosition.x);
+        float y = Mathf.Floor(cubeTransform.localPosition.y);
+        float z = Mathf.Floor(cubeTransform.localPosition.z);
+
+        // Adjust snapping if the size is even
+        if (Mathf.Round(cube.size.x) % 2 == 1) {
+            x += 0.5f;
+        }
+        if (Mathf.Round(cube.size.y) % 2 == 1) {
+            y += 0.5f;
+        }
+        if (Mathf.Round(cube.size.z) % 2 == 1) {
+            z += 0.5f;
+        }
+
+        // Set the snapped position
+        cubeTransform.localPosition = new Vector3(x, y, z);
+        cubeTransform.localRotation = Quaternion.identity;
+        cubeTransform.localScale = Vector3.one;
+    }
+
     void GizmoRefreshEvent(SceneView obj) {
         SelectionZone cube = (SelectionZone)target;
+        if (target == null) {
+            return;
+        }
 
-        // Define handle positions based on the cube's size
-        Vector3[] handles = new Vector3[]
-        {
-            cube.transform.position + new Vector3(cube.size.x / 2, 0, 0), // Right
-            cube.transform.position + new Vector3(-cube.size.x / 2, 0, 0), // Left
-            cube.transform.position + new Vector3(0, cube.size.y / 2, 0), // Top
-            cube.transform.position + new Vector3(0, -cube.size.y / 2, 0), // Bottom
-            cube.transform.position + new Vector3(0, 0, cube.size.z / 2), // Front
-            cube.transform.position + new Vector3(0, 0, -cube.size.z / 2) // Back
-        };
+        if (cube.transform.hasChanged) {
+            //Debug.Log("Has changed");
+            SnapToGrid();
+            cube.transform.hasChanged = false;
+        }
+        
+
+
+        //capture mouse up and mouse down
+        if (Event.current.type == EventType.MouseUp) {
+            mouseDown = false;
+           
+        }
+        if (Event.current.type == EventType.MouseDown) {
+            mouseDown = true;
+        }
 
+        Transform cubeTransform = cube.transform;
+        
         EditorGUI.BeginChangeCheck();
 
+        Vector3 motion = Vector3.zero;
+
         // Move handles with constraints
-        for (int i = 0; i < handles.Length; i++) {
+        for (int i = 0; i < localHandleVectors.Length; i++) {
+            Vector3 localHandleStartPos = localHandleVectors[i] * handleOffset[i];
+            Vector3 worldHandleStartPos = cubeTransform.TransformPoint(localHandleStartPos);
             Vector3 axis = Vector3.zero;
-            bool isNegativeHandle = false;
+            float isNegativeHandle = 1;
+
             switch (i) {
                 case 0: axis = Vector3.right; break;
-                case 1: axis = Vector3.right; isNegativeHandle = true; break;
+                case 1: axis = Vector3.right; isNegativeHandle = -1; break;
                 case 2: axis = Vector3.up; break;
-                case 3: axis = Vector3.up; isNegativeHandle = true; break;
+                case 3: axis = Vector3.up; isNegativeHandle = -1; break;
                 case 4: axis = Vector3.forward; break;
-                case 5: axis = Vector3.forward; isNegativeHandle = true; break;
+                case 5: axis = Vector3.forward; isNegativeHandle = -1; break;
             }
 
+         
             // Draw spheres as handles and constrain movement
-            Vector3 newPos = Handles.Slider(handles[i], axis, handleSize, Handles.SphereHandleCap, 0);
-
-            // Calculate the snapped movement
-            float movement = Mathf.Floor((newPos - handles[i]).magnitude / snapValue) * snapValue * Mathf.Sign(Vector3.Dot(newPos - handles[i], axis));
+            //Set the color
+            Handles.color = axisColors[i];
+            Vector3 newWorldPos = Handles.Slider(worldHandleStartPos, cubeTransform.TransformDirection(axis), handleSize, Handles.SphereHandleCap,0);
             
-            float resize = movement;
+            Handles.color = Color.white;
 
-            if (movement != 0) {
-                // Invert the movement for negative handles
-                if (isNegativeHandle) {
-                    resize = -resize;
-                }
+            Vector3 localHandlePos = cubeTransform.InverseTransformPoint(newWorldPos);
 
-                switch (i) {
-                    case 0:
-                    case 1:
-                    cube.size.x += resize;
-                    cube.transform.position += axis * (movement / 2);
-                    break;
-                    case 2:
-                    case 3:
-                    cube.size.y += resize;
-                    cube.transform.position += axis * (movement / 2);
-                    break;
-                    case 4:
-                    case 5:
-                    cube.size.z += resize;
-                    cube.transform.position += axis * (movement / 2);
-                    break;
-                }
+            bool moved = false;
+            if ((newWorldPos - worldHandleStartPos).magnitude > 0)  {
+                moved = true;
             }
-        }
-
-        if (EditorGUI.EndChangeCheck()) {
-            Undo.RecordObject(cube, "Resize Cube");
-            cube.size = new Vector3(Mathf.Max(1, Mathf.Round(cube.size.x)), Mathf.Max(1, Mathf.Round(cube.size.y)), Mathf.Max(1, Mathf.Round(cube.size.z)));
-
-            //Snap the position
-            //cube.transform.position = new Vector3(Mathf.Floor(cube.transform.position.x), Mathf.Floor(cube.transform.position.y), Mathf.Floor(cube.transform.position.z));
 
-            //Snap each axis of the position separately, depending on if that size is odd or even
-            float x = Mathf.Floor(cube.transform.position.x);
-            float y = Mathf.Floor(cube.transform.position.y);
-            float z = Mathf.Floor(cube.transform.position.z);
-
-            if (Mathf.Round(cube.size.x) % 2 == 0) {
-                x += 0.5f;
-            }
-            if (Mathf.Round(cube.size.y) % 2 == 0) {
-                y += 0.5f;
-            }
-            if (Mathf.Round(cube.size.z) % 2 == 0) {
-                z += 0.5f;
+            if (mouseDown == false && Mathf.Abs(trueHandleOffset[i] - handleOffset[i]) > Mathf.Epsilon) {
+                handleOffset[i] = trueHandleOffset[i]; //Reset it
             }
-            //Set it
-            cube.transform.position = new Vector3(x, y, z);
-
+            
+            if (moved == true) {
+                
+                float distance =  localHandlePos.magnitude - trueHandleOffset[i];
+                float steps = Mathf.Floor(distance);
+
+                handleOffset[i] = localHandlePos.magnitude;
+                
+                if (steps != 0) {
+              
+                    cube.size += steps * axis;
+                    cube.transform.localPosition += (steps * axis / 2) * isNegativeHandle;
+                    SnapToGrid();
+                    
+                    //Recalc handle pos
+                    trueHandleOffset[0] = (cube.size.x / 2) + 0.5f; 
+                    trueHandleOffset[1] = (cube.size.x / 2) + 0.5f; 
+                    trueHandleOffset[2] = (cube.size.y / 2) + 0.5f; 
+                    trueHandleOffset[3] = (cube.size.y / 2) + 0.5f; 
+                    trueHandleOffset[4] = (cube.size.z / 2) + 0.5f; 
+                    trueHandleOffset[5] = (cube.size.z / 2) + 0.5f;
+                    for (int j = 0; j < 6; j++) {
+                        //Reset all handles except the one being dragged
+                        if (j==i) {
+                            continue;
+                        }
+                        handleOffset[j] = trueHandleOffset[j];
+                    }
+
+                    handleOffset[i] -= (steps * 0.5f);
 
+                }
+                
+            }
+        }
+        
+        if (EditorGUI.EndChangeCheck()) {
+     
             cube.BuildCube();
             EditorUtility.SetDirty(cube);
         }

package/Runtime/Code/VoxelWorld/Editor/VoxelBuilderEditorWindow.cs

@@ -53,6 +53,14 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
                     return voxelWorld;
                 }
             }
+
+            if (selectedObject) {
+                var selectionZone = selectedObject.GetComponentInParent<SelectionZone>();
+                if (selectionZone && selectionZone.voxelWorld) {
+                    return selectionZone.voxelWorld;
+                }
+            }
+
             return null;
         }
   
@@ -64,9 +72,13 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             //Shows a list of all the VoxelWorld objects in the scene as clickable buttons
             VoxelWorld[] voxelWorlds = GameObject.FindObjectsOfType<VoxelWorld>();
+            
             for (int i = 0; i < voxelWorlds.Length; i++) {
 
-                if (Selection.activeGameObject == voxelWorlds[i].gameObject) {
+
+                SelectionZone selectionZone = voxelWorlds[i].GetComponentInChildren<SelectionZone>();
+
+                if (Selection.activeGameObject == voxelWorlds[i].gameObject || (selectionZone!=null && Selection.activeGameObject == selectionZone.gameObject)) {
                     GUI.backgroundColor = Color.green;
                 }
                 else {
@@ -85,6 +97,7 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             GUI.backgroundColor = Color.white;
         }
+ 
 
         void OnGUI() {
             //Create an active toggle as a button that toggles on and off
@@ -96,11 +109,43 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             ShowSelectionGui();
             
+            
+            
             VoxelWorld world = GetVoxelWorld();
+            SelectionZone selection = null;
             if (world == null || world.voxelBlocks == null) {
-                GUI.enabled = true;
+                GUI.enabled = true; //cleanup from above
                 return; 
             }
+            
+
+            //See if we're in the selection mode
+            if (VoxelWorldSelectionToolBase.buttonActive == true) {
+                //Find or create the SelectionZone for this voxelWorld
+
+                selection = world.GetComponentInChildren<SelectionZone>();
+                if (selection == null) {
+                    selection = new GameObject("SelectionZone").AddComponent<SelectionZone>();
+                    selection.hideFlags = HideFlags.DontSave;
+                    selection.transform.parent = world.transform;
+                    selection.transform.localPosition = Vector3.zero;
+                    selection.voxelWorld = world;
+                }
+                //Select this
+                Selection.activeGameObject = selection.gameObject;
+            }
+            if (VoxelWorldEditorToolBase.buttonActive == true) {
+            
+                //If we're not in selection mode, destroy the selection zone
+                selection = world.GetComponentInChildren<SelectionZone>();
+                                
+                if (selection) {
+                    //Select the world
+                    Selection.activeGameObject = world.gameObject;
+                    //Destroy it
+                    DestroyImmediate(selection.gameObject);
+                }
+            }
 
             //Show a foldable help box
             EditorGUILayout.HelpBox("Left click to add\nShift+click to delete\nCtrl+click for repeat placement", MessageType.Info);
@@ -119,13 +164,19 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             GUIStyle selectedStyle = new GUIStyle(GUI.skin.button);
             selectedStyle.normal.textColor = Color.green;
-
+            selectedStyle.hover.textColor = Color.green;
             
             foreach (var pair in world.voxelBlocks.loadedBlocks) {
+
+                string name = pair.Value.definition.name;
+                if (name == "") {
+                    name = "Air";
+                }
+
                 if (pair.Key == world.selectedBlockIndex) {
-                    GUILayout.Button(pair.Value.definition.name, selectedStyle);
+                    GUILayout.Button(name, selectedStyle);
                 } else {
-                    if (GUILayout.Button(pair.Value.definition.name)) {
+                    if (GUILayout.Button(name)) {
                         world.selectedBlockIndex = pair.Key;
                     }
                 }
@@ -133,6 +184,10 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
             GUILayout.EndScrollView();
             GUI.enabled = true;
         }
+
+        void OnEnable() {
+            base.autoRepaintOnSceneChange = true;
+        }
     }
 }
 #endif

package/Runtime/Code/VoxelWorld/Editor/VoxelWorldEditor.cs

@@ -7,17 +7,32 @@ using UnityEditor.EditorTools;
 using UnityEngine;
 using System;
 using static UnityEditor.PlayerSettings;
+using static VoxelEditAction;
 
 public class VoxelEditAction {
-    public Vector3Int position;
-    public ushort oldValue;
-    public ushort newValue;
+    
+    public struct EditInfo{
+        public Vector3Int position;
+        public ushort oldValue;
+        public ushort newValue;
+        //constructor
+        public EditInfo(Vector3Int position, ushort oldValue, ushort newValue){
+            this.position = position;
+            this.oldValue = oldValue;
+            this.newValue = newValue;
+        }
+    }
+    public List<EditInfo> edits = new List<EditInfo>();
+
     [NonSerialized]
     public WeakReference<VoxelWorld> world;
-    public void Initialize(VoxelWorld world, Vector3Int position, ushort oldValue, ushort newValue) {
-        this.position = position;
-        this.oldValue = oldValue;
-        this.newValue = newValue;
+    public void CreateSingleEdit(VoxelWorld world, Vector3Int position, ushort oldValue, ushort newValue) {
+        edits.Add(new EditInfo(position, oldValue, newValue));
+        this.world = new(world);
+    }
+
+    public void CreateMultiEdit(VoxelWorld world, List<EditInfo> edits) {
+        this.edits = edits;
         this.world = new(world);
     }
 }
@@ -30,11 +45,10 @@ public class VoxelEditManager : Singleton<VoxelEditManager> {
     VoxelEditMarker undoObject;
     public List<VoxelEditAction> edits = new List<VoxelEditAction>();
     public List<VoxelEditAction> redos = new List<VoxelEditAction>();
-
-
+        
     public void AddEdit(VoxelWorld world, Vector3Int position, ushort oldValue, ushort newValue, string name) {
         VoxelEditAction edit = new VoxelEditAction();
-        edit.Initialize(world, position, oldValue, newValue);
+        edit.CreateSingleEdit(world, position, oldValue, newValue);
         edits.Add(edit);
 
         //If we're adding a new edit, clear the redos
@@ -52,9 +66,33 @@ public class VoxelEditManager : Singleton<VoxelEditManager> {
         world.DirtyNeighborMeshes(position);
 
         world.hasUnsavedChanges = true; 
- 
     }
 
+    public void AddEdits(VoxelWorld world, List<EditInfo> editInfos, string name) {
+        VoxelEditAction edit = new VoxelEditAction();
+        edit.CreateMultiEdit(world, editInfos);
+        edits.Add(edit);
+
+        //If we're adding a new edit, clear the redos
+        redos.Clear();
+
+        if (undoObject == null) {
+            undoObject = ScriptableObject.CreateInstance<VoxelEditMarker>();
+        }
+        undoObject.lastAction = edit;
+
+        //Save the state of this whole object into the undo system
+        Undo.RegisterCompleteObjectUndo(undoObject, name);
+
+        foreach (EditInfo editInfo in editInfos) {
+            world.WriteVoxelAtInternal(editInfo.position, editInfo.newValue);
+            world.DirtyNeighborMeshes(editInfo.position);
+        }
+        
+        world.hasUnsavedChanges = true;
+    }
+
+
     //Constructor
     public VoxelEditManager() {
         Undo.undoRedoEvent += UndoRedoEvent;
@@ -69,8 +107,10 @@ public class VoxelEditManager : Singleton<VoxelEditManager> {
 
                 edit.world.TryGetTarget(out VoxelWorld currentWorld);
                 if (currentWorld){
-                    currentWorld.WriteVoxelAtInternal(edit.position, edit.oldValue);
-                    currentWorld.DirtyNeighborMeshes(edit.position);
+                    foreach (var editInfo in edit.edits) {
+                        currentWorld.WriteVoxelAtInternal(editInfo.position, editInfo.oldValue);
+                        currentWorld.DirtyNeighborMeshes(editInfo.position);
+                    }
                     currentWorld.hasUnsavedChanges = true;
                 }
 
@@ -83,8 +123,10 @@ public class VoxelEditManager : Singleton<VoxelEditManager> {
                 redos.RemoveAt(redos.Count - 1);
                 edit.world.TryGetTarget(out VoxelWorld currentWorld);
                 if (currentWorld) {
-                    currentWorld.WriteVoxelAtInternal(edit.position, edit.newValue);
-                    currentWorld.DirtyNeighborMeshes(edit.position);
+                    foreach (var editInfo in edit.edits) {
+                        currentWorld.WriteVoxelAtInternal(editInfo.position, editInfo.newValue);
+                        currentWorld.DirtyNeighborMeshes(editInfo.position);
+                    }
                     currentWorld.hasUnsavedChanges = true;
                 }
 
@@ -380,9 +422,7 @@ public class VoxelWorldEditor : UnityEditor.Editor {
             handle.name = "_SelectionHandle";
             handle.hideFlags = HideFlags.HideAndDontSave; 
         }
-
-
-
+        
         if (faceHandle == null) {
             faceHandle = GameObject.CreatePrimitive(PrimitiveType.Quad);
             faceHandle.transform.localScale = new Vector3(1.01f, 1.01f, 1.01f);
@@ -396,13 +436,12 @@ public class VoxelWorldEditor : UnityEditor.Editor {
         if (Event.current.shift) { //Delete
             DestroyImmediate(faceHandle);
             faceHandle = null;
-                
         }
-        
 
         if (handle) {
             handle.transform.position = world.TransformPointToWorldSpace(lastPos + new Vector3(0.5f,0.5f,0.5f));
             handle.transform.localScale = new Vector3(1.01f, 1.01f, 1.01f);
+            handle.transform.localRotation = Quaternion.identity;
 
             WireCube wireCube = handle.GetComponent<WireCube>();
             if (wireCube) {
@@ -422,7 +461,7 @@ public class VoxelWorldEditor : UnityEditor.Editor {
         
         if (faceHandle) {
             faceHandle.transform.position = world.TransformPointToWorldSpace(lastPos + new Vector3(0.5f, 0.5f, 0.5f) + lastNormal * 0.51f);
-            faceHandle.transform.rotation = Quaternion.LookRotation(lastNormal);
+            faceHandle.transform.rotation = Quaternion.LookRotation(world.TransformVectorToWorldSpace(lastNormal));
 
             MeshRenderer ren = faceHandle.GetComponent<MeshRenderer>();
             if (leftControlDown == true) {
@@ -447,7 +486,7 @@ public class VoxelWorldEditor : UnityEditor.Editor {
         Event e = Event.current;
 
         //Only allow editing if both the editor window is active and the gizmo toolbar is active
-        bool enabled = VoxelBuilderEditorWindow.Enabled() && VoxelWorldEditorTool.buttonActive;
+        bool enabled = VoxelBuilderEditorWindow.Enabled() && VoxelWorldEditorToolBase.buttonActive;
         
         if (enabled != lastEnabled) {
             CleanupHandles();
@@ -567,26 +606,35 @@ public class VoxelWorldEditor : UnityEditor.Editor {
         SceneView.duringSceneGui += GizmoRefreshEvent;
     }
 
-    void OnSelectionChanged() {
+    private void OnDestroy() {
+        //Remove selection handler
+        Selection.selectionChanged -= OnSelectionChanged;
+
+        //Remove the gizmo refresh event handler
+        SceneView.duringSceneGui -= GizmoRefreshEvent;
+    }
+
+    void OnSelectionChanged() { 
         if (target == null) {
             return;
         }
         //If we're seleceted
         if (Selection.activeGameObject == ((VoxelWorld)target).gameObject) {
-            ToolManager.SetActiveTool<VoxelWorldEditorTool>();
+            ToolManager.SetActiveTool<VoxelWorldEditorToolBase>();
         }
+
+        
        
     }
 }
 
 
 //Create the spiffy toolbar addition
-[EditorTool("Edit Voxel World", typeof(VoxelWorld))]
-public class VoxelWorldEditorTool : EditorTool {
+public class VoxelWorldEditorToolBase : EditorTool {
 
     public static bool buttonActive = false;
 
-    GUIContent iconContent = null;
+    static GUIContent iconContent = null;
     
     public override void OnActivated() {
         buttonActive = true;
@@ -608,4 +656,49 @@ public class VoxelWorldEditorTool : EditorTool {
     }
 }
 
+
+
+public class VoxelWorldSelectionToolBase : EditorTool {
+
+    public static bool buttonActive = false;
+
+    static GUIContent iconContent = null;
+
+    public override void OnActivated() {
+        buttonActive = true;
+
+    }
+    public override void OnWillBeDeactivated() {
+        buttonActive = false;
+    }
+    public override GUIContent toolbarIcon {
+        get {
+            if (iconContent == null) {
+                iconContent = new GUIContent() {
+                    image = Resources.Load<Texture>("SelectIcon"),
+                    tooltip = "Selection"
+                };
+            }
+            return iconContent;
+        }
+    }
+}
+
+[EditorTool("Edit Voxel World", typeof(VoxelWorld))]
+public class VoxelWorldSelectionToolVW : VoxelWorldSelectionToolBase {
+}
+
+[EditorTool("Edit Voxel Selection", typeof(VoxelWorld))]
+public class VoxelWorldEditorToolVW : VoxelWorldEditorToolBase {
+}
+
+//Same again for SelectionZone
+[EditorTool("Edit Voxel World", typeof(SelectionZone))]
+public class VoxelWorldSelectionToolSZ : VoxelWorldSelectionToolBase {
+}
+
+[EditorTool("Edit Voxel Selection", typeof(SelectionZone))]
+public class VoxelWorldEditorToolSZ : VoxelWorldEditorToolBase {
+}
+
 #endif

package/Runtime/Code/VoxelWorld/Resources/SelectIcon.png.meta

@@ -0,0 +1,153 @@
+fileFormatVersion: 2
+guid: e096bf0b5cc9a8240915e1374148925c
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 1
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Code/VoxelWorld/VoxelWorld.cs

@@ -138,6 +138,11 @@ public partial class VoxelWorld : MonoBehaviour {
         return transform.localToWorldMatrix.MultiplyPoint(point);
     }
 
+    public Vector3 TransformVectorToWorldSpace(Vector3 vec) {
+        return transform.localToWorldMatrix.MultiplyVector(vec);
+    }
+
+
     public void InvokeOnFinishedReplicatingChunksFromServer() {
         this.finishedReplicatingChunksFromServer = true;
         this.OnFinishedReplicatingChunksFromServer?.Invoke();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gg.easy.airship",
-  "version": "0.1.1661",
+  "version": "0.1.1663",
   "displayName": "Airship",
   "unity": "2021.3",
   "unityRelease": "12f1",